blob: d45827158a24a709166638275f6585a001a387de [file] [log] [blame]
Mac Michaelsd8667cb2005-07-07 17:58:29 -07001/*
Michael Krufky1963c902005-08-08 09:22:43 -07002 * Support for LGDT3302 and LGDT3303 - VSB/QAM
Mac Michaelsd8667cb2005-07-07 17:58:29 -07003 *
4 * Copyright (C) 2005 Wilson Michaels <wilsonmichaels@earthlink.net>
5 *
Mac Michaelsd8667cb2005-07-07 17:58:29 -07006 * 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 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 */
21
22/*
23 * NOTES ABOUT THIS DRIVER
24 *
Michael Krufky1963c902005-08-08 09:22:43 -070025 * This Linux driver supports:
26 * DViCO FusionHDTV 3 Gold-Q
27 * DViCO FusionHDTV 3 Gold-T
28 * DViCO FusionHDTV 5 Gold
Michael Krufky3cff00d2005-11-08 21:35:12 -080029 * DViCO FusionHDTV 5 Lite
Michael Krufkyd8e6acf2006-01-09 15:32:42 -020030 * DViCO FusionHDTV 5 USB Gold
Michael Krufkyc0b11b92005-11-08 21:35:32 -080031 * Air2PC/AirStar 2 ATSC 3rd generation (HD5000)
Michael Krufky20fe4f652006-04-10 09:40:40 -030032 * pcHDTV HD5500
Mac Michaelsd8667cb2005-07-07 17:58:29 -070033 *
Mac Michaelsd8667cb2005-07-07 17:58:29 -070034 */
35
Mac Michaelsd8667cb2005-07-07 17:58:29 -070036#include <linux/kernel.h>
37#include <linux/module.h>
Mac Michaelsd8667cb2005-07-07 17:58:29 -070038#include <linux/init.h>
39#include <linux/delay.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080040#include <linux/string.h>
41#include <linux/slab.h>
Mac Michaelsd8667cb2005-07-07 17:58:29 -070042#include <asm/byteorder.h>
43
44#include "dvb_frontend.h"
Trent Piepho19be6852006-10-29 13:35:39 -030045#include "dvb_math.h"
Michael Krufky6ddcc912005-07-27 11:46:00 -070046#include "lgdt330x_priv.h"
47#include "lgdt330x.h"
Mac Michaelsd8667cb2005-07-07 17:58:29 -070048
Trent Piepho19be6852006-10-29 13:35:39 -030049/* Use Equalizer Mean Squared Error instead of Phaser Tracker MSE */
50/* #define USE_EQMSE */
51
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030052static int debug;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070053module_param(debug, int, 0644);
Michael Krufky6ddcc912005-07-27 11:46:00 -070054MODULE_PARM_DESC(debug,"Turn on/off lgdt330x frontend debugging (default:off).");
Mac Michaelsd8667cb2005-07-07 17:58:29 -070055#define dprintk(args...) \
56do { \
Michael Krufky6ddcc912005-07-27 11:46:00 -070057if (debug) printk(KERN_DEBUG "lgdt330x: " args); \
Mac Michaelsd8667cb2005-07-07 17:58:29 -070058} while (0)
59
Michael Krufky6ddcc912005-07-27 11:46:00 -070060struct lgdt330x_state
Mac Michaelsd8667cb2005-07-07 17:58:29 -070061{
62 struct i2c_adapter* i2c;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070063
64 /* Configuration settings */
Michael Krufky6ddcc912005-07-27 11:46:00 -070065 const struct lgdt330x_config* config;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070066
67 struct dvb_frontend frontend;
68
69 /* Demodulator private data */
70 fe_modulation_t current_modulation;
Trent Piepho19be6852006-10-29 13:35:39 -030071 u32 snr; /* Result of last SNR calculation */
Mac Michaelsd8667cb2005-07-07 17:58:29 -070072
73 /* Tuner private data */
74 u32 current_frequency;
75};
76
Michael Krufky1963c902005-08-08 09:22:43 -070077static int i2c_write_demod_bytes (struct lgdt330x_state* state,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -070078 u8 *buf, /* data bytes to send */
79 int len /* number of bytes to send */ )
Mac Michaelsd8667cb2005-07-07 17:58:29 -070080{
Michael Krufkyb6aef072005-07-27 11:45:54 -070081 struct i2c_msg msg =
Michael Krufky1963c902005-08-08 09:22:43 -070082 { .addr = state->config->demod_address,
83 .flags = 0,
84 .buf = buf,
85 .len = 2 };
Michael Krufkyb6aef072005-07-27 11:45:54 -070086 int i;
Michael Krufky1963c902005-08-08 09:22:43 -070087 int err;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070088
Michael Krufky1963c902005-08-08 09:22:43 -070089 for (i=0; i<len-1; i+=2){
Mac Michaelsd8667cb2005-07-07 17:58:29 -070090 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
Harvey Harrison271ddbf2008-04-08 23:20:00 -030091 printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __func__, msg.buf[0], msg.buf[1], err);
Michael Krufky58ba0062005-07-12 13:58:37 -070092 if (err < 0)
93 return err;
94 else
95 return -EREMOTEIO;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070096 }
Michael Krufky1963c902005-08-08 09:22:43 -070097 msg.buf += 2;
Mac Michaelsd8667cb2005-07-07 17:58:29 -070098 }
99 return 0;
100}
Michael Krufkyb6aef072005-07-27 11:45:54 -0700101
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700102/*
103 * This routine writes the register (reg) to the demod bus
104 * then reads the data returned for (len) bytes.
105 */
106
Michael Krufky1963c902005-08-08 09:22:43 -0700107static u8 i2c_read_demod_bytes (struct lgdt330x_state* state,
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700108 enum I2C_REG reg, u8* buf, int len)
109{
110 u8 wr [] = { reg };
111 struct i2c_msg msg [] = {
112 { .addr = state->config->demod_address,
113 .flags = 0, .buf = wr, .len = 1 },
114 { .addr = state->config->demod_address,
115 .flags = I2C_M_RD, .buf = buf, .len = len },
116 };
117 int ret;
118 ret = i2c_transfer(state->i2c, msg, 2);
119 if (ret != 2) {
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300120 printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __func__, state->config->demod_address, reg, ret);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700121 } else {
122 ret = 0;
123 }
124 return ret;
125}
126
127/* Software reset */
Michael Krufky1963c902005-08-08 09:22:43 -0700128static int lgdt3302_SwReset(struct lgdt330x_state* state)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700129{
130 u8 ret;
131 u8 reset[] = {
132 IRQ_MASK,
133 0x00 /* bit 6 is active low software reset
134 * bits 5-0 are 1 to mask interrupts */
135 };
136
Michael Krufky1963c902005-08-08 09:22:43 -0700137 ret = i2c_write_demod_bytes(state,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700138 reset, sizeof(reset));
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700139 if (ret == 0) {
Michael Krufky1963c902005-08-08 09:22:43 -0700140
141 /* force reset high (inactive) and unmask interrupts */
142 reset[1] = 0x7f;
143 ret = i2c_write_demod_bytes(state,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700144 reset, sizeof(reset));
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700145 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700146 return ret;
147}
148
Michael Krufky1963c902005-08-08 09:22:43 -0700149static int lgdt3303_SwReset(struct lgdt330x_state* state)
150{
151 u8 ret;
152 u8 reset[] = {
153 0x02,
154 0x00 /* bit 0 is active low software reset */
155 };
156
157 ret = i2c_write_demod_bytes(state,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700158 reset, sizeof(reset));
Michael Krufky1963c902005-08-08 09:22:43 -0700159 if (ret == 0) {
160
161 /* force reset high (inactive) */
162 reset[1] = 0x01;
163 ret = i2c_write_demod_bytes(state,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700164 reset, sizeof(reset));
Michael Krufky1963c902005-08-08 09:22:43 -0700165 }
166 return ret;
167}
168
169static int lgdt330x_SwReset(struct lgdt330x_state* state)
170{
171 switch (state->config->demod_chip) {
172 case LGDT3302:
173 return lgdt3302_SwReset(state);
174 case LGDT3303:
175 return lgdt3303_SwReset(state);
176 default:
177 return -ENODEV;
178 }
179}
180
Michael Krufky6ddcc912005-07-27 11:46:00 -0700181static int lgdt330x_init(struct dvb_frontend* fe)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700182{
183 /* Hardware reset is done using gpio[0] of cx23880x chip.
184 * I'd like to do it here, but don't know how to find chip address.
185 * cx88-cards.c arranges for the reset bit to be inactive (high).
186 * Maybe there needs to be a callable function in cx88-core or
187 * the caller of this function needs to do it. */
188
Michael Krufky1963c902005-08-08 09:22:43 -0700189 /*
190 * Array of byte pairs <address, value>
191 * to initialize each different chip
192 */
193 static u8 lgdt3302_init_data[] = {
194 /* Use 50MHz parameter values from spec sheet since xtal is 50 */
195 /* Change the value of NCOCTFV[25:0] of carrier
196 recovery center frequency register */
197 VSB_CARRIER_FREQ0, 0x00,
198 VSB_CARRIER_FREQ1, 0x87,
199 VSB_CARRIER_FREQ2, 0x8e,
200 VSB_CARRIER_FREQ3, 0x01,
201 /* Change the TPCLK pin polarity
202 data is valid on falling clock */
203 DEMUX_CONTROL, 0xfb,
204 /* Change the value of IFBW[11:0] of
205 AGC IF/RF loop filter bandwidth register */
206 AGC_RF_BANDWIDTH0, 0x40,
207 AGC_RF_BANDWIDTH1, 0x93,
208 AGC_RF_BANDWIDTH2, 0x00,
209 /* Change the value of bit 6, 'nINAGCBY' and
210 'NSSEL[1:0] of ACG function control register 2 */
211 AGC_FUNC_CTRL2, 0xc6,
212 /* Change the value of bit 6 'RFFIX'
213 of AGC function control register 3 */
214 AGC_FUNC_CTRL3, 0x40,
215 /* Set the value of 'INLVTHD' register 0x2a/0x2c
216 to 0x7fe */
217 AGC_DELAY0, 0x07,
218 AGC_DELAY2, 0xfe,
219 /* Change the value of IAGCBW[15:8]
Adrian Bunk9aaeded2006-06-30 18:19:55 +0200220 of inner AGC loop filter bandwidth */
Michael Krufky1963c902005-08-08 09:22:43 -0700221 AGC_LOOP_BANDWIDTH0, 0x08,
222 AGC_LOOP_BANDWIDTH1, 0x9a
223 };
224
225 static u8 lgdt3303_init_data[] = {
226 0x4c, 0x14
227 };
228
Michael Krufkyc0f4c0a2008-06-28 02:06:50 -0300229 static u8 flip_1_lgdt3303_init_data[] = {
Michael Krufkyc0b11b92005-11-08 21:35:32 -0800230 0x4c, 0x14,
231 0x87, 0xf3
232 };
233
Michael Krufkyc0f4c0a2008-06-28 02:06:50 -0300234 static u8 flip_2_lgdt3303_init_data[] = {
235 0x4c, 0x14,
236 0x87, 0xda
237 };
238
Michael Krufky1963c902005-08-08 09:22:43 -0700239 struct lgdt330x_state* state = fe->demodulator_priv;
240 char *chip_name;
241 int err;
242
243 switch (state->config->demod_chip) {
244 case LGDT3302:
245 chip_name = "LGDT3302";
246 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700247 sizeof(lgdt3302_init_data));
248 break;
Michael Krufky1963c902005-08-08 09:22:43 -0700249 case LGDT3303:
250 chip_name = "LGDT3303";
Michael Krufkyc0f4c0a2008-06-28 02:06:50 -0300251 switch (state->config->clock_polarity_flip) {
252 case 2:
253 err = i2c_write_demod_bytes(state,
254 flip_2_lgdt3303_init_data,
255 sizeof(flip_2_lgdt3303_init_data));
256 break;
257 case 1:
258 err = i2c_write_demod_bytes(state,
259 flip_1_lgdt3303_init_data,
260 sizeof(flip_1_lgdt3303_init_data));
261 break;
262 case 0:
263 default:
Michael Krufkyc0b11b92005-11-08 21:35:32 -0800264 err = i2c_write_demod_bytes(state, lgdt3303_init_data,
265 sizeof(lgdt3303_init_data));
266 }
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700267 break;
Michael Krufky1963c902005-08-08 09:22:43 -0700268 default:
269 chip_name = "undefined";
270 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
271 err = -ENODEV;
272 }
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300273 dprintk("%s entered as %s\n", __func__, chip_name);
Michael Krufky1963c902005-08-08 09:22:43 -0700274 if (err < 0)
275 return err;
276 return lgdt330x_SwReset(state);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700277}
278
Michael Krufky6ddcc912005-07-27 11:46:00 -0700279static int lgdt330x_read_ber(struct dvb_frontend* fe, u32* ber)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700280{
Michael Krufky1963c902005-08-08 09:22:43 -0700281 *ber = 0; /* Not supplied by the demod chips */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700282 return 0;
283}
284
Michael Krufky6ddcc912005-07-27 11:46:00 -0700285static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700286{
Michael Krufky1963c902005-08-08 09:22:43 -0700287 struct lgdt330x_state* state = fe->demodulator_priv;
288 int err;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700289 u8 buf[2];
290
Michael Krufky26110da2011-12-15 10:16:09 -0300291 *ucblocks = 0;
292
Michael Krufky1963c902005-08-08 09:22:43 -0700293 switch (state->config->demod_chip) {
294 case LGDT3302:
295 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700296 buf, sizeof(buf));
297 break;
Michael Krufky1963c902005-08-08 09:22:43 -0700298 case LGDT3303:
299 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700300 buf, sizeof(buf));
301 break;
Michael Krufky1963c902005-08-08 09:22:43 -0700302 default:
303 printk(KERN_WARNING
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700304 "Only LGDT3302 and LGDT3303 are supported chips.\n");
Michael Krufky1963c902005-08-08 09:22:43 -0700305 err = -ENODEV;
306 }
Michael Krufky26110da2011-12-15 10:16:09 -0300307 if (err < 0)
308 return err;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700309
310 *ucblocks = (buf[0] << 8) | buf[1];
311 return 0;
312}
313
Michael Krufky6ddcc912005-07-27 11:46:00 -0700314static int lgdt330x_set_parameters(struct dvb_frontend* fe,
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700315 struct dvb_frontend_parameters *param)
316{
Michael Krufky1963c902005-08-08 09:22:43 -0700317 /*
318 * Array of byte pairs <address, value>
319 * to initialize 8VSB for lgdt3303 chip 50 MHz IF
320 */
321 static u8 lgdt3303_8vsb_44_data[] = {
322 0x04, 0x00,
323 0x0d, 0x40,
Michael Krufky0b6389f2006-11-28 02:35:02 -0300324 0x0e, 0x87,
325 0x0f, 0x8e,
326 0x10, 0x01,
327 0x47, 0x8b };
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700328
Michael Krufky1963c902005-08-08 09:22:43 -0700329 /*
330 * Array of byte pairs <address, value>
331 * to initialize QAM for lgdt3303 chip
332 */
333 static u8 lgdt3303_qam_data[] = {
334 0x04, 0x00,
335 0x0d, 0x00,
336 0x0e, 0x00,
337 0x0f, 0x00,
338 0x10, 0x00,
339 0x51, 0x63,
340 0x47, 0x66,
341 0x48, 0x66,
342 0x4d, 0x1a,
343 0x49, 0x08,
344 0x4a, 0x9b };
345
346 struct lgdt330x_state* state = fe->demodulator_priv;
347
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700348 static u8 top_ctrl_cfg[] = { TOP_CONTROL, 0x03 };
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700349
Michael Krufky1963c902005-08-08 09:22:43 -0700350 int err;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700351 /* Change only if we are actually changing the modulation */
352 if (state->current_modulation != param->u.vsb.modulation) {
353 switch(param->u.vsb.modulation) {
354 case VSB_8:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300355 dprintk("%s: VSB_8 MODE\n", __func__);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700356
Michael Krufky1963c902005-08-08 09:22:43 -0700357 /* Select VSB mode */
358 top_ctrl_cfg[1] = 0x03;
Michael Krufky0ccef6d2005-07-27 11:45:55 -0700359
360 /* Select ANT connector if supported by card */
361 if (state->config->pll_rf_set)
362 state->config->pll_rf_set(fe, 1);
Michael Krufky1963c902005-08-08 09:22:43 -0700363
364 if (state->config->demod_chip == LGDT3303) {
365 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700366 sizeof(lgdt3303_8vsb_44_data));
Michael Krufky1963c902005-08-08 09:22:43 -0700367 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700368 break;
369
370 case QAM_64:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300371 dprintk("%s: QAM_64 MODE\n", __func__);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700372
Michael Krufky1963c902005-08-08 09:22:43 -0700373 /* Select QAM_64 mode */
374 top_ctrl_cfg[1] = 0x00;
Michael Krufky0ccef6d2005-07-27 11:45:55 -0700375
376 /* Select CABLE connector if supported by card */
377 if (state->config->pll_rf_set)
378 state->config->pll_rf_set(fe, 0);
Michael Krufky1963c902005-08-08 09:22:43 -0700379
380 if (state->config->demod_chip == LGDT3303) {
381 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
382 sizeof(lgdt3303_qam_data));
383 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700384 break;
385
386 case QAM_256:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300387 dprintk("%s: QAM_256 MODE\n", __func__);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700388
Michael Krufky1963c902005-08-08 09:22:43 -0700389 /* Select QAM_256 mode */
390 top_ctrl_cfg[1] = 0x01;
Michael Krufky0ccef6d2005-07-27 11:45:55 -0700391
392 /* Select CABLE connector if supported by card */
393 if (state->config->pll_rf_set)
394 state->config->pll_rf_set(fe, 0);
Michael Krufky1963c902005-08-08 09:22:43 -0700395
396 if (state->config->demod_chip == LGDT3303) {
397 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
398 sizeof(lgdt3303_qam_data));
399 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700400 break;
401 default:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300402 printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __func__, param->u.vsb.modulation);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700403 return -1;
404 }
Michael Krufky1963c902005-08-08 09:22:43 -0700405 /*
406 * select serial or parallel MPEG harware interface
407 * Serial: 0x04 for LGDT3302 or 0x40 for LGDT3303
408 * Parallel: 0x00
409 */
410 top_ctrl_cfg[1] |= state->config->serial_mpeg;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700411
412 /* Select the requested mode */
Michael Krufky1963c902005-08-08 09:22:43 -0700413 i2c_write_demod_bytes(state, top_ctrl_cfg,
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700414 sizeof(top_ctrl_cfg));
415 if (state->config->set_ts_params)
416 state->config->set_ts_params(fe, 0);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700417 state->current_modulation = param->u.vsb.modulation;
418 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700419
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700420 /* Tune to the specified frequency */
Patrick Boettcherdea74862006-05-14 05:01:31 -0300421 if (fe->ops.tuner_ops.set_params) {
422 fe->ops.tuner_ops.set_params(fe, param);
423 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
Andrew de Quincey02269f32006-04-18 17:47:11 -0300424 }
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700425
426 /* Keep track of the new frequency */
Mauro Carvalho Chehab4302c152006-01-09 15:25:22 -0200427 /* FIXME this is the wrong way to do this... */
428 /* The tuner is shared with the video4linux analog API */
Michael Krufkydc9ca2a2005-09-06 15:19:40 -0700429 state->current_frequency = param->frequency;
430
Michael Krufky6ddcc912005-07-27 11:46:00 -0700431 lgdt330x_SwReset(state);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700432 return 0;
433}
434
Michael Krufky6ddcc912005-07-27 11:46:00 -0700435static int lgdt330x_get_frontend(struct dvb_frontend* fe,
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700436 struct dvb_frontend_parameters* param)
437{
Michael Krufky6ddcc912005-07-27 11:46:00 -0700438 struct lgdt330x_state *state = fe->demodulator_priv;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700439 param->frequency = state->current_frequency;
440 return 0;
441}
442
Michael Krufky1963c902005-08-08 09:22:43 -0700443static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700444{
Michael Krufky1963c902005-08-08 09:22:43 -0700445 struct lgdt330x_state* state = fe->demodulator_priv;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700446 u8 buf[3];
447
448 *status = 0; /* Reset status result */
449
Michael Krufky08d80522005-07-07 17:58:43 -0700450 /* AGC status register */
Michael Krufky1963c902005-08-08 09:22:43 -0700451 i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300452 dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
Michael Krufky08d80522005-07-07 17:58:43 -0700453 if ((buf[0] & 0x0c) == 0x8){
454 /* Test signal does not exist flag */
455 /* as well as the AGC lock flag. */
456 *status |= FE_HAS_SIGNAL;
Michael Krufky08d80522005-07-07 17:58:43 -0700457 }
458
Michael Krufky1963c902005-08-08 09:22:43 -0700459 /*
460 * You must set the Mask bits to 1 in the IRQ_MASK in order
461 * to see that status bit in the IRQ_STATUS register.
462 * This is done in SwReset();
463 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700464 /* signal status */
Michael Krufky1963c902005-08-08 09:22:43 -0700465 i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300466 dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __func__, buf[0], buf[1], buf[2]);
Michael Krufky08d80522005-07-07 17:58:43 -0700467
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700468
469 /* sync status */
470 if ((buf[2] & 0x03) == 0x01) {
471 *status |= FE_HAS_SYNC;
472 }
473
474 /* FEC error status */
475 if ((buf[2] & 0x0c) == 0x08) {
476 *status |= FE_HAS_LOCK;
477 *status |= FE_HAS_VITERBI;
478 }
479
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700480 /* Carrier Recovery Lock Status Register */
Michael Krufky1963c902005-08-08 09:22:43 -0700481 i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300482 dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700483 switch (state->current_modulation) {
484 case QAM_256:
485 case QAM_64:
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200486 /* Need to understand why there are 3 lock levels here */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700487 if ((buf[0] & 0x07) == 0x07)
488 *status |= FE_HAS_CARRIER;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700489 break;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700490 case VSB_8:
491 if ((buf[0] & 0x80) == 0x80)
492 *status |= FE_HAS_CARRIER;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700493 break;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700494 default:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300495 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700496 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700497
498 return 0;
499}
500
Michael Krufky1963c902005-08-08 09:22:43 -0700501static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700502{
Michael Krufky1963c902005-08-08 09:22:43 -0700503 struct lgdt330x_state* state = fe->demodulator_priv;
504 int err;
505 u8 buf[3];
506
507 *status = 0; /* Reset status result */
508
509 /* lgdt3303 AGC status register */
510 err = i2c_read_demod_bytes(state, 0x58, buf, 1);
511 if (err < 0)
512 return err;
513
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300514 dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
Michael Krufky1963c902005-08-08 09:22:43 -0700515 if ((buf[0] & 0x21) == 0x01){
516 /* Test input signal does not exist flag */
517 /* as well as the AGC lock flag. */
518 *status |= FE_HAS_SIGNAL;
Michael Krufky1963c902005-08-08 09:22:43 -0700519 }
520
521 /* Carrier Recovery Lock Status Register */
522 i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300523 dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
Michael Krufky1963c902005-08-08 09:22:43 -0700524 switch (state->current_modulation) {
525 case QAM_256:
526 case QAM_64:
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200527 /* Need to understand why there are 3 lock levels here */
Michael Krufky1963c902005-08-08 09:22:43 -0700528 if ((buf[0] & 0x07) == 0x07)
529 *status |= FE_HAS_CARRIER;
530 else
531 break;
532 i2c_read_demod_bytes(state, 0x8a, buf, 1);
533 if ((buf[0] & 0x04) == 0x04)
534 *status |= FE_HAS_SYNC;
535 if ((buf[0] & 0x01) == 0x01)
536 *status |= FE_HAS_LOCK;
537 if ((buf[0] & 0x08) == 0x08)
538 *status |= FE_HAS_VITERBI;
539 break;
540 case VSB_8:
541 if ((buf[0] & 0x80) == 0x80)
542 *status |= FE_HAS_CARRIER;
543 else
544 break;
545 i2c_read_demod_bytes(state, 0x38, buf, 1);
546 if ((buf[0] & 0x02) == 0x00)
547 *status |= FE_HAS_SYNC;
548 if ((buf[0] & 0x01) == 0x01) {
549 *status |= FE_HAS_LOCK;
550 *status |= FE_HAS_VITERBI;
551 }
552 break;
553 default:
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300554 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
Michael Krufky1963c902005-08-08 09:22:43 -0700555 }
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700556 return 0;
557}
558
Trent Piepho19be6852006-10-29 13:35:39 -0300559/* Calculate SNR estimation (scaled by 2^24)
560
561 8-VSB SNR equations from LGDT3302 and LGDT3303 datasheets, QAM
562 equations from LGDT3303 datasheet. VSB is the same between the '02
563 and '03, so maybe QAM is too? Perhaps someone with a newer datasheet
564 that has QAM information could verify?
565
566 For 8-VSB: (two ways, take your pick)
567 LGDT3302:
568 SNR_EQ = 10 * log10(25 * 24^2 / EQ_MSE)
569 LGDT3303:
570 SNR_EQ = 10 * log10(25 * 32^2 / EQ_MSE)
571 LGDT3302 & LGDT3303:
572 SNR_PT = 10 * log10(25 * 32^2 / PT_MSE) (we use this one)
573 For 64-QAM:
574 SNR = 10 * log10( 688128 / MSEQAM)
575 For 256-QAM:
576 SNR = 10 * log10( 696320 / MSEQAM)
577
578 We re-write the snr equation as:
579 SNR * 2^24 = 10*(c - intlog10(MSE))
580 Where for 256-QAM, c = log10(696320) * 2^24, and so on. */
581
582static u32 calculate_snr(u32 mse, u32 c)
Michael Krufky1963c902005-08-08 09:22:43 -0700583{
Trent Piepho19be6852006-10-29 13:35:39 -0300584 if (mse == 0) /* No signal */
585 return 0;
586
587 mse = intlog10(mse);
588 if (mse > c) {
589 /* Negative SNR, which is possible, but realisticly the
590 demod will lose lock before the signal gets this bad. The
591 API only allows for unsigned values, so just return 0 */
592 return 0;
593 }
594 return 10*(c - mse);
Michael Krufky1963c902005-08-08 09:22:43 -0700595}
596
597static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700598{
Michael Krufky6ddcc912005-07-27 11:46:00 -0700599 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
Trent Piepho19be6852006-10-29 13:35:39 -0300600 u8 buf[5]; /* read data buffer */
601 u32 noise; /* noise value */
602 u32 c; /* per-modulation SNR calculation constant */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700603
Trent Piepho19be6852006-10-29 13:35:39 -0300604 switch(state->current_modulation) {
605 case VSB_8:
606 i2c_read_demod_bytes(state, LGDT3302_EQPH_ERR0, buf, 5);
607#ifdef USE_EQMSE
608 /* Use Equalizer Mean-Square Error Register */
609 /* SNR for ranges from -15.61 to +41.58 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700610 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
Trent Piepho19be6852006-10-29 13:35:39 -0300611 c = 69765745; /* log10(25*24^2)*2^24 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700612#else
Trent Piepho19be6852006-10-29 13:35:39 -0300613 /* Use Phase Tracker Mean-Square Error Register */
614 /* SNR for ranges from -13.11 to +44.08 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700615 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
Trent Piepho19be6852006-10-29 13:35:39 -0300616 c = 73957994; /* log10(25*32^2)*2^24 */
617#endif
618 break;
619 case QAM_64:
620 case QAM_256:
621 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
Michael Krufky1963c902005-08-08 09:22:43 -0700622 noise = ((buf[0] & 3) << 8) | buf[1];
Trent Piepho19be6852006-10-29 13:35:39 -0300623 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
624 /* log10(688128)*2^24 and log10(696320)*2^24 */
625 break;
626 default:
627 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300628 __func__);
Trent Piepho19be6852006-10-29 13:35:39 -0300629 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700630 }
631
Trent Piepho19be6852006-10-29 13:35:39 -0300632 state->snr = calculate_snr(noise, c);
633 *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700634
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300635 dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
Trent Piepho19be6852006-10-29 13:35:39 -0300636 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700637
638 return 0;
639}
640
Michael Krufky1963c902005-08-08 09:22:43 -0700641static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
642{
Michael Krufky1963c902005-08-08 09:22:43 -0700643 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
Trent Piepho19be6852006-10-29 13:35:39 -0300644 u8 buf[5]; /* read data buffer */
645 u32 noise; /* noise value */
646 u32 c; /* per-modulation SNR calculation constant */
Michael Krufky1963c902005-08-08 09:22:43 -0700647
Trent Piepho19be6852006-10-29 13:35:39 -0300648 switch(state->current_modulation) {
649 case VSB_8:
650 i2c_read_demod_bytes(state, LGDT3303_EQPH_ERR0, buf, 5);
651#ifdef USE_EQMSE
652 /* Use Equalizer Mean-Square Error Register */
653 /* SNR for ranges from -16.12 to +44.08 */
654 noise = ((buf[0] & 0x78) << 13) | (buf[1] << 8) | buf[2];
655 c = 73957994; /* log10(25*32^2)*2^24 */
656#else
657 /* Use Phase Tracker Mean-Square Error Register */
658 /* SNR for ranges from -13.11 to +44.08 */
Michael Krufky1963c902005-08-08 09:22:43 -0700659 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
Trent Piepho19be6852006-10-29 13:35:39 -0300660 c = 73957994; /* log10(25*32^2)*2^24 */
661#endif
662 break;
663 case QAM_64:
664 case QAM_256:
665 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
Michael Krufky1963c902005-08-08 09:22:43 -0700666 noise = (buf[0] << 8) | buf[1];
Trent Piepho19be6852006-10-29 13:35:39 -0300667 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
668 /* log10(688128)*2^24 and log10(696320)*2^24 */
669 break;
670 default:
671 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300672 __func__);
Trent Piepho19be6852006-10-29 13:35:39 -0300673 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
Michael Krufky1963c902005-08-08 09:22:43 -0700674 }
675
Trent Piepho19be6852006-10-29 13:35:39 -0300676 state->snr = calculate_snr(noise, c);
677 *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
Michael Krufky1963c902005-08-08 09:22:43 -0700678
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300679 dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
Trent Piepho19be6852006-10-29 13:35:39 -0300680 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
681
682 return 0;
683}
684
685static int lgdt330x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
686{
687 /* Calculate Strength from SNR up to 35dB */
688 /* Even though the SNR can go higher than 35dB, there is some comfort */
689 /* factor in having a range of strong signals that can show at 100% */
690 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
691 u16 snr;
692 int ret;
693
694 ret = fe->ops.read_snr(fe, &snr);
695 if (ret != 0)
696 return ret;
697 /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
698 /* scale the range 0 - 35*2^24 into 0 - 65535 */
699 if (state->snr >= 8960 * 0x10000)
700 *strength = 0xffff;
701 else
702 *strength = state->snr / 8960;
Michael Krufky1963c902005-08-08 09:22:43 -0700703
704 return 0;
705}
706
Michael Krufky6ddcc912005-07-27 11:46:00 -0700707static int lgdt330x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700708{
709 /* I have no idea about this - it may not be needed */
710 fe_tune_settings->min_delay_ms = 500;
711 fe_tune_settings->step_size = 0;
712 fe_tune_settings->max_drift = 0;
713 return 0;
714}
715
Michael Krufky6ddcc912005-07-27 11:46:00 -0700716static void lgdt330x_release(struct dvb_frontend* fe)
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700717{
Michael Krufky6ddcc912005-07-27 11:46:00 -0700718 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700719 kfree(state);
720}
721
Michael Krufky1963c902005-08-08 09:22:43 -0700722static struct dvb_frontend_ops lgdt3302_ops;
723static struct dvb_frontend_ops lgdt3303_ops;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700724
Michael Krufky6ddcc912005-07-27 11:46:00 -0700725struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700726 struct i2c_adapter* i2c)
727{
Michael Krufky6ddcc912005-07-27 11:46:00 -0700728 struct lgdt330x_state* state = NULL;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700729 u8 buf[1];
730
731 /* Allocate memory for the internal state */
Panagiotis Issaris74081872006-01-11 19:40:56 -0200732 state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700733 if (state == NULL)
734 goto error;
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700735
736 /* Setup the state */
737 state->config = config;
738 state->i2c = i2c;
Patrick Boettcherdea74862006-05-14 05:01:31 -0300739
740 /* Create dvb_frontend */
Michael Krufky1963c902005-08-08 09:22:43 -0700741 switch (config->demod_chip) {
742 case LGDT3302:
Patrick Boettcherdea74862006-05-14 05:01:31 -0300743 memcpy(&state->frontend.ops, &lgdt3302_ops, sizeof(struct dvb_frontend_ops));
Michael Krufky1963c902005-08-08 09:22:43 -0700744 break;
745 case LGDT3303:
Patrick Boettcherdea74862006-05-14 05:01:31 -0300746 memcpy(&state->frontend.ops, &lgdt3303_ops, sizeof(struct dvb_frontend_ops));
Michael Krufky1963c902005-08-08 09:22:43 -0700747 break;
748 default:
749 goto error;
750 }
Patrick Boettcherdea74862006-05-14 05:01:31 -0300751 state->frontend.demodulator_priv = state;
Michael Krufky1963c902005-08-08 09:22:43 -0700752
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700753 /* Verify communication with demod chip */
Michael Krufky1963c902005-08-08 09:22:43 -0700754 if (i2c_read_demod_bytes(state, 2, buf, 1))
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700755 goto error;
756
757 state->current_frequency = -1;
758 state->current_modulation = -1;
759
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700760 return &state->frontend;
761
762error:
Jesper Juhl2ea75332005-11-07 01:01:31 -0800763 kfree(state);
Harvey Harrison271ddbf2008-04-08 23:20:00 -0300764 dprintk("%s: ERROR\n",__func__);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700765 return NULL;
766}
767
Michael Krufky1963c902005-08-08 09:22:43 -0700768static struct dvb_frontend_ops lgdt3302_ops = {
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700769 .info = {
Michael Krufkye179d8b2005-08-09 17:48:54 -0700770 .name= "LG Electronics LGDT3302 VSB/QAM Frontend",
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700771 .type = FE_ATSC,
772 .frequency_min= 54000000,
773 .frequency_max= 858000000,
774 .frequency_stepsize= 62500,
Michael Krufky66944e92005-11-08 21:35:55 -0800775 .symbol_rate_min = 5056941, /* QAM 64 */
776 .symbol_rate_max = 10762000, /* VSB 8 */
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700777 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
778 },
Michael Krufky6ddcc912005-07-27 11:46:00 -0700779 .init = lgdt330x_init,
780 .set_frontend = lgdt330x_set_parameters,
781 .get_frontend = lgdt330x_get_frontend,
782 .get_tune_settings = lgdt330x_get_tune_settings,
Michael Krufky1963c902005-08-08 09:22:43 -0700783 .read_status = lgdt3302_read_status,
Michael Krufky6ddcc912005-07-27 11:46:00 -0700784 .read_ber = lgdt330x_read_ber,
785 .read_signal_strength = lgdt330x_read_signal_strength,
Michael Krufky1963c902005-08-08 09:22:43 -0700786 .read_snr = lgdt3302_read_snr,
Michael Krufky6ddcc912005-07-27 11:46:00 -0700787 .read_ucblocks = lgdt330x_read_ucblocks,
788 .release = lgdt330x_release,
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700789};
790
Michael Krufky1963c902005-08-08 09:22:43 -0700791static struct dvb_frontend_ops lgdt3303_ops = {
792 .info = {
793 .name= "LG Electronics LGDT3303 VSB/QAM Frontend",
794 .type = FE_ATSC,
795 .frequency_min= 54000000,
796 .frequency_max= 858000000,
797 .frequency_stepsize= 62500,
Michael Krufky66944e92005-11-08 21:35:55 -0800798 .symbol_rate_min = 5056941, /* QAM 64 */
799 .symbol_rate_max = 10762000, /* VSB 8 */
Michael Krufky1963c902005-08-08 09:22:43 -0700800 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
801 },
802 .init = lgdt330x_init,
803 .set_frontend = lgdt330x_set_parameters,
804 .get_frontend = lgdt330x_get_frontend,
805 .get_tune_settings = lgdt330x_get_tune_settings,
806 .read_status = lgdt3303_read_status,
807 .read_ber = lgdt330x_read_ber,
808 .read_signal_strength = lgdt330x_read_signal_strength,
809 .read_snr = lgdt3303_read_snr,
810 .read_ucblocks = lgdt330x_read_ucblocks,
811 .release = lgdt330x_release,
812};
813
814MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700815MODULE_AUTHOR("Wilson Michaels");
816MODULE_LICENSE("GPL");
817
Michael Krufky6ddcc912005-07-27 11:46:00 -0700818EXPORT_SYMBOL(lgdt330x_attach);
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700819
820/*
821 * Local variables:
822 * c-basic-offset: 8
Mac Michaelsd8667cb2005-07-07 17:58:29 -0700823 * End:
824 */