drivers/media/usb/as102/as10x_cmd.c

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