[deliverable/linux.git] / drivers / gpu / drm / sti / sti_awg_utils.c

/*
 * Copyright (C) STMicroelectronics SA 2014
 * Author: Vincent Abriou <vincent.abriou@st.com> for STMicroelectronics.
 * License terms:  GNU General Public License (GPL), version 2
 */

#include "sti_awg_utils.h"

#define AWG_OPCODE_OFFSET 10

enum opcode {
	SET,
	RPTSET,
	RPLSET,
	SKIP,
	STOP,
	REPEAT,
	REPLAY,
	JUMP,
	HOLD,
};

static int awg_generate_instr(enum opcode opcode,
			      long int arg,
			      long int mux_sel,
			      long int data_en,
			      struct awg_code_generation_params *fwparams)
{
	u32 instruction = 0;
	u32 mux = (mux_sel << 8) & 0x1ff;
	u32 data_enable = (data_en << 9) & 0x2ff;
	long int arg_tmp = arg;

	/* skip, repeat and replay arg should not exceed 1023.
	 * If user wants to exceed this value, the instruction should be
	 * duplicate and arg should be adjust for each duplicated instruction.
	 */

	while (arg_tmp > 0) {
		arg = arg_tmp;
		if (fwparams->instruction_offset >= AWG_MAX_INST) {
			DRM_ERROR("too many number of instructions\n");
			return -EINVAL;
		}

		switch (opcode) {
		case SKIP:
			/* leave 'arg' + 1 pixel elapsing without changing
			 * output bus */
			arg--; /* pixel adjustment */
			arg_tmp--;

			if (arg < 0) {
				/* SKIP instruction not needed */
				return 0;
			}

			if (arg == 0) {
				/* SKIP 0 not permitted but we want to skip 1
				 * pixel. So we transform SKIP into SET
				 * instruction */
				opcode = SET;
				break;
			}

			mux = 0;
			data_enable = 0;
			arg = (arg << 22) >> 22;
			arg &= (0x3ff);
			break;
		case REPEAT:
		case REPLAY:
			if (arg == 0) {
				/* REPEAT or REPLAY instruction not needed */
				return 0;
			}

			mux = 0;
			data_enable = 0;
			arg = (arg << 22) >> 22;
			arg &= (0x3ff);
			break;
		case JUMP:
			mux = 0;
			data_enable = 0;
			arg |= 0x40; /* for jump instruction 7th bit is 1 */
			arg = (arg << 22) >> 22;
			arg &= 0x3ff;
			break;
		case STOP:
			arg = 0;
			break;
		case SET:
		case RPTSET:
		case RPLSET:
		case HOLD:
			arg = (arg << 24) >> 24;
			arg &= (0x0ff);
			break;
		default:
			DRM_ERROR("instruction %d does not exist\n", opcode);
			return -EINVAL;
		}

		arg_tmp = arg_tmp - arg;

		arg = ((arg + mux) + data_enable);

		instruction = ((opcode) << AWG_OPCODE_OFFSET) | arg;
		fwparams->ram_code[fwparams->instruction_offset] =
			instruction & (0x3fff);
		fwparams->instruction_offset++;
	}
	return 0;
}

int sti_awg_generate_code_data_enable_mode(
		struct awg_code_generation_params *fwparams,
		struct awg_timing *timing)
{
	long int val;
	long int data_en;
	int ret = 0;

	if (timing->trailing_lines > 0) {
		/* skip trailing lines */
		val = timing->blanking_level;
		data_en = 0;
		ret |= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);

		val = timing->trailing_lines - 1;
		data_en = 0;
		ret |= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);
	}

	if (timing->trailing_pixels > 0) {
		/* skip trailing pixel */
		val = timing->blanking_level;
		data_en = 0;
		ret |= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);

		val = timing->trailing_pixels - 1;
		data_en = 0;
		ret |= awg_generate_instr(SKIP, val, 0, data_en, fwparams);
	}

	/* set DE signal high */
	val = timing->blanking_level;
	data_en = 1;
	ret |= awg_generate_instr((timing->trailing_pixels > 0) ? SET : RPLSET,
			val, 0, data_en, fwparams);

	if (timing->blanking_pixels > 0) {
		/* skip the number of active pixel */
		val = timing->active_pixels - 1;
		data_en = 1;
		ret |= awg_generate_instr(SKIP, val, 0, data_en, fwparams);

		/* set DE signal low */
		val = timing->blanking_level;
		data_en = 0;
		ret |= awg_generate_instr(SET, val, 0, data_en, fwparams);
	}

	/* replay the sequence as many active lines defined */
	val = timing->active_lines - 1;
	data_en = 0;
	ret |= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);

	if (timing->blanking_lines > 0) {
		/* skip blanking lines */
		val = timing->blanking_level;
		data_en = 0;
		ret |= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);

		val = timing->blanking_lines - 1;
		data_en = 0;
		ret |= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);
	}

	return ret;
}
Commit	Line	Data
f32c4c50 BG	1	/*
	2	* Copyright (C) STMicroelectronics SA 2014
	3	* Author: Vincent Abriou <vincent.abriou@st.com> for STMicroelectronics.
	4	* License terms: GNU General Public License (GPL), version 2
	5	*/
	6
	7	#include "sti_awg_utils.h"
	8
	9	#define AWG_OPCODE_OFFSET 10
	10
	11	enum opcode {
	12	SET,
	13	RPTSET,
	14	RPLSET,
	15	SKIP,
	16	STOP,
	17	REPEAT,
	18	REPLAY,
	19	JUMP,
	20	HOLD,
	21	};
	22
	23	static int awg_generate_instr(enum opcode opcode,
	24	long int arg,
	25	long int mux_sel,
	26	long int data_en,
	27	struct awg_code_generation_params *fwparams)
	28	{
	29	u32 instruction = 0;
	30	u32 mux = (mux_sel << 8) & 0x1ff;
	31	u32 data_enable = (data_en << 9) & 0x2ff;
	32	long int arg_tmp = arg;
	33
	34	/* skip, repeat and replay arg should not exceed 1023.
	35	* If user wants to exceed this value, the instruction should be
	36	* duplicate and arg should be adjust for each duplicated instruction.
	37	*/
	38
	39	while (arg_tmp > 0) {
	40	arg = arg_tmp;
	41	if (fwparams->instruction_offset >= AWG_MAX_INST) {
	42	DRM_ERROR("too many number of instructions\n");
	43	return -EINVAL;
	44	}
	45
	46	switch (opcode) {
	47	case SKIP:
	48	/* leave 'arg' + 1 pixel elapsing without changing
	49	* output bus */
	50	arg--; /* pixel adjustment */
	51	arg_tmp--;
	52
	53	if (arg < 0) {
	54	/* SKIP instruction not needed */
	55	return 0;
	56	}
	57
	58	if (arg == 0) {
	59	/* SKIP 0 not permitted but we want to skip 1
	60	* pixel. So we transform SKIP into SET
	61	* instruction */
	62	opcode = SET;
f32c4c50 BG	63	break;
	64	}
	65
	66	mux = 0;
	67	data_enable = 0;
	68	arg = (arg << 22) >> 22;
	69	arg &= (0x3ff);
	70	break;
	71	case REPEAT:
	72	case REPLAY:
	73	if (arg == 0) {
	74	/* REPEAT or REPLAY instruction not needed */
	75	return 0;
	76	}
	77
	78	mux = 0;
	79	data_enable = 0;
	80	arg = (arg << 22) >> 22;
	81	arg &= (0x3ff);
	82	break;
	83	case JUMP:
	84	mux = 0;
	85	data_enable = 0;
	86	arg \|= 0x40; /* for jump instruction 7th bit is 1 */
	87	arg = (arg << 22) >> 22;
	88	arg &= 0x3ff;
	89	break;
	90	case STOP:
	91	arg = 0;
	92	break;
	93	case SET:
	94	case RPTSET:
	95	case RPLSET:
	96	case HOLD:
	97	arg = (arg << 24) >> 24;
	98	arg &= (0x0ff);
	99	break;
	100	default:
	101	DRM_ERROR("instruction %d does not exist\n", opcode);
	102	return -EINVAL;
	103	}
	104
	105	arg_tmp = arg_tmp - arg;
	106
	107	arg = ((arg + mux) + data_enable);
	108
	109	instruction = ((opcode) << AWG_OPCODE_OFFSET) \| arg;
	110	fwparams->ram_code[fwparams->instruction_offset] =
	111	instruction & (0x3fff);
	112	fwparams->instruction_offset++;
	113	}
	114	return 0;
	115	}
	116
	117	int sti_awg_generate_code_data_enable_mode(
	118	struct awg_code_generation_params *fwparams,
	119	struct awg_timing *timing)
	120	{
	121	long int val;
	122	long int data_en;
	123	int ret = 0;
	124
	125	if (timing->trailing_lines > 0) {
	126	/* skip trailing lines */
127	val = timing->blanking_level;
128	data_en = 0;
129	ret \|= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);
130
131	val = timing->trailing_lines - 1;
132	data_en = 0;
133	ret \|= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);
134	}
135
136	if (timing->trailing_pixels > 0) {
137	/* skip trailing pixel */
138	val = timing->blanking_level;
139	data_en = 0;
140	ret \|= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);
141
142	val = timing->trailing_pixels - 1;
143	data_en = 0;
144	ret \|= awg_generate_instr(SKIP, val, 0, data_en, fwparams);
145	}
146
147	/* set DE signal high */
148	val = timing->blanking_level;
149	data_en = 1;
150	ret \|= awg_generate_instr((timing->trailing_pixels > 0) ? SET : RPLSET,
151	val, 0, data_en, fwparams);
152
153	if (timing->blanking_pixels > 0) {
154	/* skip the number of active pixel */
155	val = timing->active_pixels - 1;
156	data_en = 1;
157	ret \|= awg_generate_instr(SKIP, val, 0, data_en, fwparams);
158
159	/* set DE signal low */
160	val = timing->blanking_level;
161	data_en = 0;
162	ret \|= awg_generate_instr(SET, val, 0, data_en, fwparams);
163	}
164
165	/* replay the sequence as many active lines defined */
166	val = timing->active_lines - 1;
167	data_en = 0;
168	ret \|= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);
169
170	if (timing->blanking_lines > 0) {
171	/* skip blanking lines */
172	val = timing->blanking_level;
173	data_en = 0;
174	ret \|= awg_generate_instr(RPLSET, val, 0, data_en, fwparams);
175
176	val = timing->blanking_lines - 1;
177	data_en = 0;
178	ret \|= awg_generate_instr(REPLAY, val, 0, data_en, fwparams);
179	}
180
181	return ret;
182	}