Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * ChromeOS specific ACPI extensions
0004  *
0005  * Copyright 2022 Google LLC
0006  *
0007  * This driver attaches to the ChromeOS ACPI device and then exports the
0008  * values reported by the ACPI in a sysfs directory. All values are
0009  * presented in the string form (numbers as decimal values) and can be
0010  * accessed as the contents of the appropriate read only files in the
0011  * sysfs directory tree.
0012  */
0013 #include <linux/acpi.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/kernel.h>
0016 #include <linux/list.h>
0017 #include <linux/module.h>
0018 
0019 #define ACPI_ATTR_NAME_LEN 4
0020 
0021 #define DEV_ATTR(_var, _name)                   \
0022     static struct device_attribute dev_attr_##_var =    \
0023         __ATTR(_name, 0444, chromeos_first_level_attr_show, NULL);
0024 
0025 #define GPIO_ATTR_GROUP(_group, _name, _num)                        \
0026     static umode_t attr_is_visible_gpio_##_num(struct kobject *kobj,        \
0027                            struct attribute *attr, int n)   \
0028     {                                       \
0029         if (_num < chromeos_acpi_gpio_groups)                   \
0030             return attr->mode;                      \
0031         return 0;                               \
0032     }                                       \
0033     static ssize_t chromeos_attr_show_gpio_##_num(struct device *dev,       \
0034                               struct device_attribute *attr,    \
0035                               char *buf)            \
0036     {                                       \
0037         char name[ACPI_ATTR_NAME_LEN + 1];                  \
0038         int ret, num;                               \
0039                                             \
0040         ret = parse_attr_name(attr->attr.name, name, &num);         \
0041         if (ret)                                \
0042             return ret;                         \
0043         return chromeos_acpi_evaluate_method(dev, _num, num, name, buf);    \
0044     }                                       \
0045     static struct device_attribute dev_attr_0_##_group =                \
0046         __ATTR(GPIO.0, 0444, chromeos_attr_show_gpio_##_num, NULL);     \
0047     static struct device_attribute dev_attr_1_##_group =                \
0048         __ATTR(GPIO.1, 0444, chromeos_attr_show_gpio_##_num, NULL);     \
0049     static struct device_attribute dev_attr_2_##_group =                \
0050         __ATTR(GPIO.2, 0444, chromeos_attr_show_gpio_##_num, NULL);     \
0051     static struct device_attribute dev_attr_3_##_group =                \
0052         __ATTR(GPIO.3, 0444, chromeos_attr_show_gpio_##_num, NULL);     \
0053                                             \
0054     static struct attribute *attrs_##_group[] = {                   \
0055         &dev_attr_0_##_group.attr,                      \
0056         &dev_attr_1_##_group.attr,                      \
0057         &dev_attr_2_##_group.attr,                      \
0058         &dev_attr_3_##_group.attr,                      \
0059         NULL                                    \
0060     };                                      \
0061     static const struct attribute_group attr_group_##_group = {         \
0062         .name = _name,                              \
0063         .is_visible = attr_is_visible_gpio_##_num,              \
0064         .attrs = attrs_##_group,                        \
0065     };
0066 
0067 static unsigned int chromeos_acpi_gpio_groups;
0068 
0069 /* Parse the ACPI package and return the data related to that attribute */
0070 static int chromeos_acpi_handle_package(struct device *dev, union acpi_object *obj,
0071                     int pkg_num, int sub_pkg_num, char *name, char *buf)
0072 {
0073     union acpi_object *element = obj->package.elements;
0074 
0075     if (pkg_num >= obj->package.count)
0076         return -EINVAL;
0077     element += pkg_num;
0078 
0079     if (element->type == ACPI_TYPE_PACKAGE) {
0080         if (sub_pkg_num >= element->package.count)
0081             return -EINVAL;
0082         /* select sub element inside this package */
0083         element = element->package.elements;
0084         element += sub_pkg_num;
0085     }
0086 
0087     switch (element->type) {
0088     case ACPI_TYPE_INTEGER:
0089         return sysfs_emit(buf, "%d\n", (int)element->integer.value);
0090     case ACPI_TYPE_STRING:
0091         return sysfs_emit(buf, "%s\n", element->string.pointer);
0092     case ACPI_TYPE_BUFFER:
0093         return sysfs_emit(buf, "%s\n", element->buffer.pointer);
0094     default:
0095         dev_err(dev, "element type %d not supported\n", element->type);
0096         return -EINVAL;
0097     }
0098 }
0099 
0100 static int chromeos_acpi_evaluate_method(struct device *dev, int pkg_num, int sub_pkg_num,
0101                      char *name, char *buf)
0102 {
0103     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0104     acpi_status status;
0105     int ret = -EINVAL;
0106 
0107     status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output);
0108     if (ACPI_FAILURE(status)) {
0109         dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status));
0110         return ret;
0111     }
0112 
0113     if (((union acpi_object *)output.pointer)->type == ACPI_TYPE_PACKAGE)
0114         ret = chromeos_acpi_handle_package(dev, output.pointer, pkg_num, sub_pkg_num,
0115                            name, buf);
0116 
0117     kfree(output.pointer);
0118     return ret;
0119 }
0120 
0121 static int parse_attr_name(const char *name, char *attr_name, int *attr_num)
0122 {
0123     int ret;
0124 
0125     ret = strscpy(attr_name, name, ACPI_ATTR_NAME_LEN + 1);
0126     if (ret == -E2BIG)
0127         return kstrtoint(&name[ACPI_ATTR_NAME_LEN + 1], 0, attr_num);
0128     return 0;
0129 }
0130 
0131 static ssize_t chromeos_first_level_attr_show(struct device *dev, struct device_attribute *attr,
0132                           char *buf)
0133 {
0134     char attr_name[ACPI_ATTR_NAME_LEN + 1];
0135     int ret, attr_num = 0;
0136 
0137     ret = parse_attr_name(attr->attr.name, attr_name, &attr_num);
0138     if (ret)
0139         return ret;
0140     return chromeos_acpi_evaluate_method(dev, attr_num, 0, attr_name, buf);
0141 }
0142 
0143 static unsigned int get_gpio_pkg_num(struct device *dev)
0144 {
0145     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0146     union acpi_object *obj;
0147     acpi_status status;
0148     unsigned int count = 0;
0149     char *name = "GPIO";
0150 
0151     status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output);
0152     if (ACPI_FAILURE(status)) {
0153         dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status));
0154         return count;
0155     }
0156 
0157     obj = output.pointer;
0158 
0159     if (obj->type == ACPI_TYPE_PACKAGE)
0160         count = obj->package.count;
0161 
0162     kfree(output.pointer);
0163     return count;
0164 }
0165 
0166 DEV_ATTR(binf2, BINF.2)
0167 DEV_ATTR(binf3, BINF.3)
0168 DEV_ATTR(chsw, CHSW)
0169 DEV_ATTR(fmap, FMAP)
0170 DEV_ATTR(frid, FRID)
0171 DEV_ATTR(fwid, FWID)
0172 DEV_ATTR(hwid, HWID)
0173 DEV_ATTR(meck, MECK)
0174 DEV_ATTR(vbnv0, VBNV.0)
0175 DEV_ATTR(vbnv1, VBNV.1)
0176 DEV_ATTR(vdat, VDAT)
0177 
0178 static struct attribute *first_level_attrs[] = {
0179     &dev_attr_binf2.attr,
0180     &dev_attr_binf3.attr,
0181     &dev_attr_chsw.attr,
0182     &dev_attr_fmap.attr,
0183     &dev_attr_frid.attr,
0184     &dev_attr_fwid.attr,
0185     &dev_attr_hwid.attr,
0186     &dev_attr_meck.attr,
0187     &dev_attr_vbnv0.attr,
0188     &dev_attr_vbnv1.attr,
0189     &dev_attr_vdat.attr,
0190     NULL
0191 };
0192 
0193 static const struct attribute_group first_level_attr_group = {
0194     .attrs = first_level_attrs,
0195 };
0196 
0197 /*
0198  * Every platform can have a different number of GPIO attribute groups.
0199  * Define upper limit groups. At run time, the platform decides to show
0200  * the present number of groups only, others are hidden.
0201  */
0202 GPIO_ATTR_GROUP(gpio0, "GPIO.0", 0)
0203 GPIO_ATTR_GROUP(gpio1, "GPIO.1", 1)
0204 GPIO_ATTR_GROUP(gpio2, "GPIO.2", 2)
0205 GPIO_ATTR_GROUP(gpio3, "GPIO.3", 3)
0206 GPIO_ATTR_GROUP(gpio4, "GPIO.4", 4)
0207 GPIO_ATTR_GROUP(gpio5, "GPIO.5", 5)
0208 GPIO_ATTR_GROUP(gpio6, "GPIO.6", 6)
0209 GPIO_ATTR_GROUP(gpio7, "GPIO.7", 7)
0210 
0211 static const struct attribute_group *chromeos_acpi_all_groups[] = {
0212     &first_level_attr_group,
0213     &attr_group_gpio0,
0214     &attr_group_gpio1,
0215     &attr_group_gpio2,
0216     &attr_group_gpio3,
0217     &attr_group_gpio4,
0218     &attr_group_gpio5,
0219     &attr_group_gpio6,
0220     &attr_group_gpio7,
0221     NULL
0222 };
0223 
0224 static int chromeos_acpi_device_probe(struct platform_device *pdev)
0225 {
0226     chromeos_acpi_gpio_groups = get_gpio_pkg_num(&pdev->dev);
0227 
0228     /*
0229      * If the platform has more GPIO attribute groups than the number of
0230      * groups this driver supports, give out a warning message.
0231      */
0232     if (chromeos_acpi_gpio_groups > ARRAY_SIZE(chromeos_acpi_all_groups) - 2)
0233         dev_warn(&pdev->dev, "Only %zu GPIO attr groups supported by the driver out of total %u.\n",
0234              ARRAY_SIZE(chromeos_acpi_all_groups) - 2, chromeos_acpi_gpio_groups);
0235     return 0;
0236 }
0237 
0238 /* GGL is valid PNP ID of Google. PNP ID can be used with the ACPI devices. */
0239 static const struct acpi_device_id chromeos_device_ids[] = {
0240     { "GGL0001", 0 },
0241     {}
0242 };
0243 MODULE_DEVICE_TABLE(acpi, chromeos_device_ids);
0244 
0245 static struct platform_driver chromeos_acpi_device_driver = {
0246     .probe = chromeos_acpi_device_probe,
0247     .driver = {
0248         .name = KBUILD_MODNAME,
0249         .dev_groups = chromeos_acpi_all_groups,
0250         .acpi_match_table = chromeos_device_ids,
0251     }
0252 };
0253 module_platform_driver(chromeos_acpi_device_driver);
0254 
0255 MODULE_AUTHOR("Muhammad Usama Anjum <usama.anjum@collabora.com>");
0256 MODULE_LICENSE("GPL");
0257 MODULE_DESCRIPTION("ChromeOS specific ACPI extensions");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!