Linux的芯片驱动firmware自动升级之二：MELFAS的TP升级实例

最新推荐文章于 2024-01-22 08:51:13 发布
最新推荐文章于 2024-01-22 08:51:13 发布
阅读量874 收藏 2
点赞数
分类专栏： 固件升级
以MELFAS的MS6000芯片固件升级实例，说明一般的数组格式的IMAGE文件烧录的过程。该芯片需要PIN脚组合完成一定的时序并实现一组命令码进入烧录模式，并且在烧录模式下的I2C地址是0XFA（跟芯片正常工作时的地址0X40不同），在烧录完毕后进行复位并开始相应正常的TP操作。芯片大致的烧录了流程图如下：

         

实现代码如下：

（1）基础宏定义

[cpp] view plain copy print ?
  1. #define FIAMWARE_NAME   "MELFAS_W105.h"                     //数组格式IMAGE的名字 
  2. static unsigned char MS6000CTPM_FW[] =                      //以数组划分空间存储烧录映象 
  3. { 
  4.     #include FIAMWARE_NAME 
  5. }; 
  6. #define MS6000_ADDR_MODULE_REVISION                 0x98 
  7. #define MS6000_ADDR_FIRMWARE_VERSION                    0x9C        //烧录IMAGE中对应的特定字节地址 
  8. #define MS6000_TRANSFER_LENGTH                      64  //一次烧录的packet字节数 
  9.  
  10. /*ISP command*/ 
  11. #define MS6000_ISP_CMD_ERASE                    0x02 
  12. #define MS6000_ISP_CMD_ERASE_TIMING                 0x0F 
  13. #define MS6000_ISP_CMD_PROGRAM_FLASH                    0x03 
  14. #define MS6000_ISP_CMD_READ_FLASH                   0x04 
  15. #define MS6000_ISP_CMD_PROGRAM_TIMING               0x0F 
  16. #define MS6000_ISP_CMD_READ_INFORMATION             0x06 
  17. #define MS6000_ISP_CMD_RESET                            0x07 
  18.  
  19. #define MS6000_7BIT_DOWNLOAD_ADDR                   0x7D         
  20. #define MS6000_8BIT_DOWNLOAD_ADDR                   (MS6000_7BIT_DOWNLOAD_ADDR<<1) //linux的i2Cclient需8位地址  
  21. #define MS6000_I2C_SLAVE_READY_STATUS               0x55 
  22.  
  23. // MCS6000's responses 
  24. #define MS6000_ISP_ACK_ERASE_DONE                   0x82 
  25. #define MS6000_ISP_ACK_PREPARE_ERASE_DONE           0x8F 
  26. #define MS6000_I2C_ACK_PREPARE_PROGRAM              0x8F 
  27. #define MS6000_MDS_ACK_PROGRAM_FLASH                    0x83 
  28. #define MS6000_MDS_ACK_READ_FLASH                   0x84 
  29. #define MS6000_MDS_ACK_PROGRAM_INFORMATION          0x88 
  30. #define MS6000_MDS_ACK_PROGRAM_LOCKED               0xFE 
  31. #define MS6000_MDS_ACK_READ_LOCKED                  0xFE 
  32. #define MS6000_MDS_ACK_FAIL                         0xFE 
  33.  
  34. #define MS6000_ISP_ERASE_TIMING_VALUE_0             0x01 
  35. #define MS6000_ISP_ERASE_TIMING_VALUE_1             0xD4 
  36. #define MS6000_ISP_ERASE_TIMING_VALUE_2             0xC0 
  37.  
  38. #define MS6000_ISP_PROGRAM_TIMING_VALUE_0           0x00 
  39. #define MS6000_ISP_PROGRAM_TIMING_VALUE_1           0x00 
  40. #define MS6000_ISP_PROGRAM_TIMING_VALUE_2           0x78  
#define FIAMWARE_NAME 	"MELFAS_W105.h"    					//数组格式IMAGE的名字
static unsigned char MS6000CTPM_FW[] =						//以数组划分空间存储烧录映象
{
	#include FIAMWARE_NAME
};
#define MS6000_ADDR_MODULE_REVISION					0x98
#define MS6000_ADDR_FIRMWARE_VERSION					0x9C		//烧录IMAGE中对应的特定字节地址
#define MS6000_TRANSFER_LENGTH						64	//一次烧录的packet字节数

/*ISP command*/
#define MS6000_ISP_CMD_ERASE					0x02
#define MS6000_ISP_CMD_ERASE_TIMING					0x0F
#define MS6000_ISP_CMD_PROGRAM_FLASH					0x03
#define MS6000_ISP_CMD_READ_FLASH					0x04
#define MS6000_ISP_CMD_PROGRAM_TIMING				0x0F
#define MS6000_ISP_CMD_READ_INFORMATION				0x06
#define MS6000_ISP_CMD_RESET							0x07

#define MS6000_7BIT_DOWNLOAD_ADDR					0x7D		
#define MS6000_8BIT_DOWNLOAD_ADDR					(MS6000_7BIT_DOWNLOAD_ADDR<<1) //linux的i2Cclient需8位地址	
#define MS6000_I2C_SLAVE_READY_STATUS				0x55

// MCS6000's responses
#define MS6000_ISP_ACK_ERASE_DONE					0x82
#define MS6000_ISP_ACK_PREPARE_ERASE_DONE			0x8F
#define MS6000_I2C_ACK_PREPARE_PROGRAM				0x8F
#define MS6000_MDS_ACK_PROGRAM_FLASH					0x83
#define MS6000_MDS_ACK_READ_FLASH					0x84
#define MS6000_MDS_ACK_PROGRAM_INFORMATION			0x88
#define MS6000_MDS_ACK_PROGRAM_LOCKED				0xFE
#define MS6000_MDS_ACK_READ_LOCKED					0xFE
#define MS6000_MDS_ACK_FAIL							0xFE

#define MS6000_ISP_ERASE_TIMING_VALUE_0				0x01
#define MS6000_ISP_ERASE_TIMING_VALUE_1				0xD4
#define MS6000_ISP_ERASE_TIMING_VALUE_2				0xC0

#define MS6000_ISP_PROGRAM_TIMING_VALUE_0			0x00
#define MS6000_ISP_PROGRAM_TIMING_VALUE_1			0x00
#define MS6000_ISP_PROGRAM_TIMING_VALUE_2			0x78

（2）I2C烧写和读TP FLASH的函数
       注意：该芯片在烧录模式下的单字节读操作和写操作都不需要寄存器地址，只send芯片地址就行。里面用到的i2c_client->address已变换地址。

[cpp] view plain copy print ?
  1. static bool mfs_i2c_write_single_byte(unsigned char bufVal) 
  2. { 
  3.     int ret; 
  4.     unsigned char buf; 
  5.     buf = bufVal; 
  6.  
  7.     ret = i2c_master_send(i2c_client, &buf, 1); 
  8.     if(ret <= 0){ 
  9.                 printk("mfs_i2c_write_single_byte error line = %d, ret = %d\n", __LINE__, ret); 
  10.                 return false; 
  11.         } 
  12.     return true; 
  13. } 
  14. static bool mfs_i2c_read_single_byte(unsigned char *buf) 
  15. { 
  16.     int ret; 
  17.     ret = i2c_master_recv(i2c_client, buf, 1); 
  18.     if(ret <= 0){ 
  19.                 printk("mfs_i2c_read_single_byte error line = %d, ret = %d\n", __LINE__, ret); 
  20.                 return false; 
  21.         } 
  22.     return true; 
  23. } 
  24. static int mfs_i2c_read_flash(unsigned char *pBuffer,UINT16 nAddr_start,unsigned char cLength) 
  25. {                               //将nAddr_start开始的cLength个字节读到pBuffer所指的空间中 
  26.     int nRet = MS6000_RET_READ_FLASH_FAILED,i; 
  27.     BOOL bRet; 
  28.     unsigned char cmd[4],ucTemp; 
  29.  
  30. // Send Read Flash command   [ Read code - address high - address low - size ]   
  31.     cmd[0] = MS6000_ISP_CMD_READ_FLASH; 
  32.     cmd[1] = (UINT8)((nAddr_start >> 8 ) & 0xFF); 
  33.     cmd[2] = (UINT8)((nAddr_start      ) & 0xFF); 
  34.     cmd[3] = cLength; 
  35.  
  36.     for(i=0;i<4;i++){ 
  37.         bRet = mfs_i2c_write_single_byte(cmd[i]); 
  38.         udelay(15); 
  39.         if(bRet == FALSE) 
  40.             goto MS6000_I2C_READ_FLASH_FINISH; 
  41.     } 
  42. // Read 'Result of command' 
  43.     bRet = mfs_i2c_read_single_byte(&ucTemp); 
  44.     if( !bRet || ucTemp != MS6000_MDS_ACK_READ_FLASH){ 
  45.         goto MS6000_I2C_READ_FLASH_FINISH; 
  46.     } 
  47. // Read Data  [ pCmd[3] == Size ] 
  48.     for(i=0; i<(int)cmd[3]; i++){ 
  49.         udelay(100); 
  50.         bRet = mfs_i2c_read_single_byte(pBuffer++); 
  51.         if( bRet == FALSE && i!=(int)(cmd[3]-1) ) 
  52.             goto MS6000_I2C_READ_FLASH_FINISH; 
  53.     } 
  54.     nRet = MS6000_RET_SUCCESS; 
  55.      
  56. MS6000_I2C_READ_FLASH_FINISH: 
  57.     return nRet; 
  58. }  
static bool mfs_i2c_write_single_byte(unsigned char bufVal)
{
	int ret;
	unsigned char buf;
	buf = bufVal;

	ret = i2c_master_send(i2c_client, &buf, 1);
	if(ret <= 0){
        		printk("mfs_i2c_write_single_byte error line = %d, ret = %d\n", __LINE__, ret);
        		return false;
    	}
	return true;
}
static bool mfs_i2c_read_single_byte(unsigned char *buf)
{
	int ret;
	ret = i2c_master_recv(i2c_client, buf, 1);
	if(ret <= 0){
        		printk("mfs_i2c_read_single_byte error line = %d, ret = %d\n", __LINE__, ret);
        		return false;
    	}
	return true;
}
static int mfs_i2c_read_flash(unsigned char *pBuffer,UINT16 nAddr_start,unsigned char cLength)
{								//将nAddr_start开始的cLength个字节读到pBuffer所指的空间中
	int nRet = MS6000_RET_READ_FLASH_FAILED,i;
	BOOL bRet;
	unsigned char cmd[4],ucTemp;

// Send Read Flash command   [ Read code - address high - address low - size ]	
	cmd[0] = MS6000_ISP_CMD_READ_FLASH;
	cmd[1] = (UINT8)((nAddr_start >> 8 ) & 0xFF);
	cmd[2] = (UINT8)((nAddr_start      ) & 0xFF);
	cmd[3] = cLength;

	for(i=0;i<4;i++){
		bRet = mfs_i2c_write_single_byte(cmd[i]);
		udelay(15);
		if(bRet == FALSE)
			goto MS6000_I2C_READ_FLASH_FINISH;
	}
// Read 'Result of command'
	bRet = mfs_i2c_read_single_byte(&ucTemp);
	if( !bRet || ucTemp != MS6000_MDS_ACK_READ_FLASH){
		goto MS6000_I2C_READ_FLASH_FINISH;
	}
// Read Data  [ pCmd[3] == Size ]
	for(i=0; i<(int)cmd[3]; i++){
		udelay(100);
		bRet = mfs_i2c_read_single_byte(pBuffer++);
		if( bRet == FALSE && i!=(int)(cmd[3]-1) )
			goto MS6000_I2C_READ_FLASH_FINISH;
	}
	nRet = MS6000_RET_SUCCESS;
	
MS6000_I2C_READ_FLASH_FINISH:
	return nRet;
}

（3）进入download功能

[cpp] view plain copy print ?
  1. static void ms6000_write_download_mode_signal(void)                 //通过RESET脚和EINT脚发出一组组合电平 
  2. { 
  3.     int i; 
  4.     unsigned char enter_code[14] = { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1 }; 
  5.  
  6.     for(i=0; i<14; i++){ 
  7.         if(enter_code[i]){ 
  8.             mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);     
  9.             mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ONE); 
  10.         } 
  11.         else{ 
  12.             mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);    
  13.             mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO); 
  14.         } 
  15.         mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ONE); 
  16.         udelay(15); 
  17.         mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ZERO); 
  18.  
  19.         mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);    
  20.         mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO); 
  21.         udelay(100); 
  22.     } 
  23.     mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ONE); 
  24.     udelay(100); 
  25.     mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ONE); 
  26.     mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);     
  27. } 
  28. static int ms6000_enter_download_mode(void) 
  29. { 
  30.     bool bRet; 
  31.     int nRet = MS6000_RET_ENTER_DOWNLOAD_MODE_FAILED; 
  32.  
  33.     unsigned char cData=0; 
  34.  
  35.     hwPowerDown(MT65XX_POWER_LDO_VGP2, "TP");   //TKEY_VDD_SET_LOW();     
  36.  
  37.     mt_set_gpio_mode(GPIO_I2C0_SCA_PIN, GPIO_I2C0_SCA_PIN_M_GPIO); 
  38.     mt_set_gpio_dir(GPIO_I2C0_SCA_PIN, GPIO_DIR_OUT); 
  39.     mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ZERO);   
  40.     mt_set_gpio_mode(GPIO_I2C0_SDA_PIN, GPIO_I2C0_SDA_PIN_M_GPIO); 
  41.     mt_set_gpio_dir(GPIO_I2C0_SDA_PIN, GPIO_DIR_OUT); 
  42.     mt_set_gpio_out(GPIO_I2C0_SDA_PIN, GPIO_OUT_ZERO);      //I2C变GPIO功能 
  43.  
  44.     mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_GPIO); 
  45.     mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_OUT);           //TKEY_INTR_SET_OUTPUT(); 
  46.     mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO);      //TKEY_INTR_SET_LOW(); 
  47.  
  48.     mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO); 
  49.         mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);        //TKEY_RESETB_SET_OUTPUT(); 
  50.         mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);       //若干功能脚均需完成电平拉低的作用   
  51.  
  52.     mdelay(90);     //Delay for Stable VDD 
  53.  
  54.     hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");   //TKEY_VDD_SET_HIGH(); 
  55.     mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);        //TKEY_CE_SET_HIGH(); 
  56.     mt_set_gpio_out(GPIO_I2C0_SDA_PIN, GPIO_OUT_ONE);       //TKEY_I2C_SDA_SET_HIGH(); 
  57.     mdelay(25); 
  58.  
  59.     ms6000_write_download_mode_signal();                    //写命令码 
  60.     mt_set_gpio_mode(GPIO_I2C0_SCA_PIN, GPIO_I2C0_SCA_PIN_M_SCL); 
  61.     mt_set_gpio_mode(GPIO_I2C0_SDA_PIN, GPIO_I2C0_SDA_PIN_M_SDA);      //使能I2C的PIN脚恢复I2C功能 
  62.     mdelay(2); 
  63.     bRet = mfs_i2c_read_single_byte(&cData); 
  64.     if( bRet != TRUE || cData != MS6000_I2C_SLAVE_READY_STATUS ){ 
  65.         goto MS6000_ENTER_DOWNLOAD_MODE_FINISH; 
  66.     } 
  67.     else 
  68.         printk("respond from download mode commande is 0x55 \r\n");   //只有芯片状态返回0x55，才说明进入DOWNLOAD模式 
  69.     nRet = MS6000_RET_SUCCESS;  //Entering MDS ISP mode finished. 
  70.  
  71. MS6000_ENTER_DOWNLOAD_MODE_FINISH: 
  72.     return nRet; 
  73. }  
static void ms6000_write_download_mode_signal(void)					//通过RESET脚和EINT脚发出一组组合电平
{
	int i;
	unsigned char enter_code[14] = { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1 };

	for(i=0; i<14; i++){
		if(enter_code[i]){
			mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);	
			mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ONE);
		}
		else{
			mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);	
			mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO);
		}
		mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ONE);
		udelay(15);
		mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ZERO);

		mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);	
		mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO);
		udelay(100);
	}
	mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ONE);
	udelay(100);
	mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ONE);
	mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);	
}
static int ms6000_enter_download_mode(void)
{
	bool bRet;
	int nRet = MS6000_RET_ENTER_DOWNLOAD_MODE_FAILED;

	unsigned char cData=0;

	hwPowerDown(MT65XX_POWER_LDO_VGP2, "TP");	//TKEY_VDD_SET_LOW();    

	mt_set_gpio_mode(GPIO_I2C0_SCA_PIN, GPIO_I2C0_SCA_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_I2C0_SCA_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_I2C0_SCA_PIN, GPIO_OUT_ZERO);	
	mt_set_gpio_mode(GPIO_I2C0_SDA_PIN, GPIO_I2C0_SDA_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_I2C0_SDA_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_I2C0_SDA_PIN, GPIO_OUT_ZERO);		//I2C变GPIO功能

	mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_OUT);			//TKEY_INTR_SET_OUTPUT();
	mt_set_gpio_out(GPIO_CTP_EINT_PIN, GPIO_OUT_ZERO);		//TKEY_INTR_SET_LOW();

	mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
    	mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);		//TKEY_RESETB_SET_OUTPUT();
    	mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);		//若干功能脚均需完成电平拉低的作用	

	mdelay(90);		//Delay for Stable VDD

	hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");	//TKEY_VDD_SET_HIGH();
	mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);		//TKEY_CE_SET_HIGH();
	mt_set_gpio_out(GPIO_I2C0_SDA_PIN, GPIO_OUT_ONE);		//TKEY_I2C_SDA_SET_HIGH();
	mdelay(25);

	ms6000_write_download_mode_signal();					//写命令码
	mt_set_gpio_mode(GPIO_I2C0_SCA_PIN, GPIO_I2C0_SCA_PIN_M_SCL);
	mt_set_gpio_mode(GPIO_I2C0_SDA_PIN, GPIO_I2C0_SDA_PIN_M_SDA);      //使能I2C的PIN脚恢复I2C功能
	mdelay(2);
	bRet = mfs_i2c_read_single_byte(&cData);
	if( bRet != TRUE || cData != MS6000_I2C_SLAVE_READY_STATUS ){
		goto MS6000_ENTER_DOWNLOAD_MODE_FINISH;
	}
	else
		printk("respond from download mode commande is 0x55 \r\n");   //只有芯片状态返回0x55，才说明进入DOWNLOAD模式
	nRet = MS6000_RET_SUCCESS;	//Entering MDS ISP mode finished.

MS6000_ENTER_DOWNLOAD_MODE_FINISH:
	return nRet;
}

（4）芯片复位和TP FLASH擦除

[cpp] view plain copy print ?
  1. static void ms6000_reset_command(void)                  //不管是升级过程失败还是成功，最后都需要复位并使能芯片 
  2. { 
  3.     unsigned char buf; 
  4.     mdelay(1); 
  5.     buf = MS6000_ISP_CMD_RESET; 
  6.     if(mfs_i2c_write_single_byte(buf) == true) 
  7.         printk("mfs6000_reset_command reset success \r\n"); 
  8.     mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT); 
  9.     mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN); 
  10.     mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE); 
  11.     mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);           //恢复EINT的pin功能 
  12.     mdelay(180); 
  13. } 
  14. static unsigned char ms6000_GetLibVer(void)                     //取得新固件中的版本号，以便比较 
  15. { 
  16.      unsigned int sz; 
  17.         sz = sizeof(MS6000CTPM_FW); 
  18.  
  19.         if(sz > 2){ 
  20.                 return (MS6000CTPM_FW[157]-0x30);                   //版本号字节数据 
  21.         } 
  22.         else{ 
  23.                 return 0xff; 
  24.         } 
  25. } 
  26. static int ms6000_i2c_prepare_erase_flash(void) 
  27. { 
  28.     int   nRet = MS6000_RET_PREPARE_ERASE_FLASH_FAILED,i; 
  29.     BOOL bRet; 
  30.  
  31.     UINT8 i2c_buffer[4] = { MS6000_ISP_CMD_ERASE_TIMING, 
  32.                             MS6000_ISP_ERASE_TIMING_VALUE_0, 
  33.                             MS6000_ISP_ERASE_TIMING_VALUE_1, 
  34.                             MS6000_ISP_ERASE_TIMING_VALUE_2   }; 
  35.     UINT8   ucTemp; 
  36. // Send Erase Setting code 
  37.     for(i=0; i<4; i++){ 
  38.         bRet = mfs_i2c_write_single_byte(i2c_buffer[i]); 
  39.         if( !bRet ){ 
  40.             goto MS6000_I2C_PREPARE_ERASE_FLASH_FINISH; 
  41.         } 
  42.         udelay(15); 
  43.     } 
  44. // Read Result 
  45.     udelay(500); 
  46.     bRet = mfs_i2c_read_single_byte(&ucTemp); 
  47.     if( bRet && ucTemp == MS6000_ISP_ACK_PREPARE_ERASE_DONE ){ 
  48.         nRet = MS6000_RET_SUCCESS; 
  49.     } 
  50.  
  51. MS6000_I2C_PREPARE_ERASE_FLASH_FINISH: 
  52.     return nRet; 
  53. } 
  54. static int ms6000_i2c_erase_flash(void) 
  55. { 
  56.     int   nRet = MS6000_RET_ERASE_FLASH_FAILED,i; 
  57.     BOOL bRet; 
  58.     UINT8   i2c_buffer[1] = {   MS6000_ISP_CMD_ERASE}; 
  59.     UINT8   ucTemp; 
  60. // Send Erase code 
  61.     for(i=0; i<1; i++){ 
  62.         bRet = mfs_i2c_write_single_byte(i2c_buffer[i]); 
  63.         if( !bRet ) 
  64.             goto MS6000_I2C_ERASE_FLASH_FINISH; 
  65.         udelay(15); 
  66.     } 
  67. // Read Result 
  68.     mdelay(45); 
  69.     bRet = mfs_i2c_read_single_byte(&ucTemp); 
  70.     if( bRet && ucTemp == MS6000_ISP_ACK_ERASE_DONE ){ 
  71.         nRet = MS6000_RET_SUCCESS; 
  72.     } 
  73.  
  74. MS6000_I2C_ERASE_FLASH_FINISH:   
  75.     return nRet; 
  76. }  
static void ms6000_reset_command(void)					//不管是升级过程失败还是成功，最后都需要复位并使能芯片
{
	unsigned char buf;
	mdelay(1);
	buf = MS6000_ISP_CMD_RESET;
	if(mfs_i2c_write_single_byte(buf) == true)
		printk("mfs6000_reset_command reset success \r\n");
	mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
	mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
	mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);			//恢复EINT的pin功能
	mdelay(180);
}
static unsigned char ms6000_GetLibVer(void)						//取得新固件中的版本号，以便比较
{
	 unsigned int sz;
    	sz = sizeof(MS6000CTPM_FW);

    	if(sz > 2){
        		return (MS6000CTPM_FW[157]-0x30);					//版本号字节数据
    	}
    	else{
        		return 0xff;
    	}
}
static int ms6000_i2c_prepare_erase_flash(void)
{
	int   nRet = MS6000_RET_PREPARE_ERASE_FLASH_FAILED,i;
	BOOL bRet;

	UINT8 i2c_buffer[4] = {	MS6000_ISP_CMD_ERASE_TIMING,
	                        MS6000_ISP_ERASE_TIMING_VALUE_0,
	                        MS6000_ISP_ERASE_TIMING_VALUE_1,
	                        MS6000_ISP_ERASE_TIMING_VALUE_2   };
	UINT8	ucTemp;
// Send Erase Setting code
	for(i=0; i<4; i++){
		bRet = mfs_i2c_write_single_byte(i2c_buffer[i]);
		if( !bRet ){
			goto MS6000_I2C_PREPARE_ERASE_FLASH_FINISH;
		}
		udelay(15);
   	}
// Read Result
	udelay(500);
	bRet = mfs_i2c_read_single_byte(&ucTemp);
	if( bRet && ucTemp == MS6000_ISP_ACK_PREPARE_ERASE_DONE ){
		nRet = MS6000_RET_SUCCESS;
	}

MS6000_I2C_PREPARE_ERASE_FLASH_FINISH:
	return nRet;
}
static int ms6000_i2c_erase_flash(void)
{
	int   nRet = MS6000_RET_ERASE_FLASH_FAILED,i;
	BOOL bRet;
	UINT8 	i2c_buffer[1] = {	MS6000_ISP_CMD_ERASE};
	UINT8 	ucTemp;
// Send Erase code
	for(i=0; i<1; i++){
		bRet = mfs_i2c_write_single_byte(i2c_buffer[i]);
		if( !bRet )
			goto MS6000_I2C_ERASE_FLASH_FINISH;
		udelay(15);
   	}
// Read Result
	mdelay(45);
	bRet = mfs_i2c_read_single_byte(&ucTemp);
	if( bRet && ucTemp == MS6000_ISP_ACK_ERASE_DONE ){
		nRet = MS6000_RET_SUCCESS;
	}

MS6000_I2C_ERASE_FLASH_FINISH:	
	return nRet;
}

（5）预编程和编程函数，以及download映象主函数

[cpp] view plain copy print ?
  1. static int ms6000_i2c_prepare_program(void) 
  2. { 
  3.     int nRet = MS6000_RET_PREPARE_PROGRAM_FAILED,i; 
  4.     BOOL bRet; 
  5.     UINT8 i2c_buffer[4] = { MS6000_ISP_CMD_PROGRAM_TIMING, 
  6.                             MS6000_ISP_PROGRAM_TIMING_VALUE_0, 
  7.                             MS6000_ISP_PROGRAM_TIMING_VALUE_1, 
  8.                             MS6000_ISP_PROGRAM_TIMING_VALUE_2}; 
  9. //   Write Program timing information 
  10.     for(i=0; i<4; i++){ 
  11.         bRet = mfs_i2c_write_single_byte(i2c_buffer[i]); 
  12.         if( bRet == FALSE ) 
  13.             goto MS6000_I2C_PREPARE_PROGRAM_FINISH; 
  14.         udelay(15); 
  15.     } 
  16.     udelay(500); 
  17. //   Read command's result 
  18.     bRet = mfs_i2c_read_single_byte(&i2c_buffer[4]); 
  19.     if( bRet == FALSE || i2c_buffer[4] != MS6000_I2C_ACK_PREPARE_PROGRAM) 
  20.         goto MS6000_I2C_PREPARE_PROGRAM_FINISH; 
  21.     mdelay(100); 
  22.     nRet = MS6000_RET_SUCCESS; 
  23.  
  24. MS6000_I2C_PREPARE_PROGRAM_FINISH:   
  25.     return nRet; 
  26. } 
  27. static int ms6000_i2c_program_flash( UINT8 *pData, UINT16 nAddr_start, UINT8 cLength )  //FLASH one packet编程主函数 
  28. {                                   //参数是待编程数据，写入地址，待编程数据长度 
  29.     int nRet = MS6000_RET_PROGRAM_FLASH_FAILED; 
  30.     int     i,j; 
  31.     BOOL   bRet; 
  32.     UINT8    cData; 
  33.     UINT8    tmp; 
  34.     UINT8    cmd[4]; 
  35. // Send program code     
  36.     cmd[0] = MS6000_ISP_CMD_PROGRAM_FLASH; 
  37.     cmd[1] = (UINT8)((nAddr_start >> 8 ) & 0xFF); 
  38.     cmd[2] = (UINT8)((nAddr_start      ) & 0xFF); 
  39.     cmd[3] = cLength; 
  40.     for(i=0; i<4; i++){ 
  41.         bRet = mfs_i2c_write_single_byte(cmd[i]); 
  42.         udelay(15); 
  43.         if( bRet == FALSE ) 
  44.             goto MS6000_I2C_PROGRAM_FLASH_FINISH; 
  45.     } 
  46. // Check command result 
  47.     bRet = mfs_i2c_read_single_byte(&cData); 
  48.     if( bRet == FALSE || cData != MS6000_MDS_ACK_PROGRAM_FLASH ){ 
  49.         goto MS6000_I2C_PROGRAM_FLASH_FINISH; 
  50.     } 
  51. // Program Data 
  52.     udelay(150); 
  53.     for(i=0; i<(int)cmd[3]; i+=2){               //一次写入两个字节，先写高位，再写低位 
  54.         bRet = mfs_i2c_write_single_byte(pData[i+1]); 
  55.         if( bRet == FALSE ) 
  56.             goto MS6000_I2C_PROGRAM_FLASH_FINISH; 
  57.         udelay(100);              // Delay about 150us 
  58.         bRet = mfs_i2c_write_single_byte(pData[i]); 
  59.         udelay(150);                   // Delay about 150us 
  60.         if( bRet == FALSE ) 
  61.             goto MS6000_I2C_PROGRAM_FLASH_FINISH; 
  62.     } 
  63.     nRet = MS6000_RET_SUCCESS; 
  64.  
  65. MS6000_I2C_PROGRAM_FLASH_FINISH:     
  66.     return nRet; 
  67. } 
  68. static int ms6000_download(const UINT8 *pData, const UINT16 nLength )   //download主函数，参数是映象内存首地址及映象长度 
  69. { 
  70.     int i,nRet; 
  71.     unsigned char cLength,buffer[MS6000_TRANSFER_LENGTH]; 
  72.     uint16_t nStart_address=0; 
  73.     unsigned char *pOriginal_data; 
  74. //enter in download mode 
  75.     nRet = ms6000_enter_download_mode(); 
  76.     if(nRet != MS6000_RET_SUCCESS) 
  77.         goto MS6000_DOWNLOAD_FINISH; 
  78.  
  79.     mdelay(1); 
  80. // Erase Flash 
  81.     nRet = ms6000_i2c_prepare_erase_flash(); 
  82.     if(nRet !=MS6000_RET_SUCCESS){ 
  83.         goto MS6000_DOWNLOAD_FINISH;     
  84.     } 
  85.     mdelay(1); 
  86.     nRet = ms6000_i2c_erase_flash(); 
  87.     if(nRet !=MS6000_RET_SUCCESS) 
  88.         goto MS6000_DOWNLOAD_FINISH; 
  89.     mdelay(1); 
  90. // Verify erase 
  91.     nRet = mfs_i2c_read_flash( buffer, 0x00, 16 );      // Must be '0xFF' after erase 
  92.     if( nRet != MS6000_RET_SUCCESS ) 
  93.         goto MS6000_DOWNLOAD_FINISH; 
  94.     for(i=0; i<16; i++){ 
  95.         if( buffer[i] != 0xFF ){ 
  96.             nRet = MS6000_RET_ERASE_VERIFY_FAILED; 
  97.             goto MS6000_DOWNLOAD_FINISH; 
  98.         } 
  99.     } 
  100.     mdelay(1); 
  101. // Prepare for Program flash.    
  102.     nRet = ms6000_i2c_prepare_program(); 
  103.     if( nRet != MS6000_RET_SUCCESS ) 
  104.         goto MS6000_DOWNLOAD_FINISH; 
  105.     mdelay(1); 
  106. // Program flash 
  107. #if 1 
  108.     pOriginal_data  = (UINT8 *)pData;                   //保留原始首地址 
  109.     nStart_address = 0;                     //烧录起始地址 
  110.     cLength  = MS6000_TRANSFER_LENGTH;                  //一次烧录长度，64B 
  111.     for( nStart_address = 0; nStart_address < nLength; nStart_address+=cLength ){ 
  112.         if( ( nLength - nStart_address ) < MS6000_TRANSFER_LENGTH ){ 
  113.             cLength  = (UINT8)(nLength - nStart_address); 
  114.             cLength += (cLength%2);     // For odd length.最后不足64B的，补上1字节当偶数处理，因为以WORD烧录 
  115.         } 
  116.         nRet = ms6000_i2c_program_flash( pOriginal_data, nStart_address, cLength ); 
  117.         if( nRet != MS6000_RET_SUCCESS ){ 
  118.             goto MS6000_DOWNLOAD_FINISH; 
  119.         } 
  120.         pOriginal_data  += cLength; 
  121.         udelay(500); 
  122.         printk("#"); 
  123.     } 
  124.     printk("mfs6000 program finished \r\n"); 
  125. #endif   
  126. // Verify flash 
  127. #if 1 
  128.     pOriginal_data  = (UINT8 *) pData;                  //保留原始首地址 
  129.     nStart_address = 0; 
  130.     cLength  = MS6000_TRANSFER_LENGTH; 
  131.     for( nStart_address = 0; nStart_address < nLength; nStart_address+=cLength ){ 
  132.         if( ( nLength - nStart_address ) < MS6000_TRANSFER_LENGTH ){ 
  133.             cLength = (UINT8)(nLength - nStart_address); 
  134.             cLength += (cLength%2);             // For odd length. 
  135.         } 
  136.         // Read flash 
  137.         nRet = mfs_i2c_read_flash( buffer, nStart_address, cLength ); 
  138.         // Comparing 
  139.         for(i=0; i<(int)cLength; i++){ 
  140.             if( buffer[i] != pOriginal_data[i] ){       //如果读出的对应地址字节与原始对应地址数据不同 
  141.                 nRet = MS6000_RET_PROGRAM_VERIFY_FAILED; 
  142.                 goto MS6000_DOWNLOAD_FINISH; 
  143.             } 
  144.         } 
  145.         pOriginal_data += cLength; 
  146.         udelay(500); 
  147.         printk("*"); 
  148.     } 
  149.     printk("mfs6000 Verify finished \r\n"); 
  150. #endif   
  151.     nRet = MS6000_RET_SUCCESS; 
  152.  
  153. MS6000_DOWNLOAD_FINISH: 
  154.     ms6000_reset_command(); 
  155.     return nRet; 
  156. }  
static int ms6000_i2c_prepare_program(void)
{
	int nRet = MS6000_RET_PREPARE_PROGRAM_FAILED,i;
	BOOL bRet;
	UINT8 i2c_buffer[4] = { MS6000_ISP_CMD_PROGRAM_TIMING,
		                    MS6000_ISP_PROGRAM_TIMING_VALUE_0,
		                    MS6000_ISP_PROGRAM_TIMING_VALUE_1,
		                    MS6000_ISP_PROGRAM_TIMING_VALUE_2};
//   Write Program timing information
	for(i=0; i<4; i++){
		bRet = mfs_i2c_write_single_byte(i2c_buffer[i]);
		if( bRet == FALSE )
			goto MS6000_I2C_PREPARE_PROGRAM_FINISH;
		udelay(15);
	}
	udelay(500);
//   Read command's result
	bRet = mfs_i2c_read_single_byte(&i2c_buffer[4]);
	if( bRet == FALSE || i2c_buffer[4] != MS6000_I2C_ACK_PREPARE_PROGRAM)
		goto MS6000_I2C_PREPARE_PROGRAM_FINISH;
	mdelay(100);
	nRet = MS6000_RET_SUCCESS;

MS6000_I2C_PREPARE_PROGRAM_FINISH:	
	return nRet;
}
static int ms6000_i2c_program_flash( UINT8 *pData, UINT16 nAddr_start, UINT8 cLength )	//FLASH one packet编程主函数
{									//参数是待编程数据，写入地址，待编程数据长度
	int nRet = MS6000_RET_PROGRAM_FLASH_FAILED;
	int     i,j;
	BOOL   bRet;
	UINT8    cData;
	UINT8    tmp;
	UINT8    cmd[4];
// Send program code	
	cmd[0] = MS6000_ISP_CMD_PROGRAM_FLASH;
	cmd[1] = (UINT8)((nAddr_start >> 8 ) & 0xFF);
	cmd[2] = (UINT8)((nAddr_start      ) & 0xFF);
	cmd[3] = cLength;
	for(i=0; i<4; i++){
		bRet = mfs_i2c_write_single_byte(cmd[i]);
		udelay(15);
		if( bRet == FALSE )
			goto MS6000_I2C_PROGRAM_FLASH_FINISH;
	}
// Check command result
	bRet = mfs_i2c_read_single_byte(&cData);
	if( bRet == FALSE || cData != MS6000_MDS_ACK_PROGRAM_FLASH ){
		goto MS6000_I2C_PROGRAM_FLASH_FINISH;
	}
// Program Data
	udelay(150);
	for(i=0; i<(int)cmd[3]; i+=2){				//一次写入两个字节，先写高位，再写低位
		bRet = mfs_i2c_write_single_byte(pData[i+1]);
		if( bRet == FALSE )
			goto MS6000_I2C_PROGRAM_FLASH_FINISH;
		udelay(100);              // Delay about 150us
		bRet = mfs_i2c_write_single_byte(pData[i]);
		udelay(150);                   // Delay about 150us
		if( bRet == FALSE )
			goto MS6000_I2C_PROGRAM_FLASH_FINISH;
	}
	nRet = MS6000_RET_SUCCESS;

MS6000_I2C_PROGRAM_FLASH_FINISH:	
	return nRet;
}
static int ms6000_download(const UINT8 *pData, const UINT16 nLength )	//download主函数，参数是映象内存首地址及映象长度
{
	int i,nRet;
	unsigned char cLength,buffer[MS6000_TRANSFER_LENGTH];
	uint16_t nStart_address=0;
	unsigned char *pOriginal_data;
//enter in download mode
	nRet = ms6000_enter_download_mode();
	if(nRet != MS6000_RET_SUCCESS)
		goto MS6000_DOWNLOAD_FINISH;

	mdelay(1);
// Erase Flash
	nRet = ms6000_i2c_prepare_erase_flash();
	if(nRet !=MS6000_RET_SUCCESS){
		goto MS6000_DOWNLOAD_FINISH;	
	}
	mdelay(1);
	nRet = ms6000_i2c_erase_flash();
	if(nRet !=MS6000_RET_SUCCESS)
		goto MS6000_DOWNLOAD_FINISH;
	mdelay(1);
// Verify erase
	nRet = mfs_i2c_read_flash( buffer, 0x00, 16 );		// Must be '0xFF' after erase
	if( nRet != MS6000_RET_SUCCESS )
		goto MS6000_DOWNLOAD_FINISH;
	for(i=0; i<16; i++){
		if( buffer[i] != 0xFF ){
			nRet = MS6000_RET_ERASE_VERIFY_FAILED;
			goto MS6000_DOWNLOAD_FINISH;
		}
	}
	mdelay(1);
// Prepare for Program flash.	
	nRet = ms6000_i2c_prepare_program();
	if( nRet != MS6000_RET_SUCCESS )
		goto MS6000_DOWNLOAD_FINISH;
	mdelay(1);
// Program flash
#if 1
	pOriginal_data  = (UINT8 *)pData;					//保留原始首地址
	nStart_address = 0;						//烧录起始地址
	cLength  = MS6000_TRANSFER_LENGTH;					//一次烧录长度，64B
	for( nStart_address = 0; nStart_address < nLength; nStart_address+=cLength ){
		if( ( nLength - nStart_address ) < MS6000_TRANSFER_LENGTH ){
			cLength  = (UINT8)(nLength - nStart_address);
			cLength += (cLength%2);		// For odd length.最后不足64B的，补上1字节当偶数处理，因为以WORD烧录
		}
		nRet = ms6000_i2c_program_flash( pOriginal_data, nStart_address, cLength );
		if( nRet != MS6000_RET_SUCCESS ){
			goto MS6000_DOWNLOAD_FINISH;
		}
		pOriginal_data  += cLength;
		udelay(500);
		printk("#");
	}
	printk("mfs6000 program finished \r\n");
#endif	
// Verify flash
#if 1
	pOriginal_data  = (UINT8 *) pData;					//保留原始首地址
	nStart_address = 0;
	cLength  = MS6000_TRANSFER_LENGTH;
	for( nStart_address = 0; nStart_address < nLength; nStart_address+=cLength ){
		if( ( nLength - nStart_address ) < MS6000_TRANSFER_LENGTH ){
			cLength = (UINT8)(nLength - nStart_address);
			cLength += (cLength%2);				// For odd length.
		}
		// Read flash
		nRet = mfs_i2c_read_flash( buffer, nStart_address, cLength );
		// Comparing
		for(i=0; i<(int)cLength; i++){
			if( buffer[i] != pOriginal_data[i] ){		//如果读出的对应地址字节与原始对应地址数据不同
				nRet = MS6000_RET_PROGRAM_VERIFY_FAILED;
				goto MS6000_DOWNLOAD_FINISH;
			}
		}
		pOriginal_data += cLength;
		udelay(500);
		printk("*");
	}
	printk("mfs6000 Verify finished \r\n");
#endif	
	nRet = MS6000_RET_SUCCESS;

MS6000_DOWNLOAD_FINISH:
	ms6000_reset_command();
	return nRet;
}

（6）升级主函数，以及TP probe函数中的处理

[cpp] view plain copy print ?
  1. static int ms6000_firmware_upgrade() 
  2. { 
  3.     unsigned char NewFwVersion,OldFwVersion; 
  4.     uint16_t nBinary_length = 0; 
  5.     int nRead = 0; 
  6.     unsigned char *ptrBuff = NULL; 
  7.     int ret = MS6000_RET_FILE_ACCESS_FAILED; 
  8.  
  9.     if(mfs_i2c_read_single_reg(0x21,&OldFwVersion) == true){        //在此之前，TP的供电及初始化一定要有，否则读不出来 
  10.         NewFwVersion = ms6000_GetLibVer(); 
  11.         printk("mfs6000 OldFwVersion is %d,and  NewFwVersion is %d \r\n",OldFwVersion,NewFwVersion); 
  12.     } 
  13. i2c_client->addr = MS6000_8BIT_DOWNLOAD_ADDR;                    //变换成TP的升级I2C地址 
  14.     if(NewFwVersion != OldFwVersion){                   //如果版本号不同就升级 
  15.         ptrBuff = MS6000CTPM_FW; 
  16.         nBinary_length = sizeof(MS6000CTPM_FW); 
  17.          
  18. //download process 
  19.         printk("start download \r\n"); 
  20.         mtk_wdt_disable(); 
  21.         ret = ms6000_download(ptrBuff,nBinary_length); 
  22.         mtk_wdt_get_en_setting();                   //升级前后必须有禁止WDT和使能WDT的动作，否则易重启 
  23. //check process 
  24.     } 
  25.     else{                               //如果版本号相同则不动作 
  26.         printk("because of the same lib, update abort!\r\n"); 
  27.     } 
  28.  
  29.     return ret; 
  30. } 
  31. //如下是TPD_RROBE中的改动 
  32. { 
  33.     mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);                    //mask TP中断 
  34.     int UpResult; 
  35.     UpResult = ms6000_firmware_upgrade(); 
  36.     if(UpResult== MS6000_RET_SUCCESS) 
  37.         printk("MFS6000 DOWNLOAD SUCCESS \r\n"); 
  38.     else 
  39.         mfs6000_print_fail_result(UpResult); 
  40.     i2c_client->addr = MS6000_8BIT_I2CADDR;                  //恢复TP的正常操作时I2C地址 
  41.     mt_set_gpio_mode(GPIO_I2C0_SCA_PIN, GPIO_I2C0_SCA_PIN_M_SCL); 
  42.     mt_set_gpio_mode(GPIO_I2C0_SDA_PIN, GPIO_I2C0_SDA_PIN_M_SDA);           //恢复I2C功能脚 
  43.     mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);              //unmask TP中断 
  44. } 
sir_zeng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TP固件升级 一种request_firmwave方式
u012497906的专栏
12-18 1404
#define GOODIX_CONFIG_FILE_NAME "KLL_S50029_GT911_1060_Config_20191217_V67.cfg"static int gup_update_config(struct i2c_client *client){.... ret = request_firmware(&fw_cfg, GOODIX_CONFIG_FILE_NAME, &client->dev);....}报的错误：[32m[
linux-firmware-amdgpu:修复W
03-05
步骤2 cd linux-firmware-amdgpu/amdgpu 步骤3 cp -a . /lib/firmware/amdgpu/ cp -a . /lib/firmware/amdgpu/ 全部完成。 希望您的问题现在得到解决。 当前可用的固件 banksbanks_k_2_smc bonaire carrizo fiji...
UD LAN-401 信号处理模块
universaldata的博客
05-20 1117
UD LAN-401信号处理模块由双通道的A/D采样（最高支持250MSPS/14bit）、双通道D/A回放（最高支持1000MSPS/16bit）、FPGA+ARM（最高支持XC7Z045）及对外的通信接口（100M/1000M以太网、GPIO、CAN或串口等）组成。UD LAN-401外形尺寸为145.2mm（长）* 95 mm（宽）*20mm（厚），采用底面散热的方式，可满足工业级以上用户的要求。
【linux驱动】高通gt9xx TP固件升级
John_chaos的博客
10-16 1212
高通tp gt9xx固件升级的一次个记录理解： 固件一般是.h和bin文件，配置参数是cfg-data，要分开理解吗... 大概是固件是一次下发，后面配置固件参数这样，以前都是直接更新固件.h或者bin文件... in gtp_init_panel: { //读出到opr_buf[0]，与0xBE比较，判断固件是否有问题 ret = gtp_i2c_r...
c# mvvm模式获取当前窗口_运动控制卡应用开发教程之C#
weixin_39880328的博客
11-20 462
点击上方“正运动小助手”，随时关注新动态！今天，正运动小助手为大家分享一下应用C#开发一个多段连续插补的运动控制应用。我们主要从新建项目，添加函数库讲起，再了解PC函数使用，最后通过项目实战——连续插补运动例程讲解，来让大家熟悉它的项目开发。在正式学习之前，我们先了解一下正运动技术的运动控制卡ECI2418和ECI2618。这两款产品分别是4轴，6轴运动控制卡。ECI2418支持4轴脉冲...
RK3188上运行Ubuntu系统
热门推荐
Android/Linux的专栏
12-12 2万+
参照：http://androtab.info/radxa_rock/ubuntu/ 注意事项： 1.不要使用163源，163的源上不带 armhf架构。 2.Sdcard使用不了可以使用u盘，这都无所谓。 3.最后启动桌面时如果出现： xf86OpenConsole: Cannot open /dev/tty0 (No such file or directory) Device D
更新linux内核方法
渔潭的博客
01-11 3247
背景：买了块网件的A6210无线网卡，用的是mt7612u芯片，插到deepin下不能识别，ubuntu 18.04下同样不能识别，查过内核版本号，用的都是4.15的内核，去Github查了Linux内核仓库，确认4.15内核里没有mt7612u的驱动，Github上有几个其他的驱动试了试居然会编译出错，后来我查到OpenWRT的mt76驱动是支持mt7612u的，而且这个驱动在4.19的时候就被...
linux 嵌入式 远程升级,嵌入式设备远程固件升级方法与流程
weixin_29485887的博客
05-05 1258
本发明属于远程固件更新技术领域：，特别是一种基于STM32F407单片机的靶场测试数据采集设备的远程固件升级方法。背景技术：：固件(firmware)一般存储于设备中的电可擦除只读存储器EEPROM(ElectricallyErasableProgrammableROM)或FLASH芯片中，一般可由用户通过特定的刷新程序进行升级的程序。在目前的嵌入式领域应用中，对设备进行固件更新通常使用编程器(下...
Linux命令查看系统cpu,内存，网卡等硬件固件信息
lcdxshengpeng的博客
09-10 3941
1.查看CPU信息 命令lscpu [全称： list CPU] 我们可以看到一些cpu的架构的信息 例如： 架构：64位；CPU个数：6；CPU频率：800MHz; 1,2,3级缓存 等等 也可通过命令 dmidecode -t processor 查看 2.查看内存信息 cat /proc/meminfo 我们可以看到有总量，空余量，缓存大小等信息。如果想要只看到内存使用信息，可以使...
stm32、gd32等芯片固件升级思路
a113160的博客
03-28 1732
stm32的一些下载程序方式
芯课堂 | 通过ISP升级芯片固件方法及框架
SYNWIT的博客
01-22 1021
芯片在应用前，是一颗裸片，内部没有任何驱动或应用程序。芯片在贴上PCB板子后，会实现各种功能，这是时候会开发对应的驱动或者应用程序，在芯片上面运行的程序，一般称之为固件（Firmware）。
Linux驱动之设备树-学习笔记
07-31
> FDT: flattened device tree：开放设备树、扁平设备树（powerpc使用的设备树，起源的设备又称openFirmware）因为源于openFirmware所以设备树很多函数带有of字词 > dts：device tree source : 设备树源码 > dtsi：...
linux-firmware
02-13
linux-firmware-20210208.tar.gz linux firmware 20210208版本
drivers-linux-firmware：来自DebianUbuntuLinux固件驱动程序（更新）（04-10-2020）
01-28
drivers-linux-firmware：来自DebianUbuntuLinux固件驱动程序（更新）（04-10-2020）
linux-firmware-20191215
01-05
通常存储于硬件设备中的EEPROM或FLASH芯片中，一般可由用户通过特定的刷新程序进行升级的程序。一般来说，担任着一个硬件产品最基础最底层工作的软件才可以称之为固件。
Rain Water Algorithm雨水优化算法附matlab代码.zip
最新发布
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于springboot+vue的房屋租赁出售系统
04-26
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
杭电-[数据结构(c语言版)]复习题纲杭州电子科技大学.pdf
04-26
杭州电子科技大学，期末考试资料，计算机专业期末考试试卷，试卷及答案，数据结构。
年医院医生个人工作总结.docx
04-26
工作总结，新年计划，岗位总结，工作汇报，个人总结，述职报告，范文下载，新年总结，新建计划。
requires: linux-firmware >= 20190429-72
11-22
"requires: linux-firmware >= 20190429-72" 表示需要安装的软件包需要的最低版本为 20190429-72 的 linux-firmware。linux-firmware 是 Linux 系统所需的固件包，它包含了设备驱动程序和固件文件。在安装软件时，系统要求所需的 linux-firmware 版本必须大于等于 20190429-72 才能正常运行。如果当前系统中的 linux-firmware 版本小于 20190429-72，就需要先升级 linux-firmware 才能安装该软件。 要满足这个要求，可以通过更新系统软件包来升级 linux-firmware 到最新版本。可以使用系统自带的软件包管理工具，如 apt、yum 等来进行更新。具体命令可以根据不同的 Linux 发行版而有所不同。 另外，也可以手动下载并安装符合要求的 linux-firmware 软件包。可以在官方软件仓库或者第三方软件源中找到对应的 linux-firmware 包，并按照对应的安装说明进行安装。在安装完成后，再进行所需软件包的安装操作。 总之，满足"requires: linux-firmware >= 20190429-72" 这个要求，需要确保系统中的 linux-firmware 版本符合要求，通过软件包管理工具升级或手动安装适合的版本。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值