1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PowerNV OPAL Sensor-groups interface 4 * 5 * Copyright 2017 IBM Corp. 6 */ 7 8 #define pr_fmt(fmt) "opal-sensor-groups: " fmt 9 10 #include <linux/of.h> 11 #include <linux/kobject.h> 12 #include <linux/slab.h> 13 14 #include <asm/opal.h> 15 16 static DEFINE_MUTEX(sg_mutex); 17 18 static struct kobject *sg_kobj; 19 20 struct sg_attr { 21 u32 handle; 22 struct kobj_attribute attr; 23 }; 24 25 static struct sensor_group { 26 char name[20]; 27 struct attribute_group sg; 28 struct sg_attr *sgattrs; 29 } *sgs; 30 31 int sensor_group_enable(u32 handle, bool enable) 32 { 33 struct opal_msg msg; 34 int token, ret; 35 36 token = opal_async_get_token_interruptible(); 37 if (token < 0) 38 return token; 39 40 ret = opal_sensor_group_enable(handle, token, enable); 41 if (ret == OPAL_ASYNC_COMPLETION) { 42 ret = opal_async_wait_response(token, &msg); 43 if (ret) { 44 pr_devel("Failed to wait for the async response\n"); 45 ret = -EIO; 46 goto out; 47 } 48 ret = opal_error_code(opal_get_async_rc(msg)); 49 } else { 50 ret = opal_error_code(ret); 51 } 52 53 out: 54 opal_async_release_token(token); 55 return ret; 56 } 57 EXPORT_SYMBOL_GPL(sensor_group_enable); 58 59 static ssize_t sg_store(struct kobject *kobj, struct kobj_attribute *attr, 60 const char *buf, size_t count) 61 { 62 struct sg_attr *sattr = container_of(attr, struct sg_attr, attr); 63 struct opal_msg msg; 64 u32 data; 65 int ret, token; 66 67 ret = kstrtoint(buf, 0, &data); 68 if (ret) 69 return ret; 70 71 if (data != 1) 72 return -EINVAL; 73 74 token = opal_async_get_token_interruptible(); 75 if (token < 0) { 76 pr_devel("Failed to get token\n"); 77 return token; 78 } 79 80 ret = mutex_lock_interruptible(&sg_mutex); 81 if (ret) 82 goto out_token; 83 84 ret = opal_sensor_group_clear(sattr->handle, token); 85 switch (ret) { 86 case OPAL_ASYNC_COMPLETION: 87 ret = opal_async_wait_response(token, &msg); 88 if (ret) { 89 pr_devel("Failed to wait for the async response\n"); 90 ret = -EIO; 91 goto out; 92 } 93 ret = opal_error_code(opal_get_async_rc(msg)); 94 if (!ret) 95 ret = count; 96 break; 97 case OPAL_SUCCESS: 98 ret = count; 99 break; 100 default: 101 ret = opal_error_code(ret); 102 } 103 104 out: 105 mutex_unlock(&sg_mutex); 106 out_token: 107 opal_async_release_token(token); 108 return ret; 109 } 110 111 static struct sg_ops_info { 112 int opal_no; 113 const char *attr_name; 114 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr, 115 const char *buf, size_t count); 116 } ops_info[] = { 117 { OPAL_SENSOR_GROUP_CLEAR, "clear", sg_store }, 118 }; 119 120 static void add_attr(int handle, struct sg_attr *attr, int index) 121 { 122 attr->handle = handle; 123 sysfs_attr_init(&attr->attr.attr); 124 attr->attr.attr.name = ops_info[index].attr_name; 125 attr->attr.attr.mode = 0220; 126 attr->attr.store = ops_info[index].store; 127 } 128 129 static int add_attr_group(const __be32 *ops, int len, struct sensor_group *sg, 130 u32 handle) 131 { 132 int i, j; 133 int count = 0; 134 135 for (i = 0; i < len; i++) 136 for (j = 0; j < ARRAY_SIZE(ops_info); j++) 137 if (be32_to_cpu(ops[i]) == ops_info[j].opal_no) { 138 add_attr(handle, &sg->sgattrs[count], j); 139 sg->sg.attrs[count] = 140 &sg->sgattrs[count].attr.attr; 141 count++; 142 } 143 144 return sysfs_create_group(sg_kobj, &sg->sg); 145 } 146 147 static int get_nr_attrs(const __be32 *ops, int len) 148 { 149 int i, j; 150 int nr_attrs = 0; 151 152 for (i = 0; i < len; i++) 153 for (j = 0; j < ARRAY_SIZE(ops_info); j++) 154 if (be32_to_cpu(ops[i]) == ops_info[j].opal_no) 155 nr_attrs++; 156 157 return nr_attrs; 158 } 159 160 void __init opal_sensor_groups_init(void) 161 { 162 struct device_node *sg, *node; 163 int i = 0; 164 165 sg = of_find_compatible_node(NULL, NULL, "ibm,opal-sensor-group"); 166 if (!sg) { 167 pr_devel("Sensor groups node not found\n"); 168 return; 169 } 170 171 sgs = kcalloc(of_get_child_count(sg), sizeof(*sgs), GFP_KERNEL); 172 if (!sgs) 173 return; 174 175 sg_kobj = kobject_create_and_add("sensor_groups", opal_kobj); 176 if (!sg_kobj) { 177 pr_warn("Failed to create sensor group kobject\n"); 178 goto out_sgs; 179 } 180 181 for_each_child_of_node(sg, node) { 182 const __be32 *ops; 183 u32 sgid, len, nr_attrs, chipid; 184 185 ops = of_get_property(node, "ops", &len); 186 if (!ops) 187 continue; 188 189 nr_attrs = get_nr_attrs(ops, len); 190 if (!nr_attrs) 191 continue; 192 193 sgs[i].sgattrs = kcalloc(nr_attrs, sizeof(*sgs[i].sgattrs), 194 GFP_KERNEL); 195 if (!sgs[i].sgattrs) 196 goto out_sgs_sgattrs; 197 198 sgs[i].sg.attrs = kcalloc(nr_attrs + 1, 199 sizeof(*sgs[i].sg.attrs), 200 GFP_KERNEL); 201 202 if (!sgs[i].sg.attrs) { 203 kfree(sgs[i].sgattrs); 204 goto out_sgs_sgattrs; 205 } 206 207 if (of_property_read_u32(node, "sensor-group-id", &sgid)) { 208 pr_warn("sensor-group-id property not found\n"); 209 goto out_sgs_sgattrs; 210 } 211 212 if (!of_property_read_u32(node, "ibm,chip-id", &chipid)) 213 sprintf(sgs[i].name, "%pOFn%d", node, chipid); 214 else 215 sprintf(sgs[i].name, "%pOFn", node); 216 217 sgs[i].sg.name = sgs[i].name; 218 if (add_attr_group(ops, len, &sgs[i], sgid)) { 219 pr_warn("Failed to create sensor attribute group %s\n", 220 sgs[i].sg.name); 221 goto out_sgs_sgattrs; 222 } 223 i++; 224 } 225 226 return; 227 228 out_sgs_sgattrs: 229 while (--i >= 0) { 230 kfree(sgs[i].sgattrs); 231 kfree(sgs[i].sg.attrs); 232 } 233 kobject_put(sg_kobj); 234 out_sgs: 235 kfree(sgs); 236 } 237