aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/dvb-frontends/af9033.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/dvb-frontends/af9033.c')
-rw-r--r--drivers/media/dvb-frontends/af9033.c757
1 files changed, 425 insertions, 332 deletions
diff --git a/drivers/media/dvb-frontends/af9033.c b/drivers/media/dvb-frontends/af9033.c
index 5c90ea683a7e..63a89c1c59ff 100644
--- a/drivers/media/dvb-frontends/af9033.c
+++ b/drivers/media/dvb-frontends/af9033.c
@@ -24,29 +24,35 @@
24/* Max transfer size done by I2C transfer functions */ 24/* Max transfer size done by I2C transfer functions */
25#define MAX_XFER_SIZE 64 25#define MAX_XFER_SIZE 64
26 26
27struct af9033_state { 27struct af9033_dev {
28 struct i2c_adapter *i2c; 28 struct i2c_client *client;
29 struct dvb_frontend fe; 29 struct dvb_frontend fe;
30 struct af9033_config cfg; 30 struct af9033_config cfg;
31 bool is_af9035;
32 bool is_it9135;
31 33
32 u32 bandwidth_hz; 34 u32 bandwidth_hz;
33 bool ts_mode_parallel; 35 bool ts_mode_parallel;
34 bool ts_mode_serial; 36 bool ts_mode_serial;
35 37
36 u32 ber; 38 fe_status_t fe_status;
37 u32 ucb; 39 u64 post_bit_error_prev; /* for old read_ber we return (curr - prev) */
38 unsigned long last_stat_check; 40 u64 post_bit_error;
41 u64 post_bit_count;
42 u64 error_block_count;
43 u64 total_block_count;
44 struct delayed_work stat_work;
39}; 45};
40 46
41/* write multiple registers */ 47/* write multiple registers */
42static int af9033_wr_regs(struct af9033_state *state, u32 reg, const u8 *val, 48static int af9033_wr_regs(struct af9033_dev *dev, u32 reg, const u8 *val,
43 int len) 49 int len)
44{ 50{
45 int ret; 51 int ret;
46 u8 buf[MAX_XFER_SIZE]; 52 u8 buf[MAX_XFER_SIZE];
47 struct i2c_msg msg[1] = { 53 struct i2c_msg msg[1] = {
48 { 54 {
49 .addr = state->cfg.i2c_addr, 55 .addr = dev->client->addr,
50 .flags = 0, 56 .flags = 0,
51 .len = 3 + len, 57 .len = 3 + len,
52 .buf = buf, 58 .buf = buf,
@@ -54,9 +60,9 @@ static int af9033_wr_regs(struct af9033_state *state, u32 reg, const u8 *val,
54 }; 60 };
55 61
56 if (3 + len > sizeof(buf)) { 62 if (3 + len > sizeof(buf)) {
57 dev_warn(&state->i2c->dev, 63 dev_warn(&dev->client->dev,
58 "%s: i2c wr reg=%04x: len=%d is too big!\n", 64 "i2c wr reg=%04x: len=%d is too big!\n",
59 KBUILD_MODNAME, reg, len); 65 reg, len);
60 return -EINVAL; 66 return -EINVAL;
61 } 67 }
62 68
@@ -65,12 +71,12 @@ static int af9033_wr_regs(struct af9033_state *state, u32 reg, const u8 *val,
65 buf[2] = (reg >> 0) & 0xff; 71 buf[2] = (reg >> 0) & 0xff;
66 memcpy(&buf[3], val, len); 72 memcpy(&buf[3], val, len);
67 73
68 ret = i2c_transfer(state->i2c, msg, 1); 74 ret = i2c_transfer(dev->client->adapter, msg, 1);
69 if (ret == 1) { 75 if (ret == 1) {
70 ret = 0; 76 ret = 0;
71 } else { 77 } else {
72 dev_warn(&state->i2c->dev, "%s: i2c wr failed=%d reg=%06x " \ 78 dev_warn(&dev->client->dev, "i2c wr failed=%d reg=%06x len=%d\n",
73 "len=%d\n", KBUILD_MODNAME, ret, reg, len); 79 ret, reg, len);
74 ret = -EREMOTEIO; 80 ret = -EREMOTEIO;
75 } 81 }
76 82
@@ -78,31 +84,31 @@ static int af9033_wr_regs(struct af9033_state *state, u32 reg, const u8 *val,
78} 84}
79 85
80/* read multiple registers */ 86/* read multiple registers */
81static int af9033_rd_regs(struct af9033_state *state, u32 reg, u8 *val, int len) 87static int af9033_rd_regs(struct af9033_dev *dev, u32 reg, u8 *val, int len)
82{ 88{
83 int ret; 89 int ret;
84 u8 buf[3] = { (reg >> 16) & 0xff, (reg >> 8) & 0xff, 90 u8 buf[3] = { (reg >> 16) & 0xff, (reg >> 8) & 0xff,
85 (reg >> 0) & 0xff }; 91 (reg >> 0) & 0xff };
86 struct i2c_msg msg[2] = { 92 struct i2c_msg msg[2] = {
87 { 93 {
88 .addr = state->cfg.i2c_addr, 94 .addr = dev->client->addr,
89 .flags = 0, 95 .flags = 0,
90 .len = sizeof(buf), 96 .len = sizeof(buf),
91 .buf = buf 97 .buf = buf
92 }, { 98 }, {
93 .addr = state->cfg.i2c_addr, 99 .addr = dev->client->addr,
94 .flags = I2C_M_RD, 100 .flags = I2C_M_RD,
95 .len = len, 101 .len = len,
96 .buf = val 102 .buf = val
97 } 103 }
98 }; 104 };
99 105
100 ret = i2c_transfer(state->i2c, msg, 2); 106 ret = i2c_transfer(dev->client->adapter, msg, 2);
101 if (ret == 2) { 107 if (ret == 2) {
102 ret = 0; 108 ret = 0;
103 } else { 109 } else {
104 dev_warn(&state->i2c->dev, "%s: i2c rd failed=%d reg=%06x " \ 110 dev_warn(&dev->client->dev, "i2c rd failed=%d reg=%06x len=%d\n",
105 "len=%d\n", KBUILD_MODNAME, ret, reg, len); 111 ret, reg, len);
106 ret = -EREMOTEIO; 112 ret = -EREMOTEIO;
107 } 113 }
108 114
@@ -111,19 +117,19 @@ static int af9033_rd_regs(struct af9033_state *state, u32 reg, u8 *val, int len)
111 117
112 118
113/* write single register */ 119/* write single register */
114static int af9033_wr_reg(struct af9033_state *state, u32 reg, u8 val) 120static int af9033_wr_reg(struct af9033_dev *dev, u32 reg, u8 val)
115{ 121{
116 return af9033_wr_regs(state, reg, &val, 1); 122 return af9033_wr_regs(dev, reg, &val, 1);
117} 123}
118 124
119/* read single register */ 125/* read single register */
120static int af9033_rd_reg(struct af9033_state *state, u32 reg, u8 *val) 126static int af9033_rd_reg(struct af9033_dev *dev, u32 reg, u8 *val)
121{ 127{
122 return af9033_rd_regs(state, reg, val, 1); 128 return af9033_rd_regs(dev, reg, val, 1);
123} 129}
124 130
125/* write single register with mask */ 131/* write single register with mask */
126static int af9033_wr_reg_mask(struct af9033_state *state, u32 reg, u8 val, 132static int af9033_wr_reg_mask(struct af9033_dev *dev, u32 reg, u8 val,
127 u8 mask) 133 u8 mask)
128{ 134{
129 int ret; 135 int ret;
@@ -131,7 +137,7 @@ static int af9033_wr_reg_mask(struct af9033_state *state, u32 reg, u8 val,
131 137
132 /* no need for read if whole reg is written */ 138 /* no need for read if whole reg is written */
133 if (mask != 0xff) { 139 if (mask != 0xff) {
134 ret = af9033_rd_regs(state, reg, &tmp, 1); 140 ret = af9033_rd_regs(dev, reg, &tmp, 1);
135 if (ret) 141 if (ret)
136 return ret; 142 return ret;
137 143
@@ -140,17 +146,17 @@ static int af9033_wr_reg_mask(struct af9033_state *state, u32 reg, u8 val,
140 val |= tmp; 146 val |= tmp;
141 } 147 }
142 148
143 return af9033_wr_regs(state, reg, &val, 1); 149 return af9033_wr_regs(dev, reg, &val, 1);
144} 150}
145 151
146/* read single register with mask */ 152/* read single register with mask */
147static int af9033_rd_reg_mask(struct af9033_state *state, u32 reg, u8 *val, 153static int af9033_rd_reg_mask(struct af9033_dev *dev, u32 reg, u8 *val,
148 u8 mask) 154 u8 mask)
149{ 155{
150 int ret, i; 156 int ret, i;
151 u8 tmp; 157 u8 tmp;
152 158
153 ret = af9033_rd_regs(state, reg, &tmp, 1); 159 ret = af9033_rd_regs(dev, reg, &tmp, 1);
154 if (ret) 160 if (ret)
155 return ret; 161 return ret;
156 162
@@ -167,18 +173,17 @@ static int af9033_rd_reg_mask(struct af9033_state *state, u32 reg, u8 *val,
167} 173}
168 174
169/* write reg val table using reg addr auto increment */ 175/* write reg val table using reg addr auto increment */
170static int af9033_wr_reg_val_tab(struct af9033_state *state, 176static int af9033_wr_reg_val_tab(struct af9033_dev *dev,
171 const struct reg_val *tab, int tab_len) 177 const struct reg_val *tab, int tab_len)
172{ 178{
173#define MAX_TAB_LEN 212 179#define MAX_TAB_LEN 212
174 int ret, i, j; 180 int ret, i, j;
175 u8 buf[1 + MAX_TAB_LEN]; 181 u8 buf[1 + MAX_TAB_LEN];
176 182
177 dev_dbg(&state->i2c->dev, "%s: tab_len=%d\n", __func__, tab_len); 183 dev_dbg(&dev->client->dev, "tab_len=%d\n", tab_len);
178 184
179 if (tab_len > sizeof(buf)) { 185 if (tab_len > sizeof(buf)) {
180 dev_warn(&state->i2c->dev, "%s: tab len %d is too big\n", 186 dev_warn(&dev->client->dev, "tab len %d is too big\n", tab_len);
181 KBUILD_MODNAME, tab_len);
182 return -EINVAL; 187 return -EINVAL;
183 } 188 }
184 189
@@ -186,7 +191,7 @@ static int af9033_wr_reg_val_tab(struct af9033_state *state,
186 buf[j] = tab[i].val; 191 buf[j] = tab[i].val;
187 192
188 if (i == tab_len - 1 || tab[i].reg != tab[i + 1].reg - 1) { 193 if (i == tab_len - 1 || tab[i].reg != tab[i + 1].reg - 1) {
189 ret = af9033_wr_regs(state, tab[i].reg - j, buf, j + 1); 194 ret = af9033_wr_regs(dev, tab[i].reg - j, buf, j + 1);
190 if (ret < 0) 195 if (ret < 0)
191 goto err; 196 goto err;
192 197
@@ -199,16 +204,16 @@ static int af9033_wr_reg_val_tab(struct af9033_state *state,
199 return 0; 204 return 0;
200 205
201err: 206err:
202 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 207 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
203 208
204 return ret; 209 return ret;
205} 210}
206 211
207static u32 af9033_div(struct af9033_state *state, u32 a, u32 b, u32 x) 212static u32 af9033_div(struct af9033_dev *dev, u32 a, u32 b, u32 x)
208{ 213{
209 u32 r = 0, c = 0, i; 214 u32 r = 0, c = 0, i;
210 215
211 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d\n", __func__, a, b, x); 216 dev_dbg(&dev->client->dev, "a=%d b=%d x=%d\n", a, b, x);
212 217
213 if (a > b) { 218 if (a > b) {
214 c = a / b; 219 c = a / b;
@@ -225,22 +230,15 @@ static u32 af9033_div(struct af9033_state *state, u32 a, u32 b, u32 x)
225 } 230 }
226 r = (c << (u32)x) + r; 231 r = (c << (u32)x) + r;
227 232
228 dev_dbg(&state->i2c->dev, "%s: a=%d b=%d x=%d r=%d r=%x\n", 233 dev_dbg(&dev->client->dev, "a=%d b=%d x=%d r=%d r=%x\n", a, b, x, r, r);
229 __func__, a, b, x, r, r);
230 234
231 return r; 235 return r;
232} 236}
233 237
234static void af9033_release(struct dvb_frontend *fe)
235{
236 struct af9033_state *state = fe->demodulator_priv;
237
238 kfree(state);
239}
240
241static int af9033_init(struct dvb_frontend *fe) 238static int af9033_init(struct dvb_frontend *fe)
242{ 239{
243 struct af9033_state *state = fe->demodulator_priv; 240 struct af9033_dev *dev = fe->demodulator_priv;
241 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
244 int ret, i, len; 242 int ret, i, len;
245 const struct reg_val *init; 243 const struct reg_val *init;
246 u8 buf[4]; 244 u8 buf[4];
@@ -248,7 +246,7 @@ static int af9033_init(struct dvb_frontend *fe)
248 struct reg_val_mask tab[] = { 246 struct reg_val_mask tab[] = {
249 { 0x80fb24, 0x00, 0x08 }, 247 { 0x80fb24, 0x00, 0x08 },
250 { 0x80004c, 0x00, 0xff }, 248 { 0x80004c, 0x00, 0xff },
251 { 0x00f641, state->cfg.tuner, 0xff }, 249 { 0x00f641, dev->cfg.tuner, 0xff },
252 { 0x80f5ca, 0x01, 0x01 }, 250 { 0x80f5ca, 0x01, 0x01 },
253 { 0x80f715, 0x01, 0x01 }, 251 { 0x80f715, 0x01, 0x01 },
254 { 0x00f41f, 0x04, 0x04 }, 252 { 0x00f41f, 0x04, 0x04 },
@@ -267,88 +265,82 @@ static int af9033_init(struct dvb_frontend *fe)
267 { 0x00d830, 0x01, 0xff }, 265 { 0x00d830, 0x01, 0xff },
268 { 0x00d831, 0x00, 0xff }, 266 { 0x00d831, 0x00, 0xff },
269 { 0x00d832, 0x00, 0xff }, 267 { 0x00d832, 0x00, 0xff },
270 { 0x80f985, state->ts_mode_serial, 0x01 }, 268 { 0x80f985, dev->ts_mode_serial, 0x01 },
271 { 0x80f986, state->ts_mode_parallel, 0x01 }, 269 { 0x80f986, dev->ts_mode_parallel, 0x01 },
272 { 0x00d827, 0x00, 0xff }, 270 { 0x00d827, 0x00, 0xff },
273 { 0x00d829, 0x00, 0xff }, 271 { 0x00d829, 0x00, 0xff },
274 { 0x800045, state->cfg.adc_multiplier, 0xff }, 272 { 0x800045, dev->cfg.adc_multiplier, 0xff },
275 }; 273 };
276 274
277 /* program clock control */ 275 /* program clock control */
278 clock_cw = af9033_div(state, state->cfg.clock, 1000000ul, 19ul); 276 clock_cw = af9033_div(dev, dev->cfg.clock, 1000000ul, 19ul);
279 buf[0] = (clock_cw >> 0) & 0xff; 277 buf[0] = (clock_cw >> 0) & 0xff;
280 buf[1] = (clock_cw >> 8) & 0xff; 278 buf[1] = (clock_cw >> 8) & 0xff;
281 buf[2] = (clock_cw >> 16) & 0xff; 279 buf[2] = (clock_cw >> 16) & 0xff;
282 buf[3] = (clock_cw >> 24) & 0xff; 280 buf[3] = (clock_cw >> 24) & 0xff;
283 281
284 dev_dbg(&state->i2c->dev, "%s: clock=%d clock_cw=%08x\n", 282 dev_dbg(&dev->client->dev, "clock=%d clock_cw=%08x\n",
285 __func__, state->cfg.clock, clock_cw); 283 dev->cfg.clock, clock_cw);
286 284
287 ret = af9033_wr_regs(state, 0x800025, buf, 4); 285 ret = af9033_wr_regs(dev, 0x800025, buf, 4);
288 if (ret < 0) 286 if (ret < 0)
289 goto err; 287 goto err;
290 288
291 /* program ADC control */ 289 /* program ADC control */
292 for (i = 0; i < ARRAY_SIZE(clock_adc_lut); i++) { 290 for (i = 0; i < ARRAY_SIZE(clock_adc_lut); i++) {
293 if (clock_adc_lut[i].clock == state->cfg.clock) 291 if (clock_adc_lut[i].clock == dev->cfg.clock)
294 break; 292 break;
295 } 293 }
296 294
297 adc_cw = af9033_div(state, clock_adc_lut[i].adc, 1000000ul, 19ul); 295 adc_cw = af9033_div(dev, clock_adc_lut[i].adc, 1000000ul, 19ul);
298 buf[0] = (adc_cw >> 0) & 0xff; 296 buf[0] = (adc_cw >> 0) & 0xff;
299 buf[1] = (adc_cw >> 8) & 0xff; 297 buf[1] = (adc_cw >> 8) & 0xff;
300 buf[2] = (adc_cw >> 16) & 0xff; 298 buf[2] = (adc_cw >> 16) & 0xff;
301 299
302 dev_dbg(&state->i2c->dev, "%s: adc=%d adc_cw=%06x\n", 300 dev_dbg(&dev->client->dev, "adc=%d adc_cw=%06x\n",
303 __func__, clock_adc_lut[i].adc, adc_cw); 301 clock_adc_lut[i].adc, adc_cw);
304 302
305 ret = af9033_wr_regs(state, 0x80f1cd, buf, 3); 303 ret = af9033_wr_regs(dev, 0x80f1cd, buf, 3);
306 if (ret < 0) 304 if (ret < 0)
307 goto err; 305 goto err;
308 306
309 /* program register table */ 307 /* program register table */
310 for (i = 0; i < ARRAY_SIZE(tab); i++) { 308 for (i = 0; i < ARRAY_SIZE(tab); i++) {
311 ret = af9033_wr_reg_mask(state, tab[i].reg, tab[i].val, 309 ret = af9033_wr_reg_mask(dev, tab[i].reg, tab[i].val,
312 tab[i].mask); 310 tab[i].mask);
313 if (ret < 0) 311 if (ret < 0)
314 goto err; 312 goto err;
315 } 313 }
316 314
317 /* feed clock to RF tuner */ 315 /* clock output */
318 switch (state->cfg.tuner) { 316 if (dev->cfg.dyn0_clk) {
319 case AF9033_TUNER_IT9135_38: 317 ret = af9033_wr_reg(dev, 0x80fba8, 0x00);
320 case AF9033_TUNER_IT9135_51:
321 case AF9033_TUNER_IT9135_52:
322 case AF9033_TUNER_IT9135_60:
323 case AF9033_TUNER_IT9135_61:
324 case AF9033_TUNER_IT9135_62:
325 ret = af9033_wr_reg(state, 0x80fba8, 0x00);
326 if (ret < 0) 318 if (ret < 0)
327 goto err; 319 goto err;
328 } 320 }
329 321
330 /* settings for TS interface */ 322 /* settings for TS interface */
331 if (state->cfg.ts_mode == AF9033_TS_MODE_USB) { 323 if (dev->cfg.ts_mode == AF9033_TS_MODE_USB) {
332 ret = af9033_wr_reg_mask(state, 0x80f9a5, 0x00, 0x01); 324 ret = af9033_wr_reg_mask(dev, 0x80f9a5, 0x00, 0x01);
333 if (ret < 0) 325 if (ret < 0)
334 goto err; 326 goto err;
335 327
336 ret = af9033_wr_reg_mask(state, 0x80f9b5, 0x01, 0x01); 328 ret = af9033_wr_reg_mask(dev, 0x80f9b5, 0x01, 0x01);
337 if (ret < 0) 329 if (ret < 0)
338 goto err; 330 goto err;
339 } else { 331 } else {
340 ret = af9033_wr_reg_mask(state, 0x80f990, 0x00, 0x01); 332 ret = af9033_wr_reg_mask(dev, 0x80f990, 0x00, 0x01);
341 if (ret < 0) 333 if (ret < 0)
342 goto err; 334 goto err;
343 335
344 ret = af9033_wr_reg_mask(state, 0x80f9b5, 0x00, 0x01); 336 ret = af9033_wr_reg_mask(dev, 0x80f9b5, 0x00, 0x01);
345 if (ret < 0) 337 if (ret < 0)
346 goto err; 338 goto err;
347 } 339 }
348 340
349 /* load OFSM settings */ 341 /* load OFSM settings */
350 dev_dbg(&state->i2c->dev, "%s: load ofsm settings\n", __func__); 342 dev_dbg(&dev->client->dev, "load ofsm settings\n");
351 switch (state->cfg.tuner) { 343 switch (dev->cfg.tuner) {
352 case AF9033_TUNER_IT9135_38: 344 case AF9033_TUNER_IT9135_38:
353 case AF9033_TUNER_IT9135_51: 345 case AF9033_TUNER_IT9135_51:
354 case AF9033_TUNER_IT9135_52: 346 case AF9033_TUNER_IT9135_52:
@@ -367,14 +359,13 @@ static int af9033_init(struct dvb_frontend *fe)
367 break; 359 break;
368 } 360 }
369 361
370 ret = af9033_wr_reg_val_tab(state, init, len); 362 ret = af9033_wr_reg_val_tab(dev, init, len);
371 if (ret < 0) 363 if (ret < 0)
372 goto err; 364 goto err;
373 365
374 /* load tuner specific settings */ 366 /* load tuner specific settings */
375 dev_dbg(&state->i2c->dev, "%s: load tuner specific settings\n", 367 dev_dbg(&dev->client->dev, "load tuner specific settings\n");
376 __func__); 368 switch (dev->cfg.tuner) {
377 switch (state->cfg.tuner) {
378 case AF9033_TUNER_TUA9001: 369 case AF9033_TUNER_TUA9001:
379 len = ARRAY_SIZE(tuner_init_tua9001); 370 len = ARRAY_SIZE(tuner_init_tua9001);
380 init = tuner_init_tua9001; 371 init = tuner_init_tua9001;
@@ -424,90 +415,108 @@ static int af9033_init(struct dvb_frontend *fe)
424 init = tuner_init_it9135_62; 415 init = tuner_init_it9135_62;
425 break; 416 break;
426 default: 417 default:
427 dev_dbg(&state->i2c->dev, "%s: unsupported tuner ID=%d\n", 418 dev_dbg(&dev->client->dev, "unsupported tuner ID=%d\n",
428 __func__, state->cfg.tuner); 419 dev->cfg.tuner);
429 ret = -ENODEV; 420 ret = -ENODEV;
430 goto err; 421 goto err;
431 } 422 }
432 423
433 ret = af9033_wr_reg_val_tab(state, init, len); 424 ret = af9033_wr_reg_val_tab(dev, init, len);
434 if (ret < 0) 425 if (ret < 0)
435 goto err; 426 goto err;
436 427
437 if (state->cfg.ts_mode == AF9033_TS_MODE_SERIAL) { 428 if (dev->cfg.ts_mode == AF9033_TS_MODE_SERIAL) {
438 ret = af9033_wr_reg_mask(state, 0x00d91c, 0x01, 0x01); 429 ret = af9033_wr_reg_mask(dev, 0x00d91c, 0x01, 0x01);
439 if (ret < 0) 430 if (ret < 0)
440 goto err; 431 goto err;
441 432
442 ret = af9033_wr_reg_mask(state, 0x00d917, 0x00, 0x01); 433 ret = af9033_wr_reg_mask(dev, 0x00d917, 0x00, 0x01);
443 if (ret < 0) 434 if (ret < 0)
444 goto err; 435 goto err;
445 436
446 ret = af9033_wr_reg_mask(state, 0x00d916, 0x00, 0x01); 437 ret = af9033_wr_reg_mask(dev, 0x00d916, 0x00, 0x01);
447 if (ret < 0) 438 if (ret < 0)
448 goto err; 439 goto err;
449 } 440 }
450 441
451 switch (state->cfg.tuner) { 442 switch (dev->cfg.tuner) {
452 case AF9033_TUNER_IT9135_60: 443 case AF9033_TUNER_IT9135_60:
453 case AF9033_TUNER_IT9135_61: 444 case AF9033_TUNER_IT9135_61:
454 case AF9033_TUNER_IT9135_62: 445 case AF9033_TUNER_IT9135_62:
455 ret = af9033_wr_reg(state, 0x800000, 0x01); 446 ret = af9033_wr_reg(dev, 0x800000, 0x01);
456 if (ret < 0) 447 if (ret < 0)
457 goto err; 448 goto err;
458 } 449 }
459 450
460 state->bandwidth_hz = 0; /* force to program all parameters */ 451 dev->bandwidth_hz = 0; /* force to program all parameters */
452 /* init stats here in order signal app which stats are supported */
453 c->strength.len = 1;
454 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
455 c->cnr.len = 1;
456 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
457 c->block_count.len = 1;
458 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
459 c->block_error.len = 1;
460 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
461 c->post_bit_count.len = 1;
462 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
463 c->post_bit_error.len = 1;
464 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
465 /* start statistics polling */
466 schedule_delayed_work(&dev->stat_work, msecs_to_jiffies(2000));
461 467
462 return 0; 468 return 0;
463 469
464err: 470err:
465 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 471 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
466 472
467 return ret; 473 return ret;
468} 474}
469 475
470static int af9033_sleep(struct dvb_frontend *fe) 476static int af9033_sleep(struct dvb_frontend *fe)
471{ 477{
472 struct af9033_state *state = fe->demodulator_priv; 478 struct af9033_dev *dev = fe->demodulator_priv;
473 int ret, i; 479 int ret, i;
474 u8 tmp; 480 u8 tmp;
475 481
476 ret = af9033_wr_reg(state, 0x80004c, 1); 482 /* stop statistics polling */
483 cancel_delayed_work_sync(&dev->stat_work);
484
485 ret = af9033_wr_reg(dev, 0x80004c, 1);
477 if (ret < 0) 486 if (ret < 0)
478 goto err; 487 goto err;
479 488
480 ret = af9033_wr_reg(state, 0x800000, 0); 489 ret = af9033_wr_reg(dev, 0x800000, 0);
481 if (ret < 0) 490 if (ret < 0)
482 goto err; 491 goto err;
483 492
484 for (i = 100, tmp = 1; i && tmp; i--) { 493 for (i = 100, tmp = 1; i && tmp; i--) {
485 ret = af9033_rd_reg(state, 0x80004c, &tmp); 494 ret = af9033_rd_reg(dev, 0x80004c, &tmp);
486 if (ret < 0) 495 if (ret < 0)
487 goto err; 496 goto err;
488 497
489 usleep_range(200, 10000); 498 usleep_range(200, 10000);
490 } 499 }
491 500
492 dev_dbg(&state->i2c->dev, "%s: loop=%d\n", __func__, i); 501 dev_dbg(&dev->client->dev, "loop=%d\n", i);
493 502
494 if (i == 0) { 503 if (i == 0) {
495 ret = -ETIMEDOUT; 504 ret = -ETIMEDOUT;
496 goto err; 505 goto err;
497 } 506 }
498 507
499 ret = af9033_wr_reg_mask(state, 0x80fb24, 0x08, 0x08); 508 ret = af9033_wr_reg_mask(dev, 0x80fb24, 0x08, 0x08);
500 if (ret < 0) 509 if (ret < 0)
501 goto err; 510 goto err;
502 511
503 /* prevent current leak (?) */ 512 /* prevent current leak (?) */
504 if (state->cfg.ts_mode == AF9033_TS_MODE_SERIAL) { 513 if (dev->cfg.ts_mode == AF9033_TS_MODE_SERIAL) {
505 /* enable parallel TS */ 514 /* enable parallel TS */
506 ret = af9033_wr_reg_mask(state, 0x00d917, 0x00, 0x01); 515 ret = af9033_wr_reg_mask(dev, 0x00d917, 0x00, 0x01);
507 if (ret < 0) 516 if (ret < 0)
508 goto err; 517 goto err;
509 518
510 ret = af9033_wr_reg_mask(state, 0x00d916, 0x01, 0x01); 519 ret = af9033_wr_reg_mask(dev, 0x00d916, 0x01, 0x01);
511 if (ret < 0) 520 if (ret < 0)
512 goto err; 521 goto err;
513 } 522 }
@@ -515,7 +524,7 @@ static int af9033_sleep(struct dvb_frontend *fe)
515 return 0; 524 return 0;
516 525
517err: 526err:
518 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 527 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
519 528
520 return ret; 529 return ret;
521} 530}
@@ -533,14 +542,14 @@ static int af9033_get_tune_settings(struct dvb_frontend *fe,
533 542
534static int af9033_set_frontend(struct dvb_frontend *fe) 543static int af9033_set_frontend(struct dvb_frontend *fe)
535{ 544{
536 struct af9033_state *state = fe->demodulator_priv; 545 struct af9033_dev *dev = fe->demodulator_priv;
537 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 546 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
538 int ret, i, spec_inv, sampling_freq; 547 int ret, i, spec_inv, sampling_freq;
539 u8 tmp, buf[3], bandwidth_reg_val; 548 u8 tmp, buf[3], bandwidth_reg_val;
540 u32 if_frequency, freq_cw, adc_freq; 549 u32 if_frequency, freq_cw, adc_freq;
541 550
542 dev_dbg(&state->i2c->dev, "%s: frequency=%d bandwidth_hz=%d\n", 551 dev_dbg(&dev->client->dev, "frequency=%d bandwidth_hz=%d\n",
543 __func__, c->frequency, c->bandwidth_hz); 552 c->frequency, c->bandwidth_hz);
544 553
545 /* check bandwidth */ 554 /* check bandwidth */
546 switch (c->bandwidth_hz) { 555 switch (c->bandwidth_hz) {
@@ -554,8 +563,7 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
554 bandwidth_reg_val = 0x02; 563 bandwidth_reg_val = 0x02;
555 break; 564 break;
556 default: 565 default:
557 dev_dbg(&state->i2c->dev, "%s: invalid bandwidth_hz\n", 566 dev_dbg(&dev->client->dev, "invalid bandwidth_hz\n");
558 __func__);
559 ret = -EINVAL; 567 ret = -EINVAL;
560 goto err; 568 goto err;
561 } 569 }
@@ -565,23 +573,23 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
565 fe->ops.tuner_ops.set_params(fe); 573 fe->ops.tuner_ops.set_params(fe);
566 574
567 /* program CFOE coefficients */ 575 /* program CFOE coefficients */
568 if (c->bandwidth_hz != state->bandwidth_hz) { 576 if (c->bandwidth_hz != dev->bandwidth_hz) {
569 for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) { 577 for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) {
570 if (coeff_lut[i].clock == state->cfg.clock && 578 if (coeff_lut[i].clock == dev->cfg.clock &&
571 coeff_lut[i].bandwidth_hz == c->bandwidth_hz) { 579 coeff_lut[i].bandwidth_hz == c->bandwidth_hz) {
572 break; 580 break;
573 } 581 }
574 } 582 }
575 ret = af9033_wr_regs(state, 0x800001, 583 ret = af9033_wr_regs(dev, 0x800001,
576 coeff_lut[i].val, sizeof(coeff_lut[i].val)); 584 coeff_lut[i].val, sizeof(coeff_lut[i].val));
577 } 585 }
578 586
579 /* program frequency control */ 587 /* program frequency control */
580 if (c->bandwidth_hz != state->bandwidth_hz) { 588 if (c->bandwidth_hz != dev->bandwidth_hz) {
581 spec_inv = state->cfg.spec_inv ? -1 : 1; 589 spec_inv = dev->cfg.spec_inv ? -1 : 1;
582 590
583 for (i = 0; i < ARRAY_SIZE(clock_adc_lut); i++) { 591 for (i = 0; i < ARRAY_SIZE(clock_adc_lut); i++) {
584 if (clock_adc_lut[i].clock == state->cfg.clock) 592 if (clock_adc_lut[i].clock == dev->cfg.clock)
585 break; 593 break;
586 } 594 }
587 adc_freq = clock_adc_lut[i].adc; 595 adc_freq = clock_adc_lut[i].adc;
@@ -602,12 +610,12 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
602 else 610 else
603 sampling_freq *= -1; 611 sampling_freq *= -1;
604 612
605 freq_cw = af9033_div(state, sampling_freq, adc_freq, 23ul); 613 freq_cw = af9033_div(dev, sampling_freq, adc_freq, 23ul);
606 614
607 if (spec_inv == -1) 615 if (spec_inv == -1)
608 freq_cw = 0x800000 - freq_cw; 616 freq_cw = 0x800000 - freq_cw;
609 617
610 if (state->cfg.adc_multiplier == AF9033_ADC_MULTIPLIER_2X) 618 if (dev->cfg.adc_multiplier == AF9033_ADC_MULTIPLIER_2X)
611 freq_cw /= 2; 619 freq_cw /= 2;
612 620
613 buf[0] = (freq_cw >> 0) & 0xff; 621 buf[0] = (freq_cw >> 0) & 0xff;
@@ -618,26 +626,26 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
618 if (if_frequency == 0) 626 if (if_frequency == 0)
619 buf[2] = 0; 627 buf[2] = 0;
620 628
621 ret = af9033_wr_regs(state, 0x800029, buf, 3); 629 ret = af9033_wr_regs(dev, 0x800029, buf, 3);
622 if (ret < 0) 630 if (ret < 0)
623 goto err; 631 goto err;
624 632
625 state->bandwidth_hz = c->bandwidth_hz; 633 dev->bandwidth_hz = c->bandwidth_hz;
626 } 634 }
627 635
628 ret = af9033_wr_reg_mask(state, 0x80f904, bandwidth_reg_val, 0x03); 636 ret = af9033_wr_reg_mask(dev, 0x80f904, bandwidth_reg_val, 0x03);
629 if (ret < 0) 637 if (ret < 0)
630 goto err; 638 goto err;
631 639
632 ret = af9033_wr_reg(state, 0x800040, 0x00); 640 ret = af9033_wr_reg(dev, 0x800040, 0x00);
633 if (ret < 0) 641 if (ret < 0)
634 goto err; 642 goto err;
635 643
636 ret = af9033_wr_reg(state, 0x800047, 0x00); 644 ret = af9033_wr_reg(dev, 0x800047, 0x00);
637 if (ret < 0) 645 if (ret < 0)
638 goto err; 646 goto err;
639 647
640 ret = af9033_wr_reg_mask(state, 0x80f999, 0x00, 0x01); 648 ret = af9033_wr_reg_mask(dev, 0x80f999, 0x00, 0x01);
641 if (ret < 0) 649 if (ret < 0)
642 goto err; 650 goto err;
643 651
@@ -646,33 +654,33 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
646 else 654 else
647 tmp = 0x01; /* UHF */ 655 tmp = 0x01; /* UHF */
648 656
649 ret = af9033_wr_reg(state, 0x80004b, tmp); 657 ret = af9033_wr_reg(dev, 0x80004b, tmp);
650 if (ret < 0) 658 if (ret < 0)
651 goto err; 659 goto err;
652 660
653 ret = af9033_wr_reg(state, 0x800000, 0x00); 661 ret = af9033_wr_reg(dev, 0x800000, 0x00);
654 if (ret < 0) 662 if (ret < 0)
655 goto err; 663 goto err;
656 664
657 return 0; 665 return 0;
658 666
659err: 667err:
660 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 668 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
661 669
662 return ret; 670 return ret;
663} 671}
664 672
665static int af9033_get_frontend(struct dvb_frontend *fe) 673static int af9033_get_frontend(struct dvb_frontend *fe)
666{ 674{
667 struct af9033_state *state = fe->demodulator_priv; 675 struct af9033_dev *dev = fe->demodulator_priv;
668 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 676 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
669 int ret; 677 int ret;
670 u8 buf[8]; 678 u8 buf[8];
671 679
672 dev_dbg(&state->i2c->dev, "%s:\n", __func__); 680 dev_dbg(&dev->client->dev, "\n");
673 681
674 /* read all needed registers */ 682 /* read all needed registers */
675 ret = af9033_rd_regs(state, 0x80f900, buf, sizeof(buf)); 683 ret = af9033_rd_regs(dev, 0x80f900, buf, sizeof(buf));
676 if (ret < 0) 684 if (ret < 0)
677 goto err; 685 goto err;
678 686
@@ -784,21 +792,21 @@ static int af9033_get_frontend(struct dvb_frontend *fe)
784 return 0; 792 return 0;
785 793
786err: 794err:
787 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 795 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
788 796
789 return ret; 797 return ret;
790} 798}
791 799
792static int af9033_read_status(struct dvb_frontend *fe, fe_status_t *status) 800static int af9033_read_status(struct dvb_frontend *fe, fe_status_t *status)
793{ 801{
794 struct af9033_state *state = fe->demodulator_priv; 802 struct af9033_dev *dev = fe->demodulator_priv;
795 int ret; 803 int ret;
796 u8 tmp; 804 u8 tmp;
797 805
798 *status = 0; 806 *status = 0;
799 807
800 /* radio channel status, 0=no result, 1=has signal, 2=no signal */ 808 /* radio channel status, 0=no result, 1=has signal, 2=no signal */
801 ret = af9033_rd_reg(state, 0x800047, &tmp); 809 ret = af9033_rd_reg(dev, 0x800047, &tmp);
802 if (ret < 0) 810 if (ret < 0)
803 goto err; 811 goto err;
804 812
@@ -808,7 +816,7 @@ static int af9033_read_status(struct dvb_frontend *fe, fe_status_t *status)
808 816
809 if (tmp != 0x02) { 817 if (tmp != 0x02) {
810 /* TPS lock */ 818 /* TPS lock */
811 ret = af9033_rd_reg_mask(state, 0x80f5a9, &tmp, 0x01); 819 ret = af9033_rd_reg_mask(dev, 0x80f5a9, &tmp, 0x01);
812 if (ret < 0) 820 if (ret < 0)
813 goto err; 821 goto err;
814 822
@@ -817,7 +825,7 @@ static int af9033_read_status(struct dvb_frontend *fe, fe_status_t *status)
817 FE_HAS_VITERBI; 825 FE_HAS_VITERBI;
818 826
819 /* full lock */ 827 /* full lock */
820 ret = af9033_rd_reg_mask(state, 0x80f999, &tmp, 0x01); 828 ret = af9033_rd_reg_mask(dev, 0x80f999, &tmp, 0x01);
821 if (ret < 0) 829 if (ret < 0)
822 goto err; 830 goto err;
823 831
@@ -827,76 +835,38 @@ static int af9033_read_status(struct dvb_frontend *fe, fe_status_t *status)
827 FE_HAS_LOCK; 835 FE_HAS_LOCK;
828 } 836 }
829 837
838 dev->fe_status = *status;
839
830 return 0; 840 return 0;
831 841
832err: 842err:
833 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 843 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
834 844
835 return ret; 845 return ret;
836} 846}
837 847
838static int af9033_read_snr(struct dvb_frontend *fe, u16 *snr) 848static int af9033_read_snr(struct dvb_frontend *fe, u16 *snr)
839{ 849{
840 struct af9033_state *state = fe->demodulator_priv; 850 struct af9033_dev *dev = fe->demodulator_priv;
841 int ret, i, len; 851 struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
842 u8 buf[3], tmp;
843 u32 snr_val;
844 const struct val_snr *uninitialized_var(snr_lut);
845
846 /* read value */
847 ret = af9033_rd_regs(state, 0x80002c, buf, 3);
848 if (ret < 0)
849 goto err;
850 852
851 snr_val = (buf[2] << 16) | (buf[1] << 8) | buf[0]; 853 /* use DVBv5 CNR */
852 854 if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
853 /* read current modulation */ 855 *snr = div_s64(c->cnr.stat[0].svalue, 100); /* 1000x => 10x */
854 ret = af9033_rd_reg(state, 0x80f903, &tmp); 856 else
855 if (ret < 0) 857 *snr = 0;
856 goto err;
857
858 switch ((tmp >> 0) & 3) {
859 case 0:
860 len = ARRAY_SIZE(qpsk_snr_lut);
861 snr_lut = qpsk_snr_lut;
862 break;
863 case 1:
864 len = ARRAY_SIZE(qam16_snr_lut);
865 snr_lut = qam16_snr_lut;
866 break;
867 case 2:
868 len = ARRAY_SIZE(qam64_snr_lut);
869 snr_lut = qam64_snr_lut;
870 break;
871 default:
872 goto err;
873 }
874
875 for (i = 0; i < len; i++) {
876 tmp = snr_lut[i].snr;
877
878 if (snr_val < snr_lut[i].val)
879 break;
880 }
881
882 *snr = tmp * 10; /* dB/10 */
883 858
884 return 0; 859 return 0;
885
886err:
887 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
888
889 return ret;
890} 860}
891 861
892static int af9033_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 862static int af9033_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
893{ 863{
894 struct af9033_state *state = fe->demodulator_priv; 864 struct af9033_dev *dev = fe->demodulator_priv;
895 int ret; 865 int ret;
896 u8 strength2; 866 u8 strength2;
897 867
898 /* read signal strength of 0-100 scale */ 868 /* read signal strength of 0-100 scale */
899 ret = af9033_rd_reg(state, 0x800048, &strength2); 869 ret = af9033_rd_reg(dev, 0x800048, &strength2);
900 if (ret < 0) 870 if (ret < 0)
901 goto err; 871 goto err;
902 872
@@ -906,244 +876,225 @@ static int af9033_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
906 return 0; 876 return 0;
907 877
908err: 878err:
909 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 879 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
910
911 return ret;
912}
913
914static int af9033_update_ch_stat(struct af9033_state *state)
915{
916 int ret = 0;
917 u32 err_cnt, bit_cnt;
918 u16 abort_cnt;
919 u8 buf[7];
920
921 /* only update data every half second */
922 if (time_after(jiffies, state->last_stat_check + msecs_to_jiffies(500))) {
923 ret = af9033_rd_regs(state, 0x800032, buf, sizeof(buf));
924 if (ret < 0)
925 goto err;
926 /* in 8 byte packets? */
927 abort_cnt = (buf[1] << 8) + buf[0];
928 /* in bits */
929 err_cnt = (buf[4] << 16) + (buf[3] << 8) + buf[2];
930 /* in 8 byte packets? always(?) 0x2710 = 10000 */
931 bit_cnt = (buf[6] << 8) + buf[5];
932
933 if (bit_cnt < abort_cnt) {
934 abort_cnt = 1000;
935 state->ber = 0xffffffff;
936 } else {
937 /* 8 byte packets, that have not been rejected already */
938 bit_cnt -= (u32)abort_cnt;
939 if (bit_cnt == 0) {
940 state->ber = 0xffffffff;
941 } else {
942 err_cnt -= (u32)abort_cnt * 8 * 8;
943 bit_cnt *= 8 * 8;
944 state->ber = err_cnt * (0xffffffff / bit_cnt);
945 }
946 }
947 state->ucb += abort_cnt;
948 state->last_stat_check = jiffies;
949 }
950
951 return 0;
952err:
953 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret);
954 880
955 return ret; 881 return ret;
956} 882}
957 883
958static int af9033_read_ber(struct dvb_frontend *fe, u32 *ber) 884static int af9033_read_ber(struct dvb_frontend *fe, u32 *ber)
959{ 885{
960 struct af9033_state *state = fe->demodulator_priv; 886 struct af9033_dev *dev = fe->demodulator_priv;
961 int ret;
962
963 ret = af9033_update_ch_stat(state);
964 if (ret < 0)
965 return ret;
966 887
967 *ber = state->ber; 888 *ber = (dev->post_bit_error - dev->post_bit_error_prev);
889 dev->post_bit_error_prev = dev->post_bit_error;
968 890
969 return 0; 891 return 0;
970} 892}
971 893
972static int af9033_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 894static int af9033_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
973{ 895{
974 struct af9033_state *state = fe->demodulator_priv; 896 struct af9033_dev *dev = fe->demodulator_priv;
975 int ret;
976
977 ret = af9033_update_ch_stat(state);
978 if (ret < 0)
979 return ret;
980
981 *ucblocks = state->ucb;
982 897
898 *ucblocks = dev->error_block_count;
983 return 0; 899 return 0;
984} 900}
985 901
986static int af9033_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 902static int af9033_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
987{ 903{
988 struct af9033_state *state = fe->demodulator_priv; 904 struct af9033_dev *dev = fe->demodulator_priv;
989 int ret; 905 int ret;
990 906
991 dev_dbg(&state->i2c->dev, "%s: enable=%d\n", __func__, enable); 907 dev_dbg(&dev->client->dev, "enable=%d\n", enable);
992 908
993 ret = af9033_wr_reg_mask(state, 0x00fa04, enable, 0x01); 909 ret = af9033_wr_reg_mask(dev, 0x00fa04, enable, 0x01);
994 if (ret < 0) 910 if (ret < 0)
995 goto err; 911 goto err;
996 912
997 return 0; 913 return 0;
998 914
999err: 915err:
1000 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 916 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
1001 917
1002 return ret; 918 return ret;
1003} 919}
1004 920
1005static int af9033_pid_filter_ctrl(struct dvb_frontend *fe, int onoff) 921static int af9033_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
1006{ 922{
1007 struct af9033_state *state = fe->demodulator_priv; 923 struct af9033_dev *dev = fe->demodulator_priv;
1008 int ret; 924 int ret;
1009 925
1010 dev_dbg(&state->i2c->dev, "%s: onoff=%d\n", __func__, onoff); 926 dev_dbg(&dev->client->dev, "onoff=%d\n", onoff);
1011 927
1012 ret = af9033_wr_reg_mask(state, 0x80f993, onoff, 0x01); 928 ret = af9033_wr_reg_mask(dev, 0x80f993, onoff, 0x01);
1013 if (ret < 0) 929 if (ret < 0)
1014 goto err; 930 goto err;
1015 931
1016 return 0; 932 return 0;
1017 933
1018err: 934err:
1019 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 935 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
1020 936
1021 return ret; 937 return ret;
1022} 938}
1023 939
1024static int af9033_pid_filter(struct dvb_frontend *fe, int index, u16 pid, int onoff) 940static int af9033_pid_filter(struct dvb_frontend *fe, int index, u16 pid,
941 int onoff)
1025{ 942{
1026 struct af9033_state *state = fe->demodulator_priv; 943 struct af9033_dev *dev = fe->demodulator_priv;
1027 int ret; 944 int ret;
1028 u8 wbuf[2] = {(pid >> 0) & 0xff, (pid >> 8) & 0xff}; 945 u8 wbuf[2] = {(pid >> 0) & 0xff, (pid >> 8) & 0xff};
1029 946
1030 dev_dbg(&state->i2c->dev, "%s: index=%d pid=%04x onoff=%d\n", 947 dev_dbg(&dev->client->dev, "index=%d pid=%04x onoff=%d\n",
1031 __func__, index, pid, onoff); 948 index, pid, onoff);
1032 949
1033 if (pid > 0x1fff) 950 if (pid > 0x1fff)
1034 return 0; 951 return 0;
1035 952
1036 ret = af9033_wr_regs(state, 0x80f996, wbuf, 2); 953 ret = af9033_wr_regs(dev, 0x80f996, wbuf, 2);
1037 if (ret < 0) 954 if (ret < 0)
1038 goto err; 955 goto err;
1039 956
1040 ret = af9033_wr_reg(state, 0x80f994, onoff); 957 ret = af9033_wr_reg(dev, 0x80f994, onoff);
1041 if (ret < 0) 958 if (ret < 0)
1042 goto err; 959 goto err;
1043 960
1044 ret = af9033_wr_reg(state, 0x80f995, index); 961 ret = af9033_wr_reg(dev, 0x80f995, index);
1045 if (ret < 0) 962 if (ret < 0)
1046 goto err; 963 goto err;
1047 964
1048 return 0; 965 return 0;
1049 966
1050err: 967err:
1051 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 968 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
1052 969
1053 return ret; 970 return ret;
1054} 971}
1055 972
1056static struct dvb_frontend_ops af9033_ops; 973static void af9033_stat_work(struct work_struct *work)
1057
1058struct dvb_frontend *af9033_attach(const struct af9033_config *config,
1059 struct i2c_adapter *i2c,
1060 struct af9033_ops *ops)
1061{ 974{
1062 int ret; 975 struct af9033_dev *dev = container_of(work, struct af9033_dev, stat_work.work);
1063 struct af9033_state *state; 976 struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
1064 u8 buf[8]; 977 int ret, tmp, i, len;
978 u8 u8tmp, buf[7];
979
980 dev_dbg(&dev->client->dev, "\n");
981
982 /* signal strength */
983 if (dev->fe_status & FE_HAS_SIGNAL) {
984 if (dev->is_af9035) {
985 ret = af9033_rd_reg(dev, 0x80004a, &u8tmp);
986 tmp = -u8tmp * 1000;
987 } else {
988 ret = af9033_rd_reg(dev, 0x8000f7, &u8tmp);
989 tmp = (u8tmp - 100) * 1000;
990 }
991 if (ret)
992 goto err;
1065 993
1066 dev_dbg(&i2c->dev, "%s:\n", __func__); 994 c->strength.len = 1;
995 c->strength.stat[0].scale = FE_SCALE_DECIBEL;
996 c->strength.stat[0].svalue = tmp;
997 } else {
998 c->strength.len = 1;
999 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1000 }
1067 1001
1068 /* allocate memory for the internal state */ 1002 /* CNR */
1069 state = kzalloc(sizeof(struct af9033_state), GFP_KERNEL); 1003 if (dev->fe_status & FE_HAS_VITERBI) {
1070 if (state == NULL) 1004 u32 snr_val;
1071 goto err; 1005 const struct val_snr *snr_lut;
1072 1006
1073 /* setup the state */ 1007 /* read value */
1074 state->i2c = i2c; 1008 ret = af9033_rd_regs(dev, 0x80002c, buf, 3);
1075 memcpy(&state->cfg, config, sizeof(struct af9033_config)); 1009 if (ret)
1010 goto err;
1076 1011
1077 if (state->cfg.clock != 12000000) { 1012 snr_val = (buf[2] << 16) | (buf[1] << 8) | (buf[0] << 0);
1078 dev_err(&state->i2c->dev, "%s: af9033: unsupported clock=%d, " \
1079 "only 12000000 Hz is supported currently\n",
1080 KBUILD_MODNAME, state->cfg.clock);
1081 goto err;
1082 }
1083 1013
1084 /* firmware version */ 1014 /* read current modulation */
1085 ret = af9033_rd_regs(state, 0x0083e9, &buf[0], 4); 1015 ret = af9033_rd_reg(dev, 0x80f903, &u8tmp);
1086 if (ret < 0) 1016 if (ret)
1087 goto err; 1017 goto err;
1088 1018
1089 ret = af9033_rd_regs(state, 0x804191, &buf[4], 4); 1019 switch ((u8tmp >> 0) & 3) {
1090 if (ret < 0) 1020 case 0:
1091 goto err; 1021 len = ARRAY_SIZE(qpsk_snr_lut);
1022 snr_lut = qpsk_snr_lut;
1023 break;
1024 case 1:
1025 len = ARRAY_SIZE(qam16_snr_lut);
1026 snr_lut = qam16_snr_lut;
1027 break;
1028 case 2:
1029 len = ARRAY_SIZE(qam64_snr_lut);
1030 snr_lut = qam64_snr_lut;
1031 break;
1032 default:
1033 goto err_schedule_delayed_work;
1034 }
1092 1035
1093 dev_info(&state->i2c->dev, "%s: firmware version: LINK=%d.%d.%d.%d " \ 1036 for (i = 0; i < len; i++) {
1094 "OFDM=%d.%d.%d.%d\n", KBUILD_MODNAME, buf[0], buf[1], 1037 tmp = snr_lut[i].snr * 1000;
1095 buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]); 1038 if (snr_val < snr_lut[i].val)
1039 break;
1040 }
1096 1041
1097 /* sleep */ 1042 c->cnr.len = 1;
1098 switch (state->cfg.tuner) { 1043 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
1099 case AF9033_TUNER_IT9135_38: 1044 c->cnr.stat[0].svalue = tmp;
1100 case AF9033_TUNER_IT9135_51: 1045 } else {
1101 case AF9033_TUNER_IT9135_52: 1046 c->cnr.len = 1;
1102 case AF9033_TUNER_IT9135_60: 1047 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1103 case AF9033_TUNER_IT9135_61: 1048 }
1104 case AF9033_TUNER_IT9135_62:
1105 /* IT9135 did not like to sleep at that early */
1106 break;
1107 default:
1108 ret = af9033_wr_reg(state, 0x80004c, 1);
1109 if (ret < 0)
1110 goto err;
1111 1049
1112 ret = af9033_wr_reg(state, 0x800000, 0); 1050 /* UCB/PER/BER */
1113 if (ret < 0) 1051 if (dev->fe_status & FE_HAS_LOCK) {
1052 /* outer FEC, 204 byte packets */
1053 u16 abort_packet_count, rsd_packet_count;
1054 /* inner FEC, bits */
1055 u32 rsd_bit_err_count;
1056
1057 /*
1058 * Packet count used for measurement is 10000
1059 * (rsd_packet_count). Maybe it should be increased?
1060 */
1061
1062 ret = af9033_rd_regs(dev, 0x800032, buf, 7);
1063 if (ret)
1114 goto err; 1064 goto err;
1115 }
1116 1065
1117 /* configure internal TS mode */ 1066 abort_packet_count = (buf[1] << 8) | (buf[0] << 0);
1118 switch (state->cfg.ts_mode) { 1067 rsd_bit_err_count = (buf[4] << 16) | (buf[3] << 8) | buf[2];
1119 case AF9033_TS_MODE_PARALLEL: 1068 rsd_packet_count = (buf[6] << 8) | (buf[5] << 0);
1120 state->ts_mode_parallel = true;
1121 break;
1122 case AF9033_TS_MODE_SERIAL:
1123 state->ts_mode_serial = true;
1124 break;
1125 case AF9033_TS_MODE_USB:
1126 /* usb mode for AF9035 */
1127 default:
1128 break;
1129 }
1130 1069
1131 /* create dvb_frontend */ 1070 dev->error_block_count += abort_packet_count;
1132 memcpy(&state->fe.ops, &af9033_ops, sizeof(struct dvb_frontend_ops)); 1071 dev->total_block_count += rsd_packet_count;
1133 state->fe.demodulator_priv = state; 1072 dev->post_bit_error += rsd_bit_err_count;
1073 dev->post_bit_count += rsd_packet_count * 204 * 8;
1134 1074
1135 if (ops) { 1075 c->block_count.len = 1;
1136 ops->pid_filter = af9033_pid_filter; 1076 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1137 ops->pid_filter_ctrl = af9033_pid_filter_ctrl; 1077 c->block_count.stat[0].uvalue = dev->total_block_count;
1138 } 1078
1079 c->block_error.len = 1;
1080 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1081 c->block_error.stat[0].uvalue = dev->error_block_count;
1082
1083 c->post_bit_count.len = 1;
1084 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
1085 c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
1139 1086
1140 return &state->fe; 1087 c->post_bit_error.len = 1;
1088 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
1089 c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
1090 }
1141 1091
1092err_schedule_delayed_work:
1093 schedule_delayed_work(&dev->stat_work, msecs_to_jiffies(2000));
1094 return;
1142err: 1095err:
1143 kfree(state); 1096 dev_dbg(&dev->client->dev, "failed=%d\n", ret);
1144 return NULL;
1145} 1097}
1146EXPORT_SYMBOL(af9033_attach);
1147 1098
1148static struct dvb_frontend_ops af9033_ops = { 1099static struct dvb_frontend_ops af9033_ops = {
1149 .delsys = { SYS_DVBT }, 1100 .delsys = { SYS_DVBT },
@@ -1170,8 +1121,6 @@ static struct dvb_frontend_ops af9033_ops = {
1170 FE_CAN_MUTE_TS 1121 FE_CAN_MUTE_TS
1171 }, 1122 },
1172 1123
1173 .release = af9033_release,
1174
1175 .init = af9033_init, 1124 .init = af9033_init,
1176 .sleep = af9033_sleep, 1125 .sleep = af9033_sleep,
1177 1126
@@ -1188,6 +1137,150 @@ static struct dvb_frontend_ops af9033_ops = {
1188 .i2c_gate_ctrl = af9033_i2c_gate_ctrl, 1137 .i2c_gate_ctrl = af9033_i2c_gate_ctrl,
1189}; 1138};
1190 1139
1140static int af9033_probe(struct i2c_client *client,
1141 const struct i2c_device_id *id)
1142{
1143 struct af9033_config *cfg = client->dev.platform_data;
1144 struct af9033_dev *dev;
1145 int ret;
1146 u8 buf[8];
1147 u32 reg;
1148
1149 /* allocate memory for the internal state */
1150 dev = kzalloc(sizeof(struct af9033_dev), GFP_KERNEL);
1151 if (dev == NULL) {
1152 ret = -ENOMEM;
1153 dev_err(&client->dev, "Could not allocate memory for state\n");
1154 goto err;
1155 }
1156
1157 /* setup the state */
1158 dev->client = client;
1159 INIT_DELAYED_WORK(&dev->stat_work, af9033_stat_work);
1160 memcpy(&dev->cfg, cfg, sizeof(struct af9033_config));
1161
1162 if (dev->cfg.clock != 12000000) {
1163 ret = -ENODEV;
1164 dev_err(&dev->client->dev,
1165 "unsupported clock %d Hz, only 12000000 Hz is supported currently\n",
1166 dev->cfg.clock);
1167 goto err_kfree;
1168 }
1169
1170 /* firmware version */
1171 switch (dev->cfg.tuner) {
1172 case AF9033_TUNER_IT9135_38:
1173 case AF9033_TUNER_IT9135_51:
1174 case AF9033_TUNER_IT9135_52:
1175 case AF9033_TUNER_IT9135_60:
1176 case AF9033_TUNER_IT9135_61:
1177 case AF9033_TUNER_IT9135_62:
1178 dev->is_it9135 = true;
1179 reg = 0x004bfc;
1180 break;
1181 default:
1182 dev->is_af9035 = true;
1183 reg = 0x0083e9;
1184 break;
1185 }
1186
1187 ret = af9033_rd_regs(dev, reg, &buf[0], 4);
1188 if (ret < 0)
1189 goto err_kfree;
1190
1191 ret = af9033_rd_regs(dev, 0x804191, &buf[4], 4);
1192 if (ret < 0)
1193 goto err_kfree;
1194
1195 dev_info(&dev->client->dev,
1196 "firmware version: LINK %d.%d.%d.%d - OFDM %d.%d.%d.%d\n",
1197 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6],
1198 buf[7]);
1199
1200 /* sleep */
1201 switch (dev->cfg.tuner) {
1202 case AF9033_TUNER_IT9135_38:
1203 case AF9033_TUNER_IT9135_51:
1204 case AF9033_TUNER_IT9135_52:
1205 case AF9033_TUNER_IT9135_60:
1206 case AF9033_TUNER_IT9135_61:
1207 case AF9033_TUNER_IT9135_62:
1208 /* IT9135 did not like to sleep at that early */
1209 break;
1210 default:
1211 ret = af9033_wr_reg(dev, 0x80004c, 1);
1212 if (ret < 0)
1213 goto err_kfree;
1214
1215 ret = af9033_wr_reg(dev, 0x800000, 0);
1216 if (ret < 0)
1217 goto err_kfree;
1218 }
1219
1220 /* configure internal TS mode */
1221 switch (dev->cfg.ts_mode) {
1222 case AF9033_TS_MODE_PARALLEL:
1223 dev->ts_mode_parallel = true;
1224 break;
1225 case AF9033_TS_MODE_SERIAL:
1226 dev->ts_mode_serial = true;
1227 break;
1228 case AF9033_TS_MODE_USB:
1229 /* usb mode for AF9035 */
1230 default:
1231 break;
1232 }
1233
1234 /* create dvb_frontend */
1235 memcpy(&dev->fe.ops, &af9033_ops, sizeof(struct dvb_frontend_ops));
1236 dev->fe.demodulator_priv = dev;
1237 *cfg->fe = &dev->fe;
1238 if (cfg->ops) {
1239 cfg->ops->pid_filter = af9033_pid_filter;
1240 cfg->ops->pid_filter_ctrl = af9033_pid_filter_ctrl;
1241 }
1242 i2c_set_clientdata(client, dev);
1243
1244 dev_info(&dev->client->dev, "Afatech AF9033 successfully attached\n");
1245 return 0;
1246err_kfree:
1247 kfree(dev);
1248err:
1249 dev_dbg(&client->dev, "failed=%d\n", ret);
1250 return ret;
1251}
1252
1253static int af9033_remove(struct i2c_client *client)
1254{
1255 struct af9033_dev *dev = i2c_get_clientdata(client);
1256
1257 dev_dbg(&dev->client->dev, "\n");
1258
1259 dev->fe.ops.release = NULL;
1260 dev->fe.demodulator_priv = NULL;
1261 kfree(dev);
1262
1263 return 0;
1264}
1265
1266static const struct i2c_device_id af9033_id_table[] = {
1267 {"af9033", 0},
1268 {}
1269};
1270MODULE_DEVICE_TABLE(i2c, af9033_id_table);
1271
1272static struct i2c_driver af9033_driver = {
1273 .driver = {
1274 .owner = THIS_MODULE,
1275 .name = "af9033",
1276 },
1277 .probe = af9033_probe,
1278 .remove = af9033_remove,
1279 .id_table = af9033_id_table,
1280};
1281
1282module_i2c_driver(af9033_driver);
1283
1191MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1284MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1192MODULE_DESCRIPTION("Afatech AF9033 DVB-T demodulator driver"); 1285MODULE_DESCRIPTION("Afatech AF9033 DVB-T demodulator driver");
1193MODULE_LICENSE("GPL"); 1286MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-26 06:31:43 -0400