/*

* NX-GZIP compression accelerator user library

* implementing zlib library interfaces

*

* Copyright (C) IBM Corporation, 2011-2017

*

* Licenses for GPLv2 and Apache v2.0:

*

* GPLv2:

*

* 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; 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.

*

*

* Apache v2.0:

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*

* Authors: Bulent Abali <[email protected]>

* Xiao Lei Hu <[email protected]>

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <string.h>

#include <unistd.h>

#include <stdint.h>

#include <assert.h>

#include <errno.h>

#include <sys/fcntl.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <endian.h>

#include <pthread.h>

#include <sys/platform/ppc.h>

#include "nxu.h"

#include "nx_dbg.h"

#ifndef _NX_ZLIB_H

#define _NX_ZLIB_H

#define NX_GZIP_TYPE 9 /* 9 for P9 */

#define NX_MIN(X,Y) (((X)<(Y))?(X):(Y))

#define NX_MAX(X,Y) (((X)>(Y))?(X):(Y))

#define ASSERT(X) assert(X)

#ifndef __unused

# define __unused __attribute__((unused))

#endif

#define likely(x) __builtin_expect(!!(x), 1)

#define unlikely(x) __builtin_expect(!!(x), 0)

/* debug flags for libnx */

#define NX_VERBOSE_LIBNX_MASK 0x000000ff

#define NX_DEVICES_MAX 256

/* deflate header */

#define HEADER_RAW 0

#define HEADER_ZLIB 1

#define HEADER_GZIP 2

#ifndef MAX_WBITS

# define MAX_WBITS 15

#endif

#ifndef DEF_WBITS

# define DEF_WBITS MAX_WBITS

#endif

#define NXQWSZ (sizeof(nx_qw_t))

extern FILE *nx_gzip_log;

/* common config variables for all streams */

struct nx_config_t {

};

typedef struct nx_config_t *nx_configp_t;

extern struct nx_config_t nx_config;

extern int nx_dht_config;

/* NX device handle */

struct nx_dev_t {

};

typedef struct nx_dev_t *nx_devp_t;

#define NX_DEVICES_MAX 256

/* save recent header bytes for hcrc calculations */

typedef struct ckbuf_t { char buf[128]; } ckbuf_t;

/* z_stream equivalent of NX hardware */

typedef struct nx_stream_s {

} nx_stream;

typedef struct nx_stream_s *nx_streamp;

/* stream pointers and lengths manipulated */

#define update_stream_out(s,b) do{(s)->next_out = (b); (s)->total_out = (b); (s)->avail_out -= (b);}while(0)

#define update_stream_in(s,b) do{(s)->next_in = (b); (s)->total_in = (b); (s)->avail_in -= (b);}while(0)

#define copy_stream_in(d,s) do{(d)->next_in = (s)->next_in; (d)->total_in = (s)->total_in; (d)->avail_in = (s)->avail_in;}while(0)

#define copy_stream_out(d,s) do{(d)->next_out = (s)->next_out; (d)->total_out = (s)->total_out; (d)->avail_out = (s)->avail_out;}while(0)

/* Fifo buffer management. NX has scatter gather capability.

We treat the fifo queue in two steps: from current head (or tail) to

the fifo end referred to as "first" and from 0 to the current tail (or head)

referred to as "last". To add sz bytes to the fifo

1. test fifo_free_bytes >= sz

2. get fifo_free_first_bytes and fifo_free_last_bytes amounts

3. get fifo_free_first_offset and fifo_free_last_offset addresses

4. append to fifo_free_first_offset; increase 'used'

5. if any data remaining, append to fifo_free_last_offset

To remove sz bytes from the fifo

1. test fifo_used_bytes >= sz

2. get fifo_used_first_bytes and fifo_used_last_bytes

3. get fifo_used_first_offset and fifo_used_last_offset

4. remove from fifo_used_first_offset; increase 'cur' mod 'fifolen', decrease 'used'

5. if more data to go, remove from fifo_used_last_offset

*/

#define fifo_used_bytes(used) (used)

#define fifo_free_bytes(used, len) ((len)-(used))

// amount of free bytes in the first and last parts

#define fifo_free_first_bytes(cur, used, len) ((((cur) (used))<=(len))? (len)-((cur) (used)): 0)

#define fifo_free_last_bytes(cur, used, len) ((((cur) (used))<=(len))? (cur): (len)-(used))

// amount of used bytes in the first and last parts

#define fifo_used_first_bytes(cur, used, len) ((((cur) (used))<=(len))? (used) : (len)-(cur))

#define fifo_used_last_bytes(cur, used, len) ((((cur) (used))<=(len))? 0: ((used) (cur))-(len))

// first and last free parts start here

#define fifo_free_first_offset(cur, used) ((cur) (used))

#define fifo_free_last_offset(cur, used, len) fifo_used_last_bytes(cur, used, len)

// first and last used parts start here

#define fifo_used_first_offset(cur) (cur)

#define fifo_used_last_offset(cur) (0)

/* for appending bytes in to the stream */

#define nx_put_byte(s,b) do { if ((s)->avail_out > 0) \

{ *((s)->next_out ) = (b); --(s)->avail_out; (s)->total_out; \

*((s)->zstrm->next_out ) = (b); --(s)->zstrm->avail_out; (s)->zstrm->total_out; } \

else { *((s)->fifo_out (s)->cur_out (s)->used_out) = (b); (s)->used_out; } } while(0)

/* nx_inflate_get_byte is used for header processing. It goes to

inf_return when bytes are not sufficient */

#define nx_inflate_get_byte(s,b) \

do { if ((s)->avail_in == 0) goto inf_return; b = (s)->ckbuf.buf[(s)->ckidx ] = *((s)->next_in); \

update_stream_in(s,1); update_stream_in(s->zstrm, 1);\

if ((s)->ckidx == sizeof(ckbuf_t)) { \

/* when the buffer is near full do a partial checksum */ \

(s)->cksum = nx_crc32((s)->cksum, (s)->ckbuf.buf, (s)->ckidx); \

(s)->ckidx = 0; } \

} while(0)

#define print_dbg_info(s, line) \

do { prt_info(\

"== %s:%d avail_in %ld total_in %ld \

used_in %ld cur_in %ld \

avail_out %ld total_out %ld \

used_out %ld cur_out %ld \

len_in %ld len_out %ld\n", __FUNCTION__, line, \

(long)(s)->avail_in, (long)(s)->total_in, \

(long)(s)->used_in, (long)(s)->cur_in, \

(long)(s)->avail_out, (long)(s)->total_out, \

(long)(s)->used_out, (long)(s)->cur_out, \

(long)(s)->len_in, (long)(s)->len_out); \

} while (0)

/* inflate states */

typedef enum {

inf_state_header = 0,

inf_state_gzip_id1,

inf_state_gzip_id2,

inf_state_gzip_cm,

inf_state_gzip_flg,

inf_state_gzip_mtime,

inf_state_gzip_xfl,

inf_state_gzip_os,

inf_state_gzip_xlen,

inf_state_gzip_extra,

inf_state_gzip_name,

inf_state_gzip_comment,

inf_state_gzip_hcrc,

inf_state_zlib_id1,

inf_state_zlib_flg,

inf_state_zlib_dict,

inf_state_zlib_dictid,

inf_state_inflate,

inf_state_data_error,

inf_state_mem_error,

inf_state_buf_error,

inf_state_stream_error,

} inf_state_t;

#define ZLIB_SIZE_SLOTS 256 /* Each slot represents 4KiB, the last

slot is represending everything

which larger or equal 1024KiB */

struct zlib_stats {

};

extern pthread_mutex_t zlib_stats_mutex;

extern struct zlib_stats zlib_stats;

inline void zlib_stats_inc(unsigned long *count)

{

if (!nx_gzip_gather_statistics())

return;

pthread_mutex_lock(&zlib_stats_mutex);

*count = *count 1;

pthread_mutex_unlock(&zlib_stats_mutex);

}

static inline uint64_t get_nxtime_now(void)

{

return __ppc_get_timebase();

}

static inline uint64_t get_nxtime_diff(uint64_t t1, uint64_t t2)

{

if (t2 > t1) {

return t2-t1;

}else{

return (0xFFFFFFFFFFFFFFF-t1) t2;

}

}

#ifndef __KERNEL__

static inline double nxtime_to_us(uint64_t nxtime)

{

uint64_t freq;

freq = __ppc_get_timebase_freq();

return (double)(nxtime * 1000000 / freq) ;

}

#endif

#ifndef ARRAY_SIZE

# define ARRAY_SIZE(a) (sizeof((a)) / sizeof((a)[0]))

#endif

/* gzip_vas.c */

extern void *nx_fault_storage_address;

extern void *nx_function_begin(int function, int pri);

extern int nx_function_end(void *vas_handle);

/* zlib crc32.c and adler32.c */

extern unsigned long nx_crc32_combine(unsigned long crc1, unsigned long crc2, uint64_t len2);

extern unsigned long nx_adler32_combine(unsigned long adler1, unsigned long adler2, uint64_t len2);

extern unsigned long nx_crc32(unsigned long crc, const unsigned char *buf, uint64_t len);

/* nx_zlib.c */

extern nx_devp_t nx_open(int nx_id);

extern int nx_close(nx_devp_t nxdevp);

extern int nx_touch_pages(void *buf, long buf_len, long page_len, int wr);

extern void *nx_alloc_buffer(uint32_t len, long alignment, int lock);

extern void nx_free_buffer(void *buf, uint32_t len, int unlock);

extern int nx_submit_job(nx_dde_t *src, nx_dde_t *dst, nx_gzip_crb_cpb_t *cmdp, void *handle);

extern int nx_append_dde(nx_dde_t *ddl, void *addr, uint32_t len);

extern int nx_touch_pages_dde(nx_dde_t *ddep, long buf_sz, long page_sz, int wr);

extern int nx_copy(char *dst, char *src, uint64_t len, uint32_t *crc, uint32_t *adler, nx_devp_t nxdevp);

extern void nx_hw_init(void);

extern void nx_hw_done(void);

/* nx_deflate.c */

extern int nx_deflateInit_(z_streamp strm, int level, const char *version, int stream_size);

extern int nx_deflateInit2_(z_streamp strm, int level, int method, int windowBits,

int memLevel __unused, int strategy, const char *version __unused, int stream_size __unused);

#define nx_deflateInit(strm, level) nx_deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))

extern int nx_deflate(z_streamp strm, int flush);

extern int nx_deflateEnd(z_streamp strm);

extern unsigned long nx_deflateBound(z_streamp strm, unsigned long sourceLen);

/* nx_inflate.c */

extern int nx_inflateInit_(z_streamp strm, const char *version, int stream_size);

extern int nx_inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size);

#define nx_inflateInit(strm) nx_inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))

extern int nx_inflate(z_streamp strm, int flush);

extern int nx_inflateEnd(z_streamp strm);

/* nx_compress.c */

extern int nx_compress2(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level);

extern int nx_compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen);

extern uLong nx_compressBound(uLong sourceLen);

/* nx_uncompr.c */

extern int nx_uncompress2(Bytef *dest, uLongf *destLen, const Bytef *source, uLong *sourceLen);

extern int nx_uncompress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen);

/* nx_dht.c */

extern void *dht_begin(char *ifile, char *ofile);

extern void dht_end(void *handle);

extern int dht_lookup(nx_gzip_crb_cpb_t *cmdp, int request, void *handle);

#endif /* _NX_ZLIB_H */