// SPDX-License-Identifier: GPL-2.0-only /* * ChromeOS specific ACPI extensions * * Copyright 2022 Google LLC * * This driver attaches to the ChromeOS ACPI device and then exports the * values reported by the ACPI in a sysfs directory. All values are * presented in the string form (numbers as decimal values) and can be * accessed as the contents of the appropriate read only files in the * sysfs directory tree. */ #include #include #include #include #include #define ACPI_ATTR_NAME_LEN 4 #define DEV_ATTR(_var, _name) \ static struct device_attribute dev_attr_##_var = \ __ATTR(_name, 0444, chromeos_first_level_attr_show, NULL); #define GPIO_ATTR_GROUP(_group, _name, _num) \ static umode_t attr_is_visible_gpio_##_num(struct kobject *kobj, \ struct attribute *attr, int n) \ { \ if (_num < chromeos_acpi_gpio_groups) \ return attr->mode; \ return 0; \ } \ static ssize_t chromeos_attr_show_gpio_##_num(struct device *dev, \ struct device_attribute *attr, \ char *buf) \ { \ char name[ACPI_ATTR_NAME_LEN + 1]; \ int ret, num; \ \ ret = parse_attr_name(attr->attr.name, name, &num); \ if (ret) \ return ret; \ return chromeos_acpi_evaluate_method(dev, _num, num, name, buf); \ } \ static struct device_attribute dev_attr_0_##_group = \ __ATTR(GPIO.0, 0444, chromeos_attr_show_gpio_##_num, NULL); \ static struct device_attribute dev_attr_1_##_group = \ __ATTR(GPIO.1, 0444, chromeos_attr_show_gpio_##_num, NULL); \ static struct device_attribute dev_attr_2_##_group = \ __ATTR(GPIO.2, 0444, chromeos_attr_show_gpio_##_num, NULL); \ static struct device_attribute dev_attr_3_##_group = \ __ATTR(GPIO.3, 0444, chromeos_attr_show_gpio_##_num, NULL); \ \ static struct attribute *attrs_##_group[] = { \ &dev_attr_0_##_group.attr, \ &dev_attr_1_##_group.attr, \ &dev_attr_2_##_group.attr, \ &dev_attr_3_##_group.attr, \ NULL \ }; \ static const struct attribute_group attr_group_##_group = { \ .name = _name, \ .is_visible = attr_is_visible_gpio_##_num, \ .attrs = attrs_##_group, \ }; static unsigned int chromeos_acpi_gpio_groups; /* Parse the ACPI package and return the data related to that attribute */ static int chromeos_acpi_handle_package(struct device *dev, union acpi_object *obj, int pkg_num, int sub_pkg_num, char *name, char *buf) { union acpi_object *element = obj->package.elements; if (pkg_num >= obj->package.count) return -EINVAL; element += pkg_num; if (element->type == ACPI_TYPE_PACKAGE) { if (sub_pkg_num >= element->package.count) return -EINVAL; /* select sub element inside this package */ element = element->package.elements; element += sub_pkg_num; } switch (element->type) { case ACPI_TYPE_INTEGER: return sysfs_emit(buf, "%d\n", (int)element->integer.value); case ACPI_TYPE_STRING: return sysfs_emit(buf, "%s\n", element->string.pointer); case ACPI_TYPE_BUFFER: { int i, r, at, room_left; const int byte_per_line = 16; at = 0; room_left = PAGE_SIZE - 1; for (i = 0; i < element->buffer.length && room_left; i += byte_per_line) { r = hex_dump_to_buffer(element->buffer.pointer + i, element->buffer.length - i, byte_per_line, 1, buf + at, room_left, false); if (r > room_left) goto truncating; at += r; room_left -= r; r = sysfs_emit_at(buf, at, "\n"); if (!r) goto truncating; at += r; room_left -= r; } buf[at] = 0; return at; truncating: dev_info_once(dev, "truncating sysfs content for %s\n", name); sysfs_emit_at(buf, PAGE_SIZE - 4, "..\n"); return PAGE_SIZE - 1; } default: dev_err(dev, "element type %d not supported\n", element->type); return -EINVAL; } } static int chromeos_acpi_evaluate_method(struct device *dev, int pkg_num, int sub_pkg_num, char *name, char *buf) { struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; acpi_status status; int ret = -EINVAL; status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output); if (ACPI_FAILURE(status)) { dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status)); return ret; } if (((union acpi_object *)output.pointer)->type == ACPI_TYPE_PACKAGE) ret = chromeos_acpi_handle_package(dev, output.pointer, pkg_num, sub_pkg_num, name, buf); kfree(output.pointer); return ret; } static int parse_attr_name(const char *name, char *attr_name, int *attr_num) { int ret; ret = strscpy(attr_name, name, ACPI_ATTR_NAME_LEN + 1); if (ret == -E2BIG) return kstrtoint(&name[ACPI_ATTR_NAME_LEN + 1], 0, attr_num); return 0; } static ssize_t chromeos_first_level_attr_show(struct device *dev, struct device_attribute *attr, char *buf) { char attr_name[ACPI_ATTR_NAME_LEN + 1]; int ret, attr_num = 0; ret = parse_attr_name(attr->attr.name, attr_name, &attr_num); if (ret) return ret; return chromeos_acpi_evaluate_method(dev, attr_num, 0, attr_name, buf); } static unsigned int get_gpio_pkg_num(struct device *dev) { struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; union acpi_object *obj; acpi_status status; unsigned int count = 0; char *name = "GPIO"; status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output); if (ACPI_FAILURE(status)) { dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status)); return count; } obj = output.pointer; if (obj->type == ACPI_TYPE_PACKAGE) count = obj->package.count; kfree(output.pointer); return count; } DEV_ATTR(binf2, BINF.2) DEV_ATTR(binf3, BINF.3) DEV_ATTR(chsw, CHSW) DEV_ATTR(fmap, FMAP) DEV_ATTR(frid, FRID) DEV_ATTR(fwid, FWID) DEV_ATTR(hwid, HWID) DEV_ATTR(meck, MECK) DEV_ATTR(vbnv0, VBNV.0) DEV_ATTR(vbnv1, VBNV.1) DEV_ATTR(vdat, VDAT) static struct attribute *first_level_attrs[] = { &dev_attr_binf2.attr, &dev_attr_binf3.attr, &dev_attr_chsw.attr, &dev_attr_fmap.attr, &dev_attr_frid.attr, &dev_attr_fwid.attr, &dev_attr_hwid.attr, &dev_attr_meck.attr, &dev_attr_vbnv0.attr, &dev_attr_vbnv1.attr, &dev_attr_vdat.attr, NULL }; static const struct attribute_group first_level_attr_group = { .attrs = first_level_attrs, }; /* * Every platform can have a different number of GPIO attribute groups. * Define upper limit groups. At run time, the platform decides to show * the present number of groups only, others are hidden. */ GPIO_ATTR_GROUP(gpio0, "GPIO.0", 0) GPIO_ATTR_GROUP(gpio1, "GPIO.1", 1) GPIO_ATTR_GROUP(gpio2, "GPIO.2", 2) GPIO_ATTR_GROUP(gpio3, "GPIO.3", 3) GPIO_ATTR_GROUP(gpio4, "GPIO.4", 4) GPIO_ATTR_GROUP(gpio5, "GPIO.5", 5) GPIO_ATTR_GROUP(gpio6, "GPIO.6", 6) GPIO_ATTR_GROUP(gpio7, "GPIO.7", 7) static const struct attribute_group *chromeos_acpi_all_groups[] = { &first_level_attr_group, &attr_group_gpio0, &attr_group_gpio1, &attr_group_gpio2, &attr_group_gpio3, &attr_group_gpio4, &attr_group_gpio5, &attr_group_gpio6, &attr_group_gpio7, NULL }; static int chromeos_acpi_device_probe(struct platform_device *pdev) { chromeos_acpi_gpio_groups = get_gpio_pkg_num(&pdev->dev); /* * If the platform has more GPIO attribute groups than the number of * groups this driver supports, give out a warning message. */ if (chromeos_acpi_gpio_groups > ARRAY_SIZE(chromeos_acpi_all_groups) - 2) dev_warn(&pdev->dev, "Only %zu GPIO attr groups supported by the driver out of total %u.\n", ARRAY_SIZE(chromeos_acpi_all_groups) - 2, chromeos_acpi_gpio_groups); return 0; } static const struct acpi_device_id chromeos_device_ids[] = { { "GGL0001", 0 }, { "GOOG0016", 0 }, {} }; MODULE_DEVICE_TABLE(acpi, chromeos_device_ids); static struct platform_driver chromeos_acpi_device_driver = { .probe = chromeos_acpi_device_probe, .driver = { .name = KBUILD_MODNAME, .dev_groups = chromeos_acpi_all_groups, .acpi_match_table = chromeos_device_ids, } }; module_platform_driver(chromeos_acpi_device_driver); MODULE_AUTHOR("Muhammad Usama Anjum "); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("ChromeOS specific ACPI extensions");