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
48 struct 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
61 struct mshw0011_handler_data {
62 struct acpi_connection_info info;
63 struct i2c_client *client;
64 };
65
66 struct 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
89 struct bst {
90 u32 battery_state;
91 s32 battery_present_rate;
92 u32 battery_remaining_capacity;
93 u32 battery_present_voltage;
94 } __packed;
95
96 struct gsb_command {
97 u8 arg0;
98 u8 arg1;
99 u8 arg2;
100 } __packed;
101
102 struct 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 */
153 static const guid_t mshw0011_guid =
154 GUID_INIT(0x3F99E367, 0x6220, 0x4955, 0x8B, 0x0F, 0x06, 0xEF,
155 0x2A, 0xE7, 0x94, 0x12);
156
157 static int
mshw0011_notify(struct mshw0011_data * cdata,u8 arg1,u8 arg2,unsigned int * ret_value)158 mshw0011_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
185 static 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
mshw0011_bix(struct mshw0011_data * cdata,struct bix * bix)208 static 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
mshw0011_bst(struct mshw0011_data * cdata,struct bst * bst)272 static 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
mshw0011_adp_psr(struct mshw0011_data * cdata)306 static int mshw0011_adp_psr(struct mshw0011_data *cdata)
307 {
308 return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR);
309 }
310
mshw0011_isr(struct mshw0011_data * cdata)311 static 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
mshw0011_poll_task(void * data)353 static 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
374 static acpi_status
mshw0011_space_handler(u32 function,acpi_physical_address command,u32 bits,u64 * value64,void * handler_context,void * region_context)375 mshw0011_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
mshw0011_install_space_handler(struct i2c_client * client)454 static 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
mshw0011_remove_space_handler(struct i2c_client * client)492 static 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
mshw0011_probe(struct i2c_client * client)513 static 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
557 out_err:
558 if (data->kthread_running)
559 kthread_stop(data->poll_task);
560 i2c_unregister_device(data->bat0);
561 return error;
562 }
563
mshw0011_remove(struct i2c_client * client)564 static 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
578 static const struct acpi_device_id mshw0011_acpi_match[] = {
579 { "MSHW0011", 0 },
580 { }
581 };
582 MODULE_DEVICE_TABLE(acpi, mshw0011_acpi_match);
583
584 static 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 };
592 module_i2c_driver(mshw0011_driver);
593
594 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
595 MODULE_DESCRIPTION("mshw0011 driver");
596 MODULE_LICENSE("GPL v2");
597