Building and testing RTEMS-libbsd for BeagleBone Black BSP

------------------------------------------------------------------------
Building and testing libbsd for BeagleBone Black BSP
------------------------------------------------------------------------


== Installation overview ==

=== Initial setup ===

- Jump into your workspace and make a directory named sandbox
  This folder will contain all our project files
- cd sandbox/
- export sandbox=$PWD
- git clone git://git.rtems.org/rtems-source-builder.git
- git clone git://git.rtems.org/rtems.git
- git clone git://git.rtems.org/rtems-libbsd.git

=== Building desired toolset for ARM ===

- cd rtems-source-builder/rtems/
- ../source-builder/sb-check
- ../source-builder/sb-set-builder --prefix=$sandbox/5 5/rtems-arm
- cd $sandbox
- export PATH=$PWD/5/bin:$PATH

After having required toolchain, we can now proceed towards building our Board Support Package(BSP)

=== Building Beagleboneblack BSP ===

- cd $sandbox
- mkdir beagleboneblack
- cd rtems
- ./bootstrap -c &&  ./bootstrap
- ../rtems-source-builder/source-builder/sb-bootstrap
- cd ..
- cd beagleboneblack/
- ../rtems/configure --prefix=$sandbox/5 --target=arm-rtems5 --disable-networking --enable-rtemsbsp=beagleboneblack
- make
- make install
- cd $sandbox

BeagleBone black  BSP is now ready, and we should start building libbsd now

=== Building libbsd ===

Before moving forward, we have to install waf(https://waf.io/)

- cd $sandbox
- curl -o waf https://waf.io/waf-2.0.6
- chmod +x waf

Adding it to path,

- export PATH=$PWD:$PATH

Verify installment by,

- waf --version

Now, let's start by configuring and initializing libbsd module

- git submodule init
- git submodule update rtems_waf
- waf configure --prefix="$sandbox/5" --rtems-bsps=arm/beagleboneblack
- waf
- waf install

Libbsd installation is done, now we can move on to testing and building test suite examples

== Testing and Building Examples ==

Default libbsd test examples can be found under $sandbox/rtems-libbsd/build/arm-rtems5-beagleboneblack/

=== Building selectpollkqueue01 example ===

By now, under the example directory ( $sandbox/rtems-libbsd/build/arm-rtems5-beagleboneblack/ )
you can find selectpollkqueue01.exe file. We need to convert this file to its image file
i.e. selectpollkqueue01.img. There are several ways to do that, few of them are:

1)  Direct method: Here, binary of the executable is directly converted into its image file via mkimage tool.
    STEPS:
    # arm-rtems4.11-objcopy selectpollkqueue01.exe -O binary selectpollkqueue01.bin
    # gzip -9 selectpollkqueue01.bin
    # mkimage -A arm -O rtems -T kernel -a 0x80000000 -e 0x80000000 -n RTEMS -d selectpollkqueue01.bin.gz selectpollkqueue01.img

    Here, selectpoolkqueue01.img is the image file, that need to be loaded via uboot.
    Please note that this method is depreciated as it doesn't incorporate bootloader and Device tree. So, for
    loading it, one has to interrupt uboot's(Which is already present in the EMMC) default setup and then load
    the image file via fatload command (for this to work, you should have image in sd card with filesystem type as FAT) for example:

    # fatload mmc :0 0x80800000 selectpollkqueue01.img
    # bootm 0x80800000

2)  Via automated script: create-sdcardimage.sh script file takes the executable file as input and outputs the image file
    after including uboot along with device tree. This method will be elaborated with next example.

As of now, this post is partially complete, i'll update it asap.

Comments

Post a Comment

Popular posts from this blog

Understanding SD, SDIO and MMC Interface

Image
    In this blog post i will present the gist of the paper http://www.kaltech.co.il/pdf/Eureka_sd_wp1.pdf ,  It's crucial for anyone willing to understand how removable devices like sd card work, different protocols/functionalities they support. Secure Digital (SD) memory card today, is one of the most popular non-volatile removable data storage media for consumer applications. It's not intended to remove hard-disk. Hard-disk can still deliver much better speed and memory capacity. SD card is used in applications demanding optimum memory capacity, smaller size, and low end product cost.  The combination of small foot print, lower cost and optimal performance contributed in SD-card's success. What is MultiMedia Card (MMC)? MMC and Sd-card share many common features and have the same physical and electrical specifications. The differences between the two standards are mainly on the software level commands. The similarities allow many hosts to accept both MMC and SD cards on
Read more

Software licensing : Introduction and it's types

Image
A lot of things changes when you write your first code for commercially use. Software licensing is one of those. Usually while coding for my own projects, i earlier use to omit this. However, recently i was hit hard by this 'vague' topic of licensing. So, i decided to study in depth about different types of licenses for open source and propriety usage and here's the summary: A software license is a type of contract between the company/person who produces the code and the one who uses it. It defines the terms of usage of that piece of code. Before moving forward i have a curious question: What if, i copy a code without accepting it's license and use it under my own terms?Who's gonna know it, just copy, paste and use!! ? Well after searching the net i came across various case studies, some of which are very interesting... Reference: here Now, coming to the types of available licenses in Open source community:  GNU GPL License GPL license has mai
Read more

Implementing a MMC/SD/SDIO stack using CAM framework(Part 2)

Image
Hi, In the next part lets look at other files which makes up the SDIO stack within mmccam framework. Please have  a look at previous part for more info: http://81.4.107.225/wordpress/index.php/2018/03/19/implementing-a-mmc-sd-sdio-stack-using-cam-framework/ mmc_sdio.c +void sdio_fill_mmcio_rw_direct(union ccb *ccb, uint8_t f, uint8_t wr, uint32_t adr, uint8_t *data) { + struct ccb_mmcio *mmcio; + + CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, + ("sdio_fill_mmcio(f=%d, wr=%d, adr=%02x, data=%02x)\n", f, wr, adr, (data == NULL ? 0 : *data))); + mmcio = &ccb->mmcio; + + mmcio->cmd.opcode = SD_IO_RW_DIRECT; + mmcio->cmd.arg = SD_IO_RW_FUNC(f) | SD_IO_RW_ADR(adr); + if (wr) + mmcio->cmd.arg |= SD_IO_RW_WR | SD_IO_RW_RAW | SD_IO_RW_DAT(*data); + mmcio->cmd.flags = MMC_RSP_R5 | MMC_CMD_AC; + mmcio->cmd.data->len = 0; +} sdio_fill_mmcio_rw_direct is basically a wrapper for CMD_52 that's needed
Read more