1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * DMI based code to deal with broken DSDTs on X86 tablets which ship with
4 * Android as (part of) the factory image. The factory kernels shipped on these
5 * devices typically have a bunch of things hardcoded, rather than specified
6 * in their DSDT.
7 *
8 * Copyright (C) 2021 Hans de Goede <hdegoede@redhat.com>
9 */
10
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13 #include <linux/acpi.h>
14 #include <linux/dmi.h>
15 #include <linux/efi.h>
16 #include <linux/gpio_keys.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/gpio/driver.h>
19 #include <linux/gpio/machine.h>
20 #include <linux/i2c.h>
21 #include <linux/input.h>
22 #include <linux/irq.h>
23 #include <linux/irqdomain.h>
24 #include <linux/module.h>
25 #include <linux/mod_devicetable.h>
26 #include <linux/pinctrl/consumer.h>
27 #include <linux/pinctrl/machine.h>
28 #include <linux/platform_data/lp855x.h>
29 #include <linux/platform_device.h>
30 #include <linux/power/bq24190_charger.h>
31 #include <linux/reboot.h>
32 #include <linux/rmi.h>
33 #include <linux/serdev.h>
34 #include <linux/spi/spi.h>
35 #include <linux/string.h>
36 /* For gpio_get_desc() which is EXPORT_SYMBOL_GPL() */
37 #include "../../gpio/gpiolib.h"
38 #include "../../gpio/gpiolib-acpi.h"
39
40 /*
41 * Helper code to get Linux IRQ numbers given a description of the IRQ source
42 * (either IOAPIC index, or GPIO chip name + pin-number).
43 */
44 enum x86_acpi_irq_type {
45 X86_ACPI_IRQ_TYPE_NONE,
46 X86_ACPI_IRQ_TYPE_APIC,
47 X86_ACPI_IRQ_TYPE_GPIOINT,
48 X86_ACPI_IRQ_TYPE_PMIC,
49 };
50
51 struct x86_acpi_irq_data {
52 char *chip; /* GPIO chip label (GPIOINT) or PMIC ACPI path (PMIC) */
53 enum x86_acpi_irq_type type;
54 enum irq_domain_bus_token domain;
55 int index;
56 int trigger; /* ACPI_EDGE_SENSITIVE / ACPI_LEVEL_SENSITIVE */
57 int polarity; /* ACPI_ACTIVE_HIGH / ACPI_ACTIVE_LOW / ACPI_ACTIVE_BOTH */
58 };
59
gpiochip_find_match_label(struct gpio_chip * gc,void * data)60 static int gpiochip_find_match_label(struct gpio_chip *gc, void *data)
61 {
62 return gc->label && !strcmp(gc->label, data);
63 }
64
x86_android_tablet_get_gpiod(char * label,int pin,struct gpio_desc ** desc)65 static int x86_android_tablet_get_gpiod(char *label, int pin, struct gpio_desc **desc)
66 {
67 struct gpio_desc *gpiod;
68 struct gpio_chip *chip;
69
70 chip = gpiochip_find(label, gpiochip_find_match_label);
71 if (!chip) {
72 pr_err("error cannot find GPIO chip %s\n", label);
73 return -ENODEV;
74 }
75
76 gpiod = gpiochip_get_desc(chip, pin);
77 if (IS_ERR(gpiod)) {
78 pr_err("error %ld getting GPIO %s %d\n", PTR_ERR(gpiod), label, pin);
79 return PTR_ERR(gpiod);
80 }
81
82 *desc = gpiod;
83 return 0;
84 }
85
x86_acpi_irq_helper_get(const struct x86_acpi_irq_data * data)86 static int x86_acpi_irq_helper_get(const struct x86_acpi_irq_data *data)
87 {
88 struct irq_fwspec fwspec = { };
89 struct irq_domain *domain;
90 struct acpi_device *adev;
91 struct gpio_desc *gpiod;
92 unsigned int irq_type;
93 acpi_handle handle;
94 acpi_status status;
95 int irq, ret;
96
97 switch (data->type) {
98 case X86_ACPI_IRQ_TYPE_APIC:
99 /*
100 * The DSDT may already reference the GSI in a device skipped by
101 * acpi_quirk_skip_i2c_client_enumeration(). Unregister the GSI
102 * to avoid EBUSY errors in this case.
103 */
104 acpi_unregister_gsi(data->index);
105 irq = acpi_register_gsi(NULL, data->index, data->trigger, data->polarity);
106 if (irq < 0)
107 pr_err("error %d getting APIC IRQ %d\n", irq, data->index);
108
109 return irq;
110 case X86_ACPI_IRQ_TYPE_GPIOINT:
111 /* Like acpi_dev_gpio_irq_get(), but without parsing ACPI resources */
112 ret = x86_android_tablet_get_gpiod(data->chip, data->index, &gpiod);
113 if (ret)
114 return ret;
115
116 irq = gpiod_to_irq(gpiod);
117 if (irq < 0) {
118 pr_err("error %d getting IRQ %s %d\n", irq, data->chip, data->index);
119 return irq;
120 }
121
122 irq_type = acpi_dev_get_irq_type(data->trigger, data->polarity);
123 if (irq_type != IRQ_TYPE_NONE && irq_type != irq_get_trigger_type(irq))
124 irq_set_irq_type(irq, irq_type);
125
126 return irq;
127 case X86_ACPI_IRQ_TYPE_PMIC:
128 status = acpi_get_handle(NULL, data->chip, &handle);
129 if (ACPI_FAILURE(status)) {
130 pr_err("error could not get %s handle\n", data->chip);
131 return -ENODEV;
132 }
133
134 adev = acpi_fetch_acpi_dev(handle);
135 if (!adev) {
136 pr_err("error could not get %s adev\n", data->chip);
137 return -ENODEV;
138 }
139
140 fwspec.fwnode = acpi_fwnode_handle(adev);
141 domain = irq_find_matching_fwspec(&fwspec, data->domain);
142 if (!domain) {
143 pr_err("error could not find IRQ domain for %s\n", data->chip);
144 return -ENODEV;
145 }
146
147 return irq_create_mapping(domain, data->index);
148 default:
149 return 0;
150 }
151 }
152
153 struct x86_i2c_client_info {
154 struct i2c_board_info board_info;
155 char *adapter_path;
156 struct x86_acpi_irq_data irq_data;
157 };
158
159 struct x86_serdev_info {
160 const char *ctrl_hid;
161 const char *ctrl_uid;
162 const char *ctrl_devname;
163 /*
164 * ATM the serdev core only supports of or ACPI matching; and sofar all
165 * Android x86 tablets DSDTs have usable serdev nodes, but sometimes
166 * under the wrong controller. So we just tie the existing serdev ACPI
167 * node to the right controller.
168 */
169 const char *serdev_hid;
170 };
171
172 struct x86_dev_info {
173 char *invalid_aei_gpiochip;
174 const char * const *modules;
175 const struct software_node *bat_swnode;
176 struct gpiod_lookup_table * const *gpiod_lookup_tables;
177 const struct x86_i2c_client_info *i2c_client_info;
178 const struct platform_device_info *pdev_info;
179 const struct x86_serdev_info *serdev_info;
180 int i2c_client_count;
181 int pdev_count;
182 int serdev_count;
183 int (*init)(void);
184 void (*exit)(void);
185 };
186
187 /* Generic / shared charger / battery settings */
188 static const char * const tusb1211_chg_det_psy[] = { "tusb1211-charger-detect" };
189 static const char * const bq24190_psy[] = { "bq24190-charger" };
190 static const char * const bq25890_psy[] = { "bq25890-charger" };
191
192 static const struct property_entry fg_bq24190_supply_props[] = {
193 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
194 { }
195 };
196
197 static const struct software_node fg_bq24190_supply_node = {
198 .properties = fg_bq24190_supply_props,
199 };
200
201 static const struct property_entry fg_bq25890_supply_props[] = {
202 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq25890_psy),
203 { }
204 };
205
206 static const struct software_node fg_bq25890_supply_node = {
207 .properties = fg_bq25890_supply_props,
208 };
209
210 /* LiPo HighVoltage (max 4.35V) settings used by most devs with a HV bat. */
211 static const struct property_entry generic_lipo_hv_4v35_battery_props[] = {
212 PROPERTY_ENTRY_STRING("compatible", "simple-battery"),
213 PROPERTY_ENTRY_STRING("device-chemistry", "lithium-ion"),
214 PROPERTY_ENTRY_U32("precharge-current-microamp", 256000),
215 PROPERTY_ENTRY_U32("charge-term-current-microamp", 128000),
216 PROPERTY_ENTRY_U32("constant-charge-current-max-microamp", 1856000),
217 PROPERTY_ENTRY_U32("constant-charge-voltage-max-microvolt", 4352000),
218 PROPERTY_ENTRY_U32("factory-internal-resistance-micro-ohms", 150000),
219 { }
220 };
221
222 static const struct software_node generic_lipo_hv_4v35_battery_node = {
223 .properties = generic_lipo_hv_4v35_battery_props,
224 };
225
226 /* For enabling the bq24190 5V boost based on id-pin */
227 static struct regulator_consumer_supply intel_int3496_consumer = {
228 .supply = "vbus",
229 .dev_name = "intel-int3496",
230 };
231
232 static const struct regulator_init_data bq24190_vbus_init_data = {
233 .constraints = {
234 .name = "bq24190_vbus",
235 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
236 },
237 .consumer_supplies = &intel_int3496_consumer,
238 .num_consumer_supplies = 1,
239 };
240
241 static struct bq24190_platform_data bq24190_pdata = {
242 .regulator_init_data = &bq24190_vbus_init_data,
243 };
244
245 static const char * const bq24190_modules[] __initconst = {
246 "intel_crystal_cove_charger", /* For the bq24190 IRQ */
247 "bq24190_charger", /* For the Vbus regulator for intel-int3496 */
248 NULL
249 };
250
251 /* Generic pdevs array and gpio-lookups for micro USB ID pin handling */
252 static const struct platform_device_info int3496_pdevs[] __initconst = {
253 {
254 /* For micro USB ID pin handling */
255 .name = "intel-int3496",
256 .id = PLATFORM_DEVID_NONE,
257 },
258 };
259
260 static struct gpiod_lookup_table int3496_gpo2_pin22_gpios = {
261 .dev_id = "intel-int3496",
262 .table = {
263 GPIO_LOOKUP("INT33FC:02", 22, "id", GPIO_ACTIVE_HIGH),
264 { }
265 },
266 };
267
268 /* Asus ME176C and TF103C tablets shared data */
269 static struct gpio_keys_button asus_me176c_tf103c_lid = {
270 .code = SW_LID,
271 /* .gpio gets filled in by asus_me176c_tf103c_init() */
272 .active_low = true,
273 .desc = "lid_sw",
274 .type = EV_SW,
275 .wakeup = true,
276 .debounce_interval = 50,
277 };
278
279 static const struct gpio_keys_platform_data asus_me176c_tf103c_lid_pdata __initconst = {
280 .buttons = &asus_me176c_tf103c_lid,
281 .nbuttons = 1,
282 .name = "lid_sw",
283 };
284
285 static const struct platform_device_info asus_me176c_tf103c_pdevs[] __initconst = {
286 {
287 .name = "gpio-keys",
288 .id = PLATFORM_DEVID_AUTO,
289 .data = &asus_me176c_tf103c_lid_pdata,
290 .size_data = sizeof(asus_me176c_tf103c_lid_pdata),
291 },
292 {
293 /* For micro USB ID pin handling */
294 .name = "intel-int3496",
295 .id = PLATFORM_DEVID_NONE,
296 },
297 };
298
asus_me176c_tf103c_init(void)299 static int __init asus_me176c_tf103c_init(void)
300 {
301 struct gpio_desc *gpiod;
302 int ret;
303
304 ret = x86_android_tablet_get_gpiod("INT33FC:02", 12, &gpiod);
305 if (ret < 0)
306 return ret;
307 asus_me176c_tf103c_lid.gpio = desc_to_gpio(gpiod);
308
309 return 0;
310 }
311
312
313 /* Asus ME176C tablets have an Android factory img with everything hardcoded */
314 static const char * const asus_me176c_accel_mount_matrix[] = {
315 "-1", "0", "0",
316 "0", "1", "0",
317 "0", "0", "1"
318 };
319
320 static const struct property_entry asus_me176c_accel_props[] = {
321 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", asus_me176c_accel_mount_matrix),
322 { }
323 };
324
325 static const struct software_node asus_me176c_accel_node = {
326 .properties = asus_me176c_accel_props,
327 };
328
329 static const struct property_entry asus_me176c_bq24190_props[] = {
330 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
331 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
332 PROPERTY_ENTRY_U32("ti,system-minimum-microvolt", 3600000),
333 PROPERTY_ENTRY_BOOL("omit-battery-class"),
334 PROPERTY_ENTRY_BOOL("disable-reset"),
335 { }
336 };
337
338 static const struct software_node asus_me176c_bq24190_node = {
339 .properties = asus_me176c_bq24190_props,
340 };
341
342 static const struct property_entry asus_me176c_ug3105_props[] = {
343 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
344 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
345 PROPERTY_ENTRY_U32("upisemi,rsns-microohm", 10000),
346 { }
347 };
348
349 static const struct software_node asus_me176c_ug3105_node = {
350 .properties = asus_me176c_ug3105_props,
351 };
352
353 static const struct x86_i2c_client_info asus_me176c_i2c_clients[] __initconst = {
354 {
355 /* bq24297 battery charger */
356 .board_info = {
357 .type = "bq24190",
358 .addr = 0x6b,
359 .dev_name = "bq24297",
360 .swnode = &asus_me176c_bq24190_node,
361 .platform_data = &bq24190_pdata,
362 },
363 .adapter_path = "\\_SB_.I2C1",
364 .irq_data = {
365 .type = X86_ACPI_IRQ_TYPE_PMIC,
366 .chip = "\\_SB_.I2C7.PMIC",
367 .domain = DOMAIN_BUS_WAKEUP,
368 .index = 0,
369 },
370 }, {
371 /* ug3105 battery monitor */
372 .board_info = {
373 .type = "ug3105",
374 .addr = 0x70,
375 .dev_name = "ug3105",
376 .swnode = &asus_me176c_ug3105_node,
377 },
378 .adapter_path = "\\_SB_.I2C1",
379 }, {
380 /* ak09911 compass */
381 .board_info = {
382 .type = "ak09911",
383 .addr = 0x0c,
384 .dev_name = "ak09911",
385 },
386 .adapter_path = "\\_SB_.I2C5",
387 }, {
388 /* kxtj21009 accel */
389 .board_info = {
390 .type = "kxtj21009",
391 .addr = 0x0f,
392 .dev_name = "kxtj21009",
393 .swnode = &asus_me176c_accel_node,
394 },
395 .adapter_path = "\\_SB_.I2C5",
396 .irq_data = {
397 .type = X86_ACPI_IRQ_TYPE_APIC,
398 .index = 0x44,
399 .trigger = ACPI_EDGE_SENSITIVE,
400 .polarity = ACPI_ACTIVE_LOW,
401 },
402 }, {
403 /* goodix touchscreen */
404 .board_info = {
405 .type = "GDIX1001:00",
406 .addr = 0x14,
407 .dev_name = "goodix_ts",
408 },
409 .adapter_path = "\\_SB_.I2C6",
410 .irq_data = {
411 .type = X86_ACPI_IRQ_TYPE_APIC,
412 .index = 0x45,
413 .trigger = ACPI_EDGE_SENSITIVE,
414 .polarity = ACPI_ACTIVE_LOW,
415 },
416 },
417 };
418
419 static const struct x86_serdev_info asus_me176c_serdevs[] __initconst = {
420 {
421 .ctrl_hid = "80860F0A",
422 .ctrl_uid = "2",
423 .ctrl_devname = "serial0",
424 .serdev_hid = "BCM2E3A",
425 },
426 };
427
428 static struct gpiod_lookup_table asus_me176c_goodix_gpios = {
429 .dev_id = "i2c-goodix_ts",
430 .table = {
431 GPIO_LOOKUP("INT33FC:00", 60, "reset", GPIO_ACTIVE_HIGH),
432 GPIO_LOOKUP("INT33FC:02", 28, "irq", GPIO_ACTIVE_HIGH),
433 { }
434 },
435 };
436
437 static struct gpiod_lookup_table * const asus_me176c_gpios[] = {
438 &int3496_gpo2_pin22_gpios,
439 &asus_me176c_goodix_gpios,
440 NULL
441 };
442
443 static const struct x86_dev_info asus_me176c_info __initconst = {
444 .i2c_client_info = asus_me176c_i2c_clients,
445 .i2c_client_count = ARRAY_SIZE(asus_me176c_i2c_clients),
446 .pdev_info = asus_me176c_tf103c_pdevs,
447 .pdev_count = ARRAY_SIZE(asus_me176c_tf103c_pdevs),
448 .serdev_info = asus_me176c_serdevs,
449 .serdev_count = ARRAY_SIZE(asus_me176c_serdevs),
450 .gpiod_lookup_tables = asus_me176c_gpios,
451 .bat_swnode = &generic_lipo_hv_4v35_battery_node,
452 .modules = bq24190_modules,
453 .invalid_aei_gpiochip = "INT33FC:02",
454 .init = asus_me176c_tf103c_init,
455 };
456
457 /* Asus TF103C tablets have an Android factory img with everything hardcoded */
458 static const char * const asus_tf103c_accel_mount_matrix[] = {
459 "0", "-1", "0",
460 "-1", "0", "0",
461 "0", "0", "1"
462 };
463
464 static const struct property_entry asus_tf103c_accel_props[] = {
465 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", asus_tf103c_accel_mount_matrix),
466 { }
467 };
468
469 static const struct software_node asus_tf103c_accel_node = {
470 .properties = asus_tf103c_accel_props,
471 };
472
473 static const struct property_entry asus_tf103c_touchscreen_props[] = {
474 PROPERTY_ENTRY_STRING("compatible", "atmel,atmel_mxt_ts"),
475 { }
476 };
477
478 static const struct software_node asus_tf103c_touchscreen_node = {
479 .properties = asus_tf103c_touchscreen_props,
480 };
481
482 static const struct property_entry asus_tf103c_battery_props[] = {
483 PROPERTY_ENTRY_STRING("compatible", "simple-battery"),
484 PROPERTY_ENTRY_STRING("device-chemistry", "lithium-ion-polymer"),
485 PROPERTY_ENTRY_U32("precharge-current-microamp", 256000),
486 PROPERTY_ENTRY_U32("charge-term-current-microamp", 128000),
487 PROPERTY_ENTRY_U32("constant-charge-current-max-microamp", 2048000),
488 PROPERTY_ENTRY_U32("constant-charge-voltage-max-microvolt", 4208000),
489 PROPERTY_ENTRY_U32("factory-internal-resistance-micro-ohms", 150000),
490 { }
491 };
492
493 static const struct software_node asus_tf103c_battery_node = {
494 .properties = asus_tf103c_battery_props,
495 };
496
497 static const struct property_entry asus_tf103c_bq24190_props[] = {
498 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
499 PROPERTY_ENTRY_REF("monitored-battery", &asus_tf103c_battery_node),
500 PROPERTY_ENTRY_U32("ti,system-minimum-microvolt", 3600000),
501 PROPERTY_ENTRY_BOOL("omit-battery-class"),
502 PROPERTY_ENTRY_BOOL("disable-reset"),
503 { }
504 };
505
506 static const struct software_node asus_tf103c_bq24190_node = {
507 .properties = asus_tf103c_bq24190_props,
508 };
509
510 static const struct property_entry asus_tf103c_ug3105_props[] = {
511 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
512 PROPERTY_ENTRY_REF("monitored-battery", &asus_tf103c_battery_node),
513 PROPERTY_ENTRY_U32("upisemi,rsns-microohm", 5000),
514 { }
515 };
516
517 static const struct software_node asus_tf103c_ug3105_node = {
518 .properties = asus_tf103c_ug3105_props,
519 };
520
521 static const struct x86_i2c_client_info asus_tf103c_i2c_clients[] __initconst = {
522 {
523 /* bq24297 battery charger */
524 .board_info = {
525 .type = "bq24190",
526 .addr = 0x6b,
527 .dev_name = "bq24297",
528 .swnode = &asus_tf103c_bq24190_node,
529 .platform_data = &bq24190_pdata,
530 },
531 .adapter_path = "\\_SB_.I2C1",
532 .irq_data = {
533 .type = X86_ACPI_IRQ_TYPE_PMIC,
534 .chip = "\\_SB_.I2C7.PMIC",
535 .domain = DOMAIN_BUS_WAKEUP,
536 .index = 0,
537 },
538 }, {
539 /* ug3105 battery monitor */
540 .board_info = {
541 .type = "ug3105",
542 .addr = 0x70,
543 .dev_name = "ug3105",
544 .swnode = &asus_tf103c_ug3105_node,
545 },
546 .adapter_path = "\\_SB_.I2C1",
547 }, {
548 /* ak09911 compass */
549 .board_info = {
550 .type = "ak09911",
551 .addr = 0x0c,
552 .dev_name = "ak09911",
553 },
554 .adapter_path = "\\_SB_.I2C5",
555 }, {
556 /* kxtj21009 accel */
557 .board_info = {
558 .type = "kxtj21009",
559 .addr = 0x0f,
560 .dev_name = "kxtj21009",
561 .swnode = &asus_tf103c_accel_node,
562 },
563 .adapter_path = "\\_SB_.I2C5",
564 }, {
565 /* atmel touchscreen */
566 .board_info = {
567 .type = "atmel_mxt_ts",
568 .addr = 0x4a,
569 .dev_name = "atmel_mxt_ts",
570 .swnode = &asus_tf103c_touchscreen_node,
571 },
572 .adapter_path = "\\_SB_.I2C6",
573 .irq_data = {
574 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
575 .chip = "INT33FC:02",
576 .index = 28,
577 .trigger = ACPI_EDGE_SENSITIVE,
578 .polarity = ACPI_ACTIVE_LOW,
579 },
580 },
581 };
582
583 static struct gpiod_lookup_table * const asus_tf103c_gpios[] = {
584 &int3496_gpo2_pin22_gpios,
585 NULL
586 };
587
588 static const struct x86_dev_info asus_tf103c_info __initconst = {
589 .i2c_client_info = asus_tf103c_i2c_clients,
590 .i2c_client_count = ARRAY_SIZE(asus_tf103c_i2c_clients),
591 .pdev_info = asus_me176c_tf103c_pdevs,
592 .pdev_count = ARRAY_SIZE(asus_me176c_tf103c_pdevs),
593 .gpiod_lookup_tables = asus_tf103c_gpios,
594 .bat_swnode = &asus_tf103c_battery_node,
595 .modules = bq24190_modules,
596 .invalid_aei_gpiochip = "INT33FC:02",
597 .init = asus_me176c_tf103c_init,
598 };
599
600 /*
601 * When booted with the BIOS set to Android mode the Chuwi Hi8 (CWI509) DSDT
602 * contains a whole bunch of bogus ACPI I2C devices and is missing entries
603 * for the touchscreen and the accelerometer.
604 */
605 static const struct property_entry chuwi_hi8_gsl1680_props[] = {
606 PROPERTY_ENTRY_U32("touchscreen-size-x", 1665),
607 PROPERTY_ENTRY_U32("touchscreen-size-y", 1140),
608 PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"),
609 PROPERTY_ENTRY_BOOL("silead,home-button"),
610 PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hi8.fw"),
611 { }
612 };
613
614 static const struct software_node chuwi_hi8_gsl1680_node = {
615 .properties = chuwi_hi8_gsl1680_props,
616 };
617
618 static const char * const chuwi_hi8_mount_matrix[] = {
619 "1", "0", "0",
620 "0", "-1", "0",
621 "0", "0", "1"
622 };
623
624 static const struct property_entry chuwi_hi8_bma250e_props[] = {
625 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", chuwi_hi8_mount_matrix),
626 { }
627 };
628
629 static const struct software_node chuwi_hi8_bma250e_node = {
630 .properties = chuwi_hi8_bma250e_props,
631 };
632
633 static const struct x86_i2c_client_info chuwi_hi8_i2c_clients[] __initconst = {
634 {
635 /* Silead touchscreen */
636 .board_info = {
637 .type = "gsl1680",
638 .addr = 0x40,
639 .swnode = &chuwi_hi8_gsl1680_node,
640 },
641 .adapter_path = "\\_SB_.I2C4",
642 .irq_data = {
643 .type = X86_ACPI_IRQ_TYPE_APIC,
644 .index = 0x44,
645 .trigger = ACPI_EDGE_SENSITIVE,
646 .polarity = ACPI_ACTIVE_HIGH,
647 },
648 }, {
649 /* BMA250E accelerometer */
650 .board_info = {
651 .type = "bma250e",
652 .addr = 0x18,
653 .swnode = &chuwi_hi8_bma250e_node,
654 },
655 .adapter_path = "\\_SB_.I2C3",
656 .irq_data = {
657 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
658 .chip = "INT33FC:02",
659 .index = 23,
660 .trigger = ACPI_LEVEL_SENSITIVE,
661 .polarity = ACPI_ACTIVE_HIGH,
662 },
663 },
664 };
665
chuwi_hi8_init(void)666 static int __init chuwi_hi8_init(void)
667 {
668 /*
669 * Avoid the acpi_unregister_gsi() call in x86_acpi_irq_helper_get()
670 * breaking the touchscreen + logging various errors when the Windows
671 * BIOS is used.
672 */
673 if (acpi_dev_present("MSSL0001", NULL, 1))
674 return -ENODEV;
675
676 return 0;
677 }
678
679 static const struct x86_dev_info chuwi_hi8_info __initconst = {
680 .i2c_client_info = chuwi_hi8_i2c_clients,
681 .i2c_client_count = ARRAY_SIZE(chuwi_hi8_i2c_clients),
682 .init = chuwi_hi8_init,
683 };
684
685 #define CZC_EC_EXTRA_PORT 0x68
686 #define CZC_EC_ANDROID_KEYS 0x63
687
czc_p10t_init(void)688 static int __init czc_p10t_init(void)
689 {
690 /*
691 * The device boots up in "Windows 7" mode, when the home button sends a
692 * Windows specific key sequence (Left Meta + D) and the second button
693 * sends an unknown one while also toggling the Radio Kill Switch.
694 * This is a surprising behavior when the second button is labeled "Back".
695 *
696 * The vendor-supplied Android-x86 build switches the device to a "Android"
697 * mode by writing value 0x63 to the I/O port 0x68. This just seems to just
698 * set bit 6 on address 0x96 in the EC region; switching the bit directly
699 * seems to achieve the same result. It uses a "p10t_switcher" to do the
700 * job. It doesn't seem to be able to do anything else, and no other use
701 * of the port 0x68 is known.
702 *
703 * In the Android mode, the home button sends just a single scancode,
704 * which can be handled in Linux userspace more reasonably and the back
705 * button only sends a scancode without toggling the kill switch.
706 * The scancode can then be mapped either to Back or RF Kill functionality
707 * in userspace, depending on how the button is labeled on that particular
708 * model.
709 */
710 outb(CZC_EC_ANDROID_KEYS, CZC_EC_EXTRA_PORT);
711 return 0;
712 }
713
714 static const struct x86_dev_info czc_p10t __initconst = {
715 .init = czc_p10t_init,
716 };
717
718 /* Lenovo Yoga Book X90F / X91F / X91L need manual instantiation of the fg client */
719 static const struct x86_i2c_client_info lenovo_yogabook_x9x_i2c_clients[] __initconst = {
720 {
721 /* BQ27542 fuel-gauge */
722 .board_info = {
723 .type = "bq27542",
724 .addr = 0x55,
725 .dev_name = "bq27542",
726 .swnode = &fg_bq25890_supply_node,
727 },
728 .adapter_path = "\\_SB_.PCI0.I2C1",
729 },
730 };
731
732 static const struct x86_dev_info lenovo_yogabook_x9x_info __initconst = {
733 .i2c_client_info = lenovo_yogabook_x9x_i2c_clients,
734 .i2c_client_count = ARRAY_SIZE(lenovo_yogabook_x9x_i2c_clients),
735 };
736
737 /* Lenovo Yoga Tablet 2 1050F/L's Android factory img has everything hardcoded */
738 static const struct property_entry lenovo_yoga_tab2_830_1050_bq24190_props[] = {
739 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
740 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
741 PROPERTY_ENTRY_BOOL("omit-battery-class"),
742 PROPERTY_ENTRY_BOOL("disable-reset"),
743 { }
744 };
745
746 static const struct software_node lenovo_yoga_tab2_830_1050_bq24190_node = {
747 .properties = lenovo_yoga_tab2_830_1050_bq24190_props,
748 };
749
750 /* This gets filled by lenovo_yoga_tab2_830_1050_init() */
751 static struct rmi_device_platform_data lenovo_yoga_tab2_830_1050_rmi_pdata = { };
752
753 static struct lp855x_platform_data lenovo_yoga_tab2_830_1050_lp8557_pdata = {
754 .device_control = 0x86,
755 .initial_brightness = 128,
756 };
757
758 static const struct x86_i2c_client_info lenovo_yoga_tab2_830_1050_i2c_clients[] __initconst = {
759 {
760 /* bq24292i battery charger */
761 .board_info = {
762 .type = "bq24190",
763 .addr = 0x6b,
764 .dev_name = "bq24292i",
765 .swnode = &lenovo_yoga_tab2_830_1050_bq24190_node,
766 .platform_data = &bq24190_pdata,
767 },
768 .adapter_path = "\\_SB_.I2C1",
769 .irq_data = {
770 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
771 .chip = "INT33FC:02",
772 .index = 2,
773 .trigger = ACPI_EDGE_SENSITIVE,
774 .polarity = ACPI_ACTIVE_HIGH,
775 },
776 }, {
777 /* BQ27541 fuel-gauge */
778 .board_info = {
779 .type = "bq27541",
780 .addr = 0x55,
781 .dev_name = "bq27541",
782 .swnode = &fg_bq24190_supply_node,
783 },
784 .adapter_path = "\\_SB_.I2C1",
785 }, {
786 /* Synaptics RMI touchscreen */
787 .board_info = {
788 .type = "rmi4_i2c",
789 .addr = 0x38,
790 .dev_name = "rmi4_i2c",
791 .platform_data = &lenovo_yoga_tab2_830_1050_rmi_pdata,
792 },
793 .adapter_path = "\\_SB_.I2C6",
794 .irq_data = {
795 .type = X86_ACPI_IRQ_TYPE_APIC,
796 .index = 0x45,
797 .trigger = ACPI_EDGE_SENSITIVE,
798 .polarity = ACPI_ACTIVE_HIGH,
799 },
800 }, {
801 /* LP8557 Backlight controller */
802 .board_info = {
803 .type = "lp8557",
804 .addr = 0x2c,
805 .dev_name = "lp8557",
806 .platform_data = &lenovo_yoga_tab2_830_1050_lp8557_pdata,
807 },
808 .adapter_path = "\\_SB_.I2C3",
809 },
810 };
811
812 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_int3496_gpios = {
813 .dev_id = "intel-int3496",
814 .table = {
815 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_LOW),
816 GPIO_LOOKUP("INT33FC:02", 24, "id", GPIO_ACTIVE_HIGH),
817 { }
818 },
819 };
820
821 #define LENOVO_YOGA_TAB2_830_1050_CODEC_NAME "spi-10WM5102:00"
822
823 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_codec_gpios = {
824 .dev_id = LENOVO_YOGA_TAB2_830_1050_CODEC_NAME,
825 .table = {
826 GPIO_LOOKUP("gpio_crystalcove", 3, "reset", GPIO_ACTIVE_HIGH),
827 GPIO_LOOKUP("INT33FC:01", 23, "wlf,ldoena", GPIO_ACTIVE_HIGH),
828 GPIO_LOOKUP("arizona", 2, "wlf,spkvdd-ena", GPIO_ACTIVE_HIGH),
829 GPIO_LOOKUP("arizona", 4, "wlf,micd-pol", GPIO_ACTIVE_LOW),
830 { }
831 },
832 };
833
834 static struct gpiod_lookup_table * const lenovo_yoga_tab2_830_1050_gpios[] = {
835 &lenovo_yoga_tab2_830_1050_int3496_gpios,
836 &lenovo_yoga_tab2_830_1050_codec_gpios,
837 NULL
838 };
839
840 static int __init lenovo_yoga_tab2_830_1050_init(void);
841 static void lenovo_yoga_tab2_830_1050_exit(void);
842
843 static struct x86_dev_info lenovo_yoga_tab2_830_1050_info __initdata = {
844 .i2c_client_info = lenovo_yoga_tab2_830_1050_i2c_clients,
845 /* i2c_client_count gets set by lenovo_yoga_tab2_830_1050_init() */
846 .pdev_info = int3496_pdevs,
847 .pdev_count = ARRAY_SIZE(int3496_pdevs),
848 .gpiod_lookup_tables = lenovo_yoga_tab2_830_1050_gpios,
849 .bat_swnode = &generic_lipo_hv_4v35_battery_node,
850 .modules = bq24190_modules,
851 .invalid_aei_gpiochip = "INT33FC:02",
852 .init = lenovo_yoga_tab2_830_1050_init,
853 .exit = lenovo_yoga_tab2_830_1050_exit,
854 };
855
856 /*
857 * The Lenovo Yoga Tablet 2 830 and 1050 (8" vs 10") versions use the same
858 * mainboard, but they need some different treatment related to the display:
859 * 1. The 830 uses a portrait LCD panel with a landscape touchscreen, requiring
860 * the touchscreen driver to adjust the touch-coords to match the LCD.
861 * 2. Both use an TI LP8557 LED backlight controller. On the 1050 the LP8557's
862 * PWM input is connected to the PMIC's PWM output and everything works fine
863 * with the defaults programmed into the LP8557 by the BIOS.
864 * But on the 830 the LP8557's PWM input is connected to a PWM output coming
865 * from the LCD panel's controller. The Android code has a hack in the i915
866 * driver to write the non-standard DSI reg 0x9f with the desired backlight
867 * level to set the duty-cycle of the LCD's PWM output.
868 *
869 * To avoid having to have a similar hack in the mainline kernel the LP8557
870 * entry in lenovo_yoga_tab2_830_1050_i2c_clients instead just programs the
871 * LP8557 to directly set the level, ignoring the PWM input. This means that
872 * the LP8557 i2c_client should only be instantiated on the 830.
873 */
lenovo_yoga_tab2_830_1050_init_display(void)874 static int __init lenovo_yoga_tab2_830_1050_init_display(void)
875 {
876 struct gpio_desc *gpiod;
877 int ret;
878
879 /* Use PMIC GPIO 10 bootstrap pin to differentiate 830 vs 1050 */
880 ret = x86_android_tablet_get_gpiod("gpio_crystalcove", 10, &gpiod);
881 if (ret)
882 return ret;
883
884 ret = gpiod_get_value_cansleep(gpiod);
885 if (ret) {
886 pr_info("detected Lenovo Yoga Tablet 2 1050F/L\n");
887 lenovo_yoga_tab2_830_1050_info.i2c_client_count =
888 ARRAY_SIZE(lenovo_yoga_tab2_830_1050_i2c_clients) - 1;
889 } else {
890 pr_info("detected Lenovo Yoga Tablet 2 830F/L\n");
891 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.swap_axes = true;
892 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.flip_y = true;
893 lenovo_yoga_tab2_830_1050_info.i2c_client_count =
894 ARRAY_SIZE(lenovo_yoga_tab2_830_1050_i2c_clients);
895 }
896
897 return 0;
898 }
899
900 /* SUS (INT33FC:02) pin 6 needs to be configured as pmu_clk for the audio codec */
901 static const struct pinctrl_map lenovo_yoga_tab2_830_1050_codec_pinctrl_map =
902 PIN_MAP_MUX_GROUP(LENOVO_YOGA_TAB2_830_1050_CODEC_NAME, "codec_32khz_clk",
903 "INT33FC:02", "pmu_clk2_grp", "pmu_clk");
904
905 static struct pinctrl *lenovo_yoga_tab2_830_1050_codec_pinctrl;
906 static struct sys_off_handler *lenovo_yoga_tab2_830_1050_sys_off_handler;
907
lenovo_yoga_tab2_830_1050_init_codec(void)908 static int __init lenovo_yoga_tab2_830_1050_init_codec(void)
909 {
910 struct device *codec_dev;
911 struct pinctrl *pinctrl;
912 int ret;
913
914 codec_dev = bus_find_device_by_name(&spi_bus_type, NULL,
915 LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
916 if (!codec_dev) {
917 pr_err("error cannot find %s device\n", LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
918 return -ENODEV;
919 }
920
921 ret = pinctrl_register_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map, 1);
922 if (ret)
923 goto err_put_device;
924
925 pinctrl = pinctrl_get_select(codec_dev, "codec_32khz_clk");
926 if (IS_ERR(pinctrl)) {
927 ret = dev_err_probe(codec_dev, PTR_ERR(pinctrl), "selecting codec_32khz_clk\n");
928 goto err_unregister_mappings;
929 }
930
931 /* We're done with the codec_dev now */
932 put_device(codec_dev);
933
934 lenovo_yoga_tab2_830_1050_codec_pinctrl = pinctrl;
935 return 0;
936
937 err_unregister_mappings:
938 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
939 err_put_device:
940 put_device(codec_dev);
941 return ret;
942 }
943
944 /*
945 * These tablet's DSDT does not set acpi_gbl_reduced_hardware, so acpi_power_off
946 * gets used as pm_power_off handler. This causes "poweroff" on these tablets
947 * to hang hard. Requiring pressing the powerbutton for 30 seconds *twice*
948 * followed by a normal 3 second press to recover. Avoid this by doing an EFI
949 * poweroff instead.
950 */
lenovo_yoga_tab2_830_1050_power_off(struct sys_off_data * data)951 static int lenovo_yoga_tab2_830_1050_power_off(struct sys_off_data *data)
952 {
953 efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
954
955 return NOTIFY_DONE;
956 }
957
lenovo_yoga_tab2_830_1050_init(void)958 static int __init lenovo_yoga_tab2_830_1050_init(void)
959 {
960 int ret;
961
962 ret = lenovo_yoga_tab2_830_1050_init_display();
963 if (ret)
964 return ret;
965
966 ret = lenovo_yoga_tab2_830_1050_init_codec();
967 if (ret)
968 return ret;
969
970 /* SYS_OFF_PRIO_FIRMWARE + 1 so that it runs before acpi_power_off */
971 lenovo_yoga_tab2_830_1050_sys_off_handler =
972 register_sys_off_handler(SYS_OFF_MODE_POWER_OFF, SYS_OFF_PRIO_FIRMWARE + 1,
973 lenovo_yoga_tab2_830_1050_power_off, NULL);
974 if (IS_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler))
975 return PTR_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler);
976
977 return 0;
978 }
979
lenovo_yoga_tab2_830_1050_exit(void)980 static void lenovo_yoga_tab2_830_1050_exit(void)
981 {
982 unregister_sys_off_handler(lenovo_yoga_tab2_830_1050_sys_off_handler);
983
984 if (lenovo_yoga_tab2_830_1050_codec_pinctrl) {
985 pinctrl_put(lenovo_yoga_tab2_830_1050_codec_pinctrl);
986 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
987 }
988 }
989
990 /* Nextbook Ares 8 tablets have an Android factory img with everything hardcoded */
991 static const char * const nextbook_ares8_accel_mount_matrix[] = {
992 "0", "-1", "0",
993 "-1", "0", "0",
994 "0", "0", "1"
995 };
996
997 static const struct property_entry nextbook_ares8_accel_props[] = {
998 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", nextbook_ares8_accel_mount_matrix),
999 { }
1000 };
1001
1002 static const struct software_node nextbook_ares8_accel_node = {
1003 .properties = nextbook_ares8_accel_props,
1004 };
1005
1006 static const struct property_entry nextbook_ares8_touchscreen_props[] = {
1007 PROPERTY_ENTRY_U32("touchscreen-size-x", 800),
1008 PROPERTY_ENTRY_U32("touchscreen-size-y", 1280),
1009 { }
1010 };
1011
1012 static const struct software_node nextbook_ares8_touchscreen_node = {
1013 .properties = nextbook_ares8_touchscreen_props,
1014 };
1015
1016 static const struct x86_i2c_client_info nextbook_ares8_i2c_clients[] __initconst = {
1017 {
1018 /* Freescale MMA8653FC accel */
1019 .board_info = {
1020 .type = "mma8653",
1021 .addr = 0x1d,
1022 .dev_name = "mma8653",
1023 .swnode = &nextbook_ares8_accel_node,
1024 },
1025 .adapter_path = "\\_SB_.I2C3",
1026 }, {
1027 /* FT5416DQ9 touchscreen controller */
1028 .board_info = {
1029 .type = "edt-ft5x06",
1030 .addr = 0x38,
1031 .dev_name = "ft5416",
1032 .swnode = &nextbook_ares8_touchscreen_node,
1033 },
1034 .adapter_path = "\\_SB_.I2C4",
1035 .irq_data = {
1036 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
1037 .chip = "INT33FC:02",
1038 .index = 3,
1039 .trigger = ACPI_EDGE_SENSITIVE,
1040 .polarity = ACPI_ACTIVE_LOW,
1041 },
1042 },
1043 };
1044
1045 static struct gpiod_lookup_table nextbook_ares8_int3496_gpios = {
1046 .dev_id = "intel-int3496",
1047 .table = {
1048 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_HIGH),
1049 GPIO_LOOKUP("INT33FC:02", 18, "id", GPIO_ACTIVE_HIGH),
1050 { }
1051 },
1052 };
1053
1054 static struct gpiod_lookup_table * const nextbook_ares8_gpios[] = {
1055 &nextbook_ares8_int3496_gpios,
1056 NULL
1057 };
1058
1059 static const struct x86_dev_info nextbook_ares8_info __initconst = {
1060 .i2c_client_info = nextbook_ares8_i2c_clients,
1061 .i2c_client_count = ARRAY_SIZE(nextbook_ares8_i2c_clients),
1062 .pdev_info = int3496_pdevs,
1063 .pdev_count = ARRAY_SIZE(int3496_pdevs),
1064 .gpiod_lookup_tables = nextbook_ares8_gpios,
1065 .invalid_aei_gpiochip = "INT33FC:02",
1066 };
1067
1068 /*
1069 * Whitelabel (sold as various brands) TM800A550L tablets.
1070 * These tablet's DSDT contains a whole bunch of bogus ACPI I2C devices
1071 * (removed through acpi_quirk_skip_i2c_client_enumeration()) and
1072 * the touchscreen fwnode has the wrong GPIOs.
1073 */
1074 static const char * const whitelabel_tm800a550l_accel_mount_matrix[] = {
1075 "-1", "0", "0",
1076 "0", "1", "0",
1077 "0", "0", "1"
1078 };
1079
1080 static const struct property_entry whitelabel_tm800a550l_accel_props[] = {
1081 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", whitelabel_tm800a550l_accel_mount_matrix),
1082 { }
1083 };
1084
1085 static const struct software_node whitelabel_tm800a550l_accel_node = {
1086 .properties = whitelabel_tm800a550l_accel_props,
1087 };
1088
1089 static const struct property_entry whitelabel_tm800a550l_goodix_props[] = {
1090 PROPERTY_ENTRY_STRING("firmware-name", "gt912-tm800a550l.fw"),
1091 PROPERTY_ENTRY_STRING("goodix,config-name", "gt912-tm800a550l.cfg"),
1092 PROPERTY_ENTRY_U32("goodix,main-clk", 54),
1093 { }
1094 };
1095
1096 static const struct software_node whitelabel_tm800a550l_goodix_node = {
1097 .properties = whitelabel_tm800a550l_goodix_props,
1098 };
1099
1100 static const struct x86_i2c_client_info whitelabel_tm800a550l_i2c_clients[] __initconst = {
1101 {
1102 /* goodix touchscreen */
1103 .board_info = {
1104 .type = "GDIX1001:00",
1105 .addr = 0x14,
1106 .dev_name = "goodix_ts",
1107 .swnode = &whitelabel_tm800a550l_goodix_node,
1108 },
1109 .adapter_path = "\\_SB_.I2C2",
1110 .irq_data = {
1111 .type = X86_ACPI_IRQ_TYPE_APIC,
1112 .index = 0x44,
1113 .trigger = ACPI_EDGE_SENSITIVE,
1114 .polarity = ACPI_ACTIVE_HIGH,
1115 },
1116 }, {
1117 /* kxcj91008 accel */
1118 .board_info = {
1119 .type = "kxcj91008",
1120 .addr = 0x0f,
1121 .dev_name = "kxcj91008",
1122 .swnode = &whitelabel_tm800a550l_accel_node,
1123 },
1124 .adapter_path = "\\_SB_.I2C3",
1125 },
1126 };
1127
1128 static struct gpiod_lookup_table whitelabel_tm800a550l_goodix_gpios = {
1129 .dev_id = "i2c-goodix_ts",
1130 .table = {
1131 GPIO_LOOKUP("INT33FC:01", 26, "reset", GPIO_ACTIVE_HIGH),
1132 GPIO_LOOKUP("INT33FC:02", 3, "irq", GPIO_ACTIVE_HIGH),
1133 { }
1134 },
1135 };
1136
1137 static struct gpiod_lookup_table * const whitelabel_tm800a550l_gpios[] = {
1138 &whitelabel_tm800a550l_goodix_gpios,
1139 NULL
1140 };
1141
1142 static const struct x86_dev_info whitelabel_tm800a550l_info __initconst = {
1143 .i2c_client_info = whitelabel_tm800a550l_i2c_clients,
1144 .i2c_client_count = ARRAY_SIZE(whitelabel_tm800a550l_i2c_clients),
1145 .gpiod_lookup_tables = whitelabel_tm800a550l_gpios,
1146 };
1147
1148 /*
1149 * If the EFI bootloader is not Xiaomi's own signed Android loader, then the
1150 * Xiaomi Mi Pad 2 X86 tablet sets OSID in the DSDT to 1 (Windows), causing
1151 * a bunch of devices to be hidden.
1152 *
1153 * This takes care of instantiating the hidden devices manually.
1154 */
1155 static const struct x86_i2c_client_info xiaomi_mipad2_i2c_clients[] __initconst = {
1156 {
1157 /* BQ27520 fuel-gauge */
1158 .board_info = {
1159 .type = "bq27520",
1160 .addr = 0x55,
1161 .dev_name = "bq27520",
1162 .swnode = &fg_bq25890_supply_node,
1163 },
1164 .adapter_path = "\\_SB_.PCI0.I2C1",
1165 }, {
1166 /* KTD2026 RGB notification LED controller */
1167 .board_info = {
1168 .type = "ktd2026",
1169 .addr = 0x30,
1170 .dev_name = "ktd2026",
1171 },
1172 .adapter_path = "\\_SB_.PCI0.I2C3",
1173 },
1174 };
1175
1176 static const struct x86_dev_info xiaomi_mipad2_info __initconst = {
1177 .i2c_client_info = xiaomi_mipad2_i2c_clients,
1178 .i2c_client_count = ARRAY_SIZE(xiaomi_mipad2_i2c_clients),
1179 };
1180
1181 static const struct dmi_system_id x86_android_tablet_ids[] __initconst = {
1182 {
1183 /* Asus MeMO Pad 7 ME176C */
1184 .matches = {
1185 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1186 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ME176C"),
1187 },
1188 .driver_data = (void *)&asus_me176c_info,
1189 },
1190 {
1191 /* Asus TF103C */
1192 .matches = {
1193 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1194 DMI_MATCH(DMI_PRODUCT_NAME, "TF103C"),
1195 },
1196 .driver_data = (void *)&asus_tf103c_info,
1197 },
1198 {
1199 /* Chuwi Hi8 (CWI509) */
1200 .matches = {
1201 DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
1202 DMI_MATCH(DMI_BOARD_NAME, "BYT-PA03C"),
1203 DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
1204 DMI_MATCH(DMI_PRODUCT_NAME, "S806"),
1205 },
1206 .driver_data = (void *)&chuwi_hi8_info,
1207 },
1208 {
1209 /* CZC P10T */
1210 .ident = "CZC ODEON TPC-10 (\"P10T\")",
1211 .matches = {
1212 DMI_MATCH(DMI_SYS_VENDOR, "CZC"),
1213 DMI_MATCH(DMI_PRODUCT_NAME, "ODEON*TPC-10"),
1214 },
1215 .driver_data = (void *)&czc_p10t,
1216 },
1217 {
1218 /* CZC P10T variant */
1219 .ident = "ViewSonic ViewPad 10",
1220 .matches = {
1221 DMI_MATCH(DMI_SYS_VENDOR, "ViewSonic"),
1222 DMI_MATCH(DMI_PRODUCT_NAME, "VPAD10"),
1223 },
1224 .driver_data = (void *)&czc_p10t,
1225 },
1226 {
1227 /* Lenovo Yoga Book X90F / X91F / X91L */
1228 .matches = {
1229 /* Non exact match to match all versions */
1230 DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9"),
1231 },
1232 .driver_data = (void *)&lenovo_yogabook_x9x_info,
1233 },
1234 {
1235 /*
1236 * Lenovo Yoga Tablet 2 830F/L or 1050F/L (The 8" and 10"
1237 * Lenovo Yoga Tablet 2 use the same mainboard)
1238 */
1239 .matches = {
1240 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corp."),
1241 DMI_MATCH(DMI_PRODUCT_NAME, "VALLEYVIEW C0 PLATFORM"),
1242 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"),
1243 /* Partial match on beginning of BIOS version */
1244 DMI_MATCH(DMI_BIOS_VERSION, "BLADE_21"),
1245 },
1246 .driver_data = (void *)&lenovo_yoga_tab2_830_1050_info,
1247 },
1248 {
1249 /* Nextbook Ares 8 */
1250 .matches = {
1251 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
1252 DMI_MATCH(DMI_PRODUCT_NAME, "M890BAP"),
1253 },
1254 .driver_data = (void *)&nextbook_ares8_info,
1255 },
1256 {
1257 /* Whitelabel (sold as various brands) TM800A550L */
1258 .matches = {
1259 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1260 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1261 /* Above strings are too generic, also match on BIOS version */
1262 DMI_MATCH(DMI_BIOS_VERSION, "ZY-8-BI-PX4S70VTR400-X423B-005-D"),
1263 },
1264 .driver_data = (void *)&whitelabel_tm800a550l_info,
1265 },
1266 {
1267 /* Xiaomi Mi Pad 2 */
1268 .matches = {
1269 DMI_MATCH(DMI_SYS_VENDOR, "Xiaomi Inc"),
1270 DMI_MATCH(DMI_PRODUCT_NAME, "Mipad2"),
1271 },
1272 .driver_data = (void *)&xiaomi_mipad2_info,
1273 },
1274 { }
1275 };
1276 MODULE_DEVICE_TABLE(dmi, x86_android_tablet_ids);
1277
1278 static int i2c_client_count;
1279 static int pdev_count;
1280 static int serdev_count;
1281 static struct i2c_client **i2c_clients;
1282 static struct platform_device **pdevs;
1283 static struct serdev_device **serdevs;
1284 static struct gpiod_lookup_table * const *gpiod_lookup_tables;
1285 static const struct software_node *bat_swnode;
1286 static void (*exit_handler)(void);
1287
x86_instantiate_i2c_client(const struct x86_dev_info * dev_info,int idx)1288 static __init int x86_instantiate_i2c_client(const struct x86_dev_info *dev_info,
1289 int idx)
1290 {
1291 const struct x86_i2c_client_info *client_info = &dev_info->i2c_client_info[idx];
1292 struct i2c_board_info board_info = client_info->board_info;
1293 struct i2c_adapter *adap;
1294 acpi_handle handle;
1295 acpi_status status;
1296
1297 board_info.irq = x86_acpi_irq_helper_get(&client_info->irq_data);
1298 if (board_info.irq < 0)
1299 return board_info.irq;
1300
1301 status = acpi_get_handle(NULL, client_info->adapter_path, &handle);
1302 if (ACPI_FAILURE(status)) {
1303 pr_err("Error could not get %s handle\n", client_info->adapter_path);
1304 return -ENODEV;
1305 }
1306
1307 adap = i2c_acpi_find_adapter_by_handle(handle);
1308 if (!adap) {
1309 pr_err("error could not get %s adapter\n", client_info->adapter_path);
1310 return -ENODEV;
1311 }
1312
1313 i2c_clients[idx] = i2c_new_client_device(adap, &board_info);
1314 put_device(&adap->dev);
1315 if (IS_ERR(i2c_clients[idx]))
1316 return dev_err_probe(&adap->dev, PTR_ERR(i2c_clients[idx]),
1317 "creating I2C-client %d\n", idx);
1318
1319 return 0;
1320 }
1321
x86_instantiate_serdev(const struct x86_serdev_info * info,int idx)1322 static __init int x86_instantiate_serdev(const struct x86_serdev_info *info, int idx)
1323 {
1324 struct acpi_device *ctrl_adev, *serdev_adev;
1325 struct serdev_device *serdev;
1326 struct device *ctrl_dev;
1327 int ret = -ENODEV;
1328
1329 ctrl_adev = acpi_dev_get_first_match_dev(info->ctrl_hid, info->ctrl_uid, -1);
1330 if (!ctrl_adev) {
1331 pr_err("error could not get %s/%s ctrl adev\n",
1332 info->ctrl_hid, info->ctrl_uid);
1333 return -ENODEV;
1334 }
1335
1336 serdev_adev = acpi_dev_get_first_match_dev(info->serdev_hid, NULL, -1);
1337 if (!serdev_adev) {
1338 pr_err("error could not get %s serdev adev\n", info->serdev_hid);
1339 goto put_ctrl_adev;
1340 }
1341
1342 /* get_first_physical_node() returns a weak ref, no need to put() it */
1343 ctrl_dev = acpi_get_first_physical_node(ctrl_adev);
1344 if (!ctrl_dev) {
1345 pr_err("error could not get %s/%s ctrl physical dev\n",
1346 info->ctrl_hid, info->ctrl_uid);
1347 goto put_serdev_adev;
1348 }
1349
1350 /* ctrl_dev now points to the controller's parent, get the controller */
1351 ctrl_dev = device_find_child_by_name(ctrl_dev, info->ctrl_devname);
1352 if (!ctrl_dev) {
1353 pr_err("error could not get %s/%s %s ctrl dev\n",
1354 info->ctrl_hid, info->ctrl_uid, info->ctrl_devname);
1355 goto put_serdev_adev;
1356 }
1357
1358 serdev = serdev_device_alloc(to_serdev_controller(ctrl_dev));
1359 if (!serdev) {
1360 ret = -ENOMEM;
1361 goto put_serdev_adev;
1362 }
1363
1364 ACPI_COMPANION_SET(&serdev->dev, serdev_adev);
1365 acpi_device_set_enumerated(serdev_adev);
1366
1367 ret = serdev_device_add(serdev);
1368 if (ret) {
1369 dev_err(&serdev->dev, "error %d adding serdev\n", ret);
1370 serdev_device_put(serdev);
1371 goto put_serdev_adev;
1372 }
1373
1374 serdevs[idx] = serdev;
1375
1376 put_serdev_adev:
1377 acpi_dev_put(serdev_adev);
1378 put_ctrl_adev:
1379 acpi_dev_put(ctrl_adev);
1380 return ret;
1381 }
1382
x86_android_tablet_cleanup(void)1383 static void x86_android_tablet_cleanup(void)
1384 {
1385 int i;
1386
1387 for (i = 0; i < serdev_count; i++) {
1388 if (serdevs[i])
1389 serdev_device_remove(serdevs[i]);
1390 }
1391
1392 kfree(serdevs);
1393
1394 for (i = 0; i < pdev_count; i++)
1395 platform_device_unregister(pdevs[i]);
1396
1397 kfree(pdevs);
1398
1399 for (i = 0; i < i2c_client_count; i++)
1400 i2c_unregister_device(i2c_clients[i]);
1401
1402 kfree(i2c_clients);
1403
1404 if (exit_handler)
1405 exit_handler();
1406
1407 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1408 gpiod_remove_lookup_table(gpiod_lookup_tables[i]);
1409
1410 software_node_unregister(bat_swnode);
1411 }
1412
x86_android_tablet_init(void)1413 static __init int x86_android_tablet_init(void)
1414 {
1415 const struct x86_dev_info *dev_info;
1416 const struct dmi_system_id *id;
1417 struct gpio_chip *chip;
1418 int i, ret = 0;
1419
1420 id = dmi_first_match(x86_android_tablet_ids);
1421 if (!id)
1422 return -ENODEV;
1423
1424 dev_info = id->driver_data;
1425
1426 /*
1427 * The broken DSDTs on these devices often also include broken
1428 * _AEI (ACPI Event Interrupt) handlers, disable these.
1429 */
1430 if (dev_info->invalid_aei_gpiochip) {
1431 chip = gpiochip_find(dev_info->invalid_aei_gpiochip,
1432 gpiochip_find_match_label);
1433 if (!chip) {
1434 pr_err("error cannot find GPIO chip %s\n", dev_info->invalid_aei_gpiochip);
1435 return -ENODEV;
1436 }
1437 acpi_gpiochip_free_interrupts(chip);
1438 }
1439
1440 /*
1441 * Since this runs from module_init() it cannot use -EPROBE_DEFER,
1442 * instead pre-load any modules which are listed as requirements.
1443 */
1444 for (i = 0; dev_info->modules && dev_info->modules[i]; i++)
1445 request_module(dev_info->modules[i]);
1446
1447 bat_swnode = dev_info->bat_swnode;
1448 if (bat_swnode) {
1449 ret = software_node_register(bat_swnode);
1450 if (ret)
1451 return ret;
1452 }
1453
1454 gpiod_lookup_tables = dev_info->gpiod_lookup_tables;
1455 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1456 gpiod_add_lookup_table(gpiod_lookup_tables[i]);
1457
1458 if (dev_info->init) {
1459 ret = dev_info->init();
1460 if (ret < 0) {
1461 x86_android_tablet_cleanup();
1462 return ret;
1463 }
1464 exit_handler = dev_info->exit;
1465 }
1466
1467 i2c_clients = kcalloc(dev_info->i2c_client_count, sizeof(*i2c_clients), GFP_KERNEL);
1468 if (!i2c_clients) {
1469 x86_android_tablet_cleanup();
1470 return -ENOMEM;
1471 }
1472
1473 i2c_client_count = dev_info->i2c_client_count;
1474 for (i = 0; i < i2c_client_count; i++) {
1475 ret = x86_instantiate_i2c_client(dev_info, i);
1476 if (ret < 0) {
1477 x86_android_tablet_cleanup();
1478 return ret;
1479 }
1480 }
1481
1482 pdevs = kcalloc(dev_info->pdev_count, sizeof(*pdevs), GFP_KERNEL);
1483 if (!pdevs) {
1484 x86_android_tablet_cleanup();
1485 return -ENOMEM;
1486 }
1487
1488 pdev_count = dev_info->pdev_count;
1489 for (i = 0; i < pdev_count; i++) {
1490 pdevs[i] = platform_device_register_full(&dev_info->pdev_info[i]);
1491 if (IS_ERR(pdevs[i])) {
1492 x86_android_tablet_cleanup();
1493 return PTR_ERR(pdevs[i]);
1494 }
1495 }
1496
1497 serdevs = kcalloc(dev_info->serdev_count, sizeof(*serdevs), GFP_KERNEL);
1498 if (!serdevs) {
1499 x86_android_tablet_cleanup();
1500 return -ENOMEM;
1501 }
1502
1503 serdev_count = dev_info->serdev_count;
1504 for (i = 0; i < serdev_count; i++) {
1505 ret = x86_instantiate_serdev(&dev_info->serdev_info[i], i);
1506 if (ret < 0) {
1507 x86_android_tablet_cleanup();
1508 return ret;
1509 }
1510 }
1511
1512 return 0;
1513 }
1514
1515 module_init(x86_android_tablet_init);
1516 module_exit(x86_android_tablet_cleanup);
1517
1518 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1519 MODULE_DESCRIPTION("X86 Android tablets DSDT fixups driver");
1520 MODULE_LICENSE("GPL");
1521
