Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 1 | /* |
| 2 | * nvec_power: power supply driver for a NVIDIA compliant embedded controller |
| 3 | * |
| 4 | * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.launchpad.net> |
| 5 | * |
| 6 | * Authors: Ilya Petrov <ilya.muromec@gmail.com> |
| 7 | * Marc Dietrich <marvin24@gmx.de> |
| 8 | * |
| 9 | * This file is subject to the terms and conditions of the GNU General Public |
| 10 | * License. See the file "COPYING" in the main directory of this archive |
| 11 | * for more details. |
| 12 | * |
| 13 | */ |
| 14 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 15 | #include <linux/module.h> |
| 16 | #include <linux/platform_device.h> |
| 17 | #include <linux/err.h> |
| 18 | #include <linux/power_supply.h> |
| 19 | #include <linux/slab.h> |
| 20 | #include <linux/workqueue.h> |
| 21 | #include <linux/delay.h> |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 22 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 23 | #include "nvec.h" |
| 24 | |
Marc Dietrich | 93eff83 | 2013-01-27 17:43:43 +0100 | [diff] [blame] | 25 | #define GET_SYSTEM_STATUS 0x00 |
| 26 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 27 | struct nvec_power { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 28 | struct notifier_block notifier; |
| 29 | struct delayed_work poller; |
| 30 | struct nvec_chip *nvec; |
| 31 | int on; |
| 32 | int bat_present; |
| 33 | int bat_status; |
| 34 | int bat_voltage_now; |
| 35 | int bat_current_now; |
| 36 | int bat_current_avg; |
| 37 | int time_remain; |
| 38 | int charge_full_design; |
| 39 | int charge_last_full; |
| 40 | int critical_capacity; |
| 41 | int capacity_remain; |
| 42 | int bat_temperature; |
| 43 | int bat_cap; |
| 44 | int bat_type_enum; |
| 45 | char bat_manu[30]; |
| 46 | char bat_model[30]; |
| 47 | char bat_type[30]; |
| 48 | }; |
| 49 | |
| 50 | enum { |
| 51 | SLOT_STATUS, |
| 52 | VOLTAGE, |
| 53 | TIME_REMAINING, |
| 54 | CURRENT, |
| 55 | AVERAGE_CURRENT, |
| 56 | AVERAGING_TIME_INTERVAL, |
| 57 | CAPACITY_REMAINING, |
| 58 | LAST_FULL_CHARGE_CAPACITY, |
| 59 | DESIGN_CAPACITY, |
| 60 | CRITICAL_CAPACITY, |
| 61 | TEMPERATURE, |
| 62 | MANUFACTURER, |
| 63 | MODEL, |
| 64 | TYPE, |
| 65 | }; |
| 66 | |
| 67 | enum { |
| 68 | AC, |
| 69 | BAT, |
| 70 | }; |
| 71 | |
| 72 | struct bat_response { |
| 73 | u8 event_type; |
| 74 | u8 length; |
| 75 | u8 sub_type; |
| 76 | u8 status; |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 77 | /* payload */ |
| 78 | union { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 79 | char plc[30]; |
| 80 | u16 plu; |
| 81 | s16 pls; |
| 82 | }; |
| 83 | }; |
| 84 | |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 85 | static struct power_supply *nvec_bat_psy; |
| 86 | static struct power_supply *nvec_psy; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 87 | |
| 88 | static int nvec_power_notifier(struct notifier_block *nb, |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 89 | unsigned long event_type, void *data) |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 90 | { |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 91 | struct nvec_power *power = |
| 92 | container_of(nb, struct nvec_power, notifier); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 93 | struct bat_response *res = (struct bat_response *)data; |
| 94 | |
| 95 | if (event_type != NVEC_SYS) |
| 96 | return NOTIFY_DONE; |
| 97 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 98 | if (res->sub_type == 0) { |
| 99 | if (power->on != res->plu) { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 100 | power->on = res->plu; |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 101 | power_supply_changed(nvec_psy); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 102 | } |
| 103 | return NOTIFY_STOP; |
| 104 | } |
| 105 | return NOTIFY_OK; |
| 106 | } |
| 107 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 108 | static const int bat_init[] = { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 109 | LAST_FULL_CHARGE_CAPACITY, DESIGN_CAPACITY, CRITICAL_CAPACITY, |
| 110 | MANUFACTURER, MODEL, TYPE, |
| 111 | }; |
| 112 | |
| 113 | static void get_bat_mfg_data(struct nvec_power *power) |
| 114 | { |
| 115 | int i; |
Marc Dietrich | 93eff83 | 2013-01-27 17:43:43 +0100 | [diff] [blame] | 116 | char buf[] = { NVEC_BAT, SLOT_STATUS }; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 117 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 118 | for (i = 0; i < ARRAY_SIZE(bat_init); i++) { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 119 | buf[1] = bat_init[i]; |
| 120 | nvec_write_async(power->nvec, buf, 2); |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | static int nvec_power_bat_notifier(struct notifier_block *nb, |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 125 | unsigned long event_type, void *data) |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 126 | { |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 127 | struct nvec_power *power = |
| 128 | container_of(nb, struct nvec_power, notifier); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 129 | struct bat_response *res = (struct bat_response *)data; |
| 130 | int status_changed = 0; |
| 131 | |
| 132 | if (event_type != NVEC_BAT) |
| 133 | return NOTIFY_DONE; |
| 134 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 135 | switch (res->sub_type) { |
| 136 | case SLOT_STATUS: |
| 137 | if (res->plc[0] & 1) { |
| 138 | if (power->bat_present == 0) { |
| 139 | status_changed = 1; |
| 140 | get_bat_mfg_data(power); |
| 141 | } |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 142 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 143 | power->bat_present = 1; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 144 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 145 | switch ((res->plc[0] >> 1) & 3) { |
| 146 | case 0: |
| 147 | power->bat_status = |
| 148 | POWER_SUPPLY_STATUS_NOT_CHARGING; |
| 149 | break; |
| 150 | case 1: |
| 151 | power->bat_status = |
| 152 | POWER_SUPPLY_STATUS_CHARGING; |
| 153 | break; |
| 154 | case 2: |
| 155 | power->bat_status = |
| 156 | POWER_SUPPLY_STATUS_DISCHARGING; |
| 157 | break; |
| 158 | default: |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 159 | power->bat_status = POWER_SUPPLY_STATUS_UNKNOWN; |
| 160 | } |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 161 | } else { |
| 162 | if (power->bat_present == 1) |
| 163 | status_changed = 1; |
| 164 | |
| 165 | power->bat_present = 0; |
| 166 | power->bat_status = POWER_SUPPLY_STATUS_UNKNOWN; |
| 167 | } |
| 168 | power->bat_cap = res->plc[1]; |
| 169 | if (status_changed) |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 170 | power_supply_changed(nvec_bat_psy); |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 171 | break; |
| 172 | case VOLTAGE: |
| 173 | power->bat_voltage_now = res->plu * 1000; |
| 174 | break; |
| 175 | case TIME_REMAINING: |
| 176 | power->time_remain = res->plu * 3600; |
| 177 | break; |
| 178 | case CURRENT: |
| 179 | power->bat_current_now = res->pls * 1000; |
| 180 | break; |
| 181 | case AVERAGE_CURRENT: |
| 182 | power->bat_current_avg = res->pls * 1000; |
| 183 | break; |
| 184 | case CAPACITY_REMAINING: |
| 185 | power->capacity_remain = res->plu * 1000; |
| 186 | break; |
| 187 | case LAST_FULL_CHARGE_CAPACITY: |
| 188 | power->charge_last_full = res->plu * 1000; |
| 189 | break; |
| 190 | case DESIGN_CAPACITY: |
| 191 | power->charge_full_design = res->plu * 1000; |
| 192 | break; |
| 193 | case CRITICAL_CAPACITY: |
| 194 | power->critical_capacity = res->plu * 1000; |
| 195 | break; |
| 196 | case TEMPERATURE: |
| 197 | power->bat_temperature = res->plu - 2732; |
| 198 | break; |
| 199 | case MANUFACTURER: |
| 200 | memcpy(power->bat_manu, &res->plc, res->length - 2); |
| 201 | power->bat_model[res->length - 2] = '\0'; |
| 202 | break; |
| 203 | case MODEL: |
| 204 | memcpy(power->bat_model, &res->plc, res->length - 2); |
| 205 | power->bat_model[res->length - 2] = '\0'; |
| 206 | break; |
| 207 | case TYPE: |
| 208 | memcpy(power->bat_type, &res->plc, res->length - 2); |
| 209 | power->bat_type[res->length - 2] = '\0'; |
| 210 | /* this differs a little from the spec |
| 211 | fill in more if you find some */ |
| 212 | if (!strncmp(power->bat_type, "Li", 30)) |
| 213 | power->bat_type_enum = POWER_SUPPLY_TECHNOLOGY_LION; |
| 214 | else |
| 215 | power->bat_type_enum = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; |
| 216 | break; |
| 217 | default: |
| 218 | return NOTIFY_STOP; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | return NOTIFY_STOP; |
| 222 | } |
| 223 | |
| 224 | static int nvec_power_get_property(struct power_supply *psy, |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 225 | enum power_supply_property psp, |
| 226 | union power_supply_propval *val) |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 227 | { |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 228 | struct nvec_power *power = dev_get_drvdata(psy->dev.parent); |
Pawel Lebioda | fa79961 | 2014-07-03 21:15:57 +0200 | [diff] [blame] | 229 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 230 | switch (psp) { |
| 231 | case POWER_SUPPLY_PROP_ONLINE: |
| 232 | val->intval = power->on; |
| 233 | break; |
| 234 | default: |
| 235 | return -EINVAL; |
| 236 | } |
| 237 | return 0; |
| 238 | } |
| 239 | |
| 240 | static int nvec_battery_get_property(struct power_supply *psy, |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 241 | enum power_supply_property psp, |
| 242 | union power_supply_propval *val) |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 243 | { |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 244 | struct nvec_power *power = dev_get_drvdata(psy->dev.parent); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 245 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 246 | switch (psp) { |
| 247 | case POWER_SUPPLY_PROP_STATUS: |
| 248 | val->intval = power->bat_status; |
| 249 | break; |
| 250 | case POWER_SUPPLY_PROP_CAPACITY: |
| 251 | val->intval = power->bat_cap; |
| 252 | break; |
| 253 | case POWER_SUPPLY_PROP_PRESENT: |
| 254 | val->intval = power->bat_present; |
| 255 | break; |
| 256 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
| 257 | val->intval = power->bat_voltage_now; |
| 258 | break; |
| 259 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
| 260 | val->intval = power->bat_current_now; |
| 261 | break; |
| 262 | case POWER_SUPPLY_PROP_CURRENT_AVG: |
| 263 | val->intval = power->bat_current_avg; |
| 264 | break; |
| 265 | case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: |
| 266 | val->intval = power->time_remain; |
| 267 | break; |
| 268 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: |
| 269 | val->intval = power->charge_full_design; |
| 270 | break; |
| 271 | case POWER_SUPPLY_PROP_CHARGE_FULL: |
| 272 | val->intval = power->charge_last_full; |
| 273 | break; |
| 274 | case POWER_SUPPLY_PROP_CHARGE_EMPTY: |
| 275 | val->intval = power->critical_capacity; |
| 276 | break; |
| 277 | case POWER_SUPPLY_PROP_CHARGE_NOW: |
| 278 | val->intval = power->capacity_remain; |
| 279 | break; |
| 280 | case POWER_SUPPLY_PROP_TEMP: |
| 281 | val->intval = power->bat_temperature; |
| 282 | break; |
| 283 | case POWER_SUPPLY_PROP_MANUFACTURER: |
| 284 | val->strval = power->bat_manu; |
| 285 | break; |
| 286 | case POWER_SUPPLY_PROP_MODEL_NAME: |
| 287 | val->strval = power->bat_model; |
| 288 | break; |
| 289 | case POWER_SUPPLY_PROP_TECHNOLOGY: |
| 290 | val->intval = power->bat_type_enum; |
| 291 | break; |
| 292 | default: |
| 293 | return -EINVAL; |
| 294 | } |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | static enum power_supply_property nvec_power_props[] = { |
| 299 | POWER_SUPPLY_PROP_ONLINE, |
| 300 | }; |
| 301 | |
| 302 | static enum power_supply_property nvec_battery_props[] = { |
| 303 | POWER_SUPPLY_PROP_STATUS, |
| 304 | POWER_SUPPLY_PROP_PRESENT, |
| 305 | POWER_SUPPLY_PROP_CAPACITY, |
| 306 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 307 | POWER_SUPPLY_PROP_CURRENT_NOW, |
| 308 | #ifdef EC_FULL_DIAG |
| 309 | POWER_SUPPLY_PROP_CURRENT_AVG, |
| 310 | POWER_SUPPLY_PROP_TEMP, |
| 311 | POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, |
| 312 | #endif |
| 313 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, |
| 314 | POWER_SUPPLY_PROP_CHARGE_FULL, |
| 315 | POWER_SUPPLY_PROP_CHARGE_EMPTY, |
| 316 | POWER_SUPPLY_PROP_CHARGE_NOW, |
| 317 | POWER_SUPPLY_PROP_MANUFACTURER, |
| 318 | POWER_SUPPLY_PROP_MODEL_NAME, |
| 319 | POWER_SUPPLY_PROP_TECHNOLOGY, |
| 320 | }; |
| 321 | |
| 322 | static char *nvec_power_supplied_to[] = { |
| 323 | "battery", |
| 324 | }; |
| 325 | |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 326 | static const struct power_supply_desc nvec_bat_psy_desc = { |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 327 | .name = "battery", |
| 328 | .type = POWER_SUPPLY_TYPE_BATTERY, |
| 329 | .properties = nvec_battery_props, |
| 330 | .num_properties = ARRAY_SIZE(nvec_battery_props), |
| 331 | .get_property = nvec_battery_get_property, |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 332 | }; |
| 333 | |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 334 | static const struct power_supply_desc nvec_psy_desc = { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 335 | .name = "ac", |
| 336 | .type = POWER_SUPPLY_TYPE_MAINS, |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 337 | .properties = nvec_power_props, |
| 338 | .num_properties = ARRAY_SIZE(nvec_power_props), |
| 339 | .get_property = nvec_power_get_property, |
| 340 | }; |
| 341 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 342 | static int counter; |
| 343 | static int const bat_iter[] = { |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 344 | SLOT_STATUS, VOLTAGE, CURRENT, CAPACITY_REMAINING, |
| 345 | #ifdef EC_FULL_DIAG |
| 346 | AVERAGE_CURRENT, TEMPERATURE, TIME_REMAINING, |
| 347 | #endif |
| 348 | }; |
| 349 | |
| 350 | static void nvec_power_poll(struct work_struct *work) |
| 351 | { |
Marc Dietrich | 93eff83 | 2013-01-27 17:43:43 +0100 | [diff] [blame] | 352 | char buf[] = { NVEC_SYS, GET_SYSTEM_STATUS }; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 353 | struct nvec_power *power = container_of(work, struct nvec_power, |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 354 | poller.work); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 355 | |
| 356 | if (counter >= ARRAY_SIZE(bat_iter)) |
| 357 | counter = 0; |
| 358 | |
| 359 | /* AC status via sys req */ |
| 360 | nvec_write_async(power->nvec, buf, 2); |
| 361 | msleep(100); |
| 362 | |
| 363 | /* select a battery request function via round robin |
| 364 | doing it all at once seems to overload the power supply */ |
Marc Dietrich | 93eff83 | 2013-01-27 17:43:43 +0100 | [diff] [blame] | 365 | buf[0] = NVEC_BAT; |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 366 | buf[1] = bat_iter[counter++]; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 367 | nvec_write_async(power->nvec, buf, 2); |
| 368 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 369 | schedule_delayed_work(to_delayed_work(work), msecs_to_jiffies(5000)); |
| 370 | }; |
| 371 | |
Bill Pemberton | 4662080 | 2012-11-19 13:22:07 -0500 | [diff] [blame] | 372 | static int nvec_power_probe(struct platform_device *pdev) |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 373 | { |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 374 | struct power_supply **psy; |
| 375 | const struct power_supply_desc *psy_desc; |
Marc Dietrich | f5e3352 | 2012-06-24 23:25:16 +0200 | [diff] [blame] | 376 | struct nvec_power *power; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 377 | struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent); |
Krzysztof Kozlowski | 2dc9215 | 2015-03-12 08:44:02 +0100 | [diff] [blame] | 378 | struct power_supply_config psy_cfg = {}; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 379 | |
Marc Dietrich | f5e3352 | 2012-06-24 23:25:16 +0200 | [diff] [blame] | 380 | power = devm_kzalloc(&pdev->dev, sizeof(struct nvec_power), GFP_NOWAIT); |
Somya Anand | 4c42d97 | 2015-03-16 19:34:11 +0530 | [diff] [blame] | 381 | if (!power) |
Marc Dietrich | f5e3352 | 2012-06-24 23:25:16 +0200 | [diff] [blame] | 382 | return -ENOMEM; |
| 383 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 384 | dev_set_drvdata(&pdev->dev, power); |
| 385 | power->nvec = nvec; |
| 386 | |
| 387 | switch (pdev->id) { |
| 388 | case AC: |
| 389 | psy = &nvec_psy; |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 390 | psy_desc = &nvec_psy_desc; |
Krzysztof Kozlowski | 2dc9215 | 2015-03-12 08:44:02 +0100 | [diff] [blame] | 391 | psy_cfg.supplied_to = nvec_power_supplied_to; |
| 392 | psy_cfg.num_supplicants = ARRAY_SIZE(nvec_power_supplied_to); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 393 | |
| 394 | power->notifier.notifier_call = nvec_power_notifier; |
| 395 | |
| 396 | INIT_DELAYED_WORK(&power->poller, nvec_power_poll); |
| 397 | schedule_delayed_work(&power->poller, msecs_to_jiffies(5000)); |
| 398 | break; |
| 399 | case BAT: |
| 400 | psy = &nvec_bat_psy; |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 401 | psy_desc = &nvec_bat_psy_desc; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 402 | |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 403 | power->notifier.notifier_call = nvec_power_bat_notifier; |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 404 | break; |
| 405 | default: |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 406 | return -ENODEV; |
| 407 | } |
| 408 | |
| 409 | nvec_register_notifier(nvec, &power->notifier, NVEC_SYS); |
| 410 | |
| 411 | if (pdev->id == BAT) |
| 412 | get_bat_mfg_data(power); |
| 413 | |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 414 | *psy = power_supply_register(&pdev->dev, psy_desc, &psy_cfg); |
| 415 | |
| 416 | return PTR_ERR_OR_ZERO(*psy); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 417 | } |
| 418 | |
Bill Pemberton | 1a6a8a8 | 2012-11-19 13:26:41 -0500 | [diff] [blame] | 419 | static int nvec_power_remove(struct platform_device *pdev) |
Marc Dietrich | 3cdde3a | 2012-06-24 23:25:21 +0200 | [diff] [blame] | 420 | { |
| 421 | struct nvec_power *power = platform_get_drvdata(pdev); |
| 422 | |
| 423 | cancel_delayed_work_sync(&power->poller); |
Marc Dietrich | c2b62f6 | 2013-04-29 23:14:52 +0200 | [diff] [blame] | 424 | nvec_unregister_notifier(power->nvec, &power->notifier); |
Marc Dietrich | 3cdde3a | 2012-06-24 23:25:21 +0200 | [diff] [blame] | 425 | switch (pdev->id) { |
| 426 | case AC: |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 427 | power_supply_unregister(nvec_psy); |
Marc Dietrich | 3cdde3a | 2012-06-24 23:25:21 +0200 | [diff] [blame] | 428 | break; |
| 429 | case BAT: |
Krzysztof Kozlowski | 297d716 | 2015-03-12 08:44:11 +0100 | [diff] [blame] | 430 | power_supply_unregister(nvec_bat_psy); |
Marc Dietrich | 3cdde3a | 2012-06-24 23:25:21 +0200 | [diff] [blame] | 431 | } |
| 432 | |
| 433 | return 0; |
| 434 | } |
| 435 | |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 436 | static struct platform_driver nvec_power_driver = { |
| 437 | .probe = nvec_power_probe, |
Bill Pemberton | 44b90a3 | 2012-11-19 13:20:55 -0500 | [diff] [blame] | 438 | .remove = nvec_power_remove, |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 439 | .driver = { |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 440 | .name = "nvec-power", |
Marc Dietrich | 162c7d8 | 2011-09-27 19:00:40 +0200 | [diff] [blame] | 441 | } |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 442 | }; |
| 443 | |
Marc Dietrich | 9891b1c | 2012-06-24 23:25:18 +0200 | [diff] [blame] | 444 | module_platform_driver(nvec_power_driver); |
Marc Dietrich | 32890b9 | 2011-05-19 16:34:42 +0200 | [diff] [blame] | 445 | |
| 446 | MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>"); |
| 447 | MODULE_LICENSE("GPL"); |
| 448 | MODULE_DESCRIPTION("NVEC battery and AC driver"); |
| 449 | MODULE_ALIAS("platform:nvec-power"); |