slitaz-arm view sat-rpi @ rev 52
Small fix to sat-rpi and rpi linux patch
| author | Christophe Lincoln <pankso@slitaz.org> |
|---|---|
| date | Tue Mar 11 22:12:16 2014 +0100 (2014-03-11) |
| parents | 77d9496b62f5 |
| children | f02931a2c41f |
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-tools Download or update RPi Tools (mkimage)
56 get-prebuilt Get a prebuilt SliTaz ARM toolchain
57 clean Clean the current work directory
59 $(boldify "Options:")
60 --up Update for commands: firmware, tools, kernel
61 --turbo Force the RPi to run at the highest arm_freq
62 --oclock= Set the RPi overclocking mode in config.txt
63 --vc Install the RPi VC libraries in /opt/vc
64 --nosat Don't regenerate the distro with sat
65 --git Remove RPi git files on clean up
67 EOT
68 }
70 error() {
71 echo "[ $(colorize 31 'ERROR') ] $@"
72 }
74 header() {
75 newline
76 boldify "$@"
77 separator
78 }
80 # Get minimal RPi firmware
81 get_fw() {
82 mkdir -p $firmware/boot
83 for fw in $fwlist
84 do
85 [ "$up" ] && rm -f $firmware/boot/$fw
86 if [ ! -f "$firmware/boot/$fw" ]; then
87 echo -n "Fetching: $fw"
88 wget -q --no-check-certificate ${fw_url}${fw} \
89 -O $firmware/boot/${fw}; status
90 fi
91 done
92 }
94 # Get all RPi firmware
95 clone_fw() {
96 [ -d "${rpi_git}/firmware" ] && return 0
97 mkdir -p ${rpi_git} && cd ${rpi_git}
98 git clone --depth 1 ${rpi_git_url}firmware.git
99 }
101 # Get RPi tools
102 get_tools() {
103 mkdir -p $tools
104 for t in $toolslist
105 do
106 [ "$up" ] && rm -f ${tools}/${t}
107 if [ ! -f "$tools/$t" ]; then
108 echo -n "Fetching: $t"
109 wget -q --no-check-certificate ${tools_url}${t} \
110 -O ${tools}/${t}; status
111 fi
112 done
113 }
115 # --> will move to tazberry
116 set_oclock() {
117 case "$oclock" in
118 none)
119 arm_freq=700
120 core_freq=250
121 sdram_freq=400
122 over_voltage=0 ;;
123 modest)
124 arm_freq=800
125 core_freq=300
126 sdram_freq=400
127 over_voltage=0 ;;
128 medium)
129 arm_freq=900
130 core_freq=333
131 sdram_freq=450
132 over_voltage=2 ;;
133 hight)
134 arm_freq=950
135 core_freq=450
136 sdram_freq=450
137 over_voltage=6 ;;
138 turbo)
139 arm_freq=1000
140 core_freq=500
141 sdram_freq=500
142 over_voltage=6 ;;
143 esac
144 cat >> ${boot}/config.txt << EOT
145 arm_freq=$arm_freq
146 core_freq=$core_freq
147 sdram_freq=$sdram_freq
148 over_voltage=$over_voltage
149 EOT
150 }
152 #
153 # Commands
154 #
156 case "$1" in
157 info)
158 header "SliTaz Raspberry Pi info"
159 echo "Firmware : $fwlist"
160 echo "RPi path : $rpi"
161 colorize 36 "/boot/cmdline.txt:"
162 cat ${boot}/cmdline.txt
163 colorize 36 "/boot/config.txt:"
164 cat ${boot}/config.txt
165 separator && newline ;;
167 install)
168 rpiboot="/media/rpi/boot"
169 rpiroot="/media/rpi/rootfs"
170 header "SliTaz Raspberry Pi install"
171 if [ ! "$dev" ]; then
172 echo "Missing: --dev= cmdline option"
173 newline && exit 1
174 fi
176 # Store sdcard partition(s) list
177 fdisk -l /dev/${dev} | grep "^/dev/$dev" | awk '{print $1}' \
178 > ${data}/sdcard.part
179 partnb=$(cat ${data}/sdcard.part | wc -l)
180 if [ "$partnb" != 3 ]; then
181 error "SliTaz RPi needs 3 partitions on the sdcard"
182 newline && exit 1
183 fi
185 # Mount sdcard
186 if mount | grep -q "^/dev/$dev[1-3]"; then
187 debug "Unmounting: /dev/$dev"
188 umount /dev/${dev}1 2>/dev/null || exit 1
189 umount /dev/${dev}3 2>/dev/null || exit 1
190 fi
191 echo -n "Mounting: /dev/$dev partitions"
192 mkdir -p ${rpiboot} ${rpiroot}
193 mount /dev/${dev}1 ${rpiboot}
194 mount /dev/${dev}3 ${rpiroot}; status
195 echo -n "Cleaning: filesystem directories"
196 for dir in bin dev etc lib media mnt proc sbin sys tmp usr var run
197 do
198 rm -rf ${rpiroot}/${dir}
199 done; status
200 echo -n "Installing: boot files"
201 cp -rf ${boot}/* ${rpiboot}; status
202 echo -n "Installing: rootfs files"
203 cp -a ${rootfs}/* ${rpiroot}; status
205 # Unmount
206 echo -n "Unmounting: RPi sdcard"
207 umount ${rpiboot} || exit 1
208 umount ${rpiroot} || exit 1
209 status
211 # Boot flag
212 #echo -n "Setting boot flag on: /dev/${dev}1"
213 #fdisk /dev/${dev} >/dev/null << EOF
214 #a
215 #1
216 #w
217 #EOF
218 #status
219 rm -f ${data}/sdcard.part
220 separator && newline ;;
222 ls-dev)
223 newline
224 fdisk -l | grep "^Disk /dev/sd*"
225 newline ;;
227 gen)
228 # Separate boot files since the Raspberry Pi boots off a FAT32 /boot
229 # partition on the sdcard.
230 : ${flavor=rpi}
231 : ${oclock=none}
233 # Use the rootfs generated by sat
234 if [ ! -x "/usr/bin/sat" ]; then
235 error "Sat is not installed" && exit 1
236 fi
238 # We may want to simply regenerate the RPi distro
239 if [ ! "$nosat" ]; then
240 sat gen --work="$work" --flavor="$flavor" --kmap --noinit --nolinux
241 fi
243 header "SliTaz Raspberry Pi distro"
245 # Boot firmware
246 echo -n "Copying: firmware files..."
247 mkdir -p ${boot} && get_fw
248 for fw in $fwlist
249 do
250 cp ${firmware}/boot/${fw} ${boot}
251 done
252 status
254 # TazBerry
255 echo -n "Installing TazBerry..."
256 cp -f ${rpi}/tazberry ${rootfs}/usr/bin
257 status
259 # Overclocking
260 echo -n "Setting: Overclocking..."
261 set_oclock; status
263 # Force turbo
264 if [ "$turbo" ]; then
265 if ! fgrep 'force_turbo=1' ${boot}/config.txt; then
266 echo -n "Config: force_turbo=1"
267 echo "force_turbo=1" >> ${boot}/config.txt; status
268 fi
269 fi
271 # RPi VC libraries
272 if [ "$vc" ]; then
273 vc="${rootfs}/opt/vc"
274 if [ ! -d "$firmware/opt/vc" ]; then
275 error "Missing firmware git repository" && exit 1
276 fi
277 echo -n "Copying: standard VC libraries"
278 cp -a ${firmware}/opt ${rootfs}
279 # --> armv6hf
280 #cp -a ${firmware}/hardfp/opt ${rootfs}
281 chown -R root.root ${rootfs}/opt
282 status
283 echo -n "Cleaning: VC libraries devel files"
284 cross_tools="/cross/${arch}/tools/bin"
285 rm -rf ${vc}/include ${vc}/src ${vc}/lib/*.a
286 ${cross_tools}/${arch}-slitaz-linux-gnueabi-strip -s ${vc}/lib/*.so
287 status
288 fi
290 # Kernel at last
291 . $data/linux-*/receipt
292 kvers="$VERSION"
293 kpkg="$rootfs/var/lib/tazpkg/installed/linux"
294 fs="$data/linux-$kvers/fs"
295 ksize=$(du -sh $fs | awk '{print $1}')
296 if [ -d "$fs" ]; then
297 echo -n "Copying: kernel $kvers ($ksize)"
298 rm -rf ${rootfs}/lib/modules
299 cp -rf ${fs}/lib/* ${rootfs}/lib
300 cp -f ${fs}/boot/* ${boot}
301 mkdir -p ${kpkg}
302 cd ${data}/linux-${kvers}
303 cp -f files.list md5sum receipt ${kpkg}
304 status
305 else
306 echo "SliTaz RPi Kernel: not used"
307 fi
309 separator
310 echo -n "Boot: $(du -sh $boot | awk '{print $1}') "
311 echo "- Rootfs: $(du -sh $rootfs | awk '{print $1}')"
312 newline ;;
314 cook-linux)
315 # Native SliTaz Toolchain and cross toolchain must be installed
316 check_root
317 install="$data/linux-install"
318 if [ ! -d "/cross/$arch" ]; then
319 error "Missing cross toolchain in: /cross/$arch"
320 exit 1
321 fi
323 # Kernel source
324 cd ${rpi_git}
325 [ -d "$kernel" ] || git clone --depth 1 ${rpi_git_url}linux.git
327 # Compile
328 [ "$clean" ] && rm -rf ${install}
329 if [ ! -d "$install" ]; then
330 cd ${kernel}
331 export PATH=$PATH:/cross/${arch}/tools/bin
332 export HOST_SYSTEM=${arch}-slitaz-linux-gnueabi
333 make mrproper &&
334 make ARCH=arm bcmrpi_defconfig
335 echo "Patching SliTaz RPi Linux .config"
336 patch -p0 -i ${rpi}/linux-rpi.patch || exit 1
337 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- zImage &&
338 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- modules &&
339 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- \
340 INSTALL_MOD_PATH=${install} modules_install || exit 1
341 mkdir -p ${install}/boot
342 cp -a arch/arm/boot/zImage ${install}/boot/kernel.img
343 fi
345 # Kernel version
346 kvers=$(ls ${install}/lib/modules)
347 kvers=${kvers%-slitaz-rpi+}+
349 # Compress modules
350 cd ${install}/lib/modules/${kvers%+}-slitaz-rpi+/ || exit 1
351 mods=$(find . -name "*.ko$" | wc -l)
352 newline
353 echo "Compressing kernel modules: $mods"
354 find . -name "*.ko$" -exec gzip '{}' \; #2> /dev/null
356 # Rebuild modules.dep
357 cd ${install}
358 depmod -b . ${kvers%+}-slitaz-rpi+
360 # Kernel
361 fs="$data/linux-$kvers/fs"
362 echo "Kernel version: $kvers"
363 if [ -d "$install" ]; then
364 rm -rf ${data}/linux-${kvers}
365 mkdir -p ${data}/linux-${kvers}
366 cp -a ${install} ${fs}
367 rm -f ${fs}/lib/modules/*/build \
368 ${fs}/lib/modules/*/source
369 fi
371 #get_tools
372 #echo "Compressing: zImage to kernel.img"
373 #cd ${tools}
374 #python imagetool-uncompressed.py ${fs}/boot/zImage
375 #mv -f kernel.img ${fs}/boot && rm ${fs}/boot/zImage
377 # Pack .tazpkg
378 cd ${data}
379 echo "Creating package: receipt"
380 cat > linux-$kvers/receipt << EOT
381 # SliTaz package receipt
383 PACKAGE="linux"
384 VERSION="$kvers"
385 SHORT_DESC="SliTaz Linux Kernel for the Raspberry Pi."
386 WEB_SITE="http://www.kernel.org"
388 EOT
389 tazpkg pack linux-$kvers ;;
391 get-fw)
392 get_fw ;;
394 get-tools)
395 get_tools ;;
397 get-linux)
398 # Precook RPi kernel
399 mkdir -p ${data}
401 # Last version
402 rm -f ${data}/linux-version.txt
403 if busybox wget -q -s ${rpi_mirror}/last-linux.txt; then
404 echo -n "Fetching latest Kernel string..."
405 wget -q ${rpi_mirror}/last-linux.txt \
406 -O ${data}/linux-version.txt || exit 1
407 status
408 else
409 echo "Mirror is unreachable" && exit 1
410 fi
411 kvers=$(cat $data/linux-version.txt)
412 [ "$up" ] && rm -rf ${data}/linux-${kvers}*
413 echo "Kernel version: $kvers"
415 # Download
416 if [ ! -f "$data/linux-$kvers.tazpkg" ]; then
417 echo -n "Fetching latest Linux package..."
418 wget -q ${rpi_mirror}/linux-${kvers}.tazpkg \
419 -O ${data}/linux-${kvers}.tazpkg; status
420 fi
422 # Extract
423 if [ ! -d "$data/linux-$kvers" ]; then
424 cd ${data} && tazpkg extract linux-${kvers}.tazpkg
425 fi
426 rm -f ${data}/linux-version.txt ;;
428 get-prebuilt)
429 # --> in cross ??
430 : ${arch=arm}
431 name="slitaz-$arch-toolchain"
432 vers="20140304"
433 tarball="$name-$vers.tar.bz2"
434 url="http://mirror.slitaz.org/packages/cross/"
435 mkdir -p /cross
436 cd /cross
437 if [ ! -f "$tarball" ]; then
438 if busybox wget -qs ${url%/}/${tarball}; then
439 busybox wget ${url%/}/${tarball}
440 else
441 echo "Toolchain URL is unreachable" && exit 1
442 fi
443 fi
444 if [ ! -d "${name}-${vers}" ]; then
445 echo "Extracting: $tarball"
446 tar xjf ${tarball}
447 fi
448 echo "Copying: ${name}-${vers}/${arch}"
449 mkdir -p ${arch}
450 cp -a ${name}-${vers}/${arch}/* ${arch}
451 echo "Tools path: /cross/${arch}/tools/bin" ;;
453 clone-fw)
454 clone_fw ;;
456 release)
457 # Used to release official SliTaz RPi images
458 cd ${distro} || exit 1
459 if [ ! "$flavor" ]; then
460 . $distro/rootfs/etc/slitaz/flavor.conf || exit 1
461 flavor="$FLAVOR"
462 fi
463 dirname="slitaz-$flavor-$(date +%Y%m%d)"
464 dsize=$(du -sh $distro | awk '{print $1}' | cut -d "." -f 1)
465 mkdir ${dirname}
466 # To be continued...
467 ;;
469 clean)
470 echo "Cleaning: $rpi"
471 rm -rf ${data}
472 [ "$git" ] && rm -rf ${rpi_git} ;;
473 *) usage ;;
474 esac
475 exit 0