2 * Driver for Zarlink DVB-T ZL10353 demodulator
4 * Copyright (C) 2006 Christopher Pascoe <c.pascoe@itee.uq.edu.au>
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.
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
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.=
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/string.h>
28 #include <linux/slab.h>
30 #include "dvb_frontend.h"
31 #include "zl10353_priv.h"
34 struct zl10353_state
{
35 struct i2c_adapter
*i2c
;
36 struct dvb_frontend frontend
;
38 struct zl10353_config config
;
41 static int debug_regs
= 0;
43 static int zl10353_single_write(struct dvb_frontend
*fe
, u8 reg
, u8 val
)
45 struct zl10353_state
*state
= fe
->demodulator_priv
;
46 u8 buf
[2] = { reg
, val
};
47 struct i2c_msg msg
= { .addr
= state
->config
.demod_address
, .flags
= 0,
48 .buf
= buf
, .len
= 2 };
49 int err
= i2c_transfer(state
->i2c
, &msg
, 1);
51 printk("zl10353: write to reg %x failed (err = %d)!\n", reg
, err
);
57 int zl10353_write(struct dvb_frontend
*fe
, u8
*ibuf
, int ilen
)
60 for (i
= 0; i
< ilen
- 1; i
++)
61 if ((err
= zl10353_single_write(fe
, ibuf
[0] + i
, ibuf
[i
+ 1])))
67 static int zl10353_read_register(struct zl10353_state
*state
, u8 reg
)
72 struct i2c_msg msg
[2] = { { .addr
= state
->config
.demod_address
,
74 .buf
= b0
, .len
= 1 },
75 { .addr
= state
->config
.demod_address
,
77 .buf
= b1
, .len
= 1 } };
79 ret
= i2c_transfer(state
->i2c
, msg
, 2);
82 printk("%s: readreg error (reg=%d, ret==%i)\n",
83 __FUNCTION__
, reg
, ret
);
90 static void zl10353_dump_regs(struct dvb_frontend
*fe
)
92 struct zl10353_state
*state
= fe
->demodulator_priv
;
93 char buf
[52], buf2
[4];
97 /* Dump all registers. */
98 for (reg
= 0; ; reg
++) {
101 printk(KERN_DEBUG
"%s\n", buf
);
102 sprintf(buf
, "%02x: ", reg
);
104 ret
= zl10353_read_register(state
, reg
);
106 sprintf(buf2
, "%02x ", (u8
)ret
);
113 printk(KERN_DEBUG
"%s\n", buf
);
116 static int zl10353_sleep(struct dvb_frontend
*fe
)
118 static u8 zl10353_softdown
[] = { 0x50, 0x0C, 0x44 };
120 zl10353_write(fe
, zl10353_softdown
, sizeof(zl10353_softdown
));
124 static int zl10353_set_parameters(struct dvb_frontend
*fe
,
125 struct dvb_frontend_parameters
*param
)
127 struct zl10353_state
*state
= fe
->demodulator_priv
;
129 u8 pllbuf
[6] = { 0x67 };
131 /* These settings set "auto-everything" and start the FSM. */
132 zl10353_single_write(fe
, 0x55, 0x80);
134 zl10353_single_write(fe
, 0xEA, 0x01);
136 zl10353_single_write(fe
, 0xEA, 0x00);
138 zl10353_single_write(fe
, 0x56, 0x28);
139 zl10353_single_write(fe
, 0x89, 0x20);
140 zl10353_single_write(fe
, 0x5E, 0x00);
141 zl10353_single_write(fe
, 0x65, 0x5A);
142 zl10353_single_write(fe
, 0x66, 0xE9);
143 zl10353_single_write(fe
, 0x6C, 0xCD);
144 zl10353_single_write(fe
, 0x6D, 0x7E);
145 zl10353_single_write(fe
, 0x62, 0x0A);
147 // if there is no attached secondary tuner, we call set_params to program
148 // a potential tuner attached somewhere else
149 if (state
->config
.no_tuner
) {
150 if (fe
->ops
.tuner_ops
.set_params
) {
151 fe
->ops
.tuner_ops
.set_params(fe
, param
);
152 if (fe
->ops
.i2c_gate_ctrl
) fe
->ops
.i2c_gate_ctrl(fe
, 0);
156 // if pllbuf is defined, retrieve the settings
157 if (fe
->ops
.tuner_ops
.calc_regs
) {
158 fe
->ops
.tuner_ops
.calc_regs(fe
, param
, pllbuf
+1, 5);
161 // fake pllbuf settings
162 pllbuf
[1] = 0x61 << 1;
169 // there is no call to _just_ start decoding, so we send the pllbuf anyway
170 // even if there isn't a PLL attached to the secondary bus
171 zl10353_write(fe
, pllbuf
, sizeof(pllbuf
));
173 zl10353_single_write(fe
, 0x5F, 0x13);
174 zl10353_single_write(fe
, 0x70, 0x01);
176 zl10353_single_write(fe
, 0xE4, 0x00);
177 zl10353_single_write(fe
, 0xE5, 0x2A);
178 zl10353_single_write(fe
, 0xE9, 0x02);
179 zl10353_single_write(fe
, 0xE7, 0x40);
180 zl10353_single_write(fe
, 0xE8, 0x10);
185 static int zl10353_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
187 struct zl10353_state
*state
= fe
->demodulator_priv
;
190 if ((s6
= zl10353_read_register(state
, STATUS_6
)) < 0)
192 if ((s7
= zl10353_read_register(state
, STATUS_7
)) < 0)
194 if ((s8
= zl10353_read_register(state
, STATUS_8
)) < 0)
199 *status
|= FE_HAS_CARRIER
;
201 *status
|= FE_HAS_VITERBI
;
203 *status
|= FE_HAS_LOCK
;
205 *status
|= FE_HAS_SYNC
;
207 *status
|= FE_HAS_SIGNAL
;
209 if ((*status
& (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
)) !=
210 (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
))
211 *status
&= ~FE_HAS_LOCK
;
216 static int zl10353_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
218 struct zl10353_state
*state
= fe
->demodulator_priv
;
222 zl10353_dump_regs(fe
);
224 _snr
= zl10353_read_register(state
, SNR
);
225 *snr
= (_snr
<< 8) | _snr
;
230 static int zl10353_get_tune_settings(struct dvb_frontend
*fe
,
231 struct dvb_frontend_tune_settings
234 fe_tune_settings
->min_delay_ms
= 1000;
235 fe_tune_settings
->step_size
= 0;
236 fe_tune_settings
->max_drift
= 0;
241 static int zl10353_init(struct dvb_frontend
*fe
)
243 struct zl10353_state
*state
= fe
->demodulator_priv
;
244 u8 zl10353_reset_attach
[6] = { 0x50, 0x03, 0x64, 0x46, 0x15, 0x0F };
248 zl10353_dump_regs(fe
);
249 if (state
->config
.parallel_ts
)
250 zl10353_reset_attach
[2] &= ~0x20;
252 /* Do a "hard" reset if not already done */
253 if (zl10353_read_register(state
, 0x50) != zl10353_reset_attach
[1] ||
254 zl10353_read_register(state
, 0x51) != zl10353_reset_attach
[2]) {
255 rc
= zl10353_write(fe
, zl10353_reset_attach
,
256 sizeof(zl10353_reset_attach
));
258 zl10353_dump_regs(fe
);
264 static void zl10353_release(struct dvb_frontend
*fe
)
266 struct zl10353_state
*state
= fe
->demodulator_priv
;
270 static struct dvb_frontend_ops zl10353_ops
;
272 struct dvb_frontend
*zl10353_attach(const struct zl10353_config
*config
,
273 struct i2c_adapter
*i2c
)
275 struct zl10353_state
*state
= NULL
;
277 /* allocate memory for the internal state */
278 state
= kzalloc(sizeof(struct zl10353_state
), GFP_KERNEL
);
282 /* setup the state */
284 memcpy(&state
->config
, config
, sizeof(struct zl10353_config
));
286 /* check if the demod is there */
287 if (zl10353_read_register(state
, CHIP_ID
) != ID_ZL10353
)
290 /* create dvb_frontend */
291 memcpy(&state
->frontend
.ops
, &zl10353_ops
, sizeof(struct dvb_frontend_ops
));
292 state
->frontend
.demodulator_priv
= state
;
294 return &state
->frontend
;
300 static struct dvb_frontend_ops zl10353_ops
= {
303 .name
= "Zarlink ZL10353 DVB-T",
305 .frequency_min
= 174000000,
306 .frequency_max
= 862000000,
307 .frequency_stepsize
= 166667,
308 .frequency_tolerance
= 0,
309 .caps
= FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
|
310 FE_CAN_FEC_3_4
| FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
|
312 FE_CAN_QPSK
| FE_CAN_QAM_16
| FE_CAN_QAM_64
| FE_CAN_QAM_AUTO
|
313 FE_CAN_TRANSMISSION_MODE_AUTO
| FE_CAN_GUARD_INTERVAL_AUTO
|
314 FE_CAN_HIERARCHY_AUTO
| FE_CAN_RECOVER
|
318 .release
= zl10353_release
,
320 .init
= zl10353_init
,
321 .sleep
= zl10353_sleep
,
322 .write
= zl10353_write
,
324 .set_frontend
= zl10353_set_parameters
,
325 .get_tune_settings
= zl10353_get_tune_settings
,
327 .read_status
= zl10353_read_status
,
328 .read_snr
= zl10353_read_snr
,
331 module_param(debug_regs
, int, 0644);
332 MODULE_PARM_DESC(debug_regs
, "Turn on/off frontend register dumps (default:off).");
334 MODULE_DESCRIPTION("Zarlink ZL10353 DVB-T demodulator driver");
335 MODULE_AUTHOR("Chris Pascoe");
336 MODULE_LICENSE("GPL");
338 EXPORT_SYMBOL(zl10353_attach
);