projects/linux·blob master · refs

586 lines · 14.2 KiB

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 <[email protected]>
7 * (C) Copyright 2016 Stephen Just <[email protected]>
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 <linux/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 acpi_handle handle;
163 unsigned int i;
164
165 handle = ACPI_HANDLE(&cdata->adp1->dev);
166 if (!handle)
167 return -ENODEV;
168
169 obj = acpi_evaluate_dsm_typed(handle, &mshw0011_guid, arg1, arg2, NULL,
170 ACPI_TYPE_BUFFER);
171 if (!obj) {
172 dev_err(&cdata->adp1->dev, "device _DSM execution failed\n");
173 return -ENODEV;
174 }
175
176 *ret_value = 0;
177 for (i = 0; i < obj->buffer.length; i++)
178 *ret_value |= obj->buffer.pointer[i] << (i * 8);
179
180 ACPI_FREE(obj);
181 return 0;
182}
183
184static const struct bix default_bix = {
185 .revision = 0x00,
186 .power_unit = 0x01,
187 .design_capacity = 0x1dca,
188 .last_full_charg_capacity = 0x1dca,
189 .battery_technology = 0x01,
190 .design_voltage = 0x10df,
191 .design_capacity_of_warning = 0x8f,
192 .design_capacity_of_low = 0x47,
193 .cycle_count = 0xffffffff,
194 .measurement_accuracy = 0x00015f90,
195 .max_sampling_time = 0x03e8,
196 .min_sampling_time = 0x03e8,
197 .max_average_interval = 0x03e8,
198 .min_average_interval = 0x03e8,
199 .battery_capacity_granularity_1 = 0x45,
200 .battery_capacity_granularity_2 = 0x11,
201 .model = "P11G8M",
202 .serial = "",
203 .type = "LION",
204 .OEM = "",
205};
206
207static int mshw0011_bix(struct mshw0011_data *cdata, struct bix *bix)
208{
209 struct i2c_client *client = cdata->bat0;
210 char buf[SURFACE_3_STRLEN];
211 int ret;
212
213 *bix = default_bix;
214
215 /* get design capacity */
216 ret = i2c_smbus_read_word_data(client,
217 MSHW0011_BAT0_REG_DESIGN_CAPACITY);
218 if (ret < 0) {
219 dev_err(&client->dev, "Error reading design capacity: %d\n",
220 ret);
221 return ret;
222 }
223 bix->design_capacity = ret;
224
225 /* get last full charge capacity */
226 ret = i2c_smbus_read_word_data(client,
227 MSHW0011_BAT0_REG_FULL_CHG_CAPACITY);
228 if (ret < 0) {
229 dev_err(&client->dev,
230 "Error reading last full charge capacity: %d\n", ret);
231 return ret;
232 }
233 bix->last_full_charg_capacity = ret;
234
235 /*
236 * Get serial number, on some devices (with unofficial replacement
237 * battery?) reading any of the serial number range addresses gets
238 * nacked in this case just leave the serial number empty.
239 */
240 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO,
241 sizeof(buf), buf);
242 if (ret == -EREMOTEIO) {
243 /* no serial number available */
244 } else if (ret != sizeof(buf)) {
245 dev_err(&client->dev, "Error reading serial no: %d\n", ret);
246 return ret;
247 } else {
248 snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf);
249 }
250
251 /* get cycle count */
252 ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT);
253 if (ret < 0) {
254 dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
255 return ret;
256 }
257 bix->cycle_count = ret;
258
259 /* get OEM name */
260 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_OEM,
261 4, buf);
262 if (ret != 4) {
263 dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
264 return ret;
265 }
266 snprintf(bix->OEM, ARRAY_SIZE(bix->OEM), "%3pE", buf);
267
268 return 0;
269}
270
271static int mshw0011_bst(struct mshw0011_data *cdata, struct bst *bst)
272{
273 struct i2c_client *client = cdata->bat0;
274 int rate, capacity, voltage, state;
275 s16 tmp;
276
277 rate = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_RATE);
278 if (rate < 0)
279 return rate;
280
281 capacity = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CAPACITY);
282 if (capacity < 0)
283 return capacity;
284
285 voltage = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_VOLTAGE);
286 if (voltage < 0)
287 return voltage;
288
289 tmp = rate;
290 bst->battery_present_rate = abs((s32)tmp);
291
292 state = 0;
293 if ((s32) tmp > 0)
294 state |= ACPI_BATTERY_STATE_CHARGING;
295 else if ((s32) tmp < 0)
296 state |= ACPI_BATTERY_STATE_DISCHARGING;
297 bst->battery_state = state;
298
299 bst->battery_remaining_capacity = capacity;
300 bst->battery_present_voltage = voltage;
301
302 return 0;
303}
304
305static int mshw0011_adp_psr(struct mshw0011_data *cdata)
306{
307 return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR);
308}
309
310static int mshw0011_isr(struct mshw0011_data *cdata)
311{
312 struct bst bst;
313 struct bix bix;
314 int ret;
315 bool status, bat_status;
316
317 ret = mshw0011_adp_psr(cdata);
318 if (ret < 0)
319 return ret;
320
321 status = ret;
322 if (status != cdata->charging)
323 mshw0011_notify(cdata, cdata->notify_mask,
324 MSHW0011_NOTIFY_ADP1, &ret);
325
326 cdata->charging = status;
327
328 ret = mshw0011_bst(cdata, &bst);
329 if (ret < 0)
330 return ret;
331
332 bat_status = bst.battery_state;
333 if (bat_status != cdata->bat_charging)
334 mshw0011_notify(cdata, cdata->notify_mask,
335 MSHW0011_NOTIFY_BAT0_BST, &ret);
336
337 cdata->bat_charging = bat_status;
338
339 ret = mshw0011_bix(cdata, &bix);
340 if (ret < 0)
341 return ret;
342
343 if (bix.last_full_charg_capacity != cdata->full_capacity)
344 mshw0011_notify(cdata, cdata->notify_mask,
345 MSHW0011_NOTIFY_BAT0_BIX, &ret);
346
347 cdata->full_capacity = bix.last_full_charg_capacity;
348
349 return 0;
350}
351
352static int mshw0011_poll_task(void *data)
353{
354 struct mshw0011_data *cdata = data;
355 int ret = 0;
356
357 cdata->kthread_running = true;
358
359 set_freezable();
360
361 while (!kthread_should_stop()) {
362 schedule_timeout_interruptible(SURFACE_3_POLL_INTERVAL);
363 try_to_freeze();
364 ret = mshw0011_isr(data);
365 if (ret)
366 break;
367 }
368
369 cdata->kthread_running = false;
370 return ret;
371}
372
373static acpi_status
374mshw0011_space_handler(u32 function, acpi_physical_address command,
375 u32 bits, u64 *value64,
376 void *handler_context, void *region_context)
377{
378 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
379 struct mshw0011_handler_data *data = handler_context;
380 struct acpi_connection_info *info = &data->info;
381 struct acpi_resource_i2c_serialbus *sb;
382 struct i2c_client *client = data->client;
383 struct mshw0011_data *cdata = i2c_get_clientdata(client);
384 struct acpi_resource *ares;
385 u32 accessor_type = function >> 16;
386 acpi_status ret;
387 int status = 1;
388
389 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
390 if (ACPI_FAILURE(ret))
391 return ret;
392
393 if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) {
394 ret = AE_BAD_PARAMETER;
395 goto err;
396 }
397
398 if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) {
399 ret = AE_BAD_PARAMETER;
400 goto err;
401 }
402
403 if (gsb->cmd.arg0 == MSHW0011_CMD_DEST_ADP1 &&
404 gsb->cmd.arg1 == MSHW0011_CMD_ADP1_PSR) {
405 status = mshw0011_adp_psr(cdata);
406 if (status >= 0) {
407 ret = AE_OK;
408 goto out;
409 } else {
410 ret = AE_ERROR;
411 goto err;
412 }
413 }
414
415 if (gsb->cmd.arg0 != MSHW0011_CMD_DEST_BAT0) {
416 ret = AE_BAD_PARAMETER;
417 goto err;
418 }
419
420 switch (gsb->cmd.arg1) {
421 case MSHW0011_CMD_BAT0_STA:
422 break;
423 case MSHW0011_CMD_BAT0_BIX:
424 ret = mshw0011_bix(cdata, &gsb->bix);
425 break;
426 case MSHW0011_CMD_BAT0_BTP:
427 cdata->trip_point = gsb->cmd.arg2;
428 break;
429 case MSHW0011_CMD_BAT0_BST:
430 ret = mshw0011_bst(cdata, &gsb->bst);
431 break;
432 default:
433 dev_info(&cdata->bat0->dev, "command(0x%02x) is not supported.\n", gsb->cmd.arg1);
434 ret = AE_BAD_PARAMETER;
435 goto err;
436 }
437
438 out:
439 gsb->ret = status;
440 gsb->status = 0;
441
442 err:
443 ACPI_FREE(ares);
444 return ret;
445}
446
447static int mshw0011_install_space_handler(struct i2c_client *client)
448{
449 struct acpi_device *adev;
450 struct mshw0011_handler_data *data;
451 acpi_status status;
452
453 adev = ACPI_COMPANION(&client->dev);
454 if (!adev)
455 return -ENODEV;
456
457 data = kzalloc_obj(struct mshw0011_handler_data);
458 if (!data)
459 return -ENOMEM;
460
461 data->client = client;
462 status = acpi_bus_attach_private_data(adev->handle, (void *)data);
463 if (ACPI_FAILURE(status)) {
464 kfree(data);
465 return -ENOMEM;
466 }
467
468 status = acpi_install_address_space_handler(adev->handle,
469 ACPI_ADR_SPACE_GSBUS,
470 &mshw0011_space_handler,
471 NULL,
472 data);
473 if (ACPI_FAILURE(status)) {
474 dev_err(&client->dev, "Error installing i2c space handler\n");
475 acpi_bus_detach_private_data(adev->handle);
476 kfree(data);
477 return -ENOMEM;
478 }
479
480 acpi_dev_clear_dependencies(adev);
481 return 0;
482}
483
484static void mshw0011_remove_space_handler(struct i2c_client *client)
485{
486 struct mshw0011_handler_data *data;
487 acpi_handle handle;
488 acpi_status status;
489
490 handle = ACPI_HANDLE(&client->dev);
491 if (!handle)
492 return;
493
494 acpi_remove_address_space_handler(handle,
495 ACPI_ADR_SPACE_GSBUS,
496 &mshw0011_space_handler);
497
498 status = acpi_bus_get_private_data(handle, (void **)&data);
499 if (ACPI_SUCCESS(status))
500 kfree(data);
501
502 acpi_bus_detach_private_data(handle);
503}
504
505static int mshw0011_probe(struct i2c_client *client)
506{
507 struct i2c_board_info board_info;
508 struct device *dev = &client->dev;
509 struct i2c_client *bat0;
510 struct mshw0011_data *data;
511 int error, mask;
512
513 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
514 if (!data)
515 return -ENOMEM;
516
517 data->adp1 = client;
518 i2c_set_clientdata(client, data);
519
520 memset(&board_info, 0, sizeof(board_info));
521 strscpy(board_info.type, "MSHW0011-bat0", I2C_NAME_SIZE);
522
523 bat0 = i2c_acpi_new_device(dev, 1, &board_info);
524 if (IS_ERR(bat0))
525 return PTR_ERR(bat0);
526
527 data->bat0 = bat0;
528 i2c_set_clientdata(bat0, data);
529
530 error = mshw0011_notify(data, 1, MSHW0011_NOTIFY_GET_VERSION, &mask);
531 if (error)
532 goto out_err;
533
534 data->notify_mask = mask == MSHW0011_EV_2_5_MASK;
535
536 data->poll_task = kthread_run(mshw0011_poll_task, data, "mshw0011_adp");
537 if (IS_ERR(data->poll_task)) {
538 error = PTR_ERR(data->poll_task);
539 dev_err(&client->dev, "Unable to run kthread err %d\n", error);
540 goto out_err;
541 }
542
543 error = mshw0011_install_space_handler(client);
544 if (error)
545 goto out_err;
546
547 return 0;
548
549out_err:
550 if (data->kthread_running)
551 kthread_stop(data->poll_task);
552 i2c_unregister_device(data->bat0);
553 return error;
554}
555
556static void mshw0011_remove(struct i2c_client *client)
557{
558 struct mshw0011_data *cdata = i2c_get_clientdata(client);
559
560 mshw0011_remove_space_handler(client);
561
562 if (cdata->kthread_running)
563 kthread_stop(cdata->poll_task);
564
565 i2c_unregister_device(cdata->bat0);
566}
567
568static const struct acpi_device_id mshw0011_acpi_match[] = {
569 { "MSHW0011", 0 },
570 { }
571};
572MODULE_DEVICE_TABLE(acpi, mshw0011_acpi_match);
573
574static struct i2c_driver mshw0011_driver = {
575 .probe = mshw0011_probe,
576 .remove = mshw0011_remove,
577 .driver = {
578 .name = "mshw0011",
579 .acpi_match_table = mshw0011_acpi_match,
580 },
581};
582module_i2c_driver(mshw0011_driver);
583
584MODULE_AUTHOR("Benjamin Tissoires <[email protected]>");
585MODULE_DESCRIPTION("mshw0011 driver");
586MODULE_LICENSE("GPL v2");