slitaz-arm view spi @ rev 37

Bunch of improvments, add /opt/vc support
author Christophe Lincoln <pankso@slitaz.org>
date Fri Mar 07 23:06:51 2014 +0100 (2014-03-07)
parents 5445fd3856ad
children 7a9f08753b34
line source
1 #!/bin/sh
2 #
3 # Spi - SliTaz Raspberry Pi Tool
4 #
5 # Copyright (C) 2012-2014 SliTaz ARM - BSD License
6 # Author: Christophe Lincoln <pankso@slitaz.org>
7 #
8 . /lib/libtaz.sh
9
10 # Paths
11 [ "$work" ] || work="$(pwd)"
12 distro="$work/distro"
13 rpi="$work/rpi"
14 data="$rpi/data"
15 boot="$distro/boot"
16 rootfs="$distro/rootfs"
17 rpi_git="$rpi/git"
18 kernel="$rpi_git/linux"
19 firmware="$rpi_git/firmware"
20 tools="$rpi_git/tools"
21
22 # URLs
23 rpi_mirror="http://mirror.slitaz.org/arm/rpi/"
24 fw_url="https://github.com/raspberrypi/firmware/raw/master/boot/"
25 tools_url="https://raw.github.com/raspberrypi/tools/master/mkimage/"
26 rpi_git_url="git://github.com/raspberrypi/"
27
28 # Lists
29 fwlist="bootcode.bin fixup.dat start.elf"
30 toolslist="imagetool-uncompressed.py args-uncompressed.txt \
31 boot-uncompressed.txt"
32
33 #
34 # Functions
35 #
36
37 usage() {
38 cat << EOT
39
40 $(boldify "Usage:") $(basename $0) [command] [--option]
41
42 $(boldify "Commands:")
43 info Display paths and distro info
44 install Install SliTaz RPi to sdcard
45 gen Generate a new SliTaz RPi distro
46 cook-linux Build the Raspberry Pi Linux kernel
47 get-linux Get the SliTaz RPi linux package
48 get-fw Download or update RPi Firmware
49 clone-fw Clone the RPi Firmware repository
50 get-tools Download or update RPi Tools (mkimage)
51 get-prebuilt Get a prebuilt SliTaz ARM toolchain
52 oclock Display overclocking information
53
54 $(boldify "Options:")
55 --up Update for commands: firmware, tools, kernel
56 --turbo Force the RPi to run at the highest arm_freq
57 --oclock= Set the RPi overclocking mode in config.txt
58 --vc Install the RPi VC libraries in /opt/vc
59 --nosat Dont regenerate the distro with sat
60
61 EOT
62 }
63
64 error() {
65 echo "[ $(colorize 31 'ERROR') ] $@"
66 }
67
68 header() {
69 newline
70 boldify "$@"
71 separator
72 }
73
74 # Get minimal RPi firmware
75 get_fw() {
76 mkdir -p $firmware/boot
77 for fw in $fwlist
78 do
79 [ "$up" ] && rm -f $firmware/boot/$fw
80 if [ ! -f "$firmware/boot/$fw" ]; then
81 echo -n "Fetching: $fw"
82 wget -q --no-check-certificate ${fw_url}${fw} \
83 -O $firmware/boot/${fw}; status
84 fi
85 done
86 }
87
88 # Get all RPi firmware
89 clone_fw() {
90 [ -d "${rpi_git}/firmware" ] && return 0
91 mkdir -p ${rpi_git} && cd ${rpi_git}
92 git clone --depth 1 ${rpi_git_url}firmware.git
93 }
94
95 # Get RPi tools
96 get_tools() {
97 mkdir -p $tools
98 for t in $toolslist
99 do
100 [ "$up" ] && rm -f ${tools}/${t}
101 if [ ! -f "$data/$t" ]; then
102 echo -n "Fetching: $t"
103 wget -q --no-check-certificate ${tools_url}${t} \
104 -O ${tools}/${t}; status
105 fi
106 done
107 }
108
109 # Configure overclocking
110 set_oclock() {
111 case "$oclock" in
112 none)
113 arm_freq=700
114 core_freq=250
115 sdram_freq=400
116 over_voltage=0 ;;
117 modest)
118 arm_freq=800
119 core_freq=300
120 sdram_freq=400
121 over_voltage=0 ;;
122 medium)
123 arm_freq=900
124 core_freq=333
125 sdram_freq=450
126 over_voltage=2 ;;
127 hight)
128 arm_freq=950
129 core_freq=450
130 sdram_freq=450
131 over_voltage=6 ;;
132 turbo)
133 arm_freq=1000
134 core_freq=500
135 sdram_freq=500
136 over_voltage=6 ;;
137 esac
138 cat >> ${boot}/config.txt << EOT
139 arm_freq=$arm_freq
140 core_freq=$core_freq
141 sdram_freq=$sdram_freq
142 over_voltage=$over_voltage
143 EOT
144 }
145
146 #
147 # Commands
148 #
149
150 case "$1" in
151 info)
152 header "SliTaz Raspberry Pi info"
153 echo "Firmware : $fwlist"
154 echo "RPi path : $rpi"
155 colorize 36 "/boot/cmdline.txt:"
156 cat ${boot}/cmdline.txt
157 colorize 36 "/boot/config.txt:"
158 cat ${boot}/config.txt
159 separator && newline ;;
160
161 install)
162 rpiboot="/media/rpi/boot"
163 rpiroot="/media/rpi/rootfs"
164 header "SliTaz Raspberry Pi install"
165 if [ ! "$dev" ]; then
166 echo "Missing: --dev= cmdline option" && exit 1
167 fi
168
169 # Store sdcard partition(s) list
170 fdisk -l /dev/${dev} | grep "^/dev/$dev" | awk '{print $1}' \
171 > ${data}/sdcard.part
172 partnb=$(cat ${data}/sdcard.part | wc -l)
173 if [ "$partnb" != 3 ]; then
174 error "SliTaz RPi needs 3 partitions on the sdcard"
175 newline && exit 1
176 fi
177
178 # Mount sdcard
179 if mount | grep -q "^/dev/$dev[1-3]"; then
180 debug "Unmounting: /dev/$dev"
181 umount /dev/${dev}1 2>/dev/null || exit 1
182 umount /dev/${dev}3 2>/dev/null || exit 1
183 fi
184 echo -n "Mounting: /dev/$dev partitions"
185 mkdir -p ${rpiboot} ${rpiroot}
186 mount /dev/${dev}1 ${rpiboot}
187 mount /dev/${dev}3 ${rpiroot}; status
188 echo -n "Installing: boot files"
189 cp -rf ${boot}/* ${rpiboot}; status
190 echo -n "Installing: rootfs files"
191 cp -a ${rootfs}/* ${rpiroot}; status
192
193 # Unmount
194 echo -n "Unmounting: RPi sdcard"
195 umount ${rpiboot} || exit 1
196 umount ${rpiroot} || exit 1
197 status
198
199 # Boot flag
200 #echo -n "Setting boot flag on: /dev/${dev}1"
201 #fdisk /dev/${dev} >/dev/null << EOF
202 #a
203 #1
204 #w
205 #EOF
206 #status
207 rm -f ${data}/sdcard.part
208 separator && newline ;;
209
210 ls-dev)
211 newline
212 fdisk -l | grep "^Disk /dev/sd*"
213 newline ;;
214
215 gen)
216 # Separate boot files since the Raspberry Pi boots off a FAT32 /boot
217 # partition on the sdcard.
218 : ${flavor=rpi}
219 : ${oclock=none}
220
221 # Use the rootfs generated by sat
222 if [ ! -x "/usr/bin/sat" ]; then
223 error "Sat is not installed" && exit 1
224 fi
225
226 # We may want to simply regenerate the RPi distro
227 if [ ! "$nosat" ]; then
228 sat gen --work="$work" --flavor="$flavor" --kmap --noinit --rpi
229 fi
230
231 header "SliTaz Raspberry Pi distro"
232
233 # Boot firmware
234 echo -n "Copying: firmware files..."
235 mkdir -p ${boot} && get_fw
236 for fw in $fwlist
237 do
238 cp ${firmware}/boot/${fw} ${boot}
239 done
240 status
241
242 # SliTaz Raspberry Pi custom rootfs files. Make sure all files
243 # belong to root
244 if [ -d "$rpi/rootfs" ]; then
245 size=$(du -sh $rpi/rootfs | awk '{print $1}')
246 echo -n "Copying: SliTaz RPi rootfs ($size)"
247 tmp=${distro}/tmp-$$
248 mkdir -p ${tmp}
249 cp -r ${rpi}/rootfs/* ${tmp}
250 chown -R root.root ${tmp}
251 cp -a ${tmp}/* ${rootfs} && rm -rf ${tmp}
252 # Move files to $boot
253 mv -f ${rootfs}/boot/* ${boot}
254 status
255 fi
256
257 # Overcloking
258 echo -n "Setting: Overcloking"
259 set_oclock; status
260
261 # Force turbo
262 if [ "$turbo" ]; then
263 echo -n "Config: force_turbo=1"
264 echo "force_turbo=1" >> ${boot}/config.txt; status
265 fi
266
267 # Kernel
268 kvers=$(ls $data/linux-*/fs/lib/modules)
269 kpkg="$rootfs/var/lib/tazpkg/installed/linux"
270 fs="$data/linux-$kvers/fs"
271 ksize=$(du -sh $fs | awk '{print $1}')
272 if [ -d "$fs" ]; then
273 echo -n "Copying: kernel $kvers ($ksize)"
274 rm -rf ${rootfs}/lib/modules
275 cp -rf ${fs}/lib/* ${rootfs}/lib
276 cp -f ${fs}/boot/* ${boot}
277 mkdir -p ${kpkg}
278 cd ${data}/linux-${kvers}
279 cp -f files.list md5sum receipt ${kpkg}
280 status
281 else
282 echo "RPi Kernel: not used"
283 fi
284
285 # RPi VC libraries
286 if [ "$vc" ]; then
287 if [ ! -d "$firmware/opt/vc" ]; then
288 error "Missing firmware git repository" && exit 1
289 fi
290 # --hardfp
291 if [ "$hardfp" ]; then
292 echo -n "Not yet supported: SliTaz ARMv6hf"; false
293 else
294 echo -n "Installing standard: VC libraries"
295 cp -a ${firmware}/opt ${rootfs}
296 fi
297 status
298 fi
299
300 separator
301 echo -n "Boot: $(du -sh $boot | awk '{print $1}') "
302 echo "- Rootfs: $(du -sh $rootfs | awk '{print $1}')"
303 newline ;;
304
305 cook-linux)
306 # Native SliTaz Toolchain and cross toolchain must be installed
307 check_root
308 #: ${arch=armv6hf}
309 : ${arch=arm}
310 install="$data/linux-install"
311 if [ ! -d "/cross/$arch" ]; then
312 error "Missing cross toolchain in: /cross/$arch"
313 exit 1
314 fi
315
316 # Kernel source
317 cd ${rpi_git}
318 [ -d "$kernel" ] || git clone --depth 1 ${rpi_git_url}linux.git
319
320 # Compile
321 if [ ! -d "$install" ]; then
322 cd ${kernel}
323 export PATH=$PATH:/cross/${arch}/tools/bin
324 export HOST_SYSTEM=${arch}-slitaz-linux-gnueabi
325 make ARCH=arm bcmrpi_defconfig &&
326 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- zImage &&
327 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- modules &&
328 make ARCH=arm CROSS_COMPILE=${HOST_SYSTEM}- \
329 INSTALL_MOD_PATH=${install} modules_install || exit 1
330 mkdir -p ${install}/boot
331 cp -a arch/arm/boot/zImage ${install}/boot
332 fi
333
334 # Compress modules
335 mods=$(find . -name "*.ko" | wc -l)
336 newline
337 echo "Kernel modules: $mods"
338 #echo -n "Compressing modules: $mods"
339 #find . -name "*.ko" -exec gz '{}' \; 2> /dev/null
340
341 # Pack
342 fs="$data/linux-$kvers/fs"
343 kvers=$(ls ${install}/lib/modules)
344 newline
345 echo "Kernel version: $kvers"
346 if [ -d "$install" ]; then
347 rm -rf ${data}/linux-${kvers}
348 mkdir -p ${data}/linux-${kvers}
349 cp -a ${install} ${fs}
350 rm ${fs}/lib/modules/build ${fs}/lib/modules/source
351 fi
352 get_tools
353 echo "Compressing: zImage to kernel.img"
354 cd ${tools}
355 python imagetool-uncompressed.py ${fs}/boot/zImage
356 cd ${data}
357 mv kernel.img ${fs}/boot && rm ${fs}/boot/zImage
358 echo "Creating package: receipt"
359 cat > linux-$kvers/receipt << EOT
360 # SliTaz package receipt
361
362 PACKAGE="linux"
363 VERSION="$kvers"
364 SHORT_DESC="SliTaz Linux Kernel for the Raspberry Pi."
365 WEB_SITE="http://www.kernel.org"
366
367 EOT
368 tazpkg pack linux-$kvers ;;
369
370 get-fw)
371 get_fw ;;
372
373 get-tools)
374 get_tools ;;
375
376 get-linux)
377 # Precook RPi kernel
378 mkdir -p ${data}
379 rm -f ${data}/linux-version.txt
380
381 # Last version
382 if busybox wget -q -s ${rpi_mirror}/last-linux.txt; then
383 echo -n "Fetching latest Kernel string..."
384 wget -q ${rpi_mirror}/last-linux.txt \
385 -O ${data}/linux-version.txt || exit 1
386 status
387 else
388 echo "Mirror is unreachable" && exit 1
389 fi
390 kvers=$(cat $data/linux-version.txt)
391 [ "$up" ] && rm -rf ${data}/linux-${kvers}*
392 echo "Kernel version: $kvers"
393
394 # Download
395 if [ ! -f "$data/linux-$kvers.tazpkg" ]; then
396 echo -n "Fetching latest Linux package..."
397 wget -q ${rpi_mirror}/linux-${kvers}.tazpkg \
398 -O ${data}/linux-${kvers}.tazpkg; status
399 fi
400
401 # Extract
402 if [ ! -d "$data/linux-$kvers" ]; then
403 cd ${data} && tazpkg extract linux-${kvers}.tazpkg
404 fi
405 rm -f ${data}/linux-version.txt ;;
406
407 get-prebuilt)
408 # --> in cross ??
409 : ${arch=arm}
410 name="slitaz-$arch-toolchain"
411 vers="20140304"
412 tarball="$name-$vers.tar.bz2"
413 url="http://mirror.slitaz.org/packages/cross/"
414 mkdir -p /cross
415 cd /cross
416 if [ ! -f "$tarball" ]; then
417 if busybox wget -qs ${url%/}/${tarball}; then
418 busybox wget ${url%/}/${tarball}
419 else
420 echo "Toolchain URL is unreachable" && exit 1
421 fi
422 fi
423 if [ ! -d "${name}-${vers}" ]; then
424 echo "Extracting: $tarball"
425 tar xjf ${tarball}
426 fi
427 echo "Copying: ${name}-${vers}/${arch}"
428 mkdir -p ${arch}
429 cp -a ${name}-${vers}/${arch}/* ${arch}
430 echo "Tools path: /cross/${arch}/tools/bin" ;;
431
432 clone-fw)
433 clone_fw ;;
434
435 oclock)
436 cat << EOT
437
438 $(boldify "Overclocking modes:")
439 none 700MHz ARM 250MHz core 400MHz SDRAM 0 overvolt
440 modest 800MHz ARM 300MHz core 400MHz SDRAM 0 overvolt
441 medium 900MHz ARM 333MHz core 450MHz SDRAM 2 overvolt
442 high 950MHz ARM 450MHz core 450MHz SDRAM 6 overvolt
443 turbo 1000MHz ARM 500MHz core 500MHz SDRAM 6 overvolt
444
445 EOT
446 if [ -f "$boot/config.txt" ]; then
447 boldify "Current config.txt:"
448 cat ${boot}/config.txt
449 newline
450 fi ;;
451 *) usage ;;
452 esac
453 exit 0