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
, 0x62, 0x0A);
145 // if there is no attached secondary tuner, we call set_params to program
146 // a potential tuner attached somewhere else
147 if (state
->config
.no_tuner
) {
148 if (fe
->ops
.tuner_ops
.set_params
) {
149 fe
->ops
.tuner_ops
.set_params(fe
, param
);
150 if (fe
->ops
.i2c_gate_ctrl
) fe
->ops
.i2c_gate_ctrl(fe
, 0);
154 // if pllbuf is defined, retrieve the settings
155 if (fe
->ops
.tuner_ops
.calc_regs
) {
156 fe
->ops
.tuner_ops
.calc_regs(fe
, param
, pllbuf
+1, 5);
159 // fake pllbuf settings
160 pllbuf
[1] = 0x61 << 1;
167 // there is no call to _just_ start decoding, so we send the pllbuf anyway
168 // even if there isn't a PLL attached to the secondary bus
169 zl10353_write(fe
, pllbuf
, sizeof(pllbuf
));
171 zl10353_single_write(fe
, 0x70, 0x01);
173 zl10353_single_write(fe
, 0xE4, 0x00);
174 zl10353_single_write(fe
, 0xE5, 0x2A);
175 zl10353_single_write(fe
, 0xE9, 0x02);
176 zl10353_single_write(fe
, 0xE7, 0x40);
177 zl10353_single_write(fe
, 0xE8, 0x10);
182 static int zl10353_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
184 struct zl10353_state
*state
= fe
->demodulator_priv
;
187 if ((s6
= zl10353_read_register(state
, STATUS_6
)) < 0)
189 if ((s7
= zl10353_read_register(state
, STATUS_7
)) < 0)
191 if ((s8
= zl10353_read_register(state
, STATUS_8
)) < 0)
196 *status
|= FE_HAS_CARRIER
;
198 *status
|= FE_HAS_VITERBI
;
200 *status
|= FE_HAS_LOCK
;
202 *status
|= FE_HAS_SYNC
;
204 *status
|= FE_HAS_SIGNAL
;
206 if ((*status
& (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
)) !=
207 (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
))
208 *status
&= ~FE_HAS_LOCK
;
213 static int zl10353_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
215 struct zl10353_state
*state
= fe
->demodulator_priv
;
219 zl10353_dump_regs(fe
);
221 _snr
= zl10353_read_register(state
, SNR
);
222 *snr
= (_snr
<< 8) | _snr
;
227 static int zl10353_get_tune_settings(struct dvb_frontend
*fe
,
228 struct dvb_frontend_tune_settings
231 fe_tune_settings
->min_delay_ms
= 1000;
232 fe_tune_settings
->step_size
= 0;
233 fe_tune_settings
->max_drift
= 0;
238 static int zl10353_init(struct dvb_frontend
*fe
)
240 struct zl10353_state
*state
= fe
->demodulator_priv
;
241 u8 zl10353_reset_attach
[6] = { 0x50, 0x03, 0x64, 0x46, 0x15, 0x0F };
245 zl10353_dump_regs(fe
);
247 /* Do a "hard" reset if not already done */
248 if (zl10353_read_register(state
, 0x50) != 0x03) {
249 rc
= zl10353_write(fe
, zl10353_reset_attach
,
250 sizeof(zl10353_reset_attach
));
252 zl10353_dump_regs(fe
);
258 static void zl10353_release(struct dvb_frontend
*fe
)
260 struct zl10353_state
*state
= fe
->demodulator_priv
;
265 static struct dvb_frontend_ops zl10353_ops
;
267 struct dvb_frontend
*zl10353_attach(const struct zl10353_config
*config
,
268 struct i2c_adapter
*i2c
)
270 struct zl10353_state
*state
= NULL
;
272 /* allocate memory for the internal state */
273 state
= kzalloc(sizeof(struct zl10353_state
), GFP_KERNEL
);
277 /* setup the state */
279 memcpy(&state
->config
, config
, sizeof(struct zl10353_config
));
281 /* check if the demod is there */
282 if (zl10353_read_register(state
, CHIP_ID
) != ID_ZL10353
)
285 /* create dvb_frontend */
286 memcpy(&state
->frontend
.ops
, &zl10353_ops
, sizeof(struct dvb_frontend_ops
));
287 state
->frontend
.demodulator_priv
= state
;
289 return &state
->frontend
;
295 static struct dvb_frontend_ops zl10353_ops
= {
298 .name
= "Zarlink ZL10353 DVB-T",
300 .frequency_min
= 174000000,
301 .frequency_max
= 862000000,
302 .frequency_stepsize
= 166667,
303 .frequency_tolerance
= 0,
304 .caps
= FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
|
305 FE_CAN_FEC_3_4
| FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
|
307 FE_CAN_QPSK
| FE_CAN_QAM_16
| FE_CAN_QAM_64
| FE_CAN_QAM_AUTO
|
308 FE_CAN_TRANSMISSION_MODE_AUTO
| FE_CAN_GUARD_INTERVAL_AUTO
|
309 FE_CAN_HIERARCHY_AUTO
| FE_CAN_RECOVER
|
313 .release
= zl10353_release
,
315 .init
= zl10353_init
,
316 .sleep
= zl10353_sleep
,
318 .set_frontend
= zl10353_set_parameters
,
319 .get_tune_settings
= zl10353_get_tune_settings
,
321 .read_status
= zl10353_read_status
,
322 .read_snr
= zl10353_read_snr
,
325 module_param(debug_regs
, int, 0644);
326 MODULE_PARM_DESC(debug_regs
, "Turn on/off frontend register dumps (default:off).");
328 MODULE_DESCRIPTION("Zarlink ZL10353 DVB-T demodulator driver");
329 MODULE_AUTHOR("Chris Pascoe");
330 MODULE_LICENSE("GPL");
332 EXPORT_SYMBOL(zl10353_attach
);
333 EXPORT_SYMBOL(zl10353_write
);