100% Knowledge Guarantee
100% Genuine Placement Assistance

Linux device drivers training institutes in bangalore,Linux Kernel Training, Embedded linux training Institute,Linux Training, Embedded Course, Courses in Bangalore,weekend, Embedded linux training in bangalore, Linux device driver training in bangalore, Embedded linux course in bangalore, Embedded linux project in bangalore, Embedded linux in bangalore india.

LINUX DEVICE DRIVER AND KERNEL PROGRAMMING

PREREQUISITE : Advanced C and Linux Systems Programming

Embisyslabs is the Linux Kernel Device Drivers Training Institute conducts best Courses on Linux Kernel Programming, Character, Block, USB Gadget, PCI, Network, I2C, SPI Driver, Device tree, Linux internals, Porting linux kernel, Embedded Linux, Embedded Firmware, RTOS, Beaglebone, Raspberry-PI, ARM courses, ARM 7, ARM9 For Freshers and Working Professionals on Weekend as well Weekdays in Bangalore Bengaluru India.

 

 

| New Batch | 17th APRIL | Duration: 7 to 8 WEEKENDS | Fees 30k+18%(GST) = 35.4k |

 

CH1: AN INTRO. TO DEVICE DRIVERS

Role and Definition of the Device Drivers

Splitting the kernel into its functionalities

Drivers have two parts -Device specific and OS specific

Kernel Architecture or Model

 

CH2: BUILDING AND RUNNING MODULES

Types of Modules in the kernel

Writing Your first kernel module

Module Related Commands

Kernel Module vs Applications

Compiling Modules

Loading and Unloading Modules

Module Parameters

Modules and Exporting Symbols

Hands-On Assignments

Lab1: Simple Hello Linux Kernel Module.

Lab2: Write a module that can take an integer parameter when it is loaded, It should have a default value when none is specified.

Lab3: Write a pair of modules where the second one calls a function in the first one

 

CH3: CHARACTER DEVICE DRIVER and ITS IMPLEMENTATION

Allocating and Registering a Character Device

Concept behind Major and Minor Number

The Internal Representation of Device Numbers

Allocating and Freeing Device Numbers

Exchanging data between user space and kernel space

File Operations Data structure

Driver methods and Function Pointers

Filling the file operations structure

The Cdev Structure, inode Structure, file Structure

Manual Creation of Device Files using mknod()

Automatic Creation of Device Files using devive and class create

 

Hands-On Assignments

Lab1: Print the major and minor numbers when Registering by Static or Dynamic method.

Lab2: Implement a open,write,read and close entry point.

Lab3: Print the major and minor numbers when the device is Opened and keep track of the number of times it has been opened since loading, and print out the counter every time the device is opened.

Lab4: Modify the previous driver so that each opening of the device allocates its own data area, which is freed upon release. Thus data will not be persistent across multiple opens.

Lab5 : Implement a lseek entry point and Keeping track of file position.

Lab6: Dynamical Node Creation,Adapt the previous dynamic registration driver to use udev to create the device node on the fly.

 

CH4: KERNEL MEMORY ALLOCATION TECHNIQUE

System Memory Layout - Kernel space and User space

Concept of LOW and HIGH Memory

Kmalloc family allocator

The Flags Argument

Memory zones

vmalloc and Friends

Memory caches

 

Hands-On Assignments

Lab1:Testing Maximum Memory Allocation ,using kmalloc()

Lab2:Testing Maximum Memory Allocation ,using __get_free_pages().

Lab3: Testing Memory Allocation,using vmalloc().

Lab4 :Memory cachesExtend your chararcter driver to allocate the driver's internal buffer by using your own memory cache.Make sure you free any slabs you create.

 

CH5: ADVANCED CHARACTER DRIVER OPERATIONS

Inpout/Output Control Device (ioctl)

User space, the ioctl system call

The ioctl driver method

Generating ioctl command

Choosing the ioctl Commands

Using the ioctl Argument

 

Hands-On Assignments

Lab1 : Implement a ioctl entry point along with read and write entry point.

Lab2 : Implement read and write entry point using ioctl command.

Lab3 : Write a character driver that has three ioctl commands: a)Set the process ID to which signals should be sent. b)Set the signal which should be sent. c)Send the signal.

 

CH6: KERNEL LOCKING MECHANISM CONCURRENCY AND RACE CONDITION

Concurrency and its Managements

Semaphores versus Mutexes

Spinlock versus Mutexes

Linux Semaphore Implementation

Introduction to the Semaphore API

Spinlocks Implementation

Introduction to the Spinlock API

Spinlocks and Atomic Context

 

Hands-On Assignments

Lab1: Mutex Contention -Write three simple modules where the second and third one use a variable exported from the first one.The second (third) module should attempt to lock the mutex and if it is locked, either fail to load or hang until the mutex is available.

Lab2: Sempahore Contention -Now do the same thing using semaphores .

 

CH7: INTERRUPT AND INTERRUPT HANDLING

The Definition and Role of Interrupt

Installing an Interrupt Handler

The /proc Interface

Implementing a Handler

Handler Arguments and Return Value

Installing a Shared Handler

 

Hands-On Assignments

Lab1: Write a module that shares its IRQ with your network card. You can generate some network interrupts either by browsing or pinging.

Lab2: Extend the previous solution to construct a character driver that shares every possible interrupt with already installed handlers.

Lab3: Mutex Unlocking from an Interrupt. Modify the simple interrupt sharing lab to have a mutex taken out and then released in the interrupt handler.

 

CH8: TIME, DELAY AND DEFERRED WORK

Top and Bottom Halves

Tasklets and Workqueues Mechanisms

Measuring Time Lapses

Using the jiffies Counter

The Timer API

 

Hands-On Assignments

Lab1: Program based on Kernel Timer API

Lab2: Program based on Jiffies and HZ

Lab3: Program based on Taklet API

Lab4: Prgram based on Workqueue API

Lab5: Write a driver that puts launches a kernel timer whenever a write to the device takes place. Pass some data to the driver and have it print out. Have it print out the current->pid field when the timer function is scheduled, and then again when the function is executed.

Lab6: Write a module that launches a periodic kernel timer function; i.e., it should re-install itself.

 

CH9: FUNDAMENTALS OF BLOCK DEVICE DRIVER

Block drivers Definitions.

Block drivers Registration.

Block device operations.

Linux Block I/O Layer

I/O Schedulers

Block Driver Data Structures and Methods

How to handle block devices

 

Hands-On Assignments

Lab1: Registering and unregistering a simple Block Driver to get Major number.

 

CH10: IMPLEMENTATION OF RAMDISK DEVIVE DRIVER

RAMDISK-based block device driver

Using the RAMDISK block device

Driver registration

Obtaining a gendisk object

Implement the driver’s methods

Request Queue & Handle the request queue

 

Hands-On Assignments

Lab1: Write a simple Block driver program to read (and/or write) from the node, using the standard I/O functions (open(), read(), write(), close() .After loading the module with insmod use this program to access the node.

Lab2: Mountable Read/Write Block Driver, Extend the previous exercise in order to put or create an ext3 or ex4 file system on your Block device.

Lab3: Write a program to implement a ram disk device and make it into many partition like systems Hard disk and perform read() , write() operation through block driver vertical.

 

CH11: UNDERSTANDING PARTITIONING OF BLOCK DEVICES

Partitioning a Block Device

Sector,Cylinder and Head

Structure of a generic MBR

Partition Table

The Bootstrap Code Area/Bootloader

MBR – Partition Table Entries

Boot Record Signature/Magic Number

Creating a RAM Block Device

 

Hands-On Assignments

Lab1: Write a program to implement a ram disk device and make it into many partition like systems Hard disk and perform read() , write() operation through block driver vertical.

 

CH12: UNDERSTANDING USB DEVICE DRIVER

USB device and USB Host Controller Overview

Decoding a USB device section

USB Device detection in Linux kernel

USB Device Basics and usb_device structure

USB Configuration,Interfaces and Endpoint structure

USB Driver types - USB Host and Gadget Driver

Defferents types of data transfers mechanism

USB Driver registration with USB core

Creating usb device node in /Dev using Char Driver

Hands-On Assignments

Lab1:Installing a and writing a simple USB device driver.The driver should register itself with the USB subsystem upon loading and unregister upon unloading.

Lab2: Write a USB device driver to print out information abot configuration , interfaces and endpoint for a registered usb device.

 

CH13: USB GADGET DEVICE DRIVER ON BEAGLEBONE

Linux USB Gadget & Host Drivers

USB Gadget Driver Mechanism

USB Host Driver Mechanism

USB Core & Hot Plug n Play

USB Gadget Transfer Functions

Integration with a Vertical

Types of USB Device Drivers

Register a composite driver

Structure of usb_composite_driver

Structure of struct usb_function

 

Hands-On Assignment

Lab1:Beaglebone Black as standard USB Gadget Devices

Lab2:First take at a USB Gadget Driver

Lab3:Getting down to the hardware of BBB

Lab4:Creating Interface for USB Gadget Driver

Lab5:Creating Endpoint for USB Gadget Driver

Lab6:LoopBack USB Gadget Device Driver

Lab7:Creating Multiple Interface for USB Gadget Driver

Lab8:Controlling using custom USB Host Driver & App

Lab9:Controlling BBB GPIO LED through USB Drivers

 

CH14: PCI DEVICE DRIVER AND ITS ROLE

Understanding the x86 processor bus: PCI

PCI Core & Programming the PCI

Finding & Interacting with a PCI Device

PCI Bus, Device and Function numbers

Registering & Finding a PCI device

Mapping & Accessing the PCI device regions

Accessing the Configuration Space

Accessing the I/O and Memory Regions

Enabling the PCI Device

 

Hands-On Assignments

Lab1:Registering the driver with the PCI subsystem.

Lab2: Write a module that scans your PCI devices, and gathers information about them.For each found device, read some information from its configuration register.Fields you may wish to obtain could include: PCI_VENDOR_ID, PCI_DEVICE_ID, PCI_REVISION_ID,PCI_INTERRUPT_LINE,PCI_LATENCY_TIMER,PCI_COMMAND.

Lab3: Write a Character based PCI driver to find Information about IRQ Line,Memory region,I/O region,configuration region,prefetchable and non-prefetchable region in BAR.

 

CH15: MEMORY MAPPING AND DMA

What memory is DMA'able

DMA addressing limitations

Types of DMA mappings

DMA Direction

 

Hands-On Assignments

Lab1: Write a module that allocates and maps a suitable DMA buffer, and obtains the bus address handle. Do this in three ways: (a)Using dma_alloc_coherent(), (b)Using dma_map_single(), (c)Using a DMA Pool.

 

CH16: BASIC NETWORK DEVICE DRIVER

Registering the Network Driver

Buffer Management with skbuffs

Packet Transmission & Reception

Reception using interrupt and poll

Start the network interface’s transmit Queue

Other network operations including statistics

 

Hands-On Assignments

Lab1: Building a Transmitting Network Driver, Module to include a transmission function.

Lab2: Adding Reception, Extend your transmitting device driver to include a reception function.

 

CH17: ADVANVED NETWORK DEVICE DRIVER

Registering with the Linux low level bus interface subsystem

Allocating interface descriptor block (net_device)

Device specific structure and initializing media specific fields

Getting device specific structure object pointer

Enabling Network interface card

Getting the Device resources (MMIO and PMIO)

Getting device MAC address

Initialization of device methods in the net_device

Registering net_device object with the kernel

Registering the interrupt handler (ISR)

Allocating Rxring and Txring

Initializing the hardware (network interface card)

 

Hands-On Assignments

Lab3: Writing the PCI based Network Driver for NIC(Network Interface Card). Programming the Network Device Registers, Implementing the Transmission & Reception with the actual device(NIC) and Setting up the network across computers.

 

CH18: UNDERSTANDING I2C DEVICE DRIVER AND I2C SUBSYSTEM IN LINUX

Overview of I2C protocol

Understanding I2C registers of target device

Understanding the Linux I2C Framework

Understanding the I2C Adapter, Algorithm

Understanding the Client Device Driver

Developing stand alone low level I2C driver

Writing I2C Adapter and Client driver

Interfacing client driver with EEPROM

 

Hands-On Assignments

Lab1:Setting and porting platform specific embedded linux on BBB

Lab2:Writing low level I2C driver.

Lab3: Writing I2C Adapter and Client driver.

Lab4:Interfacing with I2C EEPROM

 

CH19: UNDERSTANDING SPI DEVICE DRIVER AND SPI SUBSYSTEM IN LINUX

Overview of SPI protocol

Understanding SPI registers of target device

Writing independent low level SPI driver

Understanding the Linux SPI Framework

Concept of Controller, Client driver registration and probe

Developing stand alone SPI client and cotroller driver

Interfacing with a SPI device

 

Hands-On Assignment on Embedded Board

Lab1:Setting and porting platform specific embedded linux on BBB

Lab2:Writing low level SPI driver

Lab3:Writing client and controller driver

Lab4:Interfacing with external device ADC

 

Why Training in Embisyslabs

Flexible and Convenient time Slots for Classes.

Experience and co-operative Trainers

Maximum 6 to 8 Participants in one Batch.

Indivisual Attention to each Participant.

High Quality practical/application Oriented Training.

Repeatation classes will be conducted as required.

Training and Practicals Process

Classes 5-Days a week for Weekdays Batch

Theory(1 1⁄2 -2 hrs.) and practical (2hrs.)

OR

Classes 2-Days for a Weekend Batch(Sat & Sun)

Theory(2 1⁄2 -3 hrs) and practical (3hrs.)

info@embisyslabs.com

+91-88848 67053

Embisys Labs Development,Training,Consultancy & Support www.embisyslabs.com