1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * AC driver for 7th-generation Microsoft Surface devices via Surface System 4 * Aggregator Module (SSAM). 5 * 6 * Copyright (C) 2019-2021 Maximilian Luz <luzmaximilian@gmail.com> 7 */ 8 9 #include <asm/unaligned.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/power_supply.h> 14 #include <linux/types.h> 15 16 #include <linux/surface_aggregator/device.h> 17 18 19 /* -- SAM interface. -------------------------------------------------------- */ 20 21 enum sam_event_cid_bat { 22 SAM_EVENT_CID_BAT_ADP = 0x17, 23 }; 24 25 enum sam_battery_sta { 26 SAM_BATTERY_STA_OK = 0x0f, 27 SAM_BATTERY_STA_PRESENT = 0x10, 28 }; 29 30 /* Get battery status (_STA). */ 31 SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_sta, __le32, { 32 .target_category = SSAM_SSH_TC_BAT, 33 .command_id = 0x01, 34 }); 35 36 /* Get platform power source for battery (_PSR / DPTF PSRC). */ 37 SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_psrc, __le32, { 38 .target_category = SSAM_SSH_TC_BAT, 39 .command_id = 0x0d, 40 }); 41 42 43 /* -- Device structures. ---------------------------------------------------- */ 44 45 struct spwr_psy_properties { 46 const char *name; 47 struct ssam_event_registry registry; 48 }; 49 50 struct spwr_ac_device { 51 struct ssam_device *sdev; 52 53 char name[32]; 54 struct power_supply *psy; 55 struct power_supply_desc psy_desc; 56 57 struct ssam_event_notifier notif; 58 59 struct mutex lock; /* Guards access to state below. */ 60 61 __le32 state; 62 }; 63 64 65 /* -- State management. ----------------------------------------------------- */ 66 67 static int spwr_ac_update_unlocked(struct spwr_ac_device *ac) 68 { 69 __le32 old = ac->state; 70 int status; 71 72 lockdep_assert_held(&ac->lock); 73 74 status = ssam_retry(ssam_bat_get_psrc, ac->sdev, &ac->state); 75 if (status < 0) 76 return status; 77 78 return old != ac->state; 79 } 80 81 static int spwr_ac_update(struct spwr_ac_device *ac) 82 { 83 int status; 84 85 mutex_lock(&ac->lock); 86 status = spwr_ac_update_unlocked(ac); 87 mutex_unlock(&ac->lock); 88 89 return status; 90 } 91 92 static int spwr_ac_recheck(struct spwr_ac_device *ac) 93 { 94 int status; 95 96 status = spwr_ac_update(ac); 97 if (status > 0) 98 power_supply_changed(ac->psy); 99 100 return status >= 0 ? 0 : status; 101 } 102 103 static u32 spwr_notify_ac(struct ssam_event_notifier *nf, const struct ssam_event *event) 104 { 105 struct spwr_ac_device *ac; 106 int status; 107 108 ac = container_of(nf, struct spwr_ac_device, notif); 109 110 dev_dbg(&ac->sdev->dev, "power event (cid = %#04x, iid = %#04x, tid = %#04x)\n", 111 event->command_id, event->instance_id, event->target_id); 112 113 /* 114 * Allow events of all targets/instances here. Global adapter status 115 * seems to be handled via target=1 and instance=1, but events are 116 * reported on all targets/instances in use. 117 * 118 * While it should be enough to just listen on 1/1, listen everywhere to 119 * make sure we don't miss anything. 120 */ 121 122 switch (event->command_id) { 123 case SAM_EVENT_CID_BAT_ADP: 124 status = spwr_ac_recheck(ac); 125 return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED; 126 127 default: 128 return 0; 129 } 130 } 131 132 133 /* -- Properties. ----------------------------------------------------------- */ 134 135 static const enum power_supply_property spwr_ac_props[] = { 136 POWER_SUPPLY_PROP_ONLINE, 137 }; 138 139 static int spwr_ac_get_property(struct power_supply *psy, enum power_supply_property psp, 140 union power_supply_propval *val) 141 { 142 struct spwr_ac_device *ac = power_supply_get_drvdata(psy); 143 int status; 144 145 mutex_lock(&ac->lock); 146 147 status = spwr_ac_update_unlocked(ac); 148 if (status) 149 goto out; 150 151 switch (psp) { 152 case POWER_SUPPLY_PROP_ONLINE: 153 val->intval = !!le32_to_cpu(ac->state); 154 break; 155 156 default: 157 status = -EINVAL; 158 goto out; 159 } 160 161 out: 162 mutex_unlock(&ac->lock); 163 return status; 164 } 165 166 167 /* -- Device setup. --------------------------------------------------------- */ 168 169 static char *battery_supplied_to[] = { 170 "BAT1", 171 "BAT2", 172 }; 173 174 static void spwr_ac_init(struct spwr_ac_device *ac, struct ssam_device *sdev, 175 struct ssam_event_registry registry, const char *name) 176 { 177 mutex_init(&ac->lock); 178 strncpy(ac->name, name, ARRAY_SIZE(ac->name) - 1); 179 180 ac->sdev = sdev; 181 182 ac->notif.base.priority = 1; 183 ac->notif.base.fn = spwr_notify_ac; 184 ac->notif.event.reg = registry; 185 ac->notif.event.id.target_category = sdev->uid.category; 186 ac->notif.event.id.instance = 0; 187 ac->notif.event.mask = SSAM_EVENT_MASK_NONE; 188 ac->notif.event.flags = SSAM_EVENT_SEQUENCED; 189 190 ac->psy_desc.name = ac->name; 191 ac->psy_desc.type = POWER_SUPPLY_TYPE_MAINS; 192 ac->psy_desc.properties = spwr_ac_props; 193 ac->psy_desc.num_properties = ARRAY_SIZE(spwr_ac_props); 194 ac->psy_desc.get_property = spwr_ac_get_property; 195 } 196 197 static int spwr_ac_register(struct spwr_ac_device *ac) 198 { 199 struct power_supply_config psy_cfg = {}; 200 __le32 sta; 201 int status; 202 203 /* Make sure the device is there and functioning properly. */ 204 status = ssam_retry(ssam_bat_get_sta, ac->sdev, &sta); 205 if (status) 206 return status; 207 208 if ((le32_to_cpu(sta) & SAM_BATTERY_STA_OK) != SAM_BATTERY_STA_OK) 209 return -ENODEV; 210 211 psy_cfg.drv_data = ac; 212 psy_cfg.supplied_to = battery_supplied_to; 213 psy_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to); 214 215 ac->psy = devm_power_supply_register(&ac->sdev->dev, &ac->psy_desc, &psy_cfg); 216 if (IS_ERR(ac->psy)) 217 return PTR_ERR(ac->psy); 218 219 return ssam_notifier_register(ac->sdev->ctrl, &ac->notif); 220 } 221 222 223 /* -- Driver setup. --------------------------------------------------------- */ 224 225 static int __maybe_unused surface_ac_resume(struct device *dev) 226 { 227 return spwr_ac_recheck(dev_get_drvdata(dev)); 228 } 229 static SIMPLE_DEV_PM_OPS(surface_ac_pm_ops, NULL, surface_ac_resume); 230 231 static int surface_ac_probe(struct ssam_device *sdev) 232 { 233 const struct spwr_psy_properties *p; 234 struct spwr_ac_device *ac; 235 236 p = ssam_device_get_match_data(sdev); 237 if (!p) 238 return -ENODEV; 239 240 ac = devm_kzalloc(&sdev->dev, sizeof(*ac), GFP_KERNEL); 241 if (!ac) 242 return -ENOMEM; 243 244 spwr_ac_init(ac, sdev, p->registry, p->name); 245 ssam_device_set_drvdata(sdev, ac); 246 247 return spwr_ac_register(ac); 248 } 249 250 static void surface_ac_remove(struct ssam_device *sdev) 251 { 252 struct spwr_ac_device *ac = ssam_device_get_drvdata(sdev); 253 254 ssam_notifier_unregister(sdev->ctrl, &ac->notif); 255 } 256 257 static const struct spwr_psy_properties spwr_psy_props_adp1 = { 258 .name = "ADP1", 259 .registry = SSAM_EVENT_REGISTRY_SAM, 260 }; 261 262 static const struct ssam_device_id surface_ac_match[] = { 263 { SSAM_SDEV(BAT, 0x01, 0x01, 0x01), (unsigned long)&spwr_psy_props_adp1 }, 264 { }, 265 }; 266 MODULE_DEVICE_TABLE(ssam, surface_ac_match); 267 268 static struct ssam_device_driver surface_ac_driver = { 269 .probe = surface_ac_probe, 270 .remove = surface_ac_remove, 271 .match_table = surface_ac_match, 272 .driver = { 273 .name = "surface_ac", 274 .pm = &surface_ac_pm_ops, 275 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 276 }, 277 }; 278 module_ssam_device_driver(surface_ac_driver); 279 280 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>"); 281 MODULE_DESCRIPTION("AC driver for Surface System Aggregator Module"); 282 MODULE_LICENSE("GPL"); 283