Docstoc

TUTORIAL

Document Sample
TUTORIAL Powered By Docstoc
					Doc scheda                                     11/01/06




                         11 gennaio 2006




                     Autore: Roberto Campari




                    TUTORIAL
  INSTALLAZIONE DI LINUX E UTILITY
       SU PIATTAFORMA ARM9




TUTORIAL_ARM_V1_0                                  1/12
Doc scheda                                                                                                               11/01/06


                                                            Indice

ll boot della scheda............................................................................................................... 3
   Operazioni preliminari...................................................................................................... 3
   Prima fase: installazione di romboot................................................................................ 3
   Seconda fase: installazione di u-boot.............................................................................. 4
   Configurare i parametri di U-BOOT.................................................................................. 4
   Qualche esempio............................................................................................................. 5
   Utilizzare le variabili di ambiente...................................................................................... 5
   Caricare il kernel in flash................................................................................................. 5
L’ambiente di sviluppo.......................................................................................................... 6
   Il Cross Compilatore......................................................................................................... 6
   Preparazione di U BOOT................................................................................................. 7
   Compilare il kernel........................................................................................................... 9
   Compilare busybox....................................................................................................... 10
   La compilazione di un modulo....................................................................................... 12




TUTORIAL_ARM_V1_0                                                                                                              2/12
Doc scheda                                                                           11/01/06

ll boot della scheda.

La CPU dispone di un software interno proprietario per le operazioni di bootstrap. E’ più
pratico tuttavia utilizzare un boot esterno che carica i programmi memorizzati nella flash
in modo automatico all’accensione.Si sceglie questa operazione attraverso un segnale ,
BMS, che se presente attiva il boot da flash esterna parallela. E’ possibile fare il boot
anche dalla flash seriale, generalmente utilizzata per la memorizzazione dei dati. In
questo modo si può semplificare significativamente la costruzione dell’hardware. Il
segnale BMS non è più necessario: all’accensione la cpu verifica la presenza di un
programma nella flash seriale e lo esegue.
Alla prima accensione della scheda si utilizzerà il boot interno per predisporre il nuovo
boot in flash memory.
Si collega un terminale a 115Kbaud alla console (ttyS0) e dopo il reset apparirà il prompt
del download con protocollo XMODEM che consiste in una serie di C in attesa dell’invio
del programma. Si caricherà nella ram interna un minuscolo programma costituito da
alcune semplici operazioni di boot e la scrittura della flash memory. Questo programma,
romboot.bin, diventerà il vero e proprio loader della scheda. Si può inoltre,interrompendo
il processo automatico, copiare un programma nella flash memory altrimenti il
programma termina lanciando un altro programma: u-boot.

Operazioni preliminari

Predisporre un PC con sistema operativo Windows dotato di programma di
comunicazione sulla porta seriale, es. Hyperterminal. Impostare i parametri di
comunicazione a 115200,n,8,1.
Tale operazione potrebbe essere eseguita anche con il programma minicom sotto sistema
operativo linux, ma in alcune versioni ci sono problemi di compatibilità, per cui se ne
sconsiglia l’utilizzo.
In una directory saranno caricati preventivamente il file romboot.bin e u-boot.bin.

Prima fase: installazione di romboot

Accendere la scheda: appare il prompt C C C C C......
Da Hyperterminal si invia il file romboot.bin con il protocollo XMODEM.
Dal menu scegliere l’opzione trasferisci. Invia file protocollo xmodem.
Una volta caricata l’applicazione partirà automaticamente.
Sulla console, premere repentinamente un tasto qualsiasi per interrompere la sequenza
automatica delle operazioni ed accedere alle opzioni.
Scegliere l’opzione 1
Digitare quindi 1 C0000000. Il numero corrisponde alla locazione di memoria dove
installare il programma.Ritorna il prompt C C C C....
Inviare una seconda volta con hyperterminal protocollo xmodem il file romboot.bin allo
stesso modo descritto in precedenza.
Questa volta il file sarà scritto nella flash memory nella locazione indicata.Se l’operazione
è andata a buon fine apparirà la scritta: data flash ok!

Seconda fase: installazione di u-boot

La seconda fase prevede l’installazione di u-boot che si occupa di alcune operazioni

TUTORIAL_ARM_V1_0                                                                        3/12
Doc scheda                                                                            11/01/06

preliminari nonché del passaggio dei parametri al linux kernel. Per una approfondita
conoscenza delle funzioni e delle potenzialità di questo strumento software si rimanda alla
documentazione disponibile in rete al sito sourceforge.net/projects/u-boot.
Verranno discussi in questo documento solo alcuni parametri principali.
U-boot viene caricato in flash memory con lo stesso principio di romboot alla locazione
c0008000.
Fare un reset della scheda. Se il caricamento di romboot ha avuto successo romboot
partirà automaticamente. Premere un tasto sulla console per accedere al menù.
Digitare 1 c0080000
Al prompt del protocollo xmodem inviare dal computer mediante hyperterminal il file u-
boot preparato in precedenza.
Sulle modalità di preparazione del file si rimanda al relativo capitolo.Si ricorda inoltre che
per potere essere eseguito in flash memory seriale si devono apportare alcune modifiche
al codice originale.
Se le operazioni descritte sopra sono state eseguite correttamente resettando si avvierà
romboot e dopo qualche istante u-boot. Entrambi i programmi hanno un breve intervallo di
tempo che consente all’operatore di interrompere l a sequenza esecuzione automatica
delle operazioni e prendere il controllo delle operazioni.

Configurare i parametri di U-BOOT

Si è detto che U-boot non è un semplice boot-loader. Ha in sé la potenzialità manipolare
la memoria, gestire i trasferimenti anche su porta ethernet e preparare i parametri per il
linux kernel. Ma U-boot è in grado di lanciare qualsiasi applicazione: potrebbe essere il
loader di applicazioni stand-alone senza l’utilizzo di un sistema operativo. La notevole
varietà di operazioni disponibili rende necessaria la possibilità di configurare tale
programma per adattarlo alle varie tipologie. Si potrà salvare la configurazione in modo
permanente per eseguire tali sequenze automaticamente.
Tramite u-boot si può decidere come e da dove caricare il sistema operativo, la
configurazione delle porte ed altro.
Tre sono i comandi essenziali:
setenv si predispone una variabile o un’operazione.
saveenv si salva in modo permanente tale configurazione.
printenv visualizza sulla console tali variabili.
In questo esempio si caricano ramdisk e kernel (uImage) da una pc remoto tramite
protocollo TFTP. Questa configurazione è particolarmente idonea durante la preparazione
del software: tutto lo sviluppo viene svolto sul PC host e testato sulla scheda. Diventa più
semplice modificare kernel, il ramdisk può essere gestito sulla macchina remota dove
generalmente si hanno a disposizione più tool di sviluppo e con una potenza di calcolo
notevolmente superiore.
La macchina remota deve essere predisposta per l’esecuzione di un server tftp. E’
disponibile un tftpserver per windows, mentre per linux generalmente è compreso nella
distribuzione.
La configurazione di U-boot si fa da console. Al reset della scheda, quando parte u-boot si
ha un breve lasso di tempo per interrompere il processo automatico. Si preme un tasto e
appare il prompt.
Al prompt di u-boot si digitano i comandi.
Ogni comando termina con il tasto Return (invio)



TUTORIAL_ARM_V1_0                                                                        4/12
Doc scheda                                                                            11/01/06

Qualche esempio

Una possibile configurazione dei parametri di u-boot potrebbe essere la seguente:
(i commenti in grassetto non vanno inseriti)
setenv ethaddr 12:34:56.78:90:AB set mac address di AT91RM9200
setenv ipaddr 192.168.1.1 indirizzo IP della scheda solo in fase di boot
setenv serverip 192.168.1.10 indirizzo ip del server tftp che conterrà il kernel e il ramdisk.
setenv bootargs root=/dev/ram rw initrd=0X21000000,6000000 ramdisk_size=15360
console=ttyS0,115200 mem=32M sono i parametri da passare al kernel
setenv bootcmd tftp 21100000 ramdisk\; tftp 21000000 uImage\; bootm 21000000 sono le
istruzioni di boot
L’elenco delle variabili si visualizza con printenv.
Notare il carattere \ necessario prima del punto e virgola per potere inserire questo
carattere in una stringa. Con printenv non viene visualizzato.
Si salva con saveenv.
Digitando help si ha la descrizione dei comandi disponibili.

Utilizzare le variabili di ambiente

Si può rendere più elegante lo script dei parametri introducendo due variabili di ambiente:
set kernel tftp 21000000 uImage carica dal server il file uImage alla locazione 21000000
set ramdisk tftp 21100000 ramdisk.
Si modifica il comando di boot nel seguente modo
setenv bootcmd run ramdisk\; run kernel\; bootm 21000000
In questo caso il comando run esegue la variabile di environment definita in precedenza.
L’utilizzo delle variabili agevola le modifiche dello script: generalmente quando la
preparazione del software è completa, lo si memorizza in flash per rendere la scheda
indipendente. Con l’utilizzo di diverse variabili è possibile cambiare agevolmente la
configurazione,particolarmente utile per testare nuove versioni del software.

Caricare il kernel in flash.

Tale operazione si esegue con i comandi di u-boot. Bisogna interrompere la sequenza
automatica per ottenere il prompt.
Prima di tutto caricare l’immagine del kernel dal computer host in ram.
Si può fare in diversi modi:
download del file da seriale, più lento.
Configurare il terminale con i seguenti parametri: 115200,8,n,1
Digitare sulla console loadb 20000000 . La scheda si predispone per ricevere un file. Sul
terminale del computer host inviare il file con il protocollo kermit.
Download da rete, consigliato.
Sul computer remoto deve essere installato il programma tftp come spiegato in
precedenza. Nella scheda a variabile di environment serverip dovrà avere l’indirizzo della
macchina remota.
Sia il ramdisk che l’immagine del kernel devono essere posti nella directory /tftpboot sulla
macchina remota da cui si effettua il download via protocollo TFTP.
Digitare tftp 20000000 <nome del file>
Al termine dell’operazione verranno indicati il numero di byte trasmessi.


TUTORIAL_ARM_V1_0                                                                         5/12
Doc scheda                                                                            11/01/06

Copiare il contenuto della ram con il comando cp.b 20000000 C0030000 123FFF
(partenza, destinazione,lunghezza file precedentemente annotata).
Eseguire questa operazione con estrema prudenza per evitare sovrapposizioni di file.
Prestare particolare attenzione a non sovrascrivere l’area in cui è memorizzato U-boot.
Ora bisogna modificare le variabili di environment.
Si aggiunge una nuova variabile flash_kernel
setenv flash_kernel cp.b c0030000 21000000 123FFF
Si modifica la sola riga di bootcmd
setenv bootcmd run ramdisk\; run flash_kernel\; bootm 21000000
Salvare sempre alla fine delle modifiche.
Alla prossima esecuzione di u-boot il kernel precedentemente salvato in flash verra
copiato in ram nella locazione corretta per la sua esecuzione.Se si volesse tornare alla
configurazione precedente basta modificare la sola riga di bootm.
Prestare molta attenzione alla scrittura corretta dell’environment che potrebbe essere
causa di anomalie.
Analogamente le operazioni per il caricamento del ramdisk seguono la stessa procedura
con diverse locazioni di memoria..


L’ambiente di sviluppo

Il Cross Compilatore

Utilizzare il sistema operativo LINUX da la possibilità trovare parecchio materiale : dal web
è possibile scaricare codici sorgente per varie applicazioni librerie, compilatori ecc.. Nella
maggior parte dei casi non è possibile utilizzare programmi già pronti, compilati
generalmente per PC su piattaforma intel386. Bisogna perciò avere a disposizione un
cross compilatore,che si esegue sul PC ma genera un codice adatto a una cpu diversa,
nel nostro caso un processore ARM9 o più precisamente AT91RM9200. La compilazione
dei programmi, ma anche dello stesso sistema operativo passa attraverso l'utilizzo del
compilatore GCC e delle librerie gnu. Anche il compilatore stesso prevede alcune opzioni
per adattarlo a processori diversi da quello del computer sul quale è installato, ma la
preparazione di questo strumento è molto difficoltosa.
E' più facile, invece ricorrere ad una soluzione preconfezionata da installare in maniera del
tutto indipendente dal compilatore GCC nativo, comprendente anche le librerie e i tool di
sviluppo per il processore della scheda.
L'utilizzo di soluzioni preconfezionate obbliga l'installazione in directory ben precise, si ha
però il vantaggio di evitare errori dovuti ad un’installazione impropria dei vari componenti.
Per potere utilizzare i tool da ogni punto del disco, bisogna inserire queste directory nella
variabile di environment PATH. Si possono avere a disposizione compilatori per diversi
processori o diverse versioni di compilatore di librerie e di linker.
La versione di cross compiler consigliata per la maggior parte di applicazioni è la arm-
linux-gcc 2.95.3. Le nuove versioni di kernel, tuttavia, non possono essere compilate con
questa versione. Attualmente per il kernel 2.6 è consigliato di avere installato almeno una
versione 3.4.X. Trattandosi di un cross compilatore spesso le ultimissime versioni non
sono stabili: attualmente non si hanno buoni risultati con le versioni 4.
E’ possibile installare diverse versioni di compilatori, è bene includere nella path un solo
compilatore alla volta per evitare pericolose sovrapposizioni.



TUTORIAL_ARM_V1_0                                                                         6/12
Doc scheda                                                                          11/01/06

esempio di installazione di arm-linux-gcc 2.95.3

Creare una directory
mkdir usr/local/arm/
è necessario rispettare questa posizione.
copiare il file
cross-2.95.3.tar.bz2 nella directory precedentemente creata.
Estrarre il file
tar jxvf cross-2.95.3.tar.bz2

Inserire il percorso nella path scrivendo:

export PATH=$PATH:.:/usr/local/arm/2.95.3/bin/

Se tale percorso deve essere visto da tutti gli utenti bisogna aggiungere questa riga nel
file /etc/profile.
Si aggiunge tale percorso nel file di inizializzazione .profile contenuto nella home di
singolo utente (.bash_profile ad esempio per l’utilizzo in una shell bash).
Oppure si digita il comando sul terminale attivo.
In questo caso il nuovo percorso verrà perso quando si chiude il terminale.
Lo stesso procedimento si utilizza anche per le versioni successive.


Preparazione di U BOOT

L’utilizzo del software libero dà la possibilità a molti utenti di modificare e ampliare le
funzionalità di un programma. Si è detto che U-boot non è solo un loader, la sua
importanza per il caricamento del kernel ne è la prova più evidente. La portabilità del
software su diversi tipi di piattaforma e l’adattamento a varie architetture necessariamente
comporta alcune scelte nella configurazione. Nel nostro caso la memorizzazione di U-boot
nella memoria flash seriale richiede oltre alla semplice configurazione per la piattaforma
ARM anche un intervento nel codice sorgente. Tali modifiche sono possibili dalla
versione 1.0. Il codice si scarica dal web all’ indirizzo sourceforge.net/projects/u-boot.
Tutti i riferimenti del software si devono sempre ricondurre alle configurazioni di ATMEL
AT91RM9200DK.
Scompattando il file crea una directory u-boot-1.0.0. Per questa versione è prevista una
patch creata dalla stessa Atmel documentata in maniera esaustiva nel doc6067b
scaricabile dal loro sito.
Si scompatta il file sorgente che crea una directory u-boot-1.0.0
Si applica la patch come da istruzioni contenute nel doc6067b.
Si modifica il codice come descritto nello stesso documento.
Si esegue l’istruzione make at91rm9200dk_config
make at91rm9200dk_config
tale istruzione predispone il makefile per la cross compilazione
Se tale operazione è andata a buon fine appare la scritta
Configuring for at91rm9200dk board
digitare
make clean
e poi
make

TUTORIAL_ARM_V1_0                                                                       7/12
Doc scheda                                                                            11/01/06

al termine verra prodotto il file u-boot.bin pronto per essere caricato sulla scheda come
descritto in precedenza.
Le versioni successive incorporano già la patch della Atmel. Bisogna comunque
modificare il file sorgente include/configs/at91rm9200dk.h
Modificare
#undef CFG_ENV_IS_IN_DATAFLASH
in
#define CFG_ENV_IS_IN_DATAFLASH                  1
modificare
#define CONFIG_ENV_OVERWRITE
in
#define CONFIG_ENV_OVERWRITE 1.

Le nuove versioni del Kernel 2.6 prevedono un parametro di identificazione del tipo di
hardware. U-boot si occupa di fornire al kernel questa informazione.
Configurando il codice di U-boot la definizione di mach-type è errata per cui il
caricamento del kernel dà errore e non può proseguire. Si deve pertanto sostituire la
definizione di MACH_TYPE .
Modificare
MACH_TYPE_AT91RM9200
con
MACH_TYPE_AT91RM9200DK
nel file ./board/at91rm9200dk/at91rm9200dk.c

estratto del listato:
/* arch number ot AT91RM9200DK-Board */
gd->bd->bi_arch_number = MACH_TYPE_AT91RM9200


Si deve ricompilare U-boot nel modo precedentemente indicato.


Compilare il kernel

Occorre innanzitutto scaricare i sorgenti del kernel. Si trovano al seguente indirizzo:
http://ftp.kernel.org/pub/linux/kernel/v2.6/
ll kernel scaricato è generico. Bisogna applicare le patch per AT91RM9200 che si trovano
al sito
http://maxim.org.za/AT91RM9200/2.6/


In questo esempio si suppone di avere scaricato la versione 2.6.15.
Nella propria home directory si è creata una sottodirectory dove depositare il materiale
scaricato dal web.
Si scompattano sorgenti e patch.
tar jxvf linux-2.6.15.tar.bz2
tale operazione creerà a sua volta una directory che racchiude i file sorgenti organizzati

TUTORIAL_ARM_V1_0                                                                         8/12
Doc scheda                                                                             11/01/06

secondo una struttura predefinita. Tale directory si chiamerà in questo caso linux-2.16.15
Analogamente scompattare i file di patch. Sempre per questo kernel si deve scompattare
patch-2.6.15.2.bz2:
bzip2 -d patch-2.6.15.2.bz2
e copiare il file in linux-2.6.15
cp patch-2.6.15.2 ./linux-2.6.15
Scompattare la patch 2.6.15-at91.patch.gz:
gunzip 2.6.15-at91.patch.gz
cp 2.6.15-at91.patch ./linux-2.6.15
Si entra in tale directory e si applicano le patch
cd linux-2.6.14
patch -p1 < patch-2.6.15.2
patch -p1 <2.6.14-at91.patch.
Eseguire quindi i seguenti comandi.
export ARCH=arm
export CROSS_COMPILE=arm-linux-
make at91rm9200dk_defconfig

In questa posizione si deve inoltre:
Copiare il file mkimage che serve a preparare l’immagine da caricare sulla scheda.
Copiare lo script make_26 che raccoglie tutte le istruzioni per la compilazione del kernel
Eseguire quindi lo script con il comando ./make_26.


Il contenuto dello script è il seguente:
export ARCH=arm
export CROSS_COMPILE=arm-linux-
make oldconfig (Da commentare alla prima esecuzione)
make menuconfig
make clean; make dep; make Image
/usr/local/arm/3.4.4/bin/arm-linux-objcopy -O binary -S vmlinux linux.bin
gzip -v9 linux.bin
./mkimage -A arm -O linux -C gzip -a 0x20008000 -e 0x20008000 -d linux.bin.gz uImage

Durante l’esecuzione dello script apparirà un menu di configurazione con tutte le opzioni
del kernel da configurare secondo le proprie esigenze. Se tutte le operazioni andranno a
buon fine il prodotto sarà il file uImage che si dovrà copiare nella directory tftpboot per
essere trasferito alla scheda.

La compilazione del kernel 2.4 avviene sostanzialmente in modo analogo ricordandosi
che:
è preferibile compilare con arm-linux-gcc 2.95.3
Si eseguono i seguenti comandi
export ARCH=arm
export CROSS_COMPILE=arm-linux-
make at91rm9200dk_config

TUTORIAL_ARM_V1_0                                                                         9/12
Doc scheda                                                                             11/01/06


si utilizza lo script make_24 leggermente diverso.

Script make_24

export ARCH=arm
export CROSS_COMPILE=arm-linux-
make oldconfig ( attenzione per la prima esecuzione questo comando non deve essere eseguito. E'
opportuno modificare lo script commentando la linea con un # all'inzio riga.)
make menuconfig
make clean; make dep; make Image
/usr/local/arm/2.95.3/bin/arm-linux-objcopy -O binary -S vmlinux linux.bin
gzip -v9 linux.bin
./mkimage -A arm -O linux -C gzip -a 0x20008000 -e 0x20008000 -d linux.bin.gz uImage



Compilare busybox

Busybox è un insieme di comandi che costituiscono la shell di linux. La shell standard
dispone di tali comandi da compilare singolarmente. In un sistema embedded data la
scarsità di risorse è più conveniente avere un unico file contenente tutti i comandi
necessari. Le dimensioni del file possono essere ulteriormente ridotte utilizzando
particolari librerie diverse da quelle standard. Vengono qui riportati i soli comandi per la
compilazione standard e l’installazione in un ramdisk preesistente.
I comandi disponibili sono selezionabili da un menu di configurazione.
E’ necessario aggiornare busybox per adattare, ad esempio, il comando insmod al kernel
2.6.
Una volta scaricato il file sorgente da http://busybox.net si scompatta il file e verrà creata
una sottodirectory busybox.
Una volta entrati in quest’ultima digitare
make menuconfig
Scegliere nel menu build options
build busybox as a static binary
cross compiler prefix         arm-linux-
salvare.
Digitare make
poi make install.
Se la compilazione è andata a buon fine nella sottodirectory _install ci sarà il file da
installare nel ramdisk.
Bisogna quindi scompattare il ramdisk, effettuare il mount perchè si possa modificare,
installare la busybox, smontare il disco e ricompattarlo.
Per le operazioni di mount e umount si utilizzano due script già pronti:opend e closed
Gli altri comandi si digitano a mano.



TUTORIAL_ARM_V1_0                                                                         10/12
Doc scheda                                                                                 11/01/06

SI suppone che la directory di lavoro contenga il ramdisk e una sottodirectory busybox-
1.01 in cui si è precedentemente compilato il programma.


./opend ramdisk
 rsync -a busybox-1.01/_install/ /mnt/ramdisk/
 chown -R root:root /mnt/ramdisk/
 sync
 closed ramdisk
Si copia poi il ramdisk nella directory /tftpboot per inviarlo alla scheda.




La compilazione di un modulo

Il kernel 2.6 prevede un nuovo meccanismo per la compilazione dei moduli chiamato
kbuild. Il meccanismo di compilazione è così completamente integrato.
Per    ulteriori  informazioni   vedere                  la     documentazione   del   kernel      in
linux/Documentation/kbuild/modules.txt.
Nella directory dove si prepara il modulo si deve creare un makefile                   dove vanno
specificati alcuni parametri per la cross compilazione.
La destinazione dei moduli, file ko, è generalmente la directory /lib/modules, ma per una
cross compilazione è preferibile lasciare l’oggetto dove risiede il sorgente. Qualora si
volesse modificare tale scelta bisogna cambiare le opzioni del parametro -C del make
come descritto in modules.txt citato in precedenza.


Nell esempio è riportato il Makefile per il modulo pbb26_dcg.c

export ARCH=arm
export CROSS_COMPILE=arm-linux-
WARN      := -W -Wall -Wstrict-prototypes -Wmissing-prototypes
CFLAGS := -O2 -DMODULE -D__KERNEL__ ${WARN} ${INCLUDE}
#qui si specifica il file oggetto
obj-m += pbb26_dcg.o
all:
# si deve specificare la directory di partenza del sorgente del kernel
         make -C /root/2.6/linux-2.6.12.3/ M=$(PWD)




TUTORIAL_ARM_V1_0                                                                               11/12
Doc scheda                                                                        11/01/06

Per compilare il file quindi basterà digitare make.
Per avere più informazioni sulle operazioni di un comando make aggiungere il parametro
KBUILD_VERBOSE=1.
Ad operazione terminata con successo si otterrà il modulo da caricare nel ramdisk con
estensione ko.
Come nel precedente caso si utilizzerà lo script opend. Si copierà il file nella posizione
desiderata e si richiuderà con closed.
Per attivare un modulo si utilizza il comando insmod.




TUTORIAL_ARM_V1_0                                                                    12/12

				
DOCUMENT INFO
Shared By:
Tags: ARM9
Stats:
views:17
posted:1/14/2012
language:
pages:12
Description: The ARM9 family processor is ARM's UK mainstream embedded processor design, including ARM9TDMI and ARM9E-S series. Mobile phone applications, for example, 2G phones only provide voice and simple text messaging, and the current 2.5G and future 3G mobile phones in addition to providing these two functions, must also provide a variety of other applications. Include: (1) wireless network devices: mobile Internet, e-mail and other location based services and other functions; (2) PDA function: with the user operating system (Windows CE, Symbian OS, Linux, etc.) and other functions; (3) high performance features: audio player, video phone, mobile phone games. 2.5G and 3G applications ARM9 has been fully replaced ARM7. Because new features to meet the ARM9 new needs while reducing product development time and reduce development costs.