Loading...
Note: File does not exist in v3.1.
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 /* get serial number */
237 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO,
238 sizeof(buf), buf);
239 if (ret != sizeof(buf)) {
240 dev_err(&client->dev, "Error reading serial no: %d\n", ret);
241 return ret;
242 }
243 snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf);
244
245 /* get cycle count */
246 ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT);
247 if (ret < 0) {
248 dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
249 return ret;
250 }
251 bix->cycle_count = ret;
252
253 /* get OEM name */
254 ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_OEM,
255 4, buf);
256 if (ret != 4) {
257 dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
258 return ret;
259 }
260 snprintf(bix->OEM, ARRAY_SIZE(bix->OEM), "%3pE", buf);
261
262 return 0;
263}
264
265static int mshw0011_bst(struct mshw0011_data *cdata, struct bst *bst)
266{
267 struct i2c_client *client = cdata->bat0;
268 int rate, capacity, voltage, state;
269 s16 tmp;
270
271 rate = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_RATE);
272 if (rate < 0)
273 return rate;
274
275 capacity = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CAPACITY);
276 if (capacity < 0)
277 return capacity;
278
279 voltage = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_VOLTAGE);
280 if (voltage < 0)
281 return voltage;
282
283 tmp = rate;
284 bst->battery_present_rate = abs((s32)tmp);
285
286 state = 0;
287 if ((s32) tmp > 0)
288 state |= ACPI_BATTERY_STATE_CHARGING;
289 else if ((s32) tmp < 0)
290 state |= ACPI_BATTERY_STATE_DISCHARGING;
291 bst->battery_state = state;
292
293 bst->battery_remaining_capacity = capacity;
294 bst->battery_present_voltage = voltage;
295
296 return 0;
297}
298
299static int mshw0011_adp_psr(struct mshw0011_data *cdata)
300{
301 return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR);
302}
303
304static int mshw0011_isr(struct mshw0011_data *cdata)
305{
306 struct bst bst;
307 struct bix bix;
308 int ret;
309 bool status, bat_status;
310
311 ret = mshw0011_adp_psr(cdata);
312 if (ret < 0)
313 return ret;
314
315 status = ret;
316 if (status != cdata->charging)
317 mshw0011_notify(cdata, cdata->notify_mask,
318 MSHW0011_NOTIFY_ADP1, &ret);
319
320 cdata->charging = status;
321
322 ret = mshw0011_bst(cdata, &bst);
323 if (ret < 0)
324 return ret;
325
326 bat_status = bst.battery_state;
327 if (bat_status != cdata->bat_charging)
328 mshw0011_notify(cdata, cdata->notify_mask,
329 MSHW0011_NOTIFY_BAT0_BST, &ret);
330
331 cdata->bat_charging = bat_status;
332
333 ret = mshw0011_bix(cdata, &bix);
334 if (ret < 0)
335 return ret;
336
337 if (bix.last_full_charg_capacity != cdata->full_capacity)
338 mshw0011_notify(cdata, cdata->notify_mask,
339 MSHW0011_NOTIFY_BAT0_BIX, &ret);
340
341 cdata->full_capacity = bix.last_full_charg_capacity;
342
343 return 0;
344}
345
346static int mshw0011_poll_task(void *data)
347{
348 struct mshw0011_data *cdata = data;
349 int ret = 0;
350
351 cdata->kthread_running = true;
352
353 set_freezable();
354
355 while (!kthread_should_stop()) {
356 schedule_timeout_interruptible(SURFACE_3_POLL_INTERVAL);
357 try_to_freeze();
358 ret = mshw0011_isr(data);
359 if (ret)
360 break;
361 }
362
363 cdata->kthread_running = false;
364 return ret;
365}
366
367static acpi_status
368mshw0011_space_handler(u32 function, acpi_physical_address command,
369 u32 bits, u64 *value64,
370 void *handler_context, void *region_context)
371{
372 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
373 struct mshw0011_handler_data *data = handler_context;
374 struct acpi_connection_info *info = &data->info;
375 struct acpi_resource_i2c_serialbus *sb;
376 struct i2c_client *client = data->client;
377 struct mshw0011_data *cdata = i2c_get_clientdata(client);
378 struct acpi_resource *ares;
379 u32 accessor_type = function >> 16;
380 acpi_status ret;
381 int status = 1;
382
383 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
384 if (ACPI_FAILURE(ret))
385 return ret;
386
387 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
388 ret = AE_BAD_PARAMETER;
389 goto err;
390 }
391
392 sb = &ares->data.i2c_serial_bus;
393 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
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(sizeof(struct mshw0011_handler_data),
458 GFP_KERNEL);
459 if (!data)
460 return -ENOMEM;
461
462 data->client = client;
463 status = acpi_bus_attach_private_data(adev->handle, (void *)data);
464 if (ACPI_FAILURE(status)) {
465 kfree(data);
466 return -ENOMEM;
467 }
468
469 status = acpi_install_address_space_handler(adev->handle,
470 ACPI_ADR_SPACE_GSBUS,
471 &mshw0011_space_handler,
472 NULL,
473 data);
474 if (ACPI_FAILURE(status)) {
475 dev_err(&client->dev, "Error installing i2c space handler\n");
476 acpi_bus_detach_private_data(adev->handle);
477 kfree(data);
478 return -ENOMEM;
479 }
480
481 acpi_dev_clear_dependencies(adev);
482 return 0;
483}
484
485static void mshw0011_remove_space_handler(struct i2c_client *client)
486{
487 struct mshw0011_handler_data *data;
488 acpi_handle handle;
489 acpi_status status;
490
491 handle = ACPI_HANDLE(&client->dev);
492 if (!handle)
493 return;
494
495 acpi_remove_address_space_handler(handle,
496 ACPI_ADR_SPACE_GSBUS,
497 &mshw0011_space_handler);
498
499 status = acpi_bus_get_private_data(handle, (void **)&data);
500 if (ACPI_SUCCESS(status))
501 kfree(data);
502
503 acpi_bus_detach_private_data(handle);
504}
505
506static int mshw0011_probe(struct i2c_client *client)
507{
508 struct i2c_board_info board_info;
509 struct device *dev = &client->dev;
510 struct i2c_client *bat0;
511 struct mshw0011_data *data;
512 int error, mask;
513
514 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
515 if (!data)
516 return -ENOMEM;
517
518 data->adp1 = client;
519 i2c_set_clientdata(client, data);
520
521 memset(&board_info, 0, sizeof(board_info));
522 strlcpy(board_info.type, "MSHW0011-bat0", I2C_NAME_SIZE);
523
524 bat0 = i2c_acpi_new_device(dev, 1, &board_info);
525 if (IS_ERR(bat0))
526 return PTR_ERR(bat0);
527
528 data->bat0 = bat0;
529 i2c_set_clientdata(bat0, data);
530
531 error = mshw0011_notify(data, 1, MSHW0011_NOTIFY_GET_VERSION, &mask);
532 if (error)
533 goto out_err;
534
535 data->notify_mask = mask == MSHW0011_EV_2_5_MASK;
536
537 data->poll_task = kthread_run(mshw0011_poll_task, data, "mshw0011_adp");
538 if (IS_ERR(data->poll_task)) {
539 error = PTR_ERR(data->poll_task);
540 dev_err(&client->dev, "Unable to run kthread err %d\n", error);
541 goto out_err;
542 }
543
544 error = mshw0011_install_space_handler(client);
545 if (error)
546 goto out_err;
547
548 return 0;
549
550out_err:
551 if (data->kthread_running)
552 kthread_stop(data->poll_task);
553 i2c_unregister_device(data->bat0);
554 return error;
555}
556
557static int mshw0011_remove(struct i2c_client *client)
558{
559 struct mshw0011_data *cdata = i2c_get_clientdata(client);
560
561 mshw0011_remove_space_handler(client);
562
563 if (cdata->kthread_running)
564 kthread_stop(cdata->poll_task);
565
566 i2c_unregister_device(cdata->bat0);
567
568 return 0;
569}
570
571static const struct acpi_device_id mshw0011_acpi_match[] = {
572 { "MSHW0011", 0 },
573 { }
574};
575MODULE_DEVICE_TABLE(acpi, mshw0011_acpi_match);
576
577static struct i2c_driver mshw0011_driver = {
578 .probe_new = mshw0011_probe,
579 .remove = mshw0011_remove,
580 .driver = {
581 .name = "mshw0011",
582 .acpi_match_table = mshw0011_acpi_match,
583 },
584};
585module_i2c_driver(mshw0011_driver);
586
587MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
588MODULE_DESCRIPTION("mshw0011 driver");
589MODULE_LICENSE("GPL v2");