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