[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 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));
}

int main(int argc, char *argv[])
{
	const char *device = "/dev/hidraw0";
	struct hidraw_devinfo info;
	char name[63];
	uint32_t v32;
	uint8_t osel;
	int ret, fd;

	if (argc > 1) {
		if (argv[1][0] == '-') {
			fprintf(stderr, "usage:\n");
			fprintf(stderr, "%s /dev/hidrawN\n", argv[0]);
			return 1;
		}
		device = argv[1];
	}

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

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

	if (info.vendor != 0x1b1c && info.product != 0x1c0b) {
		fprintf(stderr, "unexpected device: %04hx:%04hx\n",
			info.vendor, info.product);
		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
66	static void dump(const uint8_t *buf, size_t size)
67	{
68	size_t i, j;
69
70	for (i = 0; i < size; i += 16) {
71	for (j = 0; j < 16; j++) {
72	if (i + j < size)
73	printf(" %02x", buf[i + j]);
74	else
75	fputs(" ", stdout);
76	}
77	fputs(" ", stdout);
78	for (j = 0; j < 16; j++) {
79	if (i + j < size) {
80	uint8_t c = buf[i + j];
81	printf("%c", 0x20 <= c && c <= 0x7f ? c : '.');
82	}
83	else
84	break;
85	}
86	puts("");
87	}
88	}
89
90	static void send_recv_cmd(int fd, uint8_t b0, uint8_t b1, uint8_t b2,
91	void *buf, size_t buf_size)
92	{
93	uint8_t buf_w[65], buf_r[64];
94	ssize_t ret;
95
96	memset(buf_w, 0, sizeof(buf_w));
97	buf_w[1] = b0;
98	buf_w[2] = b1;
99	buf_w[3] = b2;
100	ret = write(fd, buf_w, sizeof(buf_w));
101	if (ret != sizeof(buf_w)) {
102	fprintf(stderr, "write %zd/%zd: ", ret, sizeof(buf_w));
103	perror(NULL);
104	exit(1);
105	}
106
107	ret = read(fd, buf_r, sizeof(buf_r));
108	if (ret != sizeof(buf_r)) {
109	fprintf(stderr, "read %zd/%zd: ", ret, sizeof(buf_r));
110	perror(NULL);
111	if (ret > 0)
112	dump(buf_r, ret);
113	exit(1);
114	}
115
116	if (buf_r[0] != b0 \|\| buf_r[1] != b1) {
117	fprintf(stderr, "unexpected response %02x %02x "
118	"to cmd %02x %02x %02x\n",
119	buf_r[0], buf_r[1], b0, b1, b2);
120	dump(buf_r, sizeof(buf_r));
121	exit(1);
122	}
123
124	if (buf != NULL && buf_size > 0) {
125	if (buf_size > sizeof(buf_r) - 2)
126	buf_size = sizeof(buf_r) - 2;
127	memcpy(buf, buf_r + 2, buf_size);
128	}
129	}
130
131	static void read_reg(int fd, uint8_t reg, void *buf, size_t buf_size)
132	{
133	send_recv_cmd(fd, 0x03, reg, 0x00, buf, buf_size);
134	}
135
136	static void read_reg16(int fd, uint8_t reg, uint16_t *v)
137	{
138	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
139	// FIXME: big endian host
140	}
141
142	static void read_reg32(int fd, uint8_t reg, uint32_t *v)
143	{
144	send_recv_cmd(fd, 0x03, reg, 0x00, v, sizeof(*v));
145	// FIXME: big endian host
146	}
147
148	static double mkv(uint16_t v16)
149	{
150	int p = (int)(int16_t)v16 >> 11;
151	int v = ((int)v16 << 21) >> 21;
152
153	return (double)v * pow(2.0, p);
154	}
155
156	static void print_std_reg(int fd, uint8_t reg, const char *fmt, ...)
157	{
158	size_t len = 0;
159	uint16_t val;
160	va_list ap;
161
162	read_reg16(fd, reg, &val);
163
164	va_start(ap, fmt);
165	len += vprintf(fmt, ap);
166	len += printf(": ");
167	va_end(ap);
168	for (; len < 16; len++)
169	fputs(" ", stdout);
170
171	printf("%5.1f\n", mkv(val));
172	}
173
174	int main(int argc, char *argv[])
175	{
176	const char *device = "/dev/hidraw0";
177	struct hidraw_devinfo info;
178	char name[63];
179	uint32_t v32;
180	uint8_t osel;
181	int ret, fd;
182
183	if (argc > 1) {
184	if (argv[1][0] == '-') {
185	fprintf(stderr, "usage:\n");
186	fprintf(stderr, "%s /dev/hidrawN\n", argv[0]);
187	return 1;
188	}
189	device = argv[1];
190	}
191
192	fd = open(device, O_RDWR);
193	if (fd == -1) {
194	fprintf(stderr, "open %s: ", device);
195	perror(NULL);
196	return 1;
197	}
198
199	memset(&info, 0, sizeof(info));
200	ret = ioctl(fd, HIDIOCGRAWINFO, &info);
201	if (ret != 0) {
202	perror("HIDIOCGRAWINFO");
203	return 1;
204	}
205
206	if (info.vendor != 0x1b1c && info.product != 0x1c0b) {
207	fprintf(stderr, "unexpected device: %04hx:%04hx\n",
208	info.vendor, info.product);
209	return 1;
210	}
211
212	name[sizeof(name) - 1] = 0;
213	send_recv_cmd(fd, 0xfe, 0x03, 0x00, name, sizeof(name) - 1);
214	printf("name: '%s'\n", name);
215	read_reg(fd, 0x99, name, sizeof(name) - 1);
216	printf("vendor: '%s'\n", name);
217	read_reg(fd, 0x9a, name, sizeof(name) - 1);
218	printf("product: '%s'\n", name);
219
220	read_reg32(fd, 0xd1, &v32);
221	printf("powered: %u (%dd. %dh)\n",
222	v32, v32 / (246060), v32 / (60*60) % 24);
223	read_reg32(fd, 0xd2, &v32);
224	printf("uptime: %u (%dd. %dh)\n",
225	v32, v32 / (246060), v32 / (60*60) % 24);
226
227	print_std_reg(fd, 0x8d, "temp1");
228	print_std_reg(fd, 0x8e, "temp2");
229	print_std_reg(fd, 0x90, "fan rpm");
230	print_std_reg(fd, 0x88, "supply volts");
231	print_std_reg(fd, 0xee, "total watts");
232
233	for (osel = 0; osel < 3; osel++) {
234	// reg0 write (output select)
235	send_recv_cmd(fd, 0x02, 0x00, osel, NULL, 0);
236	print_std_reg(fd, 0x8b, "output%u volts", osel);
237	print_std_reg(fd, 0x8c, "output%u amps", osel);
238	print_std_reg(fd, 0x96, "output%u watts", osel);
239	}
240
241	send_recv_cmd(fd, 0x02, 0x00, 0x00, NULL, 0);
242
243	close(fd);
244	return 0;
245	}