Mentoring Program For

Freshers On Embd.

Course Highlights

  • A fully personalized mentoring course for fresher/anyone interested in Embedded Linux and System Software Development careers
  • One-to-one personalized training.
  • This course is designed similar to the corporate trainings that we deliver for fresh recruits of major companies like Sasken, One Convergence, NCR, UTC-FS, Xilinx etc.
  • Full-time training enables us to focus on participant’s theoretical, practical, analytical and other divergent skills, which are extremely needed for industry readiness.
  • From the leaders in Embedded Linux and System Programming.

Why do you need a full-time course?

  • Regular training courses have separate theory and practical sessions, which is NOT enough for maximum training effectiveness.
  • A full-time course synchronizes theory and practical sessions in a working-like environment and ensures full understanding and hands-on on every technical topic
  • One-to-one focus on each participant is only possible in a full-time training course
  • Same faculty for theory and practical sessions will make learning more effective
  • Clear assessment of each participant through weekly written and practical tests
  • Full-time course gives the trainer high flexibility and time to make teaching more effective

Course duration:

4 months (4 hrs. per day, five days a week)

Why only Veda Solutions can conduct a full-time course like this ?

  • We are the only institute conducting full-time corporate training to fresh employees of major embedded development companies including Sasken, NCR, One Convergence, Powerwave and so on.
  • We use the same corporate training methods in our full-time course and make you industry ready
  • We are the most recommended training institute by working professionals
  • We are the only institute to have conducted corporate trainings to over 20 companies
  • We have over 10 years of training experience in Embedded Linux and System Programming area

Feedback on our training programme for fresh recruits

“Veda Solutions has delivered two corporate trainings to our freshly recruited employees in the last one year and these trainings have brought a drastic change in the way these employees approach their project work and assignments. They are also better in comparison to the other employees who could not attend the training” Also available in Full time, Weekend Workshops, Audio-Video and Online mode (refer website/counselor for details) -Praveen Sarlagundu (Manager HR, Once Convergence Pvt. Ltd. Hyderabad, Aug. 2012)

Course pre-requisites

  • Knowledge of basic C programming

Courses Contents:

1. C & DS for Kernel Programming

Key learning points from this module
  • Understand language specifications and standards
  • Learning to write standard, safer and stable C programs for Kernel/Embedded programming requirements
  • Understand compile and build process of a C program
  • Learn how to debug your C code using tools like Gdb
  • Understand how C is represented in memory
  • Easy approach to understand complex C concepts
  • Data Structures for Kernel/Embedded programming

Programming language specifications

  • Need for language specifications
  • C standard specifications & revisions
  • Compiler distribution(SDK)
  • Introduction to GNU compiler distribution(GCC)

Gnu compiler distribution

  • Understanding compile & build process
  • Object file analysis
  • Executable Images
  • Binary Portability

Exploring Linkers and Build process

  • Build process defined
  • Role of Build scripts in build process
  • Build script syntax
  • Need to modify Build scripts
  • Use cases & standard practices

Customizing build process

  • Need for customizing executable build.
  • Introduction to linker scripts
  • Role of linker scripts in build process
  • Linker script syntax
  • Understanding default linker script
  • Writing our own linker script
  • Defining user defined sections
  • Use cases & standard practices

Binary Files

  • Understanding binary files & file formats
  • Layout of C program in memory
  • Understanding Linux binary file format
  • Types of binary file formats on Linux
  • Decoding binary files using tools (objdump, readelf, nm, ldd)

Main memory

  • Introduction to main memory
  • Data storage on the memory
  • Single byte data vs. Multi byte data
  • Byte ordering
  • Why data types

Data types

  • Introduction to data types in c
  • Integer data formats
  • Signed vs. unsigned
  • Introduction to arrays
  • Introduction to structures
  • Introduction to unions

Stack Analysis

  • Introduction to stack
  • Understanding how stack grows and shrinks
  • Understanding stack frames
  • Understanding how stack frames are created and destroyed.

Storage classes

  • Need for storage classes
  • Storage classes in real time
  • why register-storage-class
  • Understanding static storage class
  • Why linkages
  • Linkages in real time

Program execution

  • Process, defined
  • Understanding how programs are loaded
  • Understanding process address space
  • Loading shared libraries
  • Understanding program entry and exit points
  • Changing program entry point

Process management

  • Kernel process descriptor
  • Accessing kernel process descriptor information
  • Introduction to Linux Process scheduler
  • Scheduling policies & priorities
  • Process scheduling for multi/many core systems
  • Process affinity
  • Linux process privileges
  • Introduction to process resource limits
  • Use cases & standard practices


  • Introduction to Files
  • Introduction to file interfaces
  • File operations
  • Understanding ASCII text files and binary files
  • Creating binary files
  • Operations over binary files
  • Understanding how file interfaces works internally

Dynamic memory

  • Why dynamic memory
  • Using dynamic memory interfaces
  • Issues while using dynamic memory
  • Standard guide lines

Data structures

  • Why data structures
  • Introduction to different data structures
  • How data structures differ for each other
  • Real time case study for implementing liner data structure
  • Hierarchy representation of data structure
  • Operations over liner and non liner data structures

Exploring object files

  • Need for understanding object files
  • Introduction to the Binary File Formats (ELF, COFF, XCOFF).
  • Understanding ELF file format
  • Inspecting object files
  • Extracting sections from object files
  • Converting executable to other formats (srec, ihex, binary)
  • Use cases


  • Types of operators
  • Compile time and run time operators
  • Operator usage-internals
  • Side effects of using operators


  • Role of functions
  • Functions arguments and return type
  • Understanding in and out params
  • Variable number of arguments
  • Pointers to functions

Structures and unions

  • Memory representation of structures and unions
  • Structure padding
  • Why avoid structure padding
  • Realtime usage of unions
  • Nesting of structures and unions

Pointer data type

  • An easy way to understand pointers
  • Practical need of pointers
  • Understanding pointer arithmetic
  • Pointers to structures and unions
  • Understanding index notation of arrays
  • Generic pointers
  • Limitations of generic pointers
  • Efficient use of pointers
  • Side effects of using pointers


  • Introduction to libraries
  • Types of libraries
  • Creating static libraries
  • Creating shared libraries (dynamic libraries)
  • Creating and using our own library

Bitwise operators

  • Intro to bitwise operators
  • Effectively performing arithmetical operations using bitwise
  • Safest way of using bitwise operators
  • Bitwise operators in real time

Structure bit fields

  • Intro to structure bit fields
  • Why structure bit fields
  • Memory representation of structure bit fields
  • Effective way of creating structure bit fields
  • Structure bit fields in real time

Preprocessor instructions

  • Understanding role of preprocessor
  • Instructions supported by preprocessor
  • Built-in preprocessor directives
  • Understanding object / function like macros
  • Using variable argument macros
  • Understanding inclusion of files
  • Avoiding recursive inclusion of files
  • Understanding conditional compilation
  • Conditional compilation in real time
  • Operators supported by preprocessor
  • Understanding token pasting and stringification

Const & volatile

  • Why const keyword
  • Why volatile keyword
  • Const and volatile together
  • Real time uses

Inline functions

  • Need for inline functions
  • Real time use cases of inline functions

Searching and sorting

  • Different searching & sorting techniques

Modular programming

  • Understanding modular programming techniques
  • Shared libraries in modular programming
  • Use cases


  • Introduction to debugging
  • Standard debugging practices
  • Linux-application debugging options
  • Using Gdb for bug investigation

2. Linux Application programming

Key learning points from this module
  • Understand key Linux OS concepts that a system programmer must know
  • Learning application designing
  • Understanding thread programming and Inter Process Communication (IPC)
  • Network Programming

Application prg. Interfaces (API)

  • Understanding need of Api
  • API vs system calls
  • User mode/ kernel mode transitions
  • Unix common API standards (Posix, BsD , SYS V)
  • APIs and application portability
  • API design practices
  • Use cases and standard practices

Managing process address space

  • Introduction to virtual address space
  • Stack allocations
  • Heap/Data segment management
  • Memory maps
  • Dynamic memory allocation & de-allocation routines
  • Choosing right memory allocation mechanism
  • Manipulating memory blocks
  • Swapping Memory Areas
  • Memory locking
  • Use cases & standard practices

Linux I/O architecture

  • Introduction to components of I/O architecture
  • Objectives of Linux I/O model
  • Virtual file system
  • File system services
  • I/O cache
  • Understanding file descriptors & inode structures

File I/O operations

  • Introduction to common file APIs
  • Accessing file attributes
  • Standard I/O operations
  • File control operations(fcntl())
  • Alternate File I/O models
  • Huge file I/O
  • Monitoring File and directory events

Process creation calls

  • Process creation calls (fork, vfork, execve)
  • Monitoring child process
  • Linux kernel process creation routines
  • Types of binary file formats on Linux
  • Handling child process termination events
  • Linux threads interface (clone)
  • Use cases & standard Practices

Posix Threads

  • Introduction to posix thread interface
  • Thread creation and management
  • Thread attributes
  • Detecting Race conditions
  • Atomic operations
  • Mutual exclusions methods (mutex, semaphores, spinlocks)
  • Detecting and handling deadlock events
  • Choosing right Mutual exclusion method
  • Designing scalable critical sections
  • Exploring Thread synchronization methods (signals, condition variables…)
  • Choosing correct Thread synchronization method
  • Thread local data
  • Thread cancellations & exit handlers
  • Linux Native posix threading support (NPTL)

Linux socket abstraction layer

  • Introduction to socket layer
  • Overview of socket APIs
  • Programming TCP/IP apps using socket APIs
  • Programming UDP/IP apps using socket APIs
  • Exploring socket data structures
  • Understanding socket attributes
  • Introduction to Raw sockets
  • Programming apps using Raw sockets
  • Alternate models for implementing network apps
  • (Without using Socket APIs)
  • Use cases & standard Practices

I/O operations of special files

  • Handling Device Files
  • Handling Pipe files
  • /proc file system
  • /sys file system

I/O multiplexing

  • Need for Multiplexed I/O
  • Standard methods
  • Linux support for I/O multiplexing
  • Use cases & standard practices

Signal management

  • Introduction to Signals
  • Linux signal types & categories
  • Signal generation and delivery
  • Linux signal management data-structures
  • Switching signal dispositions
  • Writing async signal handlers
  • Using signals for process communication
  • Blocking & Unblocking signal delivery
  • Use cases & standard Practices

Concurrent application designs

  • Introduction to concurrent applications
  • Understanding need for concurrent apps
  • Standard Concurrency models
  • Comparative analysis of concurrency models
  • Use cases & standard Practices

Time keeping & Timers

  • Calendar Time
  • Time conversion routines
  • Software time keeping
  • Process time
  • BSD Interval Timers for running periodic tasks
  • Accuracy of timers
  • Posix clocks
  • Posix interval timers
  • Linux interval timer interface
  • Use cases & standard practices

Inter-process communication

  • Introduction to IPC subsystem
  • Linux kernel IPC resources
  • IPC communication resources (pipes, msgqs., shared memory)
  • IPC synchronization resources (semaphores)
  • Comparative analysis of SYSV and POSIX IPC Implementations
  • IPC kernel data structures
  • Use cases & standard Practices

Network programming

  • Introduction to networking
  • Categories of Network Applications
  • Network communication application designs
  • Understanding Protocol stacks
  • Understanding TCP/IP networks
  • Exploring Linux kernel network subsystem

Process communication with UNIX domain sockets

  • Stream sockets in Unix domain
  • Datagram sockets in Unix domain
  • Abstract socket namespace

Build automation tools

  • Introduction to build automation
  • Make tool & Makefiles
  • Make syntax
  • Make default rules
  • Use cases

3. Linux Kernel Internals and Device Drivers

Key learning points from this module
  • Learn writing software for Kernel programming needs
  • Learn core concepts for writing Device Drivers
  • Understand how to write Device Drivers for Linux
  • Key Memory Management concepts

Linux kernel programming

  • Essentials of Linux kernel architecture
  • Understanding need for kernel programming
  • Kernel programming models
  • Kernel configuration and compilation
  • Introduction to kernel modules
  • Kernel modules vs. Applications
  • Exploring kernel module architecture

Kernel message logging infrastructure

  • Need for kernel message logging
  • Kernel message ring buffer
  • Kernel message Log priorities
  • Message Ring buffer management
  • Accessing messages from user mode apps
  • Linux message logging daemons

Linux driver architecture

  • Device Drivers defined
  • Linux Driver model
  • Types of Linux drivers
  • Driver stacks

Synchronous driver model

  • Synchronous drivers defined
  • Driver registration and de-registration
  • Driver file interface
  • Device file operations
  • Driver data structures
  • Device Configuration ops
  • Wait Queues & polling
  • Memory mapping
  • Use cases

Concurrency and Race Conditions

  • UP vs. SMP Issues
  • Combating Race Conditions
  • Atomic Operations
  • Semaphores
  • Spin Locks

Memory allocations

  • Linux kernel memory subsystem
  • Memory representation data structures
  • Memory Allocators
  • Allocating Boot memory
  • Page Tables and Address Translation

PCI device drivers

  • PCI basics
  • Linux PCI bus stack
  • PCI device access

Modules programming basics

  • Building blocks of a kernel module
  • Building kernel module binary
  • Tools for module management
  • Tracking module dependency
  • Module parameters
  • Kernel symbol table
  • Exporting Module symbols

DMA mappings

  • Need for DMA
  • Linux DMA mappings
  • Use cases

Hardware access

  • Device Addresses
  • Port mapped I/O
  • Interacting with port mapped devices
  • Memory Mapped I/O
  • Reserving address space MMIO
  • MMIO Access
  • Device Access side effects
  • Device access from u-space

Interrupt handling

  • Understanding Interrupts
  • Linux Interrupt handlers
  • Implementing Driver ISR
  • Need for deferred routines
  • Linux Deferred Routines
  • Interrupt event management

Time measurement & Delays

  • Need for time measurement
  • Kernel tick
  • Need for delays
  • Introducing delays
  • Use cases

Linux net device subsystem

  • Network driver model
  • Types of network drivers
  • Driver hands-on

Block driver subsystem

  • Block device model
  • ramdisk driver hands-on


  • USB basics
  • Linux USB bus stack
  • USB driver classes
  • Interacting with USB devices from drivers
  • Driver hands-on

4. Embedded Linux

Key learning points from this module
    • Understanding current-day Embedded System requirements
    • Using cross-compiler tool-chain
    • Using U-Boot
    • Understanding Embedded Driver stacks
    • Porting Linux on to ARM target

Introduction to embedded Linux

  • Benefits of using Linux and open source tools for embedded systems
  • SOC overview
  • Embedded Linux system architecture
  • Software components for embedded development

Cross-compiler tool-chains

  • Need for cross tool-chain
  • Different tool-chains’ build procedures
  • Using pre-build cross tool-chain
  • Building our own cross tool-chain

Machine emulator and virtualizer

  • Why emulator
  • Installing emulator
  • Using emulator for ARM


  • Supported hardware architectures
  • Using predefined config files
  • Cross-compiling the kernel for target
  • Understanding kernel boot arguments
  • Understanding NAND/NOR flash
  • File system for flash

Embedded Drivers

  • Linux Driver stack for embedded devices
    • Platform devices Stack
    • I2C stack
    • SPI stack
    • MTD stack

Linux booting process

  • Linux booting sequence
  • Components of Linux booting
  • Tweaks and changes
  • Use cases


  • Introduction to u-boot
  • Overview of U-boot source
  • Building U-boot for target
  • Booting target with U-boot
  • Understanding U-boot environment
  • Transferring images to target using U-boot

File system

  • Understanding Unix File system hierarchy
  • Creating file system
  • Porting application
  • Mounting file system as initrd
  • Integrating file system and kernel image
  • Cross-compiling applications and libraries
  • Creating jffs2 file system

Flashing Images

  • Flashing kernel image
  • Flashing file system

5. Understanding Android System Software

Key learning points from this module
    • Understanding Android Architecture
    • Looking into Android Kernel features
    • Getting used to Some tools
    • Understanding Embedded Driver stacks
    • Porting Android

Overview of Android architecture

  • Android Kernel
  • Middleware
  • Application framework
  • Android runtime [DVM]
  • Application layer

Basic android tools

  • ADB
  • logcat
  • traceview
  • emulator

Android on emulator

  • Android platform overview
  • Initializing build environment
  • Downloading the source [git]
  • Overview of source code
  • Building android for emulator
  • Build for emulator
  • Simple tests

Android Kernel features

  • Binder
  • ashmem
  • pmem
  • logger
  • wakelocks
  • oom handling
  • Alarm timers

Android on real target

  • Downloading the source
  • Building android for target
  • Build for target
  • Running Android on target
  • >> Classroom
    • Course Name :
      Embedded Linux Drivers and Android
    • Next batch starts :
      September 30, 2013
    • Class Timing :
      4:00pm to 7:00pm
    • Course Duration :
      4 months
    • Course Fee :
  • >> Audio/Video
    • Course Name :
      Embedded Linux Drivers and Android
    • Next batch starts :
      Not Available
    • Class Timing :
      Not Available
    • Course Duration :
      Not Available
    • Course Fee :
      Not Available-
  • >> Online

Course feedbacks

Success Stories

Related Articles