?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.16.11
[linux/fpc-iii.git] / drivers / media / dvb-frontends / rtl2830.c
blob7bbfe11d11edd8a6f7ee3d91170f8432096a4453
1 /*
2 * Realtek RTL2830 DVB-T demodulator driver
3 *
4 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18 #include "rtl2830_priv.h"
19
20 /* Our regmap is bypassing I2C adapter lock, thus we do it! */
21 static int rtl2830_bulk_write(struct i2c_client *client, unsigned int reg,
22 const void *val, size_t val_count)
23 {
24 struct rtl2830_dev *dev = i2c_get_clientdata(client);
25 int ret;
26
27 i2c_lock_adapter(client->adapter);
28 ret = regmap_bulk_write(dev->regmap, reg, val, val_count);
29 i2c_unlock_adapter(client->adapter);
30 return ret;
31 }
32
33 static int rtl2830_update_bits(struct i2c_client *client, unsigned int reg,
34 unsigned int mask, unsigned int val)
35 {
36 struct rtl2830_dev *dev = i2c_get_clientdata(client);
37 int ret;
38
39 i2c_lock_adapter(client->adapter);
40 ret = regmap_update_bits(dev->regmap, reg, mask, val);
41 i2c_unlock_adapter(client->adapter);
42 return ret;
43 }
44
45 static int rtl2830_bulk_read(struct i2c_client *client, unsigned int reg,
46 void *val, size_t val_count)
47 {
48 struct rtl2830_dev *dev = i2c_get_clientdata(client);
49 int ret;
50
51 i2c_lock_adapter(client->adapter);
52 ret = regmap_bulk_read(dev->regmap, reg, val, val_count);
53 i2c_unlock_adapter(client->adapter);
54 return ret;
55 }
56
57 static int rtl2830_init(struct dvb_frontend *fe)
58 {
59 struct i2c_client *client = fe->demodulator_priv;
60 struct rtl2830_dev *dev = i2c_get_clientdata(client);
61 struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
62 int ret, i;
63 struct rtl2830_reg_val_mask tab[] = {
64 {0x00d, 0x01, 0x03},
65 {0x00d, 0x10, 0x10},
66 {0x104, 0x00, 0x1e},
67 {0x105, 0x80, 0x80},
68 {0x110, 0x02, 0x03},
69 {0x110, 0x08, 0x0c},
70 {0x17b, 0x00, 0x40},
71 {0x17d, 0x05, 0x0f},
72 {0x17d, 0x50, 0xf0},
73 {0x18c, 0x08, 0x0f},
74 {0x18d, 0x00, 0xc0},
75 {0x188, 0x05, 0x0f},
76 {0x189, 0x00, 0xfc},
77 {0x2d5, 0x02, 0x02},
78 {0x2f1, 0x02, 0x06},
79 {0x2f1, 0x20, 0xf8},
80 {0x16d, 0x00, 0x01},
81 {0x1a6, 0x00, 0x80},
82 {0x106, dev->pdata->vtop, 0x3f},
83 {0x107, dev->pdata->krf, 0x3f},
84 {0x112, 0x28, 0xff},
85 {0x103, dev->pdata->agc_targ_val, 0xff},
86 {0x00a, 0x02, 0x07},
87 {0x140, 0x0c, 0x3c},
88 {0x140, 0x40, 0xc0},
89 {0x15b, 0x05, 0x07},
90 {0x15b, 0x28, 0x38},
91 {0x15c, 0x05, 0x07},
92 {0x15c, 0x28, 0x38},
93 {0x115, dev->pdata->spec_inv, 0x01},
94 {0x16f, 0x01, 0x07},
95 {0x170, 0x18, 0x38},
96 {0x172, 0x0f, 0x0f},
97 {0x173, 0x08, 0x38},
98 {0x175, 0x01, 0x07},
99 {0x176, 0x00, 0xc0},
100 };
101
102 for (i = 0; i < ARRAY_SIZE(tab); i++) {
103 ret = rtl2830_update_bits(client, tab[i].reg, tab[i].mask,
104 tab[i].val);
105 if (ret)
106 goto err;
107 }
108
109 ret = rtl2830_bulk_write(client, 0x18f, "\x28\x00", 2);
110 if (ret)
111 goto err;
112
113 ret = rtl2830_bulk_write(client, 0x195,
114 "\x04\x06\x0a\x12\x0a\x12\x1e\x28", 8);
115 if (ret)
116 goto err;
117
118 /* TODO: spec init */
119
120 /* soft reset */
121 ret = rtl2830_update_bits(client, 0x101, 0x04, 0x04);
122 if (ret)
123 goto err;
124
125 ret = rtl2830_update_bits(client, 0x101, 0x04, 0x00);
126 if (ret)
127 goto err;
128
129 /* init stats here in order signal app which stats are supported */
130 c->strength.len = 1;
131 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
132 c->cnr.len = 1;
133 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
134 c->post_bit_error.len = 1;
135 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
136 c->post_bit_count.len = 1;
137 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
138
139 dev->sleeping = false;
140
141 return ret;
142 err:
143 dev_dbg(&client->dev, "failed=%d\n", ret);
144 return ret;
145 }
146
147 static int rtl2830_sleep(struct dvb_frontend *fe)
148 {
149 struct i2c_client *client = fe->demodulator_priv;
150 struct rtl2830_dev *dev = i2c_get_clientdata(client);
151
152 dev->sleeping = true;
153 dev->fe_status = 0;
154
155 return 0;
156 }
157
158 static int rtl2830_get_tune_settings(struct dvb_frontend *fe,
159 struct dvb_frontend_tune_settings *s)
160 {
161 s->min_delay_ms = 500;
162 s->step_size = fe->ops.info.frequency_stepsize * 2;
163 s->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
164
165 return 0;
166 }
167
168 static int rtl2830_set_frontend(struct dvb_frontend *fe)
169 {
170 struct i2c_client *client = fe->demodulator_priv;
171 struct rtl2830_dev *dev = i2c_get_clientdata(client);
172 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
173 int ret, i;
174 u64 num;
175 u8 buf[3], u8tmp;
176 u32 if_ctl, if_frequency;
177 static const u8 bw_params1[3][34] = {
178 {
179 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xfa, 0x00, 0x17, 0x00, 0x41,
180 0x00, 0x64, 0x00, 0x67, 0x00, 0x38, 0x1f, 0xde, 0x1f, 0x7a,
181 0x1f, 0x47, 0x1f, 0x7c, 0x00, 0x30, 0x01, 0x4b, 0x02, 0x82,
182 0x03, 0x73, 0x03, 0xcf, /* 6 MHz */
183 }, {
184 0x1f, 0xfa, 0x1f, 0xda, 0x1f, 0xc1, 0x1f, 0xb3, 0x1f, 0xca,
185 0x00, 0x07, 0x00, 0x4d, 0x00, 0x6d, 0x00, 0x40, 0x1f, 0xca,
186 0x1f, 0x4d, 0x1f, 0x2a, 0x1f, 0xb2, 0x00, 0xec, 0x02, 0x7e,
187 0x03, 0xd0, 0x04, 0x53, /* 7 MHz */
188 }, {
189 0x00, 0x10, 0x00, 0x0e, 0x1f, 0xf7, 0x1f, 0xc9, 0x1f, 0xa0,
190 0x1f, 0xa6, 0x1f, 0xec, 0x00, 0x4e, 0x00, 0x7d, 0x00, 0x3a,
191 0x1f, 0x98, 0x1f, 0x10, 0x1f, 0x40, 0x00, 0x75, 0x02, 0x5f,
192 0x04, 0x24, 0x04, 0xdb, /* 8 MHz */
193 },
194 };
195 static const u8 bw_params2[3][6] = {
196 {0xc3, 0x0c, 0x44, 0x33, 0x33, 0x30}, /* 6 MHz */
197 {0xb8, 0xe3, 0x93, 0x99, 0x99, 0x98}, /* 7 MHz */
198 {0xae, 0xba, 0xf3, 0x26, 0x66, 0x64}, /* 8 MHz */
199 };
200
201 dev_dbg(&client->dev, "frequency=%u bandwidth_hz=%u inversion=%u\n",
202 c->frequency, c->bandwidth_hz, c->inversion);
203
204 /* program tuner */
205 if (fe->ops.tuner_ops.set_params)
206 fe->ops.tuner_ops.set_params(fe);
207
208 switch (c->bandwidth_hz) {
209 case 6000000:
210 i = 0;
211 break;
212 case 7000000:
213 i = 1;
214 break;
215 case 8000000:
216 i = 2;
217 break;
218 default:
219 dev_err(&client->dev, "invalid bandwidth_hz %u\n",
220 c->bandwidth_hz);
221 return -EINVAL;
222 }
223
224 ret = rtl2830_update_bits(client, 0x008, 0x06, i << 1);
225 if (ret)
226 goto err;
227
228 /* program if frequency */
229 if (fe->ops.tuner_ops.get_if_frequency)
230 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
231 else
232 ret = -EINVAL;
233 if (ret)
234 goto err;
235
236 num = if_frequency % dev->pdata->clk;
237 num *= 0x400000;
238 num = div_u64(num, dev->pdata->clk);
239 num = -num;
240 if_ctl = num & 0x3fffff;
241 dev_dbg(&client->dev, "if_frequency=%d if_ctl=%08x\n",
242 if_frequency, if_ctl);
243
244 buf[0] = (if_ctl >> 16) & 0x3f;
245 buf[1] = (if_ctl >> 8) & 0xff;
246 buf[2] = (if_ctl >> 0) & 0xff;
247
248 ret = rtl2830_bulk_read(client, 0x119, &u8tmp, 1);
249 if (ret)
250 goto err;
251
252 buf[0] |= u8tmp & 0xc0; /* [7:6] */
253
254 ret = rtl2830_bulk_write(client, 0x119, buf, 3);
255 if (ret)
256 goto err;
257
258 /* 1/2 split I2C write */
259 ret = rtl2830_bulk_write(client, 0x11c, &bw_params1[i][0], 17);
260 if (ret)
261 goto err;
262
263 /* 2/2 split I2C write */
264 ret = rtl2830_bulk_write(client, 0x12d, &bw_params1[i][17], 17);
265 if (ret)
266 goto err;
267
268 ret = rtl2830_bulk_write(client, 0x19d, bw_params2[i], 6);
269 if (ret)
270 goto err;
271
272 return ret;
273 err:
274 dev_dbg(&client->dev, "failed=%d\n", ret);
275 return ret;
276 }
277
278 static int rtl2830_get_frontend(struct dvb_frontend *fe,
279 struct dtv_frontend_properties *c)
280 {
281 struct i2c_client *client = fe->demodulator_priv;
282 struct rtl2830_dev *dev = i2c_get_clientdata(client);
283 int ret;
284 u8 buf[3];
285
286 if (dev->sleeping)
287 return 0;
288
289 ret = rtl2830_bulk_read(client, 0x33c, buf, 2);
290 if (ret)
291 goto err;
292
293 ret = rtl2830_bulk_read(client, 0x351, &buf[2], 1);
294 if (ret)
295 goto err;
296
297 dev_dbg(&client->dev, "TPS=%*ph\n", 3, buf);
298
299 switch ((buf[0] >> 2) & 3) {
300 case 0:
301 c->modulation = QPSK;
302 break;
303 case 1:
304 c->modulation = QAM_16;
305 break;
306 case 2:
307 c->modulation = QAM_64;
308 break;
309 }
310
311 switch ((buf[2] >> 2) & 1) {
312 case 0:
313 c->transmission_mode = TRANSMISSION_MODE_2K;
314 break;
315 case 1:
316 c->transmission_mode = TRANSMISSION_MODE_8K;
317 }
318
319 switch ((buf[2] >> 0) & 3) {
320 case 0:
321 c->guard_interval = GUARD_INTERVAL_1_32;
322 break;
323 case 1:
324 c->guard_interval = GUARD_INTERVAL_1_16;
325 break;
326 case 2:
327 c->guard_interval = GUARD_INTERVAL_1_8;
328 break;
329 case 3:
330 c->guard_interval = GUARD_INTERVAL_1_4;
331 break;
332 }
333
334 switch ((buf[0] >> 4) & 7) {
335 case 0:
336 c->hierarchy = HIERARCHY_NONE;
337 break;
338 case 1:
339 c->hierarchy = HIERARCHY_1;
340 break;
341 case 2:
342 c->hierarchy = HIERARCHY_2;
343 break;
344 case 3:
345 c->hierarchy = HIERARCHY_4;
346 break;
347 }
348
349 switch ((buf[1] >> 3) & 7) {
350 case 0:
351 c->code_rate_HP = FEC_1_2;
352 break;
353 case 1:
354 c->code_rate_HP = FEC_2_3;
355 break;
356 case 2:
357 c->code_rate_HP = FEC_3_4;
358 break;
359 case 3:
360 c->code_rate_HP = FEC_5_6;
361 break;
362 case 4:
363 c->code_rate_HP = FEC_7_8;
364 break;
365 }
366
367 switch ((buf[1] >> 0) & 7) {
368 case 0:
369 c->code_rate_LP = FEC_1_2;
370 break;
371 case 1:
372 c->code_rate_LP = FEC_2_3;
373 break;
374 case 2:
375 c->code_rate_LP = FEC_3_4;
376 break;
377 case 3:
378 c->code_rate_LP = FEC_5_6;
379 break;
380 case 4:
381 c->code_rate_LP = FEC_7_8;
382 break;
383 }
384
385 return 0;
386 err:
387 dev_dbg(&client->dev, "failed=%d\n", ret);
388 return ret;
389 }
390
391 static int rtl2830_read_status(struct dvb_frontend *fe, enum fe_status *status)
392 {
393 struct i2c_client *client = fe->demodulator_priv;
394 struct rtl2830_dev *dev = i2c_get_clientdata(client);
395 struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
396 int ret, stmp;
397 unsigned int utmp;
398 u8 u8tmp, buf[2];
399
400 *status = 0;
401
402 if (dev->sleeping)
403 return 0;
404
405 ret = rtl2830_bulk_read(client, 0x351, &u8tmp, 1);
406 if (ret)
407 goto err;
408
409 u8tmp = (u8tmp >> 3) & 0x0f; /* [6:3] */
410 if (u8tmp == 11) {
411 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
412 FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
413 } else if (u8tmp == 10) {
414 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
415 FE_HAS_VITERBI;
416 }
417
418 dev->fe_status = *status;
419
420 /* Signal strength */
421 if (dev->fe_status & FE_HAS_SIGNAL) {
422 /* Read IF AGC */
423 ret = rtl2830_bulk_read(client, 0x359, buf, 2);
424 if (ret)
425 goto err;
426
427 stmp = buf[0] << 8 | buf[1] << 0;
428 stmp = sign_extend32(stmp, 13);
429 utmp = clamp_val(-4 * stmp + 32767, 0x0000, 0xffff);
430
431 dev_dbg(&client->dev, "IF AGC=%d\n", stmp);
432
433 c->strength.stat[0].scale = FE_SCALE_RELATIVE;
434 c->strength.stat[0].uvalue = utmp;
435 } else {
436 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
437 }
438
439 /* CNR */
440 if (dev->fe_status & FE_HAS_VITERBI) {
441 unsigned int hierarchy, constellation;
442 #define CONSTELLATION_NUM 3
443 #define HIERARCHY_NUM 4
444 static const u32 constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
445 {70705899, 70705899, 70705899, 70705899},
446 {82433173, 82433173, 87483115, 94445660},
447 {92888734, 92888734, 95487525, 99770748},
448 };
449
450 ret = rtl2830_bulk_read(client, 0x33c, &u8tmp, 1);
451 if (ret)
452 goto err;
453
454 constellation = (u8tmp >> 2) & 0x03; /* [3:2] */
455 if (constellation > CONSTELLATION_NUM - 1)
456 goto err;
457
458 hierarchy = (u8tmp >> 4) & 0x07; /* [6:4] */
459 if (hierarchy > HIERARCHY_NUM - 1)
460 goto err;
461
462 ret = rtl2830_bulk_read(client, 0x40c, buf, 2);
463 if (ret)
464 goto err;
465
466 utmp = buf[0] << 8 | buf[1] << 0;
467 if (utmp)
468 stmp = (constant[constellation][hierarchy] -
469 intlog10(utmp)) / ((1 << 24) / 10000);
470 else
471 stmp = 0;
472
473 dev_dbg(&client->dev, "CNR raw=%u\n", utmp);
474
475 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
476 c->cnr.stat[0].svalue = stmp;
477 } else {
478 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
479 }
480
481 /* BER */
482 if (dev->fe_status & FE_HAS_LOCK) {
483 ret = rtl2830_bulk_read(client, 0x34e, buf, 2);
484 if (ret)
485 goto err;
486
487 utmp = buf[0] << 8 | buf[1] << 0;
488 dev->post_bit_error += utmp;
489 dev->post_bit_count += 1000000;
490
491 dev_dbg(&client->dev, "BER errors=%u total=1000000\n", utmp);
492
493 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
494 c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
495 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
496 c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
497 } else {
498 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
499 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
500 }
501
502
503 return ret;
504 err:
505 dev_dbg(&client->dev, "failed=%d\n", ret);
506 return ret;
507 }
508
509 static int rtl2830_read_snr(struct dvb_frontend *fe, u16 *snr)
510 {
511 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
512
513 if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
514 *snr = div_s64(c->cnr.stat[0].svalue, 100);
515 else
516 *snr = 0;
517
518 return 0;
519 }
520
521 static int rtl2830_read_ber(struct dvb_frontend *fe, u32 *ber)
522 {
523 struct i2c_client *client = fe->demodulator_priv;
524 struct rtl2830_dev *dev = i2c_get_clientdata(client);
525
526 *ber = (dev->post_bit_error - dev->post_bit_error_prev);
527 dev->post_bit_error_prev = dev->post_bit_error;
528
529 return 0;
530 }
531
532 static int rtl2830_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
533 {
534 *ucblocks = 0;
535
536 return 0;
537 }
538
539 static int rtl2830_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
540 {
541 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
542
543 if (c->strength.stat[0].scale == FE_SCALE_RELATIVE)
544 *strength = c->strength.stat[0].uvalue;
545 else
546 *strength = 0;
547
548 return 0;
549 }
550
551 static const struct dvb_frontend_ops rtl2830_ops = {
552 .delsys = {SYS_DVBT},
553 .info = {
554 .name = "Realtek RTL2830 (DVB-T)",
555 .caps = FE_CAN_FEC_1_2 |
556 FE_CAN_FEC_2_3 |
557 FE_CAN_FEC_3_4 |
558 FE_CAN_FEC_5_6 |
559 FE_CAN_FEC_7_8 |
560 FE_CAN_FEC_AUTO |
561 FE_CAN_QPSK |
562 FE_CAN_QAM_16 |
563 FE_CAN_QAM_64 |
564 FE_CAN_QAM_AUTO |
565 FE_CAN_TRANSMISSION_MODE_AUTO |
566 FE_CAN_GUARD_INTERVAL_AUTO |
567 FE_CAN_HIERARCHY_AUTO |
568 FE_CAN_RECOVER |
569 FE_CAN_MUTE_TS
570 },
571
572 .init = rtl2830_init,
573 .sleep = rtl2830_sleep,
574
575 .get_tune_settings = rtl2830_get_tune_settings,
576
577 .set_frontend = rtl2830_set_frontend,
578 .get_frontend = rtl2830_get_frontend,
579
580 .read_status = rtl2830_read_status,
581 .read_snr = rtl2830_read_snr,
582 .read_ber = rtl2830_read_ber,
583 .read_ucblocks = rtl2830_read_ucblocks,
584 .read_signal_strength = rtl2830_read_signal_strength,
585 };
586
587 static int rtl2830_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
588 {
589 struct i2c_client *client = fe->demodulator_priv;
590 int ret;
591 u8 u8tmp;
592
593 dev_dbg(&client->dev, "onoff=%d\n", onoff);
594
595 /* enable / disable PID filter */
596 if (onoff)
597 u8tmp = 0x80;
598 else
599 u8tmp = 0x00;
600
601 ret = rtl2830_update_bits(client, 0x061, 0x80, u8tmp);
602 if (ret)
603 goto err;
604
605 return 0;
606 err:
607 dev_dbg(&client->dev, "failed=%d\n", ret);
608 return ret;
609 }
610
611 static int rtl2830_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid, int onoff)
612 {
613 struct i2c_client *client = fe->demodulator_priv;
614 struct rtl2830_dev *dev = i2c_get_clientdata(client);
615 int ret;
616 u8 buf[4];
617
618 dev_dbg(&client->dev, "index=%d pid=%04x onoff=%d\n",
619 index, pid, onoff);
620
621 /* skip invalid PIDs (0x2000) */
622 if (pid > 0x1fff || index > 32)
623 return 0;
624
625 if (onoff)
626 set_bit(index, &dev->filters);
627 else
628 clear_bit(index, &dev->filters);
629
630 /* enable / disable PIDs */
631 buf[0] = (dev->filters >> 0) & 0xff;
632 buf[1] = (dev->filters >> 8) & 0xff;
633 buf[2] = (dev->filters >> 16) & 0xff;
634 buf[3] = (dev->filters >> 24) & 0xff;
635 ret = rtl2830_bulk_write(client, 0x062, buf, 4);
636 if (ret)
637 goto err;
638
639 /* add PID */
640 buf[0] = (pid >> 8) & 0xff;
641 buf[1] = (pid >> 0) & 0xff;
642 ret = rtl2830_bulk_write(client, 0x066 + 2 * index, buf, 2);
643 if (ret)
644 goto err;
645
646 return 0;
647 err:
648 dev_dbg(&client->dev, "failed=%d\n", ret);
649 return ret;
650 }
651
652 /*
653 * I2C gate/mux/repeater logic
654 * We must use unlocked __i2c_transfer() here (through regmap) because of I2C
655 * adapter lock is already taken by tuner driver.
656 * Gate is closed automatically after single I2C transfer.
657 */
658 static int rtl2830_select(struct i2c_mux_core *muxc, u32 chan_id)
659 {
660 struct i2c_client *client = i2c_mux_priv(muxc);
661 struct rtl2830_dev *dev = i2c_get_clientdata(client);
662 int ret;
663
664 dev_dbg(&client->dev, "\n");
665
666 /* open I2C repeater for 1 transfer, closes automatically */
667 /* XXX: regmap_update_bits() does not lock I2C adapter */
668 ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x08);
669 if (ret)
670 goto err;
671
672 return 0;
673 err:
674 dev_dbg(&client->dev, "failed=%d\n", ret);
675 return ret;
676 }
677
678 static struct dvb_frontend *rtl2830_get_dvb_frontend(struct i2c_client *client)
679 {
680 struct rtl2830_dev *dev = i2c_get_clientdata(client);
681
682 dev_dbg(&client->dev, "\n");
683
684 return &dev->fe;
685 }
686
687 static struct i2c_adapter *rtl2830_get_i2c_adapter(struct i2c_client *client)
688 {
689 struct rtl2830_dev *dev = i2c_get_clientdata(client);
690
691 dev_dbg(&client->dev, "\n");
692
693 return dev->muxc->adapter[0];
694 }
695
696 /*
697 * We implement own I2C access routines for regmap in order to get manual access
698 * to I2C adapter lock, which is needed for I2C mux adapter.
699 */
700 static int rtl2830_regmap_read(void *context, const void *reg_buf,
701 size_t reg_size, void *val_buf, size_t val_size)
702 {
703 struct i2c_client *client = context;
704 int ret;
705 struct i2c_msg msg[2] = {
706 {
707 .addr = client->addr,
708 .flags = 0,
709 .len = reg_size,
710 .buf = (u8 *)reg_buf,
711 }, {
712 .addr = client->addr,
713 .flags = I2C_M_RD,
714 .len = val_size,
715 .buf = val_buf,
716 }
717 };
718
719 ret = __i2c_transfer(client->adapter, msg, 2);
720 if (ret != 2) {
721 dev_warn(&client->dev, "i2c reg read failed %d\n", ret);
722 if (ret >= 0)
723 ret = -EREMOTEIO;
724 return ret;
725 }
726 return 0;
727 }
728
729 static int rtl2830_regmap_write(void *context, const void *data, size_t count)
730 {
731 struct i2c_client *client = context;
732 int ret;
733 struct i2c_msg msg[1] = {
734 {
735 .addr = client->addr,
736 .flags = 0,
737 .len = count,
738 .buf = (u8 *)data,
739 }
740 };
741
742 ret = __i2c_transfer(client->adapter, msg, 1);
743 if (ret != 1) {
744 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
745 if (ret >= 0)
746 ret = -EREMOTEIO;
747 return ret;
748 }
749 return 0;
750 }
751
752 static int rtl2830_regmap_gather_write(void *context, const void *reg,
753 size_t reg_len, const void *val,
754 size_t val_len)
755 {
756 struct i2c_client *client = context;
757 int ret;
758 u8 buf[256];
759 struct i2c_msg msg[1] = {
760 {
761 .addr = client->addr,
762 .flags = 0,
763 .len = 1 + val_len,
764 .buf = buf,
765 }
766 };
767
768 buf[0] = *(u8 const *)reg;
769 memcpy(&buf[1], val, val_len);
770
771 ret = __i2c_transfer(client->adapter, msg, 1);
772 if (ret != 1) {
773 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
774 if (ret >= 0)
775 ret = -EREMOTEIO;
776 return ret;
777 }
778 return 0;
779 }
780
781 static int rtl2830_probe(struct i2c_client *client,
782 const struct i2c_device_id *id)
783 {
784 struct rtl2830_platform_data *pdata = client->dev.platform_data;
785 struct rtl2830_dev *dev;
786 int ret;
787 u8 u8tmp;
788 static const struct regmap_bus regmap_bus = {
789 .read = rtl2830_regmap_read,
790 .write = rtl2830_regmap_write,
791 .gather_write = rtl2830_regmap_gather_write,
792 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
793 };
794 static const struct regmap_range_cfg regmap_range_cfg[] = {
795 {
796 .selector_reg = 0x00,
797 .selector_mask = 0xff,
798 .selector_shift = 0,
799 .window_start = 0,
800 .window_len = 0x100,
801 .range_min = 0 * 0x100,
802 .range_max = 5 * 0x100,
803 },
804 };
805 static const struct regmap_config regmap_config = {
806 .reg_bits = 8,
807 .val_bits = 8,
808 .max_register = 5 * 0x100,
809 .ranges = regmap_range_cfg,
810 .num_ranges = ARRAY_SIZE(regmap_range_cfg),
811 };
812
813 dev_dbg(&client->dev, "\n");
814
815 if (pdata == NULL) {
816 ret = -EINVAL;
817 goto err;
818 }
819
820 /* allocate memory for the internal state */
821 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
822 if (dev == NULL) {
823 ret = -ENOMEM;
824 goto err;
825 }
826
827 /* setup the state */
828 i2c_set_clientdata(client, dev);
829 dev->client = client;
830 dev->pdata = client->dev.platform_data;
831 dev->sleeping = true;
832 dev->regmap = regmap_init(&client->dev, &regmap_bus, client,
833 &regmap_config);
834 if (IS_ERR(dev->regmap)) {
835 ret = PTR_ERR(dev->regmap);
836 goto err_kfree;
837 }
838
839 /* check if the demod is there */
840 ret = rtl2830_bulk_read(client, 0x000, &u8tmp, 1);
841 if (ret)
842 goto err_regmap_exit;
843
844 /* create muxed i2c adapter for tuner */
845 dev->muxc = i2c_mux_alloc(client->adapter, &client->dev, 1, 0, 0,
846 rtl2830_select, NULL);
847 if (!dev->muxc) {
848 ret = -ENOMEM;
849 goto err_regmap_exit;
850 }
851 dev->muxc->priv = client;
852 ret = i2c_mux_add_adapter(dev->muxc, 0, 0, 0);
853 if (ret)
854 goto err_regmap_exit;
855
856 /* create dvb frontend */
857 memcpy(&dev->fe.ops, &rtl2830_ops, sizeof(dev->fe.ops));
858 dev->fe.demodulator_priv = client;
859
860 /* setup callbacks */
861 pdata->get_dvb_frontend = rtl2830_get_dvb_frontend;
862 pdata->get_i2c_adapter = rtl2830_get_i2c_adapter;
863 pdata->pid_filter = rtl2830_pid_filter;
864 pdata->pid_filter_ctrl = rtl2830_pid_filter_ctrl;
865
866 dev_info(&client->dev, "Realtek RTL2830 successfully attached\n");
867
868 return 0;
869 err_regmap_exit:
870 regmap_exit(dev->regmap);
871 err_kfree:
872 kfree(dev);
873 err:
874 dev_dbg(&client->dev, "failed=%d\n", ret);
875 return ret;
876 }
877
878 static int rtl2830_remove(struct i2c_client *client)
879 {
880 struct rtl2830_dev *dev = i2c_get_clientdata(client);
881
882 dev_dbg(&client->dev, "\n");
883
884 i2c_mux_del_adapters(dev->muxc);
885 regmap_exit(dev->regmap);
886 kfree(dev);
887
888 return 0;
889 }
890
891 static const struct i2c_device_id rtl2830_id_table[] = {
892 {"rtl2830", 0},
893 {}
894 };
895 MODULE_DEVICE_TABLE(i2c, rtl2830_id_table);
896
897 static struct i2c_driver rtl2830_driver = {
898 .driver = {
899 .name = "rtl2830",
900 .suppress_bind_attrs = true,
901 },
902 .probe = rtl2830_probe,
903 .remove = rtl2830_remove,
904 .id_table = rtl2830_id_table,
905 };
906
907 module_i2c_driver(rtl2830_driver);
908
909 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
910 MODULE_DESCRIPTION("Realtek RTL2830 DVB-T demodulator driver");
911 MODULE_LICENSE("GPL");
Linux with added FPC-III support