You can find these files in the BSP Layer at:

     meta-<bsp_name>/<bsp_license_file>
                

These optional files satisfy licensing requirements for the BSP. The type or types of files here can vary depending on the licensing requirements. For example, in the Crown Bay BSP all licensing requirements are handled with the COPYING.MIT file.

Licensing files can be MIT, BSD, GPLv*, and so forth. These files are recommended for the BSP but are optional and totally up to the BSP developer.

You can find this file in the BSP Layer at:

     meta-<bsp_name>/README
                

This file provides information on how to boot the live images that are optionally included in the binary/ directory. The README file also provides special information needed for building the image.

At a minimum, the README file must contain a list of dependencies, such as the names of any other layers on which the BSP depends and the name of the BSP maintainer with his or her contact information.

You can find this file in the BSP Layer at:

     meta-<bsp_name>/README.sources
                

This file provides information on where to locate the BSP source files. For example, information provides where to find the sources that comprise the images shipped with the BSP. Information is also included to help you find the metadata used to generate the images that ship with the BSP.

You can find these files in the BSP Layer at:

     meta-<bsp_name>/binary/<bootable_images>
                

This optional area contains useful pre-built kernels and user-space filesystem images appropriate to the target system. This directory typically contains graphical (e.g. sato) and minimal live images when the BSP tarball has been created and made available in the Yocto Project website. You can use these kernels and images to get a system running and quickly get started on development tasks.

The exact types of binaries present are highly hardware-dependent. However, a README file should be present in the BSP Layer that explains how to use the kernels and images with the target hardware. If pre-built binaries are present, source code to meet licensing requirements must also exist in some form.

You can find this file in the BSP Layer at:

     meta-<bsp_name>/conf/layer.conf
                

The conf/layer.conf file identifies the file structure as a Yocto Project layer, identifies the contents of the layer, and contains information about how Yocto Project should use it. Generally, a standard boilerplate file such as the following works. In the following example, you would replace "bsp" and "_bsp" with the actual name of the BSP (i.e. <bsp_name> from the example template).

     # We have a conf and classes directory, add to BBPATH
     BBPATH := "${BBPATH}:${LAYERDIR}"

     # We have a recipes directory, add to BBFILES
     BBFILES := "${BBFILES} ${LAYERDIR}/recipes/*/*.bb \ 
                 ${LAYERDIR}/recipes/*/*.bbappend"

     BBFILE_COLLECTIONS += "bsp"
     BBFILE_PATTERN_bsp := "^${LAYERDIR}/"
     BBFILE_PRIORITY_bsp = "6"
                

To illustrate the string substitutions, here are the last three statements from the Crown Bay conf/layer.conf file:

     BBFILE_COLLECTIONS += "crownbay"
     BBFILE_PATTERN_crownbay := "^${LAYERDIR}/"
     BBFILE_PRIORITY_crownbay = "6"
                

This file simply makes BitBake aware of the recipes and configuration directories. The file must exist so that the Yocto Project build system can recognize the BSP.

You can find these files in the BSP Layer at:

     meta-<bsp_name>/conf/machine/*.conf
                

The machine files bind together all the information contained elsewhere in the BSP into a format that the Yocto Project build system can understand. If the BSP supports multiple machines, multiple machine configuration files can be present. These filenames correspond to the values to which users have set the MACHINE variable.

These files define things such as the kernel package to use (PREFERRED_PROVIDER of virtual/kernel), the hardware drivers to include in different types of images, any special software components that are needed, any bootloader information, and also any special image format requirements.

Each BSP Layer requires at least one machine file. However, you can supply more than one file. For example, in the Crown Bay BSP shown earlier in this section, the conf/machine directory contains two configuration files: crownbay.conf and crownbay-noemgd.conf. The crownbay.conf file is used for the Crown Bay BSP that supports the Intel® Embedded Media and Graphics Driver (Intel® EMGD), while the crownbay-noemgd.conf file is used for the Crown Bay BSP that does not support the Intel® EMGD.

This crownbay.conf file could also include a hardware "tuning" file that is commonly used to define the package architecture and specify optimization flags, which are carefully chosen to give best performance on a given processor.

Tuning files are found in the meta/conf/machine/include directory of the Yocto Project Files. Tuning files can also reside in the BSP Layer itself. For example, the ia32-base.inc file resides in the meta-intel BSP Layer in conf/machine/include.

To use an include file, you simply include them in the machine configuration file. For example, the Crown Bay BSP crownbay.conf has the following statements:

     include conf/machine/include/tune-atom.inc
     include conf/machine/include/ia32-base.inc
                

You can find these files in the BSP Layer at:

     meta-<bsp_name>/recipes-bsp/*
                

This optional directory contains miscellaneous recipe files for the BSP. Most notably would be the formfactor files. For example, in the Crown Bay BSP there is the formfactor_0.0.bbappend file, which is an append file used to augment the recipe that starts the build. Furthermore, there are machine-specific settings used during the build that are defined by the machconfig files. In the Crown Bay example, two machconfig files exist: one that supports the Intel® Embedded Media and Graphics Driver (Intel® EMGD) and one that does not:

     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay/machconfig
     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay-noemgd/machconfig
     meta-crownbay/recipes-bsp/formfactor/formfactor_0.0.bbappend
                

You can find these files in the BSP Layer at:

     meta-<bsp_name>/recipes-core/*
                

This directory contains recipe files that are almost always necessary to build a useful, working Linux image. Thus, the term "core" is used to group these recipes. For example, in the Crown Bay BSP there is the task-core-tools-profile.bbappend file, which is an append file used to recommend that the SystemTap package be included as a package when the image is built.

You can find these files in the BSP Layer at:

     meta-<bsp_name>/recipes-graphics/*            
                

This optional directory contains recipes for the BSP if it has special requirements for graphics support. All files that are needed for the BSP to support a display are kept here. For example, the Crown Bay BSP contains two versions of the xorg.conf file. The version in crownbay builds a BSP that supports the Intel® Embedded Media Graphics Driver (EMGD), while the version in crownbay-noemgd builds a BSP that supports Video Electronics Standards Association (VESA) graphics only:

     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config_0.1.bbappend
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay/xorg.conf
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay-noemgd/xorg.conf
                

You can find these files in the BSP Layer at:

     meta-<bsp_name>/recipes-kernel/linux/linux-yocto_*.bbappend
                

These files append your specific changes to the kernel you are using.

For your BSP, you typically want to use an existing Yocto Project kernel found in the Yocto Project Files at meta/recipes-kernel/linux. You can append your specific changes to the kernel recipe by using a similarly named append file, which is located in the BSP Layer (e.g. the meta-<bsp_name>/recipes-kernel/linux directory).

Suppose the BSP uses the linux-yocto_3.0.bb kernel, which is the preferred kernel to use for developing a new BSP using the Yocto Project. In other words, you have selected the kernel in your <bsp_name>.conf file by adding the following statements:

     PREFERRED_PROVIDER_virtual/kernel ?= "linux-yocto"
     PREFERRED_VERSION_linux-yocto = "3.0%"
                

You would use the linux-yocto_3.0.bbappend file to append specific BSP settings to the kernel, thus configuring the kernel for your particular BSP.

As an example, look at the existing Crown Bay BSP. The append file used is:

     meta-crownbay/recipes-kernel/linux/linux-yocto_3.0.bbappend
                

The following listing shows the file. Be aware that the actual commit ID strings in this example listing might be different than the actual strings in the file from the meta-intel Git source repository.

     FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

     COMPATIBLE_MACHINE_crownbay = "crownbay"
     KMACHINE_crownbay  = "yocto/standard/crownbay"
     KERNEL_FEATURES_append_crownbay += " cfg/smp.scc"

     COMPATIBLE_MACHINE_crownbay-noemgd = "crownbay-noemgd"
     KMACHINE_crownbay-noemgd  = "yocto/standard/crownbay"
     KERNEL_FEATURES_append_crownbay-noemgd += " cfg/smp.scc"

     SRCREV_machine_pn-linux-yocto_crownbay ?= "63c65842a3a74e4bd3128004ac29b5639f16433f"
     SRCREV_meta_pn-linux-yocto_crownbay ?= "59314a3523e360796419d76d78c6f7d8c5ef2593"

     SRCREV_machine_pn-linux-yocto_crownbay-noemgd ?= "63c65842a3a74e4bd3128004ac29b5639f16433f"
     SRCREV_meta_pn-linux-yocto_crownbay-noemgd ?= "59314a3523e360796419d76d78c6f7d8c5ef2593"
                

This append file contains statements used to support the Crown Bay BSP for both Intel® EMGD and the VESA graphics. The build process, in this case, recognizes and uses only the statements that apply to the defined machine name - crownbay in this case. So, the applicable statements in the linux-yocto_3.0.bbappend file are follows:

     FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

     COMPATIBLE_MACHINE_crownbay = "crownbay"
     KMACHINE_crownbay  = "yocto/standard/crownbay"
     KERNEL_FEATURES_append_crownbay += " cfg/smp.scc"

     SRCREV_machine_pn-linux-yocto_crownbay ?= "63c65842a3a74e4bd3128004ac29b5639f16433f"
     SRCREV_meta_pn-linux-yocto_crownbay ?= "59314a3523e360796419d76d78c6f7d8c5ef2593"
                

The append file defines crownbay as the compatible machine and defines the KMACHINE. The file also points to some configuration fragments to use by setting the KERNEL_FEATURES variable. The location for the configuration fragments is the kernel tree itself in the Yocto Project Build Directory under linux/meta. Finally, the append file points to the specific commits in the Yocto Project Files Git repository and the meta Git repository branches to identify the exact kernel needed to build the Crown Bay BSP.

One thing missing in this particular BSP, which you will typically need when developing a BSP, is the kernel configuration file (.config) for your BSP. When developing a BSP, you probably have a kernel configuration file or a set of kernel configuration files that, when taken together, define the kernel configuration for your BSP. You can accomplish this definition by putting the configurations in a file or a set of files inside a directory located at the same level as your append file and having the same name as the kernel. With all these conditions met simply reference those files in a SRC_URI statement in the append file.

For example, suppose you had a set of configuration options in a file called myconfig. If you put that file inside a directory named /linux-yocto and then added a SRC_URI statement such as the following to the append file, those configuration options will be picked up and applied when the kernel is built.

     SRC_URI += "file://myconfig"
                

As mentioned earlier, you can group related configurations into multiple files and name them all in the SRC_URI statement as well. For example, you could group separate configurations specifically for Ethernet and graphics into their own files and add those by using a SRC_URI statement like the following in your append file:

     SRC_URI += "file://myconfig \
            file://eth.cfg \
            file://gfx.cfg"
                

The FILESEXTRAPATHS variable is in boilerplate form in the previous example in order to make it easy to do that. This variable must be in your layer or BitBake will not find the patches or configurations even if you have them in your SRC_URI. The FILESEXTRAPATHS variable enables the build process to find those configuration files.

Before looking at BSP requirements, you should consider the following:

Following are the requirements for a released BSP that conforms to the Yocto Project:

Following are recommendations for a released BSP that conforms to the Yocto Project:

Designed to have a command interface somewhat like Git, each tool is structured as a set of sub-commands under a top-level command. The top-level command (yocto-bsp or yocto-kernel) itself does nothing but invoke or provide help on the sub-commands it supports.

Both tools reside in the scripts/ subdirectory of the Yocto Project Files. Consequently, to use the scripts, you must source the environment just as you would when invoking a build:

     $ source oe-init-build-env [build_dir]
                    

The most immediately useful function is to get help on both tools. The built-in help system makes it easy to drill down at any time and view the syntax required for any specific command. Simply enter the name of the command, or the command along with help to display a list of the available sub-commands. Here is an example:

     $ yocto-bsp
     $ yocto-bsp help

     Usage:

     Create a customized Yocto BSP layer.

     usage: yocto-bsp [--version] [--help] COMMAND [ARGS]

     The most commonly used 'yocto-bsp' commands are:
     create            Create a new Yocto BSP
     list              List available values for options and BSP properties

     See 'yocto-bsp help COMMAND' for more information on a specific command.


     Options:
     --version    show program's version number and exit
     -h, --help   show this help message and exit
     -D, --debug  output debug information
                    

Similarly, entering just the name of a sub-command shows the detailed usage for that sub-command:

     $ yocto-bsp create

     Usage:

     Create a new Yocto BSP
     usage: yocto-bsp create <bsp-name> <karch> [-o <DIRNAME> | --outdir <DIRNAME>]
             [-i <JSON PROPERTY FILE> | --infile <JSON PROPERTY_FILE>]

                 This command creates a Yocto BSP based on the specified parameters.
                 The new BSP will be a new Yocto BSP layer contained by default within
                 the top-level directory specified as 'meta-bsp-name'.  The -o option
                 can be used to place the BSP layer in a directory with a different
                 name and location.

                 ...
                    

For any sub-command, you can also use the word 'help' just before the sub-command to get more extensive documentation:

     $ yocto-bsp help create

     NAME
     yocto-bsp create - Create a new Yocto BSP

     SYNOPSIS
     yocto-bsp create <bsp-name> <karch> [-o <DIRNAME> | --outdir <DIRNAME>]
             [-i <JSON PROPERTY FILE> | --infile <JSON PROPERTY_FILE>]

     DESCRIPTION
     This command creates a Yocto BSP based on the specified
     parameters.  The new BSP will be a new Yocto BSP layer contained
     by default within the top-level directory specified as
     'meta-bsp-name'.  The -o option can be used to place the BSP layer
     in a directory with a different name and location.
			    
     The value of the 'karch' parameter determines the set of files
     that will be generated for the BSP, along with the specific set of
     'properties' that will be used to fill out the BSP-specific
     portions of the BSP.
			    
     ...
			    
     NOTE: Once created, you should add your new layer to your
     bblayers.conf file in order for it to be subsequently seen and
     modified by the yocto-kernel tool.
			    
     NOTE for x86- and x86_64-based BSPs: The generated BSP assumes the
     presence of the of the meta-intel layer, so you should also have a
     meta-intel layer present and added to your bblayers.conf as well.
                    

Now that you know where these two commands reside and how to access information on them, you should find it relatively straightforward to discover the commands necessary to create a BSP and perform basic kernel maintenance on that BSP using the tools. The next sections provide a concrete starting point to expand on a few points that might not be immediately obvious or that could use further explanation.

The yocto-bsp script creates a new BSP layer for any architecture supported by the Yocto Project, as well as QEMU versions of the same. The default mode of the script's operation is to prompt you for information needed to generate the BSP layer. For the current set of BSPs, the script prompts you for various important parameters such as:

You use the yocto-bsp create sub-command to create a new BSP layer. This command requires you to specify a particular architecture on which to base the BSP. Assuming you have sourced the environment, you can use the yocto-bsp list karch sub-command to list the architectures available for BSP creation as follows:

     $ yocto-bsp list karch
     Architectures available:
         arm
         powerpc
         i386
         mips
         x86_64
         qemu
                    

The remainder of this section presents an example that uses myarm as the machine name and qemu as the machine architecture. Of the available architectures, qemu is the only architecture that causes the script to prompt you further for an actual architecture. In every other way, this architecture is representative of how creating a BSP for a 'real' machine would work. The reason the example uses this architecture is because it is an emulated architecture and can easily be followed without requiring actual hardware.

As the yocto-bsp create command runs, default values for the prompts appear in brackets. Pressing enter without supplying anything on the command line or pressing enter and providing an invalid response causes the script to accept the default value.

Following is the complete example:

     $ yocto-bsp create myarm qemu
     Which qemu architecture would you like to use? [default: x86]
             1) common 32-bit x86
             2) common 64-bit x86
             3) common 32-bit ARM
             4) common 32-bit PowerPC
             5) common 32-bit MIPS
     3
     Would you like to use the default (3.2) kernel? (Y/n)
     Do you need a new machine branch for this BSP (the alternative is to re-use an existing branch)? [Y/n]
     Getting branches from remote repo git://git.yoctoproject.org/linux-yocto-3.2...
     Please choose a machine branch to base this BSP on => [default: standard/default/common-pc]
             1) base
             2) standard/base
             3) standard/default/arm-versatile-926ejs
             4) standard/default/base
             5) standard/default/beagleboard
             6) standard/default/cedartrailbsp (copy).xml
             7) standard/default/common-pc-64/base
             8) standard/default/common-pc-64/jasperforest
             9) standard/default/common-pc-64/romley
             10) standard/default/common-pc-64/sugarbay
             11) standard/default/common-pc/atom-pc
             12) standard/default/common-pc/base
             13) standard/default/crownbay
             14) standard/default/emenlow
             15) standard/default/fishriver
             16) standard/default/fri2
             17) standard/default/fsl-mpc8315e-rdb
             18) standard/default/mti-malta32-be
             19) standard/default/mti-malta32-le
             20) standard/default/preempt-rt
             21) standard/default/qemu-ppc32
             22) standard/default/routerstationpro
             23) standard/preempt-rt/base
             24) standard/preempt-rt/qemu-ppc32
             25) standard/preempt-rt/routerstationpro
             26) standard/tiny
     3
     Do you need SMP support? (Y/n)
     Does your BSP have a touchscreen? (y/N)
     Does your BSP have a keyboard? (Y/n)
     New qemu BSP created in meta-myarm
                    

Let's take a closer look at the example now:

Once the BSP Layer is created, you must add it to your bblayers.conf file. Here is an example:

     BBLAYERS = " \
        /usr/local/src/yocto/meta \
        /usr/local/src/yocto/meta-yocto \
        /usr/local/src/yocto/meta-myarm \
        "
                    

Adding the layer to this file allows the build system to build the BSP and the yocto-kernel tool to be able to find the layer and other metadata it needs on which to operate.

Assuming you have created a Yocto Project BSP Layer using yocto-bsp and you added it to your BBLAYERS variable in the bblayers.conf file, you can now use the yocto-kernel script to add patches and configuration items to the BSP's kernel.

The yocto-kernel script allows you to add, remove, and list patches and kernel config settings to a Yocto Project BSP's kernel .bbappend file. All you need to do is use the appropriate sub-command. Recall that the easiest way to see exactly what sub-commands are available is to use the yocto-kernel built-in help as follows:

     $ yocto-kernel
     Usage:

     Modify and list Yocto BSP kernel config items and patches.

     usage: yocto-kernel [--version] [--help] COMMAND [ARGS]

     The most commonly used 'yocto-kernel' commands are:
     config list       List the modifiable set of bare kernel config options for a BSP
     config add        Add or modify bare kernel config options for a BSP 
     config rm         Remove bare kernel config options from a BSP
     patch list        List the patches associated with a BSP
     patch add         Patch the Yocto kernel for a BSP
     patch rm          Remove patches from a BSP

     See 'yocto-kernel help COMMAND' for more information on a specific command.
                    

The yocto-kernel patch add sub-command allows you to add a patch to a BSP. The following example adds two patches to the myarm BSP:

     $ yocto-kernel patch add myarm ~/test.patch
     Added patches:
             test.patch

     $ yocto-kernel patch add myarm ~/yocto-testmod.patch
     Added patches:
             yocto-testmod.patch
                    

You can verify patches have been added by using the yocto-kernel patch list sub-command. Here is an example:

     $ yocto-kernel patch list myarm
     The current set of machine-specific patches for myarm is:
             1) test.patch
             2) yocto-testmod.patch
                    

You can also use the yocto-kernel script to remove a patch using the yocto-kernel patch rm sub-command. Here is an example:

     $ yocto-kernel patch rm myarm
     Specify the patches to remove:
             1) test.patch
             2) yocto-testmod.patch
     1
     Removed patches:
             test.patch
                    

Again, using the yocto-kernel patch list sub-command, you can verify that the patch was in fact removed:

     $ yocto-kernel patch list myarm
     The current set of machine-specific patches for myarm is:
             1) yocto-testmod.patch
                    

In a completely similar way, you can use the yocto-kernel config add sub-command to add one or more kernel config item settings to a BSP. The following commands add a couple of config items to the myarm BSP:

     $ yocto-kernel config add myarm CONFIG_MISC_DEVICES=y
     Added items:
             CONFIG_MISC_DEVICES=y

     $ yocto-kernel config add myarm KCONFIG_YOCTO_TESTMOD=y
     Added items:
             CONFIG_YOCTO_TESTMOD=y
                    

You can list the config items now associated with the BSP. Doing so shows you the config items you added as well as others associated with the BSP:

     $ yocto-kernel config list myarm
     The current set of machine-specific kernel config items for myarm is:
             1) CONFIG_MISC_DEVICES=y
             2) CONFIG_YOCTO_TESTMOD=y
                    

Finally, you can remove one or more config items using the yocto-kernel config rm sub-command in a manner completely analogous to yocto-kernel patch rm.