drivers/power/supply/surface_battery.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Battery driver for 7th-generation Microsoft Surface devices via Surface
   4  * System Aggregator Module (SSAM).
   5  *
   6  * Copyright (C) 2019-2021 Maximilian Luz <luzmaximilian@gmail.com>
   7  */
   8
   9 #include <linux/unaligned.h>
  10 #include <linux/jiffies.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/power_supply.h>
  15 #include <linux/sysfs.h>
  16 #include <linux/types.h>
  17 #include <linux/workqueue.h>
  18
  19 #include <linux/surface_aggregator/device.h>
  20
  21
  22 /* -- SAM interface. -------------------------------------------------------- */
  23
  24 enum sam_event_cid_bat {
  25         SAM_EVENT_CID_BAT_BIX         = 0x15,
  26         SAM_EVENT_CID_BAT_BST         = 0x16,
  27         SAM_EVENT_CID_BAT_ADP         = 0x17,
  28         SAM_EVENT_CID_BAT_PROT        = 0x18,
  29         SAM_EVENT_CID_BAT_DPTF        = 0x53,
  30 };
  31
  32 enum sam_battery_sta {
  33         SAM_BATTERY_STA_OK            = 0x0f,
  34         SAM_BATTERY_STA_PRESENT       = 0x10,
  35 };
  36
  37 enum sam_battery_state {
  38         SAM_BATTERY_STATE_DISCHARGING = BIT(0),
  39         SAM_BATTERY_STATE_CHARGING    = BIT(1),
  40         SAM_BATTERY_STATE_CRITICAL    = BIT(2),
  41 };
  42
  43 enum sam_battery_power_unit {
  44         SAM_BATTERY_POWER_UNIT_mW     = 0,
  45         SAM_BATTERY_POWER_UNIT_mA     = 1,
  46 };
  47
  48 /* Equivalent to data returned in ACPI _BIX method, revision 0. */
  49 struct spwr_bix {
  50         u8  revision;
  51         __le32 power_unit;
  52         __le32 design_cap;
  53         __le32 last_full_charge_cap;
  54         __le32 technology;
  55         __le32 design_voltage;
  56         __le32 design_cap_warn;
  57         __le32 design_cap_low;
  58         __le32 cycle_count;
  59         __le32 measurement_accuracy;
  60         __le32 max_sampling_time;
  61         __le32 min_sampling_time;
  62         __le32 max_avg_interval;
  63         __le32 min_avg_interval;
  64         __le32 bat_cap_granularity_1;
  65         __le32 bat_cap_granularity_2;
  66         __u8 model[21];
  67         __u8 serial[11];
  68         __u8 type[5];
  69         __u8 oem_info[21];
  70 } __packed;
  71
  72 static_assert(sizeof(struct spwr_bix) == 119);
  73
  74 /* Equivalent to data returned in ACPI _BST method. */
  75 struct spwr_bst {
  76         __le32 state;
  77         __le32 present_rate;
  78         __le32 remaining_cap;
  79         __le32 present_voltage;
  80 } __packed;
  81
  82 static_assert(sizeof(struct spwr_bst) == 16);
  83
  84 #define SPWR_BIX_REVISION               0
  85 #define SPWR_BATTERY_VALUE_UNKNOWN      0xffffffff
  86
  87 /* Get battery status (_STA) */
  88 SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_sta, __le32, {
  89         .target_category = SSAM_SSH_TC_BAT,
  90         .command_id      = 0x01,
  91 });
  92
  93 /* Get battery static information (_BIX). */
  94 SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_bix, struct spwr_bix, {
  95         .target_category = SSAM_SSH_TC_BAT,
  96         .command_id      = 0x02,
  97 });
  98
  99 /* Get battery dynamic information (_BST). */
 100 SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_bst, struct spwr_bst, {
 101         .target_category = SSAM_SSH_TC_BAT,
 102         .command_id      = 0x03,
 103 });
 104
 105 /* Set battery trip point (_BTP). */
 106 SSAM_DEFINE_SYNC_REQUEST_CL_W(ssam_bat_set_btp, __le32, {
 107         .target_category = SSAM_SSH_TC_BAT,
 108         .command_id      = 0x04,
 109 });
 110
 111
 112 /* -- Device structures. ---------------------------------------------------- */
 113
 114 struct spwr_psy_properties {
 115         const char *name;
 116         struct ssam_event_registry registry;
 117 };
 118
 119 struct spwr_battery_device {
 120         struct ssam_device *sdev;
 121
 122         char name[32];
 123         struct power_supply *psy;
 124         struct power_supply_desc psy_desc;
 125
 126         struct delayed_work update_work;
 127
 128         struct ssam_event_notifier notif;
 129
 130         struct mutex lock;  /* Guards access to state data below. */
 131         unsigned long timestamp;
 132
 133         __le32 sta;
 134         struct spwr_bix bix;
 135         struct spwr_bst bst;
 136         u32 alarm;
 137 };
 138
 139
 140 /* -- Module parameters. ---------------------------------------------------- */
 141
 142 static unsigned int cache_time = 1000;
 143 module_param(cache_time, uint, 0644);
 144 MODULE_PARM_DESC(cache_time, "battery state caching time in milliseconds [default: 1000]");
 145
 146
 147 /* -- State management. ----------------------------------------------------- */
 148
 149 /*
 150  * Delay for battery update quirk. See spwr_external_power_changed() below
 151  * for more details.
 152  */
 153 #define SPWR_AC_BAT_UPDATE_DELAY        msecs_to_jiffies(5000)
 154
 155 static bool spwr_battery_present(struct spwr_battery_device *bat)
 156 {
 157         lockdep_assert_held(&bat->lock);
 158
 159         return le32_to_cpu(bat->sta) & SAM_BATTERY_STA_PRESENT;
 160 }
 161
 162 static int spwr_battery_load_sta(struct spwr_battery_device *bat)
 163 {
 164         lockdep_assert_held(&bat->lock);
 165
 166         return ssam_retry(ssam_bat_get_sta, bat->sdev, &bat->sta);
 167 }
 168
 169 static int spwr_battery_load_bix(struct spwr_battery_device *bat)
 170 {
 171         int status;
 172
 173         lockdep_assert_held(&bat->lock);
 174
 175         if (!spwr_battery_present(bat))
 176                 return 0;
 177
 178         status = ssam_retry(ssam_bat_get_bix, bat->sdev, &bat->bix);
 179
 180         /* Enforce NULL terminated strings in case anything goes wrong... */
 181         bat->bix.model[ARRAY_SIZE(bat->bix.model) - 1] = 0;
 182         bat->bix.serial[ARRAY_SIZE(bat->bix.serial) - 1] = 0;
 183         bat->bix.type[ARRAY_SIZE(bat->bix.type) - 1] = 0;
 184         bat->bix.oem_info[ARRAY_SIZE(bat->bix.oem_info) - 1] = 0;
 185
 186         return status;
 187 }
 188
 189 static int spwr_battery_load_bst(struct spwr_battery_device *bat)
 190 {
 191         lockdep_assert_held(&bat->lock);
 192
 193         if (!spwr_battery_present(bat))
 194                 return 0;
 195
 196         return ssam_retry(ssam_bat_get_bst, bat->sdev, &bat->bst);
 197 }
 198
 199 static int spwr_battery_set_alarm_unlocked(struct spwr_battery_device *bat, u32 value)
 200 {
 201         __le32 value_le = cpu_to_le32(value);
 202
 203         lockdep_assert_held(&bat->lock);
 204
 205         bat->alarm = value;
 206         return ssam_retry(ssam_bat_set_btp, bat->sdev, &value_le);
 207 }
 208
 209 static int spwr_battery_update_bst_unlocked(struct spwr_battery_device *bat, bool cached)
 210 {
 211         unsigned long cache_deadline = bat->timestamp + msecs_to_jiffies(cache_time);
 212         int status;
 213
 214         lockdep_assert_held(&bat->lock);
 215
 216         if (cached && bat->timestamp && time_is_after_jiffies(cache_deadline))
 217                 return 0;
 218
 219         status = spwr_battery_load_sta(bat);
 220         if (status)
 221                 return status;
 222
 223         status = spwr_battery_load_bst(bat);
 224         if (status)
 225                 return status;
 226
 227         bat->timestamp = jiffies;
 228         return 0;
 229 }
 230
 231 static int spwr_battery_update_bst(struct spwr_battery_device *bat, bool cached)
 232 {
 233         int status;
 234
 235         mutex_lock(&bat->lock);
 236         status = spwr_battery_update_bst_unlocked(bat, cached);
 237         mutex_unlock(&bat->lock);
 238
 239         return status;
 240 }
 241
 242 static int spwr_battery_update_bix_unlocked(struct spwr_battery_device *bat)
 243 {
 244         int status;
 245
 246         lockdep_assert_held(&bat->lock);
 247
 248         status = spwr_battery_load_sta(bat);
 249         if (status)
 250                 return status;
 251
 252         status = spwr_battery_load_bix(bat);
 253         if (status)
 254                 return status;
 255
 256         status = spwr_battery_load_bst(bat);
 257         if (status)
 258                 return status;
 259
 260         if (bat->bix.revision != SPWR_BIX_REVISION)
 261                 dev_warn(&bat->sdev->dev, "unsupported battery revision: %u\n", bat->bix.revision);
 262
 263         bat->timestamp = jiffies;
 264         return 0;
 265 }
 266
 267 static u32 sprw_battery_get_full_cap_safe(struct spwr_battery_device *bat)
 268 {
 269         u32 full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
 270
 271         lockdep_assert_held(&bat->lock);
 272
 273         if (full_cap == 0 || full_cap == SPWR_BATTERY_VALUE_UNKNOWN)
 274                 full_cap = get_unaligned_le32(&bat->bix.design_cap);
 275
 276         return full_cap;
 277 }
 278
 279 static bool spwr_battery_is_full(struct spwr_battery_device *bat)
 280 {
 281         u32 state = get_unaligned_le32(&bat->bst.state);
 282         u32 full_cap = sprw_battery_get_full_cap_safe(bat);
 283         u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
 284
 285         lockdep_assert_held(&bat->lock);
 286
 287         return full_cap != SPWR_BATTERY_VALUE_UNKNOWN && full_cap != 0 &&
 288                 remaining_cap != SPWR_BATTERY_VALUE_UNKNOWN &&
 289                 remaining_cap >= full_cap &&
 290                 state == 0;
 291 }
 292
 293 static int spwr_battery_recheck_full(struct spwr_battery_device *bat)
 294 {
 295         bool present;
 296         u32 unit;
 297         int status;
 298
 299         mutex_lock(&bat->lock);
 300         unit = get_unaligned_le32(&bat->bix.power_unit);
 301         present = spwr_battery_present(bat);
 302
 303         status = spwr_battery_update_bix_unlocked(bat);
 304         if (status)
 305                 goto out;
 306
 307         /* If battery has been attached, (re-)initialize alarm. */
 308         if (!present && spwr_battery_present(bat)) {
 309                 u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
 310
 311                 status = spwr_battery_set_alarm_unlocked(bat, cap_warn);
 312                 if (status)
 313                         goto out;
 314         }
 315
 316         /*
 317          * Warn if the unit has changed. This is something we genuinely don't
 318          * expect to happen, so make this a big warning. If it does, we'll
 319          * need to add support for it.
 320          */
 321         WARN_ON(unit != get_unaligned_le32(&bat->bix.power_unit));
 322
 323 out:
 324         mutex_unlock(&bat->lock);
 325
 326         if (!status)
 327                 power_supply_changed(bat->psy);
 328
 329         return status;
 330 }
 331
 332 static int spwr_battery_recheck_status(struct spwr_battery_device *bat)
 333 {
 334         int status;
 335
 336         status = spwr_battery_update_bst(bat, false);
 337         if (!status)
 338                 power_supply_changed(bat->psy);
 339
 340         return status;
 341 }
 342
 343 static u32 spwr_notify_bat(struct ssam_event_notifier *nf, const struct ssam_event *event)
 344 {
 345         struct spwr_battery_device *bat = container_of(nf, struct spwr_battery_device, notif);
 346         int status;
 347
 348         /*
 349          * We cannot use strict matching when registering the notifier as the
 350          * EC expects us to register it against instance ID 0. Strict matching
 351          * would thus drop events, as those may have non-zero instance IDs in
 352          * this subsystem. So we need to check the instance ID of the event
 353          * here manually.
 354          */
 355         if (event->instance_id != bat->sdev->uid.instance)
 356                 return 0;
 357
 358         dev_dbg(&bat->sdev->dev, "power event (cid = %#04x, iid = %#04x, tid = %#04x)\n",
 359                 event->command_id, event->instance_id, event->target_id);
 360
 361         switch (event->command_id) {
 362         case SAM_EVENT_CID_BAT_BIX:
 363                 status = spwr_battery_recheck_full(bat);
 364                 break;
 365
 366         case SAM_EVENT_CID_BAT_BST:
 367                 status = spwr_battery_recheck_status(bat);
 368                 break;
 369
 370         case SAM_EVENT_CID_BAT_PROT:
 371                 /*
 372                  * TODO: Implement support for battery protection status change
 373                  *       event.
 374                  */
 375                 status = 0;
 376                 break;
 377
 378         case SAM_EVENT_CID_BAT_DPTF:
 379                 /*
 380                  * TODO: Implement support for DPTF event.
 381                  */
 382                 status = 0;
 383                 break;
 384
 385         default:
 386                 return 0;
 387         }
 388
 389         return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
 390 }
 391
 392 static void spwr_battery_update_bst_workfn(struct work_struct *work)
 393 {
 394         struct delayed_work *dwork = to_delayed_work(work);
 395         struct spwr_battery_device *bat;
 396         int status;
 397
 398         bat = container_of(dwork, struct spwr_battery_device, update_work);
 399
 400         status = spwr_battery_update_bst(bat, false);
 401         if (status) {
 402                 dev_err(&bat->sdev->dev, "failed to update battery state: %d\n", status);
 403                 return;
 404         }
 405
 406         power_supply_changed(bat->psy);
 407 }
 408
 409 static void spwr_external_power_changed(struct power_supply *psy)
 410 {
 411         struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
 412
 413         /*
 414          * Handle battery update quirk: When the battery is fully charged (or
 415          * charged up to the limit imposed by the UEFI battery limit) and the
 416          * adapter is plugged in or removed, the EC does not send a separate
 417          * event for the state (charging/discharging) change. Furthermore it
 418          * may take some time until the state is updated on the battery.
 419          * Schedule an update to solve this.
 420          */
 421
 422         schedule_delayed_work(&bat->update_work, SPWR_AC_BAT_UPDATE_DELAY);
 423 }
 424
 425
 426 /* -- Properties. ----------------------------------------------------------- */
 427
 428 static const enum power_supply_property spwr_battery_props_chg[] = {
 429         POWER_SUPPLY_PROP_STATUS,
 430         POWER_SUPPLY_PROP_PRESENT,
 431         POWER_SUPPLY_PROP_TECHNOLOGY,
 432         POWER_SUPPLY_PROP_CYCLE_COUNT,
 433         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 434         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 435         POWER_SUPPLY_PROP_CURRENT_NOW,
 436         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 437         POWER_SUPPLY_PROP_CHARGE_FULL,
 438         POWER_SUPPLY_PROP_CHARGE_NOW,
 439         POWER_SUPPLY_PROP_CAPACITY,
 440         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 441         POWER_SUPPLY_PROP_MODEL_NAME,
 442         POWER_SUPPLY_PROP_MANUFACTURER,
 443         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 444 };
 445
 446 static const enum power_supply_property spwr_battery_props_eng[] = {
 447         POWER_SUPPLY_PROP_STATUS,
 448         POWER_SUPPLY_PROP_PRESENT,
 449         POWER_SUPPLY_PROP_TECHNOLOGY,
 450         POWER_SUPPLY_PROP_CYCLE_COUNT,
 451         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 452         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 453         POWER_SUPPLY_PROP_POWER_NOW,
 454         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 455         POWER_SUPPLY_PROP_ENERGY_FULL,
 456         POWER_SUPPLY_PROP_ENERGY_NOW,
 457         POWER_SUPPLY_PROP_CAPACITY,
 458         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 459         POWER_SUPPLY_PROP_MODEL_NAME,
 460         POWER_SUPPLY_PROP_MANUFACTURER,
 461         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 462 };
 463
 464 static int spwr_battery_prop_status(struct spwr_battery_device *bat)
 465 {
 466         u32 state = get_unaligned_le32(&bat->bst.state);
 467         u32 present_rate = get_unaligned_le32(&bat->bst.present_rate);
 468
 469         lockdep_assert_held(&bat->lock);
 470
 471         if (state & SAM_BATTERY_STATE_DISCHARGING)
 472                 return POWER_SUPPLY_STATUS_DISCHARGING;
 473
 474         if (state & SAM_BATTERY_STATE_CHARGING)
 475                 return POWER_SUPPLY_STATUS_CHARGING;
 476
 477         if (spwr_battery_is_full(bat))
 478                 return POWER_SUPPLY_STATUS_FULL;
 479
 480         if (present_rate == 0)
 481                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 482
 483         return POWER_SUPPLY_STATUS_UNKNOWN;
 484 }
 485
 486 static int spwr_battery_prop_technology(struct spwr_battery_device *bat)
 487 {
 488         lockdep_assert_held(&bat->lock);
 489
 490         if (!strcasecmp("NiCd", bat->bix.type))
 491                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
 492
 493         if (!strcasecmp("NiMH", bat->bix.type))
 494                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
 495
 496         if (!strcasecmp("LION", bat->bix.type))
 497                 return POWER_SUPPLY_TECHNOLOGY_LION;
 498
 499         if (!strncasecmp("LI-ION", bat->bix.type, 6))
 500                 return POWER_SUPPLY_TECHNOLOGY_LION;
 501
 502         if (!strcasecmp("LiP", bat->bix.type))
 503                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
 504
 505         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 506 }
 507
 508 static int spwr_battery_prop_capacity(struct spwr_battery_device *bat)
 509 {
 510         u32 full_cap = sprw_battery_get_full_cap_safe(bat);
 511         u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
 512
 513         lockdep_assert_held(&bat->lock);
 514
 515         if (full_cap == 0 || full_cap == SPWR_BATTERY_VALUE_UNKNOWN)
 516                 return -ENODATA;
 517
 518         if (remaining_cap == SPWR_BATTERY_VALUE_UNKNOWN)
 519                 return -ENODATA;
 520
 521         return remaining_cap * 100 / full_cap;
 522 }
 523
 524 static int spwr_battery_prop_capacity_level(struct spwr_battery_device *bat)
 525 {
 526         u32 state = get_unaligned_le32(&bat->bst.state);
 527         u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
 528
 529         lockdep_assert_held(&bat->lock);
 530
 531         if (state & SAM_BATTERY_STATE_CRITICAL)
 532                 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 533
 534         if (spwr_battery_is_full(bat))
 535                 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 536
 537         if (remaining_cap <= bat->alarm)
 538                 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 539
 540         return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 541 }
 542
 543 static int spwr_battery_get_property(struct power_supply *psy, enum power_supply_property psp,
 544                                      union power_supply_propval *val)
 545 {
 546         struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
 547         u32 value;
 548         int status;
 549
 550         mutex_lock(&bat->lock);
 551
 552         status = spwr_battery_update_bst_unlocked(bat, true);
 553         if (status)
 554                 goto out;
 555
 556         /* Abort if battery is not present. */
 557         if (!spwr_battery_present(bat) && psp != POWER_SUPPLY_PROP_PRESENT) {
 558                 status = -ENODEV;
 559                 goto out;
 560         }
 561
 562         switch (psp) {
 563         case POWER_SUPPLY_PROP_STATUS:
 564                 val->intval = spwr_battery_prop_status(bat);
 565                 break;
 566
 567         case POWER_SUPPLY_PROP_PRESENT:
 568                 val->intval = spwr_battery_present(bat);
 569                 break;
 570
 571         case POWER_SUPPLY_PROP_TECHNOLOGY:
 572                 val->intval = spwr_battery_prop_technology(bat);
 573                 break;
 574
 575         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 576                 value = get_unaligned_le32(&bat->bix.cycle_count);
 577                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 578                         val->intval = value;
 579                 else
 580                         status = -ENODATA;
 581                 break;
 582
 583         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 584                 value = get_unaligned_le32(&bat->bix.design_voltage);
 585                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 586                         val->intval = value * 1000;
 587                 else
 588                         status = -ENODATA;
 589                 break;
 590
 591         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 592                 value = get_unaligned_le32(&bat->bst.present_voltage);
 593                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 594                         val->intval = value * 1000;
 595                 else
 596                         status = -ENODATA;
 597                 break;
 598
 599         case POWER_SUPPLY_PROP_CURRENT_NOW:
 600         case POWER_SUPPLY_PROP_POWER_NOW:
 601                 value = get_unaligned_le32(&bat->bst.present_rate);
 602                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 603                         val->intval = value * 1000;
 604                 else
 605                         status = -ENODATA;
 606                 break;
 607
 608         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 609         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 610                 value = get_unaligned_le32(&bat->bix.design_cap);
 611                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 612                         val->intval = value * 1000;
 613                 else
 614                         status = -ENODATA;
 615                 break;
 616
 617         case POWER_SUPPLY_PROP_CHARGE_FULL:
 618         case POWER_SUPPLY_PROP_ENERGY_FULL:
 619                 value = get_unaligned_le32(&bat->bix.last_full_charge_cap);
 620                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 621                         val->intval = value * 1000;
 622                 else
 623                         status = -ENODATA;
 624                 break;
 625
 626         case POWER_SUPPLY_PROP_CHARGE_NOW:
 627         case POWER_SUPPLY_PROP_ENERGY_NOW:
 628                 value = get_unaligned_le32(&bat->bst.remaining_cap);
 629                 if (value != SPWR_BATTERY_VALUE_UNKNOWN)
 630                         val->intval = value * 1000;
 631                 else
 632                         status = -ENODATA;
 633                 break;
 634
 635         case POWER_SUPPLY_PROP_CAPACITY:
 636                 val->intval = spwr_battery_prop_capacity(bat);
 637                 break;
 638
 639         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 640                 val->intval = spwr_battery_prop_capacity_level(bat);
 641                 break;
 642
 643         case POWER_SUPPLY_PROP_MODEL_NAME:
 644                 val->strval = bat->bix.model;
 645                 break;
 646
 647         case POWER_SUPPLY_PROP_MANUFACTURER:
 648                 val->strval = bat->bix.oem_info;
 649                 break;
 650
 651         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 652                 val->strval = bat->bix.serial;
 653                 break;
 654
 655         default:
 656                 status = -EINVAL;
 657                 break;
 658         }
 659
 660 out:
 661         mutex_unlock(&bat->lock);
 662         return status;
 663 }
 664
 665
 666 /* -- Alarm attribute. ------------------------------------------------------ */
 667
 668 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, char *buf)
 669 {
 670         struct power_supply *psy = dev_get_drvdata(dev);
 671         struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
 672         int status;
 673
 674         mutex_lock(&bat->lock);
 675         status = sysfs_emit(buf, "%d\n", bat->alarm * 1000);
 676         mutex_unlock(&bat->lock);
 677
 678         return status;
 679 }
 680
 681 static ssize_t alarm_store(struct device *dev, struct device_attribute *attr, const char *buf,
 682                            size_t count)
 683 {
 684         struct power_supply *psy = dev_get_drvdata(dev);
 685         struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
 686         unsigned long value;
 687         int status;
 688
 689         status = kstrtoul(buf, 0, &value);
 690         if (status)
 691                 return status;
 692
 693         mutex_lock(&bat->lock);
 694
 695         if (!spwr_battery_present(bat)) {
 696                 mutex_unlock(&bat->lock);
 697                 return -ENODEV;
 698         }
 699
 700         status = spwr_battery_set_alarm_unlocked(bat, value / 1000);
 701         if (status) {
 702                 mutex_unlock(&bat->lock);
 703                 return status;
 704         }
 705
 706         mutex_unlock(&bat->lock);
 707         return count;
 708 }
 709
 710 static DEVICE_ATTR_RW(alarm);
 711
 712 static struct attribute *spwr_battery_attrs[] = {
 713         &dev_attr_alarm.attr,
 714         NULL,
 715 };
 716 ATTRIBUTE_GROUPS(spwr_battery);
 717
 718
 719 /* -- Device setup. --------------------------------------------------------- */
 720
 721 static void spwr_battery_init(struct spwr_battery_device *bat, struct ssam_device *sdev,
 722                               struct ssam_event_registry registry, const char *name)
 723 {
 724         mutex_init(&bat->lock);
 725         strscpy(bat->name, name, sizeof(bat->name));
 726
 727         bat->sdev = sdev;
 728
 729         bat->notif.base.priority = 1;
 730         bat->notif.base.fn = spwr_notify_bat;
 731         bat->notif.event.reg = registry;
 732         bat->notif.event.id.target_category = sdev->uid.category;
 733         bat->notif.event.id.instance = 0;       /* need to register with instance 0 */
 734         bat->notif.event.mask = SSAM_EVENT_MASK_TARGET;
 735         bat->notif.event.flags = SSAM_EVENT_SEQUENCED;
 736
 737         bat->psy_desc.name = bat->name;
 738         bat->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY;
 739         bat->psy_desc.get_property = spwr_battery_get_property;
 740
 741         INIT_DELAYED_WORK(&bat->update_work, spwr_battery_update_bst_workfn);
 742 }
 743
 744 static int spwr_battery_register(struct spwr_battery_device *bat)
 745 {
 746         struct power_supply_config psy_cfg = {};
 747         __le32 sta;
 748         int status;
 749
 750         /* Make sure the device is there and functioning properly. */
 751         status = ssam_retry(ssam_bat_get_sta, bat->sdev, &sta);
 752         if (status)
 753                 return status;
 754
 755         if ((le32_to_cpu(sta) & SAM_BATTERY_STA_OK) != SAM_BATTERY_STA_OK)
 756                 return -ENODEV;
 757
 758         /* Satisfy lockdep although we are in an exclusive context here. */
 759         mutex_lock(&bat->lock);
 760
 761         status = spwr_battery_update_bix_unlocked(bat);
 762         if (status) {
 763                 mutex_unlock(&bat->lock);
 764                 return status;
 765         }
 766
 767         if (spwr_battery_present(bat)) {
 768                 u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
 769
 770                 status = spwr_battery_set_alarm_unlocked(bat, cap_warn);
 771                 if (status) {
 772                         mutex_unlock(&bat->lock);
 773                         return status;
 774                 }
 775         }
 776
 777         mutex_unlock(&bat->lock);
 778
 779         bat->psy_desc.external_power_changed = spwr_external_power_changed;
 780
 781         switch (get_unaligned_le32(&bat->bix.power_unit)) {
 782         case SAM_BATTERY_POWER_UNIT_mW:
 783                 bat->psy_desc.properties = spwr_battery_props_eng;
 784                 bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_eng);
 785                 break;
 786
 787         case SAM_BATTERY_POWER_UNIT_mA:
 788                 bat->psy_desc.properties = spwr_battery_props_chg;
 789                 bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_chg);
 790                 break;
 791
 792         default:
 793                 dev_err(&bat->sdev->dev, "unsupported battery power unit: %u\n",
 794                         get_unaligned_le32(&bat->bix.power_unit));
 795                 return -EINVAL;
 796         }
 797
 798         psy_cfg.drv_data = bat;
 799         psy_cfg.attr_grp = spwr_battery_groups;
 800
 801         bat->psy = devm_power_supply_register(&bat->sdev->dev, &bat->psy_desc, &psy_cfg);
 802         if (IS_ERR(bat->psy))
 803                 return PTR_ERR(bat->psy);
 804
 805         return ssam_device_notifier_register(bat->sdev, &bat->notif);
 806 }
 807
 808
 809 /* -- Driver setup. --------------------------------------------------------- */
 810
 811 static int __maybe_unused surface_battery_resume(struct device *dev)
 812 {
 813         return spwr_battery_recheck_full(dev_get_drvdata(dev));
 814 }
 815 static SIMPLE_DEV_PM_OPS(surface_battery_pm_ops, NULL, surface_battery_resume);
 816
 817 static int surface_battery_probe(struct ssam_device *sdev)
 818 {
 819         const struct spwr_psy_properties *p;
 820         struct spwr_battery_device *bat;
 821
 822         p = ssam_device_get_match_data(sdev);
 823         if (!p)
 824                 return -ENODEV;
 825
 826         bat = devm_kzalloc(&sdev->dev, sizeof(*bat), GFP_KERNEL);
 827         if (!bat)
 828                 return -ENOMEM;
 829
 830         spwr_battery_init(bat, sdev, p->registry, p->name);
 831         ssam_device_set_drvdata(sdev, bat);
 832
 833         return spwr_battery_register(bat);
 834 }
 835
 836 static void surface_battery_remove(struct ssam_device *sdev)
 837 {
 838         struct spwr_battery_device *bat = ssam_device_get_drvdata(sdev);
 839
 840         ssam_device_notifier_unregister(sdev, &bat->notif);
 841         cancel_delayed_work_sync(&bat->update_work);
 842 }
 843
 844 static const struct spwr_psy_properties spwr_psy_props_bat1 = {
 845         .name = "BAT1",
 846         .registry = SSAM_EVENT_REGISTRY_SAM,
 847 };
 848
 849 static const struct spwr_psy_properties spwr_psy_props_bat2_sb3 = {
 850         .name = "BAT2",
 851         .registry = SSAM_EVENT_REGISTRY_KIP,
 852 };
 853
 854 static const struct ssam_device_id surface_battery_match[] = {
 855         { SSAM_SDEV(BAT, SAM, 0x01, 0x00), (unsigned long)&spwr_psy_props_bat1     },
 856         { SSAM_SDEV(BAT, KIP, 0x01, 0x00), (unsigned long)&spwr_psy_props_bat2_sb3 },
 857         { },
 858 };
 859 MODULE_DEVICE_TABLE(ssam, surface_battery_match);
 860
 861 static struct ssam_device_driver surface_battery_driver = {
 862         .probe = surface_battery_probe,
 863         .remove = surface_battery_remove,
 864         .match_table = surface_battery_match,
 865         .driver = {
 866                 .name = "surface_battery",
 867                 .pm = &surface_battery_pm_ops,
 868                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 869         },
 870 };
 871 module_ssam_device_driver(surface_battery_driver);
 872
 873 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
 874 MODULE_DESCRIPTION("Battery driver for Surface System Aggregator Module");
 875 MODULE_LICENSE("GPL");