From patchwork Tue Oct 29 07:23:12 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rajeshwari Shinde X-Patchwork-Id: 21263 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-qe0-f71.google.com (mail-qe0-f71.google.com [209.85.128.71]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 6607420354 for ; Tue, 29 Oct 2013 07:22:14 +0000 (UTC) Received: by mail-qe0-f71.google.com with SMTP id 1sf21289932qec.2 for ; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:from:to:cc:subject :date:message-id:in-reply-to:references:dlp-filter:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-unsubscribe; bh=+2FCPGN8P7Dxww8ZbxTuKzJBBw14PtYJChG2FHbNoFE=; b=V8FhwgaWca5/V5GNUO+d1ZUlP3xC/y9nkohah417KyLA75weFQuuhv/VKDNFnhYn5O nA0HdDgEUly9arNdh0zpBHniLPMcmgan2hPV1Fv4CQI+fhqBRwkJomDZfsiGwggNX0KJ 8EDQrobW2URJC0v/krCur/w+AIGDg4AQMxZb9cWugXikmLEgvhzesjN6vvd/27Fgfj1c nnmyl4y+xcdvXnBCIzFLr2ce8J7hHLVMM0HaTmEWdpLILp19fWBnYSSCwLxxWYEN8TVC 4nwSGJlP8fx5zjSWs1gnAKASo2nGWxR7PBNXr9WoY5uWgkIcv1oTrt5/bY1N6MsD5LQY O/0w== X-Gm-Message-State: ALoCoQnVeoGzkKunv39Ue6yqnhta2NL/ZUpQaffokXloj20rUU0tVuaqnwjAdknBasMpBQNj9PrO X-Received: by 10.236.36.39 with SMTP id v27mr24445262yha.5.1383031334280; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.49.59.36 with SMTP id w4ls2289720qeq.67.gmail; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) X-Received: by 10.220.174.200 with SMTP id u8mr15846233vcz.6.1383031334170; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) Received: from mail-vc0-f171.google.com (mail-vc0-f171.google.com [209.85.220.171]) by mx.google.com with ESMTPS id bb4si6661505vcb.75.2013.10.29.00.22.14 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 29 Oct 2013 00:22:14 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.220.171 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=209.85.220.171; Received: by mail-vc0-f171.google.com with SMTP id ik5so1083798vcb.16 for ; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) X-Received: by 10.52.229.234 with SMTP id st10mr663226vdc.34.1383031334056; Tue, 29 Oct 2013 00:22:14 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patches@linaro.org Received: by 10.220.174.196 with SMTP id u4csp181042vcz; Tue, 29 Oct 2013 00:22:13 -0700 (PDT) X-Received: by 10.66.142.170 with SMTP id rx10mr138761pab.117.1383031332862; Tue, 29 Oct 2013 00:22:12 -0700 (PDT) Received: from mailout1.samsung.com (mailout1.samsung.com. [203.254.224.24]) by mx.google.com with ESMTP id jp3si14074860pbc.276.2013.10.29.00.22.12 for ; Tue, 29 Oct 2013 00:22:12 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of rajeshwari.s@samsung.com designates 203.254.224.24 as permitted sender) client-ip=203.254.224.24; Received: from epcpsbgr1.samsung.com (u141.gpu120.samsung.co.kr [203.254.230.141]) by mailout1.samsung.com (Oracle Communications Messaging Server 7u4-24.01 (7.0.4.24.0) 64bit (built Nov 17 2011)) with ESMTP id <0MVF00IJP5SXT840@mailout1.samsung.com>; Tue, 29 Oct 2013 16:22:11 +0900 (KST) Received: from epcpsbgm2.samsung.com ( [172.20.52.122]) by epcpsbgr1.samsung.com (EPCPMTA) with SMTP id 11.B0.10672.3226F625; Tue, 29 Oct 2013 16:22:11 +0900 (KST) X-AuditID: cbfee68d-b7fa16d0000029b0-1a-526f62234a44 Received: from epmmp2 ( [203.254.227.17]) by epcpsbgm2.samsung.com (EPCPMTA) with SMTP id 95.27.08134.2226F625; Tue, 29 Oct 2013 16:22:11 +0900 (KST) Received: from localhost.localdomain.com ([107.108.73.95]) by mmp2.samsung.com (Oracle Communications Messaging Server 7u4-24.01 (7.0.4.24.0) 64bit (built Nov 17 2011)) with ESMTPA id <0MVF00H2J5SC3W70@mmp2.samsung.com>; Tue, 29 Oct 2013 16:22:10 +0900 (KST) From: Rajeshwari S Shinde To: u-boot@lists.denx.de Cc: patches@linaro.org, sjg@chromium.org, mk7.kang@samsung.com, chander.kashyap@linaro.org, u-boot-review@google.com, panto@antoniou-consulting.com, alim.akhtar@samsung.com, trini@ti.com Subject: [PATCH 09/10 V6] SPL: EXYNOS: Prepare for variable size SPL support Date: Tue, 29 Oct 2013 12:53:12 +0530 Message-id: <1383031393-6093-10-git-send-email-rajeshwari.s@samsung.com> X-Mailer: git-send-email 1.7.11.7 In-reply-to: <1383031393-6093-1-git-send-email-rajeshwari.s@samsung.com> References: <1383031393-6093-1-git-send-email-rajeshwari.s@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFupikeLIzCtJLcpLzFFi42JZI2JSpauclB9ksHaagMWDedvYLB6uv8li 0XGkhdFi1+3JLBZTDn9hsfi2ZRujxeTF85ktlr/eyG7xdm8nuwOnx7yfE5k8ZjdcZPFYsKnU 4861PWweZ+/sYPTo27KK0eP4je1MAexRXDYpqTmZZalF+nYJXBkL771mL/jsWXHx7muWBsZL Vl2MnBwSAiYS5/4sYIGwxSQu3FvP1sXIxSEksJRRomXpfKYuRg6womPv8iHi0xklJl77wwLh dDFJnLo3ixWkiA2oaOOJBJBBIgISEr/6rzKC1DAL7GOU2P99DTNIQljAR+L0srdgNouAqsSH GzvAbF4BD4mL848xQVyhKDFjyTNGEJsTKL5n7h+wGiEBd4mz2x+DDZUQ2MUu8e/ILKhBAhLf Jh9igbhUVmLTAWaIOZISB1fcYJnAKLyAkWEVo2hqQXJBcVJ6kaFecWJucWleul5yfu4mRmA8 nP73rHcH4+0D1ocYk4HGTWSWEk3OB8ZTXkm8obGZkYWpiamxkbmlGWnCSuK8SQ+TgoQE0hNL UrNTUwtSi+KLSnNSiw8xMnFwSjUwXrh+ZuGrzI5TKtZm3nucC7ZmfVip/LvnevRD19/2TVs0 ul6/Pq9n/j1vnUCn3AL9uz/X2Dkt/Jnw1a9ZxNbvXHuC2SdjgatqYZn3l/fOE8368WfrEq3f FarXiqdtSDVOm/LK0Wd3Ypbh+Ws7dS+03X5t8iK71PbxU/noRklZnsfL5K4VaR1JUGIpzkg0 1GIuKk4EAMLPKZSdAgAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFnrOIsWRmVeSWpSXmKPExsVy+t9jQV3lpPwgg53TWC0ezNvGZvFw/U0W i44jLYwWu25PZrGYcvgLi8W3LdsYLSYvns9ssfz1RnaLt3s72R04Peb9nMjkMbvhIovHgk2l Hneu7WHzOHtnB6NH35ZVjB7Hb2xnCmCPamC0yUhNTEktUkjNS85PycxLt1XyDo53jjc1MzDU NbS0MFdSyEvMTbVVcvEJ0HXLzAG6TUmhLDGnFCgUkFhcrKRvh2lCaIibrgVMY4Sub0gQXI+R ARpIWMOYsfDea/aCz54VF+++ZmlgvGTVxcjBISFgInHsXX4XIyeQKSZx4d56ti5GLg4hgemM EhOv/WGBcLqYJE7dm8UK0sAG1LDxRAJIg4iAhMSv/quMIDXMAvsYJfZ/X8MMkhAW8JE4vewt mM0ioCrx4cYOMJtXwEPi4vxjTBDbFCVmLHnGCGJzAsX3zP0DViMk4C5xdvtjxgmMvAsYGVYx iqYWJBcUJ6XnGukVJ+YWl+al6yXn525iBEfbM+kdjKsaLA4xCnAwKvHwWrDlBwmxJpYVV+Ye YpTgYFYS4d0RDBTiTUmsrEotyo8vKs1JLT7EmAx01URmKdHkfGAiyCuJNzQ2MTc1NrU0sTAx syRNWEmc92CrdaCQQHpiSWp2ampBahHMFiYOTqkGRg3DJVN8fCq9eX5/+rPlpJ9KwEQ5q3Ni Nwose+ZlH/Rw3i1hc6vzofCk8CqdcNsZ1pbNL6fMmZOpl5/oe7OBJ/7S+0pzqa0CNRN+bzt1 scVELuEGl03rHIfVVrpHbI+nXnniZrzjRZ3pimWPpzUbx23i7Vfq/ph16WG40Zuw0K+XzRct VHFZq8RSnJFoqMVcVJwIAAlpb7H6AgAA DLP-Filter: Pass X-MTR: 20000000000000000@CPGS X-CFilter-Loop: Reflected X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: rajeshwari.s@samsung.com X-Original-Authentication-Results: mx.google.com; spf=neutral (google.com: 209.85.220.171 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Precedence: list Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org List-ID: X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , When variable size SPL is used, the BL1 expects the SPL to be encapsulated differently: instead of putting the checksum at a fixed offset in the SPL blob, prepend the blob with a header including the size and the checksum. The enhancements include - adding a command line option, '--vs' to indicate the need for the variable size encapsulation - padding the fixed size encapsulated blob with 0xff instead of random memory contents - do not silently truncate the input file, report error instead - no need to explicitly closing files/freeing memory, this all happens on exit; removing cleanups it makes code clearer - profuse commenting - modify Makefile to allow enabling the new feature per board Signed-off-by: Vadim Bendebury Signed-off-by: Rajeshwari S Shinde Acked-by: Simon Glass --- Changes in V2: - None Changes in V3: - None Changes in V4: - Created a common exynos5-dt.h Changes in V5: - None Changes in V6: - None. include/configs/smdk5420.h | 7 ++ spl/Makefile | 7 +- tools/mkexynosspl.c | 167 +++++++++++++++++++++++++++++++++------------ 3 files changed, 137 insertions(+), 44 deletions(-) diff --git a/include/configs/smdk5420.h b/include/configs/smdk5420.h index e580049..447f8e5 100644 --- a/include/configs/smdk5420.h +++ b/include/configs/smdk5420.h @@ -19,6 +19,8 @@ #define CONFIG_ARCH_DEVICE_TREE exynos5420 +#define CONFIG_VAR_SIZE_SPL + #define CONFIG_SYS_SDRAM_BASE 0x20000000 #define CONFIG_SYS_TEXT_BASE 0x23E00000 @@ -31,7 +33,12 @@ /* select serial console configuration */ #define CONFIG_SERIAL3 /* use SERIAL 3 */ +#ifdef CONFIG_VAR_SIZE_SPL +#define CONFIG_SPL_TEXT_BASE 0x02024410 +#else #define CONFIG_SPL_TEXT_BASE 0x02024400 +#endif + #define CONFIG_BOOTCOMMAND "mmc read 20007000 451 2000; bootm 20007000" #define CONFIG_SYS_PROMPT "SMDK5420 # " diff --git a/spl/Makefile b/spl/Makefile index b366ac2..d5f6ae8 100644 --- a/spl/Makefile +++ b/spl/Makefile @@ -184,8 +184,13 @@ endif all: $(ALL-y) ifdef CONFIG_SAMSUNG +ifdef CONFIG_VAR_SIZE_SPL +VAR_SIZE_PARAM = --vs +else +VAR_SIZE_PARAM = +endif $(obj)$(BOARD)-spl.bin: $(obj)u-boot-spl.bin - $(OBJTREE)/tools/mk$(BOARD)spl \ + $(OBJTREE)/tools/mk$(BOARD)spl $(VAR_SIZE_PARAM) \ $(obj)u-boot-spl.bin $(obj)$(BOARD)-spl.bin endif diff --git a/tools/mkexynosspl.c b/tools/mkexynosspl.c index ef685b7..32b786c 100644 --- a/tools/mkexynosspl.c +++ b/tools/mkexynosspl.c @@ -14,93 +14,174 @@ #include #define CHECKSUM_OFFSET (14*1024-4) -#define BUFSIZE (14*1024) #define FILE_PERM (S_IRUSR | S_IWUSR | S_IRGRP \ | S_IWGRP | S_IROTH | S_IWOTH) /* -* Requirement: -* IROM code reads first 14K bytes from boot device. -* It then calculates the checksum of 14K-4 bytes and compare with data at -* 14K-4 offset. -* -* This function takes two filenames: -* IN "u-boot-spl.bin" and -* OUT "$(BOARD)-spl.bin as filenames. -* It reads the "u-boot-spl.bin" in 16K buffer. -* It calculates checksum of 14K-4 Bytes and stores at 14K-4 offset in buffer. -* It writes the buffer to "$(BOARD)-spl.bin" file. -*/ + * Requirement for the fixed size SPL header: + * IROM code reads first (CHECKSUM_OFFSET + 4) bytes from boot device. It then + * calculates the checksum of CHECKSUM_OFFSET bytes and compares with data at + * CHECKSUM_OFFSET location. + * + * Requirement for the variable size SPL header: + + * IROM code reads the below header to find out the size of the blob (total + * size, header size included) and its checksum. Then it reads the rest of the + * blob [i.e size - sizeof(struct var_size_header) bytes], calculates the + * checksum and compares it with value read from the header. + */ +struct var_size_header { + uint32_t spl_size; + uint32_t spl_checksum; + uint32_t reserved[2]; +}; + +static const char *prog_name; + +static void write_to_file(int ofd, void *buffer, int size) +{ + if (write(ofd, buffer, size) == size) + return; + + fprintf(stderr, "%s: Failed to write to output file: %s\n", + prog_name, strerror(errno)); + exit(EXIT_FAILURE); +} +/* + * The argv is expected to include one optional parameter and two filenames: + * [--vs] IN OUT + * + * --vs - turns on the variable size SPL mode + * IN - the u-boot SPL binary, usually u-boot-spl.bin + * OUT - the prepared SPL blob, usually ${BOARD}-spl.bin + * + * This utility first reads the "u-boot-spl.bin" into a buffer. In case of + * fixed size SPL the buffer size is exactly CHECKSUM_OFFSET (such that + * smaller u-boot-spl.bin gets padded with 0xff bytes, the larger than limit + * u-boot-spl.bin causes an error). For variable size SPL the buffer size is + * eqaul to size of the IN file. + * + * Then it calculates checksum of the buffer by just summing up all bytes. + * Then + * + * - for fixed size SPL the buffer is written into the output file and the + * checksum is appended to the file in little endian format, which results + * in checksum added exactly at CHECKSUM_OFFSET. + * + * - for variable size SPL the checksum and file size are stored in the + * var_size_header structure (again, in little endian format) and the + * structure is written into the output file. Then the buffer is written + * into the output file. + */ int main(int argc, char **argv) { - unsigned char buffer[BUFSIZE]; + unsigned char *buffer; int i, ifd, ofd; uint32_t checksum = 0; off_t len; - ssize_t count; + int var_size_flag, read_size, count; struct stat stat; - - if (argc != 3) { - fprintf(stderr, "Usage: %s \n", argv[0]); + const int if_index = argc - 2; /* Input file name index in argv. */ + const int of_index = argc - 1; /* Output file name index in argv. */ + + /* Strip path off the program name. */ + prog_name = strrchr(argv[0], '/'); + if (prog_name) + prog_name++; + else + prog_name = argv[0]; + + if ((argc < 3) || + (argc > 4) || + ((argc == 4) && strcmp(argv[1], "--vs"))) { + fprintf(stderr, "Usage: %s [--vs] \n", + prog_name); exit(EXIT_FAILURE); } - ifd = open(argv[1], O_RDONLY); + /* four args mean variable size SPL wrapper is required */ + var_size_flag = (argc == 4); + + ifd = open(argv[if_index], O_RDONLY); if (ifd < 0) { fprintf(stderr, "%s: Can't open %s: %s\n", - argv[0], argv[1], strerror(errno)); + prog_name, argv[if_index], strerror(errno)); exit(EXIT_FAILURE); } - ofd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM); + ofd = open(argv[of_index], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM); if (ifd < 0) { fprintf(stderr, "%s: Can't open %s: %s\n", - argv[0], argv[2], strerror(errno)); - close(ifd); + prog_name, argv[of_index], strerror(errno)); exit(EXIT_FAILURE); } if (fstat(ifd, &stat)) { fprintf(stderr, "%s: Unable to get size of %s: %s\n", - argv[0], argv[1], strerror(errno)); - close(ifd); - close(ofd); + prog_name, argv[if_index], strerror(errno)); exit(EXIT_FAILURE); } len = stat.st_size; - count = (len < CHECKSUM_OFFSET) ? len : CHECKSUM_OFFSET; - - if (read(ifd, buffer, count) != count) { - fprintf(stderr, "%s: Can't read %s: %s\n", - argv[0], argv[1], strerror(errno)); + if (var_size_flag) { + read_size = len; + count = len; + } else { + if (len > CHECKSUM_OFFSET) { + fprintf(stderr, + "%s: %s is too big (exceeds %d bytes)\n", + prog_name, argv[if_index], CHECKSUM_OFFSET); + exit(EXIT_FAILURE); + } + count = CHECKSUM_OFFSET; + read_size = len; + } - close(ifd); - close(ofd); + buffer = malloc(count); + if (!buffer) { + fprintf(stderr, + "%s: Failed to allocate %d bytes to store %s\n", + prog_name, count, argv[if_index]); + exit(EXIT_FAILURE); + } + if (read(ifd, buffer, read_size) != read_size) { + fprintf(stderr, "%s: Can't read %s: %s\n", + prog_name, argv[if_index], strerror(errno)); exit(EXIT_FAILURE); } - for (i = 0, checksum = 0; i < CHECKSUM_OFFSET; i++) - checksum += buffer[i]; + /* Pad if needed with 0xff to make flashing faster. */ + if (read_size < count) + memset((char *)buffer + read_size, 0xff, count - read_size); + for (i = 0, checksum = 0; i < count; i++) + checksum += buffer[i]; checksum = cpu_to_le32(checksum); - memcpy(&buffer[CHECKSUM_OFFSET], &checksum, sizeof(checksum)); - - if (write(ofd, buffer, BUFSIZE) != BUFSIZE) { - fprintf(stderr, "%s: Can't write %s: %s\n", - argv[0], argv[2], strerror(errno)); + if (var_size_flag) { + /* Prepare and write out the variable size SPL header. */ + struct var_size_header vsh; + uint32_t spl_size; - close(ifd); - close(ofd); + memset(&vsh, 0, sizeof(vsh)); + memcpy(&vsh.spl_checksum, &checksum, sizeof(checksum)); - exit(EXIT_FAILURE); + spl_size = cpu_to_le32(count + sizeof(struct var_size_header)); + memcpy(&vsh.spl_size, &spl_size, sizeof(spl_size)); + write_to_file(ofd, &vsh, sizeof(vsh)); } + write_to_file(ofd, buffer, count); + + /* For fixed size SPL checksum is appended in the end. */ + if (!var_size_flag) + write_to_file(ofd, &checksum, sizeof(checksum)); + close(ifd); close(ofd); + free(buffer); return EXIT_SUCCESS; }