Quelle  mxl301rf.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * MaxLinear MxL301RF OFDM tuner driver
 *
 * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com>
 */

/*
 * NOTICE:
 * This driver is incomplete and lacks init/config of the chips,
 * as the necessary info is not disclosed.
 * Other features like get_if_frequency() are missing as well.
 * It assumes that users of this driver (such as a PCI bridge of
 * DTV receiver cards) properly init and configure the chip
 * via I2C *before* calling this driver's init() function.
 *
 * Currently, PT3 driver is the only one that uses this driver,
 * and contains init/config code in its firmware.
 * Thus some part of the code might be dependent on PT3 specific config.
 */

#include <linux/kernel.h>
#include "mxl301rf.h"

struct mxl301rf_state {
 struct mxl301rf_config cfg;
 struct i2c_client *i2c;
};

static struct mxl301rf_state *cfg_to_state(struct mxl301rf_config *c)
{
 return container_of(c, struct mxl301rf_state, cfg);
}

static int raw_write(struct mxl301rf_state *state, const u8 *buf, int len)
{
 int ret;

 ret = i2c_master_send(state->i2c, buf, len);
 if (ret >= 0 && ret < len)
  ret = -EIO;
 return (ret == len) ? 0 : ret;
}

static int reg_write(struct mxl301rf_state *state, u8 reg, u8 val)
{
 u8 buf[2] = { reg, val };

 return raw_write(state, buf, 2);
}

static int reg_read(struct mxl301rf_state *state, u8 reg, u8 *val)
{
 u8 wbuf[2] = { 0xfb, reg };
 int ret;

 ret = raw_write(state, wbuf, sizeof(wbuf));
 if (ret == 0)
  ret = i2c_master_recv(state->i2c, val, 1);
 if (ret >= 0 && ret < 1)
  ret = -EIO;
 return (ret == 1) ? 0 : ret;
}

/* tuner_ops */

/* get RSSI and update property cache, set to *out in % */
static int mxl301rf_get_rf_strength(struct dvb_frontend *fe, u16 *out)
{
 struct mxl301rf_state *state;
 int ret;
 u8  rf_in1, rf_in2, rf_off1, rf_off2;
 u16 rf_in, rf_off;
 s64 level;
 struct dtv_fe_stats *rssi;

 rssi = &fe->dtv_property_cache.strength;
 rssi->len = 1;
 rssi->stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 *out = 0;

 state = fe->tuner_priv;
 ret = reg_write(state, 0x14, 0x01);
 if (ret < 0)
  return ret;
 usleep_range(1000, 2000);

 ret = reg_read(state, 0x18, &rf_in1);
 if (ret == 0)
  ret = reg_read(state, 0x19, &rf_in2);
 if (ret == 0)
  ret = reg_read(state, 0xd6, &rf_off1);
 if (ret == 0)
  ret = reg_read(state, 0xd7, &rf_off2);
 if (ret != 0)
  return ret;

 rf_in = (rf_in2 & 0x07) << 8 | rf_in1;
 rf_off = (rf_off2 & 0x0f) << 5 | (rf_off1 >> 3);
 level = rf_in - rf_off - (113 << 3); /* x8 dBm */
 level = level * 1000 / 8;
 rssi->stat[0].svalue = level;
 rssi->stat[0].scale = FE_SCALE_DECIBEL;
 /* *out = (level - min) * 100 / (max - min) */
 *out = (rf_in - rf_off + (1 << 9) - 1) * 100 / ((5 << 9) - 2);
 return 0;
}

/* spur shift parameters */
struct shf {
 u32 freq;  /* Channel center frequency */
 u32 ofst_th; /* Offset frequency threshold */
 u8 shf_val; /* Spur shift value */
 u8 shf_dir; /* Spur shift direction */
};

static const struct shf shf_tab[] = {
 {  64500, 500, 0x92, 0x07 },
 { 191500, 300, 0xe2, 0x07 },
 { 205500, 500, 0x2c, 0x04 },
 { 212500, 500, 0x1e, 0x04 },
 { 226500, 500, 0xd4, 0x07 },
 {  99143, 500, 0x9c, 0x07 },
 { 173143, 500, 0xd4, 0x07 },
 { 191143, 300, 0xd4, 0x07 },
 { 207143, 500, 0xce, 0x07 },
 { 225143, 500, 0xce, 0x07 },
 { 243143, 500, 0xd4, 0x07 },
 { 261143, 500, 0xd4, 0x07 },
 { 291143, 500, 0xd4, 0x07 },
 { 339143, 500, 0x2c, 0x04 },
 { 117143, 500, 0x7a, 0x07 },
 { 135143, 300, 0x7a, 0x07 },
 { 153143, 500, 0x01, 0x07 }
};

struct reg_val {
 u8 reg;
 u8 val;
} __attribute__ ((__packed__));

static const struct reg_val set_idac[] = {
 { 0x0d, 0x00 },
 { 0x0c, 0x67 },
 { 0x6f, 0x89 },
 { 0x70, 0x0c },
 { 0x6f, 0x8a },
 { 0x70, 0x0e },
 { 0x6f, 0x8b },
 { 0x70, 0x1c },
};

static int mxl301rf_set_params(struct dvb_frontend *fe)
{
 struct reg_val tune0[] = {
  { 0x13, 0x00 },  /* abort tuning */
  { 0x3b, 0xc0 },
  { 0x3b, 0x80 },
  { 0x10, 0x95 },  /* BW */
  { 0x1a, 0x05 },
  { 0x61, 0x00 },  /* spur shift value (placeholder) */
  { 0x62, 0xa0 }  /* spur shift direction (placeholder) */
 };

 struct reg_val tune1[] = {
  { 0x11, 0x40 },  /* RF frequency L (placeholder) */
  { 0x12, 0x0e },  /* RF frequency H (placeholder) */
  { 0x13, 0x01 }  /* start tune */
 };

 struct mxl301rf_state *state;
 u32 freq;
 u16 f;
 u32 tmp, div;
 int i, ret;

 state = fe->tuner_priv;
 freq = fe->dtv_property_cache.frequency;

 /* spur shift function (for analog) */
 for (i = 0; i < ARRAY_SIZE(shf_tab); i++) {
  if (freq >= (shf_tab[i].freq - shf_tab[i].ofst_th) * 1000 &&
      freq <= (shf_tab[i].freq + shf_tab[i].ofst_th) * 1000) {
   tune0[5].val = shf_tab[i].shf_val;
   tune0[6].val = 0xa0 | shf_tab[i].shf_dir;
   break;
  }
 }
 ret = raw_write(state, (u8 *) tune0, sizeof(tune0));
 if (ret < 0)
  goto failed;
 usleep_range(3000, 4000);

 /* convert freq to 10.6 fixed point float [MHz] */
 f = freq / 1000000;
 tmp = freq % 1000000;
 div = 1000000;
 for (i = 0; i < 6; i++) {
  f <<= 1;
  div >>= 1;
  if (tmp > div) {
   tmp -= div;
   f |= 1;
  }
 }
 if (tmp > 7812)
  f++;
 tune1[0].val = f & 0xff;
 tune1[1].val = f >> 8;
 ret = raw_write(state, (u8 *) tune1, sizeof(tune1));
 if (ret < 0)
  goto failed;
 msleep(31);

 ret = reg_write(state, 0x1a, 0x0d);
 if (ret < 0)
  goto failed;
 ret = raw_write(state, (u8 *) set_idac, sizeof(set_idac));
 if (ret < 0)
  goto failed;
 return 0;

failed:
 dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n",
  __func__, fe->dvb->num, fe->id);
 return ret;
}

static const struct reg_val standby_data[] = {
 { 0x01, 0x00 },
 { 0x13, 0x00 }
};

static int mxl301rf_sleep(struct dvb_frontend *fe)
{
 struct mxl301rf_state *state;
 int ret;

 state = fe->tuner_priv;
 ret = raw_write(state, (u8 *)standby_data, sizeof(standby_data));
 if (ret < 0)
  dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n",
   __func__, fe->dvb->num, fe->id);
 return ret;
}


/* init sequence is not public.
 * the parent must have init'ed the device.
 * just wake up here.
 */
static int mxl301rf_init(struct dvb_frontend *fe)
{
 struct mxl301rf_state *state;
 int ret;

 state = fe->tuner_priv;

 ret = reg_write(state, 0x01, 0x01);
 if (ret < 0) {
  dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n",
    __func__, fe->dvb->num, fe->id);
  return ret;
 }
 return 0;
}

/* I2C driver functions */

static const struct dvb_tuner_ops mxl301rf_ops = {
 .info = {
  .name = "MaxLinear MxL301RF",

  .frequency_min_hz =  93 * MHz,
  .frequency_max_hz = 803 * MHz + 142857,
 },

 .init = mxl301rf_init,
 .sleep = mxl301rf_sleep,

 .set_params = mxl301rf_set_params,
 .get_rf_strength = mxl301rf_get_rf_strength,
};


static int mxl301rf_probe(struct i2c_client *client)
{
 struct mxl301rf_state *state;
 struct mxl301rf_config *cfg;
 struct dvb_frontend *fe;

 state = kzalloc(sizeof(*state), GFP_KERNEL);
 if (!state)
  return -ENOMEM;

 state->i2c = client;
 cfg = client->dev.platform_data;

 memcpy(&state->cfg, cfg, sizeof(state->cfg));
 fe = cfg->fe;
 fe->tuner_priv = state;
 memcpy(&fe->ops.tuner_ops, &mxl301rf_ops, sizeof(mxl301rf_ops));

 i2c_set_clientdata(client, &state->cfg);
 dev_info(&client->dev, "MaxLinear MxL301RF attached.\n");
 return 0;
}

static void mxl301rf_remove(struct i2c_client *client)
{
 struct mxl301rf_state *state;

 state = cfg_to_state(i2c_get_clientdata(client));
 state->cfg.fe->tuner_priv = NULL;
 kfree(state);
}


static const struct i2c_device_id mxl301rf_id[] = {
 { "mxl301rf" },
 {}
};
MODULE_DEVICE_TABLE(i2c, mxl301rf_id);

static struct i2c_driver mxl301rf_driver = {
 .driver = {
  .name = "mxl301rf",
 },
 .probe  = mxl301rf_probe,
 .remove  = mxl301rf_remove,
 .id_table = mxl301rf_id,
};

module_i2c_driver(mxl301rf_driver);

MODULE_DESCRIPTION("MaxLinear MXL301RF tuner");
MODULE_AUTHOR("Akihiro TSUKADA");
MODULE_LICENSE("GPL");