Modify ag9064 platform module and add support psutil. (#3305)

Signed-off-by: johnson <JOHNSON.LU@deltaww.com>

device/delta/x86_64-delta_ag9064-r0/plugins/psuutil.py

@@ -0,0 +1,78 @@
+#
+# Module contains an implementation of SONiC PSU Base API and
+# provides the PSUs status which are available in the platform
+#
+
+import os.path
+import subprocess
+
+try:
+    from sonic_psu.psu_base import PsuBase
+except ImportError as e:
+    raise ImportError (str(e) + "- required module not found")
+
+class PsuUtil(PsuBase):
+    """Platform-specific PSUutil class"""
+
+    def __init__(self):
+        PsuBase.__init__(self)
+        self.psu_presence = "cat /sys/devices/platform/delta-ag9064-cpld.0/psu{}_scan"
+        self.psu_status = "cat /sys/devices/platform/delta-ag9064-swpld1.0/psu{}_pwr_ok"
+
+    def get_num_psus(self):
+        """
+        Retrieves the number of PSUs available on the device
+
+        :return: An integer, the number of PSUs available on the device
+        """
+        return 2
+
+    def get_psu_status(self, index):
+        """
+        Retrieves the oprational status of power supply unit (PSU) defined
+                by 1-based index <index>
+
+        :param index: An integer, 1-based index of the PSU of which to query status
+        :return: Boolean, True if PSU is operating properly, False if PSU is faulty
+        """
+        if index is None:
+            return False
+
+        status = 0
+        try:
+            p = os.popen(self.psu_status.format(index))
+            content = p.readline().rstrip()
+            reg_value = int(content)
+            if reg_value != 0:
+               return False
+            status = 1
+            p.close()
+        except IOError:
+            return False
+        return status == 1
+
+
+
+    def get_psu_presence(self, index):
+        """
+        Retrieves the presence status of power supply unit (PSU) defined
+                by 1-based index <index>
+
+        :param index: An integer, 1-based index of the PSU of which to query status
+        :return: Boolean, True if PSU is plugged, False if not
+        """
+        if index is None:
+            return False
+        status = 0
+        try:
+            p = os.popen(self.psu_presence.format(index))
+            content = p.readline().rstrip()
+            reg_value = int(content, 16)
+            if reg_value != 0:
+                return False
+            status = 1
+            p.close()
+        except IOError:
+            return False
+        return status == 1
+

device/delta/x86_64-delta_ag9064-r0/plugins/sfputil.py

@@ -17,7 +17,7 @@ class SfpUtil(SfpUtilBase):
     PORT_END = 63
     PORTS_IN_BLOCK = 64
 
-    EEPROM_OFFSET = 20
+    EEPROM_OFFSET = 1
 
     _port_to_eeprom_mapping = {}
 
@@ -38,7 +38,7 @@ class SfpUtil(SfpUtilBase):
         return self._port_to_eeprom_mapping
 
     def __init__(self):
-        eeprom_path = "/sys/class/i2c-adapter/i2c-{0}/{0}-0050/eeprom"
+        eeprom_path = "/sys/kernel/sfp/eeprom_sfp_{0}"
 
         for x in range(0, self.port_end + 1):
             self._port_to_eeprom_mapping[x] = eeprom_path.format(x + self.EEPROM_OFFSET)

platform/broadcom/sonic-platform-modules-delta/ag9064/modules/delta_ag9064_common.h

@@ -14,8 +14,10 @@
 #define IPMI_MAX_INTF (4)
 #define DELTA_NETFN 0x38
 #define BMC_BUS_5   0x04
+#define BMC_BUS_1   0x00
 #define CMD_SETDATA 0x03
 #define CMD_GETDATA 0x02
+#define CMD_DEVICE_SCAN 0x01
 
 #define CPUPLD_ADDR 0x31
 #define SWPLD1_ADDR 0x35
@@ -23,19 +25,27 @@
 #define SWPLD3_ADDR 0x33
 #define SWPLD4_ADDR 0x32
 #define QSFP_PORT_MUX_REG 0x13
+#define PSU1_EEPROM_ADDR 0x50
+#define PSU2_EEPROM_ADDR 0x51
 
 #define DEFAULT_NUM    1
 #define BUS9_DEV_NUM  64
 #define BUS9_BASE_NUM 20
+#define EEPROM_SIZE 640
+#define EEPROM_ARCH_SIZE 256
+#define EEPROM_MASK   20
+#define ATTR_R 1
+#define ATTR_W 2
 
 extern int dni_bmc_cmd(char set_cmd, char *cmd_data, int cmd_data_len);
 extern int dni_create_user(void);
 extern unsigned char dni_log2 (unsigned char num);
-
 extern void device_release(struct device *dev);
 extern void msg_handler(struct ipmi_recv_msg *recv_msg,void* handler_data);
 extern void dummy_smi_free(struct ipmi_smi_msg *msg);
 extern void dummy_recv_free(struct ipmi_recv_msg *msg);
+extern void dni_klock(void);
+extern void dni_kunlock(void);
 
 static ipmi_user_t ipmi_mh_user = NULL;
 static struct ipmi_user_hndl ipmi_hndlrs = { .ipmi_recv_hndl = msg_handler,};
@@ -129,6 +139,8 @@ enum cpld_attributes {
     SWPLD3_REG_VALUE,
     SWPLD4_REG_ADDR,
     SWPLD4_REG_VALUE,
+    PSU1_SCAN,
+    PSU2_SCAN,
  //CPLD   
     CPLD_VER,
     CPU_BOARD_VER,
@@ -203,6 +215,73 @@ enum cpld_attributes {
     FAN_EEPROM_WP,
 };
 
+enum sfp_attributes{
+    EEPROM_SFP_1,
+    EEPROM_SFP_2,
+    EEPROM_SFP_3,
+    EEPROM_SFP_4,
+    EEPROM_SFP_5,
+    EEPROM_SFP_6,
+    EEPROM_SFP_7,
+    EEPROM_SFP_8,
+    EEPROM_SFP_9,
+    EEPROM_SFP_10,
+    EEPROM_SFP_11,
+    EEPROM_SFP_12,
+    EEPROM_SFP_13,
+    EEPROM_SFP_14,
+    EEPROM_SFP_15,
+    EEPROM_SFP_16,
+    EEPROM_SFP_17,
+    EEPROM_SFP_18,
+    EEPROM_SFP_19,
+    EEPROM_SFP_20,
+    EEPROM_SFP_21,
+    EEPROM_SFP_22,
+    EEPROM_SFP_23,
+    EEPROM_SFP_24,
+    EEPROM_SFP_25,
+    EEPROM_SFP_26,
+    EEPROM_SFP_27,
+    EEPROM_SFP_28,
+    EEPROM_SFP_29,
+    EEPROM_SFP_30,
+    EEPROM_SFP_31,
+    EEPROM_SFP_32,
+    EEPROM_SFP_33,
+    EEPROM_SFP_34,
+    EEPROM_SFP_35,
+    EEPROM_SFP_36,
+    EEPROM_SFP_37,
+    EEPROM_SFP_38,
+    EEPROM_SFP_39,
+    EEPROM_SFP_40,
+    EEPROM_SFP_41,
+    EEPROM_SFP_42,
+    EEPROM_SFP_43,
+    EEPROM_SFP_44,
+    EEPROM_SFP_45,
+    EEPROM_SFP_46,
+    EEPROM_SFP_47,
+    EEPROM_SFP_48,
+    EEPROM_SFP_49,
+    EEPROM_SFP_50,
+    EEPROM_SFP_51,
+    EEPROM_SFP_52,
+    EEPROM_SFP_53,
+    EEPROM_SFP_54,
+    EEPROM_SFP_55,
+    EEPROM_SFP_56,
+    EEPROM_SFP_57,
+    EEPROM_SFP_58,
+    EEPROM_SFP_59,
+    EEPROM_SFP_60,
+    EEPROM_SFP_61,
+    EEPROM_SFP_62,
+    EEPROM_SFP_63,
+    EEPROM_SFP_64,
+};
+
 static struct cpld_attribute_data attribute_data[] = {
     [CPLD_REG_ADDR] = {
     },
@@ -564,4 +643,4 @@ static struct cpld_attribute_data attribute_data[] = {
         .reg  = 0x15,       .mask = 1 << 2,
         .note = "“1” = enables the lock-down mechanism.\n“0” = overrides the lock-down function enabling blocks to be erased or programmed using software commands."
     },
-};
+};

platform/broadcom/sonic-platform-modules-delta/ag9064/modules/delta_ag9064_cpld.c

@@ -65,9 +65,10 @@ static ssize_t get_present(struct device *dev, struct device_attribute \
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -119,6 +120,7 @@ static ssize_t get_present(struct device *dev, struct device_attribute \
     ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
     data |= (u64)(ret & 0xff) << 56;
 
+    dni_kunlock();
     return sprintf(buf, "0x%016llx\n", data);
 }
 
@@ -130,9 +132,10 @@ static ssize_t get_lpmode(struct device *dev, struct device_attribute \
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -184,6 +187,8 @@ static ssize_t get_lpmode(struct device *dev, struct device_attribute \
     ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
     data |= (u64)(ret & 0xff) << 56;
 
+    dni_kunlock();
+ 
     return sprintf(buf, "0x%016llx\n", data);
 }
 
@@ -195,9 +200,10 @@ static ssize_t get_reset(struct device *dev, struct device_attribute \
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -249,6 +255,8 @@ static ssize_t get_reset(struct device *dev, struct device_attribute \
     ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
     data |= (u64)(ret & 0xff) << 56;
 
+    dni_kunlock();
+
     return sprintf(buf, "0x%016llx\n", data);
 }
 
@@ -260,9 +268,10 @@ static ssize_t get_response(struct device *dev, struct device_attribute \
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -314,6 +323,8 @@ static ssize_t get_response(struct device *dev, struct device_attribute \
     ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
     data |= (u64)(ret & 0xff) << 56;
 
+    dni_kunlock();
+
     return sprintf(buf, "0x%016llx\n", data);
 }
 
@@ -325,9 +336,10 @@ static ssize_t get_interrupt(struct device *dev, struct device_attribute \
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -379,6 +391,8 @@ static ssize_t get_interrupt(struct device *dev, struct device_attribute \
     ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
     data |= (u64)(ret & 0xff) << 56;
 
+    dni_kunlock();
+
     return sprintf(buf, "0x%016llx\n", data);
 }
 
@@ -386,16 +400,19 @@ static ssize_t set_lpmode(struct device *dev, struct device_attribute *devattr,
 {
     unsigned long long set_data;
     int err;
-    
-    err = kstrtoull(buf, 16, &set_data);
-    if (err){
-        return err;
-    } 
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_SETDATA;
+
+    dni_klock();
+
+    err = kstrtoull(buf, 16, &set_data);
+    if (err){
+        dni_kunlock();
+        return err;
+    } 
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -446,6 +463,8 @@ static ssize_t set_lpmode(struct device *dev, struct device_attribute *devattr,
     cmd_data[3] = ((set_data >> 56 ) & 0xff);
     dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
 
+    dni_kunlock();
+   
     return count;
 }
 
@@ -453,17 +472,19 @@ static ssize_t set_reset(struct device *dev, struct device_attribute *devattr, c
 {
     unsigned long long set_data;
     int err;
-
-    err = kstrtoull(buf, 16, &set_data);
-    if (err){
-        return err;
-    }
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_SETDATA;
 
+    dni_klock();
+
+    err = kstrtoull(buf, 16, &set_data);
+    if (err){
+        dni_kunlock();
+        return err;
+    }
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -514,6 +535,8 @@ static ssize_t set_reset(struct device *dev, struct device_attribute *devattr, c
     cmd_data[3] = ((set_data >> 56 ) & 0xff);
     dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
 
+    dni_kunlock();
+
     return count;
 }
 
@@ -521,17 +544,19 @@ static ssize_t set_response(struct device *dev, struct device_attribute *devattr
 {
     unsigned long long set_data;
     int err;
-
-    err = kstrtoull(buf, 16, &set_data);
-    if (err){
-        return err;
-    }
     uint8_t cmd_data[4]={0};
     uint8_t set_cmd;
     int cmd_data_len;
-
     set_cmd = CMD_SETDATA;
 
+    dni_klock();
+
+    err = kstrtoull(buf, 16, &set_data);
+    if (err){
+        dni_kunlock();
+        return err;
+    }
+
     /*QSFP1~8*/
     cmd_data[0] = BMC_BUS_5;
     cmd_data[1] = SWPLD1_ADDR;
@@ -581,10 +606,38 @@ static ssize_t set_response(struct device *dev, struct device_attribute *devattr
     cmd_data[2] = QSFP_RESPONSE_8;
     cmd_data[3] = ((set_data >> 56 ) & 0xff);
     dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
+
+    dni_kunlock();  
  
     return count;
 }
 
+static ssize_t psu_scan(struct device *dev, struct device_attribute *dev_attr, char *buf)
+{
+    struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+    int ret;
+    uint8_t cmd_data[2]={0};
+    uint8_t set_cmd;
+    int cmd_data_len;
+    set_cmd = CMD_DEVICE_SCAN;
+
+    dni_klock();
+    cmd_data[0] = BMC_BUS_1;
+    switch (attr->index)
+    {
+        case PSU1_SCAN:
+            cmd_data[1] = PSU1_EEPROM_ADDR;
+            break;
+        case PSU2_SCAN:
+            cmd_data[1] = PSU2_EEPROM_ADDR;
+            break;
+    }
+    cmd_data_len = sizeof(cmd_data);
+    ret = dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
+    dni_kunlock();
+    return sprintf(buf, "0x%x\n", ret);
+}
+
 static ssize_t get_cpld_reg(struct device *dev, struct device_attribute *dev_attr, char *buf) 
 {
     int ret;
@@ -594,12 +647,16 @@ static ssize_t get_cpld_reg(struct device *dev, struct device_attribute *dev_att
     unsigned char reg;
     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
     struct cpld_platform_data *pdata = dev->platform_data;
+
+    dni_klock();
     
     switch (attr->index) {
         case CPLD_REG_ADDR:
+            dni_kunlock();
             return sprintf(buf, "0x%02x\n", cpupld_reg_addr);
         case CPLD_REG_VALUE:
             ret = i2c_smbus_read_byte_data(pdata[system_cpld].client, cpupld_reg_addr);
+            dni_kunlock();
             return sprintf(buf, "0x%02x\n", ret);
         case CPLD_VER ... OP_MODULE_INT:
             reg   = attribute_data[attr->index].reg;
@@ -609,21 +666,28 @@ static ssize_t get_cpld_reg(struct device *dev, struct device_attribute *dev_att
             value = (value & mask);
             break;
         default:
+            dni_kunlock();
             return sprintf(buf, "%d not found", attr->index);
     } 
     
     switch (mask) {
         case 0xFF:
+            dni_kunlock();
             return sprintf(buf, "0x%02x%s", value, note);
         case 0x0F:
+            dni_kunlock();
             return sprintf(buf, "0x%01x%s", value, note);
         case 0xF0:
             value = value >> 4;
+            dni_kunlock();
             return sprintf(buf, "0x%01x%s", value, note);
         default :
             value = value >> dni_log2(mask);
+            dni_kunlock();
             return sprintf(buf, "%d%s", value, note);
     }
+    dni_kunlock();
+    return sprintf(buf, "%d not found", attr->index);
 }
 
 static ssize_t set_cpld_reg(struct device *dev, struct device_attribute *dev_attr,
@@ -636,27 +700,32 @@ static ssize_t set_cpld_reg(struct device *dev, struct device_attribute *dev_att
     unsigned char reg;
     unsigned char mask;  
     unsigned char mask_out;      
-
     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
     struct cpld_platform_data *pdata = dev->platform_data;
 
+    dni_klock();
+
     err = kstrtoul(buf, 0, &set_data_ul);
     if (err){
+        dni_kunlock();
         return err;
     }
     
     set_data = (int)set_data_ul;
     if (set_data > 0xff){
         printk(KERN_ALERT "address out of range (0x00-0xFF)\n");
+        dni_kunlock();
         return count;
     }
 
     switch (attr->index) {
         case CPLD_REG_ADDR:
             cpupld_reg_addr = set_data;
+            dni_kunlock();
             return count;
         case CPLD_REG_VALUE:
             i2c_smbus_write_byte_data(pdata[system_cpld].client, cpupld_reg_addr, set_data);
+            dni_kunlock();
             return count;
         case CPLD_VER ... OP_MODULE_INT:
             reg   = attribute_data[attr->index].reg;
@@ -665,6 +734,7 @@ static ssize_t set_cpld_reg(struct device *dev, struct device_attribute *dev_att
             mask_out = value & ~(mask);
             break;
         default:
+            dni_kunlock();
             return sprintf(buf, "%d not found", attr->index); 
     }
 
@@ -684,6 +754,7 @@ static ssize_t set_cpld_reg(struct device *dev, struct device_attribute *dev_att
     }   
 
     i2c_smbus_write_byte_data(pdata[system_cpld].client, reg, set_data);
+    dni_kunlock();
     return count;
 }
 
@@ -712,6 +783,8 @@ static SENSOR_DEVICE_ATTR(mb_pwr,            S_IRUGO,           get_cpld_reg, NU
 static SENSOR_DEVICE_ATTR(mb_rst,            S_IRUGO | S_IWUSR, get_cpld_reg, set_cpld_reg, MB_RST);
 static SENSOR_DEVICE_ATTR(psu_fan_int,       S_IRUGO,           get_cpld_reg, NULL,         PSU_FAN_INT);
 static SENSOR_DEVICE_ATTR(op_module_int,     S_IRUGO,           get_cpld_reg, NULL,         OP_MODULE_INT);
+static SENSOR_DEVICE_ATTR(psu1_scan,         S_IRUGO,           psu_scan,     NULL,         PSU1_SCAN);
+static SENSOR_DEVICE_ATTR(psu2_scan,         S_IRUGO,           psu_scan,     NULL,         PSU2_SCAN);
 
 static struct attribute *ag9064_cpld_attrs[] = {
     &dev_attr_qsfp_present.attr,
@@ -738,6 +811,8 @@ static struct attribute *ag9064_cpld_attrs[] = {
     &sensor_dev_attr_mb_rst.dev_attr.attr,
     &sensor_dev_attr_psu_fan_int.dev_attr.attr,
     &sensor_dev_attr_op_module_int.dev_attr.attr,
+    &sensor_dev_attr_psu1_scan.dev_attr.attr,
+    &sensor_dev_attr_psu2_scan.dev_attr.attr,
     NULL,
 };
 
@@ -823,11 +898,6 @@ static int __init delta_ag9064_cpupld_init(void)
     int ret;
     printk(KERN_WARNING "ag9064_platform_cpupld module initialization\n");
 
-    ret = dni_create_user();
-    if (ret != 0){
-        printk(KERN_WARNING "Fail to create IPMI user\n");
-    }
-
     // set the CPUPLD prob and remove
     ret = platform_driver_register(&cpld_driver);
     if (ret) {

platform/broadcom/sonic-platform-modules-delta/ag9064/modules/delta_ag9064_swpld.c

@@ -52,6 +52,7 @@ static ssize_t get_swpld_reg(struct device *dev, struct device_attribute *dev_at
     uint8_t get_cmd;       
     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 
+    dni_klock();
     cmd_data_len = sizeof(cmd_data);
     get_cmd = CMD_GETDATA;
     cmd_data[0] = BMC_BUS_5;
@@ -62,12 +63,16 @@ static ssize_t get_swpld_reg(struct device *dev, struct device_attribute *dev_at
     if (attr->index <= SWPLD4_REG_VALUE){
         switch (attr->index) {
             case SWPLD1_REG_ADDR:
+                dni_kunlock();
                 return sprintf(buf, "0x%02x\n", swpld1_reg_addr);
             case SWPLD2_REG_ADDR:
+                dni_kunlock();
                 return sprintf(buf, "0x%02x\n", swpld2_reg_addr);
             case SWPLD3_REG_ADDR:
+                dni_kunlock();
                 return sprintf(buf, "0x%02x\n", swpld3_reg_addr);
             case SWPLD4_REG_ADDR:
+                dni_kunlock();
                 return sprintf(buf, "0x%02x\n", swpld4_reg_addr);
             case SWPLD1_REG_VALUE:
                 cmd_data[1] = SWPLD1_ADDR;
@@ -86,10 +91,12 @@ static ssize_t get_swpld_reg(struct device *dev, struct device_attribute *dev_at
                 cmd_data[2] = swpld4_reg_addr;
                 break;
             default:
+                dni_kunlock();
                 return sprintf(buf, "%d not found", attr->index);
         }
         ret = dni_bmc_cmd(get_cmd, cmd_data, cmd_data_len);
         ret = ret & 0xff;
+        dni_kunlock();
         return sprintf(buf, "0x%02x\n", ret);
     }else{
 
@@ -107,6 +114,7 @@ static ssize_t get_swpld_reg(struct device *dev, struct device_attribute *dev_at
                 cmd_data[1] = SWPLD4_ADDR;
                 break;
             default:
+                dni_kunlock();
                 return sprintf(buf, "%d not found", attr->index);
         }
         cmd_data[2] = attribute_data[attr->index].reg;
@@ -114,23 +122,31 @@ static ssize_t get_swpld_reg(struct device *dev, struct device_attribute *dev_at
         value = value & mask;
         switch (mask) {
             case 0xFF:
+                dni_kunlock();
                 return sprintf(buf, "0x%02x%s", value, note);
             case 0x0F:
+                dni_kunlock();
                 return sprintf(buf, "0x%01x%s", value, note);
             case 0xF0:
                 value = value >> 4;
+                dni_kunlock();
                 return sprintf(buf, "0x%01x%s", value, note);
             case 0xC0:
                 value = value >> 6;
+                dni_kunlock();
                 return sprintf(buf, "0x%01x%s", value, note);
             case 0x30:
                 value = value >> 4;
+                dni_kunlock();
                 return sprintf(buf, "0x%01x%s", value, note);       
             default :
                 value = value >> dni_log2(mask);
+                dni_kunlock();
                 return sprintf(buf, "%d%s", value, note);
         }        
-    } 
+    }
+    dni_kunlock();
+    return sprintf(buf, "%d not found", attr->index); 
 }
 
 static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_attr,
@@ -152,13 +168,17 @@ static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_at
     set_cmd = CMD_SETDATA;
     get_cmd = CMD_GETDATA;
 
+    dni_klock();
+
     err = kstrtoul(buf, 0, &set_data_ul);
     if (err){
+        dni_kunlock();
         return err;
     }
 
     if (set_data > 0xff){
         printk(KERN_ALERT "address out of range (0x00-0xFF)\n");
+        dni_kunlock();
         return count;
     }
 
@@ -170,15 +190,19 @@ static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_at
         //reg_addr
             case SWPLD1_REG_ADDR:
                 swpld1_reg_addr = set_data;
+                dni_kunlock();
                 return count;
             case SWPLD2_REG_ADDR:
                 swpld2_reg_addr = set_data;
+                dni_kunlock();
                 return count;
             case SWPLD3_REG_ADDR:
                 swpld3_reg_addr = set_data;
+                dni_kunlock();
                 return count;         
             case SWPLD4_REG_ADDR:
                 swpld4_reg_addr = set_data;
+                dni_kunlock();
                 return count;
         //reg_value       
             case SWPLD1_REG_VALUE:
@@ -198,9 +222,11 @@ static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_at
                 cmd_data[2] = swpld4_reg_addr;
                 break;
             default :
+                dni_kunlock();
                 return sprintf(buf, "%d not found", attr->index); 
         }
         dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
+        dni_kunlock();
         return count;
     }
     else{
@@ -222,6 +248,7 @@ static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_at
                 cmd_data[1] = SWPLD4_ADDR;
                 break;
             default:
+                dni_kunlock();
                 return sprintf(buf, "%d not found", attr->index); 
         }
 
@@ -252,8 +279,11 @@ static ssize_t set_swpld_reg(struct device *dev, struct device_attribute *dev_at
                 set_data = mask_out | (set_data << dni_log2(mask) );        
         }   
         dni_bmc_cmd(set_cmd, cmd_data, cmd_data_len);
+        dni_kunlock();
         return count;
     }
+    dni_kunlock();
+    return count;
 }
 
 //SWPLD
@@ -524,11 +554,6 @@ static int __init delta_ag9064_swpld_init(void)
     int ret;
     printk(KERN_WARNING "ag9064_platform_swpld module initialization\n");
 
-    ret = dni_create_user();
-    if (ret != 0){
-        printk(KERN_WARNING "Fail to create IPMI user\n");
-    }
-
     // set the SWPLD prob and remove
     ret = platform_driver_register(&swpld1_driver);
     if (ret) {

platform/broadcom/sonic-platform-modules-delta/debian/platform-modules-ag9064.init

@@ -14,6 +14,18 @@
 case "$1" in
 start)
     echo -n "Setting up board... "
+    if [ `grep -c usemsi /etc/init.d/opennsl-modules` = "0" ]; then
+        sed -i "s/debug=4 dma_debug=1/debug=4 dma_debug=1 usemsi=1/g" /etc/init.d/opennsl-modules
+        rmmod linux_knet_cb
+        rmmod linux_bcm_knet
+        rmmod linux_user_bde
+        rmmod linux_kernel_bde
+        /etc/init.d/opennsl-modules start
+        modprobe linux_kernel_bde
+        modprobe linux_user_bde
+        modprobe linux_bcm_knet
+        modprobe linux_knet_cb
+    fi
     depmod -a
     rmmod i2c-i801
     rmmod i2c-ismt