在mtk移植个linux内核,移植linux内核红黑树

最新推荐文章于 2022-07-25 14:39:59 发布
最新推荐文章于 2022-07-25 14:39:59 发布
阅读量116 收藏
点赞数
文章标签： 在mtk移植个linux内核

头文件及定义

typedef struct _RB_NODE

{

unsigned longm_Color;

struct _RB_NODE *pRight;

struct _RB_NODE *pLeft;

}RB_NODE,*PRB_NODE;

typedef struct _RB_ROOT

{

struct _RB_NODE *pRootNode;

}RB_ROOT,*PRB_ROOT;

typedef struct _SYMBOL

{

RB_NODErb_node;

intstart;

intend;

intnamelen;

intbinding;

charname[0];

}SYMBOL,*PSYMBOL;

typedef struct _DSO

{

LIST_HEAD node;

RB_ROOT symbols;

char loaded;

char build_id[32];

const char *short_name;

char *long_name;

int long_name_len;

int short_name_len;

char name[0];

}DSO,*PDSO;

实现

/*

************************************************************************************************************************************************************************

* 常数与宏定义

************************************************************************************************************************************************************************

*/

#defineRB_RED0

#defineRB_BLACK1

#define _RB_PARENT(pc)    ((RB_NODE*)(pc&~3))

#define _RB_COLOR(pc)     ((pc)&1)

#define _RB_IS_BLACK(pc)  _RB_COLOR(pc)

#define _RB_IS_RED(pc)    (!_RB_COLOR(pc))

#define RB_COLOR(rb)       _RB_COLOR((rb)->m_Color)

#define RB_IS_RED(rb)      _RB_IS_RED((rb)->m_Color)

#define RB_IS_BLACK(rb)   _RB_IS_BLACK((rb)->m_Color)

#define RB_PARENT(r)   ((RB_NODE*)((r)->m_Color&~3))

#define RB_EMPTY_NODE(node)  ((node)->m_Color==(unsigned long)(node))

#defineRB_ENTRY(ptr, type, member) container_of(ptr,type,member)

/*

************************************************************************************************************************************************************************

* 数据类型定义

************************************************************************************************************************************************************************

*/

static inline void DummyPropagate(RB_NODE *pNode,RB_NODE *pStop){}

static inline void DummyCopy(RB_NODE *pOld,RB_NODE *pNew){}

static inline void DummyRotate(RB_NODE *pOld,RB_NODE *pNew){}

typedef struct _RB_AUGMENT_CALLBACKS

{

void (*Propagate)(RB_NODE *pNode,RB_NODE *pStop);

void (*Copy)(RB_NODE *pOld,RB_NODE *pNew);

void (*Rotate)(RB_NODE *pOld,RB_NODE *pNew);

}RB_AUGMENT_CALLBACKS,*PRB_AUGMENT_CALLBACKS;

/*

************************************************************************************************************************************************************************

* 全局变量

************************************************************************************************************************************************************************

*/

static const RB_AUGMENT_CALLBACKS DummyCallbacks=

{

DummyPropagate,DummyCopy,DummyRotate

};

static DSO sDsoInfo;

/*

****************************************************************************************************************************************************

* 函数定义

*****************************************************************************************************************************************************

*/

static inline void RbSetBlack(RB_NODE *pRbNode)

{

pRbNode->m_Color|=RB_BLACK;

}

static inline RB_NODE* RbGetParent(RB_NODE *pRbNode)

{

return (RB_NODE *)pRbNode->m_Color;

}

static inline void RbSetParent(RB_NODE *pRbNode,RB_NODE *pParent)

{

pRbNode->m_Color= RB_COLOR(pRbNode)|(unsigned long)pParent;

}

static inline void RbSetParentColor(RB_NODE *pRbNode,RB_NODE *pParent,int Color)

{

pRbNode->m_Color=(unsigned long)pParent|Color;

}

static inline void RbChangeChild(RB_NODE *pOldNode,RB_NODE *pNewNode,RB_NODE *pParent,RB_ROOT *pRbRoot)

{

if(pParent)

{

if(pParent->pLeft==pOldNode)

pParent->pLeft=pNewNode;

else

pParent->pRight=pNewNode;

}

else

{

pRbRoot->pRootNode=pNewNode;

}

}

static inline void RbRotateSetParents(RB_NODE *pOldNode,RB_NODE *pNewNode,RB_ROOT *pRbRoot,int Color)

{

RB_NODE *pParent=RB_PARENT(pOldNode);

pNewNode->m_Color=pOldNode->m_Color;

RbSetParentColor(pOldNode,pNewNode,Color);

RbChangeChild(pOldNode,pNewNode,pParent,pRbRoot);

}

static inline void RbInsertNode(RB_NODE *pNode,RB_ROOT *pRbRoot,void (*AugmentRotate)(RB_NODE *pOld,RB_NODE *pNew))

{

RB_NODE *pParent=RbGetParent(pNode),*pGparent,*pTmpNode;

while(1)

{

if(!pParent)

{

RbSetParentColor(pNode,NULL,RB_BLACK);

break;

}

else if(RB_IS_BLACK(pParent))

{

break;

}

pGparent=RbGetParent(pParent);

pTmpNode=pGparent->pRight;

if(pParent!=pTmpNode)

{

if(pTmpNode && RB_IS_RED(pTmpNode))

{

RbSetParentColor(pTmpNode,pGparent,RB_BLACK);

RbSetParentColor(pParent,pGparent,RB_BLACK);

pNode=pGparent;

pParent=RB_PARENT(pNode);

RbSetParentColor(pNode,pParent,RB_RED);

continue;

}

pTmpNode=pParent->pRight;

if(pNode==pTmpNode)

{

pParent->pRight=pTmpNode=pNode->pLeft;

pNode->pLeft=pParent;

if(pTmpNode)

RbSetParentColor(pTmpNode,pParent,RB_BLACK);

RbSetParentColor(pParent,pNode,RB_RED);

AugmentRotate(pParent,pNode);

pParent=pNode;

pTmpNode=pNode->pRight;

}

pGparent->pLeft=pTmpNode;

pParent->pRight=pGparent;

if(pTmpNode)

RbSetParentColor(pTmpNode,pGparent,RB_BLACK);

RbRotateSetParents(pGparent,pParent,pRbRoot,RB_RED);

AugmentRotate(pGparent,pParent);

break;

}

else

{

pTmpNode=pGparent->pLeft;

if(pTmpNode && RB_IS_RED(pTmpNode))

{

RbSetParentColor(pTmpNode,pGparent,RB_BLACK);

RbSetParentColor(pParent,pGparent,RB_BLACK);

pNode=pGparent;

pParent=RB_PARENT(pNode);

RbSetParentColor(pNode,pParent,RB_RED);

continue;

}

pTmpNode=pParent->pLeft;

if(pNode==pTmpNode)

{

pParent->pLeft=pTmpNode=pNode->pRight;

pNode->pRight=pParent;

if(pTmpNode)

RbSetParentColor(pTmpNode,pParent,RB_BLACK);

RbSetParentColor(pParent,pNode,RB_RED);

AugmentRotate(pParent,pNode);

pParent=pNode;

pTmpNode=pNode->pLeft;

}

pGparent->pRight=pTmpNode;

pParent->pLeft=pGparent;

if(pTmpNode)

RbSetParentColor(pTmpNode,pGparent,RB_BLACK);

RbRotateSetParents(pGparent,pParent,pRbRoot,RB_RED);

AugmentRotate(pGparent,pParent);

break;

}

}

}

static inline void RbEraseColor(RB_NODE *pParent,RB_ROOT *pRbRoot,void (*AugmentRotate)(RB_NODE *pOld,RB_NODE *pNew))

{

RB_NODE *pNode=NULL,*pSibling,*pTmpNode1,*pTmpNode2;

while(1)

{

pSibling=pParent->pRight;

if(pNode!=pSibling)

{

if(RB_IS_RED(pSibling))

{

pParent->pRight=pTmpNode1=pSibling->pLeft;

pSibling->pLeft=pParent;

RbSetParentColor(pTmpNode1,pParent,RB_BLACK);

RbRotateSetParents(pParent,pSibling,pRbRoot,RB_RED);

AugmentRotate(pParent,pSibling);

pSibling=pTmpNode1;

}

pTmpNode1=pSibling->pRight;

if(!pTmpNode1||RB_IS_BLACK(pTmpNode1))

{

pTmpNode2=pSibling->pLeft;

if(!pTmpNode2||RB_IS_BLACK(pTmpNode2))

{

RbSetParentColor(pSibling,pParent,RB_RED);

if(RB_IS_RED(pParent))

RbSetBlack(pParent);

else

{

pNode=pParent;

pParent=RB_PARENT(pNode);

if(pParent)

continue;

}

break;

}

pSibling->pLeft=pTmpNode1=pTmpNode2->pRight;

pTmpNode2->pRight=pSibling;

pParent->pRight=pTmpNode2;

if(pTmpNode1)

RbSetParentColor(pTmpNode1,pSibling,RB_BLACK);

AugmentRotate(pSibling,pTmpNode2);

pTmpNode1=pSibling;

pSibling=pTmpNode2;

}

pParent->pRight=pTmpNode2=pSibling->pLeft;

pSibling->pLeft=pParent;

RbSetParentColor(pTmpNode1,pSibling,RB_BLACK);

if(pTmpNode2)

RbSetParent(pTmpNode2,pParent);

RbRotateSetParents(pParent,pSibling,pRbRoot,RB_BLACK);

AugmentRotate(pParent,pSibling);

break;

}

else

{

pSibling=pParent->pLeft;

if(RB_IS_RED(pSibling))

{

pParent->pLeft=pTmpNode1=pSibling->pRight;

pSibling->pRight=pParent;

RbSetParentColor(pTmpNode1,pParent,RB_BLACK);

RbRotateSetParents(pParent,pSibling,pRbRoot,RB_RED);

AugmentRotate(pParent,pSibling);

pSibling=pTmpNode1;

}

pTmpNode1=pSibling->pLeft;

if(!pTmpNode1||RB_IS_BLACK(pTmpNode1))

{

pTmpNode2=pSibling->pRight;

if(!pTmpNode2||RB_IS_BLACK(pTmpNode2))

{

RbSetParentColor(pSibling,pParent,RB_RED);

if(RB_IS_RED(pParent))

RbSetBlack(pParent);

else

{

pNode=pParent;

pParent=RB_PARENT(pNode);

if(pParent)

continue;

}

break;

}

pSibling->pRight=pTmpNode1=pTmpNode2->pLeft;

pTmpNode2->pLeft=pSibling;

pParent->pLeft=pTmpNode2;

if(pTmpNode1)

RbSetParentColor(pTmpNode1,pSibling,RB_BLACK);

AugmentRotate(pSibling,pTmpNode2);

pTmpNode1=pSibling;

pSibling=pTmpNode2;

}

pParent->pLeft=pTmpNode2=pSibling->pRight;

pSibling->pRight=pParent;

RbSetParentColor(pTmpNode1,pSibling,RB_BLACK);

if(pTmpNode2)

RbSetParent(pTmpNode2,pParent);

RbRotateSetParents(pParent,pSibling,pRbRoot,RB_BLACK);

AugmentRotate(pParent,pSibling);

break;

}

}

}

static inline RB_NODE* RbEraseAugmented(RB_NODE *pNode,RB_ROOT *pRbRoot,const RB_AUGMENT_CALLBACKS *pAugment)

{

RB_NODE *pChild=pNode->pRight,*pTmpNode=pNode->pLeft;

RB_NODE *pParent,*pRebalanceNode;

unsigned long pc;

if(!pTmpNode)

{

pc=pNode->m_Color;

pParent=_RB_PARENT(pc);

RbChangeChild(pNode,pChild,pParent,pRbRoot);

if(pChild)

{

pChild->m_Color=pc;

pRebalanceNode=NULL;

}

else

{

pRebalanceNode=_RB_IS_BLACK(pc)?pParent:NULL;

}

pTmpNode=pParent;

}

else if(!pChild)

{

pTmpNode->m_Color= pc=pNode->m_Color;

pParent=_RB_PARENT(pc);

RbChangeChild(pNode,pTmpNode,pParent,pRbRoot);

pRebalanceNode=NULL;

pTmpNode=pParent;

}

else

{

RB_NODE *successor=pChild,*child2;

pTmpNode=pChild->pLeft;

if(!pTmpNode)

{

pParent=successor;

child2=successor->pRight;

pAugment->Copy(pNode,successor);

}

else

{

do

{

pParent=successor;

successor=pTmpNode;

pTmpNode=pTmpNode->pLeft;

}

while(pTmpNode);

pParent->pLeft=child2=successor->pRight;

successor->pRight=pChild;

RbSetParent(pChild,successor);

pAugment->Copy(pNode,successor);

pAugment->Propagate(pParent,successor);

}

successor->pLeft=pTmpNode=pNode->pLeft;

RbSetParent(pTmpNode,successor);

pc=pNode->m_Color;

pTmpNode=_RB_PARENT(pc);

RbChangeChild(pNode,successor,pTmpNode,pRbRoot);

if(child2)

{

successor->m_Color=pc;

RbSetParentColor(child2,pParent,RB_BLACK);

pRebalanceNode=NULL;

}

else

{

unsigned long pc2=successor->m_Color;

successor->m_Color=pc;

pRebalanceNode=_RB_IS_BLACK(pc2)?pParent:NULL;

}

pTmpNode=successor;

}

pAugment->Propagate(pTmpNode,NULL);

return pRebalanceNode;

}

extern void RbInsertColor(RB_NODE *pNode,RB_ROOT *pRbRoot)

{

RbInsertNode(pNode,pRbRoot,DummyRotate);

}

extern void RbLinkNode(RB_NODE *pNode,RB_NODE *pParent,RB_NODE **ppRbLink)

{

pNode->m_Color=(unsigned long)pParent;

pNode->pLeft=pNode->pRight=NULL;

*ppRbLink=pNode;

}

extern void RbEraseNode(RB_NODE *pNode,RB_ROOT *pRbRoot)

{

RB_NODE *pRebalanceNode;

pRebalanceNode=RbEraseAugmented(pNode,pRbRoot,&DummyCallbacks);

if(pRebalanceNode)

RbEraseColor(pRebalanceNode,pRbRoot,DummyRotate);

}

extern void RbReplaceNode(RB_NODE *pVictim,RB_NODE *pNewNode,RB_ROOT *pRbRoot)

{

RB_NODE *pParent=RB_PARENT(pVictim);

RbChangeChild(pVictim,pNewNode,pParent,pRbRoot);

if(pVictim->pLeft)

RbSetParent(pVictim->pLeft,pNewNode);

if(pVictim->pRight)

RbSetParent(pVictim->pRight,pNewNode);

*pNewNode=*pVictim;

}

extern RB_NODE *RbFirstNode(const RB_ROOT *pRbRoot)

{

RB_NODE*pNode;

pNode=pRbRoot->pRootNode;

if(!pNode)

return NULL;

while(pNode->pLeft)

pNode=pNode->pLeft;

return pNode;

}

extern RB_NODE *RbLastNode(const RB_ROOT *pRbRoot)

{

RB_NODE*pNode;

pNode=pRbRoot->pRootNode;

if(!pNode)

return NULL;

while(pNode->pRight)

pNode=pNode->pRight;

return pNode;

}

extern RB_NODE *RbNextNode(const RB_NODE *pNode)

{

RB_NODE *pParent;

if(RB_EMPTY_NODE(pNode))

return NULL;

if(pNode->pRight)

{

pNode=pNode->pRight;

while(pNode->pLeft)

pNode=pNode->pLeft;

return (RB_NODE *)pNode;

}

while((pParent=RB_PARENT(pNode))&&pNode==pParent->pRight)

pNode=pParent;

return pParent;

}

extern RB_NODE *RbPrevNode(const RB_NODE *pNode)

{

RB_NODE *pParent;

if(RB_EMPTY_NODE(pNode))

return NULL;

if(pNode->pLeft)

{

pNode=pNode->pLeft;

while(pNode->pRight)

pNode=pNode->pRight;

return (RB_NODE *)pNode;

}

while((pParent=RB_PARENT(pNode))&&pNode==pParent->pLeft)

pNode=pParent;

return pParent;

}

测试程序

extern void SymbolDel(SYMBOL *pSymbol)

{

free(((void *)pSymbol));

}

extern SYMBOL *SymbolNew(int start,int len,int binding,const char *name)

{

size_t namelen=strlen(name)+1;

SYMBOL *pSymbol=calloc(1,(sizeof(*pSymbol)+namelen));

if(pSymbol==NULL)

return NULL;

pSymbol->start=start;

pSymbol->end=len?start+len-1:start;

pSymbol->binding=binding;

pSymbol->namelen=namelen-1;

memcpy(pSymbol->name,name,namelen);

return pSymbol;

}

extern void SymbolsDelete(RB_ROOT *pSymbols)

{

SYMBOL *pPos;

RB_NODE *next=RbFirstNode(pSymbols);

while(next)

{

pPos=RB_ENTRY(next,SYMBOL,rb_node);

next=RbNextNode(&pPos->rb_node);

RbEraseNode(&pPos->rb_node,pSymbols);

SymbolDel(pPos);

}

}

extern void SymbolsInsert(RB_ROOT *pSymbols,SYMBOL *pSymbol)

{

RB_NODE **ppNode=&pSymbols->pRootNode;

RB_NODE *parent=NULL;

SYMBOL *pTmpSymbol;

const int pos=pSymbol->start;

while(*ppNode!=NULL)

{

parent=*ppNode;

pTmpSymbol=RB_ENTRY(parent,SYMBOL,rb_node);

if(posstart)

ppNode=&(*ppNode)->pLeft;

else

ppNode=&(*ppNode)->pRight;

}

RbLinkNode(&pSymbol->rb_node,parent,ppNode);

RbInsertColor(&pSymbol->rb_node,pSymbols);

}

extern SYMBOL *SymbolsFind(RB_ROOT *pSymbols,int pos)

{

RB_NODE *pNode;

if(pSymbols==NULL)

return NULL;

pNode=pSymbols->pRootNode;

while(pNode)

{

SYMBOL *pSymbol=RB_ENTRY(pNode,SYMBOL,rb_node);

if(posstart)

pNode=pNode->pLeft;

else if(pos>pSymbol->end)

pNode=pNode->pRight;

else

return pSymbol;

}

return NULL;

}

extern void SymbolDelTest(void)

{

SymbolsDelete(&sDsoInfo.symbols);

}

extern BOOL SymbolAddTest(void)

{

SYMBOL *pSymbol;

RB_ROOT *root=&sDsoInfo.symbols;

pSymbol=SymbolNew(1,0,7,"jsya1");

if(pSymbol==NULL)

return FALSE;

SymbolsInsert(root,pSymbol);

pSymbol=SymbolNew(5,0,57,"jsya5");

if(pSymbol==NULL)

return FALSE;

SymbolsInsert(root,pSymbol);

pSymbol=SymbolNew(4,0,47,"jsya4");

if(pSymbol==NULL)

return FALSE;

SymbolsInsert(root,pSymbol);

pSymbol=SymbolNew(2,0,27,"jsya2");

if(pSymbol==NULL)

return FALSE;

SymbolsInsert(root,pSymbol);

pSymbol=SymbolNew(3,0,37,"jsya3");

if(pSymbol==NULL)

return FALSE;

SymbolsInsert(root,pSymbol);

return TRUE;

}

extern SYMBOL *SymbolFindTest(int pos)

{

return SymbolsFind(&sDsoInfo.symbols,pos);

}

weixin_39801879
关注
yocto编译linux内核,如何编译Linux的内核
weixin_32905035的博客
04-29 1137
如何编译Linux的内核. 内核，是一个操作系统的核心。它负责管理系统的进程、内存、 设备驱动程序、文件和网络系统，决定着系统的性能和稳定性。Linux作为一个自由软件， 在广大爱好者的支持下，内核版本不断更新。新的内核修订了旧内核的bug，并增加了许如何编译Linux内核- Linuxer - CSDNBlog如何编译Linux内核. 对于linux新手来说，编译内核相对有一些难度，甚至不知道如...
Linux内核打开ilitek,MTK平台TP驱动调用流程分析_kernel-4.4
weixin_32522079的博客
05-01 1499
MTK Touch 驱动的组成Mtk Touch driver 驱动包括：Mtkplatform 虚拟平台设备驱动、Module touch IC驱动、Inputsubsystem。Mtk platform 设备驱动是mtk为了兼容多个touchIC驱动而设计出来的虚拟驱动，它会去遍历每一个touch IC驱动，直到其中一个初始化成功。Linuxinput_subsystem是linux的输入子系...
MT7628MTK官方linuxSDK开发资料和数据手册
08-09
MT7628MTK官方linuxSDK开发资料,MT7628datasheet,MT7628数据手册
linux红黑树 移植
C_Creator的博客
03-13 2002
红黑树简单移植与简单封装
在mtk移植个linux内核,移植 Linux Kernel 造成無法開機之解決方案以及除錯工具
weixin_39617215的博客
04-29 605
一般在以下情況, 我們會進行移植 Linux Kernel 的動作.1. 將新版 Linux Kernel 移植到全新 SoC 上開發人員為 SoC 廠商(e.g. MTK, TI, Allwinner) R&D engineer.在此階段的移植, 需要寫 dtsi, low-level code (位於 arch// 底下) 以及 SoC 相關的底層驅動程式. 並且須確保 SoC 功能運...
红黑树（三） - Linux内核实现
生活需要深度
07-06 310
前面分别介绍了红黑树的理论知识 以及 通过C语言实现了红黑树。本章继续会红黑树进行介绍，下面将Linux 内核中的红黑树单独移植出来进行测试验证。若读者对红黑树的理论知识不熟悉，建立先学习红黑树的理论知识，再来学习本章。转载请注明出处：红黑树(三)之 Linux内核中红黑树的经典实现 - 如果天空不死 - 博客园更多内容：数据结构与算法系列 目录(01) 红黑树(一)之 原理和算法详细介绍 (02) 红黑树(二)之 C语言的实现 (03) 红黑树(三)之 Linux内核中红黑树的经典实现 (04) 红黑树(
红黑树(三)之 Linux内核中红黑树的经典实现
kk的博客
04-02 195
概要 前面分别介绍了红黑树的理论知识 以及 通过C语言实现了红黑树。本章继续会红黑树进行介绍，下面将Linux 内核中的红黑树单独移植出来进行测试验证。若读者对红黑树的理论知识不熟悉，建立先学习红黑树的理论知识，再来学习本章。 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3624202.html 更多内容：数据结构与算法系列...
MT7668驱动 适用于安卓系统 linux内核
最新发布
06-10
总之，MT7668驱动在Android系统和Linux内核中的应用是一个涉及硬件接口、内核模块、用户空间服务、配置文件等多个层面的技术问题。理解和掌握这些知识点，对于开发和维护基于MT7668的Android设备至关重要。
MTK Fuel Gauge算法分析 - Linux内核电量计相关.doc
05-29
MTK Fuel Gauge算法分析 - Linux内核电量计相关.doc
MTK6582快捷逆向移植工具_联发科MT6582逆向移植工具_
09-30
4. **系统层适配**：如果原始软件基于不同的操作系统，如Android、Linux或其他定制系统，工具应能帮助调整内核配置，确保系统层兼容性。 5. **调试支持**：移植过程中，调试是非常重要的一环。工具可能提供集成的...
MTK平台移植camera步骤详解
06-08
MTK平台移植camera的步骤，并对每一个步骤中的易错点，容易忽略点做了介绍。有助于初学者对MTK平台的理解！ 以MTK6589移植camera为例！
Linux内核红黑树使用方法
╰☆╮EvilCode的专栏╭☆╯
09-08 1944
转载自Linux2.6.29 内核文档，rbtree.txt 如果要使用红黑树，可直接复制内核中的代码rbtree.c/h Red-black Trees (rbtree) in Linux January 18, 2007 Rob Lan
手把手教你移植linux内核---------OK6410（五）
laoylhuli
08-29 3840
搭建NFS网络文件系统          NFS (Network File System)是由Sun开发的一种在不同机器之间通过网络共享文件的技术。在嵌入式Linux系统的开发调试阶段，可以利用该技术在主机上建立基于NFS的根文件系统，挂载到嵌入式设备，可以很方便地修改根文件系统的内容。         根文件系统是Linux启动时使用的第一个文件系统。没有根文件系统，Linux将无法正常启
linux下安装mtk编译环境,Ubuntu 14.04 搭建MTK Android源码编译环境搭建
weixin_35385921的博客
05-11 398
安装必备的工具：BuildEnvironment Requirement=============================================================* ********* Suggested OS and Tool Chain toinstall *********OS : Linux distribution Ubuntu 10.04Memory ...
linux刷机软件,MTK平台刷机工具——SP_Flash_Tool
weixin_30025473的博客
05-05 7544
0、前言大家好，最近用了一段时间的SP_Flash_Tool刷机工具。今天简单给大家分下。观众老爷，觉得有用文末支持一下。您的支持是对我最大的鼓励。1、怎么用三种下载选项：Download Only 只是下载部分文件，如果项目中只是编译个 kernel，那么只需要下载boot，这样速度快效率高Firmware Upgrade 更新下载，只是下载那些变化过的文件，没有改变的文件不进行下载Format...
TEE OS 开发基于OP-Tee，MTK平台的移植方法
求变，从思想开始
05-30 7324
最近一直在研究TEE  OS，经过一断时间，终于把自己的OS移植到MTK平台！现在把主要的方法记录一下，1. 下载代码https://github.com/OP-TEE/optee_os$ mkdir open-tee        //创建目录  $ cd open-tee           //切换到创建的目录  $ repo init -u https://github.com/OP-TE...
嵌入式系统移植【7】——Linux内核移植
imysy_22_的博客
07-25 1384
关于linux内核uImage的由来
Linux 内核移植
安迪西_嵌入式攻城狮
10-26 4020
内核移植
MTK移植过程中的错误解决与技巧
在进行MediaTek（MTK）平台的软件移植工作时，开发者经常会遇到各种问题，这些问题主要涉及文件包含顺序、枚举定义、函数或变量的可用性以及文件路径等问题。以下是对这些问题的详细分析和解决策略： 1. 文件包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值