samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d219ea822c89ffa2fa246e3caf45b64e81811154
android_kernel_samsung_sm86…/raydium/raydium_fw_update.c
Srikanth Katteboina 447a6d32fc touch: Request firmware from userspace 
Add upgrade mode with request firmware file from userspace.

Change-Id: Ifb4329d39eb8e80c11e6738d173870be94a63ea3
Signed-off-by: Srikanth Katteboina <quic_skattebo@quicinc.com>
2022-09-21 15:49:55 +05:30

1240 lines
33 KiB
C
Raw Blame History

/* raydium_fw_update.c
*
* Raydium TouchScreen driver.
*
* Copyright (c) 2021 Raydium tech Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/unistd.h>
#include <linux/uaccess.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/device.h>
#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
void raydium_mem_table_init(unsigned short u16_id)
{
LOGD(LOG_INFO, "[touch]Raydium table init 0x%x\n", u16_id);
g_rad_boot_image = kzalloc(RAD_BOOT_3X_SIZE, GFP_KERNEL);
g_rad_init_image = kzalloc(RAD_INIT_3X_SIZE, GFP_KERNEL);
g_rad_fw_image = kzalloc(RAD_FW_3X_SIZE, GFP_KERNEL);
g_rad_para_image = kzalloc(RAD_PARA_3X_SIZE + 4, GFP_KERNEL);
g_rad_testfw_image = kzalloc(RAD_TESTFW_3X_SIZE, GFP_KERNEL);
g_rad_testpara_image = kzalloc(RAD_PARA_3X_SIZE + 4,
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;
LOGD(LOG_INFO, "[touch]Raydium ID is 0x%x\n", g_raydium_ts->id);
switch (g_raydium_ts->id) {
case RAD_30:
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);
memcpy(g_rad_testfw_image, u8_rad_testfw_30, RAD_FW_3X_SIZE);
memcpy(g_rad_testfw_image + RAD_FW_3X_SIZE, u8_rad_testpara_30
, RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_para_image, u8_rad_para_30, RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_testpara_image, u8_rad_testpara_30,
RAD_PARA_3X_SIZE + 4);
break;
#if defined(FW_MAPPING_EN)
case RAD_31:
memcpy(g_rad_boot_image, u8_rad_boot_31, RAD_BOOT_3X_SIZE);
memcpy(g_rad_init_image, u8_rad_init_31, RAD_INIT_3X_SIZE);
memcpy(g_rad_fw_image, u8_rad_fw_31, RAD_FW_3X_SIZE);
memcpy(g_rad_testfw_image, u8_rad_testfw_31, RAD_FW_3X_SIZE);
memcpy(g_rad_testfw_image + RAD_FW_3X_SIZE, u8_rad_testpara_31,
RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_para_image, u8_rad_para_31, RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_testpara_image, u8_rad_testpara_31,
RAD_PARA_3X_SIZE + 4);
break;
#endif
default:
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);
memcpy(g_rad_testfw_image, u8_rad_testfw_30, RAD_FW_3X_SIZE);
memcpy(g_rad_testfw_image + RAD_FW_3X_SIZE, u8_rad_testpara_30
, RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_para_image, u8_rad_para_30, RAD_PARA_3X_SIZE + 4);
memcpy(g_rad_testpara_image, u8_rad_testpara_30,
RAD_PARA_3X_SIZE + 4);
g_raydium_ts->id = RAD_30;
i32_ret = SUCCESS;
break;
}
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;
i32_ret = 0;
switch (u8_type) {
case 0:
g_raydium_ts->id = RAD_30;
i32_ret = SUCCESS;
break;
#if defined(FW_MAPPING_EN)
case 1:
g_raydium_ts->id = RAD_31;
i32_ret = SUCCESS;
break;
#endif
}
return i32_ret;
}
#endif
unsigned int bits_reverse(unsigned int u32_num, unsigned int bit_num)
{
unsigned int reverse = 0, u32_i;
for (u32_i = 0; u32_i < bit_num; u32_i++) {
if (u32_num & (1 << u32_i))
reverse |= 1 << ((bit_num - 1) - u32_i);
}
return reverse;
}
unsigned int rc_crc32(const char *buf, unsigned int u32_len,
unsigned int u32_crc)
{
unsigned int u32_i;
unsigned char u8_flash_byte, u8_current, u8_j;
for (u32_i = 0; u32_i < u32_len; u32_i++) {
u8_flash_byte = buf[u32_i];
u8_current = (unsigned char)bits_reverse(u8_flash_byte, 8);
for (u8_j = 0; u8_j < 8; u8_j++) {
if ((u32_crc ^ u8_current) & 0x01)
u32_crc = (u32_crc >> 1) ^ 0xedb88320;
else
u32_crc >>= 1;
u8_current >>= 1;
}
}
return u32_crc;
}
int wait_fw_state(struct i2c_client *client, unsigned int u32_addr,
unsigned int u32_state, unsigned long u32_delay_us,
unsigned short u16_retry)
{
unsigned char u8_buf[4];
unsigned int u32_read_data;
unsigned int u32_min_delay_us = u32_delay_us - 500;
unsigned int u32_max_delay_us = u32_delay_us + 500;
do {
if (handle_i2c_pda_read(client, u32_addr, u8_buf, 4) == ERROR)
return ERROR;
memcpy(&u32_read_data, u8_buf, 4);
u16_retry--;
usleep_range(u32_min_delay_us, u32_max_delay_us);
} while ((u32_read_data != u32_state) && (u16_retry != 0));
if (u32_read_data != u32_state) {
LOGD(LOG_ERR, "[touch]confirm data error : 0x%x\n", u32_read_data);
return ERROR;
}
return SUCCESS;
}
int wait_irq_state(struct i2c_client *client, unsigned int retry_time,
unsigned int u32_delay_us)
{
int i32_ret = SUCCESS;
unsigned int u32_retry;
unsigned int u32_irq_value;
unsigned int u32_min_delay_us = u32_delay_us - 500;
unsigned int u32_max_delay_us = u32_delay_us + 500;
u32_retry = retry_time;
u32_irq_value = 0;
while (u32_retry != 0 && u32_irq_value != 1) {
u32_irq_value = gpio_get_value(g_raydium_ts->irq_gpio);
usleep_range(u32_min_delay_us, u32_max_delay_us);
u32_retry--;
}
LOGD(LOG_DEBUG, "[touch]irq_value is %d\n", u32_irq_value);
if (u32_retry == 0) {
LOGD(LOG_ERR, "[touch]%s, FW not ready, retry error!\n", __func__);
i32_ret = ERROR;
}
return i32_ret;
}
int raydium_do_software_reset(struct i2c_client *client)
{
int i32_ret = SUCCESS;
unsigned char u8_buf[4];
/*SW reset*/
g_u8_resetflag = true;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x01;
LOGD(LOG_INFO, "[touch]SW reset\n");
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BLKRST, u8_buf, 4);
if (i32_ret < 0)
goto exit;
msleep(35);
if (raydium_disable_i2c_deglitch() == ERROR) {
LOGD(LOG_ERR, "[touch] 1.disable_i2c_deglitch_3x NG!\r\n");
goto exit;
}
exit:
return i32_ret;
}
int set_skip_load(struct i2c_client *client)
{
int i32_ret = SUCCESS;
unsigned int u32_retry_time = 1000;
unsigned char u8_buf[4];
/*Skip load*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x10;
u8_buf[1] = 0x08;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTREG, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_do_software_reset(client);
if (i32_ret < 0)
LOGD(LOG_ERR, "[touch]%s, SW reset error!\n", __func__);
msleep(35);
i32_ret = wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0x82, 2000, u32_retry_time);
if (i32_ret < 0)
LOGD(LOG_ERR, "[touch]%s, wait_fw_state error!\n", __func__);
exit_upgrade:
return i32_ret;
}
/*check pram crc32*/
static int raydium_check_pram_crc_3X(struct i2c_client *client,
unsigned int u32_addr,
unsigned int u32_len)
{
int i32_ret = SUCCESS;
unsigned int u32_crc_addr = u32_addr + u32_len;
unsigned int u32_end_addr = u32_crc_addr - 1;
unsigned int u32_crc_result, u32_read_data;
unsigned int u32_retry = 1000;
unsigned char u8_buf[4], u8_retry = 3;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = (unsigned char)(u32_addr & 0xFF);
u8_buf[1] = (unsigned char)((u32_addr & 0xFF00) >> 8);
u8_buf[2] = (unsigned char)(u32_end_addr & 0xFF);
u8_buf[3] = (unsigned char)((u32_end_addr & 0xFF00) >> 8);
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRGCHKSUMADDR, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = handle_i2c_pda_read(client, RAYDIUM_PDA_PRGCHKSUMENG, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
u8_buf[3] |= 0x81;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRGCHKSUMENG, u8_buf, 4);
while (u8_buf[3] != 0x80 && u32_retry != 0) {
i32_ret = handle_i2c_pda_read(client, RAYDIUM_PDA_PRGCHKSUMENG, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
u32_retry--;
usleep_range(4500, 5500);
}
if (u32_retry == 0) {
LOGD(LOG_ERR, "[touch]%s, Cal CRC not ready, retry error!\n",
__func__);
i32_ret = ERROR;
}
i32_ret = handle_i2c_pda_read(client, RAYDIUM_PDA_PRGCHKSUMRESULT, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memcpy(&u32_crc_result, u8_buf, 4);
i32_ret = handle_i2c_pda_read(client, u32_crc_addr, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memcpy(&u32_read_data, u8_buf, 4);
while (u32_read_data != u32_crc_result && u8_retry > 0) {
i32_ret = handle_i2c_pda_read(client, RAYDIUM_PDA_PRGCHKSUMRESULT, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memcpy(&u32_crc_result, u8_buf, 4);
usleep_range(1500, 2500);
u8_retry--;
}
if (u32_read_data != u32_crc_result) {
LOGD(LOG_ERR, "[touch]check pram crc fail!!\n");
LOGD(LOG_ERR, "[touch]u32_read_data 0x%x\n", u32_read_data);
LOGD(LOG_ERR, "[touch]u32_crc_result 0x%x\n", u32_crc_result);
i32_ret = ERROR;
goto exit_upgrade;
} else if (u8_retry != 3) {
LOGD(LOG_DEBUG, "[touch]check pram crc pass!!\n");
LOGD(LOG_DEBUG, "[touch]u8_retry : %d\n", u8_retry);
LOGD(LOG_DEBUG, "[touch]u32_read_data 0x%x\n", u32_read_data);
LOGD(LOG_DEBUG, "[touch]u32_crc_result 0x%x\n", u32_crc_result);
i32_ret = ERROR;
goto exit_upgrade;
} else {
LOGD(LOG_DEBUG, "[touch]check pram crc pass!!\n");
LOGD(LOG_DEBUG, "[touch]u8_retry : %d\n", u8_retry);
LOGD(LOG_DEBUG, "[touch]u32_read_data 0x%x\n", u32_read_data);
LOGD(LOG_DEBUG, "[touch]u32_crc_result 0x%x\n", u32_crc_result);
i32_ret = SUCCESS;
}
exit_upgrade:
return i32_ret;
}
/* upgrade firmware with image file */
static int raydium_write_to_pram_3X(struct i2c_client *client,
unsigned int u32_fw_addr,
unsigned char u8_type)
{
int i32_ret = ERROR;
unsigned int u32_fw_size = 0;
unsigned char *p_u8_firmware_data = NULL;
unsigned int u32_write_offset = 0;
unsigned short u16_write_length = 0;
switch (u8_type) {
case RAYDIUM_INIT:
u32_fw_size = 0x80;
p_u8_firmware_data = g_rad_init_image;
break;
case RAYDIUM_BOOTLOADER:
u32_fw_size = 0x800;
p_u8_firmware_data = g_rad_boot_image;
break;
case RAYDIUM_PARA:
u32_fw_size = RAYDIUM_PDA_PARALENGTH;
p_u8_firmware_data = g_rad_para_image;
break;
case RAYDIUM_FIRMWARE:
u32_fw_size = RAYDIUM_PDA_FIRMWARELENGTH;
p_u8_firmware_data = g_rad_fw_image;
break;
case RAYDIUM_TEST_FW:
u32_fw_size = RAYDIUM_PDA_FIRMWARELENGTH + RAYDIUM_PDA_PARALENGTH;
p_u8_firmware_data = g_rad_testfw_image;
break;
default:
goto exit_upgrate;
}
u32_write_offset = 0;
while (u32_write_offset < u32_fw_size) {
if ((u32_write_offset + MAX_WRITE_PACKET_SIZE) < u32_fw_size)
u16_write_length = MAX_WRITE_PACKET_SIZE;
else
u16_write_length =
(unsigned short)(u32_fw_size - u32_write_offset);
i32_ret = handle_i2c_pda_write(
client,
(u32_fw_addr + u32_write_offset),
(p_u8_firmware_data + u32_write_offset),
u16_write_length);
if (i32_ret < 0)
goto exit_upgrate;
u32_write_offset += (unsigned long)u16_write_length;
}
u32_fw_addr += u32_write_offset;
exit_upgrate:
if (i32_ret < 0) {
LOGD(LOG_ERR, "[touch]upgrade failed\n");
return i32_ret;
}
LOGD(LOG_INFO, "[touch]upgrade success\n");
return SUCCESS;
}
unsigned char raydium_stop_mcu_3x(unsigned char u8_is_tp_reset)
{
unsigned short u16_time_out = 100;
unsigned int u32_read_data;
unsigned int u32_write = 0;
if (u8_is_tp_reset) {
gpio_set_value(g_raydium_ts->rst_gpio, 1);
gpio_set_value(g_raydium_ts->rst_gpio, 0);
msleep(RAYDIUM_RESET_INTERVAL_MSEC);
gpio_set_value(g_raydium_ts->rst_gpio, 1);
g_u8_i2c_mode = PDA2_MODE;
msleep(35);
if (raydium_disable_i2c_deglitch() == ERROR) {
LOGD(LOG_ERR, "[touch] disable_i2c_deglitch_3x NG!\r\n");
return ERROR;
}
}
LOGD(LOG_INFO, "[touch]%s\r\n", __func__);
u32_write = 0x30;
if (handle_i2c_pda_write(g_raydium_ts->client, RAYDIUM_PDA_BOOTREG
, (unsigned char *)&u32_write, 4) == ERROR) {
return ERROR;
}
u32_write = 0x01;
if (handle_i2c_pda_write(g_raydium_ts->client, RAYDIUM_PDA_BLKRST, (unsigned char *)&u32_write, 4
) == ERROR) {
return ERROR;
}
msleep(100);
if (raydium_disable_i2c_deglitch() == ERROR) {
LOGD(LOG_ERR, "[touch] disable_i2c_deglitch_3x NG!\r\n");
return ERROR;
}
LOGD(LOG_INFO, "[touch] stop_mcu 2\r\n");
if (handle_i2c_pda_read(g_raydium_ts->client, RAYDIUM_PDA_BOOTREG
, (unsigned char *)(&u32_read_data), 4) == ERROR) {
return ERROR;
}
while ((u32_read_data & 0x2000) == 0 && u16_time_out-- > 0) {
msleep(20);
if (handle_i2c_pda_read(g_raydium_ts->client, RAYDIUM_PDA_BOOTREG
, (unsigned char *)(&u32_read_data), 4) == ERROR) {
return ERROR;
}
}
LOGD(LOG_DEBUG, "[touch]Stop MCU=0x%X(0x%x)(%d)!!\r\n", u32_read_data, (u32_read_data & 0x2000), u16_time_out);
if ((u32_read_data & 0x2000) == 0)
return ERROR;
return SUCCESS;
}
/* Raydium fireware upgrade flow */
static int raydium_fw_upgrade_3X(struct i2c_client *client,
unsigned char u8_type,
unsigned char u8_check_crc)
{
int i32_ret = 0;
unsigned char u8_buf[4];
unsigned short u16_retry = 1000;
unsigned int u32_write = 0;
/*##### wait for boot-loader start #####*/
LOGD(LOG_INFO, "[touch]Type is %x\n", u8_type);
/*read Boot version*/
if (handle_i2c_pda_read(client, RAYDIUM_PDA_BOOTVERSION, u8_buf, 4) == ERROR)
return ERROR;
u32_write = (u8_buf[3] << 24) | (u8_buf[2] << 16) | (u8_buf[1] << 8) | u8_buf[0];
LOGD(LOG_INFO, "[touch]bootloader ver: 0x%x\r\n", u32_write);
if (u8_type != RAYDIUM_COMP) {
if (raydium_stop_mcu_3x(0) == ERROR)
return ERROR;
}
/*#start write data to PRAM*/
if (u8_type == RAYDIUM_FIRMWARE) {
/* unlock PRAM */
u8_buf[0] = (BOTLR_LOCK | COMP_LOCK | BASEL_LOCK | INICO_LOCK);
i32_ret = handle_i2c_pda_write(client,
RAYDIUM_PDA_PRAMLOCK,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_write_to_pram_3X(client, RAYDIUM_PDA_FIRMWAREADDR,
RAYDIUM_FIRMWARE);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_write_to_pram_3X(client, RAYDIUM_PDA_PARAADDR,
RAYDIUM_PARA);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_check_pram_crc_3X(client, RAYDIUM_PDA_FIRMWAREADDR,
RAYDIUM_PDA_CRCLENGTH);
if (i32_ret < 0)
goto exit_upgrade;
} else if (u8_type == RAYDIUM_BOOTLOADER) {
/* unlock PRAM */
u8_buf[0] = (BOTLR_LOCK | CONFIG_LOCK | COMP_LOCK | BASEL_LOCK | INICO_LOCK);
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMLOCK,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_write_to_pram_3X(client, 0x0800,
RAYDIUM_BOOTLOADER);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_write_to_pram_3X(client, 0x1000,
RAYDIUM_INIT);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_check_pram_crc_3X(client, 0x800,
0x7FC);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_check_pram_crc_3X(client, 0x1000,
0x7C);
if (i32_ret < 0)
goto exit_upgrade;
}
if (u8_type != RAYDIUM_COMP) {
/*release mcu hold*/
/*Skip load*/
i32_ret = set_skip_load(client);
if (i32_ret < 0)
LOGD(LOG_ERR, "[touch]%s, set skip_load error!\n", __func__);
/*#confirm in burn mode*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0x82,
2000, u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]Error, confirm in burn mode 1\n");
i32_ret = ERROR;
goto exit_upgrade;
}
}
/*#setting burning mode*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x01;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTENG1, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTENG2, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTENG3, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x01;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTMODE, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#confirm in burn mode*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0xFF,
2000, u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]bootloader wrt empty flash fail\r\n");
LOGD(LOG_ERR, "[touch]bootloader confirm in burn mode fail, Type=%d\r\n", u8_type);
i32_ret = ERROR;
goto exit_upgrade;
}
/* burning setting */
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x10;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTREG, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = u8_type;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMTYPE, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#set PRAM length (at 'h5000_090C)*/
if (u8_type == RAYDIUM_COMP) {
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x78;
u8_buf[1] = 0x7c;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMADDR,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
} else if (u8_type == RAYDIUM_FIRMWARE) {
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x00;
u8_buf[1] = 0x08;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMADDR,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
} else if (u8_type == RAYDIUM_BOOTLOADER) {
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x00;
u8_buf[1] = 0x08;
i32_ret = handle_i2c_pda_write(client, 0x50000908,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
}
/*#set sync_data(RAYDIUM_PDA_SYNCDATA) = 0 as WRT data finish*/
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_SYNCDATA, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#wait for sync_data finish*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTENG4, 168, 1000,
u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]Error, wait for input unlock key\n");
i32_ret = ERROR;
goto exit_upgrade;
}
/*#flash unlock key*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0xd7;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLKEY2, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0xa5;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLKEY1, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLKEY1, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0xa5;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLKEY1, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLKEY2, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_FLASHPRO, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#ready to burn flash*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0xa8;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTSTATE, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#clr sync_data(RAYDIUM_PDA_SYNCDATA) = 0 as finish*/
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_SYNCDATA, u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/* wait erase/wrt finish
* confirm burning_state result (gu8I2CSyncData.burning_state =
* BURNING_WRT_FLASH_FINISH at RAYDIUM_PDA_BOOTENG3)
*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTENG3, 6, 8000,
u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]Error, wait erase/wrt finish\n");
i32_ret = ERROR;
goto exit_upgrade;
}
LOGD(LOG_INFO, "[touch]Burn flash ok\n");
if (u8_check_crc) {
memset(u8_buf, 0, sizeof(u8_buf));
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_SYNCDATA,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#wait software reset finish*/
msleep(35);
/* wait sw reset finished RAYDIUM_PDA_BOOTSTATE = 0x82 */
if (wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0x82, 2000,
u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]Error, wait sw reset finished\n");
i32_ret = ERROR;
goto exit_upgrade;
}
/*#set test_mode = 1 start to check crc*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x01;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTMODE,
u8_buf, 4);
if (i32_ret < 0)
goto exit_upgrade;
/*#wait crc check finish*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTENG2, 2,
2000, u16_retry)
== ERROR) {
LOGD(LOG_ERR, "[touch]Error, wait crc check finish\n");
i32_ret = ERROR;
goto exit_upgrade;
}
/*#crc check pass RAYDIUM_PDA_BOOTSTATE = 0x81*/
if (wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0x81,
2000, u16_retry)
== ERROR) {
LOGD(LOG_ERR, "[touch]Error, confirm crc result\n");
i32_ret = ERROR;
goto exit_upgrade;
}
/*#run to next step*/
LOGD(LOG_INFO, "[touch]Type 0x%x => Pass\n", u8_type);
/* sw rest */
i32_ret = raydium_do_software_reset(client);
if (i32_ret < 0)
goto exit_upgrade;
g_u8_i2c_mode = PDA2_MODE;
LOGD(LOG_INFO, "[touch]Burn FW finish!\n");
}
exit_upgrade:
return i32_ret;
}
static int raydium_boot_upgrade_3X(struct i2c_client *client, unsigned char u8_is_tp_reset)
{
int i32_ret = SUCCESS;
unsigned char u8_buf[4];
unsigned short u16_retry = 1000;
/*set mcu hold*/
memset(u8_buf, 0, sizeof(u8_buf));
if (raydium_stop_mcu_3x(u8_is_tp_reset) == ERROR)
return ERROR;
/*WRT boot-loader to PRAM first*/
memset(u8_buf, 0, sizeof(u8_buf));
u8_buf[0] = 0x1F;
i32_ret = handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMLOCK, u8_buf, 4);
/*Sending bootloader*/
i32_ret = raydium_write_to_pram_3X(client, 0x0000,
RAYDIUM_BOOTLOADER);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_check_pram_crc_3X(client, 0x000, 0x7FC);
if (i32_ret < 0)
goto exit_upgrade;
/*Sending initial code*/
i32_ret = raydium_write_to_pram_3X(client, 0x7f80,
RAYDIUM_INIT);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_check_pram_crc_3X(client, 0x7F80, 0x7C);
if (i32_ret < 0)
goto exit_upgrade;
/*release mcu hold*/
/*Skip load*/
i32_ret = set_skip_load(client);
if (i32_ret < 0)
LOGD(LOG_ERR, "[touch]%s, set skip_load error!\n", __func__);
msleep(35);
if (wait_fw_state(client, RAYDIUM_PDA_BOOTSTATE, 0x82, 1000,
u16_retry) == ERROR) {
LOGD(LOG_ERR, "[touch]Error, wait for input unlock key\n");
i32_ret = ERROR;
goto exit_upgrade;
}
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)
{
int i32_ret = ERROR;
g_u8_resetflag = true;
if ((g_raydium_ts->id & 0x3000) != 0) {
LOGD(LOG_INFO, "[touch]start burn function!\n");
i32_ret = raydium_boot_upgrade_3X(client, 1);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_fw_upgrade_3X(client, RAYDIUM_BOOTLOADER, 0);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_fw_upgrade_3X(client, RAYDIUM_FIRMWARE, 1);
if (i32_ret < 0)
goto exit_upgrade;
} else {
LOGD(LOG_ERR, "[touch]FW ID ERROR!\n");
}
exit_upgrade:
return i32_ret;
}
int raydium_fw_update_init(unsigned short u16_i2c_data)
{
unsigned char u8_rbuffer[4];
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);
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;
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 0x%.8x\n", u32_fw_version);
g_raydium_ts->fw_version = u32_fw_version;
g_raydium_ts->id = ((u16_i2c_data & 0xF) << 12) |
((u8_rbuffer[0] & 0xF) << 8) | u8_rbuffer[1];
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) |
(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);
#endif
} else {
LOGD(LOG_ERR, "[touch]Mem setting failed, Stop fw upgrade!\n");
return i32_ret;
}
#ifdef FW_UPDATE_EN
#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
#endif
return i32_ret;
exit_error:
mutex_unlock(&g_raydium_ts->lock);
return i32_ret;
}
int raydium_burn_comp(struct i2c_client *client)
{
int i32_ret = ERROR;
i32_ret = raydium_boot_upgrade_3X(client, 0);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = set_skip_load(client);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = raydium_fw_upgrade_3X(client, RAYDIUM_COMP, 1);
if (i32_ret < 0)
goto exit_upgrade;
i32_ret = SUCCESS;
exit_upgrade:
return i32_ret;
}
int raydium_check_fw_ready(struct i2c_client *client)
{
int i32_ret = SUCCESS;
unsigned int u32_retry = 400;
unsigned char u8_buf[4];
u8_buf[1] = 0;
while (u8_buf[1] != 0x40 && u32_retry != 0) {
i32_ret = handle_i2c_pda_read(client, RAYDIUM_PDA_BOOTREG, u8_buf, 4);
if (i32_ret < 0)
goto exit;
u32_retry--;
usleep_range(4500, 5500);
}
if (u32_retry == 0) {
LOGD(LOG_ERR, "[touch]%s, FW not ready, retry error!\n", __func__);
i32_ret = ERROR;
} else {
LOGD(LOG_INFO, "[touch]%s, FW is ready!!\n", __func__);
usleep_range(4500, 5500);
}
exit:
return i32_ret;
}
/* upgrade firmware with image file */
int raydium_fw_upgrade_with_image(struct i2c_client *client,
unsigned int u32_fw_addr,
unsigned char u8_type)
{
int i32_ret = ERROR;
unsigned int u32_fw_size = 0;
unsigned char *p_u8_firmware_data = NULL;
unsigned int u32_write_offset = 0;
unsigned short u16_write_length = 0;
unsigned int u32_checksum = 0xFFFFFFFF;
switch (u8_type) {
case RAYDIUM_INIT:
u32_fw_size = 0x1fc;
p_u8_firmware_data = g_rad_init_image;
break;
case RAYDIUM_PARA:
u32_fw_size = 0x158;
p_u8_firmware_data = g_rad_para_image;
break;
case RAYDIUM_FIRMWARE:
u32_fw_size = 0x61fc;
p_u8_firmware_data = g_rad_fw_image;
break;
case RAYDIUM_BOOTLOADER:
u32_fw_size = 0x7FC;
p_u8_firmware_data = g_rad_boot_image;
break;
case RAYDIUM_TEST_FW:
u32_fw_size = 0x635C;
p_u8_firmware_data = g_rad_testfw_image;
break;
}
LOGD(LOG_DEBUG, "[touch]CRC 0x%08X\n",
*(unsigned int *)(p_u8_firmware_data + u32_fw_size));
u32_checksum = rc_crc32(p_u8_firmware_data,
u32_fw_size, u32_checksum);
u32_checksum = bits_reverse(u32_checksum, 32);
memcpy((p_u8_firmware_data + u32_fw_size), &u32_checksum, 4);
LOGD(LOG_DEBUG, "[touch]CRC result 0x%08X\n", u32_checksum);
u32_fw_size += 4;
u32_write_offset = 0;
while (u32_write_offset < u32_fw_size) {
if ((u32_write_offset + MAX_WRITE_PACKET_SIZE) < u32_fw_size)
u16_write_length = MAX_WRITE_PACKET_SIZE;
else
u16_write_length =
(unsigned short)
(u32_fw_size - u32_write_offset);
i32_ret = handle_i2c_pda_write(
client,
(u32_fw_addr + u32_write_offset),
(p_u8_firmware_data + u32_write_offset),
u16_write_length);
if (i32_ret < 0)
goto exit_upgrate;
u32_write_offset += (unsigned long)u16_write_length;
}
u32_fw_addr += u32_write_offset;
exit_upgrate:
if (i32_ret < 0) {
LOGD(LOG_ERR, "[touch]upgrade failed\n");
return i32_ret;
}
LOGD(LOG_INFO, "[touch]upgrade success\n");
return SUCCESS;
}
int raydium_load_test_fw(struct i2c_client *client)
{
unsigned int u32_read_data;
unsigned int u32_write = 0;
int i32_ret = ERROR;
/* set skip load & MCU hold then SW reset*/
/* sync_data:210;cmd_type:210h;ret_data:214h;test_mode:218h*/
if (raydium_stop_mcu_3x(1) == ERROR)
goto ERROR_EXIT;
/*WRT boot-loader to PRAM first*/
u32_write = 1;
if (handle_i2c_pda_write(client, RAYDIUM_PDA_PRAMLOCK, (unsigned char *)&u32_write, 4) == ERROR)
return ERROR;
/*Sending bootloader*/
i32_ret = raydium_write_to_pram_3X(client, 0x0000,
RAYDIUM_BOOTLOADER);
if (i32_ret < 0)
goto ERROR_EXIT;
i32_ret = raydium_check_pram_crc_3X(client, 0x000, 0x7FC);
if (i32_ret < 0)
goto ERROR_EXIT;
i32_ret = raydium_write_to_pram_3X(client, RAYDIUM_PDA_FIRMWAREADDR,
RAYDIUM_TEST_FW);
if (i32_ret < 0)
goto ERROR_EXIT;
i32_ret = raydium_check_pram_crc_3X(client, RAYDIUM_PDA_FIRMWAREADDR,
RAYDIUM_PDA_CRCLENGTH);
if (i32_ret < 0)
goto ERROR_EXIT;
/*clear CC & BL info*/
u32_write = 0x00000000;
if (handle_i2c_pda_write(client, 0x7F78, (unsigned char *)&u32_write, 4) == ERROR)
return ERROR;
/* set skip load & MCU hold then SW reset*/
/* sync_data:210;cmd_type:210h;ret_data:214h;test_mode:218h*/
/* read bootloader version*/
if (handle_i2c_pda_read(client, 0x80, (unsigned char *)(&u32_read_data), 4) == ERROR)
goto ERROR_EXIT;
LOGD(LOG_INFO, "[touch]Read bootloader ver=0x%x!!\r\n", u32_read_data);
u32_write = 0x0410;
if (handle_i2c_pda_write(client, RAYDIUM_PDA_BOOTREG, (unsigned char *)&u32_write, 4) == ERROR)
return ERROR;
if (handle_i2c_pda_read(client, RAYDIUM_PDA_BOOTREG, (unsigned char *)(&u32_read_data), 4) == ERROR)
goto ERROR_EXIT;
LOGD(LOG_DEBUG, "[touch]write MCU STATUS=0x%x!!\r\n", u32_read_data);
/*wait sw rst finish*/
u32_write = 1;
handle_i2c_pda_write(client, RAYDIUM_PDA_BLKRST, (unsigned char *)&u32_write, 4);
msleep(35);
if (handle_i2c_pda_read(client, RAYDIUM_PDA_BOOTREG, (unsigned char *)(&u32_read_data), 4) == ERROR)
goto ERROR_EXIT;
LOGD(LOG_INFO, "[touch]Read MCU STATUS=0x%x!!\r\n", u32_read_data);
if (handle_i2c_pda_read(client, 0x200006E4, (unsigned char *)(&u32_read_data), 4) == ERROR)
goto ERROR_EXIT;
LOGD(LOG_INFO, "[touch]Read test fw version=0x%x!!\r\n", u32_read_data);
return SUCCESS;
ERROR_EXIT:
return ERROR;
}
Reference in New Issue View Git Blame Copy Permalink