Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 // Copyright IBM Corp 2019
0003 
0004 #include <linux/device.h>
0005 #include <linux/export.h>
0006 #include <linux/hwmon.h>
0007 #include <linux/hwmon-sysfs.h>
0008 #include <linux/jiffies.h>
0009 #include <linux/kernel.h>
0010 #include <linux/math64.h>
0011 #include <linux/module.h>
0012 #include <linux/mutex.h>
0013 #include <linux/sysfs.h>
0014 #include <asm/unaligned.h>
0015 
0016 #include "common.h"
0017 
0018 #define EXTN_FLAG_SENSOR_ID     BIT(7)
0019 
0020 #define OCC_ERROR_COUNT_THRESHOLD   2   /* required by OCC spec */
0021 
0022 #define OCC_STATE_SAFE          4
0023 #define OCC_SAFE_TIMEOUT        msecs_to_jiffies(60000) /* 1 min */
0024 
0025 #define OCC_UPDATE_FREQUENCY        msecs_to_jiffies(1000)
0026 
0027 #define OCC_TEMP_SENSOR_FAULT       0xFF
0028 
0029 #define OCC_FRU_TYPE_VRM        3
0030 
0031 /* OCC sensor type and version definitions */
0032 
0033 struct temp_sensor_1 {
0034     u16 sensor_id;
0035     u16 value;
0036 } __packed;
0037 
0038 struct temp_sensor_2 {
0039     u32 sensor_id;
0040     u8 fru_type;
0041     u8 value;
0042 } __packed;
0043 
0044 struct temp_sensor_10 {
0045     u32 sensor_id;
0046     u8 fru_type;
0047     u8 value;
0048     u8 throttle;
0049     u8 reserved;
0050 } __packed;
0051 
0052 struct freq_sensor_1 {
0053     u16 sensor_id;
0054     u16 value;
0055 } __packed;
0056 
0057 struct freq_sensor_2 {
0058     u32 sensor_id;
0059     u16 value;
0060 } __packed;
0061 
0062 struct power_sensor_1 {
0063     u16 sensor_id;
0064     u32 update_tag;
0065     u32 accumulator;
0066     u16 value;
0067 } __packed;
0068 
0069 struct power_sensor_2 {
0070     u32 sensor_id;
0071     u8 function_id;
0072     u8 apss_channel;
0073     u16 reserved;
0074     u32 update_tag;
0075     u64 accumulator;
0076     u16 value;
0077 } __packed;
0078 
0079 struct power_sensor_data {
0080     u16 value;
0081     u32 update_tag;
0082     u64 accumulator;
0083 } __packed;
0084 
0085 struct power_sensor_data_and_time {
0086     u16 update_time;
0087     u16 value;
0088     u32 update_tag;
0089     u64 accumulator;
0090 } __packed;
0091 
0092 struct power_sensor_a0 {
0093     u32 sensor_id;
0094     struct power_sensor_data_and_time system;
0095     u32 reserved;
0096     struct power_sensor_data_and_time proc;
0097     struct power_sensor_data vdd;
0098     struct power_sensor_data vdn;
0099 } __packed;
0100 
0101 struct caps_sensor_2 {
0102     u16 cap;
0103     u16 system_power;
0104     u16 n_cap;
0105     u16 max;
0106     u16 min;
0107     u16 user;
0108     u8 user_source;
0109 } __packed;
0110 
0111 struct caps_sensor_3 {
0112     u16 cap;
0113     u16 system_power;
0114     u16 n_cap;
0115     u16 max;
0116     u16 hard_min;
0117     u16 soft_min;
0118     u16 user;
0119     u8 user_source;
0120 } __packed;
0121 
0122 struct extended_sensor {
0123     union {
0124         u8 name[4];
0125         u32 sensor_id;
0126     };
0127     u8 flags;
0128     u8 reserved;
0129     u8 data[6];
0130 } __packed;
0131 
0132 static int occ_poll(struct occ *occ)
0133 {
0134     int rc;
0135     u8 cmd[7];
0136     struct occ_poll_response_header *header;
0137 
0138     /* big endian */
0139     cmd[0] = 0;         /* sequence number */
0140     cmd[1] = 0;         /* cmd type */
0141     cmd[2] = 0;         /* data length msb */
0142     cmd[3] = 1;         /* data length lsb */
0143     cmd[4] = occ->poll_cmd_data;    /* data */
0144     cmd[5] = 0;         /* checksum msb */
0145     cmd[6] = 0;         /* checksum lsb */
0146 
0147     /* mutex should already be locked if necessary */
0148     rc = occ->send_cmd(occ, cmd, sizeof(cmd), &occ->resp, sizeof(occ->resp));
0149     if (rc) {
0150         occ->last_error = rc;
0151         if (occ->error_count++ > OCC_ERROR_COUNT_THRESHOLD)
0152             occ->error = rc;
0153 
0154         goto done;
0155     }
0156 
0157     /* clear error since communication was successful */
0158     occ->error_count = 0;
0159     occ->last_error = 0;
0160     occ->error = 0;
0161 
0162     /* check for safe state */
0163     header = (struct occ_poll_response_header *)occ->resp.data;
0164     if (header->occ_state == OCC_STATE_SAFE) {
0165         if (occ->last_safe) {
0166             if (time_after(jiffies,
0167                        occ->last_safe + OCC_SAFE_TIMEOUT))
0168                 occ->error = -EHOSTDOWN;
0169         } else {
0170             occ->last_safe = jiffies;
0171         }
0172     } else {
0173         occ->last_safe = 0;
0174     }
0175 
0176 done:
0177     occ_sysfs_poll_done(occ);
0178     return rc;
0179 }
0180 
0181 static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap)
0182 {
0183     int rc;
0184     u8 cmd[8];
0185     u8 resp[8];
0186     __be16 user_power_cap_be = cpu_to_be16(user_power_cap);
0187 
0188     cmd[0] = 0; /* sequence number */
0189     cmd[1] = 0x22;  /* cmd type */
0190     cmd[2] = 0; /* data length msb */
0191     cmd[3] = 2; /* data length lsb */
0192 
0193     memcpy(&cmd[4], &user_power_cap_be, 2);
0194 
0195     cmd[6] = 0; /* checksum msb */
0196     cmd[7] = 0; /* checksum lsb */
0197 
0198     rc = mutex_lock_interruptible(&occ->lock);
0199     if (rc)
0200         return rc;
0201 
0202     rc = occ->send_cmd(occ, cmd, sizeof(cmd), resp, sizeof(resp));
0203 
0204     mutex_unlock(&occ->lock);
0205 
0206     return rc;
0207 }
0208 
0209 int occ_update_response(struct occ *occ)
0210 {
0211     int rc = mutex_lock_interruptible(&occ->lock);
0212 
0213     if (rc)
0214         return rc;
0215 
0216     /* limit the maximum rate of polling the OCC */
0217     if (time_after(jiffies, occ->next_update)) {
0218         rc = occ_poll(occ);
0219         occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
0220     } else {
0221         rc = occ->last_error;
0222     }
0223 
0224     mutex_unlock(&occ->lock);
0225     return rc;
0226 }
0227 
0228 static ssize_t occ_show_temp_1(struct device *dev,
0229                    struct device_attribute *attr, char *buf)
0230 {
0231     int rc;
0232     u32 val = 0;
0233     struct temp_sensor_1 *temp;
0234     struct occ *occ = dev_get_drvdata(dev);
0235     struct occ_sensors *sensors = &occ->sensors;
0236     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0237 
0238     rc = occ_update_response(occ);
0239     if (rc)
0240         return rc;
0241 
0242     temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;
0243 
0244     switch (sattr->nr) {
0245     case 0:
0246         val = get_unaligned_be16(&temp->sensor_id);
0247         break;
0248     case 1:
0249         /*
0250          * If a sensor reading has expired and couldn't be refreshed,
0251          * OCC returns 0xFFFF for that sensor.
0252          */
0253         if (temp->value == 0xFFFF)
0254             return -EREMOTEIO;
0255         val = get_unaligned_be16(&temp->value) * 1000;
0256         break;
0257     default:
0258         return -EINVAL;
0259     }
0260 
0261     return sysfs_emit(buf, "%u\n", val);
0262 }
0263 
0264 static ssize_t occ_show_temp_2(struct device *dev,
0265                    struct device_attribute *attr, char *buf)
0266 {
0267     int rc;
0268     u32 val = 0;
0269     struct temp_sensor_2 *temp;
0270     struct occ *occ = dev_get_drvdata(dev);
0271     struct occ_sensors *sensors = &occ->sensors;
0272     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0273 
0274     rc = occ_update_response(occ);
0275     if (rc)
0276         return rc;
0277 
0278     temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;
0279 
0280     switch (sattr->nr) {
0281     case 0:
0282         val = get_unaligned_be32(&temp->sensor_id);
0283         break;
0284     case 1:
0285         val = temp->value;
0286         if (val == OCC_TEMP_SENSOR_FAULT)
0287             return -EREMOTEIO;
0288 
0289         /*
0290          * VRM doesn't return temperature, only alarm bit. This
0291          * attribute maps to tempX_alarm instead of tempX_input for
0292          * VRM
0293          */
0294         if (temp->fru_type != OCC_FRU_TYPE_VRM) {
0295             /* sensor not ready */
0296             if (val == 0)
0297                 return -EAGAIN;
0298 
0299             val *= 1000;
0300         }
0301         break;
0302     case 2:
0303         val = temp->fru_type;
0304         break;
0305     case 3:
0306         val = temp->value == OCC_TEMP_SENSOR_FAULT;
0307         break;
0308     default:
0309         return -EINVAL;
0310     }
0311 
0312     return sysfs_emit(buf, "%u\n", val);
0313 }
0314 
0315 static ssize_t occ_show_temp_10(struct device *dev,
0316                 struct device_attribute *attr, char *buf)
0317 {
0318     int rc;
0319     u32 val = 0;
0320     struct temp_sensor_10 *temp;
0321     struct occ *occ = dev_get_drvdata(dev);
0322     struct occ_sensors *sensors = &occ->sensors;
0323     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0324 
0325     rc = occ_update_response(occ);
0326     if (rc)
0327         return rc;
0328 
0329     temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index;
0330 
0331     switch (sattr->nr) {
0332     case 0:
0333         val = get_unaligned_be32(&temp->sensor_id);
0334         break;
0335     case 1:
0336         val = temp->value;
0337         if (val == OCC_TEMP_SENSOR_FAULT)
0338             return -EREMOTEIO;
0339 
0340         /* sensor not ready */
0341         if (val == 0)
0342             return -EAGAIN;
0343 
0344         val *= 1000;
0345         break;
0346     case 2:
0347         val = temp->fru_type;
0348         break;
0349     case 3:
0350         val = temp->value == OCC_TEMP_SENSOR_FAULT;
0351         break;
0352     case 4:
0353         val = temp->throttle * 1000;
0354         break;
0355     default:
0356         return -EINVAL;
0357     }
0358 
0359     return sysfs_emit(buf, "%u\n", val);
0360 }
0361 
0362 static ssize_t occ_show_freq_1(struct device *dev,
0363                    struct device_attribute *attr, char *buf)
0364 {
0365     int rc;
0366     u16 val = 0;
0367     struct freq_sensor_1 *freq;
0368     struct occ *occ = dev_get_drvdata(dev);
0369     struct occ_sensors *sensors = &occ->sensors;
0370     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0371 
0372     rc = occ_update_response(occ);
0373     if (rc)
0374         return rc;
0375 
0376     freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;
0377 
0378     switch (sattr->nr) {
0379     case 0:
0380         val = get_unaligned_be16(&freq->sensor_id);
0381         break;
0382     case 1:
0383         val = get_unaligned_be16(&freq->value);
0384         break;
0385     default:
0386         return -EINVAL;
0387     }
0388 
0389     return sysfs_emit(buf, "%u\n", val);
0390 }
0391 
0392 static ssize_t occ_show_freq_2(struct device *dev,
0393                    struct device_attribute *attr, char *buf)
0394 {
0395     int rc;
0396     u32 val = 0;
0397     struct freq_sensor_2 *freq;
0398     struct occ *occ = dev_get_drvdata(dev);
0399     struct occ_sensors *sensors = &occ->sensors;
0400     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0401 
0402     rc = occ_update_response(occ);
0403     if (rc)
0404         return rc;
0405 
0406     freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;
0407 
0408     switch (sattr->nr) {
0409     case 0:
0410         val = get_unaligned_be32(&freq->sensor_id);
0411         break;
0412     case 1:
0413         val = get_unaligned_be16(&freq->value);
0414         break;
0415     default:
0416         return -EINVAL;
0417     }
0418 
0419     return sysfs_emit(buf, "%u\n", val);
0420 }
0421 
0422 static ssize_t occ_show_power_1(struct device *dev,
0423                 struct device_attribute *attr, char *buf)
0424 {
0425     int rc;
0426     u64 val = 0;
0427     struct power_sensor_1 *power;
0428     struct occ *occ = dev_get_drvdata(dev);
0429     struct occ_sensors *sensors = &occ->sensors;
0430     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0431 
0432     rc = occ_update_response(occ);
0433     if (rc)
0434         return rc;
0435 
0436     power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;
0437 
0438     switch (sattr->nr) {
0439     case 0:
0440         val = get_unaligned_be16(&power->sensor_id);
0441         break;
0442     case 1:
0443         val = get_unaligned_be32(&power->accumulator) /
0444             get_unaligned_be32(&power->update_tag);
0445         val *= 1000000ULL;
0446         break;
0447     case 2:
0448         val = (u64)get_unaligned_be32(&power->update_tag) *
0449                occ->powr_sample_time_us;
0450         break;
0451     case 3:
0452         val = get_unaligned_be16(&power->value) * 1000000ULL;
0453         break;
0454     default:
0455         return -EINVAL;
0456     }
0457 
0458     return sysfs_emit(buf, "%llu\n", val);
0459 }
0460 
0461 static u64 occ_get_powr_avg(u64 *accum, u32 *samples)
0462 {
0463     u64 divisor = get_unaligned_be32(samples);
0464 
0465     return (divisor == 0) ? 0 :
0466         div64_u64(get_unaligned_be64(accum) * 1000000ULL, divisor);
0467 }
0468 
0469 static ssize_t occ_show_power_2(struct device *dev,
0470                 struct device_attribute *attr, char *buf)
0471 {
0472     int rc;
0473     u64 val = 0;
0474     struct power_sensor_2 *power;
0475     struct occ *occ = dev_get_drvdata(dev);
0476     struct occ_sensors *sensors = &occ->sensors;
0477     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0478 
0479     rc = occ_update_response(occ);
0480     if (rc)
0481         return rc;
0482 
0483     power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;
0484 
0485     switch (sattr->nr) {
0486     case 0:
0487         return sysfs_emit(buf, "%u_%u_%u\n",
0488                   get_unaligned_be32(&power->sensor_id),
0489                   power->function_id, power->apss_channel);
0490     case 1:
0491         val = occ_get_powr_avg(&power->accumulator,
0492                        &power->update_tag);
0493         break;
0494     case 2:
0495         val = (u64)get_unaligned_be32(&power->update_tag) *
0496                occ->powr_sample_time_us;
0497         break;
0498     case 3:
0499         val = get_unaligned_be16(&power->value) * 1000000ULL;
0500         break;
0501     default:
0502         return -EINVAL;
0503     }
0504 
0505     return sysfs_emit(buf, "%llu\n", val);
0506 }
0507 
0508 static ssize_t occ_show_power_a0(struct device *dev,
0509                  struct device_attribute *attr, char *buf)
0510 {
0511     int rc;
0512     u64 val = 0;
0513     struct power_sensor_a0 *power;
0514     struct occ *occ = dev_get_drvdata(dev);
0515     struct occ_sensors *sensors = &occ->sensors;
0516     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0517 
0518     rc = occ_update_response(occ);
0519     if (rc)
0520         return rc;
0521 
0522     power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;
0523 
0524     switch (sattr->nr) {
0525     case 0:
0526         return sysfs_emit(buf, "%u_system\n",
0527                   get_unaligned_be32(&power->sensor_id));
0528     case 1:
0529         val = occ_get_powr_avg(&power->system.accumulator,
0530                        &power->system.update_tag);
0531         break;
0532     case 2:
0533         val = (u64)get_unaligned_be32(&power->system.update_tag) *
0534                occ->powr_sample_time_us;
0535         break;
0536     case 3:
0537         val = get_unaligned_be16(&power->system.value) * 1000000ULL;
0538         break;
0539     case 4:
0540         return sysfs_emit(buf, "%u_proc\n",
0541                   get_unaligned_be32(&power->sensor_id));
0542     case 5:
0543         val = occ_get_powr_avg(&power->proc.accumulator,
0544                        &power->proc.update_tag);
0545         break;
0546     case 6:
0547         val = (u64)get_unaligned_be32(&power->proc.update_tag) *
0548                occ->powr_sample_time_us;
0549         break;
0550     case 7:
0551         val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
0552         break;
0553     case 8:
0554         return sysfs_emit(buf, "%u_vdd\n",
0555                   get_unaligned_be32(&power->sensor_id));
0556     case 9:
0557         val = occ_get_powr_avg(&power->vdd.accumulator,
0558                        &power->vdd.update_tag);
0559         break;
0560     case 10:
0561         val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
0562                occ->powr_sample_time_us;
0563         break;
0564     case 11:
0565         val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
0566         break;
0567     case 12:
0568         return sysfs_emit(buf, "%u_vdn\n",
0569                   get_unaligned_be32(&power->sensor_id));
0570     case 13:
0571         val = occ_get_powr_avg(&power->vdn.accumulator,
0572                        &power->vdn.update_tag);
0573         break;
0574     case 14:
0575         val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
0576                occ->powr_sample_time_us;
0577         break;
0578     case 15:
0579         val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
0580         break;
0581     default:
0582         return -EINVAL;
0583     }
0584 
0585     return sysfs_emit(buf, "%llu\n", val);
0586 }
0587 
0588 static ssize_t occ_show_caps_1_2(struct device *dev,
0589                  struct device_attribute *attr, char *buf)
0590 {
0591     int rc;
0592     u64 val = 0;
0593     struct caps_sensor_2 *caps;
0594     struct occ *occ = dev_get_drvdata(dev);
0595     struct occ_sensors *sensors = &occ->sensors;
0596     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0597 
0598     rc = occ_update_response(occ);
0599     if (rc)
0600         return rc;
0601 
0602     caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;
0603 
0604     switch (sattr->nr) {
0605     case 0:
0606         return sysfs_emit(buf, "system\n");
0607     case 1:
0608         val = get_unaligned_be16(&caps->cap) * 1000000ULL;
0609         break;
0610     case 2:
0611         val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
0612         break;
0613     case 3:
0614         val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
0615         break;
0616     case 4:
0617         val = get_unaligned_be16(&caps->max) * 1000000ULL;
0618         break;
0619     case 5:
0620         val = get_unaligned_be16(&caps->min) * 1000000ULL;
0621         break;
0622     case 6:
0623         val = get_unaligned_be16(&caps->user) * 1000000ULL;
0624         break;
0625     case 7:
0626         if (occ->sensors.caps.version == 1)
0627             return -EINVAL;
0628 
0629         val = caps->user_source;
0630         break;
0631     default:
0632         return -EINVAL;
0633     }
0634 
0635     return sysfs_emit(buf, "%llu\n", val);
0636 }
0637 
0638 static ssize_t occ_show_caps_3(struct device *dev,
0639                    struct device_attribute *attr, char *buf)
0640 {
0641     int rc;
0642     u64 val = 0;
0643     struct caps_sensor_3 *caps;
0644     struct occ *occ = dev_get_drvdata(dev);
0645     struct occ_sensors *sensors = &occ->sensors;
0646     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0647 
0648     rc = occ_update_response(occ);
0649     if (rc)
0650         return rc;
0651 
0652     caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;
0653 
0654     switch (sattr->nr) {
0655     case 0:
0656         return sysfs_emit(buf, "system\n");
0657     case 1:
0658         val = get_unaligned_be16(&caps->cap) * 1000000ULL;
0659         break;
0660     case 2:
0661         val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
0662         break;
0663     case 3:
0664         val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
0665         break;
0666     case 4:
0667         val = get_unaligned_be16(&caps->max) * 1000000ULL;
0668         break;
0669     case 5:
0670         val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;
0671         break;
0672     case 6:
0673         val = get_unaligned_be16(&caps->user) * 1000000ULL;
0674         break;
0675     case 7:
0676         val = caps->user_source;
0677         break;
0678     case 8:
0679         val = get_unaligned_be16(&caps->soft_min) * 1000000ULL;
0680         break;
0681     default:
0682         return -EINVAL;
0683     }
0684 
0685     return sysfs_emit(buf, "%llu\n", val);
0686 }
0687 
0688 static ssize_t occ_store_caps_user(struct device *dev,
0689                    struct device_attribute *attr,
0690                    const char *buf, size_t count)
0691 {
0692     int rc;
0693     u16 user_power_cap;
0694     unsigned long long value;
0695     struct occ *occ = dev_get_drvdata(dev);
0696 
0697     rc = kstrtoull(buf, 0, &value);
0698     if (rc)
0699         return rc;
0700 
0701     user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */
0702 
0703     rc = occ_set_user_power_cap(occ, user_power_cap);
0704     if (rc)
0705         return rc;
0706 
0707     return count;
0708 }
0709 
0710 static ssize_t occ_show_extended(struct device *dev,
0711                  struct device_attribute *attr, char *buf)
0712 {
0713     int rc;
0714     struct extended_sensor *extn;
0715     struct occ *occ = dev_get_drvdata(dev);
0716     struct occ_sensors *sensors = &occ->sensors;
0717     struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
0718 
0719     rc = occ_update_response(occ);
0720     if (rc)
0721         return rc;
0722 
0723     extn = ((struct extended_sensor *)sensors->extended.data) +
0724         sattr->index;
0725 
0726     switch (sattr->nr) {
0727     case 0:
0728         if (extn->flags & EXTN_FLAG_SENSOR_ID) {
0729             rc = sysfs_emit(buf, "%u",
0730                     get_unaligned_be32(&extn->sensor_id));
0731         } else {
0732             rc = sysfs_emit(buf, "%4phN\n", extn->name);
0733         }
0734         break;
0735     case 1:
0736         rc = sysfs_emit(buf, "%02x\n", extn->flags);
0737         break;
0738     case 2:
0739         rc = sysfs_emit(buf, "%6phN\n", extn->data);
0740         break;
0741     default:
0742         return -EINVAL;
0743     }
0744 
0745     return rc;
0746 }
0747 
0748 /*
0749  * Some helper macros to make it easier to define an occ_attribute. Since these
0750  * are dynamically allocated, we shouldn't use the existing kernel macros which
0751  * stringify the name argument.
0752  */
0753 #define ATTR_OCC(_name, _mode, _show, _store) {             \
0754     .attr   = {                         \
0755         .name = _name,                      \
0756         .mode = VERIFY_OCTAL_PERMISSIONS(_mode),        \
0757     },                              \
0758     .show   = _show,                        \
0759     .store  = _store,                       \
0760 }
0761 
0762 #define SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index) { \
0763     .dev_attr   = ATTR_OCC(_name, _mode, _show, _store),    \
0764     .index      = _index,                   \
0765     .nr     = _nr,                      \
0766 }
0767 
0768 #define OCC_INIT_ATTR(_name, _mode, _show, _store, _nr, _index)     \
0769     ((struct sensor_device_attribute_2)             \
0770         SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index))
0771 
0772 /*
0773  * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
0774  * use our own instead of the built-in hwmon attribute types.
0775  */
0776 static int occ_setup_sensor_attrs(struct occ *occ)
0777 {
0778     unsigned int i, s, num_attrs = 0;
0779     struct device *dev = occ->bus_dev;
0780     struct occ_sensors *sensors = &occ->sensors;
0781     struct occ_attribute *attr;
0782     struct temp_sensor_2 *temp;
0783     ssize_t (*show_temp)(struct device *, struct device_attribute *,
0784                  char *) = occ_show_temp_1;
0785     ssize_t (*show_freq)(struct device *, struct device_attribute *,
0786                  char *) = occ_show_freq_1;
0787     ssize_t (*show_power)(struct device *, struct device_attribute *,
0788                   char *) = occ_show_power_1;
0789     ssize_t (*show_caps)(struct device *, struct device_attribute *,
0790                  char *) = occ_show_caps_1_2;
0791 
0792     switch (sensors->temp.version) {
0793     case 1:
0794         num_attrs += (sensors->temp.num_sensors * 2);
0795         break;
0796     case 2:
0797         num_attrs += (sensors->temp.num_sensors * 4);
0798         show_temp = occ_show_temp_2;
0799         break;
0800     case 0x10:
0801         num_attrs += (sensors->temp.num_sensors * 5);
0802         show_temp = occ_show_temp_10;
0803         break;
0804     default:
0805         sensors->temp.num_sensors = 0;
0806     }
0807 
0808     switch (sensors->freq.version) {
0809     case 2:
0810         show_freq = occ_show_freq_2;
0811         fallthrough;
0812     case 1:
0813         num_attrs += (sensors->freq.num_sensors * 2);
0814         break;
0815     default:
0816         sensors->freq.num_sensors = 0;
0817     }
0818 
0819     switch (sensors->power.version) {
0820     case 2:
0821         show_power = occ_show_power_2;
0822         fallthrough;
0823     case 1:
0824         num_attrs += (sensors->power.num_sensors * 4);
0825         break;
0826     case 0xA0:
0827         num_attrs += (sensors->power.num_sensors * 16);
0828         show_power = occ_show_power_a0;
0829         break;
0830     default:
0831         sensors->power.num_sensors = 0;
0832     }
0833 
0834     switch (sensors->caps.version) {
0835     case 1:
0836         num_attrs += (sensors->caps.num_sensors * 7);
0837         break;
0838     case 2:
0839         num_attrs += (sensors->caps.num_sensors * 8);
0840         break;
0841     case 3:
0842         show_caps = occ_show_caps_3;
0843         num_attrs += (sensors->caps.num_sensors * 9);
0844         break;
0845     default:
0846         sensors->caps.num_sensors = 0;
0847     }
0848 
0849     switch (sensors->extended.version) {
0850     case 1:
0851         num_attrs += (sensors->extended.num_sensors * 3);
0852         break;
0853     default:
0854         sensors->extended.num_sensors = 0;
0855     }
0856 
0857     occ->attrs = devm_kzalloc(dev, sizeof(*occ->attrs) * num_attrs,
0858                   GFP_KERNEL);
0859     if (!occ->attrs)
0860         return -ENOMEM;
0861 
0862     /* null-terminated list */
0863     occ->group.attrs = devm_kzalloc(dev, sizeof(*occ->group.attrs) *
0864                     num_attrs + 1, GFP_KERNEL);
0865     if (!occ->group.attrs)
0866         return -ENOMEM;
0867 
0868     attr = occ->attrs;
0869 
0870     for (i = 0; i < sensors->temp.num_sensors; ++i) {
0871         s = i + 1;
0872         temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
0873 
0874         snprintf(attr->name, sizeof(attr->name), "temp%d_label", s);
0875         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
0876                          0, i);
0877         attr++;
0878 
0879         if (sensors->temp.version == 2 &&
0880             temp->fru_type == OCC_FRU_TYPE_VRM) {
0881             snprintf(attr->name, sizeof(attr->name),
0882                  "temp%d_alarm", s);
0883         } else {
0884             snprintf(attr->name, sizeof(attr->name),
0885                  "temp%d_input", s);
0886         }
0887 
0888         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
0889                          1, i);
0890         attr++;
0891 
0892         if (sensors->temp.version > 1) {
0893             snprintf(attr->name, sizeof(attr->name),
0894                  "temp%d_fru_type", s);
0895             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0896                              show_temp, NULL, 2, i);
0897             attr++;
0898 
0899             snprintf(attr->name, sizeof(attr->name),
0900                  "temp%d_fault", s);
0901             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0902                              show_temp, NULL, 3, i);
0903             attr++;
0904 
0905             if (sensors->temp.version == 0x10) {
0906                 snprintf(attr->name, sizeof(attr->name),
0907                      "temp%d_max", s);
0908                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0909                                  show_temp, NULL,
0910                                  4, i);
0911                 attr++;
0912             }
0913         }
0914     }
0915 
0916     for (i = 0; i < sensors->freq.num_sensors; ++i) {
0917         s = i + 1;
0918 
0919         snprintf(attr->name, sizeof(attr->name), "freq%d_label", s);
0920         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
0921                          0, i);
0922         attr++;
0923 
0924         snprintf(attr->name, sizeof(attr->name), "freq%d_input", s);
0925         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
0926                          1, i);
0927         attr++;
0928     }
0929 
0930     if (sensors->power.version == 0xA0) {
0931         /*
0932          * Special case for many-attribute power sensor. Split it into
0933          * a sensor number per power type, emulating several sensors.
0934          */
0935         for (i = 0; i < sensors->power.num_sensors; ++i) {
0936             unsigned int j;
0937             unsigned int nr = 0;
0938 
0939             s = (i * 4) + 1;
0940 
0941             for (j = 0; j < 4; ++j) {
0942                 snprintf(attr->name, sizeof(attr->name),
0943                      "power%d_label", s);
0944                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0945                                  show_power, NULL,
0946                                  nr++, i);
0947                 attr++;
0948 
0949                 snprintf(attr->name, sizeof(attr->name),
0950                      "power%d_average", s);
0951                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0952                                  show_power, NULL,
0953                                  nr++, i);
0954                 attr++;
0955 
0956                 snprintf(attr->name, sizeof(attr->name),
0957                      "power%d_average_interval", s);
0958                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0959                                  show_power, NULL,
0960                                  nr++, i);
0961                 attr++;
0962 
0963                 snprintf(attr->name, sizeof(attr->name),
0964                      "power%d_input", s);
0965                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0966                                  show_power, NULL,
0967                                  nr++, i);
0968                 attr++;
0969 
0970                 s++;
0971             }
0972         }
0973 
0974         s = (sensors->power.num_sensors * 4) + 1;
0975     } else {
0976         for (i = 0; i < sensors->power.num_sensors; ++i) {
0977             s = i + 1;
0978 
0979             snprintf(attr->name, sizeof(attr->name),
0980                  "power%d_label", s);
0981             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0982                              show_power, NULL, 0, i);
0983             attr++;
0984 
0985             snprintf(attr->name, sizeof(attr->name),
0986                  "power%d_average", s);
0987             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0988                              show_power, NULL, 1, i);
0989             attr++;
0990 
0991             snprintf(attr->name, sizeof(attr->name),
0992                  "power%d_average_interval", s);
0993             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
0994                              show_power, NULL, 2, i);
0995             attr++;
0996 
0997             snprintf(attr->name, sizeof(attr->name),
0998                  "power%d_input", s);
0999             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1000                              show_power, NULL, 3, i);
1001             attr++;
1002         }
1003 
1004         s = sensors->power.num_sensors + 1;
1005     }
1006 
1007     if (sensors->caps.num_sensors >= 1) {
1008         snprintf(attr->name, sizeof(attr->name), "power%d_label", s);
1009         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1010                          0, 0);
1011         attr++;
1012 
1013         snprintf(attr->name, sizeof(attr->name), "power%d_cap", s);
1014         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1015                          1, 0);
1016         attr++;
1017 
1018         snprintf(attr->name, sizeof(attr->name), "power%d_input", s);
1019         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1020                          2, 0);
1021         attr++;
1022 
1023         snprintf(attr->name, sizeof(attr->name),
1024              "power%d_cap_not_redundant", s);
1025         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1026                          3, 0);
1027         attr++;
1028 
1029         snprintf(attr->name, sizeof(attr->name), "power%d_cap_max", s);
1030         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1031                          4, 0);
1032         attr++;
1033 
1034         snprintf(attr->name, sizeof(attr->name), "power%d_cap_min", s);
1035         attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1036                          5, 0);
1037         attr++;
1038 
1039         snprintf(attr->name, sizeof(attr->name), "power%d_cap_user",
1040              s);
1041         attr->sensor = OCC_INIT_ATTR(attr->name, 0644, show_caps,
1042                          occ_store_caps_user, 6, 0);
1043         attr++;
1044 
1045         if (sensors->caps.version > 1) {
1046             snprintf(attr->name, sizeof(attr->name),
1047                  "power%d_cap_user_source", s);
1048             attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1049                              show_caps, NULL, 7, 0);
1050             attr++;
1051 
1052             if (sensors->caps.version > 2) {
1053                 snprintf(attr->name, sizeof(attr->name),
1054                      "power%d_cap_min_soft", s);
1055                 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1056                                  show_caps, NULL,
1057                                  8, 0);
1058                 attr++;
1059             }
1060         }
1061     }
1062 
1063     for (i = 0; i < sensors->extended.num_sensors; ++i) {
1064         s = i + 1;
1065 
1066         snprintf(attr->name, sizeof(attr->name), "extn%d_label", s);
1067         attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1068                          occ_show_extended, NULL, 0, i);
1069         attr++;
1070 
1071         snprintf(attr->name, sizeof(attr->name), "extn%d_flags", s);
1072         attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1073                          occ_show_extended, NULL, 1, i);
1074         attr++;
1075 
1076         snprintf(attr->name, sizeof(attr->name), "extn%d_input", s);
1077         attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1078                          occ_show_extended, NULL, 2, i);
1079         attr++;
1080     }
1081 
1082     /* put the sensors in the group */
1083     for (i = 0; i < num_attrs; ++i) {
1084         sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr);
1085         occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr;
1086     }
1087 
1088     return 0;
1089 }
1090 
1091 /* only need to do this once at startup, as OCC won't change sensors on us */
1092 static void occ_parse_poll_response(struct occ *occ)
1093 {
1094     unsigned int i, old_offset, offset = 0, size = 0;
1095     struct occ_sensor *sensor;
1096     struct occ_sensors *sensors = &occ->sensors;
1097     struct occ_response *resp = &occ->resp;
1098     struct occ_poll_response *poll =
1099         (struct occ_poll_response *)&resp->data[0];
1100     struct occ_poll_response_header *header = &poll->header;
1101     struct occ_sensor_data_block *block = &poll->block;
1102 
1103     dev_info(occ->bus_dev, "OCC found, code level: %.16s\n",
1104          header->occ_code_level);
1105 
1106     for (i = 0; i < header->num_sensor_data_blocks; ++i) {
1107         block = (struct occ_sensor_data_block *)((u8 *)block + offset);
1108         old_offset = offset;
1109         offset = (block->header.num_sensors *
1110               block->header.sensor_length) + sizeof(block->header);
1111         size += offset;
1112 
1113         /* validate all the length/size fields */
1114         if ((size + sizeof(*header)) >= OCC_RESP_DATA_BYTES) {
1115             dev_warn(occ->bus_dev, "exceeded response buffer\n");
1116             return;
1117         }
1118 
1119         dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n",
1120             old_offset, offset - 1, block->header.eye_catcher,
1121             block->header.num_sensors);
1122 
1123         /* match sensor block type */
1124         if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0)
1125             sensor = &sensors->temp;
1126         else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0)
1127             sensor = &sensors->freq;
1128         else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0)
1129             sensor = &sensors->power;
1130         else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0)
1131             sensor = &sensors->caps;
1132         else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0)
1133             sensor = &sensors->extended;
1134         else {
1135             dev_warn(occ->bus_dev, "sensor not supported %.4s\n",
1136                  block->header.eye_catcher);
1137             continue;
1138         }
1139 
1140         sensor->num_sensors = block->header.num_sensors;
1141         sensor->version = block->header.sensor_format;
1142         sensor->data = &block->data;
1143     }
1144 
1145     dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size,
1146         sizeof(*header), size + sizeof(*header));
1147 }
1148 
1149 int occ_active(struct occ *occ, bool active)
1150 {
1151     int rc = mutex_lock_interruptible(&occ->lock);
1152 
1153     if (rc)
1154         return rc;
1155 
1156     if (active) {
1157         if (occ->active) {
1158             rc = -EALREADY;
1159             goto unlock;
1160         }
1161 
1162         occ->error_count = 0;
1163         occ->last_safe = 0;
1164 
1165         rc = occ_poll(occ);
1166         if (rc < 0) {
1167             dev_err(occ->bus_dev,
1168                 "failed to get OCC poll response=%02x: %d\n",
1169                 occ->resp.return_status, rc);
1170             goto unlock;
1171         }
1172 
1173         occ->active = true;
1174         occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
1175         occ_parse_poll_response(occ);
1176 
1177         rc = occ_setup_sensor_attrs(occ);
1178         if (rc) {
1179             dev_err(occ->bus_dev,
1180                 "failed to setup sensor attrs: %d\n", rc);
1181             goto unlock;
1182         }
1183 
1184         occ->hwmon = hwmon_device_register_with_groups(occ->bus_dev,
1185                                    "occ", occ,
1186                                    occ->groups);
1187         if (IS_ERR(occ->hwmon)) {
1188             rc = PTR_ERR(occ->hwmon);
1189             occ->hwmon = NULL;
1190             dev_err(occ->bus_dev,
1191                 "failed to register hwmon device: %d\n", rc);
1192             goto unlock;
1193         }
1194     } else {
1195         if (!occ->active) {
1196             rc = -EALREADY;
1197             goto unlock;
1198         }
1199 
1200         if (occ->hwmon)
1201             hwmon_device_unregister(occ->hwmon);
1202         occ->active = false;
1203         occ->hwmon = NULL;
1204     }
1205 
1206 unlock:
1207     mutex_unlock(&occ->lock);
1208     return rc;
1209 }
1210 
1211 int occ_setup(struct occ *occ)
1212 {
1213     int rc;
1214 
1215     mutex_init(&occ->lock);
1216     occ->groups[0] = &occ->group;
1217 
1218     rc = occ_setup_sysfs(occ);
1219     if (rc)
1220         dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc);
1221 
1222     return rc;
1223 }
1224 EXPORT_SYMBOL_GPL(occ_setup);
1225 
1226 void occ_shutdown(struct occ *occ)
1227 {
1228     mutex_lock(&occ->lock);
1229 
1230     occ_shutdown_sysfs(occ);
1231 
1232     if (occ->hwmon)
1233         hwmon_device_unregister(occ->hwmon);
1234     occ->hwmon = NULL;
1235 
1236     mutex_unlock(&occ->lock);
1237 }
1238 EXPORT_SYMBOL_GPL(occ_shutdown);
1239 
1240 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>");
1241 MODULE_DESCRIPTION("Common OCC hwmon code");
1242 MODULE_LICENSE("GPL");
[ 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!