COURSE CONTENTS

Introduction to Linux  
        History and open source
        Features
        Modular and monolithic vs micro  
        Kernel design goals  

Understanding the kernel
        Kernel structure  
        Kernel components and organization
        Modes of operation  
        User library different from kernel  
 
Booting and kernel initialization  
        Booting Basics  
        System Ups and Down under Linux  
        Boot-loaders (Various target specific boot loaders)  
        Understanding Linux start_kernel in brief  
 
Linux Basic Common Set  
        File and directory related command  
        Using VI effectively [contrast w.r.t Word processor]
        Commands for filters, IO redirection and etc  
        Process related commands  
        Miscellaneous Command [zip/tar/mount etc]  
        Shell scripts  
a. Simple handy utilities
b. Major script techniques  
        Compiling C codes  
 
System calls  
        Understanding the Layer for Communication  
        Basics
        Common system calls  
        How is it implemented in Linux?  
        Using a system call directly in assembly
        Linux implemented methods  
 
Day-2

Introduction Embedded OS
        What is Embedded OS  
        The cross development environment  
        Various commercial OS
        Embedded Linux and other  
        Scalable Features: Linux Kernel  
        Customizing Linux kernel
Introduction to GNU toolchain  
        The gcc command  
        Size
        Nm
        Readelf  
        Strace
        Ar
        Ranlib
        Objdump  
        Strings
        The make utility
        Gdb

Building your own kernel  
        Kernel source code  
        Configuring kernel  
        Building the Image  
        Entering the image path to the loader’s script  
        Rebooting the system with your image  
 
Experimenting the fresh 2.4 kernel  
Applying patch for a kernel
        Configuring the Kdb with patch  

Experimenting the 2.6 kernel
        Building the default kernel to startup a new 2.6 kernel  

Setting up the host and target board  
        Minicom utility
        Running existing kernel with the same
        Also testing on Hyper Channel  

Day-3

Introduction to X-Scale architecture  
        The feature of board  
        The board memory map  
        The application support on the board  
 
Loading Boot loader  
        JTAG based loading
        Testing the board again  

Configuring the BOOTP/TFTP
        TFTP bootloader  
        Flash bootloader  
        TFTP kernel
        Flash kernel
        TFTP file system
        Flash file system  
        Boot the code  
Installing GNU-X tool chain  
        GNU gcc compilers for C, C++  
        Setting up the path for the tools installed  
        Checking a simple program  
        Try all other commands as review on GNU tools   Size, nm, readelf,    
 
Setting up the gdb for target borad  
        Download gdb 5.3  
        Install gdb
        Connect gdb for Xscale board  
        Using minicom and zModem  
        Download the program on board  
        Running gdb on PC and debugging on target  

Compiling and configuring kernel  
Using menuconfiguration  
Making a bzImage
Downloading Your Modified Kernel  
 
DAY 4

Linux Device Driver using X86
Introduction to Device Drivers:brief
Introduction to LKMS
        Introduction to Linux Loadable Kernel Modules
        Terminology
        History of Loadable Kernel Modules
        The Case For Loadable Kernel Modules
        What LKMs Can't Do
        What LKMs Are Used For
        Making Loadable Kernel Modules
        LKM Utilities
        How To Insert And Remove LKMs
        Unresolved Symbols
        About Module Parameters
        Writing Your Own Loadable Kernel Module
 Lab-session: Using X86 architecture
 After the concept’s presentation trainee will work on
        Module Programming
        Parameters passing
        Stacked module
 

Introduction to Linux Device Drivers
Types of drivers (Other OS based discussion)
Character and Block Device Drivers
        Major and Minor numbers
        Dynamic Allocation of Major Numbers
        Registering your driver
        Removing a Driver from the system
        File Operations
        The file Structure
        Open, release, read, and write
        Copy to/from user
        A sample Device Driver: simple_char
 
Debugging Techniques
        Debugging by Printing
        Debugging by Querying
        Debuggers and Related Tools

Lab-session: Using X86 Architecture
        After the concept’s presentation trainee will work on
        Write drivers programs and implement a test driver
        Check applications on the same
        Major Debugging Techniques
        Configuring KDB based patch when needed

OBJECTIVES

Participants will Improve their skills on embedded programming and device driver fundamentals in linux environment

WHO SHOULD ATTEND

This course is meant for Linux Programmers and Administrator who wants to specialize their skills towards embedded programming & device driver fundamentals.

DURATION

4 days