Changes between Version 22 and Version 23 of provisioning

Timestamp:

03/07/2023 08:55:19 PM (14 months ago)

Author:

Tim Harvey

Comment:

fix ubifs image transfer instructions

provisioning

@@ -327 +327 @@
 
 ==== Root Filesystem ====
-The ubi root filesystem is originally built by the build system of the specific BSP your using, however if you end up imaging this onto a board, and customizing it, you may be able to pull it back off as long as your flash size is far less than your memory:
- * From Linux assuming /tmp is a tmpfs (ram based) and that you are booted into the filesystem you are copying and you have more ram available than the size of /dev/mtd2 (such as a 256MB flash on a 512MB system)
-{{{#!bash
-dd if=/dev/mtd2 of=/tmp/ubi bs=4M
-}}}
- * From U-Boot
-{{{#!bash
-# read the rootfs (filesystem) partition into temporary memory, note the size reported below as 0xef00000
-
-Ventana > nand read ${loadaddr} rootfs
-
-NAND read: device 0 offset 0x1100000, size 0xef00000
- 250609664 bytes read: OK
-
-
-# store it to file on micro-SD with an ext4 fs (size re-used from above)
-Ventana > mmc dev 0 && ext4write mmc 0:1 ${loadaddr} /rootfs 0xef00000
-switch to partitions #0, OK
-mmc0 is current device
-File System is consistent
-update journal finished
-250609664 bytes written in 57489 ms (4.2 MiB/s)
-Ventana > 
-
-# or store it to file on USB mass storage with an ext4 fs
-usb start && usb dev 0 && ext4write usb 0:1 ${loadaddr} /rootfs 0xef00000
-}}}
-  - Note that your ext4 filesystem must not have checksums enabled (metadata_csum, a feature added to newer e2fsprogs) as U-Boot does not support this in ext4write.
+The ubi root filesystem is originally built by the build system of the specific BSP your using, however if you end up imaging this onto a board, and customizing it, you will not be able to bit-per-bit copy it to another board due to flash geometry changes and bad block mapping on the physical raw NAND parts.
+
+Instead, you will have to boot a ramdisk based Linux rescue image, mount the ubifs and create a tarball of the files which you can then use to re-create a ubi on a Linux development host that can be applied to a new target board via U-Boot or Linux.
+
+Procedure:
+ 1. Boot a Linux rescue image that has networking and UBI/EXT4/FAT filesystem support. The [wiki:buildroot#VentanaIMX6 buildroot based image] is suitable for this. You will need to copy the uImage and dtb files from http://dev.gateworks.com/buildroot/ventana/minimal/ to a TFTP server on your network or a removable microSD or USB storage device and boot with one of the following:
+  a. boot rescue image from network tftpserver
+{{{#!bash
+setenv bootargs console=ttymxc1,115200
+setenv fsload tftpboot
+setenv bootdir ventana # set this to the prefix of your tftp dir
+run loadfdt && $fsload $loadaddr $bootdir/uImage && bootm $loadaddr - $fdt_addr
+}}}
+  b. boot rescue image from microSD (dev 0 partition 1) with ext/fat filesystem
+{{{#!bash
+setenv bootargs console=ttymxc1,115200
+setenv fsload load mmc 0:1
+setenv bootdir . # set this to the prefix of your tftp dir
+run loadfdt && $fsload $loadaddr $bootdir/uImage && bootm $loadaddr - $fdt_addr
+}}}
+  c. boot rescue image from USB (dev 0 partition 1) with ext/fat filesystem
+{{{#!bash
+setenv bootargs console=ttymxc1,115200
+setenv fsload load usb 0:1
+usb start
+setenv bootdir . # set this to the prefix of your tftp dir
+run loadfdt && $fsload $loadaddr $bootdir/uImage && bootm $loadaddr - $fdt_addr
+}}}
+ 2. Mount a filesystem on removable storage (you could use a tmpfs filesystem to do this on a ramdisk if you have enough space):
+{{{#!bash
+mkdir /mnt/removable
+mount /dev/sda1 /mnt/removable
+}}}
+  * /dev/sd* would be for USB or mSATA devices and /dev/mmc* would be for microSD devices 
+ 3. Mount the ubifs:
+{{{#!bash
+ubiattach /dev/ubi_ctrl -m 2 # attach /dev/mtd2 as /dev/ubi0
+mkdir -p /mnt/ubifs # create a mountpoint for it
+mount -t ubifs ubi0:rootfs /mnt/ubifs # mount 'rootfs' volume
+}}}
+  * Note that at this point you could create a tarball of the rootfs if you want to perfor the following steps later or on a Linux development host (tar --numeric-owner -cvzf /mnt/removable/rootfs.tar.gz -C /mnt/ubifs .)
+ 4. Create a ubi image for the particular flash geometry of the target device (see wiki:linux/ubi#creatingubi):
+  a. 'normal' geometry FLASH devices (2048 byte page size)
+{{{#!bash
+# create a ubifs image
+mkfs.ubifs -F -m 2048 -e 124KiB -c 16248 -x zlib -o /mnt/removable/root.ubifs -d /mnt/ubifs
+# create a ubi image
+cat <<EOF > ubinize.cfg
+[ubifs]
+mode=ubi
+image=/mnt/removable/root.ubifs
+vol_id=0
+vol_type=dynamic
+vol_name=rootfs
+vol_flags=autoresize
+EOF
+# create ubi suitable for 2048byte page size and 128KiB block size devices
+ubinize -m 2048 -p 128KiB -o /mnt/removable/root.ubi ubinize.cfg
+}}}
+   * Note that the mkfs.ubifs process can take quite a bit of time with no output depending on the size of your filesystem; takes about 8 minutes for a 1GiB filesystem
+  b. 'large' geometry FLASH devices (4096 byte page size)
+{{{#!bash
+# create a ubif image
+mkfs.ubifs -F -m 4096 -e 248KiB -c 8124 -x zlib -o /mnt/removable/root.ubifs -d /mnt/ubifs
+# create a ubi image
+cat <<EOF > ubinize.cfg
+[ubifs]
+mode=ubi
+image=/mnt/removable/root.ubifs
+vol_id=0
+vol_type=dynamic
+vol_name=rootfs
+vol_flags=autoresize
+EOF
+# create ubi suitable for 4096byte page size and 256KiB block size devices
+ubinize -m 4096 -p 256KiB -o /mnt/removable/root.ubi ubinize.cfg
+}}}
+   * Note that the mkfs.ubifs process can take quite a bit of time with no output depending on the size of your filesystem; takes about 8 minutes for a 1GiB filesystem
+ 5. Unmount the filesystems:
+{{{#!bash
+umount /mnt/removable
+umount /mnt/ubifs
+ubidetach /dev/ubi_ctrl -m 2
+}}}
 
 
@@ -369 +425 @@
 }}}
  2. once the above is flashed with the Gateworks JTAG adapter and software you can flash the ubi (much more quickly than via JTAG) within U-Boot
- 3. break out into the bootloader, transfer the ubi image from a tftp server into SDRAM, and flash it:
+ 3. break out into the bootloader and load the ubi image and flash it:
+  a. from network via tftp:
 {{{#!bash
 setenv ipaddr 192.168.1.1 # local ip
@@ -377 +434 @@
 nand write ${loadaddr} rootfs ${filesize} # write the downloaded ubi to rootfs
 }}}
+  b. from removable storage via msata (device 0 partition 1):
+{{{#!bash
+sata init
+load sata 0:1 $loadaddr root.ubi
+nand erase.part rootfs
+nand write $loadaddr rootfs $filesize
+}}}
+ c. from removable storage via USB (device 0 partition 1):
+{{{#!bash
+usb start
+load usb 0:1 $loadaddr root.ubi
+nand erase.part rootfs
+nand write $loadaddr rootfs $filesize
+}}}
+ d. from removable storage via microSD (device 0 partition 1):
+{{{#!bash
+load mmc 0:1 $loadaddr root.ubi
+nand erase.part rootfs
+nand write $loadaddr rootfs $filesize
+}}}
+  * Note writing the nand may take some time; several minutes for a 600MB ubi
 
 Notes: