[mirror_ubuntu-bionic-kernel.git] / drivers / misc / altera-stapl / altera-comp.c

/*
 * altera-comp.c
 *
 * altera FPGA driver
 *
 * Copyright (C) Altera Corporation 1998-2001
 * Copyright (C) 2010 NetUP Inc.
 * Copyright (C) 2010 Igor M. Liplianin <liplianin@netup.ru>
 *
 * 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.
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/kernel.h>
#include "altera-exprt.h"

#define	SHORT_BITS		16
#define	CHAR_BITS		8
#define	DATA_BLOB_LENGTH	3
#define	MATCH_DATA_LENGTH	8192
#define ALTERA_REQUEST_SIZE	1024
#define ALTERA_BUFFER_SIZE	(MATCH_DATA_LENGTH + ALTERA_REQUEST_SIZE)

static u32 altera_bits_req(u32 n)
{
	u32 result = SHORT_BITS;

	if (n == 0)
		result = 1;
	else {
		/* Look for the highest non-zero bit position */
		while ((n & (1 << (SHORT_BITS - 1))) == 0) {
			n <<= 1;
			--result;
		}
	}

	return result;
}

static u32 altera_read_packed(u8 *buffer, u32 bits, u32 *bits_avail,
							u32 *in_index)
{
	u32 result = 0;
	u32 shift = 0;
	u32 databyte = 0;

	while (bits > 0) {
		databyte = buffer[*in_index];
		result |= (((databyte >> (CHAR_BITS - *bits_avail))
			& (0xff >> (CHAR_BITS - *bits_avail))) << shift);

		if (bits <= *bits_avail) {
			result &= (0xffff >> (SHORT_BITS - (bits + shift)));
			*bits_avail -= bits;
			bits = 0;
		} else {
			++(*in_index);
			shift += *bits_avail;
			bits -= *bits_avail;
			*bits_avail = CHAR_BITS;
		}
	}

	return result;
}

u32 altera_shrink(u8 *in, u32 in_length, u8 *out, u32 out_length, s32 version)
{
	u32 i, j, data_length = 0L;
	u32 offset, length;
	u32 match_data_length = MATCH_DATA_LENGTH;
	u32 bits_avail = CHAR_BITS;
	u32 in_index = 0L;

	if (version > 0)
		--match_data_length;

	for (i = 0; i < out_length; ++i)
		out[i] = 0;

	/* Read number of bytes in data. */
	for (i = 0; i < sizeof(in_length); ++i) {
		data_length = data_length | (
			altera_read_packed(in,
					CHAR_BITS,
					&bits_avail,
					&in_index) << (i * CHAR_BITS));
	}

	if (data_length > out_length) {
		data_length = 0L;
		return data_length;
	}

	i = 0;
	while (i < data_length) {
		/* A 0 bit indicates literal data. */
		if (altera_read_packed(in, 1, &bits_avail,
						&in_index) == 0) {
			for (j = 0; j < DATA_BLOB_LENGTH; ++j) {
				if (i < data_length) {
					out[i] = (u8)altera_read_packed(in,
							CHAR_BITS,
							&bits_avail,
							&in_index);
					i++;
				}
			}
		} else {
			/* A 1 bit indicates offset/length to follow. */
			offset = altera_read_packed(in, altera_bits_req((s16)
					(i > match_data_length ?
						match_data_length : i)),
					&bits_avail,
					&in_index);
			length = altera_read_packed(in, CHAR_BITS,
					&bits_avail,
					&in_index);
			for (j = 0; j < length; ++j) {
				if (i < data_length) {
					out[i] = out[i - offset];
					i++;
				}
			}
		}
	}

	return data_length;
}
Commit	Line	Data
fa766c9b IL	1	/*
	2	* altera-comp.c
	3	*
	4	* altera FPGA driver
	5	*
	6	* Copyright (C) Altera Corporation 1998-2001
	7	* Copyright (C) 2010 NetUP Inc.
	8	* Copyright (C) 2010 Igor M. Liplianin <liplianin@netup.ru>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	*
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	24	*/
	25
	26	#include <linux/kernel.h>
	27	#include "altera-exprt.h"
	28
	29	#define SHORT_BITS 16
	30	#define CHAR_BITS 8
	31	#define DATA_BLOB_LENGTH 3
	32	#define MATCH_DATA_LENGTH 8192
	33	#define ALTERA_REQUEST_SIZE 1024
	34	#define ALTERA_BUFFER_SIZE (MATCH_DATA_LENGTH + ALTERA_REQUEST_SIZE)
	35
	36	static u32 altera_bits_req(u32 n)
	37	{
	38	u32 result = SHORT_BITS;
	39
	40	if (n == 0)
	41	result = 1;
	42	else {
	43	/* Look for the highest non-zero bit position */
	44	while ((n & (1 << (SHORT_BITS - 1))) == 0) {
	45	n <<= 1;
	46	--result;
	47	}
	48	}
	49
	50	return result;
	51	}
	52
	53	static u32 altera_read_packed(u8 buffer, u32 bits, u32 bits_avail,
	54	u32 *in_index)
	55	{
	56	u32 result = 0;
	57	u32 shift = 0;
	58	u32 databyte = 0;
	59
	60	while (bits > 0) {
	61	databyte = buffer[*in_index];
	62	result \|= (((databyte >> (CHAR_BITS - *bits_avail))
	63	& (0xff >> (CHAR_BITS - *bits_avail))) << shift);
	64
65	if (bits <= *bits_avail) {
66	result &= (0xffff >> (SHORT_BITS - (bits + shift)));
67	*bits_avail -= bits;
68	bits = 0;
69	} else {
70	++(*in_index);
71	shift += *bits_avail;
72	bits -= *bits_avail;
73	*bits_avail = CHAR_BITS;
74	}
75	}
76
77	return result;
78	}
79
80	u32 altera_shrink(u8 in, u32 in_length, u8 out, u32 out_length, s32 version)
81	{
82	u32 i, j, data_length = 0L;
83	u32 offset, length;
84	u32 match_data_length = MATCH_DATA_LENGTH;
85	u32 bits_avail = CHAR_BITS;
86	u32 in_index = 0L;
87
88	if (version > 0)
89	--match_data_length;
90
91	for (i = 0; i < out_length; ++i)
92	out[i] = 0;
93
94	/* Read number of bytes in data. */
95	for (i = 0; i < sizeof(in_length); ++i) {
96	data_length = data_length \| (
97	altera_read_packed(in,
98	CHAR_BITS,
99	&bits_avail,
100	&in_index) << (i * CHAR_BITS));
101	}
102
103	if (data_length > out_length) {
104	data_length = 0L;
105	return data_length;
106	}
107
108	i = 0;
109	while (i < data_length) {
110	/* A 0 bit indicates literal data. */
111	if (altera_read_packed(in, 1, &bits_avail,
112	&in_index) == 0) {
113	for (j = 0; j < DATA_BLOB_LENGTH; ++j) {
114	if (i < data_length) {
115	out[i] = (u8)altera_read_packed(in,
116	CHAR_BITS,
117	&bits_avail,
118	&in_index);
119	i++;
120	}
121	}
122	} else {
123	/* A 1 bit indicates offset/length to follow. */
124	offset = altera_read_packed(in, altera_bits_req((s16)
125	(i > match_data_length ?
126	match_data_length : i)),
127	&bits_avail,
128	&in_index);
129	length = altera_read_packed(in, CHAR_BITS,
130	&bits_avail,
131	&in_index);
132	for (j = 0; j < length; ++j) {
133	if (i < data_length) {
134	out[i] = out[i - offset];
135	i++;
136	}
137	}
138	}
139	}
140
141	return data_length;
142	}