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

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;

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