This document describes a Linux Driver and Embedded Developer training course offered by Veda Solutions. The 3-month course covers topics like Linux programming, kernel programming, embedded Linux, device drivers, and Android system software. It is aimed at working professionals seeking to develop skills in embedded Linux, Linux kernel programming, and device drivers. The course contents are divided into modules covering various aspects of Linux programming, kernel internals, device drivers, embedded Linux, and an overview of the Android system.

1. 1
Linux Driver and
Embedded Developer
with Android
Course Highlights
 The flagship training programme from Veda Solutions, successfully being conducted
from the past 10 years
 A comprehensive expert level course covering all aspects of system programming like
Linux Programming, Kernel Programming, Embedded Linux , Network Programming,
Linux Device Drivers and Android System Software
 Most attended and recommended by working professionals (from over 100 companies
and 8 nations)
 From corporate trainers to over 20 major technology and embedded companies
 Available in regular, full-time, weekend workshops, audio-video and online training
modes
301, Prashanthiram Towers, Saradhi Studio Lane, Ameerpet, Hyderabad
Ph:040-66100265 Email: info@techveda.org www.techveda.org

2. 2
Who should attend?
 Working professionals expecting projects/work assignments on Embedded Linux, Linux
kernel programming, Device Drivers or other core system development requirements
 Working professionals looking to upgrade their system development skills on Linux
 Programmers from Windows OS platform interested to add/migrate to Linux and
Embedded Systems
 Microcontroller based embedded developers who are willing to upgrade their skills and
enhance their career positions
Course pre-requisites
 Proficiency in C programming
 Knowledge of basic Linux commands
What you will learn?
 Linux programming essentials, for understanding the key Linux; issues, concepts and
finer nuances of programming to get a proper grounding before getting deeper into
core system development
 Linux Kernel Programming and Internals for getting a complete grip on core OS concepts
and module programming
 Linux Device Drivers and Embedded Drivers enabling you to start writing Driver
programs for embedded and GPOS targets
 Practical Embedded Linux enablement skills for any target hardware like ARM and so on.
 Overview of Android system software development
Course Duration
 Regular mode – 3 months (1.5 hrs. per day, five days a week)
 Also available in Full time, Weekend Workshops, Audio-Video and Online mode (refer
website/counselor for details)
Why Veda Solutions?
 Most recommended training organization by working professionals
 10 years of training experience in Embedded Linux and Linux system programming
 Delivered corporate training to over 20 technology majors including Sasken, NCR, UTC-
FS, Xilinx and so on
 First institute in Asia to start online courses on Linux Kernel, Device Drivers and
Embedded Linux
 Participants from over 8 nations and 100 companies

3. 3
Course Contents
This course is divided into three logical modules to enable easy and effective understanding of
the entire course
Linux Programming Essentials
Gnu compiler distribution
 Understanding compile & build process
 Tool chain
 Object file analysis
 Executable Images
 Binary Portability
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
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
Libraries
 Introduction to libraries
 Creating Static Libraries
 Creating Shared Libraries
 Using Libraries
 Managing dynamic libraries
 Use cases & standard practices
Process management
 Introduction to program loading
 Process, defined
 Understanding process address space.
 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
Stack Analysis
 Introduction to stack
 Understanding how stack grows and
shrinks
 Understanding how function
parameters are passed.
 Understanding how stack frames are
created and destroyed.
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

4. 4
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
 Use cases
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
Process creation calls
 Process creation calls (fork, vfork,
execve)
 Monitoring child process
 Linux kernel process creation routines
 Copy-on-write resources
 Handling child process termination
events
 Linux threads interface (clone)
 Use cases & standard Practices

5. 5
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)
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
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

6. 6
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
Linux Kernel Internals and Device Drivers
Linux kernel programming
 Essentials of Linux kernel architecture
 Understanding need for kernel
programming
 Kernel programming models
 Modifying kernel sources
 Kernel configuration and compilation
 Introduction to kernel modules
 Kernel modules vs. Applications
 Exploring kernel module architecture
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
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

7. 7
Memory allocations
 Linux kernel memory subsystem
 Memory representation data
structures
 Memory Allocators
 Allocating Boot memory
 Page Tables and Address Translation
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
PCI device drivers
 PCI basics
 Linux PCI bus stack
 PCI device access
USB
 USB basics
 Linux USB bus stack
 USB driver classes
 Interacting with USB devices from
drivers
 Driver hands-on

8. 8
Embedded Linux
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
Linux booting process
 Linux booting sequence
 Components of Linux booting
 Tweaks and changes
 Use cases
U-boot
 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
Kernel
 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
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

9. 9
Understanding Android System Software
Overview of Android architecture
 Android Kernel
 Middleware
 Application framework
 Android runtime [DVM]
 Application layer
Android Kernel features
 Binder
 ashmem
 pmem
 logger
 wakelocks
 oom handling
 RAM_CONSOLE
 Alarm timers
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 on real target
 Downloading the source
 Building android for target
 Build for target
 Running Android on target
301, Prashanthiram Towers, Saradhi Studio Lane, Ameerpet, Hyderabad
Ph:040-66100265 Email: info@techveda.org www.techveda.org