Writing Linux Device Driver

2009-12-22T21:06:00.000-08:00

User space and kernel space

When you write device drivers, it’s important to make the distinction between “user space” and “kernel space”.

Kernel space. Linux (which is a kernel) manages the machine’s hardware in a simple and efficient manner, offering the user a simple and uniform programming interface. In the same way, the kernel, and in particular its device drivers, form a bridge or interface between the end-user/programmer and the hardware. Any subroutines or functions forming part of the kernel (modules and device drivers, for example) are considered to be part of kernel space.
User space. End-user programs, like the UNIX shell or other GUI based applications (kpresenter for example), are part of the user space. Obviously, these applications need to interact with the system’s hardware . However, they don’t do so directly, but through the kernel supported functions.

All of this is shown in figure 1.

: Figure 1: User space where applications reside, and kernel space where modules or device drivers reside

Interfacing functions between user space and kernel space

The kernel offers several subroutines or functions in user space, which allow the end-user application programmer to interact with the hardware. Usually, in UNIX or Linux systems, this dialogue is performed through functions or subroutines in order to read and write files. The reason for this is that in Unix devices are seen, from the point of view of the user, as files.

On the other hand, in kernel space Linux also offers several functions or subroutines to perform the low level interactions directly with the hardware, and allow the transfer of information from kernel to user space.

Usually, for each function in user space (allowing the use of devices or files), there exists an equivalent in kernel space (allowing the transfer of information from the kernel to the user and vice-versa). This is shown in Table 1, which is, at this point, empty. It will be filled when the different device drivers concepts are introduced.


Events	User functions	Kernel functions
Load module
Open device
Read device
Write device
Close device
Remove module

Table 1. Device driver events and their associated interfacing functions in kernel space and user space.

Interfacing functions between kernel space and the hardware device

There are also functions in kernel space which control the device or exchange information between the kernel and the hardware. Table 2 illustrates these concepts. This table will also be filled as the concepts are introduced.

Overview of Embedded Linux Booting Sequence

2009-12-22T09:22:00.001-08:00

This Text provides an insight in to the Embedded Linux Boot Process. Reader should have a basic Knowledge of Boot Process in general and should be familiar with Embedded Linux Boot Process.

.................
PART-A
................

(1) Software components Involved in Embedded Linux Boot Process
(a) Bootloader
(b) kernel Image
(c) root file system - either an initrd image or a NFS location

(2) Steps during Booting process of a conventional PC
(a) System Startup - PC-BIOS/BootMonitor
(b) Stage1 bootloader - MBR
(c) stage2 bootloader - LILO,GRUB etc
(d) kernel - Linux
(e) init - The User Space

(3) Booting process for an Emebedded Systems
(a) Instead of BIOS you will run program from a fixed location in Flash
(b) The components involved in the first steps of PC boot process are combined in to a single "boot strap firmware", called "boot loader".
(c) Bootloader also provides additional features useful for development & debugging.

(4) What is System Startup?
[ Exact process depends on the Target Hardware ]
(a) CPU starts exectuing BIOS at address 0xFFFF0
(b) POST (Power On Self Test) - is the first step of BIOS.
(c) run time services - involve local device enumeration and
initialization
(d) After the POST is complete, POST related code is flushed out of
memory. But BIOS runtime services remain in memory and are available to
the target OS.
(e) The runtime searches for devices that are both active and
bootable in order of preference defined in CMOS settings
(f) The primary boot loader is loaded and BIOS returns control to it

(5) The Primary boot loader
(a) Performs few optional initializations
(b) Its main job is to Load the secondary boot loader

(6) Secondary boot loader
(a) The Second Stage boot loader loads the Linux & an optional
initial RAM disk in to the memory
(b) on PC, the initrd is used as a temporary root files
system, before final root file system gets mounted. However, on embedded
systems, the initrd is generally the final root file system.
(c) The secondary loader passes control to the kernel image - kernel is
decompressed & initialized
(d) So, the secondary boot loaderis the kernel Loader, can also load optional initial RAM disk (initrd), and then invokes the kernel image

(7) Kernel Invocation
(a) As the kernel is invoked, it performs the checks on system hardware, enumerates the attached hardware devices, mounts the root device
(b) Next it loads the necessary kernel modules
(c) First user-space program (init) now starts and high-level system initialization is performed
(d) The Kernel Invocation Process is similar on Embedded Linux Systems as well as on PC. We will discuss this in detail in following text.

(8) Kernel Image
(a) Is typically a compressed image [zlib compression]
(b) Typical named a zImage (<512 KB) or bzImage (> 512 KB)
(c) At the head of this image (in file head.S) is a routine that does some minimal amount of hardware set up and then decompresses the kernel contained in the kernel image and places in to high memory (high memory & low memory)

.................
PART-B
..................

(1) Kernel Invocation Process - A Summary

(a) zImage Entry Point
(b) PERFORM BASIC HARDWARE SET UP
(c) PERFORM BASIC ENVIRONMENT SET UP (stack etc)
(d) CLEAR BSS

[Now We have set up the run time environment for the code to be
executed next]

(e) DECOMPRESS THE KERNEL IMAGE
(f) Execute the decompressed Kernel Image
- INITIALIZE PAGE TABLES
- ENABLE MMU
- DETECT CPU (& optoinal FPU) TYPE & SAVE THIS INFO

[With above set up, we are now ready to execute a general C
Code. Till now we only executed asm routines.]

(g) The First Kernel C function
- DO FURTHER INITIALIZATIONS
- LOAD INITRD

[ The above code is being executed by swapper process, the one
with pid 0]

(h) The Init Process
- FORK INIT PROCESS
- Init process is with pid 1
- Invoke Scheduler
- RELINQUISH CONTROL TO SCHEDULER

(2) zImage Entry point
(a) This is a call to the absolute physical address by boot loader

- Refer to file arch/***/boot/compressed/head.S: start() in kernel source.
- For the ARM process this is "arch/arm/boot/compressed/head.S: start()"

(b) start() performs
- basic hardware set up
- basic environment set up
- clears bss
- calls the decompress_kernel()

(3) Decompressing Kernel Image
(a) This is a call to arch/***/boot/compressed/misc.c: decompress_kernel()
- This function decompresses the kernel image, stores it in to the RAM & returns the address of decompressed image in RAM.
(b) on ARM processor this maps to "arch/arm/boot/compressed/misc.c: decompress_kernel()" routine.

(4) Execute the decompressed Kernel Image
(a) After we have got the (uncompressed) kernel image in RAM, we execute it.
(b) Execution starts with call_kernel() function call [from start()].
(c) call_kernel() will start executing the kernel code, from Kernel
entry point.
(d) arch/***/kernel/head.S contains the kernel entry point.
- separate entry points for Master CPU and Secondary CPUs (for SMP
systems).
- This code is in asm
- Page Tables are Initialized & MMU is enabled.
- type of CPU alongwith optional FPU is detected and stored
- For Master CPU; start_kernel(), which is the first C function to
be executed in kernel, is called.
- For secondary CPUs (on an SMP system); secondary_start_kernel()
is the first C function to be called.
(e) On ARM process it maps to "arch/arm/kernel/head.S
- Contains kernel ENTRY points for master and secondary CPU.
- For Master CPU "mmap_switched()" is called as soon as mmu gets enabled. The mmap_switched() saves the CPU info makes a call to start_kernel()
- For Secondary CPU "secondary_start_kernel()" is called as soon as MMU gets enabled.

(5) The first kernel C function
(a) The start_kernel() function is being executed by the swapper process.
(b) Refer to init/main.c: start_kernel() in the kernel source.
(c) start_kernel():
- a long list of initialization functions are called: this sets up interrupts, performs further memory configuration & loads the initrd.
- calls rest_init() in the End.
(d) econdary_start_kernel() for secondary CPUs (on SMP systems).
- arch/***/kernel/smp.c: secondary_start_kernel()
- for ARM, arch/arm/kernel/smp.c
- there is not rest_init() call for secondary CPUs.

(6) Init process
(a) Refer to init/main.c: rest_init() in kernel source.
(b) Executed only on the Master CPU
(c) rest_init() forks new process by calling kernel_thread() function
(d) kernel_thread(kern_init,*,*); kern_init has PID-1
(e) kern_init() will call the initialization scripts.
(f) kernel_thread() defined in "arch/***/kernel/process.c: kernel_thread()".
(g) on ARM, arch/arm/kernel/process.c

(7) Invoke scheduler
(a) The rest_init() calls cpu_idle() in end [after it is done creating the init process]
(b) For the Secondary CPUs (on SMP systems), cpu_idle is directly
called from secondary_start_kernel [no step-5 & hence no init process].
(c) cpu_idle() defined in "arch/***/kernel/process.c: cpu_idle()".
(d) on ARM, arch/arm/kernel/process.c

(8) initrd image
(a) The initrd serves as a temporary root file system in RAM & allows the kernel to fully boot without having to mount and physical disks. Since the necessary modules needed to interface with peripherals
can be part of initrd the kernel can be very small.
(b) pivot_root() routine: the root files system is pivoted where the initrd root file system is unmounted & the real root file system is mounted.
(c) In any embedded system, the initrd could be the root file system.

........................

References:
http://www.ibm.com/developerworks/linux/library/l-linuxboot/
http://duartes.org/gustavo/blog/post/how-computers-boot-up
http://duartes.org/gustavo/blog/post/kernel-boot-process

EMBEDDED SYSTEMS

Writing Linux Device Driver

User space and kernel space

Interfacing functions between user space and kernel space

Interfacing functions between kernel space and the hardware device

Overview of Embedded Linux Booting Sequence