From 0f8d0e8319b5017ef18282a3687418ca62241b25 Mon Sep 17 00:00:00 2001 From: Fuzail Khan Date: Sun, 22 Jan 2023 22:59:24 -0800 Subject: [PATCH 1/5] Enabling FPGA support in PDDF --- .../i2c/modules/fan/driver/pddf_fan_api.c | 171 +++- .../pddf/i2c/modules/include/pddf_fan_defs.h | 2 + .../pddf/i2c/modules/include/pddf_led_defs.h | 30 +- .../pddf/i2c/modules/led/pddf_led_module.c | 958 ++++++++++-------- .../i2c/modules/psu/driver/pddf_psu_driver.c | 2 +- .../i2c/modules/xcvr/driver/pddf_xcvr_api.c | 300 ++++++ .../modules/xcvr/driver/pddf_xcvr_driver.c | 8 +- platform/pddf/i2c/utils/pddf_util.py | 3 + platform/pddf/i2c/utils/pddfparse.py | 183 +++- 9 files changed, 1125 insertions(+), 532 deletions(-) diff --git a/platform/pddf/i2c/modules/fan/driver/pddf_fan_api.c b/platform/pddf/i2c/modules/fan/driver/pddf_fan_api.c index 0fecee963ed2..76b35a7e8ab6 100644 --- a/platform/pddf/i2c/modules/fan/driver/pddf_fan_api.c +++ b/platform/pddf/i2c/modules/fan/driver/pddf_fan_api.c @@ -330,6 +330,106 @@ int fan_cpld_client_read(FAN_DATA_ATTR *udata) return status; } +int fan_cpld_client_write(FAN_DATA_ATTR *udata, uint32_t val) +{ + int status = 0; + + if (udata->len==1) + { + status = board_i2c_cpld_write(udata->devaddr, udata->offset, val); + } + else + { + /* Get the I2C client for the CPLD */ + struct i2c_client *client_ptr=NULL; + client_ptr = (struct i2c_client *)get_device_table(udata->devname); + if (client_ptr) + { + if (udata->len==2) + { + uint8_t val_lsb = val & 0xFF; + uint8_t val_hsb = (val >> 8) & 0xFF; + /* TODO: Check this logic for LE and BE */ + status = i2c_smbus_write_byte_data(client_ptr, udata->offset, val_lsb); + if (status==0) status = i2c_smbus_write_byte_data(client_ptr, udata->offset+1, val_hsb); + } + else + printk(KERN_ERR "PDDF_FAN: Doesn't support block CPLD write yet"); + } + else + printk(KERN_ERR "Unable to get the client handle for %s\n", udata->devname); + } + + return status; +} + +int fan_fpgai2c_client_read(FAN_DATA_ATTR *udata) +{ + int status = -1; + + if (udata!=NULL) + { + if (udata->len==1) + { + status = board_i2c_fpga_read(udata->devaddr , udata->offset); + /*printk(KERN_ERR "### Reading offset 0x%x from 0x%x device ... val 0x%x\n", udata->offset, udata->devaddr, status);*/ + } + else + { + /* Get the I2C client for the FPGAI2C */ + struct i2c_client *client_ptr=NULL; + client_ptr = (struct i2c_client *)get_device_table(udata->devname); + if (client_ptr) + { + if (udata->len==2) + { + status = i2c_smbus_read_word_swapped(client_ptr, udata->offset); + } + else + printk(KERN_ERR "PDDF_FAN: Doesn't support block FPGAI2C read yet"); + } + else + printk(KERN_ERR "Unable to get the client handle for %s\n", udata->devname); + } + + } + + return status; +} + +int fan_fpgai2c_client_write(FAN_DATA_ATTR *udata, uint32_t val) +{ + int status = 0; + + if (udata->len==1) + { + status = board_i2c_fpga_write(udata->devaddr, udata->offset, val); + } + else + { + /* Get the I2C client for the FPGAI2C */ + struct i2c_client *client_ptr=NULL; + client_ptr = (struct i2c_client *)get_device_table(udata->devname); + if (client_ptr) + { + if (udata->len==2) + { + uint8_t val_lsb = val & 0xFF; + uint8_t val_hsb = (val >> 8) & 0xFF; + /* TODO: Check this logic for LE and BE */ + status = i2c_smbus_write_byte_data(client_ptr, udata->offset, val_lsb); + if (status==0) status = i2c_smbus_write_byte_data(client_ptr, udata->offset+1, val_hsb); + } + else + printk(KERN_ERR "PDDF_FAN: Doesn't support block FPGAI2C write yet"); + } + else + printk(KERN_ERR "Unable to get the client handle for %s\n", udata->devname); + } + + return status; +} + int sonic_i2c_get_fan_present_default(void *client, FAN_DATA_ATTR *udata, void *info) { @@ -341,6 +441,10 @@ int sonic_i2c_get_fan_present_default(void *client, FAN_DATA_ATTR *udata, void * { val = fan_cpld_client_read(udata); } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + val = fan_fpgai2c_client_read(udata); + } else { val = i2c_smbus_read_byte_data((struct i2c_client *)client, udata->offset); @@ -365,6 +469,10 @@ int sonic_i2c_get_fan_rpm_default(void *client, FAN_DATA_ATTR *udata, void *info { val = fan_cpld_client_read(udata); } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + val = fan_fpgai2c_client_read(udata); + } else { if (udata->len == 1) @@ -395,18 +503,26 @@ int sonic_i2c_get_fan_rpm_default(void *client, FAN_DATA_ATTR *udata, void *info int sonic_i2c_get_fan_direction_default(void *client, FAN_DATA_ATTR *udata, void *info) { int status = 0; - uint32_t val = 0; + int val = 0; struct fan_attr_info *painfo = (struct fan_attr_info *)info; if (strcmp(udata->devtype, "cpld") == 0) { val = fan_cpld_client_read(udata); } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + val = fan_fpgai2c_client_read(udata); + } else { val = i2c_smbus_read_byte_data((struct i2c_client *)client, udata->offset); } - painfo->val.intval = ((val & udata->mask) == udata->cmpval); + + if (val < 0) + status = val; + else + painfo->val.intval = ((val & udata->mask) == udata->cmpval); return status; } @@ -415,7 +531,7 @@ int sonic_i2c_get_fan_direction_default(void *client, FAN_DATA_ATTR *udata, void int sonic_i2c_set_fan_pwm_default(struct i2c_client *client, FAN_DATA_ATTR *udata, void *info) { int status = 0; - uint32_t val = 0; + int val = 0; struct fan_attr_info *painfo = (struct fan_attr_info *)info; val = painfo->val.intval & udata->mask; @@ -427,52 +543,31 @@ int sonic_i2c_set_fan_pwm_default(struct i2c_client *client, FAN_DATA_ATTR *udat if (strcmp(udata->devtype, "cpld") == 0) { - if (udata->len==1) - { - status = board_i2c_cpld_write(udata->devaddr , udata->offset, val); - } - else - { - /* Get the I2C client for the CPLD */ - struct i2c_client *client_ptr=NULL; - client_ptr = (struct i2c_client *)get_device_table(udata->devname); - if (client_ptr) - { - if (udata->len==2) - { - uint8_t val_lsb = val & 0xFF; - uint8_t val_hsb = (val >> 8) & 0xFF; - /* TODO: Check this logic for LE and BE */ - i2c_smbus_write_byte_data(client, udata->offset, val_lsb); - i2c_smbus_write_byte_data(client, udata->offset+1, val_hsb); - } - else - printk(KERN_ERR "PDDF_FAN: Doesn't support block CPLD write yet"); - } - else - printk(KERN_ERR "Unable to get the client handle for %s\n", udata->devname); - } - + status = fan_cpld_client_write(udata, val); + } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + status = fan_fpgai2c_client_write(udata, val); } else { if (udata->len == 1) - i2c_smbus_write_byte_data(client, udata->offset, val); + status = i2c_smbus_write_byte_data(client, udata->offset, val); else if (udata->len == 2) { uint8_t val_lsb = val & 0xFF; uint8_t val_hsb = (val >> 8) & 0xFF; /* TODO: Check this logic for LE and BE */ - i2c_smbus_write_byte_data(client, udata->offset, val_lsb); - i2c_smbus_write_byte_data(client, udata->offset+1, val_hsb); + status = i2c_smbus_write_byte_data(client, udata->offset, val_lsb); + if (status == 0) status = i2c_smbus_write_byte_data(client, udata->offset+1, val_hsb); } else { printk(KERN_DEBUG "%s: pwm should be of len 1/2 bytes. Not setting the pwm as the length is %d\n", __FUNCTION__, udata->len); } } - - return status; + + return status; } @@ -486,6 +581,10 @@ int sonic_i2c_get_fan_pwm_default(void *client, FAN_DATA_ATTR *udata, void *info { val = fan_cpld_client_read(udata); } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + val = fan_fpgai2c_client_read(udata); + } else { if (udata->len == 1) @@ -520,6 +619,10 @@ int sonic_i2c_get_fan_fault_default(void *client, FAN_DATA_ATTR *udata, void *in { val = fan_cpld_client_read(udata); } + else if (strcmp(udata->devtype, "fpgai2c") == 0) + { + val = fan_fpgai2c_client_read(udata); + } else { val = i2c_smbus_read_byte_data((struct i2c_client *)client, udata->offset); diff --git a/platform/pddf/i2c/modules/include/pddf_fan_defs.h b/platform/pddf/i2c/modules/include/pddf_fan_defs.h index 7765e5446293..066e956e11b3 100644 --- a/platform/pddf/i2c/modules/include/pddf_fan_defs.h +++ b/platform/pddf/i2c/modules/include/pddf_fan_defs.h @@ -88,4 +88,6 @@ typedef struct FAN_PDATA extern int board_i2c_cpld_read(unsigned short cpld_addr, u8 reg); extern int board_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value); +extern int board_i2c_fpga_read(unsigned short cpld_addr, u8 reg); +extern int board_i2c_fpga_write(unsigned short cpld_addr, u8 reg, u8 value); #endif diff --git a/platform/pddf/i2c/modules/include/pddf_led_defs.h b/platform/pddf/i2c/modules/include/pddf_led_defs.h index 1603f8c5af8e..0056cf537eb5 100644 --- a/platform/pddf/i2c/modules/include/pddf_led_defs.h +++ b/platform/pddf/i2c/modules/include/pddf_led_defs.h @@ -33,6 +33,7 @@ struct kobject *cur_state_kobj=NULL; * space JSON data file *****************************************/ #define NAME_SIZE 32 +#define VALUE_SIZE 5 typedef enum { STATUS_LED_COLOR_GREEN, STATUS_LED_COLOR_GREEN_BLINK, @@ -42,20 +43,24 @@ typedef enum { STATUS_LED_COLOR_AMBER_BLINK, STATUS_LED_COLOR_BLUE, STATUS_LED_COLOR_BLUE_BLINK, + STATUS_LED_COLOR_YELLOW, + STATUS_LED_COLOR_YELLOW_BLINK, STATUS_LED_COLOR_OFF, MAX_LED_STATUS }LED_STATUS; char* LED_STATUS_STR[] = { - "STATUS_LED_COLOR_GREEN", - "STATUS_LED_COLOR_GREEN_BLINK", - "STATUS_LED_COLOR_RED", - "STATUS_LED_COLOR_RED_BLINK", - "STATUS_LED_COLOR_AMBER", - "STATUS_LED_COLOR_AMBER_BLINK", - "STATUS_LED_COLOR_BLUE", - "STATUS_LED_COLOR_BLUE_BLINK", - "STATUS_LED_COLOR_OFF" + "green", + "green_blink", + "red", + "red_blink", + "amber", + "amber_blink", + "blue", + "blue_blink", + "yellow", + "yellow_blink", + "off" }; @@ -71,7 +76,10 @@ typedef struct int swpld_addr; int swpld_addr_offset; MASK_BITS bits; - unsigned short value; + u8 reg_values[VALUE_SIZE]; + char value[NAME_SIZE]; + char attr_devtype[NAME_SIZE]; + char attr_devname[NAME_SIZE]; } LED_DATA; typedef struct @@ -88,6 +96,8 @@ typedef struct LED_DATA data[MAX_LED_STATUS]; int swpld_addr; int swpld_addr_offset; + char attr_devtype[NAME_SIZE]; + char attr_devname[NAME_SIZE]; } LED_OPS_DATA; typedef enum{ diff --git a/platform/pddf/i2c/modules/led/pddf_led_module.c b/platform/pddf/i2c/modules/led/pddf_led_module.c index 362467e5ab98..79b3418b1228 100644 --- a/platform/pddf/i2c/modules/led/pddf_led_module.c +++ b/platform/pddf/i2c/modules/led/pddf_led_module.c @@ -37,618 +37,686 @@ LED_OPS_DATA loc_led_ops_data[1]= {0}; LED_OPS_DATA* fantray_led_ops_data=NULL; LED_OPS_DATA temp_data={0}; LED_OPS_DATA* dev_list[LED_TYPE_MAX] = { - sys_led_ops_data, - NULL, - fan_led_ops_data, - NULL, - diag_led_ops_data, - loc_led_ops_data, + sys_led_ops_data, + NULL, + fan_led_ops_data, + NULL, + diag_led_ops_data, + loc_led_ops_data, }; int num_psus = 0; int num_fantrays = 0; extern int board_i2c_cpld_read(unsigned short cpld_addr, u8 reg); extern int board_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value); +extern int board_i2c_fpga_read(unsigned short cpld_addr, u8 reg); +extern int board_i2c_fpga_write(unsigned short cpld_addr, u8 reg, u8 value); + extern ssize_t show_pddf_data(struct device *dev, struct device_attribute *da, char *buf); extern ssize_t store_pddf_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count); static LED_STATUS find_state_index(const char* state_str) { - int index; - char *ptr = (char *)state_str; - while (*ptr && *ptr!= '\n' && *ptr !='\0') ptr++; - *ptr='\0'; - for ( index = 0; index < MAX_LED_STATUS; index++) { - /*int rc = strcmp(state_str, LED_STATUS_STR[index]) ;*/ - if (strcmp(state_str, LED_STATUS_STR[index]) == 0 ) { - return index; - } - } - return MAX_LED_STATUS; + int index; + char *ptr = (char *)state_str; + while (*ptr && *ptr!= '\n' && *ptr !='\0') ptr++; + *ptr='\0'; + for ( index = 0; index < MAX_LED_STATUS; index++) { + if (strcmp(state_str, LED_STATUS_STR[index]) == 0 ) { + return index; + } + } + return MAX_LED_STATUS; } static LED_TYPE get_dev_type(char* name) { - LED_TYPE ret = LED_TYPE_MAX; - if(strcasecmp(name, "SYS_LED")==0) { - ret = LED_SYS; - } else if(strcasecmp(name, "FAN_LED")==0) { - ret = LED_FAN; - } else if(strstr(name, "PSU_LED")) { - ret = LED_PSU; - } else if(strcasecmp(name, "DIAG_LED")==0) { - ret = LED_DIAG; - } else if(strcasecmp(name, "LOC_LED")==0) { - ret = LED_LOC; - } else if(strstr(name, "FANTRAY_LED")) { - ret = LED_FANTRAY; - } + LED_TYPE ret = LED_TYPE_MAX; + if(strcasecmp(name, "SYS_LED") == 0) { + ret = LED_SYS; + } else if(strcasecmp(name, "FAN_LED") == 0) { + ret = LED_FAN; + } else if(strstr(name, "PSU_LED")) { + ret = LED_PSU; + } else if(strcasecmp(name, "DIAG_LED") == 0) { + ret = LED_DIAG; + } else if(strcasecmp(name, "LOC_LED") == 0) { + ret = LED_LOC; + } else if(strstr(name, "FANTRAY_LED")) { + ret = LED_FANTRAY; + } #if DEBUG > 1 - pddf_dbg(LED, KERN_INFO "LED get_dev_type: %s; %d\n", name, ret); + pddf_dbg(LED, KERN_INFO "LED get_dev_type: %s; %d\n", name, ret); #endif - return (ret); + return (ret); } static int dev_index_check(LED_TYPE type, int index) { #if DEBUG - pddf_dbg(LED, "dev_index_check: type:%s index:%d num_psus:%d num_fantrays:%d\n", - LED_TYPE_STR[type], index, num_psus, num_fantrays); + pddf_dbg(LED, "dev_index_check: type:%s index:%d num_psus:%d num_fantrays:%d\n", + LED_TYPE_STR[type], index, num_psus, num_fantrays); #endif - switch(type) - { - case LED_PSU: - if(index >= num_psus) return (-1); - break; - case LED_FANTRAY: - if(index >= num_fantrays) return (-1); - break; - default: - if(index >= 1) return (-1); - break; - } - return (0); + switch(type) + { + case LED_PSU: + if(index >= num_psus) return (-1); + break; + case LED_FANTRAY: + if(index >= num_fantrays) return (-1); + break; + default: + if(index >= 1) return (-1); + break; + } + return (0); } static LED_OPS_DATA* find_led_ops_data(struct device_attribute *da) { - struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; - LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr; - LED_TYPE led_type; - if(!ptr || strlen(ptr->device_name)==0 ) return(NULL); - - - if((led_type=get_dev_type(ptr->device_name))==LED_TYPE_MAX) { - printk(KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__); - return(NULL); - } - if(dev_index_check(led_type, ptr->index)==-1) { - printk(KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%s\n", __func__, ptr->index, ptr->device_name); - return(NULL); - } + struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; + LED_OPS_DATA* ptr = (LED_OPS_DATA*)_ptr->addr; + LED_TYPE led_type; + if(!ptr || strlen(ptr->device_name) == 0 ) return (NULL); + + if((led_type=get_dev_type(ptr->device_name)) == LED_TYPE_MAX) { + printk(KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__); + return (NULL); + } + if(dev_index_check(led_type, ptr->index) == -1) { + printk(KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%s\n", __func__, ptr->index, ptr->device_name); + return (NULL); + } #if DEBUG > 1 - pddf_dbg(LED, "find_led_ops_data: name:%s; index=%d tempAddr:%p actualAddr:%p\n", - ptr->device_name, ptr->index, ptr, dev_list[led_type]+ptr->index); + pddf_dbg(LED, "find_led_ops_data: name:%s; index=%d tempAddr:%p actualAddr:%p\n", + ptr->device_name, ptr->index, ptr, dev_list[led_type]+ptr->index); #endif - return (dev_list[led_type]+ptr->index); + return (dev_list[led_type]+ptr->index); } static void print_led_data(LED_OPS_DATA *ptr, LED_STATUS state) { int i = 0; - if(!ptr) return ; - pddf_dbg(LED, KERN_INFO "Print %s index:%d num_psus:%d num_fantrays:%d ADDR=%p\n", - ptr->device_name, ptr->index, num_psus, num_fantrays, ptr); - pddf_dbg(LED, KERN_INFO "\tindex: %d\n", ptr->index); - pddf_dbg(LED, KERN_INFO "\tcur_state: %d; %s \n", ptr->cur_state.state, ptr->cur_state.color); - for (i = 0; i< MAX_LED_STATUS; i++) { - if(ptr->data[i].swpld_addr && (i == state || state == -1)) { - pddf_dbg(LED, KERN_INFO "\t\t[%s]: addr/offset:0x%x;0x%x color:%s; value:%x; mask_bits: 0x%x; pos:%d\n", - LED_STATUS_STR[i], - ptr->data[i].swpld_addr, ptr->data[i].swpld_addr_offset, - LED_STATUS_STR[i], ptr->data[i].value, ptr->data[i].bits.mask_bits, ptr->data[i].bits.pos); - } + if(!ptr) return ; + pddf_dbg(LED, KERN_INFO "Print %s index:%d num_psus:%d num_fantrays:%d ADDR=%p\n", + ptr->device_name, ptr->index, num_psus, num_fantrays, ptr); + pddf_dbg(LED, KERN_INFO "\tindex: %d\n", ptr->index); + pddf_dbg(LED, KERN_INFO "\tdevtype/devname: %s:%s\n", ptr->attr_devtype, ptr->attr_devname); + pddf_dbg(LED, KERN_INFO "\tcur_state: %d; %s \n", ptr->cur_state.state, ptr->cur_state.color); + for (i = 0; i< MAX_LED_STATUS; i++) { + if(ptr->data[i].swpld_addr && (i == state || state == -1)) { + pddf_dbg(LED, KERN_INFO "\t\t[%s]: addr/offset:0x%x;0x%x color:%s; value:[%s][0x%x][0x%x] mask_bits: 0x%x;" + "pos:%d attr_devtype:%s attr_devname:%s\n",LED_STATUS_STR[i], ptr->data[i].swpld_addr, + ptr->data[i].swpld_addr_offset, LED_STATUS_STR[i], ptr->data[i].value, + ptr->data[i].reg_values[0], ptr->data[i].reg_values[1], ptr->data[i].bits.mask_bits, + ptr->data[i].bits.pos, ptr->data[i].attr_devtype, ptr->data[i].attr_devname); } + } } - + ssize_t get_status_led(struct device_attribute *da) { - int ret=0; - struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; - LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr; - LED_OPS_DATA* ops_ptr=find_led_ops_data(da); - uint32_t color_val=0, sys_val=0; - int state=0; - if (!ops_ptr) { - pddf_dbg(LED, KERN_ERR "ERROR %s: Cannot find LED Ptr", __func__); - return (-1); - } - if (ops_ptr->swpld_addr == 0x0) { - pddf_dbg(LED, KERN_ERR "ERROR %s: device: %s %d not configured\n", __func__, - temp_data_ptr->device_name, temp_data_ptr->index); - return (-1); - } - sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); - if (sys_val < 0) - return sys_val; - - strcpy(temp_data.cur_state.color, "None"); - for (state=0; statedata[state].bits.mask_bits); - if ((color_val ^ (ops_ptr->data[state].value<data[state].bits.pos))==0) { - strcpy(temp_data.cur_state.color, LED_STATUS_STR[state]); - } - } -#if DEBUG > 1 - pddf_dbg(LED, KERN_ERR "Get : %s:%d addr/offset:0x%x; 0x%x value=0x%x [%s]\n", - ops_ptr->device_name, ops_ptr->index, - ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, sys_val, - temp_data.cur_state.color); -#endif + int ret=0; + struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; + LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr; + LED_OPS_DATA* ops_ptr=find_led_ops_data(da); + uint32_t color_val=0, sys_val=0; + int state=0; + int cpld_type=0; + int j; + + if (!ops_ptr) { + pddf_dbg(LED, KERN_ERR "ERROR %s: Cannot find LED Ptr", __func__); + return (-1); + } + + if (ops_ptr->swpld_addr == 0x0) { + pddf_dbg(LED, KERN_ERR "ERROR %s: device: %s %d not configured\n", __func__, + temp_data_ptr->device_name, temp_data_ptr->index); + return (-1); + } - return(ret); + if (strcmp(ops_ptr->attr_devtype, "cpld") == 0) { + cpld_type = 1; + sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else if (strcmp(ops_ptr->attr_devtype, "fpgai2c") == 0) { + sys_val = board_i2c_fpga_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else { + pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d devtype:%s 0x%x:0x%x not configured\n",__func__, + ops_ptr->device_name, ops_ptr->index, ops_ptr->attr_devtype, ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + return (-1); + } + + if (sys_val < 0) { + pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d devtype:%s 0x%x:0x%x read failed\n",__func__, + ops_ptr->device_name, ops_ptr->index, ops_ptr->attr_devtype, ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + return sys_val; + } + + strcpy(temp_data.cur_state.color, "None"); + for (state=0; statedata[state].bits.mask_bits); + for (j = 0; j < VALUE_SIZE && ops_ptr->data[state].reg_values[j] != 0xff; j++) { + if ((color_val ^ (ops_ptr->data[state].reg_values[j] << ops_ptr->data[state].bits.pos)) == 0) { + strcpy(temp_data.cur_state.color, LED_STATUS_STR[state]); + break; + } + } + } +#if DEBUG + pddf_dbg(LED, KERN_ERR "Get : %s:%d addr/offset:0x%x; 0x%x devtype:%s;%s value=0x%x [%s]\n", + ops_ptr->device_name, ops_ptr->index, ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, + ops_ptr->attr_devtype, cpld_type? "cpld": "fpgai2c", sys_val, temp_data.cur_state.color); +#endif + return(ret); } ssize_t set_status_led(struct device_attribute *da) { - int ret=0; - uint32_t sys_val=0, new_val=0; - LED_STATUS cur_state = MAX_LED_STATUS; - struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; - LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr; - LED_OPS_DATA* ops_ptr=find_led_ops_data(da); - char* _buf=temp_data_ptr->cur_state.color; - - if (!ops_ptr) { - pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: Cannot find LED Ptr", __func__); - return (-1); - } - if (ops_ptr->swpld_addr == 0x0) { - pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: device: %s %d not configured\n", - __func__, ops_ptr->device_name, ops_ptr->index); - return (-1); - } - pddf_dbg(LED, KERN_ERR "%s: Set [%s;%d] color[%s]\n", __func__, - temp_data_ptr->device_name, temp_data_ptr->index, - temp_data_ptr->cur_state.color); - cur_state = find_state_index(_buf); - - if (cur_state == MAX_LED_STATUS) { - pddf_dbg(LED, KERN_ERR "ERROR %s: not supported: %s\n", _buf, __func__); - return (-1); + int ret=0; + uint32_t sys_val=0, new_val=0, read_val=0; + LED_STATUS cur_state = MAX_LED_STATUS; + struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; + LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr; + LED_OPS_DATA* ops_ptr=find_led_ops_data(da); + char* _buf=temp_data_ptr->cur_state.color; + int cpld_type = 0; + + if (!ops_ptr) { + pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: Cannot find LED Ptr", __func__); + return (-1); + } + + if (ops_ptr->swpld_addr == 0x0) { + pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: device: %s %d not configured\n", + __func__, ops_ptr->device_name, ops_ptr->index); + return (-1); + } + + pddf_dbg(LED, KERN_ERR "%s: Set [%s;%d] color[%s]\n", __func__, + temp_data_ptr->device_name, temp_data_ptr->index, + temp_data_ptr->cur_state.color); + cur_state = find_state_index(_buf); + + if (cur_state == MAX_LED_STATUS) { + pddf_dbg(LED, KERN_ERR "ERROR %s: not supported: %s\n", _buf, __func__); + return (-1); + } + + if (ops_ptr->data[cur_state].swpld_addr != 0x0) { + if (strcmp(ops_ptr->data[cur_state].attr_devtype, "cpld") == 0) { + cpld_type = 1; + sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else if (strcmp(ops_ptr->data[cur_state].attr_devtype, "fpgai2c") == 0) { + sys_val = board_i2c_fpga_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else { + pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d devtype:%s not configured\n",__func__, + ops_ptr->device_name, ops_ptr->index, ops_ptr->attr_devtype); + return (-1); } - if(ops_ptr->data[cur_state].swpld_addr != 0x0) { - sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); - if (sys_val < 0) - return sys_val; - - new_val = (sys_val & ops_ptr->data[cur_state].bits.mask_bits) | - (ops_ptr->data[cur_state].value << ops_ptr->data[cur_state].bits.pos); - - } else { - pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d state %d; %s not configured\n",__func__, - ops_ptr->device_name, ops_ptr->index, cur_state, _buf); - return (-1); - } - - board_i2c_cpld_write(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, new_val); - pddf_dbg(LED, KERN_INFO "Set color:%s; 0x%x:0x%x sys_val:0x%x new_val:0x%x read:0x%x\n", - LED_STATUS_STR[cur_state], - ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, - sys_val, new_val, - ret = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset)); - if (ret < 0) - { - pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: Error %d in reading from cpld(0x%x) offset 0x%x\n", __FUNCTION__, ret, ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); - return ret; - } - return(ret); + if (sys_val < 0) + return sys_val; + + new_val = (sys_val & ops_ptr->data[cur_state].bits.mask_bits) | + (ops_ptr->data[cur_state].reg_values[0] << ops_ptr->data[cur_state].bits.pos); + + } else { + pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d devtype:%s state %d; %s not configured\n",__func__, + ops_ptr->device_name, ops_ptr->index, ops_ptr->attr_devtype, cur_state, _buf); + return (-1); + } + + if (strcmp(ops_ptr->data[cur_state].attr_devtype, "cpld") == 0) { + ret = board_i2c_cpld_write(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, new_val); + read_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else if (strcmp(ops_ptr->data[cur_state].attr_devtype, "fpgai2c") == 0) { + ret = board_i2c_fpga_write(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, (uint8_t)new_val); + read_val = board_i2c_fpga_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset); + } else { + pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d devtype:%s not configured\n",__func__, + ops_ptr->device_name, ops_ptr->index, ops_ptr->attr_devtype); + return (-1); + } + +#if DEBUG + pddf_dbg(LED, KERN_INFO "Set color:%s; 0x%x:0x%x sys_val:0x%x new_val:0x%x devtype:%s w_ret:0x%x read:0x%x devtype:%s\n", + LED_STATUS_STR[cur_state], ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, sys_val, new_val, + cpld_type? "cpld":"fpgai2c", ret, read_val, ops_ptr->data[cur_state].attr_devtype); +#endif + + return(ret); } ssize_t show_pddf_data(struct device *dev, struct device_attribute *da, char *buf) { - int ret = 0; - struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; - switch(ptr->type) - { - case PDDF_CHAR: - ret = sprintf(buf, "%s\n", ptr->addr); - break; - case PDDF_INT_DEC: - ret = sprintf(buf, "%d\n", *(int*)(ptr->addr)); - break; - case PDDF_INT_HEX: - ret = sprintf(buf, "0x%x\n", *(int*)(ptr->addr)); - break; - case PDDF_USHORT: - ret = sprintf(buf, "0x%x\n", *(unsigned short *)(ptr->addr)); - break; - case PDDF_UINT32: - ret = sprintf(buf, "0x%x\n", *(uint32_t *)(ptr->addr)); - break; - default: - break; - } + int ret = 0; + struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; + switch (ptr->type) + { + case PDDF_CHAR: + ret = sprintf(buf, "%s\n", ptr->addr); + break; + case PDDF_INT_DEC: + ret = sprintf(buf, "%d\n", *(int*)(ptr->addr)); + break; + case PDDF_INT_HEX: + ret = sprintf(buf, "0x%x\n", *(int*)(ptr->addr)); + break; + case PDDF_USHORT: + ret = sprintf(buf, "0x%x\n", *(unsigned short *)(ptr->addr)); + break; + case PDDF_UINT32: + ret = sprintf(buf, "0x%x\n", *(uint32_t *)(ptr->addr)); + break; + default: + break; + } #if DEBUG > 1 - pddf_dbg(LED, "[ READ ] DATA ATTR PTR [%s] TYPE:%d, Value:[%s]\n", - ptr->dev_attr.attr.name, ptr->type, buf); + pddf_dbg(LED, "[ READ ] DATA ATTR PTR [%s] TYPE:%d, Value:[%s]\n", + ptr->dev_attr.attr.name, ptr->type, buf); #endif - return ret; + return ret; } ssize_t store_pddf_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { - int ret = 0, num = 0; - struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; - switch(ptr->type) - { - case PDDF_CHAR: - strncpy(ptr->addr, buf, strlen(buf)-1); // to discard newline char form buf - ptr->addr[strlen(buf)-1] = '\0'; + int ret = 0, num = 0; + struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; + switch (ptr->type) + { + case PDDF_CHAR: + strncpy(ptr->addr, buf, strlen(buf)-1); // to discard newline char form buf + ptr->addr[strlen(buf)-1] = '\0'; #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_CHAR VALUE:%s\n", - ptr->dev_attr.attr.name, ptr->addr); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_CHAR VALUE:%s\n", + ptr->dev_attr.attr.name, ptr->addr); #endif - break; - case PDDF_INT_DEC: - ret = kstrtoint(buf,10,&num); - if (ret==0) - *(int *)(ptr->addr) = num; + break; + case PDDF_INT_DEC: + ret = kstrtoint(buf,10,&num); + if (ret==0) + *(int *)(ptr->addr) = num; #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_DEC VALUE:%d\n", - ptr->dev_attr.attr.name, *(int *)(ptr->addr)); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_DEC VALUE:%d\n", + ptr->dev_attr.attr.name, *(int *)(ptr->addr)); #endif - break; - case PDDF_INT_HEX: - ret = kstrtoint(buf,16,&num); - if (ret==0) - *(int *)(ptr->addr) = num; + break; + case PDDF_INT_HEX: + ret = kstrtoint(buf,16,&num); + if (ret==0) + *(int *)(ptr->addr) = num; #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_HEX VALUE:0x%x\n", - ptr->dev_attr.attr.name, *(int *)(ptr->addr)); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_HEX VALUE:0x%x\n", + ptr->dev_attr.attr.name, *(int *)(ptr->addr)); #endif - break; - case PDDF_USHORT: - ret = kstrtoint(buf,16,&num); - if (ret==0) - *(unsigned short *)(ptr->addr) = (unsigned short)num; + break; + case PDDF_USHORT: + ret = kstrtoint(buf,16,&num); + if (ret==0) + *(unsigned short *)(ptr->addr) = (unsigned short)num; #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_USHORT VALUE:%x\n", - ptr->dev_attr.attr.name, *(unsigned short *)(ptr->addr)); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_USHORT VALUE:%x\n", + ptr->dev_attr.attr.name, *(unsigned short *)(ptr->addr)); #endif - break; - case PDDF_UINT32: - ret = kstrtoint(buf,16,&num); - if (ret==0) - *(uint32_t *)(ptr->addr) = (uint32_t)num; + break; + case PDDF_UINT32: + ret = kstrtoint(buf,16,&num); + if (ret==0) + *(uint32_t *)(ptr->addr) = (uint32_t)num; #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_UINT32 VALUE:%d\n", - ptr->dev_attr.attr.name, *(uint32_t *)(ptr->addr)); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_UINT32 VALUE:%d\n", + ptr->dev_attr.attr.name, *(uint32_t *)(ptr->addr)); #endif - break; - default: - break; - } - return count; + break; + default: + break; + } + return count; } static int load_led_ops_data(struct device_attribute *da, LED_STATUS state) { - struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; - LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr; - LED_TYPE led_type; - LED_OPS_DATA* ops_ptr=NULL; - if(!ptr || strlen(ptr->device_name)==0 ) { - pddf_dbg(LED, KERN_INFO "SYSTEM_LED: load_led_ops_data return -1 device_name:%s\n", ptr? ptr->device_name:"NULL"); - return(-1); - } - if(ptr->device_name) + struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; + LED_OPS_DATA* ptr = (LED_OPS_DATA*)_ptr->addr; + LED_TYPE led_type; + LED_OPS_DATA* ops_ptr = NULL; + int i = 0; + char *token = NULL, *value_ptr = NULL; + + if(!ptr || strlen(ptr->device_name)==0 ) { + pddf_dbg(LED, KERN_INFO "SYSTEM_LED: load_led_ops_data return -1 device_name:%s\n", ptr? ptr->device_name:"NULL"); + return(-1); + } + + if(ptr->device_name) { - pddf_dbg(LED, KERN_INFO "[%s]: load_led_ops_data: index=%d addr=0x%x;0x%x valu=0x%x\n", - ptr->device_name, ptr->index, ptr->swpld_addr, ptr->swpld_addr_offset, ptr->data[0].value); - } - if((led_type=get_dev_type(ptr->device_name))==LED_TYPE_MAX) { - pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__); - return(-1); - } - if(dev_index_check(led_type, ptr->index)==-1) { - pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%d\n", __func__, ptr->index, led_type); - return(-1); - } - ops_ptr = dev_list[led_type]+ptr->index; - - memcpy(ops_ptr->device_name, ptr->device_name, sizeof(ops_ptr->device_name)); - ops_ptr->index = ptr->index; - memcpy(&ops_ptr->data[state], &ptr->data[0], sizeof(LED_DATA)); - ops_ptr->data[state].swpld_addr = ptr->swpld_addr; - ops_ptr->data[state].swpld_addr_offset = ptr->swpld_addr_offset; - ops_ptr->swpld_addr = ptr->swpld_addr; - ops_ptr->swpld_addr_offset = ptr->swpld_addr_offset; - - print_led_data(dev_list[led_type]+ptr->index, state); - - memset(ptr, 0, sizeof(LED_OPS_DATA)); - return (0); + pddf_dbg(LED, KERN_INFO "[%s]: load_led_ops_data: index=%d addr=0x%x;0x%x devtype:%s devname=%s valu=%s\n", + ptr->device_name, ptr->index, ptr->swpld_addr, ptr->swpld_addr_offset, ptr->attr_devtype, ptr->attr_devname, ptr->data[0].value); + } + if((led_type=get_dev_type(ptr->device_name))==LED_TYPE_MAX) { + pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__); + return(-1); + } + if(dev_index_check(led_type, ptr->index)==-1) { + pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%d\n", __func__, ptr->index, led_type); + return(-1); + } + ops_ptr = dev_list[led_type]+ptr->index; + + memcpy(ops_ptr->device_name, ptr->device_name, sizeof(ops_ptr->device_name)); + ops_ptr->index = ptr->index; + memcpy(&ops_ptr->data[state], &ptr->data[0], sizeof(LED_DATA)); + ops_ptr->data[state].swpld_addr = ptr->swpld_addr; + ops_ptr->data[state].swpld_addr_offset = ptr->swpld_addr_offset; + ops_ptr->swpld_addr = ptr->swpld_addr; + ops_ptr->swpld_addr_offset = ptr->swpld_addr_offset; + memcpy(ops_ptr->data[state].attr_devtype, ptr->attr_devtype, sizeof(ops_ptr->data[state].attr_devtype)); + memcpy(ops_ptr->data[state].attr_devname, ptr->attr_devname, sizeof(ops_ptr->data[state].attr_devname)); + memcpy(ops_ptr->attr_devtype, ptr->attr_devtype, sizeof(ops_ptr->attr_devtype)); + memcpy(ops_ptr->attr_devname, ptr->attr_devname, sizeof(ops_ptr->attr_devname)); + + memset(ops_ptr->data[state].reg_values, 0xff, sizeof(ops_ptr->data[state].reg_values)); + value_ptr = kzalloc(sizeof(ops_ptr->data[state].value), GFP_KERNEL); + if (value_ptr) { + memcpy(value_ptr, ops_ptr->data[state].value, sizeof(ops_ptr->data[state].value)); + while((token = strsep((char**)&value_ptr,";")) != NULL && i < VALUE_SIZE) { + if (kstrtou8(token, 16, &ops_ptr->data[state].reg_values[i])) { + pddf_dbg(LED, KERN_ERR "load_led_ops_data: [%s] conversion error\n", token); + } + i++; + } + kfree(value_ptr); + } + + print_led_data(dev_list[led_type]+ptr->index, state); + + memset(ptr, 0, sizeof(LED_OPS_DATA)); + return (0); } static int show_led_ops_data(struct device_attribute *da) { - LED_OPS_DATA* ops_ptr=find_led_ops_data(da); - print_led_data(ops_ptr, -1); - return(0); + LED_OPS_DATA* ops_ptr = find_led_ops_data(da); + print_led_data(ops_ptr, -1); + return(0); } static int verify_led_ops_data(struct device_attribute *da) { - struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; - LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr; - LED_OPS_DATA* ops_ptr=find_led_ops_data(da); + struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da; + LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr; + LED_OPS_DATA* ops_ptr=find_led_ops_data(da); - if(ops_ptr) - memcpy(ptr, ops_ptr, sizeof(LED_OPS_DATA)); - else + if(ops_ptr) + memcpy(ptr, ops_ptr, sizeof(LED_OPS_DATA)); + else { - pddf_dbg(LED, "SYSTEM_LED: verify_led_ops_data: Failed to find ops_ptr name:%s; index=%d\n", ptr->device_name, ptr->index); + pddf_dbg(LED, "SYSTEM_LED: verify_led_ops_data: Failed to find ops_ptr name:%s; index=%d\n", ptr->device_name, ptr->index); } - return (0); + return (0); } ssize_t dev_operation(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { #if DEBUG - pddf_dbg(LED, KERN_INFO "dev_operation [%s]\n", buf); + pddf_dbg(LED, KERN_INFO "dev_operation [%s]\n", buf); #endif - if(strstr(buf, "STATUS_LED_COLOR")!= NULL) { - LED_STATUS index = find_state_index(buf); - if (index < MAX_LED_STATUS ) { - load_led_ops_data(da, index); - } else { - printk(KERN_ERR "PDDF_ERROR %s: Invalid state for dev_ops %s", __FUNCTION__, buf); - } - } - else if(strncmp(buf, "show", strlen("show"))==0 ) { - show_led_ops_data(da); - } - else if(strncmp(buf, "verify", strlen("verify"))==0 ) { - verify_led_ops_data(da); - } - else if(strncmp(buf, "get_status", strlen("get_status"))==0 ) { - get_status_led(da); - } - else if(strncmp(buf, "set_status", strlen("set_status"))==0 ) { - set_status_led(da); - } - else { - printk(KERN_ERR "PDDF_ERROR %s: Invalid value for dev_ops %s", __FUNCTION__, buf); - } - return(count); + if(strncmp(buf, "show", strlen("show")) == 0) { + show_led_ops_data(da); + } + else if(strncmp(buf, "verify", strlen("verify")) == 0) { + verify_led_ops_data(da); + } + else if(strncmp(buf, "get_status", strlen("get_status")) == 0) { + get_status_led(da); + } + else if(strncmp(buf, "set_status", strlen("set_status")) == 0) { + set_status_led(da); + } + else { + LED_STATUS index = find_state_index(buf); + if (index < MAX_LED_STATUS) { + load_led_ops_data(da, index); + } else { + printk(KERN_ERR "PDDF_ERROR: %s: Invalid value for dev_ops %s\n", __FUNCTION__, buf); + } + } + return (count); } ssize_t store_config_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { - int ret, num; - struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; - if(strncmp(ptr->dev_attr.attr.name, "num_psus", strlen("num_psus"))==0 ) { - ret = kstrtoint(buf,10,&num); - if (ret==0) - *(int *)(ptr->addr) = num; - if(psu_led_ops_data == NULL) { - if ((psu_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) { - printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for PSU LED\n"); - return (count); - } - pddf_dbg(LED, "Allocate PSU LED Memory ADDR=%p\n", psu_led_ops_data); - dev_list[LED_PSU]=psu_led_ops_data; - } + int ret, num; + struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; + if(strncmp(ptr->dev_attr.attr.name, "num_psus", strlen("num_psus")) == 0) { + ret = kstrtoint(buf,10,&num); + if (ret==0) + *(int *)(ptr->addr) = num; + if (psu_led_ops_data == NULL) { + if ((psu_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) { + printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for PSU LED\n"); + return (count); + } + pddf_dbg(LED, "Allocate PSU LED Memory ADDR=%p\n", psu_led_ops_data); + dev_list[LED_PSU]=psu_led_ops_data; + } #if DEBUG pddf_dbg(LED, "[ WRITE ] ATTR CONFIG [%s] VALUE:%d; %d\n", - ptr->dev_attr.attr.name, num, num_psus); + ptr->dev_attr.attr.name, num, num_psus); #endif - return(count); - } - if(strncmp(ptr->dev_attr.attr.name, "num_fantrays", strlen("num_fantrays"))==0 ) { - ret = kstrtoint(buf,10,&num); - if (ret==0) - *(int *)(ptr->addr) = num; - if (fantray_led_ops_data == NULL) { - if ((fantray_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) { - printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for FANTRAY LED\n"); - return (count); - } - pddf_dbg(LED, "Allocate FanTray LED Memory ADDR=%p\n", fantray_led_ops_data); - dev_list[LED_FANTRAY]=fantray_led_ops_data; - } + return(count); + } + if (strncmp(ptr->dev_attr.attr.name, "num_fantrays", strlen("num_fantrays")) ==0) { + ret = kstrtoint(buf, 10, &num); + if (ret == 0) + *(int *)(ptr->addr) = num; + if (fantray_led_ops_data == NULL) { + if ((fantray_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) { + printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for FANTRAY LED\n"); + return (count); + } + pddf_dbg(LED, "Allocate FanTray LED Memory ADDR=%p\n", fantray_led_ops_data); + dev_list[LED_FANTRAY]=fantray_led_ops_data; + } #if DEBUG pddf_dbg(LED, "[ WRITE ] ATTR CONFIG [%s] VALUE:%d; %d\n", - ptr->dev_attr.attr.name, num, num_fantrays); + ptr->dev_attr.attr.name, num, num_fantrays); #endif - return(count); - } return (count); + } + return (count); } ssize_t store_bits_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count) { - int len = 0, num1 = 0, num2 = 0, i=0, rc1=0, rc2=0; - char mask=0xFF; - char *pptr=NULL; - char bits[NAME_SIZE]; - struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; - MASK_BITS* bits_ptr=(MASK_BITS*)(ptr->addr); - strncpy(bits_ptr->bits, buf, strlen(buf)-1); // to discard newline char form buf - bits_ptr->bits[strlen(buf)-1] = '\0'; - if((pptr=strstr(buf,":")) != NULL) { - len=pptr-buf; + int len = 0, num1 = 0, num2 = 0, i=0, rc1=0, rc2=0; + char mask=0xFF; + char *pptr=NULL; + char bits[NAME_SIZE]; + struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da; + MASK_BITS* bits_ptr=(MASK_BITS*)(ptr->addr); + strncpy(bits_ptr->bits, buf, strlen(buf)-1); // to discard newline char form buf + bits_ptr->bits[strlen(buf)-1] = '\0'; + if((pptr=strstr(buf,":")) != NULL) { + len = pptr-buf; sprintf(bits, buf); - bits[len]='\0'; - rc1=kstrtoint(bits,16,&num1); - if (rc1==0) + bits[len] = '\0'; + rc1 = kstrtoint(bits, 16, &num1); + if (rc1 == 0) { sprintf(bits, ++pptr); - rc2=kstrtoint(bits,16,&num2); - if (rc2==0) + rc2 = kstrtoint(bits, 16, &num2); + if (rc2 == 0) { for (i=num2; i<=num1; i++) { - mask &= ~(1 << i); + mask &= ~(1 << i); } bits_ptr->mask_bits = mask; bits_ptr->pos = num2; } } - } else { - rc1=kstrtoint(buf,16,&num1); - if (rc1==0) + } else { + rc1 = kstrtoint(buf, 16, &num1); + if (rc1 == 0) { bits_ptr->mask_bits = mask & ~(1 << num1); bits_ptr->pos = num1; } - } + } #if DEBUG - pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR Bits [%s] VALUE:%s mask:0x%x; pos:0x%x\n", - ptr->dev_attr.attr.name, bits_ptr->bits, bits_ptr->mask_bits, bits_ptr->pos); + pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR Bits [%s] VALUE:%s mask:0x%x; pos:0x%x\n", + ptr->dev_attr.attr.name, bits_ptr->bits, bits_ptr->mask_bits, bits_ptr->pos); #endif - return (count); + return (count); } /************************************************************************** - * platform/ attributes + * platform/ attributes **************************************************************************/ -PDDF_LED_DATA_ATTR(platform, num_psus, S_IWUSR|S_IRUGO, show_pddf_data, - store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_psus); -PDDF_LED_DATA_ATTR(platform, num_fantrays, S_IWUSR|S_IRUGO, show_pddf_data, - store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_fantrays); +PDDF_LED_DATA_ATTR(platform, num_psus, S_IWUSR|S_IRUGO, show_pddf_data, + store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_psus); +PDDF_LED_DATA_ATTR(platform, num_fantrays, S_IWUSR|S_IRUGO, show_pddf_data, + store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_fantrays); struct attribute* attrs_platform[]={ - &pddf_dev_platform_attr_num_psus.dev_attr.attr, - &pddf_dev_platform_attr_num_fantrays.dev_attr.attr, - NULL, + &pddf_dev_platform_attr_num_psus.dev_attr.attr, + &pddf_dev_platform_attr_num_fantrays.dev_attr.attr, + NULL, }; struct attribute_group attr_group_platform={ - .attrs = attrs_platform, + .attrs = attrs_platform, }; /************************************************************************** - * led/ attributes + * led/ attributes **************************************************************************/ -PDDF_LED_DATA_ATTR(dev, device_name, S_IWUSR|S_IRUGO, show_pddf_data, - store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.device_name); -PDDF_LED_DATA_ATTR(dev, index, S_IWUSR|S_IRUGO, show_pddf_data, - store_pddf_data, PDDF_INT_DEC, sizeof(int), (void*)&temp_data.index); -PDDF_LED_DATA_ATTR(dev, swpld_addr, S_IWUSR|S_IRUGO, show_pddf_data, - store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr); -PDDF_LED_DATA_ATTR(dev, swpld_addr_offset, S_IWUSR|S_IRUGO, show_pddf_data, - store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr_offset); -PDDF_LED_DATA_ATTR(dev, dev_ops , S_IWUSR, NULL, - dev_operation, PDDF_CHAR, NAME_SIZE, (void*)&temp_data); - -struct attribute* attrs_dev[]={ - &pddf_dev_dev_attr_device_name.dev_attr.attr, - &pddf_dev_dev_attr_index.dev_attr.attr, - &pddf_dev_dev_attr_swpld_addr.dev_attr.attr, - &pddf_dev_dev_attr_swpld_addr_offset.dev_attr.attr, - &pddf_dev_dev_attr_dev_ops.dev_attr.attr, - NULL, -}; -struct attribute_group attr_group_dev={ - .attrs = attrs_dev, -}; +PDDF_LED_DATA_ATTR(dev, device_name, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.device_name); +PDDF_LED_DATA_ATTR(dev, attr_devtype, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.attr_devtype); +PDDF_LED_DATA_ATTR(dev, attr_devname, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.attr_devname); +PDDF_LED_DATA_ATTR(dev, index, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_INT_DEC, sizeof(int), (void*)&temp_data.index); +PDDF_LED_DATA_ATTR(dev, swpld_addr, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr); +PDDF_LED_DATA_ATTR(dev, swpld_addr_offset, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr_offset); +PDDF_LED_DATA_ATTR(dev, dev_ops , S_IWUSR, NULL, + dev_operation, PDDF_CHAR, NAME_SIZE, (void*)&temp_data); + +struct attribute* attrs_dev[] = { + &pddf_dev_dev_attr_device_name.dev_attr.attr, + &pddf_dev_dev_attr_attr_devtype.dev_attr.attr, + &pddf_dev_dev_attr_attr_devname.dev_attr.attr, + &pddf_dev_dev_attr_index.dev_attr.attr, + &pddf_dev_dev_attr_swpld_addr.dev_attr.attr, + &pddf_dev_dev_attr_swpld_addr_offset.dev_attr.attr, + &pddf_dev_dev_attr_dev_ops.dev_attr.attr, + NULL, +}; + +struct attribute_group attr_group_dev = { + .attrs = attrs_dev, +}; /************************************************************************** - * state_attr/ attributes + * state_attr/ attributes **************************************************************************/ #define LED_DEV_STATE_ATTR_GROUP(name, func) \ - PDDF_LED_DATA_ATTR(name, bits, S_IWUSR|S_IRUGO, show_pddf_data, \ - store_bits_data, PDDF_CHAR, NAME_SIZE, func.bits.bits); \ - PDDF_LED_DATA_ATTR(name, value, S_IWUSR|S_IRUGO, show_pddf_data, \ - store_pddf_data, PDDF_USHORT, sizeof(unsigned short), func.value); \ - struct attribute* attrs_##name[]={ \ - &pddf_dev_##name##_attr_bits.dev_attr.attr, \ - &pddf_dev_##name##_attr_value.dev_attr.attr, \ - NULL, \ - }; \ - struct attribute_group attr_group_##name={ \ - .attrs = attrs_##name, \ - }; \ + PDDF_LED_DATA_ATTR(name, bits, S_IWUSR|S_IRUGO, show_pddf_data, \ + store_bits_data, PDDF_CHAR, NAME_SIZE, func.bits.bits); \ + PDDF_LED_DATA_ATTR(name, value, S_IWUSR|S_IRUGO, show_pddf_data, \ + store_pddf_data, PDDF_CHAR, NAME_SIZE, func.value); \ + struct attribute* attrs_##name[]={ \ + &pddf_dev_##name##_attr_bits.dev_attr.attr, \ + &pddf_dev_##name##_attr_value.dev_attr.attr, \ + NULL, \ + }; \ + struct attribute_group attr_group_##name={ \ + .attrs = attrs_##name, \ + }; \ LED_DEV_STATE_ATTR_GROUP(state_attr, (void*)&temp_data.data[0]) /************************************************************************** - * cur_state/ attributes + * cur_state/ attributes **************************************************************************/ -PDDF_LED_DATA_ATTR(cur_state, color, S_IWUSR|S_IRUGO, show_pddf_data, - store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.cur_state.color); +PDDF_LED_DATA_ATTR(cur_state, color, S_IWUSR|S_IRUGO, show_pddf_data, + store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.cur_state.color); -struct attribute* attrs_cur_state[]={ - &pddf_dev_cur_state_attr_color.dev_attr.attr, - NULL, +struct attribute* attrs_cur_state[] = { + &pddf_dev_cur_state_attr_color.dev_attr.attr, + NULL, }; + struct attribute_group attr_group_cur_state={ - .attrs = attrs_cur_state, + .attrs = attrs_cur_state, }; /*************************************************************************/ #define KOBJ_FREE(obj) \ - if(obj) kobject_put(obj); \ + if(obj) kobject_put(obj); \ void free_kobjs(void) { - KOBJ_FREE(cur_state_kobj) - KOBJ_FREE(state_attr_kobj) - KOBJ_FREE(led_kobj) - KOBJ_FREE(platform_kobj) + KOBJ_FREE(cur_state_kobj) + KOBJ_FREE(state_attr_kobj) + KOBJ_FREE(led_kobj) + KOBJ_FREE(platform_kobj) } int KBOJ_CREATE(char* name, struct kobject* parent, struct kobject** child) { - if (parent) { - *child = kobject_create_and_add(name, parent); - } else { - printk(KERN_ERR "PDDF_LED ERROR to create %s kobj; null parent\n", name); - free_kobjs(); - return (-ENOMEM); - } - return (0); + if (parent) { + *child = kobject_create_and_add(name, parent); + } else { + printk(KERN_ERR "PDDF_LED ERROR to create %s kobj; null parent\n", name); + free_kobjs(); + return (-ENOMEM); + } + return (0); } -int LED_DEV_ATTR_CREATE(struct kobject *kobj, const struct attribute_group *attr, const char* name) +int LED_DEV_ATTR_CREATE(struct kobject *kobj, const struct attribute_group *attr, const char* name) { - int status = sysfs_create_group(kobj, attr); - if(status) { - pddf_dbg(LED, KERN_ERR "Driver ERROR: sysfs_create %s failed rc=%d\n", name, status); - } + int status = sysfs_create_group(kobj, attr); + if(status) { + pddf_dbg(LED, KERN_ERR "Driver ERROR: sysfs_create %s failed rc=%d\n", name, status); + } return (status); } static int __init led_init(void) { - struct kobject *device_kobj; - pddf_dbg(LED, KERN_INFO "PDDF GENERIC LED MODULE init..\n"); - - device_kobj = get_device_i2c_kobj(); - if(!device_kobj) - return -ENOMEM; - - KBOJ_CREATE("platform", device_kobj, &platform_kobj); - KBOJ_CREATE("led", device_kobj, &led_kobj); - KBOJ_CREATE("state_attr", led_kobj, &state_attr_kobj); - KBOJ_CREATE("cur_state", led_kobj, &cur_state_kobj); - - LED_DEV_ATTR_CREATE(platform_kobj, &attr_group_platform, "attr_group_platform"); - LED_DEV_ATTR_CREATE(led_kobj, &attr_group_dev, "attr_group_dev"); - LED_DEV_ATTR_CREATE(state_attr_kobj, &attr_group_state_attr, "attr_group_state_attr"); - LED_DEV_ATTR_CREATE(cur_state_kobj, &attr_group_cur_state, "attr_group_cur_state"); - return (0); + struct kobject *device_kobj; + pddf_dbg(LED, KERN_INFO "PDDF GENERIC LED MODULE init..\n"); + + device_kobj = get_device_i2c_kobj(); + if(!device_kobj) + return -ENOMEM; + + KBOJ_CREATE("platform", device_kobj, &platform_kobj); + KBOJ_CREATE("led", device_kobj, &led_kobj); + KBOJ_CREATE("state_attr", led_kobj, &state_attr_kobj); + KBOJ_CREATE("cur_state", led_kobj, &cur_state_kobj); + + LED_DEV_ATTR_CREATE(platform_kobj, &attr_group_platform, "attr_group_platform"); + LED_DEV_ATTR_CREATE(led_kobj, &attr_group_dev, "attr_group_dev"); + LED_DEV_ATTR_CREATE(state_attr_kobj, &attr_group_state_attr, "attr_group_state_attr"); + LED_DEV_ATTR_CREATE(cur_state_kobj, &attr_group_cur_state, "attr_group_cur_state"); + return (0); } static void __exit led_exit(void) { - pddf_dbg(LED, "PDDF GENERIC LED MODULE exit..\n"); - free_kobjs(); - if(psu_led_ops_data) kfree(psu_led_ops_data); - if(fantray_led_ops_data) kfree(fantray_led_ops_data); + pddf_dbg(LED, "PDDF GENERIC LED MODULE exit..\n"); + free_kobjs(); + if(psu_led_ops_data) kfree(psu_led_ops_data); + if(fantray_led_ops_data) kfree(fantray_led_ops_data); } module_init(led_init); diff --git a/platform/pddf/i2c/modules/psu/driver/pddf_psu_driver.c b/platform/pddf/i2c/modules/psu/driver/pddf_psu_driver.c index 86b2c1271c47..bd26f13e9b84 100644 --- a/platform/pddf/i2c/modules/psu/driver/pddf_psu_driver.c +++ b/platform/pddf/i2c/modules/psu/driver/pddf_psu_driver.c @@ -383,7 +383,7 @@ int psu_init(void) } EXPORT_SYMBOL(psu_init); -void __exit psu_exit(void) +void psu_exit(void) { pddf_dbg(PSU, "GENERIC_PSU_DRIVER.. exit\n"); if (pddf_psu_ops.pre_exit) (pddf_psu_ops.pre_exit)(); diff --git a/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_api.c b/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_api.c index a7be64328cab..18303cc788b9 100644 --- a/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_api.c +++ b/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_api.c @@ -40,6 +40,10 @@ extern XCVR_SYSFS_ATTR_OPS xcvr_ops[]; extern void *get_device_table(char *name); +extern int (*ptr_fpgapci_read)(uint32_t); +extern int (*ptr_fpgapci_write)(uint32_t, uint32_t); + + int get_xcvr_module_attr_data(struct i2c_client *client, struct device *dev, struct device_attribute *da); @@ -146,6 +150,148 @@ int xcvr_i2c_cpld_write(XCVR_ATTR *info, uint32_t val) return status; } +int xcvr_i2c_fpga_read(XCVR_ATTR *info) +{ + int status = -1; + int retry = 10; + + if (info!=NULL) + { + /* Get the I2C client for the CPLD */ + struct i2c_client *client_ptr=NULL; + client_ptr = (struct i2c_client *)get_device_table(info->devname); + if (client_ptr) + { + if (info->len==1) + { + while(retry) + { + status = i2c_smbus_read_byte_data(client_ptr , info->offset); + if (unlikely(status < 0)) + { + msleep(60); + retry--; + continue; + } + break; + } + } + else if (info->len==2) + { + retry = 10; + while(retry) + { + status = i2c_smbus_read_word_swapped(client_ptr, info->offset); + if (unlikely(status < 0)) + { + msleep(60); + retry--; + continue; + } + break; + } + } + else + printk(KERN_ERR "PDDF_XCVR: Doesn't support block FPGAI2C read yet"); + } + else + printk(KERN_ERR "Unable to get the client handle for %s\n", info->devname); + } + + return status; +} + +int xcvr_i2c_fpga_write(XCVR_ATTR *info, uint32_t val) +{ + int status = 0; + unsigned int val_mask = 0, dnd_value = 0; + uint32_t reg; + struct i2c_client *client_ptr = NULL; + + val_mask = BIT_INDEX(info->mask); + /* Get the I2C client for the CPLD */ + client_ptr = (struct i2c_client *)get_device_table(info->devname); + + if (client_ptr) + { + if (info->len == 1) + status = i2c_smbus_read_byte_data(client_ptr, info->offset); + else if (info->len == 2) + status = i2c_smbus_read_word_swapped(client_ptr, info->offset); + else + { + printk(KERN_ERR "PDDF_XCVR: Doesn't support block FPGAI2C read yet"); + status = -1; + } + } + else + { + printk(KERN_ERR "Unable to get the client handle for %s\n", info->devname); + status = -1; + } + + if (status < 0) + return status; + else + { + msleep(60); + dnd_value = status & ~val_mask; + if (((val == 1) && (info->cmpval != 0)) || ((val == 0) && (info->cmpval == 0))) + reg = dnd_value | val_mask; + else + reg = dnd_value; + if (info->len == 1) + status = i2c_smbus_write_byte_data(client_ptr, info->offset, (uint8_t)reg); + else if (info->len == 2) + status = i2c_smbus_write_word_swapped(client_ptr, info->offset, (uint16_t)reg); + else + { + printk(KERN_ERR "PDDF_XCVR: Doesn't support block FPGAI2C write yet"); + status = -1; + } + } + return status; +} + +int xcvr_fpgapci_read(XCVR_ATTR *info) +{ + int reg_val= 0; + uint32_t offset = 0; + + if (ptr_fpgapci_read == NULL) { + printk(KERN_ERR "PDDF_XCVR: Doesn't support FPGAPCI read yet"); + return (-1); + } + + offset = info->devaddr + info->offset; + reg_val = ptr_fpgapci_read(offset); + return reg_val; +} + +int xcvr_fpgapci_write(XCVR_ATTR *info, uint32_t val) +{ + int status= 0; + uint32_t reg, val_mask = 0, dnd_value = 0, reg_val; + uint32_t offset = 0; + + if (ptr_fpgapci_read == NULL || ptr_fpgapci_write == NULL) { + printk(KERN_ERR "PDDF_XCVR: Doesn't support FPGAPCI read or write yet"); + return (-1); + } + + offset = info->devaddr + info->offset; + val_mask = BIT_INDEX(info->mask); + reg_val = ptr_fpgapci_read(offset); + dnd_value = reg_val & ~val_mask; + + if (((val == 1) && (info->cmpval != 0)) || ((val == 0) && (info->cmpval == 0))) + reg = dnd_value | val_mask; + else + reg = dnd_value; + + status = ptr_fpgapci_write(offset, reg); + return status; +} int sonic_i2c_get_mod_pres(struct i2c_client *client, XCVR_ATTR *info, struct xcvr_data *data) { @@ -164,6 +310,31 @@ int sonic_i2c_get_mod_pres(struct i2c_client *client, XCVR_ATTR *info, struct xc sfp_dbg(KERN_INFO "\nMod presence :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + modpres = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nMod presence :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } + else if ( strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_read(info); + + if (status < 0) + return status; + else + { + modpres = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nMod presence :0x%x, status= 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } + else if(strcmp(info->devtype, "eeprom") == 0) { /* get client client for eeprom - Not Applicable */ @@ -189,6 +360,30 @@ int sonic_i2c_get_mod_reset(struct i2c_client *client, XCVR_ATTR *info, struct x sfp_dbg(KERN_INFO "\nMod Reset :0x%x, reg_value = 0x%x\n", modreset, status); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + modreset = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nMod reset :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } + else if ( strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_read(info); + sfp_dbg(KERN_INFO "\n[%s] status=%x\n", __FUNCTION__, status); + if (status < 0) + return status; + else + { + modreset = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nMod reset :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modreset, status, info->devaddr, info->mask, info->offset); + } + } else if(strcmp(info->devtype, "eeprom") == 0) { /* get client client for eeprom - Not Applicable */ @@ -214,6 +409,31 @@ int sonic_i2c_get_mod_intr_status(struct i2c_client *client, XCVR_ATTR *info, st sfp_dbg(KERN_INFO "\nModule Interrupt :0x%x, reg_value = 0x%x\n", mod_intr, status); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + mod_intr = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule Interrupt :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } + else if ( strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_read(info); + sfp_dbg(KERN_INFO "\n[%s] status=%x\n", __FUNCTION__, status); + if (status < 0) + return status; + else + { + mod_intr = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule Interrupt :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", mod_intr, status, info->devaddr, info->mask, info->offset); + } + } + else if(strcmp(info->devtype, "eeprom") == 0) { /* get client client for eeprom - Not Applicable */ @@ -240,6 +460,30 @@ int sonic_i2c_get_mod_lpmode(struct i2c_client *client, XCVR_ATTR *info, struct sfp_dbg(KERN_INFO "\nModule LPmode :0x%x, reg_value = 0x%x\n", lpmode, status); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + lpmode = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule LPmode :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } + else if ( strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_read(info); + sfp_dbg(KERN_INFO "\n[%s] status=%x\n", __FUNCTION__, status); + if (status < 0) + return status; + else + { + lpmode = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nlpmode :0x%x, reg_val = 0x%x, op=0x%x, mask=0x%x, offset=0x%x\n", lpmode, status, status & BIT_INDEX(info->mask), info->mask, info->offset); + } + } else if (strcmp(info->devtype, "eeprom") == 0) { /* get client client for eeprom - Not Applicable */ @@ -266,6 +510,18 @@ int sonic_i2c_get_mod_rxlos(struct i2c_client *client, XCVR_ATTR *info, struct x sfp_dbg(KERN_INFO "\nModule RxLOS :0x%x, reg_value = 0x%x\n", rxlos, status); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + rxlos = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule RxLOS :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } data->rxlos = rxlos; return 0; @@ -287,6 +543,18 @@ int sonic_i2c_get_mod_txdisable(struct i2c_client *client, XCVR_ATTR *info, stru sfp_dbg(KERN_INFO "\nModule TxDisable :0x%x, reg_value = 0x%x\n", txdis, status); } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + txdis = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule TxDisable :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } data->txdisable = txdis; return 0; @@ -309,6 +577,18 @@ int sonic_i2c_get_mod_txfault(struct i2c_client *client, XCVR_ATTR *info, struct } } + else if ( strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_read(info); + + if (status < 0) + return status; + else + { + txflt = ((status & BIT_INDEX(info->mask)) == info->cmpval) ? 1 : 0; + sfp_dbg(KERN_INFO "\nModule Txfault :0x%x, reg_value = 0x%x, devaddr=0x%x, mask=0x%x, offset=0x%x\n", modpres, status, info->devaddr, info->mask, info->offset); + } + } data->txfault = txflt; return 0; @@ -322,6 +602,14 @@ int sonic_i2c_set_mod_reset(struct i2c_client *client, XCVR_ATTR *info, struct x { status = xcvr_i2c_cpld_write(info, data->reset); } + else if (strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_write(info, data->reset); + } + else if (strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_write(info, data->reset); + } else { printk(KERN_ERR "Error: Invalid device type (%s) to set xcvr reset\n", info->devtype); @@ -339,6 +627,14 @@ int sonic_i2c_set_mod_lpmode(struct i2c_client *client, XCVR_ATTR *info, struct { status = xcvr_i2c_cpld_write(info, data->lpmode); } + else if (strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_write(info, data->lpmode); + } + else if (strcmp(info->devtype, "fpgapci") == 0) + { + status = xcvr_fpgapci_write(info, data->lpmode); + } else { printk(KERN_ERR "Error: Invalid device type (%s) to set xcvr lpmode\n", info->devtype); @@ -356,6 +652,10 @@ int sonic_i2c_set_mod_txdisable(struct i2c_client *client, XCVR_ATTR *info, stru { status = xcvr_i2c_cpld_write(info, data->txdisable); } + else if (strcmp(info->devtype, "fpgai2c") == 0) + { + status = xcvr_i2c_fpga_write(info, data->txdisable); + } else { printk(KERN_ERR "Error: Invalid device type (%s) to set xcvr txdisable\n", info->devtype); diff --git a/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_driver.c b/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_driver.c index 7ce1bca94b71..be4a01acf176 100644 --- a/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_driver.c +++ b/platform/pddf/i2c/modules/xcvr/driver/pddf_xcvr_driver.c @@ -278,7 +278,7 @@ int xcvr_init(void) } EXPORT_SYMBOL(xcvr_init); -void __exit xcvr_exit(void) +void xcvr_exit(void) { pddf_dbg(XCVR, "PDDF XCVR DRIVER.. exit\n"); if (pddf_xcvr_ops.pre_exit) (pddf_xcvr_ops.pre_exit)(); @@ -288,9 +288,9 @@ void __exit xcvr_exit(void) } EXPORT_SYMBOL(xcvr_exit); +module_init(xcvr_init); +module_exit(xcvr_exit); + MODULE_AUTHOR("Broadcom"); MODULE_DESCRIPTION("Driver for transceiver operations"); MODULE_LICENSE("GPL"); - -module_init(xcvr_init); -module_exit(xcvr_exit); diff --git a/platform/pddf/i2c/utils/pddf_util.py b/platform/pddf/i2c/utils/pddf_util.py index d3ee5e43aca9..7943f8b77fc8 100755 --- a/platform/pddf/i2c/utils/pddf_util.py +++ b/platform/pddf/i2c/utils/pddf_util.py @@ -203,7 +203,9 @@ def config_pddf_utils(): if not os.path.exists(SONIC_PLATFORM_BSP_WHL_PKG_BK): # bsp 2.0 classes are installed. Take a backup and copy pddf 2.0 whl pkg log_os_system('mv '+SONIC_PLATFORM_BSP_WHL_PKG+' '+SONIC_PLATFORM_BSP_WHL_PKG_BK, 1) + log_os_system('sync', 1) shutil.copy(SONIC_PLATFORM_PDDF_WHL_PKG, SONIC_PLATFORM_BSP_WHL_PKG) + log_os_system('sync', 1) # uninstall the existing bsp whl pkg status, output = log_os_system("pip3 uninstall sonic-platform -y &> /dev/null", 1) if status: @@ -328,6 +330,7 @@ def create_pddf_log_files(): log_os_system("sudo touch /var/log/pddf/cpldmux.txt", 1) log_os_system("sudo touch /var/log/pddf/client.txt", 1) log_os_system("sudo touch /var/log/pddf/mux.txt", 1) + log_os_system("sudo touch /var/log/pddf/fpgapci.txt", 1) def driver_install(): global FORCE diff --git a/platform/pddf/i2c/utils/pddfparse.py b/platform/pddf/i2c/utils/pddfparse.py index 2f3a3b108cf9..70f2b4e017bb 100755 --- a/platform/pddf/i2c/utils/pddfparse.py +++ b/platform/pddf/i2c/utils/pddfparse.py @@ -18,19 +18,6 @@ dirname = os.path.dirname(os.path.realpath(__file__)) -color_map = { - "STATUS_LED_COLOR_GREEN" : "green", - "STATUS_LED_COLOR_RED" : "red", - "STATUS_LED_COLOR_AMBER" : "amber", - "STATUS_LED_COLOR_BLUE" : "blue", - "STATUS_LED_COLOR_GREEN_BLINK" : "blinking green", - "STATUS_LED_COLOR_RED_BLINK" : "blinking red", - "STATUS_LED_COLOR_AMBER_BLINK" : "blinking amber", - "STATUS_LED_COLOR_BLUE_BLINK" : "blinking blue", - "STATUS_LED_COLOR_OFF" : "off" -} - - class PddfParse(): def __init__(self): if not os.path.exists("/usr/share/sonic/platform"): @@ -128,7 +115,7 @@ def get_led_color(self): except IOError: return ("Error") - return (color_map[color]) + return (color) ################################################################################################################### # CREATE DEFS @@ -262,6 +249,30 @@ def create_cpld_device(self, dev, ops): return create_ret.append(ret) + def create_fpgai2c_device(self, dev, ops): + create_ret = [] + ret = 0 + if dev['i2c']['topo_info']['dev_type'] in self.data['PLATFORM']['pddf_dev_types']['FPGAI2C']: + ret = self.create_device(dev['i2c']['topo_info'], "pddf/devices/fpgai2c", ops) + if ret!=0: + return create_ret.append(ret) + + cmd= "echo '%s' > /sys/kernel/pddf/devices/fpgai2c/i2c_name"%(dev['dev_info']['device_name']) + ret = self.runcmd(cmd) + if ret!=0: + return create_ret.append(ret) + cmd= "echo 'add' > /sys/kernel/pddf/devices/fpgai2c/dev_ops" + ret = self.runcmd(cmd) + if ret!=0: + return create_ret.append(ret) + else: + cmd= "echo %s 0x%x > /sys/bus/i2c/devices/i2c-%d/new_device" % (dev['i2c']['topo_info']['dev_type'], int(dev['i2c']['topo_info']['dev_addr'], 0), int(dev['i2c']['topo_info']['parent_bus'], 0)) + ret = self.runcmd(cmd) + if ret!=0: + return create_ret.append(ret) + + return create_ret.append(ret) + def create_cpldmux_device(self, dev, ops): create_ret = [] ret = 0 @@ -436,7 +447,19 @@ def create_eeprom_device(self, dev, ops): return create_ret.append(ret) - ################################################################################################################### + def create_fpgapci_device(self, dev, ops): + create_ret = [] + ret = 0 + ret = self.create_device(dev['i2c']['dev_attr'], "pddf/devices/fpgapci", ops) + if ret!=0: + return create_ret.append(ret) + + cmd = "echo 'fpgapci_init' > /sys/kernel/pddf/devices/fpgapci/dev_ops" + ret = self.runcmd(cmd) + return create_ret.append(ret) + + + ################################################################################################################################# # DELETE DEFS ################################################################################################################### def delete_eeprom_device(self, dev, ops): @@ -494,6 +517,16 @@ def delete_cpld_device(self, dev, ops): int(dev['i2c']['topo_info']['dev_addr'], 0), int(dev['i2c']['topo_info']['parent_bus'], 0)) self.runcmd(cmd) + def delete_fpgai2c_device(self, dev, ops): + if dev['i2c']['topo_info']['dev_type'] in self.data['PLATFORM']['pddf_dev_types']['FPGAI2C']: + cmd= "echo '%s' > /sys/kernel/pddf/devices/fpgai2c/i2c_name"%(dev['dev_info']['device_name']) + self.runcmd(cmd) + cmd= "echo 'delete' > /sys/kernel/pddf/devices/fpgai2c/dev_ops" + self.runcmd(cmd) + else: + cmd= "echo 0x%x > /sys/bus/i2c/devices/i2c-%d/delete_device" % (int(dev['i2c']['topo_info']['dev_addr'], 0), int(dev['i2c']['topo_info']['parent_bus'], 0)) + self.runcmd(cmd) + def delete_cpldmux_device(self, dev, ops): if dev['i2c']['topo_info']['dev_type'] in self.data['PLATFORM']['pddf_dev_types']['CPLDMUX']: cmd = "echo '%s' > /sys/kernel/pddf/devices/cpldmux/i2c_name" % (dev['dev_info']['device_name']) @@ -534,7 +567,9 @@ def delete_psu_device(self, dev, ops): self.delete_psu_i2c_device(dev, ops) return - ################################################################################################################### + def delete_fpgapci_device(self, dev, ops): + return + ################################################################################################################################# # SHOW ATTRIBIUTES DEFS ################################################################################################################### def is_led_device_configured(self, device_name, attr_name): @@ -991,6 +1026,21 @@ def show_cpld_device(self, dev, ops): '/sys/kernel/pddf/devices/cpld/error'] self.add_list_sysfs_obj(self.sysfs_obj, KEY, extra_list) + def show_fpgai2c_device(self, dev, ops): + KEY ='fpgai2c' + if dev['i2c']['topo_info']['dev_type'] in self.data['PLATFORM']['pddf_dev_types']['FPGAI2C']: + if not KEY in self.sysfs_obj: + self.sysfs_obj[KEY] = [] + self.sysfs_device(dev['i2c']['topo_info'], "pddf/devices/fpgai2c", self.sysfs_obj, KEY) + sysfs_path = "/sys/kernel/pddf/devices/fpgai2c/dev_ops" + if not sysfs_path in self.sysfs_obj[KEY]: + self.sysfs_obj[KEY].append(sysfs_path) + extra_list = ['/sys/kernel/pddf/devices/fpgai2c/i2c_type', + '/sys/kernel/pddf/devices/fpgai2c/i2c_name', + '/sys/kernel/pddf/devices/fpgai2c/error'] + self.add_list_sysfs_obj(self.sysfs_obj, KEY, extra_list) + + def show_led_platform_device(self, key, ops): if ops['attr'] == 'all' or ops['attr'] == 'PLATFORM': KEY = 'platform' @@ -1006,21 +1056,36 @@ def show_led_device(self, key, ops): if not KEY in self.sysfs_obj: self.sysfs_obj[KEY] = [] path="pddf/devices/led" - for attr in self.data[key]['i2c']['attr_list']: - self.sysfs_attr('device_name', self.data[key]['dev_info']['device_name'],path,self.sysfs_obj,KEY) - self.sysfs_attr('swpld_addr', self.data[key]['dev_info']['device_name'],path,self.sysfs_obj, KEY) - self.sysfs_attr('swpld_addr_offset',self.data[key]['dev_info']['device_name'], - path,self.sysfs_obj, KEY) - self.sysfs_device(self.data[key]['dev_attr'], path, self.sysfs_obj, KEY) - for attr_key in attr.keys(): - attr_path = "pddf/devices/led/" + attr['attr_name'] - if (attr_key != 'attr_name' and attr_key != 'swpld_addr' and attr_key != 'swpld_addr_offset'): - self.sysfs_attr(attr_key, attr[attr_key], attr_path, self.sysfs_obj, KEY) + self.sysfs_attr('device_name', self.data[key]['dev_info']['device_name'], path, self.sysfs_obj, KEY) + self.sysfs_attr('swpld_addr', self.data[key]['dev_info']['device_name'], path, self.sysfs_obj, KEY) + self.sysfs_attr('swpld_addr_offset', self.data[key]['dev_info']['device_name'], path, self.sysfs_obj, KEY) + state_attr_path="pddf/devices/led/state_attr" + self.sysfs_attr('bits', self.data[key]['dev_info']['device_name'], state_attr_path, self.sysfs_obj, KEY) + self.sysfs_attr('value', self.data[key]['dev_info']['device_name'], state_attr_path, self.sysfs_obj, KEY) sysfs_path="/sys/kernel/pddf/devices/led/dev_ops" if not sysfs_path in self.sysfs_obj[KEY]: self.sysfs_obj[KEY].append(sysfs_path) - list=['/sys/kernel/pddf/devices/led/cur_state/color'] - self.add_list_sysfs_obj(self.sysfs_obj, KEY, list) + extra_list=['/sys/kernel/pddf/devices/led/cur_state/color'] + self.add_list_sysfs_obj(self.sysfs_obj, KEY, extra_list) + + + def show_fpgapci_device(self, dev, ops): + KEY ='fpgapci' + if dev['dev_info']['device_type'] in self.data['PLATFORM']['pddf_dev_types']['FPGAPCIE']: + if not KEY in self.sysfs_obj: + self.sysfs_obj[KEY] = [] + sysfs_path = "/sys/kernel/pddf/devices/fpgapci" + if not sysfs_path in self.sysfs_obj[KEY]: + self.sysfs_obj[KEY].append(sysfs_path) + extra_list = ['/sys/kernel/pddf/devices/fpgapci/vendor_id', + '/sys/kernel/pddf/devices/fpgapci/virt_bus', + '/sys/kernel/pddf/devices/fpgapci/device_id', + '/sys/kernel/pddf/devices/fpgapci/data_base_offset', + '/sys/kernel/pddf/devices/fpgapci/data_size', + '/sys/kernel/pddf/devices/fpgapci/i2c_ch_base_offset', + '/sys/kernel/pddf/devices/fpgapci/i2c_ch_size', + '/sys/kernel/pddf/devices/fpgapci/virt_i2c_ch'] + self.add_list_sysfs_obj(self.sysfs_obj, KEY, extra_list) def validate_xcvr_device(self, dev, ops): @@ -1077,6 +1142,13 @@ def validate_cpld_device(self, dev, ops): ret_val = "cpld success" print(ret_val) + def validate_fpgai2c_device(self, dev, ops): + devtype_list = ['i2c_fpga'] + ret_val = "fpgai2c failed" + + if dev['i2c']['topo_info']['dev_type'] in devtype_list: + ret_val = "fpgai2c success" + print(ret_val) def validate_sysstatus_device(self, dev, ops): dev_attribs = ['board_info', 'cpld1_version', 'power_module_status', 'system_reset5', @@ -1284,7 +1356,7 @@ def modules_validation(self, validate_type): else: print("Loaded") else: - print(validate_type + " not configured" ) + print(validate_type + " not configured") @@ -1530,7 +1602,28 @@ def cpu_parse_reverse(self, bus, ops): val.extend(ret) return val + def fpgapci_parse(self, dev, ops): + val = [] + ret = getattr(self, ops['cmd']+"_fpgapci_device")(dev, ops) + if ret: + if str(ret[0]).isdigit(): + if ret[0]!=0: + # in case if 'create' functions + print("{}_fpgapci_device() cmd failed".format(ops['cmd'])) + return ret + else: + val.extend(ret) + for bus in dev['i2c']['channel']: + ret = self.dev_parse(self.data[bus['dev']], ops) + if ret: + if str(ret[0]).isdigit(): + if ret[0]!=0: + # in case if 'create' functions + return ret + else: + val.extend(ret) + return val # 'create' and 'show_attr' ops returns an array # 'delete', 'show' and 'validate' ops return None @@ -1542,6 +1635,9 @@ def dev_parse(self, dev, ops): else: return self.cpu_parse(dev, ops) + if attr['device_type'] == 'FPGAPCIE': + return self.fpgapci_parse(dev, ops) + if attr['device_type'] == 'EEPROM': return self.eeprom_parse(dev, ops) @@ -1568,6 +1664,9 @@ def dev_parse(self, dev, ops): attr['device_type'] == 'QSFP-DD': return self.optic_parse(dev, ops) + if attr['device_type'] == 'FPGAI2C': + return self.fpgai2c_parse(dev, ops) + if attr['device_type'] == 'CPLD': return self.cpld_parse(dev, ops) @@ -1589,9 +1688,10 @@ def is_supported_sysled_state(self, sysled_name, sysled_state): return False, "[FAILED]: Invalid color" - def create_attr(self, key, value, path): - cmd = "echo '%s' > /sys/kernel/%s/%s" % (value, path, key) - self.runcmd(cmd) + def create_attr(self, key, value, path, exceptions=[]): + if key not in exceptions: + cmd = "echo '%s' > /sys/kernel/%s/%s" % (value, path, key) + self.runcmd(cmd) def create_led_platform_device(self, key, ops): if ops['attr'] == 'all' or ops['attr'] == 'PLATFORM': @@ -1601,16 +1701,23 @@ def create_led_platform_device(self, key, ops): def create_led_device(self, key, ops): if ops['attr']=='all' or ops['attr']==self.data[key]['dev_info']['device_name']: - path="pddf/devices/led" + path = "pddf/devices/led" + ops_state = "" + if 'bmc' in self.data[key]: + return for attr in self.data[key]['i2c']['attr_list']: self.create_attr('device_name', self.data[key]['dev_info']['device_name'], path) - self.create_device(self.data[key]['dev_attr'], path, ops) + self.create_attr('index', self.data[key]['dev_attr']['index'], path) + #attr_devtype and attr_devname are optional in json file. + #if attr_devtype is not defined, it means it is "cpld" + if 'attr_devtype' not in attr.keys(): + self.create_attr('attr_devtype', 'cpld', path) for attr_key in attr.keys(): - if (attr_key == 'swpld_addr_offset' or attr_key == 'swpld_addr'): + if (attr_key == 'swpld_addr_offset' or attr_key == 'swpld_addr' or \ + attr_key == 'attr_devtype' or attr_key == 'attr_devname' ): self.create_attr(attr_key, attr[attr_key], path) - elif (attr_key != 'attr_name' and attr_key != 'descr' and - attr_key != 'attr_devtype' and attr_key != 'attr_devname'): - state_path=path+'/state_attr' + elif (attr_key != 'attr_name' and attr_key != 'descr' and attr_key != 'state'): + state_path = path+'/state_attr' self.create_attr(attr_key, attr[attr_key],state_path) cmd="echo '" + attr['attr_name']+"' > /sys/kernel/pddf/devices/led/dev_ops" self.runcmd(cmd) From 9f14e6f90332b349e5f21a847dc0a39ae2f8f05e Mon Sep 17 00:00:00 2001 From: Fuzail Khan Date: Sun, 29 Jan 2023 20:47:45 -0800 Subject: [PATCH 2/5] Enabling FPGA support in PDDF: Fixing semgrep check failure --- platform/pddf/i2c/modules/led/pddf_led_module.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/platform/pddf/i2c/modules/led/pddf_led_module.c b/platform/pddf/i2c/modules/led/pddf_led_module.c index 79b3418b1228..f419af3372d1 100644 --- a/platform/pddf/i2c/modules/led/pddf_led_module.c +++ b/platform/pddf/i2c/modules/led/pddf_led_module.c @@ -16,6 +16,7 @@ * A pddf kernel module to manage various LEDs of a switch */ +#define __STDC_WANT_LIB_EXT1__ 1 #include #include #include @@ -415,8 +416,11 @@ static int load_led_ops_data(struct device_attribute *da, LED_STATUS state) memcpy(ops_ptr->data[state].attr_devname, ptr->attr_devname, sizeof(ops_ptr->data[state].attr_devname)); memcpy(ops_ptr->attr_devtype, ptr->attr_devtype, sizeof(ops_ptr->attr_devtype)); memcpy(ops_ptr->attr_devname, ptr->attr_devname, sizeof(ops_ptr->attr_devname)); - +#ifdef __STDC_LIB_EXT1__ + memset_s(ops_ptr->data[state].reg_values, sizeof(ops_ptr->data[state].reg_values), 0xff, sizeof(ops_ptr->data[state].reg_values)); +#else memset(ops_ptr->data[state].reg_values, 0xff, sizeof(ops_ptr->data[state].reg_values)); +#endif value_ptr = kzalloc(sizeof(ops_ptr->data[state].value), GFP_KERNEL); if (value_ptr) { memcpy(value_ptr, ops_ptr->data[state].value, sizeof(ops_ptr->data[state].value)); From a9fa93b8d3517953b06f405bd42a274fa046f5f0 Mon Sep 17 00:00:00 2001 From: Fuzail Khan Date: Mon, 30 Jan 2023 00:50:47 -0800 Subject: [PATCH 3/5] Enabling FPGA support in PDDF: Moving the Makefiles changes to respective PRs --- platform/pddf/i2c/debian/rules | 2 +- platform/pddf/i2c/modules/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/platform/pddf/i2c/debian/rules b/platform/pddf/i2c/debian/rules index 4ddbbdfd2405..edca93ee06a8 100755 --- a/platform/pddf/i2c/debian/rules +++ b/platform/pddf/i2c/debian/rules @@ -18,7 +18,7 @@ PACKAGE_PRE_NAME := sonic-platform-pddf KVERSION ?= $(shell uname -r) KERNEL_SRC := /lib/modules/$(KVERSION) MOD_SRC_DIR:= $(shell pwd) -MODULE_DIRS:= client cpld cpld/driver cpldmux cpldmux/driver fpgai2c fpgai2c/driver fpgapci fpgapci/driver fpgapci/algos fan fan/driver mux gpio led psu psu/driver sysstatus xcvr xcvr/driver +MODULE_DIRS:= client cpld cpld/driver cpldmux cpldmux/driver fan fan/driver mux gpio led psu psu/driver sysstatus xcvr xcvr/driver MODULE_DIR:= modules UTILS_DIR := utils SERVICE_DIR := service diff --git a/platform/pddf/i2c/modules/Makefile b/platform/pddf/i2c/modules/Makefile index a936ff9756c3..ebfce193c273 100644 --- a/platform/pddf/i2c/modules/Makefile +++ b/platform/pddf/i2c/modules/Makefile @@ -1 +1 @@ -obj-m := client/ cpld/ cpldmux/ fpgai2c/ fpgapci/ xcvr/ mux/ gpio/ psu/ fan/ led/ sysstatus/ +obj-m := client/ cpld/ cpldmux/ xcvr/ mux/ gpio/ psu/ fan/ led/ sysstatus/ From 5d835c8e446727343dac0e28b4d71e6d9ae1215f Mon Sep 17 00:00:00 2001 From: Fuzail Khan Date: Wed, 8 Feb 2023 19:25:26 -0800 Subject: [PATCH 4/5] Enabling FPGA support in PDDF: Adding the missing files changes for compile error --- platform/pddf/i2c/debian/rules | 2 +- platform/pddf/i2c/modules/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/platform/pddf/i2c/debian/rules b/platform/pddf/i2c/debian/rules index edca93ee06a8..4ddbbdfd2405 100755 --- a/platform/pddf/i2c/debian/rules +++ b/platform/pddf/i2c/debian/rules @@ -18,7 +18,7 @@ PACKAGE_PRE_NAME := sonic-platform-pddf KVERSION ?= $(shell uname -r) KERNEL_SRC := /lib/modules/$(KVERSION) MOD_SRC_DIR:= $(shell pwd) -MODULE_DIRS:= client cpld cpld/driver cpldmux cpldmux/driver fan fan/driver mux gpio led psu psu/driver sysstatus xcvr xcvr/driver +MODULE_DIRS:= client cpld cpld/driver cpldmux cpldmux/driver fpgai2c fpgai2c/driver fpgapci fpgapci/driver fpgapci/algos fan fan/driver mux gpio led psu psu/driver sysstatus xcvr xcvr/driver MODULE_DIR:= modules UTILS_DIR := utils SERVICE_DIR := service diff --git a/platform/pddf/i2c/modules/Makefile b/platform/pddf/i2c/modules/Makefile index ebfce193c273..a936ff9756c3 100644 --- a/platform/pddf/i2c/modules/Makefile +++ b/platform/pddf/i2c/modules/Makefile @@ -1 +1 @@ -obj-m := client/ cpld/ cpldmux/ xcvr/ mux/ gpio/ psu/ fan/ led/ sysstatus/ +obj-m := client/ cpld/ cpldmux/ fpgai2c/ fpgapci/ xcvr/ mux/ gpio/ psu/ fan/ led/ sysstatus/ From fbd5ccb68d8bfc1031b636576b0d25e483801f26 Mon Sep 17 00:00:00 2001 From: Fuzail Khan Date: Thu, 9 Feb 2023 23:12:35 -0800 Subject: [PATCH 5/5] Fixing compilation failure in Ragile platform deb which has dependency on PDDF common code --- .../ra-b6510-32c/modules/driver/pddf_custom_led_module.c | 4 ++-- .../ra-b6920-4s/modules/driver/pddf_custom_led_module.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/platform/broadcom/sonic-platform-modules-ragile/ra-b6510-32c/modules/driver/pddf_custom_led_module.c b/platform/broadcom/sonic-platform-modules-ragile/ra-b6510-32c/modules/driver/pddf_custom_led_module.c index d9968f9151a1..f20406b96de3 100644 --- a/platform/broadcom/sonic-platform-modules-ragile/ra-b6510-32c/modules/driver/pddf_custom_led_module.c +++ b/platform/broadcom/sonic-platform-modules-ragile/ra-b6510-32c/modules/driver/pddf_custom_led_module.c @@ -27,8 +27,8 @@ #include #include #include -#include "../../../../../pddf/i2c/modules/include/pddf_led_defs.h" -#include "../../../../../pddf/i2c/modules/include/pddf_client_defs.h" +#include "pddf_led_defs.h" +#include "pddf_client_defs.h" #define DEBUG 0 LED_OPS_DATA sys_led_ops_data[1]={0}; diff --git a/platform/broadcom/sonic-platform-modules-ragile/ra-b6920-4s/modules/driver/pddf_custom_led_module.c b/platform/broadcom/sonic-platform-modules-ragile/ra-b6920-4s/modules/driver/pddf_custom_led_module.c index a789889e2a9a..4a884deb9539 100644 --- a/platform/broadcom/sonic-platform-modules-ragile/ra-b6920-4s/modules/driver/pddf_custom_led_module.c +++ b/platform/broadcom/sonic-platform-modules-ragile/ra-b6920-4s/modules/driver/pddf_custom_led_module.c @@ -22,8 +22,8 @@ #include #include #include -#include "../../../../../pddf/i2c/modules/include/pddf_led_defs.h" -#include "../../../../../pddf/i2c/modules/include/pddf_client_defs.h" +#include "../../../ra-b6510-32c/modules/driver/pddf_led_defs.h" +#include "../../../ra-b6510-32c/modules/driver//pddf_client_defs.h" #include #include #include