common.c

   1// SPDX-License-Identifier: GPL-2.0+
   2// Copyright IBM Corp 2019
   3
   4#include <linux/device.h>
   5#include <linux/export.h>
   6#include <linux/hwmon.h>
   7#include <linux/hwmon-sysfs.h>
   8#include <linux/jiffies.h>
   9#include <linux/kernel.h>
  10#include <linux/math64.h>
  11#include <linux/module.h>
  12#include <linux/mutex.h>
  13#include <linux/property.h>
  14#include <linux/sysfs.h>
  15#include <linux/unaligned.h>
  16
  17#include "common.h"
  18
  19#define EXTN_FLAG_SENSOR_ID		BIT(7)
  20
  21#define OCC_ERROR_COUNT_THRESHOLD	2	/* required by OCC spec */
  22
  23#define OCC_STATE_SAFE			4
  24#define OCC_SAFE_TIMEOUT		msecs_to_jiffies(60000) /* 1 min */
  25
  26#define OCC_UPDATE_FREQUENCY		msecs_to_jiffies(1000)
  27
  28#define OCC_TEMP_SENSOR_FAULT		0xFF
  29
  30#define OCC_FRU_TYPE_VRM		3
  31
  32/* OCC sensor type and version definitions */
  33
  34struct temp_sensor_1 {
  35	u16 sensor_id;
  36	u16 value;
  37} __packed;
  38
  39struct temp_sensor_2 {
  40	u32 sensor_id;
  41	u8 fru_type;
  42	u8 value;
  43} __packed;
  44
  45struct temp_sensor_10 {
  46	u32 sensor_id;
  47	u8 fru_type;
  48	u8 value;
  49	u8 throttle;
  50	u8 reserved;
  51} __packed;
  52
  53struct freq_sensor_1 {
  54	u16 sensor_id;
  55	u16 value;
  56} __packed;
  57
  58struct freq_sensor_2 {
  59	u32 sensor_id;
  60	u16 value;
  61} __packed;
  62
  63struct power_sensor_1 {
  64	u16 sensor_id;
  65	u32 update_tag;
  66	u32 accumulator;
  67	u16 value;
  68} __packed;
  69
  70struct power_sensor_2 {
  71	u32 sensor_id;
  72	u8 function_id;
  73	u8 apss_channel;
  74	u16 reserved;
  75	u32 update_tag;
  76	u64 accumulator;
  77	u16 value;
  78} __packed;
  79
  80struct power_sensor_data {
  81	u16 value;
  82	u32 update_tag;
  83	u64 accumulator;
  84} __packed;
  85
  86struct power_sensor_data_and_time {
  87	u16 update_time;
  88	u16 value;
  89	u32 update_tag;
  90	u64 accumulator;
  91} __packed;
  92
  93struct power_sensor_a0 {
  94	u32 sensor_id;
  95	struct power_sensor_data_and_time system;
  96	u32 reserved;
  97	struct power_sensor_data_and_time proc;
  98	struct power_sensor_data vdd;
  99	struct power_sensor_data vdn;
 100} __packed;
 101
 102struct caps_sensor_2 {
 103	u16 cap;
 104	u16 system_power;
 105	u16 n_cap;
 106	u16 max;
 107	u16 min;
 108	u16 user;
 109	u8 user_source;
 110} __packed;
 111
 112struct caps_sensor_3 {
 113	u16 cap;
 114	u16 system_power;
 115	u16 n_cap;
 116	u16 max;
 117	u16 hard_min;
 118	u16 soft_min;
 119	u16 user;
 120	u8 user_source;
 121} __packed;
 122
 123struct extended_sensor {
 124	union {
 125		u8 name[4];
 126		u32 sensor_id;
 127	};
 128	u8 flags;
 129	u8 reserved;
 130	u8 data[6];
 131} __packed;
 132
 133static int occ_poll(struct occ *occ)
 134{
 135	int rc;
 136	u8 cmd[7];
 137	struct occ_poll_response_header *header;
 138
 139	/* big endian */
 140	cmd[0] = 0;			/* sequence number */
 141	cmd[1] = 0;			/* cmd type */
 142	cmd[2] = 0;			/* data length msb */
 143	cmd[3] = 1;			/* data length lsb */
 144	cmd[4] = occ->poll_cmd_data;	/* data */
 145	cmd[5] = 0;			/* checksum msb */
 146	cmd[6] = 0;			/* checksum lsb */
 147
 148	/* mutex should already be locked if necessary */
 149	rc = occ->send_cmd(occ, cmd, sizeof(cmd), &occ->resp, sizeof(occ->resp));
 150	if (rc) {
 151		occ->last_error = rc;
 152		if (occ->error_count++ > OCC_ERROR_COUNT_THRESHOLD)
 153			occ->error = rc;
 154
 155		goto done;
 156	}
 157
 158	/* clear error since communication was successful */
 159	occ->error_count = 0;
 160	occ->last_error = 0;
 161	occ->error = 0;
 162
 163	/* check for safe state */
 164	header = (struct occ_poll_response_header *)occ->resp.data;
 165	if (header->occ_state == OCC_STATE_SAFE) {
 166		if (occ->last_safe) {
 167			if (time_after(jiffies,
 168				       occ->last_safe + OCC_SAFE_TIMEOUT))
 169				occ->error = -EHOSTDOWN;
 170		} else {
 171			occ->last_safe = jiffies;
 172		}
 173	} else {
 174		occ->last_safe = 0;
 175	}
 176
 177done:
 178	occ_sysfs_poll_done(occ);
 179	return rc;
 180}
 181
 182static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap)
 183{
 184	int rc;
 185	u8 cmd[8];
 186	u8 resp[8];
 187	__be16 user_power_cap_be = cpu_to_be16(user_power_cap);
 188
 189	cmd[0] = 0;	/* sequence number */
 190	cmd[1] = 0x22;	/* cmd type */
 191	cmd[2] = 0;	/* data length msb */
 192	cmd[3] = 2;	/* data length lsb */
 193
 194	memcpy(&cmd[4], &user_power_cap_be, 2);
 195
 196	cmd[6] = 0;	/* checksum msb */
 197	cmd[7] = 0;	/* checksum lsb */
 198
 199	rc = mutex_lock_interruptible(&occ->lock);
 200	if (rc)
 201		return rc;
 202
 203	rc = occ->send_cmd(occ, cmd, sizeof(cmd), resp, sizeof(resp));
 204
 205	mutex_unlock(&occ->lock);
 206
 207	return rc;
 208}
 209
 210int occ_update_response(struct occ *occ)
 211{
 212	int rc = mutex_lock_interruptible(&occ->lock);
 213
 214	if (rc)
 215		return rc;
 216
 217	/* limit the maximum rate of polling the OCC */
 218	if (time_after(jiffies, occ->next_update)) {
 219		rc = occ_poll(occ);
 220		occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
 221	} else {
 222		rc = occ->last_error;
 223	}
 224
 225	mutex_unlock(&occ->lock);
 226	return rc;
 227}
 228
 229static ssize_t occ_show_temp_1(struct device *dev,
 230			       struct device_attribute *attr, char *buf)
 231{
 232	int rc;
 233	u32 val = 0;
 234	struct temp_sensor_1 *temp;
 235	struct occ *occ = dev_get_drvdata(dev);
 236	struct occ_sensors *sensors = &occ->sensors;
 237	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 238
 239	rc = occ_update_response(occ);
 240	if (rc)
 241		return rc;
 242
 243	temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;
 244
 245	switch (sattr->nr) {
 246	case 0:
 247		val = get_unaligned_be16(&temp->sensor_id);
 248		break;
 249	case 1:
 250		/*
 251		 * If a sensor reading has expired and couldn't be refreshed,
 252		 * OCC returns 0xFFFF for that sensor.
 253		 */
 254		if (temp->value == 0xFFFF)
 255			return -EREMOTEIO;
 256		val = get_unaligned_be16(&temp->value) * 1000;
 257		break;
 258	default:
 259		return -EINVAL;
 260	}
 261
 262	return sysfs_emit(buf, "%u\n", val);
 263}
 264
 265static ssize_t occ_show_temp_2(struct device *dev,
 266			       struct device_attribute *attr, char *buf)
 267{
 268	int rc;
 269	u32 val = 0;
 270	struct temp_sensor_2 *temp;
 271	struct occ *occ = dev_get_drvdata(dev);
 272	struct occ_sensors *sensors = &occ->sensors;
 273	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 274
 275	rc = occ_update_response(occ);
 276	if (rc)
 277		return rc;
 278
 279	temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;
 280
 281	switch (sattr->nr) {
 282	case 0:
 283		val = get_unaligned_be32(&temp->sensor_id);
 284		break;
 285	case 1:
 286		val = temp->value;
 287		if (val == OCC_TEMP_SENSOR_FAULT)
 288			return -EREMOTEIO;
 289
 290		/*
 291		 * VRM doesn't return temperature, only alarm bit. This
 292		 * attribute maps to tempX_alarm instead of tempX_input for
 293		 * VRM
 294		 */
 295		if (temp->fru_type != OCC_FRU_TYPE_VRM) {
 296			/* sensor not ready */
 297			if (val == 0)
 298				return -EAGAIN;
 299
 300			val *= 1000;
 301		}
 302		break;
 303	case 2:
 304		val = temp->fru_type;
 305		break;
 306	case 3:
 307		val = temp->value == OCC_TEMP_SENSOR_FAULT;
 308		break;
 309	default:
 310		return -EINVAL;
 311	}
 312
 313	return sysfs_emit(buf, "%u\n", val);
 314}
 315
 316static ssize_t occ_show_temp_10(struct device *dev,
 317				struct device_attribute *attr, char *buf)
 318{
 319	int rc;
 320	u32 val = 0;
 321	struct temp_sensor_10 *temp;
 322	struct occ *occ = dev_get_drvdata(dev);
 323	struct occ_sensors *sensors = &occ->sensors;
 324	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 325
 326	rc = occ_update_response(occ);
 327	if (rc)
 328		return rc;
 329
 330	temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index;
 331
 332	switch (sattr->nr) {
 333	case 0:
 334		val = get_unaligned_be32(&temp->sensor_id);
 335		break;
 336	case 1:
 337		val = temp->value;
 338		if (val == OCC_TEMP_SENSOR_FAULT)
 339			return -EREMOTEIO;
 340
 341		/* sensor not ready */
 342		if (val == 0)
 343			return -EAGAIN;
 344
 345		val *= 1000;
 346		break;
 347	case 2:
 348		val = temp->fru_type;
 349		break;
 350	case 3:
 351		val = temp->value == OCC_TEMP_SENSOR_FAULT;
 352		break;
 353	case 4:
 354		val = temp->throttle * 1000;
 355		break;
 356	default:
 357		return -EINVAL;
 358	}
 359
 360	return sysfs_emit(buf, "%u\n", val);
 361}
 362
 363static ssize_t occ_show_freq_1(struct device *dev,
 364			       struct device_attribute *attr, char *buf)
 365{
 366	int rc;
 367	u16 val = 0;
 368	struct freq_sensor_1 *freq;
 369	struct occ *occ = dev_get_drvdata(dev);
 370	struct occ_sensors *sensors = &occ->sensors;
 371	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 372
 373	rc = occ_update_response(occ);
 374	if (rc)
 375		return rc;
 376
 377	freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;
 378
 379	switch (sattr->nr) {
 380	case 0:
 381		val = get_unaligned_be16(&freq->sensor_id);
 382		break;
 383	case 1:
 384		val = get_unaligned_be16(&freq->value);
 385		break;
 386	default:
 387		return -EINVAL;
 388	}
 389
 390	return sysfs_emit(buf, "%u\n", val);
 391}
 392
 393static ssize_t occ_show_freq_2(struct device *dev,
 394			       struct device_attribute *attr, char *buf)
 395{
 396	int rc;
 397	u32 val = 0;
 398	struct freq_sensor_2 *freq;
 399	struct occ *occ = dev_get_drvdata(dev);
 400	struct occ_sensors *sensors = &occ->sensors;
 401	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 402
 403	rc = occ_update_response(occ);
 404	if (rc)
 405		return rc;
 406
 407	freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;
 408
 409	switch (sattr->nr) {
 410	case 0:
 411		val = get_unaligned_be32(&freq->sensor_id);
 412		break;
 413	case 1:
 414		val = get_unaligned_be16(&freq->value);
 415		break;
 416	default:
 417		return -EINVAL;
 418	}
 419
 420	return sysfs_emit(buf, "%u\n", val);
 421}
 422
 423static u64 occ_get_powr_avg(u64 accum, u32 samples)
 424{
 425	return (samples == 0) ? 0 :
 426		mul_u64_u32_div(accum, 1000000UL, samples);
 427}
 428
 429static ssize_t occ_show_power_1(struct device *dev,
 430				struct device_attribute *attr, char *buf)
 431{
 432	int rc;
 433	u64 val = 0;
 434	struct power_sensor_1 *power;
 435	struct occ *occ = dev_get_drvdata(dev);
 436	struct occ_sensors *sensors = &occ->sensors;
 437	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 438
 439	rc = occ_update_response(occ);
 440	if (rc)
 441		return rc;
 442
 443	power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;
 444
 445	switch (sattr->nr) {
 446	case 0:
 447		val = get_unaligned_be16(&power->sensor_id);
 448		break;
 449	case 1:
 450		val = occ_get_powr_avg(get_unaligned_be32(&power->accumulator),
 451				       get_unaligned_be32(&power->update_tag));
 452		break;
 453	case 2:
 454		val = (u64)get_unaligned_be32(&power->update_tag) *
 455			   occ->powr_sample_time_us;
 456		break;
 457	case 3:
 458		val = get_unaligned_be16(&power->value) * 1000000ULL;
 459		break;
 460	default:
 461		return -EINVAL;
 462	}
 463
 464	return sysfs_emit(buf, "%llu\n", val);
 465}
 466
 467static ssize_t occ_show_power_2(struct device *dev,
 468				struct device_attribute *attr, char *buf)
 469{
 470	int rc;
 471	u64 val = 0;
 472	struct power_sensor_2 *power;
 473	struct occ *occ = dev_get_drvdata(dev);
 474	struct occ_sensors *sensors = &occ->sensors;
 475	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 476
 477	rc = occ_update_response(occ);
 478	if (rc)
 479		return rc;
 480
 481	power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;
 482
 483	switch (sattr->nr) {
 484	case 0:
 485		return sysfs_emit(buf, "%u_%u_%u\n",
 486				  get_unaligned_be32(&power->sensor_id),
 487				  power->function_id, power->apss_channel);
 488	case 1:
 489		val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator),
 490				       get_unaligned_be32(&power->update_tag));
 491		break;
 492	case 2:
 493		val = (u64)get_unaligned_be32(&power->update_tag) *
 494			   occ->powr_sample_time_us;
 495		break;
 496	case 3:
 497		val = get_unaligned_be16(&power->value) * 1000000ULL;
 498		break;
 499	default:
 500		return -EINVAL;
 501	}
 502
 503	return sysfs_emit(buf, "%llu\n", val);
 504}
 505
 506static ssize_t occ_show_power_a0(struct device *dev,
 507				 struct device_attribute *attr, char *buf)
 508{
 509	int rc;
 510	u64 val = 0;
 511	struct power_sensor_a0 *power;
 512	struct occ *occ = dev_get_drvdata(dev);
 513	struct occ_sensors *sensors = &occ->sensors;
 514	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 515
 516	rc = occ_update_response(occ);
 517	if (rc)
 518		return rc;
 519
 520	power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;
 521
 522	switch (sattr->nr) {
 523	case 0:
 524		return sysfs_emit(buf, "%u_system\n",
 525				  get_unaligned_be32(&power->sensor_id));
 526	case 1:
 527		val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator),
 528				       get_unaligned_be32(&power->system.update_tag));
 529		break;
 530	case 2:
 531		val = (u64)get_unaligned_be32(&power->system.update_tag) *
 532			   occ->powr_sample_time_us;
 533		break;
 534	case 3:
 535		val = get_unaligned_be16(&power->system.value) * 1000000ULL;
 536		break;
 537	case 4:
 538		return sysfs_emit(buf, "%u_proc\n",
 539				  get_unaligned_be32(&power->sensor_id));
 540	case 5:
 541		val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator),
 542				       get_unaligned_be32(&power->proc.update_tag));
 543		break;
 544	case 6:
 545		val = (u64)get_unaligned_be32(&power->proc.update_tag) *
 546			   occ->powr_sample_time_us;
 547		break;
 548	case 7:
 549		val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
 550		break;
 551	case 8:
 552		return sysfs_emit(buf, "%u_vdd\n",
 553				  get_unaligned_be32(&power->sensor_id));
 554	case 9:
 555		val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator),
 556				       get_unaligned_be32(&power->vdd.update_tag));
 557		break;
 558	case 10:
 559		val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
 560			   occ->powr_sample_time_us;
 561		break;
 562	case 11:
 563		val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
 564		break;
 565	case 12:
 566		return sysfs_emit(buf, "%u_vdn\n",
 567				  get_unaligned_be32(&power->sensor_id));
 568	case 13:
 569		val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator),
 570				       get_unaligned_be32(&power->vdn.update_tag));
 571		break;
 572	case 14:
 573		val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
 574			   occ->powr_sample_time_us;
 575		break;
 576	case 15:
 577		val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
 578		break;
 579	default:
 580		return -EINVAL;
 581	}
 582
 583	return sysfs_emit(buf, "%llu\n", val);
 584}
 585
 586static ssize_t occ_show_caps_1_2(struct device *dev,
 587				 struct device_attribute *attr, char *buf)
 588{
 589	int rc;
 590	u64 val = 0;
 591	struct caps_sensor_2 *caps;
 592	struct occ *occ = dev_get_drvdata(dev);
 593	struct occ_sensors *sensors = &occ->sensors;
 594	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 595
 596	rc = occ_update_response(occ);
 597	if (rc)
 598		return rc;
 599
 600	caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;
 601
 602	switch (sattr->nr) {
 603	case 0:
 604		return sysfs_emit(buf, "system\n");
 605	case 1:
 606		val = get_unaligned_be16(&caps->cap) * 1000000ULL;
 607		break;
 608	case 2:
 609		val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
 610		break;
 611	case 3:
 612		val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
 613		break;
 614	case 4:
 615		val = get_unaligned_be16(&caps->max) * 1000000ULL;
 616		break;
 617	case 5:
 618		val = get_unaligned_be16(&caps->min) * 1000000ULL;
 619		break;
 620	case 6:
 621		val = get_unaligned_be16(&caps->user) * 1000000ULL;
 622		break;
 623	case 7:
 624		if (occ->sensors.caps.version == 1)
 625			return -EINVAL;
 626
 627		val = caps->user_source;
 628		break;
 629	default:
 630		return -EINVAL;
 631	}
 632
 633	return sysfs_emit(buf, "%llu\n", val);
 634}
 635
 636static ssize_t occ_show_caps_3(struct device *dev,
 637			       struct device_attribute *attr, char *buf)
 638{
 639	int rc;
 640	u64 val = 0;
 641	struct caps_sensor_3 *caps;
 642	struct occ *occ = dev_get_drvdata(dev);
 643	struct occ_sensors *sensors = &occ->sensors;
 644	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 645
 646	rc = occ_update_response(occ);
 647	if (rc)
 648		return rc;
 649
 650	caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;
 651
 652	switch (sattr->nr) {
 653	case 0:
 654		return sysfs_emit(buf, "system\n");
 655	case 1:
 656		val = get_unaligned_be16(&caps->cap) * 1000000ULL;
 657		break;
 658	case 2:
 659		val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
 660		break;
 661	case 3:
 662		val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
 663		break;
 664	case 4:
 665		val = get_unaligned_be16(&caps->max) * 1000000ULL;
 666		break;
 667	case 5:
 668		val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;
 669		break;
 670	case 6:
 671		val = get_unaligned_be16(&caps->user) * 1000000ULL;
 672		break;
 673	case 7:
 674		val = caps->user_source;
 675		break;
 676	case 8:
 677		val = get_unaligned_be16(&caps->soft_min) * 1000000ULL;
 678		break;
 679	default:
 680		return -EINVAL;
 681	}
 682
 683	return sysfs_emit(buf, "%llu\n", val);
 684}
 685
 686static ssize_t occ_store_caps_user(struct device *dev,
 687				   struct device_attribute *attr,
 688				   const char *buf, size_t count)
 689{
 690	int rc;
 691	u16 user_power_cap;
 692	unsigned long long value;
 693	struct occ *occ = dev_get_drvdata(dev);
 694
 695	rc = kstrtoull(buf, 0, &value);
 696	if (rc)
 697		return rc;
 698
 699	user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */
 700
 701	rc = occ_set_user_power_cap(occ, user_power_cap);
 702	if (rc)
 703		return rc;
 704
 705	return count;
 706}
 707
 708static ssize_t occ_show_extended(struct device *dev,
 709				 struct device_attribute *attr, char *buf)
 710{
 711	int rc;
 712	struct extended_sensor *extn;
 713	struct occ *occ = dev_get_drvdata(dev);
 714	struct occ_sensors *sensors = &occ->sensors;
 715	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 716
 717	rc = occ_update_response(occ);
 718	if (rc)
 719		return rc;
 720
 721	extn = ((struct extended_sensor *)sensors->extended.data) +
 722		sattr->index;
 723
 724	switch (sattr->nr) {
 725	case 0:
 726		if (extn->flags & EXTN_FLAG_SENSOR_ID) {
 727			rc = sysfs_emit(buf, "%u\n",
 728					get_unaligned_be32(&extn->sensor_id));
 729		} else {
 730			rc = sysfs_emit(buf, "%4phN\n", extn->name);
 731		}
 732		break;
 733	case 1:
 734		rc = sysfs_emit(buf, "%02x\n", extn->flags);
 735		break;
 736	case 2:
 737		rc = sysfs_emit(buf, "%6phN\n", extn->data);
 738		break;
 739	default:
 740		return -EINVAL;
 741	}
 742
 743	return rc;
 744}
 745
 746/*
 747 * A helper to make it easier to define an occ_attribute. Since these
 748 * are dynamically allocated, we cannot use the existing kernel macros which
 749 * stringify the name argument.
 750 */
 751__printf(7, 8)
 752static void occ_init_attribute(struct occ_attribute *attr, int mode,
 753	ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf),
 754	ssize_t (*store)(struct device *dev, struct device_attribute *attr,
 755				   const char *buf, size_t count),
 756	int nr, int index, const char *fmt, ...)
 757{
 758	va_list args;
 759
 760	va_start(args, fmt);
 761	vsnprintf(attr->name, sizeof(attr->name), fmt, args);
 762	va_end(args);
 763
 764	attr->sensor.dev_attr.attr.name = attr->name;
 765	attr->sensor.dev_attr.attr.mode = mode;
 766	attr->sensor.dev_attr.show = show;
 767	attr->sensor.dev_attr.store = store;
 768	attr->sensor.index = index;
 769	attr->sensor.nr = nr;
 770}
 771
 772/*
 773 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
 774 * use our own instead of the built-in hwmon attribute types.
 775 */
 776static int occ_setup_sensor_attrs(struct occ *occ)
 777{
 778	unsigned int i, s, num_attrs = 0;
 779	struct device *dev = occ->bus_dev;
 780	struct occ_sensors *sensors = &occ->sensors;
 781	struct occ_attribute *attr;
 782	struct temp_sensor_2 *temp;
 783	ssize_t (*show_temp)(struct device *, struct device_attribute *,
 784			     char *) = occ_show_temp_1;
 785	ssize_t (*show_freq)(struct device *, struct device_attribute *,
 786			     char *) = occ_show_freq_1;
 787	ssize_t (*show_power)(struct device *, struct device_attribute *,
 788			      char *) = occ_show_power_1;
 789	ssize_t (*show_caps)(struct device *, struct device_attribute *,
 790			     char *) = occ_show_caps_1_2;
 791
 792	switch (sensors->temp.version) {
 793	case 1:
 794		num_attrs += (sensors->temp.num_sensors * 2);
 795		break;
 796	case 2:
 797		num_attrs += (sensors->temp.num_sensors * 4);
 798		show_temp = occ_show_temp_2;
 799		break;
 800	case 0x10:
 801		num_attrs += (sensors->temp.num_sensors * 5);
 802		show_temp = occ_show_temp_10;
 803		break;
 804	default:
 805		sensors->temp.num_sensors = 0;
 806	}
 807
 808	switch (sensors->freq.version) {
 809	case 2:
 810		show_freq = occ_show_freq_2;
 811		fallthrough;
 812	case 1:
 813		num_attrs += (sensors->freq.num_sensors * 2);
 814		break;
 815	default:
 816		sensors->freq.num_sensors = 0;
 817	}
 818
 819	switch (sensors->power.version) {
 820	case 2:
 821		show_power = occ_show_power_2;
 822		fallthrough;
 823	case 1:
 824		num_attrs += (sensors->power.num_sensors * 4);
 825		break;
 826	case 0xA0:
 827		num_attrs += (sensors->power.num_sensors * 16);
 828		show_power = occ_show_power_a0;
 829		break;
 830	default:
 831		sensors->power.num_sensors = 0;
 832	}
 833
 834	switch (sensors->caps.version) {
 835	case 1:
 836		num_attrs += (sensors->caps.num_sensors * 7);
 837		break;
 838	case 2:
 839		num_attrs += (sensors->caps.num_sensors * 8);
 840		break;
 841	case 3:
 842		show_caps = occ_show_caps_3;
 843		num_attrs += (sensors->caps.num_sensors * 9);
 844		break;
 845	default:
 846		sensors->caps.num_sensors = 0;
 847	}
 848
 849	switch (sensors->extended.version) {
 850	case 1:
 851		num_attrs += (sensors->extended.num_sensors * 3);
 852		break;
 853	default:
 854		sensors->extended.num_sensors = 0;
 855	}
 856
 857	occ->attrs = devm_kcalloc(dev, num_attrs, sizeof(*occ->attrs),
 858				  GFP_KERNEL);
 859	if (!occ->attrs)
 860		return -ENOMEM;
 861
 862	/* null-terminated list */
 863	occ->group.attrs = devm_kcalloc(dev, num_attrs + 1,
 864					sizeof(*occ->group.attrs),
 865					GFP_KERNEL);
 866	if (!occ->group.attrs)
 867		return -ENOMEM;
 868
 869	attr = occ->attrs;
 870
 871	for (i = 0; i < sensors->temp.num_sensors; ++i) {
 872		s = i + 1;
 873		temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
 874
 875		occ_init_attribute(attr, 0444, show_temp, NULL,
 876				   0, i, "temp%d_label", s);
 877		attr++;
 878
 879		if (sensors->temp.version == 2 &&
 880		    temp->fru_type == OCC_FRU_TYPE_VRM) {
 881			occ_init_attribute(attr, 0444, show_temp, NULL,
 882					   1, i, "temp%d_alarm", s);
 883		} else {
 884			occ_init_attribute(attr, 0444, show_temp, NULL,
 885					   1, i, "temp%d_input", s);
 886		}
 887
 888		attr++;
 889
 890		if (sensors->temp.version > 1) {
 891			occ_init_attribute(attr, 0444, show_temp, NULL,
 892					   2, i, "temp%d_fru_type", s);
 893			attr++;
 894
 895			occ_init_attribute(attr, 0444, show_temp, NULL,
 896					   3, i, "temp%d_fault", s);
 897			attr++;
 898
 899			if (sensors->temp.version == 0x10) {
 900				occ_init_attribute(attr, 0444, show_temp, NULL,
 901						   4, i, "temp%d_max", s);
 902				attr++;
 903			}
 904		}
 905	}
 906
 907	for (i = 0; i < sensors->freq.num_sensors; ++i) {
 908		s = i + 1;
 909
 910		occ_init_attribute(attr, 0444, show_freq, NULL,
 911				   0, i, "freq%d_label", s);
 912		attr++;
 913
 914		occ_init_attribute(attr, 0444, show_freq, NULL,
 915				   1, i, "freq%d_input", s);
 916		attr++;
 917	}
 918
 919	if (sensors->power.version == 0xA0) {
 920		/*
 921		 * Special case for many-attribute power sensor. Split it into
 922		 * a sensor number per power type, emulating several sensors.
 923		 */
 924		for (i = 0; i < sensors->power.num_sensors; ++i) {
 925			unsigned int j;
 926			unsigned int nr = 0;
 927
 928			s = (i * 4) + 1;
 929
 930			for (j = 0; j < 4; ++j) {
 931				occ_init_attribute(attr, 0444, show_power,
 932						   NULL, nr++, i,
 933						   "power%d_label", s);
 934				attr++;
 935
 936				occ_init_attribute(attr, 0444, show_power,
 937						   NULL, nr++, i,
 938						   "power%d_average", s);
 939				attr++;
 940
 941				occ_init_attribute(attr, 0444, show_power,
 942						   NULL, nr++, i,
 943						   "power%d_average_interval", s);
 944				attr++;
 945
 946				occ_init_attribute(attr, 0444, show_power,
 947						   NULL, nr++, i,
 948						   "power%d_input", s);
 949				attr++;
 950
 951				s++;
 952			}
 953		}
 954
 955		s = (sensors->power.num_sensors * 4) + 1;
 956	} else {
 957		for (i = 0; i < sensors->power.num_sensors; ++i) {
 958			s = i + 1;
 959
 960			occ_init_attribute(attr, 0444, show_power, NULL,
 961					   0, i, "power%d_label", s);
 962			attr++;
 963
 964			occ_init_attribute(attr, 0444, show_power, NULL,
 965					   1, i, "power%d_average", s);
 966			attr++;
 967
 968			occ_init_attribute(attr, 0444, show_power, NULL,
 969					   2, i, "power%d_average_interval", s);
 970			attr++;
 971
 972			occ_init_attribute(attr, 0444, show_power, NULL,
 973					   3, i, "power%d_input", s);
 974			attr++;
 975		}
 976
 977		s = sensors->power.num_sensors + 1;
 978	}
 979
 980	if (sensors->caps.num_sensors >= 1) {
 981		occ_init_attribute(attr, 0444, show_caps, NULL,
 982				   0, 0, "power%d_label", s);
 983		attr++;
 984
 985		occ_init_attribute(attr, 0444, show_caps, NULL,
 986				   1, 0, "power%d_cap", s);
 987		attr++;
 988
 989		occ_init_attribute(attr, 0444, show_caps, NULL,
 990				   2, 0, "power%d_input", s);
 991		attr++;
 992
 993		occ_init_attribute(attr, 0444, show_caps, NULL,
 994				   3, 0, "power%d_cap_not_redundant", s);
 995		attr++;
 996
 997		occ_init_attribute(attr, 0444, show_caps, NULL,
 998				   4, 0, "power%d_cap_max", s);
 999		attr++;
1000
1001		occ_init_attribute(attr, 0444, show_caps, NULL,
1002				   5, 0, "power%d_cap_min", s);
1003		attr++;
1004
1005		occ_init_attribute(attr, 0644, show_caps, occ_store_caps_user,
1006				   6, 0, "power%d_cap_user", s);
1007		attr++;
1008
1009		if (sensors->caps.version > 1) {
1010			occ_init_attribute(attr, 0444, show_caps, NULL,
1011					   7, 0, "power%d_cap_user_source", s);
1012			attr++;
1013
1014			if (sensors->caps.version > 2) {
1015				occ_init_attribute(attr, 0444, show_caps, NULL,
1016						   8, 0,
1017						   "power%d_cap_min_soft", s);
1018				attr++;
1019			}
1020		}
1021	}
1022
1023	for (i = 0; i < sensors->extended.num_sensors; ++i) {
1024		s = i + 1;
1025
1026		occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1027				   0, i, "extn%d_label", s);
1028		attr++;
1029
1030		occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1031				   1, i, "extn%d_flags", s);
1032		attr++;
1033
1034		occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1035				   2, i, "extn%d_input", s);
1036		attr++;
1037	}
1038
1039	/* put the sensors in the group */
1040	for (i = 0; i < num_attrs; ++i) {
1041		sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr);
1042		occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr;
1043	}
1044
1045	return 0;
1046}
1047
1048/* only need to do this once at startup, as OCC won't change sensors on us */
1049static void occ_parse_poll_response(struct occ *occ)
1050{
1051	unsigned int i, old_offset, offset = 0, size = 0;
1052	struct occ_sensor *sensor;
1053	struct occ_sensors *sensors = &occ->sensors;
1054	struct occ_response *resp = &occ->resp;
1055	struct occ_poll_response *poll =
1056		(struct occ_poll_response *)&resp->data[0];
1057	struct occ_poll_response_header *header = &poll->header;
1058	struct occ_sensor_data_block *block = &poll->block;
1059
1060	dev_info(occ->bus_dev, "OCC found, code level: %.16s\n",
1061		 header->occ_code_level);
1062
1063	for (i = 0; i < header->num_sensor_data_blocks; ++i) {
1064		block = (struct occ_sensor_data_block *)((u8 *)block + offset);
1065		old_offset = offset;
1066		offset = (block->header.num_sensors *
1067			  block->header.sensor_length) + sizeof(block->header);
1068		size += offset;
1069
1070		/* validate all the length/size fields */
1071		if ((size + sizeof(*header)) >= OCC_RESP_DATA_BYTES) {
1072			dev_warn(occ->bus_dev, "exceeded response buffer\n");
1073			return;
1074		}
1075
1076		dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n",
1077			old_offset, offset - 1, block->header.eye_catcher,
1078			block->header.num_sensors);
1079
1080		/* match sensor block type */
1081		if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0)
1082			sensor = &sensors->temp;
1083		else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0)
1084			sensor = &sensors->freq;
1085		else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0)
1086			sensor = &sensors->power;
1087		else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0)
1088			sensor = &sensors->caps;
1089		else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0)
1090			sensor = &sensors->extended;
1091		else {
1092			dev_warn(occ->bus_dev, "sensor not supported %.4s\n",
1093				 block->header.eye_catcher);
1094			continue;
1095		}
1096
1097		sensor->num_sensors = block->header.num_sensors;
1098		sensor->version = block->header.sensor_format;
1099		sensor->data = &block->data;
1100	}
1101
1102	dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size,
1103		sizeof(*header), size + sizeof(*header));
1104}
1105
1106int occ_active(struct occ *occ, bool active)
1107{
1108	int rc = mutex_lock_interruptible(&occ->lock);
1109
1110	if (rc)
1111		return rc;
1112
1113	if (active) {
1114		if (occ->active) {
1115			rc = -EALREADY;
1116			goto unlock;
1117		}
1118
1119		occ->error_count = 0;
1120		occ->last_safe = 0;
1121
1122		rc = occ_poll(occ);
1123		if (rc < 0) {
1124			dev_err(occ->bus_dev,
1125				"failed to get OCC poll response=%02x: %d\n",
1126				occ->resp.return_status, rc);
1127			goto unlock;
1128		}
1129
1130		occ->active = true;
1131		occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
1132		occ_parse_poll_response(occ);
1133
1134		rc = occ_setup_sensor_attrs(occ);
1135		if (rc) {
1136			dev_err(occ->bus_dev,
1137				"failed to setup sensor attrs: %d\n", rc);
1138			goto unlock;
1139		}
1140
1141		occ->hwmon = hwmon_device_register_with_groups(occ->bus_dev,
1142							       "occ", occ,
1143							       occ->groups);
1144		if (IS_ERR(occ->hwmon)) {
1145			rc = PTR_ERR(occ->hwmon);
1146			occ->hwmon = NULL;
1147			dev_err(occ->bus_dev,
1148				"failed to register hwmon device: %d\n", rc);
1149			goto unlock;
1150		}
1151	} else {
1152		if (!occ->active) {
1153			rc = -EALREADY;
1154			goto unlock;
1155		}
1156
1157		if (occ->hwmon)
1158			hwmon_device_unregister(occ->hwmon);
1159		occ->active = false;
1160		occ->hwmon = NULL;
1161	}
1162
1163unlock:
1164	mutex_unlock(&occ->lock);
1165	return rc;
1166}
1167
1168int occ_setup(struct occ *occ)
1169{
1170	int rc;
1171
1172	mutex_init(&occ->lock);
1173	occ->groups[0] = &occ->group;
1174
1175	rc = occ_setup_sysfs(occ);
1176	if (rc) {
1177		dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc);
1178		return rc;
1179	}
1180
1181	if (!device_property_read_bool(occ->bus_dev, "ibm,no-poll-on-init")) {
1182		rc = occ_active(occ, true);
1183		if (rc)
1184			occ_shutdown_sysfs(occ);
1185	}
1186
1187	return rc;
1188}
1189EXPORT_SYMBOL_GPL(occ_setup);
1190
1191void occ_shutdown(struct occ *occ)
1192{
1193	mutex_lock(&occ->lock);
1194
1195	occ_shutdown_sysfs(occ);
1196
1197	if (occ->hwmon)
1198		hwmon_device_unregister(occ->hwmon);
1199	occ->hwmon = NULL;
1200
1201	mutex_unlock(&occ->lock);
1202}
1203EXPORT_SYMBOL_GPL(occ_shutdown);
1204
1205MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>");
1206MODULE_DESCRIPTION("Common OCC hwmon code");
1207MODULE_LICENSE("GPL");