Embedded Linux Kernel and Driver Development (LNXKRN1)

Unix-like systems, Linux - programming

Linux is a highly adaptable open-source operating system that runs on a wide range of devices, from supercomputers to embedded systems. This course focuses on developing device drivers and customizing Linux for specific hardware boards and peripherals. Participants will learn to navigate the Linux kernel’s intricacies, from initialization processes to advanced techniques for working with hardware buses and synchronization mechanisms.

Ideal for embedded systems developers and system programmers, this course provides a comprehensive understanding of kernel-level programming and driver development for Linux.

Location, current course term

Contact us

Custom

Customized Training (date, location, content, duration)

The course:

Hide detail

• Linux kernel initialization process
1. Kernel boot image and device tree
2. Root file system and init process
3. Loadable modules and initramfs

• Getting a lab environment
1. Virtual machine environment
2. Build environment and tools
3. Running the first kernel code

• Kernel code limitations and constraints
1. Lack of stable driver API
2. Maintenance of kernel code over time
3. Kernel code design specifics

• Alternatives in the userspace
1. Device drivers for some subsystems
2. Stable user space-facing API
3. Free choice of programming language

• Building kernel modules
1. Initialization and finalization
2. Resource acquisition and cleanup
3. Operation structure registration

• Creating user-space interfaces
1. Kernel side of the virtual file system
2. Reading, writing, and ioctl calls
3. Purpose of procfs, sysfs, and debugfs

• Exposing character devices
1. Global character device numbers
2. Dynamic miscdev allocation
3. Publishing devices in devtmpfs

• The mechanics of hardware drivers
1. Device driver model in Linux
2. Initialization and finalization 
3. Resource acquisition and cleanup

• Hardware bus representation
1. Platform device pseudo-bus
2. Non-enumerating buses (I2C, SPI, …)
3. Enumerating buses (USB, PCI, …)

• Connecting the user-space and hardware
1. Hardware device presented to user-space
2. Character devices and the block layer
3. Plugging into the big subsystems

• Kernel module design patterns
1. Failed initialization unrolling
2. Callbacks with container_of
3. Pre-allocated buffers and FIFOs

• Dynamic module loading infrastructure
1. Loading and unloading procedure
2. Symbol dependencies between modules
3. Resource acquisition and busy modules

• Locking and waiting mechanisms
1. Mutexes and multiprocessing
2. Spin locks and interrupts
3. Timers and wait queues

• ARM board support
1. Device & board files
2. Device tree binaries
3. Pinctrls, GPIOs, and interrupts

• Kernel development discussion
1. Differences from bare-metal programming
2. Real-time & performance considerations
3. Legal, community, and public relations

Assumed knowledge:

Knowledge of the Unix environment and programming in C language.

Schedule:

5 days (9:00 AM - 5:00 PM )

Language: