diff --git a/arch/arm64/boot/dts/qcom/msm8953-camera-sensor-mtp.dtsi b/arch/arm64/boot/dts/qcom/msm8953-camera-sensor-mtp.dtsi
index f3e13c0..270515a 100644
--- a/arch/arm64/boot/dts/qcom/msm8953-camera-sensor-mtp.dtsi
+++ b/arch/arm64/boot/dts/qcom/msm8953-camera-sensor-mtp.dtsi
@@ -20,7 +20,7 @@
 		reg = <0x0>;
 		compatible = "qcom,actuator";
 		qcom,cci-master = <0>;
-		cam_vaf-supply = <&pm8953_l17>;
+//		cam_vaf-supply = <&pm8953_l17>;
 		qcom,cam-vreg-name = "cam_vaf";
 		qcom,cam-vreg-min-voltage = <2850000>;
 		qcom,cam-vreg-max-voltage = <2850000>;
@@ -44,113 +44,110 @@
 		compatible = "qcom,eeprom";
 		qcom,cci-master = <0>;
 		reg = <0x0>;
-		cam_vio-supply = <&pm8953_l6>;
-		cam_vdig-supply = <&pm8953_l2>;
-		cam_vaf-supply = <&pm8953_l17>;
-		qcom,cam-vreg-name = "cam_vio", "cam_vdig", "cam_vaf";
-		qcom,cam-vreg-min-voltage = <0 1200000 2850000>;
-		qcom,cam-vreg-max-voltage = <0 1200000 2850000>;
-		qcom,cam-vreg-op-mode = <0 105000 100000>;
+		cam_vana-supply = <&pm8953_l22>;
+		cam_v_custom1-supply = <&pm8953_l2>;
+		qcom,cam-vreg-name = "cam_vana", "cam_v_custom1";
+		qcom,cam-vreg-min-voltage = <2800000 1175000>;
+		qcom,cam-vreg-max-voltage = <2800000 1175000>;
+		qcom,cam-vreg-op-mode = <80000 105000>;
 		pinctrl-names = "cam_default", "cam_suspend";
-		pinctrl-0 = <&cam_sensor_mclk0_default
-				&cam_sensor_rear_default
-				&cam_sensor_rear_vana>;
-		pinctrl-1 = <&cam_sensor_mclk0_sleep &cam_sensor_rear_sleep
-				&cam_sensor_rear_vana_sleep>;
+		pinctrl-0 = <&cam_sensor_mclk0_default &cam_sensor_rear_default>;
+		pinctrl-1 = <&cam_sensor_mclk0_sleep &cam_sensor_rear_sleep>;
 		gpios = <&tlmm 26 0>,
 			<&tlmm 40 0>,
-			<&tlmm 39 0>,
-			<&tlmm 134 0>;
+			<&tlmm 130 0>;
 		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-vana = <3>;
-		qcom,gpio-req-tbl-num = <0 1 2 3>;
-		qcom,gpio-req-tbl-flags = <1 0 0 0>;
+		qcom,gpio-vio = <2>;
+		qcom,gpio-req-tbl-num = <0 1 2>;
+		qcom,gpio-req-tbl-flags = <1 0 0>;
 		qcom,gpio-req-tbl-label = "CAMIF_MCLK0",
 			"CAM_RESET0",
-			"CAM_STANDBY0",
-			"CAM_VANA";
+			"CAM_VIO";
+		qcom,sensor-position = <0>;
+		qcom,sensor-mode = <0>;
 		status = "ok";
 		clocks = <&clock_gcc clk_mclk0_clk_src>,
 				<&clock_gcc clk_gcc_camss_mclk0_clk>;
 		clock-names = "cam_src_clk", "cam_clk";
-		qcom,clock-rates = <19200000 0>;
+		qcom,clock-rates = <24000000 0>;
 	};
 
+/*<2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]Modified for new front camera device driver S5K4H7YX. */
 	eeprom1: qcom,eeprom@1 {
 		cell-index = <1>;
-		reg = <0x1>;
 		compatible = "qcom,eeprom";
 		qcom,cci-master = <1>;
-		cam_vdig-supply = <&pm8953_l23>;
-		cam_vio-supply = <&pm8953_l6>;
-		cam_vana-supply = <&pm8953_l22>;
-		cam_vaf-supply = <&pm8953_l17>;
-		qcom,cam-vreg-name = "cam_vdig", "cam_vio", "cam_vana",
-					"cam_vaf";
-		qcom,cam-vreg-min-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-max-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-op-mode = <105000 0 80000 100000>;
+		reg = <0x1>;
+
+#if 0
+		qcom,eeprom-name = "samsung_s5k4h7yx";
+		qcom,slave-addr = <0x20>;
+		qcom,num-blocks = <2>;
+
+		qcom,page0 = <1 0x0100 2 0x01 1 1>;
+		qcom,poll0 = <0 0x0 2 0x0 1 0>;
+		qcom,mem0 = <0 0x0 2 0x0 1 0>;
+#endif
+
+		/* cam_vio-supply = <&cam_vio_gpio_regulator>; */ /* IOVDD */
+		cam_vana-supply = <&pm8953_l22>; /* AVDD */
+		/* cam_vdig-supply = <&cam_front_dvdd_gpio_regulator>; */ /* DVDD */
+		/* cam_vaf-supply = <&pm8953_l17>; */ /* AFVDD is not usage */
+		qcom,cam-vreg-name = "cam_vana";  /* "cam_vio", "cam_vana", "cam_vdig"; */
+		qcom,cam-vreg-min-voltage = <2800000>;
+		qcom,cam-vreg-max-voltage = <2800000>;
+		qcom,cam-vreg-op-mode = <80000>;
 		qcom,gpio-no-mux = <0>;
+
 		pinctrl-names = "cam_default", "cam_suspend";
 		pinctrl-0 = <&cam_sensor_mclk1_default
-				&cam_sensor_front1_default>;
+				&cam_sensor_front1_default
+				&cam_sensor_front1_vdig_default
+				&cam_sensor_front1_vio_default>;
 		pinctrl-1 = <&cam_sensor_mclk1_sleep
-				&cam_sensor_front1_sleep>;
-		gpios = <&tlmm 27 0>,
-			<&tlmm 129 0>,
-			<&tlmm 130 0>;
-		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-req-tbl-num = <0 1 2>;
-		qcom,gpio-req-tbl-flags = <1 0 0>;
-		qcom,gpio-req-tbl-label = "CAMIF_MCLK2",
-					  "CAM_RESET2",
-					  "CAM_STANDBY2";
-		qcom,sensor-position = <1>;
-		qcom,sensor-mode = <0>;
-		status = "ok";
-		clocks = <&clock_gcc clk_mclk1_clk_src>,
-			<&clock_gcc clk_gcc_camss_mclk1_clk>;
-		clock-names = "cam_src_clk", "cam_clk";
-		qcom,clock-rates = <19200000 0>;
-	};
+				&cam_sensor_front1_sleep
+				&cam_sensor_front1_vdig_sleep
+				&cam_sensor_front1_vio_sleep>;
 
-	eeprom2: qcom,eeprom@2 {
-		cell-index = <2>;
-		compatible = "qcom,eeprom";
-		qcom,cci-master = <1>;
-		reg = <0x2>;
-		cam_vdig-supply = <&pm8953_l23>;
-		cam_vana-supply = <&pm8953_l22>;
-		cam_vio-supply = <&pm8953_l6>;
-		cam_vaf-supply = <&pm8953_l17>;
-		qcom,cam-vreg-name = "cam_vdig", "cam_vio", "cam_vana",
-					"cam_vaf";
-		qcom,cam-vreg-min-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-max-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-op-mode = <200000 0 80000 100000>;
-		pinctrl-names = "cam_default", "cam_suspend";
-		pinctrl-0 = <&cam_sensor_mclk2_default
-				&cam_sensor_front_default>;
-		pinctrl-1 = <&cam_sensor_mclk2_sleep
-				&cam_sensor_front_sleep>;
-		gpios = <&tlmm 28 0>,
-			<&tlmm 131 0>,
-			<&tlmm 132 0>;
+/*<2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]VOI control pin.PCBA EP0 is GPIO123;EP1 and above is GPIO130 */
+		gpios = <&tlmm 27 0>,
+				<&tlmm 129 0>,
+				<&tlmm 46 0>,
+#if 1
+				<&tlmm 130 0>;
+#else /* PCBA EP0 */
+				<&tlmm 123 0>;
+#endif
+/*>2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][] */
 		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-req-tbl-num = <0 1 2>;
-		qcom,gpio-req-tbl-flags = <1 0 0>;
-		qcom,gpio-req-tbl-label = "CAMIF_MCLK1",
-			"CAM_RESET1",
-			"CAM_STANDBY1";
+		qcom,gpio-vdig = <2>;
+		qcom,gpio-vio = <3>;
+		qcom,gpio-req-tbl-num = <0 1 2 3>;
+		qcom,gpio-req-tbl-flags = <1 0 0 0>;
+		qcom,gpio-req-tbl-label = "CAMIF_MCLK2",
+				"CAM_RESET2",
+				"CAM_VDIG2",
+				"CAM_VIO2";
+
 		status = "ok";
-		clocks = <&clock_gcc clk_mclk2_clk_src>,
-				<&clock_gcc clk_gcc_camss_mclk2_clk>;
+#if 1
+		qcom,cam-power-seq-val = "sensor_gpio_reset",
+				"cam_vana", "sensor_gpio_vdig",
+				"sensor_gpio_vio", "sensor_gpio_reset",
+				"sensor_cam_mclk";
+		qcom,cam-power-seq-type = "sensor_gpio",
+				"sensor_vreg", "sensor_gpio",
+				"sensor_gpio", "sensor_gpio",
+				"sensor_clk";
+		qcom,cam-power-seq-cfg-val = <0 1 1 1 1 24000000>;
+		qcom,cam-power-seq-delay = <5 1 1 3 3 10>; /* <1 1 1 1 1 10>; */
+#endif
 		clock-names = "cam_src_clk", "cam_clk";
+		clocks = <&clock_gcc clk_mclk1_clk_src>,
+				<&clock_gcc clk_gcc_camss_mclk1_clk>;
 		qcom,clock-rates = <19200000 0>;
 	};
+/*>2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]. */
 
 	camera0: qcom,camera@0 {
 		cell-index = <0>;
@@ -162,16 +159,15 @@
 		qcom,led-flash-src = <&led_flash0>;
 		qcom,eeprom-src = <&eeprom0>;
 		qcom,actuator-src = <&actuator0>;
-		cam_vio-supply = <&pm8953_l6>;
-		cam_vdig-supply = <&pm8953_l2>;
-		cam_vaf-supply = <&pm8953_l17>;
+//		cam_vio-supply = <&pm8953_l6>;
+//		cam_vdig-supply = <&pm8953_l2>;
+//		cam_vaf-supply = <&pm8953_l17>;
 		cam_vana-supply = <&pm8953_l22>;
-		cam_v_custom1-supply = <&pm8953_l23>;
-		qcom,cam-vreg-name = "cam_vio", "cam_vdig", "cam_vaf",
-						"cam_vana", "cam_v_custom1";
-		qcom,cam-vreg-min-voltage = <0 1200000 2850000 2800000 1200000>;
-		qcom,cam-vreg-max-voltage = <0 1200000 2850000 2800000 1200000>;
-		qcom,cam-vreg-op-mode = <0 105000 100000 80000 105000>;
+		cam_v_custom1-supply = <&pm8953_l2>;
+		qcom,cam-vreg-name = "cam_vana", "cam_v_custom1";
+		qcom,cam-vreg-min-voltage = <2800000 1175000>;
+		qcom,cam-vreg-max-voltage = <2800000 1175000>;
+		qcom,cam-vreg-op-mode = <80000 105000>;
 		pinctrl-names = "cam_default", "cam_suspend";
 		pinctrl-0 = <&cam_sensor_mclk0_default
 				&cam_sensor_rear_default
@@ -180,17 +176,17 @@
 				&cam_sensor_rear_vana_sleep>;
 		gpios = <&tlmm 26 0>,
 			<&tlmm 40 0>,
-			<&tlmm 39 0>,
-			<&tlmm 134 0>;
+			<&tlmm 130 0>,
+			<&tlmm 128 0>;
 		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-vana = <3>;
+		qcom,gpio-vio = <2>;
+		qcom,gpio-vaf = <3>;
 		qcom,gpio-req-tbl-num = <0 1 2 3>;
 		qcom,gpio-req-tbl-flags = <1 0 0 0>;
 		qcom,gpio-req-tbl-label = "CAMIF_MCLK0",
 			"CAM_RESET0",
-			"CAM_STANDBY0",
-			"CAM_VANA";
+			"CAM_VIO",
+			"CAM_VAF";
 		qcom,sensor-position = <0>;
 		qcom,sensor-mode = <0>;
 		qcom,cci-master = <0>;
@@ -201,90 +197,65 @@
 		qcom,clock-rates = <24000000 0>;
 	};
 
-	qcom,camera@1 {
-		cell-index = <1>;
-		compatible = "qcom,camera";
-		reg = <0x1>;
-		qcom,csiphy-sd-index = <1>;
-		qcom,csid-sd-index = <1>;
-		qcom,mount-angle = <90>;
-		qcom,eeprom-src = <&eeprom2>;
-		qcom,actuator-src = <&actuator1>;
-		cam_vdig-supply = <&pm8953_l23>;
-		cam_vana-supply = <&pm8953_l22>;
-		cam_vio-supply = <&pm8953_l6>;
-		cam_vaf-supply = <&pm8953_l17>;
-		qcom,cam-vreg-name = "cam_vdig", "cam_vio", "cam_vana",
-							"cam_vaf";
-		qcom,cam-vreg-min-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-max-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-op-mode = <200000 0 80000 100000>;
-		pinctrl-names = "cam_default", "cam_suspend";
-		pinctrl-0 = <&cam_sensor_mclk2_default
-				&cam_sensor_front_default>;
-		pinctrl-1 = <&cam_sensor_mclk2_sleep
-				&cam_sensor_front_sleep>;
-		gpios = <&tlmm 28 0>,
-			<&tlmm 131 0>,
-			<&tlmm 132 0>;
-		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-req-tbl-num = <0 1 2>;
-		qcom,gpio-req-tbl-flags = <1 0 0>;
-		qcom,gpio-req-tbl-label = "CAMIF_MCLK1",
-			"CAM_RESET1",
-			"CAM_STANDBY1";
-		qcom,sensor-position = <0x100>;
-		qcom,sensor-mode = <1>;
-		qcom,cci-master = <1>;
-		status = "ok";
-		clocks = <&clock_gcc clk_mclk2_clk_src>,
-				<&clock_gcc clk_gcc_camss_mclk2_clk>;
-		clock-names = "cam_src_clk", "cam_clk";
-		qcom,clock-rates = <24000000 0>;
-	};
-
-	qcom,camera@2 {
+/*<2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]Modified for new front camera device driver S5K4H7YX. */
+	camera2: qcom,camera@2 {
 		cell-index = <2>;
 		compatible = "qcom,camera";
 		reg = <0x02>;
 		qcom,csiphy-sd-index = <2>;
-		qcom,csid-sd-index = <2>;
-		qcom,mount-angle = <90>;
+		qcom,csid-sd-index = <1>; /* SDM450 support 2 CSID cores. MSM8953 is 3 CSID cores */
+		qcom,mount-angle = <270>; /* <90>; */
 		qcom,eeprom-src = <&eeprom1>;
-		qcom,actuator-src = <&actuator1>;
-		cam_vdig-supply = <&pm8953_l23>;
-		cam_vio-supply = <&pm8953_l6>;
+		/* qcom,actuator-src = <&actuator1>; */ /* The auto focus is not support */
+
+		/* cam_vio-supply = <&cam_vio_gpio_regulator>; */
 		cam_vana-supply = <&pm8953_l22>;
-		cam_vaf-supply = <&pm8953_l17>;
-		qcom,cam-vreg-name = "cam_vdig", "cam_vio", "cam_vana",
-					"cam_vaf";
-		qcom,cam-vreg-min-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-max-voltage = <1200000 0 2800000 2850000>;
-		qcom,cam-vreg-op-mode = <105000 0 80000 100000>;
+		/* cam_vdig-supply = <&cam_front_dvdd_gpio_regulator>; */
+		/* cam_vaf-supply = <&pm8953_l17>; */ /* The AFVDD is not support */
+		qcom,cam-vreg-name = "cam_vana";
+		qcom,cam-vreg-min-voltage = <2800000>;
+		qcom,cam-vreg-max-voltage = <2800000>;
+		qcom,cam-vreg-op-mode = <80000>;
 		qcom,gpio-no-mux = <0>;
+
 		pinctrl-names = "cam_default", "cam_suspend";
 		pinctrl-0 = <&cam_sensor_mclk1_default
-				&cam_sensor_front1_default>;
+				&cam_sensor_front1_default
+				&cam_sensor_front1_vdig_default
+				&cam_sensor_front1_vio_default>;
 		pinctrl-1 = <&cam_sensor_mclk1_sleep
-				&cam_sensor_front1_sleep>;
+				&cam_sensor_front1_sleep
+				&cam_sensor_front1_vdig_sleep
+				&cam_sensor_front1_vio_sleep>;
+
+/*<2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]VOI control pin.PCBA EP0 is GPIO123;EP1 and above is GPIO130 */
 		gpios = <&tlmm 27 0>,
-			<&tlmm 129 0>,
-			<&tlmm 130 0>;
+				<&tlmm 129 0>,
+				<&tlmm 46 0>,
+#if 1
+				<&tlmm 130 0>;
+#else /* PCBA EP0 */
+				<&tlmm 123 0>;
+#endif
+/*>2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][] */
 		qcom,gpio-reset = <1>;
-		qcom,gpio-standby = <2>;
-		qcom,gpio-req-tbl-num = <0 1 2>;
-		qcom,gpio-req-tbl-flags = <1 0 0>;
+		qcom,gpio-vdig = <2>;
+		qcom,gpio-vio = <3>;
+		qcom,gpio-req-tbl-num = <0 1 2 3>;
+		qcom,gpio-req-tbl-flags = <1 0 0 0>;
 		qcom,gpio-req-tbl-label = "CAMIF_MCLK2",
-					  "CAM_RESET2",
-					  "CAM_STANDBY2";
+				"CAM_RESET2",
+				"CAM_VDIG2",
+				"CAM_VIO2";
+
 		qcom,sensor-position = <1>;
 		qcom,sensor-mode = <0>;
 		qcom,cci-master = <1>;
 		status = "ok";
-		clocks = <&clock_gcc clk_mclk1_clk_src>,
-			<&clock_gcc clk_gcc_camss_mclk1_clk>;
 		clock-names = "cam_src_clk", "cam_clk";
+		clocks = <&clock_gcc clk_mclk1_clk_src>,
+				<&clock_gcc clk_gcc_camss_mclk1_clk>;
 		qcom,clock-rates = <24000000 0>;
 	};
+/*>2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]. */
 };
diff --git a/arch/arm64/boot/dts/qcom/msm8953-pinctrl.dtsi b/arch/arm64/boot/dts/qcom/msm8953-pinctrl.dtsi
index 908cdd0..7cbb7ed 100644
--- a/arch/arm64/boot/dts/qcom/msm8953-pinctrl.dtsi
+++ b/arch/arm64/boot/dts/qcom/msm8953-pinctrl.dtsi
@@ -118,7 +118,9 @@
 
 				config {
 					pins = "gpio31", "gpio32";
-					drive-strength = <2>; /* 2 MA */
+				/*<2019/05/10-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]Pull up the strength level when camera cannot detected sometimes */
+					drive-strength = <4>; /* 2 MA */
+				/*>2019/05/10-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][] */
 					bias-disable; /* No PULL */
 				};
 			};
@@ -229,12 +231,12 @@
 		cam_sensor_rear_vana: cam_sensor_rear_vdig {
 			/* VDIG */
 			mux {
-				pins = "gpio134";
+				pins = "gpio128";
 				function = "gpio";
 			};
 
 			config {
-				pins = "gpio134";
+				pins = "gpio128";
 				bias-disable; /* No PULL */
 				drive-strength = <2>; /* 2 MA */
 			};
@@ -243,12 +245,12 @@
 		cam_sensor_rear_vana_sleep: cam_sensor_rear_vdig_sleep {
 			/* VDIG */
 			mux {
-				pins = "gpio134";
+				pins = "gpio128";
 				function = "gpio";
 			};
 
 			config {
-				pins = "gpio134";
+				pins = "gpio128";
 				bias-disable; /* No PULL */
 				drive-strength = <2>; /* 2 MA */
 			};
@@ -265,7 +267,9 @@
 			config {
 				pins = "gpio27";
 				bias-disable; /* No PULL */
-				drive-strength = <2>; /* 2 MA */
+			/*<2019/05/10-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]Pull up the MIPI CLK strength level when camera cannot detected sometimes */
+				drive-strength = <8>; /* <2>; */ /* 2 MA */
+			/*>2019/05/10-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][] */
 			};
 		};
 
@@ -342,15 +346,98 @@
 			};
 		};
 
-		cam_sensor_front1_default: cam_sensor_front1_default {
-			/* RESET, STANDBY */
+/*<2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]Modified for new front camera device driver S5K4H7YX. */
+/*<2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]VOI control pin.PCBA EP0 is GPIO123;EP1 and above is GPIO130 */
+		cam_sensor_front1_vio_default: cam_sensor_front1_vio_default {
+			/* CAM IOVDD */
 			mux {
-				pins = "gpio129", "gpio130";
+			#if 1
+				pins = "gpio130";
+			#else /* PCBA EP0 */
+				pins = "gpio123";
+			#endif
 				function = "gpio";
 			};
 
 			config {
+			#if 1
+				pins = "gpio130";
+			#else /* PCBA EP0 */
+				pins = "gpio123";
+			#endif
+				bias-disable; /* No PULL */
+				drive-strength = <2>; /* 2 MA */
+			};
+		};
+
+		cam_sensor_front1_vio_sleep: cam_sensor_front1_vio_sleep {
+			/* CAM IOVDD */
+			mux {
+			#if 1
+				pins = "gpio130";
+			#else /* PCBA EP0 */
+				pins = "gpio123";
+			#endif
+				function = "gpio";
+			};
+
+			config {
+			#if 1
+				pins = "gpio130";
+			#else /* PCBA EP0 */
+				pins = "gpio123";
+			#endif
+				bias-disable; /* No PULL */
+				drive-strength = <2>; /* 2 MA */
+			};
+		};
+/*>2018/11/14-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][] */
+
+		cam_sensor_front1_vdig_default: cam_sensor_front1_vdig_default {
+			/* CAM DVDD */
+			mux {
+				pins = "gpio46";
+				function = "gpio";
+			};
+
+			config {
+				pins = "gpio46";
+				bias-disable; /* No PULL */
+				drive-strength = <2>; /* 2 MA */
+			};
+		};
+
+		cam_sensor_front1_vdig_sleep: cam_sensor_front1_vdig_sleep {
+			/* CAM DVDD */
+			mux {
+				pins = "gpio46";
+				function = "gpio";
+			};
+
+			config {
+				pins = "gpio46";
+				bias-disable; /* No PULL */
+				drive-strength = <2>; /* 2 MA */
+			};
+		};
+
+		cam_sensor_front1_default: cam_sensor_front1_default {
+			/* RESET, STANDBY */
+			mux {
+			#if 1
+				pins = "gpio129";   /* Only Reset,Non-standby GPIO */
+			#else /* Qualcomm default */
 				pins = "gpio129", "gpio130";
+			#endif
+				function = "gpio";
+			};
+
+			config {
+			#if 1
+				pins = "gpio129";   /* Only Reset,Non-standby GPIO */
+			#else /* Qualcomm default */
+				pins = "gpio129", "gpio130";
+			#endif
 				bias-disable; /* No PULL */
 				drive-strength = <2>; /* 2 MA */
 			};
@@ -359,16 +446,25 @@
 		cam_sensor_front1_sleep: cam_sensor_front1_sleep {
 			/* RESET, STANDBY */
 			mux {
+			#if 1
+				pins = "gpio129";   /* Only Reset,Non-standby GPIO */
+			#else /* Qualcomm default */
 				pins = "gpio129", "gpio130";
+			#endif
 				function = "gpio";
 			};
 
 			config {
+			#if 1
+				pins = "gpio129";   /* Only Reset,Non-standby GPIO */
+			#else /* Qualcomm default */
 				pins = "gpio129", "gpio130";
+			#endif
 				bias-disable; /* No PULL */
 				drive-strength = <2>; /* 2 MA */
 			};
 		};
+/*>2018/10/18-Yuting Shih.[FAIRPHONE][MISC][COMMON][CAMERA][][]. */
 
 		pmx_adv7533_int: pmx_adv7533_int {
 			adv7533_int_active: adv7533_int_active {
