Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

The SmartMedia FTL code depends on new kfifo bits from 2.6.33

15 files changed, 468 insertions, 27 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 1cfe51628e1b..97b136ff117e 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -117,6 +117,10 @@ config DECOMPRESS_BZIP2
 config DECOMPRESS_LZMA
         tristate
 
+config DECOMPRESS_LZO
+        select LZO_DECOMPRESS
+        tristate
+
 #
 # Generic allocator support is selected if needed
 #
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 8cf9938dd147..25c3ed594c54 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -360,6 +360,7 @@ config DEBUG_KMEMLEAK
         select DEBUG_FS if SYSFS
         select STACKTRACE if STACKTRACE_SUPPORT
         select KALLSYMS
+        select CRC32
         help
           Say Y here if you want to enable the memory leak
           detector. The memory allocation/freeing is traced in a way
diff --git a/lib/Makefile b/lib/Makefile
index 347ad8db29d3..3b0b4a696db9 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -21,7 +21,7 @@ lib-y	+= kobject.o kref.o klist.o
 
 obj-y += bcd.o div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \
          bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o \
-         string_helpers.o gcd.o
+         string_helpers.o gcd.o list_sort.o
 
 ifeq ($(CONFIG_DEBUG_KOBJECT),y)
 CFLAGS_kobject.o += -DDEBUG
@@ -69,6 +69,7 @@ obj-$(CONFIG_LZO_DECOMPRESS) += lzo/
 lib-$(CONFIG_DECOMPRESS_GZIP) += decompress_inflate.o
 lib-$(CONFIG_DECOMPRESS_BZIP2) += decompress_bunzip2.o
 lib-$(CONFIG_DECOMPRESS_LZMA) += decompress_unlzma.o
+lib-$(CONFIG_DECOMPRESS_LZO) += decompress_unlzo.o
 
 obj-$(CONFIG_TEXTSEARCH) += textsearch.o
 obj-$(CONFIG_TEXTSEARCH_KMP) += ts_kmp.o
diff --git a/lib/decompress.c b/lib/decompress.c
index d2842f571674..a7606815541f 100644
--- a/lib/decompress.c
+++ b/lib/decompress.c
@@ -9,6 +9,7 @@
 #include <linux/decompress/bunzip2.h>
 #include <linux/decompress/unlzma.h>
 #include <linux/decompress/inflate.h>
+#include <linux/decompress/unlzo.h>
 
 #include <linux/types.h>
 #include <linux/string.h>
@@ -22,6 +23,9 @@
 #ifndef CONFIG_DECOMPRESS_LZMA
 # define unlzma NULL
 #endif
+#ifndef CONFIG_DECOMPRESS_LZO
+# define unlzo NULL
+#endif
 
 static const struct compress_format {
         unsigned char magic[2];
@@ -32,6 +36,7 @@ static const struct compress_format {
         { {037, 0236}, "gzip", gunzip },
         { {0x42, 0x5a}, "bzip2", bunzip2 },
         { {0x5d, 0x00}, "lzma", unlzma },
+        { {0x89, 0x4c}, "lzo", unlzo },
         { {0, 0}, NULL, NULL }
 };
 
diff --git a/lib/decompress_bunzip2.c b/lib/decompress_bunzip2.c
index 76074209f9a2..a4e971dee102 100644
--- a/lib/decompress_bunzip2.c
+++ b/lib/decompress_bunzip2.c
@@ -637,6 +637,8 @@ static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len,
 
         /* Allocate bunzip_data.  Most fields initialize to zero. */
         bd = *bdp = malloc(i);
+        if (!bd)
+                return RETVAL_OUT_OF_MEMORY;
         memset(bd, 0, sizeof(struct bunzip_data));
         /* Setup input buffer */
         bd->inbuf = inbuf;
@@ -664,6 +666,8 @@ static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len,
         bd->dbufSize = 100000*(i-BZh0);
 
         bd->dbuf = large_malloc(bd->dbufSize * sizeof(int));
+        if (!bd->dbuf)
+                return RETVAL_OUT_OF_MEMORY;
         return RETVAL_OK;
 }
 
@@ -686,7 +690,7 @@ STATIC int INIT bunzip2(unsigned char *buf, int len,
 
         if (!outbuf) {
                 error("Could not allocate output bufer");
-                return -1;
+                return RETVAL_OUT_OF_MEMORY;
         }
         if (buf)
                 inbuf = buf;
@@ -694,6 +698,7 @@ STATIC int INIT bunzip2(unsigned char *buf, int len,
                 inbuf = malloc(BZIP2_IOBUF_SIZE);
         if (!inbuf) {
                 error("Could not allocate input bufer");
+                i = RETVAL_OUT_OF_MEMORY;
                 goto exit_0;
         }
         i = start_bunzip(&bd, inbuf, len, fill);
@@ -720,11 +725,14 @@ STATIC int INIT bunzip2(unsigned char *buf, int len,
         } else if (i == RETVAL_UNEXPECTED_OUTPUT_EOF) {
                 error("Compressed file ends unexpectedly");
         }
+        if (!bd)
+                goto exit_1;
         if (bd->dbuf)
                 large_free(bd->dbuf);
         if (pos)
                 *pos = bd->inbufPos;
         free(bd);
+exit_1:
         if (!buf)
                 free(inbuf);
 exit_0:
diff --git a/lib/decompress_unlzo.c b/lib/decompress_unlzo.c
new file mode 100644
index 000000000000..db521f45626e
--- /dev/null
+++ b/lib/decompress_unlzo.c
@@ -0,0 +1,209 @@
+/*
+ * LZO decompressor for the Linux kernel. Code borrowed from the lzo
+ * implementation by Markus Franz Xaver Johannes Oberhumer.
+ *
+ * Linux kernel adaptation:
+ * Copyright (C) 2009
+ * Albin Tonnerre, Free Electrons <albin.tonnerre@free-electrons.com>
+ *
+ * Original code:
+ * Copyright (C) 1996-2005 Markus Franz Xaver Johannes Oberhumer
+ * All Rights Reserved.
+ *
+ * lzop and the LZO library are free software; you can redistribute them
+ * and/or modify them under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * 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; see the file COPYING.
+ * If not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Markus F.X.J. Oberhumer
+ * <markus@oberhumer.com>
+ * http://www.oberhumer.com/opensource/lzop/
+ */
+
+#ifdef STATIC
+#include "lzo/lzo1x_decompress.c"
+#else
+#include <linux/slab.h>
+#include <linux/decompress/unlzo.h>
+#endif
+
+#include <linux/types.h>
+#include <linux/lzo.h>
+#include <linux/decompress/mm.h>
+
+#include <linux/compiler.h>
+#include <asm/unaligned.h>
+
+static const unsigned char lzop_magic[] = {
+        0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a };
+
+#define LZO_BLOCK_SIZE        (256*1024l)
+#define HEADER_HAS_FILTER      0x00000800L
+
+STATIC inline int INIT parse_header(u8 *input, u8 *skip)
+{
+        int l;
+        u8 *parse = input;
+        u8 level = 0;
+        u16 version;
+
+        /* read magic: 9 first bits */
+        for (l = 0; l < 9; l++) {
+                if (*parse++ != lzop_magic[l])
+                        return 0;
+        }
+        /* get version (2bytes), skip library version (2),
+         * 'need to be extracted' version (2) and
+         * method (1) */
+        version = get_unaligned_be16(parse);
+        parse += 7;
+        if (version >= 0x0940)
+                level = *parse++;
+        if (get_unaligned_be32(parse) & HEADER_HAS_FILTER)
+                parse += 8; /* flags + filter info */
+        else
+                parse += 4; /* flags */
+
+        /* skip mode and mtime_low */
+        parse += 8;
+        if (version >= 0x0940)
+                parse += 4;     /* skip mtime_high */
+
+        l = *parse++;
+        /* don't care about the file name, and skip checksum */
+        parse += l + 4;
+
+        *skip = parse - input;
+        return 1;
+}
+
+STATIC inline int INIT unlzo(u8 *input, int in_len,
+                                int (*fill) (void *, unsigned int),
+                                int (*flush) (void *, unsigned int),
+                                u8 *output, int *posp,
+                                void (*error_fn) (char *x))
+{
+        u8 skip = 0, r = 0;
+        u32 src_len, dst_len;
+        size_t tmp;
+        u8 *in_buf, *in_buf_save, *out_buf;
+        int obytes_processed = 0;
+
+        set_error_fn(error_fn);
+
+        if (output) {
+                out_buf = output;
+        } else if (!flush) {
+                error("NULL output pointer and no flush function provided");
+                goto exit;
+        } else {
+                out_buf = malloc(LZO_BLOCK_SIZE);
+                if (!out_buf) {
+                        error("Could not allocate output buffer");
+                        goto exit;
+                }
+        }
+
+        if (input && fill) {
+                error("Both input pointer and fill function provided, don't know what to do");
+                goto exit_1;
+        } else if (input) {
+                in_buf = input;
+        } else if (!fill || !posp) {
+                error("NULL input pointer and missing position pointer or fill function");
+                goto exit_1;
+        } else {
+                in_buf = malloc(lzo1x_worst_compress(LZO_BLOCK_SIZE));
+                if (!in_buf) {
+                        error("Could not allocate input buffer");
+                        goto exit_1;
+                }
+        }
+        in_buf_save = in_buf;
+
+        if (posp)
+                *posp = 0;
+
+        if (fill)
+                fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE));
+
+        if (!parse_header(input, &skip)) {
+                error("invalid header");
+                goto exit_2;
+        }
+        in_buf += skip;
+
+        if (posp)
+                *posp = skip;
+
+        for (;;) {
+                /* read uncompressed block size */
+                dst_len = get_unaligned_be32(in_buf);
+                in_buf += 4;
+
+                /* exit if last block */
+                if (dst_len == 0) {
+                        if (posp)
+                                *posp += 4;
+                        break;
+                }
+
+                if (dst_len > LZO_BLOCK_SIZE) {
+                        error("dest len longer than block size");
+                        goto exit_2;
+                }
+
+                /* read compressed block size, and skip block checksum info */
+                src_len = get_unaligned_be32(in_buf);
+                in_buf += 8;
+
+                if (src_len <= 0 || src_len > dst_len) {
+                        error("file corrupted");
+                        goto exit_2;
+                }
+
+                /* decompress */
+                tmp = dst_len;
+                r = lzo1x_decompress_safe((u8 *) in_buf, src_len,
+                                                out_buf, &tmp);
+
+                if (r != LZO_E_OK || dst_len != tmp) {
+                        error("Compressed data violation");
+                        goto exit_2;
+                }
+
+                obytes_processed += dst_len;
+                if (flush)
+                        flush(out_buf, dst_len);
+                if (output)
+                        out_buf += dst_len;
+                if (posp)
+                        *posp += src_len + 12;
+                if (fill) {
+                        in_buf = in_buf_save;
+                        fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE));
+                } else
+                        in_buf += src_len;
+        }
+
+exit_2:
+        if (!input)
+                free(in_buf);
+exit_1:
+        if (!output)
+                free(out_buf);
+exit:
+        return obytes_processed;
+}
+
+#define decompress unlzo
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index d9b08e0f7f55..ba8b67039d13 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -587,7 +587,7 @@ out_unlock:
         return count;
 }
 
-const struct file_operations filter_fops = {
+static const struct file_operations filter_fops = {
         .read  = filter_read,
         .write = filter_write,
 };
@@ -670,12 +670,13 @@ static int device_dma_allocations(struct device *dev)
         return count;
 }
 
-static int dma_debug_device_change(struct notifier_block *nb,
-                                    unsigned long action, void *data)
+static int dma_debug_device_change(struct notifier_block *nb, unsigned long action, void *data)
 {
         struct device *dev = data;
         int count;
 
+        if (global_disable)
+                return 0;
 
         switch (action) {
         case BUS_NOTIFY_UNBOUND_DRIVER:
@@ -697,6 +698,9 @@ void dma_debug_add_bus(struct bus_type *bus)
 {
         struct notifier_block *nb;
 
+        if (global_disable)
+                return;
+
         nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
         if (nb == NULL) {
                 pr_err("dma_debug_add_bus: out of memory\n");
@@ -909,6 +913,9 @@ static void check_sync(struct device *dev,
                                 ref->size);
         }
 
+        if (entry->direction == DMA_BIDIRECTIONAL)
+                goto out;
+
         if (ref->direction != entry->direction) {
                 err_printk(dev, entry, "DMA-API: device driver syncs "
                                 "DMA memory with different direction "
@@ -919,9 +926,6 @@ static void check_sync(struct device *dev,
                                 dir2name[ref->direction]);
         }
 
-        if (entry->direction == DMA_BIDIRECTIONAL)
-                goto out;
-
         if (to_cpu && !(entry->direction == DMA_FROM_DEVICE) &&
                       !(ref->direction == DMA_TO_DEVICE))
                 err_printk(dev, entry, "DMA-API: device driver syncs "
@@ -944,7 +948,6 @@ static void check_sync(struct device *dev,
 
 out:
         put_hash_bucket(bucket, &flags);
-
 }
 
 void debug_dma_map_page(struct device *dev, struct page *page, size_t offset,
diff --git a/lib/idr.c b/lib/idr.c
index 21f9266d1e41..5ee8b1a57370 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -156,10 +156,12 @@ static int sub_alloc(struct idr *idp, int *starting_id, struct idr_layer **pa)
                         id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;
 
                         /* if already at the top layer, we need to grow */
-                        if (!(p = pa[l])) {
+                        if (id >= 1 << (idp->layers * IDR_BITS)) {
                                 *starting_id = id;
                                 return IDR_NEED_TO_GROW;
                         }
+                        p = pa[l];
+                        BUG_ON(!p);
 
                         /* If we need to go up one layer, continue the
                          * loop; otherwise, restart from the top.
diff --git a/lib/list_sort.c b/lib/list_sort.c
new file mode 100644
index 000000000000..19d11e0bb958
--- /dev/null
+++ b/lib/list_sort.c
@@ -0,0 +1,102 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/list_sort.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+
+/**
+ * list_sort - sort a list.
+ * @priv: private data, passed to @cmp
+ * @head: the list to sort
+ * @cmp: the elements comparison function
+ *
+ * This function has been implemented by Mark J Roberts <mjr@znex.org>. It
+ * implements "merge sort" which has O(nlog(n)) complexity. The list is sorted
+ * in ascending order.
+ *
+ * The comparison function @cmp is supposed to return a negative value if @a is
+ * less than @b, and a positive value if @a is greater than @b. If @a and @b
+ * are equivalent, then it does not matter what this function returns.
+ */
+void list_sort(void *priv, struct list_head *head,
+               int (*cmp)(void *priv, struct list_head *a,
+                          struct list_head *b))
+{
+        struct list_head *p, *q, *e, *list, *tail, *oldhead;
+        int insize, nmerges, psize, qsize, i;
+
+        if (list_empty(head))
+                return;
+
+        list = head->next;
+        list_del(head);
+        insize = 1;
+        for (;;) {
+                p = oldhead = list;
+                list = tail = NULL;
+                nmerges = 0;
+
+                while (p) {
+                        nmerges++;
+                        q = p;
+                        psize = 0;
+                        for (i = 0; i < insize; i++) {
+                                psize++;
+                                q = q->next == oldhead ? NULL : q->next;
+                                if (!q)
+                                        break;
+                        }
+
+                        qsize = insize;
+                        while (psize > 0 || (qsize > 0 && q)) {
+                                if (!psize) {
+                                        e = q;
+                                        q = q->next;
+                                        qsize--;
+                                        if (q == oldhead)
+                                                q = NULL;
+                                } else if (!qsize || !q) {
+                                        e = p;
+                                        p = p->next;
+                                        psize--;
+                                        if (p == oldhead)
+                                                p = NULL;
+                                } else if (cmp(priv, p, q) <= 0) {
+                                        e = p;
+                                        p = p->next;
+                                        psize--;
+                                        if (p == oldhead)
+                                                p = NULL;
+                                } else {
+                                        e = q;
+                                        q = q->next;
+                                        qsize--;
+                                        if (q == oldhead)
+                                                q = NULL;
+                                }
+                                if (tail)
+                                        tail->next = e;
+                                else
+                                        list = e;
+                                e->prev = tail;
+                                tail = e;
+                        }
+                        p = q;
+                }
+
+                tail->next = list;
+                list->prev = tail;
+
+                if (nmerges <= 1)
+                        break;
+
+                insize *= 2;
+        }
+
+        head->next = list;
+        head->prev = list->prev;
+        list->prev->next = head;
+        list->prev = head;
+}
+
+EXPORT_SYMBOL(list_sort);
diff --git a/lib/lmb.c b/lib/lmb.c
index 0343c05609f0..9cee17142b2c 100644
--- a/lib/lmb.c
+++ b/lib/lmb.c
@@ -263,7 +263,7 @@ long __init lmb_reserve(u64 base, u64 size)
         return lmb_add_region(_rgn, base, size);
 }
 
-long __init lmb_overlaps_region(struct lmb_region *rgn, u64 base, u64 size)
+long lmb_overlaps_region(struct lmb_region *rgn, u64 base, u64 size)
 {
         unsigned long i;
 
@@ -493,6 +493,11 @@ int __init lmb_is_reserved(u64 addr)
         return 0;
 }
 
+int lmb_is_region_reserved(u64 base, u64 size)
+{
+        return lmb_overlaps_region(&lmb.reserved, base, size);
+}
+
 /*
  * Given a <base, len>, find which memory regions belong to this range.
  * Adjust the request and return a contiguous chunk.
diff --git a/lib/lzo/lzo1x_decompress.c b/lib/lzo/lzo1x_decompress.c
index 5dc6b29c1575..f2fd09850223 100644
--- a/lib/lzo/lzo1x_decompress.c
+++ b/lib/lzo/lzo1x_decompress.c
@@ -11,11 +11,13 @@
  *  Richard Purdie <rpurdie@openedhand.com>
  */
 
+#ifndef STATIC
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/lzo.h>
-#include <asm/byteorder.h>
+#endif
+
 #include <asm/unaligned.h>
+#include <linux/lzo.h>
 #include "lzodefs.h"
 
 #define HAVE_IP(x, ip_end, ip) ((size_t)(ip_end - ip) < (x))
@@ -244,9 +246,10 @@ lookbehind_overrun:
         *out_len = op - out;
         return LZO_E_LOOKBEHIND_OVERRUN;
 }
-
+#ifndef STATIC
 EXPORT_SYMBOL_GPL(lzo1x_decompress_safe);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("LZO1X Decompressor");
 
+#endif
diff --git a/lib/rational.c b/lib/rational.c
index b3c099b5478e..3ed247b80662 100644
--- a/lib/rational.c
+++ b/lib/rational.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/rational.h>
+#include <linux/module.h>
 
 /*
  * calculate best rational approximation for a given fraction
diff --git a/lib/string.c b/lib/string.c
index afce96af3afd..a1cdcfcc42d0 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -338,10 +338,10 @@ EXPORT_SYMBOL(strnchr);
 #endif
 
 /**
- * skip_spaces - Removes leading whitespace from @s.
- * @s: The string to be stripped.
+ * skip_spaces - Removes leading whitespace from @str.
+ * @str: The string to be stripped.
  *
- * Returns a pointer to the first non-whitespace character in @s.
+ * Returns a pointer to the first non-whitespace character in @str.
  */
 char *skip_spaces(const char *str)
 {
@@ -667,7 +667,7 @@ EXPORT_SYMBOL(memscan);
  */
 char *strstr(const char *s1, const char *s2)
 {
-        int l1, l2;
+        size_t l1, l2;
 
         l2 = strlen(s2);
         if (!l2)
@@ -684,6 +684,31 @@ char *strstr(const char *s1, const char *s2)
 EXPORT_SYMBOL(strstr);
 #endif
 
+#ifndef __HAVE_ARCH_STRNSTR
+/**
+ * strnstr - Find the first substring in a length-limited string
+ * @s1: The string to be searched
+ * @s2: The string to search for
+ * @len: the maximum number of characters to search
+ */
+char *strnstr(const char *s1, const char *s2, size_t len)
+{
+        size_t l1 = len, l2;
+
+        l2 = strlen(s2);
+        if (!l2)
+                return (char *)s1;
+        while (l1 >= l2) {
+                l1--;
+                if (!memcmp(s1, s2, l2))
+                        return (char *)s1;
+                s1++;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(strnstr);
+#endif
+
 #ifndef __HAVE_ARCH_MEMCHR
 /**
  * memchr - Find a character in an area of memory.
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 735343fc857a..3b8aeec4e327 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -903,7 +903,7 @@ static char *uuid_string(char *buf, char *end, const u8 *addr,
  *       IPv6 omits the colons (01020304...0f)
  *       IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
  * - 'I6c' for IPv6 addresses printed as specified by
- *       http://www.ietf.org/id/draft-kawamura-ipv6-text-representation-03.txt
+ *       http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
  * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
  *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  *       Options for %pU are:
@@ -1179,7 +1179,18 @@ qualifier:
  * %ps output the name of a text symbol without offset
  * %pF output the name of a function pointer with its offset
  * %pf output the name of a function pointer without its offset
- * %pR output the address range in a struct resource
+ * %pR output the address range in a struct resource with decoded flags
+ * %pr output the address range in a struct resource with raw flags
+ * %pM output a 6-byte MAC address with colons
+ * %pm output a 6-byte MAC address without colons
+ * %pI4 print an IPv4 address without leading zeros
+ * %pi4 print an IPv4 address with leading zeros
+ * %pI6 print an IPv6 address with colons
+ * %pi6 print an IPv6 address without colons
+ * %pI6c print an IPv6 address as specified by
+ *   http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
+ * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
+ *   case.
  * %n is ignored
  *
  * The return value is the number of characters which would
diff --git a/lib/zlib_inflate/inffast.c b/lib/zlib_inflate/inffast.c
index 8550b0c05d00..215447c55261 100644
--- a/lib/zlib_inflate/inffast.c
+++ b/lib/zlib_inflate/inffast.c
@@ -8,6 +8,21 @@
 #include "inflate.h"
 #include "inffast.h"
 
+/* Only do the unaligned "Faster" variant when
+ * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS is set
+ *
+ * On powerpc, it won't be as we don't include autoconf.h
+ * automatically for the boot wrapper, which is intended as
+ * we run in an environment where we may not be able to deal
+ * with (even rare) alignment faults. In addition, we do not
+ * define __KERNEL__ for arch/powerpc/boot unlike x86
+ */
+
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+#include <asm/unaligned.h>
+#include <asm/byteorder.h>
+#endif
+
 #ifndef ASMINF
 
 /* Allow machine dependent optimization for post-increment or pre-increment.
@@ -24,9 +39,11 @@
 #ifdef POSTINC
 #  define OFF 0
 #  define PUP(a) *(a)++
+#  define UP_UNALIGNED(a) get_unaligned((a)++)
 #else
 #  define OFF 1
 #  define PUP(a) *++(a)
+#  define UP_UNALIGNED(a) get_unaligned(++(a))
 #endif
 
 /*
@@ -239,18 +256,62 @@ void inflate_fast(z_streamp strm, unsigned start)
                     }
                 }
                 else {
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+                    unsigned short *sout;
+                    unsigned long loops;
+
+                    from = out - dist;          /* copy direct from output */
+                    /* minimum length is three */
+                    /* Align out addr */
+                    if (!((long)(out - 1 + OFF) & 1)) {
+                        PUP(out) = PUP(from);
+                        len--;
+                    }
+                    sout = (unsigned short *)(out - OFF);
+                    if (dist > 2) {
+                        unsigned short *sfrom;
+
+                        sfrom = (unsigned short *)(from - OFF);
+                        loops = len >> 1;
+                        do
+                            PUP(sout) = UP_UNALIGNED(sfrom);
+                        while (--loops);
+                        out = (unsigned char *)sout + OFF;
+                        from = (unsigned char *)sfrom + OFF;
+                    } else { /* dist == 1 or dist == 2 */
+                        unsigned short pat16;
+
+                        pat16 = *(sout-2+2*OFF);
+                        if (dist == 1)
+#if defined(__BIG_ENDIAN)
+                            pat16 = (pat16 & 0xff) | ((pat16 & 0xff) << 8);
+#elif defined(__LITTLE_ENDIAN)
+                            pat16 = (pat16 & 0xff00) | ((pat16 & 0xff00) >> 8);
+#else
+#error __BIG_ENDIAN nor __LITTLE_ENDIAN is defined
+#endif
+                        loops = len >> 1;
+                        do
+                            PUP(sout) = pat16;
+                        while (--loops);
+                        out = (unsigned char *)sout + OFF;
+                    }
+                    if (len & 1)
+                        PUP(out) = PUP(from);
+#else /* CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */
                     from = out - dist;          /* copy direct from output */
                     do {                        /* minimum length is three */
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
+                         PUP(out) = PUP(from);
+                         PUP(out) = PUP(from);
+                         PUP(out) = PUP(from);
+                         len -= 3;
                     } while (len > 2);
                     if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
+                         PUP(out) = PUP(from);
+                         if (len > 1)
+                             PUP(out) = PUP(from);
                     }
+#endif /* !CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */
                 }
             }
             else if ((op & 64) == 0) {          /* 2nd level distance code */