diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/acpi.h | 1 | ||||
| -rw-r--r-- | include/image-metadata.h | 38 | ||||
| -rw-r--r-- | include/linux/clk/clk-conf.h | 15 | ||||
| -rw-r--r-- | include/linux/hash.h | 104 | ||||
| -rw-r--r-- | include/linux/jffs2.h | 218 | ||||
| -rw-r--r-- | include/mci.h | 25 | ||||
| -rw-r--r-- | include/mfd/pfuze.h | 16 | ||||
| -rw-r--r-- | include/param.h | 4 | ||||
| -rw-r--r-- | include/spi/eeprom.h | 2 |
9 files changed, 406 insertions, 17 deletions
diff --git a/include/acpi.h b/include/acpi.h index 2d5fd3086a..b8e73b35df 100644 --- a/include/acpi.h +++ b/include/acpi.h @@ -6,6 +6,7 @@ #ifndef __ACPI_H_ #define __ACPI_H_ +#include <linux/string.h> #include <linux/types.h> #include <driver.h> diff --git a/include/image-metadata.h b/include/image-metadata.h index 5904d95acd..4ed5448a8c 100644 --- a/include/image-metadata.h +++ b/include/image-metadata.h @@ -25,9 +25,12 @@ #define IMD_TYPE_MODEL 0x640c8004 /* The board name this image is for */ #define IMD_TYPE_OF_COMPATIBLE 0x640c8005 /* the device tree compatible string */ #define IMD_TYPE_PARAMETER 0x640c8006 /* A generic parameter. Use key=value as data */ +#define IMD_TYPE_CRC32 0x640c1007 /* the checksum of the barebox images */ #define IMD_TYPE_END 0x640c7fff #define IMD_TYPE_INVALID 0xffffffff +#define IMD_CRC32_FLAG_TAG_VALID (1 << 0) + /* * The IMD header. All data is stored in little endian format in the image. * The next header starts at the next 4 byte boundary after the data. @@ -51,8 +54,26 @@ static inline int imd_is_string(uint32_t type) return (type & 0x8000) ? 1 : 0; } -static inline int imd_type_valid(uint32_t type) +/* + * A IMD int. + */ +struct imd_entry_crc32 { + struct imd_header header; + uint32_t data; + uint32_t flags; +}; + +static inline int imd_is_crc32(uint32_t type) +{ + return (type & IMD_TYPE_CRC32) ? 1 : 0; +} + +static inline int imd_crc32_is_valid(uint32_t flags) { + return (flags & IMD_CRC32_FLAG_TAG_VALID) ? 1 : 0; +} + +static inline int imd_type_valid(uint32_t type) { return (type & 0xffff0000) == 0x640c0000; } @@ -78,11 +99,18 @@ static inline uint32_t imd_read_length(const struct imd_header *imd) return imd_read_le32(&imd->datalength); } +static inline uint32_t imd_read_flags(const struct imd_entry_crc32 *imd) +{ + return imd_read_le32(&imd->flags); +} + const struct imd_header *imd_find_type(const struct imd_header *imd, uint32_t type); const struct imd_header *imd_get(const void *buf, int size); const char *imd_string_data(const struct imd_header *imd, int index); +const uint32_t *imd_uint32_data(const struct imd_header *imd); +uint32_t *imd_uint32_flags(const struct imd_header *imd); const char *imd_type_to_name(uint32_t type); char *imd_concat_strings(const struct imd_header *imd); const char *imd_get_param(const struct imd_header *imd, const char *name); @@ -90,6 +118,7 @@ const char *imd_get_param(const struct imd_header *imd, const char *name); extern int imd_command_verbose; int imd_command_setenv(const char *variable_name, const char *value); int imd_command(int argc, char *argv[]); +int imd_verify_crc32(void *buf, size_t size); #ifdef __BAREBOX__ @@ -107,6 +136,13 @@ int imd_command(int argc, char *argv[]); .data = _string, \ } +#define BAREBOX_IMD_CRC(_name, _crc, _keep_if_unused) \ + const struct imd_entry_crc32 __barebox_imd_##__name \ + __BAREBOX_IMD_SECTION(.barebox_imd_ ## _keep_if_unused ## _ ## _name) = { \ + .header.type = cpu_to_le32(IMD_TYPE_CRC32), \ + .header.datalength = cpu_to_le32(sizeof(uint32_t) * 2), \ + .data = _crc, \ + } #ifdef CONFIG_IMD void imd_used(const void *); diff --git a/include/linux/clk/clk-conf.h b/include/linux/clk/clk-conf.h index 8f4382e6c6..8da0f99d66 100644 --- a/include/linux/clk/clk-conf.h +++ b/include/linux/clk/clk-conf.h @@ -6,12 +6,23 @@ * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ - -#if defined(CONFIG_OFTREE) && defined(CONFIG_COMMON_CLK_OF_PROVIDER) +#ifndef __CLK_CONF_H +#define __CLK_CONF_H #include <linux/types.h> +#if defined(CONFIG_OFTREE) && defined(CONFIG_COMMON_CLK_OF_PROVIDER) + struct device_node; int of_clk_set_defaults(struct device_node *node, bool clk_supplier); +#else + +static inline int of_clk_set_defaults(struct device_node *node, + bool clk_supplier) +{ + return 0; +} + #endif +#endif /* __CLK_CONF_H */ diff --git a/include/linux/hash.h b/include/linux/hash.h new file mode 100644 index 0000000000..ad6fa21d97 --- /dev/null +++ b/include/linux/hash.h @@ -0,0 +1,104 @@ +#ifndef _LINUX_HASH_H +#define _LINUX_HASH_H +/* Fast hashing routine for ints, longs and pointers. + (C) 2002 Nadia Yvette Chambers, IBM */ + +#include <asm/types.h> +#include <linux/compiler.h> + +/* + * The "GOLDEN_RATIO_PRIME" is used in ifs/btrfs/brtfs_inode.h and + * fs/inode.c. It's not actually prime any more (the previous primes + * were actively bad for hashing), but the name remains. + */ +#if BITS_PER_LONG == 32 +#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_32 +#define hash_long(val, bits) hash_32(val, bits) +#elif BITS_PER_LONG == 64 +#define hash_long(val, bits) hash_64(val, bits) +#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_64 +#else +#error Wordsize not 32 or 64 +#endif + +/* + * This hash multiplies the input by a large odd number and takes the + * high bits. Since multiplication propagates changes to the most + * significant end only, it is essential that the high bits of the + * product be used for the hash value. + * + * Chuck Lever verified the effectiveness of this technique: + * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf + * + * Although a random odd number will do, it turns out that the golden + * ratio phi = (sqrt(5)-1)/2, or its negative, has particularly nice + * properties. (See Knuth vol 3, section 6.4, exercise 9.) + * + * These are the negative, (1 - phi) = phi**2 = (3 - sqrt(5))/2, + * which is very slightly easier to multiply by and makes no + * difference to the hash distribution. + */ +#define GOLDEN_RATIO_32 0x61C88647 +#define GOLDEN_RATIO_64 0x61C8864680B583EBull + +#ifdef CONFIG_HAVE_ARCH_HASH +/* This header may use the GOLDEN_RATIO_xx constants */ +#include <asm/hash.h> +#endif + +/* + * The _generic versions exist only so lib/test_hash.c can compare + * the arch-optimized versions with the generic. + * + * Note that if you change these, any <asm/hash.h> that aren't updated + * to match need to have their HAVE_ARCH_* define values updated so the + * self-test will not false-positive. + */ +#ifndef HAVE_ARCH__HASH_32 +#define __hash_32 __hash_32_generic +#endif +static inline u32 __hash_32_generic(u32 val) +{ + return val * GOLDEN_RATIO_32; +} + +#ifndef HAVE_ARCH_HASH_32 +#define hash_32 hash_32_generic +#endif +static inline u32 hash_32_generic(u32 val, unsigned int bits) +{ + /* High bits are more random, so use them. */ + return __hash_32(val) >> (32 - bits); +} + +#ifndef HAVE_ARCH_HASH_64 +#define hash_64 hash_64_generic +#endif +static __always_inline u32 hash_64_generic(u64 val, unsigned int bits) +{ +#if BITS_PER_LONG == 64 + /* 64x64-bit multiply is efficient on all 64-bit processors */ + return val * GOLDEN_RATIO_64 >> (64 - bits); +#else + /* Hash 64 bits using only 32x32-bit multiply. */ + return hash_32((u32)val ^ __hash_32(val >> 32), bits); +#endif +} + +static inline u32 hash_ptr(const void *ptr, unsigned int bits) +{ + return hash_long((unsigned long)ptr, bits); +} + +/* This really should be called fold32_ptr; it does no hashing to speak of. */ +static inline u32 hash32_ptr(const void *ptr) +{ + unsigned long val = (unsigned long)ptr; + +#if BITS_PER_LONG == 64 + val ^= (val >> 32); +#endif + return (u32)val; +} + +#endif /* _LINUX_HASH_H */ diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h new file mode 100644 index 0000000000..ed2ebcfc42 --- /dev/null +++ b/include/linux/jffs2.h @@ -0,0 +1,218 @@ +/* + * JFFS2 -- Journalling Flash File System, Version 2. + * + * Copyright © 2001-2007 Red Hat, Inc. + * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> + * + * Created by David Woodhouse <dwmw2@infradead.org> + * + * For licensing information, see the file 'LICENCE' in the + * jffs2 directory. + */ + +#ifndef __LINUX_JFFS2_H__ +#define __LINUX_JFFS2_H__ + +#include <linux/types.h> +#include <linux/magic.h> + +/* You must include something which defines the C99 uintXX_t types. + We don't do it from here because this file is used in too many + different environments. */ + +/* Values we may expect to find in the 'magic' field */ +#define JFFS2_OLD_MAGIC_BITMASK 0x1984 +#define JFFS2_MAGIC_BITMASK 0x1985 +#define KSAMTIB_CIGAM_2SFFJ 0x8519 /* For detecting wrong-endian fs */ +#define JFFS2_EMPTY_BITMASK 0xffff +#define JFFS2_DIRTY_BITMASK 0x0000 + +/* Summary node MAGIC marker */ +#define JFFS2_SUM_MAGIC 0x02851885 + +/* We only allow a single char for length, and 0xFF is empty flash so + we don't want it confused with a real length. Hence max 254. +*/ +#define JFFS2_MAX_NAME_LEN 254 + +/* How small can we sensibly write nodes? */ +#define JFFS2_MIN_DATA_LEN 128 + +#define JFFS2_COMPR_NONE 0x00 +#define JFFS2_COMPR_ZERO 0x01 +#define JFFS2_COMPR_RTIME 0x02 +#define JFFS2_COMPR_RUBINMIPS 0x03 +#define JFFS2_COMPR_COPY 0x04 +#define JFFS2_COMPR_DYNRUBIN 0x05 +#define JFFS2_COMPR_ZLIB 0x06 +#define JFFS2_COMPR_LZO 0x07 +/* Compatibility flags. */ +#define JFFS2_COMPAT_MASK 0xc000 /* What do to if an unknown nodetype is found */ +#define JFFS2_NODE_ACCURATE 0x2000 +/* INCOMPAT: Fail to mount the filesystem */ +#define JFFS2_FEATURE_INCOMPAT 0xc000 +/* ROCOMPAT: Mount read-only */ +#define JFFS2_FEATURE_ROCOMPAT 0x8000 +/* RWCOMPAT_COPY: Mount read/write, and copy the node when it's GC'd */ +#define JFFS2_FEATURE_RWCOMPAT_COPY 0x4000 +/* RWCOMPAT_DELETE: Mount read/write, and delete the node when it's GC'd */ +#define JFFS2_FEATURE_RWCOMPAT_DELETE 0x0000 + +#define JFFS2_NODETYPE_DIRENT (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 1) +#define JFFS2_NODETYPE_INODE (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 2) +#define JFFS2_NODETYPE_CLEANMARKER (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3) +#define JFFS2_NODETYPE_PADDING (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 4) + +#define JFFS2_NODETYPE_SUMMARY (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 6) + +#define JFFS2_NODETYPE_XATTR (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 8) +#define JFFS2_NODETYPE_XREF (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 9) + +/* XATTR Related */ +#define JFFS2_XPREFIX_USER 1 /* for "user." */ +#define JFFS2_XPREFIX_SECURITY 2 /* for "security." */ +#define JFFS2_XPREFIX_ACL_ACCESS 3 /* for "system.posix_acl_access" */ +#define JFFS2_XPREFIX_ACL_DEFAULT 4 /* for "system.posix_acl_default" */ +#define JFFS2_XPREFIX_TRUSTED 5 /* for "trusted.*" */ + +#define JFFS2_ACL_VERSION 0x0001 + +#define JFFS2_INO_FLAG_PREREAD 1 /* Do read_inode() for this one at + mount time, don't wait for it to + happen later */ +#define JFFS2_INO_FLAG_USERCOMPR 2 /* User has requested a specific + compression type */ + + +/* These can go once we've made sure we've caught all uses without + byteswapping */ + +typedef struct { + __u32 v32; +} __attribute__((packed)) jint32_t; + +typedef struct { + __u32 m; +} __attribute__((packed)) jmode_t; + +typedef struct { + __u16 v16; +} __attribute__((packed)) jint16_t; + +struct jffs2_unknown_node +{ + /* All start like this */ + jint16_t magic; + jint16_t nodetype; + jint32_t totlen; /* So we can skip over nodes we don't grok */ + jint32_t hdr_crc; +}; + +struct jffs2_raw_dirent +{ + jint16_t magic; + jint16_t nodetype; /* == JFFS2_NODETYPE_DIRENT */ + jint32_t totlen; + jint32_t hdr_crc; + jint32_t pino; + jint32_t version; + jint32_t ino; /* == zero for unlink */ + jint32_t mctime; + __u8 nsize; + __u8 type; + __u8 unused[2]; + jint32_t node_crc; + jint32_t name_crc; + __u8 name[0]; +}; + +/* The JFFS2 raw inode structure: Used for storage on physical media. */ +/* The uid, gid, atime, mtime and ctime members could be longer, but + are left like this for space efficiency. If and when people decide + they really need them extended, it's simple enough to add support for + a new type of raw node. +*/ +struct jffs2_raw_inode +{ + jint16_t magic; /* A constant magic number. */ + jint16_t nodetype; /* == JFFS2_NODETYPE_INODE */ + jint32_t totlen; /* Total length of this node (inc data, etc.) */ + jint32_t hdr_crc; + jint32_t ino; /* Inode number. */ + jint32_t version; /* Version number. */ + jmode_t mode; /* The file's type or mode. */ + jint16_t uid; /* The file's owner. */ + jint16_t gid; /* The file's group. */ + jint32_t isize; /* Total resultant size of this inode (used for truncations) */ + jint32_t atime; /* Last access time. */ + jint32_t mtime; /* Last modification time. */ + jint32_t ctime; /* Change time. */ + jint32_t offset; /* Where to begin to write. */ + jint32_t csize; /* (Compressed) data size */ + jint32_t dsize; /* Size of the node's data. (after decompression) */ + __u8 compr; /* Compression algorithm used */ + __u8 usercompr; /* Compression algorithm requested by the user */ + jint16_t flags; /* See JFFS2_INO_FLAG_* */ + jint32_t data_crc; /* CRC for the (compressed) data. */ + jint32_t node_crc; /* CRC for the raw inode (excluding data) */ + __u8 data[0]; +}; + +struct jffs2_raw_xattr { + jint16_t magic; + jint16_t nodetype; /* = JFFS2_NODETYPE_XATTR */ + jint32_t totlen; + jint32_t hdr_crc; + jint32_t xid; /* XATTR identifier number */ + jint32_t version; + __u8 xprefix; + __u8 name_len; + jint16_t value_len; + jint32_t data_crc; + jint32_t node_crc; + __u8 data[0]; +} __attribute__((packed)); + +struct jffs2_raw_xref +{ + jint16_t magic; + jint16_t nodetype; /* = JFFS2_NODETYPE_XREF */ + jint32_t totlen; + jint32_t hdr_crc; + jint32_t ino; /* inode number */ + jint32_t xid; /* XATTR identifier number */ + jint32_t xseqno; /* xref sequential number */ + jint32_t node_crc; +} __attribute__((packed)); + +struct jffs2_raw_summary +{ + jint16_t magic; + jint16_t nodetype; /* = JFFS2_NODETYPE_SUMMARY */ + jint32_t totlen; + jint32_t hdr_crc; + jint32_t sum_num; /* number of sum entries*/ + jint32_t cln_mkr; /* clean marker size, 0 = no cleanmarker */ + jint32_t padded; /* sum of the size of padding nodes */ + jint32_t sum_crc; /* summary information crc */ + jint32_t node_crc; /* node crc */ + jint32_t sum[0]; /* inode summary info */ +}; + +union jffs2_node_union +{ + struct jffs2_raw_inode i; + struct jffs2_raw_dirent d; + struct jffs2_raw_xattr x; + struct jffs2_raw_xref r; + struct jffs2_raw_summary s; + struct jffs2_unknown_node u; +}; + +/* Data payload for device nodes. */ +union jffs2_device_node { + jint16_t old_id; + jint32_t new_id; +}; + +#endif /* __LINUX_JFFS2_H__ */ diff --git a/include/mci.h b/include/mci.h index a45d744761..57a4629d12 100644 --- a/include/mci.h +++ b/include/mci.h @@ -367,6 +367,18 @@ struct mci_data { unsigned blocksize; /**< block size in bytes (mostly 512) */ }; +enum mci_timing { + MMC_TIMING_LEGACY = 0, + MMC_TIMING_MMC_HS = 1, + MMC_TIMING_SD_HS = 2, + MMC_TIMING_UHS_SDR12 = MMC_TIMING_LEGACY, + MMC_TIMING_UHS_SDR25 = MMC_TIMING_SD_HS, + MMC_TIMING_UHS_SDR50 = 3, + MMC_TIMING_UHS_SDR104 = 4, + MMC_TIMING_UHS_DDR50 = 5, + MMC_TIMING_MMC_HS200 = 6, +}; + struct mci_ios { unsigned int clock; /* clock rate */ @@ -376,17 +388,7 @@ struct mci_ios { #define MMC_BUS_WIDTH_4 2 #define MMC_BUS_WIDTH_8 3 - unsigned char timing; /* timing specification used */ - -#define MMC_TIMING_LEGACY 0 -#define MMC_TIMING_MMC_HS 1 -#define MMC_TIMING_SD_HS 2 -#define MMC_TIMING_UHS_SDR12 MMC_TIMING_LEGACY -#define MMC_TIMING_UHS_SDR25 MMC_TIMING_SD_HS -#define MMC_TIMING_UHS_SDR50 3 -#define MMC_TIMING_UHS_SDR104 4 -#define MMC_TIMING_UHS_DDR50 5 -#define MMC_TIMING_MMC_HS200 6 + enum mci_timing timing; /* timing specification used */ #define MMC_SDR_MODE 0 #define MMC_1_2V_DDR_MODE 1 @@ -408,6 +410,7 @@ struct mci_host { unsigned f_max; /**< host interface upper limit */ unsigned clock; /**< Current clock used to talk to the card */ unsigned bus_width; /**< used data bus width to the card */ + enum mci_timing timing; /**< used timing specification to the card */ unsigned max_req_size; unsigned dsr_val; /**< optional dsr value */ int use_dsr; /**< optional dsr usage flag */ diff --git a/include/mfd/pfuze.h b/include/mfd/pfuze.h index 6045ceec0a..8e021680ef 100644 --- a/include/mfd/pfuze.h +++ b/include/mfd/pfuze.h @@ -1,6 +1,22 @@ #ifndef __INCLUDE_PFUZE_H #define __INCLUDE_PFUZE_H +#include <regmap.h> + +#ifdef CONFIG_REGULATOR_PFUZE +/* + * For proper poweroff sequencing, users on imx6 needs to call + * poweroff_handler_register_fn(imx6_pm_stby_poweroff); + * inside of the callback, to ensure a proper poweroff sequence + */ int pfuze_register_init_callback(void(*callback)(struct regmap *map)); +#else + +static inline int pfuze_register_init_callback(void(*callback)(struct regmap *map)) +{ + return -ENODEV; +} +#endif + #endif /* __INCLUDE_PFUZE_H */ diff --git a/include/param.h b/include/param.h index d75f50ea3e..f1166eb289 100644 --- a/include/param.h +++ b/include/param.h @@ -37,6 +37,8 @@ struct param_d { enum param_type type; }; +enum param_tristate { PARAM_TRISTATE_UNKNOWN, PARAM_TRISTATE_TRUE, PARAM_TRISTATE_FALSE }; + #ifdef CONFIG_PARAMETER const char *get_param_type(struct param_d *param); const char *dev_get_param(struct device_d *dev, const char *name); @@ -63,8 +65,6 @@ struct param_d *dev_add_param_enum(struct device_d *dev, const char *name, int (*get)(struct param_d *p, void *priv), int *value, const char * const *names, int max, void *priv); -enum param_tristate { PARAM_TRISTATE_UNKNOWN, PARAM_TRISTATE_TRUE, PARAM_TRISTATE_FALSE }; - struct param_d *dev_add_param_tristate(struct device_d *dev, const char *name, int (*set)(struct param_d *p, void *priv), int (*get)(struct param_d *p, void *priv), diff --git a/include/spi/eeprom.h b/include/spi/eeprom.h index 15495e59f5..137718f026 100644 --- a/include/spi/eeprom.h +++ b/include/spi/eeprom.h @@ -10,7 +10,7 @@ */ struct spi_eeprom { char name[10]; - u16 page_size; /* for writes */ + u32 page_size; /* for writes */ u16 flags; #define EE_ADDR1 0x0001 /* 8 bit addrs */ #define EE_ADDR2 0x0002 /* 16 bit addrs */ |