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
;
37 struct dvb_frontend_ops ops
;
39 struct zl10353_config config
;
42 static int debug_regs
= 0;
44 static int zl10353_single_write(struct dvb_frontend
*fe
, u8 reg
, u8 val
)
46 struct zl10353_state
*state
= fe
->demodulator_priv
;
47 u8 buf
[2] = { reg
, val
};
48 struct i2c_msg msg
= { .addr
= state
->config
.demod_address
, .flags
= 0,
49 .buf
= buf
, .len
= 2 };
50 int err
= i2c_transfer(state
->i2c
, &msg
, 1);
52 printk("zl10353: write to reg %x failed (err = %d)!\n", reg
, err
);
58 int zl10353_write(struct dvb_frontend
*fe
, u8
*ibuf
, int ilen
)
61 for (i
= 0; i
< ilen
- 1; i
++)
62 if ((err
= zl10353_single_write(fe
, ibuf
[0] + i
, ibuf
[i
+ 1])))
68 static int zl10353_read_register(struct zl10353_state
*state
, u8 reg
)
73 struct i2c_msg msg
[2] = { { .addr
= state
->config
.demod_address
,
75 .buf
= b0
, .len
= 1 },
76 { .addr
= state
->config
.demod_address
,
78 .buf
= b1
, .len
= 1 } };
80 ret
= i2c_transfer(state
->i2c
, msg
, 2);
83 printk("%s: readreg error (reg=%d, ret==%i)\n",
84 __FUNCTION__
, reg
, ret
);
91 static void zl10353_dump_regs(struct dvb_frontend
*fe
)
93 struct zl10353_state
*state
= fe
->demodulator_priv
;
94 char buf
[52], buf2
[4];
98 /* Dump all registers. */
99 for (reg
= 0; ; reg
++) {
102 printk(KERN_DEBUG
"%s\n", buf
);
103 sprintf(buf
, "%02x: ", reg
);
105 ret
= zl10353_read_register(state
, reg
);
107 sprintf(buf2
, "%02x ", (u8
)ret
);
114 printk(KERN_DEBUG
"%s\n", buf
);
117 static int zl10353_sleep(struct dvb_frontend
*fe
)
119 static u8 zl10353_softdown
[] = { 0x50, 0x0C, 0x44 };
121 zl10353_write(fe
, zl10353_softdown
, sizeof(zl10353_softdown
));
125 static int zl10353_set_parameters(struct dvb_frontend
*fe
,
126 struct dvb_frontend_parameters
*param
)
128 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 state
->config
.pll_set(fe
, param
, pllbuf
+ 1);
146 zl10353_write(fe
, pllbuf
, sizeof(pllbuf
));
148 zl10353_single_write(fe
, 0x70, 0x01);
150 zl10353_single_write(fe
, 0xE4, 0x00);
151 zl10353_single_write(fe
, 0xE5, 0x2A);
152 zl10353_single_write(fe
, 0xE9, 0x02);
153 zl10353_single_write(fe
, 0xE7, 0x40);
154 zl10353_single_write(fe
, 0xE8, 0x10);
159 static int zl10353_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
161 struct zl10353_state
*state
= fe
->demodulator_priv
;
164 if ((s6
= zl10353_read_register(state
, STATUS_6
)) < 0)
166 if ((s7
= zl10353_read_register(state
, STATUS_7
)) < 0)
168 if ((s8
= zl10353_read_register(state
, STATUS_8
)) < 0)
173 *status
|= FE_HAS_CARRIER
;
175 *status
|= FE_HAS_VITERBI
;
177 *status
|= FE_HAS_LOCK
;
179 *status
|= FE_HAS_SYNC
;
181 *status
|= FE_HAS_SIGNAL
;
183 if ((*status
& (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
)) !=
184 (FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
))
185 *status
&= ~FE_HAS_LOCK
;
190 static int zl10353_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
192 struct zl10353_state
*state
= fe
->demodulator_priv
;
196 zl10353_dump_regs(fe
);
198 _snr
= zl10353_read_register(state
, SNR
);
199 *snr
= (_snr
<< 8) | _snr
;
204 static int zl10353_get_tune_settings(struct dvb_frontend
*fe
,
205 struct dvb_frontend_tune_settings
208 fe_tune_settings
->min_delay_ms
= 1000;
209 fe_tune_settings
->step_size
= 0;
210 fe_tune_settings
->max_drift
= 0;
215 static int zl10353_init(struct dvb_frontend
*fe
)
217 struct zl10353_state
*state
= fe
->demodulator_priv
;
218 u8 zl10353_reset_attach
[6] = { 0x50, 0x03, 0x64, 0x46, 0x15, 0x0F };
222 zl10353_dump_regs(fe
);
224 /* Do a "hard" reset if not already done */
225 if (zl10353_read_register(state
, 0x50) != 0x03) {
226 rc
= zl10353_write(fe
, zl10353_reset_attach
,
227 sizeof(zl10353_reset_attach
));
229 zl10353_dump_regs(fe
);
235 static void zl10353_release(struct dvb_frontend
*fe
)
237 struct zl10353_state
*state
= fe
->demodulator_priv
;
242 static struct dvb_frontend_ops zl10353_ops
;
244 struct dvb_frontend
*zl10353_attach(const struct zl10353_config
*config
,
245 struct i2c_adapter
*i2c
)
247 struct zl10353_state
*state
= NULL
;
249 /* allocate memory for the internal state */
250 state
= kzalloc(sizeof(struct zl10353_state
), GFP_KERNEL
);
254 /* setup the state */
256 memcpy(&state
->config
, config
, sizeof(struct zl10353_config
));
257 memcpy(&state
->ops
, &zl10353_ops
, sizeof(struct dvb_frontend_ops
));
259 /* check if the demod is there */
260 if (zl10353_read_register(state
, CHIP_ID
) != ID_ZL10353
)
263 /* create dvb_frontend */
264 state
->frontend
.ops
= &state
->ops
;
265 state
->frontend
.demodulator_priv
= state
;
267 return &state
->frontend
;
273 static struct dvb_frontend_ops zl10353_ops
= {
276 .name
= "Zarlink ZL10353 DVB-T",
278 .frequency_min
= 174000000,
279 .frequency_max
= 862000000,
280 .frequency_stepsize
= 166667,
281 .frequency_tolerance
= 0,
282 .caps
= FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
|
283 FE_CAN_FEC_3_4
| FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
|
285 FE_CAN_QPSK
| FE_CAN_QAM_16
| FE_CAN_QAM_64
| FE_CAN_QAM_AUTO
|
286 FE_CAN_TRANSMISSION_MODE_AUTO
| FE_CAN_GUARD_INTERVAL_AUTO
|
287 FE_CAN_HIERARCHY_AUTO
| FE_CAN_RECOVER
|
291 .release
= zl10353_release
,
293 .init
= zl10353_init
,
294 .sleep
= zl10353_sleep
,
296 .set_frontend
= zl10353_set_parameters
,
297 .get_tune_settings
= zl10353_get_tune_settings
,
299 .read_status
= zl10353_read_status
,
300 .read_snr
= zl10353_read_snr
,
303 module_param(debug_regs
, int, 0644);
304 MODULE_PARM_DESC(debug_regs
, "Turn on/off frontend register dumps (default:off).");
306 MODULE_DESCRIPTION("Zarlink ZL10353 DVB-T demodulator driver");
307 MODULE_AUTHOR("Chris Pascoe");
308 MODULE_LICENSE("GPL");
310 EXPORT_SYMBOL(zl10353_attach
);
311 EXPORT_SYMBOL(zl10353_write
);