1 /* 2 * Copyright (C) 2017 Spreadtrum Communications Inc. 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/interrupt.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/mfd/core.h> 18 #include <linux/of_device.h> 19 #include <linux/regmap.h> 20 #include <linux/spi/spi.h> 21 22 #define SPRD_PMIC_INT_MASK_STATUS 0x0 23 #define SPRD_PMIC_INT_RAW_STATUS 0x4 24 #define SPRD_PMIC_INT_EN 0x8 25 26 #define SPRD_SC2731_IRQ_BASE 0x140 27 #define SPRD_SC2731_IRQ_NUMS 16 28 29 struct sprd_pmic { 30 struct regmap *regmap; 31 struct device *dev; 32 struct regmap_irq *irqs; 33 struct regmap_irq_chip irq_chip; 34 struct regmap_irq_chip_data *irq_data; 35 int irq; 36 }; 37 38 struct sprd_pmic_data { 39 u32 irq_base; 40 u32 num_irqs; 41 }; 42 43 /* 44 * Since different PMICs of SC27xx series can have different interrupt 45 * base address and irq number, we should save irq number and irq base 46 * in the device data structure. 47 */ 48 static const struct sprd_pmic_data sc2731_data = { 49 .irq_base = SPRD_SC2731_IRQ_BASE, 50 .num_irqs = SPRD_SC2731_IRQ_NUMS, 51 }; 52 53 static const struct mfd_cell sprd_pmic_devs[] = { 54 { 55 .name = "sc27xx-wdt", 56 .of_compatible = "sprd,sc27xx-wdt", 57 }, { 58 .name = "sc27xx-rtc", 59 .of_compatible = "sprd,sc27xx-rtc", 60 }, { 61 .name = "sc27xx-charger", 62 .of_compatible = "sprd,sc27xx-charger", 63 }, { 64 .name = "sc27xx-chg-timer", 65 .of_compatible = "sprd,sc27xx-chg-timer", 66 }, { 67 .name = "sc27xx-fast-chg", 68 .of_compatible = "sprd,sc27xx-fast-chg", 69 }, { 70 .name = "sc27xx-chg-wdt", 71 .of_compatible = "sprd,sc27xx-chg-wdt", 72 }, { 73 .name = "sc27xx-typec", 74 .of_compatible = "sprd,sc27xx-typec", 75 }, { 76 .name = "sc27xx-flash", 77 .of_compatible = "sprd,sc27xx-flash", 78 }, { 79 .name = "sc27xx-eic", 80 .of_compatible = "sprd,sc27xx-eic", 81 }, { 82 .name = "sc27xx-efuse", 83 .of_compatible = "sprd,sc27xx-efuse", 84 }, { 85 .name = "sc27xx-thermal", 86 .of_compatible = "sprd,sc27xx-thermal", 87 }, { 88 .name = "sc27xx-adc", 89 .of_compatible = "sprd,sc27xx-adc", 90 }, { 91 .name = "sc27xx-audio-codec", 92 .of_compatible = "sprd,sc27xx-audio-codec", 93 }, { 94 .name = "sc27xx-regulator", 95 .of_compatible = "sprd,sc27xx-regulator", 96 }, { 97 .name = "sc27xx-vibrator", 98 .of_compatible = "sprd,sc27xx-vibrator", 99 }, { 100 .name = "sc27xx-keypad-led", 101 .of_compatible = "sprd,sc27xx-keypad-led", 102 }, { 103 .name = "sc27xx-bltc", 104 .of_compatible = "sprd,sc27xx-bltc", 105 }, { 106 .name = "sc27xx-fgu", 107 .of_compatible = "sprd,sc27xx-fgu", 108 }, { 109 .name = "sc27xx-7sreset", 110 .of_compatible = "sprd,sc27xx-7sreset", 111 }, { 112 .name = "sc27xx-poweroff", 113 .of_compatible = "sprd,sc27xx-poweroff", 114 }, 115 }; 116 117 static int sprd_pmic_spi_write(void *context, const void *data, size_t count) 118 { 119 struct device *dev = context; 120 struct spi_device *spi = to_spi_device(dev); 121 122 return spi_write(spi, data, count); 123 } 124 125 static int sprd_pmic_spi_read(void *context, 126 const void *reg, size_t reg_size, 127 void *val, size_t val_size) 128 { 129 struct device *dev = context; 130 struct spi_device *spi = to_spi_device(dev); 131 u32 rx_buf[2] = { 0 }; 132 int ret; 133 134 /* Now we only support one PMIC register to read every time. */ 135 if (reg_size != sizeof(u32) || val_size != sizeof(u32)) 136 return -EINVAL; 137 138 /* Copy address to read from into first element of SPI buffer. */ 139 memcpy(rx_buf, reg, sizeof(u32)); 140 ret = spi_read(spi, rx_buf, 1); 141 if (ret < 0) 142 return ret; 143 144 memcpy(val, rx_buf, val_size); 145 return 0; 146 } 147 148 static struct regmap_bus sprd_pmic_regmap = { 149 .write = sprd_pmic_spi_write, 150 .read = sprd_pmic_spi_read, 151 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE, 152 .val_format_endian_default = REGMAP_ENDIAN_NATIVE, 153 }; 154 155 static const struct regmap_config sprd_pmic_config = { 156 .reg_bits = 32, 157 .val_bits = 32, 158 .reg_stride = 4, 159 .max_register = 0xffff, 160 }; 161 162 static int sprd_pmic_probe(struct spi_device *spi) 163 { 164 struct sprd_pmic *ddata; 165 const struct sprd_pmic_data *pdata; 166 int ret, i; 167 168 pdata = of_device_get_match_data(&spi->dev); 169 if (!pdata) { 170 dev_err(&spi->dev, "No matching driver data found\n"); 171 return -EINVAL; 172 } 173 174 ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); 175 if (!ddata) 176 return -ENOMEM; 177 178 ddata->regmap = devm_regmap_init(&spi->dev, &sprd_pmic_regmap, 179 &spi->dev, &sprd_pmic_config); 180 if (IS_ERR(ddata->regmap)) { 181 ret = PTR_ERR(ddata->regmap); 182 dev_err(&spi->dev, "Failed to allocate register map %d\n", ret); 183 return ret; 184 } 185 186 spi_set_drvdata(spi, ddata); 187 ddata->dev = &spi->dev; 188 ddata->irq = spi->irq; 189 190 ddata->irq_chip.name = dev_name(&spi->dev); 191 ddata->irq_chip.status_base = 192 pdata->irq_base + SPRD_PMIC_INT_MASK_STATUS; 193 ddata->irq_chip.mask_base = pdata->irq_base + SPRD_PMIC_INT_EN; 194 ddata->irq_chip.ack_base = 0; 195 ddata->irq_chip.num_regs = 1; 196 ddata->irq_chip.num_irqs = pdata->num_irqs; 197 ddata->irq_chip.mask_invert = true; 198 199 ddata->irqs = devm_kzalloc(&spi->dev, sizeof(struct regmap_irq) * 200 pdata->num_irqs, GFP_KERNEL); 201 if (!ddata->irqs) 202 return -ENOMEM; 203 204 ddata->irq_chip.irqs = ddata->irqs; 205 for (i = 0; i < pdata->num_irqs; i++) { 206 ddata->irqs[i].reg_offset = i / pdata->num_irqs; 207 ddata->irqs[i].mask = BIT(i % pdata->num_irqs); 208 } 209 210 ret = devm_regmap_add_irq_chip(&spi->dev, ddata->regmap, ddata->irq, 211 IRQF_ONESHOT | IRQF_NO_SUSPEND, 0, 212 &ddata->irq_chip, &ddata->irq_data); 213 if (ret) { 214 dev_err(&spi->dev, "Failed to add PMIC irq chip %d\n", ret); 215 return ret; 216 } 217 218 ret = devm_mfd_add_devices(&spi->dev, PLATFORM_DEVID_AUTO, 219 sprd_pmic_devs, ARRAY_SIZE(sprd_pmic_devs), 220 NULL, 0, 221 regmap_irq_get_domain(ddata->irq_data)); 222 if (ret) { 223 dev_err(&spi->dev, "Failed to register device %d\n", ret); 224 return ret; 225 } 226 227 return 0; 228 } 229 230 static const struct of_device_id sprd_pmic_match[] = { 231 { .compatible = "sprd,sc2731", .data = &sc2731_data }, 232 {}, 233 }; 234 MODULE_DEVICE_TABLE(of, sprd_pmic_match); 235 236 static struct spi_driver sprd_pmic_driver = { 237 .driver = { 238 .name = "sc27xx-pmic", 239 .bus = &spi_bus_type, 240 .of_match_table = sprd_pmic_match, 241 }, 242 .probe = sprd_pmic_probe, 243 }; 244 245 static int __init sprd_pmic_init(void) 246 { 247 return spi_register_driver(&sprd_pmic_driver); 248 } 249 subsys_initcall(sprd_pmic_init); 250 251 static void __exit sprd_pmic_exit(void) 252 { 253 spi_unregister_driver(&sprd_pmic_driver); 254 } 255 module_exit(sprd_pmic_exit); 256 257 MODULE_LICENSE("GPL v2"); 258 MODULE_DESCRIPTION("Spreadtrum SC27xx PMICs driver"); 259 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>"); 260