summaryrefslogtreecommitdiffstats
path: root/documentation/bsp-guide/bsp.xml
blob: 08c90b46c184c1145562e80366f1a8e46478c611 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">

<chapter id='bsp'>

        <title>Board Support Packages (BSP) - Developer's Guide</title>

        <para>
            A Board Support Package (BSP) is a collection of information that
            defines how to support a particular hardware device, set of devices, or 
            hardware platform. 
            The BSP includes information about the hardware features 
            present on the device and kernel configuration information along with any 
            additional hardware drivers required.
            The BSP also lists any additional software 
            components required in addition to a generic Linux software stack for both 
            essential and optional platform features.
        </para>

        <para>
            This section (or document if you are reading the BSP Developer's Guide) defines
            a structure for these components
            so that BSPs follow a commonly understood layout.
            Providing a common form allows end-users to understand and become familiar 
            with the layout.  
            A common form also encourages standardization 
            of software support of hardware.
        </para>

        <note>
            The information here does not provide an example of how to create a BSP.
            For examples on how to create a BSP, see the
            "<ulink url='http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html#dev-manual-bsp-appendix'>BSP Development Example</ulink>"
            section in The Yocto Project Development Manual.
            You can also see the 
            <ulink url='https://wiki.yoctoproject.org/wiki/Transcript:_creating_one_generic_Atom_BSP_from_another'>
            wiki page</ulink>.
        </note>

        <para>
            The proposed format does have elements that are specific to the Yocto Project and 
            OpenEmbedded build systems. 
            It is intended that this information can be 
            used by other systems besides Yocto Project and OpenEmbedded and that it will be simple
            to extract information and convert it to other formats if required.
            Yocto Project, through its standard layers mechanism, can directly accept the format 
            described as a layer.
            The BSP captures all 
            the hardware-specific details in one place in a standard format, which is 
            useful for any person wishing to use the hardware platform regardless of 
            the build system they are using.
        </para>

        <para>
            The BSP specification does not include a build system or other tools -
            it 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.
        </para>

        <section id='bsp-layers'>
            <title>BSP Layers</title>

            <para>
                The BSP consists of a file structure inside a base directory.
                Collectively, you can think of the base directory and the file structure 
                as a BSP Layer.
                BSP Layers use the following naming convention:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;
                </literallayout>
                "bsp_name" is a placeholder for the machine or platform name.
            </para>

            <para>
                The Yocto Project organizes BSP Layers within the Yocto Metadata Layers area 
                of the Yocto Project Source Repositories at 
                <ulink url='http://git.yoctoproject.org/cgit.cgi'></ulink>.
                If you examine the source repositories, you will find many BSP Layers.
                Here are a few:
                <literallayout class='monospaced'>
     meta-baryon
     meta-fsl-ppc
     meta-intel
     meta-selinux
     meta-ti
                </literallayout>
                It is worth noting that the <filename>meta-intel</filename> BSP Layer contains 
                within itself several other BSP Layers, which makes it sort of a "super" BSP layer.
                Following is a sampling of the BSP Layers that the <filename>meta-intel</filename> 
                BSP Layer contains:
                <literallayout class='monospaced'>
     meta-cedartrail
     meta-crownbay
     meta-emenlow
     meta-fishriver
     meta-fri2
                </literallayout>
            </para>

            <para>
                The layer's base directory (<filename>meta-&lt;bsp_name&gt;</filename>) is the root 
                of the BSP Layer.
                This root is what you add to the <filename>BBLAYERS</filename>
                variable in the <filename>conf/bblayers.conf</filename> file found in the 
                <ulink url='http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html#yocto-project-build-directory'>Yocto Project Build Directory</ulink>.
                Adding the root allows the Yocto Project build system to recognize the BSP 
                definition and from it build an image.
                Here is an example:
                <literallayout class='monospaced'>
     BBLAYERS = " \
        /usr/local/src/yocto/meta \
        /usr/local/src/yocto/meta-yocto \
        /usr/local/src/yocto/meta-&lt;bsp_name&gt; \
        "
                </literallayout>
            </para>

            <para>
                For more detailed information on layers, see the 
                "<ulink url='http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html#usingpoky-changes-layers'>Bitbake Layers</ulink>" 
                section of the Yocto Project Development Manual.
                You can also see the detailed examples in the appendices of  
                <ulink url='http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html'>
                The Yocto Project Development Manual</ulink>.
            </para>
        </section>


        <section id="bsp-filelayout">
            <title>Example Filesystem Layout</title>

            <para>
                Below is the common form for the file structure inside a BSP Layer.
                While you can use this basic form for the standard, realize that the actual structures
                for specific BSPs could differ. 

                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/                                
     meta-&lt;bsp_name&gt;/&lt;bsp_license_file&gt;
     meta-&lt;bsp_name&gt;/README
     meta-&lt;bsp_name&gt;/binary/&lt;bootable_images&gt;
     meta-&lt;bsp_name&gt;/conf/layer.conf 
     meta-&lt;bsp_name&gt;/conf/machine/*.conf
     meta-&lt;bsp_name&gt;/recipes-bsp/*
     meta-&lt;bsp_name&gt;/recipes-graphics/*            
     meta-&lt;bsp_name&gt;/recipes-kernel/linux/linux-yocto_&lt;kernel_rev&gt;.bbappend
                </literallayout>
            </para>

            <para>
                Below is an example of the Crown Bay BSP:

                <literallayout class='monospaced'>
     meta-crownbay/COPYING.MIT
     meta-crownbay/README
     meta-crownbay/README.sources
     meta-crownbay/binary
     meta-crownbay/conf/
     meta-crownbay/conf/layer.conf
     meta-crownbay/conf/machine/
     meta-crownbay/conf/machine/crownbay.conf
     meta-crownbay/conf/machine/crownbay-noemgd.conf
     meta-crownbay/recipes-bsp/
     meta-crownbay/recipes-bsp/formfactor/
     meta-crownbay/recipes-bsp/formfactor/formfactor_0.0.bbappend
     meta-crownbay/recipes-bsp/formfactor/formfactor/
     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay/
     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay/machconfig
     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay-noemgd/
     meta-crownbay/recipes-bsp/formfactor/formfactor/crownbay-noemgd/machconfig
     meta-crownbay/recipes-core
     meta-crownbay/recipes-core/tasks
     meta-crownbay/recipes-core/tasks/task-core-tools-profile.bbappend
     meta-crownbay/recipes-graphics/
     meta-crownbay/recipes-graphics/xorg-xserver/
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config_0.1.bbappend
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay/
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay/xorg.conf
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay-noemgd/
     meta-crownbay/recipes-graphics/xorg-xserver/xserver-xf86-config/crownbay-noemgd/xorg.conf
     meta-crownbay/recipes-kernel/
     meta-crownbay/recipes-kernel/linux/
     meta-crownbay/recipes-kernel/linux/linux-yocto-rt_3.0.bbappend
     meta-crownbay/recipes-kernel/linux/linux-yocto_2.6.37.bbappend
     meta-crownbay/recipes-kernel/linux/linux-yocto_3.0.bbappend
                </literallayout>
            </para>

            <para>
                The following sections describe each part of the proposed BSP format.
            </para>

            <section id="bsp-filelayout-license">
            <title>License Files</title>

            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/&lt;bsp_license_file&gt;
                </literallayout>
            </para>

            <para>
                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 
                <filename>COPYING.MIT</filename> file.  
            </para>

            <para>
                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.
            </para>
            </section>

            <section id="bsp-filelayout-readme">
            <title>README File</title>
            <para>
                You can find this file in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/README
                </literallayout>
            </para>

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

            <para>
                Technically speaking a <filename>README</filename> file is optional but it is highly 
                recommended that every BSP has one.
            </para>
            </section>

            <section id="bsp-filelayout-readme-sources">
            <title>README.sources File</title>
            <para>
                You can find this file in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/README.sources
                </literallayout>
            </para>

            <para>
                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.
            </para>

            <para>
                Technically speaking a <filename>README.sources</filename> file is optional but it is highly 
                recommended that every BSP has one.
            </para>
            </section>

            <section id="bsp-filelayout-binary">
            <title>Pre-built User Binaries</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/binary/&lt;bootable_images&gt;
                </literallayout>
            </para>

            <para>
                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 
                <ulink url='http://www.yoctoproject.org'>Yocto Project</ulink> website. 
                You can use these kernels and images to get a system running and quickly get started 
                on development tasks.
            </para>

            <para> 
                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.
            </para>
            </section>

            <section id='bsp-filelayout-layer'>
            <title>Layer Configuration File</title>
            <para>
                You can find this file in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/conf/layer.conf
                </literallayout>
            </para>

            <para>
                The <filename>conf/layer.conf</filename> 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. &lt;bsp_name&gt; from the example template).
            </para>

            <para>
               <literallayout class='monospaced'>
     # We have a conf directory, add to BBPATH
     BBPATH := "${BBPATH}:${LAYERDIR}"

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

     BBFILE_COLLECTIONS += "bsp"
     BBFILE_PATTERN_bsp := "^${LAYERDIR}/"
     BBFILE_PRIORITY_bsp = "5"
                </literallayout>
            </para>

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

            <section id="bsp-filelayout-machine">
            <title>Hardware Configuration Options</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/conf/machine/*.conf
                </literallayout>
            </para>

            <para>
                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 
                <filename>MACHINE</filename> variable.
            </para>

            <para>
                These files define things such as the kernel package to use
                (<filename>PREFERRED_PROVIDER</filename> 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.
            </para>

            <para>
                At least one machine file is required for a BSP layer.
                However, you can supply more than one file.
                For example, in the Crown Bay BSP shown earlier in this section, the 
                <filename>conf/machine</filename> directory contains two configuration files:
                <filename>crownbay.conf</filename> and <filename>crownbay-noemgd.conf</filename>.
                The <filename>crownbay.conf</filename> file is used for the Crown Bay BSP
                that supports the <trademark class='registered'>Intel</trademark> Embedded
                Media and Graphics Driver (<trademark class='registered'>Intel</trademark>
                EMGD), while the <filename>crownbay-noemgd.conf</filename> file is used for the 
                Crown Bay BSP that does not support the <trademark class='registered'>Intel</trademark>
                EMGD.
            </para>

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

            <para>
                Tuning files are found in the <filename>meta/conf/machine/include</filename>
                directory.
                To use them, you simply include them in the machine configuration file. 
                For example, the Crown Bay BSP <filename>crownbay.conf</filename> has the 
                following statement:
                <literallayout class='monospaced'>
     include conf/machine/include/tune-atom.inc
                </literallayout>
            </para>
            </section>

            <section id='bsp-filelayout-misc-recipes'>
            <title>Miscellaneous Recipe Files</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/recipes-bsp/*
                </literallayout> 
            </para>

            <para>
                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 
                <filename>formfactor_0.0.bbappend</filename> 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 <filename>machconfig</filename> files.
                In the Crown Bay example, two <filename>machconfig</filename> files exist:
                one that supports the Intel EMGD and one that does not:
                <literallayout class='monospaced'>
     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
                </literallayout>
            </para>

            <note><para>
                If a BSP does not have a formfactor entry, defaults are established according to
                the configuration script.
            </para></note>
            </section>

            <section id='bsp-filelayout-core-recipes'>
            <title>Core Recipe Files</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/recipes-core/*
                </literallayout> 
            </para>

            <para>
                This directory contains recipe files for the core.
                For example, in the Crown Bay BSP there is the 
                <filename>task-core-tools.bbappend</filename> file, which is an append file used 
                to recommend that the SystemTap package be included as a package when the image
                is built.
            </para>
            </section>

            <section id='bsp-filelayout-recipes-graphics'>
            <title>Display Support Files</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/recipes-graphics/*            
                </literallayout>
            </para>

            <para>
                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 the following files that support 
                building a BSP that supports and does not support the Intel EMGD:
                <literallayout class='monospaced'>
     meta-crownbay/recipes-graphics/xorg-xserver/emgd-driver-bin_1.6.bb
     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
                </literallayout>
            </para>
            </section>

            <section id='bsp-filelayout-kernel'>
            <title>Linux Kernel Configuration</title>
            <para>
                You can find these files in the BSP Layer at:
                <literallayout class='monospaced'>
     meta-&lt;bsp_name&gt;/recipes-kernel/linux/linux-yocto_*.bbappend
                </literallayout>
            </para>

            <para>
                These files append your specific changes to the kernel you are using.
            </para>
            <para>
                For your BSP, you typically want to use an existing Yocto Project kernel found in the 
                Yocto Project repository at <filename>meta/recipes-kernel/linux</filename>.
                You can append your specific changes to the kernel recipe by using a
                similarly named append file, which is located in the 
                <filename>meta-&lt;bsp_name&gt;/recipes-kernel/linux</filename> 
                directory.
            </para>
            <para>
                Suppose you use a BSP that uses the <filename>linux-yocto_3.0.bb</filename> 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 
                <filename>&lt;bsp_name&gt;.conf</filename> file by adding the following statements:
                <literallayout class='monospaced'>
     PREFERRED_PROVIDER_virtual/kernel ?= "linux-yocto"
     PREFERRED_VERSION_linux-yocto = "3.0%"
                </literallayout>
                You would use the <filename>linux-yocto_3.0.bbappend</filename> file to append 
                specific BSP settings to the kernel, thus configuring the kernel for your particular BSP.
            </para>
            <para>
                As an example, look at the existing Crown Bay BSP.
                The append file used is:
                <literallayout class='monospaced'>
     meta-crownbay/recipes-kernel/linux/linux-yocto_3.0.bbappend
                </literallayout>
                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 Yocto Project <filename>meta-intel</filename>
                Git source repository.
                <literallayout class='monospaced'>
     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"
                </literallayout>
                This append file contains statements used to support the Crown Bay BSP for both
                Intel EMGD and non-EMGD.
                The build process, in this case, recognizes and uses only the statements that 
                apply to the defined machine name - <filename>crownbay</filename> in this case.
                So, the applicable statements in the <filename>linux-yocto_3.0.bbappend</filename> 
                file are follows:
                <literallayout class='monospaced'>
     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"
                </literallayout>
                The append file defines <filename>crownbay</filename> as the compatible machine,
                defines the <filename>KMACHINE</filename>, points to some configuration fragments
                to use by setting the <filename>KERNEL_FEATURES</filename> variable, and then points
                to the specific commits in the Yocto Project files Git repository and the 
                <filename>meta</filename> Git repository branches to identify the exact kernel needed 
                to build the Crown Bay BSP.
            </para>
            <para>
                One thing missing in this particular BSP, which you will typically need when 
                developing a BSP, is the kernel configuration file (<filename>.config</filename>) 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 
                <filename>SRC_URI</filename> statement in the append file.
            </para>
            <para>
                For example, suppose you had a set of configuration options in a file called 
                <filename>defconfig</filename>.  
                If you put that file inside a directory named 
                <filename>/linux-yocto</filename> and then added 
                a <filename>SRC_URI</filename> statement such as the following to the append file, 
                those configuration
                options will be picked up and applied when the kernel is built.
                <literallayout class='monospaced'>
     SRC_URI += "file://defconfig"
                </literallayout>
            </para>
            <para>
                As mentioned earlier, you can group related configurations into multiple files and 
                name them all in the <filename>SRC_URI</filename> 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 <filename>SRC_URI</filename> statement like the 
                following in your append file:
                <literallayout class='monospaced'>
     SRC_URI += "file://defconfig \
            file://eth.cfg \
            file://gfx.cfg"
                </literallayout>
            </para>
            <para>
                The <filename>FILESEXTRAPATHS</filename> variable is in boilerplate form here 
                in order to make it easy to do that.
                It basically allows those configuration files to be found by the build process.
            </para>
            <note>
                <para>
                Other methods exist to accomplish grouping and defining configuration options.
                For example, you could directly add configuration options to the Yocto kernel 
                <filename>meta</filename> branch for your BSP.
                The configuration options will likely end up in that location anyway if the BSP gets 
                added to the Yocto Project. 
                For an example showing how to change the BSP configuration, see the
                "<ulink url='http://www.yoctoproject.org/docs/latest/dev-manual/dev-manual.html#changing-the-bsp-configuration'>Changing the BSP Configuration</ulink>" section 
                in the Yocto Project Development Manual.</para>
                <para>
                In general, however, the Yocto Project maintainers take care of moving the 
                <filename>SRC_URI</filename>-specified 
                configuration options to the <filename>meta</filename> branch.
                Not only is it easier for BSP developers to not have to worry about putting those 
                configurations in the branch, but having the maintainers do it allows them to apply 
                'global' knowledge about the kinds of common configuration options multiple BSPs in 
                the tree are typically using.  
                This allows for promotion of common configurations into common features.</para>
            </note>
            </section>
        </section>

        <section id='bsp-click-through-licensing'>
            <title>BSP 'Click-Through' Licensing Procedure</title>

            <note> This section describes how
		click-through licensing is expected to work.
                Currently, this functionality is not yet implemented.
            </note>

            <para>
	      In some cases, a BSP contains separately licensed IP
	      (Intellectual Property) for a component that imposes
	      upon the user a requirement to accept the terms of a
	      'click-through' license.  
              Once the license is accepted the
	      Yocto Project build system can then build and include the
	      corresponding component in the final BSP image.  
              Some affected components might be essential to the normal
	      functioning of the system and have no 'free' replacement
	      (i.e. the resulting system would be non-functional
	      without them).
              On the other hand, other components might be simply
	      'good-to-have' or purely elective, or if essential
	      nonetheless have a 'free' (possibly less-capable)
	      version that could be used as a in the BSP recipe.
            </para>

            <para>
	      For cases where you can substitute something and still maintain functionality, 
              the Yocto Project website's  
              <ulink url='http://www.yoctoproject.org/download/all?keys=&amp;download_type=1&amp;download_version='>BSP Download Page</ulink> 
              makes available 'de-featured' BSPs that are completely free of any IP encumbrances.
              For these cases you can use the substitution directly and without any further licensing
              requirements.  
              If present, these fully 'de-featured' BSPs are named appropriately different 
              as compared to the names of the respective encumbered BSPs.
              If available, these substitutions are the simplest and most preferred options.
              This, of course, assumes the resulting functionality meets requirements.
            </para>

            <para>
	      If however, a non-encumbered version is unavailable or the 'free' version 
              would provide unsuitable functionality or quality, you can use 
              an encumbered version.  
            </para>

            <para>  
              Several methods exist within the Yocto Project build system to satisfy the licensing
	      requirements for an encumbered BSP.
              The following list describes them in preferential order:
            </para>

	    <orderedlist>
            <listitem>

		<para>
		  Get a license key (or keys) for the encumbered BSP by visiting 
                  a website and providing the name of the BSP and your email address
                  through a web form.
                </para>
 
		<para>
		  After agreeing to any applicable license terms, the
		  BSP key(s) will be immediately sent to the address
		  you gave and you can use them by specifying BSPKEY_&lt;keydomain&gt;
		  environment variables when building the image:
		</para>

		<literallayout class='monospaced'>
     $ BSPKEY_&lt;keydomain&gt;=&lt;key&gt; bitbake core-image-sato
		</literallayout>

		<para>
		  These steps allow the encumbered image to be built
		  with no change at all to the normal build process.
		</para>

		<para>
		  Equivalently and probably more conveniently, a line
		  for each key can instead be put into the user's
		  <filename>local.conf</filename> file found in the Yocto Project file's
                  build directory.
		</para>

		<para>
		  The &lt;keydomain&gt; component of the
		  BSPKEY_&lt;keydomain&gt; is required because there
		  might be multiple licenses in effect for a given BSP.
                  In such cases, a given &lt;keydomain&gt; corresponds to
		  a particular license.  In order for an encumbered
		  BSP that encompasses multiple key domains to be built
		  successfully, a &lt;keydomain&gt; entry for each
		  applicable license must be present in <filename>local.conf</filename> or
		  supplied on the command-line.
		</para>
              </listitem> 
              <listitem>
		<para>
		  Do nothing - build as you normally would.
                  When a license is needed the build will stop and prompt you with instructions.
                  Follow the license prompts that originate from the
		  encumbered BSP.  
                  These prompts usually take the form of instructions
		  needed to manually fetch the encumbered package(s)
		  and md5 sums into the required directory 
                  (e.g. the <filename>yocto/build/downloads</filename>).
                  Once the manual package fetch has been
		  completed, restart the build to continue where
		  it left off.
                  During the build the prompt will not appear again since you have satisfied the 
                  requirement.
		</para>
              </listitem>
              <listitem>
		<para>
		  Get a full-featured BSP recipe rather than a key.
                  You can do this by visiting the Yocto Project website's
                  <ulink url='http://www.yoctoproject.org/download'>Download</ulink> page and 
                  clicking on "BSP Downloads".
		  BSP tarballs that have proprietary information can be downloaded after agreeing 
                  to licensing requirements as part of the download process. 
                  Obtaining the code this way allows you to build an encumbered image with 
                  no changes at all as compared to the normal build. 
                </para>
              </listitem>
	    </orderedlist>
	    <para>
	      Note that the third method is also the only option available
	      when downloading pre-compiled images generated from non-free BSPs.  
              Those images are likewise available at from the Yocto Project website.
            </para> 
        </section>

</chapter>