max77819: remove log & dead code, fix indent

2 files changed, 456 insertions, 655 deletions

diff --git a/drivers/misc/mediatek/power/mt6735/max77819_charger.c b/drivers/misc/mediatek/power/mt6735/max77819_charger.c
index a5096b0d0..87a3c1261 100644
--- a/drivers/misc/mediatek/power/mt6735/max77819_charger.c
+++ b/drivers/misc/mediatek/power/mt6735/max77819_charger.c
@@ -34,9 +34,9 @@
 #define MAX77819_FCHGCRNT		0x38
 #define MAX77819_TOPOFF			0x39
 #define MAX77819_BATREG			0x3A
-#define MAX77819_DCCRNT 		0x3B
+#define MAX77819_DCCRNT			0x3B
 #define MAX77819_AICLCNTL		0x3C
-#define MAX77819_RBOOST_CTL1	0x3D
+#define MAX77819_RBOOST_CTL1		0x3D
 #define MAX77819_CHGCTL2		0x3E
 #define MAX77819_BATDET			0x3F
 #define MAX77819_USBCHGCTL		0x40
@@ -78,16 +78,16 @@
 #define MAX77819_AICL_NOK		(1 << 7)
 
  /* MAX77819_DC_BATT_DTLS */
-#define MAX77819_DC_AICL 		(1 << 7)
+#define MAX77819_DC_AICL		(1 << 7)
 #define MAX77819_DC_I			(1 << 6)
-#define MAX77819_DC_OVP 		(1 << 5)
+#define MAX77819_DC_OVP		(1 << 5)
 #define MAX77819_DC_UVP			(1 << 4)
-#define MAX77819_BAT_DTLS 		(3 << 2)
+#define MAX77819_BAT_DTLS		(3 << 2)
 #define MAX77819_BATDET_DTLS		(3 << 0)
 
  /* MAX77819_CHG_DTLS */
-#define MAX77819_THM_DTLS 		(7 << 5)
-#define MAX77819_TOPOFF_DTLS 		(1 << 4)
+#define MAX77819_THM_DTLS		(7 << 5)
+#define MAX77819_TOPOFF_DTLS		(1 << 4)
 #define MAX77819_CHG_DTL		(0x0F << 0)
 
  /* MAX77819_DETAILS3 */
@@ -188,14 +188,13 @@
  /*Charger initialization valute*/
 
 
-extern int battery_charger_dis ;
+extern int battery_charger_dis;
 extern void max77819_charger_dump_register(void);
 
 #define M2SH(m) ((m) & 0x0F ? ((m) & 0x03 ? ((m) & 0x01 ? 0 : 1) : ((m) & 0x04 ? 2 : 3)) : \
 					((m) & 0x30 ? ((m) & 0x10 ? 4 : 5) : ((m) & 0x40 ? 6 : 7)))
 
-struct max77819_charger_platform_data
-{
+struct max77819_charger_platform_data {
 	int fast_charge_timer;			/* One of 0, 4, 5, 6, 7, 8, 9, 16Hr */
 	int restart_threshold;			/* 150000uV or 200000uV */
 	int current_limit;			/* 100000uA ~ 1875000uA */
@@ -211,7 +210,7 @@ struct max77819_charger_platform_data
 
 
 static struct max77819_charger_platform_data max77819_charger_pdata = {
-	        .fast_charge_timer = 0,
+		.fast_charge_timer = 0,
 					.restart_threshold = 150000,
 					.current_limit = 1500000,
 					.topoff_current_threshold = 150000, /* modified by lyf*/
@@ -226,59 +225,57 @@ static struct max77819_charger_platform_data max77819_charger_pdata = {
 static kal_uint32 max77819_charger_inited = KAL_FALSE;
 //static kal_uint32 max77819_charger_enabled = KAL_FALSE;
 
-static kal_uint32 last_chgcc = 0;
-static kal_uint32 last_inputcc = 0;
-static kal_uint32 last_cv_voltage = 0;
+static kal_uint32 last_chgcc;
+static kal_uint32 last_inputcc;
+static kal_uint32 last_cv_voltage;
 
 kal_bool max77819_charger_is_locked(void)
 {
     kal_uint8 val = 0;
+
     max77819_pmic_reg_read(MAX77819_CHGCTL1, &val);
-    if((val & MAX77819_CHGPROT) == MAX77819_CHGPROT)
-    {
-        return KAL_FALSE;
-    }
-    else
-        return KAL_TRUE;
+    if ((val & MAX77819_CHGPROT) == MAX77819_CHGPROT) {
+	return KAL_FALSE;
+    } else
+	return KAL_TRUE;
 }
 void max77819_otg_enable(bool on)
 {
-	if(on){
-		max77819_pmic_reg_update_bits(MAX77819_RBOOST_CTL1,(1 << 0),1);//enable reverse boost
-		max77819_pmic_reg_update_bits(MAX77819_BAT2SOC_CTL,(1 << 5),(1 << 5));//enable otg
-	}
-	else{
-		max77819_pmic_reg_update_bits(MAX77819_BAT2SOC_CTL,(1 << 5),0);//disable otg
-		max77819_pmic_reg_update_bits(MAX77819_RBOOST_CTL1,(1 << 0),0);//disable reverse boost
+	if (on) {
+		max77819_pmic_reg_update_bits(MAX77819_RBOOST_CTL1, (1 << 0), 1);//enable reverse boost
+		max77819_pmic_reg_update_bits(MAX77819_BAT2SOC_CTL, (1 << 5), (1 << 5));//enable otg
+	} else{
+		max77819_pmic_reg_update_bits(MAX77819_BAT2SOC_CTL, (1 << 5), 0);//disable otg
+		max77819_pmic_reg_update_bits(MAX77819_RBOOST_CTL1, (1 << 0), 0);//disable reverse boost
 	}
 }
 
 void max77819_buck_enable(bool on)
 {
-	if(on){
-		max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,(1 << 2),(1 << 2));//enable buck
-	}
-	else{
-		max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,(1 << 2),0);//disable buck
+	if (on) {
+		max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, (1 << 2), (1 << 2));//enable buck
+	} else{
+		max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, (1 << 2), 0);//disable buck
 
 	}
 
 }
 /*charger unlock*/
-static int max77819_charger_unlock (void)
+static int max77819_charger_unlock(void)
 {
     int rc;
-    rc = max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,MAX77819_CHGPROT,3);
+
+    rc = max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, MAX77819_CHGPROT, 3);
 	printk("max77819_charger_unlock [%d]\n", rc);
 
     return rc;
 }
 /*charger lock*/
-static int max77819_charger_lock (void)
+static int max77819_charger_lock(void)
 {
     int rc;
 
-    rc = max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,MAX77819_CHGPROT,0);
+    rc = max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, MAX77819_CHGPROT, 0);
 	printk("max77819_charger_lock [%d]\n", rc);
 
     return rc;
@@ -288,58 +285,56 @@ static int max77819_charger_lock (void)
  /*set charging cc current, the input value should be less than 2.0A*/
  int max77819_charger_set_current(void *data)
  {
- 	 kal_int32 chgcc = *(kal_int32*)(data);
+	 kal_int32 chgcc = *(kal_int32 *)(data);
 	 kal_uint8 val = 0;
 	 int ret;
     //    chgcc = 150000;
-	 printk( "max77819_charger_set_current: %d\n", chgcc);
+	 printk("max77819_charger_set_current: %d\n", chgcc);
 
-     if(last_chgcc == chgcc)
-     {
-        printk( "max77819_charger_set_current: same chgcc, ignore it\n");
-        return 0;
+     if (last_chgcc == chgcc) {
+	printk("max77819_charger_set_current: same chgcc, ignore it\n");
+	return 0;
      }
 	 /*set maximal charging current to */
 	 max77819_pmic_reg_write(MAX77819_CHGCCMAX, 0x1F);
 
 
-	  if(chgcc<25000)
-                   val = 0;
-         else if (chgcc >= 25000 && chgcc <=155000)
-                   val = ((chgcc -25000)/5000 + 0x1 )<<(M2SH(MAX77819_CHGCC));
-         else if((chgcc>155000 )&&(chgcc < 180000))
-                   val = 0x1b;
-         else if((chgcc>=180000 )&&(chgcc < 186700))
-                   val = 0x1c;
-         else if((chgcc>=186700 )&&(chgcc < 193300))
-                   val = 0x1d;
-     else if((chgcc>=193300 )&&(chgcc < 200000))
-                   val = 0x1e;
-         else if(chgcc == 200000)
-                   val = 0x1f;
+	if (chgcc < 25000)
+		   val = 0;
+	 else if (chgcc >= 25000 && chgcc <= 155000)
+		   val = ((chgcc - 25000)/5000 + 0x1)<<(M2SH(MAX77819_CHGCC));
+	 else if ((chgcc > 155000) && (chgcc < 180000))
+		   val = 0x1b;
+	 else if ((chgcc >= 180000) && (chgcc < 186700))
+		   val = 0x1c;
+	 else if ((chgcc >= 186700) && (chgcc < 193300))
+		   val = 0x1d;
+     else if ((chgcc >= 193300) && (chgcc < 200000))
+		   val = 0x1e;
+	else if (chgcc == 200000)
+		   val = 0x1f;
      else
-              val = 0x06; //default 500mA
+	      val = 0x06; //default 500mA
 
     // val |= 0 << M2SH(MAX77819_FCHGTIME);//disable timer
 
 
 #if 0
-	 if (50000 == chgcc)
-        val |= 0x06; /* 500mA */
+	if (chgcc == 50000)
+	val |= 0x06; /* 500mA */
      else
-        val |= 0x1A; /* 1500mA */
+	val |= 0x1A; /* 1500mA */
 #endif
     ret = max77819_charger_unlock();
-    ret |= max77819_pmic_reg_update_bits(MAX77819_FCHGCRNT,MAX77819_CHGCC,val);
+    ret |= max77819_pmic_reg_update_bits(MAX77819_FCHGCRNT, MAX77819_CHGCC, val);
     ret |= max77819_charger_lock();
 
      last_chgcc = chgcc;
-         if (ret < 0)
-         {
-                   printk(KERN_INFO "Failed to set FCHGCRNT: %d\n", ret);
-                   last_chgcc = 0;
-                   return -1;
-         }
+	if (ret < 0) {
+		   printk(KERN_INFO "Failed to set FCHGCRNT: %d\n", ret);
+		   last_chgcc = 0;
+		return -1;
+	}
 
      return ret;
  }
@@ -354,95 +349,92 @@ static int max77819_charger_lock (void)
 
 /* charger lock protection, start */
 	 max77819_charger_unlock();
-	 ret = max77819_pmic_reg_read(MAX77819_FCHGCRNT,&chgcc);
+	 ret = max77819_pmic_reg_read(MAX77819_FCHGCRNT, &chgcc);
 	 max77819_charger_lock();
 /* charger lock protection, end */
-	 if(chgcc == 0)
-		 *(kal_int32*)(data) = 0;
-	 else if (chgcc >= 0x01 && chgcc <= 0x1b)
-		 *(kal_int32*)(data) = 25000 + 5000*(chgcc - 1);
-	 else if(chgcc == 0x1c)
-		 *(kal_int32*)(data) = 180000;
-	 else if(chgcc == 0x1d)
-		 *(kal_int32*)(data) = 186700;
-	 else if(chgcc == 0x1e)
-		 *(kal_int32*)(data) = 193300;
-	 else if(chgcc == 0x1f)
-		 *(kal_int32*)(data) = 200000;
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set FCHGCRNT: %d\n", ret);
-		 return -1;
-	 }
+	if (chgcc == 0)
+		 *(kal_int32 *)(data) = 0;
+	else if (chgcc >= 0x01 && chgcc <= 0x1b)
+		 *(kal_int32 *)(data) = 25000 + 5000*(chgcc - 1);
+	else if (chgcc == 0x1c)
+		 *(kal_int32 *)(data) = 180000;
+	else if (chgcc == 0x1d)
+		 *(kal_int32 *)(data) = 186700;
+	else if (chgcc == 0x1e)
+		 *(kal_int32 *)(data) = 193300;
+	else if (chgcc == 0x1f)
+		 *(kal_int32 *)(data) = 200000;
+	if (ret < 0) {
+		 printk("Failed to set FCHGCRNT: %d\n", ret);
+		return -1;
+	}
 
      return ret;
  }
  /*set DC input current limitation,input would be mA*/
  int max77819_charger_set_input_current(void *data)
  {
-	 kal_int32 uA = *(kal_int32*)(data);
+	 kal_int32 uA = *(kal_int32 *)(data);
 	 kal_uint8 val = 0;
      int ret;
     //uA = 150000;
 
-	 printk( "max77819_charger_set_input_current: %d\n", uA);
+	 printk("max77819_charger_set_input_current: %d\n", uA);
 
-     if(last_inputcc == uA)
-     {
-        printk( "max77819_charger_set_input_current: same inputcc, ignore it\n");
-        return 0;
+     if (last_inputcc == uA) {
+	printk("max77819_charger_set_input_current: same inputcc, ignore it\n");
+	return 0;
      }
 
   //      uA = 100000;
 
-	 if (uA == 10000)
+	if (uA == 10000)
 		 val = 0 << M2SH(MAX77819_DCILMT);
-	 else if (uA >= 27500 && uA <= 150000)
-                   val = ((0x3+((uA - 27500) / 2500)) << M2SH(MAX77819_DCILMT));
-     else if(uA>150000 && uA<170900)
-                   val = 0x34;
-     else if(uA>=170900 && uA<175000)
-                   val = 0x35;
-     else if(uA>=175000 && uA<179200)
-                   val = 0x36;
-     else if(uA>=179200 && uA<183400)
-                   val = 0x37;
-  	 else if(uA>=183400 && uA<187500)
-                   val = 0x38;
-  	 else if(uA>=187500 && uA<191700)
-                   val = 0x39;
-     else if(uA>=191700 && uA<195900)
-                   val = 0x3A;
-     else if(uA>=195900 && uA<200000)
-                   val = 0x3B;
-	 else if(uA>=200000 && uA<204200)
-                   val = 0x3C;
-	 else if(uA>=204200 && uA<208400)
+	else if (uA >= 27500 && uA <= 150000)
+		   val = ((0x3+((uA - 27500) / 2500)) << M2SH(MAX77819_DCILMT));
+     else if (uA > 150000 && uA < 170900)
+		   val = 0x34;
+     else if (uA >= 170900 && uA < 175000)
+		   val = 0x35;
+     else if (uA >= 175000 && uA < 179200)
+		   val = 0x36;
+     else if (uA >= 179200 && uA < 183400)
+		   val = 0x37;
+	 else if (uA >= 183400 && uA < 187500)
+		   val = 0x38;
+	 else if (uA >= 187500 && uA < 191700)
+		   val = 0x39;
+     else if (uA >= 191700 && uA < 195900)
+		   val = 0x3A;
+     else if (uA >= 195900 && uA < 200000)
+		   val = 0x3B;
+	else if (uA >= 200000 && uA < 204200)
+		   val = 0x3C;
+	else if (uA >= 204200 && uA < 208400)
 				 val = 0x3D;
-	 else if(uA>=208400)
+	else if (uA >= 208400)
 				 val = 0x3E;
      else if (uA == -1)
-              val = 0x3F << M2SH(MAX77819_DCILMT);
+	      val = 0x3F << M2SH(MAX77819_DCILMT);
 
 
 
 #if 0
-     if (50000 == uA)
-        val = 0x0C; /* 500mA */
+     if (uA == 50000)
+	val = 0x0C; /* 500mA */
      else
-        val = 0x34; /* 1500mA */
+	val = 0x34; /* 1500mA */
 #endif
 /*  charger lock protection, start */
- 	   max77819_charger_unlock();
+	   max77819_charger_unlock();
      ret = max77819_pmic_reg_write(MAX77819_DCCRNT, val);
 	  max77819_charger_lock();
  /*charger lock protection, end */
-      if (ret < 0)
-         {
-                   printk(KERN_INFO "Failed to set input current: %d\n", ret);
-                   last_inputcc = 0;
-                   return -1;
-         }
+      if (ret < 0) {
+		printk(KERN_INFO "Failed to set input current: %d\n", ret);
+		last_inputcc = 0;
+		return -1;
+	}
 
      last_inputcc = uA;
      return ret;
@@ -452,36 +444,33 @@ static int max77819_charger_lock (void)
 int max77819_charger_enable(void *data)
  {
 	 int ret;
-     kal_uint32 enable = *(kal_uint32*)(data);
+     kal_uint32 enable = *(kal_uint32 *)(data);
 
-	 printk( "max77819_charger_enable: %d\n", enable);
+	 printk("max77819_charger_enable: %d\n", enable);
 
 	 max77819_charger_unlock();
-	 ret = max77819_pmic_reg_update_bits(MAX77819_CHGCTL2, MAX77819_CEN,enable ?MAX77819_CEN : 0);
+	 ret = max77819_pmic_reg_update_bits(MAX77819_CHGCTL2, MAX77819_CEN, enable ? MAX77819_CEN : 0);
 	 max77819_charger_lock();
 
-        if ( battery_charger_dis){
-           printk(KERN_EMERG "max77819_charger_enable: battery_charger_dis == 1\n");
-            max77819_buck_enable(false);
-        //    max77819_charger_inited = KAL_FALSE;
-        //    last_chgcc = 0;
-         //   last_inputcc = 0;
-         //   last_cv_voltage = 0;
-        }
-        else
-        {
-    	 printk(KERN_EMERG "max77819_charger_enable: battery_charger_dis == 0\n");
-            max77819_buck_enable(true);
-         }
-            max77819_charger_dump_register();
-     if(enable == KAL_FALSE)
-     {
-        max77819_charger_inited = KAL_FALSE;
-        last_chgcc = 0;
-        last_inputcc = 0;
-        last_cv_voltage = 0;
+	if (battery_charger_dis) {
+	   printk(KERN_EMERG "max77819_charger_enable: battery_charger_dis == 1\n");
+	    max77819_buck_enable(false);
+	//    max77819_charger_inited = KAL_FALSE;
+	//    last_chgcc = 0;
+	//   last_inputcc = 0;
+	//   last_cv_voltage = 0;
+	} else {
+	 printk(KERN_EMERG "max77819_charger_enable: battery_charger_dis == 0\n");
+	    max77819_buck_enable(true);
+	}
+	    max77819_charger_dump_register();
+     if (enable == KAL_FALSE) {
+	max77819_charger_inited = KAL_FALSE;
+	last_chgcc = 0;
+	last_inputcc = 0;
+	last_cv_voltage = 0;
      }
-	 return ret;
+	return ret;
  }
  /*set battery regulation voltage*/
 int max77819_charger_set_cv_voltage(void *data)
@@ -490,53 +479,49 @@ int max77819_charger_set_cv_voltage(void *data)
 	 kal_uint32 vol = *(kal_uint32 *)(data);
 	 kal_uint8 val = 0;
 
-	 printk( "max77819_charger_set_cv_voltage: %d\n", vol);
+	 printk("max77819_charger_set_cv_voltage: %d\n", vol);
 	 /*set battery regulation control register-->register address:0x3A*/
-     if(last_cv_voltage == vol)
-     {
-        printk( "max77819_charger_set_cv_voltage: same cv_voltage, ignore it\n");
-        return 0;
+     if (last_cv_voltage == vol) {
+	printk("max77819_charger_set_cv_voltage: same cv_voltage, ignore it\n");
+	return 0;
      }
 
-	 switch(vol)
-	 {
-	 case 3550000:
+	switch (vol) {
+	case 3550000:
 		 val = 0 << M2SH(MAX77819_MBATREG);
-		 break;
-	 case 3700000 ... 4400000:
+		break;
+	case 3700000 ... 4400000:
 		 val = ((vol - 3700000) / 50000 + 1) << M2SH(MAX77819_MBATREG);
-		 break;
-	 default:
-		 printk( "Invalid voltage: %d\n", vol);
-		 return -1;
-	 }
-
-     switch(max77819_charger_pdata.restart_threshold)
-	 {
-	 case 150000:
-		 val |= 0 << M2SH(MAX77819_CHGRSTRT);
-		 break;
-	 case 200000:
-		 val |= 1 << M2SH(MAX77819_CHGRSTRT);
-		 break;
-	 default:
-		 printk( "Invalid restart_threshold: %d\n", max77819_charger_pdata.restart_threshold);
-		 return -1;
-	 }
+		break;
+	default:
+		 printk("Invalid voltage: %d\n", vol);
+		return -1;
+	}
+
+	switch (max77819_charger_pdata.restart_threshold) {
+	case 150000:
+		val |= 0 << M2SH(MAX77819_CHGRSTRT);
+		break;
+	case 200000:
+		val |= 1 << M2SH(MAX77819_CHGRSTRT);
+		break;
+	default:
+		printk("Invalid restart_threshold: %d\n", max77819_charger_pdata.restart_threshold);
+		return -1;
+	}
 /*  charger lock protection, start */
 	 max77819_charger_unlock();
 	 ret = max77819_pmic_reg_write(MAX77819_BATREG, val);
 	 max77819_charger_lock();
 
  /* charger lock protection, end */
-    if (ret < 0)
-         {
-                   printk(KERN_INFO "Failed to set cv: %d\n", ret);
-                   last_cv_voltage = 0;
-                   return -1;
-         }
+    if (ret < 0) {
+		   printk(KERN_INFO "Failed to set cv: %d\n", ret);
+		   last_cv_voltage = 0;
+		return -1;
+	}
     last_cv_voltage = vol;
-	 return ret;
+	return ret;
  }
 
  int max77819_charger_get_charging_status(void *data)
@@ -546,29 +531,28 @@ int max77819_charger_set_cv_voltage(void *data)
 
 
 	ret = max77819_pmic_reg_read(MAX77819_CHG_DTLS, &value);
-	 if (ret < 0)
+	if (ret < 0)
 		 printk("cannot read CHG_DTLS : %d\n", ret);
-	 printk( "max77819_charger_get_charging_status:0x%x\n", (value & MAX77819_CHG_DTL) >> M2SH(MAX77819_CHG_DTL));
-	 switch((value & MAX77819_CHG_DTL) >> M2SH(MAX77819_CHG_DTL))
-	 {
-			 case 0x1:	 /* prequal */
-			 case 0x2:	 /* CC */
-			 case 0x3:	 /* CV */
-				return 0;
-			 case 0x4:	 /* topoff */
-			 case 0x5:	 /* done */
-				return 1;
-			 case 0x0:	 /* dead batter */
-			 case 0x6:	 /* timer fault */
-			 case 0x7:	 /* temperature suspend */
-			 case 0x8:	 /* buck,charger off */
-			 case 0xB:	 /* USB suspend */
-				 return 0;
-			 case 0xA:	 /* OTG debounce time-out */
-			 case 0x9:	 /* thermal loop */
-			 default:
-				 return 0;
-	 }
+	 printk("max77819_charger_get_charging_status:0x%x\n", (value & MAX77819_CHG_DTL) >> M2SH(MAX77819_CHG_DTL));
+	switch ((value & MAX77819_CHG_DTL) >> M2SH(MAX77819_CHG_DTL)) {
+	case 0x1:	 /* prequal */
+	case 0x2:	 /* CC */
+	case 0x3:	 /* CV */
+		return 0;
+	case 0x4:	 /* topoff */
+	case 0x5:	 /* done */
+		return 1;
+	case 0x0:	 /* dead batter */
+	case 0x6:	 /* timer fault */
+	case 0x7:	 /* temperature suspend */
+	case 0x8:	 /* buck,charger off */
+	case 0xB:	 /* USB suspend */
+		return 0;
+	case 0xA:	 /* OTG debounce time-out */
+	case 0x9:	 /* thermal loop */
+	default:
+		return 0;
+	}
  }
  /*init charger with inital parameters */
  int max77819_charger_hw_init(void *data)
@@ -577,15 +561,15 @@ int max77819_charger_set_cv_voltage(void *data)
 	  int ret;
 	  kal_uint8 val = 0, status = 0;
 
-	  printk( "max77819_charger_hw_init: start\n");
-    printk( "max77819_charger_hw_init: firstly check charging status,if in charging state, just do nothing\n");
+	  printk("max77819_charger_hw_init: start\n");
+    printk("max77819_charger_hw_init: firstly check charging status,if in charging state, just do nothing\n");
     ret = max77819_pmic_reg_read(MAX77819_CHG_DTLS, &status);
-    if(ret <0)
+    if (ret < 0)
        return -1;
     //jelphi
     val = (status & MAX77819_CHG_DTL) >> M2SH(MAX77819_CHG_DTL);
 
-	  if((max77819_charger_inited == KAL_TRUE )&&((val == 0x01)||(val == 0x02)||(val == 0x03)||(val == 0x04)||(val == 0x05))){
+	if ((max77819_charger_inited == KAL_TRUE) && ((val == 0x01) || (val == 0x02) || (val == 0x03) || (val == 0x04) || (val == 0x05))) {
 
       printk(KERN_INFO "max77819_charger is in charging state ,init done already, return\n");
       return 0;
@@ -595,7 +579,7 @@ int max77819_charger_set_cv_voltage(void *data)
 
 	 /* Unlock protected registers-->resister address :0x37 */
 	 ret = max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,
-			 MAX77819_CHGPROT | MAX77819_THM_DIS | MAX77819_JEITA_EN ,
+			 MAX77819_CHGPROT | MAX77819_THM_DIS | MAX77819_JEITA_EN,
 			 MAX77819_CHGPROT | MAX77819_THM_DIS | MAX77819_JEITA_EN);
 
 
@@ -607,148 +591,95 @@ int max77819_charger_set_cv_voltage(void *data)
 	 /*configure automatic input current limitation--> 0x3C*/
 
 
-	 if (pdata->enable_aicl)
-	 {
+	if (pdata->enable_aicl) {
 	   /* check voltage,it should be 3.9v--4.8v*/
-		 if (unlikely(pdata->aicl_voltage < 3900000 || pdata->aicl_voltage > 4800000))
-		 {
-			 printk( "Invalid aicl_voltage: %duA\n", pdata->aicl_voltage);
-			 return -1;
-		 }
+		if (unlikely(pdata->aicl_voltage < 3900000 || pdata->aicl_voltage > 4800000)) {
+			 printk("Invalid aicl_voltage: %duA\n", pdata->aicl_voltage);
+			return -1;
+		}
 	 /* check reset threshold below the voltage setting: eitther 100mv or 200mv*/
-		 if (unlikely(pdata->aicl_threshold != 100000 && pdata->aicl_threshold != 200000))
-		 {
-			 printk( "Invalid aicl_threshold: %duA\n", pdata->aicl_threshold);
-			 return -1;
-		 }
+		if (unlikely(pdata->aicl_threshold != 100000 && pdata->aicl_threshold != 200000)) {
+			 printk("Invalid aicl_threshold: %duA\n", pdata->aicl_threshold);
+			return -1;
+		}
 
 		 val = ((((pdata->aicl_voltage - 3900000) / 100000) << M2SH(MAX77819_AICL)) |
 				 (((pdata->aicl_threshold - 100000) / 100000) << M2SH(MAX77819_AICL_RESET)));
-	 }
-	 else
+	} else
 		 val = MAX77819_DCMON_DIS;
 	 ret = max77819_pmic_reg_write(MAX77819_AICLCNTL, val);
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set AICLCNTL: %d\n", ret);
-		 return -1;
-	 }
-
-#if 0
-     /*set DC input current limitation -->0x3B*/
-	 ret = max77819_charger_set_input_current(&(pdata->current_limit));
-	 if (ret < 0)
-	 {
-		 printk( "Failed to call max77819_charger_set_input_current(): %d\n", ret);
-		 return -1;
-	 }
-	 max77819_charger_unlock();
-	 max77819_pmic_reg_update_bits(MAX77819_CHGCTL2, MAX77819_DCILIM_EN, 1<<7);
-	 max77819_charger_lock();
-#endif
-
-#if 0
-	 /*set fast charge timer-->adress: 0x38*/
-	 switch(pdata->fast_charge_timer)
-	 {
-	 case 0:
-		 val = 0 << M2SH(MAX77819_FCHGTIME);
-		 break;
-	 case 4 ... 9:
-		 val = (pdata->fast_charge_timer - 3) << M2SH(MAX77819_FCHGTIME);
-		 break;
-	 case 16:
-		 val = 0x07 << M2SH(MAX77819_FCHGTIME);
-		 break;
-	 default:
-		 printk( "Invalid fast_charge_timer: %d\n", pdata->fast_charge_timer);
-		 return -1;
-	 }
-	 val |= 0x1F << M2SH(MAX77819_CHGCC);		 /* Charging current = 1.80A, here just set max current*/
-	 max77819_charger_unlock();
-	 ret = max77819_pmic_reg_write(MAX77819_FCHGCRNT, val);
-	 max77819_charger_lock();
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set FCHGCRNT: %d\n", ret);
-		 return -1;
-	 }
-#endif
+	if (ret < 0) {
+		 printk("Failed to set AICLCNTL: %d\n", ret);
+		return -1;
+	}
 
    /*set topoff curent threshold and topoff timer -->register address: 0x39*/
 
-	 if(unlikely(pdata->topoff_current_threshold < 50000 ||
-			 pdata->topoff_current_threshold > 400000))
-	 {
-		 printk( "Invalid topoff_current_threshold: %d\n",
+	if (unlikely(pdata->topoff_current_threshold < 50000 ||
+			 pdata->topoff_current_threshold > 400000)) {
+		 printk("Invalid topoff_current_threshold: %d\n",
 				 pdata->topoff_current_threshold);
-		 return -1;
-	 }
+		return -1;
+	}
 	 /*topoff current threshold*/
 	 val = ((pdata->topoff_current_threshold - 50000) / 50000) << M2SH(MAX77819_ITOPOFF);
-	 if (unlikely(pdata->topoff_timer < -1 || pdata->topoff_timer > 60))
-	 {
-		 printk( "Invalid topoff_timer: %d\n", pdata->topoff_timer);
-		 return -1;
-	 } else if (pdata->topoff_timer == -1) /*never enter DONE state*/
+	if (unlikely(pdata->topoff_timer < -1 || pdata->topoff_timer > 60)) {
+		 printk("Invalid topoff_timer: %d\n", pdata->topoff_timer);
+		return -1;
+	} else if (pdata->topoff_timer == -1) /*never enter DONE state*/
 		 val |= 7 << M2SH(MAX77819_TOPOFFTIME);
-	 else
+	else
 		 val |= (pdata->topoff_timer / 10) << M2SH(MAX77819_TOPOFFTIME);
  /* charger lock protection, start */
      max77819_charger_unlock();
-	 ret = max77819_pmic_reg_update_bits(MAX77819_TOPOFF,MAX77819_ITOPOFF | MAX77819_TOPOFFTIME, val);
+	 ret = max77819_pmic_reg_update_bits(MAX77819_TOPOFF, MAX77819_ITOPOFF | MAX77819_TOPOFFTIME, val);
 	 max77819_charger_lock();
 /* charger lock protection, end */
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set TOPOFF: %d\n", ret);
-		 return -1;
-	 }
+	if (ret < 0) {
+		 printk("Failed to set TOPOFF: %d\n", ret);
+		return -1;
+	}
 
 #if 1
    /*set battery regulation control register-->register address:0x3A*/
-	 switch(pdata->voltage)
-	 {
-	 case 3550000:
+	switch (pdata->voltage) {
+	case 3550000:
 		 val = 0 << M2SH(MAX77819_MBATREG);
-		 break;
-	 case 3700000 ... 4400000:
+		break;
+	case 3700000 ... 4400000:
 		 val = ((pdata->voltage - 3700000) / 50000 + 1) << M2SH(MAX77819_MBATREG);
-		 break;
-	 default:
-		 printk( "Invalid voltage: %d\n", pdata->voltage);
-		 return -1;
-	 }
+		break;
+	default:
+		 printk("Invalid voltage: %d\n", pdata->voltage);
+		return -1;
+	}
 	 /*restart threshold should be 150000 uV or 200000uV only*/
-	 switch(pdata->restart_threshold)
-	 {
-	 case 150000:
+	switch (pdata->restart_threshold) {
+	case 150000:
 		 val |= 0 << M2SH(MAX77819_CHGRSTRT);
-		 break;
-	 case 200000:
+		break;
+	case 200000:
 		 val |= 1 << M2SH(MAX77819_CHGRSTRT);
-		 break;
-	 default:
-		 printk( "Invalid restart_threshold: %d\n", pdata->restart_threshold);
-		 return -1;
-	 }
+		break;
+	default:
+		 printk("Invalid restart_threshold: %d\n", pdata->restart_threshold);
+		return -1;
+	}
 	 max77819_charger_unlock();
-	 ret = max77819_pmic_reg_update_bits(MAX77819_BATREG,MAX77819_MBATREG | MAX77819_CHGRSTRT, val);
+	 ret = max77819_pmic_reg_update_bits(MAX77819_BATREG, MAX77819_MBATREG | MAX77819_CHGRSTRT, val);
 	 max77819_charger_lock();
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set MAX77819_CHG_CNFG_04: %d\n", ret);
-		 return -1;
-	 }
+	if (ret < 0) {
+		 printk("Failed to set MAX77819_CHG_CNFG_04: %d\n", ret);
+		return -1;
+	}
 #endif
 
 	 /*set CHGCTL2-->register address:0x3e*/
 	 /*set prequal current, enable input charge limitataton*/
-	 if (unlikely(pdata->prequal_current < 100000 || pdata->prequal_current > 400000))
-	 {
-		 printk( "Invalid prequal_current: %d\n", pdata->prequal_current);
-		 return -1;
-	 }
+	if (unlikely(pdata->prequal_current < 100000 || pdata->prequal_current > 400000)) {
+		 printk("Invalid prequal_current: %d\n", pdata->prequal_current);
+		return -1;
+	}
 	 val = ((pdata->prequal_current / 100000 - 1) << M2SH(MAX77819_PREQCUR)) | MAX77819_DCILIM_EN | 0x04; /* min Vsys 3.4V*/
 /* charger lock protection, start */
 	 max77819_charger_unlock();
@@ -756,30 +687,29 @@ int max77819_charger_set_cv_voltage(void *data)
 			 MAX77819_PREQCUR | MAX77819_DCILIM_EN | MAX77819_QBATEN | MAX77819_VSYSREG, val);
 	 max77819_charger_lock();
 /* charger lock protection, end */
-	 if (ret < 0)
-	 {
-		 printk( "Failed to set MAX77819_CHG_CNFG_04: %d\n", ret);
-		 return -1;
-	 }
-            max77819_pmic_reg_write(0x3d,0x20);
-	 max77819_pmic_reg_write(0x36,0x00);
-	 max77819_pmic_reg_write(0x40,0x00);
-            max77819_pmic_reg_write(0x41,0x0f);
-	 max77819_pmic_reg_write(0x42,0x1f);
-            max77819_pmic_reg_write(0x43,0x54);   
-
-     
+	if (ret < 0) {
+		 printk("Failed to set MAX77819_CHG_CNFG_04: %d\n", ret);
+		return -1;
+	}
+	    max77819_pmic_reg_write(0x3d, 0x20);
+	 max77819_pmic_reg_write(0x36, 0x00);
+	 max77819_pmic_reg_write(0x40, 0x00);
+	    max77819_pmic_reg_write(0x41, 0x0f);
+	 max77819_pmic_reg_write(0x42, 0x1f);
+	    max77819_pmic_reg_write(0x43, 0x54);
+
+
 	 #if 0
 	 //test-------------------------------------------
-	 max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,MAX77819_JEITA_EN,1<<3);
-	 max77819_pmic_reg_update_bits(MAX77819_CHGCTL1,MAX77819_THM_DIS,1<<4);
-	 max77819_pmic_reg_write(0x38,0x50);
-	 max77819_pmic_reg_write(0x3a,0x16);
-	 max77819_pmic_reg_write(0x3b,0x34);
-	 max77819_pmic_reg_write(0x3f,0x6e);
-	 max77819_pmic_reg_write(0x40,0x08);
-	 max77819_pmic_reg_write(0x41,0x0f);
-	 max77819_pmic_reg_write(0x42,0x1f);
+	 max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, MAX77819_JEITA_EN, 1<<3);
+	 max77819_pmic_reg_update_bits(MAX77819_CHGCTL1, MAX77819_THM_DIS, 1<<4);
+	 max77819_pmic_reg_write(0x38, 0x50);
+	 max77819_pmic_reg_write(0x3a, 0x16);
+	 max77819_pmic_reg_write(0x3b, 0x34);
+	 max77819_pmic_reg_write(0x3f, 0x6e);
+	 max77819_pmic_reg_write(0x40, 0x08);
+	 max77819_pmic_reg_write(0x41, 0x0f);
+	 max77819_pmic_reg_write(0x42, 0x1f);
 	 //test-------------------------------------------
 	 #endif
 
@@ -787,29 +717,28 @@ int max77819_charger_set_cv_voltage(void *data)
      last_chgcc = 0;
      last_inputcc = 0;
      last_cv_voltage = 0;
-	   printk( "max77819_charger_hw_init: end\n");
+	   printk("max77819_charger_hw_init: end\n");
 
      return 0;
  }
 /*get aicl flag status*/
-bool  max77819_charger_get_aicl_status(void )
+bool  max77819_charger_get_aicl_status(void)
  {
 	 kal_uint8 flag = 0;
-            bool aicl_on = false;
+	    bool aicl_on = false;
 	 int ret;
 
-	 ret = max77819_pmic_reg_read(MAX77819_CHG_STAT,&flag);
-	 if (ret < 0)
-	 {
-		 printk( "Failed to get AICL flag status: %d\n", ret);
-		 return -1;
-	 }
+	 ret = max77819_pmic_reg_read(MAX77819_CHG_STAT, &flag);
+	if (ret < 0) {
+		 printk("Failed to get AICL flag status: %d\n", ret);
+		return -1;
+	}
+
+	  aicl_on = flag &  0x80;
 
-          aicl_on = flag &  0x80;
+	  printk(KERN_EMERG "max77819_charger_get_aicl_status:  aici_on = %d\n", aicl_on);
 
-          printk(KERN_EMERG "max77819_charger_get_aicl_status:  aici_on = %d\n",aicl_on);
-        
-          return aicl_on;
+	return aicl_on;
  }
 
 void max77819_adjust_input_current(void)
@@ -817,84 +746,84 @@ void max77819_adjust_input_current(void)
     kal_uint32 reg_inputcc = 0;
     kal_uint32 current_inputcc = 0;
 
-    max77819_pmic_reg_read(MAX77819_DCCRNT,&reg_inputcc );
+    max77819_pmic_reg_read(MAX77819_DCCRNT, &reg_inputcc);
 
     current_inputcc = reg_inputcc & 0x3f;  //bit: 0-5
     current_inputcc -= 12; //300mA
-    printk(KERN_EMERG "max77819_adjust_input_current: current_inputcc=%x\n",current_inputcc);
-    if(current_inputcc <= 0X0c)//threshold :500mA
-        current_inputcc = 0x0c;
+    printk(KERN_EMERG "max77819_adjust_input_current: current_inputcc=%x\n", current_inputcc);
+    if (current_inputcc <= 0X0c)//threshold :500mA
+	current_inputcc = 0x0c;
 
     reg_inputcc = (reg_inputcc & (!0x3f))|current_inputcc;
-    printk(KERN_EMERG "max77819_adjust_input_current: reg_inputcc(0x3b)=%x\n",reg_inputcc);
+    printk(KERN_EMERG "max77819_adjust_input_current: reg_inputcc(0x3b)=%x\n", reg_inputcc);
     max77819_pmic_reg_write(MAX77819_DCCRNT, reg_inputcc);
 
 }
 
 void max77819_aicl_control(void)
 {
-              kal_uint32 reg_chgcc = 0;
-              kal_uint32 reg_inputcc = 0;
-              kal_uint32 current_chgcc = 0;
-              kal_uint32 current_inputcc = 0;
-                if(!max77819_charger_get_aicl_status())
-                    return  -1;
-
-              
-             max77819_charger_unlock();
-	 max77819_pmic_reg_read(MAX77819_FCHGCRNT,&reg_chgcc );
-            max77819_pmic_reg_read(MAX77819_DCCRNT,&reg_inputcc );
-            printk(KERN_EMERG " reg_chgcc(0x38) = %x, reg_inputcc(0x3b)=%x\n",reg_chgcc,reg_inputcc);
-            current_chgcc = reg_chgcc & 0x1f;  //bit: 0-4 
-            current_inputcc = reg_inputcc & 0x3f;  //bit: 0-5
-            if((current_chgcc <= 0x06)||(current_inputcc <= 0x0c))
-                return;
-	 do{
-                current_chgcc -= 1;
-                current_inputcc -= 2;
-                if(current_chgcc <= 0X06)
-                       current_chgcc = 0x06;   //threshold :500mA
-                 if(current_inputcc <= 0X0c)//threshold :500mA
-                       current_inputcc = 0x0c;
-
-                 reg_chgcc = (reg_chgcc & (!0x1f))|current_chgcc;
-                 reg_inputcc = (reg_inputcc & (!0x3f))|current_inputcc;
-           //      max77819_pmic_reg_write(MAX77819_FCHGCRNT, reg_chgcc);
-                 max77819_pmic_reg_write(MAX77819_DCCRNT, reg_inputcc);
-                 msleep(50);
-              } while(max77819_charger_get_aicl_status() &&  !(current_inputcc = 0x0c));
-
-            max77819_adjust_input_current();
-
-              max77819_charger_lock();
+	      kal_uint32 reg_chgcc = 0;
+	      kal_uint32 reg_inputcc = 0;
+	      kal_uint32 current_chgcc = 0;
+	      kal_uint32 current_inputcc = 0;
+		if (!max77819_charger_get_aicl_status())
+		return  -1;
+
+
+	     max77819_charger_unlock();
+	 max77819_pmic_reg_read(MAX77819_FCHGCRNT, &reg_chgcc);
+	    max77819_pmic_reg_read(MAX77819_DCCRNT, &reg_inputcc);
+	    printk(KERN_EMERG " reg_chgcc(0x38) = %x, reg_inputcc(0x3b)=%x\n", reg_chgcc, reg_inputcc);
+	    current_chgcc = reg_chgcc & 0x1f;  //bit: 0-4
+	    current_inputcc = reg_inputcc & 0x3f;  //bit: 0-5
+	    if ((current_chgcc <= 0x06) || (current_inputcc <= 0x0c))
+		return;
+	do {
+		current_chgcc -= 1;
+		current_inputcc -= 2;
+		if (current_chgcc <= 0X06)
+		       current_chgcc = 0x06;   //threshold :500mA
+		if (current_inputcc <= 0X0c)//threshold :500mA
+		       current_inputcc = 0x0c;
+
+		 reg_chgcc = (reg_chgcc & (!0x1f))|current_chgcc;
+		 reg_inputcc = (reg_inputcc & (!0x3f))|current_inputcc;
+	   //      max77819_pmic_reg_write(MAX77819_FCHGCRNT, reg_chgcc);
+		 max77819_pmic_reg_write(MAX77819_DCCRNT, reg_inputcc);
+		 msleep(50);
+	} while (max77819_charger_get_aicl_status() &&  !(current_inputcc = 0x0c));
+
+	    max77819_adjust_input_current();
+
+	      max77819_charger_lock();
 }
 
 void max77819_vol_control(void)
 {
-              kal_uint32 reg_chgcc = 0;
-              kal_uint32 reg_inputcc = 0;
-              kal_uint32 current_chgcc = 0;
-              kal_uint32 current_inputcc = 0;
-
-
-             max77819_charger_unlock();
-	 max77819_pmic_reg_read(MAX77819_FCHGCRNT,&reg_chgcc );
-            max77819_pmic_reg_read(MAX77819_DCCRNT,&reg_inputcc );
-            printk(KERN_EMERG " reg_chgcc(0x38) = %x, reg_inputcc(0x3b)=%x\n",reg_chgcc,reg_inputcc);
-            current_chgcc = reg_chgcc & 0x1f;  //bit: 0-4
-            current_inputcc = reg_inputcc & 0x3f;  //bit: 0-5
-            if((current_chgcc <= 0x06)||(current_inputcc <= 0x0c))
-                return;
-
-                current_chgcc = 0x10; // 1A
-                current_inputcc = 0x20;// 1A
-
-                 reg_chgcc = (reg_chgcc & (!0x1f))|current_chgcc;
-                 reg_inputcc = (reg_inputcc & (!0x3f))|current_inputcc;
-                //max77819_pmic_reg_write(MAX77819_FCHGCRNT, reg_chgcc);
-                 max77819_pmic_reg_write(MAX77819_DCCRNT, reg_inputcc);
-
-              max77819_charger_lock();
+	      kal_uint32 reg_chgcc = 0;
+	      kal_uint32 reg_inputcc = 0;
+	      kal_uint32 current_chgcc = 0;
+	      kal_uint32 current_inputcc = 0;
+
+
+	     max77819_charger_unlock();
+	 max77819_pmic_reg_read(MAX77819_FCHGCRNT, &reg_chgcc);
+	    max77819_pmic_reg_read(MAX77819_DCCRNT, &reg_inputcc);
+	    printk(KERN_EMERG " reg_chgcc(0x38) = %x, reg_inputcc(0x3b)=%x\n", reg_chgcc, reg_inputcc);
+	    current_chgcc = reg_chgcc & 0x1f;  //bit: 0-4
+	    current_inputcc = reg_inputcc & 0x3f;  //bit: 0-5
+	if ((current_chgcc <= 0x06) || (current_inputcc <= 0x0c))
+		return;
+
+		current_chgcc = 0x10; // 1A
+		current_inputcc = 0x20;// 1A
+
+		 reg_chgcc = (reg_chgcc & (!0x1f))|current_chgcc;
+		 reg_inputcc = (reg_inputcc & (!0x3f))|current_inputcc;
+		//max77819_pmic_reg_write(MAX77819_FCHGCRNT, reg_chgcc);
+		 max77819_pmic_reg_write(MAX77819_DCCRNT, reg_inputcc);
+
+	      max77819_charger_lock();
 }
 
  void max77819_charger_dump_register(void)
@@ -903,8 +832,8 @@ void max77819_vol_control(void)
 		  int i = 0;
 		  int ret;
 
-		  for(i=0x30 ; i<=0x4b; i++)
-				ret = max77819_pmic_reg_read(i,&reg_val);
+		for (i = 0x30 ; i <= 0x4b; i++)
+				ret = max77819_pmic_reg_read(i, &reg_val);
  }
 
  // =========================Maxim77819=================================== //
diff --git a/drivers/misc/mediatek/power/mt6735/max77819_pmic.c b/drivers/misc/mediatek/power/mt6735/max77819_pmic.c
index 3d9fa6c2e..a20a7e1e0 100644
--- a/drivers/misc/mediatek/power/mt6735/max77819_pmic.c
+++ b/drivers/misc/mediatek/power/mt6735/max77819_pmic.c
@@ -47,7 +47,7 @@
 
 /*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
-#define DEBUG 1
+#define DEBUG 0
 /*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
@@ -56,10 +56,10 @@
 
 #define MAX77819_PMIC_DEV_NAME        "MAX77819_PMIC"
 /*----------------------------------------------------------------------------*/
-static const struct i2c_device_id max77819_pmic_i2c_id[] = {{MAX77819_PMIC_DEV_NAME,0},{}};
+static const struct i2c_device_id max77819_pmic_i2c_id[] = {{MAX77819_PMIC_DEV_NAME, 0}, {} };
 /*the adapter id will be available in customization*/
 
-static struct i2c_board_info __initdata i2c_max77819_pmic={ I2C_BOARD_INFO("MAX77819_PMIC", 0xCC>>1)};
+static struct i2c_board_info i2c_max77819_pmic __initdata = { I2C_BOARD_INFO("MAX77819_PMIC", 0xCC>>1)};
 
 kal_bool chargin_hw_init_done = KAL_FALSE;
 
@@ -76,7 +76,7 @@ typedef enum {
     BLS_TRC_READ  = 0x01,
     BLS_TRC_RAWDATA = 0x02,
     BLS_TRC_IOCTL   = 0x04,
-    BLS_TRC_FILTER  =0x08,
+    BLS_TRC_FILTER = 0x08,
 } BLS_TRC;
 /*----------------------------------------------------------------------------*/
 
@@ -95,10 +95,10 @@ struct max77819_pmic_i2c_data {
 /*----------------------------------------------------------------------------*/
 static struct i2c_driver max77819_pmic_i2c_driver = {
     .driver = {
-        .name           = MAX77819_PMIC_DEV_NAME,
+	.name           = MAX77819_PMIC_DEV_NAME,
     },
-	.probe      		= max77819_pmic_i2c_probe,
-	.remove    			= max77819_pmic_i2c_remove,
+	.probe		= max77819_pmic_i2c_probe,
+	.remove			= max77819_pmic_i2c_remove,
 #if !defined(CONFIG_HAS_EARLYSUSPEND)
     .suspend            = max77819_pmic_suspend,
     .resume             = max77819_pmic_resume,
@@ -107,130 +107,19 @@ static struct i2c_driver max77819_pmic_i2c_driver = {
 };
 
 /*----------------------------------------------------------------------------*/
-static struct i2c_client *max77819_pmic_i2c_client = NULL;
+static struct i2c_client *max77819_pmic_i2c_client;
 static struct platform_driver max77819_pmic_backlight_driver;
-static struct max77819_pmic_i2c_data *obj_i2c_data = NULL;
+static struct max77819_pmic_i2c_data *obj_i2c_data;
 
 /*----------------------------------------------------------------------------*/
 #define BLS_TAG                  "[MAX77819_PMIC] "
 #define BLS_FUN(f)               printk(KERN_ERR BLS_TAG"%s\n", __func__)
 #define BLS_ERR(fmt, args...)    printk(KERN_ERR BLS_TAG"%s %d : "fmt, __func__, __LINE__, ##args)
 #define BLS_LOG(fmt, args...)    printk(KERN_ERR BLS_TAG fmt, ##args)
-/*----------------------------------------------------------------------------*/
-/*
-static int max77819_pmic_data_resolution[] = {
-    4096,
-    2048,
-    1024,
-    512,
-    256,
-};
-*/
-/*----------------------------------------------------------------------------*/
-
-/*-------------------- power control function----------------------------------*/
-
-
-
-#if 0
-
-/*----------------------------------------------------------------------------*/
-/*
-static ssize_t show_chipinfo_value(struct device_driver *ddri, char *buf)
-{
-
-	struct i2c_client *client = max77819_pmic_i2c_client;
-	char strbuf[MAX77819_PMIC_BUFSIZE];
-	BLS_LOG(" show_chipinfo_value \n");
-	if(NULL == client)
-	{
-		BLS_ERR("i2c client is null!!\n");
-		return 0;
-	}
-
-	return snprintk(buf, PAGE_SIZE, "%s\n", strbuf);
-
-}
-*/
-/*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
-static ssize_t show_trace_value(struct device_driver *ddri, char *buf)
-{
-	ssize_t res;
-	struct max77819_pmic_i2c_data *obj = obj_i2c_data;
-	BLS_LOG(" show_trace_value \n");
-	if (obj == NULL)
-	{
-		BLS_ERR("i2c_data obj is null!!\n");
-		return 0;
-	}
-
-	res = snprintk(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
-	return res;
-}
-/*----------------------------------------------------------------------------*/
-/*----------------------------------------------------------------------------*/
-static ssize_t show_status_value(struct device_driver *ddri, char *buf)
-{
-	ssize_t len = 0;
-	BLS_LOG(" show_status_value \n");
-
-	return len;
-}
-/*----------------------------------------------------------------------------*/
-//static DRIVER_ATTR(chipinfo,             S_IRUGO, show_chipinfo_value,      NULL);
-static DRIVER_ATTR(sensordata,           S_IRUGO, show_sensordata_value,    NULL);
-static DRIVER_ATTR(trace,      S_IWUSR | S_IRUGO, show_trace_value,         store_trace_value);
-static DRIVER_ATTR(status,               S_IRUGO, show_status_value,        NULL);
-/*----------------------------------------------------------------------------*/
-static struct driver_attribute *max77819_pmic_attr_list[] = {
-	//&driver_attr_chipinfo,     /*chip information*/
-	&driver_attr_trace,        /*trace log*/
-	&driver_attr_status,       /*enable or disable*/
-};
-/*----------------------------------------------------------------------------*/
-static int max77819_pmic_create_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(sizeof(max77819_pmic_attr_list)/sizeof(max77819_pmic_attr_list[0]));
-	if (driver == NULL)
-	{
-		return -EINVAL;
-	}
-
-	for(idx = 0; idx < num; idx++)
-	{
-		if((err = driver_create_file(driver, max77819_pmic_attr_list[idx])))
-		{
-			BLS_ERR("driver_create_file (%s) = %d\n", max77819_pmic_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-/*----------------------------------------------------------------------------*/
-static int max77819_pmic_delete_attr(struct device_driver *driver)
-{
-	int idx ,err = 0;
-	int num = (int)(sizeof(max77819_pmic_attr_list)/sizeof(max77819_pmic_attr_list[0]));
-
-	if(driver == NULL)
-	{
-		return -EINVAL;
-	}
 
-
-	for(idx = 0; idx < num; idx++)
-	{
-		driver_remove_file(driver, max77819_pmic_attr_list[idx]);
-	}
-
-
-	return err;
-}
-#endif
-/*----------------------------------------------------------------------------*/
+/*-------------------- power control function----------------------------------*/
 
 /******************************************************************************
  * Function Configuration
@@ -239,8 +128,7 @@ static int max77819_pmic_open(struct inode *inode, struct file *file)
 {
 	file->private_data = max77819_pmic_i2c_client;
 
-	if(file->private_data == NULL)
-	{
+	if (file->private_data == NULL) {
 		BLS_ERR("null pointer!!\n");
 		return -EINVAL;
 	}
@@ -252,23 +140,7 @@ static int max77819_pmic_release(struct inode *inode, struct file *file)
 	file->private_data = NULL;
 	return 0;
 }
-/*----------------------------------------------------------------------------*/
 
-#if 0
-/*----------------------------------------------------------------------------*/
-static struct file_operations max77819_pmic_fops = {
-	.owner = THIS_MODULE,
-	.open = max77819_pmic_open,
-	.release = max77819_pmic_release,
-	.ioctl = max77819_pmic_ioctl,
-};
-/*----------------------------------------------------------------------------*/
-static struct miscdevice max77819_pmic_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "backlight",
-	.fops = &max77819_pmic_fops,
-};
-#endif
 /*----------------------------------------------------------------------------*/
 #ifndef CONFIG_HAS_EARLYSUSPEND
 /*----------------------------------------------------------------------------*/
@@ -276,7 +148,8 @@ static int max77819_pmic_suspend(struct i2c_client *client, pm_message_t msg)
 {
 	struct max77819_pmic_i2c_data *obj = i2c_get_clientdata(client);
 	int err = 0;
-	kal_uint8  dat=0;
+	kal_uint8  dat = 0;
+
 	GSE_FUN();
 
 	return err;
@@ -286,10 +159,10 @@ static int max77819_pmic_resume(struct i2c_client *client)
 {
 	struct max77819_pmic_i2c_data *obj = i2c_get_clientdata(client);
 	int err;
+
 	GSE_FUN();
 
-	if(obj == NULL)
-	{
+	if (obj == NULL) {
 		BLS_ERR("null pointer!!\n");
 		return -EINVAL;
 	}
@@ -305,8 +178,7 @@ static void max77819_pmic_early_suspend(struct early_suspend *h)
 //	int err;
 	BLS_FUN();
 
-	if(obj == NULL)
-	{
+	if (obj == NULL) {
 		BLS_ERR("null pointer!!\n");
 		return;
 	}
@@ -317,6 +189,7 @@ static void max77819_pmic_late_resume(struct early_suspend *h)
 {
 	struct max77819_pmic_i2c_data *obj = container_of(h, struct max77819_pmic_i2c_data, early_drv);
 	int err;
+
 	BLS_FUN();
 }
 /*----------------------------------------------------------------------------*/
@@ -333,21 +206,19 @@ int max77819_pmic_read_byte(kal_uint8 cmd, kal_uint8 *returnData)
 {
     char     cmd_buf = 0;
     char     readData = 0;
-    int      ret=0;
+    int      ret = 0;
 
     BLS_FUN();
     mutex_lock(&max77819_pmic_i2c_access);
 
     cmd_buf = cmd;
 
-    max77819_pmic_i2c_client->addr = (max77819_pmic_i2c_client->addr & I2C_MASK_FLAG) | I2C_WR_FLAG |I2C_RS_FLAG;
+    max77819_pmic_i2c_client->addr = (max77819_pmic_i2c_client->addr & I2C_MASK_FLAG) | I2C_WR_FLAG | I2C_RS_FLAG;
     ret = i2c_master_send(max77819_pmic_i2c_client, &cmd_buf, (1<<8 | 1));
-    if (ret < 0)
-    {
-		BLS_ERR("send command error!!\n");
-
-        mutex_unlock(&max77819_pmic_i2c_access);
-        return ret;
+    if (ret < 0) {
+	BLS_ERR("send command error!!\n");
+	mutex_unlock(&max77819_pmic_i2c_access);
+	return ret;
     }
 
     readData = cmd_buf;
@@ -362,7 +233,7 @@ int max77819_pmic_read_byte(kal_uint8 cmd, kal_uint8 *returnData)
 int max77819_pmic_write_byte(kal_uint8 cmd, kal_uint8 writeData)
 {
     char    write_data[2] = {0};
-    int     ret=0;
+    int     ret = 0;
 
 	BLS_FUN();
     mutex_lock(&max77819_pmic_i2c_access);
@@ -370,18 +241,16 @@ int max77819_pmic_write_byte(kal_uint8 cmd, kal_uint8 writeData)
     write_data[0] = cmd;
     write_data[1] = writeData;
     ret = i2c_master_send(max77819_pmic_i2c_client, write_data, 2);
-    if (ret < 0)
-    {
-
-	   BLS_ERR("send command error!!\n");
-        mutex_unlock(&max77819_pmic_i2c_access);
-        return ret;
+    if (ret < 0) {
+	BLS_ERR("send command error!!\n");
+	mutex_unlock(&max77819_pmic_i2c_access);
+	return ret;
     }
     mutex_unlock(&max77819_pmic_i2c_access);
     return 0;
 }
 
-u32 max77819_pmic_read_interface (kal_uint8 RegNum, kal_uint8 *val, kal_uint8 MASK, kal_uint8 SHIFT)
+u32 max77819_pmic_read_interface(kal_uint8 RegNum, kal_uint8 *val, kal_uint8 MASK, kal_uint8 SHIFT)
 {
     kal_uint8 max77819_reg = 0;
     int ret = 0;
@@ -398,7 +267,7 @@ u32 max77819_pmic_read_interface (kal_uint8 RegNum, kal_uint8 *val, kal_uint8 MA
     return ret;
 }
 
-u32 max77819_pmic_config_interface (kal_uint8 RegNum, kal_uint8 val, kal_uint8 MASK, kal_uint8 SHIFT)
+u32 max77819_pmic_config_interface(kal_uint8 RegNum, kal_uint8 val, kal_uint8 MASK, kal_uint8 SHIFT)
 {
     kal_uint8 max77819_pmic_reg = 0;
     int ret = 0;
@@ -420,16 +289,16 @@ static int max77819_pmic_read_byte_sr(struct i2c_client *client, kal_uint8 addr,
    kal_uint8 buf;
 	int ret = 0;
 
-	client->addr = (client->addr & I2C_MASK_FLAG) | I2C_WR_FLAG |I2C_RS_FLAG;
+	client->addr = (client->addr & I2C_MASK_FLAG) | I2C_WR_FLAG | I2C_RS_FLAG;
 	buf = addr;
-	ret = i2c_master_send(client, (const char*)&buf, 1<<8 | 1);
+	ret = i2c_master_send(client, (const char *)&buf, 1<<8 | 1);
 	if (ret < 0) {
 		BLS_ERR("send command error!!\n");
 		return ret;
 	}
 
 	*data = buf;
-	client->addr = client->addr& I2C_MASK_FLAG;
+	client->addr = client->addr & I2C_MASK_FLAG;
 	return 0;
 }
 
@@ -437,36 +306,36 @@ static int max77819_pmic_read_byte_sr(struct i2c_client *client, kal_uint8 addr,
 int max77819_pmic_read_block(struct i2c_client *client, kal_uint8 addr, kal_uint8 *data, kal_uint8 len)
 {
     if (len == 1) {
-        return max77819_pmic_read_byte_sr(client, addr, data);
+	return max77819_pmic_read_byte_sr(client, addr, data);
     } else {
-        kal_uint8 beg = addr;
-        struct i2c_msg msgs[2] = {
-            {
-                .addr = client->addr,    .flags = 0,
-                .len = 1,                .buf= &beg
-            },
-            {
-                .addr = client->addr,    .flags = I2C_M_RD,
-                .len = len,             .buf = data,
-            }
-        };
-        int err;
-
-        if (!client)
-            return -EINVAL;
-        else if (len > C_I2C_FIFO_SIZE) {
-            BLS_ERR(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
-            return -EINVAL;
-        }
-
-        err = i2c_transfer(client->adapter, msgs, sizeof(msgs)/sizeof(msgs[0]));
-        if (err != 2) {
-            BLS_ERR("i2c_transfer error: (%d %p %d) %d\n", addr, data, len, err);
-            err = -EIO;
-        } else {
-            err = 0;    /*no error*/
-        }
-        return err;
+	kal_uint8 beg = addr;
+	struct i2c_msg msgs[2] = {
+	{
+		.addr = client->addr,    .flags = 0,
+		.len = 1,                .buf = &beg
+	    },
+	{
+		.addr = client->addr,    .flags = I2C_M_RD,
+		.len = len,             .buf = data,
+	}
+	};
+	int err;
+
+	if (!client)
+	return -EINVAL;
+	else if (len > C_I2C_FIFO_SIZE) {
+	    BLS_ERR(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
+	return -EINVAL;
+	}
+
+	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+	if (err != 2) {
+	    BLS_ERR("i2c_transfer error: (%d %p %d) %d\n", addr, data, len, err);
+	    err = -EIO;
+	} else {
+	    err = 0;    /*no error*/
+	}
+	return err;
     }
 
 }
@@ -481,23 +350,23 @@ int max77819_pmic_write_block(struct i2c_client *client, kal_uint8 addr, kal_uin
     char buf[C_I2C_FIFO_SIZE];
 
     if (!client)
-        return -EINVAL;
+	return -EINVAL;
     else if (len >= C_I2C_FIFO_SIZE) {
-        BLS_ERR(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
-        return -EINVAL;
+	BLS_ERR(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
+	return -EINVAL;
     }
 
     num = 0;
     buf[num++] = addr;
     for (idx = 0; idx < len; idx++)
-        buf[num++] = data[idx];
+	buf[num++] = data[idx];
 
     err = i2c_master_send(client, buf, num);
     if (err < 0) {
-        BLS_ERR("send command error!!\n");
-        return -EFAULT;
+	BLS_ERR("send command error!!\n");
+	return -EFAULT;
     } else {
-        err = 0;    /*no error*/
+	err = 0;    /*no error*/
     }
     return err;
 }
@@ -510,23 +379,30 @@ int max77819_pmic_reg_write(kal_uint8 reg, kal_uint8 val)
     int ret = 0;
 
     max77819_pmic_read_byte(reg, &max77819_reg);
+
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_write] Before Reg[%x]=0x%x\n", reg, max77819_reg);
+    #endif
 
-    if(val == max77819_reg)
-    {
-        BLS_LOG("[max77819_pmic_reg_write] Set Reg[%x] same value 0x%x\n", reg, max77819_reg);
-        return 0;
+    if (val == max77819_reg) {
+	#ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
+	BLS_LOG("[max77819_pmic_reg_write] Set Reg[%x] same value 0x%x\n", reg, max77819_reg);
+	#endif
+	return 0;
     }
 
 	ret = max77819_pmic_write_byte(reg, val);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_write] write Reg[%x]=0x%x\n", reg, val);
+    #endif
 
     max77819_pmic_read_byte(reg, &max77819_reg);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_write] After Reg[%x]=0x%x\n", reg, max77819_reg);
+    #endif
 
-    if(max77819_reg != val)
-    {
-        return -1;
+    if (max77819_reg != val) {
+	return -1;
     }
     return ret;
 }
@@ -539,7 +415,9 @@ int max77819_pmic_reg_read(kal_uint8 reg, kal_uint8 *val)
     int ret = 0;
 
     ret = max77819_pmic_read_byte(reg, val);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_read] Reg[%x]=0x%x\n", reg, *val);
+    #endif
 
     return ret;
 
@@ -555,28 +433,34 @@ int max77819_pmic_reg_update_bits(kal_uint8 reg, kal_uint8 mask, kal_uint8 val)
     int ret = 0;
 
     max77819_pmic_read_byte(reg, &max77819_reg);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_update_bits] Before Reg[%x]=0x%x\n", reg, max77819_reg);
+    #endif
 
     old_reg = max77819_reg;
     max77819_reg &= ~(mask);
     max77819_reg |= val;
-    if(old_reg == max77819_reg)
-    {
-        BLS_LOG("[max77819_pmic_reg_update_bits] Set Reg[%x] same value 0x%x\n", reg, max77819_reg);
-        return 0;
+    if (old_reg == max77819_reg) {
+	#ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
+	BLS_LOG("[max77819_pmic_reg_update_bits] Set Reg[%x] same value 0x%x\n", reg, max77819_reg);
+	#endif
+	return 0;
     }
 
     new_reg = max77819_reg;
 
     ret = max77819_pmic_write_byte(reg, max77819_reg);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_update_bits] write Reg[%x]=0x%x\n", reg, max77819_reg);
+    #endif
 
 	max77819_pmic_read_byte(reg, &max77819_reg);
+    #ifndef CONFIG_MEIZU_CLOSE_MTK_LOG
     BLS_LOG("[max77819_pmic_reg_update_bits] After Reg[%x]=0x%x\n", reg, max77819_reg);
+    #endif
 
-    if(max77819_reg != new_reg)
-    {
-        return -1;
+    if (max77819_reg != new_reg) {
+	return -1;
     }
     return ret;
 
@@ -590,12 +474,11 @@ static int max77819_pmic_i2c_probe(struct i2c_client *client, const struct i2c_d
 	struct i2c_client *new_client;
 	struct max77819_pmic_i2c_data *obj;
 
-	int err = 0,i = 0;
+	int err = 0, i = 0;
 
 	BLS_FUN();
 
-	if(!(obj = kzalloc(sizeof(*obj), GFP_KERNEL)))
-	{
+	if (!(obj = kzalloc(sizeof(*obj), GFP_KERNEL))) {
 		err = -1;
 		goto exit;
 	}
@@ -605,7 +488,7 @@ static int max77819_pmic_i2c_probe(struct i2c_client *client, const struct i2c_d
 	obj_i2c_data = obj;
 	obj->client = client;
 	new_client = obj->client;
-	i2c_set_clientdata(new_client,obj);
+	i2c_set_clientdata(new_client, obj);
 
 	atomic_set(&obj->trace, 0);
 	atomic_set(&obj->suspend, 0);
@@ -615,9 +498,9 @@ static int max77819_pmic_i2c_probe(struct i2c_client *client, const struct i2c_d
 
 
 
-kal_uint8 reg_val = 0;
-		  for(i=0x30 ; i<=0x4b; i++)
-			 max77819_pmic_reg_read(i,&reg_val);
+kal_uint8 reg_val;
+		for (i = 0x30 ; i <= 0x4b; i++)
+			 max77819_pmic_reg_read(i, &reg_val);
 
 exit:
 
@@ -628,17 +511,7 @@ exit:
 static int max77819_pmic_i2c_remove(struct i2c_client *client)
 {
 	int err = 0;
-#if 0
 
-	if((err = max77819_pmic_delete_attr(&max77819_pmic_backlight_driver.driver)))
-	{
-		BLS_ERR("max77819_pmic_delete_attr fail: %d\n", err);
-	}
-	if((err = misc_deregister(&max77819_pmic_device)))
-	{
-		BLS_ERR("misc_deregister fail: %d\n", err);
-	}
-#endif
 	max77819_pmic_i2c_client = NULL;
 	i2c_unregister_device(client);
 	kfree(i2c_get_clientdata(client));
@@ -651,8 +524,7 @@ static int __init max77819_pmic_init(void)
 {
 	BLS_FUN();
 	i2c_register_board_info(/*2*/MAX77819_PMIC_I2C_NUM, &i2c_max77819_pmic, 1);
-	if(i2c_add_driver(&max77819_pmic_i2c_driver))
-	{
+	if (i2c_add_driver(&max77819_pmic_i2c_driver)) {
 		BLS_ERR("add driver error\n");
 		return -1;
 	}
@@ -662,8 +534,8 @@ static int __init max77819_pmic_init(void)
 /*----------------------------------------------------------------------------*/
 static void __exit max77819_pmic_exit(void)
 {
-    BLS_FUN();
-    i2c_del_driver(&max77819_pmic_i2c_driver);
+	BLS_FUN();
+	i2c_del_driver(&max77819_pmic_i2c_driver);
 }
 /*----------------------------------------------------------------------------*/
 module_init(max77819_pmic_init);