1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Supports for the power IC on the Surface 3 tablet. 4 * 5 * (C) Copyright 2016-2018 Red Hat, Inc 6 * (C) Copyright 2016-2018 Benjamin Tissoires <benjamin.tissoires@gmail.com> 7 * (C) Copyright 2016 Stephen Just <stephenjust@gmail.com> 8 * 9 * This driver has been reverse-engineered by parsing the DSDT of the Surface 3 10 * and looking at the registers of the chips. 11 * 12 * The DSDT allowed to find out that: 13 * - the driver is required for the ACPI BAT0 device to communicate to the chip 14 * through an operation region. 15 * - the various defines for the operation region functions to communicate with 16 * this driver 17 * - the DSM 3f99e367-6220-4955-8b0f-06ef2ae79412 allows to trigger ACPI 18 * events to BAT0 (the code is all available in the DSDT). 19 * 20 * Further findings regarding the 2 chips declared in the MSHW0011 are: 21 * - there are 2 chips declared: 22 * . 0x22 seems to control the ADP1 line status (and probably the charger) 23 * . 0x55 controls the battery directly 24 * - the battery chip uses a SMBus protocol (using plain SMBus allows non 25 * destructive commands): 26 * . the commands/registers used are in the range 0x00..0x7F 27 * . if bit 8 (0x80) is set in the SMBus command, the returned value is the 28 * same as when it is not set. There is a high chance this bit is the 29 * read/write 30 * . the various registers semantic as been deduced by observing the register 31 * dumps. 32 */ 33 34#include <linux/acpi.h> 35#include <linux/bits.h> 36#include <linux/freezer.h> 37#include <linux/i2c.h> 38#include <linux/kernel.h> 39#include <linux/kthread.h> 40#include <linux/slab.h> 41#include <linux/types.h> 42#include <linux/uuid.h> 43#include <asm/unaligned.h> 44 45#define SURFACE_3_POLL_INTERVAL (2 * HZ) 46#define SURFACE_3_STRLEN 10 47 48struct mshw0011_data { 49 struct i2c_client *adp1; 50 struct i2c_client *bat0; 51 unsigned short notify_mask; 52 struct task_struct *poll_task; 53 bool kthread_running; 54 55 bool charging; 56 bool bat_charging; 57 u8 trip_point; 58 s32 full_capacity; 59}; 60 61struct mshw0011_handler_data { 62 struct acpi_connection_info info; 63 struct i2c_client *client; 64}; 65 66struct bix { 67 u32 revision; 68 u32 power_unit; 69 u32 design_capacity; 70 u32 last_full_charg_capacity; 71 u32 battery_technology; 72 u32 design_voltage; 73 u32 design_capacity_of_warning; 74 u32 design_capacity_of_low; 75 u32 cycle_count; 76 u32 measurement_accuracy; 77 u32 max_sampling_time; 78 u32 min_sampling_time; 79 u32 max_average_interval; 80 u32 min_average_interval; 81 u32 battery_capacity_granularity_1; 82 u32 battery_capacity_granularity_2; 83 char model[SURFACE_3_STRLEN]; 84 char serial[SURFACE_3_STRLEN]; 85 char type[SURFACE_3_STRLEN]; 86 char OEM[SURFACE_3_STRLEN]; 87} __packed; 88 89struct bst { 90 u32 battery_state; 91 s32 battery_present_rate; 92 u32 battery_remaining_capacity; 93 u32 battery_present_voltage; 94} __packed; 95 96struct gsb_command { 97 u8 arg0; 98 u8 arg1; 99 u8 arg2; 100} __packed; 101 102struct gsb_buffer { 103 u8 status; 104 u8 len; 105 u8 ret; 106 union { 107 struct gsb_command cmd; 108 struct bst bst; 109 struct bix bix; 110 } __packed; 111} __packed; 112 113#define ACPI_BATTERY_STATE_DISCHARGING BIT(0) 114#define ACPI_BATTERY_STATE_CHARGING BIT(1) 115#define ACPI_BATTERY_STATE_CRITICAL BIT(2) 116 117#define MSHW0011_CMD_DEST_BAT0 0x01 118#define MSHW0011_CMD_DEST_ADP1 0x03 119 120#define MSHW0011_CMD_BAT0_STA 0x01 121#define MSHW0011_CMD_BAT0_BIX 0x02 122#define MSHW0011_CMD_BAT0_BCT 0x03 123#define MSHW0011_CMD_BAT0_BTM 0x04 124#define MSHW0011_CMD_BAT0_BST 0x05 125#define MSHW0011_CMD_BAT0_BTP 0x06 126#define MSHW0011_CMD_ADP1_PSR 0x07 127#define MSHW0011_CMD_BAT0_PSOC 0x09 128#define MSHW0011_CMD_BAT0_PMAX 0x0a 129#define MSHW0011_CMD_BAT0_PSRC 0x0b 130#define MSHW0011_CMD_BAT0_CHGI 0x0c 131#define MSHW0011_CMD_BAT0_ARTG 0x0d 132 133#define MSHW0011_NOTIFY_GET_VERSION 0x00 134#define MSHW0011_NOTIFY_ADP1 0x01 135#define MSHW0011_NOTIFY_BAT0_BST 0x02 136#define MSHW0011_NOTIFY_BAT0_BIX 0x05 137 138#define MSHW0011_ADP1_REG_PSR 0x04 139 140#define MSHW0011_BAT0_REG_CAPACITY 0x0c 141#define MSHW0011_BAT0_REG_FULL_CHG_CAPACITY 0x0e 142#define MSHW0011_BAT0_REG_DESIGN_CAPACITY 0x40 143#define MSHW0011_BAT0_REG_VOLTAGE 0x08 144#define MSHW0011_BAT0_REG_RATE 0x14 145#define MSHW0011_BAT0_REG_OEM 0x45 146#define MSHW0011_BAT0_REG_TYPE 0x4e 147#define MSHW0011_BAT0_REG_SERIAL_NO 0x56 148#define MSHW0011_BAT0_REG_CYCLE_CNT 0x6e 149 150#define MSHW0011_EV_2_5_MASK GENMASK(8, 0) 151 152/* 3f99e367-6220-4955-8b0f-06ef2ae79412 */ 153static const guid_t mshw0011_guid = 154 GUID_INIT(0x3F99E367, 0x6220, 0x4955, 0x8B, 0x0F, 0x06, 0xEF, 155 0x2A, 0xE7, 0x94, 0x12); 156 157static int 158mshw0011_notify(struct mshw0011_data *cdata, u8 arg1, u8 arg2, 159 unsigned int *ret_value) 160{ 161 union acpi_object *obj; 162 struct acpi_device *adev; 163 acpi_handle handle; 164 unsigned int i; 165 166 handle = ACPI_HANDLE(&cdata->adp1->dev); 167 if (!handle || acpi_bus_get_device(handle, &adev)) 168 return -ENODEV; 169 170 obj = acpi_evaluate_dsm_typed(handle, &mshw0011_guid, arg1, arg2, NULL, 171 ACPI_TYPE_BUFFER); 172 if (!obj) { 173 dev_err(&cdata->adp1->dev, "device _DSM execution failed\n"); 174 return -ENODEV; 175 } 176 177 *ret_value = 0; 178 for (i = 0; i < obj->buffer.length; i++) 179 *ret_value |= obj->buffer.pointer[i] << (i * 8); 180 181 ACPI_FREE(obj); 182 return 0; 183} 184 185static const struct bix default_bix = { 186 .revision = 0x00, 187 .power_unit = 0x01, 188 .design_capacity = 0x1dca, 189 .last_full_charg_capacity = 0x1dca, 190 .battery_technology = 0x01, 191 .design_voltage = 0x10df, 192 .design_capacity_of_warning = 0x8f, 193 .design_capacity_of_low = 0x47, 194 .cycle_count = 0xffffffff, 195 .measurement_accuracy = 0x00015f90, 196 .max_sampling_time = 0x03e8, 197 .min_sampling_time = 0x03e8, 198 .max_average_interval = 0x03e8, 199 .min_average_interval = 0x03e8, 200 .battery_capacity_granularity_1 = 0x45, 201 .battery_capacity_granularity_2 = 0x11, 202 .model = "P11G8M", 203 .serial = "", 204 .type = "LION", 205 .OEM = "", 206}; 207 208static int mshw0011_bix(struct mshw0011_data *cdata, struct bix *bix) 209{ 210 struct i2c_client *client = cdata->bat0; 211 char buf[SURFACE_3_STRLEN]; 212 int ret; 213 214 *bix = default_bix; 215 216 /* get design capacity */ 217 ret = i2c_smbus_read_word_data(client, 218 MSHW0011_BAT0_REG_DESIGN_CAPACITY); 219 if (ret < 0) { 220 dev_err(&client->dev, "Error reading design capacity: %d\n", 221 ret); 222 return ret; 223 } 224 bix->design_capacity = ret; 225 226 /* get last full charge capacity */ 227 ret = i2c_smbus_read_word_data(client, 228 MSHW0011_BAT0_REG_FULL_CHG_CAPACITY); 229 if (ret < 0) { 230 dev_err(&client->dev, 231 "Error reading last full charge capacity: %d\n", ret); 232 return ret; 233 } 234 bix->last_full_charg_capacity = ret; 235 236 /* 237 * Get serial number, on some devices (with unofficial replacement 238 * battery?) reading any of the serial number range addresses gets 239 * nacked in this case just leave the serial number empty. 240 */ 241 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO, 242 sizeof(buf), buf); 243 if (ret == -EREMOTEIO) { 244 /* no serial number available */ 245 } else if (ret != sizeof(buf)) { 246 dev_err(&client->dev, "Error reading serial no: %d\n", ret); 247 return ret; 248 } else { 249 snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf); 250 } 251 252 /* get cycle count */ 253 ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT); 254 if (ret < 0) { 255 dev_err(&client->dev, "Error reading cycle count: %d\n", ret); 256 return ret; 257 } 258 bix->cycle_count = ret; 259 260 /* get OEM name */ 261 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_OEM, 262 4, buf); 263 if (ret != 4) { 264 dev_err(&client->dev, "Error reading cycle count: %d\n", ret); 265 return ret; 266 } 267 snprintf(bix->OEM, ARRAY_SIZE(bix->OEM), "%3pE", buf); 268 269 return 0; 270} 271 272static int mshw0011_bst(struct mshw0011_data *cdata, struct bst *bst) 273{ 274 struct i2c_client *client = cdata->bat0; 275 int rate, capacity, voltage, state; 276 s16 tmp; 277 278 rate = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_RATE); 279 if (rate < 0) 280 return rate; 281 282 capacity = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CAPACITY); 283 if (capacity < 0) 284 return capacity; 285 286 voltage = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_VOLTAGE); 287 if (voltage < 0) 288 return voltage; 289 290 tmp = rate; 291 bst->battery_present_rate = abs((s32)tmp); 292 293 state = 0; 294 if ((s32) tmp > 0) 295 state |= ACPI_BATTERY_STATE_CHARGING; 296 else if ((s32) tmp < 0) 297 state |= ACPI_BATTERY_STATE_DISCHARGING; 298 bst->battery_state = state; 299 300 bst->battery_remaining_capacity = capacity; 301 bst->battery_present_voltage = voltage; 302 303 return 0; 304} 305 306static int mshw0011_adp_psr(struct mshw0011_data *cdata) 307{ 308 return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR); 309} 310 311static int mshw0011_isr(struct mshw0011_data *cdata) 312{ 313 struct bst bst; 314 struct bix bix; 315 int ret; 316 bool status, bat_status; 317 318 ret = mshw0011_adp_psr(cdata); 319 if (ret < 0) 320 return ret; 321 322 status = ret; 323 if (status != cdata->charging) 324 mshw0011_notify(cdata, cdata->notify_mask, 325 MSHW0011_NOTIFY_ADP1, &ret); 326 327 cdata->charging = status; 328 329 ret = mshw0011_bst(cdata, &bst); 330 if (ret < 0) 331 return ret; 332 333 bat_status = bst.battery_state; 334 if (bat_status != cdata->bat_charging) 335 mshw0011_notify(cdata, cdata->notify_mask, 336 MSHW0011_NOTIFY_BAT0_BST, &ret); 337 338 cdata->bat_charging = bat_status; 339 340 ret = mshw0011_bix(cdata, &bix); 341 if (ret < 0) 342 return ret; 343 344 if (bix.last_full_charg_capacity != cdata->full_capacity) 345 mshw0011_notify(cdata, cdata->notify_mask, 346 MSHW0011_NOTIFY_BAT0_BIX, &ret); 347 348 cdata->full_capacity = bix.last_full_charg_capacity; 349 350 return 0; 351} 352 353static int mshw0011_poll_task(void *data) 354{ 355 struct mshw0011_data *cdata = data; 356 int ret = 0; 357 358 cdata->kthread_running = true; 359 360 set_freezable(); 361 362 while (!kthread_should_stop()) { 363 schedule_timeout_interruptible(SURFACE_3_POLL_INTERVAL); 364 try_to_freeze(); 365 ret = mshw0011_isr(data); 366 if (ret) 367 break; 368 } 369 370 cdata->kthread_running = false; 371 return ret; 372} 373 374static acpi_status 375mshw0011_space_handler(u32 function, acpi_physical_address command, 376 u32 bits, u64 *value64, 377 void *handler_context, void *region_context) 378{ 379 struct gsb_buffer *gsb = (struct gsb_buffer *)value64; 380 struct mshw0011_handler_data *data = handler_context; 381 struct acpi_connection_info *info = &data->info; 382 struct acpi_resource_i2c_serialbus *sb; 383 struct i2c_client *client = data->client; 384 struct mshw0011_data *cdata = i2c_get_clientdata(client); 385 struct acpi_resource *ares; 386 u32 accessor_type = function >> 16; 387 acpi_status ret; 388 int status = 1; 389 390 ret = acpi_buffer_to_resource(info->connection, info->length, &ares); 391 if (ACPI_FAILURE(ret)) 392 return ret; 393 394 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) { 395 ret = AE_BAD_PARAMETER; 396 goto err; 397 } 398 399 sb = &ares->data.i2c_serial_bus; 400 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { 401 ret = AE_BAD_PARAMETER; 402 goto err; 403 } 404 405 if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) { 406 ret = AE_BAD_PARAMETER; 407 goto err; 408 } 409 410 if (gsb->cmd.arg0 == MSHW0011_CMD_DEST_ADP1 && 411 gsb->cmd.arg1 == MSHW0011_CMD_ADP1_PSR) { 412 status = mshw0011_adp_psr(cdata); 413 if (status >= 0) { 414 ret = AE_OK; 415 goto out; 416 } else { 417 ret = AE_ERROR; 418 goto err; 419 } 420 } 421 422 if (gsb->cmd.arg0 != MSHW0011_CMD_DEST_BAT0) { 423 ret = AE_BAD_PARAMETER; 424 goto err; 425 } 426 427 switch (gsb->cmd.arg1) { 428 case MSHW0011_CMD_BAT0_STA: 429 break; 430 case MSHW0011_CMD_BAT0_BIX: 431 ret = mshw0011_bix(cdata, &gsb->bix); 432 break; 433 case MSHW0011_CMD_BAT0_BTP: 434 cdata->trip_point = gsb->cmd.arg2; 435 break; 436 case MSHW0011_CMD_BAT0_BST: 437 ret = mshw0011_bst(cdata, &gsb->bst); 438 break; 439 default: 440 dev_info(&cdata->bat0->dev, "command(0x%02x) is not supported.\n", gsb->cmd.arg1); 441 ret = AE_BAD_PARAMETER; 442 goto err; 443 } 444 445 out: 446 gsb->ret = status; 447 gsb->status = 0; 448 449 err: 450 ACPI_FREE(ares); 451 return ret; 452} 453 454static int mshw0011_install_space_handler(struct i2c_client *client) 455{ 456 acpi_handle handle; 457 struct mshw0011_handler_data *data; 458 acpi_status status; 459 460 handle = ACPI_HANDLE(&client->dev); 461 if (!handle) 462 return -ENODEV; 463 464 data = kzalloc(sizeof(struct mshw0011_handler_data), 465 GFP_KERNEL); 466 if (!data) 467 return -ENOMEM; 468 469 data->client = client; 470 status = acpi_bus_attach_private_data(handle, (void *)data); 471 if (ACPI_FAILURE(status)) { 472 kfree(data); 473 return -ENOMEM; 474 } 475 476 status = acpi_install_address_space_handler(handle, 477 ACPI_ADR_SPACE_GSBUS, 478 &mshw0011_space_handler, 479 NULL, 480 data); 481 if (ACPI_FAILURE(status)) { 482 dev_err(&client->dev, "Error installing i2c space handler\n"); 483 acpi_bus_detach_private_data(handle); 484 kfree(data); 485 return -ENOMEM; 486 } 487 488 acpi_walk_dep_device_list(handle); 489 return 0; 490} 491 492static void mshw0011_remove_space_handler(struct i2c_client *client) 493{ 494 struct mshw0011_handler_data *data; 495 acpi_handle handle; 496 acpi_status status; 497 498 handle = ACPI_HANDLE(&client->dev); 499 if (!handle) 500 return; 501 502 acpi_remove_address_space_handler(handle, 503 ACPI_ADR_SPACE_GSBUS, 504 &mshw0011_space_handler); 505 506 status = acpi_bus_get_private_data(handle, (void **)&data); 507 if (ACPI_SUCCESS(status)) 508 kfree(data); 509 510 acpi_bus_detach_private_data(handle); 511} 512 513static int mshw0011_probe(struct i2c_client *client) 514{ 515 struct i2c_board_info board_info; 516 struct device *dev = &client->dev; 517 struct i2c_client *bat0; 518 struct mshw0011_data *data; 519 int error, mask; 520 521 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 522 if (!data) 523 return -ENOMEM; 524 525 data->adp1 = client; 526 i2c_set_clientdata(client, data); 527 528 memset(&board_info, 0, sizeof(board_info)); 529 strlcpy(board_info.type, "MSHW0011-bat0", I2C_NAME_SIZE); 530 531 bat0 = i2c_acpi_new_device(dev, 1, &board_info); 532 if (IS_ERR(bat0)) 533 return PTR_ERR(bat0); 534 535 data->bat0 = bat0; 536 i2c_set_clientdata(bat0, data); 537 538 error = mshw0011_notify(data, 1, MSHW0011_NOTIFY_GET_VERSION, &mask); 539 if (error) 540 goto out_err; 541 542 data->notify_mask = mask == MSHW0011_EV_2_5_MASK; 543 544 data->poll_task = kthread_run(mshw0011_poll_task, data, "mshw0011_adp"); 545 if (IS_ERR(data->poll_task)) { 546 error = PTR_ERR(data->poll_task); 547 dev_err(&client->dev, "Unable to run kthread err %d\n", error); 548 goto out_err; 549 } 550 551 error = mshw0011_install_space_handler(client); 552 if (error) 553 goto out_err; 554 555 return 0; 556 557out_err: 558 if (data->kthread_running) 559 kthread_stop(data->poll_task); 560 i2c_unregister_device(data->bat0); 561 return error; 562} 563 564static int mshw0011_remove(struct i2c_client *client) 565{ 566 struct mshw0011_data *cdata = i2c_get_clientdata(client); 567 568 mshw0011_remove_space_handler(client); 569 570 if (cdata->kthread_running) 571 kthread_stop(cdata->poll_task); 572 573 i2c_unregister_device(cdata->bat0); 574 575 return 0; 576} 577 578static const struct acpi_device_id mshw0011_acpi_match[] = { 579 { "MSHW0011", 0 }, 580 { } 581}; 582MODULE_DEVICE_TABLE(acpi, mshw0011_acpi_match); 583 584static struct i2c_driver mshw0011_driver = { 585 .probe_new = mshw0011_probe, 586 .remove = mshw0011_remove, 587 .driver = { 588 .name = "mshw0011", 589 .acpi_match_table = mshw0011_acpi_match, 590 }, 591}; 592module_i2c_driver(mshw0011_driver); 593 594MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 595MODULE_DESCRIPTION("mshw0011 driver"); 596MODULE_LICENSE("GPL v2"); 597