Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Core driver for TI TPS6586x PMIC family
0004  *
0005  * Copyright (c) 2010 CompuLab Ltd.
0006  * Mike Rapoport <mike@compulab.co.il>
0007  *
0008  * Based on da903x.c.
0009  * Copyright (C) 2008 Compulab, Ltd.
0010  * Mike Rapoport <mike@compulab.co.il>
0011  * Copyright (C) 2006-2008 Marvell International Ltd.
0012  * Eric Miao <eric.miao@marvell.com>
0013  */
0014 
0015 #include <linux/interrupt.h>
0016 #include <linux/irq.h>
0017 #include <linux/irqdomain.h>
0018 #include <linux/kernel.h>
0019 #include <linux/module.h>
0020 #include <linux/mutex.h>
0021 #include <linux/slab.h>
0022 #include <linux/err.h>
0023 #include <linux/i2c.h>
0024 #include <linux/platform_device.h>
0025 #include <linux/regmap.h>
0026 #include <linux/of.h>
0027 
0028 #include <linux/mfd/core.h>
0029 #include <linux/mfd/tps6586x.h>
0030 
0031 #define TPS6586X_SUPPLYENE  0x14
0032 #define EXITSLREQ_BIT       BIT(1)
0033 #define SLEEP_MODE_BIT      BIT(3)
0034 
0035 /* interrupt control registers */
0036 #define TPS6586X_INT_ACK1   0xb5
0037 #define TPS6586X_INT_ACK2   0xb6
0038 #define TPS6586X_INT_ACK3   0xb7
0039 #define TPS6586X_INT_ACK4   0xb8
0040 
0041 /* interrupt mask registers */
0042 #define TPS6586X_INT_MASK1  0xb0
0043 #define TPS6586X_INT_MASK2  0xb1
0044 #define TPS6586X_INT_MASK3  0xb2
0045 #define TPS6586X_INT_MASK4  0xb3
0046 #define TPS6586X_INT_MASK5  0xb4
0047 
0048 /* device id */
0049 #define TPS6586X_VERSIONCRC 0xcd
0050 
0051 /* Maximum register */
0052 #define TPS6586X_MAX_REGISTER   TPS6586X_VERSIONCRC
0053 
0054 struct tps6586x_irq_data {
0055     u8  mask_reg;
0056     u8  mask_mask;
0057 };
0058 
0059 #define TPS6586X_IRQ(_reg, _mask)               \
0060     {                           \
0061         .mask_reg = (_reg) - TPS6586X_INT_MASK1,    \
0062         .mask_mask = (_mask),               \
0063     }
0064 
0065 static const struct tps6586x_irq_data tps6586x_irqs[] = {
0066     [TPS6586X_INT_PLDO_0]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 0),
0067     [TPS6586X_INT_PLDO_1]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 1),
0068     [TPS6586X_INT_PLDO_2]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 2),
0069     [TPS6586X_INT_PLDO_3]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 3),
0070     [TPS6586X_INT_PLDO_4]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 4),
0071     [TPS6586X_INT_PLDO_5]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 5),
0072     [TPS6586X_INT_PLDO_6]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 6),
0073     [TPS6586X_INT_PLDO_7]   = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 7),
0074     [TPS6586X_INT_COMP_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 0),
0075     [TPS6586X_INT_ADC]  = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 1),
0076     [TPS6586X_INT_PLDO_8]   = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 2),
0077     [TPS6586X_INT_PLDO_9]   = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 3),
0078     [TPS6586X_INT_PSM_0]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 4),
0079     [TPS6586X_INT_PSM_1]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 5),
0080     [TPS6586X_INT_PSM_2]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 6),
0081     [TPS6586X_INT_PSM_3]    = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 7),
0082     [TPS6586X_INT_RTC_ALM1] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 4),
0083     [TPS6586X_INT_ACUSB_OVP] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 0x03),
0084     [TPS6586X_INT_USB_DET]  = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 2),
0085     [TPS6586X_INT_AC_DET]   = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 3),
0086     [TPS6586X_INT_BAT_DET]  = TPS6586X_IRQ(TPS6586X_INT_MASK3, 1 << 0),
0087     [TPS6586X_INT_CHG_STAT] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 0xfc),
0088     [TPS6586X_INT_CHG_TEMP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0x06),
0089     [TPS6586X_INT_PP]   = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0xf0),
0090     [TPS6586X_INT_RESUME]   = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 5),
0091     [TPS6586X_INT_LOW_SYS]  = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 6),
0092     [TPS6586X_INT_RTC_ALM2] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 1),
0093 };
0094 
0095 static const struct resource tps6586x_rtc_resources[] = {
0096     {
0097         .start  = TPS6586X_INT_RTC_ALM1,
0098         .end    = TPS6586X_INT_RTC_ALM1,
0099         .flags  = IORESOURCE_IRQ,
0100     },
0101 };
0102 
0103 static const struct mfd_cell tps6586x_cell[] = {
0104     {
0105         .name = "tps6586x-gpio",
0106     },
0107     {
0108         .name = "tps6586x-regulator",
0109     },
0110     {
0111         .name = "tps6586x-rtc",
0112         .num_resources = ARRAY_SIZE(tps6586x_rtc_resources),
0113         .resources = &tps6586x_rtc_resources[0],
0114     },
0115     {
0116         .name = "tps6586x-onkey",
0117     },
0118 };
0119 
0120 struct tps6586x {
0121     struct device       *dev;
0122     struct i2c_client   *client;
0123     struct regmap       *regmap;
0124     int         version;
0125 
0126     int         irq;
0127     struct irq_chip     irq_chip;
0128     struct mutex        irq_lock;
0129     int         irq_base;
0130     u32         irq_en;
0131     u8          mask_reg[5];
0132     struct irq_domain   *irq_domain;
0133 };
0134 
0135 static inline struct tps6586x *dev_to_tps6586x(struct device *dev)
0136 {
0137     return i2c_get_clientdata(to_i2c_client(dev));
0138 }
0139 
0140 int tps6586x_write(struct device *dev, int reg, uint8_t val)
0141 {
0142     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0143 
0144     return regmap_write(tps6586x->regmap, reg, val);
0145 }
0146 EXPORT_SYMBOL_GPL(tps6586x_write);
0147 
0148 int tps6586x_writes(struct device *dev, int reg, int len, uint8_t *val)
0149 {
0150     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0151 
0152     return regmap_bulk_write(tps6586x->regmap, reg, val, len);
0153 }
0154 EXPORT_SYMBOL_GPL(tps6586x_writes);
0155 
0156 int tps6586x_read(struct device *dev, int reg, uint8_t *val)
0157 {
0158     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0159     unsigned int rval;
0160     int ret;
0161 
0162     ret = regmap_read(tps6586x->regmap, reg, &rval);
0163     if (!ret)
0164         *val = rval;
0165     return ret;
0166 }
0167 EXPORT_SYMBOL_GPL(tps6586x_read);
0168 
0169 int tps6586x_reads(struct device *dev, int reg, int len, uint8_t *val)
0170 {
0171     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0172 
0173     return regmap_bulk_read(tps6586x->regmap, reg, val, len);
0174 }
0175 EXPORT_SYMBOL_GPL(tps6586x_reads);
0176 
0177 int tps6586x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
0178 {
0179     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0180 
0181     return regmap_update_bits(tps6586x->regmap, reg, bit_mask, bit_mask);
0182 }
0183 EXPORT_SYMBOL_GPL(tps6586x_set_bits);
0184 
0185 int tps6586x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
0186 {
0187     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0188 
0189     return regmap_update_bits(tps6586x->regmap, reg, bit_mask, 0);
0190 }
0191 EXPORT_SYMBOL_GPL(tps6586x_clr_bits);
0192 
0193 int tps6586x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
0194 {
0195     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0196 
0197     return regmap_update_bits(tps6586x->regmap, reg, mask, val);
0198 }
0199 EXPORT_SYMBOL_GPL(tps6586x_update);
0200 
0201 int tps6586x_irq_get_virq(struct device *dev, int irq)
0202 {
0203     struct tps6586x *tps6586x = dev_to_tps6586x(dev);
0204 
0205     return irq_create_mapping(tps6586x->irq_domain, irq);
0206 }
0207 EXPORT_SYMBOL_GPL(tps6586x_irq_get_virq);
0208 
0209 int tps6586x_get_version(struct device *dev)
0210 {
0211     struct tps6586x *tps6586x = dev_get_drvdata(dev);
0212 
0213     return tps6586x->version;
0214 }
0215 EXPORT_SYMBOL_GPL(tps6586x_get_version);
0216 
0217 static int __remove_subdev(struct device *dev, void *unused)
0218 {
0219     platform_device_unregister(to_platform_device(dev));
0220     return 0;
0221 }
0222 
0223 static int tps6586x_remove_subdevs(struct tps6586x *tps6586x)
0224 {
0225     return device_for_each_child(tps6586x->dev, NULL, __remove_subdev);
0226 }
0227 
0228 static void tps6586x_irq_lock(struct irq_data *data)
0229 {
0230     struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
0231 
0232     mutex_lock(&tps6586x->irq_lock);
0233 }
0234 
0235 static void tps6586x_irq_enable(struct irq_data *irq_data)
0236 {
0237     struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
0238     unsigned int __irq = irq_data->hwirq;
0239     const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
0240 
0241     tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask;
0242     tps6586x->irq_en |= (1 << __irq);
0243 }
0244 
0245 static void tps6586x_irq_disable(struct irq_data *irq_data)
0246 {
0247     struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
0248 
0249     unsigned int __irq = irq_data->hwirq;
0250     const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
0251 
0252     tps6586x->mask_reg[data->mask_reg] |= data->mask_mask;
0253     tps6586x->irq_en &= ~(1 << __irq);
0254 }
0255 
0256 static void tps6586x_irq_sync_unlock(struct irq_data *data)
0257 {
0258     struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
0259     int i;
0260 
0261     for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) {
0262         int ret;
0263         ret = tps6586x_write(tps6586x->dev,
0264                         TPS6586X_INT_MASK1 + i,
0265                         tps6586x->mask_reg[i]);
0266         WARN_ON(ret);
0267     }
0268 
0269     mutex_unlock(&tps6586x->irq_lock);
0270 }
0271 
0272 #ifdef CONFIG_PM_SLEEP
0273 static int tps6586x_irq_set_wake(struct irq_data *irq_data, unsigned int on)
0274 {
0275     struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
0276     return irq_set_irq_wake(tps6586x->irq, on);
0277 }
0278 #else
0279 #define tps6586x_irq_set_wake NULL
0280 #endif
0281 
0282 static struct irq_chip tps6586x_irq_chip = {
0283     .name = "tps6586x",
0284     .irq_bus_lock = tps6586x_irq_lock,
0285     .irq_bus_sync_unlock = tps6586x_irq_sync_unlock,
0286     .irq_disable = tps6586x_irq_disable,
0287     .irq_enable = tps6586x_irq_enable,
0288     .irq_set_wake = tps6586x_irq_set_wake,
0289 };
0290 
0291 static int tps6586x_irq_map(struct irq_domain *h, unsigned int virq,
0292                 irq_hw_number_t hw)
0293 {
0294     struct tps6586x *tps6586x = h->host_data;
0295 
0296     irq_set_chip_data(virq, tps6586x);
0297     irq_set_chip_and_handler(virq, &tps6586x_irq_chip, handle_simple_irq);
0298     irq_set_nested_thread(virq, 1);
0299     irq_set_noprobe(virq);
0300 
0301     return 0;
0302 }
0303 
0304 static const struct irq_domain_ops tps6586x_domain_ops = {
0305     .map    = tps6586x_irq_map,
0306     .xlate  = irq_domain_xlate_twocell,
0307 };
0308 
0309 static irqreturn_t tps6586x_irq(int irq, void *data)
0310 {
0311     struct tps6586x *tps6586x = data;
0312     uint32_t acks;
0313     __le32 val;
0314     int ret = 0;
0315 
0316     ret = tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1,
0317                  sizeof(acks), (uint8_t *)&val);
0318 
0319     if (ret < 0) {
0320         dev_err(tps6586x->dev, "failed to read interrupt status\n");
0321         return IRQ_NONE;
0322     }
0323 
0324     acks = le32_to_cpu(val);
0325 
0326     while (acks) {
0327         int i = __ffs(acks);
0328 
0329         if (tps6586x->irq_en & (1 << i))
0330             handle_nested_irq(
0331                 irq_find_mapping(tps6586x->irq_domain, i));
0332 
0333         acks &= ~(1 << i);
0334     }
0335 
0336     return IRQ_HANDLED;
0337 }
0338 
0339 static int tps6586x_irq_init(struct tps6586x *tps6586x, int irq,
0340                        int irq_base)
0341 {
0342     int i, ret;
0343     u8 tmp[4];
0344     int new_irq_base;
0345     int irq_num = ARRAY_SIZE(tps6586x_irqs);
0346 
0347     tps6586x->irq = irq;
0348 
0349     mutex_init(&tps6586x->irq_lock);
0350     for (i = 0; i < 5; i++) {
0351         tps6586x->mask_reg[i] = 0xff;
0352         tps6586x_write(tps6586x->dev, TPS6586X_INT_MASK1 + i, 0xff);
0353     }
0354 
0355     tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1, sizeof(tmp), tmp);
0356 
0357     if  (irq_base > 0) {
0358         new_irq_base = irq_alloc_descs(irq_base, 0, irq_num, -1);
0359         if (new_irq_base < 0) {
0360             dev_err(tps6586x->dev,
0361                 "Failed to alloc IRQs: %d\n", new_irq_base);
0362             return new_irq_base;
0363         }
0364     } else {
0365         new_irq_base = 0;
0366     }
0367 
0368     tps6586x->irq_domain = irq_domain_add_simple(tps6586x->dev->of_node,
0369                 irq_num, new_irq_base, &tps6586x_domain_ops,
0370                 tps6586x);
0371     if (!tps6586x->irq_domain) {
0372         dev_err(tps6586x->dev, "Failed to create IRQ domain\n");
0373         return -ENOMEM;
0374     }
0375     ret = request_threaded_irq(irq, NULL, tps6586x_irq, IRQF_ONESHOT,
0376                    "tps6586x", tps6586x);
0377 
0378     if (!ret)
0379         device_init_wakeup(tps6586x->dev, 1);
0380 
0381     return ret;
0382 }
0383 
0384 static int tps6586x_add_subdevs(struct tps6586x *tps6586x,
0385                       struct tps6586x_platform_data *pdata)
0386 {
0387     struct tps6586x_subdev_info *subdev;
0388     struct platform_device *pdev;
0389     int i, ret = 0;
0390 
0391     for (i = 0; i < pdata->num_subdevs; i++) {
0392         subdev = &pdata->subdevs[i];
0393 
0394         pdev = platform_device_alloc(subdev->name, subdev->id);
0395         if (!pdev) {
0396             ret = -ENOMEM;
0397             goto failed;
0398         }
0399 
0400         pdev->dev.parent = tps6586x->dev;
0401         pdev->dev.platform_data = subdev->platform_data;
0402         pdev->dev.of_node = subdev->of_node;
0403 
0404         ret = platform_device_add(pdev);
0405         if (ret) {
0406             platform_device_put(pdev);
0407             goto failed;
0408         }
0409     }
0410     return 0;
0411 
0412 failed:
0413     tps6586x_remove_subdevs(tps6586x);
0414     return ret;
0415 }
0416 
0417 #ifdef CONFIG_OF
0418 static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
0419 {
0420     struct device_node *np = client->dev.of_node;
0421     struct tps6586x_platform_data *pdata;
0422 
0423     pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
0424     if (!pdata)
0425         return NULL;
0426 
0427     pdata->num_subdevs = 0;
0428     pdata->subdevs = NULL;
0429     pdata->gpio_base = -1;
0430     pdata->irq_base = -1;
0431     pdata->pm_off = of_property_read_bool(np, "ti,system-power-controller");
0432 
0433     return pdata;
0434 }
0435 
0436 static const struct of_device_id tps6586x_of_match[] = {
0437     { .compatible = "ti,tps6586x", },
0438     { },
0439 };
0440 #else
0441 static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
0442 {
0443     return NULL;
0444 }
0445 #endif
0446 
0447 static bool is_volatile_reg(struct device *dev, unsigned int reg)
0448 {
0449     /* Cache all interrupt mask register */
0450     if ((reg >= TPS6586X_INT_MASK1) && (reg <= TPS6586X_INT_MASK5))
0451         return false;
0452 
0453     return true;
0454 }
0455 
0456 static const struct regmap_config tps6586x_regmap_config = {
0457     .reg_bits = 8,
0458     .val_bits = 8,
0459     .max_register = TPS6586X_MAX_REGISTER,
0460     .volatile_reg = is_volatile_reg,
0461     .cache_type = REGCACHE_RBTREE,
0462 };
0463 
0464 static struct device *tps6586x_dev;
0465 static void tps6586x_power_off(void)
0466 {
0467     if (tps6586x_clr_bits(tps6586x_dev, TPS6586X_SUPPLYENE, EXITSLREQ_BIT))
0468         return;
0469 
0470     tps6586x_set_bits(tps6586x_dev, TPS6586X_SUPPLYENE, SLEEP_MODE_BIT);
0471 }
0472 
0473 static void tps6586x_print_version(struct i2c_client *client, int version)
0474 {
0475     const char *name;
0476 
0477     switch (version) {
0478     case TPS658621A:
0479         name = "TPS658621A";
0480         break;
0481     case TPS658621CD:
0482         name = "TPS658621C/D";
0483         break;
0484     case TPS658623:
0485         name = "TPS658623";
0486         break;
0487     case TPS658640:
0488     case TPS658640v2:
0489         name = "TPS658640";
0490         break;
0491     case TPS658643:
0492         name = "TPS658643";
0493         break;
0494     default:
0495         name = "TPS6586X";
0496         break;
0497     }
0498 
0499     dev_info(&client->dev, "Found %s, VERSIONCRC is %02x\n", name, version);
0500 }
0501 
0502 static int tps6586x_i2c_probe(struct i2c_client *client,
0503                     const struct i2c_device_id *id)
0504 {
0505     struct tps6586x_platform_data *pdata = dev_get_platdata(&client->dev);
0506     struct tps6586x *tps6586x;
0507     int ret;
0508     int version;
0509 
0510     if (!pdata && client->dev.of_node)
0511         pdata = tps6586x_parse_dt(client);
0512 
0513     if (!pdata) {
0514         dev_err(&client->dev, "tps6586x requires platform data\n");
0515         return -ENOTSUPP;
0516     }
0517 
0518     version = i2c_smbus_read_byte_data(client, TPS6586X_VERSIONCRC);
0519     if (version < 0) {
0520         dev_err(&client->dev, "Chip ID read failed: %d\n", version);
0521         return -EIO;
0522     }
0523 
0524     tps6586x = devm_kzalloc(&client->dev, sizeof(*tps6586x), GFP_KERNEL);
0525     if (!tps6586x)
0526         return -ENOMEM;
0527 
0528     tps6586x->version = version;
0529     tps6586x_print_version(client, tps6586x->version);
0530 
0531     tps6586x->client = client;
0532     tps6586x->dev = &client->dev;
0533     i2c_set_clientdata(client, tps6586x);
0534 
0535     tps6586x->regmap = devm_regmap_init_i2c(client,
0536                     &tps6586x_regmap_config);
0537     if (IS_ERR(tps6586x->regmap)) {
0538         ret = PTR_ERR(tps6586x->regmap);
0539         dev_err(&client->dev, "regmap init failed: %d\n", ret);
0540         return ret;
0541     }
0542 
0543 
0544     if (client->irq) {
0545         ret = tps6586x_irq_init(tps6586x, client->irq,
0546                     pdata->irq_base);
0547         if (ret) {
0548             dev_err(&client->dev, "IRQ init failed: %d\n", ret);
0549             return ret;
0550         }
0551     }
0552 
0553     ret = mfd_add_devices(tps6586x->dev, -1,
0554                   tps6586x_cell, ARRAY_SIZE(tps6586x_cell),
0555                   NULL, 0, tps6586x->irq_domain);
0556     if (ret < 0) {
0557         dev_err(&client->dev, "mfd_add_devices failed: %d\n", ret);
0558         goto err_mfd_add;
0559     }
0560 
0561     ret = tps6586x_add_subdevs(tps6586x, pdata);
0562     if (ret) {
0563         dev_err(&client->dev, "add devices failed: %d\n", ret);
0564         goto err_add_devs;
0565     }
0566 
0567     if (pdata->pm_off && !pm_power_off) {
0568         tps6586x_dev = &client->dev;
0569         pm_power_off = tps6586x_power_off;
0570     }
0571 
0572     return 0;
0573 
0574 err_add_devs:
0575     mfd_remove_devices(tps6586x->dev);
0576 err_mfd_add:
0577     if (client->irq)
0578         free_irq(client->irq, tps6586x);
0579     return ret;
0580 }
0581 
0582 static int tps6586x_i2c_remove(struct i2c_client *client)
0583 {
0584     struct tps6586x *tps6586x = i2c_get_clientdata(client);
0585 
0586     tps6586x_remove_subdevs(tps6586x);
0587     mfd_remove_devices(tps6586x->dev);
0588     if (client->irq)
0589         free_irq(client->irq, tps6586x);
0590     return 0;
0591 }
0592 
0593 static int __maybe_unused tps6586x_i2c_suspend(struct device *dev)
0594 {
0595     struct tps6586x *tps6586x = dev_get_drvdata(dev);
0596 
0597     if (tps6586x->client->irq)
0598         disable_irq(tps6586x->client->irq);
0599 
0600     return 0;
0601 }
0602 
0603 static int __maybe_unused tps6586x_i2c_resume(struct device *dev)
0604 {
0605     struct tps6586x *tps6586x = dev_get_drvdata(dev);
0606 
0607     if (tps6586x->client->irq)
0608         enable_irq(tps6586x->client->irq);
0609 
0610     return 0;
0611 }
0612 
0613 static SIMPLE_DEV_PM_OPS(tps6586x_pm_ops, tps6586x_i2c_suspend,
0614              tps6586x_i2c_resume);
0615 
0616 static const struct i2c_device_id tps6586x_id_table[] = {
0617     { "tps6586x", 0 },
0618     { },
0619 };
0620 MODULE_DEVICE_TABLE(i2c, tps6586x_id_table);
0621 
0622 static struct i2c_driver tps6586x_driver = {
0623     .driver = {
0624         .name   = "tps6586x",
0625         .of_match_table = of_match_ptr(tps6586x_of_match),
0626         .pm = &tps6586x_pm_ops,
0627     },
0628     .probe      = tps6586x_i2c_probe,
0629     .remove     = tps6586x_i2c_remove,
0630     .id_table   = tps6586x_id_table,
0631 };
0632 
0633 static int __init tps6586x_init(void)
0634 {
0635     return i2c_add_driver(&tps6586x_driver);
0636 }
0637 subsys_initcall(tps6586x_init);
0638 
0639 static void __exit tps6586x_exit(void)
0640 {
0641     i2c_del_driver(&tps6586x_driver);
0642 }
0643 module_exit(tps6586x_exit);
0644 
0645 MODULE_DESCRIPTION("TPS6586X core driver");
0646 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
0647 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!