drivers/media/dvb-frontends/zl10039.c

   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 void 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 }
 255
 256 static const struct dvb_tuner_ops zl10039_ops = {
 257         .release = zl10039_release,
 258         .init = zl10039_init,
 259         .sleep = zl10039_sleep,
 260         .set_params = zl10039_set_params,
 261 };
 262
 263 struct dvb_frontend *zl10039_attach(struct dvb_frontend *fe,
 264                 u8 i2c_addr, struct i2c_adapter *i2c)
 265 {
 266         struct zl10039_state *state = NULL;
 267
 268         dprintk("%s\n", __func__);
 269         state = kmalloc(sizeof(struct zl10039_state), GFP_KERNEL);
 270         if (state == NULL)
 271                 goto error;
 272
 273         state->i2c = i2c;
 274         state->i2c_addr = i2c_addr;
 275
 276         /* Open i2c gate */
 277         if (fe->ops.i2c_gate_ctrl)
 278                 fe->ops.i2c_gate_ctrl(fe, 1);
 279         /* check if this is a valid tuner */
 280         if (zl10039_readreg(state, GENERAL, &state->id) < 0) {
 281                 /* Close i2c gate */
 282                 if (fe->ops.i2c_gate_ctrl)
 283                         fe->ops.i2c_gate_ctrl(fe, 0);
 284                 goto error;
 285         }
 286         /* Close i2c gate */
 287         if (fe->ops.i2c_gate_ctrl)
 288                 fe->ops.i2c_gate_ctrl(fe, 0);
 289
 290         state->id = state->id & 0x0f;
 291         switch (state->id) {
 292         case ID_ZL10039:
 293                 strcpy(fe->ops.tuner_ops.info.name,
 294                         "Zarlink ZL10039 DVB-S tuner");
 295                 break;
 296         default:
 297                 dprintk("Chip ID=%x does not match a known type\n", state->id);
 298                 goto error;
 299         }
 300
 301         memcpy(&fe->ops.tuner_ops, &zl10039_ops, sizeof(struct dvb_tuner_ops));
 302         fe->tuner_priv = state;
 303         dprintk("Tuner attached @ i2c address 0x%02x\n", i2c_addr);
 304         return fe;
 305 error:
 306         kfree(state);
 307         return NULL;
 308 }
 309 EXPORT_SYMBOL(zl10039_attach);
 310
 311 module_param(debug, int, 0644);
 312 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 313 MODULE_DESCRIPTION("Zarlink ZL10039 DVB-S tuner driver");
 314 MODULE_AUTHOR("Jan D. Louw <jd.louw@mweb.co.za>");
 315 MODULE_LICENSE("GPL");