There's this www.pmbus.org thing that's slowly been getting under way, intended for digital power supply management. I think some recent Dell boxes use it internally. Wikipedia summarizes the tech fairly well; note the deltas from SMBus: http://en.wikipedia.org/wiki/PMBus When trying to talk to one such device, I put together the query utility appended to this message. I hope it will be useful to other folk who may need to access such devices from Linux. If nothing else it provides a consistent host-side interpretation of those specs, and calls out some ambiguous areas ... and it should be possible to build other tools based on this core code. - Dave /* $(CROSS)gcc -Wall -Os -o pmbus_peek pmbus_peek.c */ /* * pmbus_peek.c - initial userspace interrogation of PMBus devices * * Copyright (C) 2008 David Brownell * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <errno.h> #include <fcntl.h> #include <math.h> #include <stdio.h> //#include <stdbool.h> #define bool u8 #define true 1 #define false 0 #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <linux/i2c.h> #include <linux/i2c-dev.h> #define HACK /* can issue no-arguments (W0) mfr-specific calls */ /* * This is a simple "tell me about that PMBus device" tool. It can probe * PMBus devices and (for PMBus 1.1 devices) show their self-advertised * capabilities. It knows about all the operations defined in the spec, * and can invoke a number of them. * * Note that those "self-advertised" capabilities are optional, and may * be better suited to firmware-based devices rather than pure hardware. * A microcontroller with just 2 KB of program memory can support these * capabilities, but a bit more memory would help it do Real Work too. * * Tested on Linux 2.6.24+ using the i2c-gpio bitbanger. * * See www.pmbus.org to get PMBus 1.1 (or newer) specifications. */ typedef __u8 u8; typedef __u16 u16; typedef __s8 s8; typedef __s16 s16; enum pmbus_cmd_type { /* _undef_ = 0, */ RW1 = 1, /* read/write one byte */ RW2, /* read/write two byte "word" */ RWB, /* read/write block (up to 255 bytes) */ RWB14, /* read/write block (of 14 bytes) */ RWP_QUERY, /* block write/read process call for QUERY */ RWP_COEFF, /* block write/read process call for COEFFICIENTS */ W0, /* write zero bytes ("send byte", command only) */ W1, /* write one byte */ R1, /* read one byte */ R2, /* read two byte "word" */ }; enum pmbus_unit_type { /* _undef_ = 0, */ /* for RW2 and R2 types */ VOLTS = 1, AMPERES, MILLISECONDS, DEGREES_C, WATTS, BITS, /* REVISIT: there are quite a few more units: * - mV/uSec for V transition rates * - mV/A (mOhm) for V droop * - Ohms for calibration * - percent for duty cycle and fan speed * - RPM for fan speed * - kHz for frequency * - ... */ /* for various RWB bits of inventory data */ STRING, }; struct pmbus_coefficients { u8 valid; /* Coefficients of the device, valid only after initialization. * * Yeech ... the PMBus spec doesn't talk about signs, except to * say that output voltages are always positive. Here we will * assume that all values include sign bits. */ s8 R; s16 m; s16 b; }; /* * This struct captures the PMBus 1.1 command summary data, in Part II * Appendix I of the spec and updated to include units. It's set up so * it can be easily augmented with device-specfic query data and other * data as needed to work with these commands. */ struct pmbus_cmd_desc { /* data from Part II of PMBus spec (constant) */ const char *tag; u16 cmd; u8 type; u8 units; /* data just for this utility */ u8 flags; #if 0 void (*decode)(struct pmbus_cmd_desc *op, int value); // REVISIT encode too #endif /* from device (variable) */ u8 query; struct pmbus_coefficients c[2]; /* 0 = w, 1 = r */ }; /* some of the command codes found in pmbus_cmd_desc.cmd; * these are specifically recognized in this code. */ #define PMB_CLEAR_FAULT 0x03 #define PMB_CAPABILITY 0x19 #define PMB_QUERY 0x1a #define PMB_COEFFICIENTS 0x30 #define PMB_STATUS_BYTE 0x78 #define PMB_STATUS_WORD 0x79 #define PMB_STATUS_VOUT 0x7a #define PMB_STATUS_IOUT 0x7b #define PMB_STATUS_INPUT 0x7c #define PMB_STATUS_TEMPERATURE 0x7d #define PMB_STATUS_CML 0x7e #define PMB_STATUS_OTHER 0x7f #define PMB_STATUS_MFR_SPECIFIC 0x80 #define PMB_STATUS_FANS_1_2 0x81 #define PMB_STATUS_FANS_3_4 0x82 #define PMB_PMBUS_REVISION 0x98 #define PMB_MFR_ID 0x99 #define PMB_MFR_MODEL 0x9a #define PMB_MFR_REVISION 0x9b #define PMB_MFR_LOCATION 0x9c #define PMB_MFR_DATE 0x9d #define PMB_MFR_SERIAL 0x9e #define PMB_USER_DATA(x) (0xb0 + (x)) /* 0 <= x <= 15 */ #define PMB_MFR_SPECIFIC(x) (0xd0 + (x)) /* 0 <= x <= 45 */ #define PMB_MFR_EXT(x) (0xfe00 + (x)) /* 0 <= x <= 255 */ #define PMB_EXT(x) (0xff00 + (x)) /* 0 <= x <= 255 */ /* flags for pmbus_cmd-desc.flags */ #define FLG_SHOW_P1 (1 << 0) #define FLG_STATUS (1 << 1) static inline int is_pmb_8bit(u16 cmd) { /* pure 8 bit command */ return (cmd & 0xff00) == 0 && (cmd & 0xfe) != 0xfe; } static inline int is_pmb_extended(u16 cmd) { /* 9 bit command, with 2nd (upper) byte */ return (cmd & 0xfe00) == 0xfe00; } /*----------------------------------------------------------------------*/ /* * NOTE: first version expects these static values to be morphed * in place ... maximum of one device per process. To support more * than one PMBus device per process, make this table "const" then * use these as examplars. * * REVISIT more of these should probably have units... */ static struct pmbus_cmd_desc pmbus_ops[] = { /* These are in numeric order, modulo sequence gaps in the PMBus spec. */ { .cmd = 0x00, .tag = "page", .type = RW1, }, { .cmd = 0x01, .tag = "operation", .type = RW1, }, { .cmd = 0x02, .tag = "on_off_config", .type = RW1, }, { .cmd = PMB_CLEAR_FAULT, .tag = "clear_fault", .type = W0, }, { .cmd = 0x04, .tag = "phase", .type = RW1, }, { .cmd = 0x10, .tag = "write_protect", .type = RW1, }, { .cmd = 0x11, .tag = "store_default_all", .type = W0, }, { .cmd = 0x12, .tag = "restore_default_all", .type = W0, }, { .cmd = 0x13, .tag = "store_default_code", .type = W1, }, { .cmd = 0x14, .tag = "restore_default_code", .type = W1, }, { .cmd = 0x15, .tag = "store_user_all", .type = W0, }, { .cmd = 0x16, .tag = "restore_user_all", .type = W0, }, { .cmd = 0x17, .tag = "store_user_code", .type = W1, }, { .cmd = 0x18, .tag = "restore_user_code", .type = W1, }, { .cmd = PMB_CAPABILITY, .tag = "capability", .type = R1, .flags = FLG_SHOW_P1, }, { .cmd = PMB_QUERY, .tag = "query", .type = RWP_QUERY, }, { .cmd = 0x20, .tag = "vout_mode", .type = RW1, }, { .cmd = 0x21, .tag = "vout_command", .type = RW2, }, { .cmd = 0x22, .tag = "vout_trim", .type = RW2, .units = VOLTS, }, { .cmd = 0x23, .tag = "vout_cal_offset", .type = RW2, .units = VOLTS, }, { .cmd = 0x24, .tag = "vout_max", .type = RW2, .units = VOLTS, }, { .cmd = 0x25, .tag = "vout_margin_high", .type = RW2, .units = VOLTS, }, { .cmd = 0x26, .tag = "vout_margin_low", .type = RW2, .units = VOLTS, }, { .cmd = 0x27, .tag = "vout_transition_rate", .type = RW2, }, { .cmd = 0x28, .tag = "vout_droop", .type = RW2, }, { .cmd = 0x29, .tag = "vout_scale_loop", .type = RW2, }, { .cmd = 0x2a, .tag = "vout_scale_monitor", .type = RW2, }, { .cmd = PMB_COEFFICIENTS, .tag = "coefficients", .type = RWP_COEFF, }, { .cmd = 0x31, .tag = "pout_max", .type = RW2, .units = WATTS, }, { .cmd = 0x32, .tag = "max_duty", .type = RW2, }, { .cmd = 0x33, .tag = "frequency_switch", .type = RW2, }, { .cmd = 0x35, .tag = "vin_on", .type = RW2, .units = VOLTS, }, { .cmd = 0x36, .tag = "vin_off", .type = RW2, .units = VOLTS, }, { .cmd = 0x37, .tag = "interleave", .type = RW2, }, { .cmd = 0x38, .tag = "iout_cal_gain", .type = RW2, }, { .cmd = 0x39, .tag = "iout_cal_offset", .type = RW2, .units = AMPERES, }, { .cmd = 0x3a, .tag = "fan_config_1_2", .type = RW1, }, { .cmd = 0x3b, .tag = "fan_command_1", .type = RW2, }, { .cmd = 0x3c, .tag = "fan_command_2", .type = RW2, }, { .cmd = 0x3d, .tag = "fan_config_3_4", .type = RW1, }, { .cmd = 0x3e, .tag = "fan_command_3", .type = RW2, }, { .cmd = 0x3f, .tag = "fan_command_4", .type = RW2, }, { .cmd = 0x40, .tag = "vout_ov_fault_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x41, .tag = "vout_ov_fault_response", .type = RW1, }, { .cmd = 0x42, .tag = "vout_ov_warn_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x43, .tag = "vout_uv_warn_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x44, .tag = "vout_uv_fault_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x45, .tag = "vout_uv_fault_response", .type = RW1, }, { .cmd = 0x46, .tag = "iout_oc_fault_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x47, .tag = "iout_oc_fault_response", .type = RW1, }, { .cmd = 0x48, .tag = "iout_oc_lv_fault_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x49, .tag = "iout_oc_lv_fault_response", .type = RW1, }, { .cmd = 0x4a, .tag = "iout_oc_warn_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x4b, .tag = "iout_uc_fault_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x4c, .tag = "iout_uc_fault_response", .type = RW1, }, { .cmd = 0x4f, .tag = "ot_fault_limit", .type = RW2, .units = DEGREES_C,}, { .cmd = 0x50, .tag = "ot_fault_response", .type = RW1, }, { .cmd = 0x51, .tag = "ot_warn_limit", .type = RW2, .units = DEGREES_C,}, { .cmd = 0x52, .tag = "ut_warn_limit", .type = RW2, .units = DEGREES_C,}, { .cmd = 0x53, .tag = "ut_fault_limit", .type = RW2, .units = DEGREES_C,}, { .cmd = 0x54, .tag = "ut_fault_response", .type = RW1, }, { .cmd = 0x55, .tag = "vin_ov_fault_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x56, .tag = "vin_ov_fault_response", .type = RW1, }, { .cmd = 0x57, .tag = "vin_ov_warn_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x58, .tag = "vin_uv_warn_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x59, .tag = "vin_uv_fault_limit", .type = RW2, .units = VOLTS, }, { .cmd = 0x5a, .tag = "vin_uv_fault_response", .type = RW1, }, { .cmd = 0x5b, .tag = "iin_oc_fault_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x5c, .tag = "iin_oc_fault_response", .type = RW1, }, { .cmd = 0x5d, .tag = "iin_oc_warn_limit", .type = RW2, .units = AMPERES, }, { .cmd = 0x5e, .tag = "power_good_on", .type = RW2, .units = VOLTS, }, { .cmd = 0x5f, .tag = "power_good_off", .type = RW2, .units = VOLTS, }, { .cmd = 0x60, .tag = "ton_delay", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x61, .tag = "ton_rise", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x62, .tag = "ton_max_fault_limit", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x63, .tag = "ton_max_fault_response", .type = RW1, }, { .cmd = 0x64, .tag = "toff_delay", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x65, .tag = "toff_fall", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x66, .tag = "toff_max_warn_limit", .type = RW2, .units = MILLISECONDS, }, { .cmd = 0x68, .tag = "pout_op_fault_limit", .type = RW2, .units = WATTS, }, { .cmd = 0x69, .tag = "pout_op_fault_response", .type = RW1, }, { .cmd = 0x6a, .tag = "pout_op_warn_limit", .type = RW2, .units = WATTS, }, { .cmd = 0x6b, .tag = "pin_op_warn_limit", .type = RW2, .units = WATTS, }, { .cmd = PMB_STATUS_BYTE, .tag = "status_byte", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_WORD, .tag = "status_word", .type = R2, .units = BITS, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_VOUT, .tag = "status_vout", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_IOUT, .tag = "status_iout", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_INPUT, .tag = "status_input", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_TEMPERATURE, .tag = "status_temperature", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_CML, .tag = "status_cml", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_OTHER, .tag = "status_other", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_MFR_SPECIFIC, .tag = "status_mfr_specific", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_FANS_1_2, .tag = "status_fans_1_2", .type = R1, .flags = FLG_STATUS, }, { .cmd = PMB_STATUS_FANS_3_4, .tag = "status_fans_3_4", .type = R1, .flags = FLG_STATUS, }, { .cmd = 0x88, .tag = "read_vin", .type = R2, .units = VOLTS, }, { .cmd = 0x89, .tag = "read_iin", .type = R2, .units = AMPERES, }, { .cmd = 0x8a, .tag = "read_vcap", .type = R2, .units = VOLTS, }, { .cmd = 0x8b, .tag = "read_vout", .type = R2, .units = VOLTS, }, { .cmd = 0x8c, .tag = "read_iout", .type = R2, .units = AMPERES, }, { .cmd = 0x8d, .tag = "read_temperature_1", .type = R2, .units = DEGREES_C, }, { .cmd = 0x8e, .tag = "read_temperature_2", .type = R2, .units = DEGREES_C, }, { .cmd = 0x8f, .tag = "read_temperature_3", .type = R2, .units = DEGREES_C, }, { .cmd = 0x90, .tag = "read_fan_speed_1", .type = R2, }, { .cmd = 0x91, .tag = "read_fan_speed_2", .type = R2, }, { .cmd = 0x92, .tag = "read_fan_speed_3", .type = R2, }, { .cmd = 0x93, .tag = "read_fan_speed_4", .type = R2, }, { .cmd = 0x94, .tag = "read_duty_cycle", .type = R2, }, { .cmd = 0x95, .tag = "read_frequency", .type = R2, }, { .cmd = 0x96, .tag = "read_pout", .type = R2, .units = WATTS, }, { .cmd = 0x97, .tag = "read_pin", .type = R2, .units = WATTS, }, { .cmd = PMB_PMBUS_REVISION, .tag = "pmbus_revision", .type = R1, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_ID, .tag = "mfr_id", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_MODEL, .tag = "mfr_model", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_REVISION, .tag = "mfr_revision", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_LOCATION, .tag = "mfr_location", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_DATE, .tag = "mfr_date", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = PMB_MFR_SERIAL, .tag = "mfr_serial", .type = RWB, .units = STRING, .flags = FLG_SHOW_P1, }, { .cmd = 0xa0, .tag = "mfr_vin_min", .type = R2, .units = VOLTS, }, { .cmd = 0xa1, .tag = "mfr_vin_max", .type = R2, .units = VOLTS, }, { .cmd = 0xa2, .tag = "mfr_iin_max", .type = R2, .units = AMPERES, }, { .cmd = 0xa3, .tag = "mfr_pin_max", .type = R2, .units = WATTS, }, { .cmd = 0xa4, .tag = "mfr_vout_min", .type = R2, .units = VOLTS, }, { .cmd = 0xa5, .tag = "mfr_vout_max", .type = R2, .units = VOLTS, }, { .cmd = 0xa5, .tag = "mfr_iout_max", .type = R2, .units = AMPERES, }, { .cmd = 0xa7, .tag = "mfr_pout_max", .type = R2, .units = WATTS, }, { .cmd = 0xa8, .tag = "mfr_tambient_max", .type = R2, .units = DEGREES_C, }, { .cmd = 0xa9, .tag = "mfr_tambient_min", .type = R2, .units = DEGREES_C, }, { .cmd = 0xaa, .tag = "mfr_efficiency_ll", .type = RWB14, }, { .cmd = 0xab, .tag = "mfr_efficiency_hl", .type = RWB14, }, { .cmd = PMB_USER_DATA(0), .tag = "user_data_00", .type = RWB, }, { .cmd = PMB_USER_DATA(1), .tag = "user_data_01", .type = RWB, }, { .cmd = PMB_USER_DATA(2), .tag = "user_data_02", .type = RWB, }, { .cmd = PMB_USER_DATA(3), .tag = "user_data_03", .type = RWB, }, { .cmd = PMB_USER_DATA(4), .tag = "user_data_04", .type = RWB, }, { .cmd = PMB_USER_DATA(5), .tag = "user_data_05", .type = RWB, }, { .cmd = PMB_USER_DATA(6), .tag = "user_data_06", .type = RWB, }, { .cmd = PMB_USER_DATA(7), .tag = "user_data_07", .type = RWB, }, { .cmd = PMB_USER_DATA(8), .tag = "user_data_08", .type = RWB, }, { .cmd = PMB_USER_DATA(9), .tag = "user_data_09", .type = RWB, }, { .cmd = PMB_USER_DATA(10), .tag = "user_data_10", .type = RWB, }, { .cmd = PMB_USER_DATA(11), .tag = "user_data_11", .type = RWB, }, { .cmd = PMB_USER_DATA(12), .tag = "user_data_12", .type = RWB, }, { .cmd = PMB_USER_DATA(13), .tag = "user_data_13", .type = RWB, }, { .cmd = PMB_USER_DATA(14), .tag = "user_data_14", .type = RWB, }, { .cmd = PMB_USER_DATA(15), .tag = "user_data_15", .type = RWB, }, { .cmd = PMB_MFR_SPECIFIC(0), .tag = "mfr_specific_00", }, { .cmd = PMB_MFR_SPECIFIC(1), .tag = "mfr_specific_01", }, { .cmd = PMB_MFR_SPECIFIC(2), .tag = "mfr_specific_02", }, { .cmd = PMB_MFR_SPECIFIC(3), .tag = "mfr_specific_03", }, { .cmd = PMB_MFR_SPECIFIC(4), .tag = "mfr_specific_04", }, { .cmd = PMB_MFR_SPECIFIC(5), .tag = "mfr_specific_05", }, { .cmd = PMB_MFR_SPECIFIC(6), .tag = "mfr_specific_06", }, { .cmd = PMB_MFR_SPECIFIC(7), .tag = "mfr_specific_07", }, { .cmd = PMB_MFR_SPECIFIC(8), .tag = "mfr_specific_08", }, { .cmd = PMB_MFR_SPECIFIC(9), .tag = "mfr_specific_09", }, { .cmd = PMB_MFR_SPECIFIC(10), .tag = "mfr_specific_10", }, { .cmd = PMB_MFR_SPECIFIC(11), .tag = "mfr_specific_11", }, { .cmd = PMB_MFR_SPECIFIC(12), .tag = "mfr_specific_12", }, { .cmd = PMB_MFR_SPECIFIC(13), .tag = "mfr_specific_13", }, { .cmd = PMB_MFR_SPECIFIC(14), .tag = "mfr_specific_14", }, { .cmd = PMB_MFR_SPECIFIC(15), .tag = "mfr_specific_15", }, { .cmd = PMB_MFR_SPECIFIC(16), .tag = "mfr_specific_16", }, { .cmd = PMB_MFR_SPECIFIC(17), .tag = "mfr_specific_17", }, { .cmd = PMB_MFR_SPECIFIC(18), .tag = "mfr_specific_18", }, { .cmd = PMB_MFR_SPECIFIC(19), .tag = "mfr_specific_19", }, { .cmd = PMB_MFR_SPECIFIC(20), .tag = "mfr_specific_20", }, { .cmd = PMB_MFR_SPECIFIC(21), .tag = "mfr_specific_21", }, { .cmd = PMB_MFR_SPECIFIC(22), .tag = "mfr_specific_22", }, { .cmd = PMB_MFR_SPECIFIC(23), .tag = "mfr_specific_23", }, { .cmd = PMB_MFR_SPECIFIC(24), .tag = "mfr_specific_24", }, { .cmd = PMB_MFR_SPECIFIC(25), .tag = "mfr_specific_25", }, { .cmd = PMB_MFR_SPECIFIC(26), .tag = "mfr_specific_26", }, { .cmd = PMB_MFR_SPECIFIC(27), .tag = "mfr_specific_27", }, { .cmd = PMB_MFR_SPECIFIC(29), .tag = "mfr_specific_28", }, { .cmd = PMB_MFR_SPECIFIC(29), .tag = "mfr_specific_29", }, { .cmd = PMB_MFR_SPECIFIC(30), .tag = "mfr_specific_30", }, { .cmd = PMB_MFR_SPECIFIC(31), .tag = "mfr_specific_31", }, { .cmd = PMB_MFR_SPECIFIC(32), .tag = "mfr_specific_32", }, { .cmd = PMB_MFR_SPECIFIC(33), .tag = "mfr_specific_33", }, { .cmd = PMB_MFR_SPECIFIC(34), .tag = "mfr_specific_34", }, { .cmd = PMB_MFR_SPECIFIC(35), .tag = "mfr_specific_35", }, { .cmd = PMB_MFR_SPECIFIC(36), .tag = "mfr_specific_36", }, { .cmd = PMB_MFR_SPECIFIC(37), .tag = "mfr_specific_37", }, { .cmd = PMB_MFR_SPECIFIC(38), .tag = "mfr_specific_38", }, { .cmd = PMB_MFR_SPECIFIC(39), .tag = "mfr_specific_39", }, { .cmd = PMB_MFR_SPECIFIC(40), .tag = "mfr_specific_40", }, { .cmd = PMB_MFR_SPECIFIC(41), .tag = "mfr_specific_41", }, { .cmd = PMB_MFR_SPECIFIC(42), .tag = "mfr_specific_42", }, { .cmd = PMB_MFR_SPECIFIC(43), .tag = "mfr_specific_43", }, { .cmd = PMB_MFR_SPECIFIC(44), .tag = "mfr_specific_44", }, { .cmd = PMB_MFR_SPECIFIC(45), .tag = "mfr_specific_45", }, { .cmd = 0xfe, .tag = "mfr_specific_command_ext", }, { .cmd = 0xff, .tag = "pmbus_command_ext", }, { /* ZEROES TERMINATE THIS LIST */ }, }; static struct pmbus_cmd_desc unsupported = { .tag = "UNSUPPORTED", }; /*----------------------------------------------------------------------*/ struct pmbus_dev { int fd; unsigned long funcs; char *bus; u8 addr; /* on bus */ u8 revision; u8 capability; u8 no_query; u8 use_pec; struct pmbus_cmd_desc *op[256]; }; static int verbose; static int enable_pec; /*----------------------------------------------------------------------*/ /* * The only userspace code for SMBus ops I found comes with a libsensors * package that clobbers <linux/i2c-dev.h> on install. And what we need * is PMBus ops anyway... hence this code, which understands some of the * ways that PMBus differs from SMBus. * * Use of 2-byte commands is rejected, but comments show how it could * be implemented with reasonable portability. * * REVISIT return values handling ... "errno" seems to be meaningless * since it's almost always EPERM (1), sigh. */ /* Send a bit to the device, if it's present. */ static inline int smbus_quick(int fd, int flag) { struct i2c_smbus_ioctl_data arg; memset(&arg, 0, sizeof arg); arg.read_write = flag ? I2C_SMBUS_READ : I2C_SMBUS_WRITE; /* no command */ arg.size = I2C_SMBUS_QUICK; /* no data */ if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; return 0; } /*----------------------------------------------------------------------*/ /* * READ operations */ /* Returns a byte, or negative errno. */ static int pmbus_read_byte_data(int fd, u16 cmd) { struct i2c_smbus_ioctl_data arg; u8 byte; /* use i2c; or READ_I2C_BLOCK_2: 2 byte cmd, 1 byte block */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_READ; arg.command = cmd; arg.size = I2C_SMBUS_BYTE_DATA; arg.data = (union i2c_smbus_data *) &byte; if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; return byte; } /* Returns a word, or negative errno. */ static int pmbus_read_word_data(int fd, u16 cmd) { struct i2c_smbus_ioctl_data arg; u16 word; /* use i2c; or READ_I2C_BLOCK_2: 2 byte cmd, 2 byte block */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_READ; arg.command = cmd; arg.size = I2C_SMBUS_WORD_DATA; arg.data = (union i2c_smbus_data *) &word; if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; /* adapter code handled byteswapping if needed */ return word; } /* Returns the number of bytes copied into read_buf, or negative errno. * If the block is bigger than read_len, read_len is copied and -E2BIG * is returned (so the caller can recover, somewhat). */ static int pmbus_read_block(struct pmbus_dev *pmdev, u16 cmd, unsigned read_len, u8 *read_buf) { struct i2c_smbus_ioctl_data arg; union i2c_smbus_data data; int retval; int len; if (!read_buf || read_len == 0) return -EINVAL; /* use i2c; or READ_I2C_BLOCK_2: 2 byte cmd, N byte block */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; /* Handle "large" blocks sanely by issuing an extra read to * prevent one fault-path traversal (e.g. SMBALERT#) when the * block is bigger than the morsel allowed by SMBus. */ len = pmbus_read_byte_data(pmdev->fd, cmd); if (len < 0) return len; if (len > I2C_SMBUS_BLOCK_MAX) { retval = -EFBIG; goto try_i2c; } /* If there's no SMBus support, I2C will work (we checked). * Or, we might use "I2C block read" for up to 31 data bytes. */ if (!(pmdev->funcs & I2C_FUNC_SMBUS_READ_BLOCK_DATA)) { retval = -EOPNOTSUPP; goto try_i2c; } memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_READ; arg.command = cmd; arg.size = I2C_SMBUS_BLOCK_DATA; arg.data = &data; /* When this fails, we can't really know why. In case it's the * SMBus code saying "block too big", try again (if possible). */ if (ioctl(pmdev->fd, I2C_SMBUS, &arg) < 0) { retval = -errno; goto try_i2c; } if (data.block[0] <= read_len) { if (data.block[0] > 32) { /* NOTE: this probably won't be visible */ retval = -EFBIG; goto try_i2c; } retval = read_len = data.block[0]; } else retval = -E2BIG; memcpy(read_buf, &data.block[1], read_len); return retval; try_i2c: /* NOTE: no PEC here, but it *could* be done here in userspace */ if (pmdev->funcs & I2C_FUNC_I2C) { struct i2c_msg msg[2]; struct i2c_rdwr_ioctl_data msgdat; u8 buf[256]; msgdat.msgs = msg; msgdat.nmsgs = 2; msg[0].addr = msg[1].addr = pmdev->addr; buf[0] = cmd & 0x0ff; msg[0].flags = 0; msg[0].len = 1; msg[0].buf = buf; msg[1].flags = I2C_M_RD; msg[1].len = len + 1; msg[1].buf = buf; if (ioctl(pmdev->fd, I2C_RDWR, &msgdat) < 0) return -errno; if (buf[0] <= read_len) retval = read_len = buf[0]; else retval = -E2BIG; memcpy(read_buf, &buf[1], read_len); } return retval; } /*----------------------------------------------------------------------*/ /* * WRITE operations */ /* This is ONLY to temporarily shut up some gcc warnings; most * of the write-side infrastructure is not yet used here. */ #define SHADDAP inline /* With PMBus, transactions may never start with the "read" bit set. * That includes "Quick" messages. Break that rule and get a CML * alert (e.g. SMBALERT#). */ static int pmbus_quick(int fd) { return smbus_quick(fd, 0); } /* Returns zero, or negative errno. */ static int smbus_write_byte(int fd, u8 byte) { struct i2c_smbus_ioctl_data arg; memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_WRITE; arg.command = byte; arg.size = I2C_SMBUS_BYTE; if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; return 0; } /* Returns zero, or negative errno. */ static SHADDAP int pmbus_write_byte_data(int fd, u16 cmd, u8 byte) { struct i2c_smbus_ioctl_data arg; /* use i2c; or WRITE_I2C_BLOCK_2: 2 byte cmd, 1 byte block; * or tweak params to SMBus "write word" */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_WRITE; arg.command = cmd; arg.size = I2C_SMBUS_BYTE_DATA; arg.data = (union i2c_smbus_data *) &byte; if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; return 0; } /* Returns zero, or negative errno. */ static SHADDAP int pmbus_write_word_data(int fd, u16 cmd, u16 word) { struct i2c_smbus_ioctl_data arg; /* use i2c; or WRITE_I2C_BLOCK_2: 2 byte cmd, 2 byte block */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; /* adapter code handles byteswapping if needed */ memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_WRITE; arg.command = cmd; arg.size = I2C_SMBUS_WORD_DATA; arg.data = (union i2c_smbus_data *) &word; if (ioctl(fd, I2C_SMBUS, &arg) < 0) return -errno; return 0; } /* Returns zero, or negative errno. */ static SHADDAP int pmbus_write_block(struct pmbus_dev *pmdev, u16 cmd, unsigned write_len, u8 *write_buf) { struct i2c_smbus_ioctl_data arg; union i2c_smbus_data data; int retval; if (!write_buf || write_len == 0 || write_len > 255) return -EINVAL; /* use i2c; or WRITE_I2C_BLOCK_2: 2 byte cmd, N byte block */ if (is_pmb_extended(cmd)) return -ENOSYS; if (!is_pmb_8bit(cmd)) return -EINVAL; /* If there's no SMBus support, I2C might work (we did NOT ensure * there will be one or the other) */ if (!(pmdev->funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) { retval = -EOPNOTSUPP; goto try_i2c; } if (write_len > 32) { retval = -EFBIG; goto try_i2c; } data.block[0] = write_len; memcpy(&data.block[1], write_buf, write_len); memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_WRITE; arg.command = cmd; arg.size = I2C_SMBUS_BLOCK_DATA; arg.data = &data; if (ioctl(pmdev->fd, I2C_SMBUS, &arg) < 0) return -errno; return 0; try_i2c: /* NOTE: no PEC here, but it *could* be done here in userspace */ if (pmdev->funcs & I2C_FUNC_I2C) { struct i2c_msg msg; struct i2c_rdwr_ioctl_data msgdat; u8 buf[257]; msgdat.msgs = &msg; msgdat.nmsgs = 1; msg.addr = pmdev->addr; msg.flags = 0; msg.len = 2 + write_len; msg.buf = buf; buf[0] = cmd; buf[1] = write_len; memcpy(&buf[2], write_buf, write_len); retval = (ioctl(pmdev->fd, I2C_RDWR, &msgdat) < 0) ? -errno : 0; } return retval; } /*----------------------------------------------------------------------*/ static void coefficients(struct pmbus_dev *pmdev, struct pmbus_cmd_desc *op, int read) { union i2c_smbus_data data; int status; struct pmbus_coefficients *c; read = !!read; c = op->c + read; /* This is specified as a block proc call, which is currently not * widely supported. The I2C-level backup makes sure that many * more systems can use this call. * * NOTE as with QUERY, handling for "extended" commands is not * specified by PMBus 1.1 ... */ if (pmdev->funcs & I2C_FUNC_SMBUS_BLOCK_PROC_CALL) { struct i2c_smbus_ioctl_data arg; data.block[0] = 2; data.block[1] = op->cmd; data.block[2] = read; memset(&arg, 0, sizeof arg); arg.read_write = I2C_SMBUS_WRITE; arg.command = PMB_COEFFICIENTS; arg.size = I2C_SMBUS_BLOCK_PROC_CALL; arg.data = &data; status = ioctl(pmdev->fd, I2C_SMBUS, &arg); /* NOTE: no PEC here, but it *could* be done here in userspace */ } else if (pmdev->funcs & I2C_FUNC_I2C) { struct i2c_msg msg[2]; struct i2c_rdwr_ioctl_data msgdat; msgdat.msgs = msg; msgdat.nmsgs = 2; msg[0].addr = msg[1].addr = pmdev->addr; msg[0].flags = 0; msg[0].len = 4; msg[0].buf = data.block; data.block[0] = PMB_COEFFICIENTS; data.block[1] = 2; data.block[2] = op->cmd; data.block[3] = read; msg[1].flags = I2C_M_RD; msg[1].len = 6; msg[1].buf = data.block; status = ioctl(pmdev->fd, I2C_RDWR, &msgdat); } else status = -EOPNOTSUPP; if (status < 0) return; if (data.block[0] != 5) return; c->m = (data.block[2] << 8) | data.block[1]; c->b = (data.block[4] << 8) | data.block[3]; c->R = data.block[5]; c->valid = 1; } static void query(struct pmbus_dev *pmdev, struct pmbus_cmd_desc *op) { struct i2c_smbus_ioctl_data arg; u16 word; /* NOTE query for "extended" commands is not specified by PMBus 1.1; * presumably that will just send a two byte block (which can't use * the portability tweak below). Fortunately there's no evident * need to support such two-byte commands yet. */ if (op->cmd > 0xff) return; /* This is specified as a block proc call, which is currently not * widely supported. Instead, implement this using normal proc * calls, which are more widely available. */ word = (op->cmd << 8) | 1; memset(&arg, 0, sizeof arg); arg.command = PMB_QUERY; arg.size = I2C_SMBUS_PROC_CALL; arg.data = (union i2c_smbus_data *) &word; if (ioctl(pmdev->fd, I2C_SMBUS, &arg) < 0 || (word & 0x00ff) != 1) { /* REVISIT we _really_ want QUERY to work, so it'd be nice * to recover from transient faults here. If we could tell * such faults from real ones, that is... instead of seeing * false EPERM reports for everything in the I2C stack. */ pmdev->no_query = 1; return; } word >>= 8; /* query supported, but not this operation? */ if (!(word & (1 << 7))) { pmdev->op[op->cmd] = &unsupported; return; } /* NOTE eventually use copy/clone here instead of in-place mutate, * when managing multiple devices concurrently */ op->query = word; pmdev->op[op->cmd] = op; /* Try to get the coefficients for DIRECT format numbers */ if (((word >> 2) & 7) == 3 && pmdev->op[PMB_COEFFICIENTS]) { if (word & (1 << 5)) /* read (always) */ coefficients(pmdev, op, 1); if (word & (1 << 6)) /* write */ coefficients(pmdev, op, 0); } } /* Return: negative = can't tell, 0 = no, 1 = yes */ static int checksupport(struct pmbus_dev *pmdev, u16 cmd) { /* NOTE: no revision check. QUERY is a PMBUS 1.1 addition, * but the device's PMBus revision may not be exposed. * * NOTE: this assumes we can check prefixes for PMB_MFR_EXT(x) * and PMB_EXT(x) operations, even though we can't query those * operations directly... */ if (is_pmb_extended(cmd)) return -1; if (pmdev->op[PMB_QUERY] == &unsupported || pmdev->no_query) return -1; if (!pmdev->op[cmd]) { struct pmbus_cmd_desc *op = pmbus_ops; for (op = pmbus_ops; !pmdev->no_query && op->tag; op++) { if (op->cmd == cmd) { query(pmdev, op); break; } } } return pmdev->op[cmd] != &unsupported; } static char *pmbus_read_string(struct pmbus_dev *pmdev, u16 cmd) { u8 buf[256]; int status; /* For non-queryable devices we'll still try to read inventory * data strings. That should be harmless but informative. */ if (checksupport(pmdev, cmd) == 0) return NULL; memset(buf, 0, sizeof buf); status = pmbus_read_block(pmdev, cmd, sizeof buf - 1, buf); return (status > 0) ? strdup((void *)buf) : NULL; } /*----------------------------------------------------------------------*/ static char *units(struct pmbus_cmd_desc *op) { switch (op->units) { case VOLTS: return "Volts"; case AMPERES: return "Amperes"; case MILLISECONDS: return "milliseconds"; case DEGREES_C: return "degrees Celsius"; case WATTS: return "Watts"; default: return NULL; } } /*----------------------------------------------------------------------*/ static void pmbus_list_inventory(struct pmbus_dev *pmdev) { char *mfr = pmbus_read_string(pmdev, PMB_MFR_ID); char *model = pmbus_read_string(pmdev, PMB_MFR_MODEL); char *revision = pmbus_read_string(pmdev, PMB_MFR_REVISION); char *location = pmbus_read_string(pmdev, PMB_MFR_LOCATION); char *date = pmbus_read_string(pmdev, PMB_MFR_DATE); char *serial = pmbus_read_string(pmdev, PMB_MFR_SERIAL); if (!mfr && !model && !revision && !location && !date && !serial) return; /* REVISIT might be useful to fetch all these strings and save * them away. They're the first handle we have on just what * kind of device we're working with... */ printf("Inventory Data:\n"); if (mfr) { printf(" Manufacturer:\t\t%s\n", mfr); free(mfr); } if (model) { printf(" Model:\t\t%s\n", model); free(model); } if (mfr) { printf(" Revision:\t\t%s\n", revision); free(revision); } if (location) { printf(" Built at:\t\t%s\n", location); free(location); } if (date) { printf(" Built on:\t\t%s\n", date); free(date); } if (serial) { printf(" Serial:\t\t%s\n", serial); free(serial); } printf("\n"); } static void pmbus_dev_show_p1(struct pmbus_dev *pmdev) { const char *s0, *s1; struct pmbus_cmd_desc *op; printf("PMBus slave on %s, address %#02x\n\n", pmdev->bus, pmdev->addr); pmbus_list_inventory(pmdev); /* * NOTE spec bug: table shows two four bit masks, which are * described as two fields, 3 bits 7-5 and 5 bits 4-0 ... in * fact part II probably deserves an extra bit. Rev 1.0 of the * spec said the fields are 3 and 5 bits; let's be compatible. */ switch ((pmdev->revision >> 5) & 0x07) { case 0: s1 = "1.0"; break; case 1: s1 = "1.1"; break; default: s1 = "?"; break; } switch (pmdev->revision & 0x1f) { case 0: s0 = "1.0"; break; case 1: s0 = "1.1"; break; default: s0 = "?"; break; } printf("PMBus revisions (%#02x):\tpart I, ver %s; part II, ver %s\n", pmdev->revision, s1, s0); if (pmdev->capability & 0xf0) { switch ((pmdev->capability >> 5) & 3) { case 0: s0 = "100 KHz"; break; case 1: s0 = "400 KHz"; break; default: s0 = "?speed?"; break; } printf("Capabilities (%#02x):\t%s%s%s\n", pmdev->capability, (pmdev->capability & (1 << 7)) ? "PEC, " : "", (pmdev->capability & (1 << 4)) ? "SMBALERT#, ": "", s0); } printf("\n"); if (pmdev->no_query) { printf("Device can't QUERY for supported commands\n"); return; } for (op = pmbus_ops; !pmdev->no_query && op->tag; op++) query(pmdev, op); } /*----------------------------------------------------------------------*/ static void showbits(u16 mask, int i, char *bits[]) { int comma = 0; while (i-- > 0) { if (!(mask & (1 << i))) continue; printf("%s%s", comma++ ? ", " : "", bits[i] ? : "?"); } } void status_byte(struct pmbus_dev *pmdev, u16 cmd, char *label, char *bits[]) { int value; int mode; mode = checksupport(pmdev, cmd); if (mode == 0) return; value = pmbus_read_byte_data(pmdev->fd, cmd); if (value < 0) { if (mode == 1) printf(" ** Device failed read of STATUS_%s?\n", label); return; } printf(" %-21s %02x: ", label, value); showbits(value, 8, bits); printf("\n"); } static void show_status_vout(struct pmbus_dev *pmdev) { static char *bits[8] = { /* FIXME list the bit labels */ }; status_byte(pmdev, PMB_STATUS_VOUT, "VOUT", bits); } static void show_status_iout(struct pmbus_dev *pmdev) { static char *bits[8] = { /* FIXME list the bit labels */ }; status_byte(pmdev, PMB_STATUS_IOUT, "IOUT", bits); } static void show_status_input(struct pmbus_dev *pmdev) { static char *bits[8] = { /* FIXME list the bit labels */ }; status_byte(pmdev, PMB_STATUS_INPUT, "INPUT", bits); } static void show_status_mfr_specific(struct pmbus_dev *pmdev) { static char *bits[8] = { "mfr_status_0", "mfr_status_1", "mfr_status_2", "mfr_status_3", "mfr_status_4", "mfr_status_5", "mfr_status_6", "mfr_status_7", }; status_byte(pmdev, PMB_STATUS_MFR_SPECIFIC, "MFR_SPECIFIC", bits); } static void show_status_fans(struct pmbus_dev *pmdev) { static char *bits1_2[8] = { "airflow warning", "airflow fault", "fan 2 speed override", "fan 1 speed override", "fan 2 warning", "fan 1 warning", "fan 2 fault", "fan 1 fault", }; static char *bits3_4[8] = { "(reserved)", "(reserved)", "fan 4 speed override", "fan 3 speed override", "fan 4 warning", "fan 4 warning", "fan 3 fault", "fan 3 fault", }; status_byte(pmdev, PMB_STATUS_FANS_1_2, "FANS_1_2", bits1_2); status_byte(pmdev, PMB_STATUS_FANS_3_4, "FANS_3_4", bits3_4); } static void show_status_other(struct pmbus_dev *pmdev) { static char *bits[8] = { /* FIXME list the bit labels */ }; status_byte(pmdev, PMB_STATUS_OTHER, "OTHER", bits); } static void show_status_temperature(struct pmbus_dev *pmdev) { static char *bits[8] = { "(reserved)", "(reserved)", "(reserved)", "(reserved)", "overtemp warning", "overtemp fault", "undertemp warning", "undertemp fault", }; status_byte(pmdev, PMB_STATUS_TEMPERATURE, "TEMPERATURE", bits); } static void show_status_cml(struct pmbus_dev *pmdev) { static char *bits[8] = { "other memory/logic fault", "other comm fault", "(reserved)", "processor fault", "memory fault", "PEC", "invalid data", "invalid command", }; status_byte(pmdev, PMB_STATUS_CML, "CML", bits); } static void pmbus_dev_show_status(struct pmbus_dev *pmdev) { static char *bits[16] = { "unspecified", "comm/memory/logic", "temperature", "vin_underflow", "iout_overflow", "vout_overflow", "off", "busy", "unknown", "other", "fan", "power_good#", "mfr", "vin", "iout", "vout", }; int value = -EINVAL; int mode; /* prefer full status word if it's available */ mode = checksupport(pmdev, PMB_STATUS_WORD); if (mode != 0) { value = pmbus_read_word_data(pmdev->fd, PMB_STATUS_WORD); if (mode == 1 && value < 0) { printf(" ** Device failed read of STATUS_%s?\n", "WORD"); return; } if (value >= 0) printf("Status %04x: ", value); } /* else use status byte */ if (value < 0) { mode = checksupport(pmdev, PMB_STATUS_BYTE); if (mode != 0) { value = pmbus_read_byte_data(pmdev->fd, PMB_STATUS_BYTE); if (value < 0) { if (mode == 1) printf(" ** Device failed read" "of STATUS_%s?\n", "BYTE"); return; } printf("Status %02x: ", value); } } showbits(value, 16, bits); printf("\n"); if (value & ((1 << 15) | (1 << 5))) show_status_vout(pmdev); if (value & ((1 << 14) | (1 << 4))) show_status_iout(pmdev); if (value & ((1 << 13) | (1 << 3))) show_status_input(pmdev); if (value & (1 << 12)) show_status_mfr_specific(pmdev); if (value & (1 << 10)) show_status_fans(pmdev); if (value & (1 << 9)) show_status_other(pmdev); if (value & (1 << 2)) show_status_temperature(pmdev); if (value & (1 << 1)) show_status_cml(pmdev); printf("\n"); } /*----------------------------------------------------------------------*/ static void pmbus_dev_show_commands(struct pmbus_dev *pmdev) { unsigned i; struct pmbus_cmd_desc *op; printf("Supported Commands:\n"); for (i = 0; i < 255; i++) { char *format; int direct = 0; op = pmdev->op[i]; if (op == &unsupported || !op) continue; /* command inputs and outputs */ switch (op->type) { case W0: format = "nodata"; break; case RW1: case W1: case R1: format = "u8 (bitmask)"; break; case RW2: case R2: switch ((op->query >> 2) & 7) { case 0: if (op->units == BITS) format = "u16 (bitmask)"; else format = "s16 (LINEAR)"; break; case 3: format = "s16 (DIRECT)"; direct = 1; break; case 5: format = "u16 (VID)"; break; case 6: format = "x16 (MFR)"; break; default: format = "x16 (UNKNOWN)"; break; } break; case RWB: case RWB14: format = "block"; break; case RWP_QUERY: case RWP_COEFF: format = "process_call"; break; default: format = "(UNKNOWN call syntax)"; break; } /* Now display it all */ printf(" %02x %-25s %c%c %s", op->cmd, op->tag, (op->query & (1 << 5)) ? 'r' : ' ', (op->query & (1 << 6)) ? 'w' : ' ', format); format = units(op); if (format == NULL && op->units == STRING) format = "ISO 8859/1 string"; if (format) printf(", %s", format); printf("\n"); /* dump coefficients; "always" R, maybe W too */ if (direct && (op->c[1].valid || op->c[0].valid)) { printf(" Coefficients: "); if (op->c[1].valid) /* Read */ printf("READ b=%d m=%d R=%d", op->c[1].b, op->c[1].m, op->c[1].R); else printf("no READ coefficients?"); if (op->c[0].valid) /* Write */ printf("; WRITE b=%d m=%d R=%d", op->c[0].b, op->c[0].m, op->c[0].R); printf("\n"); } } } static void pmbus_dev_show_values(struct pmbus_dev *pmdev) { unsigned i; struct pmbus_cmd_desc *op; printf("Attribute Values:\n"); for (i = 0; i < 255; i++) { int value; const char *name; op = pmdev->op[i]; if (op == &unsupported || !op) continue; if (op->flags & (FLG_SHOW_P1|FLG_STATUS)) continue; name = op->tag; if (strncmp(name, "read_", 5) == 0) name += 5; /* read and display values, where that's meaningful */ switch (op->type) { case W0: case W1: case RWP_QUERY: case RWP_COEFF: default: /* write-only or magic */ continue; case RW1: case R1: value = pmbus_read_byte_data(pmdev->fd, op->cmd); if (value < 0) { /* FIXME display a diagnostic */ continue; } printf(" %-21s %02x: ", name, value); /* FIXME need per-op (bitmask) decoders... */ printf("(BITMAP)"); printf("\n"); continue; case RW2: case R2: value = pmbus_read_word_data(pmdev->fd, op->cmd); if (value < 0) { /* FIXME display a diagnostic */ continue; } printf(" %-21s %04x: ", name, value); /* FIXME need decoders */ switch ((op->query >> 2) & 7) { case 0: if (op->units == BITS) { printf("(BITMAP)"); } else { double d = value & 0x03ff; /* LINEAR encoding: * - 11 LSBs are signed mantissa * - 5 LSBs are signed exponent */ if (value & 0x0400) d = -d; if (value & 0x8000) d /= 1 << ((value >> 11) & 0x0f); else if (value & 0x7100) d *= 1 << (value >> 11); printf("%g", d); } break; case 3: { double d; int r; /* DIRECT encoding: * X = ((value * (10 ^ -R)) - b) / m */ d = (s16) value; /* ideally: * d *= exp10((double)-op->c[1].R); * but that, or pow(), can be unavailable */ r = op->c[1].R; if (r < 0) { do { d *= 10.0; r++; } while (r < 0); } else if (r > 0) { do { d /= 10.0; r--; } while (r > 0); } d -= (double)op->c[1].b; d /= (double)op->c[1].m; printf("%g", d); } break; case 5: printf("u16 (VID)"); break; case 6: printf("manufacturer specific"); break; default: printf("unknown format"); break; } break; #if 0 // RWB, /* read/write block (up to 255 bytes) */ // RWB14, /* read/write block (of 14 bytes) */ case RWB: case RWB14: format = "block"; #endif break; } name = units(op); if (name) printf(" %s", name); printf("\n"); } printf("\n"); } static void pmbus_dev_show(struct pmbus_dev *pmdev, bool values, bool cmds) { pmbus_dev_show_p1(pmdev); if (values) { pmbus_dev_show_status(pmdev); pmbus_dev_show_values(pmdev); } if (cmds) pmbus_dev_show_commands(pmdev); } /*----------------------------------------------------------------------*/ static void pmbus_clear_fault(struct pmbus_dev *pmdev) { /* if we know we can't clear faults, don't try */ if (checksupport(pmdev, PMB_CLEAR_FAULT) != 0) (void) smbus_write_byte(pmdev->fd, PMB_CLEAR_FAULT); } /*----------------------------------------------------------------------*/ static int pmbus_dev_scan(struct pmbus_dev *pmdev) { int status; /* SMBus (hence PMBus) devices must always ack their addresses. */ if (pmdev->funcs & I2C_FUNC_SMBUS_QUICK) { status = pmbus_quick(pmdev->fd); if (status < 0) { fprintf(stderr, "No device present? error %d\n", status); return status; } } /* QUERY lets us see what operations this device supports, which is * the most interesting information available without product docs. * * It also lets us avoid making calls we know will fail, which is * polite since such failures will trigger host notification or * SMBALERT# on some devices. If we can't query, we'll just hope * those mechanisms aren't in use. */ checksupport(pmdev, PMB_QUERY); if (checksupport(pmdev, PMB_CAPABILITY) != 0) { status = pmbus_read_byte_data(pmdev->fd, PMB_CAPABILITY); if (status < 0) { if (verbose) fprintf(stderr, "No PMBus capability support; " "assuming no PEC, etc\n"); } else { pmdev->capability = status; /* enable PEC if the device supports it */ if ((status & (1 << 7)) && enable_pec) { if (ioctl(pmdev->fd, I2C_PEC, 1) < 0) fprintf(stderr, "couldn't " "enable PEC\n"); else pmdev->use_pec = 1; } } } /* PMBus 1.0 has PMBUS_REVISION too; it's not new to PMBus 1.1 */ if (checksupport(pmdev, PMB_PMBUS_REVISION) != 0) { status = pmbus_read_byte_data(pmdev->fd, PMB_PMBUS_REVISION); if (status < 0) { if (verbose) fprintf(stderr, "No PMBUS_REVISION support; " "assuming 1.0\n"); } else pmdev->revision = status; } /* * We may not find out anything about the device in the code above; * PMBUS 1.1 conformant devices only need to implement ONE command * that's not manufacturer-specific. * * REVISIT support part definition files, probably using XML as a * relatively neutral syntax that's easily extended and manipulated, * and which doesn't need Yet Another Lowlevel Parser. * * - They should be able to represent all the data we can query * from fully dynamic PMBus 1.1 devices. * * - And support lookup by basic product ID strings, for PMBus 1.0 * devices that may expose little more than those strings and * some sensor/control attributes. * * - Provide a "dump" option, to generate those files for devices * which do happen to be fully query-able. * * - Allow cross-validation (file against device, to find bugs), * and merging (file adds extra data, e.g. coefficients from * docs rather than by protocol requests). * * - File should be able to describe things like manufacturer * specific commands, format of user data, accuracy, how the * various controls and sensors work in the local environment, * what "pages" exist (and what each one does), and so on. * * Doing all that usefully depends on having a variety of PMBus * based products running Linux. At this writing there aren't * very many of them, although some recent Dell rackmount servers * are described as having PMBus support. */ return 0; } /*----------------------------------------------------------------------*/ static const unsigned long i2c_func_pmbus_min = I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_PROC_CALL; int main(int argc, char **argv) { int c; struct pmbus_dev dev; char *adapter = "/dev/i2c-0"; char *addr_tail; int addr; bool clear = false; bool force = false; bool list = false; bool show = false; u8 mfr_cmd = 0; while ((c = getopt(argc, argv, "b:Cflpsv" #ifdef HACK "m:" #endif )) != EOF) { switch (c) { case 'b': adapter = optarg; continue; case 'C': clear = true; continue; case 'f': force = true; continue; case 'l': list = true; continue; #ifdef HACK case 'm': c = atoi(optarg); if (c < 0 || c > 45) { fprintf(stderr, "mfr_specific_%s ??\n", optarg); goto usage; } mfr_cmd = PMB_MFR_SPECIFIC(c); continue; #endif case 'p': enable_pec = 1; continue; case 's': show = true; continue; case 'v': verbose++; continue; case '?': default: goto usage; } } if (optind == argc || *argv[optind] == '\0') { fprintf(stderr, "missing device address\n"); goto usage; } if (optind != (argc - 1)) { fprintf(stderr, "too many arguments\n"); goto usage; } addr = (int) strtol(argv[optind], &addr_tail, 0); if (*addr_tail || addr < 0) { fprintf(stderr, "'%s' is not a device address\n", optarg); goto usage; } /* SMBUS 2.0 table 4 lists reserved addresses */ if (addr < 0x09 || addr > 0x77 || addr == 0x0c || addr == 0x28 || addr == 0x37 || addr == 0x61) { fprintf(stderr, "%#02x' is a reserved device address\n", addr); goto usage; } /* * Set up a handle for the specified device on its bus. */ memset(&dev, 0, sizeof dev); dev.fd = open(adapter, O_RDWR); if (dev.fd < 0) { perror(adapter); fprintf(stderr, "Couldn't connect to I2C bus %s\n", adapter); return 1; } dev.bus = adapter; c = ioctl(dev.fd, I2C_FUNCS, &dev.funcs); if (c < 0) { perror(adapter); fprintf(stderr, "%s: Couldn't get funcs\n", adapter); return 1; } /* Trying for portability here. We want to support all core PMBus * features. Minimal SMBus support is almost good enough ... except * for block read/write and block proc calls. So we insist on I2C * where the SMBus support is weak, and if it's available we also use * it to cope with the annoying "refuse to do 33+ byte blocks" limit. * * NOTE: WRITE_BLOCK isn't currently used -- or required -- so the * pmbus_block_write() method might fail on some systems. If that * matters in your usage, add another test ... */ if ((dev.funcs & i2c_func_pmbus_min) != i2c_func_pmbus_min || !(dev.funcs & (I2C_FUNC_SMBUS_READ_BLOCK_DATA | I2C_FUNC_I2C)) || !(dev.funcs & (I2C_FUNC_SMBUS_BLOCK_PROC_CALL | I2C_FUNC_I2C)) ) { fprintf(stderr, "%s: Funcs don't support PMBus\n", adapter); return 1; } /* some adapter drivers don't support PEC */ if (!(dev.funcs & I2C_FUNC_SMBUS_PEC) && enable_pec) { fprintf(stderr, "%s: No PEC support\n", adapter); enable_pec = 0; } c = ioctl(dev.fd, force ? I2C_SLAVE_FORCE : I2C_SLAVE, addr); if (c < 0) { perror(adapter); fprintf(stderr, "Couldn't %sattach to device %#02x\n", force ? "force " : "", addr); return 1; } dev.addr = addr; if (pmbus_dev_scan(&dev) < 0) return 1; if (show || list) pmbus_dev_show(&dev, show, list); if (clear) pmbus_clear_fault(&dev); #ifdef HACK if (mfr_cmd && checksupport(&dev, mfr_cmd) == 0) { printf("Unsuppported mfr_specific command: %#02x\n", mfr_cmd); mfr_cmd = 0; } if (mfr_cmd) { if (verbose) printf("Issuing mfr_specific command, %#02x...\n", mfr_cmd); /* NOTE: manufacturer commands can be of arbitrary syntax; * the hack here is that we "know" it's write-only, no-data. */ c = smbus_write_byte(dev.fd, mfr_cmd); if (c < 0) fprintf(stderr, "Error %d on mfr cmd %#02x\n", c, mfr_cmd); } #endif return 0; usage: fprintf(stderr, "Usage: %s [options] addr\n" " SMBus address may be in hex, decimal, or octal.\n" " Valid addresses include 0x09-0x77, with exceptions\n" "\n" "Options include:\n" " -b /dev/i2c-X specify I2C bus adapter for bus X\n" " (default bus is i2c-0)\n" " -C clear all status flags\n" " -f bypass 'address in use' checks\n" " (needed with new-style I2C systems)\n" " -l list device capabilities\n" #ifdef HACK " -m NN issue no-param mfr_specific_NN\n" #endif " -p enable PEC, if the device supports it\n" " -s show device status and attribute values\n" " -v be more verbose\n" , argv[0]); return 1; }
