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