Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/net/rocker/rocker.c
Line
Count
Source
1
/*
2
 * QEMU rocker switch emulation - PCI device
3
 *
4
 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
5
 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
6
 *
7
 * This program is free software; you can redistribute it and/or modify
8
 * it under the terms of the GNU General Public License as published by
9
 * the Free Software Foundation; either version 2 of the License, or
10
 * (at your option) any later version.
11
 *
12
 * This program is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
 * GNU General Public License for more details.
16
 */
17
18
#include "qemu/osdep.h"
19
#include "hw/pci/pci_device.h"
20
#include "hw/core/qdev-properties.h"
21
#include "hw/core/qdev-properties-system.h"
22
#include "migration/vmstate.h"
23
#include "hw/pci/msix.h"
24
#include "net/net.h"
25
#include "net/eth.h"
26
#include "qapi/error.h"
27
#include "qapi/qapi-commands-rocker.h"
28
#include "qemu/iov.h"
29
#include "qemu/module.h"
30
#include "qemu/bitops.h"
31
#include "qemu/log.h"
32
33
#include "rocker.h"
34
#include "rocker_hw.h"
35
#include "rocker_fp.h"
36
#include "rocker_desc.h"
37
#include "rocker_tlv.h"
38
#include "rocker_world.h"
39
#include "rocker_of_dpa.h"
40
41
struct rocker {
42
    /* private */
43
    PCIDevice parent_obj;
44
    /* public */
45
46
    MemoryRegion mmio;
47
    MemoryRegion msix_bar;
48
49
    /* switch configuration */
50
    char *name;                  /* switch name */
51
    char *world_name;            /* world name */
52
    uint32_t fp_ports;           /* front-panel port count */
53
    NICPeers *fp_ports_peers;
54
    MACAddr fp_start_macaddr;    /* front-panel port 0 mac addr */
55
    uint64_t switch_id;          /* switch id */
56
57
    /* front-panel ports */
58
    FpPort *fp_port[ROCKER_FP_PORTS_MAX];
59
60
    /* register backings */
61
    uint32_t test_reg;
62
    uint64_t test_reg64;
63
    dma_addr_t test_dma_addr;
64
    uint32_t test_dma_size;
65
    uint64_t lower32;            /* lower 32-bit val in 2-part 64-bit access */
66
67
    /* desc rings */
68
    DescRing **rings;
69
70
    /* switch worlds */
71
    World *worlds[ROCKER_WORLD_TYPE_MAX];
72
    World *world_dflt;
73
74
    QLIST_ENTRY(rocker) next;
75
};
76
77
static QLIST_HEAD(, rocker) rockers;
78
79
Rocker *rocker_find(const char *name)
80
0
{
81
0
    Rocker *r;
82
83
0
    QLIST_FOREACH(r, &rockers, next)
84
0
        if (strcmp(r->name, name) == 0) {
85
0
            return r;
86
0
        }
87
88
0
    return NULL;
89
0
}
90
91
World *rocker_get_world(Rocker *r, enum rocker_world_type type)
92
0
{
93
0
    if (type < ROCKER_WORLD_TYPE_MAX) {
94
0
        return r->worlds[type];
95
0
    }
96
0
    return NULL;
97
0
}
98
99
RockerSwitch *qmp_query_rocker(const char *name, Error **errp)
100
0
{
101
0
    RockerSwitch *rocker;
102
0
    Rocker *r;
103
104
0
    r = rocker_find(name);
105
0
    if (!r) {
106
0
        error_setg(errp, "rocker %s not found", name);
107
0
        return NULL;
108
0
    }
109
110
0
    rocker = g_new0(RockerSwitch, 1);
111
0
    rocker->name = g_strdup(r->name);
112
0
    rocker->id = r->switch_id;
113
0
    rocker->ports = r->fp_ports;
114
115
0
    return rocker;
116
0
}
117
118
RockerPortList *qmp_query_rocker_ports(const char *name, Error **errp)
119
0
{
120
0
    RockerPortList *list = NULL;
121
0
    Rocker *r;
122
0
    int i;
123
124
0
    r = rocker_find(name);
125
0
    if (!r) {
126
0
        error_setg(errp, "rocker %s not found", name);
127
0
        return NULL;
128
0
    }
129
130
0
    for (i = r->fp_ports - 1; i >= 0; i--) {
131
0
        QAPI_LIST_PREPEND(list, fp_port_get_info(r->fp_port[i]));
132
0
    }
133
134
0
    return list;
135
0
}
136
137
static uint32_t rocker_get_pport_by_tx_ring(Rocker *r,
138
                                            DescRing *ring)
139
0
{
140
0
    return (desc_ring_index(ring) - 2) / 2 + 1;
141
0
}
142
143
static int tx_consume(Rocker *r, DescInfo *info)
144
0
{
145
0
    PCIDevice *dev = PCI_DEVICE(r);
146
0
    char *buf = desc_get_buf(info, true);
147
0
    RockerTlv *tlv_frag;
148
0
    RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];
149
0
    struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, };
150
0
    uint32_t pport;
151
0
    uint32_t port;
152
0
    uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE;
153
0
    uint16_t tx_l3_csum_off = 0;
154
0
    uint16_t tx_tso_mss = 0;
155
0
    uint16_t tx_tso_hdr_len = 0;
156
0
    int iovcnt = 0;
157
0
    int err = ROCKER_OK;
158
0
    int rem;
159
0
    int i;
160
161
0
    if (!buf) {
162
0
        return -ROCKER_ENXIO;
163
0
    }
164
165
0
    rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, buf, desc_tlv_size(info));
166
167
0
    if (!tlvs[ROCKER_TLV_TX_FRAGS]) {
168
0
        return -ROCKER_EINVAL;
169
0
    }
170
171
0
    pport = rocker_get_pport_by_tx_ring(r, desc_get_ring(info));
172
0
    if (!fp_port_from_pport(pport, &port)) {
173
0
        return -ROCKER_EINVAL;
174
0
    }
175
176
0
    if (tlvs[ROCKER_TLV_TX_OFFLOAD]) {
177
0
        tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]);
178
0
    }
179
180
0
    switch (tx_offload) {
181
0
    case ROCKER_TX_OFFLOAD_L3_CSUM:
182
0
        if (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
183
0
            return -ROCKER_EINVAL;
184
0
        }
185
0
        break;
186
0
    case ROCKER_TX_OFFLOAD_TSO:
187
0
        if (!tlvs[ROCKER_TLV_TX_TSO_MSS] ||
188
0
            !tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
189
0
            return -ROCKER_EINVAL;
190
0
        }
191
0
        break;
192
0
    }
193
194
0
    if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
195
0
        tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]);
196
0
        qemu_log_mask(LOG_UNIMP, "rocker %s: L3 not implemented"
197
0
                                 " (cksum off: %u)\n",
198
0
                      __func__, tx_l3_csum_off);
199
0
    }
200
201
0
    if (tlvs[ROCKER_TLV_TX_TSO_MSS]) {
202
0
        tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]);
203
0
        qemu_log_mask(LOG_UNIMP, "rocker %s: TSO not implemented (MSS: %u)\n",
204
0
                      __func__, tx_tso_mss);
205
0
    }
206
207
0
    if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
208
0
        tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]);
209
0
        qemu_log_mask(LOG_UNIMP, "rocker %s: TSO not implemented"
210
0
                                 " (hdr length: %u)\n",
211
0
                      __func__, tx_tso_hdr_len);
212
0
    }
213
214
0
    rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], rem) {
215
0
        hwaddr frag_addr;
216
0
        uint16_t frag_len;
217
218
0
        if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) {
219
0
            err = -ROCKER_EINVAL;
220
0
            goto err_bad_attr;
221
0
        }
222
223
0
        rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag);
224
225
0
        if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
226
0
            !tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) {
227
0
            err = -ROCKER_EINVAL;
228
0
            goto err_bad_attr;
229
0
        }
230
231
0
        frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
232
0
        frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
233
234
0
        if (iovcnt >= ROCKER_TX_FRAGS_MAX) {
235
0
            goto err_too_many_frags;
236
0
        }
237
0
        iov[iovcnt].iov_len = frag_len;
238
0
        iov[iovcnt].iov_base = g_malloc(frag_len);
239
240
0
        pci_dma_read(dev, frag_addr, iov[iovcnt].iov_base,
241
0
                     iov[iovcnt].iov_len);
242
243
0
        iovcnt++;
244
0
    }
245
246
0
    err = fp_port_eg(r->fp_port[port], iov, iovcnt);
247
248
0
err_too_many_frags:
249
0
err_bad_attr:
250
0
    for (i = 0; i < ROCKER_TX_FRAGS_MAX; i++) {
251
0
        g_free(iov[i].iov_base);
252
0
    }
253
254
0
    return err;
255
0
}
256
257
static int cmd_get_port_settings(Rocker *r,
258
                                 DescInfo *info, char *buf,
259
                                 RockerTlv *cmd_info_tlv)
260
0
{
261
0
    RockerTlv *tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1];
262
0
    RockerTlv *nest;
263
0
    FpPort *fp_port;
264
0
    uint32_t pport;
265
0
    uint32_t port;
266
0
    uint32_t speed;
267
0
    uint8_t duplex;
268
0
    uint8_t autoneg;
269
0
    uint8_t learning;
270
0
    char *phys_name;
271
0
    MACAddr macaddr;
272
0
    enum rocker_world_type mode;
273
0
    size_t tlv_size;
274
0
    int pos;
275
0
    int err;
276
277
0
    rocker_tlv_parse_nested(tlvs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX,
278
0
                            cmd_info_tlv);
279
280
0
    if (!tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]) {
281
0
        return -ROCKER_EINVAL;
282
0
    }
283
284
0
    pport = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]);
285
0
    if (!fp_port_from_pport(pport, &port)) {
286
0
        return -ROCKER_EINVAL;
287
0
    }
288
0
    fp_port = r->fp_port[port];
289
290
0
    err = fp_port_get_settings(fp_port, &speed, &duplex, &autoneg);
291
0
    if (err) {
292
0
        return err;
293
0
    }
294
295
0
    fp_port_get_macaddr(fp_port, &macaddr);
296
0
    mode = world_type(fp_port_get_world(fp_port));
297
0
    learning = fp_port_get_learning(fp_port);
298
0
    phys_name = fp_port_get_name(fp_port);
299
300
0
    tlv_size = rocker_tlv_total_size(0) +                 /* nest */
301
0
               rocker_tlv_total_size(sizeof(uint32_t)) +  /*   pport */
302
0
               rocker_tlv_total_size(sizeof(uint32_t)) +  /*   speed */
303
0
               rocker_tlv_total_size(sizeof(uint8_t)) +   /*   duplex */
304
0
               rocker_tlv_total_size(sizeof(uint8_t)) +   /*   autoneg */
305
0
               rocker_tlv_total_size(sizeof(macaddr.a)) + /*   macaddr */
306
0
               rocker_tlv_total_size(sizeof(uint8_t)) +   /*   mode */
307
0
               rocker_tlv_total_size(sizeof(uint8_t)) +   /*   learning */
308
0
               rocker_tlv_total_size(strlen(phys_name));
309
310
0
    if (tlv_size > desc_buf_size(info)) {
311
0
        return -ROCKER_EMSGSIZE;
312
0
    }
313
314
0
    pos = 0;
315
0
    nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_CMD_INFO);
316
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, pport);
317
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED, speed);
318
0
    rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX, duplex);
319
0
    rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG, autoneg);
320
0
    rocker_tlv_put(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR,
321
0
                   sizeof(macaddr.a), macaddr.a);
322
0
    rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_MODE, mode);
323
0
    rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING,
324
0
                      learning);
325
0
    rocker_tlv_put(buf, &pos, ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME,
326
0
                   strlen(phys_name), phys_name);
327
0
    rocker_tlv_nest_end(buf, &pos, nest);
328
329
0
    return desc_set_buf(info, tlv_size);
330
0
}
331
332
static int cmd_set_port_settings(Rocker *r,
333
                                 RockerTlv *cmd_info_tlv)
334
0
{
335
0
    RockerTlv *tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1];
336
0
    FpPort *fp_port;
337
0
    uint32_t pport;
338
0
    uint32_t port;
339
0
    uint32_t speed;
340
0
    uint8_t duplex;
341
0
    uint8_t autoneg;
342
0
    uint8_t learning;
343
0
    MACAddr macaddr;
344
0
    enum rocker_world_type mode;
345
0
    int err;
346
347
0
    rocker_tlv_parse_nested(tlvs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX,
348
0
                            cmd_info_tlv);
349
350
0
    if (!tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]) {
351
0
        return -ROCKER_EINVAL;
352
0
    }
353
354
0
    pport = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_PPORT]);
355
0
    if (!fp_port_from_pport(pport, &port)) {
356
0
        return -ROCKER_EINVAL;
357
0
    }
358
0
    fp_port = r->fp_port[port];
359
360
0
    if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED] &&
361
0
        tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX] &&
362
0
        tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]) {
363
364
0
        speed = rocker_tlv_get_le32(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED]);
365
0
        duplex = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX]);
366
0
        autoneg = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]);
367
368
0
        err = fp_port_set_settings(fp_port, speed, duplex, autoneg);
369
0
        if (err) {
370
0
            return err;
371
0
        }
372
0
    }
373
374
0
    if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]) {
375
0
        if (rocker_tlv_len(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]) !=
376
0
            sizeof(macaddr.a)) {
377
0
            return -ROCKER_EINVAL;
378
0
        }
379
0
        memcpy(macaddr.a,
380
0
               rocker_tlv_data(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]),
381
0
               sizeof(macaddr.a));
382
0
        fp_port_set_macaddr(fp_port, &macaddr);
383
0
    }
384
385
0
    if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]) {
386
0
        mode = rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]);
387
0
        if (mode >= ROCKER_WORLD_TYPE_MAX) {
388
0
            return -ROCKER_EINVAL;
389
0
        }
390
        /* We don't support world change. */
391
0
        if (!fp_port_check_world(fp_port, r->worlds[mode])) {
392
0
            return -ROCKER_EINVAL;
393
0
        }
394
0
    }
395
396
0
    if (tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING]) {
397
0
        learning =
398
0
            rocker_tlv_get_u8(tlvs[ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING]);
399
0
        fp_port_set_learning(fp_port, learning);
400
0
    }
401
402
0
    return ROCKER_OK;
403
0
}
404
405
static int cmd_consume(Rocker *r, DescInfo *info)
406
0
{
407
0
    char *buf = desc_get_buf(info, false);
408
0
    RockerTlv *tlvs[ROCKER_TLV_CMD_MAX + 1];
409
0
    RockerTlv *info_tlv;
410
0
    World *world;
411
0
    uint16_t cmd;
412
0
    int err;
413
414
0
    if (!buf) {
415
0
        return -ROCKER_ENXIO;
416
0
    }
417
418
0
    rocker_tlv_parse(tlvs, ROCKER_TLV_CMD_MAX, buf, desc_tlv_size(info));
419
420
0
    if (!tlvs[ROCKER_TLV_CMD_TYPE] || !tlvs[ROCKER_TLV_CMD_INFO]) {
421
0
        return -ROCKER_EINVAL;
422
0
    }
423
424
0
    cmd = rocker_tlv_get_le16(tlvs[ROCKER_TLV_CMD_TYPE]);
425
0
    info_tlv = tlvs[ROCKER_TLV_CMD_INFO];
426
427
    /* This might be reworked to something like this:
428
     * Every world will have an array of command handlers from
429
     * ROCKER_TLV_CMD_TYPE_UNSPEC to ROCKER_TLV_CMD_TYPE_MAX. There is
430
     * up to each world to implement whatever command it want.
431
     * It can reference "generic" commands as cmd_set_port_settings or
432
     * cmd_get_port_settings
433
     */
434
435
0
    switch (cmd) {
436
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD:
437
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD:
438
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL:
439
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS:
440
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD:
441
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD:
442
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL:
443
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS:
444
0
        world = r->worlds[ROCKER_WORLD_TYPE_OF_DPA];
445
0
        err = world_do_cmd(world, info, buf, cmd, info_tlv);
446
0
        break;
447
0
    case ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS:
448
0
        err = cmd_get_port_settings(r, info, buf, info_tlv);
449
0
        break;
450
0
    case ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS:
451
0
        err = cmd_set_port_settings(r, info_tlv);
452
0
        break;
453
0
    default:
454
0
        err = -ROCKER_EINVAL;
455
0
        break;
456
0
    }
457
458
0
    return err;
459
0
}
460
461
static void rocker_msix_irq(Rocker *r, unsigned vector)
462
0
{
463
0
    PCIDevice *dev = PCI_DEVICE(r);
464
465
0
    DPRINTF("MSI-X notify request for vector %d\n", vector);
466
0
    if (vector >= ROCKER_MSIX_VEC_COUNT(r->fp_ports)) {
467
0
        DPRINTF("incorrect vector %d\n", vector);
468
0
        return;
469
0
    }
470
0
    msix_notify(dev, vector);
471
0
}
472
473
int rocker_event_link_changed(Rocker *r, uint32_t pport, bool link_up)
474
0
{
475
0
    DescRing *ring = r->rings[ROCKER_RING_EVENT];
476
0
    DescInfo *info = desc_ring_fetch_desc(ring);
477
0
    RockerTlv *nest;
478
0
    char *buf;
479
0
    size_t tlv_size;
480
0
    int pos;
481
0
    int err;
482
483
0
    if (!info) {
484
0
        return -ROCKER_ENOBUFS;
485
0
    }
486
487
0
    tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) +  /* event type */
488
0
               rocker_tlv_total_size(0) +                 /* nest */
489
0
               rocker_tlv_total_size(sizeof(uint32_t)) +  /*   pport */
490
0
               rocker_tlv_total_size(sizeof(uint8_t));    /*   link up */
491
492
0
    if (tlv_size > desc_buf_size(info)) {
493
0
        err = -ROCKER_EMSGSIZE;
494
0
        goto err_too_big;
495
0
    }
496
497
0
    buf = desc_get_buf(info, false);
498
0
    if (!buf) {
499
0
        err = -ROCKER_ENOMEM;
500
0
        goto err_no_mem;
501
0
    }
502
503
0
    pos = 0;
504
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_TYPE,
505
0
                        ROCKER_TLV_EVENT_TYPE_LINK_CHANGED);
506
0
    nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_EVENT_INFO);
507
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_LINK_CHANGED_PPORT, pport);
508
0
    rocker_tlv_put_u8(buf, &pos, ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP,
509
0
                      link_up ? 1 : 0);
510
0
    rocker_tlv_nest_end(buf, &pos, nest);
511
512
0
    err = desc_set_buf(info, tlv_size);
513
514
0
err_too_big:
515
0
err_no_mem:
516
0
    if (desc_ring_post_desc(ring, err)) {
517
0
        rocker_msix_irq(r, ROCKER_MSIX_VEC_EVENT);
518
0
    }
519
520
0
    return err;
521
0
}
522
523
int rocker_event_mac_vlan_seen(Rocker *r, uint32_t pport, uint8_t *addr,
524
                               uint16_t vlan_id)
525
0
{
526
0
    DescRing *ring = r->rings[ROCKER_RING_EVENT];
527
0
    DescInfo *info;
528
0
    FpPort *fp_port;
529
0
    uint32_t port;
530
0
    RockerTlv *nest;
531
0
    char *buf;
532
0
    size_t tlv_size;
533
0
    int pos;
534
0
    int err;
535
536
0
    if (!fp_port_from_pport(pport, &port)) {
537
0
        return -ROCKER_EINVAL;
538
0
    }
539
0
    fp_port = r->fp_port[port];
540
0
    if (!fp_port_get_learning(fp_port)) {
541
0
        return ROCKER_OK;
542
0
    }
543
544
0
    info = desc_ring_fetch_desc(ring);
545
0
    if (!info) {
546
0
        return -ROCKER_ENOBUFS;
547
0
    }
548
549
0
    tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) +  /* event type */
550
0
               rocker_tlv_total_size(0) +                 /* nest */
551
0
               rocker_tlv_total_size(sizeof(uint32_t)) +  /*   pport */
552
0
               rocker_tlv_total_size(ETH_ALEN) +          /*   mac addr */
553
0
               rocker_tlv_total_size(sizeof(uint16_t));   /*   vlan_id */
554
555
0
    if (tlv_size > desc_buf_size(info)) {
556
0
        err = -ROCKER_EMSGSIZE;
557
0
        goto err_too_big;
558
0
    }
559
560
0
    buf = desc_get_buf(info, false);
561
0
    if (!buf) {
562
0
        err = -ROCKER_ENOMEM;
563
0
        goto err_no_mem;
564
0
    }
565
566
0
    pos = 0;
567
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_TYPE,
568
0
                        ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN);
569
0
    nest = rocker_tlv_nest_start(buf, &pos, ROCKER_TLV_EVENT_INFO);
570
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_PPORT, pport);
571
0
    rocker_tlv_put(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_MAC, ETH_ALEN, addr);
572
0
    rocker_tlv_put_u16(buf, &pos, ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID, vlan_id);
573
0
    rocker_tlv_nest_end(buf, &pos, nest);
574
575
0
    err = desc_set_buf(info, tlv_size);
576
577
0
err_too_big:
578
0
err_no_mem:
579
0
    if (desc_ring_post_desc(ring, err)) {
580
0
        rocker_msix_irq(r, ROCKER_MSIX_VEC_EVENT);
581
0
    }
582
583
0
    return err;
584
0
}
585
586
static DescRing *rocker_get_rx_ring_by_pport(Rocker *r,
587
                                                     uint32_t pport)
588
0
{
589
0
    return r->rings[(pport - 1) * 2 + 3];
590
0
}
591
592
int rx_produce(World *world, uint32_t pport,
593
               const struct iovec *iov, int iovcnt, uint8_t copy_to_cpu)
594
0
{
595
0
    Rocker *r = world_rocker(world);
596
0
    PCIDevice *dev = (PCIDevice *)r;
597
0
    DescRing *ring = rocker_get_rx_ring_by_pport(r, pport);
598
0
    DescInfo *info = desc_ring_fetch_desc(ring);
599
0
    char *data;
600
0
    size_t data_size = iov_size(iov, iovcnt);
601
0
    char *buf;
602
0
    uint16_t rx_flags = 0;
603
0
    uint16_t rx_csum = 0;
604
0
    size_t tlv_size;
605
0
    RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1];
606
0
    hwaddr frag_addr;
607
0
    uint16_t frag_max_len;
608
0
    int pos;
609
0
    int err;
610
611
0
    if (!info) {
612
0
        return -ROCKER_ENOBUFS;
613
0
    }
614
615
0
    buf = desc_get_buf(info, false);
616
0
    if (!buf) {
617
0
        err = -ROCKER_ENXIO;
618
0
        goto out;
619
0
    }
620
0
    rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, buf, desc_tlv_size(info));
621
622
0
    if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] ||
623
0
        !tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) {
624
0
        err = -ROCKER_EINVAL;
625
0
        goto out;
626
0
    }
627
628
0
    frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]);
629
0
    frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]);
630
631
0
    if (data_size > frag_max_len) {
632
0
        err = -ROCKER_EMSGSIZE;
633
0
        goto out;
634
0
    }
635
636
0
    if (copy_to_cpu) {
637
0
        rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD;
638
0
    }
639
640
    /* XXX calc rx flags/csum */
641
642
0
    tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) + /* flags */
643
0
               rocker_tlv_total_size(sizeof(uint16_t)) + /* scum */
644
0
               rocker_tlv_total_size(sizeof(uint64_t)) + /* frag addr */
645
0
               rocker_tlv_total_size(sizeof(uint16_t)) + /* frag max len */
646
0
               rocker_tlv_total_size(sizeof(uint16_t));  /* frag len */
647
648
0
    if (tlv_size > desc_buf_size(info)) {
649
0
        err = -ROCKER_EMSGSIZE;
650
0
        goto out;
651
0
    }
652
653
    /* TODO:
654
     * iov dma write can be optimized in similar way e1000 does it in
655
     * e1000_receive_iov. But maybe if would make sense to introduce
656
     * generic helper iov_dma_write.
657
     */
658
659
0
    data = g_malloc(data_size);
660
661
0
    iov_to_buf(iov, iovcnt, 0, data, data_size);
662
0
    pci_dma_write(dev, frag_addr, data, data_size);
663
0
    g_free(data);
664
665
0
    pos = 0;
666
0
    rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FLAGS, rx_flags);
667
0
    rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_CSUM, rx_csum);
668
0
    rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_RX_FRAG_ADDR, frag_addr);
669
0
    rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len);
670
0
    rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_LEN, data_size);
671
672
0
    err = desc_set_buf(info, tlv_size);
673
674
0
out:
675
0
    if (desc_ring_post_desc(ring, err)) {
676
0
        rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(pport - 1));
677
0
    }
678
679
0
    return err;
680
0
}
681
682
int rocker_port_eg(Rocker *r, uint32_t pport,
683
                   const struct iovec *iov, int iovcnt)
684
0
{
685
0
    FpPort *fp_port;
686
0
    uint32_t port;
687
688
0
    if (!fp_port_from_pport(pport, &port)) {
689
0
        return -ROCKER_EINVAL;
690
0
    }
691
692
0
    fp_port = r->fp_port[port];
693
694
0
    return fp_port_eg(fp_port, iov, iovcnt);
695
0
}
696
697
static void rocker_test_dma_ctrl(Rocker *r, uint32_t val)
698
0
{
699
0
    PCIDevice *dev = PCI_DEVICE(r);
700
0
    char *buf;
701
0
    int i;
702
703
0
    buf = g_malloc(r->test_dma_size);
704
705
0
    switch (val) {
706
0
    case ROCKER_TEST_DMA_CTRL_CLEAR:
707
0
        memset(buf, 0, r->test_dma_size);
708
0
        break;
709
0
    case ROCKER_TEST_DMA_CTRL_FILL:
710
0
        memset(buf, 0x96, r->test_dma_size);
711
0
        break;
712
0
    case ROCKER_TEST_DMA_CTRL_INVERT:
713
0
        pci_dma_read(dev, r->test_dma_addr, buf, r->test_dma_size);
714
0
        for (i = 0; i < r->test_dma_size; i++) {
715
0
            buf[i] = ~buf[i];
716
0
        }
717
0
        break;
718
0
    default:
719
0
        DPRINTF("not test dma control val=0x%08x\n", val);
720
0
        goto err_out;
721
0
    }
722
0
    pci_dma_write(dev, r->test_dma_addr, buf, r->test_dma_size);
723
724
0
    rocker_msix_irq(r, ROCKER_MSIX_VEC_TEST);
725
726
0
err_out:
727
0
    g_free(buf);
728
0
}
729
730
static void rocker_reset(DeviceState *dev);
731
732
static void rocker_control(Rocker *r, uint32_t val)
733
0
{
734
0
    if (val & ROCKER_CONTROL_RESET) {
735
0
        rocker_reset(DEVICE(r));
736
0
    }
737
0
}
738
739
static int rocker_pci_ring_count(Rocker *r)
740
0
{
741
    /* There are:
742
     * - command ring
743
     * - event ring
744
     * - tx and rx ring per each port
745
     */
746
0
    return 2 + (2 * r->fp_ports);
747
0
}
748
749
static bool rocker_addr_is_desc_reg(Rocker *r, hwaddr addr)
750
0
{
751
0
    hwaddr start = ROCKER_DMA_DESC_BASE;
752
0
    hwaddr end = start + (ROCKER_DMA_DESC_SIZE * rocker_pci_ring_count(r));
753
754
0
    return addr >= start && addr < end;
755
0
}
756
757
static void rocker_port_phys_enable_write(Rocker *r, uint64_t new)
758
0
{
759
0
    int i;
760
0
    bool old_enabled;
761
0
    bool new_enabled;
762
0
    FpPort *fp_port;
763
764
0
    for (i = 0; i < r->fp_ports; i++) {
765
0
        fp_port = r->fp_port[i];
766
0
        old_enabled = fp_port_enabled(fp_port);
767
0
        new_enabled = (new >> (i + 1)) & 0x1;
768
0
        if (new_enabled == old_enabled) {
769
0
            continue;
770
0
        }
771
0
        if (new_enabled) {
772
0
            fp_port_enable(r->fp_port[i]);
773
0
        } else {
774
0
            fp_port_disable(r->fp_port[i]);
775
0
        }
776
0
    }
777
0
}
778
779
static void rocker_io_writel(void *opaque, hwaddr addr, uint32_t val)
780
0
{
781
0
    Rocker *r = opaque;
782
783
0
    if (rocker_addr_is_desc_reg(r, addr)) {
784
0
        unsigned index = ROCKER_RING_INDEX(addr);
785
0
        unsigned offset = addr & ROCKER_DMA_DESC_MASK;
786
787
0
        switch (offset) {
788
0
        case ROCKER_DMA_DESC_ADDR_OFFSET:
789
0
            r->lower32 = (uint64_t)val;
790
0
            break;
791
0
        case ROCKER_DMA_DESC_ADDR_OFFSET + 4:
792
0
            desc_ring_set_base_addr(r->rings[index],
793
0
                                    ((uint64_t)val) << 32 | r->lower32);
794
0
            r->lower32 = 0;
795
0
            break;
796
0
        case ROCKER_DMA_DESC_SIZE_OFFSET:
797
0
            desc_ring_set_size(r->rings[index], val);
798
0
            break;
799
0
        case ROCKER_DMA_DESC_HEAD_OFFSET:
800
0
            if (desc_ring_set_head(r->rings[index], val)) {
801
0
                rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[index]));
802
0
            }
803
0
            break;
804
0
        case ROCKER_DMA_DESC_CTRL_OFFSET:
805
0
            desc_ring_set_ctrl(r->rings[index], val);
806
0
            break;
807
0
        case ROCKER_DMA_DESC_CREDITS_OFFSET:
808
0
            if (desc_ring_ret_credits(r->rings[index], val)) {
809
0
                rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[index]));
810
0
            }
811
0
            break;
812
0
        default:
813
0
            DPRINTF("not implemented dma reg write(l) addr=0x" HWADDR_FMT_plx
814
0
                    " val=0x%08x (ring %d, addr=0x%02x)\n",
815
0
                    addr, val, index, offset);
816
0
            break;
817
0
        }
818
0
        return;
819
0
    }
820
821
0
    switch (addr) {
822
0
    case ROCKER_TEST_REG:
823
0
        r->test_reg = val;
824
0
        break;
825
0
    case ROCKER_TEST_REG64:
826
0
    case ROCKER_TEST_DMA_ADDR:
827
0
    case ROCKER_PORT_PHYS_ENABLE:
828
0
        r->lower32 = (uint64_t)val;
829
0
        break;
830
0
    case ROCKER_TEST_REG64 + 4:
831
0
        r->test_reg64 = ((uint64_t)val) << 32 | r->lower32;
832
0
        r->lower32 = 0;
833
0
        break;
834
0
    case ROCKER_TEST_IRQ:
835
0
        rocker_msix_irq(r, val);
836
0
        break;
837
0
    case ROCKER_TEST_DMA_SIZE:
838
0
        r->test_dma_size = val & 0xFFFF;
839
0
        break;
840
0
    case ROCKER_TEST_DMA_ADDR + 4:
841
0
        r->test_dma_addr = ((uint64_t)val) << 32 | r->lower32;
842
0
        r->lower32 = 0;
843
0
        break;
844
0
    case ROCKER_TEST_DMA_CTRL:
845
0
        rocker_test_dma_ctrl(r, val);
846
0
        break;
847
0
    case ROCKER_CONTROL:
848
0
        rocker_control(r, val);
849
0
        break;
850
0
    case ROCKER_PORT_PHYS_ENABLE + 4:
851
0
        rocker_port_phys_enable_write(r, ((uint64_t)val) << 32 | r->lower32);
852
0
        r->lower32 = 0;
853
0
        break;
854
0
    default:
855
0
        DPRINTF("not implemented write(l) addr=0x" HWADDR_FMT_plx
856
0
                " val=0x%08x\n", addr, val);
857
0
        break;
858
0
    }
859
0
}
860
861
static void rocker_io_writeq(void *opaque, hwaddr addr, uint64_t val)
862
0
{
863
0
    Rocker *r = opaque;
864
865
0
    if (rocker_addr_is_desc_reg(r, addr)) {
866
0
        unsigned index = ROCKER_RING_INDEX(addr);
867
0
        unsigned offset = addr & ROCKER_DMA_DESC_MASK;
868
869
0
        switch (offset) {
870
0
        case ROCKER_DMA_DESC_ADDR_OFFSET:
871
0
            desc_ring_set_base_addr(r->rings[index], val);
872
0
            break;
873
0
        default:
874
0
            DPRINTF("not implemented dma reg write(q) addr=0x" HWADDR_FMT_plx
875
0
                    " val=0x" HWADDR_FMT_plx " (ring %d, offset=0x%02x)\n",
876
0
                    addr, val, index, offset);
877
0
            break;
878
0
        }
879
0
        return;
880
0
    }
881
882
0
    switch (addr) {
883
0
    case ROCKER_TEST_REG64:
884
0
        r->test_reg64 = val;
885
0
        break;
886
0
    case ROCKER_TEST_DMA_ADDR:
887
0
        r->test_dma_addr = val;
888
0
        break;
889
0
    case ROCKER_PORT_PHYS_ENABLE:
890
0
        rocker_port_phys_enable_write(r, val);
891
0
        break;
892
0
    default:
893
0
        DPRINTF("not implemented write(q) addr=0x" HWADDR_FMT_plx
894
0
                " val=0x" HWADDR_FMT_plx "\n", addr, val);
895
0
        break;
896
0
    }
897
0
}
898
899
#ifdef DEBUG_ROCKER
900
#define regname(reg) case (reg): return #reg
901
static const char *rocker_reg_name(void *opaque, hwaddr addr)
902
{
903
    Rocker *r = opaque;
904
905
    if (rocker_addr_is_desc_reg(r, addr)) {
906
        unsigned index = ROCKER_RING_INDEX(addr);
907
        unsigned offset = addr & ROCKER_DMA_DESC_MASK;
908
        static char buf[100];
909
        char ring_name[10];
910
911
        switch (index) {
912
        case 0:
913
            sprintf(ring_name, "cmd");
914
            break;
915
        case 1:
916
            sprintf(ring_name, "event");
917
            break;
918
        default:
919
            sprintf(ring_name, "%s-%d", index % 2 ? "rx" : "tx",
920
                    (index - 2) / 2);
921
        }
922
923
        switch (offset) {
924
        case ROCKER_DMA_DESC_ADDR_OFFSET:
925
            sprintf(buf, "Ring[%s] ADDR", ring_name);
926
            return buf;
927
        case ROCKER_DMA_DESC_ADDR_OFFSET+4:
928
            sprintf(buf, "Ring[%s] ADDR+4", ring_name);
929
            return buf;
930
        case ROCKER_DMA_DESC_SIZE_OFFSET:
931
            sprintf(buf, "Ring[%s] SIZE", ring_name);
932
            return buf;
933
        case ROCKER_DMA_DESC_HEAD_OFFSET:
934
            sprintf(buf, "Ring[%s] HEAD", ring_name);
935
            return buf;
936
        case ROCKER_DMA_DESC_TAIL_OFFSET:
937
            sprintf(buf, "Ring[%s] TAIL", ring_name);
938
            return buf;
939
        case ROCKER_DMA_DESC_CTRL_OFFSET:
940
            sprintf(buf, "Ring[%s] CTRL", ring_name);
941
            return buf;
942
        case ROCKER_DMA_DESC_CREDITS_OFFSET:
943
            sprintf(buf, "Ring[%s] CREDITS", ring_name);
944
            return buf;
945
        default:
946
            sprintf(buf, "Ring[%s] ???", ring_name);
947
            return buf;
948
        }
949
    } else {
950
        switch (addr) {
951
            regname(ROCKER_BOGUS_REG0);
952
            regname(ROCKER_BOGUS_REG1);
953
            regname(ROCKER_BOGUS_REG2);
954
            regname(ROCKER_BOGUS_REG3);
955
            regname(ROCKER_TEST_REG);
956
            regname(ROCKER_TEST_REG64);
957
            regname(ROCKER_TEST_REG64+4);
958
            regname(ROCKER_TEST_IRQ);
959
            regname(ROCKER_TEST_DMA_ADDR);
960
            regname(ROCKER_TEST_DMA_ADDR+4);
961
            regname(ROCKER_TEST_DMA_SIZE);
962
            regname(ROCKER_TEST_DMA_CTRL);
963
            regname(ROCKER_CONTROL);
964
            regname(ROCKER_PORT_PHYS_COUNT);
965
            regname(ROCKER_PORT_PHYS_LINK_STATUS);
966
            regname(ROCKER_PORT_PHYS_LINK_STATUS+4);
967
            regname(ROCKER_PORT_PHYS_ENABLE);
968
            regname(ROCKER_PORT_PHYS_ENABLE+4);
969
            regname(ROCKER_SWITCH_ID);
970
            regname(ROCKER_SWITCH_ID+4);
971
        }
972
    }
973
    return "???";
974
}
975
#else
976
static const char *rocker_reg_name(void *opaque, hwaddr addr)
977
0
{
978
0
    return NULL;
979
0
}
980
#endif
981
982
static void rocker_mmio_write(void *opaque, hwaddr addr, uint64_t val,
983
                              unsigned size)
984
0
{
985
0
    DPRINTF("Write %s addr " HWADDR_FMT_plx
986
0
            ", size %u, val " HWADDR_FMT_plx "\n",
987
0
            rocker_reg_name(opaque, addr), addr, size, val);
988
989
0
    switch (size) {
990
0
    case 4:
991
0
        rocker_io_writel(opaque, addr, val);
992
0
        break;
993
0
    case 8:
994
0
        rocker_io_writeq(opaque, addr, val);
995
0
        break;
996
0
    }
997
0
}
998
999
static uint64_t rocker_port_phys_link_status(Rocker *r)
1000
0
{
1001
0
    int i;
1002
0
    uint64_t status = 0;
1003
1004
0
    for (i = 0; i < r->fp_ports; i++) {
1005
0
        FpPort *port = r->fp_port[i];
1006
1007
0
        if (fp_port_get_link_up(port)) {
1008
0
            status |= 1ULL << (i + 1);
1009
0
        }
1010
0
    }
1011
0
    return status;
1012
0
}
1013
1014
static uint64_t rocker_port_phys_enable_read(Rocker *r)
1015
0
{
1016
0
    int i;
1017
0
    uint64_t ret = 0;
1018
1019
0
    for (i = 0; i < r->fp_ports; i++) {
1020
0
        FpPort *port = r->fp_port[i];
1021
1022
0
        if (fp_port_enabled(port)) {
1023
0
            ret |= 1ULL << (i + 1);
1024
0
        }
1025
0
    }
1026
0
    return ret;
1027
0
}
1028
1029
static uint32_t rocker_io_readl(void *opaque, hwaddr addr)
1030
0
{
1031
0
    Rocker *r = opaque;
1032
0
    uint32_t ret;
1033
1034
0
    if (rocker_addr_is_desc_reg(r, addr)) {
1035
0
        unsigned index = ROCKER_RING_INDEX(addr);
1036
0
        unsigned offset = addr & ROCKER_DMA_DESC_MASK;
1037
1038
0
        switch (offset) {
1039
0
        case ROCKER_DMA_DESC_ADDR_OFFSET:
1040
0
            ret = (uint32_t)desc_ring_get_base_addr(r->rings[index]);
1041
0
            break;
1042
0
        case ROCKER_DMA_DESC_ADDR_OFFSET + 4:
1043
0
            ret = (uint32_t)(desc_ring_get_base_addr(r->rings[index]) >> 32);
1044
0
            break;
1045
0
        case ROCKER_DMA_DESC_SIZE_OFFSET:
1046
0
            ret = desc_ring_get_size(r->rings[index]);
1047
0
            break;
1048
0
        case ROCKER_DMA_DESC_HEAD_OFFSET:
1049
0
            ret = desc_ring_get_head(r->rings[index]);
1050
0
            break;
1051
0
        case ROCKER_DMA_DESC_TAIL_OFFSET:
1052
0
            ret = desc_ring_get_tail(r->rings[index]);
1053
0
            break;
1054
0
        case ROCKER_DMA_DESC_CREDITS_OFFSET:
1055
0
            ret = desc_ring_get_credits(r->rings[index]);
1056
0
            break;
1057
0
        default:
1058
0
            DPRINTF("not implemented dma reg read(l) addr=0x" HWADDR_FMT_plx
1059
0
                    " (ring %d, addr=0x%02x)\n", addr, index, offset);
1060
0
            ret = 0;
1061
0
            break;
1062
0
        }
1063
0
        return ret;
1064
0
    }
1065
1066
0
    switch (addr) {
1067
0
    case ROCKER_BOGUS_REG0:
1068
0
    case ROCKER_BOGUS_REG1:
1069
0
    case ROCKER_BOGUS_REG2:
1070
0
    case ROCKER_BOGUS_REG3:
1071
0
        ret = 0xDEADBABE;
1072
0
        break;
1073
0
    case ROCKER_TEST_REG:
1074
0
        ret = r->test_reg * 2;
1075
0
        break;
1076
0
    case ROCKER_TEST_REG64:
1077
0
        ret = (uint32_t)(r->test_reg64 * 2);
1078
0
        break;
1079
0
    case ROCKER_TEST_REG64 + 4:
1080
0
        ret = (uint32_t)((r->test_reg64 * 2) >> 32);
1081
0
        break;
1082
0
    case ROCKER_TEST_DMA_SIZE:
1083
0
        ret = r->test_dma_size;
1084
0
        break;
1085
0
    case ROCKER_TEST_DMA_ADDR:
1086
0
        ret = (uint32_t)r->test_dma_addr;
1087
0
        break;
1088
0
    case ROCKER_TEST_DMA_ADDR + 4:
1089
0
        ret = (uint32_t)(r->test_dma_addr >> 32);
1090
0
        break;
1091
0
    case ROCKER_PORT_PHYS_COUNT:
1092
0
        ret = r->fp_ports;
1093
0
        break;
1094
0
    case ROCKER_PORT_PHYS_LINK_STATUS:
1095
0
        ret = (uint32_t)rocker_port_phys_link_status(r);
1096
0
        break;
1097
0
    case ROCKER_PORT_PHYS_LINK_STATUS + 4:
1098
0
        ret = (uint32_t)(rocker_port_phys_link_status(r) >> 32);
1099
0
        break;
1100
0
    case ROCKER_PORT_PHYS_ENABLE:
1101
0
        ret = (uint32_t)rocker_port_phys_enable_read(r);
1102
0
        break;
1103
0
    case ROCKER_PORT_PHYS_ENABLE + 4:
1104
0
        ret = (uint32_t)(rocker_port_phys_enable_read(r) >> 32);
1105
0
        break;
1106
0
    case ROCKER_SWITCH_ID:
1107
0
        ret = (uint32_t)r->switch_id;
1108
0
        break;
1109
0
    case ROCKER_SWITCH_ID + 4:
1110
0
        ret = (uint32_t)(r->switch_id >> 32);
1111
0
        break;
1112
0
    default:
1113
0
        DPRINTF("not implemented read(l) addr=0x" HWADDR_FMT_plx "\n", addr);
1114
0
        ret = 0;
1115
0
        break;
1116
0
    }
1117
0
    return ret;
1118
0
}
1119
1120
static uint64_t rocker_io_readq(void *opaque, hwaddr addr)
1121
0
{
1122
0
    Rocker *r = opaque;
1123
0
    uint64_t ret;
1124
1125
0
    if (rocker_addr_is_desc_reg(r, addr)) {
1126
0
        unsigned index = ROCKER_RING_INDEX(addr);
1127
0
        unsigned offset = addr & ROCKER_DMA_DESC_MASK;
1128
1129
0
        switch (addr & ROCKER_DMA_DESC_MASK) {
1130
0
        case ROCKER_DMA_DESC_ADDR_OFFSET:
1131
0
            ret = desc_ring_get_base_addr(r->rings[index]);
1132
0
            break;
1133
0
        default:
1134
0
            DPRINTF("not implemented dma reg read(q) addr=0x" HWADDR_FMT_plx
1135
0
                    " (ring %d, addr=0x%02x)\n", addr, index, offset);
1136
0
            ret = 0;
1137
0
            break;
1138
0
        }
1139
0
        return ret;
1140
0
    }
1141
1142
0
    switch (addr) {
1143
0
    case ROCKER_BOGUS_REG0:
1144
0
    case ROCKER_BOGUS_REG2:
1145
0
        ret = 0xDEADBABEDEADBABEULL;
1146
0
        break;
1147
0
    case ROCKER_TEST_REG64:
1148
0
        ret = r->test_reg64 * 2;
1149
0
        break;
1150
0
    case ROCKER_TEST_DMA_ADDR:
1151
0
        ret = r->test_dma_addr;
1152
0
        break;
1153
0
    case ROCKER_PORT_PHYS_LINK_STATUS:
1154
0
        ret = rocker_port_phys_link_status(r);
1155
0
        break;
1156
0
    case ROCKER_PORT_PHYS_ENABLE:
1157
0
        ret = rocker_port_phys_enable_read(r);
1158
0
        break;
1159
0
    case ROCKER_SWITCH_ID:
1160
0
        ret = r->switch_id;
1161
0
        break;
1162
0
    default:
1163
0
        DPRINTF("not implemented read(q) addr=0x" HWADDR_FMT_plx "\n", addr);
1164
0
        ret = 0;
1165
0
        break;
1166
0
    }
1167
0
    return ret;
1168
0
}
1169
1170
static uint64_t rocker_mmio_read(void *opaque, hwaddr addr, unsigned size)
1171
0
{
1172
0
    DPRINTF("Read %s addr " HWADDR_FMT_plx ", size %u\n",
1173
0
            rocker_reg_name(opaque, addr), addr, size);
1174
1175
0
    switch (size) {
1176
0
    case 4:
1177
0
        return rocker_io_readl(opaque, addr);
1178
0
    case 8:
1179
0
        return rocker_io_readq(opaque, addr);
1180
0
    }
1181
1182
0
    return -1;
1183
0
}
1184
1185
static const MemoryRegionOps rocker_mmio_ops = {
1186
    .read = rocker_mmio_read,
1187
    .write = rocker_mmio_write,
1188
    .endianness = DEVICE_LITTLE_ENDIAN,
1189
    .valid = {
1190
        .min_access_size = 4,
1191
        .max_access_size = 8,
1192
    },
1193
    .impl = {
1194
        .min_access_size = 4,
1195
        .max_access_size = 8,
1196
    },
1197
};
1198
1199
static void rocker_msix_vectors_unuse(Rocker *r,
1200
                                      unsigned int num_vectors)
1201
0
{
1202
0
    PCIDevice *dev = PCI_DEVICE(r);
1203
0
    int i;
1204
1205
0
    for (i = 0; i < num_vectors; i++) {
1206
0
        msix_vector_unuse(dev, i);
1207
0
    }
1208
0
}
1209
1210
static void rocker_msix_vectors_use(Rocker *r, unsigned int num_vectors)
1211
0
{
1212
0
    PCIDevice *dev = PCI_DEVICE(r);
1213
0
    int i;
1214
1215
0
    for (i = 0; i < num_vectors; i++) {
1216
0
        msix_vector_use(dev, i);
1217
0
    }
1218
0
}
1219
1220
static int rocker_msix_init(Rocker *r, Error **errp)
1221
0
{
1222
0
    PCIDevice *dev = PCI_DEVICE(r);
1223
0
    int err;
1224
1225
0
    err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports),
1226
0
                    &r->msix_bar,
1227
0
                    ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
1228
0
                    &r->msix_bar,
1229
0
                    ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET,
1230
0
                    0, errp);
1231
0
    if (err < 0) {
1232
0
        return err;
1233
0
    }
1234
1235
0
    rocker_msix_vectors_use(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports));
1236
1237
0
    return 0;
1238
0
}
1239
1240
static void rocker_msix_uninit(Rocker *r)
1241
0
{
1242
0
    PCIDevice *dev = PCI_DEVICE(r);
1243
1244
0
    msix_uninit(dev, &r->msix_bar, &r->msix_bar);
1245
0
    rocker_msix_vectors_unuse(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports));
1246
0
}
1247
1248
static World *rocker_world_type_by_name(Rocker *r, const char *name)
1249
0
{
1250
0
    int i;
1251
1252
0
    for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) {
1253
0
        if (strcmp(name, world_name(r->worlds[i])) == 0) {
1254
0
            return r->worlds[i];
1255
0
        }
1256
0
    }
1257
0
    return NULL;
1258
0
}
1259
1260
static void pci_rocker_realize(PCIDevice *dev, Error **errp)
1261
0
{
1262
0
    Rocker *r = ROCKER(dev);
1263
0
    const MACAddr zero = { .a = { 0, 0, 0, 0, 0, 0 } };
1264
0
    const MACAddr dflt = { .a = { 0x52, 0x54, 0x00, 0x12, 0x35, 0x01 } };
1265
0
    static int sw_index;
1266
0
    int i, err = 0;
1267
1268
    /* allocate worlds */
1269
1270
0
    r->worlds[ROCKER_WORLD_TYPE_OF_DPA] = of_dpa_world_alloc(r);
1271
1272
0
    if (!r->world_name) {
1273
0
        r->world_name = g_strdup(world_name(r->worlds[ROCKER_WORLD_TYPE_OF_DPA]));
1274
0
    }
1275
1276
0
    r->world_dflt = rocker_world_type_by_name(r, r->world_name);
1277
0
    if (!r->world_dflt) {
1278
0
        error_setg(errp,
1279
0
                "invalid argument requested world %s does not exist",
1280
0
                r->world_name);
1281
0
        goto err_world_type_by_name;
1282
0
    }
1283
1284
    /* set up memory-mapped region at BAR0 */
1285
1286
0
    memory_region_init_io(&r->mmio, OBJECT(r), &rocker_mmio_ops, r,
1287
0
                          "rocker-mmio", ROCKER_PCI_BAR0_SIZE);
1288
0
    pci_register_bar(dev, ROCKER_PCI_BAR0_IDX,
1289
0
                     PCI_BASE_ADDRESS_SPACE_MEMORY, &r->mmio);
1290
1291
    /* set up memory-mapped region for MSI-X */
1292
1293
0
    memory_region_init(&r->msix_bar, OBJECT(r), "rocker-msix-bar",
1294
0
                       ROCKER_PCI_MSIX_BAR_SIZE);
1295
0
    pci_register_bar(dev, ROCKER_PCI_MSIX_BAR_IDX,
1296
0
                     PCI_BASE_ADDRESS_SPACE_MEMORY, &r->msix_bar);
1297
1298
    /* MSI-X init */
1299
1300
0
    err = rocker_msix_init(r, errp);
1301
0
    if (err) {
1302
0
        goto err_msix_init;
1303
0
    }
1304
1305
    /* validate switch properties */
1306
1307
0
    if (!r->name) {
1308
0
        r->name = g_strdup(TYPE_ROCKER);
1309
0
    }
1310
1311
0
    if (rocker_find(r->name)) {
1312
0
        error_setg(errp, "%s already exists", r->name);
1313
0
        goto err_duplicate;
1314
0
    }
1315
1316
    /* Rocker name is passed in port name requests to OS with the intention
1317
     * that the name is used in interface names. Limit the length of the
1318
     * rocker name to avoid naming problems in the OS. Also, adding the
1319
     * port number as p# and unganged breakout b#, where # is at most 2
1320
     * digits, so leave room for it too (-1 for string terminator, -3 for
1321
     * p# and -3 for b#)
1322
     */
1323
0
#define ROCKER_IFNAMSIZ 16
1324
0
#define MAX_ROCKER_NAME_LEN  (ROCKER_IFNAMSIZ - 1 - 3 - 3)
1325
0
    if (strlen(r->name) > MAX_ROCKER_NAME_LEN) {
1326
0
        error_setg(errp,
1327
0
                "name too long; please shorten to at most %d chars",
1328
0
                MAX_ROCKER_NAME_LEN);
1329
0
        goto err_name_too_long;
1330
0
    }
1331
1332
0
    if (memcmp(&r->fp_start_macaddr, &zero, sizeof(zero)) == 0) {
1333
0
        memcpy(&r->fp_start_macaddr, &dflt, sizeof(dflt));
1334
0
        r->fp_start_macaddr.a[4] += (sw_index++);
1335
0
    }
1336
1337
0
    if (!r->switch_id) {
1338
0
        memcpy(&r->switch_id, &r->fp_start_macaddr,
1339
0
               sizeof(r->fp_start_macaddr));
1340
0
    }
1341
1342
0
    if (r->fp_ports > ROCKER_FP_PORTS_MAX) {
1343
0
        r->fp_ports = ROCKER_FP_PORTS_MAX;
1344
0
    }
1345
1346
0
    r->rings = g_new(DescRing *, rocker_pci_ring_count(r));
1347
1348
    /* Rings are ordered like this:
1349
     * - command ring
1350
     * - event ring
1351
     * - port0 tx ring
1352
     * - port0 rx ring
1353
     * - port1 tx ring
1354
     * - port1 rx ring
1355
     * .....
1356
     */
1357
1358
0
    for (i = 0; i < rocker_pci_ring_count(r); i++) {
1359
0
        DescRing *ring = desc_ring_alloc(r, i);
1360
1361
0
        if (i == ROCKER_RING_CMD) {
1362
0
            desc_ring_set_consume(ring, cmd_consume, ROCKER_MSIX_VEC_CMD);
1363
0
        } else if (i == ROCKER_RING_EVENT) {
1364
0
            desc_ring_set_consume(ring, NULL, ROCKER_MSIX_VEC_EVENT);
1365
0
        } else if (i % 2 == 0) {
1366
0
            desc_ring_set_consume(ring, tx_consume,
1367
0
                                  ROCKER_MSIX_VEC_TX((i - 2) / 2));
1368
0
        } else if (i % 2 == 1) {
1369
0
            desc_ring_set_consume(ring, NULL, ROCKER_MSIX_VEC_RX((i - 3) / 2));
1370
0
        }
1371
1372
0
        r->rings[i] = ring;
1373
0
    }
1374
1375
0
    for (i = 0; i < r->fp_ports; i++) {
1376
0
        FpPort *port =
1377
0
            fp_port_alloc(r, r->name, &r->fp_start_macaddr,
1378
0
                          i, &r->fp_ports_peers[i]);
1379
1380
0
        r->fp_port[i] = port;
1381
0
        fp_port_set_world(port, r->world_dflt);
1382
0
    }
1383
1384
0
    QLIST_INSERT_HEAD(&rockers, r, next);
1385
1386
0
    return;
1387
1388
0
err_name_too_long:
1389
0
err_duplicate:
1390
0
    rocker_msix_uninit(r);
1391
0
err_msix_init:
1392
0
    object_unparent(OBJECT(&r->msix_bar));
1393
0
    object_unparent(OBJECT(&r->mmio));
1394
0
err_world_type_by_name:
1395
0
    for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) {
1396
0
        if (r->worlds[i]) {
1397
0
            world_free(r->worlds[i]);
1398
0
        }
1399
0
    }
1400
0
}
1401
1402
static void pci_rocker_uninit(PCIDevice *dev)
1403
0
{
1404
0
    Rocker *r = ROCKER(dev);
1405
0
    int i;
1406
1407
0
    QLIST_REMOVE(r, next);
1408
1409
0
    for (i = 0; i < r->fp_ports; i++) {
1410
0
        FpPort *port = r->fp_port[i];
1411
1412
0
        fp_port_free(port);
1413
0
        r->fp_port[i] = NULL;
1414
0
    }
1415
1416
0
    for (i = 0; i < rocker_pci_ring_count(r); i++) {
1417
0
        if (r->rings[i]) {
1418
0
            desc_ring_free(r->rings[i]);
1419
0
        }
1420
0
    }
1421
0
    g_free(r->rings);
1422
1423
0
    rocker_msix_uninit(r);
1424
0
    object_unparent(OBJECT(&r->msix_bar));
1425
0
    object_unparent(OBJECT(&r->mmio));
1426
1427
0
    for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) {
1428
0
        if (r->worlds[i]) {
1429
0
            world_free(r->worlds[i]);
1430
0
        }
1431
0
    }
1432
0
}
1433
1434
static void rocker_reset(DeviceState *dev)
1435
0
{
1436
0
    Rocker *r = ROCKER(dev);
1437
0
    int i;
1438
1439
0
    for (i = 0; i < ROCKER_WORLD_TYPE_MAX; i++) {
1440
0
        if (r->worlds[i]) {
1441
0
            world_reset(r->worlds[i]);
1442
0
        }
1443
0
    }
1444
0
    for (i = 0; i < r->fp_ports; i++) {
1445
0
        fp_port_reset(r->fp_port[i]);
1446
0
        fp_port_set_world(r->fp_port[i], r->world_dflt);
1447
0
    }
1448
1449
0
    r->test_reg = 0;
1450
0
    r->test_reg64 = 0;
1451
0
    r->test_dma_addr = 0;
1452
0
    r->test_dma_size = 0;
1453
1454
0
    for (i = 0; i < rocker_pci_ring_count(r); i++) {
1455
0
        desc_ring_reset(r->rings[i]);
1456
0
    }
1457
1458
0
    DPRINTF("Reset done\n");
1459
0
}
1460
1461
static const Property rocker_properties[] = {
1462
    DEFINE_PROP_STRING("name", Rocker, name),
1463
    DEFINE_PROP_STRING("world", Rocker, world_name),
1464
    DEFINE_PROP_MACADDR("fp_start_macaddr", Rocker,
1465
                        fp_start_macaddr),
1466
    DEFINE_PROP_UINT64("switch_id", Rocker,
1467
                       switch_id, 0),
1468
    DEFINE_PROP_ARRAY("ports", Rocker, fp_ports,
1469
                      fp_ports_peers, qdev_prop_netdev, NICPeers),
1470
};
1471
1472
static const VMStateDescription rocker_vmsd = {
1473
    .name = TYPE_ROCKER,
1474
    .unmigratable = 1,
1475
};
1476
1477
static void rocker_class_init(ObjectClass *klass, const void *data)
1478
63
{
1479
63
    DeviceClass *dc = DEVICE_CLASS(klass);
1480
63
    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1481
1482
63
    k->realize = pci_rocker_realize;
1483
63
    k->exit = pci_rocker_uninit;
1484
63
    k->vendor_id = PCI_VENDOR_ID_REDHAT;
1485
63
    k->device_id = PCI_DEVICE_ID_REDHAT_ROCKER;
1486
63
    k->revision = ROCKER_PCI_REVISION;
1487
63
    k->class_id = PCI_CLASS_NETWORK_OTHER;
1488
63
    set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1489
63
    dc->desc = "Rocker Switch";
1490
63
    device_class_set_legacy_reset(dc, rocker_reset);
1491
63
    device_class_set_props(dc, rocker_properties);
1492
63
    dc->vmsd = &rocker_vmsd;
1493
63
}
1494
1495
static const TypeInfo rocker_info = {
1496
    .name          = TYPE_ROCKER,
1497
    .parent        = TYPE_PCI_DEVICE,
1498
    .instance_size = sizeof(Rocker),
1499
    .class_init    = rocker_class_init,
1500
    .interfaces = (const InterfaceInfo[]) {
1501
        { INTERFACE_CONVENTIONAL_PCI_DEVICE },
1502
        { },
1503
    },
1504
};
1505
1506
static void rocker_register_types(void)
1507
63
{
1508
63
    type_register_static(&rocker_info);
1509
63
}
1510
1511
type_init(rocker_register_types)