Lines Matching refs:bat
155 static bool spwr_battery_present(struct spwr_battery_device *bat)
157 lockdep_assert_held(&bat->lock);
159 return le32_to_cpu(bat->sta) & SAM_BATTERY_STA_PRESENT;
162 static int spwr_battery_load_sta(struct spwr_battery_device *bat)
164 lockdep_assert_held(&bat->lock);
166 return ssam_retry(ssam_bat_get_sta, bat->sdev, &bat->sta);
169 static int spwr_battery_load_bix(struct spwr_battery_device *bat)
173 lockdep_assert_held(&bat->lock);
175 if (!spwr_battery_present(bat))
178 status = ssam_retry(ssam_bat_get_bix, bat->sdev, &bat->bix);
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;
189 static int spwr_battery_load_bst(struct spwr_battery_device *bat)
191 lockdep_assert_held(&bat->lock);
193 if (!spwr_battery_present(bat))
196 return ssam_retry(ssam_bat_get_bst, bat->sdev, &bat->bst);
199 static int spwr_battery_set_alarm_unlocked(struct spwr_battery_device *bat, u32 value)
203 lockdep_assert_held(&bat->lock);
205 bat->alarm = value;
206 return ssam_retry(ssam_bat_set_btp, bat->sdev, &value_le);
209 static int spwr_battery_update_bst_unlocked(struct spwr_battery_device *bat, bool cached)
211 unsigned long cache_deadline = bat->timestamp + msecs_to_jiffies(cache_time);
214 lockdep_assert_held(&bat->lock);
216 if (cached && bat->timestamp && time_is_after_jiffies(cache_deadline))
219 status = spwr_battery_load_sta(bat);
223 status = spwr_battery_load_bst(bat);
227 bat->timestamp = jiffies;
231 static int spwr_battery_update_bst(struct spwr_battery_device *bat, bool cached)
235 mutex_lock(&bat->lock);
236 status = spwr_battery_update_bst_unlocked(bat, cached);
237 mutex_unlock(&bat->lock);
242 static int spwr_battery_update_bix_unlocked(struct spwr_battery_device *bat)
246 lockdep_assert_held(&bat->lock);
248 status = spwr_battery_load_sta(bat);
252 status = spwr_battery_load_bix(bat);
256 status = spwr_battery_load_bst(bat);
260 if (bat->bix.revision != SPWR_BIX_REVISION)
261 dev_warn(&bat->sdev->dev, "unsupported battery revision: %u\n", bat->bix.revision);
263 bat->timestamp = jiffies;
267 static u32 sprw_battery_get_full_cap_safe(struct spwr_battery_device *bat)
269 u32 full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
271 lockdep_assert_held(&bat->lock);
274 full_cap = get_unaligned_le32(&bat->bix.design_cap);
279 static bool spwr_battery_is_full(struct spwr_battery_device *bat)
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);
285 lockdep_assert_held(&bat->lock);
293 static int spwr_battery_recheck_full(struct spwr_battery_device *bat)
299 mutex_lock(&bat->lock);
300 unit = get_unaligned_le32(&bat->bix.power_unit);
301 present = spwr_battery_present(bat);
303 status = spwr_battery_update_bix_unlocked(bat);
308 if (!present && spwr_battery_present(bat)) {
309 u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
311 status = spwr_battery_set_alarm_unlocked(bat, cap_warn);
321 WARN_ON(unit != get_unaligned_le32(&bat->bix.power_unit));
324 mutex_unlock(&bat->lock);
327 power_supply_changed(bat->psy);
332 static int spwr_battery_recheck_status(struct spwr_battery_device *bat)
336 status = spwr_battery_update_bst(bat, false);
338 power_supply_changed(bat->psy);
345 struct spwr_battery_device *bat = container_of(nf, struct spwr_battery_device, notif);
355 if (event->instance_id != bat->sdev->uid.instance)
358 dev_dbg(&bat->sdev->dev, "power event (cid = %#04x, iid = %#04x, tid = %#04x)\n",
363 status = spwr_battery_recheck_full(bat);
367 status = spwr_battery_recheck_status(bat);
395 struct spwr_battery_device *bat;
398 bat = container_of(dwork, struct spwr_battery_device, update_work);
400 status = spwr_battery_update_bst(bat, false);
402 dev_err(&bat->sdev->dev, "failed to update battery state: %d\n", status);
406 power_supply_changed(bat->psy);
411 struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
422 schedule_delayed_work(&bat->update_work, SPWR_AC_BAT_UPDATE_DELAY);
464 static int spwr_battery_prop_status(struct spwr_battery_device *bat)
466 u32 state = get_unaligned_le32(&bat->bst.state);
467 u32 present_rate = get_unaligned_le32(&bat->bst.present_rate);
469 lockdep_assert_held(&bat->lock);
477 if (spwr_battery_is_full(bat))
486 static int spwr_battery_prop_technology(struct spwr_battery_device *bat)
488 lockdep_assert_held(&bat->lock);
490 if (!strcasecmp("NiCd", bat->bix.type))
493 if (!strcasecmp("NiMH", bat->bix.type))
496 if (!strcasecmp("LION", bat->bix.type))
499 if (!strncasecmp("LI-ION", bat->bix.type, 6))
502 if (!strcasecmp("LiP", bat->bix.type))
508 static int spwr_battery_prop_capacity(struct spwr_battery_device *bat)
510 u32 full_cap = sprw_battery_get_full_cap_safe(bat);
511 u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
513 lockdep_assert_held(&bat->lock);
524 static int spwr_battery_prop_capacity_level(struct spwr_battery_device *bat)
526 u32 state = get_unaligned_le32(&bat->bst.state);
527 u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
529 lockdep_assert_held(&bat->lock);
534 if (spwr_battery_is_full(bat))
537 if (remaining_cap <= bat->alarm)
546 struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
550 mutex_lock(&bat->lock);
552 status = spwr_battery_update_bst_unlocked(bat, true);
557 if (!spwr_battery_present(bat) && psp != POWER_SUPPLY_PROP_PRESENT) {
564 val->intval = spwr_battery_prop_status(bat);
568 val->intval = spwr_battery_present(bat);
572 val->intval = spwr_battery_prop_technology(bat);
576 value = get_unaligned_le32(&bat->bix.cycle_count);
584 value = get_unaligned_le32(&bat->bix.design_voltage);
592 value = get_unaligned_le32(&bat->bst.present_voltage);
601 value = get_unaligned_le32(&bat->bst.present_rate);
610 value = get_unaligned_le32(&bat->bix.design_cap);
619 value = get_unaligned_le32(&bat->bix.last_full_charge_cap);
628 value = get_unaligned_le32(&bat->bst.remaining_cap);
636 val->intval = spwr_battery_prop_capacity(bat);
640 val->intval = spwr_battery_prop_capacity_level(bat);
644 val->strval = bat->bix.model;
648 val->strval = bat->bix.oem_info;
652 val->strval = bat->bix.serial;
661 mutex_unlock(&bat->lock);
671 struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
674 mutex_lock(&bat->lock);
675 status = sysfs_emit(buf, "%d\n", bat->alarm * 1000);
676 mutex_unlock(&bat->lock);
685 struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
693 mutex_lock(&bat->lock);
695 if (!spwr_battery_present(bat)) {
696 mutex_unlock(&bat->lock);
700 status = spwr_battery_set_alarm_unlocked(bat, value / 1000);
702 mutex_unlock(&bat->lock);
706 mutex_unlock(&bat->lock);
721 static void spwr_battery_init(struct spwr_battery_device *bat, struct ssam_device *sdev,
724 mutex_init(&bat->lock);
725 strscpy(bat->name, name, sizeof(bat->name));
727 bat->sdev = sdev;
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;
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;
741 INIT_DELAYED_WORK(&bat->update_work, spwr_battery_update_bst_workfn);
744 static int spwr_battery_register(struct spwr_battery_device *bat)
751 status = ssam_retry(ssam_bat_get_sta, bat->sdev, &sta);
759 mutex_lock(&bat->lock);
761 status = spwr_battery_update_bix_unlocked(bat);
763 mutex_unlock(&bat->lock);
767 if (spwr_battery_present(bat)) {
768 u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
770 status = spwr_battery_set_alarm_unlocked(bat, cap_warn);
772 mutex_unlock(&bat->lock);
777 mutex_unlock(&bat->lock);
779 bat->psy_desc.external_power_changed = spwr_external_power_changed;
781 switch (get_unaligned_le32(&bat->bix.power_unit)) {
783 bat->psy_desc.properties = spwr_battery_props_eng;
784 bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_eng);
788 bat->psy_desc.properties = spwr_battery_props_chg;
789 bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_chg);
793 dev_err(&bat->sdev->dev, "unsupported battery power unit: %u\n",
794 get_unaligned_le32(&bat->bix.power_unit));
798 psy_cfg.drv_data = bat;
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);
805 return ssam_device_notifier_register(bat->sdev, &bat->notif);
820 struct spwr_battery_device *bat;
826 bat = devm_kzalloc(&sdev->dev, sizeof(*bat), GFP_KERNEL);
827 if (!bat)
830 spwr_battery_init(bat, sdev, p->registry, p->name);
831 ssam_device_set_drvdata(sdev, bat);
833 return spwr_battery_register(bat);
838 struct spwr_battery_device *bat = ssam_device_get_drvdata(sdev);
840 ssam_device_notifier_unregister(sdev, &bat->notif);
841 cancel_delayed_work_sync(&bat->update_work);