Download Development of Network Interface Card (NIC) RT

Development of Network Interface Card (NIC)
RT-8139C Device Driver in Linux for PowerPC
Sai kumar Devulapalli1, Shilpa Chaudhari2
IStudent, M.Sc. (Engg.), 2Asst Professor & Program Manager
Centre for Embedded Systems Design, M. S. Ramaiah School of Advanced Studies, Bangalore.
Abstract
Linux is playing a significant role in the embedded applications, and Device drivers take a major responsibility
in developing the Linux kernel. This thesis is aimed at the design and implementation of a device driver for Network
Interface Card (NIC) RT-8139C to transfer data from PC to the physical media, and from physical media to the upper
layers between the NIC card to the outside world. This is realized using Linuxfor PQ2FADS (PowerQUlCC 11Family
Application Development System) PowerPC target board
To design and implement this device driver for NIC RT-8I39C on PQ2FADS PowerPC (target) board, operating
System (OS) is required to enable the networkfunctionalities. So OS has to reside on the target board. Therefore porting
of Linux OS has to be done on the PQ2FADS PowerPC board. Linux is conjigured to make a compact kernel image
according to the application requirement for the development of device driver for NIC.Conjigured Linux kernel image is
compiled and installed. The compiled kernel image is ported onto the embedded hardware PQ2FADS PowerPC board.
As the Ethernet facility is available for x86 machines this thesis is aimed to give the same option for the PowerPC
architectures. As Linux is portable on various architectures just by conjiguring the Linux kernel with the PowerPC will
make the task easier.
Device driver routines are designed in Linux for Network Interface Card. Soft code is written for the designed
device routines in Linux for the NIC. The compiled Universal Bootloader (U-Boot) and the compact Linux kernel image
suitable for the PowerPC processor are ported on to the PQ2FADS-ZU PowerPC target board. Routinesfor the NIC were
written successfully and the data transfer between the NIC card and the outside world using Linux was demonstrated.
Key Words: NlC RT-8139C Device Driver, PowerPC, Bootloader, Linux Kernel, PQ2FADS, Porting.
Nomenclature
API
CRC
CRM
ERSR
IPC
ISR
LAN
MAC
NIC
PCI
PHY
PPC
PQ2FADS
RCR
RX
TSR
TX
WOL
good networking support and PPC architecture was
chosen as it is a powerful 32-bit processor. Before
porting Linux on to the PQ2FADS-ZU target board,
there is a need to build a toolchain (cross-compiler,
assembler, linker and other standard GNU tools) that
generates a Linux image for the PQ2FADS-ZU target
board on a standard x86 host PC [I]. Linux kernel is
configured to make a compact kernel image according
to the application requirement which is the development
of device driver for network interface card.Configured
kernel is compiled and installed, and the compiled
Linux kernel image is ported onto the embedded
hardware PQ2FADS-ZU PowerPC target board. Device
driver routines are designed in linux for Network
Interface Card .Soft code is written for the designed
device routines in Linux for the NIC card.
Application Programmable Interface
Cyclic Redundancy Check
Clock Recovery Module
Early Reception Status Register
Inter Process Mechanism
Interrupt Status Register
Local Area Network
Medium Access Control Layer
Network Interface Card
Peripheral Component Interface
Physical Layer
PowerPC
PowerQUICC II Family Application
Development System
Receive Configuration Register
Reception
Transmission Status Register
Transmission
Wake-On-LAN
2. SOFTWARE REQUIREMENTS AND
HARDWARE SETUP
To design and implement the device driver: Red Hat
Linux 9.0, Metrowerks CodeWarrior 8.6, Linux kernel
2.4.20, Binary utilities (2. I0.1), Bootstrap compiler
(gcc-3.3.2), C library setup (glibc-2.3.2) and Glibclinuxthreads (2.3.2) are the SfW requirements required.
The HfW requirements include PQ2F ADS PowerPC
Target Board, RT-8139C NlC Card, ATX Power
Supply, Power Cable, Category 5 Ethernet Cable, RS-
1. INTRODUCTION
The reason to choose Realtek RTL-8139C is a highly
integrated and cost-effective Fast Ethernet controller
that provides 32-bit performance, and supports Full
Duplex Flow Control [12]. The reason to choose Linux
OS is it's an open source and freeware and it has very
SAsTECH
44
Vol. VI, No.1, April 2007
232 Serial Cable, CodeWarrior
Parallel Cable.
USB TAP emulator,
Prepare a directory known as build-tools directory [1].
Basically this directory contains installed tool chain
packages (Binary Utilities setup, Compiler setup, C
library setup, Full compiler) which are shown in the
figure 2.
$ cd ${PRlROOT}lbuild-tools
3. PROCEDURE TO PORT LINUX ON
PQ2FADS POWERPC TARGET BOARD
Linux is one of the operating systems that run on the
PowerPC Processors. To port Linux on to the
PQ2FADS PowerPC target board PPC target board, the
steps to be followed to build and install the Linux image
on to the PQ2FADS PowerPC Processor is shown in the
figure 1.
$ mkdir build-binutils build-boot-gcc build-glibc buildgee
The selected versions for these packages, which are
downloaded from ftp.gnu.org [3], are:
~
Binary utilities setup: binutil-2. I0.1
~
Kernel headers setup [4]: Iinux-2.4.20
~
Bootstrap compiler setup: gcc-3.3.2
~
C library setup: glibc-2.3.2 and
~
Glibc-linuxthreads-2.3.2.
3.1 Procedure for Tool Chain Development
Before keeping the Linux image on to the target board,
there is a need to build a toolchain (cross-compiler,
assembler, linker and other standard GNU tools) that
could generate Linux image for the PowerPC [8] of
PQ2FADS target board on a standard x86 host PC. In
order to build the tool chain, installing of four necessary
packages involved in the development of tool chain is
shown in the figure 2.
The porting. sh script is written to build the
selected toolchain. This script file avoids writing the
whole path each and every time.
!
!
!
Unpack the Packages
Configuring the Packages
!
!
!
Toolchain Development
Building the Packages
Kernel Setup
Installing the Packages
Figure 3: Steps to Build the Packages
Root Filesystem Setup
After selecting the packages of the required versions
steps involved carrying out for the tool chain building is
shown in the figure 3.
The first step is to setup (unpack) the binutils package to
extract its source code from the downloaded archive [3].
Bootloader Setup
Fig. 1: Steps involved in the Porting
export PROJECT=porting-module
export PRJROOT=/home/msrsas/control-project
export TARGET=ppc-linux
export PREFIX=${PRJROOT}/tools
export TARGET_PREFIX=$ {PREFIX}/$ {TARGET}
exportPATH=${PREFIX}lbin :${ PATH}
cd$PRJROOT
3.2 Binary Utilities Setup
$ cd $ {PRlROOT}lbuild-tools
$ tar xvzf binutils-2. 10.I.tar.gz
This will create a directory called binutils-2.10.1 with
the package's content. The configuration of the package
for cross-platform development is the next step [1].
$ cd build-binutils
$ ..lbinutils-2.12.I/configure
--target=$T ARGET
prefix=${PREFIX}
Through this configure command; control the
creation of the Make files by passing the appropriate
options to configure. By using this Make file, build the
actual utilities using $ make
With the package now built, install the binutils by using:
$ make install
The binutils have now been installed inside the
directory pointed to by PREFIX. Check that the binutils
have been installed properly in the ${PREFIX}lbin
directory as shown in figure 4.
!
!
!
Binary Utilities Setup
Compiler Setup
C Library Setup
Full Compiler Setup
3.3 Bootstrap Compiler Setup
In contrast to the binutils package, the gee package
contains one more extra utility known as, the GNU
Fig. 2: Necessary Packages involved in the
Development of Tool chain
SASTECH
45
Vol. VI, NO.1, April 2007
$ cd $PRJROOT
$ mkdir kernel
$ cd kernel
$ tar -xvjflinux-2.4.20.tar.bz2
This will create a directory called linux-2.4.20
with the package's content. The linux kernel will be
configured in the directory, which was created for the
kernel setup
compiler, along with support components such as
runtime libraries.
$ cd $ {PRJROOT}/build-tools
$ tar xvzf gcc-3.3.2.tar.gz
This will create a directory called gcc-3.3.2 with
the package's content. The gee was configured in the
directory, which was created for the bootstrap compiler
cd build-boot-gcc
$ ..Igcc-3 .3.2/configure--target=$T ARGET-prefix=${PREFIX} --without-headers --with-newlib
enable-languages=c
3.5 Configuring
$ cd linux-2.4.20
$ make ARCH=ppc CROSS_COMPlLE=ppc-linuxmenuconfig
Linux was configured by cross compiling with the
PowerPC [8] using ppe-IinuxBy executing the command to configure the linux with
the PowerPC processor a window will be displayed to
configure the kernel according to the desired
application.
Linux kernel need to be configured in such a
way that to make a small kernel image according to the
application requirement, which in turn will be ported
onto the embedded hardware board [2]. Here the
configuration for the network file system support has to
be configured done for the purpose [5]of the device
driver.
After completion of the kernel configuration, the
newly configured kernel was saved for the development
of the required application. Crosschecking has to be
done to make sure whether the kernel configuration was
done properly or not.
This verification was done by the creation of
version.h file [I] inside the includelLinux directory of
linux-2.4.20.
$ Is $${PREFIX}/bin
ppc-linux-addr2Iine
ppc-linux-objdump
ppc-linux-as
ppc-linux-gasp
ppc-linux-objcopy
ppc-linux-ld
ppc-linux-nm
ppc-linux-ranlib
ppc-linux-ar
ppc-linux-c++filt
ppc-linux-readelf
ppc-linux-size
ppc-linux-strings
ppc-linux-strip
Fig. 4: Checking of the ...Ibin directory after
installing the Binary Utilities
On success, make file will be generated. Using
that Makefile the compiler will be build with the
command $ make all-gee. After the successful building,
the GCC (Gnu's Cross compiler) is installed using the
command $ make install-gee
The bootstrap compiler is now installed along
with the binutils, and this can be crosschecked by relisting the content of ${PREFIX}/bin [I]. The name of
the compiler, like the utilities, is prep ended with the
name of the target and additionally "ppe-linux-gee" will
be added as shown in the figure 5
3.6 Compiling
$ Is $${PREFIX}/bin
ppc-linux-gcc
ppc-linux-objdump
ppc-linux-addr2line
ppc-linux-c++fiIt
ppc-linux-objcopy
ppc-linux-ld
ppc-linux-readel
ppc-linux-nm
ppc-linux-size
ppc-linux-ranlib ppc-linux-strings
ppc-linux-ar
ppc-linux-strip
ppc-linux-gasp
ppc-linux-as
Procedure
for Linux Kernel
3.7 C Library
Configuring
Compiling
Building
!
!
Setup
Kernel
the Kernel
the Kernel
the Kernel
Fig. 6: Procedure for Linux Kernel Setup
SAsTECH
Setup
The glibc package is made up of a number of libraries
and is the most delicate and lengthy package build in
the process of Cross-Platform development toolchain
[2]
$ cd ${PRJROOT}/build-tools
$ tar xvzf glibc-2.3.2.tar.gz
This will create a directory called glibc-2.3.2 with the
package's content. In addition to the C library, Linux
threads package was also extracted in the glibc directory
using $tar-xvzfglibc-linuxthread-2.3.2.tar.gz-directory
=glibc-2.2.4.
After extracting the Linux threads, the C library was
build in the build-glibc directory
$ cd build-glibc
$CC=ppc-linux-gcc ..Iglibc-2.3.2/configure-host=$T ARGET --prefix=$PREFIX --enable-add-ons-with-headers=${T ARGET ]REFlX}/include
Firstly, configure with CC=ppc-linux-gcc. The
effect of this command is to set the Cc environment
The procedure involved in the Linux kernel [4] Setup is
shown in the figure 6. Linux 2.4.20 Kernel was used to
port linux on to the PQ2FADS PowerPC target board
[7].
selectinlthe
the Linux Kernel
After configuring the kernel the kernel has to be
compiled using $ make bzImage. When the kernel got
compiled 'VmLinux" will be generated in the $ cd
linux-2.4.20 to make sure that the kernel got installled
successfully without any errors [4].
Along with the VmLinux, a zlmage will be
created in the archlppc/bootlimagesl which is used for
the porting purpose.
Fig. 5: Checking of the ...Ibin directory after
installing the GNUs Cross-Compiler
3.4 Solution
the Linux kernel
46
Vol. VI, No.1, April 2007
11c) Check Restricted Address Range
Start = FF800000
End = FFFFFFFF
lId) Check Offset Address: Offset = FFFOOOOO.
lIe) Click the Program button. This will
take some time. Wait until the status box
indicates that the programming operation is
complete.
lIt) Click the Verify button to verify that
the flash was successful.
12. Power off the board and disconnect the USB Tap
from the board.
13. The boot loader u-boot is now ready to be used.
Return to Platform Creation Suite and continue with
the deploy process.
The V-Boot
sequence
for the PQ2F ADS
PowerPC target board is shown in the figure 7.
variable to ppc-linux-gcc. After configuring the C
library setup the glibc was compiled using $ make
The C library will be installed using $ make
installJoot=${TARGET_PREFIX}
prefix="" install
In the
above
command
install root
variable is used to specify the directory and this ensures
that the library and its headers are installed in the targetdependent
directory,
which
was
assigned
to
TARGET PREFIX earlier.
3.8 Procedure
PQ2FADS-ZU
to install u-boot on the Flash of
board
U-boot knows as universal boot loader is used to build
the PQ2FADS-ZU (IOOMHz) board. Once after
configuring and successful installing the (V-boot) boot
loader different formats of U-boot files will be
generated. In that U-boot.bin image format is required
for the target board [I].
The steps below explain how to program u-boot
into the target board's flash memory.
U-Bootloaller
Done
Flash
Devin':
LlU8F016SC
isAdllress:
at:Format.
OxOOOO1800
Auto-detection
isStart
successful.
Flash
Buffer
Size
is:
OxOOOlE800
Trying
auto-detect
...............
Flash
Timestmnll:
l\'Iemory
well
Mm'
Address:
716:57:05
OXFFSOOOOO
2007
Programming
file
C:\Documents
and
Not
of
type
Motorola
S-Record
Format.
Memory
Organization:
End
204SK*S
OXFFFFFFF
Loading
Flash
Device
Driver
at:*4
OxOOOOOOOO
Settings\Administra
tor\De
sktop\uboot.
bin
NOT
of
type
Elf
Memory
at
OxFFFOOOOO
File
isDriver
of
type
Binary/Raw
Format.
Close
Initialization
Command
Succeeded
Using
Algorithm:
Sharp
8*4.elf
Timestamp:
Programming Wed
Ox00011111
Mar 7 16:57:502007
bytes of Target
Execute: program
I. CodeWarrior has to be installed.
2. As Code Warrior is used for Windows, there is a need
to transfer the u-boot.bin image file to the windows
system.
3. Start CodeWarrior IDE.
4. Connect the USB TAP PRO to the debug connecter
labelled "COP/IT AG" on the
PQ2F ADS board. Make
sure to connect pin 1 of the ribbon cable connector to pin
1 of the connector on the board.
5. Connect power to the PQ2FADS board and
power on the board.
6. In CodeWarrior select "Tools -> Flash Programmer".
7. Click the load Settings button and select the file:
82xx]Q2]
ADS _ZU.xml
8. In Flash Programmer window, select "Target
Configuration".
8a) Check the 'Use Custom Settings' box and select:
Target Processor: 8280
Connection: USBTAP PRO MCW
8b) Check the 'Use Target Initialization' box and
Make sure that the path ends with the
appropriate file for the specified target board:
PQ2FADS-ZU:
PQ2] ADS_ ZU_ LocaUnit_1 OOMHz.cfg
8c) Target Memory Buffer
Target Memory Buffer Address: 00000000
Target Memory Buffer Size: 00020000
9. In the Flash Programmer window, select "Flash
Configuration" .
9a) 'Flash Memory Base Address' = FF800000.
9b) 'Device' = LH28FO 16SC
9c) 'Organization' = 2048Kx8x4
10. In Flash Programmer window, select "Erase / Blank
Check".
lOa) Check 'All Sectors' and check
'EraselBlank Check Sectors Individually'.
lOb) click the Erase button.
11. In Flash Programmer, select "Program / Verify".
II a) Check the 'use selected file' box.
Click the browse button and to go to the folder
where you saved the u-boot.bin image.
lIb) Set the File Type to Auto Detect or
BinarylRaw Format.
SAsTECH
Fig. 7: U-Boot sequence for the PQ2FADS board
47
Vol. VI, No.1, April 2007
3.9 Building
a Root Filesystem
3.12 Block Devices
(RFS)
A local RFS was installed on the CF card and a
BuysBox 1.1.0 infrastructure is used to build it. Linux
kernel must have a Root Filesystem, which consists of
the startup files necessary to power up the system to a
fully running state. RFS will provide all the utilities like
Is, chmod etc. as well as the file system. There are two
options to locate the RFS [5]. The first one is to keep it
onto the same compact flash (in a different partition)
where the system. ace file resides. The second is to boot
diskless and let the board find one on the network. The
procedure for building both is same - the difference is in
where to put and how to find them using kernel.
BusyBox was configured and installed by downloading
it from the figure 8. The first step is configuration of the
BusyBox [6].
3.10 Procedure
Like character devices, the block devices are accessed
by Filesystem nodes in the /dev directory. A block
device is something that can host a Filesystem, such as a
disk.
3.13 Network
Any network transaction is made through an interface,
that is, a device that is able to exchange data with other
hosts. Usually, an interface is a hardware device, but it
might also be a pure software device, like the loopback
interface. A network interface is in charge of sending
and receiving data packets, driven by the network
subsystem of the kernel, without knowing how
individual transactions map to the actual packets being
transmitted. I addition to device drivers, other
functionalities, both hardware and software, are
modularized in the kernel [II].
to Design the Driver for NIC
The UNIX way of looking at devices distinguishes
between three device types. Each module usually
implements one of these types, and thus is classifiable
as a char module, a block module, or a network module
[9].
3.11 Character
3.14 Device Driver
Devices
thesis it is the NIC device) that contains the functionality
of the 802. I I protocol, that being MAC, PHY, and a
connection to the wireless media. Typically the 802. I I
functions are implemented in the hardware and software
ofa network interface card (NIC) [10].
~ This project is aimed to the data transfer from
system to physical media and to transfer from physical
media to upper layer as shown in the figure 9. BIOS will
map the device to system memory where starting and
ending addresses are located. These addresses will be
used to send data and to receive the data.
General Configuration
~
Support for devfs
Build Options
~
Do you want to build BusyBox with a Cross
Compiler?
~ This project consist of the following modules,
init_module, probe function, tx-packet and rx-packet are
the important modules [9]. The init_module function will
register the driver to the global linked list that will be
maintained by the system.
Login I Password Management Utilities
~ Addgroup
~ Delgroup
~ Deluser
~
Getty
~
Login
~
Support for letclsecurity
~
Passwd
~
Su
~
Sulogin
~
Networking Utilities
~
Inetd
~
Ifconfig
~
Ip
~
~
~
~
netstat
nslookup
telnet
telnetd
The probe function will initialize some structures
and files. It will get the IRQ number, which will be
assigned by the system while registering. The probe
function will construct private structure, which
contains several information, which is required to
do the transformation of data. It will find out the
starting & ending addresses that are mapped in.
Probe function will enable and reset the device and
soon.
~
The tx-packet function will transmit the data from
system to physical media. The transmit path of RT8139C makes use of4 descriptors [11] as shown in
the figure 9. These descriptors are used in round
robin fashion. Each of these descriptors has a fixed
110 address offset. As a descriptor is written PCI
operation starts and moves the packet in the
memory, which the descriptor specifies to transmit
FIFO.
~ This transmit FIFO is a 2k bytes buffer in the chip
that hold the data prepared to move to line (cable) as
showing CPU usage percentage
Figure 8: Configuring the BusyBox
SAsTECH
Design Flow for RT-8139C
Device drivers take a special role in Linux kernel. The
station (STA) is the most basic component of the
wireless network. A station is any device (As per the
A character (char) device is one that can be accessed as
a stream of bytes (like a file); a char driver is in charge
of implementing this behavior. Such drivers usually
implement at1east the open, close, read, and write
system calls.
Process Utilities
~ Top
~
Support
Interfaces
48
Vol. VI, No.1, April 2007
transmission by storing an entire packet of data in one
of the descriptors in the main memory. When the entire
packet has been transferred to the Tx butTer, the
RTL8139C is instructed to move the data from the Tx
butTer to the internal transmit FIFO in PCI bus master
mode [12]. When the transmit FIFO contains a complete
packet or is filled to
the programmed threshold level, the RTL8I39C begins
packet transmission.
shown in the figure 9. Data in transmit FIFO move to
line when early transmit threshold is met. Early transmit
threshold is also specified in the descriptor.
3.15 Functional Description
3.15.1 Transmit Operation
The host CPU initiates the transmission by storing an
entire packet of data in one of the descriptors in the
main memory. When the entire packet has been
transferred to the Tx butTer, the RTL8139C is instructed
to move the data from the Tx butTer to the internal
transmit FIFO in PCI bus master mode [12]. When the
transmit FIFO contains a complete packet or is filled to
the programmed threshold level, the RTL8139C begins
packet transmission.The host CPU initiates the
t
-
-i
-t
·I Ir-.
Ne._kb...m:Q
JA1elf'u",
CU>l •*
TCP/UOPLa
nnlleat.ion La;
t
Data
et' Link:La
er ~
I t ·r-t--I
3.15.2 Receive Operation
The incoming packet is placed in the RTLSI39C's Rx
FIFO When the amount of data in the Rx FIFO reaches
the level defined in the Receive Configuration Register
(RCR), the RTL8139C requests the PCI bus to begin
transferring data to the Rx butTer in PCI bus master
mode. The Rx butTer should be pre-allocated and
indicated in RCR before packet reception. All received
packets stored in Rx butTer, including Rx header and 4byte CRC, are double-word alignment.
·
·
Physical Memory
•
•••••*.
~
,,"uaCnbl~L~
I
et'erStack.
Protocol
VirtSpoo::e
I
•• .....•
(RAM)
~ BuIT
Tx_Buff_<t.PHY
Rx_Buff_l_PH\·_Sp"""
Tx_Buff_I_PHY
_Sp"""
Binet
Me_~
Tx_Buff_3 _PHY _Spee.
_Spoo::e
I
Figure 9: The Design Flow ofTx and Rx of Data Packets
$ rmmod <fiIename.ext>.
To insert the specific module in the required path use
the command $ Insmod <fiIename.o>.
If the routines written by the device driver writer were
successful then the response from the connected system
as a reply with the number of packets transmitted,
number of packets received, and number of bytes lost,
packet size in bytes will be displayed (observed) as
shown in the figure 10.
Experimental set-up with along with the target with the
output on NIC card is shown in the figure 10. The same
above procedure has to be done on the twin systems to
see the communication between the two systems.
3.16 Adding Driver Module to the Kernel
For the communication between the NIC card and the
outside world firstly the device driver modules written
for the NIC card has to be added to the Linux Kernel as
a module. To include the written device driver module
the following command has to be used is
$ gcc -I /usr/srclLinux 2.4.20/include/ filename.c
After executing this command the driver modules will
be included in the linux directory.
To verilY wheather it is included as a module or not by
executing the following command as $ Ismod.
Displays all the modules included to the kernel. Inorder
to remove any of the modules from the kernel the
following command has to be executed
SAsTECH
49
Vol. VI, No.1, April 2007
3.17 Recommendations of future work
3.17.1 Maximizing the Performance a Gigabit
Ethernet NIC Interface
One important issue for practitioners and academicians
is that there are almost no platforms based on analytical
models for testing the impact of various architectural
and design modifications for intelligent network
interface cards [13]. Simulations are typically time
consuming, especially for experimenting with different
scenarios and what-if analysis. So Analytical Model and
Performance Analysis of a Network Interface Card can
be done to see the performance of the NIC card.
Concluding, every approach has a different motivation
and a particular range of applications. Some solutions
were planned to provide an absolute solution to the
complete set of device drivers and others are attempting
to provide tools only for a small subset of drivers. Thus,
there is no standard tool for writing device drivers; it
means that the absolute solutions haven't been found
yet.
Ethernet NIC configuration has become more than
simply enabling the interface below TCPIIP or any other
Layer 3 and above protocol stacks. The two layers
provided by the existing DLPI device driver and
hardware need some special understanding to ensure
that packets flow, in the first place [14]. Once packet
flow is established, you must ensure that packets flow
quickly and smoothly to those upper layer protocol
stacks. To measure the performance of the device
drivers, and to use those measurements to set the tunable
parameters of the gigabit Ethernet drivers to maximize
their performance.
3.17.2 Analytical Model and Performance
Analysis of a Network Interface Card
3.18 Executing the driver using Ping
Then use the ping IP address as $ ping ifconfig
192.168.12.135.
Figure 10: Experimental
Setup with the Communicating
output to the Systems ofJP 192.168.12.200
3.19 CONCLUSIONS
REFERENCES
Linux kernel has been configured according
to embedded application requirement to make small
kernel image which will be ported on the PQ2FADS
PowerPC Target Board. Here in this work I also
explained how to set up the development environment,
compile, load, and run the resultant Linux on the
PowerPC processor. Application is to be developed and
added to the kernel.
[I]
[2] He Zhu and Xiaoqiang Chen, Porting Linux to a
PowerPC, LINUX JOURNAL, October 1999.
[3] "GNUs", ftp://ft;-gnu.org/gnu,
on November 3' week)
This project is aimed to do data transfer from
system to physical media and to transfer from physical
media to upper layer by porting Linux onto the
PQ2FADS-ZU PowerPC target board. This project
includes designing and writing the soft code for the
designed routines of the NIC RT-8139C device to
communicate between the NIC card and the outside
world.
SAsTECH
Karim Yaghmour, Building Embedded Linux
Systems, O'Reilly Publishers, First Edition,
April 2003, pp. 107-237.
[4]
2006. (Browsed
"Kernel",
http://www.Kernel.org/,
(Browsed on November 3'd week)
2006.
[5] P.Raghavan, Amol Lad and Sriram Nelakandan,
Embedded
Linux
System
Design
and
Development, Auerbach Publications, Boca
Raton, New York, 2006, pp. 89-124.
50
Vol. VI, No.1, April 2007
[6]
"BusyBox", http://www.BusyBox.net/.
(Browsed on December 151 week)
2005.
[12] Realtek Single Chip Fast Ethernet
Controller
RT-8139C, Specification Document, Realtek.
[7] Atlanta Linux Expo, "Porting of Linux on the
PowerPC ", Atlanta, Georgia, October 23, 1998.
[8] MS.Thesis, "Linux on the PowerPC: Optimizing
Modern
Operating
Systems for
Modern
processors",
New
Mexico
Institute
of
Technology May 1998
[13] N. Cherukuri, G.B. Kandira ju, N. Gautam, and
A. Sivasubramaniam, "Analytical Model and
Performance Analysis of a Network Interface
Card', Journal (205) International Journal of
Modeling and Simulation, March 2004.
[9]
Alessandro
Rubini
and Johnatthan
Corbett,"Linux Ethernet Network Device Driver
- A flow of code", July 2006. (White Paper).
[14]
[10]
Introduction to IEEE 802.11, "Intelligraphics
device driver development ", IEEE-I 995.
Informit
Network,
"Maximizing
the
Performance a Gigabit Ethernet NIC Interface",
IEEE, December 2006.
[II] Ashfaq A.Khan, "Practical Linux Programming:
Device Drivers, Embedded Systems, and the
Internet", Charles River Media, Inc, First
Edition, 2002.
SAsTECH
51
Vol. VI, No.1, April 2007