BSP vs Device-Drivers

Question

While understanding each by itself (or maybe not), it looks like I'm far from understanding the practical differences between the two.

Per my understanding, a BSP is a package of drivers and configuration settings that allows a kernel image to boot up a board (and is part of it).

The individual device driver, operates on a specific component (hardware), interfacing on one side with the core kernel and on the other side with the device itself.

Looking at the Linux kernel, it is unclear to me where the BSP role starts and the device driver role ends. Specifically, I am used to see one BSP per board per image, however, the generic Linux kernel may be loaded on any architecture family with the same image (it is clear that for different families there are different images: x86, amd64, arm, etc.), where the specific board and peripherals drivers are loaded per need from the initrd.

Is there a BSP for the common Linux kernel distributions? Or is BSP relevant just for special cases boards?

Is this behavior similar on other kernels? VxWorks?

And the last one, is it common to merge different BSP/s in order to generate a single image that will fit different boards?

Answer 1

Based on my experience, BSP is a much larger scope. It includes bootloader, rootfs, kernel, drivers, etc., which means having a BSP makes your board capable of booting itself up. Drivers make devices working and are just a part of BSP.

Drivers is not equal to BSP.

Answer 2

A board support package includes everything that is needed to use the board by an application. These include device drivers for the devices on the board and utility software for application programmers. A windowing environment is also available on multi-media boards. System engineers can further add extensions to the board. Some applications require reimplementing some part of the BSP for enhancements. Here the BSP plays a role of a reference implementation or a starting point for such requirements.

The confusion lies in the business model. The reference or development board is not an end/consumer product like a mobile device. It plays an important role to design and develop a product like iPhone or Samsung Galaxy.

A generic BSP will lack optimization in most cases therefore you can only expect a generic BSP for the newbie model or where optimization is left for you to be done. In case of cheap boards the BSP is quite generic because the producer will put less investment into it.

Don't stress much on the terms of kernel and user-space as there are also microkernels available. Here the drivers are part of user-space! Again think of a low-power board which only has one piece of code without any kernel. So it boils down to software that supports the board to do its job.

Answer 3

I see the relationship between BSPs and devices drivers as "has-a". Board support packages include device drivers.

The differences between BSPs & kernels isn't easy to distinguish. A kernel translates instructions to the hardware. Kernels are often written to particular families of hardware, so they're not as portable or generic as they seem. It amounts to different permutations of the code for each architecture family.

The BSP acts as sort of the inverse: it provides the tools & instructions to work with that board's specific set of hardware. In specific, controlled situations, the kernel could do this work. But the BSP enables any compatible kernel/OS/application stack to use that board, by following its configuration instructions.

If you just need to access CPU cycles & memory, maybe a few protocols (USB, Ethernet, and a couple of video types), a kernel with wide architecture support is fantastic, and there was a time when the breadth of that hardware abstraction was penultimately valued. But now, consider that the board may have a suite of sensors (accelerometer, magnetometer, gyroscope, light, proximity, atmospheric pressure, etc), telephony, there may be multiple CPUs, multiple GPUs, and so on. A kernel can be written to provide VGA, DVI, HDMI, DisplayPort, and several permutations of CPU/GPU combinations, if/when someone uses those particular hardware packages, but it's not practical to write support for all theoretical contexts, compared to utilizing a BSP that's built for a specific board. And even then, that would be for one kernel; the board is capable of supporting Linux, Windows, Android, Symbian, whatever.

That's why efforts like Yocto exist, to further decouple kernel and hardware. BSPs make hardware sets extensible beyond a kernel, OS, and application stack or two, while kernels make a particular OS or application stack portable over multiple hardware architectures.

Answer 4

There is a conceptual link between board support packages and a HAL (Hardware Abstraction Layer) in the sense that the device drivers / kernel modules perform the hardware abstraction and the board support package provides an interface to the device drivers or is the hardware abstraction layer itself.

So basically a BSP has a functionality similar to the BIOS in the DOS era:

Additionally the BSP is supposed to perform the following operations

• Initialize the processor
• Initialize the bus
• Initialize the interrupt controller
• Initialize the clock
• Initialize the RAM settings
• Configure the segments
• Load and run bootloader from flash

From: Board support package (Wikipedia)

The BIOS in modern PCs initializes and tests the system hardware components, and loads a boot loader from a mass memory device which then initializes an operating system. In the era of DOS, the BIOS provided a hardware abstraction layer for the keyboard, display, and other input/output (I/O) devices [device drivers] that standardized an interface to application programs and the operating system. More recent operating systems do not use the BIOS after loading, instead accessing the hardware components directly.

Source: BIOS (Wikipedia)

Another aspect is the usage of device trees in BSPs, the device tree is a unifying or standardizing concept to describe the hardware of a machine:

U-boot boot loader and getting ready to ship

Doug Abbott, in Linux for Embedded and Real-Time Applications (Fourth Edition), 2018

Device Trees

One of the biggest problems with porting an operating system such as Linux to a new platform is describing the hardware. That is because the hardware description is scattered over perhaps several dozen or so device drivers, the kernel, and the boot loader, just to name a few. The ultimate result is that these various pieces of software become unique to each platform, the number of configuration options grows, and every board requires a unique kernel image.

There have been a number of approaches to addressing this problem. The notion of a “board support package” or BSP attempts to gather all of the hardware-dependent code in a few files in one place. It could be argued that the entire arch/ subtree of the Linux kernel source tree is a gigantic board support package.

Take a look at the arch/arm/ subtree of the kernel. In there you will find a large number of directories of the form mach-* and plat-*, presumably short for “machine” and “platform,” respectively. Most of the files in these directories provide configuration information for a specific implementation of the ARM architecture. And of course, each implementation describes its configuration differently.

Would not it be nice to have a single language that could be used to unambiguously describe the hardware of a computer system? That is the premise, and promise, of device trees.

The peripheral devices in a system can be characterized along a number of dimensions. There are, for example, character vs block devices. There are memory mapped devices, and those that connect through an external bus such as I2C or USB. Then there are platform devices and discoverable devices.

Discoverable devices are those that live on external busses, such as PCI and USB, that can tell the system what they are and how they are configured. That is, they can be “discovered” by the kernel. Having identified a device, it is a fairly simple matter to load the corresponding driver, which then interrogates the device to determine its precise configuration.

Platform devices, on the other hand, lack any mechanism to identify themselves. System on Chip (SoC) implementations, such as the Sitara, are rife with these platform devices—system clocks, interrupt controllers, GPIO, serial ports, to name a few. The device tree mechanism is particularly useful for managing platform devices.

The device tree concept evolved in the PowerPC branch of the kernel, and that is where it seems to be used the most. In fact, it is now a requirement that all PowerPC platforms pass a device tree to the kernel at boot time. The text representation of a device tree is a file with the extension .dts. These .dts files are typically found in the kernel source tree at arch/$ARCH/boot/dts.

A device tree is a hierarchical data structure that describes the collection of devices and interconnecting busses of a computer system. It is organized as nodes that begin at a root represented by “/,” just like the root file system. Every node has a name and consists of “properties” that are name-value pairs. It may also contain “child” nodes.

Listing 15.1 is a sample device tree taken from the devicetree.org website. It does nothing beyond illustrating the structure. Here we have two nodes named node1 and node2. node1 has two child nodes, and node2 has one child. Properties are represented by name=value. Values can be strings, lists of strings, one or more numeric values enclosed by square brackets, or one or more “cells” enclosed in angle brackets. The value can also be empty if the property conveys a Boolean value by its presence or absence.

Source: Board Support Package (ScienceDirect)

Via device tree overlays kernel modules can be loaded at boot time, i.e., on Raspberry Pi adding dtoverlay=lirc-rpi to /boot/config.txt loads the lirc-pi kernel module/device driver:

A future default config.txt may contain a section like this:

 # Uncomment some or all of these to enable the optional hardware interfaces
 #dtparam=i2c_arm=on
 #dtparam=i2s=on
 #dtparam=spi=on

If you have an overlay that defines some parameters, they can be specified either on subsequent lines like this:

 dtoverlay=lirc-rpi
 dtparam=gpio_out_pin=16
 dtparam=gpio_in_pin=17
 dtparam=gpio_in_pull=down

Source: Configuration (Raspberry Pi Documentation)

When building BSPs with Yocto, all the hardware information that is scattered over device drivers, the kernel, the boot loader, etc. is gathered. Here is the developer's guide how this can be done in Yocto: Yocto Project Board Support Package Developer's Guide

[Yocto documentation]... states that the BSP “…is concerned with the hardware-specific components only. At the end-distribution point, you can ship the BSP combined with a build system and other tools. However, it is important to maintain the distinction that these are separate components that happen to be combined in certain end products.”

Source: Board Support Package: what is it?

Answer 5

Today things are modular to increase reusability, and software development for embedded systems normally breaks down into three layers.

• Kernel (which contain task handling, scheduling, and memory management)
• Stack (which is the upper layer on the device drivers and provides protocol implementations for I²C, SPI, Ethernet, SDIO, serial, file system, networking, etc.)
• BSP = Device drivers (which provide access to any controller's registers on hardware like registers of I²C, SDIO, SPI, Ethernet MAC address, UART (serial) and interrupt handling (ISR).

Board support package (device driver) is a software layer which changes with every board, keeping the other two software layers unchanged.

Answer 6

The driver is a program which says to the kernel like the behavior of the device... The device may be USB devices or camera or Bluetooth or it can be anything.

Based on the size of operation we classify into three char, block, network. But it only gives access to each device...It configures only the device alone not configure the memory, CPU speed. It does not give the instruction for that processor or controller. It is work on that processor or controller. Who enables that microcontroller who define the functionalities, who gives the starting point of the microcontroller. Who gives instructions. Now comes the answer like BSP.

BSP is a board support package which enables the bootloader. It gives the behavior of the system.

Consider the two scenarios,

1. One is having pc in pc having a USB connector option. All are okay. This is the first scenario

2. Second is I am having a pc, board alone in the board having USB. The board should talk to USB. What can I do?

3. In this case, I have a pc with an OS, so I do not need to think about the behaviour of the system. So I just enable the behavior of the device with system OS

4. In this, the board means that processor with all peripherals. In this case, we do not have an OS, so we need to make or we need to enable the behavior of that device.