Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Sony CXD2820R demodulator driver
0004  *
0005  * Copyright (C) 2010 Antti Palosaari <crope@iki.fi>
0006  */
0007 
0008 
0009 #include "cxd2820r_priv.h"
0010 
0011 /* Write register table */
0012 int cxd2820r_wr_reg_val_mask_tab(struct cxd2820r_priv *priv,
0013                  const struct reg_val_mask *tab, int tab_len)
0014 {
0015     struct i2c_client *client = priv->client[0];
0016     int ret;
0017     unsigned int i, reg, mask, val;
0018     struct regmap *regmap;
0019 
0020     dev_dbg(&client->dev, "tab_len=%d\n", tab_len);
0021 
0022     for (i = 0; i < tab_len; i++) {
0023         if ((tab[i].reg >> 16) & 0x1)
0024             regmap = priv->regmap[1];
0025         else
0026             regmap = priv->regmap[0];
0027 
0028         reg = (tab[i].reg >> 0) & 0xffff;
0029         val = tab[i].val;
0030         mask = tab[i].mask;
0031 
0032         if (mask == 0xff)
0033             ret = regmap_write(regmap, reg, val);
0034         else
0035             ret = regmap_write_bits(regmap, reg, mask, val);
0036         if (ret)
0037             goto error;
0038     }
0039 
0040     return 0;
0041 error:
0042     dev_dbg(&client->dev, "failed=%d\n", ret);
0043     return ret;
0044 }
0045 
0046 int cxd2820r_gpio(struct dvb_frontend *fe, u8 *gpio)
0047 {
0048     struct cxd2820r_priv *priv = fe->demodulator_priv;
0049     struct i2c_client *client = priv->client[0];
0050     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0051     int ret, i;
0052     u8 tmp0, tmp1;
0053 
0054     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0055 
0056     /* update GPIOs only when needed */
0057     if (!memcmp(gpio, priv->gpio, sizeof(priv->gpio)))
0058         return 0;
0059 
0060     tmp0 = 0x00;
0061     tmp1 = 0x00;
0062     for (i = 0; i < sizeof(priv->gpio); i++) {
0063         /* enable / disable */
0064         if (gpio[i] & CXD2820R_GPIO_E)
0065             tmp0 |= (2 << 6) >> (2 * i);
0066         else
0067             tmp0 |= (1 << 6) >> (2 * i);
0068 
0069         /* input / output */
0070         if (gpio[i] & CXD2820R_GPIO_I)
0071             tmp1 |= (1 << (3 + i));
0072         else
0073             tmp1 |= (0 << (3 + i));
0074 
0075         /* high / low */
0076         if (gpio[i] & CXD2820R_GPIO_H)
0077             tmp1 |= (1 << (0 + i));
0078         else
0079             tmp1 |= (0 << (0 + i));
0080 
0081         dev_dbg(&client->dev, "gpio i=%d %02x %02x\n", i, tmp0, tmp1);
0082     }
0083 
0084     dev_dbg(&client->dev, "wr gpio=%02x %02x\n", tmp0, tmp1);
0085 
0086     /* write bits [7:2] */
0087     ret = regmap_update_bits(priv->regmap[0], 0x0089, 0xfc, tmp0);
0088     if (ret)
0089         goto error;
0090 
0091     /* write bits [5:0] */
0092     ret = regmap_update_bits(priv->regmap[0], 0x008e, 0x3f, tmp1);
0093     if (ret)
0094         goto error;
0095 
0096     memcpy(priv->gpio, gpio, sizeof(priv->gpio));
0097 
0098     return ret;
0099 error:
0100     dev_dbg(&client->dev, "failed=%d\n", ret);
0101     return ret;
0102 }
0103 
0104 static int cxd2820r_set_frontend(struct dvb_frontend *fe)
0105 {
0106     struct cxd2820r_priv *priv = fe->demodulator_priv;
0107     struct i2c_client *client = priv->client[0];
0108     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0109     int ret;
0110 
0111     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0112 
0113     switch (c->delivery_system) {
0114     case SYS_DVBT:
0115         ret = cxd2820r_init_t(fe);
0116         if (ret < 0)
0117             goto err;
0118         ret = cxd2820r_set_frontend_t(fe);
0119         if (ret < 0)
0120             goto err;
0121         break;
0122     case SYS_DVBT2:
0123         ret = cxd2820r_init_t(fe);
0124         if (ret < 0)
0125             goto err;
0126         ret = cxd2820r_set_frontend_t2(fe);
0127         if (ret < 0)
0128             goto err;
0129         break;
0130     case SYS_DVBC_ANNEX_A:
0131         ret = cxd2820r_init_c(fe);
0132         if (ret < 0)
0133             goto err;
0134         ret = cxd2820r_set_frontend_c(fe);
0135         if (ret < 0)
0136             goto err;
0137         break;
0138     default:
0139         dev_dbg(&client->dev, "invalid delivery_system\n");
0140         ret = -EINVAL;
0141         break;
0142     }
0143 err:
0144     return ret;
0145 }
0146 
0147 static int cxd2820r_read_status(struct dvb_frontend *fe, enum fe_status *status)
0148 {
0149     struct cxd2820r_priv *priv = fe->demodulator_priv;
0150     struct i2c_client *client = priv->client[0];
0151     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0152     int ret;
0153 
0154     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0155 
0156     switch (c->delivery_system) {
0157     case SYS_DVBT:
0158         ret = cxd2820r_read_status_t(fe, status);
0159         break;
0160     case SYS_DVBT2:
0161         ret = cxd2820r_read_status_t2(fe, status);
0162         break;
0163     case SYS_DVBC_ANNEX_A:
0164         ret = cxd2820r_read_status_c(fe, status);
0165         break;
0166     default:
0167         ret = -EINVAL;
0168         break;
0169     }
0170     return ret;
0171 }
0172 
0173 static int cxd2820r_get_frontend(struct dvb_frontend *fe,
0174                  struct dtv_frontend_properties *p)
0175 {
0176     struct cxd2820r_priv *priv = fe->demodulator_priv;
0177     struct i2c_client *client = priv->client[0];
0178     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0179     int ret;
0180 
0181     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0182 
0183     if (priv->delivery_system == SYS_UNDEFINED)
0184         return 0;
0185 
0186     switch (c->delivery_system) {
0187     case SYS_DVBT:
0188         ret = cxd2820r_get_frontend_t(fe, p);
0189         break;
0190     case SYS_DVBT2:
0191         ret = cxd2820r_get_frontend_t2(fe, p);
0192         break;
0193     case SYS_DVBC_ANNEX_A:
0194         ret = cxd2820r_get_frontend_c(fe, p);
0195         break;
0196     default:
0197         ret = -EINVAL;
0198         break;
0199     }
0200     return ret;
0201 }
0202 
0203 static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber)
0204 {
0205     struct cxd2820r_priv *priv = fe->demodulator_priv;
0206     struct i2c_client *client = priv->client[0];
0207     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0208 
0209     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0210 
0211     *ber = (priv->post_bit_error - priv->post_bit_error_prev_dvbv3);
0212     priv->post_bit_error_prev_dvbv3 = priv->post_bit_error;
0213 
0214     return 0;
0215 }
0216 
0217 static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
0218 {
0219     struct cxd2820r_priv *priv = fe->demodulator_priv;
0220     struct i2c_client *client = priv->client[0];
0221     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0222 
0223     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0224 
0225     if (c->strength.stat[0].scale == FE_SCALE_RELATIVE)
0226         *strength = c->strength.stat[0].uvalue;
0227     else
0228         *strength = 0;
0229 
0230     return 0;
0231 }
0232 
0233 static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr)
0234 {
0235     struct cxd2820r_priv *priv = fe->demodulator_priv;
0236     struct i2c_client *client = priv->client[0];
0237     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0238 
0239     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0240 
0241     if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
0242         *snr = div_s64(c->cnr.stat[0].svalue, 100);
0243     else
0244         *snr = 0;
0245 
0246     return 0;
0247 }
0248 
0249 static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
0250 {
0251     struct cxd2820r_priv *priv = fe->demodulator_priv;
0252     struct i2c_client *client = priv->client[0];
0253     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0254 
0255     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0256 
0257     *ucblocks = 0;
0258 
0259     return 0;
0260 }
0261 
0262 static int cxd2820r_init(struct dvb_frontend *fe)
0263 {
0264     return 0;
0265 }
0266 
0267 static int cxd2820r_sleep(struct dvb_frontend *fe)
0268 {
0269     struct cxd2820r_priv *priv = fe->demodulator_priv;
0270     struct i2c_client *client = priv->client[0];
0271     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0272     int ret;
0273 
0274     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0275 
0276     switch (c->delivery_system) {
0277     case SYS_DVBT:
0278         ret = cxd2820r_sleep_t(fe);
0279         break;
0280     case SYS_DVBT2:
0281         ret = cxd2820r_sleep_t2(fe);
0282         break;
0283     case SYS_DVBC_ANNEX_A:
0284         ret = cxd2820r_sleep_c(fe);
0285         break;
0286     default:
0287         ret = -EINVAL;
0288         break;
0289     }
0290     return ret;
0291 }
0292 
0293 static int cxd2820r_get_tune_settings(struct dvb_frontend *fe,
0294                       struct dvb_frontend_tune_settings *s)
0295 {
0296     struct cxd2820r_priv *priv = fe->demodulator_priv;
0297     struct i2c_client *client = priv->client[0];
0298     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0299     int ret;
0300 
0301     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0302 
0303     switch (c->delivery_system) {
0304     case SYS_DVBT:
0305         ret = cxd2820r_get_tune_settings_t(fe, s);
0306         break;
0307     case SYS_DVBT2:
0308         ret = cxd2820r_get_tune_settings_t2(fe, s);
0309         break;
0310     case SYS_DVBC_ANNEX_A:
0311         ret = cxd2820r_get_tune_settings_c(fe, s);
0312         break;
0313     default:
0314         ret = -EINVAL;
0315         break;
0316     }
0317     return ret;
0318 }
0319 
0320 static enum dvbfe_search cxd2820r_search(struct dvb_frontend *fe)
0321 {
0322     struct cxd2820r_priv *priv = fe->demodulator_priv;
0323     struct i2c_client *client = priv->client[0];
0324     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0325     int ret, i;
0326     enum fe_status status = 0;
0327 
0328     dev_dbg(&client->dev, "delivery_system=%d\n", c->delivery_system);
0329 
0330     /* switch between DVB-T and DVB-T2 when tune fails */
0331     if (priv->last_tune_failed) {
0332         if (priv->delivery_system == SYS_DVBT) {
0333             ret = cxd2820r_sleep_t(fe);
0334             if (ret)
0335                 goto error;
0336 
0337             c->delivery_system = SYS_DVBT2;
0338         } else if (priv->delivery_system == SYS_DVBT2) {
0339             ret = cxd2820r_sleep_t2(fe);
0340             if (ret)
0341                 goto error;
0342 
0343             c->delivery_system = SYS_DVBT;
0344         }
0345     }
0346 
0347     /* set frontend */
0348     ret = cxd2820r_set_frontend(fe);
0349     if (ret)
0350         goto error;
0351 
0352     /* frontend lock wait loop count */
0353     switch (priv->delivery_system) {
0354     case SYS_DVBT:
0355     case SYS_DVBC_ANNEX_A:
0356         i = 20;
0357         break;
0358     case SYS_DVBT2:
0359         i = 40;
0360         break;
0361     case SYS_UNDEFINED:
0362     default:
0363         i = 0;
0364         break;
0365     }
0366 
0367     /* wait frontend lock */
0368     for (; i > 0; i--) {
0369         dev_dbg(&client->dev, "loop=%d\n", i);
0370         msleep(50);
0371         ret = cxd2820r_read_status(fe, &status);
0372         if (ret)
0373             goto error;
0374 
0375         if (status & FE_HAS_LOCK)
0376             break;
0377     }
0378 
0379     /* check if we have a valid signal */
0380     if (status & FE_HAS_LOCK) {
0381         priv->last_tune_failed = false;
0382         return DVBFE_ALGO_SEARCH_SUCCESS;
0383     } else {
0384         priv->last_tune_failed = true;
0385         return DVBFE_ALGO_SEARCH_AGAIN;
0386     }
0387 
0388 error:
0389     dev_dbg(&client->dev, "failed=%d\n", ret);
0390     return DVBFE_ALGO_SEARCH_ERROR;
0391 }
0392 
0393 static enum dvbfe_algo cxd2820r_get_frontend_algo(struct dvb_frontend *fe)
0394 {
0395     return DVBFE_ALGO_CUSTOM;
0396 }
0397 
0398 static void cxd2820r_release(struct dvb_frontend *fe)
0399 {
0400     struct cxd2820r_priv *priv = fe->demodulator_priv;
0401     struct i2c_client *client = priv->client[0];
0402 
0403     dev_dbg(&client->dev, "\n");
0404 
0405     i2c_unregister_device(client);
0406 
0407     return;
0408 }
0409 
0410 static int cxd2820r_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
0411 {
0412     struct cxd2820r_priv *priv = fe->demodulator_priv;
0413     struct i2c_client *client = priv->client[0];
0414 
0415     dev_dbg_ratelimited(&client->dev, "enable=%d\n", enable);
0416 
0417     return regmap_update_bits(priv->regmap[0], 0x00db, 0x01, enable ? 1 : 0);
0418 }
0419 
0420 #ifdef CONFIG_GPIOLIB
0421 static int cxd2820r_gpio_direction_output(struct gpio_chip *chip, unsigned nr,
0422         int val)
0423 {
0424     struct cxd2820r_priv *priv = gpiochip_get_data(chip);
0425     struct i2c_client *client = priv->client[0];
0426     u8 gpio[GPIO_COUNT];
0427 
0428     dev_dbg(&client->dev, "nr=%u val=%d\n", nr, val);
0429 
0430     memcpy(gpio, priv->gpio, sizeof(gpio));
0431     gpio[nr] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | (val << 2);
0432 
0433     return cxd2820r_gpio(&priv->fe, gpio);
0434 }
0435 
0436 static void cxd2820r_gpio_set(struct gpio_chip *chip, unsigned nr, int val)
0437 {
0438     struct cxd2820r_priv *priv = gpiochip_get_data(chip);
0439     struct i2c_client *client = priv->client[0];
0440     u8 gpio[GPIO_COUNT];
0441 
0442     dev_dbg(&client->dev, "nr=%u val=%d\n", nr, val);
0443 
0444     memcpy(gpio, priv->gpio, sizeof(gpio));
0445     gpio[nr] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | (val << 2);
0446 
0447     (void) cxd2820r_gpio(&priv->fe, gpio);
0448 
0449     return;
0450 }
0451 
0452 static int cxd2820r_gpio_get(struct gpio_chip *chip, unsigned nr)
0453 {
0454     struct cxd2820r_priv *priv = gpiochip_get_data(chip);
0455     struct i2c_client *client = priv->client[0];
0456 
0457     dev_dbg(&client->dev, "nr=%u\n", nr);
0458 
0459     return (priv->gpio[nr] >> 2) & 0x01;
0460 }
0461 #endif
0462 
0463 static const struct dvb_frontend_ops cxd2820r_ops = {
0464     .delsys = { SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A },
0465     /* default: DVB-T/T2 */
0466     .info = {
0467         .name = "Sony CXD2820R",
0468 
0469         .caps = FE_CAN_FEC_1_2          |
0470             FE_CAN_FEC_2_3          |
0471             FE_CAN_FEC_3_4          |
0472             FE_CAN_FEC_5_6          |
0473             FE_CAN_FEC_7_8          |
0474             FE_CAN_FEC_AUTO         |
0475             FE_CAN_QPSK         |
0476             FE_CAN_QAM_16           |
0477             FE_CAN_QAM_32           |
0478             FE_CAN_QAM_64           |
0479             FE_CAN_QAM_128          |
0480             FE_CAN_QAM_256          |
0481             FE_CAN_QAM_AUTO         |
0482             FE_CAN_TRANSMISSION_MODE_AUTO   |
0483             FE_CAN_GUARD_INTERVAL_AUTO  |
0484             FE_CAN_HIERARCHY_AUTO       |
0485             FE_CAN_MUTE_TS          |
0486             FE_CAN_2G_MODULATION        |
0487             FE_CAN_MULTISTREAM
0488         },
0489 
0490     .release        = cxd2820r_release,
0491     .init           = cxd2820r_init,
0492     .sleep          = cxd2820r_sleep,
0493 
0494     .get_tune_settings  = cxd2820r_get_tune_settings,
0495     .i2c_gate_ctrl      = cxd2820r_i2c_gate_ctrl,
0496 
0497     .get_frontend       = cxd2820r_get_frontend,
0498 
0499     .get_frontend_algo  = cxd2820r_get_frontend_algo,
0500     .search         = cxd2820r_search,
0501 
0502     .read_status        = cxd2820r_read_status,
0503     .read_snr       = cxd2820r_read_snr,
0504     .read_ber       = cxd2820r_read_ber,
0505     .read_ucblocks      = cxd2820r_read_ucblocks,
0506     .read_signal_strength   = cxd2820r_read_signal_strength,
0507 };
0508 
0509 /*
0510  * XXX: That is wrapper to cxd2820r_probe() via driver core in order to provide
0511  * proper I2C client for legacy media attach binding.
0512  * New users must use I2C client binding directly!
0513  */
0514 struct dvb_frontend *cxd2820r_attach(const struct cxd2820r_config *config,
0515                      struct i2c_adapter *adapter,
0516                      int *gpio_chip_base)
0517 {
0518     struct i2c_client *client;
0519     struct i2c_board_info board_info;
0520     struct cxd2820r_platform_data pdata;
0521 
0522     pdata.ts_mode = config->ts_mode;
0523     pdata.ts_clk_inv = config->ts_clock_inv;
0524     pdata.if_agc_polarity = config->if_agc_polarity;
0525     pdata.spec_inv = config->spec_inv;
0526     pdata.gpio_chip_base = &gpio_chip_base;
0527     pdata.attach_in_use = true;
0528 
0529     memset(&board_info, 0, sizeof(board_info));
0530     strscpy(board_info.type, "cxd2820r", I2C_NAME_SIZE);
0531     board_info.addr = config->i2c_address;
0532     board_info.platform_data = &pdata;
0533     client = i2c_new_client_device(adapter, &board_info);
0534     if (!i2c_client_has_driver(client))
0535         return NULL;
0536 
0537     return pdata.get_dvb_frontend(client);
0538 }
0539 EXPORT_SYMBOL(cxd2820r_attach);
0540 
0541 static struct dvb_frontend *cxd2820r_get_dvb_frontend(struct i2c_client *client)
0542 {
0543     struct cxd2820r_priv *priv = i2c_get_clientdata(client);
0544 
0545     dev_dbg(&client->dev, "\n");
0546 
0547     return &priv->fe;
0548 }
0549 
0550 static int cxd2820r_probe(struct i2c_client *client,
0551               const struct i2c_device_id *id)
0552 {
0553     struct cxd2820r_platform_data *pdata = client->dev.platform_data;
0554     struct cxd2820r_priv *priv;
0555     int ret, *gpio_chip_base;
0556     unsigned int utmp;
0557     static const struct regmap_range_cfg regmap_range_cfg0[] = {
0558         {
0559             .range_min        = 0x0000,
0560             .range_max        = 0x3fff,
0561             .selector_reg     = 0x00,
0562             .selector_mask    = 0xff,
0563             .selector_shift   = 0,
0564             .window_start     = 0x00,
0565             .window_len       = 0x100,
0566         },
0567     };
0568     static const struct regmap_range_cfg regmap_range_cfg1[] = {
0569         {
0570             .range_min        = 0x0000,
0571             .range_max        = 0x01ff,
0572             .selector_reg     = 0x00,
0573             .selector_mask    = 0xff,
0574             .selector_shift   = 0,
0575             .window_start     = 0x00,
0576             .window_len       = 0x100,
0577         },
0578     };
0579     static const struct regmap_config regmap_config0 = {
0580         .reg_bits = 8,
0581         .val_bits = 8,
0582         .max_register = 0x3fff,
0583         .ranges = regmap_range_cfg0,
0584         .num_ranges = ARRAY_SIZE(regmap_range_cfg0),
0585         .cache_type = REGCACHE_NONE,
0586     };
0587     static const struct regmap_config regmap_config1 = {
0588         .reg_bits = 8,
0589         .val_bits = 8,
0590         .max_register = 0x01ff,
0591         .ranges = regmap_range_cfg1,
0592         .num_ranges = ARRAY_SIZE(regmap_range_cfg1),
0593         .cache_type = REGCACHE_NONE,
0594     };
0595 
0596     dev_dbg(&client->dev, "\n");
0597 
0598     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0599     if (!priv) {
0600         ret = -ENOMEM;
0601         goto err;
0602     }
0603 
0604     priv->client[0] = client;
0605     priv->fe.demodulator_priv = priv;
0606     priv->i2c = client->adapter;
0607     priv->ts_mode = pdata->ts_mode;
0608     priv->ts_clk_inv = pdata->ts_clk_inv;
0609     priv->if_agc_polarity = pdata->if_agc_polarity;
0610     priv->spec_inv = pdata->spec_inv;
0611     gpio_chip_base = *pdata->gpio_chip_base;
0612     priv->regmap[0] = regmap_init_i2c(priv->client[0], &regmap_config0);
0613     if (IS_ERR(priv->regmap[0])) {
0614         ret = PTR_ERR(priv->regmap[0]);
0615         goto err_kfree;
0616     }
0617 
0618     /* Check demod answers with correct chip id */
0619     ret = regmap_read(priv->regmap[0], 0x00fd, &utmp);
0620     if (ret)
0621         goto err_regmap_0_regmap_exit;
0622 
0623     dev_dbg(&client->dev, "chip_id=%02x\n", utmp);
0624 
0625     if (utmp != 0xe1) {
0626         ret = -ENODEV;
0627         goto err_regmap_0_regmap_exit;
0628     }
0629 
0630     /*
0631      * Chip has two I2C addresses for different register banks. We register
0632      * one dummy I2C client in in order to get own I2C client for each
0633      * register bank.
0634      */
0635     priv->client[1] = i2c_new_dummy_device(client->adapter, client->addr | (1 << 1));
0636     if (IS_ERR(priv->client[1])) {
0637         ret = PTR_ERR(priv->client[1]);
0638         dev_err(&client->dev, "I2C registration failed\n");
0639         goto err_regmap_0_regmap_exit;
0640     }
0641 
0642     priv->regmap[1] = regmap_init_i2c(priv->client[1], &regmap_config1);
0643     if (IS_ERR(priv->regmap[1])) {
0644         ret = PTR_ERR(priv->regmap[1]);
0645         goto err_client_1_i2c_unregister_device;
0646     }
0647 
0648     if (gpio_chip_base) {
0649 #ifdef CONFIG_GPIOLIB
0650         /* Add GPIOs */
0651         priv->gpio_chip.label = KBUILD_MODNAME;
0652         priv->gpio_chip.parent = &client->dev;
0653         priv->gpio_chip.owner = THIS_MODULE;
0654         priv->gpio_chip.direction_output = cxd2820r_gpio_direction_output;
0655         priv->gpio_chip.set = cxd2820r_gpio_set;
0656         priv->gpio_chip.get = cxd2820r_gpio_get;
0657         priv->gpio_chip.base = -1; /* Dynamic allocation */
0658         priv->gpio_chip.ngpio = GPIO_COUNT;
0659         priv->gpio_chip.can_sleep = 1;
0660         ret = gpiochip_add_data(&priv->gpio_chip, priv);
0661         if (ret)
0662             goto err_regmap_1_regmap_exit;
0663 
0664         dev_dbg(&client->dev, "gpio_chip.base=%d\n",
0665             priv->gpio_chip.base);
0666 
0667         *gpio_chip_base = priv->gpio_chip.base;
0668 #else
0669         /*
0670          * Use static GPIO configuration if GPIOLIB is undefined.
0671          * This is fallback condition.
0672          */
0673         u8 gpio[GPIO_COUNT];
0674         gpio[0] = (*gpio_chip_base >> 0) & 0x07;
0675         gpio[1] = (*gpio_chip_base >> 3) & 0x07;
0676         gpio[2] = 0;
0677         ret = cxd2820r_gpio(&priv->fe, gpio);
0678         if (ret)
0679             goto err_regmap_1_regmap_exit;
0680 #endif
0681     }
0682 
0683     /* Create dvb frontend */
0684     memcpy(&priv->fe.ops, &cxd2820r_ops, sizeof(priv->fe.ops));
0685     if (!pdata->attach_in_use)
0686         priv->fe.ops.release = NULL;
0687     i2c_set_clientdata(client, priv);
0688 
0689     /* Setup callbacks */
0690     pdata->get_dvb_frontend = cxd2820r_get_dvb_frontend;
0691 
0692     dev_info(&client->dev, "Sony CXD2820R successfully identified\n");
0693 
0694     return 0;
0695 err_regmap_1_regmap_exit:
0696     regmap_exit(priv->regmap[1]);
0697 err_client_1_i2c_unregister_device:
0698     i2c_unregister_device(priv->client[1]);
0699 err_regmap_0_regmap_exit:
0700     regmap_exit(priv->regmap[0]);
0701 err_kfree:
0702     kfree(priv);
0703 err:
0704     dev_dbg(&client->dev, "failed=%d\n", ret);
0705     return ret;
0706 }
0707 
0708 static int cxd2820r_remove(struct i2c_client *client)
0709 {
0710     struct cxd2820r_priv *priv = i2c_get_clientdata(client);
0711 
0712     dev_dbg(&client->dev, "\n");
0713 
0714 #ifdef CONFIG_GPIOLIB
0715     if (priv->gpio_chip.label)
0716         gpiochip_remove(&priv->gpio_chip);
0717 #endif
0718     regmap_exit(priv->regmap[1]);
0719     i2c_unregister_device(priv->client[1]);
0720 
0721     regmap_exit(priv->regmap[0]);
0722 
0723     kfree(priv);
0724 
0725     return 0;
0726 }
0727 
0728 static const struct i2c_device_id cxd2820r_id_table[] = {
0729     {"cxd2820r", 0},
0730     {}
0731 };
0732 MODULE_DEVICE_TABLE(i2c, cxd2820r_id_table);
0733 
0734 static struct i2c_driver cxd2820r_driver = {
0735     .driver = {
0736         .name                = "cxd2820r",
0737         .suppress_bind_attrs = true,
0738     },
0739     .probe    = cxd2820r_probe,
0740     .remove   = cxd2820r_remove,
0741     .id_table = cxd2820r_id_table,
0742 };
0743 
0744 module_i2c_driver(cxd2820r_driver);
0745 
0746 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
0747 MODULE_DESCRIPTION("Sony CXD2820R demodulator driver");
0748 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!