slitaz-arm view sat-rpi @ rev 63
sat: few fixes
| author | Christophe Lincoln <pankso@slitaz.org> |
|---|---|
| date | Sat Mar 15 18:46:41 2014 +0100 (2014-03-15) |
| parents | f74a9206fdd0 |
| children | d81795f58d28 |
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 boot="$distro/boot"
19 rootfs="$distro/rootfs"
20 rpi_git="$rpi/git"
21 kernel="$rpi_git/linux"
22 firmware="$rpi_git/firmware"
23 tools="$rpi_git/tools"
25 # URLs
26 rpi_mirror="http://mirror.slitaz.org/arm/rpi/"
27 fw_url="https://github.com/raspberrypi/firmware/raw/master/boot/"
28 tools_url="https://raw.github.com/raspberrypi/tools/master/mkimage/"
29 rpi_git_url="git://github.com/raspberrypi/"
31 # Lists
32 fwlist="bootcode.bin fixup.dat start.elf"
33 toolslist="imagetool-uncompressed.py args-uncompressed.txt \
34 boot-uncompressed.txt"
36 #
37 # Functions
38 #
40 usage() {
41 cat << EOT
43 $(boldify "Usage:") $(basename $0) [command] [--option]
45 SliTaz Raspberry Pi Tool
47 $(boldify "Commands:")
48 info Display paths and distro info
49 install Install SliTaz RPi to sdcard
50 gen Generate a new SliTaz RPi distro
51 cook-linux Build the Raspberry Pi Linux kernel
52 get-linux Get the SliTaz RPi linux package
53 get-fw Download or update minimal RPi firmware
54 clone-fw Clone the RPi firmware repository
55 get-prebuilt Get a prebuilt SliTaz ARM toolchain
56 clean Clean the current work directory
58 $(boldify "Options:")
59 --up Update for commands: firmware, tools, kernel
60 --turbo Force the RPi to run at the highest arm_freq
61 --oclock= Set the RPi overclocking mode in config.txt
62 --vc Install the RPi VC libraries in /opt/vc
63 --nosat Don't regenerate the distro with sat
64 --git Remove RPi git files on clean up
66 EOT
67 }
69 error() {
70 echo "[ $(colorize 31 'ERROR') ] $@"
71 }
73 header() {
74 newline && boldify "$@" && separator
75 }
77 # Get minimal RPi firmware
78 get_fw() {
79 mkdir -p $firmware/boot
80 for fw in $fwlist
81 do
82 [ "$up" ] && rm -f $firmware/boot/$fw
83 if [ ! -f "$firmware/boot/$fw" ]; then
84 echo -n "Fetching: $fw"
85 wget -q --no-check-certificate ${fw_url}${fw} \
86 -O $firmware/boot/${fw}; status
87 fi
88 done
89 }
91 # Get all RPi firmware
92 clone_fw() {
93 [ -d "${rpi_git}/firmware" ] && return 0
94 mkdir -p ${rpi_git} && cd ${rpi_git}
95 git clone --depth 1 ${rpi_git_url}firmware.git
96 }
98 # --> will move to tazberry
99 set_oclock() {
100 case "$oclock" in
101 none)
102 arm_freq=700
103 core_freq=250
104 sdram_freq=400
105 over_voltage=0 ;;
106 modest)
107 arm_freq=800
108 core_freq=300
109 sdram_freq=400
110 over_voltage=0 ;;
111 medium)
112 arm_freq=900
113 core_freq=333
114 sdram_freq=450
115 over_voltage=2 ;;
116 hight)
117 arm_freq=950
118 core_freq=450
119 sdram_freq=450
120 over_voltage=6 ;;
121 turbo)
122 arm_freq=1000
123 core_freq=500
124 sdram_freq=500
125 over_voltage=6 ;;
126 esac
127 cat >> ${boot}/config.txt << EOT
128 arm_freq=$arm_freq
129 core_freq=$core_freq
130 sdram_freq=$sdram_freq
131 over_voltage=$over_voltage
132 EOT
133 }
135 #
136 # Commands
137 #
139 case "$1" in
140 info)
141 header "SliTaz Raspberry Pi info"
142 echo "Firmware : $fwlist"
143 echo "RPi path : $rpi"
144 colorize 36 "/boot/cmdline.txt:"
145 cat ${boot}/cmdline.txt
146 colorize 36 "/boot/config.txt:"
147 cat ${boot}/config.txt
148 separator && newline ;;
150 install)
151 rpiboot="/media/rpi/boot"
152 rpiroot="/media/rpi/rootfs"
153 header "SliTaz Raspberry Pi install"
154 if [ ! "$dev" ]; then
155 echo "Missing: --dev= cmdline option"
156 newline && exit 1
157 fi
159 # Store sdcard partition(s) list
160 fdisk -l /dev/${dev} | grep "^/dev/$dev" | awk '{print $1}' \
161 > ${data}/sdcard.part
162 partnb=$(cat ${data}/sdcard.part | wc -l)
163 if [ "$partnb" != 3 ]; then
164 error "SliTaz RPi needs 3 partitions on the sdcard"
165 newline && exit 1
166 fi
168 # Mount sdcard
169 if mount | grep -q "^/dev/$dev[1-3]"; then
170 debug "Unmounting: /dev/$dev"
171 umount /dev/${dev}1 2>/dev/null || exit 1
172 umount /dev/${dev}3 2>/dev/null || exit 1
173 fi
174 echo -n "Mounting: /dev/$dev partitions"
175 mkdir -p ${rpiboot} ${rpiroot}
176 mount /dev/${dev}1 ${rpiboot} || exit 1
177 mount /dev/${dev}3 ${rpiroot} || exit 1
178 status
179 echo -n "Cleaning: filesystem directories"
180 for dir in bin dev etc lib media mnt proc sbin sys tmp usr var run
181 do
182 rm -rf ${rpiroot}/${dir}
183 done; status
184 echo -n "Installing: boot files"
185 cp -rf ${boot}/* ${rpiboot}; status
186 echo -n "Installing: rootfs files"
187 cp -a ${rootfs}/* ${rpiroot}; status
189 # Unmount
190 echo -n "Unmounting: RPi sdcard"
191 umount ${rpiboot}
192 umount ${rpiroot}
193 status
195 rm -f ${data}/sdcard.part
196 separator && newline ;;
198 ls-dev)
199 newline
200 fdisk -l | grep "^Disk /dev/sd*"
201 newline ;;
203 gen)
204 # Separate boot files since the Raspberry Pi boots off a FAT32 /boot
205 # partition on the sdcard.
206 : ${flavor=rpi-base}
207 : ${oclock=none}
209 # Use the rootfs generated by sat
210 if [ ! -x "/usr/bin/sat" ]; then
211 error "Sat is not installed" && exit 1
212 fi
213 check_root
215 # We may want to simply regenerate the RPi distro
216 if [ ! "$nosat" ]; then
217 sat gen --work="$work" --flavor="$flavor" --noinit --nolinux
218 else
219 newline
220 fi
222 boldify "SliTaz Raspberry Pi distro"
223 separator
224 mkdir -p ${boot}
226 # Custom RPi rootfs: make sure all files belong to root
227 if [ -d "$rpi/rootfs" ]; then
228 size=$(du -sh $rpi/rootfs | awk '{print $1}')
229 echo -n "Copying custom RPi rootfs: $size"
230 tmp=$distro/tmp-$$
231 mkdir -p $tmp
232 cp -r $rpi/rootfs/* $tmp
233 chown -R root.root $tmp
234 cp -a $tmp/* ${rootfs} && rm -rf $tmp
235 mv -f ${rootfs}/boot/* ${boot}
236 status
237 fi
239 # Boot firmware
240 echo -n "Copying: firmware files..."
241 get_fw
242 for fw in $fwlist
243 do
244 cp ${firmware}/boot/${fw} ${boot}
245 done
246 status
248 # TazBerry ncurses and CGI data/plugins
249 echo -n "Copying: TazBerry..."
250 cp -f ${rpi}/tazberry ${rootfs}/usr/bin
251 cp -a ${rpi}/cgi-adm/* ${rootfs}/var/www/adm
252 status
254 # Overclocking
255 echo -n "Setting: Overclocking..."
256 set_oclock; status
258 # Force turbo
259 if [ "$turbo" ]; then
260 if ! fgrep 'force_turbo=1' ${boot}/config.txt; then
261 echo -n "Config: force_turbo=1"
262 echo "force_turbo=1" >> ${boot}/config.txt; status
263 fi
264 fi
266 # RPi VC libraries
267 if [ "$vc" ]; then
268 vc="${rootfs}/opt/vc"
269 if [ ! -d "$firmware/opt/vc" ]; then
270 error "Missing firmware git repository" && exit 1
271 fi
272 echo -n "Copying: standard VC libraries"
273 cp -a ${firmware}/opt ${rootfs}
274 # --> armv6hf
275 #cp -a ${firmware}/hardfp/opt ${rootfs}
276 chown -R root.root ${rootfs}/opt
277 status
278 echo -n "Cleaning: VC libraries devel files"
279 cross_tools="/cross/${arch}/tools/bin"
280 rm -rf ${vc}/include ${vc}/src ${vc}/lib/*.a
281 ${cross_tools}/${arch}-slitaz-linux-gnueabi-strip -s ${vc}/lib/*.so
282 status
283 fi
285 # Kernel at last
286 . $data/linux-*/receipt
287 kvers="$VERSION"
288 kpkg="$rootfs/var/lib/tazpkg/installed/linux"
289 fs="$data/linux-$kvers/fs"
290 ksize=$(du -sh $fs | awk '{print $1}')
291 if [ -d "$fs" ]; then
292 echo -n "Copying: kernel $kvers ($ksize)"
293 rm -rf ${rootfs}/lib/modules
294 cp -rf ${fs}/lib/* ${rootfs}/lib
295 cp -f ${fs}/boot/* ${boot}
296 mkdir -p ${kpkg}
297 cd ${data}/linux-${kvers}
298 cp -f files.list md5sum receipt ${kpkg}
299 status
300 else
301 echo "SliTaz RPi Kernel: not used"
302 fi
304 separator
305 echo -n "Boot: $(du -sh $boot | awk '{print $1}') "
306 echo "- Rootfs: $(du -sh $rootfs | awk '{print $1}')"
307 newline ;;
309 cook-linux)
310 # Native SliTaz Toolchain and cross toolchain must be installed
311 check_root
312 install="$data/linux-install"
313 if [ ! -d "/cross/$arch" ]; then
314 error "Missing cross toolchain in: /cross/$arch"
315 exit 1
316 fi
318 # Kernel source
319 cd ${rpi_git}
320 [ -d "$kernel" ] || git clone --depth 1 ${rpi_git_url}linux.git
322 # Compile
323 [ "$clean" ] && rm -rf ${install}
324 if [ ! -d "$install" ]; then
325 cd ${kernel}
326 export PATH=$PATH:/cross/${arch}/tools/bin
327 export HOST_SYSTEM=${arch}-slitaz-linux-gnueabi
328 make mrproper &&
329 make ARCH=arm bcmrpi_defconfig
330 echo "Patching SliTaz RPi Linux .config"
331 patch -p0 -i ${rpi}/linux-rpi.patch || exit 1
332 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- zImage &&
333 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- modules &&
334 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- \
335 INSTALL_MOD_PATH=${install} modules_install || exit 1
336 mkdir -p ${install}/boot
337 cp -a arch/arm/boot/zImage ${install}/boot/kernel.img
338 fi
340 # Kernel version
341 kvers=$(ls ${install}/lib/modules)
342 kvers=${kvers%-slitaz-rpi+}+
344 # Compress modules
345 cd ${install}/lib/modules/${kvers%+}-slitaz-rpi+/ || exit 1
346 mods=$(find . -name "*.ko$" | wc -l)
347 newline
348 echo "Compressing kernel modules: $mods"
349 find . -name "*.ko$" -exec gzip '{}' \; #2> /dev/null
351 # Rebuild modules.dep
352 cd ${install}
353 depmod -b . ${kvers%+}-slitaz-rpi+
355 # Kernel
356 fs="$data/linux-$kvers/fs"
357 echo "Kernel version: $kvers"
358 if [ -d "$install" ]; then
359 rm -rf ${data}/linux-${kvers}
360 mkdir -p ${data}/linux-${kvers}
361 cp -a ${install} ${fs}
362 rm -f ${fs}/lib/modules/*/build \
363 ${fs}/lib/modules/*/source
364 fi
366 # Pack .tazpkg
367 cd ${data}
368 echo "Creating package: receipt"
369 cat > linux-$kvers/receipt << EOT
370 # SliTaz package receipt
372 PACKAGE="linux"
373 VERSION="$kvers"
374 SHORT_DESC="SliTaz Linux Kernel for the Raspberry Pi."
375 WEB_SITE="http://www.kernel.org"
377 EOT
378 tazpkg pack linux-$kvers ;;
380 get-fw)
381 get_fw ;;
383 get-tools)
384 get_tools ;;
386 get-linux)
387 # Precook RPi kernel
388 check_root
389 mkdir -p ${data}
391 # Last version
392 rm -f ${data}/linux-version.txt
393 if busybox wget -q -s ${rpi_mirror}/last-linux.txt; then
394 echo -n "Fetching latest Kernel string..."
395 wget -q ${rpi_mirror}/last-linux.txt \
396 -O ${data}/linux-version.txt || exit 1
397 status
398 else
399 echo "Mirror is unreachable" && exit 1
400 fi
401 kvers=$(cat $data/linux-version.txt)
402 [ "$up" ] && rm -rf ${data}/linux-${kvers}*
403 echo "Kernel version: $kvers"
405 # Download
406 if [ ! -f "$data/linux-$kvers.tazpkg" ]; then
407 echo -n "Fetching latest Linux package..."
408 wget -q ${rpi_mirror}/linux-${kvers}.tazpkg \
409 -O ${data}/linux-${kvers}.tazpkg; status
410 fi
412 # Extract
413 if [ ! -d "$data/linux-$kvers" ]; then
414 cd ${data} && tazpkg extract linux-${kvers}.tazpkg
415 fi
416 rm -f ${data}/linux-version.txt ;;
418 get-prebuilt)
419 # --> in cross ??
420 : ${arch=arm}
421 name="slitaz-$arch-toolchain"
422 vers="20140304"
423 tarball="$name-$vers.tar.bz2"
424 url="http://mirror.slitaz.org/packages/cross/"
425 mkdir -p /cross
426 cd /cross
427 if [ ! -f "$tarball" ]; then
428 if busybox wget -qs ${url%/}/${tarball}; then
429 busybox wget ${url%/}/${tarball}
430 else
431 echo "Toolchain URL is unreachable" && exit 1
432 fi
433 fi
434 if [ ! -d "${name}-${vers}" ]; then
435 echo "Extracting: $tarball"
436 tar xjf ${tarball}
437 fi
438 echo "Copying: ${name}-${vers}/${arch}"
439 mkdir -p ${arch}
440 cp -a ${name}-${vers}/${arch}/* ${arch}
441 echo "Tools path: /cross/${arch}/tools/bin" ;;
443 clone-fw)
444 clone_fw ;;
446 release)
447 # Used to release official SliTaz RPi images
448 cd ${distro} || exit 1
449 if [ ! "$flavor" ]; then
450 . $distro/rootfs/etc/slitaz/flavor.conf || exit 1
451 flavor="$FLAVOR"
452 fi
453 dname="slitaz-$flavor-$(date +%Y%m%d)"
454 dsize=$(du -sh $distro | awk '{print $1}' | cut -d "." -f 1)
455 rm -rf ${dname} && mkdir ${dname}
456 cp -a boot rootfs ${dname}
457 cat > ${dname}/README << EOT
458 SliTaz Raspberry Pi - $flavor-$(date +%Y%m%d) - http://arm.slitaz.org/rpi
459 --------------------------------------------------------------------------------
461 boot/ : Must be copied to a FAT32 partition
462 rootfs/ : Must be copied to a ext4 or btrfs partition
464 Manual Installation. Assuming the sdcard is /dev/sdc and has got 3
465 partitions (boot,swap,root). Mount the sdcard, copy files, unmount:
467 # mkdir -p /media/rpi/boot /media/rpi/root
469 # mount /dev/sdc1 /media/rpi/boot
470 # mount /dev/sdc3 /media/rpi/root
472 # cp -a boot/* /media/rpi/boot
473 # cp -a rootfs/* /media/rpi/root
475 # umount /media/rpi/boot
476 # umount /media/rpi/root
478 --------------------------------------------------------------------------------
480 EOT
481 echo "Creating: ${dname}.tar.xz"
482 tar -cJf ${dname}.tar.xz ${dname}
483 echo "Creating: ${dname}.md5"
484 md5sum ${dname}.tar.xz > ${dname}.md5
485 rm -rf ${dname} ;;
487 clean)
488 echo "Cleaning: $rpi"
489 rm -rf ${data}
490 [ "$git" ] && rm -rf ${rpi_git} ;;
491 *) usage ;;
492 esac
493 exit 0