slitaz-arm view sat-rpi @ rev 120
sat-rpi: add VC tools to path if installed
| author | Christophe Lincoln <pankso@slitaz.org> |
|---|---|
| date | Mon Apr 21 07:30:42 2014 +0200 (2014-04-21) |
| parents | 349fa2f9498f |
| children | 73088f03f824 |
line source
1 #!/bin/sh
2 #
3 # Sat RPi - SliTaz Raspberry Pi Build Tool
4 #
5 # Copyright (C) 2012-2014 SliTaz ARM - BSD License
6 # Author: Christophe Lincoln <pankso@slitaz.org>
7 #
8 . /lib/libtaz.sh
10 #: ${arch=armv6hf}
11 : ${arch=arm}
13 # Paths
14 [ "$work" ] || work="$(pwd)"
15 distro="$work/distro"
16 rpi="$work/rpi"
17 data="$rpi/data"
18 cache="$rpi/cache"
19 boot="$distro/boot"
20 rootfs="$distro/rootfs"
21 rpi_git="$rpi/git"
22 kernel="$rpi_git/linux"
23 firmware="$rpi_git/firmware"
24 dev="$2"
26 # URLs
27 rpi_mirror="http://mirror.slitaz.org/arm/rpi/"
28 fw_url="https://github.com/raspberrypi/firmware/raw/master/boot/"
29 rpi_git_url="git://github.com/raspberrypi/"
31 # Lists
32 fwlist="bootcode.bin fixup.dat start.elf"
34 #
35 # Functions
36 #
38 usage() {
39 cat << EOT
41 $(boldify "Usage:") $(basename $0) [command] [--option]
43 SliTaz Raspberry Pi Tool
45 $(boldify "Commands:")
46 info Display paths and distro info
47 install Install SliTaz RPi to sdcard
48 gen Generate a new SliTaz RPi distro
49 cook-linux Build the Raspberry Pi Linux kernel
50 get-linux Get the SliTaz RPi linux package
51 get-fw Download or update minimal RPi firmware
52 clone-fw Clone the RPi firmware repository
53 get-prebuilt Get a prebuilt SliTaz ARM toolchain
54 clean Clean the current work directory
55 release Release an installable tarball
57 $(boldify "Options:")
58 --up Update for commands: firmware and kernel
59 --vc Install the RPi VC libraries in /opt/vc
60 --nosat Don't regenerate the distro with sat
62 EOT
63 }
65 error() {
66 echo "[ $(colorize 31 'ERROR') ] $@"
67 }
69 header() {
70 newline && colorize 35 "$@" && separator
71 }
73 # Get minimal RPi firmware
74 get_fw() {
75 mkdir -p $firmware/boot
76 for fw in $fwlist
77 do
78 [ "$up" ] && rm -f $firmware/boot/$fw
79 if [ ! -f "$firmware/boot/$fw" ]; then
80 echo -n "Fetching: $fw"
81 wget -q --no-check-certificate ${fw_url}${fw} \
82 -O $firmware/boot/${fw}; status
83 fi
84 done
85 }
87 # Get all RPi firmware
88 clone_fw() {
89 [ -d "${rpi_git}/firmware" ] && return 0
90 mkdir -p ${rpi_git} && cd ${rpi_git}
91 git clone --depth 1 ${rpi_git_url}firmware.git
92 }
94 # --> will move to tazberry
95 set_oclock() {
96 case "$oclock" in
97 none)
98 arm_freq=700
99 core_freq=250
100 sdram_freq=400
101 over_voltage=0 ;;
102 modest)
103 arm_freq=800
104 core_freq=300
105 sdram_freq=400
106 over_voltage=0 ;;
107 medium)
108 arm_freq=900
109 core_freq=333
110 sdram_freq=450
111 over_voltage=2 ;;
112 hight)
113 arm_freq=950
114 core_freq=450
115 sdram_freq=450
116 over_voltage=6 ;;
117 turbo)
118 arm_freq=1000
119 core_freq=500
120 sdram_freq=500
121 over_voltage=6 ;;
122 esac
123 cat >> ${boot}/config.txt << EOT
124 # Overclocking Settings
125 arm_freq=$arm_freq
126 core_freq=$core_freq
127 sdram_freq=$sdram_freq
128 over_voltage=$over_voltage
130 EOT
131 }
133 umount_sd() {
134 umount /dev/${dev}1 2>/dev/null || exit 1
135 umount /dev/${dev}3 2>/dev/null || exit 1
136 }
138 #
139 # Commands
140 #
142 case "$1" in
143 info)
144 header "SliTaz Raspberry Pi info"
145 echo "Firmware : $fwlist"
146 echo "RPi path : $rpi"
147 colorize 36 "/boot/cmdline.txt:"
148 cat ${boot}/cmdline.txt
149 colorize 36 "/boot/config.txt:"
150 cat ${boot}/config.txt
151 separator && newline ;;
153 install)
154 rpiboot="/media/rpi/boot"
155 rpiroot="/media/rpi/rootfs"
156 header "SliTaz Raspberry Pi install"
157 if [ ! "$dev" ]; then
158 echo -n "SD card disk name (ex sdc): "; read dev
159 fi
160 [ ! "$dev" ] && exit 1
162 # Store sdcard partition(s) list
163 fdisk -l /dev/${dev} | grep "^/dev/$dev" | awk '{print $1}' \
164 > ${cache}/sdcard.part
165 partnb=$(cat ${cache}/sdcard.part | wc -l)
166 if [ "$partnb" != 3 ]; then
167 error "SliTaz RPi needs 3 partitions on the sdcard"
168 newline && exit 1
169 fi
171 # Mount sdcard
172 if mount | grep -q "^/dev/$dev[1-3]"; then
173 debug "Unmounting: /dev/$dev"
174 umount_sd
175 fi
176 echo -n "Mounting: /dev/$dev partitions"
177 mkdir -p ${rpiboot} ${rpiroot}
178 mount /dev/${dev}1 ${rpiboot} || exit 1
179 mount /dev/${dev}3 ${rpiroot} || exit 1
180 status
181 echo -n "Cleaning: filesystem directories"
182 for dir in bin dev etc lib media mnt proc sbin sys tmp usr var run
183 do
184 rm -rf ${rpiroot}/${dir}
185 done; status
186 echo -n "Installing: boot files"
187 cp -rf ${boot}/* ${rpiboot}; status
188 echo -n "Installing: rootfs files"
189 cp -a ${rootfs}/* ${rpiroot}; status
191 # Unmount
192 echo -n "Unmounting: RPi sdcard"
193 umount_sd; status
195 rm -f ${cache}/sdcard.part
196 separator
197 echo "Insert the SD card into your Raspberry Pi and boot!"
198 newline ;;
200 ls-dev)
201 newline
202 fdisk -l | grep "^Disk /dev/sd*"
203 newline ;;
205 gen)
206 # Separate boot files since the Raspberry Pi boots off a FAT32 /boot
207 # partition on the sdcard.
208 : ${flavor=rpi-base}
209 : ${oclock=none}
211 # Use the rootfs generated by sat
212 if [ ! -x "/usr/bin/sat" ]; then
213 error "Sat is not installed" && exit 1
214 fi
215 check_root
217 # We may want to simply regenerate the RPi distro
218 if [ ! "$nosat" ]; then
219 sat gen --work="$work" --flavor="$flavor" --noinit --nolinux
220 else
221 newline
222 fi
224 colorize 35 "SliTaz Raspberry Pi distro"
225 separator
226 mkdir -p ${boot}
228 # Custom RPi rootfs: make sure all files belong to root
229 if [ -d "$rpi/rootfs" ]; then
230 size=$(du -sh $rpi/rootfs | awk '{print $1}')
231 echo -n "Copying custom RPi rootfs: $size"
232 tmp=$distro/tmp-$$
233 mkdir -p $tmp
234 cp -r $rpi/rootfs/* $tmp
235 chown -R root.root $tmp
236 cp -a $tmp/* ${rootfs} && rm -rf $tmp
237 mv -f ${rootfs}/boot/* ${boot}
238 status
239 fi
241 # Boot firmware
242 echo -n "Copying: firmware files..."
243 get_fw
244 for fw in $fwlist
245 do
246 cp ${firmware}/boot/${fw} ${boot}
247 done
248 status
250 # TazBerry
251 echo -n "Copying utility: TazBerry..."
252 cp -f ${rpi}/tazberry ${rootfs}/usr/bin
253 cp -a ${rpi}/cgi-adm/* ${rootfs}/var/www/adm
254 status
256 # PiBoot
257 echo -n "Copying bootloader: PiBoot..."
258 cp -f ${rpi}/piboot ${rootfs}/sbin
259 status
261 # RPi VC libraries
262 if [ "$vc" ]; then
263 vc="${rootfs}/opt/vc"
264 if [ ! -d "$firmware/opt/vc" ]; then
265 error "Missing firmware git repository" && exit 1
266 fi
267 echo -n "Copying: standard VC libraries"
268 cp -a ${firmware}/opt ${rootfs}
269 # --> armv6hf
270 #cp -a ${firmware}/hardfp/opt ${rootfs}
271 chown -R root.root ${rootfs}/opt
272 status
273 echo -n "Cleaning: VC libraries devel files"
274 cross_tools="/cross/${arch}/tools/bin"
275 rm -rf ${vc}/include ${vc}/src ${vc}/lib/*.a
276 ${cross_tools}/${arch}-slitaz-linux-gnueabi-strip -s ${vc}/lib/*.so
277 status
278 echo -n "Adding: VC binarie to PATH"
279 echo -e '\n# Raspberry Pi VC tools' >> ${rootfs}/etc/profile
280 echo 'export PATH=$PATH:/opt/vc/bin' >> ${rootfs}/etc/profile
281 status
282 fi
284 # Kernel at last
285 . $cache/linux-*/receipt
286 kvers="$VERSION"
287 kpkg="$rootfs/var/lib/tazpkg/installed/linux"
288 fs="$cache/linux-$kvers/fs"
289 ksize=$(du -sh $fs | awk '{print $1}')
290 if [ -d "$fs" ]; then
291 echo -n "Copying: kernel $kvers ($ksize)"
292 rm -rf ${rootfs}/lib/modules
293 cp -rf ${fs}/lib/* ${rootfs}/lib
294 cp -f ${fs}/boot/* ${boot}
295 mkdir -p ${kpkg}
296 cd ${cache}/linux-${kvers}
297 cp -f files.list md5sum receipt ${kpkg}
298 status
299 else
300 echo "SliTaz RPi Kernel: not used"
301 fi
303 separator
304 echo -n "Boot: $(du -sh $boot | awk '{print $1}') "
305 echo "- Rootfs: $(du -sh $rootfs | awk '{print $1}')"
306 newline ;;
308 cook-linux)
309 # Native SliTaz Toolchain and cross toolchain must be installed
310 check_root
311 install="$cache/linux-install"
312 if [ ! -d "/cross/$arch" ]; then
313 error "Missing cross toolchain in: /cross/$arch" && exit 1
314 fi
316 # Kernel source
317 cd ${rpi_git}
318 [ -d "$kernel" ] || git clone --depth 1 ${rpi_git_url}linux.git
320 # Compile
321 [ "$clean" ] && rm -rf ${install}
322 if [ ! -d "$install" ]; then
323 cd ${kernel}
324 export PATH=$PATH:/cross/${arch}/tools/bin
325 export HOST_SYSTEM=${arch}-slitaz-linux-gnueabi
326 make mrproper &&
327 make ARCH=arm bcmrpi_defconfig
328 echo "Patching SliTaz RPi Linux .config"
329 patch -p0 -i ${data}/linux-rpi.patch || exit 1
330 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- zImage &&
331 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- modules &&
332 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- \
333 INSTALL_MOD_PATH=${install} modules_install || exit 1
334 mkdir -p ${install}/boot
335 cp -a arch/arm/boot/zImage ${install}/boot/kernel.img
336 fi
338 # Kernel version
339 kvers=$(ls ${install}/lib/modules)
340 kvers=${kvers%-slitaz-rpi+}+
342 # Compress modules
343 cd ${install}/lib/modules/${kvers%+}-slitaz-rpi+/ || exit 1
344 mods=$(find . -name "*.ko$" | wc -l)
345 newline
346 echo "Compressing kernel modules: $mods"
347 find . -name "*.ko$" -exec gzip '{}' \; #2> /dev/null
349 # Rebuild modules.dep
350 cd ${install}
351 depmod -b . ${kvers%+}-slitaz-rpi+
353 # Kernel
354 fs="$cache/linux-$kvers/fs"
355 echo "Kernel version: $kvers"
356 if [ -d "$install" ]; then
357 rm -rf ${cache}/linux-${kvers}
358 mkdir -p ${cache}/linux-${kvers}
359 cp -a ${install} ${fs}
360 rm -f ${fs}/lib/modules/*/build \
361 ${fs}/lib/modules/*/source
362 fi
364 # Pack .tazpkg
365 cd ${cache}
366 echo "Creating package: receipt"
367 cat > linux-$kvers/receipt << EOT
368 # SliTaz package receipt
370 PACKAGE="linux"
371 VERSION="$kvers"
372 SHORT_DESC="SliTaz Linux Kernel for the Raspberry Pi."
373 WEB_SITE="http://www.kernel.org"
375 EOT
376 tazpkg pack linux-$kvers ;;
378 get-fw)
379 get_fw ;;
381 clone-fw)
382 clone_fw ;;
384 get-linux)
385 # Precook RPi kernel
386 check_root
387 mkdir -p ${cache}
389 # Last version
390 rm -f ${cache}/linux-version.txt
391 if busybox wget -q -s ${rpi_mirror}/last-linux.txt; then
392 echo -n "Fetching latest Kernel string..."
393 wget -q ${rpi_mirror}/last-linux.txt \
394 -O ${cache}/linux-version.txt || exit 1
395 status
396 else
397 echo "Mirror is unreachable" && exit 1
398 fi
399 kvers=$(cat $cache/linux-version.txt)
400 [ "$up" ] && rm -rf ${cache}/linux-${kvers}*
401 echo "Kernel version: $kvers"
403 # Download
404 if [ ! -f "$cache/linux-$kvers.tazpkg" ]; then
405 echo -n "Fetching latest Linux package..."
406 wget -q ${rpi_mirror}/linux-${kvers}.tazpkg \
407 -O ${cache}/linux-${kvers}.tazpkg; status
408 fi
410 # Extract
411 if [ ! -d "$cache/linux-$kvers" ]; then
412 cd ${cache} && tazpkg extract linux-${kvers}.tazpkg
413 fi
414 rm -f ${cache}/linux-version.txt ;;
416 get-prebuilt)
417 # --> in cross ??
418 : ${arch=arm}
419 name="slitaz-$arch-toolchain"
420 vers="20140304"
421 tarball="$name-$vers.tar.bz2"
422 url="http://mirror.slitaz.org/packages/cross/"
423 mkdir -p /cross
424 cd /cross
425 if [ ! -f "$tarball" ]; then
426 if busybox wget -qs ${url%/}/${tarball}; then
427 busybox wget ${url%/}/${tarball}
428 else
429 echo "Toolchain URL is unreachable" && exit 1
430 fi
431 fi
432 if [ ! -d "${name}-${vers}" ]; then
433 echo "Extracting: $tarball"
434 tar xjf ${tarball}
435 fi
436 echo "Copying: ${name}-${vers}/${arch}"
437 mkdir -p ${arch}
438 cp -a ${name}-${vers}/${arch}/* ${arch}
439 echo "Tools path: /cross/${arch}/tools/bin" ;;
441 release)
442 # Used to release official SliTaz RPi images
443 cd ${distro} || exit 1
444 if [ ! "$flavor" ]; then
445 . $distro/rootfs/etc/slitaz/flavor.conf || exit 1
446 flavor="$FLAVOR"
447 fi
448 dname="slitaz-$flavor-$(date +%Y%m%d)"
449 dsize=$(du -sh $distro | awk '{print $1}' | cut -d "." -f 1)
450 rm -rf ${dname} && mkdir ${dname}
451 cp -a boot rootfs ${dname}
452 echo "Copying: SliTaz release files"
453 cp ${rpi}/release/* ${dname}
454 echo "Creating: ${dname}.tar.bz2"
455 tar -cjf ${dname}.tar.bz2 ${dname}
456 echo "Creating: ${dname}.md5"
457 md5sum ${dname}.tar.bz2 > ${dname}.md5
458 rm -rf ${dname} ;;
460 clean)
461 echo "Cleaning: $rpi"
462 rm -rf ${cache} ${rpi_git} ;;
464 *|*help) usage ;;
465 esac
466 exit 0