[qemu.git] / hw / smbus.c

/*
 * QEMU SMBus device emulation.
 *
 * Copyright (c) 2007 CodeSourcery.
 * Written by Paul Brook
 *
 * This code is licenced under the LGPL.
 */

/* TODO: Implement PEC.  */

#include "hw.h"
#include "i2c.h"
#include "smbus.h"

//#define DEBUG_SMBUS 1

#ifdef DEBUG_SMBUS
#define DPRINTF(fmt, args...) \
do { printf("smbus(%02x): " fmt , dev->i2c.address, ##args); } while (0)
#define BADF(fmt, args...) \
do { fprintf(stderr, "smbus: error: " fmt , ##args); exit(1);} while (0)
#else
#define DPRINTF(fmt, args...) do {} while(0)
#define BADF(fmt, args...) \
do { fprintf(stderr, "smbus: error: " fmt , ##args);} while (0)
#endif

enum {
    SMBUS_IDLE,
    SMBUS_WRITE_DATA,
    SMBUS_RECV_BYTE,
    SMBUS_READ_DATA,
    SMBUS_DONE,
    SMBUS_CONFUSED = -1
};

static void smbus_do_quick_cmd(SMBusDevice *dev, int recv)
{
    DPRINTF("Quick Command %d\n", recv);
    if (dev->quick_cmd)
        dev->quick_cmd(dev, recv);
}

static void smbus_do_write(SMBusDevice *dev)
{
    if (dev->data_len == 0) {
        smbus_do_quick_cmd(dev, 0);
    } else if (dev->data_len == 1) {
        DPRINTF("Send Byte\n");
        if (dev->send_byte) {
            dev->send_byte(dev, dev->data_buf[0]);
        }
    } else {
        dev->command = dev->data_buf[0];
        DPRINTF("Command %d len %d\n", dev->command, dev->data_len - 1);
        if (dev->write_data) {
            dev->write_data(dev, dev->command, dev->data_buf + 1,
                            dev->data_len - 1);
        }
    }
}

static void smbus_i2c_event(i2c_slave *s, enum i2c_event event)
{
    SMBusDevice *dev = (SMBusDevice *)s;
    switch (event) {
    case I2C_START_SEND:
        switch (dev->mode) {
        case SMBUS_IDLE:
            DPRINTF("Incoming data\n");
            dev->mode = SMBUS_WRITE_DATA;
            break;
        default:
            BADF("Unexpected send start condition in state %d\n", dev->mode);
            dev->mode = SMBUS_CONFUSED;
            break;
        }
        break;

    case I2C_START_RECV:
        switch (dev->mode) {
        case SMBUS_IDLE:
            DPRINTF("Read mode\n");
            dev->mode = SMBUS_RECV_BYTE;
            break;
        case SMBUS_WRITE_DATA:
            if (dev->data_len == 0) {
                BADF("Read after write with no data\n");
                dev->mode = SMBUS_CONFUSED;
            } else {
                if (dev->data_len > 1) {
                    smbus_do_write(dev);
                } else {
                    dev->command = dev->data_buf[0];
                    DPRINTF("%02x: Command %d\n", dev->i2c.address,
                            dev->command);
                }
                DPRINTF("Read mode\n");
                dev->data_len = 0;
                dev->mode = SMBUS_READ_DATA;
            }
            break;
        default:
            BADF("Unexpected recv start condition in state %d\n", dev->mode);
            dev->mode = SMBUS_CONFUSED;
            break;
        }
        break;

    case I2C_FINISH:
        switch (dev->mode) {
        case SMBUS_WRITE_DATA:
            smbus_do_write(dev);
            break;
        case SMBUS_RECV_BYTE:
            smbus_do_quick_cmd(dev, 1);
            break;
        case SMBUS_READ_DATA:
            BADF("Unexpected stop during receive\n");
            break;
        default:
            /* Nothing to do.  */
            break;
        }
        dev->mode = SMBUS_IDLE;
        dev->data_len = 0;
        break;

    case I2C_NACK:
        switch (dev->mode) {
        case SMBUS_DONE:
            /* Nothing to do.  */
            break;
        case SMBUS_READ_DATA:
            dev->mode = SMBUS_DONE;
            break;
        default:
            BADF("Unexpected NACK in state %d\n", dev->mode);
            dev->mode = SMBUS_CONFUSED;
            break;
        }
    }
}

static int smbus_i2c_recv(i2c_slave *s)
{
    SMBusDevice *dev = (SMBusDevice *)s;
    int ret;

    switch (dev->mode) {
    case SMBUS_RECV_BYTE:
        if (dev->receive_byte) {
            ret = dev->receive_byte(dev);
        } else {
            ret = 0;
        }
        DPRINTF("Receive Byte %02x\n", ret);
        dev->mode = SMBUS_DONE;
        break;
    case SMBUS_READ_DATA:
        if (dev->read_data) {
            ret = dev->read_data(dev, dev->command, dev->data_len);
            dev->data_len++;
        } else {
            ret = 0;
        }
        DPRINTF("Read data %02x\n", ret);
        break;
    default:
        BADF("Unexpected read in state %d\n", dev->mode);
        dev->mode = SMBUS_CONFUSED;
        ret = 0;
        break;
    }
    return ret;
}

static int smbus_i2c_send(i2c_slave *s, uint8_t data)
{
    SMBusDevice *dev = (SMBusDevice *)s;
    switch (dev->mode) {
    case SMBUS_WRITE_DATA:
        DPRINTF("Write data %02x\n", data);
        dev->data_buf[dev->data_len++] = data;
        break;
    default:
        BADF("Unexpected write in state %d\n", dev->mode);
        break;
    }
    return 0;
}

SMBusDevice *smbus_device_init(i2c_bus *bus, int address, int size)
{
    SMBusDevice *dev;

    if (size < sizeof(SMBusDevice))
        hw_error("SMBus struct too small");

    dev = (SMBusDevice *)i2c_slave_init(bus, address, size);
    dev->i2c.event = smbus_i2c_event;
    dev->i2c.recv = smbus_i2c_recv;
    dev->i2c.send = smbus_i2c_send;

    return dev;
}

/* Master device commands.  */
void smbus_quick_command(i2c_bus *bus, int addr, int read)
{
    i2c_start_transfer(bus, addr, read);
    i2c_end_transfer(bus);
}

uint8_t smbus_receive_byte(i2c_bus *bus, int addr)
{
    uint8_t data;

    i2c_start_transfer(bus, addr, 1);
    data = i2c_recv(bus);
    i2c_nack(bus);
    i2c_end_transfer(bus);
    return data;
}

void smbus_send_byte(i2c_bus *bus, int addr, uint8_t data)
{
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, data);
    i2c_end_transfer(bus);
}

uint8_t smbus_read_byte(i2c_bus *bus, int addr, uint8_t command)
{
    uint8_t data;
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_start_transfer(bus, addr, 1);
    data = i2c_recv(bus);
    i2c_nack(bus);
    i2c_end_transfer(bus);
    return data;
}

void smbus_write_byte(i2c_bus *bus, int addr, uint8_t command, uint8_t data)
{
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_send(bus, data);
    i2c_end_transfer(bus);
}

uint16_t smbus_read_word(i2c_bus *bus, int addr, uint8_t command)
{
    uint16_t data;
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_start_transfer(bus, addr, 1);
    data = i2c_recv(bus);
    data |= i2c_recv(bus) << 8;
    i2c_nack(bus);
    i2c_end_transfer(bus);
    return data;
}

void smbus_write_word(i2c_bus *bus, int addr, uint8_t command, uint16_t data)
{
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_send(bus, data & 0xff);
    i2c_send(bus, data >> 8);
    i2c_end_transfer(bus);
}

int smbus_read_block(i2c_bus *bus, int addr, uint8_t command, uint8_t *data)
{
    int len;
    int i;

    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_start_transfer(bus, addr, 1);
    len = i2c_recv(bus);
    if (len > 32)
        len = 0;
    for (i = 0; i < len; i++)
        data[i] = i2c_recv(bus);
    i2c_nack(bus);
    i2c_end_transfer(bus);
    return len;
}

void smbus_write_block(i2c_bus *bus, int addr, uint8_t command, uint8_t *data,
                       int len)
{
    int i;

    if (len > 32)
        len = 32;

    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, command);
    i2c_send(bus, len);
    for (i = 0; i < len; i++)
        i2c_send(bus, data[i]);
    i2c_end_transfer(bus);
}
Commit	Line	Data
5fafdf24	1	/*
0ff596d0 PB	2	* QEMU SMBus device emulation.
	3	*
	4	* Copyright (c) 2007 CodeSourcery.
	5	* Written by Paul Brook
	6	*
	7	* This code is licenced under the LGPL.
	8	*/
	9
	10	/* TODO: Implement PEC. */
	11
87ecb68b PB	12	#include "hw.h"
	13	#include "i2c.h"
	14	#include "smbus.h"
0ff596d0 PB	15
	16	//#define DEBUG_SMBUS 1
	17
	18	#ifdef DEBUG_SMBUS
	19	#define DPRINTF(fmt, args...) \
	20	do { printf("smbus(%02x): " fmt , dev->i2c.address, ##args); } while (0)
	21	#define BADF(fmt, args...) \
	22	do { fprintf(stderr, "smbus: error: " fmt , ##args); exit(1);} while (0)
	23	#else
	24	#define DPRINTF(fmt, args...) do {} while(0)
	25	#define BADF(fmt, args...) \
	26	do { fprintf(stderr, "smbus: error: " fmt , ##args);} while (0)
	27	#endif
	28
	29	enum {
	30	SMBUS_IDLE,
	31	SMBUS_WRITE_DATA,
	32	SMBUS_RECV_BYTE,
	33	SMBUS_READ_DATA,
	34	SMBUS_DONE,
	35	SMBUS_CONFUSED = -1
	36	};
	37
	38	static void smbus_do_quick_cmd(SMBusDevice *dev, int recv)
	39	{
	40	DPRINTF("Quick Command %d\n", recv);
	41	if (dev->quick_cmd)
	42	dev->quick_cmd(dev, recv);
	43	}
	44
	45	static void smbus_do_write(SMBusDevice *dev)
	46	{
	47	if (dev->data_len == 0) {
	48	smbus_do_quick_cmd(dev, 0);
	49	} else if (dev->data_len == 1) {
	50	DPRINTF("Send Byte\n");
	51	if (dev->send_byte) {
	52	dev->send_byte(dev, dev->data_buf[0]);
	53	}
	54	} else {
	55	dev->command = dev->data_buf[0];
	56	DPRINTF("Command %d len %d\n", dev->command, dev->data_len - 1);
	57	if (dev->write_data) {
	58	dev->write_data(dev, dev->command, dev->data_buf + 1,
	59	dev->data_len - 1);
	60	}
	61	}
	62	}
	63
9596ebb7	64	static void smbus_i2c_event(i2c_slave *s, enum i2c_event event)
0ff596d0 PB	65	{
	66	SMBusDevice dev = (SMBusDevice )s;
	67	switch (event) {
	68	case I2C_START_SEND:
	69	switch (dev->mode) {
	70	case SMBUS_IDLE:
	71	DPRINTF("Incoming data\n");
	72	dev->mode = SMBUS_WRITE_DATA;
	73	break;
	74	default:
	75	BADF("Unexpected send start condition in state %d\n", dev->mode);
	76	dev->mode = SMBUS_CONFUSED;
	77	break;
	78	}
	79	break;
	80
	81	case I2C_START_RECV:
	82	switch (dev->mode) {
	83	case SMBUS_IDLE:
	84	DPRINTF("Read mode\n");
	85	dev->mode = SMBUS_RECV_BYTE;
	86	break;
	87	case SMBUS_WRITE_DATA:
	88	if (dev->data_len == 0) {
	89	BADF("Read after write with no data\n");
	90	dev->mode = SMBUS_CONFUSED;
	91	} else {
	92	if (dev->data_len > 1) {
	93	smbus_do_write(dev);
	94	} else {
	95	dev->command = dev->data_buf[0];
	96	DPRINTF("%02x: Command %d\n", dev->i2c.address,
	97	dev->command);
	98	}
	99	DPRINTF("Read mode\n");
	100	dev->data_len = 0;
	101	dev->mode = SMBUS_READ_DATA;
	102	}
	103	break;
	104	default:
	105	BADF("Unexpected recv start condition in state %d\n", dev->mode);
	106	dev->mode = SMBUS_CONFUSED;
	107	break;
	108	}
	109	break;
	110
	111	case I2C_FINISH:
	112	switch (dev->mode) {
	113	case SMBUS_WRITE_DATA:
	114	smbus_do_write(dev);
	115	break;
	116	case SMBUS_RECV_BYTE:
	117	smbus_do_quick_cmd(dev, 1);
	118	break;
	119	case SMBUS_READ_DATA:
	120	BADF("Unexpected stop during receive\n");
	121	break;
	122	default:
	123	/* Nothing to do. */
	124	break;
	125	}
	126	dev->mode = SMBUS_IDLE;
	127	dev->data_len = 0;
	128	break;
129
130	case I2C_NACK:
131	switch (dev->mode) {
132	case SMBUS_DONE:
133	/* Nothing to do. */
134	break;
135	case SMBUS_READ_DATA:
136	dev->mode = SMBUS_DONE;
137	break;
138	default:
139	BADF("Unexpected NACK in state %d\n", dev->mode);
140	dev->mode = SMBUS_CONFUSED;
141	break;
142	}
143	}
144	}
145
146	static int smbus_i2c_recv(i2c_slave *s)
147	{
148	SMBusDevice dev = (SMBusDevice )s;
149	int ret;
150
151	switch (dev->mode) {
152	case SMBUS_RECV_BYTE:
153	if (dev->receive_byte) {
154	ret = dev->receive_byte(dev);
155	} else {
156	ret = 0;
157	}
158	DPRINTF("Receive Byte %02x\n", ret);
159	dev->mode = SMBUS_DONE;
160	break;
161	case SMBUS_READ_DATA:
162	if (dev->read_data) {
163	ret = dev->read_data(dev, dev->command, dev->data_len);
164	dev->data_len++;
165	} else {
166	ret = 0;
167	}
168	DPRINTF("Read data %02x\n", ret);
169	break;
170	default:
171	BADF("Unexpected read in state %d\n", dev->mode);
172	dev->mode = SMBUS_CONFUSED;
173	ret = 0;
174	break;
175	}
176	return ret;
177	}
178
179	static int smbus_i2c_send(i2c_slave *s, uint8_t data)
180	{
181	SMBusDevice dev = (SMBusDevice )s;
182	switch (dev->mode) {
183	case SMBUS_WRITE_DATA:
184	DPRINTF("Write data %02x\n", data);
185	dev->data_buf[dev->data_len++] = data;
186	break;
187	default:
188	BADF("Unexpected write in state %d\n", dev->mode);
189	break;
190	}
191	return 0;
192	}
193
194	SMBusDevice smbus_device_init(i2c_bus bus, int address, int size)
195	{
196	SMBusDevice *dev;
197
3f582262	198	if (size < sizeof(SMBusDevice))
87ecb68b	199	hw_error("SMBus struct too small");
3f582262	200
0ff596d0 PB	201	dev = (SMBusDevice *)i2c_slave_init(bus, address, size);
	202	dev->i2c.event = smbus_i2c_event;
	203	dev->i2c.recv = smbus_i2c_recv;
	204	dev->i2c.send = smbus_i2c_send;
	205
	206	return dev;
	207	}
	208
	209	/* Master device commands. */
	210	void smbus_quick_command(i2c_bus *bus, int addr, int read)
	211	{
	212	i2c_start_transfer(bus, addr, read);
	213	i2c_end_transfer(bus);
	214	}
	215
	216	uint8_t smbus_receive_byte(i2c_bus *bus, int addr)
	217	{
	218	uint8_t data;
	219
	220	i2c_start_transfer(bus, addr, 1);
	221	data = i2c_recv(bus);
	222	i2c_nack(bus);
	223	i2c_end_transfer(bus);
	224	return data;
	225	}
	226
	227	void smbus_send_byte(i2c_bus *bus, int addr, uint8_t data)
	228	{
	229	i2c_start_transfer(bus, addr, 0);
	230	i2c_send(bus, data);
	231	i2c_end_transfer(bus);
	232	}
	233
	234	uint8_t smbus_read_byte(i2c_bus *bus, int addr, uint8_t command)
	235	{
	236	uint8_t data;
	237	i2c_start_transfer(bus, addr, 0);
	238	i2c_send(bus, command);
	239	i2c_start_transfer(bus, addr, 1);
	240	data = i2c_recv(bus);
	241	i2c_nack(bus);
	242	i2c_end_transfer(bus);
	243	return data;
	244	}
	245
	246	void smbus_write_byte(i2c_bus *bus, int addr, uint8_t command, uint8_t data)
	247	{
	248	i2c_start_transfer(bus, addr, 0);
	249	i2c_send(bus, command);
	250	i2c_send(bus, data);
	251	i2c_end_transfer(bus);
	252	}
	253
	254	uint16_t smbus_read_word(i2c_bus *bus, int addr, uint8_t command)
	255	{
	256	uint16_t data;
	257	i2c_start_transfer(bus, addr, 0);
	258	i2c_send(bus, command);
	259	i2c_start_transfer(bus, addr, 1);
	260	data = i2c_recv(bus);
	261	data \|= i2c_recv(bus) << 8;
	262	i2c_nack(bus);
	263	i2c_end_transfer(bus);
	264	return data;
265	}
266
267	void smbus_write_word(i2c_bus *bus, int addr, uint8_t command, uint16_t data)
268	{
269	i2c_start_transfer(bus, addr, 0);
270	i2c_send(bus, command);
271	i2c_send(bus, data & 0xff);
272	i2c_send(bus, data >> 8);
273	i2c_end_transfer(bus);
274	}
275
276	int smbus_read_block(i2c_bus bus, int addr, uint8_t command, uint8_t data)
277	{
278	int len;
279	int i;
280
281	i2c_start_transfer(bus, addr, 0);
282	i2c_send(bus, command);
283	i2c_start_transfer(bus, addr, 1);
284	len = i2c_recv(bus);
285	if (len > 32)
286	len = 0;
287	for (i = 0; i < len; i++)
288	data[i] = i2c_recv(bus);
289	i2c_nack(bus);
290	i2c_end_transfer(bus);
291	return len;
292	}
293
294	void smbus_write_block(i2c_bus bus, int addr, uint8_t command, uint8_t data,
295	int len)
296	{
297	int i;
298
299	if (len > 32)
300	len = 32;
301
302	i2c_start_transfer(bus, addr, 0);
303	i2c_send(bus, command);
304	i2c_send(bus, len);
305	for (i = 0; i < len; i++)
306	i2c_send(bus, data[i]);
307	i2c_end_transfer(bus);
308	}