1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Battery and Power Management code for the Sharp SL-5x00 4 * 5 * Copyright (C) 2009 Thomas Kunze 6 * 7 * based on tosa_battery.c 8 */ 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/power_supply.h> 12 #include <linux/delay.h> 13 #include <linux/spinlock.h> 14 #include <linux/interrupt.h> 15 #include <linux/gpio.h> 16 #include <linux/mfd/ucb1x00.h> 17 18 #include <asm/mach/sharpsl_param.h> 19 #include <asm/mach-types.h> 20 #include <mach/collie.h> 21 22 static DEFINE_MUTEX(bat_lock); /* protects gpio pins */ 23 static struct work_struct bat_work; 24 static struct ucb1x00 *ucb; 25 26 struct collie_bat { 27 int status; 28 struct power_supply *psy; 29 int full_chrg; 30 31 struct mutex work_lock; /* protects data */ 32 33 bool (*is_present)(struct collie_bat *bat); 34 int gpio_full; 35 int gpio_charge_on; 36 37 int technology; 38 39 int gpio_bat; 40 int adc_bat; 41 int adc_bat_divider; 42 int bat_max; 43 int bat_min; 44 45 int gpio_temp; 46 int adc_temp; 47 int adc_temp_divider; 48 }; 49 50 static struct collie_bat collie_bat_main; 51 52 static unsigned long collie_read_bat(struct collie_bat *bat) 53 { 54 unsigned long value = 0; 55 56 if (bat->gpio_bat < 0 || bat->adc_bat < 0) 57 return 0; 58 mutex_lock(&bat_lock); 59 gpio_set_value(bat->gpio_bat, 1); 60 msleep(5); 61 ucb1x00_adc_enable(ucb); 62 value = ucb1x00_adc_read(ucb, bat->adc_bat, UCB_SYNC); 63 ucb1x00_adc_disable(ucb); 64 gpio_set_value(bat->gpio_bat, 0); 65 mutex_unlock(&bat_lock); 66 value = value * 1000000 / bat->adc_bat_divider; 67 68 return value; 69 } 70 71 static unsigned long collie_read_temp(struct collie_bat *bat) 72 { 73 unsigned long value = 0; 74 if (bat->gpio_temp < 0 || bat->adc_temp < 0) 75 return 0; 76 77 mutex_lock(&bat_lock); 78 gpio_set_value(bat->gpio_temp, 1); 79 msleep(5); 80 ucb1x00_adc_enable(ucb); 81 value = ucb1x00_adc_read(ucb, bat->adc_temp, UCB_SYNC); 82 ucb1x00_adc_disable(ucb); 83 gpio_set_value(bat->gpio_temp, 0); 84 mutex_unlock(&bat_lock); 85 86 value = value * 10000 / bat->adc_temp_divider; 87 88 return value; 89 } 90 91 static int collie_bat_get_property(struct power_supply *psy, 92 enum power_supply_property psp, 93 union power_supply_propval *val) 94 { 95 int ret = 0; 96 struct collie_bat *bat = power_supply_get_drvdata(psy); 97 98 if (bat->is_present && !bat->is_present(bat) 99 && psp != POWER_SUPPLY_PROP_PRESENT) { 100 return -ENODEV; 101 } 102 103 switch (psp) { 104 case POWER_SUPPLY_PROP_STATUS: 105 val->intval = bat->status; 106 break; 107 case POWER_SUPPLY_PROP_TECHNOLOGY: 108 val->intval = bat->technology; 109 break; 110 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 111 val->intval = collie_read_bat(bat); 112 break; 113 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 114 if (bat->full_chrg == -1) 115 val->intval = bat->bat_max; 116 else 117 val->intval = bat->full_chrg; 118 break; 119 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 120 val->intval = bat->bat_max; 121 break; 122 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 123 val->intval = bat->bat_min; 124 break; 125 case POWER_SUPPLY_PROP_TEMP: 126 val->intval = collie_read_temp(bat); 127 break; 128 case POWER_SUPPLY_PROP_PRESENT: 129 val->intval = bat->is_present ? bat->is_present(bat) : 1; 130 break; 131 default: 132 ret = -EINVAL; 133 break; 134 } 135 return ret; 136 } 137 138 static void collie_bat_external_power_changed(struct power_supply *psy) 139 { 140 schedule_work(&bat_work); 141 } 142 143 static irqreturn_t collie_bat_gpio_isr(int irq, void *data) 144 { 145 pr_info("collie_bat_gpio irq\n"); 146 schedule_work(&bat_work); 147 return IRQ_HANDLED; 148 } 149 150 static void collie_bat_update(struct collie_bat *bat) 151 { 152 int old; 153 struct power_supply *psy = bat->psy; 154 155 mutex_lock(&bat->work_lock); 156 157 old = bat->status; 158 159 if (bat->is_present && !bat->is_present(bat)) { 160 printk(KERN_NOTICE "%s not present\n", psy->desc->name); 161 bat->status = POWER_SUPPLY_STATUS_UNKNOWN; 162 bat->full_chrg = -1; 163 } else if (power_supply_am_i_supplied(psy)) { 164 if (bat->status == POWER_SUPPLY_STATUS_DISCHARGING) { 165 gpio_set_value(bat->gpio_charge_on, 1); 166 mdelay(15); 167 } 168 169 if (gpio_get_value(bat->gpio_full)) { 170 if (old == POWER_SUPPLY_STATUS_CHARGING || 171 bat->full_chrg == -1) 172 bat->full_chrg = collie_read_bat(bat); 173 174 gpio_set_value(bat->gpio_charge_on, 0); 175 bat->status = POWER_SUPPLY_STATUS_FULL; 176 } else { 177 gpio_set_value(bat->gpio_charge_on, 1); 178 bat->status = POWER_SUPPLY_STATUS_CHARGING; 179 } 180 } else { 181 gpio_set_value(bat->gpio_charge_on, 0); 182 bat->status = POWER_SUPPLY_STATUS_DISCHARGING; 183 } 184 185 if (old != bat->status) 186 power_supply_changed(psy); 187 188 mutex_unlock(&bat->work_lock); 189 } 190 191 static void collie_bat_work(struct work_struct *work) 192 { 193 collie_bat_update(&collie_bat_main); 194 } 195 196 197 static enum power_supply_property collie_bat_main_props[] = { 198 POWER_SUPPLY_PROP_STATUS, 199 POWER_SUPPLY_PROP_TECHNOLOGY, 200 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 201 POWER_SUPPLY_PROP_VOLTAGE_NOW, 202 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 203 POWER_SUPPLY_PROP_VOLTAGE_MAX, 204 POWER_SUPPLY_PROP_PRESENT, 205 POWER_SUPPLY_PROP_TEMP, 206 }; 207 208 static enum power_supply_property collie_bat_bu_props[] = { 209 POWER_SUPPLY_PROP_STATUS, 210 POWER_SUPPLY_PROP_TECHNOLOGY, 211 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 212 POWER_SUPPLY_PROP_VOLTAGE_NOW, 213 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 214 POWER_SUPPLY_PROP_VOLTAGE_MAX, 215 POWER_SUPPLY_PROP_PRESENT, 216 }; 217 218 static const struct power_supply_desc collie_bat_main_desc = { 219 .name = "main-battery", 220 .type = POWER_SUPPLY_TYPE_BATTERY, 221 .properties = collie_bat_main_props, 222 .num_properties = ARRAY_SIZE(collie_bat_main_props), 223 .get_property = collie_bat_get_property, 224 .external_power_changed = collie_bat_external_power_changed, 225 .use_for_apm = 1, 226 }; 227 228 static struct collie_bat collie_bat_main = { 229 .status = POWER_SUPPLY_STATUS_DISCHARGING, 230 .full_chrg = -1, 231 .psy = NULL, 232 233 .gpio_full = COLLIE_GPIO_CO, 234 .gpio_charge_on = COLLIE_GPIO_CHARGE_ON, 235 236 .technology = POWER_SUPPLY_TECHNOLOGY_LIPO, 237 238 .gpio_bat = COLLIE_GPIO_MBAT_ON, 239 .adc_bat = UCB_ADC_INP_AD1, 240 .adc_bat_divider = 155, 241 .bat_max = 4310000, 242 .bat_min = 1551 * 1000000 / 414, 243 244 .gpio_temp = COLLIE_GPIO_TMP_ON, 245 .adc_temp = UCB_ADC_INP_AD0, 246 .adc_temp_divider = 10000, 247 }; 248 249 static const struct power_supply_desc collie_bat_bu_desc = { 250 .name = "backup-battery", 251 .type = POWER_SUPPLY_TYPE_BATTERY, 252 .properties = collie_bat_bu_props, 253 .num_properties = ARRAY_SIZE(collie_bat_bu_props), 254 .get_property = collie_bat_get_property, 255 .external_power_changed = collie_bat_external_power_changed, 256 }; 257 258 static struct collie_bat collie_bat_bu = { 259 .status = POWER_SUPPLY_STATUS_UNKNOWN, 260 .full_chrg = -1, 261 .psy = NULL, 262 263 .gpio_full = -1, 264 .gpio_charge_on = -1, 265 266 .technology = POWER_SUPPLY_TECHNOLOGY_LiMn, 267 268 .gpio_bat = COLLIE_GPIO_BBAT_ON, 269 .adc_bat = UCB_ADC_INP_AD1, 270 .adc_bat_divider = 155, 271 .bat_max = 3000000, 272 .bat_min = 1900000, 273 274 .gpio_temp = -1, 275 .adc_temp = -1, 276 .adc_temp_divider = -1, 277 }; 278 279 static struct gpio collie_batt_gpios[] = { 280 { COLLIE_GPIO_CO, GPIOF_IN, "main battery full" }, 281 { COLLIE_GPIO_MAIN_BAT_LOW, GPIOF_IN, "main battery low" }, 282 { COLLIE_GPIO_CHARGE_ON, GPIOF_OUT_INIT_LOW, "main charge on" }, 283 { COLLIE_GPIO_MBAT_ON, GPIOF_OUT_INIT_LOW, "main battery" }, 284 { COLLIE_GPIO_TMP_ON, GPIOF_OUT_INIT_LOW, "main battery temp" }, 285 { COLLIE_GPIO_BBAT_ON, GPIOF_OUT_INIT_LOW, "backup battery" }, 286 }; 287 288 #ifdef CONFIG_PM 289 static int wakeup_enabled; 290 291 static int collie_bat_suspend(struct ucb1x00_dev *dev) 292 { 293 /* flush all pending status updates */ 294 flush_work(&bat_work); 295 296 if (device_may_wakeup(&dev->ucb->dev) && 297 collie_bat_main.status == POWER_SUPPLY_STATUS_CHARGING) 298 wakeup_enabled = !enable_irq_wake(gpio_to_irq(COLLIE_GPIO_CO)); 299 else 300 wakeup_enabled = 0; 301 302 return 0; 303 } 304 305 static int collie_bat_resume(struct ucb1x00_dev *dev) 306 { 307 if (wakeup_enabled) 308 disable_irq_wake(gpio_to_irq(COLLIE_GPIO_CO)); 309 310 /* things may have changed while we were away */ 311 schedule_work(&bat_work); 312 return 0; 313 } 314 #else 315 #define collie_bat_suspend NULL 316 #define collie_bat_resume NULL 317 #endif 318 319 static int collie_bat_probe(struct ucb1x00_dev *dev) 320 { 321 int ret; 322 struct power_supply_config psy_main_cfg = {}, psy_bu_cfg = {}; 323 324 if (!machine_is_collie()) 325 return -ENODEV; 326 327 ucb = dev->ucb; 328 329 ret = gpio_request_array(collie_batt_gpios, 330 ARRAY_SIZE(collie_batt_gpios)); 331 if (ret) 332 return ret; 333 334 mutex_init(&collie_bat_main.work_lock); 335 336 INIT_WORK(&bat_work, collie_bat_work); 337 338 psy_main_cfg.drv_data = &collie_bat_main; 339 collie_bat_main.psy = power_supply_register(&dev->ucb->dev, 340 &collie_bat_main_desc, 341 &psy_main_cfg); 342 if (IS_ERR(collie_bat_main.psy)) { 343 ret = PTR_ERR(collie_bat_main.psy); 344 goto err_psy_reg_main; 345 } 346 347 psy_bu_cfg.drv_data = &collie_bat_bu; 348 collie_bat_bu.psy = power_supply_register(&dev->ucb->dev, 349 &collie_bat_bu_desc, 350 &psy_bu_cfg); 351 if (IS_ERR(collie_bat_bu.psy)) { 352 ret = PTR_ERR(collie_bat_bu.psy); 353 goto err_psy_reg_bu; 354 } 355 356 ret = request_irq(gpio_to_irq(COLLIE_GPIO_CO), 357 collie_bat_gpio_isr, 358 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 359 "main full", &collie_bat_main); 360 if (ret) 361 goto err_irq; 362 363 device_init_wakeup(&ucb->dev, 1); 364 schedule_work(&bat_work); 365 366 return 0; 367 368 err_irq: 369 power_supply_unregister(collie_bat_bu.psy); 370 err_psy_reg_bu: 371 power_supply_unregister(collie_bat_main.psy); 372 err_psy_reg_main: 373 374 /* see comment in collie_bat_remove */ 375 cancel_work_sync(&bat_work); 376 gpio_free_array(collie_batt_gpios, ARRAY_SIZE(collie_batt_gpios)); 377 return ret; 378 } 379 380 static void collie_bat_remove(struct ucb1x00_dev *dev) 381 { 382 free_irq(gpio_to_irq(COLLIE_GPIO_CO), &collie_bat_main); 383 384 power_supply_unregister(collie_bat_bu.psy); 385 power_supply_unregister(collie_bat_main.psy); 386 387 /* 388 * Now cancel the bat_work. We won't get any more schedules, 389 * since all sources (isr and external_power_changed) are 390 * unregistered now. 391 */ 392 cancel_work_sync(&bat_work); 393 gpio_free_array(collie_batt_gpios, ARRAY_SIZE(collie_batt_gpios)); 394 } 395 396 static struct ucb1x00_driver collie_bat_driver = { 397 .add = collie_bat_probe, 398 .remove = collie_bat_remove, 399 .suspend = collie_bat_suspend, 400 .resume = collie_bat_resume, 401 }; 402 403 static int __init collie_bat_init(void) 404 { 405 return ucb1x00_register_driver(&collie_bat_driver); 406 } 407 408 static void __exit collie_bat_exit(void) 409 { 410 ucb1x00_unregister_driver(&collie_bat_driver); 411 } 412 413 module_init(collie_bat_init); 414 module_exit(collie_bat_exit); 415 416 MODULE_LICENSE("GPL"); 417 MODULE_AUTHOR("Thomas Kunze"); 418 MODULE_DESCRIPTION("Collie battery driver"); 419