Merge "input: touchscreen: st: enable touch firmware upgrade" (3da45a36) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/input/touchscreen/st/fts.c

+258 −68

Original line number	Diff line number	Diff line
		@@ -132,7 +132,7 @@ static void fts_interrupt_enable(struct fts_ts_info *info);
		static int fts_init_afterProbe(struct fts_ts_info *info);
		static int fts_mode_handler(struct fts_ts_info *info, int force);
		static int fts_command(struct fts_ts_info *info, unsigned char cmd);

		static int fts_chip_initialization(struct fts_ts_info *info);

		void touch_callback(unsigned int status)
		{
		@@ -2858,7 +2858,7 @@ static void fts_key_status_event_handler(struct fts_ts_info *info,
		"%s %sReceived event %02X %02X %02X %02X %02X %02X %02X %02X\n",
		tag, __func__, event[0], event[1], event[2], event[3],
		event[4], event[5], event[6], event[7]);
		/**
		/*
		* TODO: the customer should handle the events coming
		* from the keys according his needs (this is an example
		* that report only the single pressure of one key at time)
		@@ -2885,7 +2885,6 @@ static void fts_key_status_event_handler(struct fts_ts_info *info,
		logError(0,
		"%s %s:No valid Button ID or more than one key pressed!\n",
		tag, __func__);
		//goto done;
		return;
		}

		@@ -2893,9 +2892,6 @@ static void fts_key_status_event_handler(struct fts_ts_info *info,
		} else {
		logError(0, "%s %s: All buttons released!\n", tag, __func__);
		}
		//done:
		/* return fts_next_event(event); */
		//return;
		}
		#endif

		@@ -3229,6 +3225,219 @@ static void fts_event_handler(struct work_struct *work)
		fts_interrupt_enable(info);
		}

		static int cx_crc_check(void)
		{
		unsigned char regAdd1[3] = {FTS_CMD_HW_REG_R, ADDR_CRC_BYTE0,
		ADDR_CRC_BYTE1};
		unsigned char val[2];
		unsigned char crc_status;
		int res;
		u8 cmd[4] = { FTS_CMD_HW_REG_W, 0x00, 0x00, SYSTEM_RESET_VALUE };
		int event_to_search[2] = {(int)EVENTID_ERROR_EVENT,
		(int)EVENT_TYPE_CHECKSUM_ERROR};
		u8 readData[FIFO_EVENT_SIZE];

		/* read 2 bytes because the first one is a dummy byte! */
		res = fts_readCmd(regAdd1, sizeof(regAdd1), val, 2);
		if (res < OK) {
		logError(1, "%s %s Cannot read crc status ERROR %08X\n",
		tag, __func__, res);
		return res;
		}

		crc_status = val[1] & CRC_MASK;
		if (crc_status != OK) {
		logError(1, "%s %s CRC ERROR = %X\n",
		tag, __func__, crc_status);
		return crc_status;
		}


		logError(0, "%s %s: Verifying if Config CRC Error...\n", tag, __func__);
		u16ToU8_be(SYSTEM_RESET_ADDRESS, &cmd[1]);
		res = fts_writeCmd(cmd, 4);
		if (res < OK) {
		logError(1, "%s %s Cannot send system resest command:%08X\n",
		tag, __func__, res);
		return res;
		}
		setSystemResettedDown(1);
		setSystemResettedUp(1);
		res = pollForEvent(event_to_search, 2, readData, GENERAL_TIMEOUT);
		if (res < OK) {
		logError(0, "%s %s: No Config CRC Found!\n", tag, __func__);
		} else {
		if (readData[2] == CRC_CONFIG_SIGNATURE \|\|
		readData[2] == CRC_CONFIG) {
		logError(1, "%s:%s: CRC Error for config found! %02X\n",
		tag, __func__, readData[2]);
		return readData[2];
		}
		}

		return OK;
		}

		static void fts_fw_update_auto(struct work_struct *work)
		{
		u8 cmd[4] = { FTS_CMD_HW_REG_W, 0x00, 0x00, SYSTEM_RESET_VALUE };
		int event_to_search[2] = {(int)EVENTID_ERROR_EVENT,
		(int)EVENT_TYPE_CHECKSUM_ERROR};
		u8 readData[FIFO_EVENT_SIZE];
		int flag_init = 0;
		int retval = 0;
		int retval1 = 0;
		int ret;
		struct fts_ts_info *info;
		struct delayed_work *fwu_work = container_of(work,
		struct delayed_work, work);
		int crc_status = 0;
		int error = 0;

		info = container_of(fwu_work, struct fts_ts_info, fwu_work);
		logError(0, "%s Fw Auto Update is starting...\n", tag);

		/* check CRC status */
		ret = cx_crc_check();
		if (ret > OK && ftsInfo.u16_fwVer == 0x0000) {
		logError(1, "%s %s: CRC Error or NO FW!\n", tag, __func__);
		crc_status = 1;
		} else {
		crc_status = 0;
		logError(0, "%s %s:NO Error or can't read CRC register!\n",
		tag, __func__);
		}

		retval = flashProcedure(PATH_FILE_FW, crc_status, 1);
		if ((retval & ERROR_MEMH_READ) \|\| (retval & ERROR_FW_NO_UPDATE)) {
		logError(1, "%s %s: no firmware file or no newer firmware!\n",
		tag, __func__);
		goto NO_FIRMWARE_UPDATE;
		} else if ((retval & 0xFF000000) == ERROR_FLASH_PROCEDURE) {
		logError(1, "%s %s:firmware update retry! ERROR %08X\n",
		tag, __func__, retval);
		fts_chip_powercycle(info);

		retval1 = flashProcedure(PATH_FILE_FW, crc_status, 1);

		if ((retval1 & 0xFF000000) == ERROR_FLASH_PROCEDURE) {
		logError(1, "%s %s: update failed again! ERROR %08X\n",
		tag, __func__, retval1);
		logError(1, "%s Fw Auto Update Failed!\n", tag);
		}
		}

		logError(0, "%s %s: Verifying if CX CRC Error...\n",
		tag, __func__, ret);
		u16ToU8_be(SYSTEM_RESET_ADDRESS, &cmd[1]);
		ret = fts_writeCmd(cmd, 4);
		if (ret < OK) {
		logError(1, "%s %s Can't send reset command! ERROR %08X\n",
		tag, __func__, ret);
		} else {
		setSystemResettedDown(1);
		setSystemResettedUp(1);
		ret = pollForEvent(event_to_search, 2, readData,
		GENERAL_TIMEOUT);
		if (ret < OK) {
		logError(0, "%s %s: No CX CRC Found!\n", tag, __func__);
		} else {
		if (readData[2] == CRC_CX_MEMORY) {
		logError(1, "%s %s: CRC Error! ERROR:%02X\n\n",
		tag, __func__, readData[2]);

		flag_init = 1;
		}
		}
		}

		if (ftsInfo.u8_msScrConfigTuneVer != ftsInfo.u8_msScrCxmemTuneVer \|\|
		ftsInfo.u8_ssTchConfigTuneVer != ftsInfo.u8_ssTchCxmemTuneVer)
		ret = ERROR_GET_INIT_STATUS;
		else if (((ftsInfo.u32_mpPassFlag != INIT_MP)
		&& (ftsInfo.u32_mpPassFlag != INIT_FIELD)) \|\| flag_init == 1)
		ret = ERROR_GET_INIT_STATUS;
		else
		ret = OK;

		if (ret == ERROR_GET_INIT_STATUS) {
		error = fts_chip_initialization(info);
		if (error < OK)
		logError(1, "%s %s Can't initialize chip! ERROR %08X",
		tag, __func__, error);
		}

		NO_FIRMWARE_UPDATE:
		error = fts_init_afterProbe(info);
		if (error < OK)
		logError(1, "%s Can't initialize hardware device ERROR %08X\n",
		tag, error);

		logError(0, "%s Fw Auto Update Finished!\n", tag);
		}

		static int fts_chip_initialization(struct fts_ts_info *info)
		{
		int ret2 = 0;
		int retry;
		int initretrycnt = 0;
		struct TestToDo todoDefault;

		todoDefault.MutualRaw = 1;
		todoDefault.MutualRawGap = 1;
		todoDefault.MutualCx1 = 0;
		todoDefault.MutualCx2 = 0;
		todoDefault.MutualCx2Adj = 0;
		todoDefault.MutualCxTotal = 0;
		todoDefault.MutualCxTotalAdj = 0;

		todoDefault.MutualKeyRaw = 0;
		todoDefault.MutualKeyCx1 = 0;
		todoDefault.MutualKeyCx2 = 0;
		todoDefault.MutualKeyCxTotal = 0;

		todoDefault.SelfForceRaw = 0;
		todoDefault.SelfForceRawGap = 0;
		todoDefault.SelfForceIx1 = 0;
		todoDefault.SelfForceIx2 = 0;
		todoDefault.SelfForceIx2Adj = 0;
		todoDefault.SelfForceIxTotal = 0;
		todoDefault.SelfForceIxTotalAdj = 0;
		todoDefault.SelfForceCx1 = 0;
		todoDefault.SelfForceCx2 = 0;
		todoDefault.SelfForceCx2Adj = 0;
		todoDefault.SelfForceCxTotal = 0;
		todoDefault.SelfForceCxTotalAdj = 0;

		todoDefault.SelfSenseRaw = 1;
		todoDefault.SelfSenseRawGap = 0;
		todoDefault.SelfSenseIx1 = 0;
		todoDefault.SelfSenseIx2 = 0;
		todoDefault.SelfSenseIx2Adj = 0;
		todoDefault.SelfSenseIxTotal = 0;
		todoDefault.SelfSenseIxTotalAdj = 0;
		todoDefault.SelfSenseCx1 = 0;
		todoDefault.SelfSenseCx2 = 0;
		todoDefault.SelfSenseCx2Adj = 0;
		todoDefault.SelfSenseCxTotal = 0;
		todoDefault.SelfSenseCxTotalAdj = 0;

		for (retry = 0; retry <= INIT_FLAG_CNT; retry++) {
		ret2 = production_test_main(LIMITS_FILE, 1, 1, &todoDefault,
		INIT_FIELD);
		if (ret2 == OK)
		break;
		initretrycnt++;
		logError(1, "%s %s: cycle count = %04d - ERROR %08X\n",
		tag, __func__, initretrycnt, ret2);
		fts_chip_powercycle(info);
		}

		if (ret2 < OK)
		logError(1, "%s failed to initializate 3 times\n", tag);

		return ret2;
		}

		#ifdef FTS_USE_POLLING_MODE

		@@ -3338,7 +3547,7 @@ static int fts_init(struct fts_ts_info *info)
		logError(1, "%s Setting default Chip INFO!\n", tag);
		defaultChipInfo(0);
		} else {
		error = readChipInfo(0);/system reset OK/
		error = readChipInfo(0);
		if (error < OK) {
		logError(1, "%s Cannot read Chip Info!ERROR:%08X\n",
		tag, error);
		@@ -3359,7 +3568,7 @@ int fts_chip_powercycle(struct fts_ts_info *info)

		logError(0, "%s %s: Power Cycle Starting...\n", tag, __func__);

		/**
		/*
		* if IRQ pin is short with DVDD a call to
		* the ISR will triggered when the regulator is turned off
		*/
		@@ -3450,7 +3659,6 @@ int fts_chip_powercycle2(struct fts_ts_info *info, unsigned long sleep)
		if (info->bdata->reset_gpio != GPIO_NOT_DEFINED)
		gpio_set_value(info->bdata->reset_gpio, 0);

		/mdelay(sleep);/
		msleep(sleep);
		if (info->pwr_reg) {
		error = regulator_enable(info->bus_reg);
		@@ -3472,7 +3680,7 @@ int fts_chip_powercycle2(struct fts_ts_info *info, unsigned long sleep)


		if (info->bdata->reset_gpio != GPIO_NOT_DEFINED) {
		/**
		/*
		* time to wait before bring up the reset
		* gpio after the power up of the regulators
		*/
		@@ -3496,13 +3704,13 @@ static int fts_init_afterProbe(struct fts_ts_info *info)
		int error = 0;

		/* system reset */
		error = cleanUp(1);
		error = cleanUp(0);

		/* enable the features and the sensing */
		error \|= fts_mode_handler(info, 0);

		/* enable the interrupt */
		/* error \|= fts_enableInterrupt(); */
		error \|= fts_enableInterrupt();

		#if defined(CONFIG_FB_MSM)
		error \|= fb_register_client(&info->notifier);
		@@ -3517,7 +3725,7 @@ static int fts_init_afterProbe(struct fts_ts_info *info)
		return error;
		}

		/**
		/*
		* TODO: change this function according with the needs
		* of customer in terms of feature to enable/disable
		*/
		@@ -3535,15 +3743,17 @@ static int fts_mode_handler(struct fts_ts_info *info, int force)
		case 0:
		/* screen down */
		logError(0, "%s %s: Screen OFF...\n", tag, __func__);
		/**
		/*
		* do sense off in order to avoid the flooding
		* of the fifo with touch events if someone is
		* touching the panel during suspend
		*/
		logError(0, "%s %s: Sense OFF!\n", tag, __func__);
		/we need to use fts_command for speed reason/
		/(no need to check echo in this case and interrupt/
		/* can be enabled)*/
		/*
		*we need to use fts_command for speed reason
		* (no need to check echo in this case and interrupt
		* can be enabled)
		*/
		res \|= fts_command(info, FTS_CMD_MS_MT_SENSE_OFF);
		#ifdef PHONE_KEY
		logError(0, "%s %s: Key OFF!\n", tag, __func__);
		@@ -4153,8 +4363,6 @@ static int fts_probe(struct i2c_client *client,

		logError(0, "%s SET I2C Functionality and Dev INFO:\n", tag);
		openChannel(client);
		/* logError(1, "%s driver ver. %s (built on %s, %s)\n", tag,*/
		/* FTS_TS_DRV_VERSION, __DATE__, __TIME__);*/
		logError(0, "%s driver ver. %s (built on)\n", tag, FTS_TS_DRV_VERSION);

		if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		@@ -4214,8 +4422,6 @@ static int fts_probe(struct i2c_client *client,
		info->client->irq = gpio_to_irq(info->bdata->irq_gpio);

		logError(0, "%s SET Auto Fw Update:\n", tag);
		/info->fwu_workqueue =/
		/create_singlethread_workqueue("fts-fwu-queue");/
		info->fwu_workqueue = alloc_workqueue("fts-fwu-queue",
		WQ_UNBOUND\|WQ_HIGHPRI\|WQ_CPU_INTENSIVE, 1);
		if (!info->fwu_workqueue) {
		@@ -4223,10 +4429,10 @@ static int fts_probe(struct i2c_client *client,
		goto ProbeErrorExit_3;
		}

		INIT_DELAYED_WORK(&info->fwu_work, fts_fw_update_auto);

		logError(0, "%s SET Event Handler:\n", tag);
		/wake_lock_init(&info->wakelock, WAKE_LOCK_SUSPEND, "fts_tp");/
		wakeup_source_init(&info->wakeup_source, "fts_tp");
		/info->event_wq = create_singlethread_workqueue("fts-event-queue");/
		info->event_wq = alloc_workqueue("fts-event-queue",
		WQ_UNBOUND\|WQ_HIGHPRI\|WQ_CPU_INTENSIVE, 1);
		if (!info->event_wq) {
		@@ -4267,10 +4473,6 @@ static int fts_probe(struct i2c_client *client,

		input_mt_init_slots(info->input_dev, TOUCH_ID_MAX, INPUT_MT_DIRECT);

		/input_mt_init_slots(info->input_dev, TOUCH_ID_MAX);/

		/input_set_abs_params(info->input_dev,/
		/ABS_MT_TRACKING_ID, 0, FINGER_MAX, 0, 0);/
		input_set_abs_params(info->input_dev, ABS_MT_POSITION_X,
		X_AXIS_MIN, X_AXIS_MAX, 0, 0);
		input_set_abs_params(info->input_dev, ABS_MT_POSITION_Y,
		@@ -4279,8 +4481,8 @@ static int fts_probe(struct i2c_client *client,
		AREA_MIN, AREA_MAX, 0, 0);
		input_set_abs_params(info->input_dev, ABS_MT_TOUCH_MINOR,
		AREA_MIN, AREA_MAX, 0, 0);
		/input_set_abs_params(info->input_dev, ABS_MT_PRESSURE,/
		/PRESSURE_MIN, PRESSURE_MAX, 0, 0);/
		input_set_abs_params(info->input_dev, ABS_MT_PRESSURE,
		PRESSURE_MIN, PRESSURE_MAX, 0, 0);

		#ifdef PHONE_GESTURE
		input_set_capability(info->input_dev, EV_KEY, KEY_WAKEUP);
		@@ -4351,7 +4553,7 @@ static int fts_probe(struct i2c_client *client,
		goto ProbeErrorExit_6;
		}

		/**
		/*
		* init feature switches (by default all the features
		* are disable, if one feature want to be enabled from
		* the start, set the corresponding value to 1)
		@@ -4368,11 +4570,6 @@ static int fts_probe(struct i2c_client *client,

		info->resume_bit = 1;
		info->notifier = fts_noti_block;
		/error = fb_register_client(&info->notifier);/
		/if (error) {/
		/logError(1, "%s ERROR: register notifier failed!\n", tag);/
		/goto ProbeErrorExit_6;/
		/}/

		logError(0, "%s SET Device File Nodes:\n", tag);
		/* sysfs stuff */
		@@ -4429,14 +4626,8 @@ static int fts_probe(struct i2c_client *client,
		goto ProbeErrorExit_11;
		}
		#endif

		error = fts_init_afterProbe(info);
		if (error < OK) {
		logError(1,
		"%s Cannot initialize the hardware device ERROR %08X\n",
		tag, error);
		goto ProbeErrorExit_11;
		}
		queue_delayed_work(info->fwu_workqueue, &info->fwu_work,
		msecs_to_jiffies(EXP_FN_WORK_DELAY_MS));
		logError(1, "%s Probe Finished!\n", tag);
		return OK;

		@@ -4450,7 +4641,7 @@ static int fts_probe(struct i2c_client *client,
		ProbeErrorExit_10:
		#ifndef SCRIPTLESS
		sysfs_remove_group(&client->dev.kobj, &info->attrs);
		#endif /if fail before creating the/
		#endif
		#endif

		#ifdef SCRIPTLESS
		@@ -4476,7 +4667,6 @@ static int fts_probe(struct i2c_client *client,

		ProbeErrorExit_4:
		destroy_workqueue(info->fwu_workqueue);
		/* wake_lock_destroy(&info->wakelock); */
		wakeup_source_trash(&info->wakeup_source);

		ProbeErrorExit_3:

drivers/input/touchscreen/st/fts_lib/ftsError.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -254,7 +254,7 @@ int errorHandler(u8 *event, int size)
		logError(0, "%s %s: No Action taken!\n", tag, __func__);
		break;
		}
		logError(1, "%s %s: handling Finished! res = %08X\n",
		logError(0, "%s %s: handling Finished! res = %08X\n",
		tag, __func__, res);
		return res;
		}

drivers/input/touchscreen/st/fts_lib/ftsFlash.c

+24 −25

Original line number	Diff line number	Diff line
		@@ -139,8 +139,8 @@ int getFWdata(const char pathToFile, u8 data, int size, int from)
		memcpy(data, (u8 )FW_ARRAY_NAME, (*size));
		break;
		#endif
		case 2:
		logError(1, "%s Read FW from BIN file!\n", tag);
		default:
		logError(0, "%s Read FW from BIN file!\n", tag);
		dev = getDev();

		if (dev != NULL) {
		@@ -169,9 +169,6 @@ int getFWdata(const char pathToFile, u8 data, int size, int from)
		tag, __func__, ERROR_OP_NOT_ALLOW);
		return ERROR_OP_NOT_ALLOW;
		}
		break;
		default:
		return ERROR_OP_NOT_ALLOW;
		/* break; */
		}

		@@ -462,9 +459,9 @@ int flash_burn(Firmware fw, int force_burn, int keep_cx)

		if (!force_burn && (ftsInfo.u16_fwVer >= fw.fw_ver)
		&& (ftsInfo.u16_cfgId >= fw.config_id)) {
		logError(1, "Firmware in the chip newer");
		logError(1, " or equal to the one to burn! ");
		logError(1, "%s %s:NO UPDATE ERROR %02X\n",
		logError(0, "Firmware in the chip newer");
		logError(0, " or equal to the one to burn! ");
		logError(0, "%s %s:NO UPDATE ERROR %02X\n",
		tag, __func__, ERROR_FW_NO_UPDATE);
		return (ERROR_FW_NO_UPDATE \| ERROR_FLASH_BURN_FAILED);
		}
		@@ -682,56 +679,56 @@ int parseBinFile(u8 *data, int fw_size,
		}
		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		logError(1, "%s %s: Fw ID = %08X\n", tag, __func__, temp);
		logError(0, "%s %s: Fw ID = %08X\n", tag, __func__, temp);
		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->fw_ver = temp;
		logError(1, "%s %s:FILE Fw Version = %04X\n",
		logError(0, "%s %s:FILE Fw Version = %04X\n",
		tag, __func__, fwData->fw_ver);

		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->config_id = temp;
		logError(1, "%s %s:FILE Config ID = %04X\n",
		logError(0, "%s %s:FILE Config ID = %04X\n",
		tag, __func__, fwData->config_id);

		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		logError(1, "%s %s:Config Version = %08X\n",
		logError(0, "%s %s:Config Version = %08X\n",
		tag, __func__, temp);
		//skip reserved data
		index += FW_BYTES_ALIGN * 2;
		index += FW_BYTES_ALIGN;
		logError(1, "%s %s:File External Release = ",
		logError(0, "%s %s:File External Release = ",
		tag, __func__);
		for (i = 0; i < EXTERNAL_RELEASE_INFO_SIZE; i++) {
		fwData->externalRelease[i] = data[index++];
		logError(1, "%02X", fwData->externalRelease[i]);
		logError(0, "%02X", fwData->externalRelease[i]);
		}
		logError(1, "\n");
		logError(0, "\n");

		//index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->sec0_size = temp;
		logError(1, "%s %s:sec0_size = %08X (%d bytes)\n",
		logError(0, "%s %s:sec0_size = %08X (%d bytes)\n",
		tag, __func__, fwData->sec0_size, fwData->sec0_size);

		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->sec1_size = temp;
		logError(1, "%s %s:sec1_size = %08X (%d bytes)\n",
		logError(0, "%s %s:sec1_size = %08X (%d bytes)\n",
		tag, __func__, fwData->sec1_size, fwData->sec1_size);

		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->sec2_size = temp;
		logError(1, "%s %s:sec2_size = %08X (%d bytes)\n",
		logError(0, "%s %s:sec2_size = %08X (%d bytes)\n",
		tag, __func__, fwData->sec2_size, fwData->sec2_size);

		index += FW_BYTES_ALIGN;
		u8ToU32(&data[index], &temp);
		fwData->sec3_size = temp;
		logError(1, "%s %s:sec3_size = %08X (%d bytes)\n",
		logError(0, "%s %s:sec3_size = %08X (%d bytes)\n",
		tag, __func__, fwData->sec3_size, fwData->sec3_size);

		//skip header crc
		@@ -1021,15 +1018,17 @@ int flash_burn(struct Firmware fw, int force_burn, int keep_cx)
		{
		int res;

		if (!force_burn) {
		if (!force_burn && (ftsInfo.u16_fwVer >= fw.fw_ver)
		&& (ftsInfo.u16_cfgId >= fw.config_id)) {
		for (res = EXTERNAL_RELEASE_INFO_SIZE-1; res >= 0; res--) {
		if (fw.externalRelease[res] >
		ftsInfo.u8_extReleaseInfo[res])
		goto start;
		}
		logError(1, "Firmware in the chip newer or ");
		logError(1, "equal to the one to burn!");
		logError(1, "%s %s:NO UPDATE ERROR %02X\n",

		logError(0, "Firmware in the chip newer or ");
		logError(0, "equal to the one to burn!");
		logError(0, "%s %s:NO UPDATE ERROR %02X\n",
		tag, __func__, ERROR_FW_NO_UPDATE);
		return (ERROR_FW_NO_UPDATE \| ERROR_FLASH_BURN_FAILED);
		}
		@@ -1105,7 +1104,7 @@ int flash_burn(struct Firmware fw, int force_burn, int keep_cx)
		tag, ERROR_FLASH_BURN_FAILED);
		return (res \| ERROR_FLASH_BURN_FAILED);
		}
		logError(1, "%s load program DONE!\n", tag);
		logError(0, "%s load program DONE!\n", tag);
		logError(0, "%s 7) LOAD CONFIG:\n", tag);
		res = fillFlash(FLASH_ADDR_CONFIG,
		&(fw.data[fw.sec0_size]), fw.sec1_size);
		@@ -1114,7 +1113,7 @@ int flash_burn(struct Firmware fw, int force_burn, int keep_cx)
		tag, ERROR_FLASH_BURN_FAILED);
		return (res \| ERROR_FLASH_BURN_FAILED);
		}
		logError(1, "%s load config DONE!\n", tag);
		logError(0, "%s load config DONE!\n", tag);

		logError(0, "%s Flash burn COMPLETED!\n\n", tag);