diff options
Diffstat (limited to 'recipes/neuros-pkggen')
| -rw-r--r-- | recipes/neuros-pkggen/files/Makefile | 68 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/Makefile.rules | 18 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/config | 40 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/crc32.c | 198 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/package.c | 407 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/package.h | 142 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/readme | 20 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/files/zlib.h | 434 | ||||
| -rw-r--r-- | recipes/neuros-pkggen/neuros-pkggen-native.bb | 25 |
9 files changed, 1352 insertions, 0 deletions
diff --git a/recipes/neuros-pkggen/files/Makefile b/recipes/neuros-pkggen/files/Makefile new file mode 100644 index 0000000000..fed6835d06 --- /dev/null +++ b/recipes/neuros-pkggen/files/Makefile @@ -0,0 +1,68 @@ +# * Copyright(C) 2007 Neuros Technology International LLC. +# * <www.neurostechnology.com> +# * +# * ubootcmd application make file..............TQ 2007-02-05 + + +# include system config +include config + + +# executable name +NT_PACKET := packet_osd2 + + +# project directories +PACKET_DIR_ROOT := . + +# compiler flags +CFLAGS += $(DEFINES) -Wall -Werror + +# object files +OBJS := package.o crc32.o + +# build all +.PHONY: all +all: $(NT_PACKET) + +$(NT_PACKET): $(OBJS) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS) + +# install +install: $(NT_PACKET) + @echo + @echo "Installing $(NT_PACKET) ... " + @cp $(NT_PACKET) $(BSP_ROOT)/images/ + @echo + +# clean up project +.PHONY: clean + +clean: + @echo + @rm -f $(NT_PACKET) + @for dir in $(PACKET_DIR_ROOT); do \ + echo "Entering $$dir ..."; \ + for file in $$dir/*~ $$dir/*.o $$dir/*.d; do \ + if [ -f $$file ]; then \ + echo "removing $$file"; \ + rm $$file; \ + fi; \ + done; \ + done + @echo + +# include the C include dependencies +-include $(OBJS:.o=.d) + + +# calculate C inlcude dependencies +%.d: %.c + @set -e; rm -f $@; \ + $(CC) -MM $(CFLAGS) $< > $@.$$$$; \ + sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \ + rm -f $@.$$$$ + + +# include make rules. +include Makefile.rules diff --git a/recipes/neuros-pkggen/files/Makefile.rules b/recipes/neuros-pkggen/files/Makefile.rules new file mode 100644 index 0000000000..17550c5e39 --- /dev/null +++ b/recipes/neuros-pkggen/files/Makefile.rules @@ -0,0 +1,18 @@ +# * Copyright(C) 2007 Neuros Technology International LLC. +# * <www.neurostechnology.com> +# * +# * Terminal application make rules..........TQ 2007-02-05 + +## build target config. +ifeq ($(BUILD_TARGET), ARM) +DEFINES += -DBUILD_TARGET_ARM=1 +else +DEFINES += -DBUILD_TARGET_ARM=0 +endif + +## global test code switch. +ifeq ($(INCLUDE_TEST_CODE), YES) +DEFINES += -DTERMINAL_TEST_CODE=1 +else +DEFINES += -DTERMINAL_TEST_CODE=0 +endif diff --git a/recipes/neuros-pkggen/files/config b/recipes/neuros-pkggen/files/config new file mode 100644 index 0000000000..d323978b6d --- /dev/null +++ b/recipes/neuros-pkggen/files/config @@ -0,0 +1,40 @@ +# * Copyright(C) 2007 Neuros Technology International LLC. +# * <www.neurostechnology.com> +# * +# * Terminal application config file.........TQ 2007-02-05 + +# build target +# ARM -- Neuros hardware. +# HOST -- Host PC +BUILD_TARGET := HOST + +# global test code switch +# YES -- include test code +# NO -- exclude all test code +INCLUDE_TEST_CODE:= NO + +# BSP root directory +BSP_ROOT := $(PRJROOT) + + +# setting up tools etc. +ifeq ($(BUILD_TARGET), ARM) + TOOLS_PREFIX :=arm-linux- + PROJ_TERMINAL_ENV :="--ARM--" + TOOLS_PATH :=${PATH}:${BSP_ROOT}/toolchain/bin +endif +ifeq ($(BUILD_TARGET), HOST) + TOOLS_PREFIX:= + PROJ_TERMINAL_ENV="--HOST--" + TOOLS_PATH :=${PATH} +endif +PATH:=${TOOLS_PATH} + + +# tools definition +CC := $(TOOLS_PREFIX)gcc +CXX := $(TOOLS_PREFIX)g++ +AR := $(TOOLS_PREFIX)ar +LD := $(TOOLS_PREFIX)ld +NM := $(TOOLS_PREFIX)nm +STRIP := $(TOOLS_PREFIX)strip diff --git a/recipes/neuros-pkggen/files/crc32.c b/recipes/neuros-pkggen/files/crc32.c new file mode 100644 index 0000000000..995a11413d --- /dev/null +++ b/recipes/neuros-pkggen/files/crc32.c @@ -0,0 +1,198 @@ +/* + * This file is derived from crc32.c from the zlib-1.1.3 distribution + * by Jean-loup Gailly and Mark Adler. + */ + +/* crc32.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ +#if 0 +#ifndef USE_HOSTCC /* Shut down "ANSI does not permit..." warnings */ +#include <common.h> /* to get command definitions like CFG_CMD_JFFS2 */ +#endif +#endif + +#include "zlib.h" + +#define local static +#define ZEXPORT /* empty */ +unsigned long crc32 (unsigned long, const unsigned char *, unsigned int); + +#ifdef DYNAMIC_CRC_TABLE + +local int crc_table_empty = 1; +local uLongf crc_table[256]; +local void make_crc_table OF((void)); + +/* + Generate a table for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The table is simply the CRC of all possible eight bit values. This is all + the information needed to generate CRC's on data a byte at a time for all + combinations of CRC register values and incoming bytes. +*/ +local void make_crc_table() +{ + uLong c; + int n, k; + uLong poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* make exclusive-or pattern from polynomial (0xedb88320L) */ + poly = 0L; + for (n = 0; n < sizeof(p)/sizeof(Byte); n++) + poly |= 1L << (31 - p[n]); + + for (n = 0; n < 256; n++) + { + c = (uLong)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[n] = c; + } + crc_table_empty = 0; +} +#else +/* ======================================================================== + * Table of CRC-32's of all single-byte values (made by make_crc_table) + */ +local const uLongf crc_table[256] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; +#endif + +#if 0 +/* ========================================================================= + * This function can be used by asm versions of crc32() + */ +const uLongf * ZEXPORT get_crc_table() +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) make_crc_table(); +#endif + return (const uLongf *)crc_table; +} +#endif + +/* ========================================================================= */ +#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); +#define DO2(buf) DO1(buf); DO1(buf); +#define DO4(buf) DO2(buf); DO2(buf); +#define DO8(buf) DO4(buf); DO4(buf); + +/* ========================================================================= */ +uLong ZEXPORT crc32(crc, buf, len) + uLong crc; + const Bytef *buf; + uInt len; +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif + crc = crc ^ 0xffffffffL; + while (len >= 8) + { + DO8(buf); + len -= 8; + } + if (len) do { + DO1(buf); + } while (--len); + return crc ^ 0xffffffffL; +} + +#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) + +/* No ones complement version. JFFS2 (and other things ?) + * don't use ones compliment in their CRC calculations. + */ +uLong ZEXPORT crc32_no_comp(uLong crc, const Bytef *buf, uInt len) +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif + while (len >= 8) + { + DO8(buf); + len -= 8; + } + if (len) do { + DO1(buf); + } while (--len); + + return crc; +} + +#endif /* CFG_CMD_JFFS2 */ diff --git a/recipes/neuros-pkggen/files/package.c b/recipes/neuros-pkggen/files/package.c new file mode 100644 index 0000000000..6ac94f9874 --- /dev/null +++ b/recipes/neuros-pkggen/files/package.c @@ -0,0 +1,407 @@ +/* + * Copyright (C) 2006 - 2008 Neuros Technology LLC. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; only support version 2 of the License. + * + * This program is distributed in the hope that, in addition to its + * original purpose to support Neuros hardware, it will be useful + * otherwise, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *****************************************************************************/ +/** package.c + * + * This file for packaging some images to one package. + * The package is named r3.upk. + * + * 02/22/2005 T.Qiu + * Initial creation. + * 11/07/2007 T.Qiu + * change follow the new UPK structure + * 05/15/2008 JWU + * change for osd2.0 + */ + +#include <stdio.h> +#include <string.h> +#include <sys/stat.h> +#include "package.h" + +#define RETRYTIMES 15 +#define VER_LIMIT_LEN 14 +#define VER_HW2_LEN 4 +#define SAFE_SIZE (250*1024*1024) //250MB + +static package_header_t p_head; +static image_info_t i_info[10]; + +static void print_image_info(image_info_t *iif) +{ + printf("iif->i_type: %x\n", iif->i_type); + printf("iif->i_imagesize: %d\n", iif->i_imagesize); + printf("iif->i_startaddr_p: %d\n", iif->i_startaddr_p); + printf("iif->i_startaddr_f: %x\n", iif->i_startaddr_f); + printf("iif->i_endaddr_f: %x\n", iif->i_endaddr_f); + printf("iif->i_name: %s\n", iif->i_name); + printf("iif->i_version: %s\n", iif->i_version); +} + +static void print_head_info(void) +{ + package_header_t *phd = &p_head; + + printf("phd->p_headsize: %x\n", phd->p_headsize); + printf("phd->p_reserve: %x\n", phd->p_reserve); + printf("phd->p_headcrc: %x\n", phd->p_headcrc); + printf("phd->p_datasize: %d\n", phd->p_datasize); + printf("phd->p_datacrc: %x\n", phd->p_datacrc); + printf("phd->p_name: %s\n", phd->p_name); + printf("phd->p_vuboot: %s\n", phd->p_vuboot); + printf("phd->p_vkernel: %s\n", phd->p_vkernel); + printf("phd->p_vrootfs: %s\n", phd->p_vrootfs); + printf("phd->p_imagenum: %x\n", phd->p_imagenum); +} + +static void print_version_info(version_info *ver_t) +{ + printf("ver_t->upk_desc: %s\n", ver_t->upk_desc); + printf("ver_t->pack_id: %s\n", ver_t->pack_id); + printf("ver_t->os_ver : %s\n", ver_t->os_ver); + printf("ver_t->app_ver: %s\n", ver_t->app_ver); +} + +static int pack_firmware(FILE *fp_w, uint32 offst, int num, char *name[]) +{ + FILE *fp_r; + int i, j; + uint32 curptr, extcrc; + char ch; + package_header_t *phd = &p_head; + image_info_t *iif; + + /* read version file */ + if ((fp_r = fopen(UBOOT_VER_FILE, "rb")) == NULL) + { + printf("Can't open uboot version file: %s\n", UBOOT_VER_FILE); + return(-1); + } + j=0; + while (1) + { + if (feof(fp_r)) break; + if (j > VER_LIMIT_LEN+1) + { + printf("uboot version can't be longer than 14\n"); + goto bail; + } + phd->p_vuboot[j] = fgetc(fp_r); + if ((phd->p_vuboot[j]==0x0d) || (phd->p_vuboot[j]==0x0a)) + phd->p_vuboot[j] = '\0'; + j++; + } + fclose(fp_r); + + if ((fp_r = fopen(KERNEL_VER_FILE, "rb")) == NULL) + { + printf("Can't open kernel version file: %s\n", KERNEL_VER_FILE); + return(-1); + } + j=0; + while (1) + { + if (feof(fp_r)) break; + if (j > VER_LIMIT_LEN+1) + { + printf("kernel version can't be longer than 14\n"); + goto bail; + } + phd->p_vkernel[j]=fgetc(fp_r); + if ((phd->p_vkernel[j]==0x0d) || (phd->p_vkernel[j]==0x0a)) + phd->p_vkernel[j] = '\0'; + j++; + } + fclose(fp_r); + + if ((fp_r = fopen(ROOTFS_VER_FILE, "rb")) == NULL) + { + printf("Can't open rootfs version file: %s\n", ROOTFS_VER_FILE); + return(-1); + } + j=0; + while (1) + { + if (feof(fp_r)) break; + if (j > VER_LIMIT_LEN+1) + { + printf("rootfs version can't be longer than 14\n"); + goto bail; + } + phd->p_vrootfs[j] = fgetc(fp_r); + if ((phd->p_vrootfs[j]==0x0d) ||(phd->p_vrootfs[j]==0x0a)) + phd->p_vrootfs[j] = '\0'; + j++; + } + fclose(fp_r); + + phd->p_imagenum = (uint8)num; + phd->p_headsize = sizeof(package_header_t) + phd->p_imagenum * sizeof(image_info_t); + + /* Bit[3] use to indicate osd2.0 package */ + phd->p_reserve = 0x08; + + phd->p_datasize = 0; + phd->p_datacrc = 0; + phd->p_headcrc = 0; + + curptr = phd->p_headsize + sizeof(version_info); + + for (i=0; i < phd->p_imagenum; i++) + { + /* image info */ + iif = &i_info[i]; + if (strncmp(name[i], ROOTFS_FILE_NAME, strlen(ROOTFS_FILE_NAME)) == 0) + { + iif->i_type = IH_TYPE_ROOTFS; + strncpy((char *)iif->i_name, ROOTFS_FILE_NAME, NAMELEN-1); + + if ((fp_r = fopen(ROOTFS_VER_FILE, "rb")) == NULL) + { + printf("Can't open kernel version file: %s\n", ROOTFS_VER_FILE); + break; + } + for (j = 0; j < sizeof(iif->i_version); j++) + { + if (feof(fp_r)) break; + iif->i_version[j] = fgetc(fp_r); + if ((iif->i_version[j]==0x0d) || (iif->i_version[j]==0x0a)) + iif->i_version[j] = '\0'; + } + fclose(fp_r); + } + else if (strncmp(name[i], KERNEL_FILE_NAME, strlen(KERNEL_FILE_NAME)) == 0) + { + iif->i_type = IH_TYPE_KERNEL; + strncpy((char *)iif->i_name, KERNEL_FILE_NAME, NAMELEN-1); + + if ((fp_r = fopen(KERNEL_VER_FILE, "rb")) == NULL) + { + printf("Can't open kernel version file: %s\n", KERNEL_VER_FILE); + break; + } + for (j = 0; j < sizeof(iif->i_version); j++) + { + if (feof(fp_r)) break; + iif->i_version[j] = fgetc(fp_r); + if ((iif->i_version[j]==0x0d) ||(iif->i_version[j]==0x0a)) + iif->i_version[j] = '\0'; + } + fclose(fp_r); + } + else if (strncmp(name[i], UBOOT_FILE_NAME, strlen(UBOOT_FILE_NAME)) == 0) + { + iif->i_type = IH_TYPE_UBOOT; + strncpy((char *)iif->i_name, UBOOT_FILE_NAME, NAMELEN-1); + + if ((fp_r = fopen(UBOOT_VER_FILE, "rb")) == NULL) + { + printf("Can't open uboot version file: %s\n", UBOOT_VER_FILE); + break; + } + for (j = 0; j < sizeof(iif->i_version); j++) + { + if (feof(fp_r)) break; + iif->i_version[j] = fgetc(fp_r); + if ((iif->i_version[j]==0x0d)|| (iif->i_version[j]==0x0a)) + iif->i_version[j] = '\0'; + } + fclose(fp_r); + } + else if (strncmp(name[i], SCRIPT_FILE_NAME, strlen(SCRIPT_FILE_NAME)) == 0) + { + iif->i_type = IH_TYPE_SCRIPT; + strncpy((char *)iif->i_name, SCRIPT_FILE_NAME, NAMELEN-1); + } + + /* address in flash*/ + switch (iif->i_type) + { + case IH_TYPE_ROOTFS: + iif->i_startaddr_f = ROOTFS_ADDR_START; + iif->i_endaddr_f = ROOTFS_ADDR_END; + break; + case IH_TYPE_KERNEL: + iif->i_startaddr_f = KERNEL_ADDR_START; + iif->i_endaddr_f = KERNEL_ADDR_END; + break; + case IH_TYPE_UBOOT: + iif->i_startaddr_f = UBOOT_ADDR_START; + iif->i_endaddr_f = UBOOT_ADDR_END; + break; + case IH_TYPE_SCRIPT: + break; + default: + printf("un-handle image type\n"); + break; + } + + /* write whole image to package and calculate the imagesize*/ + iif->i_imagesize = 0; + /* images file */ + if ((fp_r = fopen(name[i], "rb")) == NULL) + { + printf("can't open file: %s\n", name[i]); + break; + } + + fseek(fp_w, offst+curptr,SEEK_SET); + extcrc = 0; + while (!feof(fp_r)) + { + ch = fgetc(fp_r); + fputc(ch, fp_w); + phd->p_datacrc = crc32(phd->p_datacrc,(uint8 *)&ch, 1); + iif->i_imagesize ++; + } + fclose(fp_r); + + iif->i_startaddr_p = curptr-sizeof(version_info); + curptr += iif->i_imagesize; + phd->p_datasize += iif->i_imagesize; + + print_image_info(iif); /* print iff*/ + + /*write image info */ + fseek(fp_w, offst+sizeof(version_info)+sizeof(package_header_t)+i*sizeof(image_info_t), SEEK_SET); + if (fwrite(iif, sizeof(image_info_t), 1, fp_w) != 1) + { + printf("can not write iif into package\n"); + break; + } + } + + /* write package head*/ + phd->p_headcrc = crc32(phd->p_headcrc, (uint8 *)phd, sizeof(package_header_t)); + phd->p_headcrc = crc32(phd->p_headcrc, (uint8 *)i_info, phd->p_imagenum*sizeof(image_info_t)); + + print_head_info(); /* print phd */ + + fseek(fp_w, offst+sizeof(version_info), SEEK_SET); + if (fwrite((uint8 *)phd, sizeof(package_header_t), 1, fp_w) != 1) + { + printf("can not write head into package"); + return(-1); + } + return 0; + + bail: + fclose(fp_r); + + return -1; +} + +static int pack_ver_info(FILE *fp_w, uint32 offset, char *desc) +{ + version_info ver_t; + FILE *fp_r; + int i; + + memset((char *)&ver_t, 0, sizeof(version_info)); + + if (strlen(desc) >= DESCLEN) + { + printf("The upk_desc is too long\n"); + return(-1); + } + strncpy((char *)ver_t.upk_desc, desc, DESCLEN-1); + strncpy((char *)ver_t.pack_id, (char *)PACKAGE_ID, NAMELEN-1); + strncpy((char *)ver_t.os_ver, "0.00", VERLEN-1); + strncpy((char *)ver_t.app_ver, "0.00", VERLEN-1); + + if ((fp_r = fopen(KERNEL_VER_FILE, "rb")) == NULL) + { + printf("Can't open OS version file: %s\n", KERNEL_VER_FILE); + return(-1); + } + for (i = 0; i < sizeof(ver_t.os_ver); i++) + { + if (feof(fp_r)) break; + ver_t.os_ver[i] = fgetc(fp_r); + if ((ver_t.os_ver[i]==0x0d) || (ver_t.os_ver[i]==0x0a)) + ver_t.os_ver[i] = '\0'; + } + fclose(fp_r); + + if ((fp_r = fopen(ROOTFS_VER_FILE, "rb")) == NULL) + { + printf("Can't open App version file: %s\n", ROOTFS_VER_FILE); + return(-1); + } + for (i = 0; i < sizeof(ver_t.app_ver); i++) + { + if (feof(fp_r)) break; + ver_t.app_ver[i] = fgetc(fp_r); + if ((ver_t.app_ver[i]==0x0d) || (ver_t.app_ver[i]==0x0a)) + ver_t.app_ver[i] = '\0'; + } + fclose(fp_r); + + fseek(fp_w, 0, SEEK_SET); + if (fwrite((uint8 *)&ver_t, sizeof(version_info), 1, fp_w) != 1) + { + printf("can not write the version struct into package\n"); + return(-1); + } + + print_version_info(&ver_t); + + return(0); +} + +/* argv[1] packet name + argv[2] upk descpription + argv[3] u-env image + argv[4] u-boot image + argv[5] kernel image + argv[5] rootfs image*/ +int main(int argc, char *argv[]) +{ + FILE *fp_w; + uint32 hw_len = 0; + package_header_t *phd = &p_head; + struct stat buf; + + printf("\npackage tool version %s \n", VERSION); + + strncpy((char *)phd->p_name, argv[1], NAMELEN-1); + if ((fp_w = fopen((char *)phd->p_name, "wb+")) == NULL) + { + printf("Can't open %s\n",phd->p_name); + return(-1); + } + + /* packet firmware to package */ + if (pack_firmware(fp_w, hw_len, argc - 3, &argv[3]) != 0) + return(-1); + /* packet upk_desc and version info */ + if (pack_ver_info(fp_w, hw_len+phd->p_headsize, argv[2]) != 0) + return(-1); + + fclose(fp_w); + + stat((char *)phd->p_name, &buf); + if (buf.st_size > SAFE_SIZE) + { + printf("Warning!!!!! The upk size is larger than the safe size\n"); + } + + return 0; +} + + diff --git a/recipes/neuros-pkggen/files/package.h b/recipes/neuros-pkggen/files/package.h new file mode 100644 index 0000000000..b1178dcb18 --- /dev/null +++ b/recipes/neuros-pkggen/files/package.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2006 - 2008 Neuros Technology LLC. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; only support version 2 of the License. + * + * This program is distributed in the hope that, in addition to its + * original purpose to support Neuros hardware, it will be useful + * otherwise, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *****************************************************************************/ +/** package.h + * + * Some structure for package.c + * + * 02/22/2002 T.Qiu + * Initial creation. + * 05/15/2008 JWU + * change for osd2.0 + */ + +#ifndef PACKAGE_H +#define PACKAGE_H + +#define VERSION "3.01" +#define NAMELEN 32 +#define VERLEN 20 /* should same as the uboot */ +#define DESCLEN 256 + +/* image type*/ +#define IH_TYPE_INVALID 0 /* Invalid Image */ +#define IH_TYPE_STANDALONE 1 /* Standalone Program */ +#define IH_TYPE_KERNEL 2 /* OS Kernel Image */ +#define IH_TYPE_RAMDISK 3 /* RAMDisk Image */ +#define IH_TYPE_MULTI 4 /* Multi-File Image */ +#define IH_TYPE_FIRMWARE 5 /* Firmware Image */ +#define IH_TYPE_SCRIPT 6 /* Script file */ +#define IH_TYPE_FILESYSTEM 7 /* Filesystem Image (any type) */ +#define IH_TYPE_FLATDT 8 /* Binary Flat Device Tree Blob */ +#define IH_TYPE_UBOOT 9 +#define IH_TYPE_ROOTFS 10 + +/* addr in flash */ +#define UBOOT_ADDR_START 0x000C0000 +#define UBOOT_SIZE (1*1024*1024) +#define UBOOT_ADDR_END (UBOOT_ADDR_START+UBOOT_SIZE-1) +#define KERNEL_ADDR_START (UBOOT_ADDR_END+1) +#define KERNEL_SIZE (5*1024*1024) +#define KERNEL_ADDR_END (KERNEL_ADDR_START+KERNEL_SIZE-1) +#define ROOTFS_ADDR_START (KERNEL_ADDR_END+1) +#define ROOTFS_ADDR_END (256*1024*1024 - 1) + +#define UBOOT_FILE_NAME "u-boot.bin" +#define KERNEL_FILE_NAME "uImage.jffs2" +#define ROOTFS_FILE_NAME "rootfs.yaffs2" +#define SCRIPT_FILE_NAME "default_env.img" + +#define UBOOT_VER_FILE "u-boot.version" +#define KERNEL_VER_FILE "uImage.version" +#define ROOTFS_VER_FILE "rootfs.version" + +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned int uint32; +typedef unsigned long uint64; + +#define SWAP_LONG(x) \ + ((uint32)( \ + (((uint32)(x) & (uint32)0x000000ffUL) << 24) | \ + (((uint32)(x) & (uint32)0x0000ff00UL) << 8) | \ + (((uint32)(x) & (uint32)0x00ff0000UL) >> 8) | \ + (((uint32)(x) & (uint32)0xff000000UL) >> 24) )) + +#define SWAP_SHORT(x) \ + ((uint16)( \ + (((uint16)(x) & (uint16)0x00ff) << 8) | \ + (((uint16)(x) & (uint16)0xff00) >> 8)) + +#define ntohl(a) SWAP_LONG(a) +#define htonl(a) SWAP_LONG(a) +#define ntohs(a) SWAP_SHORT(a) +#define htons(a) SWAP_SHORT(a) + +typedef struct packet_header{ + uint32 p_headsize; /* package header size */ + uint32 p_reserve; /* Bit[3]:1 OSD2.0 upk */ + uint32 p_headcrc; /* package header crc checksum */ + uint32 p_datasize; /* package data size */ + uint32 p_datacrc; /* package data crc checksum */ + uint8 p_name[NAMELEN]; /* package name */ + uint8 p_vuboot[VERLEN]; /* version of uboot which depend on */ + uint8 p_vkernel[VERLEN];/* version of kernel which depend on*/ + uint8 p_vrootfs[VERLEN];/* version of rootfs which depend on*/ + uint32 p_imagenum; /* num of the images in package*/ + /* follow is image info */ +}package_header_t; + +typedef struct image_info{ + uint32 i_type; /* image type */ + uint32 i_imagesize; /* size of image */ + uint32 i_startaddr_p; /* start address in packeage */ + uint32 i_startaddr_f; /* start address in flash */ + uint32 i_endaddr_f; /* end address in flash */ + uint8 i_name[NAMELEN]; /* image name */ + uint8 i_version[VERLEN];/* image version */ +}image_info_t; + +typedef struct image_header { + uint32 ih_magic; /* Image Header Magic Number */ + uint32 ih_hcrc; /* Image Header CRC Checksum */ + uint32 ih_time; /* Image Creation Timestamp */ + uint32 ih_size; /* Image Data Size */ + uint32 ih_load; /* Data Load Address */ + uint32 ih_ep; /* Entry Point Address */ + uint32 ih_dcrc; /* Image Data CRC Checksum */ + uint8 ih_os; /* Operating System */ + uint8 ih_arch; /* CPU architecture */ + uint8 ih_type; /* Image Type */ + uint8 ih_comp; /* Compression Type */ + uint8 ih_name[NAMELEN]; /* Image Name */ +} image_header_t; + +#define PACKAGE_ID "neuros-osd2.0" +typedef struct version_struct{ + uint8 upk_desc[DESCLEN]; + uint8 pack_id[NAMELEN]; + uint8 os_ver [VERLEN]; + uint8 app_ver[VERLEN]; +}version_info; + + +extern unsigned long crc32 (unsigned long, const unsigned char *, unsigned int); + +#endif + diff --git a/recipes/neuros-pkggen/files/readme b/recipes/neuros-pkggen/files/readme new file mode 100644 index 0000000000..fd9c31b545 --- /dev/null +++ b/recipes/neuros-pkggen/files/readme @@ -0,0 +1,20 @@ +This is the tool to generate the OSD upgrading package. + +1. Compile the tool + gcc crc32.c package.c -o osdpkg + +2. Copy tool to neuros-bsp/images + +3. Create upk + ./osdpkg nh [upk_desc] [upk_name] [bins ...] + +You can choose to either generate a full package that includes each +binary or a package just for that part that has been changed. + +Example: +<1> To create a upk by including everything + ./osdpkg nh "upk by yada_yada on 2006-10-18" r3.upk env.img +u-boot.bin uImage root.cramfs + +<2> To create a upk by just including the rootfs + ./osdpkg nh "upk by blah_blah on 2006-10-18" r3.upk root.cramfs diff --git a/recipes/neuros-pkggen/files/zlib.h b/recipes/neuros-pkggen/files/zlib.h new file mode 100644 index 0000000000..e441494d0d --- /dev/null +++ b/recipes/neuros-pkggen/files/zlib.h @@ -0,0 +1,434 @@ +/* + * This file is derived from zlib.h and zconf.h from the zlib-0.95 + * distribution by Jean-loup Gailly and Mark Adler, with some additions + * by Paul Mackerras to aid in implementing Deflate compression and + * decompression for PPP packets. + */ + +/* + * ==FILEVERSION 960122== + * + * This marker is used by the Linux installation script to determine + * whether an up-to-date version of this file is already installed. + */ + +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 0.95, Aug 16th, 1995. + + Copyright (C) 1995 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + gzip@prep.ai.mit.edu madler@alumni.caltech.edu + */ + +#ifndef _ZLIB_H +#define _ZLIB_H + +/* #include "zconf.h" */ /* included directly here */ + +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */ + +/* + The library does not install any signal handler. It is recommended to + add at least a handler for SIGSEGV when decompressing; the library checks + the consistency of the input data whenever possible but may go nuts + for some forms of corrupted input. + */ + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints + * at addresses which are not a multiple of their size. + * Under DOS, -DFAR=far or -DFAR=__far may be needed. + */ + +#ifndef STDC +# if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus) +# define STDC +# endif +#endif + +#ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */ +# include <unix.h> +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +#ifndef FAR +# define FAR +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2 */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + 1 << (windowBits+2) + 1 << (memLevel+9) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +typedef unsigned char Byte; /* 8 bits */ +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +typedef Byte FAR Bytef; +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +/* end of original zconf.h */ + +#define ZLIB_VERSION "0.95P" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms may be added later and will have the same + stream interface. + + For compression the application must provide the output buffer and + may optionally provide the input buffer for optimization. For decompression, + the application must provide the input buffer and may optionally provide + the output buffer for optimization. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt nbytes)); + +typedef void (*cb_func) OF((Bytef *buf, uInt len)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidp opaque; /* private data object passed to zalloc and zfree */ + + Byte data_type; /* best guess about the data type: ascii or binary */ + + cb_func outcb; /* called regularly just before blocks of output */ + +} z_stream; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 +#define Z_FULL_FLUSH 2 +#define Z_SYNC_FLUSH 3 /* experimental: partial_flush + byte align */ +#define Z_FINISH 4 +#define Z_PACKET_FLUSH 5 +/* See deflate() below for the usage of these constants */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +/* error codes for the compression/decompression functions */ + +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Used to set the data_type field */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +extern char *zlib_version; +/* The application can compare zlib_version and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + */ + + /* basic functions */ + +extern int inflateInit OF((z_stream *strm)); +/* + Initializes the internal stream state for decompression. The fields + zalloc and zfree must be initialized before by the caller. If zalloc and + zfree are set to Z_NULL, inflateInit updates them to use default allocation + functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory. msg is set to null if there is no error message. + inflateInit does not perform any decompression: this will be done by + inflate(). +*/ + + +extern int inflate OF((z_stream *strm, int flush)); +/* + Performs one or both of the following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() always provides as much output as possible + (until there is no more input data or no more space in the output buffer). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). + + If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH, + inflate flushes as much output as possible to the output buffer. The + flushing behavior of inflate is not specified for values of the flush + parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the + current implementation actually flushes as much output as possible + anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data + has been consumed, it is expecting to see the length field of a stored + block; if not, it returns Z_DATA_ERROR. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + inflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if the end of the + compressed data has been reached and all uncompressed output has been + produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if + the stream structure was inconsistent (for example if next_in or next_out + was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no + progress is possible or if there was not enough room in the output buffer + when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then + call inflateSync to look for a good compression block. */ + + +extern int inflateEnd OF((z_stream *strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* advanced functions */ + +extern int inflateInit2 OF((z_stream *strm, + int windowBits)); +/* + This is another version of inflateInit with more compression options. The + fields next_out, zalloc and zfree must be initialized before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library (the value 16 will be allowed soon). The + default value is 15 if inflateInit is used instead. If a compressed stream + with a larger window size is given as input, inflate() will return with + the error code Z_DATA_ERROR instead of trying to allocate a larger window. + + If next_out is not null, the library will use this buffer for the history + buffer; the buffer must either be large enough to hold the entire output + data, or have at least 1<<windowBits bytes. If next_out is null, the + library will allocate its own buffer (and leave next_out null). next_in + need not be provided here but must be provided by the application for the + next call of inflate(). + + If the history buffer is provided by the application, next_out must + never be changed by the application since the decompressor maintains + history information inside this buffer from call to call; the application + can only reset next_out to the beginning of the history buffer when + avail_out is zero and all output has been consumed. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was + not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as + windowBits < 8). msg is set to null if there is no error message. + inflateInit2 does not perform any decompression: this will be done by + inflate(). +*/ + +extern int inflateSync OF((z_stream *strm)); +/* + Skips invalid compressed data until the special marker (see deflate() + above) can be found, or until all available input is skipped. No output + is provided. + + inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no marker has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +extern int inflateReset OF((z_stream *strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +extern int inflateIncomp OF((z_stream *strm)); +/* + This function adds the data at next_in (avail_in bytes) to the output + history without performing any output. There must be no pending output, + and the decompressor must be expecting to see the start of a block. + Calling this function is equivalent to decompressing a stored block + containing the data at next_in (except that the data is not output). +*/ + + /* checksum functions */ + +/* + This function is not related to compression but is exported + anyway because it might be useful in applications using the + compression library. +*/ + +extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +#ifndef _Z_UTIL_H + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +#endif /* _ZLIB_H */ diff --git a/recipes/neuros-pkggen/neuros-pkggen-native.bb b/recipes/neuros-pkggen/neuros-pkggen-native.bb new file mode 100644 index 0000000000..13625622d2 --- /dev/null +++ b/recipes/neuros-pkggen/neuros-pkggen-native.bb @@ -0,0 +1,25 @@ +DESCRIPTION = "Tool to generate ready to flash .pkg files for neuros machines" +LICENSE = "GPLv2" +PR = "r3" + +inherit native + +SRC_URI = "file://Makefile \ + file://Makefile.rules \ + file://config \ + file://crc32.c \ + file://package.c \ + file://package.h \ + file://readme \ + file://zlib.h \ +" + +do_compile_prepend() { + ( cd ${WORKDIR} ; cp Makefile Makefile.rules config crc32.c package.c package.h readme zlib.h ${S} ) +} + +do_stage() { + install -m 0755 packet_osd2 ${STAGING_BINDIR_NATIVE} +} + + |