Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * ZyDAS ZD1301 driver (demodulator)
0004  *
0005  * Copyright (C) 2015 Antti Palosaari <crope@iki.fi>
0006  */
0007 
0008 #include "zd1301_demod.h"
0009 
0010 static u8 zd1301_demod_gain = 0x38;
0011 module_param_named(gain, zd1301_demod_gain, byte, 0644);
0012 MODULE_PARM_DESC(gain, "gain (value: 0x00 - 0x70, default: 0x38)");
0013 
0014 struct zd1301_demod_dev {
0015     struct platform_device *pdev;
0016     struct dvb_frontend frontend;
0017     struct i2c_adapter adapter;
0018     u8 gain;
0019 };
0020 
0021 static int zd1301_demod_wreg(struct zd1301_demod_dev *dev, u16 reg, u8 val)
0022 {
0023     struct platform_device *pdev = dev->pdev;
0024     struct zd1301_demod_platform_data *pdata = pdev->dev.platform_data;
0025 
0026     return pdata->reg_write(pdata->reg_priv, reg, val);
0027 }
0028 
0029 static int zd1301_demod_rreg(struct zd1301_demod_dev *dev, u16 reg, u8 *val)
0030 {
0031     struct platform_device *pdev = dev->pdev;
0032     struct zd1301_demod_platform_data *pdata = pdev->dev.platform_data;
0033 
0034     return pdata->reg_read(pdata->reg_priv, reg, val);
0035 }
0036 
0037 static int zd1301_demod_set_frontend(struct dvb_frontend *fe)
0038 {
0039     struct zd1301_demod_dev *dev = fe->demodulator_priv;
0040     struct platform_device *pdev = dev->pdev;
0041     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0042     int ret;
0043     u32 if_frequency;
0044     u8 r6a50_val;
0045 
0046     dev_dbg(&pdev->dev, "frequency=%u bandwidth_hz=%u\n",
0047         c->frequency, c->bandwidth_hz);
0048 
0049     /* Program tuner */
0050     if (fe->ops.tuner_ops.set_params &&
0051         fe->ops.tuner_ops.get_if_frequency) {
0052         ret = fe->ops.tuner_ops.set_params(fe);
0053         if (ret)
0054             goto err;
0055         ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
0056         if (ret)
0057             goto err;
0058     } else {
0059         ret = -EINVAL;
0060         goto err;
0061     }
0062 
0063     dev_dbg(&pdev->dev, "if_frequency=%u\n", if_frequency);
0064     if (if_frequency != 36150000) {
0065         ret = -EINVAL;
0066         goto err;
0067     }
0068 
0069     switch (c->bandwidth_hz) {
0070     case 6000000:
0071         r6a50_val = 0x78;
0072         break;
0073     case 7000000:
0074         r6a50_val = 0x68;
0075         break;
0076     case 8000000:
0077         r6a50_val = 0x58;
0078         break;
0079     default:
0080         ret = -EINVAL;
0081         goto err;
0082     }
0083 
0084     ret = zd1301_demod_wreg(dev, 0x6a60, 0x11);
0085     if (ret)
0086         goto err;
0087     ret = zd1301_demod_wreg(dev, 0x6a47, 0x46);
0088     if (ret)
0089         goto err;
0090     ret = zd1301_demod_wreg(dev, 0x6a48, 0x46);
0091     if (ret)
0092         goto err;
0093     ret = zd1301_demod_wreg(dev, 0x6a4a, 0x15);
0094     if (ret)
0095         goto err;
0096     ret = zd1301_demod_wreg(dev, 0x6a4b, 0x63);
0097     if (ret)
0098         goto err;
0099     ret = zd1301_demod_wreg(dev, 0x6a5b, 0x99);
0100     if (ret)
0101         goto err;
0102     ret = zd1301_demod_wreg(dev, 0x6a3b, 0x10);
0103     if (ret)
0104         goto err;
0105     ret = zd1301_demod_wreg(dev, 0x6806, 0x01);
0106     if (ret)
0107         goto err;
0108     ret = zd1301_demod_wreg(dev, 0x6a41, 0x08);
0109     if (ret)
0110         goto err;
0111     ret = zd1301_demod_wreg(dev, 0x6a42, 0x46);
0112     if (ret)
0113         goto err;
0114     ret = zd1301_demod_wreg(dev, 0x6a44, 0x14);
0115     if (ret)
0116         goto err;
0117     ret = zd1301_demod_wreg(dev, 0x6a45, 0x67);
0118     if (ret)
0119         goto err;
0120     ret = zd1301_demod_wreg(dev, 0x6a38, 0x00);
0121     if (ret)
0122         goto err;
0123     ret = zd1301_demod_wreg(dev, 0x6a4c, 0x52);
0124     if (ret)
0125         goto err;
0126     ret = zd1301_demod_wreg(dev, 0x6a49, 0x2a);
0127     if (ret)
0128         goto err;
0129     ret = zd1301_demod_wreg(dev, 0x6840, 0x2e);
0130     if (ret)
0131         goto err;
0132     ret = zd1301_demod_wreg(dev, 0x6a50, r6a50_val);
0133     if (ret)
0134         goto err;
0135     ret = zd1301_demod_wreg(dev, 0x6a38, 0x07);
0136     if (ret)
0137         goto err;
0138 
0139     return 0;
0140 err:
0141     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0142     return ret;
0143 }
0144 
0145 static int zd1301_demod_sleep(struct dvb_frontend *fe)
0146 {
0147     struct zd1301_demod_dev *dev = fe->demodulator_priv;
0148     struct platform_device *pdev = dev->pdev;
0149     int ret;
0150 
0151     dev_dbg(&pdev->dev, "\n");
0152 
0153     ret = zd1301_demod_wreg(dev, 0x6a43, 0x70);
0154     if (ret)
0155         goto err;
0156     ret = zd1301_demod_wreg(dev, 0x684e, 0x00);
0157     if (ret)
0158         goto err;
0159     ret = zd1301_demod_wreg(dev, 0x6849, 0x00);
0160     if (ret)
0161         goto err;
0162     ret = zd1301_demod_wreg(dev, 0x68e2, 0xd7);
0163     if (ret)
0164         goto err;
0165     ret = zd1301_demod_wreg(dev, 0x68e0, 0x39);
0166     if (ret)
0167         goto err;
0168     ret = zd1301_demod_wreg(dev, 0x6840, 0x21);
0169     if (ret)
0170         goto err;
0171 
0172     return 0;
0173 err:
0174     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0175     return ret;
0176 }
0177 
0178 static int zd1301_demod_init(struct dvb_frontend *fe)
0179 {
0180     struct zd1301_demod_dev *dev = fe->demodulator_priv;
0181     struct platform_device *pdev = dev->pdev;
0182     int ret;
0183 
0184     dev_dbg(&pdev->dev, "\n");
0185 
0186     ret = zd1301_demod_wreg(dev, 0x6840, 0x26);
0187     if (ret)
0188         goto err;
0189     ret = zd1301_demod_wreg(dev, 0x68e0, 0xff);
0190     if (ret)
0191         goto err;
0192     ret = zd1301_demod_wreg(dev, 0x68e2, 0xd8);
0193     if (ret)
0194         goto err;
0195     ret = zd1301_demod_wreg(dev, 0x6849, 0x4e);
0196     if (ret)
0197         goto err;
0198     ret = zd1301_demod_wreg(dev, 0x684e, 0x01);
0199     if (ret)
0200         goto err;
0201     ret = zd1301_demod_wreg(dev, 0x6a43, zd1301_demod_gain);
0202     if (ret)
0203         goto err;
0204 
0205     return 0;
0206 err:
0207     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0208     return ret;
0209 }
0210 
0211 static int zd1301_demod_get_tune_settings(struct dvb_frontend *fe,
0212                       struct dvb_frontend_tune_settings *settings)
0213 {
0214     struct zd1301_demod_dev *dev = fe->demodulator_priv;
0215     struct platform_device *pdev = dev->pdev;
0216 
0217     dev_dbg(&pdev->dev, "\n");
0218 
0219     /* ~180ms seems to be enough */
0220     settings->min_delay_ms = 400;
0221 
0222     return 0;
0223 }
0224 
0225 static int zd1301_demod_read_status(struct dvb_frontend *fe,
0226                     enum fe_status *status)
0227 {
0228     struct zd1301_demod_dev *dev = fe->demodulator_priv;
0229     struct platform_device *pdev = dev->pdev;
0230     int ret;
0231     u8 u8tmp;
0232 
0233     ret = zd1301_demod_rreg(dev, 0x6a24, &u8tmp);
0234     if (ret)
0235         goto err;
0236     if (u8tmp > 0x00 && u8tmp < 0x20)
0237         *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
0238               FE_HAS_SYNC | FE_HAS_LOCK;
0239     else
0240         *status = 0;
0241 
0242     dev_dbg(&pdev->dev, "lock byte=%02x\n", u8tmp);
0243 
0244     /*
0245      * Interesting registers here are:
0246      * 0x6a05: get some gain value
0247      * 0x6a06: get about same gain value than set to 0x6a43
0248      * 0x6a07: get some gain value
0249      * 0x6a43: set gain value by driver
0250      * 0x6a24: get demod lock bits (FSM stage?)
0251      *
0252      * Driver should implement some kind of algorithm to calculate suitable
0253      * value for register 0x6a43, based likely values from register 0x6a05
0254      * and 0x6a07. Looks like gain register 0x6a43 value could be from
0255      * range 0x00 - 0x70.
0256      */
0257 
0258     if (dev->gain != zd1301_demod_gain) {
0259         dev->gain = zd1301_demod_gain;
0260 
0261         ret = zd1301_demod_wreg(dev, 0x6a43, dev->gain);
0262         if (ret)
0263             goto err;
0264     }
0265 
0266     return 0;
0267 err:
0268     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0269     return ret;
0270 }
0271 
0272 static const struct dvb_frontend_ops zd1301_demod_ops = {
0273     .delsys = {SYS_DVBT},
0274     .info = {
0275         .name = "ZyDAS ZD1301",
0276         .caps = FE_CAN_FEC_1_2 |
0277             FE_CAN_FEC_2_3 |
0278             FE_CAN_FEC_3_4 |
0279             FE_CAN_FEC_5_6 |
0280             FE_CAN_FEC_7_8 |
0281             FE_CAN_FEC_AUTO |
0282             FE_CAN_QPSK |
0283             FE_CAN_QAM_16 |
0284             FE_CAN_QAM_64 |
0285             FE_CAN_QAM_AUTO |
0286             FE_CAN_TRANSMISSION_MODE_AUTO |
0287             FE_CAN_GUARD_INTERVAL_AUTO |
0288             FE_CAN_HIERARCHY_AUTO |
0289             FE_CAN_MUTE_TS
0290     },
0291 
0292     .sleep = zd1301_demod_sleep,
0293     .init = zd1301_demod_init,
0294     .set_frontend = zd1301_demod_set_frontend,
0295     .get_tune_settings = zd1301_demod_get_tune_settings,
0296     .read_status = zd1301_demod_read_status,
0297 };
0298 
0299 struct dvb_frontend *zd1301_demod_get_dvb_frontend(struct platform_device *pdev)
0300 {
0301     struct zd1301_demod_dev *dev = platform_get_drvdata(pdev);
0302 
0303     dev_dbg(&pdev->dev, "\n");
0304 
0305     return &dev->frontend;
0306 }
0307 EXPORT_SYMBOL(zd1301_demod_get_dvb_frontend);
0308 
0309 static int zd1301_demod_i2c_master_xfer(struct i2c_adapter *adapter,
0310                     struct i2c_msg msg[], int num)
0311 {
0312     struct zd1301_demod_dev *dev = i2c_get_adapdata(adapter);
0313     struct platform_device *pdev = dev->pdev;
0314     int ret, i;
0315     unsigned long timeout;
0316     u8 u8tmp;
0317 
0318     #define I2C_XFER_TIMEOUT 5
0319     #define ZD1301_IS_I2C_XFER_WRITE_READ(_msg, _num) \
0320         (_num == 2 && !(_msg[0].flags & I2C_M_RD) && (_msg[1].flags & I2C_M_RD))
0321     #define ZD1301_IS_I2C_XFER_WRITE(_msg, _num) \
0322         (_num == 1 && !(_msg[0].flags & I2C_M_RD))
0323     #define ZD1301_IS_I2C_XFER_READ(_msg, _num) \
0324         (_num == 1 && (_msg[0].flags & I2C_M_RD))
0325     if (ZD1301_IS_I2C_XFER_WRITE_READ(msg, num)) {
0326         dev_dbg(&pdev->dev, "write&read msg[0].len=%u msg[1].len=%u\n",
0327             msg[0].len, msg[1].len);
0328         if (msg[0].len > 1 || msg[1].len > 8) {
0329             ret = -EOPNOTSUPP;
0330             goto err;
0331         }
0332 
0333         ret = zd1301_demod_wreg(dev, 0x6811, 0x80);
0334         if (ret)
0335             goto err;
0336         ret = zd1301_demod_wreg(dev, 0x6812, 0x05);
0337         if (ret)
0338             goto err;
0339         ret = zd1301_demod_wreg(dev, 0x6813, msg[1].addr << 1);
0340         if (ret)
0341             goto err;
0342         ret = zd1301_demod_wreg(dev, 0x6801, msg[0].buf[0]);
0343         if (ret)
0344             goto err;
0345         ret = zd1301_demod_wreg(dev, 0x6802, 0x00);
0346         if (ret)
0347             goto err;
0348         ret = zd1301_demod_wreg(dev, 0x6803, 0x06);
0349         if (ret)
0350             goto err;
0351         ret = zd1301_demod_wreg(dev, 0x6805, 0x00);
0352         if (ret)
0353             goto err;
0354         ret = zd1301_demod_wreg(dev, 0x6804, msg[1].len);
0355         if (ret)
0356             goto err;
0357 
0358         /* Poll xfer ready */
0359         timeout = jiffies + msecs_to_jiffies(I2C_XFER_TIMEOUT);
0360         for (u8tmp = 1; !time_after(jiffies, timeout) && u8tmp;) {
0361             usleep_range(500, 800);
0362 
0363             ret = zd1301_demod_rreg(dev, 0x6804, &u8tmp);
0364             if (ret)
0365                 goto err;
0366         }
0367 
0368         for (i = 0; i < msg[1].len; i++) {
0369             ret = zd1301_demod_rreg(dev, 0x0600 + i, &msg[1].buf[i]);
0370             if (ret)
0371                 goto err;
0372         }
0373     } else if (ZD1301_IS_I2C_XFER_WRITE(msg, num)) {
0374         dev_dbg(&pdev->dev, "write msg[0].len=%u\n", msg[0].len);
0375         if (msg[0].len > 1 + 8) {
0376             ret = -EOPNOTSUPP;
0377             goto err;
0378         }
0379 
0380         ret = zd1301_demod_wreg(dev, 0x6811, 0x80);
0381         if (ret)
0382             goto err;
0383         ret = zd1301_demod_wreg(dev, 0x6812, 0x01);
0384         if (ret)
0385             goto err;
0386         ret = zd1301_demod_wreg(dev, 0x6813, msg[0].addr << 1);
0387         if (ret)
0388             goto err;
0389         ret = zd1301_demod_wreg(dev, 0x6800, msg[0].buf[0]);
0390         if (ret)
0391             goto err;
0392         ret = zd1301_demod_wreg(dev, 0x6802, 0x00);
0393         if (ret)
0394             goto err;
0395         ret = zd1301_demod_wreg(dev, 0x6803, 0x06);
0396         if (ret)
0397             goto err;
0398 
0399         for (i = 0; i < msg[0].len - 1; i++) {
0400             ret = zd1301_demod_wreg(dev, 0x0600 + i, msg[0].buf[1 + i]);
0401             if (ret)
0402                 goto err;
0403         }
0404 
0405         ret = zd1301_demod_wreg(dev, 0x6805, 0x80);
0406         if (ret)
0407             goto err;
0408         ret = zd1301_demod_wreg(dev, 0x6804, msg[0].len - 1);
0409         if (ret)
0410             goto err;
0411 
0412         /* Poll xfer ready */
0413         timeout = jiffies + msecs_to_jiffies(I2C_XFER_TIMEOUT);
0414         for (u8tmp = 1; !time_after(jiffies, timeout) && u8tmp;) {
0415             usleep_range(500, 800);
0416 
0417             ret = zd1301_demod_rreg(dev, 0x6804, &u8tmp);
0418             if (ret)
0419                 goto err;
0420         }
0421     } else {
0422         dev_dbg(&pdev->dev, "unknown msg[0].len=%u\n", msg[0].len);
0423         ret = -EOPNOTSUPP;
0424         goto err;
0425     }
0426 
0427     return num;
0428 err:
0429     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0430     return ret;
0431 }
0432 
0433 static u32 zd1301_demod_i2c_functionality(struct i2c_adapter *adapter)
0434 {
0435     return I2C_FUNC_I2C;
0436 }
0437 
0438 static const struct i2c_algorithm zd1301_demod_i2c_algorithm = {
0439     .master_xfer   = zd1301_demod_i2c_master_xfer,
0440     .functionality = zd1301_demod_i2c_functionality,
0441 };
0442 
0443 struct i2c_adapter *zd1301_demod_get_i2c_adapter(struct platform_device *pdev)
0444 {
0445     struct zd1301_demod_dev *dev = platform_get_drvdata(pdev);
0446 
0447     dev_dbg(&pdev->dev, "\n");
0448 
0449     return &dev->adapter;
0450 }
0451 EXPORT_SYMBOL(zd1301_demod_get_i2c_adapter);
0452 
0453 /* Platform driver interface */
0454 static int zd1301_demod_probe(struct platform_device *pdev)
0455 {
0456     struct zd1301_demod_dev *dev;
0457     struct zd1301_demod_platform_data *pdata = pdev->dev.platform_data;
0458     int ret;
0459 
0460     dev_dbg(&pdev->dev, "\n");
0461 
0462     if (!pdata) {
0463         ret = -EINVAL;
0464         dev_err(&pdev->dev, "cannot proceed without platform data\n");
0465         goto err;
0466     }
0467     if (!pdev->dev.parent->driver) {
0468         ret = -EINVAL;
0469         dev_dbg(&pdev->dev, "no parent device\n");
0470         goto err;
0471     }
0472 
0473     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
0474     if (!dev) {
0475         ret = -ENOMEM;
0476         goto err;
0477     }
0478 
0479     /* Setup the state */
0480     dev->pdev = pdev;
0481     dev->gain = zd1301_demod_gain;
0482 
0483     /* Sleep */
0484     ret = zd1301_demod_wreg(dev, 0x6840, 0x21);
0485     if (ret)
0486         goto err_kfree;
0487     ret = zd1301_demod_wreg(dev, 0x6a38, 0x07);
0488     if (ret)
0489         goto err_kfree;
0490 
0491     /* Create I2C adapter */
0492     strscpy(dev->adapter.name, "ZyDAS ZD1301 demod",
0493         sizeof(dev->adapter.name));
0494     dev->adapter.algo = &zd1301_demod_i2c_algorithm;
0495     dev->adapter.algo_data = NULL;
0496     dev->adapter.dev.parent = pdev->dev.parent;
0497     i2c_set_adapdata(&dev->adapter, dev);
0498     ret = i2c_add_adapter(&dev->adapter);
0499     if (ret) {
0500         dev_err(&pdev->dev, "I2C adapter add failed %d\n", ret);
0501         goto err_kfree;
0502     }
0503 
0504     /* Create dvb frontend */
0505     memcpy(&dev->frontend.ops, &zd1301_demod_ops, sizeof(dev->frontend.ops));
0506     dev->frontend.demodulator_priv = dev;
0507     platform_set_drvdata(pdev, dev);
0508     dev_info(&pdev->dev, "ZyDAS ZD1301 demod attached\n");
0509 
0510     return 0;
0511 err_kfree:
0512     kfree(dev);
0513 err:
0514     dev_dbg(&pdev->dev, "failed=%d\n", ret);
0515     return ret;
0516 }
0517 
0518 static int zd1301_demod_remove(struct platform_device *pdev)
0519 {
0520     struct zd1301_demod_dev *dev = platform_get_drvdata(pdev);
0521 
0522     dev_dbg(&pdev->dev, "\n");
0523 
0524     i2c_del_adapter(&dev->adapter);
0525     kfree(dev);
0526 
0527     return 0;
0528 }
0529 
0530 static struct platform_driver zd1301_demod_driver = {
0531     .driver = {
0532         .name                = "zd1301_demod",
0533         .suppress_bind_attrs = true,
0534     },
0535     .probe          = zd1301_demod_probe,
0536     .remove         = zd1301_demod_remove,
0537 };
0538 module_platform_driver(zd1301_demod_driver);
0539 
0540 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
0541 MODULE_DESCRIPTION("ZyDAS ZD1301 demodulator driver");
0542 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!