1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Platform energy and frequency attributes driver 4 * 5 * This driver creates a sys file at /sys/firmware/papr/ which encapsulates a 6 * directory structure containing files in keyword - value pairs that specify 7 * energy and frequency configuration of the system. 8 * 9 * The format of exposing the sysfs information is as follows: 10 * /sys/firmware/papr/energy_scale_info/ 11 * |-- <id>/ 12 * |-- desc 13 * |-- value 14 * |-- value_desc (if exists) 15 * |-- <id>/ 16 * |-- desc 17 * |-- value 18 * |-- value_desc (if exists) 19 * 20 * Copyright 2022 IBM Corp. 21 */ 22 23 #include <asm/hvcall.h> 24 #include <asm/machdep.h> 25 26 #include "pseries.h" 27 28 /* 29 * Flag attributes to fetch either all or one attribute from the HCALL 30 * flag = BE(0) => fetch all attributes with firstAttributeId = 0 31 * flag = BE(1) => fetch a single attribute with firstAttributeId = id 32 */ 33 #define ESI_FLAGS_ALL 0 34 #define ESI_FLAGS_SINGLE (1ull << 63) 35 36 #define KOBJ_MAX_ATTRS 3 37 38 #define ESI_HDR_SIZE sizeof(struct h_energy_scale_info_hdr) 39 #define ESI_ATTR_SIZE sizeof(struct energy_scale_attribute) 40 #define CURR_MAX_ESI_ATTRS 8 41 42 struct energy_scale_attribute { 43 __be64 id; 44 __be64 val; 45 u8 desc[64]; 46 u8 value_desc[64]; 47 } __packed; 48 49 struct h_energy_scale_info_hdr { 50 __be64 num_attrs; 51 __be64 array_offset; 52 u8 data_header_version; 53 } __packed; 54 55 struct papr_attr { 56 u64 id; 57 struct kobj_attribute kobj_attr; 58 }; 59 60 struct papr_group { 61 struct attribute_group pg; 62 struct papr_attr pgattrs[KOBJ_MAX_ATTRS]; 63 }; 64 65 static struct papr_group *papr_groups; 66 /* /sys/firmware/papr */ 67 static struct kobject *papr_kobj; 68 /* /sys/firmware/papr/energy_scale_info */ 69 static struct kobject *esi_kobj; 70 71 /* 72 * Energy modes can change dynamically hence making a new hcall each time the 73 * information needs to be retrieved 74 */ 75 static int papr_get_attr(u64 id, struct energy_scale_attribute *esi) 76 { 77 int esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * ESI_ATTR_SIZE); 78 int ret, max_esi_attrs = CURR_MAX_ESI_ATTRS; 79 struct energy_scale_attribute *curr_esi; 80 struct h_energy_scale_info_hdr *hdr; 81 char *buf; 82 83 buf = kmalloc(esi_buf_size, GFP_KERNEL); 84 if (buf == NULL) 85 return -ENOMEM; 86 87 retry: 88 ret = plpar_hcall_norets(H_GET_ENERGY_SCALE_INFO, ESI_FLAGS_SINGLE, 89 id, virt_to_phys(buf), 90 esi_buf_size); 91 92 /* 93 * If the hcall fails with not enough memory for either the 94 * header or data, attempt to allocate more 95 */ 96 if (ret == H_PARTIAL || ret == H_P4) { 97 char *temp_buf; 98 99 max_esi_attrs += 4; 100 esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * max_esi_attrs); 101 102 temp_buf = krealloc(buf, esi_buf_size, GFP_KERNEL); 103 if (temp_buf) 104 buf = temp_buf; 105 else 106 return -ENOMEM; 107 108 goto retry; 109 } 110 111 if (ret != H_SUCCESS) { 112 pr_warn("hcall failed: H_GET_ENERGY_SCALE_INFO"); 113 ret = -EIO; 114 goto out_buf; 115 } 116 117 hdr = (struct h_energy_scale_info_hdr *) buf; 118 curr_esi = (struct energy_scale_attribute *) 119 (buf + be64_to_cpu(hdr->array_offset)); 120 121 if (esi_buf_size < 122 be64_to_cpu(hdr->array_offset) + (be64_to_cpu(hdr->num_attrs) 123 * sizeof(struct energy_scale_attribute))) { 124 ret = -EIO; 125 goto out_buf; 126 } 127 128 *esi = *curr_esi; 129 130 out_buf: 131 kfree(buf); 132 133 return ret; 134 } 135 136 /* 137 * Extract and export the description of the energy scale attributes 138 */ 139 static ssize_t desc_show(struct kobject *kobj, 140 struct kobj_attribute *kobj_attr, 141 char *buf) 142 { 143 struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr, 144 kobj_attr); 145 struct energy_scale_attribute esi; 146 int ret; 147 148 ret = papr_get_attr(pattr->id, &esi); 149 if (ret) 150 return ret; 151 152 return sysfs_emit(buf, "%s\n", esi.desc); 153 } 154 155 /* 156 * Extract and export the numeric value of the energy scale attributes 157 */ 158 static ssize_t val_show(struct kobject *kobj, 159 struct kobj_attribute *kobj_attr, 160 char *buf) 161 { 162 struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr, 163 kobj_attr); 164 struct energy_scale_attribute esi; 165 int ret; 166 167 ret = papr_get_attr(pattr->id, &esi); 168 if (ret) 169 return ret; 170 171 return sysfs_emit(buf, "%llu\n", be64_to_cpu(esi.val)); 172 } 173 174 /* 175 * Extract and export the value description in string format of the energy 176 * scale attributes 177 */ 178 static ssize_t val_desc_show(struct kobject *kobj, 179 struct kobj_attribute *kobj_attr, 180 char *buf) 181 { 182 struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr, 183 kobj_attr); 184 struct energy_scale_attribute esi; 185 int ret; 186 187 ret = papr_get_attr(pattr->id, &esi); 188 if (ret) 189 return ret; 190 191 return sysfs_emit(buf, "%s\n", esi.value_desc); 192 } 193 194 static struct papr_ops_info { 195 const char *attr_name; 196 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *kobj_attr, 197 char *buf); 198 } ops_info[KOBJ_MAX_ATTRS] = { 199 { "desc", desc_show }, 200 { "value", val_show }, 201 { "value_desc", val_desc_show }, 202 }; 203 204 static void add_attr(u64 id, int index, struct papr_attr *attr) 205 { 206 attr->id = id; 207 sysfs_attr_init(&attr->kobj_attr.attr); 208 attr->kobj_attr.attr.name = ops_info[index].attr_name; 209 attr->kobj_attr.attr.mode = 0444; 210 attr->kobj_attr.show = ops_info[index].show; 211 } 212 213 static int add_attr_group(u64 id, struct papr_group *pg, bool show_val_desc) 214 { 215 int i; 216 217 for (i = 0; i < KOBJ_MAX_ATTRS; i++) { 218 if (!strcmp(ops_info[i].attr_name, "value_desc") && 219 !show_val_desc) { 220 continue; 221 } 222 add_attr(id, i, &pg->pgattrs[i]); 223 pg->pg.attrs[i] = &pg->pgattrs[i].kobj_attr.attr; 224 } 225 226 return sysfs_create_group(esi_kobj, &pg->pg); 227 } 228 229 230 static int __init papr_init(void) 231 { 232 int esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * ESI_ATTR_SIZE); 233 int ret, idx, i, max_esi_attrs = CURR_MAX_ESI_ATTRS; 234 struct h_energy_scale_info_hdr *esi_hdr; 235 struct energy_scale_attribute *esi_attrs; 236 uint64_t num_attrs; 237 char *esi_buf; 238 239 if (!firmware_has_feature(FW_FEATURE_LPAR) || 240 !firmware_has_feature(FW_FEATURE_ENERGY_SCALE_INFO)) { 241 return -ENXIO; 242 } 243 244 esi_buf = kmalloc(esi_buf_size, GFP_KERNEL); 245 if (esi_buf == NULL) 246 return -ENOMEM; 247 /* 248 * hcall( 249 * uint64 H_GET_ENERGY_SCALE_INFO, // Get energy scale info 250 * uint64 flags, // Per the flag request 251 * uint64 firstAttributeId, // The attribute id 252 * uint64 bufferAddress, // Guest physical address of the output buffer 253 * uint64 bufferSize); // The size in bytes of the output buffer 254 */ 255 retry: 256 257 ret = plpar_hcall_norets(H_GET_ENERGY_SCALE_INFO, ESI_FLAGS_ALL, 0, 258 virt_to_phys(esi_buf), esi_buf_size); 259 260 /* 261 * If the hcall fails with not enough memory for either the 262 * header or data, attempt to allocate more 263 */ 264 if (ret == H_PARTIAL || ret == H_P4) { 265 char *temp_esi_buf; 266 267 max_esi_attrs += 4; 268 esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * max_esi_attrs); 269 270 temp_esi_buf = krealloc(esi_buf, esi_buf_size, GFP_KERNEL); 271 if (temp_esi_buf) 272 esi_buf = temp_esi_buf; 273 else 274 return -ENOMEM; 275 276 goto retry; 277 } 278 279 if (ret != H_SUCCESS) { 280 pr_warn("hcall failed: H_GET_ENERGY_SCALE_INFO, ret: %d\n", ret); 281 goto out_free_esi_buf; 282 } 283 284 esi_hdr = (struct h_energy_scale_info_hdr *) esi_buf; 285 num_attrs = be64_to_cpu(esi_hdr->num_attrs); 286 esi_attrs = (struct energy_scale_attribute *) 287 (esi_buf + be64_to_cpu(esi_hdr->array_offset)); 288 289 if (esi_buf_size < 290 be64_to_cpu(esi_hdr->array_offset) + 291 (num_attrs * sizeof(struct energy_scale_attribute))) { 292 goto out_free_esi_buf; 293 } 294 295 papr_groups = kcalloc(num_attrs, sizeof(*papr_groups), GFP_KERNEL); 296 if (!papr_groups) 297 goto out_free_esi_buf; 298 299 papr_kobj = kobject_create_and_add("papr", firmware_kobj); 300 if (!papr_kobj) { 301 pr_warn("kobject_create_and_add papr failed\n"); 302 goto out_papr_groups; 303 } 304 305 esi_kobj = kobject_create_and_add("energy_scale_info", papr_kobj); 306 if (!esi_kobj) { 307 pr_warn("kobject_create_and_add energy_scale_info failed\n"); 308 goto out_kobj; 309 } 310 311 /* Allocate the groups before registering */ 312 for (idx = 0; idx < num_attrs; idx++) { 313 papr_groups[idx].pg.attrs = kcalloc(KOBJ_MAX_ATTRS + 1, 314 sizeof(*papr_groups[idx].pg.attrs), 315 GFP_KERNEL); 316 if (!papr_groups[idx].pg.attrs) 317 goto out_pgattrs; 318 319 papr_groups[idx].pg.name = kasprintf(GFP_KERNEL, "%lld", 320 be64_to_cpu(esi_attrs[idx].id)); 321 if (papr_groups[idx].pg.name == NULL) 322 goto out_pgattrs; 323 } 324 325 for (idx = 0; idx < num_attrs; idx++) { 326 bool show_val_desc = true; 327 328 /* Do not add the value desc attr if it does not exist */ 329 if (strnlen(esi_attrs[idx].value_desc, 330 sizeof(esi_attrs[idx].value_desc)) == 0) 331 show_val_desc = false; 332 333 if (add_attr_group(be64_to_cpu(esi_attrs[idx].id), 334 &papr_groups[idx], 335 show_val_desc)) { 336 pr_warn("Failed to create papr attribute group %s\n", 337 papr_groups[idx].pg.name); 338 idx = num_attrs; 339 goto out_pgattrs; 340 } 341 } 342 343 kfree(esi_buf); 344 return 0; 345 out_pgattrs: 346 for (i = 0; i < idx ; i++) { 347 kfree(papr_groups[i].pg.attrs); 348 kfree(papr_groups[i].pg.name); 349 } 350 kobject_put(esi_kobj); 351 out_kobj: 352 kobject_put(papr_kobj); 353 out_papr_groups: 354 kfree(papr_groups); 355 out_free_esi_buf: 356 kfree(esi_buf); 357 358 return -ENOMEM; 359 } 360 361 machine_device_initcall(pseries, papr_init); 362