1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ChromeOS specific ACPI extensions 4 * 5 * Copyright 2022 Google LLC 6 * 7 * This driver attaches to the ChromeOS ACPI device and then exports the 8 * values reported by the ACPI in a sysfs directory. All values are 9 * presented in the string form (numbers as decimal values) and can be 10 * accessed as the contents of the appropriate read only files in the 11 * sysfs directory tree. 12 */ 13 #include <linux/acpi.h> 14 #include <linux/platform_device.h> 15 #include <linux/kernel.h> 16 #include <linux/list.h> 17 #include <linux/module.h> 18 19 #define ACPI_ATTR_NAME_LEN 4 20 21 #define DEV_ATTR(_var, _name) \ 22 static struct device_attribute dev_attr_##_var = \ 23 __ATTR(_name, 0444, chromeos_first_level_attr_show, NULL); 24 25 #define GPIO_ATTR_GROUP(_group, _name, _num) \ 26 static umode_t attr_is_visible_gpio_##_num(struct kobject *kobj, \ 27 struct attribute *attr, int n) \ 28 { \ 29 if (_num < chromeos_acpi_gpio_groups) \ 30 return attr->mode; \ 31 return 0; \ 32 } \ 33 static ssize_t chromeos_attr_show_gpio_##_num(struct device *dev, \ 34 struct device_attribute *attr, \ 35 char *buf) \ 36 { \ 37 char name[ACPI_ATTR_NAME_LEN + 1]; \ 38 int ret, num; \ 39 \ 40 ret = parse_attr_name(attr->attr.name, name, &num); \ 41 if (ret) \ 42 return ret; \ 43 return chromeos_acpi_evaluate_method(dev, _num, num, name, buf); \ 44 } \ 45 static struct device_attribute dev_attr_0_##_group = \ 46 __ATTR(GPIO.0, 0444, chromeos_attr_show_gpio_##_num, NULL); \ 47 static struct device_attribute dev_attr_1_##_group = \ 48 __ATTR(GPIO.1, 0444, chromeos_attr_show_gpio_##_num, NULL); \ 49 static struct device_attribute dev_attr_2_##_group = \ 50 __ATTR(GPIO.2, 0444, chromeos_attr_show_gpio_##_num, NULL); \ 51 static struct device_attribute dev_attr_3_##_group = \ 52 __ATTR(GPIO.3, 0444, chromeos_attr_show_gpio_##_num, NULL); \ 53 \ 54 static struct attribute *attrs_##_group[] = { \ 55 &dev_attr_0_##_group.attr, \ 56 &dev_attr_1_##_group.attr, \ 57 &dev_attr_2_##_group.attr, \ 58 &dev_attr_3_##_group.attr, \ 59 NULL \ 60 }; \ 61 static const struct attribute_group attr_group_##_group = { \ 62 .name = _name, \ 63 .is_visible = attr_is_visible_gpio_##_num, \ 64 .attrs = attrs_##_group, \ 65 }; 66 67 static unsigned int chromeos_acpi_gpio_groups; 68 69 /* Parse the ACPI package and return the data related to that attribute */ 70 static int chromeos_acpi_handle_package(struct device *dev, union acpi_object *obj, 71 int pkg_num, int sub_pkg_num, char *name, char *buf) 72 { 73 union acpi_object *element = obj->package.elements; 74 75 if (pkg_num >= obj->package.count) 76 return -EINVAL; 77 element += pkg_num; 78 79 if (element->type == ACPI_TYPE_PACKAGE) { 80 if (sub_pkg_num >= element->package.count) 81 return -EINVAL; 82 /* select sub element inside this package */ 83 element = element->package.elements; 84 element += sub_pkg_num; 85 } 86 87 switch (element->type) { 88 case ACPI_TYPE_INTEGER: 89 return sysfs_emit(buf, "%d\n", (int)element->integer.value); 90 case ACPI_TYPE_STRING: 91 return sysfs_emit(buf, "%s\n", element->string.pointer); 92 case ACPI_TYPE_BUFFER: 93 { 94 int i, r, at, room_left; 95 const int byte_per_line = 16; 96 97 at = 0; 98 room_left = PAGE_SIZE - 1; 99 for (i = 0; i < element->buffer.length && room_left; i += byte_per_line) { 100 r = hex_dump_to_buffer(element->buffer.pointer + i, 101 element->buffer.length - i, 102 byte_per_line, 1, buf + at, room_left, 103 false); 104 if (r > room_left) 105 goto truncating; 106 at += r; 107 room_left -= r; 108 109 r = sysfs_emit_at(buf, at, "\n"); 110 if (!r) 111 goto truncating; 112 at += r; 113 room_left -= r; 114 } 115 116 buf[at] = 0; 117 return at; 118 truncating: 119 dev_info_once(dev, "truncating sysfs content for %s\n", name); 120 sysfs_emit_at(buf, PAGE_SIZE - 4, "..\n"); 121 return PAGE_SIZE - 1; 122 } 123 default: 124 dev_err(dev, "element type %d not supported\n", element->type); 125 return -EINVAL; 126 } 127 } 128 129 static int chromeos_acpi_evaluate_method(struct device *dev, int pkg_num, int sub_pkg_num, 130 char *name, char *buf) 131 { 132 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 133 acpi_status status; 134 int ret = -EINVAL; 135 136 status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output); 137 if (ACPI_FAILURE(status)) { 138 dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status)); 139 return ret; 140 } 141 142 if (((union acpi_object *)output.pointer)->type == ACPI_TYPE_PACKAGE) 143 ret = chromeos_acpi_handle_package(dev, output.pointer, pkg_num, sub_pkg_num, 144 name, buf); 145 146 kfree(output.pointer); 147 return ret; 148 } 149 150 static int parse_attr_name(const char *name, char *attr_name, int *attr_num) 151 { 152 int ret; 153 154 ret = strscpy(attr_name, name, ACPI_ATTR_NAME_LEN + 1); 155 if (ret == -E2BIG) 156 return kstrtoint(&name[ACPI_ATTR_NAME_LEN + 1], 0, attr_num); 157 return 0; 158 } 159 160 static ssize_t chromeos_first_level_attr_show(struct device *dev, struct device_attribute *attr, 161 char *buf) 162 { 163 char attr_name[ACPI_ATTR_NAME_LEN + 1]; 164 int ret, attr_num = 0; 165 166 ret = parse_attr_name(attr->attr.name, attr_name, &attr_num); 167 if (ret) 168 return ret; 169 return chromeos_acpi_evaluate_method(dev, attr_num, 0, attr_name, buf); 170 } 171 172 static unsigned int get_gpio_pkg_num(struct device *dev) 173 { 174 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 175 union acpi_object *obj; 176 acpi_status status; 177 unsigned int count = 0; 178 char *name = "GPIO"; 179 180 status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output); 181 if (ACPI_FAILURE(status)) { 182 dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status)); 183 return count; 184 } 185 186 obj = output.pointer; 187 188 if (obj->type == ACPI_TYPE_PACKAGE) 189 count = obj->package.count; 190 191 kfree(output.pointer); 192 return count; 193 } 194 195 DEV_ATTR(binf2, BINF.2) 196 DEV_ATTR(binf3, BINF.3) 197 DEV_ATTR(chsw, CHSW) 198 DEV_ATTR(fmap, FMAP) 199 DEV_ATTR(frid, FRID) 200 DEV_ATTR(fwid, FWID) 201 DEV_ATTR(hwid, HWID) 202 DEV_ATTR(meck, MECK) 203 DEV_ATTR(vbnv0, VBNV.0) 204 DEV_ATTR(vbnv1, VBNV.1) 205 DEV_ATTR(vdat, VDAT) 206 207 static struct attribute *first_level_attrs[] = { 208 &dev_attr_binf2.attr, 209 &dev_attr_binf3.attr, 210 &dev_attr_chsw.attr, 211 &dev_attr_fmap.attr, 212 &dev_attr_frid.attr, 213 &dev_attr_fwid.attr, 214 &dev_attr_hwid.attr, 215 &dev_attr_meck.attr, 216 &dev_attr_vbnv0.attr, 217 &dev_attr_vbnv1.attr, 218 &dev_attr_vdat.attr, 219 NULL 220 }; 221 222 static const struct attribute_group first_level_attr_group = { 223 .attrs = first_level_attrs, 224 }; 225 226 /* 227 * Every platform can have a different number of GPIO attribute groups. 228 * Define upper limit groups. At run time, the platform decides to show 229 * the present number of groups only, others are hidden. 230 */ 231 GPIO_ATTR_GROUP(gpio0, "GPIO.0", 0) 232 GPIO_ATTR_GROUP(gpio1, "GPIO.1", 1) 233 GPIO_ATTR_GROUP(gpio2, "GPIO.2", 2) 234 GPIO_ATTR_GROUP(gpio3, "GPIO.3", 3) 235 GPIO_ATTR_GROUP(gpio4, "GPIO.4", 4) 236 GPIO_ATTR_GROUP(gpio5, "GPIO.5", 5) 237 GPIO_ATTR_GROUP(gpio6, "GPIO.6", 6) 238 GPIO_ATTR_GROUP(gpio7, "GPIO.7", 7) 239 240 static const struct attribute_group *chromeos_acpi_all_groups[] = { 241 &first_level_attr_group, 242 &attr_group_gpio0, 243 &attr_group_gpio1, 244 &attr_group_gpio2, 245 &attr_group_gpio3, 246 &attr_group_gpio4, 247 &attr_group_gpio5, 248 &attr_group_gpio6, 249 &attr_group_gpio7, 250 NULL 251 }; 252 253 static int chromeos_acpi_device_probe(struct platform_device *pdev) 254 { 255 chromeos_acpi_gpio_groups = get_gpio_pkg_num(&pdev->dev); 256 257 /* 258 * If the platform has more GPIO attribute groups than the number of 259 * groups this driver supports, give out a warning message. 260 */ 261 if (chromeos_acpi_gpio_groups > ARRAY_SIZE(chromeos_acpi_all_groups) - 2) 262 dev_warn(&pdev->dev, "Only %zu GPIO attr groups supported by the driver out of total %u.\n", 263 ARRAY_SIZE(chromeos_acpi_all_groups) - 2, chromeos_acpi_gpio_groups); 264 return 0; 265 } 266 267 static const struct acpi_device_id chromeos_device_ids[] = { 268 { "GGL0001", 0 }, 269 { "GOOG0016", 0 }, 270 {} 271 }; 272 MODULE_DEVICE_TABLE(acpi, chromeos_device_ids); 273 274 static struct platform_driver chromeos_acpi_device_driver = { 275 .probe = chromeos_acpi_device_probe, 276 .driver = { 277 .name = KBUILD_MODNAME, 278 .dev_groups = chromeos_acpi_all_groups, 279 .acpi_match_table = chromeos_device_ids, 280 } 281 }; 282 module_platform_driver(chromeos_acpi_device_driver); 283 284 MODULE_AUTHOR("Muhammad Usama Anjum <usama.anjum@collabora.com>"); 285 MODULE_LICENSE("GPL"); 286 MODULE_DESCRIPTION("ChromeOS specific ACPI extensions"); 287