← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to hw/e1000.c

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/e1000.c
 
1
/*
 
2
 * QEMU e1000 emulation
 
3
 *
 
4
 * Software developer's manual:
 
5
 * http://download.intel.com/design/network/manuals/8254x_GBe_SDM.pdf
 
6
 *
 
7
 * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc.
 
8
 * Copyright (c) 2008 Qumranet
 
9
 * Based on work done by:
 
10
 * Copyright (c) 2007 Dan Aloni
 
11
 * Copyright (c) 2004 Antony T Curtis
 
12
 *
 
13
 * This library is free software; you can redistribute it and/or
 
14
 * modify it under the terms of the GNU Lesser General Public
 
15
 * License as published by the Free Software Foundation; either
 
16
 * version 2 of the License, or (at your option) any later version.
 
17
 *
 
18
 * This library is distributed in the hope that it will be useful,
 
19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
21
 * Lesser General Public License for more details.
 
22
 *
 
23
 * You should have received a copy of the GNU Lesser General Public
 
24
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 
25
 */
 
26
 
 
27
 
 
28
#include "hw.h"
 
29
#include "pci.h"
 
30
#include "net.h"
 
31
#include "net/checksum.h"
 
32
#include "loader.h"
 
33
#include "sysemu.h"
 
34
 
 
35
#include "e1000_hw.h"
 
36
 
 
37
#define E1000_DEBUG
 
38
 
 
39
#ifdef E1000_DEBUG
 
40
enum {
 
41
    DEBUG_GENERAL,      DEBUG_IO,       DEBUG_MMIO,     DEBUG_INTERRUPT,
 
42
    DEBUG_RX,           DEBUG_TX,       DEBUG_MDIC,     DEBUG_EEPROM,
 
43
    DEBUG_UNKNOWN,      DEBUG_TXSUM,    DEBUG_TXERR,    DEBUG_RXERR,
 
44
    DEBUG_RXFILTER,     DEBUG_NOTYET,
 
45
};
 
46
#define DBGBIT(x)       (1<<DEBUG_##x)
 
47
static int debugflags = DBGBIT(TXERR) | DBGBIT(GENERAL);
 
48
 
 
49
#define DBGOUT(what, fmt, ...) do { \
 
50
    if (debugflags & DBGBIT(what)) \
 
51
        fprintf(stderr, "e1000: " fmt, ## __VA_ARGS__); \
 
52
    } while (0)
 
53
#else
 
54
#define DBGOUT(what, fmt, ...) do {} while (0)
 
55
#endif
 
56
 
 
57
#define IOPORT_SIZE       0x40
 
58
#define PNPMMIO_SIZE      0x20000
 
59
#define MIN_BUF_SIZE      60 /* Min. octets in an ethernet frame sans FCS */
 
60
 
 
61
/*
 
62
 * HW models:
 
63
 *  E1000_DEV_ID_82540EM works with Windows and Linux
 
64
 *  E1000_DEV_ID_82573L OK with windoze and Linux 2.6.22,
 
65
 *      appears to perform better than 82540EM, but breaks with Linux 2.6.18
 
66
 *  E1000_DEV_ID_82544GC_COPPER appears to work; not well tested
 
67
 *  Others never tested
 
68
 */
 
69
enum { E1000_DEVID = E1000_DEV_ID_82540EM };
 
70
 
 
71
/*
 
72
 * May need to specify additional MAC-to-PHY entries --
 
73
 * Intel's Windows driver refuses to initialize unless they match
 
74
 */
 
75
enum {
 
76
    PHY_ID2_INIT = E1000_DEVID == E1000_DEV_ID_82573L ?         0xcc2 :
 
77
                   E1000_DEVID == E1000_DEV_ID_82544GC_COPPER ? 0xc30 :
 
78
                   /* default to E1000_DEV_ID_82540EM */        0xc20
 
79
};
 
80
 
 
81
typedef struct E1000State_st {
 
82
    PCIDevice dev;
 
83
    NICState *nic;
 
84
    NICConf conf;
 
85
    int mmio_index;
 
86
 
 
87
    uint32_t mac_reg[0x8000];
 
88
    uint16_t phy_reg[0x20];
 
89
    uint16_t eeprom_data[64];
 
90
 
 
91
    uint32_t rxbuf_size;
 
92
    uint32_t rxbuf_min_shift;
 
93
    int check_rxov;
 
94
    struct e1000_tx {
 
95
        unsigned char header[256];
 
96
        unsigned char vlan_header[4];
 
97
        /* Fields vlan and data must not be reordered or separated. */
 
98
        unsigned char vlan[4];
 
99
        unsigned char data[0x10000];
 
100
        uint16_t size;
 
101
        unsigned char sum_needed;
 
102
        unsigned char vlan_needed;
 
103
        uint8_t ipcss;
 
104
        uint8_t ipcso;
 
105
        uint16_t ipcse;
 
106
        uint8_t tucss;
 
107
        uint8_t tucso;
 
108
        uint16_t tucse;
 
109
        uint8_t hdr_len;
 
110
        uint16_t mss;
 
111
        uint32_t paylen;
 
112
        uint16_t tso_frames;
 
113
        char tse;
 
114
        int8_t ip;
 
115
        int8_t tcp;
 
116
        char cptse;     // current packet tse bit
 
117
    } tx;
 
118
 
 
119
    struct {
 
120
        uint32_t val_in;        // shifted in from guest driver
 
121
        uint16_t bitnum_in;
 
122
        uint16_t bitnum_out;
 
123
        uint16_t reading;
 
124
        uint32_t old_eecd;
 
125
    } eecd_state;
 
126
} E1000State;
 
127
 
 
128
#define defreg(x)       x = (E1000_##x>>2)
 
129
enum {
 
130
    defreg(CTRL),       defreg(EECD),   defreg(EERD),   defreg(GPRC),
 
131
    defreg(GPTC),       defreg(ICR),    defreg(ICS),    defreg(IMC),
 
132
    defreg(IMS),        defreg(LEDCTL), defreg(MANC),   defreg(MDIC),
 
133
    defreg(MPC),        defreg(PBA),    defreg(RCTL),   defreg(RDBAH),
 
134
    defreg(RDBAL),      defreg(RDH),    defreg(RDLEN),  defreg(RDT),
 
135
    defreg(STATUS),     defreg(SWSM),   defreg(TCTL),   defreg(TDBAH),
 
136
    defreg(TDBAL),      defreg(TDH),    defreg(TDLEN),  defreg(TDT),
 
137
    defreg(TORH),       defreg(TORL),   defreg(TOTH),   defreg(TOTL),
 
138
    defreg(TPR),        defreg(TPT),    defreg(TXDCTL), defreg(WUFC),
 
139
    defreg(RA),         defreg(MTA),    defreg(CRCERRS),defreg(VFTA),
 
140
    defreg(VET),
 
141
};
 
142
 
 
143
enum { PHY_R = 1, PHY_W = 2, PHY_RW = PHY_R | PHY_W };
 
144
static const char phy_regcap[0x20] = {
 
145
    [PHY_STATUS] = PHY_R,       [M88E1000_EXT_PHY_SPEC_CTRL] = PHY_RW,
 
146
    [PHY_ID1] = PHY_R,          [M88E1000_PHY_SPEC_CTRL] = PHY_RW,
 
147
    [PHY_CTRL] = PHY_RW,        [PHY_1000T_CTRL] = PHY_RW,
 
148
    [PHY_LP_ABILITY] = PHY_R,   [PHY_1000T_STATUS] = PHY_R,
 
149
    [PHY_AUTONEG_ADV] = PHY_RW, [M88E1000_RX_ERR_CNTR] = PHY_R,
 
150
    [PHY_ID2] = PHY_R,          [M88E1000_PHY_SPEC_STATUS] = PHY_R
 
151
};
 
152
 
 
153
static void
 
154
ioport_map(PCIDevice *pci_dev, int region_num, pcibus_t addr,
 
155
           pcibus_t size, int type)
 
156
{
 
157
    DBGOUT(IO, "e1000_ioport_map addr=0x%04"FMT_PCIBUS
 
158
           " size=0x%08"FMT_PCIBUS"\n", addr, size);
 
159
}
 
160
 
 
161
static void
 
162
set_interrupt_cause(E1000State *s, int index, uint32_t val)
 
163
{
 
164
    if (val)
 
165
        val |= E1000_ICR_INT_ASSERTED;
 
166
    s->mac_reg[ICR] = val;
 
167
    s->mac_reg[ICS] = val;
 
168
    qemu_set_irq(s->dev.irq[0], (s->mac_reg[IMS] & s->mac_reg[ICR]) != 0);
 
169
}
 
170
 
 
171
static void
 
172
set_ics(E1000State *s, int index, uint32_t val)
 
173
{
 
174
    DBGOUT(INTERRUPT, "set_ics %x, ICR %x, IMR %x\n", val, s->mac_reg[ICR],
 
175
        s->mac_reg[IMS]);
 
176
    set_interrupt_cause(s, 0, val | s->mac_reg[ICR]);
 
177
}
 
178
 
 
179
static int
 
180
rxbufsize(uint32_t v)
 
181
{
 
182
    v &= E1000_RCTL_BSEX | E1000_RCTL_SZ_16384 | E1000_RCTL_SZ_8192 |
 
183
         E1000_RCTL_SZ_4096 | E1000_RCTL_SZ_2048 | E1000_RCTL_SZ_1024 |
 
184
         E1000_RCTL_SZ_512 | E1000_RCTL_SZ_256;
 
185
    switch (v) {
 
186
    case E1000_RCTL_BSEX | E1000_RCTL_SZ_16384:
 
187
        return 16384;
 
188
    case E1000_RCTL_BSEX | E1000_RCTL_SZ_8192:
 
189
        return 8192;
 
190
    case E1000_RCTL_BSEX | E1000_RCTL_SZ_4096:
 
191
        return 4096;
 
192
    case E1000_RCTL_SZ_1024:
 
193
        return 1024;
 
194
    case E1000_RCTL_SZ_512:
 
195
        return 512;
 
196
    case E1000_RCTL_SZ_256:
 
197
        return 256;
 
198
    }
 
199
    return 2048;
 
200
}
 
201
 
 
202
static void
 
203
set_ctrl(E1000State *s, int index, uint32_t val)
 
204
{
 
205
    /* RST is self clearing */
 
206
    s->mac_reg[CTRL] = val & ~E1000_CTRL_RST;
 
207
}
 
208
 
 
209
static void
 
210
set_rx_control(E1000State *s, int index, uint32_t val)
 
211
{
 
212
    s->mac_reg[RCTL] = val;
 
213
    s->rxbuf_size = rxbufsize(val);
 
214
    s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1;
 
215
    DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT],
 
216
           s->mac_reg[RCTL]);
 
217
}
 
218
 
 
219
static void
 
220
set_mdic(E1000State *s, int index, uint32_t val)
 
221
{
 
222
    uint32_t data = val & E1000_MDIC_DATA_MASK;
 
223
    uint32_t addr = ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT);
 
224
 
 
225
    if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT != 1) // phy #
 
226
        val = s->mac_reg[MDIC] | E1000_MDIC_ERROR;
 
227
    else if (val & E1000_MDIC_OP_READ) {
 
228
        DBGOUT(MDIC, "MDIC read reg 0x%x\n", addr);
 
229
        if (!(phy_regcap[addr] & PHY_R)) {
 
230
            DBGOUT(MDIC, "MDIC read reg %x unhandled\n", addr);
 
231
            val |= E1000_MDIC_ERROR;
 
232
        } else
 
233
            val = (val ^ data) | s->phy_reg[addr];
 
234
    } else if (val & E1000_MDIC_OP_WRITE) {
 
235
        DBGOUT(MDIC, "MDIC write reg 0x%x, value 0x%x\n", addr, data);
 
236
        if (!(phy_regcap[addr] & PHY_W)) {
 
237
            DBGOUT(MDIC, "MDIC write reg %x unhandled\n", addr);
 
238
            val |= E1000_MDIC_ERROR;
 
239
        } else
 
240
            s->phy_reg[addr] = data;
 
241
    }
 
242
    s->mac_reg[MDIC] = val | E1000_MDIC_READY;
 
243
    set_ics(s, 0, E1000_ICR_MDAC);
 
244
}
 
245
 
 
246
static uint32_t
 
247
get_eecd(E1000State *s, int index)
 
248
{
 
249
    uint32_t ret = E1000_EECD_PRES|E1000_EECD_GNT | s->eecd_state.old_eecd;
 
250
 
 
251
    DBGOUT(EEPROM, "reading eeprom bit %d (reading %d)\n",
 
252
           s->eecd_state.bitnum_out, s->eecd_state.reading);
 
253
    if (!s->eecd_state.reading ||
 
254
        ((s->eeprom_data[(s->eecd_state.bitnum_out >> 4) & 0x3f] >>
 
255
          ((s->eecd_state.bitnum_out & 0xf) ^ 0xf))) & 1)
 
256
        ret |= E1000_EECD_DO;
 
257
    return ret;
 
258
}
 
259
 
 
260
static void
 
261
set_eecd(E1000State *s, int index, uint32_t val)
 
262
{
 
263
    uint32_t oldval = s->eecd_state.old_eecd;
 
264
 
 
265
    s->eecd_state.old_eecd = val & (E1000_EECD_SK | E1000_EECD_CS |
 
266
            E1000_EECD_DI|E1000_EECD_FWE_MASK|E1000_EECD_REQ);
 
267
    if (!(E1000_EECD_CS & val))                 // CS inactive; nothing to do
 
268
        return;
 
269
    if (E1000_EECD_CS & (val ^ oldval)) {       // CS rise edge; reset state
 
270
        s->eecd_state.val_in = 0;
 
271
        s->eecd_state.bitnum_in = 0;
 
272
        s->eecd_state.bitnum_out = 0;
 
273
        s->eecd_state.reading = 0;
 
274
    }
 
275
    if (!(E1000_EECD_SK & (val ^ oldval)))      // no clock edge
 
276
        return;
 
277
    if (!(E1000_EECD_SK & val)) {               // falling edge
 
278
        s->eecd_state.bitnum_out++;
 
279
        return;
 
280
    }
 
281
    s->eecd_state.val_in <<= 1;
 
282
    if (val & E1000_EECD_DI)
 
283
        s->eecd_state.val_in |= 1;
 
284
    if (++s->eecd_state.bitnum_in == 9 && !s->eecd_state.reading) {
 
285
        s->eecd_state.bitnum_out = ((s->eecd_state.val_in & 0x3f)<<4)-1;
 
286
        s->eecd_state.reading = (((s->eecd_state.val_in >> 6) & 7) ==
 
287
            EEPROM_READ_OPCODE_MICROWIRE);
 
288
    }
 
289
    DBGOUT(EEPROM, "eeprom bitnum in %d out %d, reading %d\n",
 
290
           s->eecd_state.bitnum_in, s->eecd_state.bitnum_out,
 
291
           s->eecd_state.reading);
 
292
}
 
293
 
 
294
static uint32_t
 
295
flash_eerd_read(E1000State *s, int x)
 
296
{
 
297
    unsigned int index, r = s->mac_reg[EERD] & ~E1000_EEPROM_RW_REG_START;
 
298
 
 
299
    if ((s->mac_reg[EERD] & E1000_EEPROM_RW_REG_START) == 0)
 
300
        return (s->mac_reg[EERD]);
 
301
 
 
302
    if ((index = r >> E1000_EEPROM_RW_ADDR_SHIFT) > EEPROM_CHECKSUM_REG)
 
303
        return (E1000_EEPROM_RW_REG_DONE | r);
 
304
 
 
305
    return ((s->eeprom_data[index] << E1000_EEPROM_RW_REG_DATA) |
 
306
           E1000_EEPROM_RW_REG_DONE | r);
 
307
}
 
308
 
 
309
static void
 
310
putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
 
311
{
 
312
    uint32_t sum;
 
313
 
 
314
    if (cse && cse < n)
 
315
        n = cse + 1;
 
316
    if (sloc < n-1) {
 
317
        sum = net_checksum_add(n-css, data+css);
 
318
        cpu_to_be16wu((uint16_t *)(data + sloc),
 
319
                      net_checksum_finish(sum));
 
320
    }
 
321
}
 
322
 
 
323
static inline int
 
324
vlan_enabled(E1000State *s)
 
325
{
 
326
    return ((s->mac_reg[CTRL] & E1000_CTRL_VME) != 0);
 
327
}
 
328
 
 
329
static inline int
 
330
vlan_rx_filter_enabled(E1000State *s)
 
331
{
 
332
    return ((s->mac_reg[RCTL] & E1000_RCTL_VFE) != 0);
 
333
}
 
334
 
 
335
static inline int
 
336
is_vlan_packet(E1000State *s, const uint8_t *buf)
 
337
{
 
338
    return (be16_to_cpup((uint16_t *)(buf + 12)) ==
 
339
                le16_to_cpup((uint16_t *)(s->mac_reg + VET)));
 
340
}
 
341
 
 
342
static inline int
 
343
is_vlan_txd(uint32_t txd_lower)
 
344
{
 
345
    return ((txd_lower & E1000_TXD_CMD_VLE) != 0);
 
346
}
 
347
 
 
348
/* FCS aka Ethernet CRC-32. We don't get it from backends and can't
 
349
 * fill it in, just pad descriptor length by 4 bytes unless guest
 
350
 * told us to strip it off the packet. */
 
351
static inline int
 
352
fcs_len(E1000State *s)
 
353
{
 
354
    return (s->mac_reg[RCTL] & E1000_RCTL_SECRC) ? 0 : 4;
 
355
}
 
356
 
 
357
static void
 
358
xmit_seg(E1000State *s)
 
359
{
 
360
    uint16_t len, *sp;
 
361
    unsigned int frames = s->tx.tso_frames, css, sofar, n;
 
362
    struct e1000_tx *tp = &s->tx;
 
363
 
 
364
    if (tp->tse && tp->cptse) {
 
365
        css = tp->ipcss;
 
366
        DBGOUT(TXSUM, "frames %d size %d ipcss %d\n",
 
367
               frames, tp->size, css);
 
368
        if (tp->ip) {           // IPv4
 
369
            cpu_to_be16wu((uint16_t *)(tp->data+css+2),
 
370
                          tp->size - css);
 
371
            cpu_to_be16wu((uint16_t *)(tp->data+css+4),
 
372
                          be16_to_cpup((uint16_t *)(tp->data+css+4))+frames);
 
373
        } else                  // IPv6
 
374
            cpu_to_be16wu((uint16_t *)(tp->data+css+4),
 
375
                          tp->size - css);
 
376
        css = tp->tucss;
 
377
        len = tp->size - css;
 
378
        DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", tp->tcp, css, len);
 
379
        if (tp->tcp) {
 
380
            sofar = frames * tp->mss;
 
381
            cpu_to_be32wu((uint32_t *)(tp->data+css+4), // seq
 
382
                be32_to_cpupu((uint32_t *)(tp->data+css+4))+sofar);
 
383
            if (tp->paylen - sofar > tp->mss)
 
384
                tp->data[css + 13] &= ~9;               // PSH, FIN
 
385
        } else  // UDP
 
386
            cpu_to_be16wu((uint16_t *)(tp->data+css+4), len);
 
387
        if (tp->sum_needed & E1000_TXD_POPTS_TXSM) {
 
388
            unsigned int phsum;
 
389
            // add pseudo-header length before checksum calculation
 
390
            sp = (uint16_t *)(tp->data + tp->tucso);
 
391
            phsum = be16_to_cpup(sp) + len;
 
392
            phsum = (phsum >> 16) + (phsum & 0xffff);
 
393
            cpu_to_be16wu(sp, phsum);
 
394
        }
 
395
        tp->tso_frames++;
 
396
    }
 
397
 
 
398
    if (tp->sum_needed & E1000_TXD_POPTS_TXSM)
 
399
        putsum(tp->data, tp->size, tp->tucso, tp->tucss, tp->tucse);
 
400
    if (tp->sum_needed & E1000_TXD_POPTS_IXSM)
 
401
        putsum(tp->data, tp->size, tp->ipcso, tp->ipcss, tp->ipcse);
 
402
    if (tp->vlan_needed) {
 
403
        memmove(tp->vlan, tp->data, 4);
 
404
        memmove(tp->data, tp->data + 4, 8);
 
405
        memcpy(tp->data + 8, tp->vlan_header, 4);
 
406
        qemu_send_packet(&s->nic->nc, tp->vlan, tp->size + 4);
 
407
    } else
 
408
        qemu_send_packet(&s->nic->nc, tp->data, tp->size);
 
409
    s->mac_reg[TPT]++;
 
410
    s->mac_reg[GPTC]++;
 
411
    n = s->mac_reg[TOTL];
 
412
    if ((s->mac_reg[TOTL] += s->tx.size) < n)
 
413
        s->mac_reg[TOTH]++;
 
414
}
 
415
 
 
416
static void
 
417
process_tx_desc(E1000State *s, struct e1000_tx_desc *dp)
 
418
{
 
419
    uint32_t txd_lower = le32_to_cpu(dp->lower.data);
 
420
    uint32_t dtype = txd_lower & (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D);
 
421
    unsigned int split_size = txd_lower & 0xffff, bytes, sz, op;
 
422
    unsigned int msh = 0xfffff, hdr = 0;
 
423
    uint64_t addr;
 
424
    struct e1000_context_desc *xp = (struct e1000_context_desc *)dp;
 
425
    struct e1000_tx *tp = &s->tx;
 
426
 
 
427
    if (dtype == E1000_TXD_CMD_DEXT) {  // context descriptor
 
428
        op = le32_to_cpu(xp->cmd_and_length);
 
429
        tp->ipcss = xp->lower_setup.ip_fields.ipcss;
 
430
        tp->ipcso = xp->lower_setup.ip_fields.ipcso;
 
431
        tp->ipcse = le16_to_cpu(xp->lower_setup.ip_fields.ipcse);
 
432
        tp->tucss = xp->upper_setup.tcp_fields.tucss;
 
433
        tp->tucso = xp->upper_setup.tcp_fields.tucso;
 
434
        tp->tucse = le16_to_cpu(xp->upper_setup.tcp_fields.tucse);
 
435
        tp->paylen = op & 0xfffff;
 
436
        tp->hdr_len = xp->tcp_seg_setup.fields.hdr_len;
 
437
        tp->mss = le16_to_cpu(xp->tcp_seg_setup.fields.mss);
 
438
        tp->ip = (op & E1000_TXD_CMD_IP) ? 1 : 0;
 
439
        tp->tcp = (op & E1000_TXD_CMD_TCP) ? 1 : 0;
 
440
        tp->tse = (op & E1000_TXD_CMD_TSE) ? 1 : 0;
 
441
        tp->tso_frames = 0;
 
442
        if (tp->tucso == 0) {   // this is probably wrong
 
443
            DBGOUT(TXSUM, "TCP/UDP: cso 0!\n");
 
444
            tp->tucso = tp->tucss + (tp->tcp ? 16 : 6);
 
445
        }
 
446
        return;
 
447
    } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) {
 
448
        // data descriptor
 
449
        if (tp->size == 0) {
 
450
            tp->sum_needed = le32_to_cpu(dp->upper.data) >> 8;
 
451
        }
 
452
        tp->cptse = ( txd_lower & E1000_TXD_CMD_TSE ) ? 1 : 0;
 
453
    } else {
 
454
        // legacy descriptor
 
455
        tp->cptse = 0;
 
456
    }
 
457
 
 
458
    if (vlan_enabled(s) && is_vlan_txd(txd_lower) &&
 
459
        (tp->cptse || txd_lower & E1000_TXD_CMD_EOP)) {
 
460
        tp->vlan_needed = 1;
 
461
        cpu_to_be16wu((uint16_t *)(tp->vlan_header),
 
462
                      le16_to_cpup((uint16_t *)(s->mac_reg + VET)));
 
463
        cpu_to_be16wu((uint16_t *)(tp->vlan_header + 2),
 
464
                      le16_to_cpu(dp->upper.fields.special));
 
465
    }
 
466
        
 
467
    addr = le64_to_cpu(dp->buffer_addr);
 
468
    if (tp->tse && tp->cptse) {
 
469
        hdr = tp->hdr_len;
 
470
        msh = hdr + tp->mss;
 
471
        do {
 
472
            bytes = split_size;
 
473
            if (tp->size + bytes > msh)
 
474
                bytes = msh - tp->size;
 
475
            cpu_physical_memory_read(addr, tp->data + tp->size, bytes);
 
476
            if ((sz = tp->size + bytes) >= hdr && tp->size < hdr)
 
477
                memmove(tp->header, tp->data, hdr);
 
478
            tp->size = sz;
 
479
            addr += bytes;
 
480
            if (sz == msh) {
 
481
                xmit_seg(s);
 
482
                memmove(tp->data, tp->header, hdr);
 
483
                tp->size = hdr;
 
484
            }
 
485
        } while (split_size -= bytes);
 
486
    } else if (!tp->tse && tp->cptse) {
 
487
        // context descriptor TSE is not set, while data descriptor TSE is set
 
488
        DBGOUT(TXERR, "TCP segmentaion Error\n");
 
489
    } else {
 
490
        cpu_physical_memory_read(addr, tp->data + tp->size, split_size);
 
491
        tp->size += split_size;
 
492
    }
 
493
 
 
494
    if (!(txd_lower & E1000_TXD_CMD_EOP))
 
495
        return;
 
496
    if (!(tp->tse && tp->cptse && tp->size < hdr))
 
497
        xmit_seg(s);
 
498
    tp->tso_frames = 0;
 
499
    tp->sum_needed = 0;
 
500
    tp->vlan_needed = 0;
 
501
    tp->size = 0;
 
502
    tp->cptse = 0;
 
503
}
 
504
 
 
505
static uint32_t
 
506
txdesc_writeback(target_phys_addr_t base, struct e1000_tx_desc *dp)
 
507
{
 
508
    uint32_t txd_upper, txd_lower = le32_to_cpu(dp->lower.data);
 
509
 
 
510
    if (!(txd_lower & (E1000_TXD_CMD_RS|E1000_TXD_CMD_RPS)))
 
511
        return 0;
 
512
    txd_upper = (le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD) &
 
513
                ~(E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | E1000_TXD_STAT_TU);
 
514
    dp->upper.data = cpu_to_le32(txd_upper);
 
515
    cpu_physical_memory_write(base + ((char *)&dp->upper - (char *)dp),
 
516
                              (void *)&dp->upper, sizeof(dp->upper));
 
517
    return E1000_ICR_TXDW;
 
518
}
 
519
 
 
520
static uint64_t tx_desc_base(E1000State *s)
 
521
{
 
522
    uint64_t bah = s->mac_reg[TDBAH];
 
523
    uint64_t bal = s->mac_reg[TDBAL] & ~0xf;
 
524
 
 
525
    return (bah << 32) + bal;
 
526
}
 
527
 
 
528
static void
 
529
start_xmit(E1000State *s)
 
530
{
 
531
    target_phys_addr_t base;
 
532
    struct e1000_tx_desc desc;
 
533
    uint32_t tdh_start = s->mac_reg[TDH], cause = E1000_ICS_TXQE;
 
534
 
 
535
    if (!(s->mac_reg[TCTL] & E1000_TCTL_EN)) {
 
536
        DBGOUT(TX, "tx disabled\n");
 
537
        return;
 
538
    }
 
539
 
 
540
    while (s->mac_reg[TDH] != s->mac_reg[TDT]) {
 
541
        base = tx_desc_base(s) +
 
542
               sizeof(struct e1000_tx_desc) * s->mac_reg[TDH];
 
543
        cpu_physical_memory_read(base, (void *)&desc, sizeof(desc));
 
544
 
 
545
        DBGOUT(TX, "index %d: %p : %x %x\n", s->mac_reg[TDH],
 
546
               (void *)(intptr_t)desc.buffer_addr, desc.lower.data,
 
547
               desc.upper.data);
 
548
 
 
549
        process_tx_desc(s, &desc);
 
550
        cause |= txdesc_writeback(base, &desc);
 
551
 
 
552
        if (++s->mac_reg[TDH] * sizeof(desc) >= s->mac_reg[TDLEN])
 
553
            s->mac_reg[TDH] = 0;
 
554
        /*
 
555
         * the following could happen only if guest sw assigns
 
556
         * bogus values to TDT/TDLEN.
 
557
         * there's nothing too intelligent we could do about this.
 
558
         */
 
559
        if (s->mac_reg[TDH] == tdh_start) {
 
560
            DBGOUT(TXERR, "TDH wraparound @%x, TDT %x, TDLEN %x\n",
 
561
                   tdh_start, s->mac_reg[TDT], s->mac_reg[TDLEN]);
 
562
            break;
 
563
        }
 
564
    }
 
565
    set_ics(s, 0, cause);
 
566
}
 
567
 
 
568
static int
 
569
receive_filter(E1000State *s, const uint8_t *buf, int size)
 
570
{
 
571
    static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
572
    static const int mta_shift[] = {4, 3, 2, 0};
 
573
    uint32_t f, rctl = s->mac_reg[RCTL], ra[2], *rp;
 
574
 
 
575
    if (is_vlan_packet(s, buf) && vlan_rx_filter_enabled(s)) {
 
576
        uint16_t vid = be16_to_cpup((uint16_t *)(buf + 14));
 
577
        uint32_t vfta = le32_to_cpup((uint32_t *)(s->mac_reg + VFTA) +
 
578
                                     ((vid >> 5) & 0x7f));
 
579
        if ((vfta & (1 << (vid & 0x1f))) == 0)
 
580
            return 0;
 
581
    }
 
582
 
 
583
    if (rctl & E1000_RCTL_UPE)                  // promiscuous
 
584
        return 1;
 
585
 
 
586
    if ((buf[0] & 1) && (rctl & E1000_RCTL_MPE))        // promiscuous mcast
 
587
        return 1;
 
588
 
 
589
    if ((rctl & E1000_RCTL_BAM) && !memcmp(buf, bcast, sizeof bcast))
 
590
        return 1;
 
591
 
 
592
    for (rp = s->mac_reg + RA; rp < s->mac_reg + RA + 32; rp += 2) {
 
593
        if (!(rp[1] & E1000_RAH_AV))
 
594
            continue;
 
595
        ra[0] = cpu_to_le32(rp[0]);
 
596
        ra[1] = cpu_to_le32(rp[1]);
 
597
        if (!memcmp(buf, (uint8_t *)ra, 6)) {
 
598
            DBGOUT(RXFILTER,
 
599
                   "unicast match[%d]: %02x:%02x:%02x:%02x:%02x:%02x\n",
 
600
                   (int)(rp - s->mac_reg - RA)/2,
 
601
                   buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 
602
            return 1;
 
603
        }
 
604
    }
 
605
    DBGOUT(RXFILTER, "unicast mismatch: %02x:%02x:%02x:%02x:%02x:%02x\n",
 
606
           buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 
607
 
 
608
    f = mta_shift[(rctl >> E1000_RCTL_MO_SHIFT) & 3];
 
609
    f = (((buf[5] << 8) | buf[4]) >> f) & 0xfff;
 
610
    if (s->mac_reg[MTA + (f >> 5)] & (1 << (f & 0x1f)))
 
611
        return 1;
 
612
    DBGOUT(RXFILTER,
 
613
           "dropping, inexact filter mismatch: %02x:%02x:%02x:%02x:%02x:%02x MO %d MTA[%d] %x\n",
 
614
           buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
 
615
           (rctl >> E1000_RCTL_MO_SHIFT) & 3, f >> 5,
 
616
           s->mac_reg[MTA + (f >> 5)]);
 
617
 
 
618
    return 0;
 
619
}
 
620
 
 
621
static void
 
622
e1000_set_link_status(VLANClientState *nc)
 
623
{
 
624
    E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
 
625
    uint32_t old_status = s->mac_reg[STATUS];
 
626
 
 
627
    if (nc->link_down)
 
628
        s->mac_reg[STATUS] &= ~E1000_STATUS_LU;
 
629
    else
 
630
        s->mac_reg[STATUS] |= E1000_STATUS_LU;
 
631
 
 
632
    if (s->mac_reg[STATUS] != old_status)
 
633
        set_ics(s, 0, E1000_ICR_LSC);
 
634
}
 
635
 
 
636
static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
 
637
{
 
638
    int bufs;
 
639
    /* Fast-path short packets */
 
640
    if (total_size <= s->rxbuf_size) {
 
641
        return s->mac_reg[RDH] != s->mac_reg[RDT] || !s->check_rxov;
 
642
    }
 
643
    if (s->mac_reg[RDH] < s->mac_reg[RDT]) {
 
644
        bufs = s->mac_reg[RDT] - s->mac_reg[RDH];
 
645
    } else if (s->mac_reg[RDH] > s->mac_reg[RDT] || !s->check_rxov) {
 
646
        bufs = s->mac_reg[RDLEN] /  sizeof(struct e1000_rx_desc) +
 
647
            s->mac_reg[RDT] - s->mac_reg[RDH];
 
648
    } else {
 
649
        return false;
 
650
    }
 
651
    return total_size <= bufs * s->rxbuf_size;
 
652
}
 
653
 
 
654
static int
 
655
e1000_can_receive(VLANClientState *nc)
 
656
{
 
657
    E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
 
658
 
 
659
    return (s->mac_reg[RCTL] & E1000_RCTL_EN) && e1000_has_rxbufs(s, 1);
 
660
}
 
661
 
 
662
static uint64_t rx_desc_base(E1000State *s)
 
663
{
 
664
    uint64_t bah = s->mac_reg[RDBAH];
 
665
    uint64_t bal = s->mac_reg[RDBAL] & ~0xf;
 
666
 
 
667
    return (bah << 32) + bal;
 
668
}
 
669
 
 
670
static ssize_t
 
671
e1000_receive(VLANClientState *nc, const uint8_t *buf, size_t size)
 
672
{
 
673
    E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
 
674
    struct e1000_rx_desc desc;
 
675
    target_phys_addr_t base;
 
676
    unsigned int n, rdt;
 
677
    uint32_t rdh_start;
 
678
    uint16_t vlan_special = 0;
 
679
    uint8_t vlan_status = 0, vlan_offset = 0;
 
680
    uint8_t min_buf[MIN_BUF_SIZE];
 
681
    size_t desc_offset;
 
682
    size_t desc_size;
 
683
    size_t total_size;
 
684
 
 
685
    if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
 
686
        return -1;
 
687
 
 
688
    /* Pad to minimum Ethernet frame length */
 
689
    if (size < sizeof(min_buf)) {
 
690
        memcpy(min_buf, buf, size);
 
691
        memset(&min_buf[size], 0, sizeof(min_buf) - size);
 
692
        buf = min_buf;
 
693
        size = sizeof(min_buf);
 
694
    }
 
695
 
 
696
    if (!receive_filter(s, buf, size))
 
697
        return size;
 
698
 
 
699
    if (vlan_enabled(s) && is_vlan_packet(s, buf)) {
 
700
        vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(buf + 14)));
 
701
        memmove((uint8_t *)buf + 4, buf, 12);
 
702
        vlan_status = E1000_RXD_STAT_VP;
 
703
        vlan_offset = 4;
 
704
        size -= 4;
 
705
    }
 
706
 
 
707
    rdh_start = s->mac_reg[RDH];
 
708
    desc_offset = 0;
 
709
    total_size = size + fcs_len(s);
 
710
    if (!e1000_has_rxbufs(s, total_size)) {
 
711
            set_ics(s, 0, E1000_ICS_RXO);
 
712
            return -1;
 
713
    }
 
714
    do {
 
715
        desc_size = total_size - desc_offset;
 
716
        if (desc_size > s->rxbuf_size) {
 
717
            desc_size = s->rxbuf_size;
 
718
        }
 
719
        base = rx_desc_base(s) + sizeof(desc) * s->mac_reg[RDH];
 
720
        cpu_physical_memory_read(base, (void *)&desc, sizeof(desc));
 
721
        desc.special = vlan_special;
 
722
        desc.status |= (vlan_status | E1000_RXD_STAT_DD);
 
723
        if (desc.buffer_addr) {
 
724
            if (desc_offset < size) {
 
725
                size_t copy_size = size - desc_offset;
 
726
                if (copy_size > s->rxbuf_size) {
 
727
                    copy_size = s->rxbuf_size;
 
728
                }
 
729
                cpu_physical_memory_write(le64_to_cpu(desc.buffer_addr),
 
730
                                          (void *)(buf + desc_offset + vlan_offset),
 
731
                                          copy_size);
 
732
            }
 
733
            desc_offset += desc_size;
 
734
            desc.length = cpu_to_le16(desc_size);
 
735
            if (desc_offset >= total_size) {
 
736
                desc.status |= E1000_RXD_STAT_EOP | E1000_RXD_STAT_IXSM;
 
737
            } else {
 
738
                /* Guest zeroing out status is not a hardware requirement.
 
739
                   Clear EOP in case guest didn't do it. */
 
740
                desc.status &= ~E1000_RXD_STAT_EOP;
 
741
            }
 
742
        } else { // as per intel docs; skip descriptors with null buf addr
 
743
            DBGOUT(RX, "Null RX descriptor!!\n");
 
744
        }
 
745
        cpu_physical_memory_write(base, (void *)&desc, sizeof(desc));
 
746
 
 
747
        if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN])
 
748
            s->mac_reg[RDH] = 0;
 
749
        s->check_rxov = 1;
 
750
        /* see comment in start_xmit; same here */
 
751
        if (s->mac_reg[RDH] == rdh_start) {
 
752
            DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
 
753
                   rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
 
754
            set_ics(s, 0, E1000_ICS_RXO);
 
755
            return -1;
 
756
        }
 
757
    } while (desc_offset < total_size);
 
758
 
 
759
    s->mac_reg[GPRC]++;
 
760
    s->mac_reg[TPR]++;
 
761
    /* TOR - Total Octets Received:
 
762
     * This register includes bytes received in a packet from the <Destination
 
763
     * Address> field through the <CRC> field, inclusively.
 
764
     */
 
765
    n = s->mac_reg[TORL] + size + /* Always include FCS length. */ 4;
 
766
    if (n < s->mac_reg[TORL])
 
767
        s->mac_reg[TORH]++;
 
768
    s->mac_reg[TORL] = n;
 
769
 
 
770
    n = E1000_ICS_RXT0;
 
771
    if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH])
 
772
        rdt += s->mac_reg[RDLEN] / sizeof(desc);
 
773
    if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >>
 
774
        s->rxbuf_min_shift)
 
775
        n |= E1000_ICS_RXDMT0;
 
776
 
 
777
    set_ics(s, 0, n);
 
778
 
 
779
    return size;
 
780
}
 
781
 
 
782
static uint32_t
 
783
mac_readreg(E1000State *s, int index)
 
784
{
 
785
    return s->mac_reg[index];
 
786
}
 
787
 
 
788
static uint32_t
 
789
mac_icr_read(E1000State *s, int index)
 
790
{
 
791
    uint32_t ret = s->mac_reg[ICR];
 
792
 
 
793
    DBGOUT(INTERRUPT, "ICR read: %x\n", ret);
 
794
    set_interrupt_cause(s, 0, 0);
 
795
    return ret;
 
796
}
 
797
 
 
798
static uint32_t
 
799
mac_read_clr4(E1000State *s, int index)
 
800
{
 
801
    uint32_t ret = s->mac_reg[index];
 
802
 
 
803
    s->mac_reg[index] = 0;
 
804
    return ret;
 
805
}
 
806
 
 
807
static uint32_t
 
808
mac_read_clr8(E1000State *s, int index)
 
809
{
 
810
    uint32_t ret = s->mac_reg[index];
 
811
 
 
812
    s->mac_reg[index] = 0;
 
813
    s->mac_reg[index-1] = 0;
 
814
    return ret;
 
815
}
 
816
 
 
817
static void
 
818
mac_writereg(E1000State *s, int index, uint32_t val)
 
819
{
 
820
    s->mac_reg[index] = val;
 
821
}
 
822
 
 
823
static void
 
824
set_rdt(E1000State *s, int index, uint32_t val)
 
825
{
 
826
    s->check_rxov = 0;
 
827
    s->mac_reg[index] = val & 0xffff;
 
828
}
 
829
 
 
830
static void
 
831
set_16bit(E1000State *s, int index, uint32_t val)
 
832
{
 
833
    s->mac_reg[index] = val & 0xffff;
 
834
}
 
835
 
 
836
static void
 
837
set_dlen(E1000State *s, int index, uint32_t val)
 
838
{
 
839
    s->mac_reg[index] = val & 0xfff80;
 
840
}
 
841
 
 
842
static void
 
843
set_tctl(E1000State *s, int index, uint32_t val)
 
844
{
 
845
    s->mac_reg[index] = val;
 
846
    s->mac_reg[TDT] &= 0xffff;
 
847
    start_xmit(s);
 
848
}
 
849
 
 
850
static void
 
851
set_icr(E1000State *s, int index, uint32_t val)
 
852
{
 
853
    DBGOUT(INTERRUPT, "set_icr %x\n", val);
 
854
    set_interrupt_cause(s, 0, s->mac_reg[ICR] & ~val);
 
855
}
 
856
 
 
857
static void
 
858
set_imc(E1000State *s, int index, uint32_t val)
 
859
{
 
860
    s->mac_reg[IMS] &= ~val;
 
861
    set_ics(s, 0, 0);
 
862
}
 
863
 
 
864
static void
 
865
set_ims(E1000State *s, int index, uint32_t val)
 
866
{
 
867
    s->mac_reg[IMS] |= val;
 
868
    set_ics(s, 0, 0);
 
869
}
 
870
 
 
871
#define getreg(x)       [x] = mac_readreg
 
872
static uint32_t (*macreg_readops[])(E1000State *, int) = {
 
873
    getreg(PBA),        getreg(RCTL),   getreg(TDH),    getreg(TXDCTL),
 
874
    getreg(WUFC),       getreg(TDT),    getreg(CTRL),   getreg(LEDCTL),
 
875
    getreg(MANC),       getreg(MDIC),   getreg(SWSM),   getreg(STATUS),
 
876
    getreg(TORL),       getreg(TOTL),   getreg(IMS),    getreg(TCTL),
 
877
    getreg(RDH),        getreg(RDT),    getreg(VET),    getreg(ICS),
 
878
    getreg(TDBAL),      getreg(TDBAH),  getreg(RDBAH),  getreg(RDBAL),
 
879
    getreg(TDLEN),      getreg(RDLEN),
 
880
 
 
881
    [TOTH] = mac_read_clr8,     [TORH] = mac_read_clr8, [GPRC] = mac_read_clr4,
 
882
    [GPTC] = mac_read_clr4,     [TPR] = mac_read_clr4,  [TPT] = mac_read_clr4,
 
883
    [ICR] = mac_icr_read,       [EECD] = get_eecd,      [EERD] = flash_eerd_read,
 
884
    [CRCERRS ... MPC] = &mac_readreg,
 
885
    [RA ... RA+31] = &mac_readreg,
 
886
    [MTA ... MTA+127] = &mac_readreg,
 
887
    [VFTA ... VFTA+127] = &mac_readreg,
 
888
};
 
889
enum { NREADOPS = ARRAY_SIZE(macreg_readops) };
 
890
 
 
891
#define putreg(x)       [x] = mac_writereg
 
892
static void (*macreg_writeops[])(E1000State *, int, uint32_t) = {
 
893
    putreg(PBA),        putreg(EERD),   putreg(SWSM),   putreg(WUFC),
 
894
    putreg(TDBAL),      putreg(TDBAH),  putreg(TXDCTL), putreg(RDBAH),
 
895
    putreg(RDBAL),      putreg(LEDCTL), putreg(VET),
 
896
    [TDLEN] = set_dlen, [RDLEN] = set_dlen,     [TCTL] = set_tctl,
 
897
    [TDT] = set_tctl,   [MDIC] = set_mdic,      [ICS] = set_ics,
 
898
    [TDH] = set_16bit,  [RDH] = set_16bit,      [RDT] = set_rdt,
 
899
    [IMC] = set_imc,    [IMS] = set_ims,        [ICR] = set_icr,
 
900
    [EECD] = set_eecd,  [RCTL] = set_rx_control, [CTRL] = set_ctrl,
 
901
    [RA ... RA+31] = &mac_writereg,
 
902
    [MTA ... MTA+127] = &mac_writereg,
 
903
    [VFTA ... VFTA+127] = &mac_writereg,
 
904
};
 
905
enum { NWRITEOPS = ARRAY_SIZE(macreg_writeops) };
 
906
 
 
907
static void
 
908
e1000_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
 
909
{
 
910
    E1000State *s = opaque;
 
911
    unsigned int index = (addr & 0x1ffff) >> 2;
 
912
 
 
913
    if (index < NWRITEOPS && macreg_writeops[index]) {
 
914
        macreg_writeops[index](s, index, val);
 
915
    } else if (index < NREADOPS && macreg_readops[index]) {
 
916
        DBGOUT(MMIO, "e1000_mmio_writel RO %x: 0x%04x\n", index<<2, val);
 
917
    } else {
 
918
        DBGOUT(UNKNOWN, "MMIO unknown write addr=0x%08x,val=0x%08x\n",
 
919
               index<<2, val);
 
920
    }
 
921
}
 
922
 
 
923
static void
 
924
e1000_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
 
925
{
 
926
    // emulate hw without byte enables: no RMW
 
927
    e1000_mmio_writel(opaque, addr & ~3,
 
928
                      (val & 0xffff) << (8*(addr & 3)));
 
929
}
 
930
 
 
931
static void
 
932
e1000_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
 
933
{
 
934
    // emulate hw without byte enables: no RMW
 
935
    e1000_mmio_writel(opaque, addr & ~3,
 
936
                      (val & 0xff) << (8*(addr & 3)));
 
937
}
 
938
 
 
939
static uint32_t
 
940
e1000_mmio_readl(void *opaque, target_phys_addr_t addr)
 
941
{
 
942
    E1000State *s = opaque;
 
943
    unsigned int index = (addr & 0x1ffff) >> 2;
 
944
 
 
945
    if (index < NREADOPS && macreg_readops[index])
 
946
    {
 
947
        return macreg_readops[index](s, index);
 
948
    }
 
949
    DBGOUT(UNKNOWN, "MMIO unknown read addr=0x%08x\n", index<<2);
 
950
    return 0;
 
951
}
 
952
 
 
953
static uint32_t
 
954
e1000_mmio_readb(void *opaque, target_phys_addr_t addr)
 
955
{
 
956
    return ((e1000_mmio_readl(opaque, addr & ~3)) >>
 
957
            (8 * (addr & 3))) & 0xff;
 
958
}
 
959
 
 
960
static uint32_t
 
961
e1000_mmio_readw(void *opaque, target_phys_addr_t addr)
 
962
{
 
963
    return ((e1000_mmio_readl(opaque, addr & ~3)) >>
 
964
            (8 * (addr & 3))) & 0xffff;
 
965
}
 
966
 
 
967
static bool is_version_1(void *opaque, int version_id)
 
968
{
 
969
    return version_id == 1;
 
970
}
 
971
 
 
972
static const VMStateDescription vmstate_e1000 = {
 
973
    .name = "e1000",
 
974
    .version_id = 2,
 
975
    .minimum_version_id = 1,
 
976
    .minimum_version_id_old = 1,
 
977
    .fields      = (VMStateField []) {
 
978
        VMSTATE_PCI_DEVICE(dev, E1000State),
 
979
        VMSTATE_UNUSED_TEST(is_version_1, 4), /* was instance id */
 
980
        VMSTATE_UNUSED(4), /* Was mmio_base.  */
 
981
        VMSTATE_UINT32(rxbuf_size, E1000State),
 
982
        VMSTATE_UINT32(rxbuf_min_shift, E1000State),
 
983
        VMSTATE_UINT32(eecd_state.val_in, E1000State),
 
984
        VMSTATE_UINT16(eecd_state.bitnum_in, E1000State),
 
985
        VMSTATE_UINT16(eecd_state.bitnum_out, E1000State),
 
986
        VMSTATE_UINT16(eecd_state.reading, E1000State),
 
987
        VMSTATE_UINT32(eecd_state.old_eecd, E1000State),
 
988
        VMSTATE_UINT8(tx.ipcss, E1000State),
 
989
        VMSTATE_UINT8(tx.ipcso, E1000State),
 
990
        VMSTATE_UINT16(tx.ipcse, E1000State),
 
991
        VMSTATE_UINT8(tx.tucss, E1000State),
 
992
        VMSTATE_UINT8(tx.tucso, E1000State),
 
993
        VMSTATE_UINT16(tx.tucse, E1000State),
 
994
        VMSTATE_UINT32(tx.paylen, E1000State),
 
995
        VMSTATE_UINT8(tx.hdr_len, E1000State),
 
996
        VMSTATE_UINT16(tx.mss, E1000State),
 
997
        VMSTATE_UINT16(tx.size, E1000State),
 
998
        VMSTATE_UINT16(tx.tso_frames, E1000State),
 
999
        VMSTATE_UINT8(tx.sum_needed, E1000State),
 
1000
        VMSTATE_INT8(tx.ip, E1000State),
 
1001
        VMSTATE_INT8(tx.tcp, E1000State),
 
1002
        VMSTATE_BUFFER(tx.header, E1000State),
 
1003
        VMSTATE_BUFFER(tx.data, E1000State),
 
1004
        VMSTATE_UINT16_ARRAY(eeprom_data, E1000State, 64),
 
1005
        VMSTATE_UINT16_ARRAY(phy_reg, E1000State, 0x20),
 
1006
        VMSTATE_UINT32(mac_reg[CTRL], E1000State),
 
1007
        VMSTATE_UINT32(mac_reg[EECD], E1000State),
 
1008
        VMSTATE_UINT32(mac_reg[EERD], E1000State),
 
1009
        VMSTATE_UINT32(mac_reg[GPRC], E1000State),
 
1010
        VMSTATE_UINT32(mac_reg[GPTC], E1000State),
 
1011
        VMSTATE_UINT32(mac_reg[ICR], E1000State),
 
1012
        VMSTATE_UINT32(mac_reg[ICS], E1000State),
 
1013
        VMSTATE_UINT32(mac_reg[IMC], E1000State),
 
1014
        VMSTATE_UINT32(mac_reg[IMS], E1000State),
 
1015
        VMSTATE_UINT32(mac_reg[LEDCTL], E1000State),
 
1016
        VMSTATE_UINT32(mac_reg[MANC], E1000State),
 
1017
        VMSTATE_UINT32(mac_reg[MDIC], E1000State),
 
1018
        VMSTATE_UINT32(mac_reg[MPC], E1000State),
 
1019
        VMSTATE_UINT32(mac_reg[PBA], E1000State),
 
1020
        VMSTATE_UINT32(mac_reg[RCTL], E1000State),
 
1021
        VMSTATE_UINT32(mac_reg[RDBAH], E1000State),
 
1022
        VMSTATE_UINT32(mac_reg[RDBAL], E1000State),
 
1023
        VMSTATE_UINT32(mac_reg[RDH], E1000State),
 
1024
        VMSTATE_UINT32(mac_reg[RDLEN], E1000State),
 
1025
        VMSTATE_UINT32(mac_reg[RDT], E1000State),
 
1026
        VMSTATE_UINT32(mac_reg[STATUS], E1000State),
 
1027
        VMSTATE_UINT32(mac_reg[SWSM], E1000State),
 
1028
        VMSTATE_UINT32(mac_reg[TCTL], E1000State),
 
1029
        VMSTATE_UINT32(mac_reg[TDBAH], E1000State),
 
1030
        VMSTATE_UINT32(mac_reg[TDBAL], E1000State),
 
1031
        VMSTATE_UINT32(mac_reg[TDH], E1000State),
 
1032
        VMSTATE_UINT32(mac_reg[TDLEN], E1000State),
 
1033
        VMSTATE_UINT32(mac_reg[TDT], E1000State),
 
1034
        VMSTATE_UINT32(mac_reg[TORH], E1000State),
 
1035
        VMSTATE_UINT32(mac_reg[TORL], E1000State),
 
1036
        VMSTATE_UINT32(mac_reg[TOTH], E1000State),
 
1037
        VMSTATE_UINT32(mac_reg[TOTL], E1000State),
 
1038
        VMSTATE_UINT32(mac_reg[TPR], E1000State),
 
1039
        VMSTATE_UINT32(mac_reg[TPT], E1000State),
 
1040
        VMSTATE_UINT32(mac_reg[TXDCTL], E1000State),
 
1041
        VMSTATE_UINT32(mac_reg[WUFC], E1000State),
 
1042
        VMSTATE_UINT32(mac_reg[VET], E1000State),
 
1043
        VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32),
 
1044
        VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128),
 
1045
        VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128),
 
1046
        VMSTATE_END_OF_LIST()
 
1047
    }
 
1048
};
 
1049
 
 
1050
static const uint16_t e1000_eeprom_template[64] = {
 
1051
    0x0000, 0x0000, 0x0000, 0x0000,      0xffff, 0x0000,      0x0000, 0x0000,
 
1052
    0x3000, 0x1000, 0x6403, E1000_DEVID, 0x8086, E1000_DEVID, 0x8086, 0x3040,
 
1053
    0x0008, 0x2000, 0x7e14, 0x0048,      0x1000, 0x00d8,      0x0000, 0x2700,
 
1054
    0x6cc9, 0x3150, 0x0722, 0x040b,      0x0984, 0x0000,      0xc000, 0x0706,
 
1055
    0x1008, 0x0000, 0x0f04, 0x7fff,      0x4d01, 0xffff,      0xffff, 0xffff,
 
1056
    0xffff, 0xffff, 0xffff, 0xffff,      0xffff, 0xffff,      0xffff, 0xffff,
 
1057
    0x0100, 0x4000, 0x121c, 0xffff,      0xffff, 0xffff,      0xffff, 0xffff,
 
1058
    0xffff, 0xffff, 0xffff, 0xffff,      0xffff, 0xffff,      0xffff, 0x0000,
 
1059
};
 
1060
 
 
1061
static const uint16_t phy_reg_init[] = {
 
1062
    [PHY_CTRL] = 0x1140,                        [PHY_STATUS] = 0x796d, // link initially up
 
1063
    [PHY_ID1] = 0x141,                          [PHY_ID2] = PHY_ID2_INIT,
 
1064
    [PHY_1000T_CTRL] = 0x0e00,                  [M88E1000_PHY_SPEC_CTRL] = 0x360,
 
1065
    [M88E1000_EXT_PHY_SPEC_CTRL] = 0x0d60,      [PHY_AUTONEG_ADV] = 0xde1,
 
1066
    [PHY_LP_ABILITY] = 0x1e0,                   [PHY_1000T_STATUS] = 0x3c00,
 
1067
    [M88E1000_PHY_SPEC_STATUS] = 0xac00,
 
1068
};
 
1069
 
 
1070
static const uint32_t mac_reg_init[] = {
 
1071
    [PBA] =     0x00100030,
 
1072
    [LEDCTL] =  0x602,
 
1073
    [CTRL] =    E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN0 |
 
1074
                E1000_CTRL_SPD_1000 | E1000_CTRL_SLU,
 
1075
    [STATUS] =  0x80000000 | E1000_STATUS_GIO_MASTER_ENABLE |
 
1076
                E1000_STATUS_ASDV | E1000_STATUS_MTXCKOK |
 
1077
                E1000_STATUS_SPEED_1000 | E1000_STATUS_FD |
 
1078
                E1000_STATUS_LU,
 
1079
    [MANC] =    E1000_MANC_EN_MNG2HOST | E1000_MANC_RCV_TCO_EN |
 
1080
                E1000_MANC_ARP_EN | E1000_MANC_0298_EN |
 
1081
                E1000_MANC_RMCP_EN,
 
1082
};
 
1083
 
 
1084
/* PCI interface */
 
1085
 
 
1086
static CPUWriteMemoryFunc * const e1000_mmio_write[] = {
 
1087
    e1000_mmio_writeb,  e1000_mmio_writew,      e1000_mmio_writel
 
1088
};
 
1089
 
 
1090
static CPUReadMemoryFunc * const e1000_mmio_read[] = {
 
1091
    e1000_mmio_readb,   e1000_mmio_readw,       e1000_mmio_readl
 
1092
};
 
1093
 
 
1094
static void
 
1095
e1000_mmio_map(PCIDevice *pci_dev, int region_num,
 
1096
                pcibus_t addr, pcibus_t size, int type)
 
1097
{
 
1098
    E1000State *d = DO_UPCAST(E1000State, dev, pci_dev);
 
1099
    int i;
 
1100
    const uint32_t excluded_regs[] = {
 
1101
        E1000_MDIC, E1000_ICR, E1000_ICS, E1000_IMS,
 
1102
        E1000_IMC, E1000_TCTL, E1000_TDT, PNPMMIO_SIZE
 
1103
    };
 
1104
 
 
1105
 
 
1106
    DBGOUT(MMIO, "e1000_mmio_map addr=0x%08"FMT_PCIBUS" 0x%08"FMT_PCIBUS"\n",
 
1107
           addr, size);
 
1108
 
 
1109
    cpu_register_physical_memory(addr, PNPMMIO_SIZE, d->mmio_index);
 
1110
    qemu_register_coalesced_mmio(addr, excluded_regs[0]);
 
1111
 
 
1112
    for (i = 0; excluded_regs[i] != PNPMMIO_SIZE; i++)
 
1113
        qemu_register_coalesced_mmio(addr + excluded_regs[i] + 4,
 
1114
                                     excluded_regs[i + 1] -
 
1115
                                     excluded_regs[i] - 4);
 
1116
}
 
1117
 
 
1118
static void
 
1119
e1000_cleanup(VLANClientState *nc)
 
1120
{
 
1121
    E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
 
1122
 
 
1123
    s->nic = NULL;
 
1124
}
 
1125
 
 
1126
static int
 
1127
pci_e1000_uninit(PCIDevice *dev)
 
1128
{
 
1129
    E1000State *d = DO_UPCAST(E1000State, dev, dev);
 
1130
 
 
1131
    cpu_unregister_io_memory(d->mmio_index);
 
1132
    qemu_del_vlan_client(&d->nic->nc);
 
1133
    return 0;
 
1134
}
 
1135
 
 
1136
static void e1000_reset(void *opaque)
 
1137
{
 
1138
    E1000State *d = opaque;
 
1139
 
 
1140
    memset(d->phy_reg, 0, sizeof d->phy_reg);
 
1141
    memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init);
 
1142
    memset(d->mac_reg, 0, sizeof d->mac_reg);
 
1143
    memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init);
 
1144
    d->rxbuf_min_shift = 1;
 
1145
    memset(&d->tx, 0, sizeof d->tx);
 
1146
}
 
1147
 
 
1148
static NetClientInfo net_e1000_info = {
 
1149
    .type = NET_CLIENT_TYPE_NIC,
 
1150
    .size = sizeof(NICState),
 
1151
    .can_receive = e1000_can_receive,
 
1152
    .receive = e1000_receive,
 
1153
    .cleanup = e1000_cleanup,
 
1154
    .link_status_changed = e1000_set_link_status,
 
1155
};
 
1156
 
 
1157
static int pci_e1000_init(PCIDevice *pci_dev)
 
1158
{
 
1159
    E1000State *d = DO_UPCAST(E1000State, dev, pci_dev);
 
1160
    uint8_t *pci_conf;
 
1161
    uint16_t checksum = 0;
 
1162
    int i;
 
1163
    uint8_t *macaddr;
 
1164
 
 
1165
    pci_conf = d->dev.config;
 
1166
 
 
1167
    /* TODO: we have no capabilities, so why is this bit set? */
 
1168
    pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_CAP_LIST);
 
1169
    /* TODO: RST# value should be 0, PCI spec 6.2.4 */
 
1170
    pci_conf[PCI_CACHE_LINE_SIZE] = 0x10;
 
1171
 
 
1172
    /* TODO: RST# value should be 0 if programmable, PCI spec 6.2.4 */
 
1173
    pci_conf[PCI_INTERRUPT_PIN] = 1; // interrupt pin 0
 
1174
 
 
1175
    d->mmio_index = cpu_register_io_memory(e1000_mmio_read,
 
1176
            e1000_mmio_write, d, DEVICE_LITTLE_ENDIAN);
 
1177
 
 
1178
    pci_register_bar(&d->dev, 0, PNPMMIO_SIZE,
 
1179
                           PCI_BASE_ADDRESS_SPACE_MEMORY, e1000_mmio_map);
 
1180
 
 
1181
    pci_register_bar(&d->dev, 1, IOPORT_SIZE,
 
1182
                           PCI_BASE_ADDRESS_SPACE_IO, ioport_map);
 
1183
 
 
1184
    memmove(d->eeprom_data, e1000_eeprom_template,
 
1185
        sizeof e1000_eeprom_template);
 
1186
    qemu_macaddr_default_if_unset(&d->conf.macaddr);
 
1187
    macaddr = d->conf.macaddr.a;
 
1188
    for (i = 0; i < 3; i++)
 
1189
        d->eeprom_data[i] = (macaddr[2*i+1]<<8) | macaddr[2*i];
 
1190
    for (i = 0; i < EEPROM_CHECKSUM_REG; i++)
 
1191
        checksum += d->eeprom_data[i];
 
1192
    checksum = (uint16_t) EEPROM_SUM - checksum;
 
1193
    d->eeprom_data[EEPROM_CHECKSUM_REG] = checksum;
 
1194
 
 
1195
    d->nic = qemu_new_nic(&net_e1000_info, &d->conf,
 
1196
                          d->dev.qdev.info->name, d->dev.qdev.id, d);
 
1197
 
 
1198
    qemu_format_nic_info_str(&d->nic->nc, macaddr);
 
1199
 
 
1200
    add_boot_device_path(d->conf.bootindex, &pci_dev->qdev, "/ethernet-phy@0");
 
1201
 
 
1202
    return 0;
 
1203
}
 
1204
 
 
1205
static void qdev_e1000_reset(DeviceState *dev)
 
1206
{
 
1207
    E1000State *d = DO_UPCAST(E1000State, dev.qdev, dev);
 
1208
    e1000_reset(d);
 
1209
}
 
1210
 
 
1211
static PCIDeviceInfo e1000_info = {
 
1212
    .qdev.name  = "e1000",
 
1213
    .qdev.desc  = "Intel Gigabit Ethernet",
 
1214
    .qdev.size  = sizeof(E1000State),
 
1215
    .qdev.reset = qdev_e1000_reset,
 
1216
    .qdev.vmsd  = &vmstate_e1000,
 
1217
    .init       = pci_e1000_init,
 
1218
    .exit       = pci_e1000_uninit,
 
1219
    .romfile    = "pxe-e1000.rom",
 
1220
    .vendor_id  = PCI_VENDOR_ID_INTEL,
 
1221
    .device_id  = E1000_DEVID,
 
1222
    .revision   = 0x03,
 
1223
    .class_id   = PCI_CLASS_NETWORK_ETHERNET,
 
1224
    .qdev.props = (Property[]) {
 
1225
        DEFINE_NIC_PROPERTIES(E1000State, conf),
 
1226
        DEFINE_PROP_END_OF_LIST(),
 
1227
    }
 
1228
};
 
1229
 
 
1230
static void e1000_register_devices(void)
 
1231
{
 
1232
    pci_qdev_register(&e1000_info);
 
1233
}
 
1234
 
 
1235
device_init(e1000_register_devices)