linux-imx

/*

 *  LZO1X Compressor from LZO

 *

 *  Copyright (C) 1996-2012 Markus F.X.J. Oberhumer <markus@oberhumer.com>

 *

 *  The full LZO package can be found at:

 *  http://www.oberhumer.com/opensource/lzo/

 *

 *  Changed for Linux kernel use by:

 *  Nitin Gupta <nitingupta910@gmail.com>

 *  Richard Purdie <rpurdie@openedhand.com>

 */

​

#include <linux/module.h>

#include <linux/kernel.h>

#include <asm/unaligned.h>

#include <linux/lzo.h>

#include "lzodefs.h"

​

static noinline size_t

lzo1x_1_do_compress(const unsigned char *in, size_t in_len,

            unsigned char *out, size_t *out_len,

            size_t ti, void *wrkmem, signed char *state_offset,

            const unsigned char bitstream_version)

{

    const unsigned char *ip;

    unsigned char *op;

    const unsigned char * const in_end = in + in_len;

    const unsigned char * const ip_end = in + in_len - 20;

    const unsigned char *ii;

    lzo_dict_t * const dict = (lzo_dict_t *) wrkmem;

​

    op = out;

    ip = in;

    ii = ip;

    ip += ti < 4 ? 4 - ti : 0;

​

    for (;;) {

        const unsigned char *m_pos = NULL;

        size_t t, m_len, m_off;

        u32 dv;

        u32 run_length = 0;

literal:

        ip += 1 + ((ip - ii) >> 5);

next:

        if (unlikely(ip >= ip_end))

            break;

        dv = get_unaligned_le32(ip);

​

        if (dv == 0 && bitstream_version) {

            const unsigned char *ir = ip + 4;

            const unsigned char *limit = ip_end

                < (ip + MAX_ZERO_RUN_LENGTH + 1)

                ? ip_end : ip + MAX_ZERO_RUN_LENGTH + 1;

#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && \

    defined(LZO_FAST_64BIT_MEMORY_ACCESS)

            u64 dv64;

​

            for (; (ir + 32) <= limit; ir += 32) {

                dv64 = get_unaligned((u64 *)ir);

                dv64 |= get_unaligned((u64 *)ir + 1);

                dv64 |= get_unaligned((u64 *)ir + 2);

                dv64 |= get_unaligned((u64 *)ir + 3);

                if (dv64)

                    break;

            }

            for (; (ir + 8) <= limit; ir += 8) {

                dv64 = get_unaligned((u64 *)ir);

                if (dv64) {

#  if defined(__LITTLE_ENDIAN)

                    ir += __builtin_ctzll(dv64) >> 3;

#  elif defined(__BIG_ENDIAN)

                    ir += __builtin_clzll(dv64) >> 3;

#  else

#    error "missing endian definition"

#  endif

                    break;

                }

            }

#else

            while ((ir < (const unsigned char *)

                    ALIGN((uintptr_t)ir, 4)) &&

                    (ir < limit) && (*ir == 0))

                ir++;

            for (; (ir + 4) <= limit; ir += 4) {

                dv = *((u32 *)ir);

                if (dv) {

#  if defined(__LITTLE_ENDIAN)

                    ir += __builtin_ctz(dv) >> 3;

#  elif defined(__BIG_ENDIAN)

                    ir += __builtin_clz(dv) >> 3;

#  else