Linux Device Drivers
BRIEF INTRODUCTION OF THE
Anahat Technologies
202, OM Complex,
Sector-15, Noida-201301
PH: (+91)9718834746,
(0120)-4559817
URL:http//www.anahat.net.in
Email: info@anahat.net.in
COURSE
What do we mean when we say "device driver"? Fundamentally, a device
driver implements the interface between a piece of peripheral hardware and
the application, with the operating system acting as intermediary. In a
traditional "flat" memory model system, a driver may be little more than a set
of functions conforming to a well-defined API and statically linked into an
executable image.
But in the context of a protected mode operating system such as Linux,
device drivers take on added significance owing to the distinction between
user space and kernel space. This training introduces the world of
programming in kernel space. As such, it provides insights not only into
device driver programming but also into the philosophy and design
strategies of the kernel itself.
This is a hands-on course in operating system internals. Students configure,
compile, and install a Linux kernel from sources; do the same for a kernel
module; navigate and read the Linux kernel sources; design and implement
Your world tour a kernel module of your own; modify, or design and implement from scratch,
a device driver; measure the performance of what you have modified or
planning experts implemented. The students in the course write device drivers or other
kernel modules, in teams
This course is intended for people who have interest in understanding and
EMPOWER THE YOUTH programming at operating systems and open source software development.
Phone: (0120)-4559817
 How Linux handles interrupts with Linux programming
Implementing and installing and
Upon completing this interrupt handler and the x86 architecture
course, participants Bottom halves, task queues, and is helpful.
tasklets
should be able to: More on modules
On-demand module loading
Configure and install a Linux kernel. Version control Numerous programming
Create, modify, and debug Linux device Block drivers exercises introduce the rich
drivers and related modules that run as part Registering a block driver kernel API that offers a
of the kernel. Handling requests multitude of services to driver
Understand the trade-offs between loadable Mounting and unmounting writers. You learn how Linux
Our first character driver and
modules and drivers compiled into the kernel. Interrupts in block drivers handles asynchronous I/O in
System Calls
Distinguish between the hardware-dependent Memory management and DMA a way that is totally
introducing scull
portions and the hardware independent Network Device Drivers transparent to applications.
Debugging kernel modules
portions of a Linux device driver. Sockets You examine the unique
printk
The net_device structure problems of debugging in
proc files
DETAILED COURSE OUTLINE: Transmit logic kernel space. Perhaps most
Tracing--strace, Linux trace toolkit
Receive logic important, you see how much
Debuggers--gdb, kdb, kgdb
Brush up C and Data Structure Concepts: of a device driver involves
Asynchronous I/O
Pointers, Linked List Concepts, Function
Blocking vs. non-blocking operation
Prerequisite skills: interactions with the kernel
Pointers. that have nothing to do with
Wait queues
Basic Linux Internal concepts accessing physical hardware.
Protected mode memory management--user
Invoking the driver from multiple Excellent C programming Although the exercises are
processes
space vs. kernel space reentrancy
skills. Some experience carried out on a PC, much of
File system and directory structure the code is easily ported to
Synchronization other architectures supported
Development environment
Race conditions by Linux.
Configuring and building the kernel Atomic access
Kernel modules Spinklocks
Introducing device drivers Kernel memory management
What is a "device driver"? kmalloc() and kfree ()
Linux device classes and user space API mmap()
Kernel space driver API Accessing real hardware
"Hooking" a driver into the kernel Using I/O ports--"side effects"
A parallel port driver
Platform dependencies
Interrupt handling