qemu

1
/*
2
 * Broadcom Serial Controller (BSC)
3
 *
4
 * Copyright (c) 2024 Rayhan Faizel <rayhan.faizel@gmail.com>
5
 *
6
 * SPDX-License-Identifier: MIT
7
 *
8
 * Permission is hereby granted, free of charge, to any person obtaining a copy
9
 * of this software and associated documentation files (the "Software"), to deal
10
 * in the Software without restriction, including without limitation the rights
11
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12
 * copies of the Software, and to permit persons to whom the Software is
13
 * furnished to do so, subject to the following conditions:
14
 *
15
 * The above copyright notice and this permission notice shall be included in
16
 * all copies or substantial portions of the Software.
17
 *
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24
 * THE SOFTWARE.
25
 */
26

27
#include "qemu/osdep.h"
28
#include "qemu/log.h"
29
#include "hw/i2c/bcm2835_i2c.h"
30
#include "hw/irq.h"
31
#include "migration/vmstate.h"
32

33
static void bcm2835_i2c_update_interrupt(BCM2835I2CState *s)
34
{
35
    int do_interrupt = 0;
36
    /* Interrupt on RXR (Needs reading) */
37
    if (s->c & BCM2835_I2C_C_INTR && s->s & BCM2835_I2C_S_RXR) {
38
        do_interrupt = 1;
39
    }
40

41
    /* Interrupt on TXW (Needs writing) */
42
    if (s->c & BCM2835_I2C_C_INTT && s->s & BCM2835_I2C_S_TXW) {
43
        do_interrupt = 1;
44
    }
45

46
    /* Interrupt on DONE (Transfer complete) */
47
    if (s->c & BCM2835_I2C_C_INTD && s->s & BCM2835_I2C_S_DONE) {
48
        do_interrupt = 1;
49
    }
50
    qemu_set_irq(s->irq, do_interrupt);
51
}
52

53
static void bcm2835_i2c_begin_transfer(BCM2835I2CState *s)
54
{
55
    int direction = s->c & BCM2835_I2C_C_READ;
56
    if (i2c_start_transfer(s->bus, s->a, direction)) {
57
        s->s |= BCM2835_I2C_S_ERR;
58
    }
59
    s->s |= BCM2835_I2C_S_TA;
60

61
    if (direction) {
62
        s->s |= BCM2835_I2C_S_RXR | BCM2835_I2C_S_RXD;
63
    } else {
64
        s->s |= BCM2835_I2C_S_TXW;
65
    }
66
}
67

68
static void bcm2835_i2c_finish_transfer(BCM2835I2CState *s)
69
{
70
    /*
71
     * STOP is sent when DLEN counts down to zero.
72
     *
73
     * https://github.com/torvalds/linux/blob/v6.7/drivers/i2c/busses/i2c-bcm2835.c#L223-L261
74
     * It is possible to initiate repeated starts on real hardware.
75
     * However, this requires sending another ST request before the bytes in
76
     * TX FIFO are shifted out.
77
     *
78
     * This is not emulated currently.
79
     */
80
    i2c_end_transfer(s->bus);
81
    s->s |= BCM2835_I2C_S_DONE;
82

83
    /* Ensure RXD is cleared, otherwise the driver registers an error */
84
    s->s &= ~(BCM2835_I2C_S_TA | BCM2835_I2C_S_RXR |
85
              BCM2835_I2C_S_TXW | BCM2835_I2C_S_RXD);
86
}
87

88
static uint64_t bcm2835_i2c_read(void *opaque, hwaddr addr, unsigned size)
89
{
90
    BCM2835I2CState *s = opaque;
91
    uint32_t readval = 0;
92

93
    switch (addr) {
94
    case BCM2835_I2C_C:
95
        readval = s->c;
96
        break;
97
    case BCM2835_I2C_S:
98
        readval = s->s;
99
        break;
100
    case BCM2835_I2C_DLEN:
101
        readval = s->dlen;
102
        break;
103
    case BCM2835_I2C_A:
104
        readval = s->a;
105
        break;
106
    case BCM2835_I2C_FIFO:
107
        /* We receive I2C messages directly instead of using FIFOs */
108
        if (s->s & BCM2835_I2C_S_TA) {
109
            readval = i2c_recv(s->bus);
110
            s->dlen -= 1;
111

112
            if (s->dlen == 0) {
113
                bcm2835_i2c_finish_transfer(s);
114
            }
115
        }
116
        bcm2835_i2c_update_interrupt(s);
117
        break;
118
    case BCM2835_I2C_DIV:
119
        readval = s->div;
120
        break;
121
    case BCM2835_I2C_DEL:
122
        readval = s->del;
123
        break;
124
    case BCM2835_I2C_CLKT:
125
        readval = s->clkt;
126
        break;
127
    default:
128
        qemu_log_mask(LOG_GUEST_ERROR,
129
                      "%s: Bad offset 0x%" HWADDR_PRIx "\n", __func__, addr);
130
    }
131

132
    return readval;
133
}
134

135
static void bcm2835_i2c_write(void *opaque, hwaddr addr,
136
                              uint64_t value, unsigned int size)
137
{
138
    BCM2835I2CState *s = opaque;
139
    uint32_t writeval = value;
140

141
    switch (addr) {
142
    case BCM2835_I2C_C:
143
        /* ST is a one-shot operation; it must read back as 0 */
144
        s->c = writeval & ~BCM2835_I2C_C_ST;
145

146
        /* Start transfer */
147
        if (writeval & (BCM2835_I2C_C_ST | BCM2835_I2C_C_I2CEN)) {
148
            bcm2835_i2c_begin_transfer(s);
149
            /*
150
             * Handle special case where transfer starts with zero data length.
151
             * Required for zero length i2c quick messages to work.
152
             */
153
            if (s->dlen == 0) {
154
                bcm2835_i2c_finish_transfer(s);
155
            }
156
        }
157

158
        bcm2835_i2c_update_interrupt(s);
159
        break;
160
    case BCM2835_I2C_S:
161
        if (writeval & BCM2835_I2C_S_DONE && s->s & BCM2835_I2C_S_DONE) {
162
            /* When DONE is cleared, DLEN should read last written value. */
163
            s->dlen = s->last_dlen;
164
        }
165

166
        /* Clear DONE, CLKT and ERR by writing 1 */
167
        s->s &= ~(writeval & (BCM2835_I2C_S_DONE |
168
                  BCM2835_I2C_S_ERR | BCM2835_I2C_S_CLKT));
169
        break;
170
    case BCM2835_I2C_DLEN:
171
        s->dlen = writeval;
172
        s->last_dlen = writeval;
173
        break;
174
    case BCM2835_I2C_A:
175
        s->a = writeval;
176
        break;
177
    case BCM2835_I2C_FIFO:
178
        /* We send I2C messages directly instead of using FIFOs */
179
        if (s->s & BCM2835_I2C_S_TA) {
180
            if (s->s & BCM2835_I2C_S_TXD) {
181
                if (!i2c_send(s->bus, writeval & 0xff)) {
182
                    s->dlen -= 1;
183
                } else {
184
                    s->s |= BCM2835_I2C_S_ERR;
185
                }
186
            }
187

188
            if (s->dlen == 0) {
189
                bcm2835_i2c_finish_transfer(s);
190
            }
191
        }
192
        bcm2835_i2c_update_interrupt(s);
193
        break;
194
    case BCM2835_I2C_DIV:
195
        s->div = writeval;
196
        break;
197
    case BCM2835_I2C_DEL:
198
        s->del = writeval;
199
        break;
200
    case BCM2835_I2C_CLKT:
201
        s->clkt = writeval;
202
        break;
203
    default:
204
        qemu_log_mask(LOG_GUEST_ERROR,
205
                      "%s: Bad offset 0x%" HWADDR_PRIx "\n", __func__, addr);
206
    }
207
}
208

209
static const MemoryRegionOps bcm2835_i2c_ops = {
210
    .read = bcm2835_i2c_read,
211
    .write = bcm2835_i2c_write,
212
    .endianness = DEVICE_NATIVE_ENDIAN,
213
    .valid = {
214
        .min_access_size = 4,
215
        .max_access_size = 4,
216
    },
217
};
218

219
static void bcm2835_i2c_realize(DeviceState *dev, Error **errp)
220
{
221
    BCM2835I2CState *s = BCM2835_I2C(dev);
222
    s->bus = i2c_init_bus(dev, NULL);
223

224
    memory_region_init_io(&s->iomem, OBJECT(dev), &bcm2835_i2c_ops, s,
225
                          TYPE_BCM2835_I2C, 0x24);
226
    sysbus_init_mmio(SYS_BUS_DEVICE(dev), &s->iomem);
227
    sysbus_init_irq(SYS_BUS_DEVICE(dev), &s->irq);
228
}
229

230
static void bcm2835_i2c_reset(DeviceState *dev)
231
{
232
    BCM2835I2CState *s = BCM2835_I2C(dev);
233

234
    /* Reset values according to BCM2835 Peripheral Documentation */
235
    s->c = 0x0;
236
    s->s = BCM2835_I2C_S_TXD | BCM2835_I2C_S_TXE;
237
    s->dlen = 0x0;
238
    s->a = 0x0;
239
    s->div = 0x5dc;
240
    s->del = 0x00300030;
241
    s->clkt = 0x40;
242
}
243

244
static const VMStateDescription vmstate_bcm2835_i2c = {
245
    .name = TYPE_BCM2835_I2C,
246
    .version_id = 1,
247
    .minimum_version_id = 1,
248
    .fields = (const VMStateField[]) {
249
        VMSTATE_UINT32(c, BCM2835I2CState),
250
        VMSTATE_UINT32(s, BCM2835I2CState),
251
        VMSTATE_UINT32(dlen, BCM2835I2CState),
252
        VMSTATE_UINT32(a, BCM2835I2CState),
253
        VMSTATE_UINT32(div, BCM2835I2CState),
254
        VMSTATE_UINT32(del, BCM2835I2CState),
255
        VMSTATE_UINT32(clkt, BCM2835I2CState),
256
        VMSTATE_UINT32(last_dlen, BCM2835I2CState),
257
        VMSTATE_END_OF_LIST()
258
    }
259
};
260

261
static void bcm2835_i2c_class_init(ObjectClass *klass, void *data)
262
{
263
    DeviceClass *dc = DEVICE_CLASS(klass);
264

265
    dc->reset = bcm2835_i2c_reset;
266
    dc->realize = bcm2835_i2c_realize;
267
    dc->vmsd = &vmstate_bcm2835_i2c;
268
}
269

270
static const TypeInfo bcm2835_i2c_info = {
271
    .name = TYPE_BCM2835_I2C,
272
    .parent = TYPE_SYS_BUS_DEVICE,
273
    .instance_size = sizeof(BCM2835I2CState),
274
    .class_init = bcm2835_i2c_class_init,
275
};
276

277
static void bcm2835_i2c_register_types(void)
278
{
279
    type_register_static(&bcm2835_i2c_info);
280
}
281

282
type_init(bcm2835_i2c_register_types)
283