tools/deploy/hikey960/mkfastboot

   1 #!/usr/bin/env python
   2
   3 # Copyright 2015, The Android Open Source Project
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 from __future__ import print_function
  18 from sys import argv, exit, stderr
  19 from argparse import ArgumentParser, FileType, Action
  20 from os import fstat
  21 from struct import pack
  22 from hashlib import sha1
  23 import sys
  24 import re
  25
  26 def filesize(f):
  27     if f is None:
  28         return 0
  29     try:
  30         return fstat(f.fileno()).st_size
  31     except OSError:
  32         return 0
  33
  34 def update_sha(sha, f):
  35     if f:
  36         sha.update(f.read())
  37         f.seek(0)
  38         sha.update(pack('I', filesize(f)))
  39     else:
  40         sha.update(pack('I', 0))
  41
  42 def pad_file(f, padding):
  43     pad = (padding - (f.tell() & (padding - 1))) & (padding - 1)
  44     f.write(pack(str(pad) + 'x'))
  45
  46 def write_header(args):
  47     BOOT_MAGIC = 'ANDROID!'.encode()
  48     dt_addr = args.tags_addr
  49
  50     if 0 == dt_addr:
  51         dt_addr = args.base + args.tags_offset
  52
  53     args.output.write(pack('8s', BOOT_MAGIC))
  54     args.output.write(pack('10I',
  55         filesize(args.kernel),                          # size in bytes
  56         args.base + args.kernel_offset,                 # physical load addr
  57         filesize(args.ramdisk),                         # size in bytes
  58         args.base + args.ramdisk_offset,                # physical load addr
  59         filesize(args.second),                          # size in bytes
  60         args.base + args.second_offset,                 # physical load addr
  61         dt_addr,                                        # physical addr for kernel tags
  62         args.pagesize,                                  # flash page size we assume
  63         0,                                              # future expansion: MUST be 0
  64         (args.os_version << 11) | args.os_patch_level)) # os version and patch level
  65     args.output.write(pack('16s', args.board.encode())) # asciiz product name
  66     args.output.write(pack('512s', args.cmdline[:512].encode()))
  67
  68     sha = sha1()
  69     update_sha(sha, args.kernel)
  70     update_sha(sha, args.ramdisk)
  71     update_sha(sha, args.second)
  72     img_id = pack('32s', sha.digest())
  73
  74     args.output.write(img_id)
  75     args.output.write(pack('1024s', args.cmdline[512:].encode()))
  76     pad_file(args.output, args.pagesize)
  77
  78     return img_id
  79
  80 class ValidateStrLenAction(Action):
  81     def __init__(self, option_strings, dest, nargs=None, **kwargs):
  82         if 'maxlen' not in kwargs:
  83             raise ValueError('maxlen must be set')
  84
  85         self.maxlen = int(kwargs['maxlen'])
  86         del kwargs['maxlen']
  87         super(ValidateStrLenAction, self).__init__(option_strings, dest, **kwargs)
  88
  89     def __call__(self, parser, namespace, values, option_string=None):
  90         if len(values) > self.maxlen:
  91             raise ValueError('String argument too long: max {0:d}, got {1:d}'.
  92                 format(self.maxlen, len(values)))
  93         setattr(namespace, self.dest, values)
  94
  95 def write_padded_file(f_out, f_in, padding):
  96     if f_in is None:
  97         return
  98
  99     f_out.write(f_in.read())
 100     pad_file(f_out, padding)
 101
 102 def parse_int(x):
 103     return int(x, 0)
 104
 105 def parse_os_version(x):
 106     match = re.search(r'^(\d{1,3})(?:\.(\d{1,3})(?:\.(\d{1,3}))?)?', x)
 107     if match:
 108         a = int(match.group(1))
 109         b = 0
 110         c = 0
 111
 112         if match.lastindex >= 2:
 113             b = int(match.group(2))
 114
 115         if match.lastindex == 3:
 116             c = int(match.group(3))
 117
 118         # 7 bits allocated for each field
 119         assert a < 128
 120         assert b < 128
 121         assert c < 128
 122         return (a << 14) | (b << 7) | c
 123
 124     return 0
 125
 126 def parse_os_patch_level(x):
 127     match = re.search(r'^(\d{4})-(\d{2})-(\d{2})', x)
 128     if match:
 129         y = int(match.group(1)) - 2000
 130         m = int(match.group(2))
 131
 132         # 7 bits allocated for the year, 4 bits for the month
 133         assert y >= 0 and y < 128
 134         assert m > 0 and m <= 12
 135         return (y << 4) | m
 136
 137     return 0
 138
 139 def parse_cmdline():
 140     parser = ArgumentParser()
 141     parser.add_argument('--kernel', help='path to the kernel', type=FileType('rb'),
 142                         required=True)
 143     parser.add_argument('--ramdisk', help='path to the ramdisk', type=FileType('rb'))
 144     parser.add_argument('--second', help='path to the 2nd bootloader', type=FileType('rb'))
 145     parser.add_argument('--cmdline', help='extra arguments to be passed on the '
 146                         'kernel command line', default='', action=ValidateStrLenAction, maxlen=1536)
 147     parser.add_argument('--base', help='base address', type=parse_int, default=0x10000000)
 148     parser.add_argument('--tags-addr', help='tags addr', type=parse_int, default=0x0)
 149     parser.add_argument('--kernel_offset', help='kernel offset', type=parse_int, default=0x00008000)
 150     parser.add_argument('--ramdisk_offset', help='ramdisk offset', type=parse_int, default=0x01000000)
 151     parser.add_argument('--second_offset', help='2nd bootloader offset', type=parse_int,
 152                         default=0x00f00000)
 153     parser.add_argument('--os_version', help='operating system version', type=parse_os_version,
 154                         default=0)
 155     parser.add_argument('--os_patch_level', help='operating system patch level',
 156                         type=parse_os_patch_level, default=0)
 157     parser.add_argument('--tags_offset', help='tags offset', type=parse_int, default=0x00000100)
 158     parser.add_argument('--board', help='board name', default='', action=ValidateStrLenAction,
 159                         maxlen=16)
 160     parser.add_argument('--pagesize', help='page size', type=parse_int,
 161                         choices=[2**i for i in range(11,15)], default=2048)
 162     parser.add_argument('--id', help='print the image ID on standard output',
 163                         action='store_true')
 164     parser.add_argument('-o', '--output', help='output file name', type=FileType('wb'),
 165                         required=True)
 166     return parser.parse_args()
 167
 168 def write_data(args):
 169     write_padded_file(args.output, args.kernel, args.pagesize)
 170     write_padded_file(args.output, args.ramdisk, args.pagesize)
 171     write_padded_file(args.output, args.second, args.pagesize)
 172
 173 def main():
 174     args = parse_cmdline()
 175     img_id = write_header(args)
 176     write_data(args)
 177     if args.id:
 178         if isinstance(img_id, str):
 179             # Python 2's struct.pack returns a string, but py3 returns bytes.
 180             img_id = [ord(x) for x in img_id]
 181
 182         print('0x' + ''.join('{:02x}'.format(c) for c in img_id))
 183
 184 if __name__ == '__main__':
 185     main()