i40e_bm.h 15.2 KB
Newer Older
Antoine Kaufmann's avatar
Antoine Kaufmann committed
1
2
#pragma once

3
#include <deque>
4
#include <sstream>
Antoine Kaufmann's avatar
Antoine Kaufmann committed
5
6
7
8
9
10
#include <stdint.h>
extern "C" {
#include <cosim_pcie_proto.h>
}
#include <nicbm.h>

11
12
13
14
15
16
//#define DEBUG_DEV
//#define DEBUG_ADMINQ
//#define DEBUG_LAN
//#define DEBUG_HMC
//#define DEBUG_QUEUES

17
struct i40e_aq_desc;
18
struct i40e_tx_desc;
19

Antoine Kaufmann's avatar
Antoine Kaufmann committed
20
21
22
namespace i40e {

class i40e_bm;
23
class lan;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
24
25
26
27
28
29
30

class dma_base : public nicbm::DMAOp {
    public:
        /** i40e_bm will call this when dma is done */
        virtual void done() = 0;
};

31
32
33
34
35
36
37
38
39
class int_ev : public nicbm::TimedEvent {
    public:
        uint16_t vector;
        bool armed;

        int_ev();
};


40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class logger : public std::ostream {
    public:
        static const char endl = '\n';

    protected:
        std::string label;
        std::stringstream ss;

    public:
        logger(const std::string &label_);
        logger &operator<<(char c);
        logger &operator<<(int32_t c);
        logger &operator<<(uint8_t i);
        logger &operator<<(uint16_t i);
        logger &operator<<(uint32_t i);
        logger &operator<<(uint64_t i);
        logger &operator<<(bool c);
        logger &operator<<(const char *str);
        logger &operator<<(void *str);
};

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/**
 * Base-class for descriptor queues (RX/TX, Admin RX/TX).
 *
 * Descriptor processing is split up into multiple phases:
 *
 *      - fetch: descriptor is read from host memory. This can be done in
 *        batches, while the batch sizes is limited by the minimum of
 *        MAX_ACTIVE_DESCS, max_active_capacity(), and max_fetch_capacity().
 *        Fetch is implemented by this base class.
 *
 *      - prepare: to be implemented in the sub class, but typically involves
 *        fetching buffer contents. Not guaranteed to happen in order. If
 *        overriden subclass must call desc_prepared() when done.
 *
 *      - process: to be implemented in the sub class. Guaranteed to be called
 *        in order. In case of tx, this actually sends the packet, in rx
 *        processing finishes when a packet for a descriptor has been received.
 *        subclass must call desc_processed() when done.
 *
 *      - write back: descriptor is written back to host-memory. Write-back
 *        capacity
 */
Antoine Kaufmann's avatar
Antoine Kaufmann committed
83
84
class queue_base {
    protected:
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
        static const uint32_t MAX_ACTIVE_DESCS = 128;

        class desc_ctx {
            friend class queue_base;
            public:
                enum state {
                    DESC_EMPTY,
                    DESC_FETCHING,
                    DESC_PREPARING,
                    DESC_PREPARED,
                    DESC_PROCESSING,
                    DESC_PROCESSED,
                    DESC_WRITING_BACK,
                    DESC_WRITTEN_BACK,
                };

Antoine Kaufmann's avatar
Antoine Kaufmann committed
101
102
103
            protected:
                queue_base &queue;
            public:
104
                enum state state;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
105
                uint32_t index;
106
107
108
109
110
                void *desc;
                void *data;
                size_t data_len;
                size_t data_capacity;

111
112
                virtual void prepared();
                virtual void processed();
113
114
115
116
117
118
119
120
121
122
123
124
125

            protected:
                void data_fetch(uint64_t addr, size_t len);
                virtual void data_fetched(uint64_t addr, size_t len);
                void data_write(uint64_t addr, size_t len, const void *buf);
                virtual void data_written(uint64_t addr, size_t len);

            public:
                desc_ctx(queue_base &queue_);
                virtual ~desc_ctx();

                virtual void prepare();
                virtual void process() = 0;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
126
127
        };

128
        class dma_fetch : public dma_base {
129
130
131
            protected:
                queue_base &queue;
            public:
132
133
134
                uint32_t pos;
                dma_fetch(queue_base &queue_, size_t len);
                virtual ~dma_fetch();
135
136
137
                virtual void done();
        };

Antoine Kaufmann's avatar
Antoine Kaufmann committed
138
139
140
141
        class dma_wb : public dma_base {
            protected:
                queue_base &queue;
            public:
142
                uint32_t pos;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
143
144
145
146
147
                dma_wb(queue_base &queue_, size_t len);
                virtual ~dma_wb();
                virtual void done();
        };

148
149
150
151
152
153
154
155
156
157
        class dma_data_fetch : public dma_base {
            protected:
                desc_ctx &ctx;

            public:
                dma_data_fetch(desc_ctx &ctx_, size_t len, void *buffer);
                virtual ~dma_data_fetch();
                virtual void done();
        };

158
159
        class dma_data_wb : public dma_base {
            protected:
160
                desc_ctx &ctx;
161
            public:
162
                dma_data_wb(desc_ctx &ctx_, size_t len);
163
164
165
166
                virtual ~dma_data_wb();
                virtual void done();
        };

167
    public:
168
        std::string qname;
169
        logger log;
170
    protected:
171
172
173
174
175
        desc_ctx *desc_ctxs[MAX_ACTIVE_DESCS];
        uint32_t active_first_pos;
        uint32_t active_first_idx;
        uint32_t active_cnt;

Antoine Kaufmann's avatar
Antoine Kaufmann committed
176
177
178
179
180
181
182
        uint64_t base;
        uint32_t len;
        uint32_t &reg_head;
        uint32_t &reg_tail;

        bool enabled;
        size_t desc_len;
183
184

        void ctxs_init();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
185
186

        void trigger_fetch();
187
188
        void trigger_process();
        void trigger_writeback();
189
        void trigger();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
190

191
192
193
        // returns how many descriptors the queue can fetch max during the next
        // fetch: default UINT32_MAX, but can be overriden by child classes
        virtual uint32_t max_fetch_capacity();
194
195
196
197
198
        virtual uint32_t max_writeback_capacity();
        virtual uint32_t max_active_capacity();

        virtual desc_ctx &desc_ctx_create() = 0;

199
200
        // dummy function, needs to be overriden if interrupts are required
        virtual void interrupt();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
201

202
203
204
205
206
207
        // this does the actual write-back. Can be overridden
        virtual void do_writeback(uint32_t first_idx, uint32_t first_pos,
                uint32_t cnt);

        // called by dma op when writeback has completed
        void writeback_done(uint32_t first_pos, uint32_t cnt);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
208
    public:
209
210
        queue_base(const std::string &qname_, uint32_t &reg_head_,
                uint32_t &reg_tail_);
211
        virtual void reset();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
212
        void reg_updated();
213
        bool is_enabled();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
214
215
216
217
};

class queue_admin_tx : public queue_base {
    protected:
218
219
220
221
222
        class admin_desc_ctx : public desc_ctx {
            protected:
                queue_admin_tx &aq;
                i40e_bm &dev;
                struct i40e_aq_desc *d;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
223

224
                virtual void data_written(uint64_t addr, size_t len);
225

226
227
228
229
230
231
232
233
                // prepare completion descriptor (fills flags, and return value)
                void desc_compl_prepare(uint16_t retval, uint16_t extra_flags);
                // complete direct response
                void desc_complete(uint16_t retval, uint16_t extra_flags = 0);
                // complete indirect response
                void desc_complete_indir(uint16_t retval, const void *data,
                        size_t len, uint16_t extra_flags = 0,
                        bool ignore_datalen=false);
234

235
236
            public:
                admin_desc_ctx(queue_admin_tx &queue_, i40e_bm &dev);
237

238
239
240
                virtual void prepare();
                virtual void process();
        };
Antoine Kaufmann's avatar
Antoine Kaufmann committed
241

242
        i40e_bm &dev;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
243
244
        uint64_t &reg_base;
        uint32_t &reg_len;
245
246

        virtual desc_ctx &desc_ctx_create();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
247
248
249
250
251
252
    public:
        queue_admin_tx(i40e_bm &dev_, uint64_t &reg_base_,
                uint32_t &reg_len_, uint32_t &reg_head_, uint32_t &reg_tail_);
        void reg_updated();
};

Antoine Kaufmann's avatar
Antoine Kaufmann committed
253
254
255
256
257
258
// host memory cache
class host_mem_cache {
    protected:
        static const uint16_t MAX_SEGMENTS = 0x1000;

        struct segment {
259
            uint64_t addr;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
260
261
262
263
264
265
266
            uint16_t pgcount;
            bool valid;
            bool direct;
        };

        i40e_bm &dev;
        segment segs[MAX_SEGMENTS];
267

Antoine Kaufmann's avatar
Antoine Kaufmann committed
268
    public:
269
270
271
272
273
        class mem_op : public dma_base {
            public:
                bool failed;
        };

Antoine Kaufmann's avatar
Antoine Kaufmann committed
274
        host_mem_cache(i40e_bm &dev);
275
        void reset();
Antoine Kaufmann's avatar
Antoine Kaufmann committed
276
        void reg_updated(uint64_t addr);
277
278
279

        // issue a hmc memory operation (address is in the context
        void issue_mem_op(mem_op &op);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
280
281
};

282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
class lan_queue_base : public queue_base {
    protected:
        class qctx_fetch : public host_mem_cache::mem_op {
            public:
                lan_queue_base &lq;

                qctx_fetch(lan_queue_base &lq_);
                virtual void done();
        };


        lan &lanmgr;

        void ctx_fetched();
        void ctx_written_back();

298
        virtual void interrupt();
299
300
301
302
303
304
305
        virtual void initialize() = 0;

    public:
        bool enabling;
        size_t idx;
        uint32_t &reg_ena;
        uint32_t &fpm_basereg;
306
        uint32_t &reg_intqctl;
307
308
309
310
311
        size_t ctx_size;
        void *ctx;

        uint32_t reg_dummy_head;

312
313
        lan_queue_base(lan &lanmgr_, const std::string &qtype, uint32_t &reg_tail,
                size_t idx_,
314
315
                uint32_t &reg_ena_, uint32_t &fpm_basereg, uint32_t &reg_intqctl,
                uint16_t ctx_size);
316
        virtual void reset();
317
318
319
320
321
322
        void enable();
        void disable();
};

class lan_queue_tx : public lan_queue_base {
    protected:
323
324
325
326
327
328
329
330
331
332
333
334
335
        static const uint16_t MTU = 2048;

        class tx_desc_ctx : public desc_ctx {
            protected:
                lan_queue_tx &tq;

            public:
                i40e_tx_desc *d;

                tx_desc_ctx(lan_queue_tx &queue_);

                virtual void prepare();
                virtual void process();
336
                virtual void processed();
337
338
339
        };


340
341
342
343
        class dma_hwb : public dma_base {
            protected:
                lan_queue_tx &queue;
            public:
344
345
                uint32_t pos;
                uint32_t cnt;
346
                uint32_t next_head;
347
348
                dma_hwb(lan_queue_tx &queue_, uint32_t pos, uint32_t cnt,
                        uint32_t next_head);
349
350
351
352
                virtual ~dma_hwb();
                virtual void done();
        };

Antoine Kaufmann's avatar
Antoine Kaufmann committed
353
        uint8_t pktbuf[MTU];
354
        std::deque<tx_desc_ctx *> ready_segments;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
355

356
357
358
359
        bool hwb;
        uint64_t hwb_addr;

        virtual void initialize();
360
        virtual desc_ctx &desc_ctx_create();
361

362
363
364
365
        virtual void do_writeback(uint32_t first_idx, uint32_t first_pos,
                uint32_t cnt);
        bool trigger_tx_packet();
        void trigger_tx();
366

367
368
    public:
        lan_queue_tx(lan &lanmgr_, uint32_t &reg_tail, size_t idx,
369
370
                uint32_t &reg_ena, uint32_t &fpm_basereg,
                uint32_t &reg_intqctl);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
371
        virtual void reset();
372
373
374
375
};

class lan_queue_rx : public lan_queue_base {
    protected:
376
377
378
379
380
381
382
383
384
        class rx_desc_ctx : public desc_ctx {
            protected:
                lan_queue_rx &rq;
                virtual void data_written(uint64_t addr, size_t len);

            public:
                rx_desc_ctx(lan_queue_rx &queue_);
                virtual void process();
                void packet_received(const void *data, size_t len);
385
386
        };

387
388
389
390
391
        uint16_t dbuff_size;
        uint16_t hbuff_size;
        uint16_t rxmax;
        bool crc_strip;

392
        std::deque<rx_desc_ctx *> dcache;
393

394
        virtual void initialize();
395
        virtual desc_ctx &desc_ctx_create();
396

397
398
    public:
        lan_queue_rx(lan &lanmgr_, uint32_t &reg_tail, size_t idx,
399
400
                uint32_t &reg_ena, uint32_t &fpm_basereg,
                uint32_t &reg_intqctl);
401
        virtual void reset();
402
        void packet_received(const void *data, size_t len);
403
404
};

405
406
407
// rx tx management
class lan {
    protected:
408
409
410
411
        friend class lan_queue_base;
        friend class lan_queue_tx;
        friend class lan_queue_rx;

412
        i40e_bm &dev;
413
        logger log;
414
        const size_t num_qs;
415
416
417
        lan_queue_rx **rxqs;
        lan_queue_tx **txqs;

418
419
    public:
        lan(i40e_bm &dev, size_t num_qs);
420
        void reset();
421
422
        void qena_updated(uint16_t idx, bool rx);
        void tail_updated(uint16_t idx, bool rx);
423
        void packet_received(const void *data, size_t len);
424
};
Antoine Kaufmann's avatar
Antoine Kaufmann committed
425

Antoine Kaufmann's avatar
Antoine Kaufmann committed
426
427
428
class shadow_ram {
    protected:
        i40e_bm &dev;
429
        logger log;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
430
431
432
433
434
435
436
437
438
439
440

    public:
        shadow_ram(i40e_bm &dev);
        void reg_updated();
        uint16_t read(uint16_t addr);
        void write(uint16_t addr, uint16_t val);
};

class i40e_bm : public nicbm::Runner::Device {
protected:
    friend class queue_admin_tx;
441
    friend class host_mem_cache;
442
443
    friend class lan;
    friend class lan_queue_base;
444
445
    friend class lan_queue_rx;
    friend class lan_queue_tx;
446
    friend class shadow_ram;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
447
448
449
450
451
452

    static const unsigned BAR_REGS = 0;
    static const unsigned BAR_IO = 2;

    static const uint32_t NUM_QUEUES = 1536;
    static const uint32_t NUM_PFINTS = 512;
453
    static const uint32_t NUM_VSIS = 384;
454
    static const uint16_t MAX_MTU = 2048;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
455
    static const uint8_t NUM_ITR = 3;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
456
457
458

    struct i40e_regs {
        uint32_t glgen_rstctl;
459
        uint32_t glgen_stat;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
460
461
462
        uint32_t gllan_rctl_0;
        uint32_t pfint_lnklst0;
        uint32_t pfint_icr0_ena;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
463
        uint32_t pfint_icr0;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
464
        uint32_t pfint_itr0[NUM_ITR];
Antoine Kaufmann's avatar
Antoine Kaufmann committed
465

466
        uint32_t pfint_dyn_ctl0;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
467
468
469
470
471
472
473
474
475
476
        uint32_t pfint_dyn_ctln[NUM_PFINTS - 1];
        uint32_t pfint_lnklstn[NUM_PFINTS - 1];
        uint32_t pfint_raten[NUM_PFINTS - 1];
        uint32_t gllan_txpre_qdis[12];

        uint32_t glnvm_srctl;
        uint32_t glnvm_srdata;

        uint32_t qint_tqctl[NUM_QUEUES];
        uint32_t qtx_ena[NUM_QUEUES];
477
        uint32_t qtx_tail[NUM_QUEUES];
Antoine Kaufmann's avatar
Antoine Kaufmann committed
478
479
        uint32_t qint_rqctl[NUM_QUEUES];
        uint32_t qrx_ena[NUM_QUEUES];
480
        uint32_t qrx_tail[NUM_QUEUES];
Antoine Kaufmann's avatar
Antoine Kaufmann committed
481

482
483
484
485
486
        uint32_t glhmc_lantxbase[16];
        uint32_t glhmc_lantxcnt[16];
        uint32_t glhmc_lanrxbase[16];
        uint32_t glhmc_lanrxcnt[16];

Antoine Kaufmann's avatar
Antoine Kaufmann committed
487
488
489
490
491
492
493
        uint32_t pfhmc_sdcmd;
        uint32_t pfhmc_sddatalow;
        uint32_t pfhmc_sddatahigh;
        uint32_t pfhmc_pdinv;
        uint32_t pfhmc_errorinfo;
        uint32_t pfhmc_errordata;

Antoine Kaufmann's avatar
Antoine Kaufmann committed
494
495
496
497
498
499
500
501
502
        uint64_t pf_atqba;
        uint32_t pf_atqlen;
        uint32_t pf_atqh;
        uint32_t pf_atqt;

        uint64_t pf_arqba;
        uint32_t pf_arqlen;
        uint32_t pf_arqh;
        uint32_t pf_arqt;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
503
504

        uint32_t glqf_hkey[13];
Antoine Kaufmann's avatar
Antoine Kaufmann committed
505
506
507
508
509
510
511
512
    };

public:
    i40e_bm();
    ~i40e_bm();

    virtual void setup_intro(struct cosim_pcie_proto_dev_intro &di);
    virtual void reg_read(uint8_t bar, uint64_t addr, void *dest, size_t len);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
513
    virtual uint32_t reg_read32(uint8_t bar, uint64_t addr);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
514
515
    virtual void reg_write(uint8_t bar, uint64_t addr, const void *src,
            size_t len);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
516
    virtual void reg_write32(uint8_t bar, uint64_t addr, uint32_t val);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
517
518
    virtual void dma_complete(nicbm::DMAOp &op);
    virtual void eth_rx(uint8_t port, const void *data, size_t len);
519
520
521
    virtual void timed_event(nicbm::TimedEvent &ev);

    void signal_interrupt(uint16_t vector, uint8_t itr);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
522
523

protected:
524
    logger log;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
525
526
    i40e_regs regs;
    queue_admin_tx pf_atq;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
527
    host_mem_cache hmc;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
528
    shadow_ram shram;
529
    lan lanmgr;
Antoine Kaufmann's avatar
Antoine Kaufmann committed
530

531
532
    int_ev intevs[NUM_PFINTS];

Antoine Kaufmann's avatar
Antoine Kaufmann committed
533
534
535
536
537
538
539
540
541
542
    /** Read from the I/O bar */
    virtual uint32_t reg_io_read(uint64_t addr);
    /** Write to the I/O bar */
    virtual void reg_io_write(uint64_t addr, uint32_t val);

    /** 32-bit read from the memory bar (should be the default) */
    virtual uint32_t reg_mem_read32(uint64_t addr);
    /** 32-bit write to the memory bar (should be the default) */
    virtual void reg_mem_write32(uint64_t addr, uint32_t val);

543
    void reset(bool indicate_done);
Antoine Kaufmann's avatar
Antoine Kaufmann committed
544
545
};

546
547
548
// places the tcp checksum in the packet (assuming ipv4)
void xsum_tcp(void *tcphdr, size_t l4len);

Antoine Kaufmann's avatar
Antoine Kaufmann committed
549
} // namespace corundum