[qemu.git] / hw / i2c / smbus.c

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

/* TODO: Implement PEC.  */

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

//#define DEBUG_SMBUS 1

#ifdef DEBUG_SMBUS
#define DPRINTF(fmt, ...) \
do { printf("smbus(%02x): " fmt , dev->i2c.address, ## __VA_ARGS__); } while (0)
#define BADF(fmt, ...) \
do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
#else
#define DPRINTF(fmt, ...) do {} while(0)
#define BADF(fmt, ...) \
do { fprintf(stderr, "smbus: error: " fmt , ## __VA_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)
{
    SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);

    DPRINTF("Quick Command %d\n", recv);
    if (sc->quick_cmd) {
        sc->quick_cmd(dev, recv);
    }
}

static void smbus_do_write(SMBusDevice *dev)
{
    SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);

    if (dev->data_len == 0) {
        smbus_do_quick_cmd(dev, 0);
    } else if (dev->data_len == 1) {
        DPRINTF("Send Byte\n");
        if (sc->send_byte) {
            sc->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 (sc->write_data) {
            sc->write_data(dev, dev->command, dev->data_buf + 1,
                           dev->data_len - 1);
        }
    }
}

static void smbus_i2c_event(I2CSlave *s, enum i2c_event event)
{
    SMBusDevice *dev = SMBUS_DEVICE(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(I2CSlave *s)
{
    SMBusDevice *dev = SMBUS_DEVICE(s);
    SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
    int ret;

    switch (dev->mode) {
    case SMBUS_RECV_BYTE:
        if (sc->receive_byte) {
            ret = sc->receive_byte(dev);
        } else {
            ret = 0;
        }
        DPRINTF("Receive Byte %02x\n", ret);
        dev->mode = SMBUS_DONE;
        break;
    case SMBUS_READ_DATA:
        if (sc->read_data) {
            ret = sc->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(I2CSlave *s, uint8_t data)
{
    SMBusDevice *dev = SMBUS_DEVICE(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;
}

static int smbus_device_init(I2CSlave *i2c)
{
    SMBusDevice *dev = SMBUS_DEVICE(i2c);
    SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);

    return sc->init(dev);
}

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

uint8_t smbus_receive_byte(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t addr, uint8_t data)
{
    i2c_start_transfer(bus, addr, 0);
    i2c_send(bus, data);
    i2c_end_transfer(bus);
}

uint8_t smbus_read_byte(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t 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(I2CBus *bus, uint8_t 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);
}

static void smbus_device_class_init(ObjectClass *klass, void *data)
{
    I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass);

    sc->init = smbus_device_init;
    sc->event = smbus_i2c_event;
    sc->recv = smbus_i2c_recv;
    sc->send = smbus_i2c_send;
}

static const TypeInfo smbus_device_type_info = {
    .name = TYPE_SMBUS_DEVICE,
    .parent = TYPE_I2C_SLAVE,
    .instance_size = sizeof(SMBusDevice),
    .abstract = true,
    .class_size = sizeof(SMBusDeviceClass),
    .class_init = smbus_device_class_init,
};

static void smbus_device_register_types(void)
{
    type_register_static(&smbus_device_type_info);
}

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