diff options
Diffstat (limited to 'drivers/media/dvb')
-rw-r--r-- | drivers/media/dvb/frontends/Kconfig | 6 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/Makefile | 1 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/dvb-pll.c | 15 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/dvb-pll.h | 2 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/zl10353.c | 311 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/zl10353.h | 43 | ||||
-rw-r--r-- | drivers/media/dvb/frontends/zl10353_priv.h | 42 |
7 files changed, 420 insertions, 0 deletions
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig index c676b1e23ab0..a1a894d81040 100644 --- a/drivers/media/dvb/frontends/Kconfig +++ b/drivers/media/dvb/frontends/Kconfig | |||
@@ -116,6 +116,12 @@ config DVB_MT352 | |||
116 | help | 116 | help |
117 | A DVB-T tuner module. Say Y when you want to support this frontend. | 117 | A DVB-T tuner module. Say Y when you want to support this frontend. |
118 | 118 | ||
119 | config DVB_ZL10353 | ||
120 | tristate "Zarlink ZL10353 based" | ||
121 | depends on DVB_CORE | ||
122 | help | ||
123 | A DVB-T tuner module. Say Y when you want to support this frontend. | ||
124 | |||
119 | config DVB_DIB3000MB | 125 | config DVB_DIB3000MB |
120 | tristate "DiBcom 3000M-B" | 126 | tristate "DiBcom 3000M-B" |
121 | depends on DVB_CORE | 127 | depends on DVB_CORE |
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile index 1af769cd90c0..d09b6071fbaf 100644 --- a/drivers/media/dvb/frontends/Makefile +++ b/drivers/media/dvb/frontends/Makefile | |||
@@ -20,6 +20,7 @@ obj-$(CONFIG_DVB_TDA1004X) += tda1004x.o | |||
20 | obj-$(CONFIG_DVB_SP887X) += sp887x.o | 20 | obj-$(CONFIG_DVB_SP887X) += sp887x.o |
21 | obj-$(CONFIG_DVB_NXT6000) += nxt6000.o | 21 | obj-$(CONFIG_DVB_NXT6000) += nxt6000.o |
22 | obj-$(CONFIG_DVB_MT352) += mt352.o | 22 | obj-$(CONFIG_DVB_MT352) += mt352.o |
23 | obj-$(CONFIG_DVB_ZL10353) += zl10353.o | ||
23 | obj-$(CONFIG_DVB_CX22702) += cx22702.o | 24 | obj-$(CONFIG_DVB_CX22702) += cx22702.o |
24 | obj-$(CONFIG_DVB_TDA10021) += tda10021.o | 25 | obj-$(CONFIG_DVB_TDA10021) += tda10021.o |
25 | obj-$(CONFIG_DVB_STV0297) += stv0297.o | 26 | obj-$(CONFIG_DVB_STV0297) += stv0297.o |
diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c index 4f682534df42..8a4c904d3a27 100644 --- a/drivers/media/dvb/frontends/dvb-pll.c +++ b/drivers/media/dvb/frontends/dvb-pll.c | |||
@@ -404,6 +404,21 @@ struct dvb_pll_desc dvb_pll_philips_td1316 = { | |||
404 | }; | 404 | }; |
405 | EXPORT_SYMBOL(dvb_pll_philips_td1316); | 405 | EXPORT_SYMBOL(dvb_pll_philips_td1316); |
406 | 406 | ||
407 | /* FE6600 used on DViCO Hybrid */ | ||
408 | struct dvb_pll_desc dvb_pll_unknown_fe6600 = { | ||
409 | .name = "FE6600", | ||
410 | .min = 44250000, | ||
411 | .max = 858000000, | ||
412 | .count = 4, | ||
413 | .entries = { | ||
414 | { 250000000, 36213333, 166667, 0xb4, 0x12 }, | ||
415 | { 455000000, 36213333, 166667, 0xfe, 0x11 }, | ||
416 | { 775500000, 36213333, 166667, 0xbc, 0x18 }, | ||
417 | { 999999999, 36213333, 166667, 0xf4, 0x18 }, | ||
418 | } | ||
419 | }; | ||
420 | EXPORT_SYMBOL(dvb_pll_unknown_fe6600); | ||
421 | |||
407 | /* ----------------------------------------------------------- */ | 422 | /* ----------------------------------------------------------- */ |
408 | /* code */ | 423 | /* code */ |
409 | 424 | ||
diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h index 56c3cd76a7fa..8a7f0b941c38 100644 --- a/drivers/media/dvb/frontends/dvb-pll.h +++ b/drivers/media/dvb/frontends/dvb-pll.h | |||
@@ -42,6 +42,8 @@ extern struct dvb_pll_desc dvb_pll_samsung_tbmv; | |||
42 | extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261; | 42 | extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261; |
43 | extern struct dvb_pll_desc dvb_pll_philips_td1316; | 43 | extern struct dvb_pll_desc dvb_pll_philips_td1316; |
44 | 44 | ||
45 | extern struct dvb_pll_desc dvb_pll_unknown_fe6600; | ||
46 | |||
45 | int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf, | 47 | int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf, |
46 | u32 freq, int bandwidth); | 48 | u32 freq, int bandwidth); |
47 | 49 | ||
diff --git a/drivers/media/dvb/frontends/zl10353.c b/drivers/media/dvb/frontends/zl10353.c new file mode 100644 index 000000000000..23846c4452ad --- /dev/null +++ b/drivers/media/dvb/frontends/zl10353.c | |||
@@ -0,0 +1,311 @@ | |||
1 | /* | ||
2 | * Driver for Zarlink DVB-T ZL10353 demodulator | ||
3 | * | ||
4 | * Copyright (C) 2006 Christopher Pascoe <c.pascoe@itee.uq.edu.au> | ||
5 | * | ||
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. | ||
10 | * | ||
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 | ||
14 | * | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
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.= | ||
20 | */ | ||
21 | |||
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> | ||
29 | |||
30 | #include "dvb_frontend.h" | ||
31 | #include "zl10353_priv.h" | ||
32 | #include "zl10353.h" | ||
33 | |||
34 | struct zl10353_state { | ||
35 | struct i2c_adapter *i2c; | ||
36 | struct dvb_frontend frontend; | ||
37 | struct dvb_frontend_ops ops; | ||
38 | |||
39 | struct zl10353_config config; | ||
40 | }; | ||
41 | |||
42 | static int debug_regs = 0; | ||
43 | |||
44 | static int zl10353_single_write(struct dvb_frontend *fe, u8 reg, u8 val) | ||
45 | { | ||
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); | ||
51 | if (err != 1) { | ||
52 | printk("zl10353: write to reg %x failed (err = %d)!\n", reg, err); | ||
53 | return err; | ||
54 | } | ||
55 | return 0; | ||
56 | } | ||
57 | |||
58 | int zl10353_write(struct dvb_frontend *fe, u8 *ibuf, int ilen) | ||
59 | { | ||
60 | int err, i; | ||
61 | for (i = 0; i < ilen - 1; i++) | ||
62 | if ((err = zl10353_single_write(fe, ibuf[0] + i, ibuf[i + 1]))) | ||
63 | return err; | ||
64 | |||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | static int zl10353_read_register(struct zl10353_state *state, u8 reg) | ||
69 | { | ||
70 | int ret; | ||
71 | u8 b0[1] = { reg }; | ||
72 | u8 b1[1] = { 0 }; | ||
73 | struct i2c_msg msg[2] = { { .addr = state->config.demod_address, | ||
74 | .flags = 0, | ||
75 | .buf = b0, .len = 1 }, | ||
76 | { .addr = state->config.demod_address, | ||
77 | .flags = I2C_M_RD, | ||
78 | .buf = b1, .len = 1 } }; | ||
79 | |||
80 | ret = i2c_transfer(state->i2c, msg, 2); | ||
81 | |||
82 | if (ret != 2) { | ||
83 | printk("%s: readreg error (reg=%d, ret==%i)\n", | ||
84 | __FUNCTION__, reg, ret); | ||
85 | return ret; | ||
86 | } | ||
87 | |||
88 | return b1[0]; | ||
89 | } | ||
90 | |||
91 | void zl10353_dump_regs(struct dvb_frontend *fe) | ||
92 | { | ||
93 | struct zl10353_state *state = fe->demodulator_priv; | ||
94 | char buf[52], buf2[4]; | ||
95 | int ret; | ||
96 | u8 reg; | ||
97 | |||
98 | /* Dump all registers. */ | ||
99 | for (reg = 0; ; reg++) { | ||
100 | if (reg % 16 == 0) { | ||
101 | if (reg) | ||
102 | printk(KERN_DEBUG "%s\n", buf); | ||
103 | sprintf(buf, "%02x: ", reg); | ||
104 | } | ||
105 | ret = zl10353_read_register(state, reg); | ||
106 | if (ret >= 0) | ||
107 | sprintf(buf2, "%02x ", (u8)ret); | ||
108 | else | ||
109 | strcpy(buf2, "-- "); | ||
110 | strcat(buf, buf2); | ||
111 | if (reg == 0xff) | ||
112 | break; | ||
113 | } | ||
114 | printk(KERN_DEBUG "%s\n", buf); | ||
115 | } | ||
116 | |||
117 | static int zl10353_sleep(struct dvb_frontend *fe) | ||
118 | { | ||
119 | static u8 zl10353_softdown[] = { 0x50, 0x0C, 0x44 }; | ||
120 | |||
121 | zl10353_write(fe, zl10353_softdown, sizeof(zl10353_softdown)); | ||
122 | return 0; | ||
123 | } | ||
124 | |||
125 | static int zl10353_set_parameters(struct dvb_frontend *fe, | ||
126 | struct dvb_frontend_parameters *param) | ||
127 | { | ||
128 | struct zl10353_state *state = fe->demodulator_priv; | ||
129 | u8 pllbuf[6] = { 0x67 }; | ||
130 | |||
131 | /* These settings set "auto-everything" and start the FSM. */ | ||
132 | zl10353_single_write(fe, 0x55, 0x80); | ||
133 | udelay(200); | ||
134 | zl10353_single_write(fe, 0xEA, 0x01); | ||
135 | udelay(200); | ||
136 | zl10353_single_write(fe, 0xEA, 0x00); | ||
137 | |||
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); | ||
144 | |||
145 | state->config.pll_set(fe, param, pllbuf + 1); | ||
146 | zl10353_write(fe, pllbuf, sizeof(pllbuf)); | ||
147 | |||
148 | zl10353_single_write(fe, 0x70, 0x01); | ||
149 | udelay(250); | ||
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); | ||
155 | |||
156 | return 0; | ||
157 | } | ||
158 | |||
159 | static int zl10353_read_status(struct dvb_frontend *fe, fe_status_t *status) | ||
160 | { | ||
161 | struct zl10353_state *state = fe->demodulator_priv; | ||
162 | int s6, s7, s8; | ||
163 | |||
164 | if ((s6 = zl10353_read_register(state, STATUS_6)) < 0) | ||
165 | return -EREMOTEIO; | ||
166 | if ((s7 = zl10353_read_register(state, STATUS_7)) < 0) | ||
167 | return -EREMOTEIO; | ||
168 | if ((s8 = zl10353_read_register(state, STATUS_8)) < 0) | ||
169 | return -EREMOTEIO; | ||
170 | |||
171 | *status = 0; | ||
172 | if (s6 & (1 << 2)) | ||
173 | *status |= FE_HAS_CARRIER; | ||
174 | if (s6 & (1 << 1)) | ||
175 | *status |= FE_HAS_VITERBI; | ||
176 | if (s6 & (1 << 5)) | ||
177 | *status |= FE_HAS_LOCK; | ||
178 | if (s7 & (1 << 4)) | ||
179 | *status |= FE_HAS_SYNC; | ||
180 | if (s8 & (1 << 6)) | ||
181 | *status |= FE_HAS_SIGNAL; | ||
182 | |||
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; | ||
186 | |||
187 | return 0; | ||
188 | } | ||
189 | |||
190 | static int zl10353_read_snr(struct dvb_frontend *fe, u16 *snr) | ||
191 | { | ||
192 | struct zl10353_state *state = fe->demodulator_priv; | ||
193 | u8 _snr; | ||
194 | |||
195 | if (debug_regs) | ||
196 | zl10353_dump_regs(fe); | ||
197 | |||
198 | _snr = zl10353_read_register(state, SNR); | ||
199 | *snr = (_snr << 8) | _snr; | ||
200 | |||
201 | return 0; | ||
202 | } | ||
203 | |||
204 | static int zl10353_get_tune_settings(struct dvb_frontend *fe, | ||
205 | struct dvb_frontend_tune_settings | ||
206 | *fe_tune_settings) | ||
207 | { | ||
208 | fe_tune_settings->min_delay_ms = 1000; | ||
209 | fe_tune_settings->step_size = 0; | ||
210 | fe_tune_settings->max_drift = 0; | ||
211 | |||
212 | return 0; | ||
213 | } | ||
214 | |||
215 | static int zl10353_init(struct dvb_frontend *fe) | ||
216 | { | ||
217 | struct zl10353_state *state = fe->demodulator_priv; | ||
218 | u8 zl10353_reset_attach[6] = { 0x50, 0x03, 0x64, 0x46, 0x15, 0x0F }; | ||
219 | int rc = 0; | ||
220 | |||
221 | if (debug_regs) | ||
222 | zl10353_dump_regs(fe); | ||
223 | |||
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)); | ||
228 | if (debug_regs) | ||
229 | zl10353_dump_regs(fe); | ||
230 | } | ||
231 | |||
232 | return 0; | ||
233 | } | ||
234 | |||
235 | static void zl10353_release(struct dvb_frontend *fe) | ||
236 | { | ||
237 | struct zl10353_state *state = fe->demodulator_priv; | ||
238 | |||
239 | kfree(state); | ||
240 | } | ||
241 | |||
242 | static struct dvb_frontend_ops zl10353_ops; | ||
243 | |||
244 | struct dvb_frontend *zl10353_attach(const struct zl10353_config *config, | ||
245 | struct i2c_adapter *i2c) | ||
246 | { | ||
247 | struct zl10353_state *state = NULL; | ||
248 | |||
249 | /* allocate memory for the internal state */ | ||
250 | state = kzalloc(sizeof(struct zl10353_state), GFP_KERNEL); | ||
251 | if (state == NULL) | ||
252 | goto error; | ||
253 | |||
254 | /* setup the state */ | ||
255 | state->i2c = i2c; | ||
256 | memcpy(&state->config, config, sizeof(struct zl10353_config)); | ||
257 | memcpy(&state->ops, &zl10353_ops, sizeof(struct dvb_frontend_ops)); | ||
258 | |||
259 | /* check if the demod is there */ | ||
260 | if (zl10353_read_register(state, CHIP_ID) != ID_ZL10353) | ||
261 | goto error; | ||
262 | |||
263 | /* create dvb_frontend */ | ||
264 | state->frontend.ops = &state->ops; | ||
265 | state->frontend.demodulator_priv = state; | ||
266 | |||
267 | return &state->frontend; | ||
268 | error: | ||
269 | kfree(state); | ||
270 | return NULL; | ||
271 | } | ||
272 | |||
273 | static struct dvb_frontend_ops zl10353_ops = { | ||
274 | |||
275 | .info = { | ||
276 | .name = "Zarlink ZL10353 DVB-T", | ||
277 | .type = FE_OFDM, | ||
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 | | ||
284 | FE_CAN_FEC_AUTO | | ||
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 | | ||
288 | FE_CAN_MUTE_TS | ||
289 | }, | ||
290 | |||
291 | .release = zl10353_release, | ||
292 | |||
293 | .init = zl10353_init, | ||
294 | .sleep = zl10353_sleep, | ||
295 | |||
296 | .set_frontend = zl10353_set_parameters, | ||
297 | .get_tune_settings = zl10353_get_tune_settings, | ||
298 | |||
299 | .read_status = zl10353_read_status, | ||
300 | .read_snr = zl10353_read_snr, | ||
301 | }; | ||
302 | |||
303 | module_param(debug_regs, int, 0644); | ||
304 | MODULE_PARM_DESC(debug_regs, "Turn on/off frontend register dumps (default:off)."); | ||
305 | |||
306 | MODULE_DESCRIPTION("Zarlink ZL10353 DVB-T demodulator driver"); | ||
307 | MODULE_AUTHOR("Chris Pascoe"); | ||
308 | MODULE_LICENSE("GPL"); | ||
309 | |||
310 | EXPORT_SYMBOL(zl10353_attach); | ||
311 | EXPORT_SYMBOL(zl10353_write); | ||
diff --git a/drivers/media/dvb/frontends/zl10353.h b/drivers/media/dvb/frontends/zl10353.h new file mode 100644 index 000000000000..5cc4ae718d8c --- /dev/null +++ b/drivers/media/dvb/frontends/zl10353.h | |||
@@ -0,0 +1,43 @@ | |||
1 | /* | ||
2 | * Driver for Zarlink DVB-T ZL10353 demodulator | ||
3 | * | ||
4 | * Copyright (C) 2006 Christopher Pascoe <c.pascoe@itee.uq.edu.au> | ||
5 | * | ||
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. | ||
10 | * | ||
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 | ||
14 | * | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
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.= | ||
20 | */ | ||
21 | |||
22 | #ifndef ZL10353_H | ||
23 | #define ZL10353_H | ||
24 | |||
25 | #include <linux/dvb/frontend.h> | ||
26 | |||
27 | struct zl10353_config | ||
28 | { | ||
29 | /* demodulator's I2C address */ | ||
30 | u8 demod_address; | ||
31 | |||
32 | /* function which configures the PLL buffer (for secondary I2C | ||
33 | * connected tuner) or tunes the PLL (for direct connected tuner) */ | ||
34 | int (*pll_set)(struct dvb_frontend *fe, | ||
35 | struct dvb_frontend_parameters *params, u8 *pllbuf); | ||
36 | }; | ||
37 | |||
38 | extern struct dvb_frontend* zl10353_attach(const struct zl10353_config *config, | ||
39 | struct i2c_adapter *i2c); | ||
40 | |||
41 | extern int zl10353_write(struct dvb_frontend *fe, u8 *ibuf, int ilen); | ||
42 | |||
43 | #endif /* ZL10353_H */ | ||
diff --git a/drivers/media/dvb/frontends/zl10353_priv.h b/drivers/media/dvb/frontends/zl10353_priv.h new file mode 100644 index 000000000000..b72224bd7dde --- /dev/null +++ b/drivers/media/dvb/frontends/zl10353_priv.h | |||
@@ -0,0 +1,42 @@ | |||
1 | /* | ||
2 | * Driver for Zarlink DVB-T ZL10353 demodulator | ||
3 | * | ||
4 | * Copyright (C) 2006 Christopher Pascoe <c.pascoe@itee.uq.edu.au> | ||
5 | * | ||
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. | ||
10 | * | ||
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 | ||
14 | * | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
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.= | ||
20 | */ | ||
21 | |||
22 | #ifndef _ZL10353_PRIV_ | ||
23 | #define _ZL10353_PRIV_ | ||
24 | |||
25 | #define ID_ZL10353 0x14 | ||
26 | |||
27 | enum zl10353_reg_addr { | ||
28 | INTERRUPT_0 = 0x00, | ||
29 | INTERRUPT_1 = 0x01, | ||
30 | INTERRUPT_2 = 0x02, | ||
31 | INTERRUPT_3 = 0x03, | ||
32 | INTERRUPT_4 = 0x04, | ||
33 | INTERRUPT_5 = 0x05, | ||
34 | STATUS_6 = 0x06, | ||
35 | STATUS_7 = 0x07, | ||
36 | STATUS_8 = 0x08, | ||
37 | STATUS_9 = 0x09, | ||
38 | SNR = 0x10, | ||
39 | CHIP_ID = 0x7F, | ||
40 | }; | ||
41 | |||
42 | #endif /* _ZL10353_PRIV_ */ | ||