LXR linux/drivers/media/usb/as102/as10x

   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 */
  18int 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
  49out:
  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 */
  59int 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
  89out:
  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 */
 100int 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
 144out:
 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 */
 155int 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
 197out:
 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 */
 208int 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
 255out:
 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 */
 266int 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
 314out:
 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 */
 326int 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
 365out:
 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 */
 375void 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 */
 391int 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