WL1835 Cape on BeagleBone with MainLine Kernel Debian Filesystem

How to Build WL1835 Cape Support in Mainline Linux

As of Kernel 4.1 the WiLink8 Wi-Fi drivers and Shared Transport UART layer are now in the mainline Linux. This means that it is no longer required to build the Wi-Fi drivers out of tree using the TI script or patch up the Shared Transport Layer for Bluetooth in your chosen kernel. Additionally the WL1835 Cape is now a supported cape in the BeagleBone Black build system here.

This page provides a script that implements the various steps described at https://eewiki.net/display/linuxonarm/BeagleBone+Black to create a K4.1rc4 based kernel running on a Debian 8.0 file system. Later tags can be supported by editing the build script.

There are several points to note about it.

• The script is only for cross-compiling on a Linux Host (tested with 32 and 64 bit Ubuntu 12.04). See this link for possible additional packages that may need to be installed for the build script to run correctly.
• The WL1835 Cape uses the same MMC interface as the eMMC on BeagleBone and so if the cape is being used then eMMC is not available and so board must boot from microSD card.

History

Current version of script is v0.3.

• Updates to 4.1.2-bone12
• fixes SSH over USB. Uses updated boot-scripts and enables root access for SSH in filesystem

Building

Create a build directory such as bbb-mainline and download and extract the build script to this directory. Run the script wl8-build.sh which will download, patch and build the kernel and create a populated Debian Filesystem which can then be written to an SD card. This is basically scripting the build process described at https://eewiki.net/display/linuxonarm/BeagleBone+Black.

Run script.

./wl8-build.sh

The content of the script is listed here and is hopefully self commented. When the script runs it calls a make menuconfig, select the exit option and then the save option. This does however mean that it is not possible to pipe the output of the build to a file.

#!/bin/bash
#Copyright (c) 2014 Texas Instruments
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
#The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
# This is a build script to create a Debian based Linux kernel 4.1rc4 and filesystem based on debian 8.0
# for Wl1835 BeagleBone Cape 
# https://eewiki.net/display/linuxonarm/BeagleBone+Black

# version 0.3 
#  July 2015

DEBIAN_FS=debian-8.1-minimal-armhf-2015-06-09
BBB_KERNEL_TAG=4.1.2-bone12
UBOOT_TAG=v2015.07

if [ ! -e fs-downloaded ]
then
  if [ ! -e fs ]
  then
     mkdir fs
  fi

  cd fs || exit
  wget -c https://rcn-ee.com/rootfs/eewiki/minfs/${DEBIAN_FS}.tar.xz
  tar xf ${DEBIAN_FS}.tar.xz

  cd ${DEBIAN_FS}
  if [ ! -e rootfs ]
  then
     mkdir rootfs
  fi

  cd rootfs
  FS=`pwd`
  sudo tar xf ../armhf-rootfs-debian-jessie.tar . 
  cd ../..

  touch ../fs-downloaded
  cd ..
else
  # just set FS
  FS=`pwd`/fs/${DEBIAN_FS}/rootfs
  cd fs/${DEBIAN_FS} || exit
  sudo rm -r rootfs/ 
  mkdir -p rootfs
  cd rootfs
  sudo tar xf ../armhf-rootfs-debian-jessie.tar . 
  cd ../../..
fi

#Download kernel and build it clean
#part of the process is to download gcc 4.9 and so do this before uboot
if [ ! -e kernel-built ]
then
  if [ ! -e kernel-git-downloaded ]
  then
     sudo rm -r bb-kernel
     git clone https://github.com/RobertCNelson/bb-kernel.git
     touch kernel-git-downloaded 
  else
     # remove bb-kernel patches
        cd bb-kernel

        git checkout patch.sh patches/defconfig system.sh.sample 
        
        cd .. 
        
  fi 
    
  cd bb-kernel/

 git checkout ${BBB_KERNEL_TAG} -b tmp

 # for a multi-core system set CORES 
  unset CORES_SET
  CORES_SET=`grep -r CORES system.sh.sample`

  if [ -z  ${CORES_SET} ];
  then
    echo "CORES=8" >> system.sh.sample
  fi

 ./build_kernel.sh || exit

   cd .. 

  touch kernel-built
fi
  
  # work on principle there is a file bb-kernel/deploy/config-x.y.z-boneX   
  # if version is a release candidate cut out the 2nd-4th elements separated by '-'
  cd bb-kernel/deploy
  export kernel_version=`find . -name config* | cut -d'-' -f 2,3,4`
  cd ../..
  echo "kernel_version:${kernel_version}"

  # now that kernel is built copy the zImage and modules to rootfs
  sudo mkdir -p ${FS}/boot/dtbs/${kernel_version}/
   
  # take base uEnv.txt from package and then add specifics to it 
  # This can't be done in this script via echo as we do not want the 
  # variables like ${loadaddr} to be evaluated by the shell now. We 
  # want them to be evaluated by u-boot at runtime
  sudo cp patches/uEnv.txt ${FS}/boot/uEnv.txt
 
  # want this expression evaluated now, not at boot
  sudo sh -c "echo 'uname_r=${kernel_version}' >> ${FS}/boot/uEnv.txt"

  sudo sh -c "echo 'cape_disable=capemgr.disable_partno=BB-BONELT-HDMI,BB-BONELT-HDMIN,BB-BONE-EMMC-2G' >> ${FS}/boot/uEnv.txt"

  # set roofs to be on MMC card rather than eMMC
  sudo sh -c "echo 'mmcroot=/dev/mmcblk0p1' >> ${FS}/boot/uEnv.txt"
  
  # set dtb file to be the wl1835 version
  sudo sh -c "echo 'fdtfile=am335x-boneblack-wl1835mod.dtb' >> ${FS}/boot/uEnv.txt"
   
  sudo cp -v bb-kernel/deploy/${kernel_version}.zImage ${FS}/boot/vmlinuz-${kernel_version} || exit
  sudo tar xfv bb-kernel/deploy/${kernel_version}-dtbs.tar.gz -C ${FS}/boot/dtbs/${kernel_version}/ || exit
  sudo tar xfv bb-kernel/deploy/${kernel_version}-modules.tar.gz -C ${FS}/ || exit
  
  # set up file system table
  sudo sh -c "echo '/dev/mmcblk0p1  /  auto  errors=remount-ro  0  1' >> ${FS}/etc/fstab"

  # enable eth0 and wlan0
  sudo sh -c "echo '
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet manual

auto wlan0
iface wlan0 inet manual
iface usb0 inet static
  address 192.168.7.2
  netmask 255.255.255.0
  network 192.168.7.0
  gateway 192.168.7.1
' > ${FS}/etc/network/interfaces"

  # and ensure that eth0 is always used even if SD card used on another board already
  sudo sh -c "echo '# BeagleBone: net device()
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{dev_id}=="0x0", ATTR{type}="1", KERNEL=="eth*", NAME="eth0"' > ${FS}/etc/udev/rules.d/70-persistent-net.rules"

  # write /boot/SOC.sh so that /etc/init.d/generic-boot-script.sh will insert g_ether to enable SSH
  # access to 192.168.7.2 from PC
  ##### /etc/init.d/generic-boot-script.sh is not currently in debian 8.0 #############
sudo sh -c "echo '
#!/bin/sh
board=am335x_evm' > ${FS}/boot/SOC.sh"   

 # Get latest Robert Nelson boot scripts so that USB g_ether will be loaded correctly
 # which will allow SSH to be done to 192.168.7.2 over USB
    cd fs || exit

    if [ ! -e RobertCNelsonScripts ]
    then
       mkdir -p RobertCNelsonScripts
    else
       sudo rm -r RobertCNelsonScripts/* || exit
    fi

    cd RobertCNelsonScripts || exit

    git clone git://github.com/RobertCNelson/boot-scripts.git
    cd boot-scripts || exit
    git checkout master
   # now included in master 
   # git am ../../../patches/filesystem/0001-use-standard-location-for-udhcpd.conf.patch
    
    cd ..

    # move default /opt/scripts 
    sudo mv ${FS}/opt/scripts ${FS}/opt/scripts-std || exit

    # and copy in updated ones
    sudo mkdir -p ${FS}/opt/scripts || exit
    sudo cp -r boot-scripts/. ${FS}/opt/scripts/ || exit

    cd ../.. 

    # make sure generic-startup.sh is called by systemd
    sudo cp patches/ethernet-usb.service ${FS}/lib/systemd/system 

  # Clean out all obsolete TI connectivity fw from FS
  sudo rm -rf ${FS}/lib/firmware/ti-connectivity/*

  # And download the latest wifi fw
  wget http://git.ti.com/wilink8-wlan/wl18xx_fw/archive-tarball/R8.5
  tar -xvf R8.5 wilink8-wlan-wl18xx_fw/wl18xx-fw-4.bin
  sudo mv wilink8-wlan-wl18xx_fw/wl18xx-fw-4.bin ${FS}/lib/firmware/ti-connectivity/
  rm -r wilink8-wlan-wl18xx_fw
  rm R8.5

  # and the latest bluetooth firmware - service pack 3.7
  rm TIInit_11.8.32.bts
  wget http://git.ti.com/ti-bt/service-packs/blobs/raw/7783edec65c91e0112961bdb7acad6db6a050092/initscripts/TIInit_11.8.32.bts
  sudo mv TIInit_11.8.32.bts ${FS}/lib/firmware/ti-connectivity/

# now set gcc 4.9 downloaded by kernel build as the toolchain 
 #extract the compiler name from the tar.xz file name to handle either 32 or 64 bit versions
 cd bb-kernel/dl 
 COMPILER_NAME=`find . -maxdepth 1 -type f | cut -d'/' -f 2 | sed 's/.tar.xz//'`
 cd ../..
  
CC=`pwd`/bb-kernel/dl/${COMPILER_NAME}/bin/arm-linux-gnueabihf-

if [ ! -e uboot-downloaded ]
then

   git clone git://git.denx.de/u-boot.git || exit 
   cd u-boot/
   # update to latest tag 
   git checkout ${UBOOT_TAG} -b tmp || exit

   # and patch it 
   wget -c https://rcn-ee.com/repos/git/u-boot-patches/${UBOOT_TAG}/0001-am335x_evm-uEnv.txt-bootz-n-fixes.patch || exit
   patch -p1 < 0001-am335x_evm-uEnv.txt-bootz-n-fixes.patch || exit

   # as u-boot is rarely rebuilt just do it once after download
   make ARCH=arm CROSS_COMPILE=${CC} distclean || exit
   make ARCH=arm CROSS_COMPILE=${CC} am335x_evm_defconfig || exit
   make ARCH=arm CROSS_COMPILE=${CC} || exit

   touch ../uboot-downloaded
   cd ..
fi

sudo cp -v ./u-boot/MLO mmc-package/
sudo cp -v ./u-boot/u-boot.img mmc-package/

# make sure generic-startup.sh is called by systemd
sudo cp patches/ethernet-usb.service ${FS}/lib/systemd/system 
# this is equaivalent to "systemctl enable" running on the the target
sudo ln -s ${FS}/lib/systemd/system/ethernet-usb.service ${FS}/etc/systemd/system/multi-user.target.wants/ethernet-usb.service    

# patch to allow root to login in over ssh
sudo sed --in-place 's/PermitRootLogin without-password/PermitRootLogin yes/' ${FS}/etc/ssh/sshd_config

# now tar up the rootfs
cd ${FS}
sudo tar -czf ../../tar-rootfs.tar.gz *
cd ../../..

#now tar up package to programme, the file mmc-package.tar.gz is file used by the programme-sd.sh script
mkdir -p mmc-package
cd fs
sudo tar -czf ../mmc-package/mmc-package.tar.gz tar-rootfs.tar.gz ../u-boot/u-boot.img ../u-boot/MLO
cd ..

echo "Build Successful"

Programming uSD card

The build process above will create the uboot files for the boot partition and a tar.gz file with the file system. The script programme-sd.sh will take these and programme an SD card. The script takes one argument which is the device name for the sd card. So if the card is mounted as /dev/sdc, then the argument passed is sdc.

$./programme-sd.sh sdc

The script is basically just an implementation of the instructions from https://eewiki.net/display/linuxonarm/BeagleBone+Black with some extra handling to automate the mounting of drives taken from SDK7

#!/bin/bash
#Copyright (c) 2014 Texas Instruments
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
#The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# script to programme SD card following instructions from https://eewiki.net/display/linuxonarm/BeagleBone+Black

if [ $# -eq 1 ]; then

  echo "will use drive /dev/$1"
  DEVICEDRIVENAME=$1
  DISK=/dev/$DEVICEDRIVENAME

  NUM_OF_DRIVES=`df | grep -c $DISK`

  # This if statement will determine if we have a mounted sdX or mmcblkX device.
  # If it is mmcblkX, then we need to set an extra char in the partition names, 'p',
  # to account for /dev/mmcblkXpY labled partitions.
  if [[ ${DEVICEDRIVENAME} =~ ^sd. ]]; then
	echo "$DRIVE is an sdx device"
	P=
  else
	echo "$DRIVE is an mmcblkx device"
	P='p'
  fi

  if [ "$NUM_OF_DRIVES" != "0" ]; then
       echo "Unmounting the $DEVICEDRIVENAME drives"
       for ((c=1; c<="$NUM_OF_DRIVES"; c++ ))
       do
               unmounted=`df | grep '\<'$DEVICEDRIVENAME$P$c'\>' | awk '{print $1}'`
               if [ -n "$unmounted" ]
               then
                    echo " unmounted ${DISK}$P$c"
                    sudo umount -f ${DISK}$P$c
               fi

       done
  fi

  # Download build package
  cd mmc-package
  tar -xzf mmc-package.tar.gz || exit
  cd ..
   
  # erase it
  sudo dd if=/dev/zero of=${DISK} bs=1M count=10
  # and write MLO & uboot
  sudo dd if=mmc-package//u-boot/MLO of=${DISK} count=1 seek=1 bs=128k
  sudo dd if=mmc-package//u-boot/u-boot.img of=${DISK} count=2 seek=1 bs=384k

  # now create partition
  sudo sfdisk --in-order --Linux --unit M ${DISK} <<-__EOF__
1,,0x83,*
__EOF__
 
  DISK_IN_USE=${DISK}${P}1
  echo "now try to format ${DISK_IN_USE}"

  sleep 2
  # and format it
  sudo mkfs.ext4 ${DISK}${P}1 -L rootfs
  sync
  sync

  #mount rootfs
  sudo mkdir -p rootfs-sd
  echo "sudo mount -t ext4 ${DISK_IN_USE} rootfs"
  sudo mount -t ext4 ${DISK_IN_USE} rootfs-sd || exit
  echo "successfully mounted"

  # Now extract rootfs
  cd rootfs-sd
  sudo tar -zxf ../mmc-package/tar-rootfs.tar.gz
  cd ..

  sync
  echo "sudo umount -f ${DISK_IN_USE} || exit"
  sudo umount -f ${DISK_IN_USE} || exit
  sudo rm -r rootfs-sd
  echo "successfully unmounted"

else
  echo "must take argument of SD card device after /dev/, so /dev/sdd is sdd" 
fi

Running the System

Now that there is a programmed uSD card from either the pre-built files or just built it is time to boot the BeagleBoneBlack and WL1835 Cape. The WL1835MOD cape uses the same MMC interface as the eMMC memory on the BeagleBoneBlack. This means that switch S2 must be held down when the power is first applied to force booting from uSD. This is slightly awkward as S2 is under the cape so recommendation is to use something like a pen to hold it down. This is only required when power is applied, the boot mode is retained when reset button (S1) is pressed.

When the device tree file is loaded it should enable both the WL_EN and BT_EN signals which will illuminate LED1 and LED2 on the cape.

Configuring the system

On the first boot there are a couple of system configurations that need to be done. This process was done while logged in as root with the password root. The minimal Debian filesystem does not contain the Bluez tools to run the Bluetooth stack, crda to handle Wi-Fi regulatory details or some utilities to test performance. These can be installed as follows with an ethernet cable connected. The first step is to request an IP address on the ethernet.

# dhclient eth0

then install the required tools

#apt-get update
#apt-get install iperf iw crda bluez bluez-tools

Once these have been installed it is necessary to reboot the board. This allows Wi-Fi to start correctly with CRDA running.

Connecting to an Access Point

wpa_supplicant is used to connect the BeagleBoneBlack as a station to an Access Point. The configuration of the Access Point to connect to is done via a file typically located at /etc/wpa_supplicant.conf. A Debian filesystem provides a generic version of this file with all the possible options in this location. To keep things simple for different configurations create new files for each connection.

Configuration for an Unsecured Access Point

Create a file /etc/wpa_supplicant-unsecuredAP.conf with the following contents to connect to SSID "MyAP"

ctrl_interface=/var/run/wpa_supplicant
update_config=1

network={
       key_mgmt=NONE
       ssid="MyAP"   
}

Configuration for a WPA2 secured Access Point

Create a file /etc/wpa_supplicant-securedAP.conf with the following contents to connect to SSID "MyAP" running WPA2 with password "password"

ctrl_interface=/var/run/wpa_supplicant
update_config=1

network={
       psk="password"
       ssid="MyAP"   
}

Connect to the AP

Run the supplicant passing the desired AP's configuration file to connect to the AP on interface wlan0

 root@arm:~#wpa_supplicant -d -Dnl80211 -c/etc/wpa_supplicant-unsecuredAP.conf -iwlan0 -B 

Check that the connection process was correct by running dmesg | grep wlan which should give following information

root@arm:/etc# dmesg | grep wlan
[    0.129013] wlan-en-regulator: 1800 mV
[ 1677.205809] IPv6: ADDRCONF(NETDEV_UP): wlan0: link is not ready
[ 1681.364364] wlan0: authenticate with a0:f3:c1:ac:af:ac
[ 1681.374940] wlan0: send auth to a0:f3:c1:ac:af:ac (try 1/3)
[ 1681.402398] wlan0: authenticated
[ 1681.406715] wlan0: associate with a0:f3:c1:ac:af:ac (try 1/3)
[ 1681.412420] wlan0: RX AssocResp from a0:f3:c1:ac:af:ac (capab=0x431 status=0 aid=1)
[ 1681.432269] wlan0: associated
[ 1681.432365] IPv6: ADDRCONF(NETDEV_CHANGE): wlan0: link becomes ready

and then request an IP address from the AP.

root@arm:~#dhclient wlan0

Testing the Connection

The simplest way to test the connection and throughput is to use iperf. iperf transmits data in either TCP or UDP from a client to a server. So running a client implies transmission and running a server implies reception. The table below shows the performance achieved from the WL1835 Cape to a TPLINK TL-WR841N AP at a range of 1m in a typical office environment (~20 SSIDs in a scan). The other device in the test was a Ubuntu machine running iperf and connected to the AP via Ethernet so that WL183x cape had sole access to the Wifi port on the AP.

	TCP (Mb/s)	UDP (Mb/s), %age loss
Rx	41.4	38.5, 1.7%
Tx	37.9	42.8, 0%

In TCP mode iperf sends the maximum possible amount of data with 100% reliability. The server (Receiver) is run as follows

#iperf -s

and the client command line used in the test for 60 seconds with a reporting interval of 10 seconds was:

#iperf -c <IP address of server> -t 60 -i 10 

In UDP mode iperf sends a fixed data rate and then reports actual data rate received and the percentage of packets lost.

The server (Receiver) is run as follows with UDP mode specified

#iperf -s -u 

and the client command line used in the test for 60 seconds with a reporting interval of 10 seconds was:

#iperf -u -c <IP address of server> -b30M -t 60 -i 10 

In this case 30Mb/s was requested. Testing UDP throughput is an iterative process repeated at different increasing bandwidths (-b<bandwidth>) until the percentage packet error is unacceptable.

Starting the Bluetooth

In order to control the Bluetooth from /dev/ttyO4 need to remove the shared transport driver

#modprobe -r st_drv

Now the BT_EN signal (gpio1_12) can be directly controlled to produce a clean reset

#echo 44 > /sys/class/gpio/export
#echo out > /sys/class/gpio/gpio44/direction
#echo 0 > /sys/class/gpio/gpio44/value
#echo 1 > /sys/class/gpio/gpio44/value

The next step for running Bluez is to load the firmware to the WL1835. This is done with the utility hciattach. The arguments specify that bluetooth is connected to UART /dev/ttyO4, that it is a Texas Instruments Bluetooth device and that the communication should switch to 3Mbaud

#hciattach /dev/ttyO4 texas 3000000 &

Once this has completed the hci0 interface can be brought up

#hciconfig hci0 up

The scan is carried out with bt-adaptor which will give an output similar to this with a list of all the devices advertising

#bt-adapter –d
Searching...

[00:0D:FD:47:54:AF]
 Name: Nokia Play 360°
 Alias: Nokia Play 360°
 Address: 00:0D:FD:47:54:AF
 Icon: (null)
 Class: 0x0
 LegacyPairing: 0
 Paired: 1
 RSSI: -33

Done
 

Connecting to the selected device is done with

# bt-device -c 00:0D:FD:47:54:AF

And then set as trusted, so subsequent connects will be automatic

# bt-device --set 00:0D:FD:47:54:AF Trusted 1