MIZI Linux SDK for S3C2410

Transcription

1 MIZI Linux SDK for S3C2410 MIZI Research, Inc. Please contact us for further queries, MIZI technical consultation team Acknowledgment This server contains MIZI Linux version 1.5 (code name which has been modified to be run in S3C2410X by Samsung Electronics. It is also capable to run in S3C2410X reference board whose name is SMDK2410X and SMDK2410TK since required software device drivers have been included. Disclaimer of Liability For documents and software available from this server, MIZI Research Incorporated does not warrant or assume any legal liability or responsibility for the accuracy, completeness, or usefulness of any information, apparatus, product, or process disclosed. License All software available from this server follow GPL by GNU. If you need to review the license term and conditions of GPL then please visit GNU homepage. 1. Introduction of an Embedded system 1.1 Definition of an Embedded system 1.2 Definition of an Embedded OS 1.3 Linux as an Embedded OS 1.4 Introduction of the MIZI Linux

2 2. Constructing MIZI Linux development environment 2.0 Development steps of Embedded Linux 2.1 Composing Hardware environment o JTAG(Joint Test Access Group) cable o Serial cable o Ethernet cable 2.2 Constructing Software environment o Installing basic software development tools o Installing MIZI Linux SDK(Software Development Kit) for S3C2410 o Installing Cross Compiler Reference o Installing Embedded Linux GUI Toolkit, Development Kit o Installing tmake o Outline of MIZI Linux SDK 3. Compiling bootloader, kernel image, filesystem for target board 3.0 Introduction of bootloader 3.1 Compiling vivi 3.2 Compiling kernel 3.3 Creating Root file system 4. Porting Embedded Linux to target board 4.1 Porting Linux when target board booting is able o minicom o ztelnet o imagewrite 4.2 Porting Linux when target board booting is disable o Uploading vivi by using JTAG o Porting Images by using vivi 5. How to use development environment 5.1 How to use Virtual FrameBuffer 5.2 How to use tmake

3 o Using tmake for x86 o Using tmake for arm 5.3 How to compile and use Qtopia source 6. Download 6.1 Development tools download 6.2 Image Download 6.3 vivi Source Download 6.4 Kernel Source Download 6.5 SMDK 2410 CD Image(ISO) download 7. News "MIZI Linux S3C2410X home page now open" "Newer patch version of VIVI bootloader" =.==.============================================================ 1. Introduction of an Embedded system 1.1 Definition of an Embedded system An embedded system is various type of computer system or computing device that performs a dedicated function and/or is designed for use with a specific embedded software application. Embedded systems may use a combination of Read-only as well as with Read-Write based operating system. But an embedded system is not usable as a commercially viable substitute for general-purpose computers or devices. 1.2 Definition of an Embedded OS An embedded operating system is the software program that manages all the other programs in an embedded device after initial load of programs by a boot loader. It normally guarantees a certain capability within a specified storage size and time constraint as well as with application programs. It also normally has small foot print including initial boot loader, OS kernel, required device drivers, file systems for the

4 user data and so forth. It has very-likely structure of a normal operating system however mainly differentiated by some factors such as type of pre-installed device, functional limits, taking designed job only. 1.3 Linux as an Embedded OS Embedded Linux is inherited from Linux that has been modified and upgraded by developers in Linux community to be fit as an embedded operating system. It is normally said that embedded Linux has advantages of portability, flexibility, lower cost and development environments. That is why embedded Linux is nowadays widely using in embedded devices. 1.4 Introduction of the MIZI Linux MIZI Linux is an embedded Linux distribution which is specially designed for a smart handhelds and digital appliances. By the efforts of MIZI Research during several years MIZI Linux distribution includes many of add-up values, software patches and development kit, and typical user applications for the target devices. MIZI Linux has been installed following type of device especially; Handheld device: Smart phone, Wireless PDA type of device or its variations Digital appliances: Home Gateway System, Digital Outdoor Banner, Non-regular type of PCs, PVR(Personal Video Recorder) and Digital TV & Set-top box. The document is dedicated to introduce our distribution, MIZI Linux v1.x (code name Linu@ ). 2. Constructing Embedded Linux development environment 2.0 Development steps of Embedded Linux The following are development steps of Embedded Linux. Seeing these steps, you will know how to construct development environment for embedded linux.

5 (1) Installing Linux to host PC (2) Installing Embedded Linux GUI Toolkit, development kit to host PC (3) Compiling bootloader, kernel image, filesystem for target board (4) Porting images compiled at the preceding step to target board (5) Porting Embedded Linux GUI Toolkit to target board (6) Developing software for target board in host PC (7) Porting the developed software to target board This document is written on the assumption that you install "Red Hat Linux 8.0" by workstation type on your host PC. If you install other distributions on your PC, some problems related to library etc can be happened. So if you want to prevent getting into trouble and spare development time, install Red Hat Linux 8.0 by workstation type on your PC. If you want to know more detail things about Red Hat Linux 8.0 Installation, visit the bellowing site. l-guide/ The following is summary of each chapter. In this chapter, we explain hardware and software which are needed to Chap4 construct development environment. And in case software, how to install it is also explained. In this chapter, we explain how to compile bootloader, kernel image and Chap5 filesystem for target board. In this chapter, we explain how to port the compiled images to target board Chap6 by using cables which connect between target board and host PC. In this chapter, we explain how to compile and test application programs of Chap7 embedded linux by using development environment constructed on host PC. 2.1 Composing Hardware environment

6 MIZI-tool-box uses three cables(jtag cable, Serial cable, Ethernet cross cable) for communication between target board and host PC. Usually each cable connects two systems when the cable needs to use. Then we introduce each cable at the following JTAG(Joint Test Access Group) cable In here, we don t deal with the principal or hardware configuration of JTAG. The following contents are written about the roles of JTAG when developing embedded system. When embedded system can t be bootable due to corruption of bootloader or when we write bootloader to flash ROM for the first time, we use JTAG cable. In those cases, we have to download bootloader from host PC to embedded system by using JTAG cable and then write the downloaded bootloader to flash ROM of embedded system. JFlash program is used for writing bootloader (for detail, downloading bootloader from host PC, then writing bootloader to flash ROM that locates inside embedded system.) S/W Vendor Embedded system Program Cable MIZI Research MIZI-tool-box Jflash-s3c2410 JTAG parallel cable Serial cable Serial cable primary uses for communicating between host PC user and embedded system. Serial cable is used when host PC user sends commands to embedded system and when embedded system displays outputs of commands or states of itself etc. to host PC. Its transfer rate is so slow that it is usually used to handshake small size data. But when high-speed communication devices did not exist, it sometimes used to transfer bulk data like kernel or filesystem image Ethernet cable Serial cable has problem to handshake bulk data between two systems because of low transfer speed. To solve this problem, embedded system offers Ethernet cable that can transfer data by high-speed rate.

7 2.2 Constructing Software environment Installing basic software development tools (1) Installing "Red Hat Linux 8.0" by workstation type Workstation installation installs software development tools as well as a graphical desktop environment(x-window System). In this case, almost basic development tools will be installed, so you can install and use MIZI Linux 1.5 SDK without additional works. (2) Already Installed "Red Hat Linux 8.0" by personal desktop type Personal desktop installation installs a graphical desktop environment(x-window System) and creates a system ideal for desktop use. But it doesn't install any RPMS related software development tools. We don't supply the basic development tools that Redhat provides, so if you use MIZI Linux 1.5 SDK well, you have to find and install software development tools from Redhat site. Software development tools include the bellowing programs as basic tools to develop; Software Development tools binutils gcc gcc-c++ glibc-kernheaders glibc-common glibc glibc-devel patch make minicom Use this version or over binutils gcc gcc-c glibc-kernheaders glibc-common glibc glibc-devel patch make minicom Etc.... You can get above RPMS at Redhat site. MS ftp://ftp.redhat.com:/pub/redhat/linux/8.0/en/os/i386/redhat/rp Download above RPMS at your local directory and install these by this order.

8 # rpm -Uvh RPMS_name * Please update your glibc RPM package to from Red Hat update site Installing MIZI Linux SDK(Software Development Kit) for S3C2410 After securing 1GB disk space in your host PC, make linuette directory. Mount CR-Rom which MIZI Linux SDK is inserted at /mnt/cdrom. # mkdir /linuette # cd /mnt/cdrom/ # tar cf -. ( cd /linuette ; tar xvf - ) Login by root account then, install all RPMs under /mnt/cdrom/rpms directory by the following command. #rpm -Uvh *.rpm If all RPMs are installed well, the basic development environment including cross-compiler is constructed in your host PC Installing Cross Compiler To develop embedded Linux kernel, device driver, application, etc., you have to construct cross-compile environment. Cross-compile environment is development environment that is embodied in host PC to develop linux for embedded system. To create embedded program, we would have to compile the program directly in target board or compile that in host PC for target board processor. But because of restricted resources (lack of memory or storage), compiling in target board is not easy. So we construct cross-compile environment to compile embedded program sources in host PC instead of target board. To construct the environment, install tool chain for target board processor. Tool chain is collection of various utilities and libraries which are needed to compile embedded program sources. Normally, Tool chain offered by GNU is used for developing Linux. gcc compiler for GNU C, C++ GNU binary utilities (assembler, linker and various object file utilities) GNU C library

9 The steps of installing tool chain are as following. binutils --> header file link --> gcc (c compiler) --> glibc --> gcc (c++ compiler) Compiling compiler is not easy because of the problem related to bootstrap. In Here, we install tool chain easy by using RPMs of "MIZI Linux SDK". Tool chain belonging to RPMS directory of MIZI Linux SDK cross-armv4l-binutils mz.i386.rpm GNU binary utilities(assembler, linker, various object file utilities) are collected in here. cross-armv4l-kernel-headers-2.4.5_rmk7_np2-1mz.i386.rpm It includes C header files for Linux kernel. The header files defines structures and constants that are needed for building most standard programs and are needed for rebuilding the kernel. cross-armv4l-gcc mz.i386.rpm It adds C support to the GNU compiler collection. It doesn t include the standard C library. cross-armv4l-glibc mz.i386.rpm It contains the most important sets of shared libraries, the standard C library and the standard math library. cross-armv4l-gcc-c mz.i386.rpm It adds C++ support to the GNU compiler collection. It includes the static standard C++ library and C++ header files. The library for dynamically linking programs is available separately. RPMS directory of MIZI Linux SDK includes not only tool chain but also the following RPMS like minicom, etc. These utilities that ate applied by RPM format are necessary for MIZI-tool-box developing. cross-armv4l-libfloat-1.0-3mz.i386.rpm It contains a shared library of functions implementing the software floating points calls emitted by GCC when -msoft-float flag is used. cross-armv4l-zlib mz.i386.rpm It provides in-memory compression and decompression functions. cross-armv4l-jpeg-6b-2mz.i386.rpm It contains a library of functions for manipulating JPEG images, as well as simple client programs for accessing the libjpeg functions. cross-armv4l-jpeg-devel-6b-2mz.i386.rpm It includes the header files and static libraries necessary for developing programs which will manipulate JPEG files using the libjpeg library.

10 linuette_sdk_arm-1.5-1mz.noarch.rpm MIZI Linux source development kit for arm linuette_sdk_x mz.noarch.rpm MIZI Linux source development kit for x86 minicom mz.i386.rpm Minicom is a simple text-based modem control and terminal emulation program Installing Embedded Linux GUI Toolkit, Development Kit If Installing MIZI Linux SDK is finished, the total environment to develop embedded system is constructed, of course, including GUI toolkit and development Kit. But owing to MIZI Linux SDK is composed to MIZI-tool-box exclusively, if you use different target board, you have to compose toolkit newly. Among embedded systems, especially PDA, smart phone, web pad, set-top box etc. use GUI which applies window system on touch screen for communicating between user and system. The developer who uses window system has to consider window manager and requirements of application developing etc. MIZI Research provides MIZI Linux GUI library to develop applications which run on embedded linux. MIZI Linux GUI library is provided by RPMs format that are located in RPMS directory of MIZI Linux SDK. RPM Installed location For X86 linuette_sdk_x mz.noarch.rpm The files are installed under /opt/host/i386/i386-unknown-linux. For ARM linuette_sdk_arm-1.5-1mz.noarch.rpm The files are installed under /opt/host/armv41/armv41-unknown-linux. All files under this directory are already compiled, so you can test and use binary files directly Outline of MIZI Linux SDK Directory structure of MIZI Linux SDK installed in host PC If you know the structure of whole directory, you can understand development process more easily.

11 Now we explain each directory very simply. Linuette Documents RPMS SRPMS host target It is the top directory of MIZI Linux SDK and has the following subdirectories. All documents that are needed to refer are located in this directory. RPM packages to construct cross-compile environment are located in here. Source RPMs of RPM packages are located in here. Files related to Qt library are located under this directory. This directory includes the whole things to port embedded programs to target board. 3. Compiling bootloader, kernel, filesystem for target board 3.0 Introduction of bootloader In embedded system, differently in general PC, general firmware like CMOS does not exist. So to boot embedded system for the first time, we have to make bootloader which adjusted well to target board. Bootloader plays a very important part in embedded system. We explain the roles of bootloader simply below.

12 Copy kernel to RAM from flash memory, and execute kernel. Initialize hardware. Bootloader have the function that writing data to flash memory. (Downloading kernel or Ram disk by serial port or other network hardware, data is stored in RAM. But RAM lost all data downloaded if you cut power supply, so to avoid this work you have to store to flash memory.) It provides interface to send commands to target board or to inform users state of target board. What is vivi? vivi is bootloader made by MIZI Research to use exclusively at ARM line processor. Because vivi still supports only serial interface, to communicate between host PC and embedded system you have to connect host PC to target board by serial cable and execute minicom or like this. 3.1 Compiling vivi First of all, extract tarball now that vivi source files are compressed with tarball. vivi tarball source is located at /linuette/target/box/boot directory. # cd /linuette/target/box/boot # tar jxvf vivi.tar.bz2 Now we will go to vivi directory created by extraction, and compile vivi. The process is as following. To set the set points, do make menuconfig command. The results are reflected on vivi binary finally. In here, we will not set all values, instead we will load default-configuration-file which includes the set points adjusted to target board well. Under vivi/arch/def-configs directory, there are default-configuration-files for various target board. If you use MIZI ToolBox that aiji system manufactures by the name of smdk2410, load arch/def-configs/smdk2410. Otherwise you use MIZI ToolBox that Meritech manufactures by the name of s3c2410-tk, load arch/def-configs/s3c2410-tk. Then save the set points and compile vivi by make command. # cd vivi # make menuconfig

13 Select Load on Alternate Configuration File menu, then write arch/def-configs/smdk2410 or arch/def-configs/s3c2410-tk.

14 Select Ok, front page appears. Select Exit, then to save the set points select Yes. # make If compiling vivi progresses well, vivi binary file is created under /linuette/target/box/boot/vivi directory. In Next chaper, we will port vivi (bootloader), kernel image, and filesystem to target board. To do this work more conveniently, it is good collecting the compiled images to image directory. Make image directory and copy the compiled images to image directory. # mkdir /image # cp vivi /image 3.2 Compiling kernel kernel sources are compressed by the name of linux rmk7-pxa1-mz4.tar.bz2 under /linuette/target/box directory. Extract this then move to rmk7-pxa1-mz4 directory created by extraction.

15 # cd /linuette/target/box # tar jxvf linux rmk7-pxa1-mz4.tar.bz2 # cd rmk7-pxa1-mz4 Alike vivi compiling, set values by doing make menuconfig command. In here also we don t select the set points one by one, instead we load default-configuration-file that is composed with values optimized to target board. In the case of kernel, default-configuration-files are located in rmk7-pxa1-mz4/arch/arm/def-configs directory. MIZI ToolBox is two type of smdk2410 or s3c2410-tk, so if you use MIZI ToolBox named smdk2410, load arch/arm/def-configs/smdk2410 file after select Load on Alternate Configuration File menu. Otherwise you use MIZI ToolBox named s3c2410-tk, load arch/arm/def-configs/s3c2410-tk file. # make menuconfig Select Load on Alternate Configuration File menu, then write arch/arm/def-configs/smdk2410 or arch/arm/def-configs/s3c2410-tk.

16 Select Ok, front page appears. Select Exit, then to save the set points select Yes.

17 Setting for compiling kernel is over. Compile embedded kernel as following. # make zimage # make modules # make modules_install If above steps are done without problems, kernel image is created in rmk7-pxa1-mz4/arch/arm/boot directory by the name of zimage. make modules command compiles the parts selected for Module in kernel setting menu. Modules mean the part undertaking independent function under big program and before linking to the big program, modules can not do any work. According to, there is advantage that we can reduce the size of kernel by modularity. make modules_install command creates kernel, pcmcia directories under /tmp/lib/modules/ rmk7-pxa1 directory. build directory in there is not related to module, it s just symbolic linked to /tmp/lib/modules/ rmk7-pxa1-mz4 directory for easy work. The created directories by above command will be included to root filesystem image. We will deal with this process more detail the next page. We just compress kernel, pcmcia directories to move root filesystem directory at once. # tar cvf mod.tgz kernel pcmcia To port to target board easily, copy zimage(kernel image) to image directory. # cd rmk7-pxa1-mz4/arch/arm/boot/ # cp zimage /image 3.3 Creating Root filesystem Root filesystem of MIZI-tool-box is composed by Cramfs(Compressed ROM file system). Cramfs is designed small and simple. The size is restricted to 256MB, but it doesn t act on a defect in embedded system. If you want to use Korean version of root filesystem, extract root_hangul.tar.bz2 file. # cd /linuette/target/box/root_dir # tar jxvf root_hangul.tar.bz2 You can select and make English or Chinese root filesystem by your favorite.

18 In here, we will explain about how to include the modules created during kernel compiling to root filesystem. Extract mod.tgz that compresses the modules under root_hangul/usr/lib/modules/ rmk7-pxa1 directory. kernel and pcmcia directory already exist in there. # cd root_hangul/usr/lib/modules/ rmk7-pxa1 # rm-rf kernel/ pcmcia/ # tar xvf /tmp/lib/modules/ rmk7-pxa1/mod.tgz -C. You can see mkcramfs binary under /linuette/target/box/root_dir directory. It makes possible convert the sources to cram filesystem. The usage about mkcramfs is written in run.sh file. Convert the contents under root_hangul directory to root_hangul.cramfs by using mkcramfs utility. # cd /linuette/target/box/root_dir #./mkcramfs./root_hangul./root_hangul.cramfs To port easily, copy the root filesystem to image directory. # cp root_hangul.cramfs /image The all images(vivi, zimage, root_hangul.cramfs) are collected in image directory. In next chapter, we will learn about how to port the images to target board. 4. Porting Embedded Linux to target board 4.1 Porting Linux when target board booting is able Now we will write vivi(bootloader), zimage(kernel image), root_hangul.cramfs to SMC(Smart Media Card) by using imagewrite utility. This method can be used after booting target board so it s used for writing images on SMC newly or writing images to new SMC. Transfer the images and the needed utilities to target board because all works are progressed in target board. Copy imagewite utility to image directory which the images are collected in. Then transfer all things in image directory to target board by ztelnet. Imagewrite utility is located under /linuette/target/box/image directory. # cd /linuette/target/box/image/

19 # cp./imagewrite /image minicom If you use ztelnet, you have to know minicom usage first. Now we explain how to use minicom. Desktop Linux has minicom program for serial communication. It is used for command prompt of vivi or shell prompt of embedded linux. Set up the values before using minicom program. # minicom -s : Execute minicom on setting mode. Select Serial port setup item. Push A key for setting Serial Device, then write serial port which is connected to target board. (If using COM1, write /dev/ttys0, if COM2, write /dev/ttys1.)

20 Push E key for setting up bps/par/bits. (Push I to set up bps to , Push P to set up Data bits to 8, Stop bits to 1, and parity to NO.)

21 Push F key for setting up Hardware Flow Control to NO. Push G key for setting up Software Flow Control to NO. The default value is NO.

22 If setting is over, press Enter key. Select Save setup as dfl item, then press Enter for saving the values.

23 Pushing Exit key, escape from the setting mode. At this time, the set points are stored to "/etc/minirc.dfl. After setting, if you supply power to target board, bootloader begins to boot and you can see the messages of booting sequences. After booting, the terminal which executes minicom program gets to role console of embedded linux, so you can send commands to target board or execute application of target board. To quit minicom, do as following. Press Ctrl + A keys, at that moment push Q key. Then Selecting Yes, minicom is quitted ztelnet If you begin to use ztelnet, target board have to be booted. SMC applied by MIZI Research has vivi, kernel image, root filesystem, so you can boot target board by SMC. Now we will download images compiled in chap 5 to target board by using ztelnet. Before downloading, connect host PC and target board by Ethernet cable. This work is progressed by two terminal windows, one is terminal executing minicom, and the other is terminal located at image directory. Terminal 1 : terminal which location is image directory

24 Terminal 2 : terminal which executes minicom (console of target board) (1) Executing minicom Terminal 1 : Terminal 2 : # cd /image # minicom After progressed booting of target board, press Ctrl + C and Enter, then you can begin to use shell of target board system. (2) Setting up IP (Both host PC and target board) Terminal 1 : Terminal 2 : # ifconfig eth0 down # ifconfig eth : Set up arbitrary IP. # ifconfig eth : Set up IP that can make a pair with that of host PC.

25 # inetd (3) Checking that two systems can communicate Terminal 1 : #ping : We can confirm that it s communicating between host PC and target board by ping command.

26 (4) Contact to target board by ztelnet Terminal 1 : # ztelnet Login by root account. Because you don t need to input password, press Enter key. (5) Transferring the images Terminal 1 : # cd /tmp # rz Pushing Ctrl + ], ztelnet> console appears. ztelnet> sz vivi zimage root_hangul.cramfs imagewrite

27 You may have question why we download the images at tmp directory. It s because only tmp directory can be possible both reading and writing, all directories except tmp are read-only filesystems. But tmp directory is ramfs, so if power supply is cut, all images downloaded are deleted. If you want to store the images, you have to write those to flash memory by using a special utility. After downloading all images, check the downloaded items by ls command. All images are transferred to target board. To write the images to SMC(flash memory), we will use imagewrite utility. Contents about using imagewrite utility are explained in next page imagewrite (1) Creating Partitions in SMC

28 Terminal executing minicom enable host PC user to work inside target board. We will make three partitions. #./imagewrite /dev/mtd/0 -part 0 192K 1M We divide SMC capacity to three partitions, and the size of each partition is as following. 0~192KB / 192KB~1MB / 1MB~End-part We will write vivi at 0~192KB partition, zimage at 192KB~1MB partition, and root_hangul.cramfs at 1MB~End-part partition. (2) Storing the images in SMC by using Imagewrite Usage : #./imagewrite <mtd_dev> <file:offset> #./imagewrite /dev/mtd/0 vivi:0 : Store vivi in SMC. #./imagewrite /dev/mtd/0 zimage:192k : Store zimage in SMC. #./imagewrite /dev/mtd/0 root_hangul.cramfs:1m : Store root_hangul.cramfs in SMC. Result Screen of #./imagewrite /dev/mtd/0 vivi:0 command

29 Result screen of #./imagewrite /dev/mtd/0 root_hangul.cramfs:1m command 4.2 Porting Linux when target board booting is disable Uploading vivi by using JTAG JTAG cable and Jflash program are needed to port by this method. Jflash program and HOWTO_USE.txt written about usage of Jflash program are located under /linuette/target/box/jflash directory. # cd /linuette/target/box/jflash Because we will write vivi(bootloader) to SMC by Jflash program, copy Jflash program to image directory. When or Why JTAG is used are mentioned in chap 4. Refer it.

30 # cp./jflash-s3c2410 /image Connect target board and host PC by JTAG. Check the size of SMC(flash memory), then supply power to target board. The capacity of SMC is written at backside of itself. #./Jflash-s3c help SEC JTAG FLASH(SJF) v modified by MIZI Usage: SJF <filename> /t=<flash_type> /d=<delay> Flash Type List 1:SMDK2410:K9S3208 4MB 2:SMDK2410:K9S6408 8MB 3:SMDK2410:K9S MB 4:SMDK2410:K9S MB 5:SMDK2410:K9S MB 6:SMDK2410:AM29LV800BB Also if you perform above command, you can know that it s needed different options when executing Jflash program according to the size of flash memory. MIZI-tool-box uses 64MB SMC, so we have to give /t=5 option. Execute Jflash program with /t=5 option. If you uses different flash memory, option will be changed. #./Jflash-s3c2410 vivi /t= SEC JTAG FLASH(SJF) v modified by MIZI > flashtype=5 > S3C2410X(ID=0x d) is detected. > K9S1208 is detected. ID=0xec76 K9S1208 NAND Flash JTAG Programmer Ver 0.0 0:K9S1208 Program 1:K9S1208 Pr BlkPage 2: Exit Select the function to test :0 : Input 0. [SMC(K9S1208) NAND Flash Writing Program]

31 Source size: 0xe4af Available target block number: 0~4095 Input target block number:0 : Input 0. target start block number =0 target size (0x4000*n) =0x10000 STATUS:Epppppppppppppppppppppppppppppppp Epppppppppppppppppppppppppppppppp Epppppppppppppppppppppppppppppppp Epppppppppppppppppppppppppppppppp K9S1208 NAND Flash JTAG Programmer Ver 0.0 0:K9S1208 Program 1:K9S1208 Pr BlkPage 2: Exit Select the function to test :2 :Quit by pushing 2. Through above work, vivi is written to flash memory Porting images by using vivi Above all things vivi(bootloader) should be stored in SMC(flash memory), only so we can write vivi(bootloader), kernel image, root filesystem etc. to SMC on prompt mode of vivi(bootloader). Exactly, if bootloader doesn t exist in flash memory, we first write bootloader by JTAG. We have uploaded vivi to SMC in above pages, so Now we will downloaded vivi(bootloader), kernel, Root filesystem etc. by xmodem of minicom. Executing vivi prompt mode Execute minicom after connecting host to target board by serial cable. Supply power to target board, in that case target board is waiting inputs during the times defined by developer. If we do not input anything or press Enter, target board begins to boot. Instead, if you input space-bar key, target board enters vivi prompt mode. The waiting time of target board is very short so press space-bar quickly if you want to use target board console. # minicom Supply power to target board, then press space-bar quickly. vivi> SMC Partitioning and Writing vivi image If writing vivi on SMC is done successfully, you can boot(?) a little and use vivi prompt. In here, you can write all images including vivi again through vivi prompt. But before writing the images, you have to do partitioning SMC to assign the

32 memories. SMC is composed of bon filesystem and vivi supports this. So you can make partitions through vivi prompt. Make partitions by following command. vivi> bon part 0 192k 1M This command make three partitions which size are 0~192k, 192k~1M, and 1M~64M.

33 0~192k : vivi will be written here. 192k~1M : zimage(kernel) will be written here. 1M~64M : root.cramfs(root filesystem) will be written here. Above command does formatting SMC as well as partitioning it. So if you do next steps like writting kernel and root filesystem, you have to write vivi again. Write vivi by following command. vivi> load flash vivi x

34

35 Writing kernel image # cd /image # minicom Supply power to target board, then press space-bar quickly. After sending load flash kernel x command, press Ctrl+A keys, and without delay press S key. Window questioning about transfer mode will appear. In there, select xmodem. Then terminal executing minicom will show the present location of host PC. Find the kernel image and select that by space-bar. Pressing Enter, transferring will starts. vivi> load flash kernel x

36 Quickly press Ctrl + A and S, then select xmodem for transfer mode. If you press space-bar twice, directory changing happens and if you press space-bar once, relevant data is selected. Select zimage by pressing space-bar one time.

37 Press Enter, then transmission begins. If transfer incomplete message is appeared when writing images, the cause is that the timeout of xmodem_initial is too short. In this case, you can solve the problem by increasing the timeout of xmodem_initial.

38 First check the value of xmodem_initial_timeout parameter. Then you think it is too short, extend timeout properly. # param show # param set xmodem_initial_timeout : means 1 second because a unit is microsecond. # param save After setting like above, do writing images again. Writing root image Let's write root filesystem in SMC. The steps of this work are the same as those of above. But there is one caution. vivi can't write the root image, which size is bigger than 1.2MB, on SMC. Because vivi is coded to use decided partition size of bon filesystem that is a kinds of layer for nand flash, although it controls all area of SMC. The decided size is approximately 1.2~1.3MB. So, please use small size of root image when writing root filesystem on SMC. If you have finished this work well and rebooted target system, you can use the console of target system. The detail steps of writing root image are listed as bellowing. Just follow. Send load flash root x command, then press Ctrl+A keys, and S key without delay. Window questioning about transfer mode will appear. In there, select xmodem.

39 Then terminal executing minicom will show the present location of host PC. Find the root image and select that by space-bar. Pressing Enter, transferring will starts. vivi> load flash root x Quickly press Ctrl + A and S, then select xmodem for transfer mode. If you press space-bar twice, directory changing happens and if you press space-bar once, relevant data is selected. Select root.cramfs by pressing space-bar one time. Press Enter, then transmission begins. If you want to use bigger size of root filesystem that includes usr applications(gui), upload the root image such as root_english.cramfs to tmp directory of target system throuth ztelnet and then write it to SMC by using imagewrite utility. The detail steps of it are explained in "4.1.3 imagewrite". Refer it. Writing root image is devided into two parts because loading big root image through serial cable takes too long. 5. How to use development environment 5.1 How to use Virtual FrameBuffer It is natural for host PC using Linux OS to use framebuffer to develop embedded linux system, but it is very discontented development environment coming and going between host PC and target board continuously. To solve this inconvenience, Qt provides Qt Virtual FrameBuffer. It s usually marked qvfb, and if you use qvfb, you can execute and test Qt/Embedded program in X-windows screen. Executing qvfb Qt/X11 and Qt/Embedded, each directory has 2.3.1/tools/qvfb subdirectory. Both qvfb binaries under there, only that of Qt/X11 works well. We will use qvfb binary under Qt/X11/2.3.1/tools/qvfb directory. Now execute qvfb compiled for Qt/X11. # cd /linuette/host/qt/x11/2.3.1/tools/qvfb Seeing under qvfb, you can find qvfb binary and env.sh file to establish environment variables more easily. Contents of env.sh file are as following.

40 # vi env.sh export QTDIR=/linuette/host/Qt/X11/2.3.1 export PATH=$QTDIR/bin:$PATH export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH Set up environment values, then execute qvfb. #../env.sh : Apply environment variables. # echo $QTDIR : We can check that environment values set up correctly. #./qvfb -width 800 -height 600 -depth 16 & : Execut qvfb by fitting those options. Executing Qt/embedded program on qvfb # cd /linuette/host/qt/embedded/2.3.1/examples/launcher Set up environment variables by env.sh file, then execute launcher program after executing qvfb. Look into contents of env.sh file. # vi env.sh export QTDIR=/linuette/host/Qt/embedded/2.3.1 export QTEDIR=/linuette/host/Qt/embedded/2.3.1 export LD_LIBRARY_PATH=$QTDIR/lib:$QTEDIR/lib:$LD_LIBRARY_PATH #../env.sh

41 #./laucher & Compiling MIZI Linux example source and Executing it on qvfb There are two simple MIZI Linux examples in /linuette/host/example directory. Sources under the directory are not compiled yet, but only giving make command after setting up environment values by env.sh file, compiling will be done. We will execute example programs on qvfb. First, execute qvfb after inputting environment variables which is needed to execute qvfb. Then execute example program. Terminal 1 : # cd /linuette/host/qt/x11/2.3.1 # export QTDIR=/linuette/host/Qt/X11/2.3.1 # export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH You can set up environment variables not only by env.sh file, but also by inputting the contents of env.sh file to terminal directly. Terminal 1 : Terminal 2 : # cd tools/qvfb #./qvfb -width 800 -height 600 -depth 16 & # cd /linuette/host/example/helloworld #../env.sh # make #./qhello -qws

42 You can see qhello_ko.cpp source file under helloworld directory. When compiling the sources, if you use qhello_ko.cpp instead of qhello.cpp, program will show Korean words as following picture. If qvfb was already executed, follow the process below. If not, execute qvfb binary ahead, then do following steps. When executing qvfb, use separate terminal window. # cd /linuette/host/example/tetris #../env.sh

43 # make #./tetris -qws 5.2 How to use tmake Using tmake for x86 We will learn how to use tmake utility. We select tetris example between two examples under /linuette/host/example for testing. Already project file named tetrix.pro and Makefile exist, so change the file names to tetrix.pro.bak and Makefile.bak in turn. Set up the PATH to use tmake utility. Originally, we have to set up both TMAKEPATH and PATH. But in case PATH, we don t need to set up this because tmake binary is included in existing PATH if using tmake-1.7-3mz.noarch.rpm offered by MIZI Linux SDK. # cd /linuette/host/example/tetris # export TMAKEPATH=/usr/lib/tmake/lib/qws/linux-x86-g++ Make project file control many source files conveniently. # progen -n tetris -o tetris.pro # vi tetris.pro TEMPLATE =app

44 CONFIG =qt warn_on release HEADERS = SOURCE = TARGET = tetris The structure of project file is as above. If you want to add header files or source files, just write the file names adjust to item. Make Makefile by using tmake utility. # tmake tetris.pro -o Makefile We made project file and Makefile control Qt sources conveniently. Now we will create binary by compiling sources. Before compiling sources, we have to set up PATH of QTDIR and LD_LIBRARY_PATH The created sources refer Qt/Embedded library of x86, so the PATHs are as following. Unless setting up PATH, the sources are not compiled. # export QTDIR=/opt/host/i386/i386-unknown-linux # export LD_LIBRARY_PATH=$QTDIR/lib:LD_LIBRARY_PATH You can set up the values by env.sh file because the above contents are written in this file. After setting, compile the sources. Compiling being over, tetris binary will be created. This program uses framebuffer, so execute tetris binary after executing qvfb. # make Usually, error happens when execute make command. It happens because some library are not linked. We can solve this problem by one of the following methods. (1) Modifying project file Add the following contents to project file, then create Makefile and compile sources. SOURCE = LIBS = -llinuetteapp -lcustomwidget -lmzdateformat TARGET = (2) Modifying Makefile

45 Add -llinuetteapp -lcustomwidget -lmzdateformat to LIBS item of Makefile, then compile sources. LIBS = $(SUBLIBS) -L$(QTDIR)/lib -llinuetteapp -lcustomwidget -lmzdateformat (3) Modifying tmake.conf Add -llinuetteapp -lcustomwidget -lmzdateformat to TMAKE_LIBS item of tmake.conf file, then compile sources. tmake.conf file is located under /usr/lib/tmake/lib/qws/linux-x86-g++/ directory. TMAKE_LIBS = -llinuetteapp -lcustomwidget -lmzdateformat If you do one of three methods, error will not happen when recompiling. New terminal : # cd /linuette/host/qt/x11/2.3.1 #../env.sh # cd tools/qvfb #./qvfb -width 800 -height 600 -depth 16 & Existing terminal : #./tetris -qws & Using tmake for arm There are no differences between using tmake for x86 and using tmake for arm. Just the difference is that we have to change PATHs of TMAKEPATH, QTDIR, and LD_LIBRARY_PATH because sources for arm refer Qt/Embedded library of arm instead of x86. The binary created like this can execute and test only in target board. We select /linuette/target/example/tetris sources to compare with the front page. Set up TMAKEPATH to use tmake utility alike the front page. # cd /linuette/target/example/tetris # export TMAKEPATH=/usr/lib/tmake/lib/qws/linux-linuette-g++ Make a project file that binds all sources related, then create Makefile by using tmake utility. # progen -n tetris -o tetris.pro # tmake tetris.pro -o Makefile

46 The same error occurs in here when executing make command, so solve the problem by modifying tetris.pro or Makefile or tmake.conf. (1) Modifying project file Add the following contents to project file, then create Makefile and compile sources. SOURCE = LIBS = -llinuetteapp -lcustomwidget -lmzdateformat TARGET = (2) Modifying Makefile Add -llinuetteapp -lcustomwidget -lmzdateformat to LIBS item of Makefile, then compile sources. LIBS = $(SUBLIBS) -L$(QTDIR)/lib -llinuetteapp -lcustomwidget -lmzdateformat (3) Modifying tmake.conf Add -llinuetteapp -lcustomwidget -lmzdateformat to TMAKE_LIBS item of tmake.conf file, then compile sources. tmake.conf file is located under /usr/lib/tmake/lib/qws/linux-x86-g++/ directory. TMAKE_LIBS = -llinuetteapp -lcustomwidget -lmzdateformat Set up PATH of QTDIR, LD_LIBRARY_PATH to compile Qt sources. # export QTDIR=/opt/host/armv4l/armv4l-unknown-linux # export LD_LIBRARY_PATH=/usr/lib:/lib:$QTDIR/lib:$LD_LIBRARY_PATH Compile then check that tetris binary is for arm. # make # file tetris tetris: ELF 32-bit LSB executable, ARM, version 1 (ARM), dynamically linked (uses shared libs), not stripped

47 5.3 How to compile and use Qtopia source The following contents are on the assumption that cross-compiler and qvfb are already installed. If you installed MIZI Linux SDK well, it doesn t have any problems. Set up environment variables. # cd /linuette/host/qt/embedded/2.3.1 # export QTDIR=`pwd` # cd /linuette/host/qt/qpe/1.3.1 # export QPEDIR=`pwd` Build qt for QPE. # cp qt/qconfig* $QTDIR/src/tools/ # cd $QTDIR #./configure -system-jpeg -gif -qvfb -qconfig qpe # make Now build qtopia. # cd $QPEDIR # cp /linuette/host/qt/x11/2.3.1/bin/uic $QTDIR/bin #./configure -debug # make If you do make without cp /linuette/host/qt/x11/2.3.1/bin/uic $QTDIR/bin, error message will occur saying uic file doesn t exist. It can be solved by copying uic file which located in /linuette/host/qt/x11/2.3.1/bin directory to /linuette/host/qt/embedded/2.3.1/bin directory. Execute qvfb. New terminal : # cd /linuette/host/qt/x11/2.3.1/tools/qvfb #./qvfb -depth 16 & Execute qtopia. Existing terminal : # cd $QPEDIR/bin #./qpe -qws

48