summaryrefslogtreecommitdiff
path: root/drivers/stream_input/tv_frontend/dtv_demod/amlfrontend.c (plain)
blob: 357b6db90966ccda0a861cfde4a553655ceb0c50
1/*****************************************************************
2 **
3 ** Copyright (C) 2009 Amlogic,Inc.
4 ** All rights reserved
5 ** Filename : amlfrontend.c
6 **
7 ** comment:
8 ** Driver for m6_demod demodulator
9 ** author :
10 ** Shijie.Rong@amlogic
11 ** version :
12 ** v1.0 12/3/13
13 ** v2.0 15/10/12
14 ****************************************************************
15 */
16
17/*
18 * Driver for gxtv_demod demodulator
19 */
20
21#include <linux/init.h>
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/string.h>
25#include <linux/delay.h>
26#include <linux/jiffies.h>
27#include <linux/slab.h>
28#include <linux/platform_device.h>
29#ifdef ARC_700
30#include <asm/arch/am_regs.h>
31#else
32/* #include <mach/am_regs.h> */
33#endif
34#include <linux/i2c.h>
35#include <linux/gpio.h>
36#include "../aml_fe.h"
37
38#include <linux/dma-contiguous.h>
39#include <linux/dvb/aml_demod.h>
40#include "demod_func.h"
41#include "../aml_dvb.h"
42#include "amlfrontend.h"
43
44MODULE_PARM_DESC(debug_aml, "\n\t\t Enable frontend debug information");
45static int debug_aml;
46module_param(debug_aml, int, 0644);
47
48#define pr_dbg(a ...) \
49 do { \
50 if (debug_aml) { \
51 printk(a); \
52 } \
53 } while (0)
54#define pr_error(fmt, args ...) pr_err("GXTV_DEMOD: "fmt, ## args)
55#define pr_inf(fmt, args...) pr_err("GXTV_DEMOD: " fmt, ## args)
56
57static int last_lock = -1;
58#define DEMOD_DEVICE_NAME "gxtv_demod"
59static int cci_thread;
60static int freq_dvbc;
61static struct aml_demod_sta demod_status;
62static fe_modulation_t atsc_mode = VSB_8;
63
64long *mem_buf;
65
66MODULE_PARM_DESC(frontend_mode, "\n\t\t Frontend mode 0-DVBC, 1-DVBT");
67static int frontend_mode = -1;
68module_param(frontend_mode, int, 0444);
69
70MODULE_PARM_DESC(frontend_i2c, "\n\t\t IIc adapter id of frontend");
71static int frontend_i2c = -1;
72module_param(frontend_i2c, int, 0444);
73
74MODULE_PARM_DESC(frontend_tuner,
75 "\n\t\t Frontend tuner type 0-NULL, 1-DCT7070, 2-Maxliner, 3-FJ2207, 4-TD1316");
76static int frontend_tuner = -1;
77module_param(frontend_tuner, int, 0444);
78
79MODULE_PARM_DESC(frontend_tuner_addr, "\n\t\t Tuner IIC address of frontend");
80static int frontend_tuner_addr = -1;
81module_param(frontend_tuner_addr, int, 0444);
82static int autoflags, autoFlagsTrig;
83static struct mutex aml_lock;
84
85static int Gxtv_Demod_Dvbc_Init(struct aml_fe_dev *dev, int mode);
86
87static ssize_t dvbc_auto_sym_show(struct class *cls,
88 struct class_attribute *attr, char *buf)
89{
90 return sprintf(buf, "dvbc_autoflags: %s\n", autoflags ? "on" : "off");
91}
92
93static ssize_t dvbc_auto_sym_store(struct class *cls,
94 struct class_attribute *attr,
95 const char *buf, size_t count)
96{
97
98 return 0;
99}
100
101static unsigned int dtmb_mode;
102
103enum {
104 DTMB_READ_STRENGTH = 0,
105 DTMB_READ_SNR = 1,
106 DTMB_READ_LOCK = 2,
107 DTMB_READ_BCH = 3,
108};
109
110
111
112int convert_snr(int in_snr)
113{
114 int out_snr;
115 static int calce_snr[40] = {
116 5, 6, 8, 10, 13,
117 16, 20, 25, 32, 40,
118 50, 63, 80, 100, 126,
119 159, 200, 252, 318, 400,
120 504, 634, 798, 1005, 1265,
121 1592, 2005, 2524, 3177, 4000,
122 5036, 6340, 7981, 10048, 12649,
123 15924, 20047, 25238, 31773, 40000};
124 for (out_snr = 1 ; out_snr <= 40; out_snr++)
125 if (in_snr <= calce_snr[out_snr])
126 break;
127
128 return out_snr;
129}
130
131
132static ssize_t dtmb_para_show(struct class *cls,
133 struct class_attribute *attr, char *buf)
134{
135 int snr, lock_status, bch, agc_if_gain;
136 struct dvb_frontend *dvbfe;
137 int strength = 0;
138
139 if (dtmb_mode == DTMB_READ_STRENGTH) {
140 dvbfe = get_si2177_tuner();
141 if (dvbfe != NULL)
142 if (dvbfe->ops.tuner_ops.get_strength) {
143 strength =
144 dvbfe->ops.tuner_ops.get_strength(dvbfe);
145 }
146 if (strength <= -56) {
147 agc_if_gain =
148 ((dtmb_read_reg(DTMB_TOP_FRONT_AGC))&0x3ff);
149 strength = dtmb_get_power_strength(agc_if_gain);
150 }
151 return sprintf(buf, "strength is %d\n", strength);
152 } else if (dtmb_mode == DTMB_READ_SNR) {
153 snr = dtmb_read_reg(DTMB_TOP_FEC_LOCK_SNR) & 0x3fff;
154 snr = convert_snr(snr);
155 return sprintf(buf, "snr is %d\n", snr);
156 } else if (dtmb_mode == DTMB_READ_LOCK) {
157 lock_status =
158 (dtmb_read_reg(DTMB_TOP_FEC_LOCK_SNR) >> 14) & 0x1;
159 return sprintf(buf, "lock_status is %d\n", lock_status);
160 } else if (dtmb_mode == DTMB_READ_BCH) {
161 bch = dtmb_read_reg(DTMB_TOP_FEC_BCH_ACC);
162 return sprintf(buf, "bch is %d\n", bch);
163 } else {
164 return sprintf(buf, "dtmb_para_show can't match mode\n");
165 }
166}
167
168
169
170static ssize_t dtmb_para_store(struct class *cls,
171 struct class_attribute *attr,
172 const char *buf, size_t count)
173{
174 if (buf[0] == '0')
175 dtmb_mode = DTMB_READ_STRENGTH;
176 else if (buf[0] == '1')
177 dtmb_mode = DTMB_READ_SNR;
178 else if (buf[0] == '2')
179 dtmb_mode = DTMB_READ_LOCK;
180 else if (buf[0] == '3')
181 dtmb_mode = DTMB_READ_BCH;
182
183 return count;
184}
185
186static int readregdata;
187
188static ssize_t dvbc_reg_show(struct class *cls, struct class_attribute *attr,
189 char *buf)
190{
191/* int readregaddr=0;*/
192 char *pbuf = buf;
193
194 pbuf += sprintf(pbuf, "%x", readregdata);
195
196 pr_dbg("read dvbc_reg\n");
197 return pbuf - buf;
198}
199
200static ssize_t dvbc_reg_store(struct class *cls, struct class_attribute *attr,
201 const char *buf, size_t count)
202{
203 return 0;
204}
205
206static CLASS_ATTR(auto_sym, 0644, dvbc_auto_sym_show, dvbc_auto_sym_store);
207static CLASS_ATTR(dtmb_para, 0644, dtmb_para_show, dtmb_para_store);
208static CLASS_ATTR(dvbc_reg, 0644, dvbc_reg_show, dvbc_reg_store);
209
210#if 0
211static irqreturn_t amdemod_isr(int irq, void *data)
212{
213/* struct aml_fe_dev *state = data;
214 *
215 * #define dvb_isr_islock() (((frontend_mode==0)&&dvbc_isr_islock()) \
216 * ||((frontend_mode==1)&&dvbt_isr_islock()))
217 * #define dvb_isr_monitor() do {\
218 * if(frontend_mode==1) dvbt_isr_monitor(); }while(0)
219 * #define dvb_isr_cancel() do { if(frontend_mode==1) dvbt_isr_cancel(); \
220 * else if(frontend_mode==0) dvbc_isr_cancel();}while(0)
221 *
222 * dvb_isr_islock();
223 * {
224 * if(waitqueue_active(&state->lock_wq))
225 * wake_up_interruptible(&state->lock_wq);
226 * }
227 *
228 * dvb_isr_monitor();
229 *
230 * dvb_isr_cancel();
231 */
232
233 return IRQ_HANDLED;
234}
235#endif
236
237static int install_isr(struct aml_fe_dev *state)
238{
239 int r = 0;
240
241 /* hook demod isr */
242/* pr_dbg("amdemod irq register[IRQ(%d)].\n", INT_DEMOD);
243 * r = request_irq(INT_DEMOD, &amdemod_isr,
244 * IRQF_SHARED, "amldemod",
245 * (void *)state);
246 * if (r) {
247 * pr_error("amdemod irq register error.\n");
248 * }
249 */
250 return r;
251}
252
253
254static int amdemod_qam(fe_modulation_t qam)
255{
256 switch (qam) {
257 case QAM_16:
258 return 0;
259 case QAM_32:
260 return 1;
261 case QAM_64:
262 return 2;
263 case QAM_128:
264 return 3;
265 case QAM_256:
266 return 4;
267 case VSB_8:
268 return 5;
269 case QAM_AUTO:
270 return 6;
271 default:
272 return 2;
273 }
274 return 2;
275}
276
277static int amdemod_stat_islock(struct aml_fe_dev *dev, int mode)
278{
279 struct aml_demod_sts demod_sts;
280 int lock_status;
281 int dvbt_status1;
282
283 if (mode == 0) {
284 /*DVBC*/
285 /*dvbc_status(state->sta, state->i2c, &demod_sts);*/
286 demod_sts.ch_sts = apb_read_reg(QAM_BASE + 0x18);
287 return demod_sts.ch_sts & 0x1;
288 } else if (mode == 1) {
289 /*DVBT*/
290 dvbt_status1 =
291 ((apb_read_reg(DVBT_BASE + (0x0a << 2)) >> 20) & 0x3ff);
292 lock_status = (apb_read_reg(DVBT_BASE + (0x2a << 2))) & 0xf;
293 if ((((lock_status) == 9) || ((lock_status) == 10))
294 && ((dvbt_status1) != 0))
295 return 1;
296 else
297 return 0;
298 /*((apb_read_reg(DVBT_BASE+0x0)>>12)&0x1);//
299 * dvbt_get_status_ops()->get_status(&demod_sts, &demod_sta);
300 */
301 } else if (mode == 2) {
302 /*ISDBT*/
303 /*return dvbt_get_status_ops()->get_status
304 * (demod_sts, demod_sta);
305 */
306 } else if (mode == 3) {
307 /*ATSC*/
308 if ((atsc_mode == QAM_64) || (atsc_mode == QAM_256))
309 return (atsc_read_iqr_reg() >> 16) == 0x1f;
310 else if (atsc_mode == VSB_8)
311 return atsc_read_reg(0x0980) == 0x79;
312 else
313 return (atsc_read_iqr_reg() >> 16) == 0x1f;
314 } else if (mode == 4) {
315 /*DTMB*/
316 /* pr_dbg("DTMB lock status is %u\n",
317 * ((dtmb_read_reg(DTMB_BASE + (0x0e3 << 2)) >> 14) &
318 * 0x1));
319 */
320 return (dtmb_read_reg(DTMB_BASE + (0x0e3 << 2)) >> 14) & 0x1;
321 }
322 return 0;
323}
324
325#define amdemod_dvbc_stat_islock(dev) amdemod_stat_islock((dev), 0)
326#define amdemod_dvbt_stat_islock(dev) amdemod_stat_islock((dev), 1)
327#define amdemod_isdbt_stat_islock(dev) amdemod_stat_islock((dev), 2)
328#define amdemod_atsc_stat_islock(dev) amdemod_stat_islock((dev), 3)
329#define amdemod_dtmb_stat_islock(dev) amdemod_stat_islock((dev), 4)
330
331static int gxtv_demod_dvbc_set_qam_mode(struct dvb_frontend *fe)
332{
333 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
334 struct aml_demod_dvbc param; /*mode 0:16, 1:32, 2:64, 3:128, 4:256*/
335
336 memset(&param, 0, sizeof(param));
337 param.mode = amdemod_qam(c->modulation);
338 dvbc_set_qam_mode(param.mode);
339 return 0;
340}
341
342static void gxtv_demod_dvbc_release(struct dvb_frontend *fe)
343{
344/*
345 * struct aml_fe_dev *state = fe->demodulator_priv;
346 *
347 * uninstall_isr(state);
348 *
349 * kfree(state);
350 */
351}
352
353static int gxtv_demod_dvbc_read_status
354 (struct dvb_frontend *fe, fe_status_t *status)
355{
356/* struct aml_fe_dev *dev = afe->dtv_demod;*/
357 struct aml_demod_sts demod_sts;
358/* struct aml_demod_sta demod_sta;*/
359/* struct aml_demod_i2c demod_i2c;*/
360 int ilock;
361
362 demod_sts.ch_sts = apb_read_reg(QAM_BASE + 0x18);
363/* dvbc_status(&demod_sta, &demod_i2c, &demod_sts);*/
364 if (demod_sts.ch_sts & 0x1) {
365 ilock = 1;
366 *status =
367 FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER |
368 FE_HAS_VITERBI | FE_HAS_SYNC;
369 } else {
370 ilock = 0;
371 *status = FE_TIMEDOUT;
372 }
373 if (last_lock != ilock) {
374 pr_error("%s.\n",
375 ilock ? "!! >> LOCK << !!" : "!! >> UNLOCK << !!");
376 last_lock = ilock;
377 }
378
379 return 0;
380}
381
382static int gxtv_demod_dvbc_read_ber(struct dvb_frontend *fe, u32 *ber)
383{
384 /*struct aml_fe_dev *dev = afe->dtv_demod;*/
385 struct aml_demod_sts demod_sts;
386 struct aml_demod_i2c demod_i2c;
387 struct aml_demod_sta demod_sta;
388
389 dvbc_status(&demod_sta, &demod_i2c, &demod_sts);
390 *ber = demod_sts.ch_ber;
391 return 0;
392}
393
394static int gxtv_demod_dvbc_read_signal_strength
395 (struct dvb_frontend *fe, u16 *strength)
396{
397 struct aml_fe *afe = fe->demodulator_priv;
398 struct aml_fe_dev *dev = afe->dtv_demod;
399
400 *strength = 256 - tuner_get_ch_power(dev);
401
402 return 0;
403}
404
405static int gxtv_demod_dvbc_read_snr(struct dvb_frontend *fe, u16 *snr)
406{
407 struct aml_demod_sts demod_sts;
408 struct aml_demod_i2c demod_i2c;
409 struct aml_demod_sta demod_sta;
410
411 dvbc_status(&demod_sta, &demod_i2c, &demod_sts);
412 *snr = demod_sts.ch_snr / 100;
413 return 0;
414}
415
416static int gxtv_demod_dvbc_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
417{
418 *ucblocks = 0;
419 return 0;
420}
421
422/*extern int aml_fe_analog_set_frontend(struct dvb_frontend *fe);*/
423
424static int gxtv_demod_dvbc_set_frontend(struct dvb_frontend *fe)
425{
426 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
427 struct aml_demod_dvbc param; /*mode 0:16, 1:32, 2:64, 3:128, 4:256*/
428 struct aml_demod_sts demod_sts;
429 struct aml_demod_i2c demod_i2c;
430 struct aml_fe *afe = fe->demodulator_priv;
431 struct aml_fe_dev *dev = afe->dtv_demod;
432 int error, times;
433
434 demod_i2c.tuner = dev->drv->id;
435 demod_i2c.addr = dev->i2c_addr;
436 times = 2;
437 memset(&param, 0, sizeof(param));
438 param.ch_freq = c->frequency / 1000;
439 param.mode = amdemod_qam(c->modulation);
440 param.symb_rate = c->symbol_rate / 1000;
441 if ((param.mode == 3) && (demod_status.tmp != Adc_mode)) {
442 Gxtv_Demod_Dvbc_Init(dev, Adc_mode);
443 pr_dbg("Gxtv_Demod_Dvbc_Init,Adc_mode\n");
444 } else {
445 /*Gxtv_Demod_Dvbc_Init(dev,Cry_mode);*/
446 }
447 if (autoflags == 0) {
448 /*pr_dbg("QAM_TUNING mode\n");*/
449 /*flag=0;*/
450 }
451 if ((autoflags == 1) && (autoFlagsTrig == 0)
452 && (freq_dvbc == param.ch_freq)) {
453 pr_dbg("now is auto symbrating\n");
454 return 0;
455 }
456 autoFlagsTrig = 0;
457 last_lock = -1;
458 pr_dbg("[gxtv_demod_dvbc_set_frontend]PARA\t"
459 "demod_i2c.tuner is %d||||demod_i2c.addr is %d||||\t"
460 "param.ch_freq is %d||||param.symb_rate is %d,\t"
461 "param.mode is %d\n",
462 demod_i2c.tuner, demod_i2c.addr, param.ch_freq,
463 param.symb_rate, param.mode);
464retry:
465 aml_dmx_before_retune(afe->ts, fe);
466 aml_fe_analog_set_frontend(fe);
467 dvbc_set_ch(&demod_status, &demod_i2c, &param);
468 if (autoflags == 1) {
469 pr_dbg("QAM_PLAYING mode,start auto sym\n");
470 dvbc_set_auto_symtrack();
471 /* flag=1;*/
472 }
473/*rsj_debug*/
474
475 dvbc_status(&demod_status, &demod_i2c, &demod_sts);
476 freq_dvbc = param.ch_freq;
477
478 times--;
479 if (amdemod_dvbc_stat_islock(dev) && times) {
480 int lock;
481
482 aml_dmx_start_error_check(afe->ts, fe);
483 msleep(20);
484 error = aml_dmx_stop_error_check(afe->ts, fe);
485 lock = amdemod_dvbc_stat_islock(dev);
486 if ((error > 200) || !lock) {
487 pr_error
488 ("amlfe too many error, error count:%d\t"
489 "lock statuc:%d, retry\n",
490 error, lock);
491 goto retry;
492 }
493 }
494
495 aml_dmx_after_retune(afe->ts, fe);
496
497 afe->params = *c;
498/* afe->params.frequency = c->frequency;
499 * afe->params.u.qam.symbol_rate = c->symbol_rate;
500 * afe->params.u.qam.modulation = c->modulation;
501 */
502
503 pr_dbg("AML amldemod => frequency=%d,symbol_rate=%d\r\n", c->frequency,
504 c->symbol_rate);
505 return 0;
506}
507
508static int gxtv_demod_dvbc_get_frontend(struct dvb_frontend *fe)
509{ /*these content will be writed into eeprom .*/
510 struct aml_fe *afe = fe->demodulator_priv;
511 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
512 int qam_mode;
513
514 qam_mode = apb_read_reg(QAM_BASE + 0x008);
515 afe->params.modulation = (qam_mode & 7) + 1;
516 pr_dbg("[mode] is %d\n", afe->params.modulation);
517
518 *c = afe->params;
519/* c->modulation= afe->params.u.qam.modulation;
520 * c->frequency= afe->params.frequency;
521 * c->symbol_rate= afe->params.u.qam.symbol_rate;
522 */
523 return 0;
524}
525
526static int Gxtv_Demod_Dvbc_Init(struct aml_fe_dev *dev, int mode)
527{
528 struct aml_demod_sys sys;
529 struct aml_demod_i2c i2c;
530
531 pr_dbg("AML Demod DVB-C init\r\n");
532 memset(&sys, 0, sizeof(sys));
533 memset(&i2c, 0, sizeof(i2c));
534 i2c.tuner = dev->drv->id;
535 i2c.addr = dev->i2c_addr;
536 /* 0 -DVBC, 1-DVBT, ISDBT, 2-ATSC*/
537 demod_status.dvb_mode = Gxtv_Dvbc;
538
539 if (mode == Adc_mode) {
540 sys.adc_clk = Adc_Clk_25M;
541 sys.demod_clk = Demod_Clk_200M;
542 demod_status.tmp = Adc_mode;
543 } else {
544 sys.adc_clk = Adc_Clk_24M;
545 sys.demod_clk = Demod_Clk_72M;
546 demod_status.tmp = Cry_mode;
547 }
548 demod_status.ch_if = Si2176_5M_If * 1000;
549 pr_dbg("[%s]adc_clk is %d,demod_clk is %d\n", __func__, sys.adc_clk,
550 sys.demod_clk);
551 autoFlagsTrig = 0;
552 demod_set_sys(&demod_status, &i2c, &sys);
553 return 0;
554}
555
556static void gxtv_demod_dvbt_release(struct dvb_frontend *fe)
557{
558/*
559 * struct aml_fe_dev *state = fe->demodulator_priv;
560 *
561 * uninstall_isr(state);
562 *
563 * kfree(state);
564 */
565}
566
567static int gxtv_demod_dvbt_read_status
568 (struct dvb_frontend *fe, fe_status_t *status)
569{
570/* struct aml_fe *afe = fe->demodulator_priv;*/
571 struct aml_demod_i2c demod_i2c;
572 struct aml_demod_sta demod_sta;
573 int ilock;
574 unsigned char s = 0;
575
576 s = dvbt_get_status_ops()->get_status(&demod_sta, &demod_i2c);
577 if (s == 1) {
578 ilock = 1;
579 *status =
580 FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER |
581 FE_HAS_VITERBI | FE_HAS_SYNC;
582 } else {
583 ilock = 0;
584 *status = FE_TIMEDOUT;
585 }
586 if (last_lock != ilock) {
587 pr_error("%s.\n",
588 ilock ? "!! >> LOCK << !!" : "!! >> UNLOCK << !!");
589 last_lock = ilock;
590 }
591
592 return 0;
593}
594
595static int gxtv_demod_dvbt_read_ber(struct dvb_frontend *fe, u32 *ber)
596{
597/* struct aml_fe *afe = fe->demodulator_priv;*/
598 struct aml_demod_i2c demod_i2c;
599 struct aml_demod_sta demod_sta;
600
601 *ber = dvbt_get_status_ops()->get_ber(&demod_sta, &demod_i2c) & 0xffff;
602 return 0;
603}
604
605static int gxtv_demod_dvbt_read_signal_strength
606 (struct dvb_frontend *fe, u16 *strength)
607{
608 struct aml_fe *afe = fe->demodulator_priv;
609 struct aml_fe_dev *dev = afe->dtv_demod;
610
611 *strength = 256 - tuner_get_ch_power(dev);
612 pr_dbg("[RSJ]tuner strength is %d dbm\n", *strength);
613 return 0;
614}
615
616static int gxtv_demod_dvbt_read_snr(struct dvb_frontend *fe, u16 *snr)
617{
618/* struct aml_fe *afe = fe->demodulator_priv;*/
619/* struct aml_demod_sts demod_sts;*/
620 struct aml_demod_i2c demod_i2c;
621 struct aml_demod_sta demod_sta;
622
623 *snr = dvbt_get_status_ops()->get_snr(&demod_sta, &demod_i2c);
624 *snr /= 8;
625 pr_dbg("[RSJ]snr is %d dbm\n", *snr);
626 return 0;
627}
628
629static int gxtv_demod_dvbt_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
630{
631 *ucblocks = 0;
632 return 0;
633}
634
635static int gxtv_demod_dvbt_set_frontend(struct dvb_frontend *fe)
636{
637 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
638 /*struct aml_demod_sts demod_sts;*/
639 struct aml_demod_i2c demod_i2c;
640 int error, times;
641 struct aml_demod_dvbt param;
642 struct aml_fe *afe = fe->demodulator_priv;
643 struct aml_fe_dev *dev = afe->dtv_demod;
644
645 demod_i2c.tuner = dev->drv->id;
646 demod_i2c.addr = dev->i2c_addr;
647
648 times = 2;
649
650 /*////////////////////////////////////*/
651 /* bw == 0 : 8M*/
652 /* 1 : 7M*/
653 /* 2 : 6M*/
654 /* 3 : 5M*/
655 /* agc_mode == 0: single AGC*/
656 /* 1: dual AGC*/
657 /*////////////////////////////////////*/
658 memset(&param, 0, sizeof(param));
659 param.ch_freq = c->frequency / 1000;
660 param.bw = c->bandwidth_hz;
661 param.agc_mode = 1;
662 /*ISDBT or DVBT : 0 is QAM, 1 is DVBT, 2 is ISDBT,
663 * 3 is DTMB, 4 is ATSC
664 */
665 param.dat0 = 1;
666 last_lock = -1;
667
668retry:
669 aml_dmx_before_retune(AM_TS_SRC_TS2, fe);
670 aml_fe_analog_set_frontend(fe);
671 dvbt_set_ch(&demod_status, &demod_i2c, &param);
672
673 /* for(count=0;count<10;count++){
674 * if(amdemod_dvbt_stat_islock(dev)){
675 * pr_dbg("first lock success\n");
676 * break;
677 * }
678 *
679 * msleep(200);
680 * }
681 */
682/*rsj_debug*/
683
684/**/
685
686 times--;
687 if (amdemod_dvbt_stat_islock(dev) && times) {
688 int lock;
689
690 aml_dmx_start_error_check(AM_TS_SRC_TS2, fe);
691 msleep(20);
692 error = aml_dmx_stop_error_check(AM_TS_SRC_TS2, fe);
693 lock = amdemod_dvbt_stat_islock(dev);
694 if ((error > 200) || !lock) {
695 pr_error
696 ("amlfe too many error,\t"
697 "error count:%d lock statuc:%d, retry\n",
698 error, lock);
699 goto retry;
700 }
701 }
702
703 aml_dmx_after_retune(AM_TS_SRC_TS2, fe);
704
705 afe->params = *c;
706
707 /*pr_dbg("AML amldemod => frequency=%d,symbol_rate=%d\r\n",
708 * p->frequency,p->u.qam.symbol_rate);
709 */
710 return 0;
711}
712
713static int gxtv_demod_dvbt_get_frontend(struct dvb_frontend *fe)
714{ /*these content will be writed into eeprom .*/
715 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
716 struct aml_fe *afe = fe->demodulator_priv;
717
718 *c = afe->params;
719 return 0;
720}
721
722int Gxtv_Demod_Dvbt_Init(struct aml_fe_dev *dev)
723{
724 struct aml_demod_sys sys;
725 struct aml_demod_i2c i2c;
726
727 pr_dbg("AML Demod DVB-T init\r\n");
728
729 memset(&sys, 0, sizeof(sys));
730 memset(&i2c, 0, sizeof(i2c));
731 memset(&demod_status, 0, sizeof(demod_status));
732 i2c.tuner = dev->drv->id;
733 i2c.addr = dev->i2c_addr;
734 /* 0 -DVBC, 1-DVBT, ISDBT, 2-ATSC*/
735 demod_status.dvb_mode = Gxtv_Dvbt_Isdbt;
736 sys.adc_clk = Adc_Clk_24M;
737 sys.demod_clk = Demod_Clk_60M;
738 demod_status.ch_if = Si2176_5M_If * 1000;
739 demod_set_sys(&demod_status, &i2c, &sys);
740 return 0;
741}
742
743static void gxtv_demod_atsc_release(struct dvb_frontend *fe)
744{
745/*
746 * struct aml_fe_dev *state = fe->demodulator_priv;
747 *
748 * uninstall_isr(state);
749 *
750 * kfree(state);
751 */
752}
753
754static int gxtv_demod_atsc_set_qam_mode(struct dvb_frontend *fe)
755{
756 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
757 struct aml_demod_atsc param; /*mode 3:64, 5:256, 7:vsb*/
758 fe_modulation_t mode;
759
760 memset(&param, 0, sizeof(param));
761 mode = c->modulation;
762 pr_dbg("mode is %d\n", mode);
763 atsc_qam_set(mode);
764 return 0;
765}
766
767static int gxtv_demod_atsc_read_status
768 (struct dvb_frontend *fe, fe_status_t *status)
769{
770 struct aml_fe *afe = fe->demodulator_priv;
771 struct aml_fe_dev *dev = afe->dtv_demod;
772/* struct aml_demod_i2c demod_i2c;*/
773/* struct aml_demod_sta demod_sta;*/
774 int ilock;
775 unsigned char s = 0;
776
777 s = amdemod_atsc_stat_islock(dev);
778 if (s == 1) {
779 ilock = 1;
780 *status =
781 FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER |
782 FE_HAS_VITERBI | FE_HAS_SYNC;
783 } else {
784 ilock = 0;
785 *status = FE_TIMEDOUT;
786 }
787 if (last_lock != ilock) {
788 pr_error("%s.\n",
789 ilock ? "!! >> LOCK << !!" : "!! >> UNLOCK << !!");
790 last_lock = ilock;
791 }
792
793 return 0;
794}
795
796static int gxtv_demod_atsc_read_ber(struct dvb_frontend *fe, u32 *ber)
797{
798/* struct aml_fe *afe = fe->demodulator_priv;*/
799/* struct aml_fe_dev *dev = afe->dtv_demod;*/
800/* struct aml_demod_sts demod_sts;*/
801/* struct aml_demod_i2c demod_i2c;*/
802/* struct aml_demod_sta demod_sta;*/
803
804/* check_atsc_fsm_status();*/
805 return 0;
806}
807
808static int gxtv_demod_atsc_read_signal_strength
809 (struct dvb_frontend *fe, u16 *strength)
810{
811 struct aml_fe *afe = fe->demodulator_priv;
812 struct aml_fe_dev *dev = afe->dtv_demod;
813
814 *strength = tuner_get_ch_power(dev);
815 return 0;
816}
817
818static int gxtv_demod_atsc_read_snr(struct dvb_frontend *fe, u16 *snr)
819{
820/* struct aml_fe *afe = fe->demodulator_priv;*/
821/* struct aml_fe_dev *dev = afe->dtv_demod;*/
822
823/* struct aml_demod_sts demod_sts;*/
824/* struct aml_demod_i2c demod_i2c;*/
825/* struct aml_demod_sta demod_sta;*/
826
827/* * snr=check_atsc_fsm_status();*/
828 return 0;
829}
830
831static int gxtv_demod_atsc_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
832{
833 *ucblocks = 0;
834 return 0;
835}
836
837static int gxtv_demod_atsc_set_frontend(struct dvb_frontend *fe)
838{
839/* struct amlfe_state *state = fe->demodulator_priv;*/
840 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
841 struct aml_demod_atsc param;
842/* struct aml_demod_sta demod_sta;*/
843/* struct aml_demod_sts demod_sts;*/
844 struct aml_demod_i2c demod_i2c;
845 int error, times;
846 struct aml_fe *afe = fe->demodulator_priv;
847 struct aml_fe_dev *dev = afe->dtv_demod;
848
849 demod_i2c.tuner = dev->drv->id;
850 demod_i2c.addr = dev->i2c_addr;
851 times = 2;
852
853 memset(&param, 0, sizeof(param));
854 param.ch_freq = c->frequency / 1000;
855
856 last_lock = -1;
857 /*p->u.vsb.modulation=QAM_64;*/
858 atsc_mode = c->modulation;
859 /* param.mode = amdemod_qam(p->u.vsb.modulation);*/
860 param.mode = c->modulation;
861
862retry:
863 aml_dmx_before_retune(AM_TS_SRC_TS2, fe);
864 aml_fe_analog_set_frontend(fe);
865 atsc_set_ch(&demod_status, &demod_i2c, &param);
866
867 /*{
868 * int ret;
869 * ret = wait_event_interruptible_timeout(
870 * dev->lock_wq, amdemod_atsc_stat_islock(dev), 4*HZ);
871 * if(!ret) pr_error("amlfe wait lock timeout.\n");
872 * }
873 */
874/*rsj_debug*/
875 /* int count;
876 * for(count=0;count<10;count++){
877 * if(amdemod_atsc_stat_islock(dev)){
878 * pr_dbg("first lock success\n");
879 * break;
880 * }
881 *
882 * msleep(200);
883 * }
884 */
885
886 times--;
887 if (amdemod_atsc_stat_islock(dev) && times) {
888 int lock;
889
890 aml_dmx_start_error_check(AM_TS_SRC_TS2, fe);
891 msleep(20);
892 error = aml_dmx_stop_error_check(AM_TS_SRC_TS2, fe);
893 lock = amdemod_atsc_stat_islock(dev);
894 if ((error > 200) || !lock) {
895 pr_error
896 ("amlfe too many error,\t"
897 "error count:%d lock statuc:%d, retry\n",
898 error, lock);
899 goto retry;
900 }
901 }
902
903 aml_dmx_after_retune(AM_TS_SRC_TS2, fe);
904
905 afe->params = *c;
906 /*pr_dbg("AML amldemod => frequency=%d,symbol_rate=%d\r\n",
907 * p->frequency,p->u.qam.symbol_rate);
908 */
909 return 0;
910}
911
912static int gxtv_demod_atsc_get_frontend(struct dvb_frontend *fe)
913{ /*these content will be writed into eeprom .*/
914 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
915 struct aml_fe *afe = fe->demodulator_priv;
916
917 pr_dbg("c->frequency is %d\n", c->frequency);
918 *c = afe->params;
919 return 0;
920}
921
922int Gxtv_Demod_Atsc_Init(struct aml_fe_dev *dev)
923{
924 struct aml_demod_sys sys;
925 struct aml_demod_i2c i2c;
926
927 pr_dbg("AML Demod ATSC init\r\n");
928
929 memset(&sys, 0, sizeof(sys));
930 memset(&i2c, 0, sizeof(i2c));
931 memset(&demod_status, 0, sizeof(demod_status));
932 /* 0 -DVBC, 1-DVBT, ISDBT, 2-ATSC*/
933 demod_status.dvb_mode = Gxtv_Atsc;
934 sys.adc_clk = Adc_Clk_25_2M; /*Adc_Clk_26M;*/
935 sys.demod_clk = Demod_Clk_75M; /*Demod_Clk_71M;//Demod_Clk_78M;*/
936 demod_status.ch_if = 6350;
937 demod_status.tmp = Adc_mode;
938 demod_set_sys(&demod_status, &i2c, &sys);
939 return 0;
940}
941
942static void gxtv_demod_dtmb_release(struct dvb_frontend *fe)
943{
944/*
945 * struct aml_fe_dev *state = fe->demodulator_priv;
946 *
947 * uninstall_isr(state);
948 *
949 * kfree(state);
950 */
951}
952
953static int gxtv_demod_dtmb_read_status
954 (struct dvb_frontend *fe, fe_status_t *status)
955{
956 struct aml_fe *afe = fe->demodulator_priv;
957 struct aml_fe_dev *dev = afe->dtv_demod;
958/* struct aml_demod_i2c demod_i2c;*/
959/* struct aml_demod_sta demod_sta;*/
960 int ilock;
961 unsigned char s = 0;
962
963/* s = amdemod_dtmb_stat_islock(dev);*/
964/* if(s==1)*/
965 if (is_meson_txl_cpu())
966 s = dtmb_check_status_txl(fe);
967 else
968 s = dtmb_check_status_gxtv(fe);
969 s = amdemod_dtmb_stat_islock(dev);
970/* s=1;*/
971 if (s == 1) {
972 ilock = 1;
973 *status =
974 FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER |
975 FE_HAS_VITERBI | FE_HAS_SYNC;
976 } else {
977 ilock = 0;
978 *status = FE_TIMEDOUT;
979 }
980 if (last_lock != ilock) {
981 pr_error("%s.\n",
982 ilock ? "!! >> LOCK << !!" : "!! >> UNLOCK << !!");
983 last_lock = ilock;
984 }
985
986 return 0;
987}
988
989static int gxtv_demod_dtmb_read_ber(struct dvb_frontend *fe, u32 *ber)
990{
991/* struct aml_fe *afe = fe->demodulator_priv;*/
992/* struct aml_fe_dev *dev = afe->dtv_demod;*/
993/* struct aml_demod_sts demod_sts;*/
994/* struct aml_demod_i2c demod_i2c;*/
995/* struct aml_demod_sta demod_sta;*/
996
997/* check_atsc_fsm_status();*/
998/* int fec_bch_add; */
999/* fec_bch_add = dtmb_read_reg(0xdf); */
1000/* *ber = fec_bch_add; */
1001 return 0;
1002}
1003
1004static int gxtv_demod_dtmb_read_signal_strength
1005 (struct dvb_frontend *fe, u16 *strength)
1006{
1007 struct aml_fe *afe = fe->demodulator_priv;
1008 struct aml_fe_dev *dev = afe->dtv_demod;
1009
1010 *strength = tuner_get_ch_power(dev);
1011 return 0;
1012}
1013
1014static int gxtv_demod_dtmb_read_snr(struct dvb_frontend *fe, u16 *snr)
1015{
1016/* struct aml_fe *afe = fe->demodulator_priv;*/
1017/* struct aml_fe_dev *dev = afe->dtv_demod;*/
1018#if 1
1019 int tmp, snr_avg;
1020
1021 tmp = snr_avg = 0;
1022 tmp = dtmb_read_reg(DTMB_TOP_FEC_LOCK_SNR);
1023/* snr_avg = (tmp >> 16) & 0x3fff;
1024 * if (snr_avg >= 2048)
1025 * snr_avg = snr_avg - 4096;
1026 * snr_avg = snr_avg / 32;
1027 */
1028 *snr = tmp&0xff;
1029#endif
1030 return 0;
1031}
1032
1033static int gxtv_demod_dtmb_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1034{
1035 *ucblocks = 0;
1036 return 0;
1037}
1038
1039static int gxtv_demod_dtmb_read_fsm(struct dvb_frontend *fe, u32 *fsm_status)
1040{
1041 int tmp;
1042
1043 tmp = dtmb_read_reg(DTMB_TOP_CTRL_FSM_STATE0);
1044 *fsm_status = tmp&0xffffffff;
1045 pr_dbg("[rsj] fsm_status is %x\n", *fsm_status);
1046 return 0;
1047}
1048
1049
1050static int gxtv_demod_dtmb_set_frontend(struct dvb_frontend *fe)
1051{
1052 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1053 struct aml_demod_dtmb param;
1054/* struct aml_demod_sta demod_sta;*/
1055/* struct aml_demod_sts demod_sts;*/
1056 struct aml_demod_i2c demod_i2c;
1057 int times;
1058 struct aml_fe *afe = fe->demodulator_priv;
1059 struct aml_fe_dev *dev = afe->dtv_demod;
1060
1061 demod_i2c.tuner = dev->drv->id;
1062 demod_i2c.addr = dev->i2c_addr;
1063 times = 2;
1064 pr_dbg("gxtv_demod_dtmb_set_frontend,freq is %d\n", c->frequency);
1065 memset(&param, 0, sizeof(param));
1066 param.ch_freq = c->frequency / 1000;
1067
1068 last_lock = -1;
1069/* demod_power_switch(PWR_OFF); */
1070 aml_fe_analog_set_frontend(fe);
1071 msleep(100);
1072/* demod_power_switch(PWR_ON); */
1073 dtmb_set_ch(&demod_status, &demod_i2c, &param);
1074 afe->params = *c;
1075 /* pr_dbg("AML amldemod => frequency=%d,symbol_rate=%d\r\n",
1076 * p->frequency,p->u.qam.symbol_rate);
1077 */
1078 return 0;
1079}
1080
1081static int gxtv_demod_dtmb_get_frontend(struct dvb_frontend *fe)
1082{ /*these content will be writed into eeprom .*/
1083 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1084 struct aml_fe *afe = fe->demodulator_priv;
1085
1086 *c = afe->params;
1087/* pr_dbg("[get frontend]c->frequency is %d\n",c->frequency);*/
1088 return 0;
1089}
1090
1091int Gxtv_Demod_Dtmb_Init(struct aml_fe_dev *dev)
1092{
1093 struct aml_demod_sys sys;
1094 struct aml_demod_i2c i2c;
1095
1096 pr_dbg("AML Demod DTMB init\r\n");
1097
1098 memset(&sys, 0, sizeof(sys));
1099 memset(&i2c, 0, sizeof(i2c));
1100 memset(&demod_status, 0, sizeof(demod_status));
1101 /* 0 -DVBC, 1-DVBT, ISDBT, 2-ATSC*/
1102 demod_status.dvb_mode = Gxtv_Dtmb;
1103 if (is_meson_txl_cpu()) {
1104 sys.adc_clk = Adc_Clk_25M; /*Adc_Clk_26M;*/
1105 sys.demod_clk = Demod_Clk_225M;
1106 } else {
1107 sys.adc_clk = Adc_Clk_25M; /*Adc_Clk_26M;*/
1108 sys.demod_clk = Demod_Clk_200M;
1109 }
1110 demod_status.ch_if = Si2176_5M_If;
1111 demod_status.tmp = Adc_mode;
1112 demod_status.spectrum = dev->spectrum;
1113 demod_set_sys(&demod_status, &i2c, &sys);
1114 return 0;
1115}
1116
1117static int gxtv_demod_fe_get_ops(struct aml_fe_dev *dev, int mode, void *ops)
1118{
1119 struct dvb_frontend_ops *fe_ops = (struct dvb_frontend_ops *)ops;
1120
1121 if (mode == AM_FE_OFDM) {
1122 fe_ops->info.frequency_min = 51000000;
1123 fe_ops->info.frequency_max = 858000000;
1124 fe_ops->info.frequency_stepsize = 0;
1125 fe_ops->info.frequency_tolerance = 0;
1126 fe_ops->info.caps =
1127 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1128 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1129 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
1130 FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
1131 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO |
1132 FE_CAN_RECOVER | FE_CAN_MUTE_TS;
1133 fe_ops->release = gxtv_demod_dvbt_release;
1134 fe_ops->set_frontend = gxtv_demod_dvbt_set_frontend;
1135 fe_ops->get_frontend = gxtv_demod_dvbt_get_frontend;
1136 fe_ops->read_status = gxtv_demod_dvbt_read_status;
1137 fe_ops->read_ber = gxtv_demod_dvbt_read_ber;
1138 fe_ops->read_signal_strength =
1139 gxtv_demod_dvbt_read_signal_strength;
1140 fe_ops->read_snr = gxtv_demod_dvbt_read_snr;
1141 fe_ops->read_ucblocks = gxtv_demod_dvbt_read_ucblocks;
1142 fe_ops->read_dtmb_fsm = NULL;
1143
1144 pr_dbg("=========================dvbt demod init\r\n");
1145 Gxtv_Demod_Dvbt_Init(dev);
1146 } else if (mode == AM_FE_QAM) {
1147 fe_ops->info.frequency_min = 51000000;
1148 fe_ops->info.frequency_max = 858000000;
1149 fe_ops->info.frequency_stepsize = 0;
1150 fe_ops->info.frequency_tolerance = 0;
1151 fe_ops->info.caps =
1152 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1153 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1154 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_32 |
1155 FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_QAM_64 |
1156 FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
1157 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO |
1158 FE_CAN_RECOVER | FE_CAN_MUTE_TS;
1159
1160 fe_ops->release = gxtv_demod_dvbc_release;
1161 fe_ops->set_frontend = gxtv_demod_dvbc_set_frontend;
1162 fe_ops->get_frontend = gxtv_demod_dvbc_get_frontend;
1163 fe_ops->read_status = gxtv_demod_dvbc_read_status;
1164 fe_ops->read_ber = gxtv_demod_dvbc_read_ber;
1165 fe_ops->read_signal_strength =
1166 gxtv_demod_dvbc_read_signal_strength;
1167 fe_ops->read_snr = gxtv_demod_dvbc_read_snr;
1168 fe_ops->read_ucblocks = gxtv_demod_dvbc_read_ucblocks;
1169 fe_ops->set_qam_mode = gxtv_demod_dvbc_set_qam_mode;
1170 fe_ops->read_dtmb_fsm = NULL;
1171 install_isr(dev);
1172 pr_dbg("=========================dvbc demod init\r\n");
1173 Gxtv_Demod_Dvbc_Init(dev, Adc_mode);
1174 } else if (mode == AM_FE_ATSC) {
1175 fe_ops->info.frequency_min = 51000000;
1176 fe_ops->info.frequency_max = 858000000;
1177 fe_ops->info.frequency_stepsize = 0;
1178 fe_ops->info.frequency_tolerance = 0;
1179 fe_ops->info.caps =
1180 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1181 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1182 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
1183 FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
1184 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO |
1185 FE_CAN_RECOVER | FE_CAN_MUTE_TS;
1186
1187 fe_ops->release = gxtv_demod_atsc_release;
1188 fe_ops->set_frontend = gxtv_demod_atsc_set_frontend;
1189 fe_ops->get_frontend = gxtv_demod_atsc_get_frontend;
1190 fe_ops->read_status = gxtv_demod_atsc_read_status;
1191 fe_ops->read_ber = gxtv_demod_atsc_read_ber;
1192 fe_ops->read_signal_strength =
1193 gxtv_demod_atsc_read_signal_strength;
1194 fe_ops->read_snr = gxtv_demod_atsc_read_snr;
1195 fe_ops->read_ucblocks = gxtv_demod_atsc_read_ucblocks;
1196 fe_ops->set_qam_mode = gxtv_demod_atsc_set_qam_mode;
1197 fe_ops->read_dtmb_fsm = NULL;
1198 Gxtv_Demod_Atsc_Init(dev);
1199 } else if (mode == AM_FE_DTMB) {
1200 fe_ops->info.frequency_min = 51000000;
1201 fe_ops->info.frequency_max = 900000000;
1202 fe_ops->info.frequency_stepsize = 0;
1203 fe_ops->info.frequency_tolerance = 0;
1204 fe_ops->info.caps =
1205 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1206 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1207 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
1208 FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
1209 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO |
1210 FE_CAN_RECOVER | FE_CAN_MUTE_TS;
1211
1212 fe_ops->release = gxtv_demod_dtmb_release;
1213 fe_ops->set_frontend = gxtv_demod_dtmb_set_frontend;
1214 fe_ops->get_frontend = gxtv_demod_dtmb_get_frontend;
1215 fe_ops->read_status = gxtv_demod_dtmb_read_status;
1216 fe_ops->read_ber = gxtv_demod_dtmb_read_ber;
1217 fe_ops->read_signal_strength =
1218 gxtv_demod_dtmb_read_signal_strength;
1219 fe_ops->read_snr = gxtv_demod_dtmb_read_snr;
1220 fe_ops->read_ucblocks = gxtv_demod_dtmb_read_ucblocks;
1221 fe_ops->read_dtmb_fsm = gxtv_demod_dtmb_read_fsm;
1222 Gxtv_Demod_Dtmb_Init(dev);
1223 }
1224 return 0;
1225}
1226
1227static int gxtv_demod_fe_resume(struct aml_fe_dev *dev)
1228{
1229 int memstart_dtmb;
1230
1231 pr_inf("gxtv_demod_fe_resume\n");
1232/* demod_power_switch(PWR_ON);*/
1233 Gxtv_Demod_Dtmb_Init(dev);
1234 memstart_dtmb = dev->fe->dtv_demod->mem_start;
1235 pr_dbg("[im]memstart is %x\n", memstart_dtmb);
1236 dtmb_write_reg(DTMB_FRONT_MEM_ADDR, memstart_dtmb);
1237 pr_dbg("[dtmb]mem_buf is 0x%x\n",
1238 dtmb_read_reg(DTMB_FRONT_MEM_ADDR));
1239 return 0;
1240}
1241
1242static int gxtv_demod_fe_suspend(struct aml_fe_dev *dev)
1243{
1244 pr_inf("gxtv_demod_fe_suspend\n");
1245/* demod_power_switch(PWR_OFF);*/
1246 return 0;
1247}
1248
1249#ifdef CONFIG_CMA
1250void dtmb_cma_alloc(struct aml_fe_dev *devp)
1251{
1252 unsigned int mem_size = devp->cma_mem_size;
1253
1254 devp->venc_pages =
1255 dma_alloc_from_contiguous(&(devp->this_pdev->dev),
1256 mem_size >> PAGE_SHIFT, 0);
1257 pr_dbg("[cma]mem_size is %d,%d\n",
1258 mem_size, mem_size >> PAGE_SHIFT);
1259 if (devp->venc_pages) {
1260 devp->mem_start = page_to_phys(devp->venc_pages);
1261 devp->mem_size = mem_size;
1262 pr_dbg("demod mem_start = 0x%x, mem_size = 0x%x\n",
1263 devp->mem_start, devp->mem_size);
1264 pr_dbg("demod cma alloc ok!\n");
1265 } else {
1266 pr_dbg("demod cma mem undefined2.\n");
1267 }
1268}
1269
1270void dtmb_cma_release(struct aml_fe_dev *devp)
1271{
1272 dma_release_from_contiguous(&(devp->this_pdev->dev),
1273 devp->venc_pages,
1274 devp->cma_mem_size>>PAGE_SHIFT);
1275 pr_dbg("demod cma release ok!\n");
1276 devp->mem_start = 0;
1277 devp->mem_size = 0;
1278}
1279#endif
1280
1281
1282static int gxtv_demod_fe_enter_mode(struct aml_fe *fe, int mode)
1283{
1284 struct aml_fe_dev *dev = fe->dtv_demod;
1285 int memstart_dtmb;
1286
1287 /* must enable the adc ref signal for demod, */
1288 vdac_enable(1, 0x2);
1289
1290 autoFlagsTrig = 1;
1291 if (cci_thread)
1292 if (dvbc_get_cci_task() == 1)
1293 dvbc_create_cci_task();
1294 /*mem_buf = (long *)phys_to_virt(memstart);*/
1295 if (mode == AM_FE_DTMB) {
1296 Gxtv_Demod_Dtmb_Init(dev);
1297 if (fe->dtv_demod->cma_flag == 1) {
1298 pr_dbg("CMA MODE, cma flag is %d,mem size is %d",
1299 fe->dtv_demod->cma_flag, fe->dtv_demod->cma_mem_size);
1300 dtmb_cma_alloc(dev);
1301 memstart_dtmb = dev->mem_start;
1302 } else {
1303 memstart_dtmb = fe->dtv_demod->mem_start;
1304 }
1305 pr_dbg("[im]memstart is %x\n", memstart_dtmb);
1306 dtmb_write_reg(DTMB_FRONT_MEM_ADDR, memstart_dtmb);
1307 pr_dbg("[dtmb]mem_buf is 0x%x\n",
1308 dtmb_read_reg(DTMB_FRONT_MEM_ADDR));
1309 /* open arbit */
1310 demod_set_demod_reg(0x8, DEMOD_REG4);
1311 } else if (mode == AM_FE_QAM) {
1312 Gxtv_Demod_Dvbc_Init(dev, Adc_mode);
1313 }
1314
1315 return 0;
1316}
1317
1318static int gxtv_demod_fe_leave_mode(struct aml_fe *fe, int mode)
1319{
1320 struct aml_fe_dev *dev = fe->dtv_demod;
1321
1322 dtvpll_init_flag(0);
1323 /*dvbc_timer_exit();*/
1324 if (cci_thread)
1325 dvbc_kill_cci_task();
1326 if (mode == AM_FE_DTMB) {
1327 /* close arbit */
1328 demod_set_demod_reg(0x0, DEMOD_REG4);
1329 if (fe->dtv_demod->cma_flag == 1)
1330 dtmb_cma_release(dev);
1331 }
1332
1333 /* should disable the adc ref signal for demod */
1334 vdac_enable(0, 0x2);
1335
1336 return 0;
1337}
1338
1339static struct aml_fe_drv gxtv_demod_dtv_demod_drv = {
1340 .id = AM_DTV_DEMOD_M1,
1341 .name = "AMLDEMOD",
1342 .capability =
1343 AM_FE_QPSK | AM_FE_QAM | AM_FE_ATSC | AM_FE_OFDM | AM_FE_DTMB,
1344 .get_ops = gxtv_demod_fe_get_ops,
1345 .suspend = gxtv_demod_fe_suspend,
1346 .resume = gxtv_demod_fe_resume,
1347 .enter_mode = gxtv_demod_fe_enter_mode,
1348 .leave_mode = gxtv_demod_fe_leave_mode
1349};
1350
1351struct class *gxtv_clsp;
1352struct class *gxtv_para_clsp;
1353
1354static int __init gxtvdemodfrontend_init(void)
1355{
1356 int ret;
1357
1358 pr_dbg("register gxtv_demod demod driver\n");
1359 ret = 0;
1360
1361 dtvpll_lock_init();
1362 mutex_init(&aml_lock);
1363
1364 gxtv_clsp = class_create(THIS_MODULE, DEMOD_DEVICE_NAME);
1365 if (!gxtv_clsp) {
1366 pr_error("[gxtv demod]%s:create class error.\n", __func__);
1367 return PTR_ERR(gxtv_clsp);
1368 }
1369 ret = class_create_file(gxtv_clsp, &class_attr_auto_sym);
1370 if (ret)
1371 pr_error("[gxtv demod]%s create class error.\n", __func__);
1372
1373 ret = class_create_file(gxtv_clsp, &class_attr_dtmb_para);
1374 if (ret)
1375 pr_error("[gxtv demod]%s create class error.\n", __func__);
1376
1377 ret = class_create_file(gxtv_clsp, &class_attr_dvbc_reg);
1378 if (ret)
1379 pr_error("[gxtv demod]%s create class error.\n", __func__);
1380
1381 return aml_register_fe_drv(AM_DEV_DTV_DEMOD, &gxtv_demod_dtv_demod_drv);
1382}
1383
1384static void __exit gxtvdemodfrontend_exit(void)
1385{
1386 pr_dbg("unregister gxtv_demod demod driver\n");
1387
1388 mutex_destroy(&aml_lock);
1389
1390 class_remove_file(gxtv_clsp, &class_attr_auto_sym);
1391 class_remove_file(gxtv_clsp, &class_attr_dtmb_para);
1392 class_remove_file(gxtv_clsp, &class_attr_dvbc_reg);
1393 class_destroy(gxtv_clsp);
1394 aml_unregister_fe_drv(AM_DEV_DTV_DEMOD, &gxtv_demod_dtv_demod_drv);
1395}
1396
1397fs_initcall(gxtvdemodfrontend_init);
1398module_exit(gxtvdemodfrontend_exit);
1399
1400MODULE_DESCRIPTION("gxtv_demod DVB-T/DVB-C/DTMB Demodulator driver");
1401MODULE_AUTHOR("RSJ");
1402MODULE_LICENSE("GPL");
1403
generated by cgit at 2024-05-19 18:05:17 (GMT)