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