Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * FCI FC2580 silicon tuner driver
0004  *
0005  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
0006  */
0007 
0008 #include "fc2580_priv.h"
0009 
0010 /*
0011  * TODO:
0012  * I2C write and read works only for one single register. Multiple registers
0013  * could not be accessed using normal register address auto-increment.
0014  * There could be (very likely) register to change that behavior....
0015  */
0016 
0017 /* write single register conditionally only when value differs from 0xff
0018  * XXX: This is special routine meant only for writing fc2580_freq_regs_lut[]
0019  * values. Do not use for the other purposes. */
0020 static int fc2580_wr_reg_ff(struct fc2580_dev *dev, u8 reg, u8 val)
0021 {
0022     if (val == 0xff)
0023         return 0;
0024     else
0025         return regmap_write(dev->regmap, reg, val);
0026 }
0027 
0028 static int fc2580_set_params(struct fc2580_dev *dev)
0029 {
0030     struct i2c_client *client = dev->client;
0031     int ret, i;
0032     unsigned int uitmp, div_ref, div_ref_val, div_n, k, k_cw, div_out;
0033     u64 f_vco;
0034     u8 synth_config;
0035     unsigned long timeout;
0036 
0037     if (!dev->active) {
0038         dev_dbg(&client->dev, "tuner is sleeping\n");
0039         return 0;
0040     }
0041 
0042     /*
0043      * Fractional-N synthesizer
0044      *
0045      *                      +---------------------------------------+
0046      *                      v                                       |
0047      *  Fref   +----+     +----+     +-------+         +----+     +------+     +---+
0048      * ------> | /R | --> | PD | --> |  VCO  | ------> | /2 | --> | /N.F | <-- | K |
0049      *         +----+     +----+     +-------+         +----+     +------+     +---+
0050      *                                 |
0051      *                                 |
0052      *                                 v
0053      *                               +-------+  Fout
0054      *                               | /Rout | ------>
0055      *                               +-------+
0056      */
0057     for (i = 0; i < ARRAY_SIZE(fc2580_pll_lut); i++) {
0058         if (dev->f_frequency <= fc2580_pll_lut[i].freq)
0059             break;
0060     }
0061     if (i == ARRAY_SIZE(fc2580_pll_lut)) {
0062         ret = -EINVAL;
0063         goto err;
0064     }
0065 
0066     #define DIV_PRE_N 2
0067     #define F_REF dev->clk
0068     div_out = fc2580_pll_lut[i].div_out;
0069     f_vco = (u64) dev->f_frequency * div_out;
0070     synth_config = fc2580_pll_lut[i].band;
0071     if (f_vco < 2600000000ULL)
0072         synth_config |= 0x06;
0073     else
0074         synth_config |= 0x0e;
0075 
0076     /* select reference divider R (keep PLL div N in valid range) */
0077     #define DIV_N_MIN 76
0078     if (f_vco >= div_u64((u64) DIV_PRE_N * DIV_N_MIN * F_REF, 1)) {
0079         div_ref = 1;
0080         div_ref_val = 0x00;
0081     } else if (f_vco >= div_u64((u64) DIV_PRE_N * DIV_N_MIN * F_REF, 2)) {
0082         div_ref = 2;
0083         div_ref_val = 0x10;
0084     } else {
0085         div_ref = 4;
0086         div_ref_val = 0x20;
0087     }
0088 
0089     /* calculate PLL integer and fractional control word */
0090     uitmp = DIV_PRE_N * F_REF / div_ref;
0091     div_n = div_u64_rem(f_vco, uitmp, &k);
0092     k_cw = div_u64((u64) k * 0x100000, uitmp);
0093 
0094     dev_dbg(&client->dev,
0095         "frequency=%u bandwidth=%u f_vco=%llu F_REF=%u div_ref=%u div_n=%u k=%u div_out=%u k_cw=%0x\n",
0096         dev->f_frequency, dev->f_bandwidth, f_vco, F_REF, div_ref,
0097         div_n, k, div_out, k_cw);
0098 
0099     ret = regmap_write(dev->regmap, 0x02, synth_config);
0100     if (ret)
0101         goto err;
0102 
0103     ret = regmap_write(dev->regmap, 0x18, div_ref_val << 0 | k_cw >> 16);
0104     if (ret)
0105         goto err;
0106 
0107     ret = regmap_write(dev->regmap, 0x1a, (k_cw >> 8) & 0xff);
0108     if (ret)
0109         goto err;
0110 
0111     ret = regmap_write(dev->regmap, 0x1b, (k_cw >> 0) & 0xff);
0112     if (ret)
0113         goto err;
0114 
0115     ret = regmap_write(dev->regmap, 0x1c, div_n);
0116     if (ret)
0117         goto err;
0118 
0119     /* registers */
0120     for (i = 0; i < ARRAY_SIZE(fc2580_freq_regs_lut); i++) {
0121         if (dev->f_frequency <= fc2580_freq_regs_lut[i].freq)
0122             break;
0123     }
0124     if (i == ARRAY_SIZE(fc2580_freq_regs_lut)) {
0125         ret = -EINVAL;
0126         goto err;
0127     }
0128 
0129     ret = fc2580_wr_reg_ff(dev, 0x25, fc2580_freq_regs_lut[i].r25_val);
0130     if (ret)
0131         goto err;
0132 
0133     ret = fc2580_wr_reg_ff(dev, 0x27, fc2580_freq_regs_lut[i].r27_val);
0134     if (ret)
0135         goto err;
0136 
0137     ret = fc2580_wr_reg_ff(dev, 0x28, fc2580_freq_regs_lut[i].r28_val);
0138     if (ret)
0139         goto err;
0140 
0141     ret = fc2580_wr_reg_ff(dev, 0x29, fc2580_freq_regs_lut[i].r29_val);
0142     if (ret)
0143         goto err;
0144 
0145     ret = fc2580_wr_reg_ff(dev, 0x2b, fc2580_freq_regs_lut[i].r2b_val);
0146     if (ret)
0147         goto err;
0148 
0149     ret = fc2580_wr_reg_ff(dev, 0x2c, fc2580_freq_regs_lut[i].r2c_val);
0150     if (ret)
0151         goto err;
0152 
0153     ret = fc2580_wr_reg_ff(dev, 0x2d, fc2580_freq_regs_lut[i].r2d_val);
0154     if (ret)
0155         goto err;
0156 
0157     ret = fc2580_wr_reg_ff(dev, 0x30, fc2580_freq_regs_lut[i].r30_val);
0158     if (ret)
0159         goto err;
0160 
0161     ret = fc2580_wr_reg_ff(dev, 0x44, fc2580_freq_regs_lut[i].r44_val);
0162     if (ret)
0163         goto err;
0164 
0165     ret = fc2580_wr_reg_ff(dev, 0x50, fc2580_freq_regs_lut[i].r50_val);
0166     if (ret)
0167         goto err;
0168 
0169     ret = fc2580_wr_reg_ff(dev, 0x53, fc2580_freq_regs_lut[i].r53_val);
0170     if (ret)
0171         goto err;
0172 
0173     ret = fc2580_wr_reg_ff(dev, 0x5f, fc2580_freq_regs_lut[i].r5f_val);
0174     if (ret)
0175         goto err;
0176 
0177     ret = fc2580_wr_reg_ff(dev, 0x61, fc2580_freq_regs_lut[i].r61_val);
0178     if (ret)
0179         goto err;
0180 
0181     ret = fc2580_wr_reg_ff(dev, 0x62, fc2580_freq_regs_lut[i].r62_val);
0182     if (ret)
0183         goto err;
0184 
0185     ret = fc2580_wr_reg_ff(dev, 0x63, fc2580_freq_regs_lut[i].r63_val);
0186     if (ret)
0187         goto err;
0188 
0189     ret = fc2580_wr_reg_ff(dev, 0x67, fc2580_freq_regs_lut[i].r67_val);
0190     if (ret)
0191         goto err;
0192 
0193     ret = fc2580_wr_reg_ff(dev, 0x68, fc2580_freq_regs_lut[i].r68_val);
0194     if (ret)
0195         goto err;
0196 
0197     ret = fc2580_wr_reg_ff(dev, 0x69, fc2580_freq_regs_lut[i].r69_val);
0198     if (ret)
0199         goto err;
0200 
0201     ret = fc2580_wr_reg_ff(dev, 0x6a, fc2580_freq_regs_lut[i].r6a_val);
0202     if (ret)
0203         goto err;
0204 
0205     ret = fc2580_wr_reg_ff(dev, 0x6b, fc2580_freq_regs_lut[i].r6b_val);
0206     if (ret)
0207         goto err;
0208 
0209     ret = fc2580_wr_reg_ff(dev, 0x6c, fc2580_freq_regs_lut[i].r6c_val);
0210     if (ret)
0211         goto err;
0212 
0213     ret = fc2580_wr_reg_ff(dev, 0x6d, fc2580_freq_regs_lut[i].r6d_val);
0214     if (ret)
0215         goto err;
0216 
0217     ret = fc2580_wr_reg_ff(dev, 0x6e, fc2580_freq_regs_lut[i].r6e_val);
0218     if (ret)
0219         goto err;
0220 
0221     ret = fc2580_wr_reg_ff(dev, 0x6f, fc2580_freq_regs_lut[i].r6f_val);
0222     if (ret)
0223         goto err;
0224 
0225     /* IF filters */
0226     for (i = 0; i < ARRAY_SIZE(fc2580_if_filter_lut); i++) {
0227         if (dev->f_bandwidth <= fc2580_if_filter_lut[i].freq)
0228             break;
0229     }
0230     if (i == ARRAY_SIZE(fc2580_if_filter_lut)) {
0231         ret = -EINVAL;
0232         goto err;
0233     }
0234 
0235     ret = regmap_write(dev->regmap, 0x36, fc2580_if_filter_lut[i].r36_val);
0236     if (ret)
0237         goto err;
0238 
0239     uitmp = (unsigned int) 8058000 - (dev->f_bandwidth * 122 / 100 / 2);
0240     uitmp = div64_u64((u64) dev->clk * uitmp, 1000000000000ULL);
0241     ret = regmap_write(dev->regmap, 0x37, uitmp);
0242     if (ret)
0243         goto err;
0244 
0245     ret = regmap_write(dev->regmap, 0x39, fc2580_if_filter_lut[i].r39_val);
0246     if (ret)
0247         goto err;
0248 
0249     timeout = jiffies + msecs_to_jiffies(30);
0250     for (uitmp = ~0xc0; !time_after(jiffies, timeout) && uitmp != 0xc0;) {
0251         /* trigger filter */
0252         ret = regmap_write(dev->regmap, 0x2e, 0x09);
0253         if (ret)
0254             goto err;
0255 
0256         /* locked when [7:6] are set (val: d7 6MHz, d5 7MHz, cd 8MHz) */
0257         ret = regmap_read(dev->regmap, 0x2f, &uitmp);
0258         if (ret)
0259             goto err;
0260         uitmp &= 0xc0;
0261 
0262         ret = regmap_write(dev->regmap, 0x2e, 0x01);
0263         if (ret)
0264             goto err;
0265     }
0266     if (uitmp != 0xc0)
0267         dev_dbg(&client->dev, "filter did not lock %02x\n", uitmp);
0268 
0269     return 0;
0270 err:
0271     dev_dbg(&client->dev, "failed=%d\n", ret);
0272     return ret;
0273 }
0274 
0275 static int fc2580_init(struct fc2580_dev *dev)
0276 {
0277     struct i2c_client *client = dev->client;
0278     int ret, i;
0279 
0280     dev_dbg(&client->dev, "\n");
0281 
0282     for (i = 0; i < ARRAY_SIZE(fc2580_init_reg_vals); i++) {
0283         ret = regmap_write(dev->regmap, fc2580_init_reg_vals[i].reg,
0284                 fc2580_init_reg_vals[i].val);
0285         if (ret)
0286             goto err;
0287     }
0288 
0289     dev->active = true;
0290     return 0;
0291 err:
0292     dev_dbg(&client->dev, "failed=%d\n", ret);
0293     return ret;
0294 }
0295 
0296 static int fc2580_sleep(struct fc2580_dev *dev)
0297 {
0298     struct i2c_client *client = dev->client;
0299     int ret;
0300 
0301     dev_dbg(&client->dev, "\n");
0302 
0303     dev->active = false;
0304 
0305     ret = regmap_write(dev->regmap, 0x02, 0x0a);
0306     if (ret)
0307         goto err;
0308     return 0;
0309 err:
0310     dev_dbg(&client->dev, "failed=%d\n", ret);
0311     return ret;
0312 }
0313 
0314 /*
0315  * DVB API
0316  */
0317 static int fc2580_dvb_set_params(struct dvb_frontend *fe)
0318 {
0319     struct fc2580_dev *dev = fe->tuner_priv;
0320     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0321 
0322     dev->f_frequency = c->frequency;
0323     dev->f_bandwidth = c->bandwidth_hz;
0324     return fc2580_set_params(dev);
0325 }
0326 
0327 static int fc2580_dvb_init(struct dvb_frontend *fe)
0328 {
0329     return fc2580_init(fe->tuner_priv);
0330 }
0331 
0332 static int fc2580_dvb_sleep(struct dvb_frontend *fe)
0333 {
0334     return fc2580_sleep(fe->tuner_priv);
0335 }
0336 
0337 static int fc2580_dvb_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
0338 {
0339     *frequency = 0; /* Zero-IF */
0340     return 0;
0341 }
0342 
0343 static const struct dvb_tuner_ops fc2580_dvb_tuner_ops = {
0344     .info = {
0345         .name             = "FCI FC2580",
0346         .frequency_min_hz = 174 * MHz,
0347         .frequency_max_hz = 862 * MHz,
0348     },
0349 
0350     .init = fc2580_dvb_init,
0351     .sleep = fc2580_dvb_sleep,
0352     .set_params = fc2580_dvb_set_params,
0353 
0354     .get_if_frequency = fc2580_dvb_get_if_frequency,
0355 };
0356 
0357 /*
0358  * V4L2 API
0359  */
0360 #if IS_ENABLED(CONFIG_VIDEO_DEV)
0361 static const struct v4l2_frequency_band bands[] = {
0362     {
0363         .type = V4L2_TUNER_RF,
0364         .index = 0,
0365         .capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS,
0366         .rangelow   =   130000000,
0367         .rangehigh  =  2000000000,
0368     },
0369 };
0370 
0371 static inline struct fc2580_dev *fc2580_subdev_to_dev(struct v4l2_subdev *sd)
0372 {
0373     return container_of(sd, struct fc2580_dev, subdev);
0374 }
0375 
0376 static int fc2580_standby(struct v4l2_subdev *sd)
0377 {
0378     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0379     int ret;
0380 
0381     ret = fc2580_sleep(dev);
0382     if (ret)
0383         return ret;
0384 
0385     return fc2580_set_params(dev);
0386 }
0387 
0388 static int fc2580_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *v)
0389 {
0390     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0391     struct i2c_client *client = dev->client;
0392 
0393     dev_dbg(&client->dev, "index=%d\n", v->index);
0394 
0395     strscpy(v->name, "FCI FC2580", sizeof(v->name));
0396     v->type = V4L2_TUNER_RF;
0397     v->capability = V4L2_TUNER_CAP_1HZ | V4L2_TUNER_CAP_FREQ_BANDS;
0398     v->rangelow  = bands[0].rangelow;
0399     v->rangehigh = bands[0].rangehigh;
0400     return 0;
0401 }
0402 
0403 static int fc2580_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *v)
0404 {
0405     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0406     struct i2c_client *client = dev->client;
0407 
0408     dev_dbg(&client->dev, "index=%d\n", v->index);
0409     return 0;
0410 }
0411 
0412 static int fc2580_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
0413 {
0414     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0415     struct i2c_client *client = dev->client;
0416 
0417     dev_dbg(&client->dev, "tuner=%d\n", f->tuner);
0418     f->frequency = dev->f_frequency;
0419     return 0;
0420 }
0421 
0422 static int fc2580_s_frequency(struct v4l2_subdev *sd,
0423                   const struct v4l2_frequency *f)
0424 {
0425     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0426     struct i2c_client *client = dev->client;
0427 
0428     dev_dbg(&client->dev, "tuner=%d type=%d frequency=%u\n",
0429         f->tuner, f->type, f->frequency);
0430 
0431     dev->f_frequency = clamp_t(unsigned int, f->frequency,
0432                    bands[0].rangelow, bands[0].rangehigh);
0433     return fc2580_set_params(dev);
0434 }
0435 
0436 static int fc2580_enum_freq_bands(struct v4l2_subdev *sd,
0437                   struct v4l2_frequency_band *band)
0438 {
0439     struct fc2580_dev *dev = fc2580_subdev_to_dev(sd);
0440     struct i2c_client *client = dev->client;
0441 
0442     dev_dbg(&client->dev, "tuner=%d type=%d index=%d\n",
0443         band->tuner, band->type, band->index);
0444 
0445     if (band->index >= ARRAY_SIZE(bands))
0446         return -EINVAL;
0447 
0448     band->capability = bands[band->index].capability;
0449     band->rangelow = bands[band->index].rangelow;
0450     band->rangehigh = bands[band->index].rangehigh;
0451     return 0;
0452 }
0453 
0454 static const struct v4l2_subdev_tuner_ops fc2580_subdev_tuner_ops = {
0455     .standby                  = fc2580_standby,
0456     .g_tuner                  = fc2580_g_tuner,
0457     .s_tuner                  = fc2580_s_tuner,
0458     .g_frequency              = fc2580_g_frequency,
0459     .s_frequency              = fc2580_s_frequency,
0460     .enum_freq_bands          = fc2580_enum_freq_bands,
0461 };
0462 
0463 static const struct v4l2_subdev_ops fc2580_subdev_ops = {
0464     .tuner                    = &fc2580_subdev_tuner_ops,
0465 };
0466 
0467 static int fc2580_s_ctrl(struct v4l2_ctrl *ctrl)
0468 {
0469     struct fc2580_dev *dev = container_of(ctrl->handler, struct fc2580_dev, hdl);
0470     struct i2c_client *client = dev->client;
0471     int ret;
0472 
0473     dev_dbg(&client->dev, "ctrl: id=%d name=%s cur.val=%d val=%d\n",
0474         ctrl->id, ctrl->name, ctrl->cur.val, ctrl->val);
0475 
0476     switch (ctrl->id) {
0477     case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
0478     case V4L2_CID_RF_TUNER_BANDWIDTH:
0479         /*
0480          * TODO: Auto logic does not work 100% correctly as tuner driver
0481          * do not have information to calculate maximum suitable
0482          * bandwidth. Calculating it is responsible of master driver.
0483          */
0484         dev->f_bandwidth = dev->bandwidth->val;
0485         ret = fc2580_set_params(dev);
0486         break;
0487     default:
0488         dev_dbg(&client->dev, "unknown ctrl");
0489         ret = -EINVAL;
0490     }
0491     return ret;
0492 }
0493 
0494 static const struct v4l2_ctrl_ops fc2580_ctrl_ops = {
0495     .s_ctrl = fc2580_s_ctrl,
0496 };
0497 #endif
0498 
0499 static struct v4l2_subdev *fc2580_get_v4l2_subdev(struct i2c_client *client)
0500 {
0501     struct fc2580_dev *dev = i2c_get_clientdata(client);
0502 
0503     if (dev->subdev.ops)
0504         return &dev->subdev;
0505     else
0506         return NULL;
0507 }
0508 
0509 static int fc2580_probe(struct i2c_client *client,
0510             const struct i2c_device_id *id)
0511 {
0512     struct fc2580_dev *dev;
0513     struct fc2580_platform_data *pdata = client->dev.platform_data;
0514     struct dvb_frontend *fe = pdata->dvb_frontend;
0515     int ret;
0516     unsigned int uitmp;
0517     static const struct regmap_config regmap_config = {
0518         .reg_bits = 8,
0519         .val_bits = 8,
0520     };
0521 
0522     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
0523     if (!dev) {
0524         ret = -ENOMEM;
0525         goto err;
0526     }
0527 
0528     if (pdata->clk)
0529         dev->clk = pdata->clk;
0530     else
0531         dev->clk = 16384000; /* internal clock */
0532     dev->client = client;
0533     dev->regmap = devm_regmap_init_i2c(client, &regmap_config);
0534     if (IS_ERR(dev->regmap)) {
0535         ret = PTR_ERR(dev->regmap);
0536         goto err_kfree;
0537     }
0538 
0539     /* check if the tuner is there */
0540     ret = regmap_read(dev->regmap, 0x01, &uitmp);
0541     if (ret)
0542         goto err_kfree;
0543 
0544     dev_dbg(&client->dev, "chip_id=%02x\n", uitmp);
0545 
0546     switch (uitmp) {
0547     case 0x56:
0548     case 0x5a:
0549         break;
0550     default:
0551         ret = -ENODEV;
0552         goto err_kfree;
0553     }
0554 
0555 #if IS_ENABLED(CONFIG_VIDEO_DEV)
0556     /* Register controls */
0557     v4l2_ctrl_handler_init(&dev->hdl, 2);
0558     dev->bandwidth_auto = v4l2_ctrl_new_std(&dev->hdl, &fc2580_ctrl_ops,
0559                         V4L2_CID_RF_TUNER_BANDWIDTH_AUTO,
0560                         0, 1, 1, 1);
0561     dev->bandwidth = v4l2_ctrl_new_std(&dev->hdl, &fc2580_ctrl_ops,
0562                        V4L2_CID_RF_TUNER_BANDWIDTH,
0563                        3000, 10000000, 1, 3000);
0564     v4l2_ctrl_auto_cluster(2, &dev->bandwidth_auto, 0, false);
0565     if (dev->hdl.error) {
0566         ret = dev->hdl.error;
0567         dev_err(&client->dev, "Could not initialize controls\n");
0568         v4l2_ctrl_handler_free(&dev->hdl);
0569         goto err_kfree;
0570     }
0571     dev->subdev.ctrl_handler = &dev->hdl;
0572     dev->f_frequency = bands[0].rangelow;
0573     dev->f_bandwidth = dev->bandwidth->val;
0574     v4l2_i2c_subdev_init(&dev->subdev, client, &fc2580_subdev_ops);
0575 #endif
0576     fe->tuner_priv = dev;
0577     memcpy(&fe->ops.tuner_ops, &fc2580_dvb_tuner_ops,
0578            sizeof(fe->ops.tuner_ops));
0579     pdata->get_v4l2_subdev = fc2580_get_v4l2_subdev;
0580     i2c_set_clientdata(client, dev);
0581 
0582     dev_info(&client->dev, "FCI FC2580 successfully identified\n");
0583     return 0;
0584 err_kfree:
0585     kfree(dev);
0586 err:
0587     dev_dbg(&client->dev, "failed=%d\n", ret);
0588     return ret;
0589 }
0590 
0591 static int fc2580_remove(struct i2c_client *client)
0592 {
0593     struct fc2580_dev *dev = i2c_get_clientdata(client);
0594 
0595     dev_dbg(&client->dev, "\n");
0596 
0597 #if IS_ENABLED(CONFIG_VIDEO_DEV)
0598     v4l2_ctrl_handler_free(&dev->hdl);
0599 #endif
0600     kfree(dev);
0601     return 0;
0602 }
0603 
0604 static const struct i2c_device_id fc2580_id_table[] = {
0605     {"fc2580", 0},
0606     {}
0607 };
0608 MODULE_DEVICE_TABLE(i2c, fc2580_id_table);
0609 
0610 static struct i2c_driver fc2580_driver = {
0611     .driver = {
0612         .name   = "fc2580",
0613         .suppress_bind_attrs = true,
0614     },
0615     .probe      = fc2580_probe,
0616     .remove     = fc2580_remove,
0617     .id_table   = fc2580_id_table,
0618 };
0619 
0620 module_i2c_driver(fc2580_driver);
0621 
0622 MODULE_DESCRIPTION("FCI FC2580 silicon tuner driver");
0623 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
0624 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!