1 /* 2 Driver for ST STB6000 DVBS Silicon tuner 3 4 Copyright (C) 2008 Igor M. Liplianin (liplianin@me.by) 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 23 #include <linux/slab.h> 24 #include <linux/module.h> 25 #include <linux/dvb/frontend.h> 26 #include <asm/types.h> 27 28 #include "stb6000.h" 29 30 static int debug; 31 #define dprintk(args...) \ 32 do { \ 33 if (debug) \ 34 printk(KERN_DEBUG "stb6000: " args); \ 35 } while (0) 36 37 struct stb6000_priv { 38 /* i2c details */ 39 int i2c_address; 40 struct i2c_adapter *i2c; 41 u32 frequency; 42 }; 43 44 static int stb6000_release(struct dvb_frontend *fe) 45 { 46 kfree(fe->tuner_priv); 47 fe->tuner_priv = NULL; 48 return 0; 49 } 50 51 static int stb6000_sleep(struct dvb_frontend *fe) 52 { 53 struct stb6000_priv *priv = fe->tuner_priv; 54 int ret; 55 u8 buf[] = { 10, 0 }; 56 struct i2c_msg msg = { 57 .addr = priv->i2c_address, 58 .flags = 0, 59 .buf = buf, 60 .len = 2 61 }; 62 63 dprintk("%s:\n", __func__); 64 65 if (fe->ops.i2c_gate_ctrl) 66 fe->ops.i2c_gate_ctrl(fe, 1); 67 68 ret = i2c_transfer(priv->i2c, &msg, 1); 69 if (ret != 1) 70 dprintk("%s: i2c error\n", __func__); 71 72 if (fe->ops.i2c_gate_ctrl) 73 fe->ops.i2c_gate_ctrl(fe, 0); 74 75 return (ret == 1) ? 0 : ret; 76 } 77 78 static int stb6000_set_params(struct dvb_frontend *fe) 79 { 80 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 81 struct stb6000_priv *priv = fe->tuner_priv; 82 unsigned int n, m; 83 int ret; 84 u32 freq_mhz; 85 int bandwidth; 86 u8 buf[12]; 87 struct i2c_msg msg = { 88 .addr = priv->i2c_address, 89 .flags = 0, 90 .buf = buf, 91 .len = 12 92 }; 93 94 dprintk("%s:\n", __func__); 95 96 freq_mhz = p->frequency / 1000; 97 bandwidth = p->symbol_rate / 1000000; 98 99 if (bandwidth > 31) 100 bandwidth = 31; 101 102 if ((freq_mhz > 949) && (freq_mhz < 2151)) { 103 buf[0] = 0x01; 104 buf[1] = 0xac; 105 if (freq_mhz < 1950) 106 buf[1] = 0xaa; 107 if (freq_mhz < 1800) 108 buf[1] = 0xa8; 109 if (freq_mhz < 1650) 110 buf[1] = 0xa6; 111 if (freq_mhz < 1530) 112 buf[1] = 0xa5; 113 if (freq_mhz < 1470) 114 buf[1] = 0xa4; 115 if (freq_mhz < 1370) 116 buf[1] = 0xa2; 117 if (freq_mhz < 1300) 118 buf[1] = 0xa1; 119 if (freq_mhz < 1200) 120 buf[1] = 0xa0; 121 if (freq_mhz < 1075) 122 buf[1] = 0xbc; 123 if (freq_mhz < 1000) 124 buf[1] = 0xba; 125 if (freq_mhz < 1075) { 126 n = freq_mhz / 8; /* vco=lo*4 */ 127 m = 2; 128 } else { 129 n = freq_mhz / 16; /* vco=lo*2 */ 130 m = 1; 131 } 132 buf[2] = n >> 1; 133 buf[3] = (unsigned char)(((n & 1) << 7) | 134 (m * freq_mhz - n * 16) | 0x60); 135 buf[4] = 0x04; 136 buf[5] = 0x0e; 137 138 buf[6] = (unsigned char)(bandwidth); 139 140 buf[7] = 0xd8; 141 buf[8] = 0xd0; 142 buf[9] = 0x50; 143 buf[10] = 0xeb; 144 buf[11] = 0x4f; 145 146 if (fe->ops.i2c_gate_ctrl) 147 fe->ops.i2c_gate_ctrl(fe, 1); 148 149 ret = i2c_transfer(priv->i2c, &msg, 1); 150 if (ret != 1) 151 dprintk("%s: i2c error\n", __func__); 152 153 udelay(10); 154 if (fe->ops.i2c_gate_ctrl) 155 fe->ops.i2c_gate_ctrl(fe, 0); 156 157 buf[0] = 0x07; 158 buf[1] = 0xdf; 159 buf[2] = 0xd0; 160 buf[3] = 0x50; 161 buf[4] = 0xfb; 162 msg.len = 5; 163 164 if (fe->ops.i2c_gate_ctrl) 165 fe->ops.i2c_gate_ctrl(fe, 1); 166 167 ret = i2c_transfer(priv->i2c, &msg, 1); 168 if (ret != 1) 169 dprintk("%s: i2c error\n", __func__); 170 171 udelay(10); 172 if (fe->ops.i2c_gate_ctrl) 173 fe->ops.i2c_gate_ctrl(fe, 0); 174 175 priv->frequency = freq_mhz * 1000; 176 177 return (ret == 1) ? 0 : ret; 178 } 179 return -1; 180 } 181 182 static int stb6000_get_frequency(struct dvb_frontend *fe, u32 *frequency) 183 { 184 struct stb6000_priv *priv = fe->tuner_priv; 185 *frequency = priv->frequency; 186 return 0; 187 } 188 189 static struct dvb_tuner_ops stb6000_tuner_ops = { 190 .info = { 191 .name = "ST STB6000", 192 .frequency_min = 950000, 193 .frequency_max = 2150000 194 }, 195 .release = stb6000_release, 196 .sleep = stb6000_sleep, 197 .set_params = stb6000_set_params, 198 .get_frequency = stb6000_get_frequency, 199 }; 200 201 struct dvb_frontend *stb6000_attach(struct dvb_frontend *fe, int addr, 202 struct i2c_adapter *i2c) 203 { 204 struct stb6000_priv *priv = NULL; 205 u8 b0[] = { 0 }; 206 u8 b1[] = { 0, 0 }; 207 struct i2c_msg msg[2] = { 208 { 209 .addr = addr, 210 .flags = 0, 211 .buf = b0, 212 .len = 0 213 }, { 214 .addr = addr, 215 .flags = I2C_M_RD, 216 .buf = b1, 217 .len = 2 218 } 219 }; 220 int ret; 221 222 dprintk("%s:\n", __func__); 223 224 if (fe->ops.i2c_gate_ctrl) 225 fe->ops.i2c_gate_ctrl(fe, 1); 226 227 /* is some i2c device here ? */ 228 ret = i2c_transfer(i2c, msg, 2); 229 if (fe->ops.i2c_gate_ctrl) 230 fe->ops.i2c_gate_ctrl(fe, 0); 231 232 if (ret != 2) 233 return NULL; 234 235 priv = kzalloc(sizeof(struct stb6000_priv), GFP_KERNEL); 236 if (priv == NULL) 237 return NULL; 238 239 priv->i2c_address = addr; 240 priv->i2c = i2c; 241 242 memcpy(&fe->ops.tuner_ops, &stb6000_tuner_ops, 243 sizeof(struct dvb_tuner_ops)); 244 245 fe->tuner_priv = priv; 246 247 return fe; 248 } 249 EXPORT_SYMBOL(stb6000_attach); 250 251 module_param(debug, int, 0644); 252 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); 253 254 MODULE_DESCRIPTION("DVB STB6000 driver"); 255 MODULE_AUTHOR("Igor M. Liplianin <liplianin@me.by>"); 256 MODULE_LICENSE("GPL"); 257