drivers/mfd/si476x-cmd.c

   1 /*
   2  * drivers/mfd/si476x-cmd.c -- Subroutines implementing command
   3  * protocol of si476x series of chips
   4  *
   5  * Copyright (C) 2012 Innovative Converged Devices(ICD)
   6  * Copyright (C) 2013 Andrey Smirnov
   7  *
   8  * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; version 2 of the License.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/completion.h>
  23 #include <linux/delay.h>
  24 #include <linux/atomic.h>
  25 #include <linux/i2c.h>
  26 #include <linux/device.h>
  27 #include <linux/gpio.h>
  28 #include <linux/videodev2.h>
  29
  30 #include <linux/mfd/si476x-core.h>
  31
  32 #include <asm/unaligned.h>
  33
  34 #define msb(x)                  ((u8)((u16) x >> 8))
  35 #define lsb(x)                  ((u8)((u16) x &  0x00FF))
  36
  37
  38
  39 #define CMD_POWER_UP                            0x01
  40 #define CMD_POWER_UP_A10_NRESP                  1
  41 #define CMD_POWER_UP_A10_NARGS                  5
  42
  43 #define CMD_POWER_UP_A20_NRESP                  1
  44 #define CMD_POWER_UP_A20_NARGS                  5
  45
  46 #define POWER_UP_DELAY_MS                       110
  47
  48 #define CMD_POWER_DOWN                          0x11
  49 #define CMD_POWER_DOWN_A10_NRESP                1
  50
  51 #define CMD_POWER_DOWN_A20_NRESP                1
  52 #define CMD_POWER_DOWN_A20_NARGS                1
  53
  54 #define CMD_FUNC_INFO                           0x12
  55 #define CMD_FUNC_INFO_NRESP                     7
  56
  57 #define CMD_SET_PROPERTY                        0x13
  58 #define CMD_SET_PROPERTY_NARGS                  5
  59 #define CMD_SET_PROPERTY_NRESP                  1
  60
  61 #define CMD_GET_PROPERTY                        0x14
  62 #define CMD_GET_PROPERTY_NARGS                  3
  63 #define CMD_GET_PROPERTY_NRESP                  4
  64
  65 #define CMD_AGC_STATUS                          0x17
  66 #define CMD_AGC_STATUS_NRESP_A10                2
  67 #define CMD_AGC_STATUS_NRESP_A20                6
  68
  69 #define PIN_CFG_BYTE(x) (0x7F & (x))
  70 #define CMD_DIG_AUDIO_PIN_CFG                   0x18
  71 #define CMD_DIG_AUDIO_PIN_CFG_NARGS             4
  72 #define CMD_DIG_AUDIO_PIN_CFG_NRESP             5
  73
  74 #define CMD_ZIF_PIN_CFG                         0x19
  75 #define CMD_ZIF_PIN_CFG_NARGS                   4
  76 #define CMD_ZIF_PIN_CFG_NRESP                   5
  77
  78 #define CMD_IC_LINK_GPO_CTL_PIN_CFG             0x1A
  79 #define CMD_IC_LINK_GPO_CTL_PIN_CFG_NARGS       4
  80 #define CMD_IC_LINK_GPO_CTL_PIN_CFG_NRESP       5
  81
  82 #define CMD_ANA_AUDIO_PIN_CFG                   0x1B
  83 #define CMD_ANA_AUDIO_PIN_CFG_NARGS             1
  84 #define CMD_ANA_AUDIO_PIN_CFG_NRESP             2
  85
  86 #define CMD_INTB_PIN_CFG                        0x1C
  87 #define CMD_INTB_PIN_CFG_NARGS                  2
  88 #define CMD_INTB_PIN_CFG_A10_NRESP              6
  89 #define CMD_INTB_PIN_CFG_A20_NRESP              3
  90
  91 #define CMD_FM_TUNE_FREQ                        0x30
  92 #define CMD_FM_TUNE_FREQ_A10_NARGS              5
  93 #define CMD_FM_TUNE_FREQ_A20_NARGS              3
  94 #define CMD_FM_TUNE_FREQ_NRESP                  1
  95
  96 #define CMD_FM_RSQ_STATUS                       0x32
  97
  98 #define CMD_FM_RSQ_STATUS_A10_NARGS             1
  99 #define CMD_FM_RSQ_STATUS_A10_NRESP             17
 100 #define CMD_FM_RSQ_STATUS_A30_NARGS             1
 101 #define CMD_FM_RSQ_STATUS_A30_NRESP             23
 102
 103
 104 #define CMD_FM_SEEK_START                       0x31
 105 #define CMD_FM_SEEK_START_NARGS                 1
 106 #define CMD_FM_SEEK_START_NRESP                 1
 107
 108 #define CMD_FM_RDS_STATUS                       0x36
 109 #define CMD_FM_RDS_STATUS_NARGS                 1
 110 #define CMD_FM_RDS_STATUS_NRESP                 16
 111
 112 #define CMD_FM_RDS_BLOCKCOUNT                   0x37
 113 #define CMD_FM_RDS_BLOCKCOUNT_NARGS             1
 114 #define CMD_FM_RDS_BLOCKCOUNT_NRESP             8
 115
 116 #define CMD_FM_PHASE_DIVERSITY                  0x38
 117 #define CMD_FM_PHASE_DIVERSITY_NARGS            1
 118 #define CMD_FM_PHASE_DIVERSITY_NRESP            1
 119
 120 #define CMD_FM_PHASE_DIV_STATUS                 0x39
 121 #define CMD_FM_PHASE_DIV_STATUS_NRESP           2
 122
 123 #define CMD_AM_TUNE_FREQ                        0x40
 124 #define CMD_AM_TUNE_FREQ_NARGS                  3
 125 #define CMD_AM_TUNE_FREQ_NRESP                  1
 126
 127 #define CMD_AM_RSQ_STATUS                       0x42
 128 #define CMD_AM_RSQ_STATUS_NARGS                 1
 129 #define CMD_AM_RSQ_STATUS_NRESP                 13
 130
 131 #define CMD_AM_SEEK_START                       0x41
 132 #define CMD_AM_SEEK_START_NARGS                 1
 133 #define CMD_AM_SEEK_START_NRESP                 1
 134
 135
 136 #define CMD_AM_ACF_STATUS                       0x45
 137 #define CMD_AM_ACF_STATUS_NRESP                 6
 138 #define CMD_AM_ACF_STATUS_NARGS                 1
 139
 140 #define CMD_FM_ACF_STATUS                       0x35
 141 #define CMD_FM_ACF_STATUS_NRESP                 8
 142 #define CMD_FM_ACF_STATUS_NARGS                 1
 143
 144 #define CMD_MAX_ARGS_COUNT                      (10)
 145
 146
 147 enum si476x_acf_status_report_bits {
 148         SI476X_ACF_BLEND_INT    = (1 << 4),
 149         SI476X_ACF_HIBLEND_INT  = (1 << 3),
 150         SI476X_ACF_HICUT_INT    = (1 << 2),
 151         SI476X_ACF_CHBW_INT     = (1 << 1),
 152         SI476X_ACF_SOFTMUTE_INT = (1 << 0),
 153
 154         SI476X_ACF_SMUTE        = (1 << 0),
 155         SI476X_ACF_SMATTN       = 0x1f,
 156         SI476X_ACF_PILOT        = (1 << 7),
 157         SI476X_ACF_STBLEND      = ~SI476X_ACF_PILOT,
 158 };
 159
 160 enum si476x_agc_status_report_bits {
 161         SI476X_AGC_MXHI         = (1 << 5),
 162         SI476X_AGC_MXLO         = (1 << 4),
 163         SI476X_AGC_LNAHI        = (1 << 3),
 164         SI476X_AGC_LNALO        = (1 << 2),
 165 };
 166
 167 enum si476x_errors {
 168         SI476X_ERR_BAD_COMMAND          = 0x10,
 169         SI476X_ERR_BAD_ARG1             = 0x11,
 170         SI476X_ERR_BAD_ARG2             = 0x12,
 171         SI476X_ERR_BAD_ARG3             = 0x13,
 172         SI476X_ERR_BAD_ARG4             = 0x14,
 173         SI476X_ERR_BUSY                 = 0x18,
 174         SI476X_ERR_BAD_INTERNAL_MEMORY  = 0x20,
 175         SI476X_ERR_BAD_PATCH            = 0x30,
 176         SI476X_ERR_BAD_BOOT_MODE        = 0x31,
 177         SI476X_ERR_BAD_PROPERTY         = 0x40,
 178 };
 179
 180 static int si476x_core_parse_and_nag_about_error(struct si476x_core *core)
 181 {
 182         int err;
 183         char *cause;
 184         u8 buffer[2];
 185
 186         if (core->revision != SI476X_REVISION_A10) {
 187                 err = si476x_core_i2c_xfer(core, SI476X_I2C_RECV,
 188                                            buffer, sizeof(buffer));
 189                 if (err == sizeof(buffer)) {
 190                         switch (buffer[1]) {
 191                         case SI476X_ERR_BAD_COMMAND:
 192                                 cause = "Bad command";
 193                                 err = -EINVAL;
 194                                 break;
 195                         case SI476X_ERR_BAD_ARG1:
 196                                 cause = "Bad argument #1";
 197                                 err = -EINVAL;
 198                                 break;
 199                         case SI476X_ERR_BAD_ARG2:
 200                                 cause = "Bad argument #2";
 201                                 err = -EINVAL;
 202                                 break;
 203                         case SI476X_ERR_BAD_ARG3:
 204                                 cause = "Bad argument #3";
 205                                 err = -EINVAL;
 206                                 break;
 207                         case SI476X_ERR_BAD_ARG4:
 208                                 cause = "Bad argument #4";
 209                                 err = -EINVAL;
 210                                 break;
 211                         case SI476X_ERR_BUSY:
 212                                 cause = "Chip is busy";
 213                                 err = -EBUSY;
 214                                 break;
 215                         case SI476X_ERR_BAD_INTERNAL_MEMORY:
 216                                 cause = "Bad internal memory";
 217                                 err = -EIO;
 218                                 break;
 219                         case SI476X_ERR_BAD_PATCH:
 220                                 cause = "Bad patch";
 221                                 err = -EINVAL;
 222                                 break;
 223                         case SI476X_ERR_BAD_BOOT_MODE:
 224                                 cause = "Bad boot mode";
 225                                 err = -EINVAL;
 226                                 break;
 227                         case SI476X_ERR_BAD_PROPERTY:
 228                                 cause = "Bad property";
 229                                 err = -EINVAL;
 230                                 break;
 231                         default:
 232                                 cause = "Unknown";
 233                                 err = -EIO;
 234                         }
 235
 236                         dev_err(&core->client->dev,
 237                                 "[Chip error status]: %s\n", cause);
 238                 } else {
 239                         dev_err(&core->client->dev,
 240                                 "Failed to fetch error code\n");
 241                         err = (err >= 0) ? -EIO : err;
 242                 }
 243         } else {
 244                 err = -EIO;
 245         }
 246
 247         return err;
 248 }
 249
 250 /**
 251  * si476x_core_send_command() - sends a command to si476x and waits its
 252  * response
 253  * @core:    si476x_device structure for the device we are
 254  *            communicating with
 255  * @command:  command id
 256  * @args:     command arguments we are sending
 257  * @argn:     actual size of @args
 258  * @response: buffer to place the expected response from the device
 259  * @respn:    actual size of @response
 260  * @usecs:    amount of time to wait before reading the response (in
 261  *            usecs)
 262  *
 263  * Function returns 0 on succsess and negative error code on
 264  * failure
 265  */
 266 static int si476x_core_send_command(struct si476x_core *core,
 267                                     const u8 command,
 268                                     const u8 args[],
 269                                     const int argn,
 270                                     u8 resp[],
 271                                     const int respn,
 272                                     const int usecs)
 273 {
 274         struct i2c_client *client = core->client;
 275         int err;
 276         u8  data[CMD_MAX_ARGS_COUNT + 1];
 277
 278         if (argn > CMD_MAX_ARGS_COUNT) {
 279                 err = -ENOMEM;
 280                 goto exit;
 281         }
 282
 283         if (!client->adapter) {
 284                 err = -ENODEV;
 285                 goto exit;
 286         }
 287
 288         /* First send the command and its arguments */
 289         data[0] = command;
 290         memcpy(&data[1], args, argn);
 291         dev_dbg(&client->dev, "Command:\n %*ph\n", argn + 1, data);
 292
 293         err = si476x_core_i2c_xfer(core, SI476X_I2C_SEND,
 294                                    (char *) data, argn + 1);
 295         if (err != argn + 1) {
 296                 dev_err(&core->client->dev,
 297                         "Error while sending command 0x%02x\n",
 298                         command);
 299                 err = (err >= 0) ? -EIO : err;
 300                 goto exit;
 301         }
 302         /* Set CTS to zero only after the command is send to avoid
 303          * possible racing conditions when working in polling mode */
 304         atomic_set(&core->cts, 0);
 305
 306         /* if (unlikely(command == CMD_POWER_DOWN) */
 307         if (!wait_event_timeout(core->command,
 308                                 atomic_read(&core->cts),
 309                                 usecs_to_jiffies(usecs) + 1))
 310                 dev_warn(&core->client->dev,
 311                          "(%s) [CMD 0x%02x] Answer timeout.\n",
 312                          __func__, command);
 313
 314         /*
 315           When working in polling mode, for some reason the tuner will
 316           report CTS bit as being set in the first status byte read,
 317           but all the consequtive ones will return zeros until the
 318           tuner is actually completed the POWER_UP command. To
 319           workaround that we wait for second CTS to be reported
 320          */
 321         if (unlikely(!core->client->irq && command == CMD_POWER_UP)) {
 322                 if (!wait_event_timeout(core->command,
 323                                         atomic_read(&core->cts),
 324                                         usecs_to_jiffies(usecs) + 1))
 325                         dev_warn(&core->client->dev,
 326                                  "(%s) Power up took too much time.\n",
 327                                  __func__);
 328         }
 329
 330         /* Then get the response */
 331         err = si476x_core_i2c_xfer(core, SI476X_I2C_RECV, resp, respn);
 332         if (err != respn) {
 333                 dev_err(&core->client->dev,
 334                         "Error while reading response for command 0x%02x\n",
 335                         command);
 336                 err = (err >= 0) ? -EIO : err;
 337                 goto exit;
 338         }
 339         dev_dbg(&client->dev, "Response:\n %*ph\n", respn, resp);
 340
 341         err = 0;
 342
 343         if (resp[0] & SI476X_ERR) {
 344                 dev_err(&core->client->dev,
 345                         "[CMD 0x%02x] Chip set error flag\n", command);
 346                 err = si476x_core_parse_and_nag_about_error(core);
 347                 goto exit;
 348         }
 349
 350         if (!(resp[0] & SI476X_CTS))
 351                 err = -EBUSY;
 352 exit:
 353         return err;
 354 }
 355
 356 static int si476x_cmd_clear_stc(struct si476x_core *core)
 357 {
 358         int err;
 359         struct si476x_rsq_status_args args = {
 360                 .primary        = false,
 361                 .rsqack         = false,
 362                 .attune         = false,
 363                 .cancel         = false,
 364                 .stcack         = true,
 365         };
 366
 367         switch (core->power_up_parameters.func) {
 368         case SI476X_FUNC_FM_RECEIVER:
 369                 err = si476x_core_cmd_fm_rsq_status(core, &args, NULL);
 370                 break;
 371         case SI476X_FUNC_AM_RECEIVER:
 372                 err = si476x_core_cmd_am_rsq_status(core, &args, NULL);
 373                 break;
 374         default:
 375                 err = -EINVAL;
 376         }
 377
 378         return err;
 379 }
 380
 381 static int si476x_cmd_tune_seek_freq(struct si476x_core *core,
 382                                      uint8_t cmd,
 383                                      const uint8_t args[], size_t argn,
 384                                      uint8_t *resp, size_t respn)
 385 {
 386         int err;
 387
 388
 389         atomic_set(&core->stc, 0);
 390         err = si476x_core_send_command(core, cmd, args, argn, resp, respn,
 391                                        SI476X_TIMEOUT_TUNE);
 392         if (!err) {
 393                 wait_event_killable(core->tuning,
 394                                     atomic_read(&core->stc));
 395                 si476x_cmd_clear_stc(core);
 396         }
 397
 398         return err;
 399 }
 400
 401 /**
 402  * si476x_cmd_func_info() - send 'FUNC_INFO' command to the device
 403  * @core: device to send the command to
 404  * @info:  struct si476x_func_info to fill all the information
 405  *         returned by the command
 406  *
 407  * The command requests the firmware and patch version for currently
 408  * loaded firmware (dependent on the function of the device FM/AM/WB)
 409  *
 410  * Function returns 0 on succsess and negative error code on
 411  * failure
 412  */
 413 int si476x_core_cmd_func_info(struct si476x_core *core,
 414                               struct si476x_func_info *info)
 415 {
 416         int err;
 417         u8  resp[CMD_FUNC_INFO_NRESP];
 418
 419         err = si476x_core_send_command(core, CMD_FUNC_INFO,
 420                                        NULL, 0,
 421                                        resp, ARRAY_SIZE(resp),
 422                                        SI476X_DEFAULT_TIMEOUT);
 423
 424         info->firmware.major    = resp[1];
 425         info->firmware.minor[0] = resp[2];
 426         info->firmware.minor[1] = resp[3];
 427
 428         info->patch_id = ((u16) resp[4] << 8) | resp[5];
 429         info->func     = resp[6];
 430
 431         return err;
 432 }
 433 EXPORT_SYMBOL_GPL(si476x_core_cmd_func_info);
 434
 435 /**
 436  * si476x_cmd_set_property() - send 'SET_PROPERTY' command to the device
 437  * @core:    device to send the command to
 438  * @property: property address
 439  * @value:    property value
 440  *
 441  * Function returns 0 on succsess and negative error code on
 442  * failure
 443  */
 444 int si476x_core_cmd_set_property(struct si476x_core *core,
 445                                  u16 property, u16 value)
 446 {
 447         u8       resp[CMD_SET_PROPERTY_NRESP];
 448         const u8 args[CMD_SET_PROPERTY_NARGS] = {
 449                 0x00,
 450                 msb(property),
 451                 lsb(property),
 452                 msb(value),
 453                 lsb(value),
 454         };
 455
 456         return si476x_core_send_command(core, CMD_SET_PROPERTY,
 457                                         args, ARRAY_SIZE(args),
 458                                         resp, ARRAY_SIZE(resp),
 459                                         SI476X_DEFAULT_TIMEOUT);
 460 }
 461 EXPORT_SYMBOL_GPL(si476x_core_cmd_set_property);
 462
 463 /**
 464  * si476x_cmd_get_property() - send 'GET_PROPERTY' command to the device
 465  * @core:    device to send the command to
 466  * @property: property address
 467  *
 468  * Function return the value of property as u16 on success or a
 469  * negative error on failure
 470  */
 471 int si476x_core_cmd_get_property(struct si476x_core *core, u16 property)
 472 {
 473         int err;
 474         u8       resp[CMD_GET_PROPERTY_NRESP];
 475         const u8 args[CMD_GET_PROPERTY_NARGS] = {
 476                 0x00,
 477                 msb(property),
 478                 lsb(property),
 479         };
 480
 481         err = si476x_core_send_command(core, CMD_GET_PROPERTY,
 482                                        args, ARRAY_SIZE(args),
 483                                        resp, ARRAY_SIZE(resp),
 484                                        SI476X_DEFAULT_TIMEOUT);
 485         if (err < 0)
 486                 return err;
 487         else
 488                 return get_unaligned_be16(resp + 2);
 489 }
 490 EXPORT_SYMBOL_GPL(si476x_core_cmd_get_property);
 491
 492 /**
 493  * si476x_cmd_dig_audio_pin_cfg() - send 'DIG_AUDIO_PIN_CFG' command to
 494  * the device
 495  * @core: device to send the command to
 496  * @dclk:  DCLK pin function configuration:
 497  *         #SI476X_DCLK_NOOP     - do not modify the behaviour
 498  *         #SI476X_DCLK_TRISTATE - put the pin in tristate condition,
 499  *                                 enable 1MOhm pulldown
 500  *         #SI476X_DCLK_DAUDIO   - set the pin to be a part of digital
 501  *                                 audio interface
 502  * @dfs:   DFS pin function configuration:
 503  *         #SI476X_DFS_NOOP      - do not modify the behaviour
 504  *         #SI476X_DFS_TRISTATE  - put the pin in tristate condition,
 505  *                             enable 1MOhm pulldown
 506  *      SI476X_DFS_DAUDIO    - set the pin to be a part of digital
 507  *                             audio interface
 508  * @dout - DOUT pin function configuration:
 509  *      SI476X_DOUT_NOOP       - do not modify the behaviour
 510  *      SI476X_DOUT_TRISTATE   - put the pin in tristate condition,
 511  *                               enable 1MOhm pulldown
 512  *      SI476X_DOUT_I2S_OUTPUT - set this pin to be digital out on I2S
 513  *                               port 1
 514  *      SI476X_DOUT_I2S_INPUT  - set this pin to be digital in on I2S
 515  *                               port 1
 516  * @xout - XOUT pin function configuration:
 517  *      SI476X_XOUT_NOOP        - do not modify the behaviour
 518  *      SI476X_XOUT_TRISTATE    - put the pin in tristate condition,
 519  *                                enable 1MOhm pulldown
 520  *      SI476X_XOUT_I2S_INPUT   - set this pin to be digital in on I2S
 521  *                                port 1
 522  *      SI476X_XOUT_MODE_SELECT - set this pin to be the input that
 523  *                                selects the mode of the I2S audio
 524  *                                combiner (analog or HD)
 525  *                                [SI4761/63/65/67 Only]
 526  *
 527  * Function returns 0 on success and negative error code on failure
 528  */
 529 int si476x_core_cmd_dig_audio_pin_cfg(struct  si476x_core *core,
 530                                       enum si476x_dclk_config dclk,
 531                                       enum si476x_dfs_config  dfs,
 532                                       enum si476x_dout_config dout,
 533                                       enum si476x_xout_config xout)
 534 {
 535         u8       resp[CMD_DIG_AUDIO_PIN_CFG_NRESP];
 536         const u8 args[CMD_DIG_AUDIO_PIN_CFG_NARGS] = {
 537                 PIN_CFG_BYTE(dclk),
 538                 PIN_CFG_BYTE(dfs),
 539                 PIN_CFG_BYTE(dout),
 540                 PIN_CFG_BYTE(xout),
 541         };
 542
 543         return si476x_core_send_command(core, CMD_DIG_AUDIO_PIN_CFG,
 544                                         args, ARRAY_SIZE(args),
 545                                         resp, ARRAY_SIZE(resp),
 546                                         SI476X_DEFAULT_TIMEOUT);
 547 }
 548 EXPORT_SYMBOL_GPL(si476x_core_cmd_dig_audio_pin_cfg);
 549
 550 /**
 551  * si476x_cmd_zif_pin_cfg - send 'ZIF_PIN_CFG_COMMAND'
 552  * @core - device to send the command to
 553  * @iqclk - IQCL pin function configuration:
 554  *       SI476X_IQCLK_NOOP     - do not modify the behaviour
 555  *       SI476X_IQCLK_TRISTATE - put the pin in tristate condition,
 556  *                               enable 1MOhm pulldown
 557  *       SI476X_IQCLK_IQ       - set pin to be a part of I/Q interace
 558  *                               in master mode
 559  * @iqfs - IQFS pin function configuration:
 560  *       SI476X_IQFS_NOOP     - do not modify the behaviour
 561  *       SI476X_IQFS_TRISTATE - put the pin in tristate condition,
 562  *                              enable 1MOhm pulldown
 563  *       SI476X_IQFS_IQ       - set pin to be a part of I/Q interace
 564  *                              in master mode
 565  * @iout - IOUT pin function configuration:
 566  *       SI476X_IOUT_NOOP     - do not modify the behaviour
 567  *       SI476X_IOUT_TRISTATE - put the pin in tristate condition,
 568  *                              enable 1MOhm pulldown
 569  *       SI476X_IOUT_OUTPUT   - set pin to be I out
 570  * @qout - QOUT pin function configuration:
 571  *       SI476X_QOUT_NOOP     - do not modify the behaviour
 572  *       SI476X_QOUT_TRISTATE - put the pin in tristate condition,
 573  *                              enable 1MOhm pulldown
 574  *       SI476X_QOUT_OUTPUT   - set pin to be Q out
 575  *
 576  * Function returns 0 on success and negative error code on failure
 577  */
 578 int si476x_core_cmd_zif_pin_cfg(struct si476x_core *core,
 579                                 enum si476x_iqclk_config iqclk,
 580                                 enum si476x_iqfs_config iqfs,
 581                                 enum si476x_iout_config iout,
 582                                 enum si476x_qout_config qout)
 583 {
 584         u8       resp[CMD_ZIF_PIN_CFG_NRESP];
 585         const u8 args[CMD_ZIF_PIN_CFG_NARGS] = {
 586                 PIN_CFG_BYTE(iqclk),
 587                 PIN_CFG_BYTE(iqfs),
 588                 PIN_CFG_BYTE(iout),
 589                 PIN_CFG_BYTE(qout),
 590         };
 591
 592         return si476x_core_send_command(core, CMD_ZIF_PIN_CFG,
 593                                         args, ARRAY_SIZE(args),
 594                                         resp, ARRAY_SIZE(resp),
 595                                         SI476X_DEFAULT_TIMEOUT);
 596 }
 597 EXPORT_SYMBOL_GPL(si476x_core_cmd_zif_pin_cfg);
 598
 599 /**
 600  * si476x_cmd_ic_link_gpo_ctl_pin_cfg - send
 601  * 'IC_LINK_GPIO_CTL_PIN_CFG' comand to the device
 602  * @core - device to send the command to
 603  * @icin - ICIN pin function configuration:
 604  *      SI476X_ICIN_NOOP      - do not modify the behaviour
 605  *      SI476X_ICIN_TRISTATE  - put the pin in tristate condition,
 606  *                              enable 1MOhm pulldown
 607  *      SI476X_ICIN_GPO1_HIGH - set pin to be an output, drive it high
 608  *      SI476X_ICIN_GPO1_LOW  - set pin to be an output, drive it low
 609  *      SI476X_ICIN_IC_LINK   - set the pin to be a part of Inter-Chip link
 610  * @icip - ICIP pin function configuration:
 611  *      SI476X_ICIP_NOOP      - do not modify the behaviour
 612  *      SI476X_ICIP_TRISTATE  - put the pin in tristate condition,
 613  *                              enable 1MOhm pulldown
 614  *      SI476X_ICIP_GPO1_HIGH - set pin to be an output, drive it high
 615  *      SI476X_ICIP_GPO1_LOW  - set pin to be an output, drive it low
 616  *      SI476X_ICIP_IC_LINK   - set the pin to be a part of Inter-Chip link
 617  * @icon - ICON pin function configuration:
 618  *      SI476X_ICON_NOOP     - do not modify the behaviour
 619  *      SI476X_ICON_TRISTATE - put the pin in tristate condition,
 620  *                             enable 1MOhm pulldown
 621  *      SI476X_ICON_I2S      - set the pin to be a part of audio
 622  *                             interface in slave mode (DCLK)
 623  *      SI476X_ICON_IC_LINK  - set the pin to be a part of Inter-Chip link
 624  * @icop - ICOP pin function configuration:
 625  *      SI476X_ICOP_NOOP     - do not modify the behaviour
 626  *      SI476X_ICOP_TRISTATE - put the pin in tristate condition,
 627  *                             enable 1MOhm pulldown
 628  *      SI476X_ICOP_I2S      - set the pin to be a part of audio
 629  *                             interface in slave mode (DOUT)
 630  *                             [Si4761/63/65/67 Only]
 631  *      SI476X_ICOP_IC_LINK  - set the pin to be a part of Inter-Chip link
 632  *
 633  * Function returns 0 on success and negative error code on failure
 634  */
 635 int si476x_core_cmd_ic_link_gpo_ctl_pin_cfg(struct si476x_core *core,
 636                                             enum si476x_icin_config icin,
 637                                             enum si476x_icip_config icip,
 638                                             enum si476x_icon_config icon,
 639                                             enum si476x_icop_config icop)
 640 {
 641         u8       resp[CMD_IC_LINK_GPO_CTL_PIN_CFG_NRESP];
 642         const u8 args[CMD_IC_LINK_GPO_CTL_PIN_CFG_NARGS] = {
 643                 PIN_CFG_BYTE(icin),
 644                 PIN_CFG_BYTE(icip),
 645                 PIN_CFG_BYTE(icon),
 646                 PIN_CFG_BYTE(icop),
 647         };
 648
 649         return si476x_core_send_command(core, CMD_IC_LINK_GPO_CTL_PIN_CFG,
 650                                         args, ARRAY_SIZE(args),
 651                                         resp, ARRAY_SIZE(resp),
 652                                         SI476X_DEFAULT_TIMEOUT);
 653 }
 654 EXPORT_SYMBOL_GPL(si476x_core_cmd_ic_link_gpo_ctl_pin_cfg);
 655
 656 /**
 657  * si476x_cmd_ana_audio_pin_cfg - send 'ANA_AUDIO_PIN_CFG' to the
 658  * device
 659  * @core - device to send the command to
 660  * @lrout - LROUT pin function configuration:
 661  *       SI476X_LROUT_NOOP     - do not modify the behaviour
 662  *       SI476X_LROUT_TRISTATE - put the pin in tristate condition,
 663  *                               enable 1MOhm pulldown
 664  *       SI476X_LROUT_AUDIO    - set pin to be audio output
 665  *       SI476X_LROUT_MPX      - set pin to be MPX output
 666  *
 667  * Function returns 0 on success and negative error code on failure
 668  */
 669 int si476x_core_cmd_ana_audio_pin_cfg(struct si476x_core *core,
 670                                       enum si476x_lrout_config lrout)
 671 {
 672         u8       resp[CMD_ANA_AUDIO_PIN_CFG_NRESP];
 673         const u8 args[CMD_ANA_AUDIO_PIN_CFG_NARGS] = {
 674                 PIN_CFG_BYTE(lrout),
 675         };
 676
 677         return si476x_core_send_command(core, CMD_ANA_AUDIO_PIN_CFG,
 678                                         args, ARRAY_SIZE(args),
 679                                         resp, ARRAY_SIZE(resp),
 680                                         SI476X_DEFAULT_TIMEOUT);
 681 }
 682 EXPORT_SYMBOL_GPL(si476x_core_cmd_ana_audio_pin_cfg);
 683
 684
 685 /**
 686  * si476x_cmd_intb_pin_cfg - send 'INTB_PIN_CFG' command to the device
 687  * @core - device to send the command to
 688  * @intb - INTB pin function configuration:
 689  *      SI476X_INTB_NOOP     - do not modify the behaviour
 690  *      SI476X_INTB_TRISTATE - put the pin in tristate condition,
 691  *                             enable 1MOhm pulldown
 692  *      SI476X_INTB_DAUDIO   - set pin to be a part of digital
 693  *                             audio interface in slave mode
 694  *      SI476X_INTB_IRQ      - set pin to be an interrupt request line
 695  * @a1 - A1 pin function configuration:
 696  *      SI476X_A1_NOOP     - do not modify the behaviour
 697  *      SI476X_A1_TRISTATE - put the pin in tristate condition,
 698  *                           enable 1MOhm pulldown
 699  *      SI476X_A1_IRQ      - set pin to be an interrupt request line
 700  *
 701  * Function returns 0 on success and negative error code on failure
 702  */
 703 static int si476x_core_cmd_intb_pin_cfg_a10(struct si476x_core *core,
 704                                             enum si476x_intb_config intb,
 705                                             enum si476x_a1_config a1)
 706 {
 707         u8       resp[CMD_INTB_PIN_CFG_A10_NRESP];
 708         const u8 args[CMD_INTB_PIN_CFG_NARGS] = {
 709                 PIN_CFG_BYTE(intb),
 710                 PIN_CFG_BYTE(a1),
 711         };
 712
 713         return si476x_core_send_command(core, CMD_INTB_PIN_CFG,
 714                                         args, ARRAY_SIZE(args),
 715                                         resp, ARRAY_SIZE(resp),
 716                                         SI476X_DEFAULT_TIMEOUT);
 717 }
 718
 719 static int si476x_core_cmd_intb_pin_cfg_a20(struct si476x_core *core,
 720                                             enum si476x_intb_config intb,
 721                                             enum si476x_a1_config a1)
 722 {
 723         u8       resp[CMD_INTB_PIN_CFG_A20_NRESP];
 724         const u8 args[CMD_INTB_PIN_CFG_NARGS] = {
 725                 PIN_CFG_BYTE(intb),
 726                 PIN_CFG_BYTE(a1),
 727         };
 728
 729         return si476x_core_send_command(core, CMD_INTB_PIN_CFG,
 730                                         args, ARRAY_SIZE(args),
 731                                         resp, ARRAY_SIZE(resp),
 732                                         SI476X_DEFAULT_TIMEOUT);
 733 }
 734
 735
 736
 737 /**
 738  * si476x_cmd_am_rsq_status - send 'AM_RSQ_STATUS' command to the
 739  * device
 740  * @core  - device to send the command to
 741  * @rsqack - if set command clears RSQINT, SNRINT, SNRLINT, RSSIHINT,
 742  *           RSSSILINT, BLENDINT, MULTHINT and MULTLINT
 743  * @attune - when set the values in the status report are the values
 744  *           that were calculated at tune
 745  * @cancel - abort ongoing seek/tune opertation
 746  * @stcack - clear the STCINT bin in status register
 747  * @report - all signal quality information retured by the command
 748  *           (if NULL then the output of the command is ignored)
 749  *
 750  * Function returns 0 on success and negative error code on failure
 751  */
 752 int si476x_core_cmd_am_rsq_status(struct si476x_core *core,
 753                                   struct si476x_rsq_status_args *rsqargs,
 754                                   struct si476x_rsq_status_report *report)
 755 {
 756         int err;
 757         u8       resp[CMD_AM_RSQ_STATUS_NRESP];
 758         const u8 args[CMD_AM_RSQ_STATUS_NARGS] = {
 759                 rsqargs->rsqack << 3 | rsqargs->attune << 2 |
 760                 rsqargs->cancel << 1 | rsqargs->stcack,
 761         };
 762
 763         err = si476x_core_send_command(core, CMD_AM_RSQ_STATUS,
 764                                        args, ARRAY_SIZE(args),
 765                                        resp, ARRAY_SIZE(resp),
 766                                        SI476X_DEFAULT_TIMEOUT);
 767         /*
 768          * Besides getting received signal quality information this
 769          * command can be used to just acknowledge different interrupt
 770          * flags in those cases it is useless to copy and parse
 771          * received data so user can pass NULL, and thus avoid
 772          * unnecessary copying.
 773          */
 774         if (!report)
 775                 return err;
 776
 777         report->snrhint         = 0x08 & resp[1];
 778         report->snrlint         = 0x04 & resp[1];
 779         report->rssihint        = 0x02 & resp[1];
 780         report->rssilint        = 0x01 & resp[1];
 781
 782         report->bltf            = 0x80 & resp[2];
 783         report->snr_ready       = 0x20 & resp[2];
 784         report->rssiready       = 0x08 & resp[2];
 785         report->afcrl           = 0x02 & resp[2];
 786         report->valid           = 0x01 & resp[2];
 787
 788         report->readfreq        = get_unaligned_be16(resp + 3);
 789         report->freqoff         = resp[5];
 790         report->rssi            = resp[6];
 791         report->snr             = resp[7];
 792         report->lassi           = resp[9];
 793         report->hassi           = resp[10];
 794         report->mult            = resp[11];
 795         report->dev             = resp[12];
 796
 797         return err;
 798 }
 799 EXPORT_SYMBOL_GPL(si476x_core_cmd_am_rsq_status);
 800
 801 int si476x_core_cmd_fm_acf_status(struct si476x_core *core,
 802                              struct si476x_acf_status_report *report)
 803 {
 804         int err;
 805         u8       resp[CMD_FM_ACF_STATUS_NRESP];
 806         const u8 args[CMD_FM_ACF_STATUS_NARGS] = {
 807                 0x0,
 808         };
 809
 810         if (!report)
 811                 return -EINVAL;
 812
 813         err = si476x_core_send_command(core, CMD_FM_ACF_STATUS,
 814                                        args, ARRAY_SIZE(args),
 815                                        resp, ARRAY_SIZE(resp),
 816                                        SI476X_DEFAULT_TIMEOUT);
 817         if (err < 0)
 818                 return err;
 819
 820         report->blend_int       = resp[1] & SI476X_ACF_BLEND_INT;
 821         report->hblend_int      = resp[1] & SI476X_ACF_HIBLEND_INT;
 822         report->hicut_int       = resp[1] & SI476X_ACF_HICUT_INT;
 823         report->chbw_int        = resp[1] & SI476X_ACF_CHBW_INT;
 824         report->softmute_int    = resp[1] & SI476X_ACF_SOFTMUTE_INT;
 825         report->smute           = resp[2] & SI476X_ACF_SMUTE;
 826         report->smattn          = resp[3] & SI476X_ACF_SMATTN;
 827         report->chbw            = resp[4];
 828         report->hicut           = resp[5];
 829         report->hiblend         = resp[6];
 830         report->pilot           = resp[7] & SI476X_ACF_PILOT;
 831         report->stblend         = resp[7] & SI476X_ACF_STBLEND;
 832
 833         return err;
 834 }
 835 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_acf_status);
 836
 837 int si476x_core_cmd_am_acf_status(struct si476x_core *core,
 838                                   struct si476x_acf_status_report *report)
 839 {
 840         int err;
 841         u8       resp[CMD_AM_ACF_STATUS_NRESP];
 842         const u8 args[CMD_AM_ACF_STATUS_NARGS] = {
 843                 0x0,
 844         };
 845
 846         if (!report)
 847                 return -EINVAL;
 848
 849         err = si476x_core_send_command(core, CMD_AM_ACF_STATUS,
 850                                        args, ARRAY_SIZE(args),
 851                                        resp, ARRAY_SIZE(resp),
 852                                        SI476X_DEFAULT_TIMEOUT);
 853         if (err < 0)
 854                 return err;
 855
 856         report->blend_int       = resp[1] & SI476X_ACF_BLEND_INT;
 857         report->hblend_int      = resp[1] & SI476X_ACF_HIBLEND_INT;
 858         report->hicut_int       = resp[1] & SI476X_ACF_HICUT_INT;
 859         report->chbw_int        = resp[1] & SI476X_ACF_CHBW_INT;
 860         report->softmute_int    = resp[1] & SI476X_ACF_SOFTMUTE_INT;
 861         report->smute           = resp[2] & SI476X_ACF_SMUTE;
 862         report->smattn          = resp[3] & SI476X_ACF_SMATTN;
 863         report->chbw            = resp[4];
 864         report->hicut           = resp[5];
 865
 866         return err;
 867 }
 868 EXPORT_SYMBOL_GPL(si476x_core_cmd_am_acf_status);
 869
 870
 871 /**
 872  * si476x_cmd_fm_seek_start - send 'FM_SEEK_START' command to the
 873  * device
 874  * @core  - device to send the command to
 875  * @seekup - if set the direction of the search is 'up'
 876  * @wrap   - if set seek wraps when hitting band limit
 877  *
 878  * This function begins search for a valid station. The station is
 879  * considered valid when 'FM_VALID_SNR_THRESHOLD' and
 880  * 'FM_VALID_RSSI_THRESHOLD' and 'FM_VALID_MAX_TUNE_ERROR' criteria
 881  * are met.
 882 } *
 883  * Function returns 0 on success and negative error code on failure
 884  */
 885 int si476x_core_cmd_fm_seek_start(struct si476x_core *core,
 886                                   bool seekup, bool wrap)
 887 {
 888         u8       resp[CMD_FM_SEEK_START_NRESP];
 889         const u8 args[CMD_FM_SEEK_START_NARGS] = {
 890                 seekup << 3 | wrap << 2,
 891         };
 892
 893         return si476x_cmd_tune_seek_freq(core, CMD_FM_SEEK_START,
 894                                          args, sizeof(args),
 895                                          resp, sizeof(resp));
 896 }
 897 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_seek_start);
 898
 899 /**
 900  * si476x_cmd_fm_rds_status - send 'FM_RDS_STATUS' command to the
 901  * device
 902  * @core - device to send the command to
 903  * @status_only - if set the data is not removed from RDSFIFO,
 904  *                RDSFIFOUSED is not decremented and data in all the
 905  *                rest RDS data contains the last valid info received
 906  * @mtfifo if set the command clears RDS receive FIFO
 907  * @intack if set the command clards the RDSINT bit.
 908  *
 909  * Function returns 0 on success and negative error code on failure
 910  */
 911 int si476x_core_cmd_fm_rds_status(struct si476x_core *core,
 912                                   bool status_only,
 913                                   bool mtfifo,
 914                                   bool intack,
 915                                   struct si476x_rds_status_report *report)
 916 {
 917         int err;
 918         u8       resp[CMD_FM_RDS_STATUS_NRESP];
 919         const u8 args[CMD_FM_RDS_STATUS_NARGS] = {
 920                 status_only << 2 | mtfifo << 1 | intack,
 921         };
 922
 923         err = si476x_core_send_command(core, CMD_FM_RDS_STATUS,
 924                                        args, ARRAY_SIZE(args),
 925                                        resp, ARRAY_SIZE(resp),
 926                                        SI476X_DEFAULT_TIMEOUT);
 927         /*
 928          * Besides getting RDS status information this command can be
 929          * used to just acknowledge different interrupt flags in those
 930          * cases it is useless to copy and parse received data so user
 931          * can pass NULL, and thus avoid unnecessary copying.
 932          */
 933         if (err < 0 || report == NULL)
 934                 return err;
 935
 936         report->rdstpptyint     = 0x10 & resp[1];
 937         report->rdspiint        = 0x08 & resp[1];
 938         report->rdssyncint      = 0x02 & resp[1];
 939         report->rdsfifoint      = 0x01 & resp[1];
 940
 941         report->tpptyvalid      = 0x10 & resp[2];
 942         report->pivalid         = 0x08 & resp[2];
 943         report->rdssync         = 0x02 & resp[2];
 944         report->rdsfifolost     = 0x01 & resp[2];
 945
 946         report->tp              = 0x20 & resp[3];
 947         report->pty             = 0x1f & resp[3];
 948
 949         report->pi              = get_unaligned_be16(resp + 4);
 950         report->rdsfifoused     = resp[6];
 951
 952         report->ble[V4L2_RDS_BLOCK_A]   = 0xc0 & resp[7];
 953         report->ble[V4L2_RDS_BLOCK_B]   = 0x30 & resp[7];
 954         report->ble[V4L2_RDS_BLOCK_C]   = 0x0c & resp[7];
 955         report->ble[V4L2_RDS_BLOCK_D]   = 0x03 & resp[7];
 956
 957         report->rds[V4L2_RDS_BLOCK_A].block = V4L2_RDS_BLOCK_A;
 958         report->rds[V4L2_RDS_BLOCK_A].msb = resp[8];
 959         report->rds[V4L2_RDS_BLOCK_A].lsb = resp[9];
 960
 961         report->rds[V4L2_RDS_BLOCK_B].block = V4L2_RDS_BLOCK_B;
 962         report->rds[V4L2_RDS_BLOCK_B].msb = resp[10];
 963         report->rds[V4L2_RDS_BLOCK_B].lsb = resp[11];
 964
 965         report->rds[V4L2_RDS_BLOCK_C].block = V4L2_RDS_BLOCK_C;
 966         report->rds[V4L2_RDS_BLOCK_C].msb = resp[12];
 967         report->rds[V4L2_RDS_BLOCK_C].lsb = resp[13];
 968
 969         report->rds[V4L2_RDS_BLOCK_D].block = V4L2_RDS_BLOCK_D;
 970         report->rds[V4L2_RDS_BLOCK_D].msb = resp[14];
 971         report->rds[V4L2_RDS_BLOCK_D].lsb = resp[15];
 972
 973         return err;
 974 }
 975 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_rds_status);
 976
 977 int si476x_core_cmd_fm_rds_blockcount(struct si476x_core *core,
 978                                 bool clear,
 979                                 struct si476x_rds_blockcount_report *report)
 980 {
 981         int err;
 982         u8       resp[CMD_FM_RDS_BLOCKCOUNT_NRESP];
 983         const u8 args[CMD_FM_RDS_BLOCKCOUNT_NARGS] = {
 984                 clear,
 985         };
 986
 987         if (!report)
 988                 return -EINVAL;
 989
 990         err = si476x_core_send_command(core, CMD_FM_RDS_BLOCKCOUNT,
 991                                        args, ARRAY_SIZE(args),
 992                                        resp, ARRAY_SIZE(resp),
 993                                        SI476X_DEFAULT_TIMEOUT);
 994
 995         if (!err) {
 996                 report->expected        = get_unaligned_be16(resp + 2);
 997                 report->received        = get_unaligned_be16(resp + 4);
 998                 report->uncorrectable   = get_unaligned_be16(resp + 6);
 999         }
1000
1001         return err;
1002 }
1003 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_rds_blockcount);
1004
1005 int si476x_core_cmd_fm_phase_diversity(struct si476x_core *core,
1006                                        enum si476x_phase_diversity_mode mode)
1007 {
1008         u8       resp[CMD_FM_PHASE_DIVERSITY_NRESP];
1009         const u8 args[CMD_FM_PHASE_DIVERSITY_NARGS] = {
1010                 mode & 0x07,
1011         };
1012
1013         return si476x_core_send_command(core, CMD_FM_PHASE_DIVERSITY,
1014                                         args, ARRAY_SIZE(args),
1015                                         resp, ARRAY_SIZE(resp),
1016                                         SI476X_DEFAULT_TIMEOUT);
1017 }
1018 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_phase_diversity);
1019 /**
1020  * si476x_core_cmd_fm_phase_div_status() - get the phase diversity
1021  * status
1022  *
1023  * @core: si476x device
1024  *
1025  * NOTE caller must hold core lock
1026  *
1027  * Function returns the value of the status bit in case of success and
1028  * negative error code in case of failre.
1029  */
1030 int si476x_core_cmd_fm_phase_div_status(struct si476x_core *core)
1031 {
1032         int err;
1033         u8 resp[CMD_FM_PHASE_DIV_STATUS_NRESP];
1034
1035         err = si476x_core_send_command(core, CMD_FM_PHASE_DIV_STATUS,
1036                                        NULL, 0,
1037                                        resp, ARRAY_SIZE(resp),
1038                                        SI476X_DEFAULT_TIMEOUT);
1039
1040         return (err < 0) ? err : resp[1];
1041 }
1042 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_phase_div_status);
1043
1044
1045 /**
1046  * si476x_cmd_am_seek_start - send 'FM_SEEK_START' command to the
1047  * device
1048  * @core  - device to send the command to
1049  * @seekup - if set the direction of the search is 'up'
1050  * @wrap   - if set seek wraps when hitting band limit
1051  *
1052  * This function begins search for a valid station. The station is
1053  * considered valid when 'FM_VALID_SNR_THRESHOLD' and
1054  * 'FM_VALID_RSSI_THRESHOLD' and 'FM_VALID_MAX_TUNE_ERROR' criteria
1055  * are met.
1056  *
1057  * Function returns 0 on success and negative error code on failure
1058  */
1059 int si476x_core_cmd_am_seek_start(struct si476x_core *core,
1060                                   bool seekup, bool wrap)
1061 {
1062         u8       resp[CMD_AM_SEEK_START_NRESP];
1063         const u8 args[CMD_AM_SEEK_START_NARGS] = {
1064                 seekup << 3 | wrap << 2,
1065         };
1066
1067         return si476x_cmd_tune_seek_freq(core,  CMD_AM_SEEK_START,
1068                                          args, sizeof(args),
1069                                          resp, sizeof(resp));
1070 }
1071 EXPORT_SYMBOL_GPL(si476x_core_cmd_am_seek_start);
1072
1073
1074
1075 static int si476x_core_cmd_power_up_a10(struct si476x_core *core,
1076                                         struct si476x_power_up_args *puargs)
1077 {
1078         u8       resp[CMD_POWER_UP_A10_NRESP];
1079         const bool intsel = (core->pinmux.a1 == SI476X_A1_IRQ);
1080         const bool ctsen  = (core->client->irq != 0);
1081         const u8 args[CMD_POWER_UP_A10_NARGS] = {
1082                 0xF7,           /* Reserved, always 0xF7 */
1083                 0x3F & puargs->xcload,  /* First two bits are reserved to be
1084                                  * zeros */
1085                 ctsen << 7 | intsel << 6 | 0x07, /* Last five bits
1086                                                    * are reserved to
1087                                                    * be written as 0x7 */
1088                 puargs->func << 4 | puargs->freq,
1089                 0x11,           /* Reserved, always 0x11 */
1090         };
1091
1092         return si476x_core_send_command(core, CMD_POWER_UP,
1093                                         args, ARRAY_SIZE(args),
1094                                         resp, ARRAY_SIZE(resp),
1095                                         SI476X_TIMEOUT_POWER_UP);
1096 }
1097
1098 static int si476x_core_cmd_power_up_a20(struct si476x_core *core,
1099                                  struct si476x_power_up_args *puargs)
1100 {
1101         u8       resp[CMD_POWER_UP_A20_NRESP];
1102         const bool intsel = (core->pinmux.a1 == SI476X_A1_IRQ);
1103         const bool ctsen  = (core->client->irq != 0);
1104         const u8 args[CMD_POWER_UP_A20_NARGS] = {
1105                 puargs->ibias6x << 7 | puargs->xstart,
1106                 0x3F & puargs->xcload,  /* First two bits are reserved to be
1107                                          * zeros */
1108                 ctsen << 7 | intsel << 6 | puargs->fastboot << 5 |
1109                 puargs->xbiashc << 3 | puargs->xbias,
1110                 puargs->func << 4 | puargs->freq,
1111                 0x10 | puargs->xmode,
1112         };
1113
1114         return si476x_core_send_command(core, CMD_POWER_UP,
1115                                         args, ARRAY_SIZE(args),
1116                                         resp, ARRAY_SIZE(resp),
1117                                         SI476X_TIMEOUT_POWER_UP);
1118 }
1119
1120 static int si476x_core_cmd_power_down_a10(struct si476x_core *core,
1121                                           struct si476x_power_down_args *pdargs)
1122 {
1123         u8 resp[CMD_POWER_DOWN_A10_NRESP];
1124
1125         return si476x_core_send_command(core, CMD_POWER_DOWN,
1126                                         NULL, 0,
1127                                         resp, ARRAY_SIZE(resp),
1128                                         SI476X_DEFAULT_TIMEOUT);
1129 }
1130
1131 static int si476x_core_cmd_power_down_a20(struct si476x_core *core,
1132                                           struct si476x_power_down_args *pdargs)
1133 {
1134         u8 resp[CMD_POWER_DOWN_A20_NRESP];
1135         const u8 args[CMD_POWER_DOWN_A20_NARGS] = {
1136                 pdargs->xosc,
1137         };
1138         return si476x_core_send_command(core, CMD_POWER_DOWN,
1139                                         args, ARRAY_SIZE(args),
1140                                         resp, ARRAY_SIZE(resp),
1141                                         SI476X_DEFAULT_TIMEOUT);
1142 }
1143
1144 static int si476x_core_cmd_am_tune_freq_a10(struct si476x_core *core,
1145                                         struct si476x_tune_freq_args *tuneargs)
1146 {
1147
1148         const int am_freq = tuneargs->freq;
1149         u8       resp[CMD_AM_TUNE_FREQ_NRESP];
1150         const u8 args[CMD_AM_TUNE_FREQ_NARGS] = {
1151                 (tuneargs->hd << 6),
1152                 msb(am_freq),
1153                 lsb(am_freq),
1154         };
1155
1156         return si476x_cmd_tune_seek_freq(core, CMD_AM_TUNE_FREQ, args,
1157                                          sizeof(args),
1158                                          resp, sizeof(resp));
1159 }
1160
1161 static int si476x_core_cmd_am_tune_freq_a20(struct si476x_core *core,
1162                                         struct si476x_tune_freq_args *tuneargs)
1163 {
1164         const int am_freq = tuneargs->freq;
1165         u8       resp[CMD_AM_TUNE_FREQ_NRESP];
1166         const u8 args[CMD_AM_TUNE_FREQ_NARGS] = {
1167                 (tuneargs->zifsr << 6) | (tuneargs->injside & 0x03),
1168                 msb(am_freq),
1169                 lsb(am_freq),
1170         };
1171
1172         return si476x_cmd_tune_seek_freq(core, CMD_AM_TUNE_FREQ,
1173                                          args, sizeof(args),
1174                                          resp, sizeof(resp));
1175 }
1176
1177 static int si476x_core_cmd_fm_rsq_status_a10(struct si476x_core *core,
1178                                         struct si476x_rsq_status_args *rsqargs,
1179                                         struct si476x_rsq_status_report *report)
1180 {
1181         int err;
1182         u8       resp[CMD_FM_RSQ_STATUS_A10_NRESP];
1183         const u8 args[CMD_FM_RSQ_STATUS_A10_NARGS] = {
1184                 rsqargs->rsqack << 3 | rsqargs->attune << 2 |
1185                 rsqargs->cancel << 1 | rsqargs->stcack,
1186         };
1187
1188         err = si476x_core_send_command(core, CMD_FM_RSQ_STATUS,
1189                                        args, ARRAY_SIZE(args),
1190                                        resp, ARRAY_SIZE(resp),
1191                                        SI476X_DEFAULT_TIMEOUT);
1192         /*
1193          * Besides getting received signal quality information this
1194          * command can be used to just acknowledge different interrupt
1195          * flags in those cases it is useless to copy and parse
1196          * received data so user can pass NULL, and thus avoid
1197          * unnecessary copying.
1198          */
1199         if (err < 0 || report == NULL)
1200                 return err;
1201
1202         report->multhint        = 0x80 & resp[1];
1203         report->multlint        = 0x40 & resp[1];
1204         report->snrhint         = 0x08 & resp[1];
1205         report->snrlint         = 0x04 & resp[1];
1206         report->rssihint        = 0x02 & resp[1];
1207         report->rssilint        = 0x01 & resp[1];
1208
1209         report->bltf            = 0x80 & resp[2];
1210         report->snr_ready       = 0x20 & resp[2];
1211         report->rssiready       = 0x08 & resp[2];
1212         report->afcrl           = 0x02 & resp[2];
1213         report->valid           = 0x01 & resp[2];
1214
1215         report->readfreq        = get_unaligned_be16(resp + 3);
1216         report->freqoff         = resp[5];
1217         report->rssi            = resp[6];
1218         report->snr             = resp[7];
1219         report->lassi           = resp[9];
1220         report->hassi           = resp[10];
1221         report->mult            = resp[11];
1222         report->dev             = resp[12];
1223         report->readantcap      = get_unaligned_be16(resp + 13);
1224         report->assi            = resp[15];
1225         report->usn             = resp[16];
1226
1227         return err;
1228 }
1229
1230 static int si476x_core_cmd_fm_rsq_status_a20(struct si476x_core *core,
1231                                      struct si476x_rsq_status_args *rsqargs,
1232                                      struct si476x_rsq_status_report *report)
1233 {
1234         int err;
1235         u8       resp[CMD_FM_RSQ_STATUS_A10_NRESP];
1236         const u8 args[CMD_FM_RSQ_STATUS_A30_NARGS] = {
1237                 rsqargs->primary << 4 | rsqargs->rsqack << 3 |
1238                 rsqargs->attune  << 2 | rsqargs->cancel << 1 |
1239                 rsqargs->stcack,
1240         };
1241
1242         err = si476x_core_send_command(core, CMD_FM_RSQ_STATUS,
1243                                        args, ARRAY_SIZE(args),
1244                                        resp, ARRAY_SIZE(resp),
1245                                        SI476X_DEFAULT_TIMEOUT);
1246         /*
1247          * Besides getting received signal quality information this
1248          * command can be used to just acknowledge different interrupt
1249          * flags in those cases it is useless to copy and parse
1250          * received data so user can pass NULL, and thus avoid
1251          * unnecessary copying.
1252          */
1253         if (err < 0 || report == NULL)
1254                 return err;
1255
1256         report->multhint        = 0x80 & resp[1];
1257         report->multlint        = 0x40 & resp[1];
1258         report->snrhint         = 0x08 & resp[1];
1259         report->snrlint         = 0x04 & resp[1];
1260         report->rssihint        = 0x02 & resp[1];
1261         report->rssilint        = 0x01 & resp[1];
1262
1263         report->bltf            = 0x80 & resp[2];
1264         report->snr_ready       = 0x20 & resp[2];
1265         report->rssiready       = 0x08 & resp[2];
1266         report->afcrl           = 0x02 & resp[2];
1267         report->valid           = 0x01 & resp[2];
1268
1269         report->readfreq        = get_unaligned_be16(resp + 3);
1270         report->freqoff         = resp[5];
1271         report->rssi            = resp[6];
1272         report->snr             = resp[7];
1273         report->lassi           = resp[9];
1274         report->hassi           = resp[10];
1275         report->mult            = resp[11];
1276         report->dev             = resp[12];
1277         report->readantcap      = get_unaligned_be16(resp + 13);
1278         report->assi            = resp[15];
1279         report->usn             = resp[16];
1280
1281         return err;
1282 }
1283
1284
1285 static int si476x_core_cmd_fm_rsq_status_a30(struct si476x_core *core,
1286                                         struct si476x_rsq_status_args *rsqargs,
1287                                         struct si476x_rsq_status_report *report)
1288 {
1289         int err;
1290         u8       resp[CMD_FM_RSQ_STATUS_A30_NRESP];
1291         const u8 args[CMD_FM_RSQ_STATUS_A30_NARGS] = {
1292                 rsqargs->primary << 4 | rsqargs->rsqack << 3 |
1293                 rsqargs->attune << 2 | rsqargs->cancel << 1 |
1294                 rsqargs->stcack,
1295         };
1296
1297         err = si476x_core_send_command(core, CMD_FM_RSQ_STATUS,
1298                                        args, ARRAY_SIZE(args),
1299                                        resp, ARRAY_SIZE(resp),
1300                                        SI476X_DEFAULT_TIMEOUT);
1301         /*
1302          * Besides getting received signal quality information this
1303          * command can be used to just acknowledge different interrupt
1304          * flags in those cases it is useless to copy and parse
1305          * received data so user can pass NULL, and thus avoid
1306          * unnecessary copying.
1307          */
1308         if (err < 0 || report == NULL)
1309                 return err;
1310
1311         report->multhint        = 0x80 & resp[1];
1312         report->multlint        = 0x40 & resp[1];
1313         report->snrhint         = 0x08 & resp[1];
1314         report->snrlint         = 0x04 & resp[1];
1315         report->rssihint        = 0x02 & resp[1];
1316         report->rssilint        = 0x01 & resp[1];
1317
1318         report->bltf            = 0x80 & resp[2];
1319         report->snr_ready       = 0x20 & resp[2];
1320         report->rssiready       = 0x08 & resp[2];
1321         report->injside         = 0x04 & resp[2];
1322         report->afcrl           = 0x02 & resp[2];
1323         report->valid           = 0x01 & resp[2];
1324
1325         report->readfreq        = get_unaligned_be16(resp + 3);
1326         report->freqoff         = resp[5];
1327         report->rssi            = resp[6];
1328         report->snr             = resp[7];
1329         report->issi            = resp[8];
1330         report->lassi           = resp[9];
1331         report->hassi           = resp[10];
1332         report->mult            = resp[11];
1333         report->dev             = resp[12];
1334         report->readantcap      = get_unaligned_be16(resp + 13);
1335         report->assi            = resp[15];
1336         report->usn             = resp[16];
1337
1338         report->pilotdev        = resp[17];
1339         report->rdsdev          = resp[18];
1340         report->assidev         = resp[19];
1341         report->strongdev       = resp[20];
1342         report->rdspi           = get_unaligned_be16(resp + 21);
1343
1344         return err;
1345 }
1346
1347 static int si476x_core_cmd_fm_tune_freq_a10(struct si476x_core *core,
1348                                         struct si476x_tune_freq_args *tuneargs)
1349 {
1350         u8       resp[CMD_FM_TUNE_FREQ_NRESP];
1351         const u8 args[CMD_FM_TUNE_FREQ_A10_NARGS] = {
1352                 (tuneargs->hd << 6) | (tuneargs->tunemode << 4)
1353                 | (tuneargs->smoothmetrics << 2),
1354                 msb(tuneargs->freq),
1355                 lsb(tuneargs->freq),
1356                 msb(tuneargs->antcap),
1357                 lsb(tuneargs->antcap)
1358         };
1359
1360         return si476x_cmd_tune_seek_freq(core, CMD_FM_TUNE_FREQ,
1361                                          args, sizeof(args),
1362                                          resp, sizeof(resp));
1363 }
1364
1365 static int si476x_core_cmd_fm_tune_freq_a20(struct si476x_core *core,
1366                                         struct si476x_tune_freq_args *tuneargs)
1367 {
1368         u8       resp[CMD_FM_TUNE_FREQ_NRESP];
1369         const u8 args[CMD_FM_TUNE_FREQ_A20_NARGS] = {
1370                 (tuneargs->hd << 6) | (tuneargs->tunemode << 4)
1371                 |  (tuneargs->smoothmetrics << 2) | (tuneargs->injside),
1372                 msb(tuneargs->freq),
1373                 lsb(tuneargs->freq),
1374         };
1375
1376         return si476x_cmd_tune_seek_freq(core, CMD_FM_TUNE_FREQ,
1377                                          args, sizeof(args),
1378                                          resp, sizeof(resp));
1379 }
1380
1381 static int si476x_core_cmd_agc_status_a20(struct si476x_core *core,
1382                                         struct si476x_agc_status_report *report)
1383 {
1384         int err;
1385         u8 resp[CMD_AGC_STATUS_NRESP_A20];
1386
1387         if (!report)
1388                 return -EINVAL;
1389
1390         err = si476x_core_send_command(core, CMD_AGC_STATUS,
1391                                        NULL, 0,
1392                                        resp, ARRAY_SIZE(resp),
1393                                        SI476X_DEFAULT_TIMEOUT);
1394         if (err < 0)
1395                 return err;
1396
1397         report->mxhi            = resp[1] & SI476X_AGC_MXHI;
1398         report->mxlo            = resp[1] & SI476X_AGC_MXLO;
1399         report->lnahi           = resp[1] & SI476X_AGC_LNAHI;
1400         report->lnalo           = resp[1] & SI476X_AGC_LNALO;
1401         report->fmagc1          = resp[2];
1402         report->fmagc2          = resp[3];
1403         report->pgagain         = resp[4];
1404         report->fmwblang        = resp[5];
1405
1406         return err;
1407 }
1408
1409 static int si476x_core_cmd_agc_status_a10(struct si476x_core *core,
1410                                         struct si476x_agc_status_report *report)
1411 {
1412         int err;
1413         u8 resp[CMD_AGC_STATUS_NRESP_A10];
1414
1415         if (!report)
1416                 return -EINVAL;
1417
1418         err = si476x_core_send_command(core, CMD_AGC_STATUS,
1419                                        NULL, 0,
1420                                        resp, ARRAY_SIZE(resp),
1421                                        SI476X_DEFAULT_TIMEOUT);
1422         if (err < 0)
1423                 return err;
1424
1425         report->mxhi    = resp[1] & SI476X_AGC_MXHI;
1426         report->mxlo    = resp[1] & SI476X_AGC_MXLO;
1427         report->lnahi   = resp[1] & SI476X_AGC_LNAHI;
1428         report->lnalo   = resp[1] & SI476X_AGC_LNALO;
1429
1430         return err;
1431 }
1432
1433 typedef int (*tune_freq_func_t) (struct si476x_core *core,
1434                                  struct si476x_tune_freq_args *tuneargs);
1435
1436 static struct {
1437         int (*power_up)(struct si476x_core *,
1438                         struct si476x_power_up_args *);
1439         int (*power_down)(struct si476x_core *,
1440                           struct si476x_power_down_args *);
1441
1442         tune_freq_func_t fm_tune_freq;
1443         tune_freq_func_t am_tune_freq;
1444
1445         int (*fm_rsq_status)(struct si476x_core *,
1446                              struct si476x_rsq_status_args *,
1447                              struct si476x_rsq_status_report *);
1448
1449         int (*agc_status)(struct si476x_core *,
1450                           struct si476x_agc_status_report *);
1451         int (*intb_pin_cfg)(struct si476x_core *core,
1452                             enum si476x_intb_config intb,
1453                             enum si476x_a1_config a1);
1454 } si476x_cmds_vtable[] = {
1455         [SI476X_REVISION_A10] = {
1456                 .power_up       = si476x_core_cmd_power_up_a10,
1457                 .power_down     = si476x_core_cmd_power_down_a10,
1458                 .fm_tune_freq   = si476x_core_cmd_fm_tune_freq_a10,
1459                 .am_tune_freq   = si476x_core_cmd_am_tune_freq_a10,
1460                 .fm_rsq_status  = si476x_core_cmd_fm_rsq_status_a10,
1461                 .agc_status     = si476x_core_cmd_agc_status_a10,
1462                 .intb_pin_cfg   = si476x_core_cmd_intb_pin_cfg_a10,
1463         },
1464         [SI476X_REVISION_A20] = {
1465                 .power_up       = si476x_core_cmd_power_up_a20,
1466                 .power_down     = si476x_core_cmd_power_down_a20,
1467                 .fm_tune_freq   = si476x_core_cmd_fm_tune_freq_a20,
1468                 .am_tune_freq   = si476x_core_cmd_am_tune_freq_a20,
1469                 .fm_rsq_status  = si476x_core_cmd_fm_rsq_status_a20,
1470                 .agc_status     = si476x_core_cmd_agc_status_a20,
1471                 .intb_pin_cfg   = si476x_core_cmd_intb_pin_cfg_a20,
1472         },
1473         [SI476X_REVISION_A30] = {
1474                 .power_up       = si476x_core_cmd_power_up_a20,
1475                 .power_down     = si476x_core_cmd_power_down_a20,
1476                 .fm_tune_freq   = si476x_core_cmd_fm_tune_freq_a20,
1477                 .am_tune_freq   = si476x_core_cmd_am_tune_freq_a20,
1478                 .fm_rsq_status  = si476x_core_cmd_fm_rsq_status_a30,
1479                 .agc_status     = si476x_core_cmd_agc_status_a20,
1480                 .intb_pin_cfg   = si476x_core_cmd_intb_pin_cfg_a20,
1481         },
1482 };
1483
1484 int si476x_core_cmd_power_up(struct si476x_core *core,
1485                              struct si476x_power_up_args *args)
1486 {
1487         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1488                core->revision == -1);
1489         return si476x_cmds_vtable[core->revision].power_up(core, args);
1490 }
1491 EXPORT_SYMBOL_GPL(si476x_core_cmd_power_up);
1492
1493 int si476x_core_cmd_power_down(struct si476x_core *core,
1494                                struct si476x_power_down_args *args)
1495 {
1496         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1497                core->revision == -1);
1498         return si476x_cmds_vtable[core->revision].power_down(core, args);
1499 }
1500 EXPORT_SYMBOL_GPL(si476x_core_cmd_power_down);
1501
1502 int si476x_core_cmd_fm_tune_freq(struct si476x_core *core,
1503                                  struct si476x_tune_freq_args *args)
1504 {
1505         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1506                core->revision == -1);
1507         return si476x_cmds_vtable[core->revision].fm_tune_freq(core, args);
1508 }
1509 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_tune_freq);
1510
1511 int si476x_core_cmd_am_tune_freq(struct si476x_core *core,
1512                                  struct si476x_tune_freq_args *args)
1513 {
1514         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1515                core->revision == -1);
1516         return si476x_cmds_vtable[core->revision].am_tune_freq(core, args);
1517 }
1518 EXPORT_SYMBOL_GPL(si476x_core_cmd_am_tune_freq);
1519
1520 int si476x_core_cmd_fm_rsq_status(struct si476x_core *core,
1521                                   struct si476x_rsq_status_args *args,
1522                                   struct si476x_rsq_status_report *report)
1523
1524 {
1525         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1526                core->revision == -1);
1527         return si476x_cmds_vtable[core->revision].fm_rsq_status(core, args,
1528                                                                 report);
1529 }
1530 EXPORT_SYMBOL_GPL(si476x_core_cmd_fm_rsq_status);
1531
1532 int si476x_core_cmd_agc_status(struct si476x_core *core,
1533                                   struct si476x_agc_status_report *report)
1534
1535 {
1536         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1537                core->revision == -1);
1538         return si476x_cmds_vtable[core->revision].agc_status(core, report);
1539 }
1540 EXPORT_SYMBOL_GPL(si476x_core_cmd_agc_status);
1541
1542 int si476x_core_cmd_intb_pin_cfg(struct si476x_core *core,
1543                             enum si476x_intb_config intb,
1544                             enum si476x_a1_config a1)
1545 {
1546         BUG_ON(core->revision > SI476X_REVISION_A30 ||
1547                core->revision == -1);
1548
1549         return si476x_cmds_vtable[core->revision].intb_pin_cfg(core, intb, a1);
1550 }
1551 EXPORT_SYMBOL_GPL(si476x_core_cmd_intb_pin_cfg);
1552
1553 MODULE_LICENSE("GPL");
1554 MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
1555 MODULE_DESCRIPTION("API for command exchange for si476x");