rockchip: remove boot image
Signed-off-by: sbwml <admin@cooluc.com>
This commit is contained in:
sbwml
parent
13a8d9338f
commit
69350f534b
BIN
files/logo.bmp
BIN
files/logo.bmp
Binary file not shown.
|
Before Width: | Height: | Size: 690 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 690 KiB |
@ -1,313 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# SPDX-License-Identifier: GPL-2.0 */
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from struct import unpack, pack
|
||||
import sys
|
||||
import getopt
|
||||
|
||||
|
||||
class BMPFile:
|
||||
|
||||
def __init__(self, file_path, force_revers=0, force_swap=0):
|
||||
self.file = open(file_path, "rb+")
|
||||
# bmp head 14bit
|
||||
self.bfType = unpack("<h", self.file.read(2))[0]
|
||||
self.bfSize = unpack("<i", self.file.read(4))[0]
|
||||
self.bfReserved1 = unpack("<h", self.file.read(2))[0]
|
||||
self.bfReserved2 = unpack("<h", self.file.read(2))[0]
|
||||
self.bfOffBits = unpack("<i", self.file.read(4))[0]
|
||||
|
||||
self.biSize = unpack("<i", self.file.read(4))[0]
|
||||
self.biWidth = unpack("<i", self.file.read(4))[0]
|
||||
self.biHeight = unpack("<i", self.file.read(4))[0]
|
||||
self.biPlanes = unpack("<h", self.file.read(2))[0]
|
||||
self.biBitCount = unpack("<h", self.file.read(2))[0]
|
||||
# bmp parameter 40 bit normaally
|
||||
self.biCompression = unpack("<i", self.file.read(4))[0]
|
||||
self.biSizeImage = unpack("<i", self.file.read(4))[0]
|
||||
self.biXPixelsPerMeter = unpack("<i", self.file.read(4))[0]
|
||||
self.biYPixelsPerMeter = unpack("<i", self.file.read(4))[0]
|
||||
self.biClrUsed = unpack("<i", self.file.read(4))[0]
|
||||
self.biClrImportant = unpack("<i", self.file.read(4))[0]
|
||||
self.head = []
|
||||
self.color_map = []
|
||||
self.bmp_data = []
|
||||
self.bf_map = []
|
||||
self.force_revers = force_revers
|
||||
self.force_swap = force_swap
|
||||
# some software change parameter size more than 40 bit
|
||||
if self.biSize > 40:
|
||||
self.read_other(self.biSize-40)
|
||||
|
||||
if self.biBitCount == 16 and self.biCompression == 3:
|
||||
for i in range(4):
|
||||
self.bf_map.append(
|
||||
[unpack("<i", self.file.read(4))[0]]
|
||||
)
|
||||
if self.biBitCount == 24:
|
||||
self.get_24bit_data()
|
||||
elif self.biBitCount == 16:
|
||||
if self.biCompression == 3:
|
||||
self.bmp16bit_to_24bit_bf()
|
||||
else:
|
||||
self.bmp16bit_to_24bit()
|
||||
elif self.biBitCount == 8:
|
||||
# Not convert 8bit bmp logo to 24 bit
|
||||
self.file.close()
|
||||
return
|
||||
else:
|
||||
self.bmp32bit_to_24bit()
|
||||
self.rb_swap = 0
|
||||
if self.bfReserved1 != 8399 and self.biHeight > 0:
|
||||
self.reverse_bmp_data()
|
||||
print("reverse data at first time")
|
||||
if self.force_revers:
|
||||
self.reverse_bmp_data()
|
||||
print("reverse data by force")
|
||||
if self.force_swap:
|
||||
self.rb_swap = 1
|
||||
print("swap rb by force'")
|
||||
|
||||
if self.bfReserved1 == 8399:
|
||||
self.file.close()
|
||||
return
|
||||
|
||||
self.write_24bit(self.rb_swap)
|
||||
self.file.close()
|
||||
|
||||
def read_other(self, n):
|
||||
for i in range(n):
|
||||
self.file.read(1)
|
||||
|
||||
def reverse_bmp_data(self):
|
||||
self.bmp_data.reverse()
|
||||
|
||||
@staticmethod
|
||||
def get_16bit_bgr_bf(pixel):
|
||||
red = (pixel[1] & 0xf8) << 0
|
||||
green = ((pixel[1] & 0x07) << 5) | ((pixel[0] & 0xe0) >> 3)
|
||||
blue = ((pixel[0] & 0x1f) << 3)
|
||||
new_pixel = [blue, green, red]
|
||||
return new_pixel
|
||||
|
||||
def bmp32bit_to_24bit(self):
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
# bmp file 4 align
|
||||
count = 0
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
[unpack("<B", self.file.read(1))[0], unpack("<B", self.file.read(1))[0], unpack("<B", self.file.read(1))[0]])
|
||||
self.file.read(1)
|
||||
count = count + 4
|
||||
while count % 4 != 0:
|
||||
self.file.read(1)
|
||||
count = count + 1
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
def bmp16bit_to_24bit_bf(self):
|
||||
self.get_16bit_data()
|
||||
temp_data = self.bmp_data
|
||||
self.bmp_data = []
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
self.get_16bit_bgr_bf(temp_data[height][width])
|
||||
)
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
def bmp8bit_to_24bit_rle(self):
|
||||
bmp_data_row = []
|
||||
data_x = []
|
||||
t_count = 0
|
||||
loop = 1
|
||||
while loop:
|
||||
data1 = unpack("<B", self.file.read(1))[0]
|
||||
if data1 > 0:
|
||||
data2 = unpack("<B", self.file.read(1))[0]
|
||||
for n in range(data1):
|
||||
bmp_data_row.append(self.color_map[data2])
|
||||
if data1 == 0:
|
||||
data2 = unpack("<B", self.file.read(1))[0]
|
||||
if data2 > 2:
|
||||
data_count = data2
|
||||
data_temp = unpack("<B", self.file.read(1))[0]
|
||||
data_x.append(data_temp)
|
||||
while data_temp != 0:
|
||||
data_temp = unpack("<B", self.file.read(1))[0]
|
||||
data_x.append(data_temp)
|
||||
for m in range(data_count):
|
||||
bmp_data_row.append(self.color_map[data_x[m]])
|
||||
if data2 == 2:
|
||||
print("data2 == 2")
|
||||
if data2 == 0:
|
||||
t_count += 1
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
bmp_data_row = []
|
||||
if data2 == 1:
|
||||
print("encode over!")
|
||||
loop = 0
|
||||
|
||||
def bmp8bit_to_24bit(self):
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
count = 0
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
self.color_map[unpack("<B", self.file.read(1))[0]])
|
||||
count = count + 1
|
||||
while count % 4 != 0:
|
||||
self.file.read(1)
|
||||
count = count + 1
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
@staticmethod
|
||||
def get_16bit_bgr(pixel):
|
||||
red = (pixel[1] & 0x7c) << 1
|
||||
green = ((pixel[1] & 0x03) << 6) | ((pixel[0] & 0xe0) >> 2)
|
||||
blue = ((pixel[0] & 0x1f) << 3)
|
||||
new_pixel = [blue, green, red]
|
||||
return new_pixel
|
||||
|
||||
def bmp16bit_to_24bit(self):
|
||||
self.get_16bit_data()
|
||||
temp_data = self.bmp_data
|
||||
self.bmp_data = []
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
self.get_16bit_bgr(temp_data[height][width])
|
||||
)
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
def get_head(self):
|
||||
self.file.seek(0, 0)
|
||||
for i in range(54):
|
||||
self.head.append(unpack("<B", self.file.read(1))[0])
|
||||
return self.head
|
||||
|
||||
def get_16bit_data(self):
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
count = 0
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
[unpack("<B", self.file.read(1))[0], unpack("<B", self.file.read(1))[0]])
|
||||
count = count + 2
|
||||
while count % 4 != 0:
|
||||
self.file.read(1)
|
||||
count = count + 1
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
def get_24bit_data(self):
|
||||
for height in range(abs(self.biHeight)):
|
||||
bmp_data_row = []
|
||||
count = 0
|
||||
for width in range(self.biWidth):
|
||||
bmp_data_row.append(
|
||||
[unpack("<B", self.file.read(1))[0], unpack("<B", self.file.read(1))[0], unpack("<B", self.file.read(1))[0]])
|
||||
count = count + 3
|
||||
while count % 4 != 0:
|
||||
self.file.read(1)
|
||||
count = count + 1
|
||||
self.bmp_data.append(bmp_data_row)
|
||||
|
||||
def write_24bit(self,rb_swap):
|
||||
self.file.seek(0, 0)
|
||||
self.write_head_24bit()
|
||||
self.write_data_24bit(rb_swap)
|
||||
|
||||
def write_head(self):
|
||||
self.file.write(pack("<h", self.bfType))
|
||||
self.file.write(pack("<i", self.bfSize))
|
||||
self.file.write(pack("<h", self.bfReserved1))
|
||||
self.file.write(pack("<h", self.bfReserved2))
|
||||
self.file.write(pack("<i", self.bfOffBits)) # bfOffBits
|
||||
self.file.write(pack("<i", self.biSize)) # biSize
|
||||
self.file.write(pack("<i", self.biWidth))
|
||||
|
||||
self.file.write(pack("<i", self.biHeight))
|
||||
self.file.write(pack("<h", self.biPlanes))
|
||||
self.file.write(pack("<h", self.biBitCount)) # biBitCount
|
||||
self.file.write(pack("<i", self.biCompression)) # biCompression
|
||||
self.file.write(pack("<i", self.biSizeImage)) # biSizeImage
|
||||
self.file.write(pack("<i", self.biXPixelsPerMeter)) # biXPixelsPerMeter
|
||||
self.file.write(pack("<i", self.biYPixelsPerMeter)) # biYPixelsPerMeter
|
||||
self.file.write(pack("<i", self.biClrUsed)) # biClrUsed
|
||||
self.file.write(pack("<i", self.biClrImportant)) # biClrImportant try to mark whether is reversed
|
||||
|
||||
def write_head_24bit(self):
|
||||
temp_bi_width = self.biWidth * 3
|
||||
while temp_bi_width % 4 != 0:
|
||||
temp_bi_width = temp_bi_width + 1
|
||||
new_bf_size = temp_bi_width * abs(self.biHeight) + 54
|
||||
self.file.write(pack("<h", self.bfType))
|
||||
self.file.write(pack("<i", new_bf_size))
|
||||
self.file.write(pack("<h", 8399)) # a mark for uboot dealing
|
||||
self.file.write(pack("<h", self.bfReserved2))
|
||||
self.file.write(pack("<i", 54)) # bfOffBits
|
||||
self.file.write(pack("<i", 40)) # biSize
|
||||
self.file.write(pack("<i", self.biWidth))
|
||||
# force height to negative let logo show normal in windows
|
||||
# the uboot code can deal with negative height
|
||||
if self.biHeight < 0:
|
||||
self.file.write(pack("<i", self.biHeight))
|
||||
else:
|
||||
self.file.write(pack("<i", self.biHeight * -1))
|
||||
self.file.write(pack("<h", self.biPlanes))
|
||||
self.file.write(pack("<h", 24)) # biBitCount
|
||||
self.file.write(pack("<i", 0)) # biCompression
|
||||
self.file.write(pack("<i", 0)) # biSizeImage
|
||||
self.file.write(pack("<i", 0)) # biXPixelsPerMeter
|
||||
self.file.write(pack("<i", 0)) # biYPixelsPerMeter
|
||||
self.file.write(pack("<i", 0)) # biClrUsed
|
||||
self.file.write(pack("<i", 0)) # biClrImportant try to mark whether is reversed
|
||||
|
||||
def write_data_24bit(self, rb_swap):
|
||||
for hg in range(abs(self.biHeight)):
|
||||
count = 0
|
||||
for wd in range(self.biWidth):
|
||||
if rb_swap:
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][2]))
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][1]))
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][0]))
|
||||
else:
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][0]))
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][1]))
|
||||
self.file.write(pack("<B", self.bmp_data[hg][wd][2]))
|
||||
count = count + 3
|
||||
while count % 4 != 0:
|
||||
self.file.write(pack("<B", 0))
|
||||
count = count + 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
swap = 0
|
||||
revers = 0
|
||||
par = len(sys.argv[1:])
|
||||
if par == 1:
|
||||
bmp = BMPFile(sys.argv[1])
|
||||
elif par == 0:
|
||||
print("This program is trying to convert different format of bmpfile to a same format"
|
||||
"to make vop can handle bmpfile easily")
|
||||
print("try such cmd to make it work python bmpconvert xxx/xxx.bmp")
|
||||
else:
|
||||
try:
|
||||
opts, args = getopt.getopt(sys.argv[2:], "hrs", ["help", "reverse", "swap"])
|
||||
for opt, arg in opts:
|
||||
|
||||
if opt in ('-h','--help'):
|
||||
print("add -r option will force program to reverse data")
|
||||
print("add -s option will force program to swap data of rb")
|
||||
if opt in ("-r", "--reverse"):
|
||||
revers = 1
|
||||
if opt in ("-s", "--swap"):
|
||||
swap = 1
|
||||
bmp = BMPFile(sys.argv[1], revers, swap)
|
||||
except getopt.GetoptError:
|
||||
sys.exit(1)
|
||||
|
||||
@ -1,316 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# Copyright 2015, The Android Open Source Project
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
from argparse import ArgumentParser, FileType, Action
|
||||
from hashlib import sha1
|
||||
from os import fstat
|
||||
import re
|
||||
from struct import pack
|
||||
|
||||
|
||||
BOOT_IMAGE_HEADER_V3_PAGESIZE = 4096
|
||||
|
||||
def filesize(f):
|
||||
if f is None:
|
||||
return 0
|
||||
try:
|
||||
return fstat(f.fileno()).st_size
|
||||
except OSError:
|
||||
return 0
|
||||
|
||||
|
||||
def update_sha(sha, f):
|
||||
if f:
|
||||
sha.update(f.read())
|
||||
f.seek(0)
|
||||
sha.update(pack('I', filesize(f)))
|
||||
else:
|
||||
sha.update(pack('I', 0))
|
||||
|
||||
|
||||
def pad_file(f, padding):
|
||||
pad = (padding - (f.tell() & (padding - 1))) & (padding - 1)
|
||||
f.write(pack(str(pad) + 'x'))
|
||||
|
||||
|
||||
def get_number_of_pages(image_size, page_size):
|
||||
"""calculates the number of pages required for the image"""
|
||||
return (image_size + page_size - 1) / page_size
|
||||
|
||||
|
||||
def get_recovery_dtbo_offset(args):
|
||||
"""calculates the offset of recovery_dtbo image in the boot image"""
|
||||
num_header_pages = 1 # header occupies a page
|
||||
num_kernel_pages = get_number_of_pages(filesize(args.kernel), args.pagesize)
|
||||
num_ramdisk_pages = get_number_of_pages(filesize(args.ramdisk), args.pagesize)
|
||||
num_second_pages = get_number_of_pages(filesize(args.second), args.pagesize)
|
||||
dtbo_offset = args.pagesize * (num_header_pages + num_kernel_pages +
|
||||
num_ramdisk_pages + num_second_pages)
|
||||
return dtbo_offset
|
||||
|
||||
|
||||
def write_header_v3(args):
|
||||
BOOT_IMAGE_HEADER_V3_SIZE = 1580
|
||||
BOOT_MAGIC = 'ANDROID!'.encode()
|
||||
|
||||
args.output.write(pack('8s', BOOT_MAGIC))
|
||||
args.output.write(pack(
|
||||
'4I',
|
||||
filesize(args.kernel), # kernel size in bytes
|
||||
filesize(args.ramdisk), # ramdisk size in bytes
|
||||
(args.os_version << 11) | args.os_patch_level, # os version and patch level
|
||||
BOOT_IMAGE_HEADER_V3_SIZE))
|
||||
|
||||
args.output.write(pack('4I', 0, 0, 0, 0)) # reserved
|
||||
|
||||
args.output.write(pack('I', args.header_version)) # version of bootimage header
|
||||
args.output.write(pack('1536s', args.cmdline.encode()))
|
||||
pad_file(args.output, BOOT_IMAGE_HEADER_V3_PAGESIZE)
|
||||
|
||||
def write_vendor_boot_header(args):
|
||||
VENDOR_BOOT_IMAGE_HEADER_V3_SIZE = 2112
|
||||
BOOT_MAGIC = 'VNDRBOOT'.encode()
|
||||
|
||||
args.vendor_boot.write(pack('8s', BOOT_MAGIC))
|
||||
args.vendor_boot.write(pack(
|
||||
'5I',
|
||||
args.header_version, # version of header
|
||||
args.pagesize, # flash page size we assume
|
||||
args.base + args.kernel_offset, # kernel physical load addr
|
||||
args.base + args.ramdisk_offset, # ramdisk physical load addr
|
||||
filesize(args.vendor_ramdisk))) # vendor ramdisk size in bytes
|
||||
args.vendor_boot.write(pack('2048s', args.vendor_cmdline.encode()))
|
||||
args.vendor_boot.write(pack('I', args.base + args.tags_offset)) # physical addr for kernel tags
|
||||
args.vendor_boot.write(pack('16s', args.board.encode())) # asciiz product name
|
||||
args.vendor_boot.write(pack('I', VENDOR_BOOT_IMAGE_HEADER_V3_SIZE)) # header size in bytes
|
||||
if filesize(args.dtb) == 0:
|
||||
raise ValueError("DTB image must not be empty.")
|
||||
args.vendor_boot.write(pack('I', filesize(args.dtb))) # size in bytes
|
||||
args.vendor_boot.write(pack('Q', args.base + args.dtb_offset)) # dtb physical load address
|
||||
pad_file(args.vendor_boot, args.pagesize)
|
||||
|
||||
def write_header(args):
|
||||
BOOT_IMAGE_HEADER_V1_SIZE = 1648
|
||||
BOOT_IMAGE_HEADER_V2_SIZE = 1660
|
||||
BOOT_MAGIC = 'ANDROID!'.encode()
|
||||
|
||||
if args.header_version > 3:
|
||||
raise ValueError('Boot header version %d not supported' % args.header_version)
|
||||
elif args.header_version == 3:
|
||||
return write_header_v3(args)
|
||||
|
||||
args.output.write(pack('8s', BOOT_MAGIC))
|
||||
final_ramdisk_offset = (args.base + args.ramdisk_offset) if filesize(args.ramdisk) > 0 else 0
|
||||
final_second_offset = (args.base + args.second_offset) if filesize(args.second) > 0 else 0
|
||||
args.output.write(pack(
|
||||
'10I',
|
||||
filesize(args.kernel), # size in bytes
|
||||
args.base + args.kernel_offset, # physical load addr
|
||||
filesize(args.ramdisk), # size in bytes
|
||||
final_ramdisk_offset, # physical load addr
|
||||
filesize(args.second), # size in bytes
|
||||
final_second_offset, # physical load addr
|
||||
args.base + args.tags_offset, # physical addr for kernel tags
|
||||
args.pagesize, # flash page size we assume
|
||||
args.header_version, # version of bootimage header
|
||||
(args.os_version << 11) | args.os_patch_level)) # os version and patch level
|
||||
args.output.write(pack('16s', args.board.encode())) # asciiz product name
|
||||
args.output.write(pack('512s', args.cmdline[:512].encode()))
|
||||
|
||||
sha = sha1()
|
||||
update_sha(sha, args.kernel)
|
||||
update_sha(sha, args.ramdisk)
|
||||
update_sha(sha, args.second)
|
||||
|
||||
if args.header_version > 0:
|
||||
update_sha(sha, args.recovery_dtbo)
|
||||
if args.header_version > 1:
|
||||
update_sha(sha, args.dtb)
|
||||
|
||||
img_id = pack('32s', sha.digest())
|
||||
|
||||
args.output.write(img_id)
|
||||
args.output.write(pack('1024s', args.cmdline[512:].encode()))
|
||||
|
||||
if args.header_version > 0:
|
||||
args.output.write(pack('I', filesize(args.recovery_dtbo))) # size in bytes
|
||||
if args.recovery_dtbo:
|
||||
args.output.write(pack('Q', get_recovery_dtbo_offset(args))) # recovery dtbo offset
|
||||
else:
|
||||
args.output.write(pack('Q', 0)) # Will be set to 0 for devices without a recovery dtbo
|
||||
|
||||
# Populate boot image header size for header versions 1 and 2.
|
||||
if args.header_version == 1:
|
||||
args.output.write(pack('I', BOOT_IMAGE_HEADER_V1_SIZE))
|
||||
elif args.header_version == 2:
|
||||
args.output.write(pack('I', BOOT_IMAGE_HEADER_V2_SIZE))
|
||||
|
||||
if args.header_version > 1:
|
||||
|
||||
# if filesize(args.dtb) == 0:
|
||||
# raise ValueError("DTB image must not be empty.")
|
||||
|
||||
args.output.write(pack('I', filesize(args.dtb))) # size in bytes
|
||||
args.output.write(pack('Q', args.base + args.dtb_offset)) # dtb physical load address
|
||||
pad_file(args.output, args.pagesize)
|
||||
return img_id
|
||||
|
||||
|
||||
class ValidateStrLenAction(Action):
|
||||
def __init__(self, option_strings, dest, nargs=None, **kwargs):
|
||||
if 'maxlen' not in kwargs:
|
||||
raise ValueError('maxlen must be set')
|
||||
self.maxlen = int(kwargs['maxlen'])
|
||||
del kwargs['maxlen']
|
||||
super(ValidateStrLenAction, self).__init__(option_strings, dest, **kwargs)
|
||||
|
||||
def __call__(self, parser, namespace, values, option_string=None):
|
||||
if len(values) > self.maxlen:
|
||||
raise ValueError(
|
||||
'String argument too long: max {0:d}, got {1:d}'.format(self.maxlen, len(values)))
|
||||
setattr(namespace, self.dest, values)
|
||||
|
||||
|
||||
def write_padded_file(f_out, f_in, padding):
|
||||
if f_in is None:
|
||||
return
|
||||
f_out.write(f_in.read())
|
||||
pad_file(f_out, padding)
|
||||
|
||||
|
||||
def parse_int(x):
|
||||
return int(x, 0)
|
||||
|
||||
|
||||
def parse_os_version(x):
|
||||
match = re.search(r'^(\d{1,3})(?:\.(\d{1,3})(?:\.(\d{1,3}))?)?', x)
|
||||
if match:
|
||||
a = int(match.group(1))
|
||||
b = c = 0
|
||||
if match.lastindex >= 2:
|
||||
b = int(match.group(2))
|
||||
if match.lastindex == 3:
|
||||
c = int(match.group(3))
|
||||
# 7 bits allocated for each field
|
||||
assert a < 128
|
||||
assert b < 128
|
||||
assert c < 128
|
||||
return (a << 14) | (b << 7) | c
|
||||
return 0
|
||||
|
||||
|
||||
def parse_os_patch_level(x):
|
||||
match = re.search(r'^(\d{4})-(\d{2})(?:-(\d{2}))?', x)
|
||||
if match:
|
||||
y = int(match.group(1)) - 2000
|
||||
m = int(match.group(2))
|
||||
# 7 bits allocated for the year, 4 bits for the month
|
||||
assert 0 <= y < 128
|
||||
assert 0 < m <= 12
|
||||
return (y << 4) | m
|
||||
return 0
|
||||
|
||||
|
||||
def parse_cmdline():
|
||||
parser = ArgumentParser()
|
||||
parser.add_argument('--kernel', help='path to the kernel', type=FileType('rb'))
|
||||
parser.add_argument('--ramdisk', help='path to the ramdisk', type=FileType('rb'))
|
||||
parser.add_argument('--second', help='path to the 2nd bootloader', type=FileType('rb'))
|
||||
parser.add_argument('--dtb', help='path to dtb', type=FileType('rb'))
|
||||
recovery_dtbo_group = parser.add_mutually_exclusive_group()
|
||||
recovery_dtbo_group.add_argument('--recovery_dtbo', help='path to the recovery DTBO',
|
||||
type=FileType('rb'))
|
||||
recovery_dtbo_group.add_argument('--recovery_acpio', help='path to the recovery ACPIO',
|
||||
type=FileType('rb'), metavar='RECOVERY_ACPIO',
|
||||
dest='recovery_dtbo')
|
||||
parser.add_argument('--cmdline', help='extra arguments to be passed on the '
|
||||
'kernel command line', default='', action=ValidateStrLenAction, maxlen=1536)
|
||||
parser.add_argument('--vendor_cmdline',
|
||||
help='kernel command line arguments contained in vendor boot',
|
||||
default='', action=ValidateStrLenAction, maxlen=2048)
|
||||
parser.add_argument('--base', help='base address', type=parse_int, default=0x10000000)
|
||||
parser.add_argument('--kernel_offset', help='kernel offset', type=parse_int, default=0x00008000)
|
||||
parser.add_argument('--ramdisk_offset', help='ramdisk offset', type=parse_int,
|
||||
default=0x01000000)
|
||||
parser.add_argument('--second_offset', help='2nd bootloader offset', type=parse_int,
|
||||
default=0x00f00000)
|
||||
parser.add_argument('--dtb_offset', help='dtb offset', type=parse_int, default=0x01f00000)
|
||||
|
||||
parser.add_argument('--os_version', help='operating system version', type=parse_os_version,
|
||||
default=0)
|
||||
parser.add_argument('--os_patch_level', help='operating system patch level',
|
||||
type=parse_os_patch_level, default=0)
|
||||
parser.add_argument('--tags_offset', help='tags offset', type=parse_int, default=0x00000100)
|
||||
parser.add_argument('--board', help='board name', default='', action=ValidateStrLenAction,
|
||||
maxlen=16)
|
||||
parser.add_argument('--pagesize', help='page size', type=parse_int,
|
||||
choices=[2**i for i in range(11, 15)], default=2048)
|
||||
parser.add_argument('--id', help='print the image ID on standard output',
|
||||
action='store_true')
|
||||
parser.add_argument('--header_version', help='boot image header version', type=parse_int,
|
||||
default=0)
|
||||
parser.add_argument('-o', '--output', help='output file name', type=FileType('wb'))
|
||||
parser.add_argument('--vendor_boot', help='vendor boot output file name', type=FileType('wb'))
|
||||
parser.add_argument('--vendor_ramdisk', help='path to the vendor ramdisk', type=FileType('rb'))
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def write_data(args, pagesize):
|
||||
write_padded_file(args.output, args.kernel, pagesize)
|
||||
write_padded_file(args.output, args.ramdisk, pagesize)
|
||||
write_padded_file(args.output, args.second, pagesize)
|
||||
|
||||
if args.header_version > 0 and args.header_version < 3:
|
||||
write_padded_file(args.output, args.recovery_dtbo, pagesize)
|
||||
if args.header_version == 2:
|
||||
write_padded_file(args.output, args.dtb, pagesize)
|
||||
|
||||
|
||||
def write_vendor_boot_data(args):
|
||||
write_padded_file(args.vendor_boot, args.vendor_ramdisk, args.pagesize)
|
||||
write_padded_file(args.vendor_boot, args.dtb, args.pagesize)
|
||||
|
||||
|
||||
def main():
|
||||
args = parse_cmdline()
|
||||
if args.vendor_boot is not None:
|
||||
if args.header_version < 3:
|
||||
raise ValueError('--vendor_boot not compatible with given header version')
|
||||
if args.vendor_ramdisk is None:
|
||||
raise ValueError('--vendor_ramdisk missing or invalid')
|
||||
write_vendor_boot_header(args)
|
||||
write_vendor_boot_data(args)
|
||||
if args.output is not None:
|
||||
if args.kernel is None:
|
||||
raise ValueError('kernel must be supplied when creating a boot image')
|
||||
if args.second is not None and args.header_version > 2:
|
||||
raise ValueError('--second not compatible with given header version')
|
||||
img_id = write_header(args)
|
||||
if args.header_version > 2:
|
||||
write_data(args, BOOT_IMAGE_HEADER_V3_PAGESIZE)
|
||||
else:
|
||||
write_data(args, args.pagesize)
|
||||
if args.id and img_id is not None:
|
||||
# Python 2's struct.pack returns a string, but py3 returns bytes.
|
||||
if isinstance(img_id, str):
|
||||
img_id = [ord(x) for x in img_id]
|
||||
print('0x' + ''.join('{:02x}'.format(c) for c in img_id))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@ -1,263 +0,0 @@
|
||||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
# Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd.
|
||||
|
||||
set -e
|
||||
|
||||
usage() {
|
||||
cat >&2 << USAGE
|
||||
usage: $0 [-h] --dtb DTB
|
||||
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--dtb DTB the dtb file name
|
||||
USAGE
|
||||
}
|
||||
|
||||
# Parse command-line arguments
|
||||
while [ $# -gt 0 ]; do
|
||||
case $1 in
|
||||
--dtb)
|
||||
DTB=$2
|
||||
shift 2
|
||||
;;
|
||||
--keep-dtb-name)
|
||||
DTB_ARGS="--dtbname"; shift 1;;
|
||||
-h)
|
||||
usage
|
||||
exit 0
|
||||
;;
|
||||
--help)
|
||||
usage
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
shift
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
srctree=${srctree-"."}
|
||||
objtree=${objtree-"."}
|
||||
if [ "${ARCH}" == "" ]; then
|
||||
if [ "$($srctree/scripts/config --state CONFIG_ARM)" == "y" ]; then
|
||||
ARCH=arm
|
||||
else
|
||||
ARCH=arm64
|
||||
fi
|
||||
fi
|
||||
|
||||
LOGO_PATH=${srctree}/logo.bmp
|
||||
[ -f ${LOGO_PATH} ] && LOGO=logo.bmp
|
||||
|
||||
LOGO_KERNEL_PATH=${srctree}/logo_kernel.bmp
|
||||
[ -f ${LOGO_KERNEL_PATH} ] && LOGO_KERNEL=logo_kernel.bmp
|
||||
|
||||
KERNEL_IMAGE_PATH=${objtree}/arch/${ARCH}/boot/Image
|
||||
KERNEL_IMAGE_ARG="--kernel ${KERNEL_IMAGE_PATH}"
|
||||
if [ "${ARCH}" == "arm" ]; then
|
||||
DTB_PATH=${objtree}/arch/arm/boot/dts/${DTB}
|
||||
ZIMAGE=zImage
|
||||
else
|
||||
DTB_PATH=${objtree}/arch/arm64/boot/dts/rockchip/${DTB}
|
||||
ZIMAGE=Image.lz4
|
||||
fi
|
||||
KERNEL_ZIMAGE_PATH=${objtree}/arch/${ARCH}/boot/${ZIMAGE}
|
||||
KERNEL_ZIMAGE_ARG="--kernel ${KERNEL_ZIMAGE_PATH}"
|
||||
if ! find ${DTB_PATH} >/dev/null; then
|
||||
echo "No dtb" >&2
|
||||
usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
OUT=out
|
||||
ITB=${BOOT_IMG}
|
||||
ITS=${OUT}/boot.its
|
||||
MKIMAGE=${MKIMAGE-"mkimage"}
|
||||
MKIMAGE_ARG="-E -p 0x800"
|
||||
|
||||
make_boot_img()
|
||||
{
|
||||
RAMDISK_IMG_PATH=${objtree}/ramdisk.img
|
||||
[ -f ${RAMDISK_IMG_PATH} ] && RAMDISK_IMG=ramdisk.img && RAMDISK_ARG="--ramdisk ${RAMDISK_IMG_PATH}"
|
||||
|
||||
${srctree}/scripts/mkbootimg \
|
||||
${KERNEL_IMAGE_ARG} \
|
||||
${RAMDISK_ARG} \
|
||||
--second resource.img \
|
||||
-o boot.img && \
|
||||
echo " Image: boot.img (with Image ${RAMDISK_IMG} resource.img) is ready";
|
||||
[ -f ${KERNEL_ZIMAGE_PATH} ] || return 0
|
||||
${srctree}/scripts/mkbootimg \
|
||||
${KERNEL_ZIMAGE_ARG} \
|
||||
${RAMDISK_ARG} \
|
||||
--second resource.img \
|
||||
-o zboot.img && \
|
||||
echo " Image: zboot.img (with ${ZIMAGE} ${RAMDISK_IMG} resource.img) is ready"
|
||||
}
|
||||
|
||||
repack_boot_img()
|
||||
{
|
||||
${srctree}/scripts/repack-bootimg \
|
||||
--boot_img ${BOOT_IMG} --out ${OUT} \
|
||||
${KERNEL_IMAGE_ARG} \
|
||||
--second resource.img \
|
||||
--dtb ${DTB_PATH} \
|
||||
-o boot.img &&
|
||||
echo " Image: boot.img (${BOOT_IMG} + Image) is ready";
|
||||
${srctree}/scripts/repack-bootimg \
|
||||
--boot_img ${BOOT_IMG} --out ${OUT} \
|
||||
${KERNEL_ZIMAGE_ARG} \
|
||||
--second resource.img \
|
||||
--dtb ${DTB_PATH} \
|
||||
-o zboot.img && \
|
||||
echo " Image: zboot.img (${BOOT_IMG} + ${ZIMAGE}) is ready"
|
||||
}
|
||||
|
||||
check_mkimage()
|
||||
{
|
||||
MKIMAGE=$(type -p ${MKIMAGE} || true)
|
||||
if [ -z "${MKIMAGE}" ]; then
|
||||
# Doesn't exist
|
||||
echo '"mkimage" command not found - U-Boot images will not be built' >&2
|
||||
exit 1;
|
||||
fi
|
||||
}
|
||||
|
||||
unpack_itb()
|
||||
{
|
||||
rm -rf ${OUT}
|
||||
mkdir -p ${OUT}
|
||||
|
||||
for NAME in $(fdtget -l ${ITB} /images)
|
||||
do
|
||||
# generate image
|
||||
NODE="/images/${NAME}"
|
||||
OFFS=$(fdtget -ti ${ITB} ${NODE} data-position)
|
||||
SIZE=$(fdtget -ti ${ITB} ${NODE} data-size)
|
||||
if [ -z ${OFFS} ]; then
|
||||
continue;
|
||||
fi
|
||||
|
||||
if [ ${SIZE} -ne 0 ]; then
|
||||
dd if=${ITB} of=${OUT}/${NAME} bs=${SIZE} count=1 skip=${OFFS} iflag=skip_bytes >/dev/null 2>&1
|
||||
else
|
||||
touch ${OUT}/${NAME}
|
||||
fi
|
||||
done
|
||||
|
||||
[ ! -f ${OUT}/kernel ] && echo "FIT ${ITB} no kernel" >&2 && exit 1 || true
|
||||
}
|
||||
|
||||
gen_its()
|
||||
{
|
||||
TMP_ITB=${OUT}/boot.tmp
|
||||
|
||||
# add placeholder
|
||||
cp ${ITB} ${TMP_ITB}
|
||||
for NAME in $(fdtget -l ${ITB} /images); do
|
||||
fdtput -t s ${TMP_ITB} /images/${NAME} data "/INCBIN/(${NAME})"
|
||||
done
|
||||
dtc -I dtb -O dts ${TMP_ITB} -o ${ITS} >/dev/null 2>&1
|
||||
rm -f ${TMP_ITB}
|
||||
|
||||
# fixup placeholder: data = "/INCBIN/(...)"; -> data = /incbin/("...");
|
||||
sed -i "s/\"\/INCBIN\/(\(.*\))\"/\/incbin\/(\"\1\")/" ${ITS}
|
||||
|
||||
# remove
|
||||
sed -i "/memreserve/d" ${ITS}
|
||||
sed -i "/timestamp/d" ${ITS}
|
||||
sed -i "/data-size/d" ${ITS}
|
||||
sed -i "/data-position/d" ${ITS}
|
||||
sed -i "/value/d" ${ITS}
|
||||
sed -i "/hashed-strings/d" ${ITS}
|
||||
sed -i "/hashed-nodes/d" ${ITS}
|
||||
sed -i "/signer-version/d" ${ITS}
|
||||
sed -i "/signer-name/d" ${ITS}
|
||||
}
|
||||
|
||||
gen_itb()
|
||||
{
|
||||
[ -f ${OUT}/fdt ] && cp -a ${DTB_PATH} ${OUT}/fdt && FDT=" + ${DTB}"
|
||||
[ -f ${OUT}/resource ] && cp -a resource.img ${OUT}/resource && RESOURCE=" + resource.img"
|
||||
COMP=$(fdtget ${ITB} /images/kernel compression)
|
||||
case "${COMP}" in
|
||||
gzip) EXT=".gz";;
|
||||
lz4) EXT=".lz4";;
|
||||
bzip2) EXT=".bz2";;
|
||||
lzma) EXT=".lzma";;
|
||||
lzo) EXT=".lzo";;
|
||||
esac
|
||||
cp -a ${KERNEL_IMAGE_PATH}${EXT} ${OUT}/kernel && \
|
||||
${MKIMAGE} ${MKIMAGE_ARG} -f ${ITS} boot.img >/dev/null && \
|
||||
echo " Image: boot.img (FIT ${BOOT_IMG} + Image${EXT}${FDT}${RESOURCE}) is ready";
|
||||
if [ "${EXT}" == "" ] && [ -f ${KERNEL_ZIMAGE_PATH} ]; then
|
||||
cp -a ${KERNEL_ZIMAGE_PATH} ${OUT}/kernel && \
|
||||
${MKIMAGE} ${MKIMAGE_ARG} -f ${ITS} zboot.img >/dev/null && \
|
||||
echo " Image: zboot.img (FIT ${BOOT_IMG} + zImage${FDT}${RESOURCE}) is ready";
|
||||
fi
|
||||
}
|
||||
|
||||
repack_itb()
|
||||
{
|
||||
check_mkimage
|
||||
unpack_itb
|
||||
gen_its
|
||||
gen_itb
|
||||
}
|
||||
|
||||
# Create U-Boot FIT Image use ${BOOT_ITS}
|
||||
make_fit_boot_img()
|
||||
{
|
||||
ITS=${OUT}/boot.its
|
||||
|
||||
check_mkimage
|
||||
mkdir -p ${OUT}
|
||||
rm -f ${OUT}/fdt ${OUT}/kernel ${OUT}/resource ${ITS}
|
||||
|
||||
cp -a ${BOOT_ITS} ${ITS}
|
||||
cp -a ${DTB_PATH} ${OUT}/fdt
|
||||
cp -a ${KERNEL_ZIMAGE_PATH} ${OUT}/kernel
|
||||
cp -a resource.img ${OUT}/resource
|
||||
|
||||
if [ "${ARCH}" == "arm64" ]; then
|
||||
sed -i -e 's/arch = ""/arch = "arm64"/g' -e 's/compression = ""/compression = "lz4"/' ${ITS}
|
||||
else
|
||||
sed -i -e 's/arch = ""/arch = "arm"/g' -e 's/compression = ""/compression = "none"/' ${ITS}
|
||||
fi
|
||||
FIT_DESC=$(${MKIMAGE} ${MKIMAGE_ARG} -f ${ITS} boot.img | grep "FIT description" | sed 's/FIT description: //')
|
||||
echo " Image: boot.img (${FIT_DESC}) is ready";
|
||||
}
|
||||
|
||||
if [ -x ${srctree}/scripts/bmpconvert ]; then
|
||||
if [ -f ${LOGO_PATH} ]; then
|
||||
${srctree}/scripts/bmpconvert ${LOGO_PATH};
|
||||
fi
|
||||
if [ -f ${LOGO_KERNEL_PATH} ]; then
|
||||
${srctree}/scripts/bmpconvert ${LOGO_KERNEL_PATH};
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "${srctree}" != "${objtree}" ]; then
|
||||
if [ -f ${LOGO_PATH} ]; then
|
||||
cp -a ${LOGO_PATH} ${objtree}/;
|
||||
fi
|
||||
if [ -f ${LOGO_KERNEL_PATH} ]; then
|
||||
cp -a ${LOGO_KERNEL_PATH} ${objtree}/;
|
||||
fi
|
||||
fi
|
||||
|
||||
scripts/resource_tool ${DTB_ARGS} ${DTB_PATH} ${LOGO} ${LOGO_KERNEL} >/dev/null
|
||||
echo " Image: resource.img (with ${DTB} ${LOGO} ${LOGO_KERNEL}) is ready"
|
||||
|
||||
if [ -f "${BOOT_IMG}" ]; then
|
||||
if file -L -p -b ${BOOT_IMG} | grep -q 'Device Tree Blob' ; then
|
||||
repack_itb;
|
||||
elif [ -x ${srctree}/scripts/repack-bootimg ]; then
|
||||
repack_boot_img;
|
||||
fi
|
||||
elif [ -f "${BOOT_ITS}" ]; then
|
||||
make_fit_boot_img;
|
||||
elif [ -x ${srctree}/scripts/mkbootimg ]; then
|
||||
make_boot_img;
|
||||
fi
|
||||
@ -1,159 +0,0 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* (C) Copyright Fuzhou Rockchip Electronics Co., Ltd
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
//#define DEBUG
|
||||
#ifdef DEBUG
|
||||
#define PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
static inline __attribute__ ((format(printf, 1, 2)))
|
||||
int PRINTF(const char *fmt, ...)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static uint32_t gTable_Crc32[256] = {
|
||||
0x00000000, 0x04c10db7, 0x09821b6e, 0x0d4316d9,
|
||||
0x130436dc, 0x17c53b6b, 0x1a862db2, 0x1e472005,
|
||||
0x26086db8, 0x22c9600f, 0x2f8a76d6, 0x2b4b7b61,
|
||||
0x350c5b64, 0x31cd56d3, 0x3c8e400a, 0x384f4dbd,
|
||||
0x4c10db70, 0x48d1d6c7, 0x4592c01e, 0x4153cda9,
|
||||
0x5f14edac, 0x5bd5e01b, 0x5696f6c2, 0x5257fb75,
|
||||
0x6a18b6c8, 0x6ed9bb7f, 0x639aada6, 0x675ba011,
|
||||
0x791c8014, 0x7ddd8da3, 0x709e9b7a, 0x745f96cd,
|
||||
0x9821b6e0, 0x9ce0bb57, 0x91a3ad8e, 0x9562a039,
|
||||
0x8b25803c, 0x8fe48d8b, 0x82a79b52, 0x866696e5,
|
||||
0xbe29db58, 0xbae8d6ef, 0xb7abc036, 0xb36acd81,
|
||||
0xad2ded84, 0xa9ece033, 0xa4aff6ea, 0xa06efb5d,
|
||||
0xd4316d90, 0xd0f06027, 0xddb376fe, 0xd9727b49,
|
||||
0xc7355b4c, 0xc3f456fb, 0xceb74022, 0xca764d95,
|
||||
0xf2390028, 0xf6f80d9f, 0xfbbb1b46, 0xff7a16f1,
|
||||
0xe13d36f4, 0xe5fc3b43, 0xe8bf2d9a, 0xec7e202d,
|
||||
0x34826077, 0x30436dc0, 0x3d007b19, 0x39c176ae,
|
||||
0x278656ab, 0x23475b1c, 0x2e044dc5, 0x2ac54072,
|
||||
0x128a0dcf, 0x164b0078, 0x1b0816a1, 0x1fc91b16,
|
||||
0x018e3b13, 0x054f36a4, 0x080c207d, 0x0ccd2dca,
|
||||
0x7892bb07, 0x7c53b6b0, 0x7110a069, 0x75d1adde,
|
||||
0x6b968ddb, 0x6f57806c, 0x621496b5, 0x66d59b02,
|
||||
0x5e9ad6bf, 0x5a5bdb08, 0x5718cdd1, 0x53d9c066,
|
||||
0x4d9ee063, 0x495fedd4, 0x441cfb0d, 0x40ddf6ba,
|
||||
0xaca3d697, 0xa862db20, 0xa521cdf9, 0xa1e0c04e,
|
||||
0xbfa7e04b, 0xbb66edfc, 0xb625fb25, 0xb2e4f692,
|
||||
0x8aabbb2f, 0x8e6ab698, 0x8329a041, 0x87e8adf6,
|
||||
0x99af8df3, 0x9d6e8044, 0x902d969d, 0x94ec9b2a,
|
||||
0xe0b30de7, 0xe4720050, 0xe9311689, 0xedf01b3e,
|
||||
0xf3b73b3b, 0xf776368c, 0xfa352055, 0xfef42de2,
|
||||
0xc6bb605f, 0xc27a6de8, 0xcf397b31, 0xcbf87686,
|
||||
0xd5bf5683, 0xd17e5b34, 0xdc3d4ded, 0xd8fc405a,
|
||||
0x6904c0ee, 0x6dc5cd59, 0x6086db80, 0x6447d637,
|
||||
0x7a00f632, 0x7ec1fb85, 0x7382ed5c, 0x7743e0eb,
|
||||
0x4f0cad56, 0x4bcda0e1, 0x468eb638, 0x424fbb8f,
|
||||
0x5c089b8a, 0x58c9963d, 0x558a80e4, 0x514b8d53,
|
||||
0x25141b9e, 0x21d51629, 0x2c9600f0, 0x28570d47,
|
||||
0x36102d42, 0x32d120f5, 0x3f92362c, 0x3b533b9b,
|
||||
0x031c7626, 0x07dd7b91, 0x0a9e6d48, 0x0e5f60ff,
|
||||
0x101840fa, 0x14d94d4d, 0x199a5b94, 0x1d5b5623,
|
||||
0xf125760e, 0xf5e47bb9, 0xf8a76d60, 0xfc6660d7,
|
||||
0xe22140d2, 0xe6e04d65, 0xeba35bbc, 0xef62560b,
|
||||
0xd72d1bb6, 0xd3ec1601, 0xdeaf00d8, 0xda6e0d6f,
|
||||
0xc4292d6a, 0xc0e820dd, 0xcdab3604, 0xc96a3bb3,
|
||||
0xbd35ad7e, 0xb9f4a0c9, 0xb4b7b610, 0xb076bba7,
|
||||
0xae319ba2, 0xaaf09615, 0xa7b380cc, 0xa3728d7b,
|
||||
0x9b3dc0c6, 0x9ffccd71, 0x92bfdba8, 0x967ed61f,
|
||||
0x8839f61a, 0x8cf8fbad, 0x81bbed74, 0x857ae0c3,
|
||||
0x5d86a099, 0x5947ad2e, 0x5404bbf7, 0x50c5b640,
|
||||
0x4e829645, 0x4a439bf2, 0x47008d2b, 0x43c1809c,
|
||||
0x7b8ecd21, 0x7f4fc096, 0x720cd64f, 0x76cddbf8,
|
||||
0x688afbfd, 0x6c4bf64a, 0x6108e093, 0x65c9ed24,
|
||||
0x11967be9, 0x1557765e, 0x18146087, 0x1cd56d30,
|
||||
0x02924d35, 0x06534082, 0x0b10565b, 0x0fd15bec,
|
||||
0x379e1651, 0x335f1be6, 0x3e1c0d3f, 0x3add0088,
|
||||
0x249a208d, 0x205b2d3a, 0x2d183be3, 0x29d93654,
|
||||
0xc5a71679, 0xc1661bce, 0xcc250d17, 0xc8e400a0,
|
||||
0xd6a320a5, 0xd2622d12, 0xdf213bcb, 0xdbe0367c,
|
||||
0xe3af7bc1, 0xe76e7676, 0xea2d60af, 0xeeec6d18,
|
||||
0xf0ab4d1d, 0xf46a40aa, 0xf9295673, 0xfde85bc4,
|
||||
0x89b7cd09, 0x8d76c0be, 0x8035d667, 0x84f4dbd0,
|
||||
0x9ab3fbd5, 0x9e72f662, 0x9331e0bb, 0x97f0ed0c,
|
||||
0xafbfa0b1, 0xab7ead06, 0xa63dbbdf, 0xa2fcb668,
|
||||
0xbcbb966d, 0xb87a9bda, 0xb5398d03, 0xb1f880b4,
|
||||
};
|
||||
|
||||
static uint32_t CRC_32(uint8_t *aData, long aSize)
|
||||
{
|
||||
long i;
|
||||
uint32_t nAccum = 0;
|
||||
|
||||
for (i = 0; i < aSize; i++)
|
||||
nAccum =
|
||||
(nAccum << 8) ^ gTable_Crc32[(nAccum >> 24) ^ *aData++];
|
||||
return nAccum;
|
||||
}
|
||||
|
||||
#define TAG_KERNEL 0x4C4E524B
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
FILE *fid_in, *fid_out;
|
||||
size_t cnt;
|
||||
uint8_t *ptr1;
|
||||
long fileSize;
|
||||
int exit_code = 0;
|
||||
uint32_t crcData;
|
||||
|
||||
PRINTF("mkkrnlimg V20111117\n");
|
||||
PRINTF("cmd:%s %s [%s]\n", argv[1], argv[2], argv[3]);
|
||||
if (argc < 3) {
|
||||
printf("Usage: %s srcFile desFile [flag]\n", argv[0]);
|
||||
printf("sample:\n");
|
||||
printf(" %s Image kernel.img\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
fid_in = fopen(argv[1], "rb");
|
||||
if (fid_in == 0) {
|
||||
printf("input open NG !\n ");
|
||||
exit(2);
|
||||
}
|
||||
|
||||
fid_out = fopen(argv[2], "wb");
|
||||
if (fid_out == 0) {
|
||||
printf("output open NG !\n ");
|
||||
fclose(fid_in);
|
||||
exit(3);
|
||||
}
|
||||
fseek(fid_in, 0, SEEK_END);
|
||||
fileSize = ftell(fid_in);
|
||||
PRINTF("fileSize = %ld\n", fileSize);
|
||||
fseek(fid_in, 0, SEEK_SET);
|
||||
ptr1 = malloc(fileSize + 512 + 20);
|
||||
if (ptr1 == 0) {
|
||||
exit_code = 4;
|
||||
printf("\n malloc error!");
|
||||
goto app_exit;
|
||||
}
|
||||
|
||||
*(uint32_t *)ptr1 = TAG_KERNEL;
|
||||
*(uint32_t *)(ptr1 + 4) = fileSize;
|
||||
fwrite(ptr1, 1, 8, fid_out);
|
||||
cnt = fread(ptr1, 1, fileSize, fid_in);
|
||||
PRINTF("fread = %lu\n", cnt);
|
||||
crcData = CRC_32(ptr1, fileSize);
|
||||
PRINTF("crc = 0x%x\n", crcData);
|
||||
cnt = fwrite(ptr1, 1, fileSize, fid_out);
|
||||
PRINTF("fwrite = %lu\n", cnt);
|
||||
fwrite(&crcData, 1, 4, fid_out);
|
||||
|
||||
app_exit:
|
||||
fclose(fid_in);
|
||||
fclose(fid_out);
|
||||
if (ptr1)
|
||||
free(ptr1);
|
||||
exit(exit_code);
|
||||
}
|
||||
@ -1,153 +0,0 @@
|
||||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
# Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd.
|
||||
set -e
|
||||
|
||||
usage() {
|
||||
cat >&2 << USAGE
|
||||
usage: $0 [-h] [-z] --boot_img BOOT_IMG [--out OUT] [--kernel KERNEL] [--ramdisk RAMDISK] [--second SECOND] [--dtb DTB ] [--recovery_dtbo RECOVERY_DTBO] -o OUTPUT
|
||||
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-z pack compressed kernel image
|
||||
--boot_img BOOT_IMG path to the original boot image
|
||||
--out OUT path to out binaries (default: out)
|
||||
--kernel KERNEL path to the new kernel
|
||||
--ramdisk RAMDISK path to the new ramdisk
|
||||
--second SECOND path to the new 2nd bootloader (default: resource.img)
|
||||
--dtb DTB path to the new dtb
|
||||
--recovery_dtbo RECOVERY_DTBO
|
||||
path to the new recovery DTBO
|
||||
-o OUTPUT, --output OUTPUT
|
||||
output file name
|
||||
USAGE
|
||||
}
|
||||
|
||||
# Parse command-line arguments
|
||||
while [ $# -gt 0 ]; do
|
||||
case $1 in
|
||||
--boot_img)
|
||||
boot_img=$2
|
||||
shift 2
|
||||
;;
|
||||
--out)
|
||||
out=$2
|
||||
shift 2
|
||||
;;
|
||||
--kernel)
|
||||
kernel=$2
|
||||
shift 2
|
||||
;;
|
||||
--ramdisk)
|
||||
ramdisk=$2
|
||||
shift 2
|
||||
;;
|
||||
--second)
|
||||
second=$2
|
||||
shift 2
|
||||
;;
|
||||
--dtb)
|
||||
dtb=$2
|
||||
shift 2
|
||||
;;
|
||||
--recovery_dtbo)
|
||||
recovery_dtbo=$2
|
||||
shift 2
|
||||
;;
|
||||
-h)
|
||||
usage
|
||||
exit 0
|
||||
;;
|
||||
--help)
|
||||
usage
|
||||
exit 0
|
||||
;;
|
||||
-z)
|
||||
compressed_kernel=y
|
||||
shift
|
||||
;;
|
||||
-o)
|
||||
output=$2
|
||||
shift 2
|
||||
;;
|
||||
--output)
|
||||
output=$2
|
||||
shift 2
|
||||
;;
|
||||
*)
|
||||
shift
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ "$boot_img" == "" -o ! -e "$boot_img" ]; then
|
||||
echo "No boot img"
|
||||
usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ "$output" == "" ]; then
|
||||
echo "No output file name"
|
||||
usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
srctree=${srctree-"."}
|
||||
objtree=${objtree-"."}
|
||||
out=${out-"out"}
|
||||
if [ "$($srctree/scripts/config --state CONFIG_ARM64)" == "y" ]; then
|
||||
if [ "$compressed_kernel" == "y" ]; then
|
||||
default_kernel=arch/arm64/boot/Image.lz4
|
||||
else
|
||||
default_kernel=arch/arm64/boot/Image
|
||||
fi
|
||||
else
|
||||
if [ "$compressed_kernel" == "y" ]; then
|
||||
default_kernel=arch/arm/boot/zImage
|
||||
else
|
||||
default_kernel=arch/arm/boot/Image
|
||||
fi
|
||||
fi
|
||||
kernel=${kernel-$objtree/$default_kernel}
|
||||
second=${second-$objtree/resource.img}
|
||||
ramdisk=${ramdisk-$out/ramdisk}
|
||||
dtb=${dtb-$out/dtb}
|
||||
recovery_dtbo=${recovery_dtbo-$out/recovery_dtbo}
|
||||
log="$out/unpack.log"
|
||||
|
||||
mkdir -p $out
|
||||
$srctree/scripts/unpack_bootimg --boot_img $boot_img --out $out > $log
|
||||
|
||||
cmdline=$(grep -a "^command line args: " $log | tr '\0' '\n'| sed "s/^command line args: //")
|
||||
extra_cmdline=$(grep -a "^additional command line args: " $log | tr '\0' '\n'| sed "s/^additional command line args: //")
|
||||
version=$(grep -a "^boot image header version: " $log | sed "s/^boot image header version: //")
|
||||
os_version=$(grep -a "^os version: " $log | sed "s/^os version: //")
|
||||
os_patch_level=$(grep -a "^os patch level: " $log | sed "s/^os patch level: //")
|
||||
|
||||
dtb_size=$(grep -a "^dtb size: " $log | sed "s/^dtb size: //")
|
||||
dtb_size=${dtb_size:-0}
|
||||
if [ $dtb_size -gt 0 -a -e "$dtb" ]; then
|
||||
DTB="--dtb $dtb"
|
||||
fi
|
||||
|
||||
recovery_dtbo_size=$(grep -a "^recovery dtbo size: " $log | sed "s/^recovery dtbo size: //")
|
||||
recovery_dtbo_size=${recovery_dtbo_size:-0}
|
||||
if [ $recovery_dtbo_size -gt 0 -a -e "$recovery_dtbo" ]; then
|
||||
RECOVERY_DTBO="--recovery_dtbo $recovery_dtbo"
|
||||
fi
|
||||
|
||||
if [ $version -lt 3 ]; then
|
||||
SECOND="--second $second"
|
||||
fi
|
||||
|
||||
$srctree/scripts/mkbootimg \
|
||||
--kernel $kernel \
|
||||
$SECOND \
|
||||
--ramdisk $ramdisk \
|
||||
$DTB \
|
||||
$RECOVERY_DTBO \
|
||||
--cmdline "${cmdline}${extra_cmdline}" \
|
||||
--header_version $version \
|
||||
--os_version $os_version \
|
||||
--os_patch_level $os_patch_level \
|
||||
--output $output
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,25 +0,0 @@
|
||||
--- a/arch/arm64/Makefile
|
||||
+++ b/arch/arm64/Makefile
|
||||
@@ -158,8 +158,12 @@ endif
|
||||
all: $(notdir $(KBUILD_IMAGE))
|
||||
|
||||
|
||||
+DTBS := rk35*-nanopi*.dtb
|
||||
Image vmlinuz.efi: vmlinux
|
||||
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
|
||||
+ $(Q)scripts/mkkrnlimg $(objtree)/arch/arm64/boot/Image $(objtree)/kernel.img >/dev/null
|
||||
+ @echo ' Image: kernel.img is ready'
|
||||
+ $(Q)$(srctree)/scripts/mkimg --dtb $(DTBS)
|
||||
|
||||
Image.%: Image
|
||||
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
|
||||
--- a/scripts/Makefile
|
||||
+++ b/scripts/Makefile
|
||||
@@ -10,6 +10,7 @@ hostprogs-always-$(CONFIG_BUILDTIME_TABL
|
||||
hostprogs-always-$(CONFIG_ASN1) += asn1_compiler
|
||||
hostprogs-always-$(CONFIG_MODULE_SIG_FORMAT) += sign-file
|
||||
hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert
|
||||
+hostprogs-always-$(CONFIG_ARM64) += resource_tool mkkrnlimg
|
||||
hostprogs-always-$(CONFIG_RUST) += generate_rust_target
|
||||
|
||||
generate_rust_target-rust := y
|
||||
Loading…
Reference in New Issue
Block a user