1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include "mn88473_priv.h"
18
19static int mn88473_get_tune_settings(struct dvb_frontend *fe,
20 struct dvb_frontend_tune_settings *s)
21{
22 s->min_delay_ms = 1000;
23 return 0;
24}
25
26static int mn88473_set_frontend(struct dvb_frontend *fe)
27{
28 struct i2c_client *client = fe->demodulator_priv;
29 struct mn88473_dev *dev = i2c_get_clientdata(client);
30 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
31 int ret, i;
32 unsigned int uitmp;
33 u32 if_frequency;
34 u8 delivery_system_val, if_val[3], *conf_val_ptr;
35 u8 reg_bank2_2d_val, reg_bank0_d2_val;
36
37 dev_dbg(&client->dev,
38 "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%d stream_id=%d\n",
39 c->delivery_system, c->modulation, c->frequency,
40 c->bandwidth_hz, c->symbol_rate, c->inversion, c->stream_id);
41
42 if (!dev->active) {
43 ret = -EAGAIN;
44 goto err;
45 }
46
47 switch (c->delivery_system) {
48 case SYS_DVBT:
49 delivery_system_val = 0x02;
50 reg_bank2_2d_val = 0x23;
51 reg_bank0_d2_val = 0x2a;
52 break;
53 case SYS_DVBT2:
54 delivery_system_val = 0x03;
55 reg_bank2_2d_val = 0x3b;
56 reg_bank0_d2_val = 0x29;
57 break;
58 case SYS_DVBC_ANNEX_A:
59 delivery_system_val = 0x04;
60 reg_bank2_2d_val = 0x3b;
61 reg_bank0_d2_val = 0x29;
62 break;
63 default:
64 ret = -EINVAL;
65 goto err;
66 }
67
68 switch (c->delivery_system) {
69 case SYS_DVBT:
70 case SYS_DVBT2:
71 switch (c->bandwidth_hz) {
72 case 6000000:
73 conf_val_ptr = "\xe9\x55\x55\x1c\x29\x1c\x29";
74 break;
75 case 7000000:
76 conf_val_ptr = "\xc8\x00\x00\x17\x0a\x17\x0a";
77 break;
78 case 8000000:
79 conf_val_ptr = "\xaf\x00\x00\x11\xec\x11\xec";
80 break;
81 default:
82 ret = -EINVAL;
83 goto err;
84 }
85 break;
86 case SYS_DVBC_ANNEX_A:
87 conf_val_ptr = "\x10\xab\x0d\xae\x1d\x9d";
88 break;
89 default:
90 break;
91 }
92
93
94 if (fe->ops.tuner_ops.set_params) {
95 ret = fe->ops.tuner_ops.set_params(fe);
96 if (ret)
97 goto err;
98 }
99
100 if (fe->ops.tuner_ops.get_if_frequency) {
101 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
102 if (ret)
103 goto err;
104
105 dev_dbg(&client->dev, "get_if_frequency=%u\n", if_frequency);
106 } else {
107 ret = -EINVAL;
108 goto err;
109 }
110
111
112 uitmp = DIV_ROUND_CLOSEST_ULL((u64) if_frequency * 0x1000000, dev->clk);
113 if_val[0] = (uitmp >> 16) & 0xff;
114 if_val[1] = (uitmp >> 8) & 0xff;
115 if_val[2] = (uitmp >> 0) & 0xff;
116
117 ret = regmap_write(dev->regmap[2], 0x05, 0x00);
118 if (ret)
119 goto err;
120 ret = regmap_write(dev->regmap[2], 0xfb, 0x13);
121 if (ret)
122 goto err;
123 ret = regmap_write(dev->regmap[2], 0xef, 0x13);
124 if (ret)
125 goto err;
126 ret = regmap_write(dev->regmap[2], 0xf9, 0x13);
127 if (ret)
128 goto err;
129 ret = regmap_write(dev->regmap[2], 0x00, 0x18);
130 if (ret)
131 goto err;
132 ret = regmap_write(dev->regmap[2], 0x01, 0x01);
133 if (ret)
134 goto err;
135 ret = regmap_write(dev->regmap[2], 0x02, 0x21);
136 if (ret)
137 goto err;
138 ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val);
139 if (ret)
140 goto err;
141 ret = regmap_write(dev->regmap[2], 0x0b, 0x00);
142 if (ret)
143 goto err;
144
145 for (i = 0; i < sizeof(if_val); i++) {
146 ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]);
147 if (ret)
148 goto err;
149 }
150
151 switch (c->delivery_system) {
152 case SYS_DVBT:
153 case SYS_DVBT2:
154 for (i = 0; i < 7; i++) {
155 ret = regmap_write(dev->regmap[2], 0x13 + i,
156 conf_val_ptr[i]);
157 if (ret)
158 goto err;
159 }
160 break;
161 case SYS_DVBC_ANNEX_A:
162 ret = regmap_bulk_write(dev->regmap[1], 0x10, conf_val_ptr, 6);
163 if (ret)
164 goto err;
165 break;
166 default:
167 break;
168 }
169
170 ret = regmap_write(dev->regmap[2], 0x2d, reg_bank2_2d_val);
171 if (ret)
172 goto err;
173 ret = regmap_write(dev->regmap[2], 0x2e, 0x00);
174 if (ret)
175 goto err;
176 ret = regmap_write(dev->regmap[2], 0x56, 0x0d);
177 if (ret)
178 goto err;
179 ret = regmap_bulk_write(dev->regmap[0], 0x01,
180 "\xba\x13\x80\xba\x91\xdd\xe7\x28", 8);
181 if (ret)
182 goto err;
183 ret = regmap_write(dev->regmap[0], 0x0a, 0x1a);
184 if (ret)
185 goto err;
186 ret = regmap_write(dev->regmap[0], 0x13, 0x1f);
187 if (ret)
188 goto err;
189 ret = regmap_write(dev->regmap[0], 0x19, 0x03);
190 if (ret)
191 goto err;
192 ret = regmap_write(dev->regmap[0], 0x1d, 0xb0);
193 if (ret)
194 goto err;
195 ret = regmap_write(dev->regmap[0], 0x2a, 0x72);
196 if (ret)
197 goto err;
198 ret = regmap_write(dev->regmap[0], 0x2d, 0x00);
199 if (ret)
200 goto err;
201 ret = regmap_write(dev->regmap[0], 0x3c, 0x00);
202 if (ret)
203 goto err;
204 ret = regmap_write(dev->regmap[0], 0x3f, 0xf8);
205 if (ret)
206 goto err;
207 ret = regmap_bulk_write(dev->regmap[0], 0x40, "\xf4\x08", 2);
208 if (ret)
209 goto err;
210 ret = regmap_write(dev->regmap[0], 0xd2, reg_bank0_d2_val);
211 if (ret)
212 goto err;
213 ret = regmap_write(dev->regmap[0], 0xd4, 0x55);
214 if (ret)
215 goto err;
216 ret = regmap_write(dev->regmap[1], 0xbe, 0x08);
217 if (ret)
218 goto err;
219 ret = regmap_write(dev->regmap[0], 0xb2, 0x37);
220 if (ret)
221 goto err;
222 ret = regmap_write(dev->regmap[0], 0xd7, 0x04);
223 if (ret)
224 goto err;
225
226
227 ret = regmap_write(dev->regmap[2], 0xf8, 0x9f);
228 if (ret)
229 goto err;
230
231 return 0;
232err:
233 dev_dbg(&client->dev, "failed=%d\n", ret);
234 return ret;
235}
236
237static int mn88473_read_status(struct dvb_frontend *fe, enum fe_status *status)
238{
239 struct i2c_client *client = fe->demodulator_priv;
240 struct mn88473_dev *dev = i2c_get_clientdata(client);
241 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
242 int ret;
243 unsigned int uitmp;
244
245 if (!dev->active) {
246 ret = -EAGAIN;
247 goto err;
248 }
249
250 *status = 0;
251
252 switch (c->delivery_system) {
253 case SYS_DVBT:
254 ret = regmap_read(dev->regmap[0], 0x62, &uitmp);
255 if (ret)
256 goto err;
257
258 if (!(uitmp & 0xa0)) {
259 if ((uitmp & 0x0f) >= 0x09)
260 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
261 FE_HAS_VITERBI | FE_HAS_SYNC |
262 FE_HAS_LOCK;
263 else if ((uitmp & 0x0f) >= 0x03)
264 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
265 }
266 break;
267 case SYS_DVBT2:
268 ret = regmap_read(dev->regmap[2], 0x8b, &uitmp);
269 if (ret)
270 goto err;
271
272 if (!(uitmp & 0x40)) {
273 if ((uitmp & 0x0f) >= 0x0d)
274 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
275 FE_HAS_VITERBI | FE_HAS_SYNC |
276 FE_HAS_LOCK;
277 else if ((uitmp & 0x0f) >= 0x0a)
278 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
279 FE_HAS_VITERBI;
280 else if ((uitmp & 0x0f) >= 0x07)
281 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
282 }
283 break;
284 case SYS_DVBC_ANNEX_A:
285 ret = regmap_read(dev->regmap[1], 0x85, &uitmp);
286 if (ret)
287 goto err;
288
289 if (!(uitmp & 0x40)) {
290 ret = regmap_read(dev->regmap[1], 0x89, &uitmp);
291 if (ret)
292 goto err;
293
294 if (uitmp & 0x01)
295 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
296 FE_HAS_VITERBI | FE_HAS_SYNC |
297 FE_HAS_LOCK;
298 }
299 break;
300 default:
301 ret = -EINVAL;
302 goto err;
303 }
304
305 return 0;
306err:
307 dev_dbg(&client->dev, "failed=%d\n", ret);
308 return ret;
309}
310
311static int mn88473_init(struct dvb_frontend *fe)
312{
313 struct i2c_client *client = fe->demodulator_priv;
314 struct mn88473_dev *dev = i2c_get_clientdata(client);
315 int ret, len, remain;
316 unsigned int uitmp;
317 const struct firmware *fw;
318 const char *name = MN88473_FIRMWARE;
319
320 dev_dbg(&client->dev, "\n");
321
322
323 ret = regmap_read(dev->regmap[0], 0xf5, &uitmp);
324 if (ret)
325 goto err;
326
327 if (!(uitmp & 0x01))
328 goto warm;
329
330
331 ret = request_firmware(&fw, name, &client->dev);
332 if (ret) {
333 dev_err(&client->dev, "firmware file '%s' not found\n", name);
334 goto err;
335 }
336
337 dev_info(&client->dev, "downloading firmware from file '%s'\n", name);
338
339 ret = regmap_write(dev->regmap[0], 0xf5, 0x03);
340 if (ret)
341 goto err_release_firmware;
342
343 for (remain = fw->size; remain > 0; remain -= (dev->i2c_wr_max - 1)) {
344 len = min(dev->i2c_wr_max - 1, remain);
345 ret = regmap_bulk_write(dev->regmap[0], 0xf6,
346 &fw->data[fw->size - remain], len);
347 if (ret) {
348 dev_err(&client->dev, "firmware download failed %d\n",
349 ret);
350 goto err_release_firmware;
351 }
352 }
353
354 release_firmware(fw);
355
356
357 ret = regmap_read(dev->regmap[0], 0xf8, &uitmp);
358 if (ret)
359 goto err;
360
361 if (uitmp & 0x10) {
362 dev_err(&client->dev, "firmware parity check failed\n");
363 ret = -EINVAL;
364 goto err;
365 }
366
367 ret = regmap_write(dev->regmap[0], 0xf5, 0x00);
368 if (ret)
369 goto err;
370warm:
371
372 ret = regmap_write(dev->regmap[2], 0x09, 0x08);
373 if (ret)
374 goto err;
375 ret = regmap_write(dev->regmap[2], 0x08, 0x1d);
376 if (ret)
377 goto err;
378
379 dev->active = true;
380
381 return 0;
382err_release_firmware:
383 release_firmware(fw);
384err:
385 dev_dbg(&client->dev, "failed=%d\n", ret);
386 return ret;
387}
388
389static int mn88473_sleep(struct dvb_frontend *fe)
390{
391 struct i2c_client *client = fe->demodulator_priv;
392 struct mn88473_dev *dev = i2c_get_clientdata(client);
393 int ret;
394
395 dev_dbg(&client->dev, "\n");
396
397 dev->active = false;
398
399 ret = regmap_write(dev->regmap[2], 0x05, 0x3e);
400 if (ret)
401 goto err;
402
403 return 0;
404err:
405 dev_dbg(&client->dev, "failed=%d\n", ret);
406 return ret;
407}
408
409static const struct dvb_frontend_ops mn88473_ops = {
410 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A},
411 .info = {
412 .name = "Panasonic MN88473",
413 .symbol_rate_min = 1000000,
414 .symbol_rate_max = 7200000,
415 .caps = FE_CAN_FEC_1_2 |
416 FE_CAN_FEC_2_3 |
417 FE_CAN_FEC_3_4 |
418 FE_CAN_FEC_5_6 |
419 FE_CAN_FEC_7_8 |
420 FE_CAN_FEC_AUTO |
421 FE_CAN_QPSK |
422 FE_CAN_QAM_16 |
423 FE_CAN_QAM_32 |
424 FE_CAN_QAM_64 |
425 FE_CAN_QAM_128 |
426 FE_CAN_QAM_256 |
427 FE_CAN_QAM_AUTO |
428 FE_CAN_TRANSMISSION_MODE_AUTO |
429 FE_CAN_GUARD_INTERVAL_AUTO |
430 FE_CAN_HIERARCHY_AUTO |
431 FE_CAN_MUTE_TS |
432 FE_CAN_2G_MODULATION
433 },
434
435 .get_tune_settings = mn88473_get_tune_settings,
436
437 .init = mn88473_init,
438 .sleep = mn88473_sleep,
439
440 .set_frontend = mn88473_set_frontend,
441
442 .read_status = mn88473_read_status,
443};
444
445static int mn88473_probe(struct i2c_client *client,
446 const struct i2c_device_id *id)
447{
448 struct mn88473_config *config = client->dev.platform_data;
449 struct mn88473_dev *dev;
450 int ret;
451 unsigned int uitmp;
452 static const struct regmap_config regmap_config = {
453 .reg_bits = 8,
454 .val_bits = 8,
455 };
456
457 dev_dbg(&client->dev, "\n");
458
459
460 if (config->fe == NULL) {
461 dev_err(&client->dev, "frontend pointer not defined\n");
462 ret = -EINVAL;
463 goto err;
464 }
465
466 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
467 if (dev == NULL) {
468 ret = -ENOMEM;
469 goto err;
470 }
471
472 if (config->i2c_wr_max)
473 dev->i2c_wr_max = config->i2c_wr_max;
474 else
475 dev->i2c_wr_max = ~0;
476
477 if (config->xtal)
478 dev->clk = config->xtal;
479 else
480 dev->clk = 25000000;
481 dev->client[0] = client;
482 dev->regmap[0] = regmap_init_i2c(dev->client[0], ®map_config);
483 if (IS_ERR(dev->regmap[0])) {
484 ret = PTR_ERR(dev->regmap[0]);
485 goto err_kfree;
486 }
487
488
489 ret = regmap_read(dev->regmap[0], 0xff, &uitmp);
490 if (ret)
491 goto err_regmap_0_regmap_exit;
492
493 dev_dbg(&client->dev, "chip id=%02x\n", uitmp);
494
495 if (uitmp != 0x03) {
496 ret = -ENODEV;
497 goto err_regmap_0_regmap_exit;
498 }
499
500
501
502
503
504
505
506
507
508 dev->client[1] = i2c_new_dummy(client->adapter, 0x1a);
509 if (dev->client[1] == NULL) {
510 ret = -ENODEV;
511 dev_err(&client->dev, "I2C registration failed\n");
512 if (ret)
513 goto err_regmap_0_regmap_exit;
514 }
515 dev->regmap[1] = regmap_init_i2c(dev->client[1], ®map_config);
516 if (IS_ERR(dev->regmap[1])) {
517 ret = PTR_ERR(dev->regmap[1]);
518 goto err_client_1_i2c_unregister_device;
519 }
520 i2c_set_clientdata(dev->client[1], dev);
521
522 dev->client[2] = i2c_new_dummy(client->adapter, 0x1c);
523 if (dev->client[2] == NULL) {
524 ret = -ENODEV;
525 dev_err(&client->dev, "2nd I2C registration failed\n");
526 if (ret)
527 goto err_regmap_1_regmap_exit;
528 }
529 dev->regmap[2] = regmap_init_i2c(dev->client[2], ®map_config);
530 if (IS_ERR(dev->regmap[2])) {
531 ret = PTR_ERR(dev->regmap[2]);
532 goto err_client_2_i2c_unregister_device;
533 }
534 i2c_set_clientdata(dev->client[2], dev);
535
536
537 ret = regmap_write(dev->regmap[2], 0x05, 0x3e);
538 if (ret)
539 goto err_regmap_2_regmap_exit;
540
541
542 memcpy(&dev->frontend.ops, &mn88473_ops, sizeof(dev->frontend.ops));
543 dev->frontend.demodulator_priv = client;
544 *config->fe = &dev->frontend;
545 i2c_set_clientdata(client, dev);
546
547 dev_info(&client->dev, "Panasonic MN88473 successfully identified\n");
548
549 return 0;
550err_regmap_2_regmap_exit:
551 regmap_exit(dev->regmap[2]);
552err_client_2_i2c_unregister_device:
553 i2c_unregister_device(dev->client[2]);
554err_regmap_1_regmap_exit:
555 regmap_exit(dev->regmap[1]);
556err_client_1_i2c_unregister_device:
557 i2c_unregister_device(dev->client[1]);
558err_regmap_0_regmap_exit:
559 regmap_exit(dev->regmap[0]);
560err_kfree:
561 kfree(dev);
562err:
563 dev_dbg(&client->dev, "failed=%d\n", ret);
564 return ret;
565}
566
567static int mn88473_remove(struct i2c_client *client)
568{
569 struct mn88473_dev *dev = i2c_get_clientdata(client);
570
571 dev_dbg(&client->dev, "\n");
572
573 regmap_exit(dev->regmap[2]);
574 i2c_unregister_device(dev->client[2]);
575
576 regmap_exit(dev->regmap[1]);
577 i2c_unregister_device(dev->client[1]);
578
579 regmap_exit(dev->regmap[0]);
580
581 kfree(dev);
582
583 return 0;
584}
585
586static const struct i2c_device_id mn88473_id_table[] = {
587 {"mn88473", 0},
588 {}
589};
590MODULE_DEVICE_TABLE(i2c, mn88473_id_table);
591
592static struct i2c_driver mn88473_driver = {
593 .driver = {
594 .name = "mn88473",
595 .suppress_bind_attrs = true,
596 },
597 .probe = mn88473_probe,
598 .remove = mn88473_remove,
599 .id_table = mn88473_id_table,
600};
601
602module_i2c_driver(mn88473_driver);
603
604MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
605MODULE_DESCRIPTION("Panasonic MN88473 DVB-T/T2/C demodulator driver");
606MODULE_LICENSE("GPL");
607MODULE_FIRMWARE(MN88473_FIRMWARE);
608
