1 /* 2 * Driver for Zarlink ZL10039 DVB-S tuner 3 * 4 * Copyright 2007 Jan D. Louw <jd.louw@mweb.co.za> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 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 * 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/string.h> 25 #include <linux/slab.h> 26 #include <linux/dvb/frontend.h> 27 28 #include "dvb_frontend.h" 29 #include "zl10039.h" 30 31 static int debug; 32 33 /* Max transfer size done by I2C transfer functions */ 34 #define MAX_XFER_SIZE 64 35 36 #define dprintk(args...) \ 37 do { \ 38 if (debug) \ 39 printk(KERN_DEBUG args); \ 40 } while (0) 41 42 enum zl10039_model_id { 43 ID_ZL10039 = 1 44 }; 45 46 struct zl10039_state { 47 struct i2c_adapter *i2c; 48 u8 i2c_addr; 49 u8 id; 50 }; 51 52 enum zl10039_reg_addr { 53 PLL0 = 0, 54 PLL1, 55 PLL2, 56 PLL3, 57 RFFE, 58 BASE0, 59 BASE1, 60 BASE2, 61 LO0, 62 LO1, 63 LO2, 64 LO3, 65 LO4, 66 LO5, 67 LO6, 68 GENERAL 69 }; 70 71 static int zl10039_read(const struct zl10039_state *state, 72 const enum zl10039_reg_addr reg, u8 *buf, 73 const size_t count) 74 { 75 u8 regbuf[] = { reg }; 76 struct i2c_msg msg[] = { 77 {/* Write register address */ 78 .addr = state->i2c_addr, 79 .flags = 0, 80 .buf = regbuf, 81 .len = 1, 82 }, {/* Read count bytes */ 83 .addr = state->i2c_addr, 84 .flags = I2C_M_RD, 85 .buf = buf, 86 .len = count, 87 }, 88 }; 89 90 dprintk("%s\n", __func__); 91 92 if (i2c_transfer(state->i2c, msg, 2) != 2) { 93 dprintk("%s: i2c read error\n", __func__); 94 return -EREMOTEIO; 95 } 96 97 return 0; /* Success */ 98 } 99 100 static int zl10039_write(struct zl10039_state *state, 101 const enum zl10039_reg_addr reg, const u8 *src, 102 const size_t count) 103 { 104 u8 buf[MAX_XFER_SIZE]; 105 struct i2c_msg msg = { 106 .addr = state->i2c_addr, 107 .flags = 0, 108 .buf = buf, 109 .len = count + 1, 110 }; 111 112 if (1 + count > sizeof(buf)) { 113 printk(KERN_WARNING 114 "%s: i2c wr reg=%04x: len=%zu is too big!\n", 115 KBUILD_MODNAME, reg, count); 116 return -EINVAL; 117 } 118 119 dprintk("%s\n", __func__); 120 /* Write register address and data in one go */ 121 buf[0] = reg; 122 memcpy(&buf[1], src, count); 123 if (i2c_transfer(state->i2c, &msg, 1) != 1) { 124 dprintk("%s: i2c write error\n", __func__); 125 return -EREMOTEIO; 126 } 127 128 return 0; /* Success */ 129 } 130 131 static inline int zl10039_readreg(struct zl10039_state *state, 132 const enum zl10039_reg_addr reg, u8 *val) 133 { 134 return zl10039_read(state, reg, val, 1); 135 } 136 137 static inline int zl10039_writereg(struct zl10039_state *state, 138 const enum zl10039_reg_addr reg, 139 const u8 val) 140 { 141 return zl10039_write(state, reg, &val, 1); 142 } 143 144 static int zl10039_init(struct dvb_frontend *fe) 145 { 146 struct zl10039_state *state = fe->tuner_priv; 147 int ret; 148 149 dprintk("%s\n", __func__); 150 if (fe->ops.i2c_gate_ctrl) 151 fe->ops.i2c_gate_ctrl(fe, 1); 152 /* Reset logic */ 153 ret = zl10039_writereg(state, GENERAL, 0x40); 154 if (ret < 0) { 155 dprintk("Note: i2c write error normal when resetting the tuner\n"); 156 } 157 /* Wake up */ 158 ret = zl10039_writereg(state, GENERAL, 0x01); 159 if (ret < 0) { 160 dprintk("Tuner power up failed\n"); 161 return ret; 162 } 163 if (fe->ops.i2c_gate_ctrl) 164 fe->ops.i2c_gate_ctrl(fe, 0); 165 166 return 0; 167 } 168 169 static int zl10039_sleep(struct dvb_frontend *fe) 170 { 171 struct zl10039_state *state = fe->tuner_priv; 172 int ret; 173 174 dprintk("%s\n", __func__); 175 if (fe->ops.i2c_gate_ctrl) 176 fe->ops.i2c_gate_ctrl(fe, 1); 177 ret = zl10039_writereg(state, GENERAL, 0x80); 178 if (ret < 0) { 179 dprintk("Tuner sleep failed\n"); 180 return ret; 181 } 182 if (fe->ops.i2c_gate_ctrl) 183 fe->ops.i2c_gate_ctrl(fe, 0); 184 185 return 0; 186 } 187 188 static int zl10039_set_params(struct dvb_frontend *fe) 189 { 190 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 191 struct zl10039_state *state = fe->tuner_priv; 192 u8 buf[6]; 193 u8 bf; 194 u32 fbw; 195 u32 div; 196 int ret; 197 198 dprintk("%s\n", __func__); 199 dprintk("Set frequency = %d, symbol rate = %d\n", 200 c->frequency, c->symbol_rate); 201 202 /* Assumed 10.111 MHz crystal oscillator */ 203 /* Cancelled num/den 80 to prevent overflow */ 204 div = (c->frequency * 1000) / 126387; 205 fbw = (c->symbol_rate * 27) / 32000; 206 /* Cancelled num/den 10 to prevent overflow */ 207 bf = ((fbw * 5088) / 1011100) - 1; 208 209 /*PLL divider*/ 210 buf[0] = (div >> 8) & 0x7f; 211 buf[1] = (div >> 0) & 0xff; 212 /*Reference divider*/ 213 /* Select reference ratio of 80 */ 214 buf[2] = 0x1D; 215 /*PLL test modes*/ 216 buf[3] = 0x40; 217 /*RF Control register*/ 218 buf[4] = 0x6E; /* Bypass enable */ 219 /*Baseband filter cutoff */ 220 buf[5] = bf; 221 222 /* Open i2c gate */ 223 if (fe->ops.i2c_gate_ctrl) 224 fe->ops.i2c_gate_ctrl(fe, 1); 225 /* BR = 10, Enable filter adjustment */ 226 ret = zl10039_writereg(state, BASE1, 0x0A); 227 if (ret < 0) 228 goto error; 229 /* Write new config values */ 230 ret = zl10039_write(state, PLL0, buf, sizeof(buf)); 231 if (ret < 0) 232 goto error; 233 /* BR = 10, Disable filter adjustment */ 234 ret = zl10039_writereg(state, BASE1, 0x6A); 235 if (ret < 0) 236 goto error; 237 238 /* Close i2c gate */ 239 if (fe->ops.i2c_gate_ctrl) 240 fe->ops.i2c_gate_ctrl(fe, 0); 241 return 0; 242 error: 243 dprintk("Error setting tuner\n"); 244 return ret; 245 } 246 247 static int zl10039_release(struct dvb_frontend *fe) 248 { 249 struct zl10039_state *state = fe->tuner_priv; 250 251 dprintk("%s\n", __func__); 252 kfree(state); 253 fe->tuner_priv = NULL; 254 return 0; 255 } 256 257 static const struct dvb_tuner_ops zl10039_ops = { 258 .release = zl10039_release, 259 .init = zl10039_init, 260 .sleep = zl10039_sleep, 261 .set_params = zl10039_set_params, 262 }; 263 264 struct dvb_frontend *zl10039_attach(struct dvb_frontend *fe, 265 u8 i2c_addr, struct i2c_adapter *i2c) 266 { 267 struct zl10039_state *state = NULL; 268 269 dprintk("%s\n", __func__); 270 state = kmalloc(sizeof(struct zl10039_state), GFP_KERNEL); 271 if (state == NULL) 272 goto error; 273 274 state->i2c = i2c; 275 state->i2c_addr = i2c_addr; 276 277 /* Open i2c gate */ 278 if (fe->ops.i2c_gate_ctrl) 279 fe->ops.i2c_gate_ctrl(fe, 1); 280 /* check if this is a valid tuner */ 281 if (zl10039_readreg(state, GENERAL, &state->id) < 0) { 282 /* Close i2c gate */ 283 if (fe->ops.i2c_gate_ctrl) 284 fe->ops.i2c_gate_ctrl(fe, 0); 285 goto error; 286 } 287 /* Close i2c gate */ 288 if (fe->ops.i2c_gate_ctrl) 289 fe->ops.i2c_gate_ctrl(fe, 0); 290 291 state->id = state->id & 0x0f; 292 switch (state->id) { 293 case ID_ZL10039: 294 strcpy(fe->ops.tuner_ops.info.name, 295 "Zarlink ZL10039 DVB-S tuner"); 296 break; 297 default: 298 dprintk("Chip ID=%x does not match a known type\n", state->id); 299 goto error; 300 } 301 302 memcpy(&fe->ops.tuner_ops, &zl10039_ops, sizeof(struct dvb_tuner_ops)); 303 fe->tuner_priv = state; 304 dprintk("Tuner attached @ i2c address 0x%02x\n", i2c_addr); 305 return fe; 306 error: 307 kfree(state); 308 return NULL; 309 } 310 EXPORT_SYMBOL(zl10039_attach); 311 312 module_param(debug, int, 0644); 313 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); 314 MODULE_DESCRIPTION("Zarlink ZL10039 DVB-S tuner driver"); 315 MODULE_AUTHOR("Jan D. Louw <jd.louw@mweb.co.za>"); 316 MODULE_LICENSE("GPL"); 317