1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Power-source driver for Bay Trail Crystal Cove PMIC 4 * 5 * Copyright (c) 2023 Hans de Goede <hdegoede@redhat.com> 6 * 7 * Based on intel_crystalcove_pwrsrc.c from Android kernel sources, which is: 8 * Copyright (C) 2013 Intel Corporation 9 */ 10 11 #include <linux/array_size.h> 12 #include <linux/bits.h> 13 #include <linux/debugfs.h> 14 #include <linux/interrupt.h> 15 #include <linux/mfd/intel_soc_pmic.h> 16 #include <linux/module.h> 17 #include <linux/platform_device.h> 18 #include <linux/power_supply.h> 19 #include <linux/property.h> 20 #include <linux/regmap.h> 21 22 #define CRYSTALCOVE_PWRSRC_IRQ 0x03 23 #define CRYSTALCOVE_SPWRSRC_REG 0x1E 24 #define CRYSTALCOVE_SPWRSRC_USB BIT(0) 25 #define CRYSTALCOVE_SPWRSRC_DC BIT(1) 26 #define CRYSTALCOVE_SPWRSRC_BATTERY BIT(2) 27 #define CRYSTALCOVE_RESETSRC0_REG 0x20 28 #define CRYSTALCOVE_RESETSRC1_REG 0x21 29 #define CRYSTALCOVE_WAKESRC_REG 0x22 30 31 struct crc_pwrsrc_data { 32 struct regmap *regmap; 33 struct dentry *debug_dentry; 34 struct power_supply *psy; 35 unsigned int resetsrc0; 36 unsigned int resetsrc1; 37 unsigned int wakesrc; 38 }; 39 40 static const char * const pwrsrc_pwrsrc_info[] = { 41 /* bit 0 */ "USB", 42 /* bit 1 */ "DC in", 43 /* bit 2 */ "Battery", 44 NULL, 45 }; 46 47 static const char * const pwrsrc_resetsrc0_info[] = { 48 /* bit 0 */ "SOC reporting a thermal event", 49 /* bit 1 */ "critical PMIC temperature", 50 /* bit 2 */ "critical system temperature", 51 /* bit 3 */ "critical battery temperature", 52 /* bit 4 */ "VSYS under voltage", 53 /* bit 5 */ "VSYS over voltage", 54 /* bit 6 */ "battery removal", 55 NULL, 56 }; 57 58 static const char * const pwrsrc_resetsrc1_info[] = { 59 /* bit 0 */ "VCRIT threshold", 60 /* bit 1 */ "BATID reporting battery removal", 61 /* bit 2 */ "user pressing the power button", 62 NULL, 63 }; 64 65 static const char * const pwrsrc_wakesrc_info[] = { 66 /* bit 0 */ "user pressing the power button", 67 /* bit 1 */ "a battery insertion", 68 /* bit 2 */ "a USB charger insertion", 69 /* bit 3 */ "an adapter insertion", 70 NULL, 71 }; 72 73 static void crc_pwrsrc_log(struct seq_file *seq, const char *prefix, 74 const char * const *info, unsigned int reg_val) 75 { 76 int i; 77 78 for (i = 0; info[i]; i++) { 79 if (reg_val & BIT(i)) 80 seq_printf(seq, "%s by %s\n", prefix, info[i]); 81 } 82 } 83 84 static int pwrsrc_show(struct seq_file *seq, void *unused) 85 { 86 struct crc_pwrsrc_data *data = seq->private; 87 unsigned int reg_val; 88 int ret; 89 90 ret = regmap_read(data->regmap, CRYSTALCOVE_SPWRSRC_REG, ®_val); 91 if (ret) 92 return ret; 93 94 crc_pwrsrc_log(seq, "System powered", pwrsrc_pwrsrc_info, reg_val); 95 return 0; 96 } 97 98 static int resetsrc_show(struct seq_file *seq, void *unused) 99 { 100 struct crc_pwrsrc_data *data = seq->private; 101 102 crc_pwrsrc_log(seq, "Last shutdown caused", pwrsrc_resetsrc0_info, data->resetsrc0); 103 crc_pwrsrc_log(seq, "Last shutdown caused", pwrsrc_resetsrc1_info, data->resetsrc1); 104 return 0; 105 } 106 107 static int wakesrc_show(struct seq_file *seq, void *unused) 108 { 109 struct crc_pwrsrc_data *data = seq->private; 110 111 crc_pwrsrc_log(seq, "Last wake caused", pwrsrc_wakesrc_info, data->wakesrc); 112 return 0; 113 } 114 115 DEFINE_SHOW_ATTRIBUTE(pwrsrc); 116 DEFINE_SHOW_ATTRIBUTE(resetsrc); 117 DEFINE_SHOW_ATTRIBUTE(wakesrc); 118 119 static int crc_pwrsrc_read_and_clear(struct crc_pwrsrc_data *data, 120 unsigned int reg, unsigned int *val) 121 { 122 int ret; 123 124 ret = regmap_read(data->regmap, reg, val); 125 if (ret) 126 return ret; 127 128 return regmap_write(data->regmap, reg, *val); 129 } 130 131 static irqreturn_t crc_pwrsrc_irq_handler(int irq, void *_data) 132 { 133 struct crc_pwrsrc_data *data = _data; 134 unsigned int irq_mask; 135 136 if (regmap_read(data->regmap, CRYSTALCOVE_PWRSRC_IRQ, &irq_mask)) 137 return IRQ_NONE; 138 139 regmap_write(data->regmap, CRYSTALCOVE_PWRSRC_IRQ, irq_mask); 140 141 power_supply_changed(data->psy); 142 return IRQ_HANDLED; 143 } 144 145 static int crc_pwrsrc_psy_get_property(struct power_supply *psy, 146 enum power_supply_property psp, 147 union power_supply_propval *val) 148 { 149 struct crc_pwrsrc_data *data = power_supply_get_drvdata(psy); 150 unsigned int pwrsrc; 151 int ret; 152 153 if (psp != POWER_SUPPLY_PROP_ONLINE) 154 return -EINVAL; 155 156 ret = regmap_read(data->regmap, CRYSTALCOVE_SPWRSRC_REG, &pwrsrc); 157 if (ret) 158 return ret; 159 160 val->intval = !!(pwrsrc & (CRYSTALCOVE_SPWRSRC_USB | 161 CRYSTALCOVE_SPWRSRC_DC)); 162 return 0; 163 } 164 165 static const enum power_supply_property crc_pwrsrc_psy_props[] = { 166 POWER_SUPPLY_PROP_ONLINE, 167 }; 168 169 static const struct power_supply_desc crc_pwrsrc_psy_desc = { 170 .name = "crystal_cove_pwrsrc", 171 .type = POWER_SUPPLY_TYPE_MAINS, 172 .properties = crc_pwrsrc_psy_props, 173 .num_properties = ARRAY_SIZE(crc_pwrsrc_psy_props), 174 .get_property = crc_pwrsrc_psy_get_property, 175 }; 176 177 static int crc_pwrsrc_probe(struct platform_device *pdev) 178 { 179 struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent); 180 struct device *dev = &pdev->dev; 181 struct crc_pwrsrc_data *data; 182 int irq, ret; 183 184 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 185 if (!data) 186 return -ENOMEM; 187 188 data->regmap = pmic->regmap; 189 190 /* 191 * Read + clear resetsrc0/1 and wakesrc now, so that they get 192 * cleared even if the debugfs interface is never used. 193 * 194 * Properly clearing the wakesrc is important, leaving bit 0 of it 195 * set turns reboot into poweroff on some tablets. 196 */ 197 ret = crc_pwrsrc_read_and_clear(data, CRYSTALCOVE_RESETSRC0_REG, &data->resetsrc0); 198 if (ret) 199 return ret; 200 201 ret = crc_pwrsrc_read_and_clear(data, CRYSTALCOVE_RESETSRC1_REG, &data->resetsrc1); 202 if (ret) 203 return ret; 204 205 ret = crc_pwrsrc_read_and_clear(data, CRYSTALCOVE_WAKESRC_REG, &data->wakesrc); 206 if (ret) 207 return ret; 208 209 if (device_property_read_bool(dev->parent, "linux,register-pwrsrc-power_supply")) { 210 struct power_supply_config psy_cfg = { .drv_data = data }; 211 212 irq = platform_get_irq(pdev, 0); 213 if (irq < 0) 214 return irq; 215 216 data->psy = devm_power_supply_register(dev, &crc_pwrsrc_psy_desc, &psy_cfg); 217 if (IS_ERR(data->psy)) 218 return dev_err_probe(dev, PTR_ERR(data->psy), "registering power-supply\n"); 219 220 ret = devm_request_threaded_irq(dev, irq, NULL, 221 crc_pwrsrc_irq_handler, 222 IRQF_ONESHOT, KBUILD_MODNAME, data); 223 if (ret) 224 return dev_err_probe(dev, ret, "requesting IRQ\n"); 225 } 226 227 data->debug_dentry = debugfs_create_dir(KBUILD_MODNAME, NULL); 228 debugfs_create_file("pwrsrc", 0444, data->debug_dentry, data, &pwrsrc_fops); 229 debugfs_create_file("resetsrc", 0444, data->debug_dentry, data, &resetsrc_fops); 230 debugfs_create_file("wakesrc", 0444, data->debug_dentry, data, &wakesrc_fops); 231 232 platform_set_drvdata(pdev, data); 233 return 0; 234 } 235 236 static void crc_pwrsrc_remove(struct platform_device *pdev) 237 { 238 struct crc_pwrsrc_data *data = platform_get_drvdata(pdev); 239 240 debugfs_remove_recursive(data->debug_dentry); 241 } 242 243 static struct platform_driver crc_pwrsrc_driver = { 244 .probe = crc_pwrsrc_probe, 245 .remove = crc_pwrsrc_remove, 246 .driver = { 247 .name = "crystal_cove_pwrsrc", 248 }, 249 }; 250 module_platform_driver(crc_pwrsrc_driver); 251 252 MODULE_ALIAS("platform:crystal_cove_pwrsrc"); 253 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 254 MODULE_DESCRIPTION("Power-source driver for Bay Trail Crystal Cove PMIC"); 255 MODULE_LICENSE("GPL"); 256