PC端自动烧写脚本，s5pv210-burn-android.sh

jjj

此脚本在ubuntu系统中可以直接烧写镜像update.bin至外部SD卡中，基于xboot的镜像升级系统

脚本如下：

1. #!/bin/sh
   
2. # burn script
   
3. 
   
4. INAND_DEVICE=/dev/sdb
   
5. 
   
6. BURN_DIR=/tmp/burn
   
7. UPDATE_DIR=$BURN_DIR/update
   
8. SYSTEM_DIR=$BURN_DIR/system
   
9. DATA_DIR=$BURN_DIR/data
   
10. CACHE_DIR=$BURN_DIR/cache
    
11. 
    
12. do_setup_environment()
    
13. {
    
14.         mkdir -p $BURN_DIR || { return 1; }
    
15.         mkdir -p $UPDATE_DIR || { return 1; }
    
16.         mkdir -p $SYSTEM_DIR || { return 1; }
    
17.         mkdir -p $DATA_DIR || { return 1; }
    
18.         mkdir -p $CACHE_DIR || { return 1; }
    
19. 
    
20.         umount ${INAND_DEVICE}1;
    
21.         umount ${INAND_DEVICE}2;
    
22.         umount ${INAND_DEVICE}3;
    
23.         umount ${INAND_DEVICE}4;
    
24.         umount ${UPDATE_DIR};
    
25. 
    
26.         sync; sync; sync;
    
27. 
    
28.         return 0;
    
29. }
    
30. 
    
31. do_fdisk_del_partition()
    
32. {
    
33.         [ -z "$1" ] && { return 1; }
    
34.         [ -b $1 ] || { return 1; }
    
35. 
    
36. fdisk $1 << EOF
    
37. d
    
38. 1
    
39. d
    
40. 2
    
41. d
    
42. 3
    
43. d
    
44. 4
    
45. w
    
46. EOF
    
47.        
    
48.         sync;
    
49.         sync;
    
50.         sync;
    
51. 
    
52.         return 0;
    
53. }
    
54. 
    
55. do_fdisk_new_partition()
    
56. {
    
57.         [ -z "$1" ] && { return 1; }
    
58.         [ -b $1 ] || { return 1; }
    
59. 
    
60. fdisk $1 << EOF
    
61. n
    
62. p
    
63. 1
    
64. +256M
    
65. +256M
    
66. n
    
67. p
    
68. 2
    
69. +544M
    
70. +256M
    
71. n
    
72. p
    
73. 3
    
74. +832M
    
75. +256M
    
76. n
    
77. p
    
78. +1120M
    
79. 
    
80. w
    
81. EOF
    
82.        
    
83.         sync;
    
84.         sync;
    
85.         sync;
    
86. 
    
87.         return 0;
    
88. }
    
89. 
    
90. do_mkfs_vfat()
    
91. {
    
92.         [ -z "$1" ] && { return 1; }
    
93. 
    
94.         mkfs.vfat $1 || { return 1; }
    
95.         return 0;
    
96. }
    
97. 
    
98. do_mkfs_ext4()
    
99. {
    
100.         [ -z "$1" ] && { return 1; }
     
101. 
     
102.         mkfs.ext4 -q $1 || { return 1; }
     
103.         return 0;
     
104. }
     
105. 
     
106. do_mount_updatebin()
     
107. {
     
108.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
109.         [ -f $1 ] || { return 1; }
     
110.         [ -d $2 ] || { return 1; }
     
111. 
     
112.         mount -t romfs -o loop $1 $2 || { return 1; }
     
113.         return 0;
     
114. }
     
115. 
     
116. do_umount_updatebin()
     
117. {
     
118.         [ -d $1 ] || { return 1; }
     
119. 
     
120.         umount $1 || { return 1; }
     
121.         return 0;
     
122. }
     
123. 
     
124. do_check_updatebin()
     
125. {
     
126.         [ -d $1 ] || { return 1; }
     
127.         cd $1 || { return 1; }
     
128. 
     
129.         md5sum -c md5sum.txt || { return 1; }
     
130.         return 0;
     
131. }
     
132. 
     
133. do_mount_system()
     
134. {
     
135.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
136.         [ -b $1 ] || { return 1; }
     
137.         [ -d $2 ] || { return 1; }
     
138. 
     
139.         mount -t ext4 $1 $2 || { return 1; }
     
140.         return 0;
     
141. }
     
142. 
     
143. do_umount_system()
     
144. {
     
145.         [ -d $1 ] || { return 1; }
     
146. 
     
147.         umount $1 || { return 1; }
     
148.         return 0;
     
149. }
     
150. 
     
151. do_mount_data()
     
152. {
     
153.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
154.         [ -b $1 ] || { return 1; }
     
155.         [ -d $2 ] || { return 1; }
     
156. 
     
157.         mount -t ext4 $1 $2 || { return 1; }
     
158.         return 0;
     
159. }
     
160. 
     
161. do_umount_data()
     
162. {
     
163.         [ -d $1 ] || { return 1; }
     
164. 
     
165.         umount $1 || { return 1; }
     
166.         return 0;
     
167. }
     
168. 
     
169. do_mount_cache()
     
170. {
     
171.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
172.         [ -b $1 ] || { return 1; }
     
173.         [ -d $2 ] || { return 1; }
     
174. 
     
175.         mount -t ext4 $1 $2 || { return 1; }
     
176.         return 0;
     
177. }
     
178. 
     
179. do_umount_cache()
     
180. {
     
181.         [ -d $1 ] || { return 1; }
     
182. 
     
183.         umount $1 || { return 1; }
     
184.         return 0;
     
185. }
     
186. 
     
187. do_burn_system()
     
188. {
     
189.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
190.         [ -f $1 ] || { return 1; }
     
191.         [ -d $2 ] || { return 1; }
     
192. 
     
193.         rm -fr $2/* || { return 1; }
     
194.         tar xvf $1 -C $2 || { return 1; }
     
195.         return 0;
     
196. }
     
197. 
     
198. do_burn_data()
     
199. {
     
200.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
201.         [ -f $1 ] || { return 1; }
     
202.         [ -d $2 ] || { return 1; }
     
203. 
     
204.         rm -fr $2/* || { return 1; }
     
205.         tar xvf $1 -C $2 || { return 1; }
     
206.         return 0;
     
207. }
     
208. 
     
209. do_burn_xboot()
     
210. {
     
211.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
212.         [ -f $1 ] || { return 1; }
     
213.         [ -b $2 ] || { return 1; }
     
214. 
     
215.         dd if=$1 of=$2 bs=512 seek=1 conv=sync || { return 1; }
     
216.         return 0;
     
217. }
     
218. 
     
219. do_burn_kernel_android()
     
220. {
     
221.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
222.         [ -f $1 ] || { return 1; }
     
223.         [ -b $2 ] || { return 1; }
     
224. 
     
225.         dd if=$1 of=$2 bs=512 seek=40960 conv=sync || { return 1; }
     
226.         return 0;
     
227. }
     
228. 
     
229. do_burn_kernel_initrd()
     
230. {
     
231.         [ -z "$1" -o -z "$2" ] && { return 1; }
     
232.         [ -f $1 ] || { return 1; }
     
233.         [ -b $2 ] || { return 1; }
     
234. 
     
235.         dd if=$1 of=$2 bs=512 seek=81920 conv=sync || { return 1; }
     
236.         return 0;
     
237. }
     
238. 
     
239. do_error()
     
240. {
     
241.         if [ ! -z "$1" ]; then
     
242.                 echo $1;
     
243.         fi
     
244. 
     
245.         sync;
     
246.         exit 0;
     
247. }
     
248. 
     
249. burnxboot=no;
     
250. burnkernel=no;
     
251. burnsystem=no;
     
252. burncache=no;
     
253. burndata=no;
     
254. 
     
255. if [ -z $1 ]; then
     
256.         burnxboot=yes;
     
257.         burnkernel=yes;
     
258.         burnsystem=yes;
     
259.         burncache=yes;
     
260.         burndata=yes;
     
261. fi
     
262. 
     
263. while [ "$1" ]; do
     
264.     case "$1" in
     
265.         -b|--bootloader)
     
266.                 burnxboot=yes;
     
267.             ;;
     
268.         -k|--kernel)
     
269.                 burnkernel=yes;
     
270.             ;;
     
271.         -s|--system)
     
272.                 burnsystem=yes;
     
273.             ;;
     
274.         -d|--data)
     
275.                 burndata=yes;
     
276.             ;;
     
277.         -c|--cache)
     
278.                 burncache=yes;
     
279.             ;;
     
280.         -a|--all)
     
281.                 burnxboot=yes;
     
282.                 burnkernel=yes;
     
283.                 burnsystem=yes;
     
284.                 burncache=yes;
     
285.                 burndata=yes;
     
286.             ;;
     
287.         -h|--help)
     
288.             cat >&2 <<EOF
     
289. Usage: burn [OPTION]
     
290. burn script for burn system image.
     
291. 
     
292.   -b, --bootloader     burn bootloader
     
293.   -k, --kernel         burn kernel
     
294.   -s, --system         burn system
     
295.   -d, --data           burn data
     
296.   -c, --cache          burn cache
     
297.   -a, --all            burn all, include anything
     
298.   -h, --help           display this help and exit
     
299. EOF
     
300.             exit 0
     
301.             ;;
     
302.         *)
     
303.             echo "burn: Unrecognised option $1" >&2
     
304.             exit 1
     
305.             ;;
     
306.     esac
     
307.     shift
     
308. done
     
309. 
     
310. echo "setup environment ..."
     
311. do_setup_environment || { do_error "fail to setup environment"; }
     
312. 
     
313. echo "mount update.bin ..."
     
314. [ -f ./update.bin ] || { echo "update.bin does not exist"; exit 1; }
     
315. do_mount_updatebin ./update.bin ${UPDATE_DIR} || { do_error "fail to mount update.bin"; }
     
316. 
     
317. echo "check update.bin ..."
     
318. do_check_updatebin ${UPDATE_DIR} || { do_error "update.bin not correct"; }
     
319. 
     
320. echo "re-partition inand";
     
321. do_fdisk_del_partition ${INAND_DEVICE} || { do_error "fail to delete partition of inand"; }
     
322. do_fdisk_new_partition ${INAND_DEVICE} || { do_error "fail to create partition of inand"; }
     
323. 
     
324. echo "waiting 3 second ..."
     
325. sleep 3;
     
326. 
     
327. echo "format ${INAND_DEVICE}1 ..."
     
328. do_mkfs_ext4 ${INAND_DEVICE}1 || { do_error "fail to format ${INAND_DEVICE}1"; }
     
329. 
     
330. echo "format ${INAND_DEVICE}2 ..."
     
331. do_mkfs_ext4 ${INAND_DEVICE}2 || { do_error "fail to format ${INAND_DEVICE}2"; }
     
332. 
     
333. echo "format ${INAND_DEVICE}3 ..."
     
334. do_mkfs_ext4 ${INAND_DEVICE}3 || { do_error "fail to format ${INAND_DEVICE}3"; }
     
335. 
     
336. echo "format ${INAND_DEVICE}4 ..."
     
337. do_mkfs_ext4 ${INAND_DEVICE}4 || { do_error "fail to format ${INAND_DEVICE}4"; }
     
338. 
     
339. if [ "${burnxboot}" = yes ]; then
     
340.         echo "write bootloader ...";
     
341.         do_burn_xboot ${UPDATE_DIR}/xboot.bin ${INAND_DEVICE} || { do_error "fail to write bootloader"; }
     
342. fi
     
343. 
     
344. if [ "${burnkernel}" = yes ]; then
     
345.         echo "write kernel ...";
     
346.         do_burn_kernel_android ${UPDATE_DIR}/zImage-android ${INAND_DEVICE} || { do_error "fail to write android kernel"; }
     
347.         do_burn_kernel_initrd ${UPDATE_DIR}/zImage-initrd ${INAND_DEVICE} || { do_error "fail to write initrd kernel"; }
     
348. fi
     
349. 
     
350. if [ "${burnsystem}" = yes ]; then
     
351.         echo "write system ...";
     
352.         do_mount_system ${INAND_DEVICE}2 ${SYSTEM_DIR} || { do_error "fail to mount system"; }
     
353.         do_burn_system ${UPDATE_DIR}/system.tar ${SYSTEM_DIR} || { do_error "fail to write system"; }
     
354.         do_umount_system ${SYSTEM_DIR} || { do_error "fail to umount system"; }
     
355. fi
     
356. 
     
357. if [ "${burncache}" = yes ]; then
     
358.         echo "write cache ...";
     
359.         do_mount_cache ${INAND_DEVICE}3 ${CACHE_DIR} || { do_error "fail to mount cache"; }
     
360.         do_umount_cache ${CACHE_DIR} || { do_error "fail to umount cache"; }
     
361. fi
     
362. 
     
363. if [ "${burndata}" = yes ]; then
     
364.         echo "write data ...";
     
365.         do_mount_data ${INAND_DEVICE}4 ${DATA_DIR} || { do_error "fail to mount data"; }
     
366.         do_burn_data ${UPDATE_DIR}/data.tar ${DATA_DIR} || { do_error "fail to write data"; }
     
367.         do_umount_data ${DATA_DIR} || { do_error "fail to umount data"; }
     
368. fi
     
369. 
     
370. echo "umount some resource ..."
     
371. cd /;
     
372. do_umount_updatebin ${UPDATE_DIR};
     
373. 
     
374. sync; sync; sync;
     
375. do_error "update successed";
     
376. exit 0;
     

复制代码

升级步骤：
1) 将update.bin拷贝至脚本当前目录;
2) 插入待烧写的系统卡，运行命令 sudo ./s5pv210-burn-android.sh -a
3) 等待至烧写完成,可更换另一张系统卡继续烧写;