Merge "touch: Request firmware from userspace"

raydium/chip_raydium/f303_ic_test.c

@@ -501,7 +501,7 @@ STATUS burn_header_log_to_flash_3x(bool is_test_finish, bool is_in_header_data_p
 	DEBUGOUT("End burn header\r\n");
 	return SUCCESS;
 }
-
+#endif
 STATUS turn_on_flash_3x(void)
 {
 	unsigned int u32_read = 0;
@@ -1921,49 +1921,7 @@ STATUS load_test_fw_3x(void)
 
 	return u8_ret;
 }
-/*
- *	STATUS check_ext_flash_fw_version(void)
- *	{
- *	unsigned int u32_addr, u32_normal_fw_version, u32_test_fw_version;
- *	unsigned short u16_data_length = 0;
- *	u16_data_length = 4;
- *
- *
- *	//get normal FW version from ext flash//
- *	u32_addr = FLASH_NORMAL_FW_FW_VERSION_ADDR;
- *	if (read_flash_data(u32_addr, u16_data_length) == ERROR) {
- *		DEBUGOUT("Read Ext Flash NG [0x%08X] \r\n", u32_addr);
- *		return ERROR;
- *	}
- *	u32_normal_fw_version = 0;
- *	u32_normal_fw_version |= g_u8_data_buf[0];
- *	u32_normal_fw_version |= g_u8_data_buf[1] << 8;
- *	u32_normal_fw_version |= g_u8_data_buf[2] << 16;
- *	u32_normal_fw_version |= g_u8_data_buf[3] << 24;
- *	//DEBUGOUT("SPI Read_addr = 0x%08X, u16DataLength = %d \r\n", u32_normal_fw_version, u16_data_length);
- */
-	/* Test FW Version*/
-	u32_addr = FLASH_TEST_FW_FW_VERSION_ADDR;
-	if (read_flash_data(u32_addr, u16_data_length) == ERROR) {
-		DEBUGOUT("Read Ext Flash NG [0x%08X] \r\n", u32_addr);
-		return ERROR;
-	}
-	u32_test_fw_version = 0;
-	u32_test_fw_version |= g_u8_data_buf[0];
-	u32_test_fw_version |= g_u8_data_buf[1] << 8;
-	u32_test_fw_version |= g_u8_data_buf[2] << 16;
-	u32_test_fw_version |= g_u8_data_buf[3] << 24;
-	/*DEBUGOUT("SPI Read_addr = 0x%08X, u16DataLength = %d \r\n", u32_test_fw_version, u16_data_length);*/
-	if (g_st_test_para_resv.u32_normal_fw_version != u32_normal_fw_version
-	    || g_st_test_para_resv.u32_test_fw_version != u32_test_fw_version) {
-		DEBUGOUT("INI FW Version NG ,0x%08X VS 0x%08X \r\n", g_st_test_para_resv.u32_normal_fw_version, u32_normal_fw_version);
-		DEBUGOUT("INI Test FW Version NG ,0x%08X VS 0x%08X \r\n", g_st_test_para_resv.u32_test_fw_version, u32_test_fw_version);
-		return ERROR;
-	}
 
-	return SUCCESS;
-}
-#endif
 STATUS system_test_3x(void)
 {
 	STATUS u8_test_result = SUCCESS;

raydium/raydium_driver.c

@@ -55,6 +55,7 @@ struct raydium_slot_status {
 struct raydium_slot_status gst_slot[MAX_TOUCH_NUM * 2];
 struct raydium_slot_status gst_slot_init = {0xFF, 0, 0};
 
+static int raydium_enable_regulator(struct raydium_ts_data *cd, bool en);
 #if (defined(CONFIG_RM_SYSFS_DEBUG))
 const struct attribute_group raydium_attr_group;
 #endif /*end of CONFIG_RM_SYSFS_DEBUG*/
@@ -151,6 +152,14 @@ static int raydium_gpio_configure(bool on)
 				goto err_irq_gpio_req;
 			}
 
+			i32_err = gpio_direction_output(g_raydium_ts->rst_gpio, 0);
+			msleep(RAYDIUM_RESET_INTERVAL_10MSEC);
+			if (i32_err) {
+				LOGD(LOG_ERR,
+				     "[touch]set_direction for irq gpio failed\n");
+				goto err_rst_gpio_dir;
+			}
+
 			i32_err = gpio_direction_output(g_raydium_ts->rst_gpio, 1);
 			if (i32_err) {
 				LOGD(LOG_ERR,
@@ -861,7 +870,7 @@ static int raydium_create_sysfs(struct i2c_client *client)
 		sysfs_remove_group(&client->dev.kobj, &raydium_attr_group);
 		ret = -EIO;
 	} else {
-		LOGD(LOG_INFO, "[touch]create raydium sysfs attr_group successful\n");
+		LOGD(LOG_DEBUG, "[touch]create raydium sysfs attr_group successful\n");
 	}
 	return ret;
 }
@@ -961,7 +970,7 @@ static int raydium_touch_report(unsigned char *p_u8_buf,
 					gst_slot[u8_j].pt_id = u8_pt_id;
 					gst_slot[u8_j].need_update = 1;
 					gst_slot[u8_j].pt_report_offset = u8_i;
-					LOGD(LOG_INFO, "[touch]x:%d,y:%d\n",
+					LOGD(LOG_DEBUG, "[touch]x:%d,y:%d\n",
 					     p_u8_buf[POS_X_L + u8_offset] |
 					     p_u8_buf[POS_X_H + u8_offset] << 8,
 					     p_u8_buf[POS_Y_L + u8_offset] |
@@ -1123,7 +1132,7 @@ int raydium_read_touchdata(unsigned char *p_u8_tp_status,  unsigned char *p_u8_b
 			LOGD(LOG_ERR, "[touch]%s: write data failed: %d\n", __func__, i32_ret);
 			goto exit_error;
 		}
-		LOGD(LOG_WARNING, "[touch]%s -> report not updated.\n", __func__);
+		LOGD(LOG_DEBUG, "[touch]%s -> report not updated.\n", __func__);
 		goto exit_error;
 	}
 	u8_seq_no = p_u8_tp_status[POS_SEQ];
@@ -1284,7 +1293,7 @@ static irqreturn_t raydium_ts_interrupt(int irq, void *dev_id)
 			}
 			mutex_unlock(&g_raydium_ts->lock);
 
-			LOGD(LOG_WARNING, "[touch]work_pending\n");
+			LOGD(LOG_DEBUG, "[touch]work_pending\n");
 		}
 	}
 	return IRQ_HANDLED;
@@ -1321,7 +1330,7 @@ static int raydium_check_i2c_ready(unsigned short *u16_i2c_data)
 
 	*u16_i2c_data = u8_buf[3] << 8 | u8_buf[2];
 
-	LOGD(LOG_INFO, "[touch]RAD check I2C : 0x%02X%02X\n", u8_buf[3], u8_buf[2]);
+	LOGD(LOG_DEBUG, "[touch]RAD check I2C : 0x%02X%02X\n", u8_buf[3], u8_buf[2]);
 
 exit_error:
 	mutex_unlock(&g_raydium_ts->lock);
@@ -1332,6 +1341,7 @@ exit_error:
 static void raydium_ts_do_suspend(void)
 {
 	unsigned char u8_i = 0;
+	int rc;
 
 	if (g_u8_raw_data_type == 0)
 		g_u8_resetflag = false;
@@ -1340,6 +1350,14 @@ static void raydium_ts_do_suspend(void)
 		return;
 	}
 
+	rc = raydium_enable_regulator(g_raydium_ts, false);
+	if (rc < 0) {
+		LOGD(LOG_ERR, "[touch]%s:Failed to disable regulators:rc=%d\n",
+				__func__, rc);
+	}
+	LOGD(LOG_INFO, "[touch]%s:voltage regulators disabled:rc=%d\n",
+			__func__, rc);
+
 	/*#ifndef GESTURE_EN*/
 	raydium_irq_control(DISABLE);
 	/*#endif*/
@@ -1420,6 +1438,13 @@ static void raydium_ts_do_resume(void)
 		g_u8_checkflag = false;
 	}
 #endif
+	rc = raydium_enable_regulator(g_raydium_ts, true);
+	if (rc < 0) {
+			LOGD(LOG_ERR, "[touch]%s:Failed to disable regulators:rc=%d\n",
+					__func__, rc);
+	}
+	LOGD(LOG_INFO, "[touch]%s:voltage regulators disabled:rc=%d\n",
+			__func__, rc);
 	raydium_irq_control(ENABLE);
 #ifdef GESTURE_EN
 	if (device_may_wakeup(&g_raydium_ts->client->dev)) {
@@ -1459,9 +1484,9 @@ static int raydium_ts_open(struct input_dev *input_dev)
 {
 	//int i32_ret = 0;
 
-	LOGD(LOG_INFO, "[touch]%s()+\n", __func__);
+	LOGD(LOG_DEBUG, "[touch]%s()+\n", __func__);
 
-	LOGD(LOG_INFO, "[touch]ts->blank:%x\n", g_raydium_ts->blank);
+	LOGD(LOG_DEBUG, "[touch]ts->blank:%x\n", g_raydium_ts->blank);
 
 	if (g_raydium_ts->is_sleep == 1) {
 		mutex_lock(&g_raydium_ts->lock);
@@ -1807,7 +1832,7 @@ static int raydium_set_resolution(void)
 	u32_x = u8_buf[3] << 8 | u8_buf[2];
 	u32_y = u8_buf[1] << 8 | u8_buf[0];
 
-	LOGD(LOG_INFO, "[touch]RAD display info x:%d, y:%d\n", u32_x, u32_y);
+	LOGD(LOG_DEBUG, "[touch]RAD display info x:%d, y:%d\n", u32_x, u32_y);
 
 	if (u32_x > 100 && u32_y > 100 &&
 	    u32_x < 600 && u32_y < 600) {
@@ -1820,6 +1845,128 @@ exit_error:
 	return i32_ret;
 }
 
+static int raydium_get_regulator(struct raydium_ts_data *cd, bool get)
+{
+	int rc;
+
+	if (!get) {
+		rc = 0;
+		goto regulator_put;
+	}
+#ifdef VDD_ANALOG_ENABLE
+	cd->vdd = regulator_get(&cd->client->dev, "vdd");
+	if (IS_ERR(cd->vdd)) {
+		rc = PTR_ERR(cd->vdd);
+		dev_err(&cd->client->dev,
+			"Regulator get failed vdd rc=%d\n", rc);
+		goto regulator_put;
+	}
+#endif
+
+	cd->vcc_i2c = regulator_get(&cd->client->dev, "vcc_i2c");
+	if (IS_ERR(cd->vcc_i2c)) {
+		rc = PTR_ERR(cd->vcc_i2c);
+		dev_err(&cd->client->dev,
+			"Regulator get failed vcc_i2c rc=%d\n", rc);
+		goto regulator_put;
+	}
+
+	return 0;
+
+regulator_put:
+#ifdef VDD_ANALOG_ENABLE
+	if (!IS_ERR(cd->vdd)) {
+		dev_err(&cd->client->dev, "Regulator put vdd\n");
+		regulator_put(cd->vdd);
+		cd->vdd = NULL;
+	}
+#endif
+
+	if (!IS_ERR(cd->vcc_i2c)) {
+		dev_err(&cd->client->dev, "Regulator put vcc_i2c\n");
+		regulator_put(cd->vcc_i2c);
+		cd->vcc_i2c = NULL;
+	}
+
+	return rc;
+}
+
+static int raydium_enable_regulator(struct raydium_ts_data *cd, bool en)
+{
+	int rc;
+
+	if (!en) {
+		rc = 0;
+		goto disable_vcc_i2c_reg;
+	}
+#ifdef VDD_ANALOG_ENABLE
+	if (cd->vdd) {
+		if (regulator_count_voltages(cd->vdd) > 0) {
+			rc = regulator_set_voltage(cd->vdd, VTG_MIN_UV,
+						VTG_MAX_UV);
+			if (rc) {
+				dev_err(&cd->client->dev,
+					"Regulator set_vtg failed vdd rc=%d\n", rc);
+				goto exit;
+			}
+		}
+
+		rc = regulator_enable(cd->vdd);
+		if (rc) {
+			dev_err(&cd->client->dev,
+				"Regulator vdd enable failed rc=%d\n", rc);
+			goto exit;
+		}
+	}
+#endif
+
+	if (cd->vcc_i2c) {
+		if (regulator_count_voltages(cd->vcc_i2c) > 0) {
+			rc = regulator_set_voltage(cd->vcc_i2c, I2C_VTG_MIN_UV,
+							I2C_VTG_MAX_UV);
+			if (rc) {
+				dev_err(&cd->client->dev,
+					"Regulator set_vtg failed vcc_i2c rc=%d\n", rc);
+				goto disable_vdd_reg;
+			}
+		}
+
+		rc = regulator_enable(cd->vcc_i2c);
+		if (rc) {
+			dev_err(&cd->client->dev,
+				"Regulator vcc_i2c enable failed rc=%d\n", rc);
+			goto disable_vdd_reg;
+		}
+	}
+
+	return 0;
+
+disable_vcc_i2c_reg:
+	if (cd->vcc_i2c) {
+		if (regulator_count_voltages(cd->vcc_i2c) > 0)
+			regulator_set_voltage(cd->vcc_i2c, I2C_VTG_MIN_UV,
+						I2C_VTG_MAX_UV);
+
+		regulator_disable(cd->vcc_i2c);
+	}
+
+disable_vdd_reg:
+#ifdef VDD_ANALOG_ENABLE
+	if (cd->vdd) {
+		if (regulator_count_voltages(cd->vdd) > 0)
+			regulator_set_voltage(cd->vdd, VTG_MIN_UV,
+						VTG_MAX_UV);
+
+		regulator_disable(cd->vdd);
+	}
+#endif
+
+#ifdef VDD_ANALOG_ENABLE
+exit:
+#endif
+	return rc;
+}
+
 static int raydium_ts_probe(struct i2c_client *client,
 			    const struct i2c_device_id *id)
 {
@@ -1900,6 +2047,17 @@ static int raydium_ts_probe(struct i2c_client *client,
 	}
 #endif /*end of MSM_NEW_VER*/
 
+	ret = raydium_get_regulator(g_raydium_ts, true);
+	if (ret) {
+		dev_err(&client->dev, "Failed to get voltage regulators\n");
+		goto error_alloc_data;
+	}
+
+	ret = raydium_enable_regulator(g_raydium_ts, true);
+	if (ret) {
+		dev_err(&client->dev, "Failed to enable regulators: rc=%d\n", ret);
+		goto error_get_regulator;
+	}
 	ret = raydium_gpio_configure(true);
 	if (ret < 0) {
 		LOGD(LOG_ERR, "[touch]failed to configure the gpios\n");
@@ -1915,9 +2073,9 @@ static int raydium_ts_probe(struct i2c_client *client,
 
 	/*print touch i2c ready*/
 	ret = raydium_check_i2c_ready(&u16_i2c_data);
-	if (ret < 0) {
+	if (ret < 0 || (u16_i2c_data == 0)) {
 		LOGD(LOG_ERR, "[touch]Check I2C failed\n");
-		ret = -ENODEV;
+		ret = -EPROBE_DEFER;
 		goto exit_check_i2c;
 	}
 
@@ -1965,8 +2123,8 @@ static int raydium_ts_probe(struct i2c_client *client,
 
 	g_raydium_ts->workqueue = create_singlethread_workqueue("raydium_ts");
 	/*irq_gpio = 13 irqflags = 108*/
-	LOGD(LOG_INFO, "[touch]pdata irq : %d\n", g_raydium_ts->irq_gpio);
-	LOGD(LOG_INFO, "[touch]client irq : %d, pdata flags : %d\n",
+	LOGD(LOG_DEBUG, "[touch]pdata irq : %d\n", g_raydium_ts->irq_gpio);
+	LOGD(LOG_DEBUG, "[touch]client irq : %d, pdata flags : %d\n",
 	     client->irq, pdata->irqflags);
 
 	g_raydium_ts->irq = gpio_to_irq(pdata->irq_gpio);
@@ -1986,15 +2144,17 @@ static int raydium_ts_probe(struct i2c_client *client,
 
 	/*raydium_irq_control(ts, ENABLE);*/
 
-	LOGD(LOG_INFO, "[touch]RAD Touch driver ver :0x%X\n", g_u32_driver_version);
+	LOGD(LOG_DEBUG, "[touch]RAD Touch driver ver :0x%X\n", g_u32_driver_version);
 
 	/*fw update check*/
-	ret = raydium_fw_update_check(u16_i2c_data);
+	ret = raydium_fw_update_init(u16_i2c_data);
 	if (ret < 0) {
-		LOGD(LOG_ERR, "[touch]FW update check failed\n");
+		LOGD(LOG_ERR, "[touch]FW update init failed\n");
 		ret = -ENODEV;
 		goto exit_irq_request_failed;
 	}
+
+	LOGD(LOG_INFO, "[touch] probe: done\n");
 	return 0;
 
 exit_irq_request_failed:
@@ -2010,27 +2170,32 @@ exit_input_register_device_failed:
 
 exit_input_dev_alloc_failed:
 exit_check_i2c:
-	if (gpio_is_valid(pdata->reset_gpio))
-		gpio_free(pdata->reset_gpio);
-
-	if (gpio_is_valid(pdata->irq_gpio))
-		gpio_free(pdata->irq_gpio);
-
-err_gpio_req:
 #ifdef MSM_NEW_VER
 	if (g_raydium_ts->ts_pinctrl) {
 		if (IS_ERR_OR_NULL(g_raydium_ts->pinctrl_state_release)) {
 			devm_pinctrl_put(g_raydium_ts->ts_pinctrl);
 			g_raydium_ts->ts_pinctrl = NULL;
 		} else {
-			ret = pinctrl_select_state(g_raydium_ts->ts_pinctrl,
-						   g_raydium_ts->pinctrl_state_release);
-			if (ret)
-				LOGD(LOG_ERR, "[touch]pinctrl_select_state failed\n");
+			if (pinctrl_select_state(g_raydium_ts->ts_pinctrl,
+					g_raydium_ts->pinctrl_state_release))
+				LOGD(LOG_ERR,
+				    "[touch]pinctrl_select_state failed\n");
 		}
 	}
 #endif/*end of MSM_NEW_VER*/
 
+	if (gpio_is_valid(pdata->reset_gpio))
+		gpio_free(pdata->reset_gpio);
+
+	if (gpio_is_valid(pdata->irq_gpio))
+		gpio_free(pdata->irq_gpio);
+
+err_gpio_req:
+	raydium_get_regulator(g_raydium_ts, false);
+error_get_regulator:
+	raydium_get_regulator(g_raydium_ts, false);
+error_alloc_data:
+
 parse_dt_failed:
 exit_check_functionality_failed:
 	return ret;
@@ -2064,8 +2229,9 @@ static int raydium_ts_remove(struct i2c_client *client)
 	cancel_work_sync(&g_raydium_ts->work);
 	destroy_workqueue(g_raydium_ts->workqueue);
 
-
-	//kfree(g_raydium_ts);
+	raydium_enable_regulator(g_raydium_ts, false);
+	raydium_get_regulator(g_raydium_ts, false);
+	kfree(g_raydium_ts);
 
 	i2c_set_clientdata(client, NULL);
 	return 0;

raydium/raydium_driver.h

@@ -23,6 +23,10 @@
 #define COORDS_ARR_SIZE    4
 #define I2C_VTG_MIN_UV    1800000
 #define I2C_VTG_MAX_UV    1800000
+#ifdef VDD_ANALOG_ENABLE
+#define VTG_MIN_UV    2800000
+#define VTG_MAX_UV    2800000
+#endif
 #define RAD_MAIN_VERSION	0x01
 #define RAD_MINOR_VERSION	0x01
 #define RAD_CUSTOMER_VERSION	0x0100
@@ -33,6 +37,7 @@
 #define RAYDIUM_RESET_INTERVAL_MSEC   5
 #define RAYDIUM_RESET_RESTORE_USEC    200
 #define RAYDIUM_RESET_DELAY_MSEC      100
+#define RAYDIUM_RESET_INTERVAL_10MSEC   10
 
 /* I2C bus slave address(ID) */
 #define RAYDIUM_I2C_EID		(0x5A)
@@ -199,6 +204,7 @@
 #define RAD_FW_3X_SIZE			0x7300
 #define RAD_PARA_3X_SIZE		0x174
 #define RAD_TESTFW_3X_SIZE		(RAD_FW_3X_SIZE + RAD_PARA_3X_SIZE + 4)
+#define RAD_ALLFW_3X_SIZE		0xF170
 
 #define RAD_CMD_UPDATE_BIN		0x80
 #define RAD_CMD_UPDATE_END		0x81
@@ -228,7 +234,7 @@
 #define GESTURE_EN
 
 /* Enable FW update */
-/* #define FW_UPDATE_EN */
+#define FW_UPDATE_EN
 /* #define FW_MAPPING_EN */
 #define MSM_NEW_VER
 
@@ -238,6 +244,9 @@
 #define RAD_SELFTEST
 #define PARA_FW_VERSION_OFFSET	4
 
+#define ENABLE_FW_LOADER       1
+#define FW_NAME		"RM6D030.bin"
+
 #define PINCTRL_STATE_ACTIVE     "pmx_ts_active"
 #define PINCTRL_STATE_SUSPEND    "pmx_ts_suspend"
 #define PINCTRL_STATE_RELEASE    "pmx_ts_release"
@@ -275,6 +284,9 @@ struct raydium_ts_data {
 #endif /*end of CONFIG_FB*/
 
 	/*struct regulator *vdd;*/
+#ifdef VDD_ANALOG_ENABLE
+	struct regulator *vdd;
+#endif
 	struct regulator *vcc_i2c;
 	unsigned int fw_version;
 	unsigned short id;
@@ -391,7 +403,8 @@ extern int raydium_burn_comp(struct i2c_client *client);
 extern int raydium_burn_fw(struct i2c_client *client);
 
 extern int raydium_load_test_fw(struct i2c_client *client);
-extern int raydium_fw_update_check(unsigned short u16_i2c_data);
+extern int raydium_fw_update_init(unsigned short u16_i2c_data);
+extern int raydium_fw_update_check(unsigned int u32_check_version);
 extern int raydium_i2c_pda_set_address(unsigned int u32_address,
 				       unsigned char u8_mode);
 extern void raydium_mem_table_init(unsigned short u16_id);

raydium/raydium_fw_update.c

@@ -31,7 +31,9 @@
 #include <asm/traps.h>
 #include <linux/firmware.h>
 #include "raydium_driver.h"
+#if !ENABLE_FW_LOADER
 #include "rad_fw_image_30.h"
+#endif
 #if defined(FW_MAPPING_EN)
 #include "rad_fw_image_31.h"
 #endif
@@ -49,7 +51,79 @@ void raydium_mem_table_init(unsigned short u16_id)
 				       GFP_KERNEL);
 	g_u8_table_init = SUCCESS;
 }
+#if ENABLE_FW_LOADER
+static void raydium_cb(const struct firmware *fw, void *ctx)
+{
+	unsigned int u32_offset = 0;
+	unsigned int u32_image_version;
+#ifdef FW_UPDATE_EN
+	int i32_ret = ERROR;
+#endif
+	if (fw && (fw->size == RAD_ALLFW_3X_SIZE)) {
+		LOGD(LOG_DEBUG, "[touch]get firmware success size:%x\n", fw->size);
+
+		memcpy(g_rad_boot_image, fw->data, RAD_BOOT_3X_SIZE);
+		u32_offset += RAD_BOOT_3X_SIZE;
+		memcpy(g_rad_init_image, fw->data + u32_offset, RAD_INIT_3X_SIZE);
+		u32_offset += RAD_INIT_3X_SIZE;
+		memcpy(g_rad_fw_image, fw->data + u32_offset, RAD_FW_3X_SIZE);
+		u32_offset += RAD_FW_3X_SIZE;
+		memcpy(g_rad_para_image, fw->data + u32_offset, RAD_PARA_3X_SIZE + 4);
+		u32_offset += RAD_PARA_3X_SIZE + 4;
+		memcpy(g_rad_testfw_image, fw->data + u32_offset, RAD_FW_3X_SIZE);
+		u32_offset += RAD_FW_3X_SIZE;
+		memcpy(g_rad_testpara_image, fw->data + u32_offset, RAD_PARA_3X_SIZE + 4);
+
+		memcpy(g_rad_testfw_image + RAD_FW_3X_SIZE, g_rad_testpara_image
+		       , RAD_PARA_3X_SIZE + 4);
+		u32_image_version = (g_rad_para_image[PARA_FW_VERSION_OFFSET] << 24) |
+				    (g_rad_para_image[PARA_FW_VERSION_OFFSET + 1] << 16) |
+				    (g_rad_para_image[PARA_FW_VERSION_OFFSET + 2] << 8) |
+				    g_rad_para_image[PARA_FW_VERSION_OFFSET + 3];
+
+		LOGD(LOG_INFO, "[touch]RAD Image FW ver : 0x%x\n", u32_image_version);
+#ifdef FW_UPDATE_EN
+		i32_ret = raydium_fw_update_check(u32_image_version);
+		if (i32_ret < 0)
+			LOGD(LOG_ERR, "[touch]fw update fail!\n");
+#endif
+	} else {
+		LOGD(LOG_ERR, "[touch]get firmware file fail!\n");
+	}
+}
+int raydium_load_image(unsigned char *u8_buf, char *name)
+{
+	int i32_ret = SUCCESS;
+	struct i2c_client *client = g_raydium_ts->client;
+
+	i32_ret = request_firmware_nowait(THIS_MODULE, true, FW_NAME, &client->dev,
+					GFP_KERNEL, g_raydium_ts, raydium_cb);
+
+	if (i32_ret) {
+		LOGD(LOG_ERR, "[touch]failed to get firmware %s %d\n",
+					name, i32_ret);
+		return i32_ret;
+	}
+
+	return i32_ret;
+}
+int raydium_mem_table_setting(void)
+{
+	int i32_ret = SUCCESS;
+	char name[RAYDIUM_FW_BIN_PATH_LENGTH];
+
+	snprintf((char *)name, RAYDIUM_FW_BIN_PATH_LENGTH, "%s", FW_NAME);
+	LOGD(LOG_DEBUG, "[touch]firmware path %s\n", name);
+	i32_ret = raydium_load_image(g_rad_fw_image, name);
+
+	if (i32_ret < 0)
+		return ERROR;
+
+	i32_ret = SUCCESS;
+	return i32_ret;
+}
 
+#else
 int raydium_mem_table_setting(void)
 {
 	int i32_ret = SUCCESS;
@@ -81,7 +155,7 @@ int raydium_mem_table_setting(void)
 		break;
 #endif
 	default:
-		LOGD(LOG_WARNING, "[touch]mapping ic setting use default fw\n");
+		LOGD(LOG_DEBUG, "[touch]mapping ic setting use default fw\n");
 		memcpy(g_rad_boot_image, u8_rad_boot_30, RAD_BOOT_3X_SIZE);
 		memcpy(g_rad_init_image, u8_rad_init_30, RAD_INIT_3X_SIZE);
 		memcpy(g_rad_fw_image, u8_rad_fw_30, RAD_FW_3X_SIZE);
@@ -99,7 +173,9 @@ int raydium_mem_table_setting(void)
 	g_u8_table_setting = 0;
 	return i32_ret;
 }
+#endif
 
+#if !ENABLE_FW_LOADER
 int raydium_id_init(unsigned char u8_type)
 {
 	int i32_ret = ERROR;
@@ -119,7 +195,7 @@ int raydium_id_init(unsigned char u8_type)
 	}
 	return i32_ret;
 }
-
+#endif
 unsigned int bits_reverse(unsigned int u32_num, unsigned int bit_num)
 {
 	unsigned int reverse = 0, u32_i;
@@ -816,6 +892,53 @@ exit_upgrade:
 	return i32_ret;
 }
 
+int raydium_fw_update_check(unsigned int u32_check_version)
+{
+	int i32_ret = ERROR;
+	unsigned int u32_fw_version;
+	unsigned char u8_rbuffer[4];
+
+	if (g_raydium_ts->fw_version != u32_check_version) {
+
+		LOGD(LOG_INFO, "[touch]FW need update.\n");
+		g_u8_raydium_flag |= ENG_MODE;
+
+		i32_ret = raydium_burn_fw(g_raydium_ts->client);
+		if (i32_ret < 0) {
+			LOGD(LOG_ERR, "[touch]FW update fail:%d\n", i32_ret);
+			goto exit_error;
+		}
+		g_u8_raydium_flag &= ~ENG_MODE;
+
+		i32_ret = raydium_i2c_pda2_set_page(g_raydium_ts->client,
+						    g_raydium_ts->is_suspend,
+						    RAYDIUM_PDA2_PAGE_0);
+		if (i32_ret < 0)
+			goto exit_error;
+
+		i32_ret = raydium_i2c_pda2_read(g_raydium_ts->client,
+						RAYDIUM_PDA2_FW_VERSION_ADDR,
+						u8_rbuffer,
+						4);
+		if (i32_ret < 0)
+			goto exit_error;
+
+		u32_fw_version = (u8_rbuffer[0] << 24) |
+				 (u8_rbuffer[1] << 16) |
+				 (u8_rbuffer[2] << 8) |
+				 u8_rbuffer[3];
+		LOGD(LOG_INFO, "[touch]RAD FW ver is 0x%x\n",
+		     u32_fw_version);
+		g_raydium_ts->fw_version = u32_fw_version;
+	} else
+		LOGD(LOG_INFO, "[touch]FW is the latest version.\n");
+
+	i32_ret = SUCCESS;
+	return i32_ret;
+
+exit_error:
+	return i32_ret;
+}
 
 int raydium_burn_fw(struct i2c_client *client)
 {
@@ -843,12 +966,15 @@ exit_upgrade:
 	return i32_ret;
 }
 
-int raydium_fw_update_check(unsigned short u16_i2c_data)
+int raydium_fw_update_init(unsigned short u16_i2c_data)
 {
 
 	unsigned char u8_rbuffer[4];
 
-	unsigned int u32_fw_version, u32_image_version;
+	unsigned int u32_fw_version;
+#if !ENABLE_FW_LOADER
+	unsigned int u32_image_version;
+#endif
 	int i32_ret = ERROR;
 
 	mutex_lock(&g_raydium_ts->lock);
@@ -878,6 +1004,7 @@ int raydium_fw_update_check(unsigned short u16_i2c_data)
 
 	raydium_mem_table_init(g_raydium_ts->id);
 	if (raydium_mem_table_setting() == SUCCESS) {
+#if !ENABLE_FW_LOADER
 
 		u32_image_version = (g_rad_para_image[PARA_FW_VERSION_OFFSET] << 24) |
 				    (g_rad_para_image[PARA_FW_VERSION_OFFSET + 1] << 16) |
@@ -885,45 +1012,20 @@ int raydium_fw_update_check(unsigned short u16_i2c_data)
 				    g_rad_para_image[PARA_FW_VERSION_OFFSET + 3];
 
 		LOGD(LOG_INFO, "[touch]RAD Image FW ver : 0x%x\n", u32_image_version);
+#endif
 	} else {
 		LOGD(LOG_ERR, "[touch]Mem setting failed, Stop fw upgrade!\n");
-		return FAIL;
+		return i32_ret;
 	}
 
 #ifdef FW_UPDATE_EN
-	if (u32_fw_version != u32_image_version) {
-		LOGD(LOG_INFO, "[touch]FW need update.\n");
-		g_u8_raydium_flag |= ENG_MODE;
 
-		i32_ret = raydium_burn_fw(g_raydium_ts->client);
-		if (i32_ret < 0)
-			LOGD(LOG_ERR, "[touch]FW update fail:%d\n", i32_ret);
-
-		g_u8_raydium_flag &= ~ENG_MODE;
-		mutex_lock(&g_raydium_ts->lock);
-		i32_ret = raydium_i2c_pda2_set_page(g_raydium_ts->client,
-						    g_raydium_ts->is_suspend,
-						    RAYDIUM_PDA2_PAGE_0);
-		if (i32_ret < 0)
-			goto exit_error;
-
-		i32_ret = raydium_i2c_pda2_read(g_raydium_ts->client,
-						RAYDIUM_PDA2_FW_VERSION_ADDR,
-						u8_rbuffer,
-						4);
-		if (i32_ret < 0)
-			goto exit_error;
+#if !ENABLE_FW_LOADER
+	i32_ret = raydium_fw_update_check(u32_image_version);
+	if (i32_ret < 0)
+		LOGD(LOG_ERR, "[touch]fw update fail!\n");
+#endif
 
-		mutex_unlock(&g_raydium_ts->lock);
-		u32_fw_version = (u8_rbuffer[0] << 24) |
-				 (u8_rbuffer[1] << 16) |
-				 (u8_rbuffer[2] << 8) |
-				 u8_rbuffer[3];
-		LOGD(LOG_INFO, "[touch]RAD FW ver is 0x%x\n",
-		     u32_fw_version);
-		g_raydium_ts->fw_version = u32_fw_version;
-	} else
-		LOGD(LOG_INFO, "[touch]FW is the latest version.\n");
 #endif
 
 
@@ -1133,3 +1235,5 @@ ERROR_EXIT:
 	return ERROR;
 }
 
+
+

raydium/raydium_sysfs.c

@@ -536,6 +536,7 @@ static ssize_t raydium_mem_store(struct device *dev,
 				 struct device_attribute *attr,
 				 const char *p_i8_buf, size_t count)
 {
+#if !ENABLE_FW_LOADER
 	int i32_ret = 0;
 	unsigned char u8_type = 0;
 	unsigned int u32_image_version;
@@ -567,18 +568,18 @@ static ssize_t raydium_mem_store(struct device *dev,
 		kfree(g_rad_fw_image);
 		g_rad_fw_image = NULL;
 	}
-	if (g_rad_para_image) {
-		ree(g_rad_para_image);
-		g_rad_para_image = NULL;
-	}
+
+	kfree(g_rad_para_image);
+	g_rad_para_image = NULL;
+
 	if (g_rad_testfw_image) {
 		kfree(g_rad_testfw_image);
 		g_rad_testfw_image = NULL;
 	}
-	if (g_rad_testpara_image) {
-		free(g_rad_testpara_image);
-		g_rad_testpara_image = NULL;
-	}
+
+	kfree(g_rad_testpara_image);
+	g_rad_testpara_image = NULL;
+
 	if (!raydium_id_init(u8_type)) {
 		LOGD(LOG_ERR, "[touch]Set Raydium id failed!\n");
 		return count;
@@ -598,7 +599,7 @@ static ssize_t raydium_mem_store(struct device *dev,
 		kfree(g_rad_para_image);
 		g_rad_para_image = NULL;
 	}
-
+#endif
 	return count;
 }