drivers/mfd/sprd-sc27xx-spi.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2017 Spreadtrum Communications Inc.
0004  */
0005
0006 #include <linux/interrupt.h>
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/mfd/core.h>
0010 #include <linux/mfd/sc27xx-pmic.h>
0011 #include <linux/of_device.h>
0012 #include <linux/of_platform.h>
0013 #include <linux/regmap.h>
0014 #include <linux/spi/spi.h>
0015 #include <uapi/linux/usb/charger.h>
0016
0017 #define SPRD_PMIC_INT_MASK_STATUS   0x0
0018 #define SPRD_PMIC_INT_RAW_STATUS    0x4
0019 #define SPRD_PMIC_INT_EN        0x8
0020
0021 #define SPRD_SC2730_IRQ_BASE        0x80
0022 #define SPRD_SC2730_IRQ_NUMS        10
0023 #define SPRD_SC2730_CHG_DET     0x1b9c
0024 #define SPRD_SC2731_IRQ_BASE        0x140
0025 #define SPRD_SC2731_IRQ_NUMS        16
0026 #define SPRD_SC2731_CHG_DET     0xedc
0027
0028 /* PMIC charger detection definition */
0029 #define SPRD_PMIC_CHG_DET_DELAY_US  200000
0030 #define SPRD_PMIC_CHG_DET_TIMEOUT   2000000
0031 #define SPRD_PMIC_CHG_DET_DONE      BIT(11)
0032 #define SPRD_PMIC_SDP_TYPE      BIT(7)
0033 #define SPRD_PMIC_DCP_TYPE      BIT(6)
0034 #define SPRD_PMIC_CDP_TYPE      BIT(5)
0035 #define SPRD_PMIC_CHG_TYPE_MASK     GENMASK(7, 5)
0036
0037 struct sprd_pmic {
0038     struct regmap *regmap;
0039     struct device *dev;
0040     struct regmap_irq *irqs;
0041     struct regmap_irq_chip irq_chip;
0042     struct regmap_irq_chip_data *irq_data;
0043     const struct sprd_pmic_data *pdata;
0044     int irq;
0045 };
0046
0047 struct sprd_pmic_data {
0048     u32 irq_base;
0049     u32 num_irqs;
0050     u32 charger_det;
0051 };
0052
0053 /*
0054  * Since different PMICs of SC27xx series can have different interrupt
0055  * base address and irq number, we should save irq number and irq base
0056  * in the device data structure.
0057  */
0058 static const struct sprd_pmic_data sc2730_data = {
0059     .irq_base = SPRD_SC2730_IRQ_BASE,
0060     .num_irqs = SPRD_SC2730_IRQ_NUMS,
0061     .charger_det = SPRD_SC2730_CHG_DET,
0062 };
0063
0064 static const struct sprd_pmic_data sc2731_data = {
0065     .irq_base = SPRD_SC2731_IRQ_BASE,
0066     .num_irqs = SPRD_SC2731_IRQ_NUMS,
0067     .charger_det = SPRD_SC2731_CHG_DET,
0068 };
0069
0070 enum usb_charger_type sprd_pmic_detect_charger_type(struct device *dev)
0071 {
0072     struct spi_device *spi = to_spi_device(dev);
0073     struct sprd_pmic *ddata = spi_get_drvdata(spi);
0074     const struct sprd_pmic_data *pdata = ddata->pdata;
0075     enum usb_charger_type type;
0076     u32 val;
0077     int ret;
0078
0079     ret = regmap_read_poll_timeout(ddata->regmap, pdata->charger_det, val,
0080                        (val & SPRD_PMIC_CHG_DET_DONE),
0081                        SPRD_PMIC_CHG_DET_DELAY_US,
0082                        SPRD_PMIC_CHG_DET_TIMEOUT);
0083     if (ret) {
0084         dev_err(&spi->dev, "failed to detect charger type\n");
0085         return UNKNOWN_TYPE;
0086     }
0087
0088     switch (val & SPRD_PMIC_CHG_TYPE_MASK) {
0089     case SPRD_PMIC_CDP_TYPE:
0090         type = CDP_TYPE;
0091         break;
0092     case SPRD_PMIC_DCP_TYPE:
0093         type = DCP_TYPE;
0094         break;
0095     case SPRD_PMIC_SDP_TYPE:
0096         type = SDP_TYPE;
0097         break;
0098     default:
0099         type = UNKNOWN_TYPE;
0100         break;
0101     }
0102
0103     return type;
0104 }
0105 EXPORT_SYMBOL_GPL(sprd_pmic_detect_charger_type);
0106
0107 static int sprd_pmic_spi_write(void *context, const void *data, size_t count)
0108 {
0109     struct device *dev = context;
0110     struct spi_device *spi = to_spi_device(dev);
0111
0112     return spi_write(spi, data, count);
0113 }
0114
0115 static int sprd_pmic_spi_read(void *context,
0116                   const void *reg, size_t reg_size,
0117                   void *val, size_t val_size)
0118 {
0119     struct device *dev = context;
0120     struct spi_device *spi = to_spi_device(dev);
0121     u32 rx_buf[2] = { 0 };
0122     int ret;
0123
0124     /* Now we only support one PMIC register to read every time. */
0125     if (reg_size != sizeof(u32) || val_size != sizeof(u32))
0126         return -EINVAL;
0127
0128     /* Copy address to read from into first element of SPI buffer. */
0129     memcpy(rx_buf, reg, sizeof(u32));
0130     ret = spi_read(spi, rx_buf, 1);
0131     if (ret < 0)
0132         return ret;
0133
0134     memcpy(val, rx_buf, val_size);
0135     return 0;
0136 }
0137
0138 static struct regmap_bus sprd_pmic_regmap = {
0139     .write = sprd_pmic_spi_write,
0140     .read = sprd_pmic_spi_read,
0141     .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
0142     .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
0143 };
0144
0145 static const struct regmap_config sprd_pmic_config = {
0146     .reg_bits = 32,
0147     .val_bits = 32,
0148     .reg_stride = 4,
0149     .max_register = 0xffff,
0150 };
0151
0152 static int sprd_pmic_probe(struct spi_device *spi)
0153 {
0154     struct sprd_pmic *ddata;
0155     const struct sprd_pmic_data *pdata;
0156     int ret, i;
0157
0158     pdata = of_device_get_match_data(&spi->dev);
0159     if (!pdata) {
0160         dev_err(&spi->dev, "No matching driver data found\n");
0161         return -EINVAL;
0162     }
0163
0164     ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);
0165     if (!ddata)
0166         return -ENOMEM;
0167
0168     ddata->regmap = devm_regmap_init(&spi->dev, &sprd_pmic_regmap,
0169                      &spi->dev, &sprd_pmic_config);
0170     if (IS_ERR(ddata->regmap)) {
0171         ret = PTR_ERR(ddata->regmap);
0172         dev_err(&spi->dev, "Failed to allocate register map %d\n", ret);
0173         return ret;
0174     }
0175
0176     spi_set_drvdata(spi, ddata);
0177     ddata->dev = &spi->dev;
0178     ddata->irq = spi->irq;
0179     ddata->pdata = pdata;
0180
0181     ddata->irq_chip.name = dev_name(&spi->dev);
0182     ddata->irq_chip.status_base =
0183         pdata->irq_base + SPRD_PMIC_INT_MASK_STATUS;
0184     ddata->irq_chip.mask_base = pdata->irq_base + SPRD_PMIC_INT_EN;
0185     ddata->irq_chip.ack_base = 0;
0186     ddata->irq_chip.num_regs = 1;
0187     ddata->irq_chip.num_irqs = pdata->num_irqs;
0188     ddata->irq_chip.mask_invert = true;
0189
0190     ddata->irqs = devm_kcalloc(&spi->dev,
0191                    pdata->num_irqs, sizeof(struct regmap_irq),
0192                    GFP_KERNEL);
0193     if (!ddata->irqs)
0194         return -ENOMEM;
0195
0196     ddata->irq_chip.irqs = ddata->irqs;
0197     for (i = 0; i < pdata->num_irqs; i++)
0198         ddata->irqs[i].mask = BIT(i);
0199
0200     ret = devm_regmap_add_irq_chip(&spi->dev, ddata->regmap, ddata->irq,
0201                        IRQF_ONESHOT, 0,
0202                        &ddata->irq_chip, &ddata->irq_data);
0203     if (ret) {
0204         dev_err(&spi->dev, "Failed to add PMIC irq chip %d\n", ret);
0205         return ret;
0206     }
0207
0208     ret = devm_of_platform_populate(&spi->dev);
0209     if (ret) {
0210         dev_err(&spi->dev, "Failed to populate sub-devices %d\n", ret);
0211         return ret;
0212     }
0213
0214     device_init_wakeup(&spi->dev, true);
0215     return 0;
0216 }
0217
0218 #ifdef CONFIG_PM_SLEEP
0219 static int sprd_pmic_suspend(struct device *dev)
0220 {
0221     struct sprd_pmic *ddata = dev_get_drvdata(dev);
0222
0223     if (device_may_wakeup(dev))
0224         enable_irq_wake(ddata->irq);
0225
0226     return 0;
0227 }
0228
0229 static int sprd_pmic_resume(struct device *dev)
0230 {
0231     struct sprd_pmic *ddata = dev_get_drvdata(dev);
0232
0233     if (device_may_wakeup(dev))
0234         disable_irq_wake(ddata->irq);
0235
0236     return 0;
0237 }
0238 #endif
0239
0240 static SIMPLE_DEV_PM_OPS(sprd_pmic_pm_ops, sprd_pmic_suspend, sprd_pmic_resume);
0241
0242 static const struct of_device_id sprd_pmic_match[] = {
0243     { .compatible = "sprd,sc2730", .data = &sc2730_data },
0244     { .compatible = "sprd,sc2731", .data = &sc2731_data },
0245     {},
0246 };
0247 MODULE_DEVICE_TABLE(of, sprd_pmic_match);
0248
0249 static const struct spi_device_id sprd_pmic_spi_ids[] = {
0250     { .name = "sc2730", .driver_data = (unsigned long)&sc2730_data },
0251     { .name = "sc2731", .driver_data = (unsigned long)&sc2731_data },
0252     {},
0253 };
0254 MODULE_DEVICE_TABLE(spi, sprd_pmic_spi_ids);
0255
0256 static struct spi_driver sprd_pmic_driver = {
0257     .driver = {
0258         .name = "sc27xx-pmic",
0259         .of_match_table = sprd_pmic_match,
0260         .pm = &sprd_pmic_pm_ops,
0261     },
0262     .probe = sprd_pmic_probe,
0263     .id_table = sprd_pmic_spi_ids,
0264 };
0265
0266 static int __init sprd_pmic_init(void)
0267 {
0268     return spi_register_driver(&sprd_pmic_driver);
0269 }
0270 subsys_initcall(sprd_pmic_init);
0271
0272 static void __exit sprd_pmic_exit(void)
0273 {
0274     spi_unregister_driver(&sprd_pmic_driver);
0275 }
0276 module_exit(sprd_pmic_exit);
0277
0278 MODULE_LICENSE("GPL v2");
0279 MODULE_DESCRIPTION("Spreadtrum SC27xx PMICs driver");
0280 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");