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