Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 1c12bf8de7e1557afeedd55d9bcec6b6a6d7b5d1

Authored by Mauro Carvalho Chehab
1 parent 41f55d5755
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

[media] tda10071: fix a warning introduced by changeset 41f55d5755 

The two new tests don't set the returned value.

Cc: Michael Krufky <mkrufky@linuxtv.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Showing 1 changed file with 2 additions and 0 deletions Inline Diff

drivers/media/dvb-frontends/tda10071.c
Diff comments   View file @ 1c12bf8
1 /* 1 /*
2 * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner driver 2 * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner driver
3 * 3 *
4 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi> 4 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
5 * 5 *
6 * This program is free software; you can redistribute it and/or modify 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 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 8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version. 9 * (at your option) any later version.
10 * 10 *
11 * This program is distributed in the hope that it will be useful, 11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details. 14 * GNU General Public License for more details.
15 * 15 *
16 * You should have received a copy of the GNU General Public License along 16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc., 17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */ 19 */
20 20
21 #include "tda10071_priv.h" 21 #include "tda10071_priv.h"
22 22
23 static struct dvb_frontend_ops tda10071_ops; 23 static struct dvb_frontend_ops tda10071_ops;
24 24
25 /* write multiple registers */ 25 /* write multiple registers */
26 static int tda10071_wr_regs(struct tda10071_priv *priv, u8 reg, u8 *val, 26 static int tda10071_wr_regs(struct tda10071_priv *priv, u8 reg, u8 *val,
27 int len) 27 int len)
28 { 28 {
29 int ret; 29 int ret;
30 u8 buf[len+1]; 30 u8 buf[len+1];
31 struct i2c_msg msg[1] = { 31 struct i2c_msg msg[1] = {
32 { 32 {
33 .addr = priv->cfg.demod_i2c_addr, 33 .addr = priv->cfg.demod_i2c_addr,
34 .flags = 0, 34 .flags = 0,
35 .len = sizeof(buf), 35 .len = sizeof(buf),
36 .buf = buf, 36 .buf = buf,
37 } 37 }
38 }; 38 };
39 39
40 buf[0] = reg; 40 buf[0] = reg;
41 memcpy(&buf[1], val, len); 41 memcpy(&buf[1], val, len);
42 42
43 ret = i2c_transfer(priv->i2c, msg, 1); 43 ret = i2c_transfer(priv->i2c, msg, 1);
44 if (ret == 1) { 44 if (ret == 1) {
45 ret = 0; 45 ret = 0;
46 } else { 46 } else {
47 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \ 47 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
48 "len=%d\n", KBUILD_MODNAME, ret, reg, len); 48 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
49 ret = -EREMOTEIO; 49 ret = -EREMOTEIO;
50 } 50 }
51 return ret; 51 return ret;
52 } 52 }
53 53
54 /* read multiple registers */ 54 /* read multiple registers */
55 static int tda10071_rd_regs(struct tda10071_priv *priv, u8 reg, u8 *val, 55 static int tda10071_rd_regs(struct tda10071_priv *priv, u8 reg, u8 *val,
56 int len) 56 int len)
57 { 57 {
58 int ret; 58 int ret;
59 u8 buf[len]; 59 u8 buf[len];
60 struct i2c_msg msg[2] = { 60 struct i2c_msg msg[2] = {
61 { 61 {
62 .addr = priv->cfg.demod_i2c_addr, 62 .addr = priv->cfg.demod_i2c_addr,
63 .flags = 0, 63 .flags = 0,
64 .len = 1, 64 .len = 1,
65 .buf = &reg, 65 .buf = &reg,
66 }, { 66 }, {
67 .addr = priv->cfg.demod_i2c_addr, 67 .addr = priv->cfg.demod_i2c_addr,
68 .flags = I2C_M_RD, 68 .flags = I2C_M_RD,
69 .len = sizeof(buf), 69 .len = sizeof(buf),
70 .buf = buf, 70 .buf = buf,
71 } 71 }
72 }; 72 };
73 73
74 ret = i2c_transfer(priv->i2c, msg, 2); 74 ret = i2c_transfer(priv->i2c, msg, 2);
75 if (ret == 2) { 75 if (ret == 2) {
76 memcpy(val, buf, len); 76 memcpy(val, buf, len);
77 ret = 0; 77 ret = 0;
78 } else { 78 } else {
79 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \ 79 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \
80 "len=%d\n", KBUILD_MODNAME, ret, reg, len); 80 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
81 ret = -EREMOTEIO; 81 ret = -EREMOTEIO;
82 } 82 }
83 return ret; 83 return ret;
84 } 84 }
85 85
86 /* write single register */ 86 /* write single register */
87 static int tda10071_wr_reg(struct tda10071_priv *priv, u8 reg, u8 val) 87 static int tda10071_wr_reg(struct tda10071_priv *priv, u8 reg, u8 val)
88 { 88 {
89 return tda10071_wr_regs(priv, reg, &val, 1); 89 return tda10071_wr_regs(priv, reg, &val, 1);
90 } 90 }
91 91
92 /* read single register */ 92 /* read single register */
93 static int tda10071_rd_reg(struct tda10071_priv *priv, u8 reg, u8 *val) 93 static int tda10071_rd_reg(struct tda10071_priv *priv, u8 reg, u8 *val)
94 { 94 {
95 return tda10071_rd_regs(priv, reg, val, 1); 95 return tda10071_rd_regs(priv, reg, val, 1);
96 } 96 }
97 97
98 /* write single register with mask */ 98 /* write single register with mask */
99 static int tda10071_wr_reg_mask(struct tda10071_priv *priv, 99 static int tda10071_wr_reg_mask(struct tda10071_priv *priv,
100 u8 reg, u8 val, u8 mask) 100 u8 reg, u8 val, u8 mask)
101 { 101 {
102 int ret; 102 int ret;
103 u8 tmp; 103 u8 tmp;
104 104
105 /* no need for read if whole reg is written */ 105 /* no need for read if whole reg is written */
106 if (mask != 0xff) { 106 if (mask != 0xff) {
107 ret = tda10071_rd_regs(priv, reg, &tmp, 1); 107 ret = tda10071_rd_regs(priv, reg, &tmp, 1);
108 if (ret) 108 if (ret)
109 return ret; 109 return ret;
110 110
111 val &= mask; 111 val &= mask;
112 tmp &= ~mask; 112 tmp &= ~mask;
113 val |= tmp; 113 val |= tmp;
114 } 114 }
115 115
116 return tda10071_wr_regs(priv, reg, &val, 1); 116 return tda10071_wr_regs(priv, reg, &val, 1);
117 } 117 }
118 118
119 /* read single register with mask */ 119 /* read single register with mask */
120 static int tda10071_rd_reg_mask(struct tda10071_priv *priv, 120 static int tda10071_rd_reg_mask(struct tda10071_priv *priv,
121 u8 reg, u8 *val, u8 mask) 121 u8 reg, u8 *val, u8 mask)
122 { 122 {
123 int ret, i; 123 int ret, i;
124 u8 tmp; 124 u8 tmp;
125 125
126 ret = tda10071_rd_regs(priv, reg, &tmp, 1); 126 ret = tda10071_rd_regs(priv, reg, &tmp, 1);
127 if (ret) 127 if (ret)
128 return ret; 128 return ret;
129 129
130 tmp &= mask; 130 tmp &= mask;
131 131
132 /* find position of the first bit */ 132 /* find position of the first bit */
133 for (i = 0; i < 8; i++) { 133 for (i = 0; i < 8; i++) {
134 if ((mask >> i) & 0x01) 134 if ((mask >> i) & 0x01)
135 break; 135 break;
136 } 136 }
137 *val = tmp >> i; 137 *val = tmp >> i;
138 138
139 return 0; 139 return 0;
140 } 140 }
141 141
142 /* execute firmware command */ 142 /* execute firmware command */
143 static int tda10071_cmd_execute(struct tda10071_priv *priv, 143 static int tda10071_cmd_execute(struct tda10071_priv *priv,
144 struct tda10071_cmd *cmd) 144 struct tda10071_cmd *cmd)
145 { 145 {
146 int ret, i; 146 int ret, i;
147 u8 tmp; 147 u8 tmp;
148 148
149 if (!priv->warm) { 149 if (!priv->warm) {
150 ret = -EFAULT; 150 ret = -EFAULT;
151 goto error; 151 goto error;
152 } 152 }
153 153
154 /* write cmd and args for firmware */ 154 /* write cmd and args for firmware */
155 ret = tda10071_wr_regs(priv, 0x00, cmd->args, cmd->len); 155 ret = tda10071_wr_regs(priv, 0x00, cmd->args, cmd->len);
156 if (ret) 156 if (ret)
157 goto error; 157 goto error;
158 158
159 /* start cmd execution */ 159 /* start cmd execution */
160 ret = tda10071_wr_reg(priv, 0x1f, 1); 160 ret = tda10071_wr_reg(priv, 0x1f, 1);
161 if (ret) 161 if (ret)
162 goto error; 162 goto error;
163 163
164 /* wait cmd execution terminate */ 164 /* wait cmd execution terminate */
165 for (i = 1000, tmp = 1; i && tmp; i--) { 165 for (i = 1000, tmp = 1; i && tmp; i--) {
166 ret = tda10071_rd_reg(priv, 0x1f, &tmp); 166 ret = tda10071_rd_reg(priv, 0x1f, &tmp);
167 if (ret) 167 if (ret)
168 goto error; 168 goto error;
169 169
170 usleep_range(200, 5000); 170 usleep_range(200, 5000);
171 } 171 }
172 172
173 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i); 173 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
174 174
175 if (i == 0) { 175 if (i == 0) {
176 ret = -ETIMEDOUT; 176 ret = -ETIMEDOUT;
177 goto error; 177 goto error;
178 } 178 }
179 179
180 return ret; 180 return ret;
181 error: 181 error:
182 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 182 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
183 return ret; 183 return ret;
184 } 184 }
185 185
186 static int tda10071_set_tone(struct dvb_frontend *fe, 186 static int tda10071_set_tone(struct dvb_frontend *fe,
187 fe_sec_tone_mode_t fe_sec_tone_mode) 187 fe_sec_tone_mode_t fe_sec_tone_mode)
188 { 188 {
189 struct tda10071_priv *priv = fe->demodulator_priv; 189 struct tda10071_priv *priv = fe->demodulator_priv;
190 struct tda10071_cmd cmd; 190 struct tda10071_cmd cmd;
191 int ret; 191 int ret;
192 u8 tone; 192 u8 tone;
193 193
194 if (!priv->warm) { 194 if (!priv->warm) {
195 ret = -EFAULT; 195 ret = -EFAULT;
196 goto error; 196 goto error;
197 } 197 }
198 198
199 dev_dbg(&priv->i2c->dev, "%s: tone_mode=%d\n", __func__, 199 dev_dbg(&priv->i2c->dev, "%s: tone_mode=%d\n", __func__,
200 fe_sec_tone_mode); 200 fe_sec_tone_mode);
201 201
202 switch (fe_sec_tone_mode) { 202 switch (fe_sec_tone_mode) {
203 case SEC_TONE_ON: 203 case SEC_TONE_ON:
204 tone = 1; 204 tone = 1;
205 break; 205 break;
206 case SEC_TONE_OFF: 206 case SEC_TONE_OFF:
207 tone = 0; 207 tone = 0;
208 break; 208 break;
209 default: 209 default:
210 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_tone_mode\n", 210 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_tone_mode\n",
211 __func__); 211 __func__);
212 ret = -EINVAL; 212 ret = -EINVAL;
213 goto error; 213 goto error;
214 } 214 }
215 215
216 cmd.args[0] = CMD_LNB_PCB_CONFIG; 216 cmd.args[0] = CMD_LNB_PCB_CONFIG;
217 cmd.args[1] = 0; 217 cmd.args[1] = 0;
218 cmd.args[2] = 0x00; 218 cmd.args[2] = 0x00;
219 cmd.args[3] = 0x00; 219 cmd.args[3] = 0x00;
220 cmd.args[4] = tone; 220 cmd.args[4] = tone;
221 cmd.len = 5; 221 cmd.len = 5;
222 ret = tda10071_cmd_execute(priv, &cmd); 222 ret = tda10071_cmd_execute(priv, &cmd);
223 if (ret) 223 if (ret)
224 goto error; 224 goto error;
225 225
226 return ret; 226 return ret;
227 error: 227 error:
228 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 228 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
229 return ret; 229 return ret;
230 } 230 }
231 231
232 static int tda10071_set_voltage(struct dvb_frontend *fe, 232 static int tda10071_set_voltage(struct dvb_frontend *fe,
233 fe_sec_voltage_t fe_sec_voltage) 233 fe_sec_voltage_t fe_sec_voltage)
234 { 234 {
235 struct tda10071_priv *priv = fe->demodulator_priv; 235 struct tda10071_priv *priv = fe->demodulator_priv;
236 struct tda10071_cmd cmd; 236 struct tda10071_cmd cmd;
237 int ret; 237 int ret;
238 u8 voltage; 238 u8 voltage;
239 239
240 if (!priv->warm) { 240 if (!priv->warm) {
241 ret = -EFAULT; 241 ret = -EFAULT;
242 goto error; 242 goto error;
243 } 243 }
244 244
245 dev_dbg(&priv->i2c->dev, "%s: voltage=%d\n", __func__, fe_sec_voltage); 245 dev_dbg(&priv->i2c->dev, "%s: voltage=%d\n", __func__, fe_sec_voltage);
246 246
247 switch (fe_sec_voltage) { 247 switch (fe_sec_voltage) {
248 case SEC_VOLTAGE_13: 248 case SEC_VOLTAGE_13:
249 voltage = 0; 249 voltage = 0;
250 break; 250 break;
251 case SEC_VOLTAGE_18: 251 case SEC_VOLTAGE_18:
252 voltage = 1; 252 voltage = 1;
253 break; 253 break;
254 case SEC_VOLTAGE_OFF: 254 case SEC_VOLTAGE_OFF:
255 voltage = 0; 255 voltage = 0;
256 break; 256 break;
257 default: 257 default:
258 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_voltage\n", 258 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_voltage\n",
259 __func__); 259 __func__);
260 ret = -EINVAL; 260 ret = -EINVAL;
261 goto error; 261 goto error;
262 } 262 }
263 263
264 cmd.args[0] = CMD_LNB_SET_DC_LEVEL; 264 cmd.args[0] = CMD_LNB_SET_DC_LEVEL;
265 cmd.args[1] = 0; 265 cmd.args[1] = 0;
266 cmd.args[2] = voltage; 266 cmd.args[2] = voltage;
267 cmd.len = 3; 267 cmd.len = 3;
268 ret = tda10071_cmd_execute(priv, &cmd); 268 ret = tda10071_cmd_execute(priv, &cmd);
269 if (ret) 269 if (ret)
270 goto error; 270 goto error;
271 271
272 return ret; 272 return ret;
273 error: 273 error:
274 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 274 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
275 return ret; 275 return ret;
276 } 276 }
277 277
278 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe, 278 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe,
279 struct dvb_diseqc_master_cmd *diseqc_cmd) 279 struct dvb_diseqc_master_cmd *diseqc_cmd)
280 { 280 {
281 struct tda10071_priv *priv = fe->demodulator_priv; 281 struct tda10071_priv *priv = fe->demodulator_priv;
282 struct tda10071_cmd cmd; 282 struct tda10071_cmd cmd;
283 int ret, i; 283 int ret, i;
284 u8 tmp; 284 u8 tmp;
285 285
286 if (!priv->warm) { 286 if (!priv->warm) {
287 ret = -EFAULT; 287 ret = -EFAULT;
288 goto error; 288 goto error;
289 } 289 }
290 290
291 dev_dbg(&priv->i2c->dev, "%s: msg_len=%d\n", __func__, 291 dev_dbg(&priv->i2c->dev, "%s: msg_len=%d\n", __func__,
292 diseqc_cmd->msg_len); 292 diseqc_cmd->msg_len);
293 293
294 if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) { 294 if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) {
295 ret = -EINVAL; 295 ret = -EINVAL;
296 goto error; 296 goto error;
297 } 297 }
298 298
299 /* wait LNB TX */ 299 /* wait LNB TX */
300 for (i = 500, tmp = 0; i && !tmp; i--) { 300 for (i = 500, tmp = 0; i && !tmp; i--) {
301 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01); 301 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01);
302 if (ret) 302 if (ret)
303 goto error; 303 goto error;
304 304
305 usleep_range(10000, 20000); 305 usleep_range(10000, 20000);
306 } 306 }
307 307
308 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i); 308 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
309 309
310 if (i == 0) { 310 if (i == 0) {
311 ret = -ETIMEDOUT; 311 ret = -ETIMEDOUT;
312 goto error; 312 goto error;
313 } 313 }
314 314
315 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01); 315 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01);
316 if (ret) 316 if (ret)
317 goto error; 317 goto error;
318 318
319 cmd.args[0] = CMD_LNB_SEND_DISEQC; 319 cmd.args[0] = CMD_LNB_SEND_DISEQC;
320 cmd.args[1] = 0; 320 cmd.args[1] = 0;
321 cmd.args[2] = 0; 321 cmd.args[2] = 0;
322 cmd.args[3] = 0; 322 cmd.args[3] = 0;
323 cmd.args[4] = 2; 323 cmd.args[4] = 2;
324 cmd.args[5] = 0; 324 cmd.args[5] = 0;
325 cmd.args[6] = diseqc_cmd->msg_len; 325 cmd.args[6] = diseqc_cmd->msg_len;
326 memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len); 326 memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len);
327 cmd.len = 7 + diseqc_cmd->msg_len; 327 cmd.len = 7 + diseqc_cmd->msg_len;
328 ret = tda10071_cmd_execute(priv, &cmd); 328 ret = tda10071_cmd_execute(priv, &cmd);
329 if (ret) 329 if (ret)
330 goto error; 330 goto error;
331 331
332 return ret; 332 return ret;
333 error: 333 error:
334 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 334 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
335 return ret; 335 return ret;
336 } 336 }
337 337
338 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe, 338 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe,
339 struct dvb_diseqc_slave_reply *reply) 339 struct dvb_diseqc_slave_reply *reply)
340 { 340 {
341 struct tda10071_priv *priv = fe->demodulator_priv; 341 struct tda10071_priv *priv = fe->demodulator_priv;
342 struct tda10071_cmd cmd; 342 struct tda10071_cmd cmd;
343 int ret, i; 343 int ret, i;
344 u8 tmp; 344 u8 tmp;
345 345
346 if (!priv->warm) { 346 if (!priv->warm) {
347 ret = -EFAULT; 347 ret = -EFAULT;
348 goto error; 348 goto error;
349 } 349 }
350 350
351 dev_dbg(&priv->i2c->dev, "%s:\n", __func__); 351 dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
352 352
353 /* wait LNB RX */ 353 /* wait LNB RX */
354 for (i = 500, tmp = 0; i && !tmp; i--) { 354 for (i = 500, tmp = 0; i && !tmp; i--) {
355 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x02); 355 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x02);
356 if (ret) 356 if (ret)
357 goto error; 357 goto error;
358 358
359 usleep_range(10000, 20000); 359 usleep_range(10000, 20000);
360 } 360 }
361 361
362 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i); 362 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
363 363
364 if (i == 0) { 364 if (i == 0) {
365 ret = -ETIMEDOUT; 365 ret = -ETIMEDOUT;
366 goto error; 366 goto error;
367 } 367 }
368 368
369 /* reply len */ 369 /* reply len */
370 ret = tda10071_rd_reg(priv, 0x46, &tmp); 370 ret = tda10071_rd_reg(priv, 0x46, &tmp);
371 if (ret) 371 if (ret)
372 goto error; 372 goto error;
373 373
374 reply->msg_len = tmp & 0x1f; /* [4:0] */ 374 reply->msg_len = tmp & 0x1f; /* [4:0] */
375 if (reply->msg_len > sizeof(reply->msg)) 375 if (reply->msg_len > sizeof(reply->msg))
376 reply->msg_len = sizeof(reply->msg); /* truncate API max */ 376 reply->msg_len = sizeof(reply->msg); /* truncate API max */
377 377
378 /* read reply */ 378 /* read reply */
379 cmd.args[0] = CMD_LNB_UPDATE_REPLY; 379 cmd.args[0] = CMD_LNB_UPDATE_REPLY;
380 cmd.args[1] = 0; 380 cmd.args[1] = 0;
381 cmd.len = 2; 381 cmd.len = 2;
382 ret = tda10071_cmd_execute(priv, &cmd); 382 ret = tda10071_cmd_execute(priv, &cmd);
383 if (ret) 383 if (ret)
384 goto error; 384 goto error;
385 385
386 ret = tda10071_rd_regs(priv, cmd.len, reply->msg, reply->msg_len); 386 ret = tda10071_rd_regs(priv, cmd.len, reply->msg, reply->msg_len);
387 if (ret) 387 if (ret)
388 goto error; 388 goto error;
389 389
390 return ret; 390 return ret;
391 error: 391 error:
392 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 392 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
393 return ret; 393 return ret;
394 } 394 }
395 395
396 static int tda10071_diseqc_send_burst(struct dvb_frontend *fe, 396 static int tda10071_diseqc_send_burst(struct dvb_frontend *fe,
397 fe_sec_mini_cmd_t fe_sec_mini_cmd) 397 fe_sec_mini_cmd_t fe_sec_mini_cmd)
398 { 398 {
399 struct tda10071_priv *priv = fe->demodulator_priv; 399 struct tda10071_priv *priv = fe->demodulator_priv;
400 struct tda10071_cmd cmd; 400 struct tda10071_cmd cmd;
401 int ret, i; 401 int ret, i;
402 u8 tmp, burst; 402 u8 tmp, burst;
403 403
404 if (!priv->warm) { 404 if (!priv->warm) {
405 ret = -EFAULT; 405 ret = -EFAULT;
406 goto error; 406 goto error;
407 } 407 }
408 408
409 dev_dbg(&priv->i2c->dev, "%s: fe_sec_mini_cmd=%d\n", __func__, 409 dev_dbg(&priv->i2c->dev, "%s: fe_sec_mini_cmd=%d\n", __func__,
410 fe_sec_mini_cmd); 410 fe_sec_mini_cmd);
411 411
412 switch (fe_sec_mini_cmd) { 412 switch (fe_sec_mini_cmd) {
413 case SEC_MINI_A: 413 case SEC_MINI_A:
414 burst = 0; 414 burst = 0;
415 break; 415 break;
416 case SEC_MINI_B: 416 case SEC_MINI_B:
417 burst = 1; 417 burst = 1;
418 break; 418 break;
419 default: 419 default:
420 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_mini_cmd\n", 420 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_mini_cmd\n",
421 __func__); 421 __func__);
422 ret = -EINVAL; 422 ret = -EINVAL;
423 goto error; 423 goto error;
424 } 424 }
425 425
426 /* wait LNB TX */ 426 /* wait LNB TX */
427 for (i = 500, tmp = 0; i && !tmp; i--) { 427 for (i = 500, tmp = 0; i && !tmp; i--) {
428 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01); 428 ret = tda10071_rd_reg_mask(priv, 0x47, &tmp, 0x01);
429 if (ret) 429 if (ret)
430 goto error; 430 goto error;
431 431
432 usleep_range(10000, 20000); 432 usleep_range(10000, 20000);
433 } 433 }
434 434
435 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i); 435 dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
436 436
437 if (i == 0) { 437 if (i == 0) {
438 ret = -ETIMEDOUT; 438 ret = -ETIMEDOUT;
439 goto error; 439 goto error;
440 } 440 }
441 441
442 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01); 442 ret = tda10071_wr_reg_mask(priv, 0x47, 0x00, 0x01);
443 if (ret) 443 if (ret)
444 goto error; 444 goto error;
445 445
446 cmd.args[0] = CMD_LNB_SEND_TONEBURST; 446 cmd.args[0] = CMD_LNB_SEND_TONEBURST;
447 cmd.args[1] = 0; 447 cmd.args[1] = 0;
448 cmd.args[2] = burst; 448 cmd.args[2] = burst;
449 cmd.len = 3; 449 cmd.len = 3;
450 ret = tda10071_cmd_execute(priv, &cmd); 450 ret = tda10071_cmd_execute(priv, &cmd);
451 if (ret) 451 if (ret)
452 goto error; 452 goto error;
453 453
454 return ret; 454 return ret;
455 error: 455 error:
456 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 456 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
457 return ret; 457 return ret;
458 } 458 }
459 459
460 static int tda10071_read_status(struct dvb_frontend *fe, fe_status_t *status) 460 static int tda10071_read_status(struct dvb_frontend *fe, fe_status_t *status)
461 { 461 {
462 struct tda10071_priv *priv = fe->demodulator_priv; 462 struct tda10071_priv *priv = fe->demodulator_priv;
463 int ret; 463 int ret;
464 u8 tmp; 464 u8 tmp;
465 465
466 *status = 0; 466 *status = 0;
467 467
468 if (!priv->warm) { 468 if (!priv->warm) {
469 ret = 0; 469 ret = 0;
470 goto error; 470 goto error;
471 } 471 }
472 472
473 ret = tda10071_rd_reg(priv, 0x39, &tmp); 473 ret = tda10071_rd_reg(priv, 0x39, &tmp);
474 if (ret) 474 if (ret)
475 goto error; 475 goto error;
476 476
477 if (tmp & 0x01) /* tuner PLL */ 477 if (tmp & 0x01) /* tuner PLL */
478 *status |= FE_HAS_SIGNAL; 478 *status |= FE_HAS_SIGNAL;
479 if (tmp & 0x02) /* demod PLL */ 479 if (tmp & 0x02) /* demod PLL */
480 *status |= FE_HAS_CARRIER; 480 *status |= FE_HAS_CARRIER;
481 if (tmp & 0x04) /* viterbi or LDPC*/ 481 if (tmp & 0x04) /* viterbi or LDPC*/
482 *status |= FE_HAS_VITERBI; 482 *status |= FE_HAS_VITERBI;
483 if (tmp & 0x08) /* RS or BCH */ 483 if (tmp & 0x08) /* RS or BCH */
484 *status |= FE_HAS_SYNC | FE_HAS_LOCK; 484 *status |= FE_HAS_SYNC | FE_HAS_LOCK;
485 485
486 priv->fe_status = *status; 486 priv->fe_status = *status;
487 487
488 return ret; 488 return ret;
489 error: 489 error:
490 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 490 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
491 return ret; 491 return ret;
492 } 492 }
493 493
494 static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr) 494 static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr)
495 { 495 {
496 struct tda10071_priv *priv = fe->demodulator_priv; 496 struct tda10071_priv *priv = fe->demodulator_priv;
497 int ret; 497 int ret;
498 u8 buf[2]; 498 u8 buf[2];
499 499
500 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) { 500 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
501 *snr = 0; 501 *snr = 0;
502 ret = 0; 502 ret = 0;
503 goto error; 503 goto error;
504 } 504 }
505 505
506 ret = tda10071_rd_regs(priv, 0x3a, buf, 2); 506 ret = tda10071_rd_regs(priv, 0x3a, buf, 2);
507 if (ret) 507 if (ret)
508 goto error; 508 goto error;
509 509
510 /* Es/No dBx10 */ 510 /* Es/No dBx10 */
511 *snr = buf[0] << 8 | buf[1]; 511 *snr = buf[0] << 8 | buf[1];
512 512
513 return ret; 513 return ret;
514 error: 514 error:
515 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 515 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
516 return ret; 516 return ret;
517 } 517 }
518 518
519 static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 519 static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
520 { 520 {
521 struct tda10071_priv *priv = fe->demodulator_priv; 521 struct tda10071_priv *priv = fe->demodulator_priv;
522 struct tda10071_cmd cmd; 522 struct tda10071_cmd cmd;
523 int ret; 523 int ret;
524 u8 tmp; 524 u8 tmp;
525 525
526 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) { 526 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
527 *strength = 0; 527 *strength = 0;
528 ret = 0; 528 ret = 0;
529 goto error; 529 goto error;
530 } 530 }
531 531
532 cmd.args[0] = CMD_GET_AGCACC; 532 cmd.args[0] = CMD_GET_AGCACC;
533 cmd.args[1] = 0; 533 cmd.args[1] = 0;
534 cmd.len = 2; 534 cmd.len = 2;
535 ret = tda10071_cmd_execute(priv, &cmd); 535 ret = tda10071_cmd_execute(priv, &cmd);
536 if (ret) 536 if (ret)
537 goto error; 537 goto error;
538 538
539 /* input power estimate dBm */ 539 /* input power estimate dBm */
540 ret = tda10071_rd_reg(priv, 0x50, &tmp); 540 ret = tda10071_rd_reg(priv, 0x50, &tmp);
541 if (ret) 541 if (ret)
542 goto error; 542 goto error;
543 543
544 if (tmp < 181) 544 if (tmp < 181)
545 tmp = 181; /* -75 dBm */ 545 tmp = 181; /* -75 dBm */
546 else if (tmp > 236) 546 else if (tmp > 236)
547 tmp = 236; /* -20 dBm */ 547 tmp = 236; /* -20 dBm */
548 548
549 /* scale value to 0x0000-0xffff */ 549 /* scale value to 0x0000-0xffff */
550 *strength = (tmp-181) * 0xffff / (236-181); 550 *strength = (tmp-181) * 0xffff / (236-181);
551 551
552 return ret; 552 return ret;
553 error: 553 error:
554 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 554 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
555 return ret; 555 return ret;
556 } 556 }
557 557
558 static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber) 558 static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber)
559 { 559 {
560 struct tda10071_priv *priv = fe->demodulator_priv; 560 struct tda10071_priv *priv = fe->demodulator_priv;
561 struct tda10071_cmd cmd; 561 struct tda10071_cmd cmd;
562 int ret, i, len; 562 int ret, i, len;
563 u8 tmp, reg, buf[8]; 563 u8 tmp, reg, buf[8];
564 564
565 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) { 565 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
566 *ber = priv->ber = 0; 566 *ber = priv->ber = 0;
567 ret = 0; 567 ret = 0;
568 goto error; 568 goto error;
569 } 569 }
570 570
571 switch (priv->delivery_system) { 571 switch (priv->delivery_system) {
572 case SYS_DVBS: 572 case SYS_DVBS:
573 reg = 0x4c; 573 reg = 0x4c;
574 len = 8; 574 len = 8;
575 i = 1; 575 i = 1;
576 break; 576 break;
577 case SYS_DVBS2: 577 case SYS_DVBS2:
578 reg = 0x4d; 578 reg = 0x4d;
579 len = 4; 579 len = 4;
580 i = 0; 580 i = 0;
581 break; 581 break;
582 default: 582 default:
583 *ber = priv->ber = 0; 583 *ber = priv->ber = 0;
584 return 0; 584 return 0;
585 } 585 }
586 586
587 ret = tda10071_rd_reg(priv, reg, &tmp); 587 ret = tda10071_rd_reg(priv, reg, &tmp);
588 if (ret) 588 if (ret)
589 goto error; 589 goto error;
590 590
591 if (priv->meas_count[i] == tmp) { 591 if (priv->meas_count[i] == tmp) {
592 dev_dbg(&priv->i2c->dev, "%s: meas not ready=%02x\n", __func__, 592 dev_dbg(&priv->i2c->dev, "%s: meas not ready=%02x\n", __func__,
593 tmp); 593 tmp);
594 *ber = priv->ber; 594 *ber = priv->ber;
595 return 0; 595 return 0;
596 } else { 596 } else {
597 priv->meas_count[i] = tmp; 597 priv->meas_count[i] = tmp;
598 } 598 }
599 599
600 cmd.args[0] = CMD_BER_UPDATE_COUNTERS; 600 cmd.args[0] = CMD_BER_UPDATE_COUNTERS;
601 cmd.args[1] = 0; 601 cmd.args[1] = 0;
602 cmd.args[2] = i; 602 cmd.args[2] = i;
603 cmd.len = 3; 603 cmd.len = 3;
604 ret = tda10071_cmd_execute(priv, &cmd); 604 ret = tda10071_cmd_execute(priv, &cmd);
605 if (ret) 605 if (ret)
606 goto error; 606 goto error;
607 607
608 ret = tda10071_rd_regs(priv, cmd.len, buf, len); 608 ret = tda10071_rd_regs(priv, cmd.len, buf, len);
609 if (ret) 609 if (ret)
610 goto error; 610 goto error;
611 611
612 if (priv->delivery_system == SYS_DVBS) { 612 if (priv->delivery_system == SYS_DVBS) {
613 *ber = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; 613 *ber = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
614 priv->ucb += (buf[4] << 8) | buf[5]; 614 priv->ucb += (buf[4] << 8) | buf[5];
615 } else { 615 } else {
616 *ber = (buf[0] << 8) | buf[1]; 616 *ber = (buf[0] << 8) | buf[1];
617 } 617 }
618 priv->ber = *ber; 618 priv->ber = *ber;
619 619
620 return ret; 620 return ret;
621 error: 621 error:
622 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 622 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
623 return ret; 623 return ret;
624 } 624 }
625 625
626 static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 626 static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
627 { 627 {
628 struct tda10071_priv *priv = fe->demodulator_priv; 628 struct tda10071_priv *priv = fe->demodulator_priv;
629 int ret = 0; 629 int ret = 0;
630 630
631 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) { 631 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
632 *ucblocks = 0; 632 *ucblocks = 0;
633 goto error; 633 goto error;
634 } 634 }
635 635
636 /* UCB is updated when BER is read. Assume BER is read anyway. */ 636 /* UCB is updated when BER is read. Assume BER is read anyway. */
637 637
638 *ucblocks = priv->ucb; 638 *ucblocks = priv->ucb;
639 639
640 return ret; 640 return ret;
641 error: 641 error:
642 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 642 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
643 return ret; 643 return ret;
644 } 644 }
645 645
646 static int tda10071_set_frontend(struct dvb_frontend *fe) 646 static int tda10071_set_frontend(struct dvb_frontend *fe)
647 { 647 {
648 struct tda10071_priv *priv = fe->demodulator_priv; 648 struct tda10071_priv *priv = fe->demodulator_priv;
649 struct tda10071_cmd cmd; 649 struct tda10071_cmd cmd;
650 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 650 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
651 int ret, i; 651 int ret, i;
652 u8 mode, rolloff, pilot, inversion, div; 652 u8 mode, rolloff, pilot, inversion, div;
653 653
654 dev_dbg(&priv->i2c->dev, "%s: delivery_system=%d modulation=%d " \ 654 dev_dbg(&priv->i2c->dev, "%s: delivery_system=%d modulation=%d " \
655 "frequency=%d symbol_rate=%d inversion=%d pilot=%d " \ 655 "frequency=%d symbol_rate=%d inversion=%d pilot=%d " \
656 "rolloff=%d\n", __func__, c->delivery_system, c->modulation, 656 "rolloff=%d\n", __func__, c->delivery_system, c->modulation,
657 c->frequency, c->symbol_rate, c->inversion, c->pilot, 657 c->frequency, c->symbol_rate, c->inversion, c->pilot,
658 c->rolloff); 658 c->rolloff);
659 659
660 priv->delivery_system = SYS_UNDEFINED; 660 priv->delivery_system = SYS_UNDEFINED;
661 661
662 if (!priv->warm) { 662 if (!priv->warm) {
663 ret = -EFAULT; 663 ret = -EFAULT;
664 goto error; 664 goto error;
665 } 665 }
666 666
667 switch (c->inversion) { 667 switch (c->inversion) {
668 case INVERSION_OFF: 668 case INVERSION_OFF:
669 inversion = 1; 669 inversion = 1;
670 break; 670 break;
671 case INVERSION_ON: 671 case INVERSION_ON:
672 inversion = 0; 672 inversion = 0;
673 break; 673 break;
674 case INVERSION_AUTO: 674 case INVERSION_AUTO:
675 /* 2 = auto; try first on then off 675 /* 2 = auto; try first on then off
676 * 3 = auto; try first off then on */ 676 * 3 = auto; try first off then on */
677 inversion = 3; 677 inversion = 3;
678 break; 678 break;
679 default: 679 default:
680 dev_dbg(&priv->i2c->dev, "%s: invalid inversion\n", __func__); 680 dev_dbg(&priv->i2c->dev, "%s: invalid inversion\n", __func__);
681 ret = -EINVAL; 681 ret = -EINVAL;
682 goto error; 682 goto error;
683 } 683 }
684 684
685 switch (c->delivery_system) { 685 switch (c->delivery_system) {
686 case SYS_DVBS: 686 case SYS_DVBS:
687 rolloff = 0; 687 rolloff = 0;
688 pilot = 2; 688 pilot = 2;
689 break; 689 break;
690 case SYS_DVBS2: 690 case SYS_DVBS2:
691 switch (c->rolloff) { 691 switch (c->rolloff) {
692 case ROLLOFF_20: 692 case ROLLOFF_20:
693 rolloff = 2; 693 rolloff = 2;
694 break; 694 break;
695 case ROLLOFF_25: 695 case ROLLOFF_25:
696 rolloff = 1; 696 rolloff = 1;
697 break; 697 break;
698 case ROLLOFF_35: 698 case ROLLOFF_35:
699 rolloff = 0; 699 rolloff = 0;
700 break; 700 break;
701 case ROLLOFF_AUTO: 701 case ROLLOFF_AUTO:
702 default: 702 default:
703 dev_dbg(&priv->i2c->dev, "%s: invalid rolloff\n", 703 dev_dbg(&priv->i2c->dev, "%s: invalid rolloff\n",
704 __func__); 704 __func__);
705 ret = -EINVAL; 705 ret = -EINVAL;
706 goto error; 706 goto error;
707 } 707 }
708 708
709 switch (c->pilot) { 709 switch (c->pilot) {
710 case PILOT_OFF: 710 case PILOT_OFF:
711 pilot = 0; 711 pilot = 0;
712 break; 712 break;
713 case PILOT_ON: 713 case PILOT_ON:
714 pilot = 1; 714 pilot = 1;
715 break; 715 break;
716 case PILOT_AUTO: 716 case PILOT_AUTO:
717 pilot = 2; 717 pilot = 2;
718 break; 718 break;
719 default: 719 default:
720 dev_dbg(&priv->i2c->dev, "%s: invalid pilot\n", 720 dev_dbg(&priv->i2c->dev, "%s: invalid pilot\n",
721 __func__); 721 __func__);
722 ret = -EINVAL; 722 ret = -EINVAL;
723 goto error; 723 goto error;
724 } 724 }
725 break; 725 break;
726 default: 726 default:
727 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n", 727 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
728 __func__); 728 __func__);
729 ret = -EINVAL; 729 ret = -EINVAL;
730 goto error; 730 goto error;
731 } 731 }
732 732
733 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) { 733 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
734 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system && 734 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system &&
735 c->modulation == TDA10071_MODCOD[i].modulation && 735 c->modulation == TDA10071_MODCOD[i].modulation &&
736 c->fec_inner == TDA10071_MODCOD[i].fec) { 736 c->fec_inner == TDA10071_MODCOD[i].fec) {
737 mode = TDA10071_MODCOD[i].val; 737 mode = TDA10071_MODCOD[i].val;
738 dev_dbg(&priv->i2c->dev, "%s: mode found=%02x\n", 738 dev_dbg(&priv->i2c->dev, "%s: mode found=%02x\n",
739 __func__, mode); 739 __func__, mode);
740 break; 740 break;
741 } 741 }
742 } 742 }
743 743
744 if (mode == 0xff) { 744 if (mode == 0xff) {
745 dev_dbg(&priv->i2c->dev, "%s: invalid parameter combination\n", 745 dev_dbg(&priv->i2c->dev, "%s: invalid parameter combination\n",
746 __func__); 746 __func__);
747 ret = -EINVAL; 747 ret = -EINVAL;
748 goto error; 748 goto error;
749 } 749 }
750 750
751 if (c->symbol_rate <= 5000000) 751 if (c->symbol_rate <= 5000000)
752 div = 14; 752 div = 14;
753 else 753 else
754 div = 4; 754 div = 4;
755 755
756 ret = tda10071_wr_reg(priv, 0x81, div); 756 ret = tda10071_wr_reg(priv, 0x81, div);
757 if (ret) 757 if (ret)
758 goto error; 758 goto error;
759 759
760 ret = tda10071_wr_reg(priv, 0xe3, div); 760 ret = tda10071_wr_reg(priv, 0xe3, div);
761 if (ret) 761 if (ret)
762 goto error; 762 goto error;
763 763
764 cmd.args[0] = CMD_CHANGE_CHANNEL; 764 cmd.args[0] = CMD_CHANGE_CHANNEL;
765 cmd.args[1] = 0; 765 cmd.args[1] = 0;
766 cmd.args[2] = mode; 766 cmd.args[2] = mode;
767 cmd.args[3] = (c->frequency >> 16) & 0xff; 767 cmd.args[3] = (c->frequency >> 16) & 0xff;
768 cmd.args[4] = (c->frequency >> 8) & 0xff; 768 cmd.args[4] = (c->frequency >> 8) & 0xff;
769 cmd.args[5] = (c->frequency >> 0) & 0xff; 769 cmd.args[5] = (c->frequency >> 0) & 0xff;
770 cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff; 770 cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff;
771 cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff; 771 cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff;
772 cmd.args[8] = (tda10071_ops.info.frequency_tolerance >> 8) & 0xff; 772 cmd.args[8] = (tda10071_ops.info.frequency_tolerance >> 8) & 0xff;
773 cmd.args[9] = (tda10071_ops.info.frequency_tolerance >> 0) & 0xff; 773 cmd.args[9] = (tda10071_ops.info.frequency_tolerance >> 0) & 0xff;
774 cmd.args[10] = rolloff; 774 cmd.args[10] = rolloff;
775 cmd.args[11] = inversion; 775 cmd.args[11] = inversion;
776 cmd.args[12] = pilot; 776 cmd.args[12] = pilot;
777 cmd.args[13] = 0x00; 777 cmd.args[13] = 0x00;
778 cmd.args[14] = 0x00; 778 cmd.args[14] = 0x00;
779 cmd.len = 15; 779 cmd.len = 15;
780 ret = tda10071_cmd_execute(priv, &cmd); 780 ret = tda10071_cmd_execute(priv, &cmd);
781 if (ret) 781 if (ret)
782 goto error; 782 goto error;
783 783
784 priv->delivery_system = c->delivery_system; 784 priv->delivery_system = c->delivery_system;
785 785
786 return ret; 786 return ret;
787 error: 787 error:
788 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 788 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
789 return ret; 789 return ret;
790 } 790 }
791 791
792 static int tda10071_get_frontend(struct dvb_frontend *fe) 792 static int tda10071_get_frontend(struct dvb_frontend *fe)
793 { 793 {
794 struct tda10071_priv *priv = fe->demodulator_priv; 794 struct tda10071_priv *priv = fe->demodulator_priv;
795 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 795 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
796 int ret, i; 796 int ret, i;
797 u8 buf[5], tmp; 797 u8 buf[5], tmp;
798 798
799 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) { 799 if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
800 ret = -EFAULT; 800 ret = -EFAULT;
801 goto error; 801 goto error;
802 } 802 }
803 803
804 ret = tda10071_rd_regs(priv, 0x30, buf, 5); 804 ret = tda10071_rd_regs(priv, 0x30, buf, 5);
805 if (ret) 805 if (ret)
806 goto error; 806 goto error;
807 807
808 tmp = buf[0] & 0x3f; 808 tmp = buf[0] & 0x3f;
809 for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) { 809 for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
810 if (tmp == TDA10071_MODCOD[i].val) { 810 if (tmp == TDA10071_MODCOD[i].val) {
811 c->modulation = TDA10071_MODCOD[i].modulation; 811 c->modulation = TDA10071_MODCOD[i].modulation;
812 c->fec_inner = TDA10071_MODCOD[i].fec; 812 c->fec_inner = TDA10071_MODCOD[i].fec;
813 c->delivery_system = TDA10071_MODCOD[i].delivery_system; 813 c->delivery_system = TDA10071_MODCOD[i].delivery_system;
814 } 814 }
815 } 815 }
816 816
817 switch ((buf[1] >> 0) & 0x01) { 817 switch ((buf[1] >> 0) & 0x01) {
818 case 0: 818 case 0:
819 c->inversion = INVERSION_OFF; 819 c->inversion = INVERSION_OFF;
820 break; 820 break;
821 case 1: 821 case 1:
822 c->inversion = INVERSION_ON; 822 c->inversion = INVERSION_ON;
823 break; 823 break;
824 } 824 }
825 825
826 switch ((buf[1] >> 7) & 0x01) { 826 switch ((buf[1] >> 7) & 0x01) {
827 case 0: 827 case 0:
828 c->pilot = PILOT_OFF; 828 c->pilot = PILOT_OFF;
829 break; 829 break;
830 case 1: 830 case 1:
831 c->pilot = PILOT_ON; 831 c->pilot = PILOT_ON;
832 break; 832 break;
833 } 833 }
834 834
835 c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0); 835 c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0);
836 836
837 ret = tda10071_rd_regs(priv, 0x52, buf, 3); 837 ret = tda10071_rd_regs(priv, 0x52, buf, 3);
838 if (ret) 838 if (ret)
839 goto error; 839 goto error;
840 840
841 c->symbol_rate = (buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0); 841 c->symbol_rate = (buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0);
842 842
843 return ret; 843 return ret;
844 error: 844 error:
845 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 845 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
846 return ret; 846 return ret;
847 } 847 }
848 848
849 static int tda10071_init(struct dvb_frontend *fe) 849 static int tda10071_init(struct dvb_frontend *fe)
850 { 850 {
851 struct tda10071_priv *priv = fe->demodulator_priv; 851 struct tda10071_priv *priv = fe->demodulator_priv;
852 struct tda10071_cmd cmd; 852 struct tda10071_cmd cmd;
853 int ret, i, len, remaining, fw_size; 853 int ret, i, len, remaining, fw_size;
854 const struct firmware *fw; 854 const struct firmware *fw;
855 u8 *fw_file = TDA10071_FIRMWARE; 855 u8 *fw_file = TDA10071_FIRMWARE;
856 u8 tmp, buf[4]; 856 u8 tmp, buf[4];
857 struct tda10071_reg_val_mask tab[] = { 857 struct tda10071_reg_val_mask tab[] = {
858 { 0xcd, 0x00, 0x07 }, 858 { 0xcd, 0x00, 0x07 },
859 { 0x80, 0x00, 0x02 }, 859 { 0x80, 0x00, 0x02 },
860 { 0xcd, 0x00, 0xc0 }, 860 { 0xcd, 0x00, 0xc0 },
861 { 0xce, 0x00, 0x1b }, 861 { 0xce, 0x00, 0x1b },
862 { 0x9d, 0x00, 0x01 }, 862 { 0x9d, 0x00, 0x01 },
863 { 0x9d, 0x00, 0x02 }, 863 { 0x9d, 0x00, 0x02 },
864 { 0x9e, 0x00, 0x01 }, 864 { 0x9e, 0x00, 0x01 },
865 { 0x87, 0x00, 0x80 }, 865 { 0x87, 0x00, 0x80 },
866 { 0xce, 0x00, 0x08 }, 866 { 0xce, 0x00, 0x08 },
867 { 0xce, 0x00, 0x10 }, 867 { 0xce, 0x00, 0x10 },
868 }; 868 };
869 struct tda10071_reg_val_mask tab2[] = { 869 struct tda10071_reg_val_mask tab2[] = {
870 { 0xf1, 0x70, 0xff }, 870 { 0xf1, 0x70, 0xff },
871 { 0x88, priv->cfg.pll_multiplier, 0x3f }, 871 { 0x88, priv->cfg.pll_multiplier, 0x3f },
872 { 0x89, 0x00, 0x10 }, 872 { 0x89, 0x00, 0x10 },
873 { 0x89, 0x10, 0x10 }, 873 { 0x89, 0x10, 0x10 },
874 { 0xc0, 0x01, 0x01 }, 874 { 0xc0, 0x01, 0x01 },
875 { 0xc0, 0x00, 0x01 }, 875 { 0xc0, 0x00, 0x01 },
876 { 0xe0, 0xff, 0xff }, 876 { 0xe0, 0xff, 0xff },
877 { 0xe0, 0x00, 0xff }, 877 { 0xe0, 0x00, 0xff },
878 { 0x96, 0x1e, 0x7e }, 878 { 0x96, 0x1e, 0x7e },
879 { 0x8b, 0x08, 0x08 }, 879 { 0x8b, 0x08, 0x08 },
880 { 0x8b, 0x00, 0x08 }, 880 { 0x8b, 0x00, 0x08 },
881 { 0x8f, 0x1a, 0x7e }, 881 { 0x8f, 0x1a, 0x7e },
882 { 0x8c, 0x68, 0xff }, 882 { 0x8c, 0x68, 0xff },
883 { 0x8d, 0x08, 0xff }, 883 { 0x8d, 0x08, 0xff },
884 { 0x8e, 0x4c, 0xff }, 884 { 0x8e, 0x4c, 0xff },
885 { 0x8f, 0x01, 0x01 }, 885 { 0x8f, 0x01, 0x01 },
886 { 0x8b, 0x04, 0x04 }, 886 { 0x8b, 0x04, 0x04 },
887 { 0x8b, 0x00, 0x04 }, 887 { 0x8b, 0x00, 0x04 },
888 { 0x87, 0x05, 0x07 }, 888 { 0x87, 0x05, 0x07 },
889 { 0x80, 0x00, 0x20 }, 889 { 0x80, 0x00, 0x20 },
890 { 0xc8, 0x01, 0xff }, 890 { 0xc8, 0x01, 0xff },
891 { 0xb4, 0x47, 0xff }, 891 { 0xb4, 0x47, 0xff },
892 { 0xb5, 0x9c, 0xff }, 892 { 0xb5, 0x9c, 0xff },
893 { 0xb6, 0x7d, 0xff }, 893 { 0xb6, 0x7d, 0xff },
894 { 0xba, 0x00, 0x03 }, 894 { 0xba, 0x00, 0x03 },
895 { 0xb7, 0x47, 0xff }, 895 { 0xb7, 0x47, 0xff },
896 { 0xb8, 0x9c, 0xff }, 896 { 0xb8, 0x9c, 0xff },
897 { 0xb9, 0x7d, 0xff }, 897 { 0xb9, 0x7d, 0xff },
898 { 0xba, 0x00, 0x0c }, 898 { 0xba, 0x00, 0x0c },
899 { 0xc8, 0x00, 0xff }, 899 { 0xc8, 0x00, 0xff },
900 { 0xcd, 0x00, 0x04 }, 900 { 0xcd, 0x00, 0x04 },
901 { 0xcd, 0x00, 0x20 }, 901 { 0xcd, 0x00, 0x20 },
902 { 0xe8, 0x02, 0xff }, 902 { 0xe8, 0x02, 0xff },
903 { 0xcf, 0x20, 0xff }, 903 { 0xcf, 0x20, 0xff },
904 { 0x9b, 0xd7, 0xff }, 904 { 0x9b, 0xd7, 0xff },
905 { 0x9a, 0x01, 0x03 }, 905 { 0x9a, 0x01, 0x03 },
906 { 0xa8, 0x05, 0x0f }, 906 { 0xa8, 0x05, 0x0f },
907 { 0xa8, 0x65, 0xf0 }, 907 { 0xa8, 0x65, 0xf0 },
908 { 0xa6, 0xa0, 0xf0 }, 908 { 0xa6, 0xa0, 0xf0 },
909 { 0x9d, 0x50, 0xfc }, 909 { 0x9d, 0x50, 0xfc },
910 { 0x9e, 0x20, 0xe0 }, 910 { 0x9e, 0x20, 0xe0 },
911 { 0xa3, 0x1c, 0x7c }, 911 { 0xa3, 0x1c, 0x7c },
912 { 0xd5, 0x03, 0x03 }, 912 { 0xd5, 0x03, 0x03 },
913 }; 913 };
914 914
915 /* firmware status */ 915 /* firmware status */
916 ret = tda10071_rd_reg(priv, 0x51, &tmp); 916 ret = tda10071_rd_reg(priv, 0x51, &tmp);
917 if (ret) 917 if (ret)
918 goto error; 918 goto error;
919 919
920 if (!tmp) { 920 if (!tmp) {
921 /* warm state - wake up device from sleep */ 921 /* warm state - wake up device from sleep */
922 priv->warm = 1; 922 priv->warm = 1;
923 923
924 for (i = 0; i < ARRAY_SIZE(tab); i++) { 924 for (i = 0; i < ARRAY_SIZE(tab); i++) {
925 ret = tda10071_wr_reg_mask(priv, tab[i].reg, 925 ret = tda10071_wr_reg_mask(priv, tab[i].reg,
926 tab[i].val, tab[i].mask); 926 tab[i].val, tab[i].mask);
927 if (ret) 927 if (ret)
928 goto error; 928 goto error;
929 } 929 }
930 930
931 cmd.args[0] = CMD_SET_SLEEP_MODE; 931 cmd.args[0] = CMD_SET_SLEEP_MODE;
932 cmd.args[1] = 0; 932 cmd.args[1] = 0;
933 cmd.args[2] = 0; 933 cmd.args[2] = 0;
934 cmd.len = 3; 934 cmd.len = 3;
935 ret = tda10071_cmd_execute(priv, &cmd); 935 ret = tda10071_cmd_execute(priv, &cmd);
936 if (ret) 936 if (ret)
937 goto error; 937 goto error;
938 } else { 938 } else {
939 /* cold state - try to download firmware */ 939 /* cold state - try to download firmware */
940 priv->warm = 0; 940 priv->warm = 0;
941 941
942 /* request the firmware, this will block and timeout */ 942 /* request the firmware, this will block and timeout */
943 ret = request_firmware(&fw, fw_file, priv->i2c->dev.parent); 943 ret = request_firmware(&fw, fw_file, priv->i2c->dev.parent);
944 if (ret) { 944 if (ret) {
945 dev_err(&priv->i2c->dev, "%s: did not find the " \ 945 dev_err(&priv->i2c->dev, "%s: did not find the " \
946 "firmware file. (%s) Please see " \ 946 "firmware file. (%s) Please see " \
947 "linux/Documentation/dvb/ for more " \ 947 "linux/Documentation/dvb/ for more " \
948 "details on firmware-problems. (%d)\n", 948 "details on firmware-problems. (%d)\n",
949 KBUILD_MODNAME, fw_file, ret); 949 KBUILD_MODNAME, fw_file, ret);
950 goto error; 950 goto error;
951 } 951 }
952 952
953 /* init */ 953 /* init */
954 for (i = 0; i < ARRAY_SIZE(tab2); i++) { 954 for (i = 0; i < ARRAY_SIZE(tab2); i++) {
955 ret = tda10071_wr_reg_mask(priv, tab2[i].reg, 955 ret = tda10071_wr_reg_mask(priv, tab2[i].reg,
956 tab2[i].val, tab2[i].mask); 956 tab2[i].val, tab2[i].mask);
957 if (ret) 957 if (ret)
958 goto error_release_firmware; 958 goto error_release_firmware;
959 } 959 }
960 960
961 /* download firmware */ 961 /* download firmware */
962 ret = tda10071_wr_reg(priv, 0xe0, 0x7f); 962 ret = tda10071_wr_reg(priv, 0xe0, 0x7f);
963 if (ret) 963 if (ret)
964 goto error_release_firmware; 964 goto error_release_firmware;
965 965
966 ret = tda10071_wr_reg(priv, 0xf7, 0x81); 966 ret = tda10071_wr_reg(priv, 0xf7, 0x81);
967 if (ret) 967 if (ret)
968 goto error_release_firmware; 968 goto error_release_firmware;
969 969
970 ret = tda10071_wr_reg(priv, 0xf8, 0x00); 970 ret = tda10071_wr_reg(priv, 0xf8, 0x00);
971 if (ret) 971 if (ret)
972 goto error_release_firmware; 972 goto error_release_firmware;
973 973
974 ret = tda10071_wr_reg(priv, 0xf9, 0x00); 974 ret = tda10071_wr_reg(priv, 0xf9, 0x00);
975 if (ret) 975 if (ret)
976 goto error_release_firmware; 976 goto error_release_firmware;
977 977
978 dev_info(&priv->i2c->dev, "%s: found a '%s' in cold state, " \ 978 dev_info(&priv->i2c->dev, "%s: found a '%s' in cold state, " \
979 "will try to load a firmware\n", KBUILD_MODNAME, 979 "will try to load a firmware\n", KBUILD_MODNAME,
980 tda10071_ops.info.name); 980 tda10071_ops.info.name);
981 dev_info(&priv->i2c->dev, "%s: downloading firmware from " \ 981 dev_info(&priv->i2c->dev, "%s: downloading firmware from " \
982 "file '%s'\n", KBUILD_MODNAME, fw_file); 982 "file '%s'\n", KBUILD_MODNAME, fw_file);
983 983
984 /* do not download last byte */ 984 /* do not download last byte */
985 fw_size = fw->size - 1; 985 fw_size = fw->size - 1;
986 986
987 for (remaining = fw_size; remaining > 0; 987 for (remaining = fw_size; remaining > 0;
988 remaining -= (priv->cfg.i2c_wr_max - 1)) { 988 remaining -= (priv->cfg.i2c_wr_max - 1)) {
989 len = remaining; 989 len = remaining;
990 if (len > (priv->cfg.i2c_wr_max - 1)) 990 if (len > (priv->cfg.i2c_wr_max - 1))
991 len = (priv->cfg.i2c_wr_max - 1); 991 len = (priv->cfg.i2c_wr_max - 1);
992 992
993 ret = tda10071_wr_regs(priv, 0xfa, 993 ret = tda10071_wr_regs(priv, 0xfa,
994 (u8 *) &fw->data[fw_size - remaining], len); 994 (u8 *) &fw->data[fw_size - remaining], len);
995 if (ret) { 995 if (ret) {
996 dev_err(&priv->i2c->dev, "%s: firmware " \ 996 dev_err(&priv->i2c->dev, "%s: firmware " \
997 "download failed=%d\n", 997 "download failed=%d\n",
998 KBUILD_MODNAME, ret); 998 KBUILD_MODNAME, ret);
999 if (ret) 999 if (ret)
1000 goto error_release_firmware; 1000 goto error_release_firmware;
1001 } 1001 }
1002 } 1002 }
1003 release_firmware(fw); 1003 release_firmware(fw);
1004 1004
1005 ret = tda10071_wr_reg(priv, 0xf7, 0x0c); 1005 ret = tda10071_wr_reg(priv, 0xf7, 0x0c);
1006 if (ret) 1006 if (ret)
1007 goto error; 1007 goto error;
1008 1008
1009 ret = tda10071_wr_reg(priv, 0xe0, 0x00); 1009 ret = tda10071_wr_reg(priv, 0xe0, 0x00);
1010 if (ret) 1010 if (ret)
1011 goto error; 1011 goto error;
1012 1012
1013 /* wait firmware start */ 1013 /* wait firmware start */
1014 msleep(250); 1014 msleep(250);
1015 1015
1016 /* firmware status */ 1016 /* firmware status */
1017 ret = tda10071_rd_reg(priv, 0x51, &tmp); 1017 ret = tda10071_rd_reg(priv, 0x51, &tmp);
1018 if (ret) 1018 if (ret)
1019 goto error; 1019 goto error;
1020 1020
1021 if (tmp) { 1021 if (tmp) {
1022 dev_info(&priv->i2c->dev, "%s: firmware did not run\n", 1022 dev_info(&priv->i2c->dev, "%s: firmware did not run\n",
1023 KBUILD_MODNAME); 1023 KBUILD_MODNAME);
1024 ret = -EFAULT; 1024 ret = -EFAULT;
1025 goto error; 1025 goto error;
1026 } else { 1026 } else {
1027 priv->warm = 1; 1027 priv->warm = 1;
1028 } 1028 }
1029 1029
1030 cmd.args[0] = CMD_GET_FW_VERSION; 1030 cmd.args[0] = CMD_GET_FW_VERSION;
1031 cmd.len = 1; 1031 cmd.len = 1;
1032 ret = tda10071_cmd_execute(priv, &cmd); 1032 ret = tda10071_cmd_execute(priv, &cmd);
1033 if (ret) 1033 if (ret)
1034 goto error; 1034 goto error;
1035 1035
1036 ret = tda10071_rd_regs(priv, cmd.len, buf, 4); 1036 ret = tda10071_rd_regs(priv, cmd.len, buf, 4);
1037 if (ret) 1037 if (ret)
1038 goto error; 1038 goto error;
1039 1039
1040 dev_info(&priv->i2c->dev, "%s: firmware version %d.%d.%d.%d\n", 1040 dev_info(&priv->i2c->dev, "%s: firmware version %d.%d.%d.%d\n",
1041 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]); 1041 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]);
1042 dev_info(&priv->i2c->dev, "%s: found a '%s' in warm state\n", 1042 dev_info(&priv->i2c->dev, "%s: found a '%s' in warm state\n",
1043 KBUILD_MODNAME, tda10071_ops.info.name); 1043 KBUILD_MODNAME, tda10071_ops.info.name);
1044 1044
1045 ret = tda10071_rd_regs(priv, 0x81, buf, 2); 1045 ret = tda10071_rd_regs(priv, 0x81, buf, 2);
1046 if (ret) 1046 if (ret)
1047 goto error; 1047 goto error;
1048 1048
1049 cmd.args[0] = CMD_DEMOD_INIT; 1049 cmd.args[0] = CMD_DEMOD_INIT;
1050 cmd.args[1] = ((priv->cfg.xtal / 1000) >> 8) & 0xff; 1050 cmd.args[1] = ((priv->cfg.xtal / 1000) >> 8) & 0xff;
1051 cmd.args[2] = ((priv->cfg.xtal / 1000) >> 0) & 0xff; 1051 cmd.args[2] = ((priv->cfg.xtal / 1000) >> 0) & 0xff;
1052 cmd.args[3] = buf[0]; 1052 cmd.args[3] = buf[0];
1053 cmd.args[4] = buf[1]; 1053 cmd.args[4] = buf[1];
1054 cmd.args[5] = priv->cfg.pll_multiplier; 1054 cmd.args[5] = priv->cfg.pll_multiplier;
1055 cmd.args[6] = priv->cfg.spec_inv; 1055 cmd.args[6] = priv->cfg.spec_inv;
1056 cmd.args[7] = 0x00; 1056 cmd.args[7] = 0x00;
1057 cmd.len = 8; 1057 cmd.len = 8;
1058 ret = tda10071_cmd_execute(priv, &cmd); 1058 ret = tda10071_cmd_execute(priv, &cmd);
1059 if (ret) 1059 if (ret)
1060 goto error; 1060 goto error;
1061 1061
1062 cmd.args[0] = CMD_TUNER_INIT; 1062 cmd.args[0] = CMD_TUNER_INIT;
1063 cmd.args[1] = 0x00; 1063 cmd.args[1] = 0x00;
1064 cmd.args[2] = 0x00; 1064 cmd.args[2] = 0x00;
1065 cmd.args[3] = 0x00; 1065 cmd.args[3] = 0x00;
1066 cmd.args[4] = 0x00; 1066 cmd.args[4] = 0x00;
1067 cmd.args[5] = (priv->cfg.tuner_i2c_addr) ? priv->cfg.tuner_i2c_addr : 0x14; 1067 cmd.args[5] = (priv->cfg.tuner_i2c_addr) ? priv->cfg.tuner_i2c_addr : 0x14;
1068 cmd.args[6] = 0x00; 1068 cmd.args[6] = 0x00;
1069 cmd.args[7] = 0x03; 1069 cmd.args[7] = 0x03;
1070 cmd.args[8] = 0x02; 1070 cmd.args[8] = 0x02;
1071 cmd.args[9] = 0x02; 1071 cmd.args[9] = 0x02;
1072 cmd.args[10] = 0x00; 1072 cmd.args[10] = 0x00;
1073 cmd.args[11] = 0x00; 1073 cmd.args[11] = 0x00;
1074 cmd.args[12] = 0x00; 1074 cmd.args[12] = 0x00;
1075 cmd.args[13] = 0x00; 1075 cmd.args[13] = 0x00;
1076 cmd.args[14] = 0x00; 1076 cmd.args[14] = 0x00;
1077 cmd.len = 15; 1077 cmd.len = 15;
1078 ret = tda10071_cmd_execute(priv, &cmd); 1078 ret = tda10071_cmd_execute(priv, &cmd);
1079 if (ret) 1079 if (ret)
1080 goto error; 1080 goto error;
1081 1081
1082 cmd.args[0] = CMD_MPEG_CONFIG; 1082 cmd.args[0] = CMD_MPEG_CONFIG;
1083 cmd.args[1] = 0; 1083 cmd.args[1] = 0;
1084 cmd.args[2] = priv->cfg.ts_mode; 1084 cmd.args[2] = priv->cfg.ts_mode;
1085 cmd.args[3] = 0x00; 1085 cmd.args[3] = 0x00;
1086 cmd.args[4] = 0x04; 1086 cmd.args[4] = 0x04;
1087 cmd.args[5] = 0x00; 1087 cmd.args[5] = 0x00;
1088 cmd.len = 6; 1088 cmd.len = 6;
1089 ret = tda10071_cmd_execute(priv, &cmd); 1089 ret = tda10071_cmd_execute(priv, &cmd);
1090 if (ret) 1090 if (ret)
1091 goto error; 1091 goto error;
1092 1092
1093 ret = tda10071_wr_reg_mask(priv, 0xf0, 0x01, 0x01); 1093 ret = tda10071_wr_reg_mask(priv, 0xf0, 0x01, 0x01);
1094 if (ret) 1094 if (ret)
1095 goto error; 1095 goto error;
1096 1096
1097 cmd.args[0] = CMD_LNB_CONFIG; 1097 cmd.args[0] = CMD_LNB_CONFIG;
1098 cmd.args[1] = 0; 1098 cmd.args[1] = 0;
1099 cmd.args[2] = 150; 1099 cmd.args[2] = 150;
1100 cmd.args[3] = 3; 1100 cmd.args[3] = 3;
1101 cmd.args[4] = 22; 1101 cmd.args[4] = 22;
1102 cmd.args[5] = 1; 1102 cmd.args[5] = 1;
1103 cmd.args[6] = 1; 1103 cmd.args[6] = 1;
1104 cmd.args[7] = 30; 1104 cmd.args[7] = 30;
1105 cmd.args[8] = 30; 1105 cmd.args[8] = 30;
1106 cmd.args[9] = 30; 1106 cmd.args[9] = 30;
1107 cmd.args[10] = 30; 1107 cmd.args[10] = 30;
1108 cmd.len = 11; 1108 cmd.len = 11;
1109 ret = tda10071_cmd_execute(priv, &cmd); 1109 ret = tda10071_cmd_execute(priv, &cmd);
1110 if (ret) 1110 if (ret)
1111 goto error; 1111 goto error;
1112 1112
1113 cmd.args[0] = CMD_BER_CONTROL; 1113 cmd.args[0] = CMD_BER_CONTROL;
1114 cmd.args[1] = 0; 1114 cmd.args[1] = 0;
1115 cmd.args[2] = 14; 1115 cmd.args[2] = 14;
1116 cmd.args[3] = 14; 1116 cmd.args[3] = 14;
1117 cmd.len = 4; 1117 cmd.len = 4;
1118 ret = tda10071_cmd_execute(priv, &cmd); 1118 ret = tda10071_cmd_execute(priv, &cmd);
1119 if (ret) 1119 if (ret)
1120 goto error; 1120 goto error;
1121 } 1121 }
1122 1122
1123 return ret; 1123 return ret;
1124 error_release_firmware: 1124 error_release_firmware:
1125 release_firmware(fw); 1125 release_firmware(fw);
1126 error: 1126 error:
1127 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 1127 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1128 return ret; 1128 return ret;
1129 } 1129 }
1130 1130
1131 static int tda10071_sleep(struct dvb_frontend *fe) 1131 static int tda10071_sleep(struct dvb_frontend *fe)
1132 { 1132 {
1133 struct tda10071_priv *priv = fe->demodulator_priv; 1133 struct tda10071_priv *priv = fe->demodulator_priv;
1134 struct tda10071_cmd cmd; 1134 struct tda10071_cmd cmd;
1135 int ret, i; 1135 int ret, i;
1136 struct tda10071_reg_val_mask tab[] = { 1136 struct tda10071_reg_val_mask tab[] = {
1137 { 0xcd, 0x07, 0x07 }, 1137 { 0xcd, 0x07, 0x07 },
1138 { 0x80, 0x02, 0x02 }, 1138 { 0x80, 0x02, 0x02 },
1139 { 0xcd, 0xc0, 0xc0 }, 1139 { 0xcd, 0xc0, 0xc0 },
1140 { 0xce, 0x1b, 0x1b }, 1140 { 0xce, 0x1b, 0x1b },
1141 { 0x9d, 0x01, 0x01 }, 1141 { 0x9d, 0x01, 0x01 },
1142 { 0x9d, 0x02, 0x02 }, 1142 { 0x9d, 0x02, 0x02 },
1143 { 0x9e, 0x01, 0x01 }, 1143 { 0x9e, 0x01, 0x01 },
1144 { 0x87, 0x80, 0x80 }, 1144 { 0x87, 0x80, 0x80 },
1145 { 0xce, 0x08, 0x08 }, 1145 { 0xce, 0x08, 0x08 },
1146 { 0xce, 0x10, 0x10 }, 1146 { 0xce, 0x10, 0x10 },
1147 }; 1147 };
1148 1148
1149 if (!priv->warm) { 1149 if (!priv->warm) {
1150 ret = -EFAULT; 1150 ret = -EFAULT;
1151 goto error; 1151 goto error;
1152 } 1152 }
1153 1153
1154 cmd.args[0] = CMD_SET_SLEEP_MODE; 1154 cmd.args[0] = CMD_SET_SLEEP_MODE;
1155 cmd.args[1] = 0; 1155 cmd.args[1] = 0;
1156 cmd.args[2] = 1; 1156 cmd.args[2] = 1;
1157 cmd.len = 3; 1157 cmd.len = 3;
1158 ret = tda10071_cmd_execute(priv, &cmd); 1158 ret = tda10071_cmd_execute(priv, &cmd);
1159 if (ret) 1159 if (ret)
1160 goto error; 1160 goto error;
1161 1161
1162 for (i = 0; i < ARRAY_SIZE(tab); i++) { 1162 for (i = 0; i < ARRAY_SIZE(tab); i++) {
1163 ret = tda10071_wr_reg_mask(priv, tab[i].reg, tab[i].val, 1163 ret = tda10071_wr_reg_mask(priv, tab[i].reg, tab[i].val,
1164 tab[i].mask); 1164 tab[i].mask);
1165 if (ret) 1165 if (ret)
1166 goto error; 1166 goto error;
1167 } 1167 }
1168 1168
1169 return ret; 1169 return ret;
1170 error: 1170 error:
1171 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); 1171 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1172 return ret; 1172 return ret;
1173 } 1173 }
1174 1174
1175 static int tda10071_get_tune_settings(struct dvb_frontend *fe, 1175 static int tda10071_get_tune_settings(struct dvb_frontend *fe,
1176 struct dvb_frontend_tune_settings *s) 1176 struct dvb_frontend_tune_settings *s)
1177 { 1177 {
1178 s->min_delay_ms = 8000; 1178 s->min_delay_ms = 8000;
1179 s->step_size = 0; 1179 s->step_size = 0;
1180 s->max_drift = 0; 1180 s->max_drift = 0;
1181 1181
1182 return 0; 1182 return 0;
1183 } 1183 }
1184 1184
1185 static void tda10071_release(struct dvb_frontend *fe) 1185 static void tda10071_release(struct dvb_frontend *fe)
1186 { 1186 {
1187 struct tda10071_priv *priv = fe->demodulator_priv; 1187 struct tda10071_priv *priv = fe->demodulator_priv;
1188 kfree(priv); 1188 kfree(priv);
1189 } 1189 }
1190 1190
1191 struct dvb_frontend *tda10071_attach(const struct tda10071_config *config, 1191 struct dvb_frontend *tda10071_attach(const struct tda10071_config *config,
1192 struct i2c_adapter *i2c) 1192 struct i2c_adapter *i2c)
1193 { 1193 {
1194 int ret; 1194 int ret;
1195 struct tda10071_priv *priv = NULL; 1195 struct tda10071_priv *priv = NULL;
1196 u8 tmp; 1196 u8 tmp;
1197 1197
1198 /* allocate memory for the internal priv */ 1198 /* allocate memory for the internal priv */
1199 priv = kzalloc(sizeof(struct tda10071_priv), GFP_KERNEL); 1199 priv = kzalloc(sizeof(struct tda10071_priv), GFP_KERNEL);
1200 if (priv == NULL) { 1200 if (priv == NULL) {
1201 ret = -ENOMEM; 1201 ret = -ENOMEM;
1202 goto error; 1202 goto error;
1203 } 1203 }
1204 1204
1205 /* make sure demod i2c address is specified */ 1205 /* make sure demod i2c address is specified */
1206 if (!config->demod_i2c_addr) { 1206 if (!config->demod_i2c_addr) {
1207 dev_dbg(&i2c->dev, "%s: invalid demod i2c address!\n", __func__); 1207 dev_dbg(&i2c->dev, "%s: invalid demod i2c address!\n", __func__);
1208 ret = -EINVAL;
1208 goto error; 1209 goto error;
1209 } 1210 }
1210 1211
1211 /* make sure tuner i2c address is specified */ 1212 /* make sure tuner i2c address is specified */
1212 if (!config->tuner_i2c_addr) { 1213 if (!config->tuner_i2c_addr) {
1213 dev_dbg(&i2c->dev, "%s: invalid tuner i2c address!\n", __func__); 1214 dev_dbg(&i2c->dev, "%s: invalid tuner i2c address!\n", __func__);
1215 ret = -EINVAL;
1214 goto error; 1216 goto error;
1215 } 1217 }
1216 1218
1217 /* setup the priv */ 1219 /* setup the priv */
1218 priv->i2c = i2c; 1220 priv->i2c = i2c;
1219 memcpy(&priv->cfg, config, sizeof(struct tda10071_config)); 1221 memcpy(&priv->cfg, config, sizeof(struct tda10071_config));
1220 1222
1221 /* chip ID */ 1223 /* chip ID */
1222 ret = tda10071_rd_reg(priv, 0xff, &tmp); 1224 ret = tda10071_rd_reg(priv, 0xff, &tmp);
1223 if (ret || tmp != 0x0f) 1225 if (ret || tmp != 0x0f)
1224 goto error; 1226 goto error;
1225 1227
1226 /* chip type */ 1228 /* chip type */
1227 ret = tda10071_rd_reg(priv, 0xdd, &tmp); 1229 ret = tda10071_rd_reg(priv, 0xdd, &tmp);
1228 if (ret || tmp != 0x00) 1230 if (ret || tmp != 0x00)
1229 goto error; 1231 goto error;
1230 1232
1231 /* chip version */ 1233 /* chip version */
1232 ret = tda10071_rd_reg(priv, 0xfe, &tmp); 1234 ret = tda10071_rd_reg(priv, 0xfe, &tmp);
1233 if (ret || tmp != 0x01) 1235 if (ret || tmp != 0x01)
1234 goto error; 1236 goto error;
1235 1237
1236 /* create dvb_frontend */ 1238 /* create dvb_frontend */
1237 memcpy(&priv->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops)); 1239 memcpy(&priv->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops));
1238 priv->fe.demodulator_priv = priv; 1240 priv->fe.demodulator_priv = priv;
1239 1241
1240 return &priv->fe; 1242 return &priv->fe;
1241 error: 1243 error:
1242 dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret); 1244 dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret);
1243 kfree(priv); 1245 kfree(priv);
1244 return NULL; 1246 return NULL;
1245 } 1247 }
1246 EXPORT_SYMBOL(tda10071_attach); 1248 EXPORT_SYMBOL(tda10071_attach);
1247 1249
1248 static struct dvb_frontend_ops tda10071_ops = { 1250 static struct dvb_frontend_ops tda10071_ops = {
1249 .delsys = { SYS_DVBS, SYS_DVBS2 }, 1251 .delsys = { SYS_DVBS, SYS_DVBS2 },
1250 .info = { 1252 .info = {
1251 .name = "NXP TDA10071", 1253 .name = "NXP TDA10071",
1252 .frequency_min = 950000, 1254 .frequency_min = 950000,
1253 .frequency_max = 2150000, 1255 .frequency_max = 2150000,
1254 .frequency_tolerance = 5000, 1256 .frequency_tolerance = 5000,
1255 .symbol_rate_min = 1000000, 1257 .symbol_rate_min = 1000000,
1256 .symbol_rate_max = 45000000, 1258 .symbol_rate_max = 45000000,
1257 .caps = FE_CAN_INVERSION_AUTO | 1259 .caps = FE_CAN_INVERSION_AUTO |
1258 FE_CAN_FEC_1_2 | 1260 FE_CAN_FEC_1_2 |
1259 FE_CAN_FEC_2_3 | 1261 FE_CAN_FEC_2_3 |
1260 FE_CAN_FEC_3_4 | 1262 FE_CAN_FEC_3_4 |
1261 FE_CAN_FEC_4_5 | 1263 FE_CAN_FEC_4_5 |
1262 FE_CAN_FEC_5_6 | 1264 FE_CAN_FEC_5_6 |
1263 FE_CAN_FEC_6_7 | 1265 FE_CAN_FEC_6_7 |
1264 FE_CAN_FEC_7_8 | 1266 FE_CAN_FEC_7_8 |
1265 FE_CAN_FEC_8_9 | 1267 FE_CAN_FEC_8_9 |
1266 FE_CAN_FEC_AUTO | 1268 FE_CAN_FEC_AUTO |
1267 FE_CAN_QPSK | 1269 FE_CAN_QPSK |
1268 FE_CAN_RECOVER | 1270 FE_CAN_RECOVER |
1269 FE_CAN_2G_MODULATION 1271 FE_CAN_2G_MODULATION
1270 }, 1272 },
1271 1273
1272 .release = tda10071_release, 1274 .release = tda10071_release,
1273 1275
1274 .get_tune_settings = tda10071_get_tune_settings, 1276 .get_tune_settings = tda10071_get_tune_settings,
1275 1277
1276 .init = tda10071_init, 1278 .init = tda10071_init,
1277 .sleep = tda10071_sleep, 1279 .sleep = tda10071_sleep,
1278 1280
1279 .set_frontend = tda10071_set_frontend, 1281 .set_frontend = tda10071_set_frontend,
1280 .get_frontend = tda10071_get_frontend, 1282 .get_frontend = tda10071_get_frontend,
1281 1283
1282 .read_status = tda10071_read_status, 1284 .read_status = tda10071_read_status,
1283 .read_snr = tda10071_read_snr, 1285 .read_snr = tda10071_read_snr,
1284 .read_signal_strength = tda10071_read_signal_strength, 1286 .read_signal_strength = tda10071_read_signal_strength,
1285 .read_ber = tda10071_read_ber, 1287 .read_ber = tda10071_read_ber,
1286 .read_ucblocks = tda10071_read_ucblocks, 1288 .read_ucblocks = tda10071_read_ucblocks,
1287 1289
1288 .diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd, 1290 .diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd,
1289 .diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply, 1291 .diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply,
1290 .diseqc_send_burst = tda10071_diseqc_send_burst, 1292 .diseqc_send_burst = tda10071_diseqc_send_burst,
1291 1293
1292 .set_tone = tda10071_set_tone, 1294 .set_tone = tda10071_set_tone,
1293 .set_voltage = tda10071_set_voltage, 1295 .set_voltage = tda10071_set_voltage,
1294 }; 1296 };
1295 1297
1296 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1298 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1297 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver"); 1299 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver");
1298 MODULE_LICENSE("GPL"); 1300 MODULE_LICENSE("GPL");
1299 MODULE_FIRMWARE(TDA10071_FIRMWARE); 1301 MODULE_FIRMWARE(TDA10071_FIRMWARE);
1300 1302