Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add Das U-Boot fork to image builder #52

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Add Das U-Boot fork to image builder #52

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 3 additions & 2 deletions .gitignore
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
# Kconfig .old
*.old

# Repos
BeagleBoard-DeviceTrees/
image-builder/
u-boot/

# Python
__pycache__/
Expand Down
6 changes: 6 additions & 0 deletions .gitmodules
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
[submodule "uboot/u-boot"]
path = image_builder/u-boot
url = https://github.com/oresat/u-boot
[submodule "image_builder/image-builder"]
path = image_builder/image-builder
url = https://github.com/RobertCNelson/omap-image-builder.git
42 changes: 42 additions & 0 deletions image_builder/Makefile
View file
Open in desktop
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This should utilize the features of make better. make is more than a shellscript with names, it is its own whole tool with its own language and rules. The general mindset is to try to write rules where the left hand side (the targets) are the files you want to produce and the right hand side (the prerequisites) are the files they are produced from. I'll recommend giving the make manual a browse - it's well written and in-depth.

Take for example the u-boot rule below. In the rule recipe it uses the shell to test for the existence of files, but that's the prime function of make rules. make will build targets if they don't exist (and are older than the prerequisites) for you. The magic of make is if most of your rule targets are files it will selectively only build the files that need to be built. For the u-boot rule specifically the outputs are the files MLO and u-boot-dtb.img so those should go in the target place. Because this rule produces two targets it needs the specialized group target as opposed to the default independent targets. For prerequisites u-boot specifically wants to input the config am335x_oresat.config because we'll likely change that during normal development. It also technically it depends on the whole u-boot project but we shouldn't be touching those files outside of updating the submodule so it can suffice to ensure it's initialized. The rule becomes:

$(UBOOT_REPO)/MLO $(UBOOT_REPO)/u-boot-dtb.img &: $(CONFIG) test
	KCONFIG_CONFIG=../$(CONFIG) $(FLAGS) make -C $(UBOOT_REPO)

Note that u-boot doesn't actually depend on device_trees any more and the mrproper call should be done in clean to avoid unnecessary u-boot rebuilding.

The next rule where make should be used for checking files instead of the shell is test. This one is a little more awkward because a glaring hole of make in my opinion is there's no good way to check if a directory is empty. The recommended way is to pick a sentinel file to check and for submodules a good pick is the readme. Additionally the make function $(error) should be used for reporting errors. So test becomes:

$(UBOOT_REPO)/README $(IMAGE_BUILDER_REPO)/readme.md :
	$(error $(dir $@) not initialized. Hint: git submodule update --init)

Note that these are independent instead of group targets so the u-boot related rule can depend only on the u-boot repo and not care about the image-builder repo and vice versa. Also $(dir $@) to get the directory name of the current target.

Finally the variable $(list) isn't used, but I think I can see what you were trying to go for, I think you were missing $@ which expands to the name of the current target:

$(list):
	./build_images.sh $@

Now you can say make c3 instead of make board=c3. Note that this rule is missing prerequisites that should be there.

Putting it all together the whole makefile should look something like:

CONFIG ?= am335x_oresat.config
boards = c3 cfc dev dxwifi generic gps star-tracker

ARCH= $(shell uname -m)
ifeq ($(ARCH), armv7l)
	FLAGS =
else
	FLAGS = ARCH=arm CROSS_COMPILE=arm-none-eabi-
endif

.PHONY: all clean $(boards)

all: c3

$(boards): build_images.sh device_trees u-boot/MLO u-boot/u-boot-dtb.img | image_builder/readme.md
	./build_images.sh $@

device_trees:
	make -C ../device_trees

u-boot/MLO u-boot/u-boot-dtb.img &: $(CONFIG) | u-boot/README
	KCONFIG_CONFIG=../$(CONFIG) $(FLAGS) make -C u-boot

u-boot/README image-builder/readme.md:
	$(error $(dir $@) not initialized. Hint: git submodule update --init)

clean:
	rm -f image_builder/configs/oresat*
	rm -f image_builder/target/chroot/oresat*
	rm -f image_builder/tools/hwpack/extlinux.conf
	make mrproper -C u-boot
	make clean -C ../device_trees

Ideally the device_trees target should be file-based as well but it would be much easier to do with changes to that makefile first so I've left this as is. Note also:

  • Ensuing .PHONY has only real rules in them
  • clean cleans only the things that this makefile generates (it's no longer producing setup_sdcard.sh.rej)
  • using | to indicate that we only care about the existence of the following prerequisites, not update time. These are known as order-only prerequisites. Good for directory and submodule related stuff.
  • Using ?= to indicate an input parameter. It's reasonable that we during development might want to test with a differently named config file and so conditional assignment is the conventional way to indicate it
  • Folding in other path names. We probably don't want to have the image-builder, device_trees, or u-boot paths to be configurable, and it's a bit more readable then to bake them into the use locations directly. Picking which things to turn into variables is a bit of a matter of taste but too much use of variables as simple renames can make things harder to read. If we do want them configurable then they should be ?= conditionally assigned.
  • defaulting to c3 if no board has been specified.

As more of build_images.sh gets moved into this makefile we can then be much more selective about which things get built.

Original file line number Diff line number Diff line change
@@ -0,0 +1,42 @@
UBOOT_REPO= u-boot
IMAGE_BUILDER_REPO= image-builder
DEVICE_TREES= ../device_trees
CONFIG= am335x_oresat.config
list= c3 cfc dev dxwifi generic gps star-tracker

.PHONY: all uboot device_trees test clean board $(list)

ARCH= $(shell uname -m)
ifeq ($(ARCH), armv7l)
FLAGS=
else
FLAGS= ARCH=arm CROSS_COMPILE=arm-none-eabi-
endif

all: uboot
./build_images.sh $(board)

uboot: test device_trees
@if [ ! -f "$(UBOOT_REPO)/MLO" ] || \
[ ! -f "$(UBOOT_REPO)/u-boot-dtb.img" ]; then \
make -C u-boot mrproper; \
KCONFIG_CONFIG=../$(CONFIG) $(FLAGS) make -C $(UBOOT_REPO); \
fi

device_trees:
make -C $(DEVICE_TREES)

test:
@if [ -z "$(wildcard $(UBOOT_REPO)/*)" ] || \
[ -z "$(wildcard $(IMAGE_BUILDER_REPO)/*)" ]; then \
echo "Hint: git submodule update --init"; \
exit 1; \
fi

clean:
rm -f $(IMAGE_BUILDER_REPO)/configs/oresat*
rm -f $(IMAGE_BUILDER_REPO)/target/chroot/oresat*
rm -f $(IMAGE_BUILDER_REPO)/tools/setup_sdcard.sh.rej
rm -f $(IMAGE_BUILDER_REPO)/tools/hwpack/extlinux.conf
make clean -C $(UBOOT_REPO)
make clean -C $(DEVICE_TREES)
124 changes: 118 additions & 6 deletions image_builder/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,14 +11,13 @@ Uses BeagleBoard's https://github.com/beagleboard/image-builder
- `scripts/`: Helpful scripts that will be placed in `/opt/scripts/` in built images.
- `configs/*.conf`: All the image configs; defines what packages are install, system settings,
etc.
- `uEnv/*-uEnv.txt`: The specific `uEnv.txt` for the image, defines what device tree overlays
are loaded on boot.

## How it Works

**NOTE:** Most of the build process is handled by BeagleBoard's image-builder, with some custom
OreSat scripts executed at specific moments.

- U-Boot bootloader is compiled.
- All device tree overlays are compiled.
- A temp directory is made, the directory is mounted with chroot.
- OreSat's early chroot script is executed (all device tree overlay binaries are copied over).
Expand All @@ -36,8 +35,9 @@ OreSat scripts executed at specific moments.

## Requirements

- Image must be built on a ARMv7 device running Debian or a Debian-based distro.
- Image must be built on a device running Debian or a Debian-based distro.
- An internet connection (it has to call `apt` a lot).
- U-boot requires cross compilation if outside of ARMv7 environment (i.e. arm-none-eabi-gcc).

## Set up

Expand All @@ -55,9 +55,6 @@ $ git clone https://github.com/oresat/oresat-linux

## Build Image

**NOTE:** On a PocketBeagle or a BeagleBone Black this will take ~40 minutes.
On a Raspberry Pi 3/4B it takes ~20 minutes.

```bash
$ cd oresat-linux/image_builder/
$ ./build_images.sh <board>
Expand All @@ -72,3 +69,118 @@ Where `<board>` can be:
- `generic`: A generic minimal flight-like image for any OreSat board.
- `gps`: The flight image the OreSat's GPS board.
- `star-tracker`: The flight image for the OreSat's Star Tracker board.

# U-Boot

## Setup

Install the GCC cross compiler for ARM Cortex-R/M processors

- Arch Linux
```bash
sudo pacman -S arm-none-eabi-gcc openssl bc
```
- Debian Linux
```bash
sudo apt install gcc-arm-none-eabi libssl-dev bc
```

## Build

This will generate `u-boot.img` and `MLO` in the oresat_bootloader folder.

```bash
$ make
```

## Flash

Flash `u-boot.img` and `MLO`. Change `/dev/sda` as needed. You can also use
scripts/write_uboot.sh.

```bash
$ sudo dd if=u-boot-dtb.img of=/dev/sda count=4 seek=1 bs=384k
$ sudo dd if=MLO of=/dev/sda count=2 seek=1 bs=128k
```
## U-Boot console

You can connect to the u-boot console using serial. On a beaglebone
black this is done by connecting a FTDI cable between your computer's
USB port and the beaglebone black. You can then use a utility like
picocom to connect. For example:
```
picocom -b 115200 /dev/serial/by-id/usb-FTDI_FT232R_USB_UART_AC01OGK9-if00-port0
```
Press the boot button and power on the beaglebone black. U-boot will start
producing output to serial. Pressing the spacebar, when propted, drops you
into the uboot console. If boot_delay=0 you will have to hold down the spacebar
or it will skip the console.

The device must be set to i2c0 to interact with the EEPROM using i2c.
To set the device, copy this command into the u-boot prompt (i.e. =>).
```
i2c dev 0
```
Reads 0x20 bytes from the EEPROM at address 0x50 offset 0x00
```
i2c md 0x50 0x00.2 20
```
Writes 1 byte (42) to the EEPROM at address 0x50 offset 0x08
```
i2c mw 0x50 0x08.2 42
```
### Example EEPROM writes to produce meaningful boot strings

#### BNLT00C0

```
i2c mw 0x50 0x08.2 42
```
```
i2c mw 0x50 0x09.2 4e
```
```
i2c mw 0x50 0x0a.2 4c
```
```
i2c mw 0x50 0x0b.2 54
```
```
i2c mw 0x50 0x0c.2 30
```
```
i2c mw 0x50 0x0d.2 30
```
```
i2c mw 0x50 0x0e.2 43
```
```
i2c mw 0x50 0x0f.2 30
```

#### OSC30100

```
i2c mw 0x50 0x08.2 4f
```
```
i2c mw 0x50 0x09.2 53
```
```
i2c mw 0x50 0x0a.2 43
```
```
i2c mw 0x50 0x0b.2 33
```
```
i2c mw 0x50 0x0c.2 30
```
```
i2c mw 0x50 0x0d.2 31
```
```
i2c mw 0x50 0x0e.2 30
```
```
i2c mw 0x50 0x0f.2 30
```
Loading