1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Abilis Systems Single DVB-T Receiver
4 * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com>
5 * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.com>
6 */
7
8 #include <linux/kernel.h>
9 #include "as102_drv.h"
10 #include "as10x_cmd.h"
11
12 /**
13 * as10x_cmd_turn_on - send turn on command to AS10x
14 * @adap: pointer to AS10x bus adapter
15 *
16 * Return 0 when no error, < 0 in case of error.
17 */
as10x_cmd_turn_on(struct as10x_bus_adapter_t * adap)18 int as10x_cmd_turn_on(struct as10x_bus_adapter_t *adap)
19 {
20 int error = AS10X_CMD_ERROR;
21 struct as10x_cmd_t *pcmd, *prsp;
22
23 pcmd = adap->cmd;
24 prsp = adap->rsp;
25
26 /* prepare command */
27 as10x_cmd_build(pcmd, (++adap->cmd_xid),
28 sizeof(pcmd->body.turn_on.req));
29
30 /* fill command */
31 pcmd->body.turn_on.req.proc_id = cpu_to_le16(CONTROL_PROC_TURNON);
32
33 /* send command */
34 if (adap->ops->xfer_cmd) {
35 error = adap->ops->xfer_cmd(adap, (uint8_t *) pcmd,
36 sizeof(pcmd->body.turn_on.req) +
37 HEADER_SIZE,
38 (uint8_t *) prsp,
39 sizeof(prsp->body.turn_on.rsp) +
40 HEADER_SIZE);
41 }
42
43 if (error < 0)
44 goto out;
45
46 /* parse response */
47 error = as10x_rsp_parse(prsp, CONTROL_PROC_TURNON_RSP);
48
49 out:
50 return error;
51 }
52
53 /**
54 * as10x_cmd_turn_off - send turn off command to AS10x
55 * @adap: pointer to AS10x bus adapter
56 *
57 * Return 0 on success or negative value in case of error.
58 */
as10x_cmd_turn_off(struct as10x_bus_adapter_t * adap)59 int as10x_cmd_turn_off(struct as10x_bus_adapter_t *adap)
60 {
61 int error = AS10X_CMD_ERROR;
62 struct as10x_cmd_t *pcmd, *prsp;
63
64 pcmd = adap->cmd;
65 prsp = adap->rsp;
66
67 /* prepare command */
68 as10x_cmd_build(pcmd, (++adap->cmd_xid),
69 sizeof(pcmd->body.turn_off.req));
70
71 /* fill command */
72 pcmd->body.turn_off.req.proc_id = cpu_to_le16(CONTROL_PROC_TURNOFF);
73
74 /* send command */
75 if (adap->ops->xfer_cmd) {
76 error = adap->ops->xfer_cmd(
77 adap, (uint8_t *) pcmd,
78 sizeof(pcmd->body.turn_off.req) + HEADER_SIZE,
79 (uint8_t *) prsp,
80 sizeof(prsp->body.turn_off.rsp) + HEADER_SIZE);
81 }
82
83 if (error < 0)
84 goto out;
85
86 /* parse response */
87 error = as10x_rsp_parse(prsp, CONTROL_PROC_TURNOFF_RSP);
88
89 out:
90 return error;
91 }
92
93 /**
94 * as10x_cmd_set_tune - send set tune command to AS10x
95 * @adap: pointer to AS10x bus adapter
96 * @ptune: tune parameters
97 *
98 * Return 0 on success or negative value in case of error.
99 */
as10x_cmd_set_tune(struct as10x_bus_adapter_t * adap,struct as10x_tune_args * ptune)100 int as10x_cmd_set_tune(struct as10x_bus_adapter_t *adap,
101 struct as10x_tune_args *ptune)
102 {
103 int error = AS10X_CMD_ERROR;
104 struct as10x_cmd_t *preq, *prsp;
105
106 preq = adap->cmd;
107 prsp = adap->rsp;
108
109 /* prepare command */
110 as10x_cmd_build(preq, (++adap->cmd_xid),
111 sizeof(preq->body.set_tune.req));
112
113 /* fill command */
114 preq->body.set_tune.req.proc_id = cpu_to_le16(CONTROL_PROC_SETTUNE);
115 preq->body.set_tune.req.args.freq = (__force __u32)cpu_to_le32(ptune->freq);
116 preq->body.set_tune.req.args.bandwidth = ptune->bandwidth;
117 preq->body.set_tune.req.args.hier_select = ptune->hier_select;
118 preq->body.set_tune.req.args.modulation = ptune->modulation;
119 preq->body.set_tune.req.args.hierarchy = ptune->hierarchy;
120 preq->body.set_tune.req.args.interleaving_mode =
121 ptune->interleaving_mode;
122 preq->body.set_tune.req.args.code_rate = ptune->code_rate;
123 preq->body.set_tune.req.args.guard_interval = ptune->guard_interval;
124 preq->body.set_tune.req.args.transmission_mode =
125 ptune->transmission_mode;
126
127 /* send command */
128 if (adap->ops->xfer_cmd) {
129 error = adap->ops->xfer_cmd(adap,
130 (uint8_t *) preq,
131 sizeof(preq->body.set_tune.req)
132 + HEADER_SIZE,
133 (uint8_t *) prsp,
134 sizeof(prsp->body.set_tune.rsp)
135 + HEADER_SIZE);
136 }
137
138 if (error < 0)
139 goto out;
140
141 /* parse response */
142 error = as10x_rsp_parse(prsp, CONTROL_PROC_SETTUNE_RSP);
143
144 out:
145 return error;
146 }
147
148 /**
149 * as10x_cmd_get_tune_status - send get tune status command to AS10x
150 * @adap: pointer to AS10x bus adapter
151 * @pstatus: pointer to updated status structure of the current tune
152 *
153 * Return 0 on success or negative value in case of error.
154 */
as10x_cmd_get_tune_status(struct as10x_bus_adapter_t * adap,struct as10x_tune_status * pstatus)155 int as10x_cmd_get_tune_status(struct as10x_bus_adapter_t *adap,
156 struct as10x_tune_status *pstatus)
157 {
158 int error = AS10X_CMD_ERROR;
159 struct as10x_cmd_t *preq, *prsp;
160
161 preq = adap->cmd;
162 prsp = adap->rsp;
163
164 /* prepare command */
165 as10x_cmd_build(preq, (++adap->cmd_xid),
166 sizeof(preq->body.get_tune_status.req));
167
168 /* fill command */
169 preq->body.get_tune_status.req.proc_id =
170 cpu_to_le16(CONTROL_PROC_GETTUNESTAT);
171
172 /* send command */
173 if (adap->ops->xfer_cmd) {
174 error = adap->ops->xfer_cmd(
175 adap,
176 (uint8_t *) preq,
177 sizeof(preq->body.get_tune_status.req) + HEADER_SIZE,
178 (uint8_t *) prsp,
179 sizeof(prsp->body.get_tune_status.rsp) + HEADER_SIZE);
180 }
181
182 if (error < 0)
183 goto out;
184
185 /* parse response */
186 error = as10x_rsp_parse(prsp, CONTROL_PROC_GETTUNESTAT_RSP);
187 if (error < 0)
188 goto out;
189
190 /* Response OK -> get response data */
191 pstatus->tune_state = prsp->body.get_tune_status.rsp.sts.tune_state;
192 pstatus->signal_strength =
193 le16_to_cpu((__force __le16)prsp->body.get_tune_status.rsp.sts.signal_strength);
194 pstatus->PER = le16_to_cpu((__force __le16)prsp->body.get_tune_status.rsp.sts.PER);
195 pstatus->BER = le16_to_cpu((__force __le16)prsp->body.get_tune_status.rsp.sts.BER);
196
197 out:
198 return error;
199 }
200
201 /**
202 * as10x_cmd_get_tps - send get TPS command to AS10x
203 * @adap: pointer to AS10x handle
204 * @ptps: pointer to TPS parameters structure
205 *
206 * Return 0 on success or negative value in case of error.
207 */
as10x_cmd_get_tps(struct as10x_bus_adapter_t * adap,struct as10x_tps * ptps)208 int as10x_cmd_get_tps(struct as10x_bus_adapter_t *adap, struct as10x_tps *ptps)
209 {
210 int error = AS10X_CMD_ERROR;
211 struct as10x_cmd_t *pcmd, *prsp;
212
213 pcmd = adap->cmd;
214 prsp = adap->rsp;
215
216 /* prepare command */
217 as10x_cmd_build(pcmd, (++adap->cmd_xid),
218 sizeof(pcmd->body.get_tps.req));
219
220 /* fill command */
221 pcmd->body.get_tune_status.req.proc_id =
222 cpu_to_le16(CONTROL_PROC_GETTPS);
223
224 /* send command */
225 if (adap->ops->xfer_cmd) {
226 error = adap->ops->xfer_cmd(adap,
227 (uint8_t *) pcmd,
228 sizeof(pcmd->body.get_tps.req) +
229 HEADER_SIZE,
230 (uint8_t *) prsp,
231 sizeof(prsp->body.get_tps.rsp) +
232 HEADER_SIZE);
233 }
234
235 if (error < 0)
236 goto out;
237
238 /* parse response */
239 error = as10x_rsp_parse(prsp, CONTROL_PROC_GETTPS_RSP);
240 if (error < 0)
241 goto out;
242
243 /* Response OK -> get response data */
244 ptps->modulation = prsp->body.get_tps.rsp.tps.modulation;
245 ptps->hierarchy = prsp->body.get_tps.rsp.tps.hierarchy;
246 ptps->interleaving_mode = prsp->body.get_tps.rsp.tps.interleaving_mode;
247 ptps->code_rate_HP = prsp->body.get_tps.rsp.tps.code_rate_HP;
248 ptps->code_rate_LP = prsp->body.get_tps.rsp.tps.code_rate_LP;
249 ptps->guard_interval = prsp->body.get_tps.rsp.tps.guard_interval;
250 ptps->transmission_mode = prsp->body.get_tps.rsp.tps.transmission_mode;
251 ptps->DVBH_mask_HP = prsp->body.get_tps.rsp.tps.DVBH_mask_HP;
252 ptps->DVBH_mask_LP = prsp->body.get_tps.rsp.tps.DVBH_mask_LP;
253 ptps->cell_ID = le16_to_cpu((__force __le16)prsp->body.get_tps.rsp.tps.cell_ID);
254
255 out:
256 return error;
257 }
258
259 /**
260 * as10x_cmd_get_demod_stats - send get demod stats command to AS10x
261 * @adap: pointer to AS10x bus adapter
262 * @pdemod_stats: pointer to demod stats parameters structure
263 *
264 * Return 0 on success or negative value in case of error.
265 */
as10x_cmd_get_demod_stats(struct as10x_bus_adapter_t * adap,struct as10x_demod_stats * pdemod_stats)266 int as10x_cmd_get_demod_stats(struct as10x_bus_adapter_t *adap,
267 struct as10x_demod_stats *pdemod_stats)
268 {
269 int error = AS10X_CMD_ERROR;
270 struct as10x_cmd_t *pcmd, *prsp;
271
272 pcmd = adap->cmd;
273 prsp = adap->rsp;
274
275 /* prepare command */
276 as10x_cmd_build(pcmd, (++adap->cmd_xid),
277 sizeof(pcmd->body.get_demod_stats.req));
278
279 /* fill command */
280 pcmd->body.get_demod_stats.req.proc_id =
281 cpu_to_le16(CONTROL_PROC_GET_DEMOD_STATS);
282
283 /* send command */
284 if (adap->ops->xfer_cmd) {
285 error = adap->ops->xfer_cmd(adap,
286 (uint8_t *) pcmd,
287 sizeof(pcmd->body.get_demod_stats.req)
288 + HEADER_SIZE,
289 (uint8_t *) prsp,
290 sizeof(prsp->body.get_demod_stats.rsp)
291 + HEADER_SIZE);
292 }
293
294 if (error < 0)
295 goto out;
296
297 /* parse response */
298 error = as10x_rsp_parse(prsp, CONTROL_PROC_GET_DEMOD_STATS_RSP);
299 if (error < 0)
300 goto out;
301
302 /* Response OK -> get response data */
303 pdemod_stats->frame_count =
304 le32_to_cpu((__force __le32)prsp->body.get_demod_stats.rsp.stats.frame_count);
305 pdemod_stats->bad_frame_count =
306 le32_to_cpu((__force __le32)prsp->body.get_demod_stats.rsp.stats.bad_frame_count);
307 pdemod_stats->bytes_fixed_by_rs =
308 le32_to_cpu((__force __le32)prsp->body.get_demod_stats.rsp.stats.bytes_fixed_by_rs);
309 pdemod_stats->mer =
310 le16_to_cpu((__force __le16)prsp->body.get_demod_stats.rsp.stats.mer);
311 pdemod_stats->has_started =
312 prsp->body.get_demod_stats.rsp.stats.has_started;
313
314 out:
315 return error;
316 }
317
318 /**
319 * as10x_cmd_get_impulse_resp - send get impulse response command to AS10x
320 * @adap: pointer to AS10x bus adapter
321 * @is_ready: pointer to value indicating when impulse
322 * response data is ready
323 *
324 * Return 0 on success or negative value in case of error.
325 */
as10x_cmd_get_impulse_resp(struct as10x_bus_adapter_t * adap,uint8_t * is_ready)326 int as10x_cmd_get_impulse_resp(struct as10x_bus_adapter_t *adap,
327 uint8_t *is_ready)
328 {
329 int error = AS10X_CMD_ERROR;
330 struct as10x_cmd_t *pcmd, *prsp;
331
332 pcmd = adap->cmd;
333 prsp = adap->rsp;
334
335 /* prepare command */
336 as10x_cmd_build(pcmd, (++adap->cmd_xid),
337 sizeof(pcmd->body.get_impulse_rsp.req));
338
339 /* fill command */
340 pcmd->body.get_impulse_rsp.req.proc_id =
341 cpu_to_le16(CONTROL_PROC_GET_IMPULSE_RESP);
342
343 /* send command */
344 if (adap->ops->xfer_cmd) {
345 error = adap->ops->xfer_cmd(adap,
346 (uint8_t *) pcmd,
347 sizeof(pcmd->body.get_impulse_rsp.req)
348 + HEADER_SIZE,
349 (uint8_t *) prsp,
350 sizeof(prsp->body.get_impulse_rsp.rsp)
351 + HEADER_SIZE);
352 }
353
354 if (error < 0)
355 goto out;
356
357 /* parse response */
358 error = as10x_rsp_parse(prsp, CONTROL_PROC_GET_IMPULSE_RESP_RSP);
359 if (error < 0)
360 goto out;
361
362 /* Response OK -> get response data */
363 *is_ready = prsp->body.get_impulse_rsp.rsp.is_ready;
364
365 out:
366 return error;
367 }
368
369 /**
370 * as10x_cmd_build - build AS10x command header
371 * @pcmd: pointer to AS10x command buffer
372 * @xid: sequence id of the command
373 * @cmd_len: length of the command
374 */
as10x_cmd_build(struct as10x_cmd_t * pcmd,uint16_t xid,uint16_t cmd_len)375 void as10x_cmd_build(struct as10x_cmd_t *pcmd,
376 uint16_t xid, uint16_t cmd_len)
377 {
378 pcmd->header.req_id = cpu_to_le16(xid);
379 pcmd->header.prog = cpu_to_le16(SERVICE_PROG_ID);
380 pcmd->header.version = cpu_to_le16(SERVICE_PROG_VERSION);
381 pcmd->header.data_len = cpu_to_le16(cmd_len);
382 }
383
384 /**
385 * as10x_rsp_parse - Parse command response
386 * @prsp: pointer to AS10x command buffer
387 * @proc_id: id of the command
388 *
389 * Return 0 on success or negative value in case of error.
390 */
as10x_rsp_parse(struct as10x_cmd_t * prsp,uint16_t proc_id)391 int as10x_rsp_parse(struct as10x_cmd_t *prsp, uint16_t proc_id)
392 {
393 int error;
394
395 /* extract command error code */
396 error = prsp->body.common.rsp.error;
397
398 if ((error == 0) &&
399 (le16_to_cpu(prsp->body.common.rsp.proc_id) == proc_id)) {
400 return 0;
401 }
402
403 return AS10X_CMD_ERROR;
404 }
405