Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/ipmi/ipmi_kcs.c
Line
Count
Source
1
/*
2
 * QEMU IPMI KCS emulation
3
 *
4
 * Copyright (c) 2015,2017 Corey Minyard, MontaVista Software, LLC
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "qemu/osdep.h"
25
#include "migration/vmstate.h"
26
#include "qemu/log.h"
27
#include "qapi/error.h"
28
#include "hw/ipmi/ipmi_kcs.h"
29
30
0
#define IPMI_KCS_OBF_BIT        0
31
0
#define IPMI_KCS_IBF_BIT        1
32
0
#define IPMI_KCS_SMS_ATN_BIT    2
33
#define IPMI_KCS_CD_BIT         3
34
35
0
#define IPMI_KCS_OBF_MASK          (1 << IPMI_KCS_OBF_BIT)
36
#define IPMI_KCS_GET_OBF(d)        (((d) >> IPMI_KCS_OBF_BIT) & 0x1)
37
0
#define IPMI_KCS_SET_OBF(d, v)     (d) = (((d) & ~IPMI_KCS_OBF_MASK) | \
38
0
                                       (((v) & 1) << IPMI_KCS_OBF_BIT))
39
0
#define IPMI_KCS_IBF_MASK          (1 << IPMI_KCS_IBF_BIT)
40
0
#define IPMI_KCS_GET_IBF(d)        (((d) >> IPMI_KCS_IBF_BIT) & 0x1)
41
0
#define IPMI_KCS_SET_IBF(d, v)     (d) = (((d) & ~IPMI_KCS_IBF_MASK) | \
42
0
                                       (((v) & 1) << IPMI_KCS_IBF_BIT))
43
0
#define IPMI_KCS_SMS_ATN_MASK      (1 << IPMI_KCS_SMS_ATN_BIT)
44
#define IPMI_KCS_GET_SMS_ATN(d)    (((d) >> IPMI_KCS_SMS_ATN_BIT) & 0x1)
45
0
#define IPMI_KCS_SET_SMS_ATN(d, v) (d) = (((d) & ~IPMI_KCS_SMS_ATN_MASK) | \
46
0
                                       (((v) & 1) << IPMI_KCS_SMS_ATN_BIT))
47
#define IPMI_KCS_CD_MASK           (1 << IPMI_KCS_CD_BIT)
48
#define IPMI_KCS_GET_CD(d)         (((d) >> IPMI_KCS_CD_BIT) & 0x1)
49
#define IPMI_KCS_SET_CD(d, v)      (d) = (((d) & ~IPMI_KCS_CD_MASK) | \
50
                                       (((v) & 1) << IPMI_KCS_CD_BIT))
51
52
0
#define IPMI_KCS_IDLE_STATE        0
53
0
#define IPMI_KCS_READ_STATE        1
54
0
#define IPMI_KCS_WRITE_STATE       2
55
0
#define IPMI_KCS_ERROR_STATE       3
56
57
0
#define IPMI_KCS_GET_STATE(d)    (((d) >> 6) & 0x3)
58
0
#define IPMI_KCS_SET_STATE(d, v) ((d) = ((d) & ~0xc0) | (((v) & 0x3) << 6))
59
60
0
#define IPMI_KCS_ABORT_STATUS_CMD       0x60
61
0
#define IPMI_KCS_WRITE_START_CMD        0x61
62
0
#define IPMI_KCS_WRITE_END_CMD          0x62
63
0
#define IPMI_KCS_READ_CMD               0x68
64
65
#define IPMI_KCS_STATUS_NO_ERR          0x00
66
0
#define IPMI_KCS_STATUS_ABORTED_ERR     0x01
67
0
#define IPMI_KCS_STATUS_BAD_CC_ERR      0x02
68
#define IPMI_KCS_STATUS_LENGTH_ERR      0x06
69
70
static void ipmi_kcs_raise_irq(IPMIKCS *ik)
71
0
{
72
0
    if (ik->use_irq && ik->irqs_enabled && ik->raise_irq) {
73
0
        ik->raise_irq(ik);
74
0
    }
75
0
}
76
77
static void ipmi_kcs_lower_irq(IPMIKCS *ik)
78
0
{
79
0
    if (ik->lower_irq) {
80
0
        ik->lower_irq(ik);
81
0
    }
82
0
}
83
84
#define SET_OBF() \
85
0
    do {                                                                      \
86
0
        IPMI_KCS_SET_OBF(ik->status_reg, 1);                                  \
87
0
        if (!ik->obf_irq_set) {                                               \
88
0
            ik->obf_irq_set = 1;                                              \
89
0
            if (!ik->atn_irq_set) {                                           \
90
0
                ipmi_kcs_raise_irq(ik);                                  \
91
0
            }                                                                 \
92
0
        }                                                                     \
93
0
    } while (0)
94
95
static void ipmi_kcs_signal(IPMIKCS *ik, IPMIInterface *ii)
96
0
{
97
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
98
99
0
    ik->do_wake = 1;
100
0
    while (ik->do_wake) {
101
0
        ik->do_wake = 0;
102
0
        iic->handle_if_event(ii);
103
0
    }
104
0
}
105
106
static void ipmi_kcs_handle_event(IPMIInterface *ii)
107
0
{
108
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
109
0
    IPMIKCS *ik = iic->get_backend_data(ii);
110
111
0
    if (ik->cmd_reg == IPMI_KCS_ABORT_STATUS_CMD) {
112
0
        if (IPMI_KCS_GET_STATE(ik->status_reg) != IPMI_KCS_ERROR_STATE) {
113
0
            ik->waiting_rsp++; /* Invalidate the message */
114
0
            ik->outmsg[0] = IPMI_KCS_STATUS_ABORTED_ERR;
115
0
            ik->outlen = 1;
116
0
            ik->outpos = 0;
117
0
            IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
118
0
            SET_OBF();
119
0
        }
120
0
        goto out;
121
0
    }
122
123
0
    switch (IPMI_KCS_GET_STATE(ik->status_reg)) {
124
0
    case IPMI_KCS_IDLE_STATE:
125
0
        if (ik->cmd_reg == IPMI_KCS_WRITE_START_CMD) {
126
0
            IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_WRITE_STATE);
127
0
            ik->cmd_reg = -1;
128
0
            ik->write_end = 0;
129
0
            ik->inlen = 0;
130
0
            SET_OBF();
131
0
        }
132
0
        break;
133
134
0
    case IPMI_KCS_READ_STATE:
135
0
    handle_read:
136
0
        if (ik->outpos >= ik->outlen) {
137
0
            IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_IDLE_STATE);
138
0
            SET_OBF();
139
0
        } else if (ik->data_in_reg == IPMI_KCS_READ_CMD) {
140
0
            ik->data_out_reg = ik->outmsg[ik->outpos];
141
0
            ik->outpos++;
142
0
            SET_OBF();
143
0
        } else {
144
0
            ik->outmsg[0] = IPMI_KCS_STATUS_BAD_CC_ERR;
145
0
            ik->outlen = 1;
146
0
            ik->outpos = 0;
147
0
            IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
148
0
            SET_OBF();
149
0
            goto out;
150
0
        }
151
0
        break;
152
153
0
    case IPMI_KCS_WRITE_STATE:
154
0
        if (ik->data_in_reg != -1) {
155
            /*
156
             * Don't worry about input overrun here, that will be
157
             * handled in the BMC.
158
             */
159
0
            if (ik->inlen < sizeof(ik->inmsg)) {
160
0
                ik->inmsg[ik->inlen] = ik->data_in_reg;
161
0
            }
162
0
            ik->inlen++;
163
0
        }
164
0
        if (ik->write_end) {
165
0
            IPMIBmcClass *bk = IPMI_BMC_GET_CLASS(ik->bmc);
166
0
            ik->outlen = 0;
167
0
            ik->write_end = 0;
168
0
            ik->outpos = 0;
169
0
            bk->handle_command(ik->bmc, ik->inmsg, ik->inlen, sizeof(ik->inmsg),
170
0
                               ik->waiting_rsp);
171
0
            return;
172
0
        } else if (ik->cmd_reg == IPMI_KCS_WRITE_END_CMD) {
173
0
            ik->cmd_reg = -1;
174
0
            ik->write_end = 1;
175
0
        }
176
0
        SET_OBF();
177
0
        break;
178
179
0
    case IPMI_KCS_ERROR_STATE:
180
0
        if (ik->data_in_reg != -1) {
181
0
            IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_READ_STATE);
182
0
            ik->data_in_reg = IPMI_KCS_READ_CMD;
183
0
            goto handle_read;
184
0
        }
185
0
        break;
186
0
    }
187
188
0
    if (ik->cmd_reg != -1) {
189
        /* Got an invalid command */
190
0
        ik->outmsg[0] = IPMI_KCS_STATUS_BAD_CC_ERR;
191
0
        ik->outlen = 1;
192
0
        ik->outpos = 0;
193
0
        IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
194
0
    }
195
196
0
 out:
197
0
    ik->cmd_reg = -1;
198
0
    ik->data_in_reg = -1;
199
0
    IPMI_KCS_SET_IBF(ik->status_reg, 0);
200
0
}
201
202
static void ipmi_kcs_handle_rsp(IPMIInterface *ii, uint8_t msg_id,
203
                                unsigned char *rsp, unsigned int rsp_len)
204
0
{
205
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
206
0
    IPMIKCS *ik = iic->get_backend_data(ii);
207
208
0
    if (ik->waiting_rsp == msg_id) {
209
0
        ik->waiting_rsp++;
210
0
        if (rsp_len > sizeof(ik->outmsg)) {
211
0
            ik->outmsg[0] = rsp[0];
212
0
            ik->outmsg[1] = rsp[1];
213
0
            ik->outmsg[2] = IPMI_CC_CANNOT_RETURN_REQ_NUM_BYTES;
214
0
            ik->outlen = 3;
215
0
        } else {
216
0
            memcpy(ik->outmsg, rsp, rsp_len);
217
0
            ik->outlen = rsp_len;
218
0
        }
219
0
        IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_READ_STATE);
220
0
        ik->data_in_reg = IPMI_KCS_READ_CMD;
221
0
        ipmi_kcs_signal(ik, ii);
222
0
    }
223
0
}
224
225
226
static uint64_t ipmi_kcs_ioport_read(void *opaque, hwaddr addr, unsigned size)
227
0
{
228
0
    IPMIInterface *ii = opaque;
229
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
230
0
    IPMIKCS *ik = iic->get_backend_data(ii);
231
0
    uint32_t ret;
232
233
0
    switch (addr & ik->size_mask) {
234
0
    case 0:
235
0
        ret = ik->data_out_reg;
236
0
        IPMI_KCS_SET_OBF(ik->status_reg, 0);
237
0
        if (ik->obf_irq_set) {
238
0
            ik->obf_irq_set = 0;
239
0
            if (!ik->atn_irq_set) {
240
0
                ipmi_kcs_lower_irq(ik);
241
0
            }
242
0
        }
243
0
        break;
244
245
0
    case 1:
246
0
        ret = ik->status_reg;
247
0
        if (ik->atn_irq_set) {
248
0
            ik->atn_irq_set = 0;
249
0
            if (!ik->obf_irq_set) {
250
0
                ipmi_kcs_lower_irq(ik);
251
0
            }
252
0
        }
253
0
        break;
254
255
0
    default:
256
0
        ret = 0xff;
257
0
    }
258
0
    return ret;
259
0
}
260
261
static void ipmi_kcs_ioport_write(void *opaque, hwaddr addr, uint64_t val,
262
                                  unsigned size)
263
0
{
264
0
    IPMIInterface *ii = opaque;
265
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
266
0
    IPMIKCS *ik = iic->get_backend_data(ii);
267
268
0
    if (IPMI_KCS_GET_IBF(ik->status_reg)) {
269
0
        return;
270
0
    }
271
272
0
    switch (addr & ik->size_mask) {
273
0
    case 0:
274
0
        ik->data_in_reg = val;
275
0
        break;
276
277
0
    case 1:
278
0
        ik->cmd_reg = val;
279
0
        break;
280
281
0
    default:
282
        /* Ignore. */
283
0
        break;
284
0
    }
285
0
    IPMI_KCS_SET_IBF(ik->status_reg, 1);
286
0
    ipmi_kcs_signal(ik, ii);
287
0
}
288
289
const MemoryRegionOps ipmi_kcs_io_ops = {
290
    .read = ipmi_kcs_ioport_read,
291
    .write = ipmi_kcs_ioport_write,
292
    .impl = {
293
        .min_access_size = 1,
294
        .max_access_size = 1,
295
    },
296
    .endianness = DEVICE_LITTLE_ENDIAN,
297
};
298
299
static void ipmi_kcs_set_atn(IPMIInterface *ii, int val, int irq)
300
0
{
301
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
302
0
    IPMIKCS *ik = iic->get_backend_data(ii);
303
304
0
    IPMI_KCS_SET_SMS_ATN(ik->status_reg, val);
305
0
    if (val) {
306
0
        if (irq && !ik->atn_irq_set) {
307
0
            ik->atn_irq_set = 1;
308
0
            if (!ik->obf_irq_set) {
309
0
                ipmi_kcs_raise_irq(ik);
310
0
            }
311
0
        }
312
0
    } else {
313
0
        if (ik->atn_irq_set) {
314
0
            ik->atn_irq_set = 0;
315
0
            if (!ik->obf_irq_set) {
316
0
                ipmi_kcs_lower_irq(ik);
317
0
            }
318
0
        }
319
0
    }
320
0
}
321
322
static void ipmi_kcs_set_irq_enable(IPMIInterface *ii, int val)
323
0
{
324
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
325
0
    IPMIKCS *ik = iic->get_backend_data(ii);
326
327
0
    ik->irqs_enabled = val;
328
0
}
329
330
/* min_size must be a power of 2. */
331
static void ipmi_kcs_init(IPMIInterface *ii, unsigned int min_size,
332
                          Error **errp)
333
0
{
334
0
    IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
335
0
    IPMIKCS *ik = iic->get_backend_data(ii);
336
337
0
    if (min_size == 0) {
338
0
        min_size = 2;
339
0
    }
340
0
    ik->size_mask = min_size - 1;
341
0
    ik->io_length = 2;
342
0
    memory_region_init_io(&ik->io, NULL, &ipmi_kcs_io_ops, ii, "ipmi-kcs",
343
0
                          min_size);
344
0
}
345
346
int ipmi_kcs_vmstate_post_load(void *opaque, int version)
347
0
{
348
0
    IPMIKCS *ik = opaque;
349
350
    /* Make sure all the values are sane. */
351
0
    if (ik->outpos >= MAX_IPMI_MSG_SIZE || ik->outlen >= MAX_IPMI_MSG_SIZE ||
352
0
        ik->outpos >= ik->outlen) {
353
0
        qemu_log_mask(LOG_GUEST_ERROR,
354
0
                      "ipmi:kcs: vmstate transfer received bad out values: %d %d\n",
355
0
                      ik->outpos, ik->outlen);
356
0
        ik->outpos = 0;
357
0
        ik->outlen = 0;
358
0
    }
359
360
0
    if (ik->inlen >= MAX_IPMI_MSG_SIZE) {
361
0
        qemu_log_mask(LOG_GUEST_ERROR,
362
0
                      "ipmi:kcs: vmstate transfer received bad in value: %d\n",
363
0
                      ik->inlen);
364
0
        ik->inlen = 0;
365
0
    }
366
367
0
    return 0;
368
0
}
369
370
static bool vmstate_kcs_before_version2(void *opaque, int version)
371
0
{
372
0
    return version <= 1;
373
0
}
374
375
const VMStateDescription vmstate_IPMIKCS = {
376
    .name = TYPE_IPMI_INTERFACE_PREFIX "kcs",
377
    .version_id = 2,
378
    .minimum_version_id = 1,
379
    .post_load = ipmi_kcs_vmstate_post_load,
380
    .fields = (const VMStateField[]) {
381
        VMSTATE_BOOL(obf_irq_set, IPMIKCS),
382
        VMSTATE_BOOL(atn_irq_set, IPMIKCS),
383
        VMSTATE_UNUSED_TEST(vmstate_kcs_before_version2, 1), /* Was use_irq */
384
        VMSTATE_BOOL(irqs_enabled, IPMIKCS),
385
        VMSTATE_UINT32(outpos, IPMIKCS),
386
        VMSTATE_UINT32_V(outlen, IPMIKCS, 2),
387
        VMSTATE_UINT8_ARRAY(outmsg, IPMIKCS, MAX_IPMI_MSG_SIZE),
388
        VMSTATE_UINT32_V(inlen, IPMIKCS, 2),
389
        VMSTATE_UINT8_ARRAY(inmsg, IPMIKCS, MAX_IPMI_MSG_SIZE),
390
        VMSTATE_BOOL(write_end, IPMIKCS),
391
        VMSTATE_UINT8(status_reg, IPMIKCS),
392
        VMSTATE_UINT8(data_out_reg, IPMIKCS),
393
        VMSTATE_INT16(data_in_reg, IPMIKCS),
394
        VMSTATE_INT16(cmd_reg, IPMIKCS),
395
        VMSTATE_UINT8(waiting_rsp, IPMIKCS),
396
        VMSTATE_END_OF_LIST()
397
    }
398
};
399
400
void ipmi_kcs_get_fwinfo(IPMIKCS *ik, IPMIFwInfo *info)
401
0
{
402
0
    info->interface_name = "kcs";
403
0
    info->interface_type = IPMI_SMBIOS_KCS;
404
0
    info->ipmi_spec_major_revision = 2;
405
0
    info->ipmi_spec_minor_revision = 0;
406
0
    info->ipmi_channel_protocol = IPMI_CHANNEL_PROTOCOL_KCS;
407
0
    info->base_address = ik->io_base;
408
0
    info->i2c_slave_address = ik->bmc->slave_addr;
409
0
    info->register_length = ik->io_length;
410
0
    info->register_spacing = 1;
411
0
    info->memspace = IPMI_MEMSPACE_IO;
412
0
    info->irq_type = IPMI_LEVEL_IRQ;
413
0
}
414
415
void ipmi_kcs_class_init(IPMIInterfaceClass *iic)
416
126
{
417
126
    iic->init = ipmi_kcs_init;
418
126
    iic->set_atn = ipmi_kcs_set_atn;
419
126
    iic->handle_rsp = ipmi_kcs_handle_rsp;
420
126
    iic->handle_if_event = ipmi_kcs_handle_event;
421
126
    iic->set_irq_enable = ipmi_kcs_set_irq_enable;
422
126
}