[corsairmi.git] / corsairmi.c

/* 
 * minimal program to read out data from Corsair RMi series of PSUs
 * tested on RM750i
 *
 * Copyright (c) notaz, 2016
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the organization nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * register list from SIV by Ray Hinchliffe
 *
 * left unimplemented:
 * 3a fan mode
 * 3b fan pwm
 * 81 fan status
 * f0 fan1 mode
 *
 * left unknown:
 * 40: e6 d3 00 ... (15.6; const?)
 * 44: 1a d2 00 ... ( 8.4; const?)
 * 46: 2c f1 00 ... (75.0; const?)
 * 4f: 46 00 ...
 * 7a: 00 ...
 * 7b: 00 ...
 * 7d: 00 ...
 * 7e: c0 00 ...
 * c4: 01 00 ...
 * d4: b9 bd eb fe 00 ... (32bit const?)
 * d8: 02 00 ...
 * d9: 00 ...
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/hidraw.h>

static const uint16_t products[] = {
	0x1c0b, /* RM750i */
	0x1c0c, /* RM850i */
};

static void dump(const uint8_t *buf, size_t size)
{
	size_t i, j;

	for (i = 0; i < size; i += 16) {
		for (j = 0; j < 16; j++) {
			if (i + j < size)
				printf(" %02x", buf[i + j]);
			else
				fputs("   ", stdout);
		}
		fputs("  ", stdout);
		for (j = 0; j < 16; j++) {
			if (i + j < size) {
				uint8_t c = buf[i + j];
				printf("%c", 0x20 <= c && c <= 0x7f ? c : '.');
			}
			else
				break;
		}
		puts("");
	}
}

static void send_recv_cmd(int fd, uint8_t b0, uint8_t b1, uint8_t b2,
	void *buf, size_t buf_size)
{
	uint8_t buf_w[65], buf_r[64];
	ssize_t ret;

	memset(buf_w, 0, sizeof(buf_w));
	buf_w[1] = b0;
	buf_w[2] = b1;
	buf_w[3] = b2;
	ret = write(fd, buf_w, sizeof(buf_w));
	if (ret != sizeof(buf_w)) {
		fprintf(stderr, "write %zd/%zd: ", ret, sizeof(buf_w));
		perror(NULL);
		exit(1);
	}

	ret = read(fd, buf_r, sizeof(buf_r));
	if (ret != sizeof(buf_r)) {
		fprintf(stderr, "read %zd/%zd: ", ret, sizeof(buf_r));
		perror(NULL);
		if (ret > 0)
			dump(buf_r, ret);
		exit(1);
	}

	if (buf_r[0] != b0 || buf_r[1] != b1) {
		fprintf(stderr, "unexpected response %02x %02x "
				"to cmd %02x %02x %02x\n",
				buf_r[0], buf_r[1], b0, b1, b2);
		dump(buf_r, sizeof(buf_r));
		exit(1);
	}

	if (buf != NULL && buf_size > 0) {
		if (buf_size > sizeof(buf_r) - 2)
			buf_size = sizeof(buf_r) - 2;
		memcpy(buf, buf_r + 2, buf_size);
	}
}

static void read_reg(int fd, uint8_t reg, void *buf, size_t buf_size)
{
	send_recv_cmd(fd, 0x03, reg, 0x00, buf, buf_size);
}

static void read_reg16(int fd, uint8_t reg, uint16_t *v)
{
	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
	// FIXME: big endian host
}

static void read_reg32(int fd, uint8_t reg, uint32_t *v)
{
	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
	// FIXME: big endian host
}

static double mkv(uint16_t v16)
{
	int p = (int)(int16_t)v16 >> 11;
	int v = ((int)v16 << 21) >> 21;

	return (double)v * pow(2.0, p);
}

static void print_std_reg(int fd, uint8_t reg, const char *fmt, ...)
{
	size_t len = 0;
	uint16_t val;
	va_list ap;

	read_reg16(fd, reg, &val);

	va_start(ap, fmt);
	len += vprintf(fmt, ap);
	len += printf(": ");
	va_end(ap);
	for (; len < 16; len++)
		fputs(" ", stdout);

	printf("%5.1f\n", mkv(val));
}

static int try_open_device(const char *name, int report_errors)
{
	struct hidraw_devinfo info;
	int found = 0;
	int i, ret, fd;

	fd = open(name, O_RDWR);
	if (fd == -1) {
		if (report_errors) {
			fprintf(stderr, "open %s: ", name);
			perror(NULL);
		}
		return -1;
	}

	memset(&info, 0, sizeof(info));
	ret = ioctl(fd, HIDIOCGRAWINFO, &info);
	if (ret != 0) {
		perror("HIDIOCGRAWINFO");
		goto out;
	}

	if (info.vendor != 0x1b1c)
		goto out;

	for (i = 0; i < sizeof(products) / sizeof(products[0]); i++) {
		if (info.product == products[i]) {
			found = 1;
			break;
		}
	}

out:
	if (!found) {
		if (report_errors)
			fprintf(stderr, "unexpected device: %04hx:%04hx\n",
				info.vendor, info.product);
		close(fd);
		fd = -1;
	}
	return fd;
}

int main(int argc, char *argv[])
{
	char name[63];
	uint32_t v32;
	uint8_t osel;
	int i, fd;

	if (argc > 1) {
		if (argv[1][0] == '-' || argc != 2) {
			fprintf(stderr, "usage:\n");
			fprintf(stderr, "%s [/dev/hidrawN]\n", argv[0]);
			return 1;
		}
		fd = try_open_device(argv[1], 1);
	}
	else {
		for (i = 0; i < 16; i++) {
			snprintf(name, sizeof(name), "/dev/hidraw%d", i);
			fd = try_open_device(name, 0);
			if (fd != -1)
				break;
		}
	}

	if (fd == -1)
		return 1;

	name[sizeof(name) - 1] = 0;
	send_recv_cmd(fd, 0xfe, 0x03, 0x00, name, sizeof(name) - 1);
	printf("name:           '%s'\n", name);
	read_reg(fd, 0x99, name, sizeof(name) - 1);
	printf("vendor:         '%s'\n", name);
	read_reg(fd, 0x9a, name, sizeof(name) - 1);
	printf("product:        '%s'\n", name);

	read_reg32(fd, 0xd1, &v32);
	printf("powered:        %u (%dd. %dh)\n",
		v32, v32 / (24*60*60), v32 / (60*60) % 24);
	read_reg32(fd, 0xd2, &v32);
	printf("uptime:         %u (%dd. %dh)\n",
		v32, v32 / (24*60*60), v32 / (60*60) % 24);

	print_std_reg(fd, 0x8d, "temp1");
	print_std_reg(fd, 0x8e, "temp2");
	print_std_reg(fd, 0x90, "fan rpm");
	print_std_reg(fd, 0x88, "supply volts");
	print_std_reg(fd, 0xee, "total watts");

	for (osel = 0; osel < 3; osel++) {
		// reg0 write (output select)
		send_recv_cmd(fd, 0x02, 0x00, osel, NULL, 0);
		print_std_reg(fd, 0x8b, "output%u volts", osel);
		print_std_reg(fd, 0x8c, "output%u amps", osel);
		print_std_reg(fd, 0x96, "output%u watts", osel);
	}

	send_recv_cmd(fd, 0x02, 0x00, 0x00, NULL, 0);

	close(fd);
	return 0;
}
Commit	Line	Data
472ae0c2	1	/*
	2	* minimal program to read out data from Corsair RMi series of PSUs
	3	* tested on RM750i
	4	*
	5	* Copyright (c) notaz, 2016
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions are met:
	9	* * Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* * Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* * Neither the name of the organization nor the
	15	* names of its contributors may be used to endorse or promote products
	16	* derived from this software without specific prior written permission.
	17	*
	18	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	19	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	20	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	21	* ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	22	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	24	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	25	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	26	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	27	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	28	*/
	29	/*
	30	* register list from SIV by Ray Hinchliffe
	31	*
	32	* left unimplemented:
	33	* 3a fan mode
	34	* 3b fan pwm
	35	* 81 fan status
	36	* f0 fan1 mode
	37	*
	38	* left unknown:
	39	* 40: e6 d3 00 ... (15.6; const?)
	40	* 44: 1a d2 00 ... ( 8.4; const?)
	41	* 46: 2c f1 00 ... (75.0; const?)
	42	* 4f: 46 00 ...
	43	* 7a: 00 ...
	44	* 7b: 00 ...
	45	* 7d: 00 ...
	46	* 7e: c0 00 ...
	47	* c4: 01 00 ...
	48	* d4: b9 bd eb fe 00 ... (32bit const?)
	49	* d8: 02 00 ...
	50	* d9: 00 ...
	51	*/
	52
	53	#include <stdio.h>
	54	#include <stdlib.h>
	55	#include <string.h>
	56	#include <stdarg.h>
	57	#include <stdint.h>
	58	#include <math.h>
	59	#include <sys/types.h>
	60	#include <sys/stat.h>
	61	#include <fcntl.h>
	62	#include <sys/ioctl.h>
	63	#include <unistd.h>
	64	#include <linux/hidraw.h>
65
465ea922	66	static const uint16_t products[] = {
	67	0x1c0b, /* RM750i */
	68	0x1c0c, /* RM850i */
	69	};
	70
472ae0c2	71	static void dump(const uint8_t *buf, size_t size)
	72	{
	73	size_t i, j;
	74
	75	for (i = 0; i < size; i += 16) {
	76	for (j = 0; j < 16; j++) {
	77	if (i + j < size)
	78	printf(" %02x", buf[i + j]);
	79	else
	80	fputs(" ", stdout);
	81	}
	82	fputs(" ", stdout);
	83	for (j = 0; j < 16; j++) {
	84	if (i + j < size) {
	85	uint8_t c = buf[i + j];
	86	printf("%c", 0x20 <= c && c <= 0x7f ? c : '.');
	87	}
	88	else
	89	break;
	90	}
	91	puts("");
	92	}
	93	}
	94
	95	static void send_recv_cmd(int fd, uint8_t b0, uint8_t b1, uint8_t b2,
	96	void *buf, size_t buf_size)
	97	{
	98	uint8_t buf_w[65], buf_r[64];
	99	ssize_t ret;
	100
	101	memset(buf_w, 0, sizeof(buf_w));
	102	buf_w[1] = b0;
	103	buf_w[2] = b1;
	104	buf_w[3] = b2;
	105	ret = write(fd, buf_w, sizeof(buf_w));
	106	if (ret != sizeof(buf_w)) {
	107	fprintf(stderr, "write %zd/%zd: ", ret, sizeof(buf_w));
	108	perror(NULL);
	109	exit(1);
	110	}
	111
	112	ret = read(fd, buf_r, sizeof(buf_r));
	113	if (ret != sizeof(buf_r)) {
	114	fprintf(stderr, "read %zd/%zd: ", ret, sizeof(buf_r));
	115	perror(NULL);
	116	if (ret > 0)
	117	dump(buf_r, ret);
	118	exit(1);
	119	}
	120
	121	if (buf_r[0] != b0 \|\| buf_r[1] != b1) {
	122	fprintf(stderr, "unexpected response %02x %02x "
	123	"to cmd %02x %02x %02x\n",
	124	buf_r[0], buf_r[1], b0, b1, b2);
	125	dump(buf_r, sizeof(buf_r));
	126	exit(1);
	127	}
	128
	129	if (buf != NULL && buf_size > 0) {
	130	if (buf_size > sizeof(buf_r) - 2)
	131	buf_size = sizeof(buf_r) - 2;
	132	memcpy(buf, buf_r + 2, buf_size);
	133	}
	134	}
135
136	static void read_reg(int fd, uint8_t reg, void *buf, size_t buf_size)
137	{
138	send_recv_cmd(fd, 0x03, reg, 0x00, buf, buf_size);
139	}
140
141	static void read_reg16(int fd, uint8_t reg, uint16_t *v)
142	{
143	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
144	// FIXME: big endian host
145	}
146
147	static void read_reg32(int fd, uint8_t reg, uint32_t *v)
148	{
149	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
150	// FIXME: big endian host
151	}
152
153	static double mkv(uint16_t v16)
154	{
155	int p = (int)(int16_t)v16 >> 11;
156	int v = ((int)v16 << 21) >> 21;
157
158	return (double)v * pow(2.0, p);
159	}
160
161	static void print_std_reg(int fd, uint8_t reg, const char *fmt, ...)
162	{
163	size_t len = 0;
164	uint16_t val;
165	va_list ap;
166
167	read_reg16(fd, reg, &val);
168
169	va_start(ap, fmt);
170	len += vprintf(fmt, ap);
171	len += printf(": ");
172	va_end(ap);
173	for (; len < 16; len++)
174	fputs(" ", stdout);
175
176	printf("%5.1f\n", mkv(val));
177	}
178
465ea922	179	static int try_open_device(const char *name, int report_errors)
472ae0c2	180	{
472ae0c2	181	struct hidraw_devinfo info;
465ea922	182	int found = 0;
	183	int i, ret, fd;
	184
	185	fd = open(name, O_RDWR);
	186	if (fd == -1) {
	187	if (report_errors) {
	188	fprintf(stderr, "open %s: ", name);
	189	perror(NULL);
	190	}
	191	return -1;
	192	}
	193
	194	memset(&info, 0, sizeof(info));
	195	ret = ioctl(fd, HIDIOCGRAWINFO, &info);
	196	if (ret != 0) {
	197	perror("HIDIOCGRAWINFO");
	198	goto out;
	199	}
	200
	201	if (info.vendor != 0x1b1c)
	202	goto out;
	203
	204	for (i = 0; i < sizeof(products) / sizeof(products[0]); i++) {
	205	if (info.product == products[i]) {
	206	found = 1;
	207	break;
	208	}
	209	}
	210
	211	out:
	212	if (!found) {
	213	if (report_errors)
	214	fprintf(stderr, "unexpected device: %04hx:%04hx\n",
	215	info.vendor, info.product);
	216	close(fd);
	217	fd = -1;
	218	}
	219	return fd;
	220	}
	221
	222	int main(int argc, char *argv[])
	223	{
472ae0c2	224	char name[63];
	225	uint32_t v32;
	226	uint8_t osel;
465ea922	227	int i, fd;
472ae0c2	228
472ae0c2	229	if (argc > 1) {
465ea922	230	if (argv[1][0] == '-' \|\| argc != 2) {
472ae0c2	231	fprintf(stderr, "usage:\n");
465ea922	232	fprintf(stderr, "%s [/dev/hidrawN]\n", argv[0]);
472ae0c2	233	return 1;
472ae0c2	234	}
465ea922	235	fd = try_open_device(argv[1], 1);
472ae0c2	236	}
465ea922	237	else {
	238	for (i = 0; i < 16; i++) {
	239	snprintf(name, sizeof(name), "/dev/hidraw%d", i);
	240	fd = try_open_device(name, 0);
	241	if (fd != -1)
	242	break;
	243	}
472ae0c2	244	}
472ae0c2	245
465ea922	246	if (fd == -1)
472ae0c2	247	return 1;
472ae0c2	248
	249	name[sizeof(name) - 1] = 0;
	250	send_recv_cmd(fd, 0xfe, 0x03, 0x00, name, sizeof(name) - 1);
	251	printf("name: '%s'\n", name);
	252	read_reg(fd, 0x99, name, sizeof(name) - 1);
	253	printf("vendor: '%s'\n", name);
	254	read_reg(fd, 0x9a, name, sizeof(name) - 1);
	255	printf("product: '%s'\n", name);
	256
	257	read_reg32(fd, 0xd1, &v32);
	258	printf("powered: %u (%dd. %dh)\n",
	259	v32, v32 / (246060), v32 / (60*60) % 24);
	260	read_reg32(fd, 0xd2, &v32);
	261	printf("uptime: %u (%dd. %dh)\n",
	262	v32, v32 / (246060), v32 / (60*60) % 24);
	263
	264	print_std_reg(fd, 0x8d, "temp1");
	265	print_std_reg(fd, 0x8e, "temp2");
	266	print_std_reg(fd, 0x90, "fan rpm");
	267	print_std_reg(fd, 0x88, "supply volts");
	268	print_std_reg(fd, 0xee, "total watts");
	269
	270	for (osel = 0; osel < 3; osel++) {
	271	// reg0 write (output select)
	272	send_recv_cmd(fd, 0x02, 0x00, osel, NULL, 0);
	273	print_std_reg(fd, 0x8b, "output%u volts", osel);
	274	print_std_reg(fd, 0x8c, "output%u amps", osel);
	275	print_std_reg(fd, 0x96, "output%u watts", osel);
	276	}
	277
	278	send_recv_cmd(fd, 0x02, 0x00, 0x00, NULL, 0);
	279
	280	close(fd);
	281	return 0;
	282	}