1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * MaxLinear MxL301RF OFDM tuner driver 4 * 5 * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com> 6 */ 7 8 /* 9 * NOTICE: 10 * This driver is incomplete and lacks init/config of the chips, 11 * as the necessary info is not disclosed. 12 * Other features like get_if_frequency() are missing as well. 13 * It assumes that users of this driver (such as a PCI bridge of 14 * DTV receiver cards) properly init and configure the chip 15 * via I2C *before* calling this driver's init() function. 16 * 17 * Currently, PT3 driver is the only one that uses this driver, 18 * and contains init/config code in its firmware. 19 * Thus some part of the code might be dependent on PT3 specific config. 20 */ 21 22 #include <linux/kernel.h> 23 #include "mxl301rf.h" 24 25 struct mxl301rf_state { 26 struct mxl301rf_config cfg; 27 struct i2c_client *i2c; 28 }; 29 30 static struct mxl301rf_state *cfg_to_state(struct mxl301rf_config *c) 31 { 32 return container_of(c, struct mxl301rf_state, cfg); 33 } 34 35 static int raw_write(struct mxl301rf_state *state, const u8 *buf, int len) 36 { 37 int ret; 38 39 ret = i2c_master_send(state->i2c, buf, len); 40 if (ret >= 0 && ret < len) 41 ret = -EIO; 42 return (ret == len) ? 0 : ret; 43 } 44 45 static int reg_write(struct mxl301rf_state *state, u8 reg, u8 val) 46 { 47 u8 buf[2] = { reg, val }; 48 49 return raw_write(state, buf, 2); 50 } 51 52 static int reg_read(struct mxl301rf_state *state, u8 reg, u8 *val) 53 { 54 u8 wbuf[2] = { 0xfb, reg }; 55 int ret; 56 57 ret = raw_write(state, wbuf, sizeof(wbuf)); 58 if (ret == 0) 59 ret = i2c_master_recv(state->i2c, val, 1); 60 if (ret >= 0 && ret < 1) 61 ret = -EIO; 62 return (ret == 1) ? 0 : ret; 63 } 64 65 /* tuner_ops */ 66 67 /* get RSSI and update propery cache, set to *out in % */ 68 static int mxl301rf_get_rf_strength(struct dvb_frontend *fe, u16 *out) 69 { 70 struct mxl301rf_state *state; 71 int ret; 72 u8 rf_in1, rf_in2, rf_off1, rf_off2; 73 u16 rf_in, rf_off; 74 s64 level; 75 struct dtv_fe_stats *rssi; 76 77 rssi = &fe->dtv_property_cache.strength; 78 rssi->len = 1; 79 rssi->stat[0].scale = FE_SCALE_NOT_AVAILABLE; 80 *out = 0; 81 82 state = fe->tuner_priv; 83 ret = reg_write(state, 0x14, 0x01); 84 if (ret < 0) 85 return ret; 86 usleep_range(1000, 2000); 87 88 ret = reg_read(state, 0x18, &rf_in1); 89 if (ret == 0) 90 ret = reg_read(state, 0x19, &rf_in2); 91 if (ret == 0) 92 ret = reg_read(state, 0xd6, &rf_off1); 93 if (ret == 0) 94 ret = reg_read(state, 0xd7, &rf_off2); 95 if (ret != 0) 96 return ret; 97 98 rf_in = (rf_in2 & 0x07) << 8 | rf_in1; 99 rf_off = (rf_off2 & 0x0f) << 5 | (rf_off1 >> 3); 100 level = rf_in - rf_off - (113 << 3); /* x8 dBm */ 101 level = level * 1000 / 8; 102 rssi->stat[0].svalue = level; 103 rssi->stat[0].scale = FE_SCALE_DECIBEL; 104 /* *out = (level - min) * 100 / (max - min) */ 105 *out = (rf_in - rf_off + (1 << 9) - 1) * 100 / ((5 << 9) - 2); 106 return 0; 107 } 108 109 /* spur shift parameters */ 110 struct shf { 111 u32 freq; /* Channel center frequency */ 112 u32 ofst_th; /* Offset frequency threshold */ 113 u8 shf_val; /* Spur shift value */ 114 u8 shf_dir; /* Spur shift direction */ 115 }; 116 117 static const struct shf shf_tab[] = { 118 { 64500, 500, 0x92, 0x07 }, 119 { 191500, 300, 0xe2, 0x07 }, 120 { 205500, 500, 0x2c, 0x04 }, 121 { 212500, 500, 0x1e, 0x04 }, 122 { 226500, 500, 0xd4, 0x07 }, 123 { 99143, 500, 0x9c, 0x07 }, 124 { 173143, 500, 0xd4, 0x07 }, 125 { 191143, 300, 0xd4, 0x07 }, 126 { 207143, 500, 0xce, 0x07 }, 127 { 225143, 500, 0xce, 0x07 }, 128 { 243143, 500, 0xd4, 0x07 }, 129 { 261143, 500, 0xd4, 0x07 }, 130 { 291143, 500, 0xd4, 0x07 }, 131 { 339143, 500, 0x2c, 0x04 }, 132 { 117143, 500, 0x7a, 0x07 }, 133 { 135143, 300, 0x7a, 0x07 }, 134 { 153143, 500, 0x01, 0x07 } 135 }; 136 137 struct reg_val { 138 u8 reg; 139 u8 val; 140 } __attribute__ ((__packed__)); 141 142 static const struct reg_val set_idac[] = { 143 { 0x0d, 0x00 }, 144 { 0x0c, 0x67 }, 145 { 0x6f, 0x89 }, 146 { 0x70, 0x0c }, 147 { 0x6f, 0x8a }, 148 { 0x70, 0x0e }, 149 { 0x6f, 0x8b }, 150 { 0x70, 0x1c }, 151 }; 152 153 static int mxl301rf_set_params(struct dvb_frontend *fe) 154 { 155 struct reg_val tune0[] = { 156 { 0x13, 0x00 }, /* abort tuning */ 157 { 0x3b, 0xc0 }, 158 { 0x3b, 0x80 }, 159 { 0x10, 0x95 }, /* BW */ 160 { 0x1a, 0x05 }, 161 { 0x61, 0x00 }, /* spur shift value (placeholder) */ 162 { 0x62, 0xa0 } /* spur shift direction (placeholder) */ 163 }; 164 165 struct reg_val tune1[] = { 166 { 0x11, 0x40 }, /* RF frequency L (placeholder) */ 167 { 0x12, 0x0e }, /* RF frequency H (placeholder) */ 168 { 0x13, 0x01 } /* start tune */ 169 }; 170 171 struct mxl301rf_state *state; 172 u32 freq; 173 u16 f; 174 u32 tmp, div; 175 int i, ret; 176 177 state = fe->tuner_priv; 178 freq = fe->dtv_property_cache.frequency; 179 180 /* spur shift function (for analog) */ 181 for (i = 0; i < ARRAY_SIZE(shf_tab); i++) { 182 if (freq >= (shf_tab[i].freq - shf_tab[i].ofst_th) * 1000 && 183 freq <= (shf_tab[i].freq + shf_tab[i].ofst_th) * 1000) { 184 tune0[5].val = shf_tab[i].shf_val; 185 tune0[6].val = 0xa0 | shf_tab[i].shf_dir; 186 break; 187 } 188 } 189 ret = raw_write(state, (u8 *) tune0, sizeof(tune0)); 190 if (ret < 0) 191 goto failed; 192 usleep_range(3000, 4000); 193 194 /* convert freq to 10.6 fixed point float [MHz] */ 195 f = freq / 1000000; 196 tmp = freq % 1000000; 197 div = 1000000; 198 for (i = 0; i < 6; i++) { 199 f <<= 1; 200 div >>= 1; 201 if (tmp > div) { 202 tmp -= div; 203 f |= 1; 204 } 205 } 206 if (tmp > 7812) 207 f++; 208 tune1[0].val = f & 0xff; 209 tune1[1].val = f >> 8; 210 ret = raw_write(state, (u8 *) tune1, sizeof(tune1)); 211 if (ret < 0) 212 goto failed; 213 msleep(31); 214 215 ret = reg_write(state, 0x1a, 0x0d); 216 if (ret < 0) 217 goto failed; 218 ret = raw_write(state, (u8 *) set_idac, sizeof(set_idac)); 219 if (ret < 0) 220 goto failed; 221 return 0; 222 223 failed: 224 dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n", 225 __func__, fe->dvb->num, fe->id); 226 return ret; 227 } 228 229 static const struct reg_val standby_data[] = { 230 { 0x01, 0x00 }, 231 { 0x13, 0x00 } 232 }; 233 234 static int mxl301rf_sleep(struct dvb_frontend *fe) 235 { 236 struct mxl301rf_state *state; 237 int ret; 238 239 state = fe->tuner_priv; 240 ret = raw_write(state, (u8 *)standby_data, sizeof(standby_data)); 241 if (ret < 0) 242 dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n", 243 __func__, fe->dvb->num, fe->id); 244 return ret; 245 } 246 247 248 /* init sequence is not public. 249 * the parent must have init'ed the device. 250 * just wake up here. 251 */ 252 static int mxl301rf_init(struct dvb_frontend *fe) 253 { 254 struct mxl301rf_state *state; 255 int ret; 256 257 state = fe->tuner_priv; 258 259 ret = reg_write(state, 0x01, 0x01); 260 if (ret < 0) { 261 dev_warn(&state->i2c->dev, "(%s) failed. [adap%d-fe%d]\n", 262 __func__, fe->dvb->num, fe->id); 263 return ret; 264 } 265 return 0; 266 } 267 268 /* I2C driver functions */ 269 270 static const struct dvb_tuner_ops mxl301rf_ops = { 271 .info = { 272 .name = "MaxLinear MxL301RF", 273 274 .frequency_min_hz = 93 * MHz, 275 .frequency_max_hz = 803 * MHz + 142857, 276 }, 277 278 .init = mxl301rf_init, 279 .sleep = mxl301rf_sleep, 280 281 .set_params = mxl301rf_set_params, 282 .get_rf_strength = mxl301rf_get_rf_strength, 283 }; 284 285 286 static int mxl301rf_probe(struct i2c_client *client) 287 { 288 struct mxl301rf_state *state; 289 struct mxl301rf_config *cfg; 290 struct dvb_frontend *fe; 291 292 state = kzalloc(sizeof(*state), GFP_KERNEL); 293 if (!state) 294 return -ENOMEM; 295 296 state->i2c = client; 297 cfg = client->dev.platform_data; 298 299 memcpy(&state->cfg, cfg, sizeof(state->cfg)); 300 fe = cfg->fe; 301 fe->tuner_priv = state; 302 memcpy(&fe->ops.tuner_ops, &mxl301rf_ops, sizeof(mxl301rf_ops)); 303 304 i2c_set_clientdata(client, &state->cfg); 305 dev_info(&client->dev, "MaxLinear MxL301RF attached.\n"); 306 return 0; 307 } 308 309 static void mxl301rf_remove(struct i2c_client *client) 310 { 311 struct mxl301rf_state *state; 312 313 state = cfg_to_state(i2c_get_clientdata(client)); 314 state->cfg.fe->tuner_priv = NULL; 315 kfree(state); 316 } 317 318 319 static const struct i2c_device_id mxl301rf_id[] = { 320 {"mxl301rf", 0}, 321 {} 322 }; 323 MODULE_DEVICE_TABLE(i2c, mxl301rf_id); 324 325 static struct i2c_driver mxl301rf_driver = { 326 .driver = { 327 .name = "mxl301rf", 328 }, 329 .probe_new = mxl301rf_probe, 330 .remove = mxl301rf_remove, 331 .id_table = mxl301rf_id, 332 }; 333 334 module_i2c_driver(mxl301rf_driver); 335 336 MODULE_DESCRIPTION("MaxLinear MXL301RF tuner"); 337 MODULE_AUTHOR("Akihiro TSUKADA"); 338 MODULE_LICENSE("GPL"); 339