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