← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to hw/i2c/bitbang_i2c.c

  • Committer: Phil Dennis-Jordan
  • Author(s): Michael Tokarev
  • Date: 2017-05-23 06:58:03 UTC
  • Revision ID: phil@philjordan.eu-20170523065803-3subwvf3y8kzkjry
Tags: upstream-2.8+dfsg
Import upstream version 2.8+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/i2c/bitbang_i2c.c
 
1
/*
 
2
 * Bit-Bang i2c emulation extracted from
 
3
 * Marvell MV88W8618 / Freecom MusicPal emulation.
 
4
 *
 
5
 * Copyright (c) 2008 Jan Kiszka
 
6
 *
 
7
 * This code is licensed under the GNU GPL v2.
 
8
 *
 
9
 * Contributions after 2012-01-13 are licensed under the terms of the
 
10
 * GNU GPL, version 2 or (at your option) any later version.
 
11
 */
 
12
#include "qemu/osdep.h"
 
13
#include "hw/hw.h"
 
14
#include "bitbang_i2c.h"
 
15
#include "hw/sysbus.h"
 
16
 
 
17
//#define DEBUG_BITBANG_I2C
 
18
 
 
19
#ifdef DEBUG_BITBANG_I2C
 
20
#define DPRINTF(fmt, ...) \
 
21
do { printf("bitbang_i2c: " fmt , ## __VA_ARGS__); } while (0)
 
22
#else
 
23
#define DPRINTF(fmt, ...) do {} while(0)
 
24
#endif
 
25
 
 
26
typedef enum bitbang_i2c_state {
 
27
    STOPPED = 0,
 
28
    SENDING_BIT7,
 
29
    SENDING_BIT6,
 
30
    SENDING_BIT5,
 
31
    SENDING_BIT4,
 
32
    SENDING_BIT3,
 
33
    SENDING_BIT2,
 
34
    SENDING_BIT1,
 
35
    SENDING_BIT0,
 
36
    WAITING_FOR_ACK,
 
37
    RECEIVING_BIT7,
 
38
    RECEIVING_BIT6,
 
39
    RECEIVING_BIT5,
 
40
    RECEIVING_BIT4,
 
41
    RECEIVING_BIT3,
 
42
    RECEIVING_BIT2,
 
43
    RECEIVING_BIT1,
 
44
    RECEIVING_BIT0,
 
45
    SENDING_ACK,
 
46
    SENT_NACK
 
47
} bitbang_i2c_state;
 
48
 
 
49
struct bitbang_i2c_interface {
 
50
    I2CBus *bus;
 
51
    bitbang_i2c_state state;
 
52
    int last_data;
 
53
    int last_clock;
 
54
    int device_out;
 
55
    uint8_t buffer;
 
56
    int current_addr;
 
57
};
 
58
 
 
59
static void bitbang_i2c_enter_stop(bitbang_i2c_interface *i2c)
 
60
{
 
61
    DPRINTF("STOP\n");
 
62
    if (i2c->current_addr >= 0)
 
63
        i2c_end_transfer(i2c->bus);
 
64
    i2c->current_addr = -1;
 
65
    i2c->state = STOPPED;
 
66
}
 
67
 
 
68
/* Set device data pin.  */
 
69
static int bitbang_i2c_ret(bitbang_i2c_interface *i2c, int level)
 
70
{
 
71
    i2c->device_out = level;
 
72
    //DPRINTF("%d %d %d\n", i2c->last_clock, i2c->last_data, i2c->device_out);
 
73
    return level & i2c->last_data;
 
74
}
 
75
 
 
76
/* Leave device data pin unodified.  */
 
77
static int bitbang_i2c_nop(bitbang_i2c_interface *i2c)
 
78
{
 
79
    return bitbang_i2c_ret(i2c, i2c->device_out);
 
80
}
 
81
 
 
82
/* Returns data line level.  */
 
83
int bitbang_i2c_set(bitbang_i2c_interface *i2c, int line, int level)
 
84
{
 
85
    int data;
 
86
 
 
87
    if (level != 0 && level != 1) {
 
88
        abort();
 
89
    }
 
90
 
 
91
    if (line == BITBANG_I2C_SDA) {
 
92
        if (level == i2c->last_data) {
 
93
            return bitbang_i2c_nop(i2c);
 
94
        }
 
95
        i2c->last_data = level;
 
96
        if (i2c->last_clock == 0) {
 
97
            return bitbang_i2c_nop(i2c);
 
98
        }
 
99
        if (level == 0) {
 
100
            DPRINTF("START\n");
 
101
            /* START condition.  */
 
102
            i2c->state = SENDING_BIT7;
 
103
            i2c->current_addr = -1;
 
104
        } else {
 
105
            /* STOP condition.  */
 
106
            bitbang_i2c_enter_stop(i2c);
 
107
        }
 
108
        return bitbang_i2c_ret(i2c, 1);
 
109
    }
 
110
 
 
111
    data = i2c->last_data;
 
112
    if (i2c->last_clock == level) {
 
113
        return bitbang_i2c_nop(i2c);
 
114
    }
 
115
    i2c->last_clock = level;
 
116
    if (level == 0) {
 
117
        /* State is set/read at the start of the clock pulse.
 
118
           release the data line at the end.  */
 
119
        return bitbang_i2c_ret(i2c, 1);
 
120
    }
 
121
    switch (i2c->state) {
 
122
    case STOPPED:
 
123
    case SENT_NACK:
 
124
        return bitbang_i2c_ret(i2c, 1);
 
125
 
 
126
    case SENDING_BIT7 ... SENDING_BIT0:
 
127
        i2c->buffer = (i2c->buffer << 1) | data;
 
128
        /* will end up in WAITING_FOR_ACK */
 
129
        i2c->state++; 
 
130
        return bitbang_i2c_ret(i2c, 1);
 
131
 
 
132
    case WAITING_FOR_ACK:
 
133
    {
 
134
        int ret;
 
135
 
 
136
        if (i2c->current_addr < 0) {
 
137
            i2c->current_addr = i2c->buffer;
 
138
            DPRINTF("Address 0x%02x\n", i2c->current_addr);
 
139
            ret = i2c_start_transfer(i2c->bus, i2c->current_addr >> 1,
 
140
                                     i2c->current_addr & 1);
 
141
        } else {
 
142
            DPRINTF("Sent 0x%02x\n", i2c->buffer);
 
143
            ret = i2c_send(i2c->bus, i2c->buffer);
 
144
        }
 
145
        if (ret) {
 
146
            /* NACK (either addressing a nonexistent device, or the
 
147
             * device we were sending to decided to NACK us).
 
148
             */
 
149
            DPRINTF("Got NACK\n");
 
150
            bitbang_i2c_enter_stop(i2c);
 
151
            return bitbang_i2c_ret(i2c, 1);
 
152
        }
 
153
        if (i2c->current_addr & 1) {
 
154
            i2c->state = RECEIVING_BIT7;
 
155
        } else {
 
156
            i2c->state = SENDING_BIT7;
 
157
        }
 
158
        return bitbang_i2c_ret(i2c, 0);
 
159
    }
 
160
    case RECEIVING_BIT7:
 
161
        i2c->buffer = i2c_recv(i2c->bus);
 
162
        DPRINTF("RX byte 0x%02x\n", i2c->buffer);
 
163
        /* Fall through... */
 
164
    case RECEIVING_BIT6 ... RECEIVING_BIT0:
 
165
        data = i2c->buffer >> 7;
 
166
        /* will end up in SENDING_ACK */
 
167
        i2c->state++;
 
168
        i2c->buffer <<= 1;
 
169
        return bitbang_i2c_ret(i2c, data);
 
170
 
 
171
    case SENDING_ACK:
 
172
        i2c->state = RECEIVING_BIT7;
 
173
        if (data != 0) {
 
174
            DPRINTF("NACKED\n");
 
175
            i2c->state = SENT_NACK;
 
176
            i2c_nack(i2c->bus);
 
177
        } else {
 
178
            DPRINTF("ACKED\n");
 
179
        }
 
180
        return bitbang_i2c_ret(i2c, 1);
 
181
    }
 
182
    abort();
 
183
}
 
184
 
 
185
bitbang_i2c_interface *bitbang_i2c_init(I2CBus *bus)
 
186
{
 
187
    bitbang_i2c_interface *s;
 
188
 
 
189
    s = g_malloc0(sizeof(bitbang_i2c_interface));
 
190
 
 
191
    s->bus = bus;
 
192
    s->last_data = 1;
 
193
    s->last_clock = 1;
 
194
    s->device_out = 1;
 
195
 
 
196
    return s;
 
197
}
 
198
 
 
199
/* GPIO interface.  */
 
200
 
 
201
#define TYPE_GPIO_I2C "gpio_i2c"
 
202
#define GPIO_I2C(obj) OBJECT_CHECK(GPIOI2CState, (obj), TYPE_GPIO_I2C)
 
203
 
 
204
typedef struct GPIOI2CState {
 
205
    SysBusDevice parent_obj;
 
206
 
 
207
    MemoryRegion dummy_iomem;
 
208
    bitbang_i2c_interface *bitbang;
 
209
    int last_level;
 
210
    qemu_irq out;
 
211
} GPIOI2CState;
 
212
 
 
213
static void bitbang_i2c_gpio_set(void *opaque, int irq, int level)
 
214
{
 
215
    GPIOI2CState *s = opaque;
 
216
 
 
217
    level = bitbang_i2c_set(s->bitbang, irq, level);
 
218
    if (level != s->last_level) {
 
219
        s->last_level = level;
 
220
        qemu_set_irq(s->out, level);
 
221
    }
 
222
}
 
223
 
 
224
static void gpio_i2c_init(Object *obj)
 
225
{
 
226
    DeviceState *dev = DEVICE(obj);
 
227
    GPIOI2CState *s = GPIO_I2C(obj);
 
228
    SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 
229
    I2CBus *bus;
 
230
 
 
231
    memory_region_init(&s->dummy_iomem, obj, "gpio_i2c", 0);
 
232
    sysbus_init_mmio(sbd, &s->dummy_iomem);
 
233
 
 
234
    bus = i2c_init_bus(dev, "i2c");
 
235
    s->bitbang = bitbang_i2c_init(bus);
 
236
 
 
237
    qdev_init_gpio_in(dev, bitbang_i2c_gpio_set, 2);
 
238
    qdev_init_gpio_out(dev, &s->out, 1);
 
239
}
 
240
 
 
241
static void gpio_i2c_class_init(ObjectClass *klass, void *data)
 
242
{
 
243
    DeviceClass *dc = DEVICE_CLASS(klass);
 
244
 
 
245
    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
 
246
    dc->desc = "Virtual GPIO to I2C bridge";
 
247
}
 
248
 
 
249
static const TypeInfo gpio_i2c_info = {
 
250
    .name          = TYPE_GPIO_I2C,
 
251
    .parent        = TYPE_SYS_BUS_DEVICE,
 
252
    .instance_size = sizeof(GPIOI2CState),
 
253
    .instance_init = gpio_i2c_init,
 
254
    .class_init    = gpio_i2c_class_init,
 
255
};
 
256
 
 
257
static void bitbang_i2c_register_types(void)
 
258
{
 
259
    type_register_static(&gpio_i2c_info);
 
260
}
 
261
 
 
262
type_init(bitbang_i2c_register_types)