2 * Core code for QEMU e1000e emulation
4 * Software developer's manuals:
5 * http://www.intel.com/content/dam/doc/datasheet/82574l-gbe-controller-datasheet.pdf
7 * Copyright (c) 2015 Ravello Systems LTD (http://ravellosystems.com)
8 * Developed by Daynix Computing LTD (http://www.daynix.com)
11 * Dmitry Fleytman <dmitry@daynix.com>
12 * Leonid Bloch <leonid@daynix.com>
13 * Yan Vugenfirer <yan@daynix.com>
15 * Based on work done by:
16 * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc.
17 * Copyright (c) 2008 Qumranet
18 * Based on work done by:
19 * Copyright (c) 2007 Dan Aloni
20 * Copyright (c) 2004 Antony T Curtis
22 * This library is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU Lesser General Public
24 * License as published by the Free Software Foundation; either
25 * version 2.1 of the License, or (at your option) any later version.
27 * This library is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
30 * Lesser General Public License for more details.
32 * You should have received a copy of the GNU Lesser General Public
33 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
36 #include "qemu/osdep.h"
40 #include "hw/net/mii.h"
41 #include "hw/pci/msi.h"
42 #include "hw/pci/msix.h"
43 #include "sysemu/runstate.h"
45 #include "net_tx_pkt.h"
46 #include "net_rx_pkt.h"
48 #include "e1000_common.h"
49 #include "e1000x_common.h"
50 #include "e1000e_core.h"
54 /* No more then 7813 interrupts per second according to spec 10.2.4.2 */
55 #define E1000E_MIN_XITR (500)
57 #define E1000E_MAX_TX_FRAGS (64)
59 union e1000_rx_desc_union
{
60 struct e1000_rx_desc legacy
;
61 union e1000_rx_desc_extended extended
;
62 union e1000_rx_desc_packet_split packet_split
;
66 e1000e_receive_internal(E1000ECore
*core
, const struct iovec
*iov
, int iovcnt
,
70 e1000e_set_interrupt_cause(E1000ECore
*core
, uint32_t val
);
72 static void e1000e_reset(E1000ECore
*core
, bool sw
);
75 e1000e_process_ts_option(E1000ECore
*core
, struct e1000_tx_desc
*dp
)
77 if (le32_to_cpu(dp
->upper
.data
) & E1000_TXD_EXTCMD_TSTAMP
) {
78 trace_e1000e_wrn_no_ts_support();
83 e1000e_process_snap_option(E1000ECore
*core
, uint32_t cmd_and_length
)
85 if (cmd_and_length
& E1000_TXD_CMD_SNAP
) {
86 trace_e1000e_wrn_no_snap_support();
91 e1000e_raise_legacy_irq(E1000ECore
*core
)
93 trace_e1000e_irq_legacy_notify(true);
94 e1000x_inc_reg_if_not_full(core
->mac
, IAC
);
95 pci_set_irq(core
->owner
, 1);
99 e1000e_lower_legacy_irq(E1000ECore
*core
)
101 trace_e1000e_irq_legacy_notify(false);
102 pci_set_irq(core
->owner
, 0);
106 e1000e_intrmgr_rearm_timer(E1000IntrDelayTimer
*timer
)
108 int64_t delay_ns
= (int64_t) timer
->core
->mac
[timer
->delay_reg
] *
109 timer
->delay_resolution_ns
;
111 trace_e1000e_irq_rearm_timer(timer
->delay_reg
<< 2, delay_ns
);
113 timer_mod(timer
->timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + delay_ns
);
115 timer
->running
= true;
119 e1000e_intmgr_timer_resume(E1000IntrDelayTimer
*timer
)
121 if (timer
->running
) {
122 e1000e_intrmgr_rearm_timer(timer
);
127 e1000e_intmgr_timer_pause(E1000IntrDelayTimer
*timer
)
129 if (timer
->running
) {
130 timer_del(timer
->timer
);
135 e1000e_intrmgr_stop_timer(E1000IntrDelayTimer
*timer
)
137 if (timer
->running
) {
138 timer_del(timer
->timer
);
139 timer
->running
= false;
144 e1000e_intrmgr_fire_delayed_interrupts(E1000ECore
*core
)
146 trace_e1000e_irq_fire_delayed_interrupts();
147 e1000e_set_interrupt_cause(core
, 0);
151 e1000e_intrmgr_on_timer(void *opaque
)
153 E1000IntrDelayTimer
*timer
= opaque
;
155 trace_e1000e_irq_throttling_timer(timer
->delay_reg
<< 2);
157 timer
->running
= false;
158 e1000e_intrmgr_fire_delayed_interrupts(timer
->core
);
162 e1000e_intrmgr_on_throttling_timer(void *opaque
)
164 E1000IntrDelayTimer
*timer
= opaque
;
166 timer
->running
= false;
168 if (msi_enabled(timer
->core
->owner
)) {
169 trace_e1000e_irq_msi_notify_postponed();
170 /* Clear msi_causes_pending to fire MSI eventually */
171 timer
->core
->msi_causes_pending
= 0;
172 e1000e_set_interrupt_cause(timer
->core
, 0);
174 trace_e1000e_irq_legacy_notify_postponed();
175 e1000e_set_interrupt_cause(timer
->core
, 0);
180 e1000e_intrmgr_on_msix_throttling_timer(void *opaque
)
182 E1000IntrDelayTimer
*timer
= opaque
;
183 int idx
= timer
- &timer
->core
->eitr
[0];
185 timer
->running
= false;
187 trace_e1000e_irq_msix_notify_postponed_vec(idx
);
188 msix_notify(timer
->core
->owner
, idx
);
192 e1000e_intrmgr_initialize_all_timers(E1000ECore
*core
, bool create
)
196 core
->radv
.delay_reg
= RADV
;
197 core
->rdtr
.delay_reg
= RDTR
;
198 core
->raid
.delay_reg
= RAID
;
199 core
->tadv
.delay_reg
= TADV
;
200 core
->tidv
.delay_reg
= TIDV
;
202 core
->radv
.delay_resolution_ns
= E1000_INTR_DELAY_NS_RES
;
203 core
->rdtr
.delay_resolution_ns
= E1000_INTR_DELAY_NS_RES
;
204 core
->raid
.delay_resolution_ns
= E1000_INTR_DELAY_NS_RES
;
205 core
->tadv
.delay_resolution_ns
= E1000_INTR_DELAY_NS_RES
;
206 core
->tidv
.delay_resolution_ns
= E1000_INTR_DELAY_NS_RES
;
208 core
->radv
.core
= core
;
209 core
->rdtr
.core
= core
;
210 core
->raid
.core
= core
;
211 core
->tadv
.core
= core
;
212 core
->tidv
.core
= core
;
214 core
->itr
.core
= core
;
215 core
->itr
.delay_reg
= ITR
;
216 core
->itr
.delay_resolution_ns
= E1000_INTR_THROTTLING_NS_RES
;
218 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
219 core
->eitr
[i
].core
= core
;
220 core
->eitr
[i
].delay_reg
= EITR
+ i
;
221 core
->eitr
[i
].delay_resolution_ns
= E1000_INTR_THROTTLING_NS_RES
;
229 timer_new_ns(QEMU_CLOCK_VIRTUAL
, e1000e_intrmgr_on_timer
, &core
->radv
);
231 timer_new_ns(QEMU_CLOCK_VIRTUAL
, e1000e_intrmgr_on_timer
, &core
->rdtr
);
233 timer_new_ns(QEMU_CLOCK_VIRTUAL
, e1000e_intrmgr_on_timer
, &core
->raid
);
236 timer_new_ns(QEMU_CLOCK_VIRTUAL
, e1000e_intrmgr_on_timer
, &core
->tadv
);
238 timer_new_ns(QEMU_CLOCK_VIRTUAL
, e1000e_intrmgr_on_timer
, &core
->tidv
);
240 core
->itr
.timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
241 e1000e_intrmgr_on_throttling_timer
,
244 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
245 core
->eitr
[i
].timer
=
246 timer_new_ns(QEMU_CLOCK_VIRTUAL
,
247 e1000e_intrmgr_on_msix_throttling_timer
,
253 e1000e_intrmgr_stop_delay_timers(E1000ECore
*core
)
255 e1000e_intrmgr_stop_timer(&core
->radv
);
256 e1000e_intrmgr_stop_timer(&core
->rdtr
);
257 e1000e_intrmgr_stop_timer(&core
->raid
);
258 e1000e_intrmgr_stop_timer(&core
->tidv
);
259 e1000e_intrmgr_stop_timer(&core
->tadv
);
263 e1000e_intrmgr_delay_rx_causes(E1000ECore
*core
, uint32_t *causes
)
265 uint32_t delayable_causes
;
266 uint32_t rdtr
= core
->mac
[RDTR
];
267 uint32_t radv
= core
->mac
[RADV
];
268 uint32_t raid
= core
->mac
[RAID
];
270 if (msix_enabled(core
->owner
)) {
274 delayable_causes
= E1000_ICR_RXQ0
|
278 if (!(core
->mac
[RFCTL
] & E1000_RFCTL_ACK_DIS
)) {
279 delayable_causes
|= E1000_ICR_ACK
;
282 /* Clean up all causes that may be delayed */
283 core
->delayed_causes
|= *causes
& delayable_causes
;
284 *causes
&= ~delayable_causes
;
287 * Check if delayed RX interrupts disabled by client
288 * or if there are causes that cannot be delayed
290 if ((rdtr
== 0) || (*causes
!= 0)) {
295 * Check if delayed RX ACK interrupts disabled by client
296 * and there is an ACK packet received
298 if ((raid
== 0) && (core
->delayed_causes
& E1000_ICR_ACK
)) {
302 /* All causes delayed */
303 e1000e_intrmgr_rearm_timer(&core
->rdtr
);
305 if (!core
->radv
.running
&& (radv
!= 0)) {
306 e1000e_intrmgr_rearm_timer(&core
->radv
);
309 if (!core
->raid
.running
&& (core
->delayed_causes
& E1000_ICR_ACK
)) {
310 e1000e_intrmgr_rearm_timer(&core
->raid
);
317 e1000e_intrmgr_delay_tx_causes(E1000ECore
*core
, uint32_t *causes
)
319 static const uint32_t delayable_causes
= E1000_ICR_TXQ0
|
324 if (msix_enabled(core
->owner
)) {
328 /* Clean up all causes that may be delayed */
329 core
->delayed_causes
|= *causes
& delayable_causes
;
330 *causes
&= ~delayable_causes
;
332 /* If there are causes that cannot be delayed */
337 /* All causes delayed */
338 e1000e_intrmgr_rearm_timer(&core
->tidv
);
340 if (!core
->tadv
.running
&& (core
->mac
[TADV
] != 0)) {
341 e1000e_intrmgr_rearm_timer(&core
->tadv
);
348 e1000e_intmgr_collect_delayed_causes(E1000ECore
*core
)
352 if (msix_enabled(core
->owner
)) {
353 assert(core
->delayed_causes
== 0);
357 res
= core
->delayed_causes
;
358 core
->delayed_causes
= 0;
360 e1000e_intrmgr_stop_delay_timers(core
);
366 e1000e_intrmgr_fire_all_timers(E1000ECore
*core
)
369 uint32_t val
= e1000e_intmgr_collect_delayed_causes(core
);
371 trace_e1000e_irq_adding_delayed_causes(val
, core
->mac
[ICR
]);
372 core
->mac
[ICR
] |= val
;
374 if (core
->itr
.running
) {
375 timer_del(core
->itr
.timer
);
376 e1000e_intrmgr_on_throttling_timer(&core
->itr
);
379 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
380 if (core
->eitr
[i
].running
) {
381 timer_del(core
->eitr
[i
].timer
);
382 e1000e_intrmgr_on_msix_throttling_timer(&core
->eitr
[i
]);
388 e1000e_intrmgr_resume(E1000ECore
*core
)
392 e1000e_intmgr_timer_resume(&core
->radv
);
393 e1000e_intmgr_timer_resume(&core
->rdtr
);
394 e1000e_intmgr_timer_resume(&core
->raid
);
395 e1000e_intmgr_timer_resume(&core
->tidv
);
396 e1000e_intmgr_timer_resume(&core
->tadv
);
398 e1000e_intmgr_timer_resume(&core
->itr
);
400 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
401 e1000e_intmgr_timer_resume(&core
->eitr
[i
]);
406 e1000e_intrmgr_pause(E1000ECore
*core
)
410 e1000e_intmgr_timer_pause(&core
->radv
);
411 e1000e_intmgr_timer_pause(&core
->rdtr
);
412 e1000e_intmgr_timer_pause(&core
->raid
);
413 e1000e_intmgr_timer_pause(&core
->tidv
);
414 e1000e_intmgr_timer_pause(&core
->tadv
);
416 e1000e_intmgr_timer_pause(&core
->itr
);
418 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
419 e1000e_intmgr_timer_pause(&core
->eitr
[i
]);
424 e1000e_intrmgr_reset(E1000ECore
*core
)
428 core
->delayed_causes
= 0;
430 e1000e_intrmgr_stop_delay_timers(core
);
432 e1000e_intrmgr_stop_timer(&core
->itr
);
434 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
435 e1000e_intrmgr_stop_timer(&core
->eitr
[i
]);
440 e1000e_intrmgr_pci_unint(E1000ECore
*core
)
444 timer_free(core
->radv
.timer
);
445 timer_free(core
->rdtr
.timer
);
446 timer_free(core
->raid
.timer
);
448 timer_free(core
->tadv
.timer
);
449 timer_free(core
->tidv
.timer
);
451 timer_free(core
->itr
.timer
);
453 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
454 timer_free(core
->eitr
[i
].timer
);
459 e1000e_intrmgr_pci_realize(E1000ECore
*core
)
461 e1000e_intrmgr_initialize_all_timers(core
, true);
465 e1000e_rx_csum_enabled(E1000ECore
*core
)
467 return (core
->mac
[RXCSUM
] & E1000_RXCSUM_PCSD
) ? false : true;
471 e1000e_rx_use_legacy_descriptor(E1000ECore
*core
)
473 return (core
->mac
[RFCTL
] & E1000_RFCTL_EXTEN
) ? false : true;
477 e1000e_rx_use_ps_descriptor(E1000ECore
*core
)
479 return !e1000e_rx_use_legacy_descriptor(core
) &&
480 (core
->mac
[RCTL
] & E1000_RCTL_DTYP_PS
);
484 e1000e_rss_enabled(E1000ECore
*core
)
486 return E1000_MRQC_ENABLED(core
->mac
[MRQC
]) &&
487 !e1000e_rx_csum_enabled(core
) &&
488 !e1000e_rx_use_legacy_descriptor(core
);
491 typedef struct E1000E_RSSInfo_st
{
499 e1000e_rss_get_hash_type(E1000ECore
*core
, struct NetRxPkt
*pkt
)
502 EthL4HdrProto l4hdr_proto
;
504 assert(e1000e_rss_enabled(core
));
506 net_rx_pkt_get_protocols(pkt
, &hasip4
, &hasip6
, &l4hdr_proto
);
509 trace_e1000e_rx_rss_ip4(l4hdr_proto
, core
->mac
[MRQC
],
510 E1000_MRQC_EN_TCPIPV4(core
->mac
[MRQC
]),
511 E1000_MRQC_EN_IPV4(core
->mac
[MRQC
]));
513 if (l4hdr_proto
== ETH_L4_HDR_PROTO_TCP
&&
514 E1000_MRQC_EN_TCPIPV4(core
->mac
[MRQC
])) {
515 return E1000_MRQ_RSS_TYPE_IPV4TCP
;
518 if (E1000_MRQC_EN_IPV4(core
->mac
[MRQC
])) {
519 return E1000_MRQ_RSS_TYPE_IPV4
;
522 eth_ip6_hdr_info
*ip6info
= net_rx_pkt_get_ip6_info(pkt
);
524 bool ex_dis
= core
->mac
[RFCTL
] & E1000_RFCTL_IPV6_EX_DIS
;
525 bool new_ex_dis
= core
->mac
[RFCTL
] & E1000_RFCTL_NEW_IPV6_EXT_DIS
;
528 * Following two traces must not be combined because resulting
529 * event will have 11 arguments totally and some trace backends
530 * (at least "ust") have limitation of maximum 10 arguments per
531 * event. Events with more arguments fail to compile for
532 * backends like these.
534 trace_e1000e_rx_rss_ip6_rfctl(core
->mac
[RFCTL
]);
535 trace_e1000e_rx_rss_ip6(ex_dis
, new_ex_dis
, l4hdr_proto
,
536 ip6info
->has_ext_hdrs
,
537 ip6info
->rss_ex_dst_valid
,
538 ip6info
->rss_ex_src_valid
,
540 E1000_MRQC_EN_TCPIPV6(core
->mac
[MRQC
]),
541 E1000_MRQC_EN_IPV6EX(core
->mac
[MRQC
]),
542 E1000_MRQC_EN_IPV6(core
->mac
[MRQC
]));
544 if ((!ex_dis
|| !ip6info
->has_ext_hdrs
) &&
545 (!new_ex_dis
|| !(ip6info
->rss_ex_dst_valid
||
546 ip6info
->rss_ex_src_valid
))) {
548 if (l4hdr_proto
== ETH_L4_HDR_PROTO_TCP
&&
549 E1000_MRQC_EN_TCPIPV6(core
->mac
[MRQC
])) {
550 return E1000_MRQ_RSS_TYPE_IPV6TCP
;
553 if (E1000_MRQC_EN_IPV6EX(core
->mac
[MRQC
])) {
554 return E1000_MRQ_RSS_TYPE_IPV6EX
;
559 if (E1000_MRQC_EN_IPV6(core
->mac
[MRQC
])) {
560 return E1000_MRQ_RSS_TYPE_IPV6
;
565 return E1000_MRQ_RSS_TYPE_NONE
;
569 e1000e_rss_calc_hash(E1000ECore
*core
,
570 struct NetRxPkt
*pkt
,
571 E1000E_RSSInfo
*info
)
573 NetRxPktRssType type
;
575 assert(e1000e_rss_enabled(core
));
577 switch (info
->type
) {
578 case E1000_MRQ_RSS_TYPE_IPV4
:
579 type
= NetPktRssIpV4
;
581 case E1000_MRQ_RSS_TYPE_IPV4TCP
:
582 type
= NetPktRssIpV4Tcp
;
584 case E1000_MRQ_RSS_TYPE_IPV6TCP
:
585 type
= NetPktRssIpV6TcpEx
;
587 case E1000_MRQ_RSS_TYPE_IPV6
:
588 type
= NetPktRssIpV6
;
590 case E1000_MRQ_RSS_TYPE_IPV6EX
:
591 type
= NetPktRssIpV6Ex
;
598 return net_rx_pkt_calc_rss_hash(pkt
, type
, (uint8_t *) &core
->mac
[RSSRK
]);
602 e1000e_rss_parse_packet(E1000ECore
*core
,
603 struct NetRxPkt
*pkt
,
604 E1000E_RSSInfo
*info
)
606 trace_e1000e_rx_rss_started();
608 if (!e1000e_rss_enabled(core
)) {
609 info
->enabled
= false;
613 trace_e1000e_rx_rss_disabled();
617 info
->enabled
= true;
619 info
->type
= e1000e_rss_get_hash_type(core
, pkt
);
621 trace_e1000e_rx_rss_type(info
->type
);
623 if (info
->type
== E1000_MRQ_RSS_TYPE_NONE
) {
629 info
->hash
= e1000e_rss_calc_hash(core
, pkt
, info
);
630 info
->queue
= E1000_RSS_QUEUE(&core
->mac
[RETA
], info
->hash
);
634 e1000e_setup_tx_offloads(E1000ECore
*core
, struct e1000e_tx
*tx
)
636 if (tx
->props
.tse
&& tx
->cptse
) {
637 if (!net_tx_pkt_build_vheader(tx
->tx_pkt
, true, true, tx
->props
.mss
)) {
641 net_tx_pkt_update_ip_checksums(tx
->tx_pkt
);
642 e1000x_inc_reg_if_not_full(core
->mac
, TSCTC
);
646 if (tx
->sum_needed
& E1000_TXD_POPTS_TXSM
) {
647 if (!net_tx_pkt_build_vheader(tx
->tx_pkt
, false, true, 0)) {
652 if (tx
->sum_needed
& E1000_TXD_POPTS_IXSM
) {
653 net_tx_pkt_update_ip_hdr_checksum(tx
->tx_pkt
);
659 static void e1000e_tx_pkt_callback(void *core
,
660 const struct iovec
*iov
,
662 const struct iovec
*virt_iov
,
665 e1000e_receive_internal(core
, virt_iov
, virt_iovcnt
, true);
669 e1000e_tx_pkt_send(E1000ECore
*core
, struct e1000e_tx
*tx
, int queue_index
)
671 int target_queue
= MIN(core
->max_queue_num
, queue_index
);
672 NetClientState
*queue
= qemu_get_subqueue(core
->owner_nic
, target_queue
);
674 if (!e1000e_setup_tx_offloads(core
, tx
)) {
678 net_tx_pkt_dump(tx
->tx_pkt
);
680 if ((core
->phy
[0][MII_BMCR
] & MII_BMCR_LOOPBACK
) ||
681 ((core
->mac
[RCTL
] & E1000_RCTL_LBM_MAC
) == E1000_RCTL_LBM_MAC
)) {
682 return net_tx_pkt_send_custom(tx
->tx_pkt
, false,
683 e1000e_tx_pkt_callback
, core
);
685 return net_tx_pkt_send(tx
->tx_pkt
, queue
);
690 e1000e_on_tx_done_update_stats(E1000ECore
*core
, struct NetTxPkt
*tx_pkt
)
692 static const int PTCregs
[6] = { PTC64
, PTC127
, PTC255
, PTC511
,
695 size_t tot_len
= net_tx_pkt_get_total_len(tx_pkt
) + 4;
697 e1000x_increase_size_stats(core
->mac
, PTCregs
, tot_len
);
698 e1000x_inc_reg_if_not_full(core
->mac
, TPT
);
699 e1000x_grow_8reg_if_not_full(core
->mac
, TOTL
, tot_len
);
701 switch (net_tx_pkt_get_packet_type(tx_pkt
)) {
703 e1000x_inc_reg_if_not_full(core
->mac
, BPTC
);
706 e1000x_inc_reg_if_not_full(core
->mac
, MPTC
);
711 g_assert_not_reached();
714 core
->mac
[GPTC
] = core
->mac
[TPT
];
715 core
->mac
[GOTCL
] = core
->mac
[TOTL
];
716 core
->mac
[GOTCH
] = core
->mac
[TOTH
];
720 e1000e_process_tx_desc(E1000ECore
*core
,
721 struct e1000e_tx
*tx
,
722 struct e1000_tx_desc
*dp
,
725 uint32_t txd_lower
= le32_to_cpu(dp
->lower
.data
);
726 uint32_t dtype
= txd_lower
& (E1000_TXD_CMD_DEXT
| E1000_TXD_DTYP_D
);
727 unsigned int split_size
= txd_lower
& 0xffff;
729 struct e1000_context_desc
*xp
= (struct e1000_context_desc
*)dp
;
730 bool eop
= txd_lower
& E1000_TXD_CMD_EOP
;
732 if (dtype
== E1000_TXD_CMD_DEXT
) { /* context descriptor */
733 e1000x_read_tx_ctx_descr(xp
, &tx
->props
);
734 e1000e_process_snap_option(core
, le32_to_cpu(xp
->cmd_and_length
));
736 } else if (dtype
== (E1000_TXD_CMD_DEXT
| E1000_TXD_DTYP_D
)) {
737 /* data descriptor */
738 tx
->sum_needed
= le32_to_cpu(dp
->upper
.data
) >> 8;
739 tx
->cptse
= (txd_lower
& E1000_TXD_CMD_TSE
) ? 1 : 0;
740 e1000e_process_ts_option(core
, dp
);
742 /* legacy descriptor */
743 e1000e_process_ts_option(core
, dp
);
747 addr
= le64_to_cpu(dp
->buffer_addr
);
750 if (!net_tx_pkt_add_raw_fragment(tx
->tx_pkt
, addr
, split_size
)) {
756 if (!tx
->skip_cp
&& net_tx_pkt_parse(tx
->tx_pkt
)) {
757 if (e1000x_vlan_enabled(core
->mac
) &&
758 e1000x_is_vlan_txd(txd_lower
)) {
759 net_tx_pkt_setup_vlan_header_ex(tx
->tx_pkt
,
760 le16_to_cpu(dp
->upper
.fields
.special
), core
->mac
[VET
]);
762 if (e1000e_tx_pkt_send(core
, tx
, queue_index
)) {
763 e1000e_on_tx_done_update_stats(core
, tx
->tx_pkt
);
768 net_tx_pkt_reset(tx
->tx_pkt
, core
->owner
);
775 static inline uint32_t
776 e1000e_tx_wb_interrupt_cause(E1000ECore
*core
, int queue_idx
)
778 if (!msix_enabled(core
->owner
)) {
779 return E1000_ICR_TXDW
;
782 return (queue_idx
== 0) ? E1000_ICR_TXQ0
: E1000_ICR_TXQ1
;
785 static inline uint32_t
786 e1000e_rx_wb_interrupt_cause(E1000ECore
*core
, int queue_idx
,
787 bool min_threshold_hit
)
789 if (!msix_enabled(core
->owner
)) {
790 return E1000_ICS_RXT0
| (min_threshold_hit
? E1000_ICS_RXDMT0
: 0);
793 return (queue_idx
== 0) ? E1000_ICR_RXQ0
: E1000_ICR_RXQ1
;
797 e1000e_txdesc_writeback(E1000ECore
*core
, dma_addr_t base
,
798 struct e1000_tx_desc
*dp
, bool *ide
, int queue_idx
)
800 uint32_t txd_upper
, txd_lower
= le32_to_cpu(dp
->lower
.data
);
802 if (!(txd_lower
& E1000_TXD_CMD_RS
) &&
803 !(core
->mac
[IVAR
] & E1000_IVAR_TX_INT_EVERY_WB
)) {
807 *ide
= (txd_lower
& E1000_TXD_CMD_IDE
) ? true : false;
809 txd_upper
= le32_to_cpu(dp
->upper
.data
) | E1000_TXD_STAT_DD
;
811 dp
->upper
.data
= cpu_to_le32(txd_upper
);
812 pci_dma_write(core
->owner
, base
+ ((char *)&dp
->upper
- (char *)dp
),
813 &dp
->upper
, sizeof(dp
->upper
));
814 return e1000e_tx_wb_interrupt_cause(core
, queue_idx
);
817 typedef struct E1000E_RingInfo_st
{
827 e1000e_ring_empty(E1000ECore
*core
, const E1000E_RingInfo
*r
)
829 return core
->mac
[r
->dh
] == core
->mac
[r
->dt
] ||
830 core
->mac
[r
->dt
] >= core
->mac
[r
->dlen
] / E1000_RING_DESC_LEN
;
833 static inline uint64_t
834 e1000e_ring_base(E1000ECore
*core
, const E1000E_RingInfo
*r
)
836 uint64_t bah
= core
->mac
[r
->dbah
];
837 uint64_t bal
= core
->mac
[r
->dbal
];
839 return (bah
<< 32) + bal
;
842 static inline uint64_t
843 e1000e_ring_head_descr(E1000ECore
*core
, const E1000E_RingInfo
*r
)
845 return e1000e_ring_base(core
, r
) + E1000_RING_DESC_LEN
* core
->mac
[r
->dh
];
849 e1000e_ring_advance(E1000ECore
*core
, const E1000E_RingInfo
*r
, uint32_t count
)
851 core
->mac
[r
->dh
] += count
;
853 if (core
->mac
[r
->dh
] * E1000_RING_DESC_LEN
>= core
->mac
[r
->dlen
]) {
854 core
->mac
[r
->dh
] = 0;
858 static inline uint32_t
859 e1000e_ring_free_descr_num(E1000ECore
*core
, const E1000E_RingInfo
*r
)
861 trace_e1000e_ring_free_space(r
->idx
, core
->mac
[r
->dlen
],
862 core
->mac
[r
->dh
], core
->mac
[r
->dt
]);
864 if (core
->mac
[r
->dh
] <= core
->mac
[r
->dt
]) {
865 return core
->mac
[r
->dt
] - core
->mac
[r
->dh
];
868 if (core
->mac
[r
->dh
] > core
->mac
[r
->dt
]) {
869 return core
->mac
[r
->dlen
] / E1000_RING_DESC_LEN
+
870 core
->mac
[r
->dt
] - core
->mac
[r
->dh
];
873 g_assert_not_reached();
878 e1000e_ring_enabled(E1000ECore
*core
, const E1000E_RingInfo
*r
)
880 return core
->mac
[r
->dlen
] > 0;
883 static inline uint32_t
884 e1000e_ring_len(E1000ECore
*core
, const E1000E_RingInfo
*r
)
886 return core
->mac
[r
->dlen
];
889 typedef struct E1000E_TxRing_st
{
890 const E1000E_RingInfo
*i
;
891 struct e1000e_tx
*tx
;
895 e1000e_mq_queue_idx(int base_reg_idx
, int reg_idx
)
897 return (reg_idx
- base_reg_idx
) / (0x100 >> 2);
901 e1000e_tx_ring_init(E1000ECore
*core
, E1000E_TxRing
*txr
, int idx
)
903 static const E1000E_RingInfo i
[E1000E_NUM_QUEUES
] = {
904 { TDBAH
, TDBAL
, TDLEN
, TDH
, TDT
, 0 },
905 { TDBAH1
, TDBAL1
, TDLEN1
, TDH1
, TDT1
, 1 }
908 assert(idx
< ARRAY_SIZE(i
));
911 txr
->tx
= &core
->tx
[idx
];
914 typedef struct E1000E_RxRing_st
{
915 const E1000E_RingInfo
*i
;
919 e1000e_rx_ring_init(E1000ECore
*core
, E1000E_RxRing
*rxr
, int idx
)
921 static const E1000E_RingInfo i
[E1000E_NUM_QUEUES
] = {
922 { RDBAH0
, RDBAL0
, RDLEN0
, RDH0
, RDT0
, 0 },
923 { RDBAH1
, RDBAL1
, RDLEN1
, RDH1
, RDT1
, 1 }
926 assert(idx
< ARRAY_SIZE(i
));
932 e1000e_start_xmit(E1000ECore
*core
, const E1000E_TxRing
*txr
)
935 struct e1000_tx_desc desc
;
937 const E1000E_RingInfo
*txi
= txr
->i
;
938 uint32_t cause
= E1000_ICS_TXQE
;
940 if (!(core
->mac
[TCTL
] & E1000_TCTL_EN
)) {
941 trace_e1000e_tx_disabled();
945 while (!e1000e_ring_empty(core
, txi
)) {
946 base
= e1000e_ring_head_descr(core
, txi
);
948 pci_dma_read(core
->owner
, base
, &desc
, sizeof(desc
));
950 trace_e1000e_tx_descr((void *)(intptr_t)desc
.buffer_addr
,
951 desc
.lower
.data
, desc
.upper
.data
);
953 e1000e_process_tx_desc(core
, txr
->tx
, &desc
, txi
->idx
);
954 cause
|= e1000e_txdesc_writeback(core
, base
, &desc
, &ide
, txi
->idx
);
956 e1000e_ring_advance(core
, txi
, 1);
959 if (!ide
|| !e1000e_intrmgr_delay_tx_causes(core
, &cause
)) {
960 e1000e_set_interrupt_cause(core
, cause
);
965 e1000e_has_rxbufs(E1000ECore
*core
, const E1000E_RingInfo
*r
,
968 uint32_t bufs
= e1000e_ring_free_descr_num(core
, r
);
970 trace_e1000e_rx_has_buffers(r
->idx
, bufs
, total_size
,
971 core
->rx_desc_buf_size
);
973 return total_size
<= bufs
/ (core
->rx_desc_len
/ E1000_MIN_RX_DESC_LEN
) *
974 core
->rx_desc_buf_size
;
978 e1000e_start_recv(E1000ECore
*core
)
982 trace_e1000e_rx_start_recv();
984 for (i
= 0; i
<= core
->max_queue_num
; i
++) {
985 qemu_flush_queued_packets(qemu_get_subqueue(core
->owner_nic
, i
));
990 e1000e_can_receive(E1000ECore
*core
)
994 if (!e1000x_rx_ready(core
->owner
, core
->mac
)) {
998 for (i
= 0; i
< E1000E_NUM_QUEUES
; i
++) {
1001 e1000e_rx_ring_init(core
, &rxr
, i
);
1002 if (e1000e_ring_enabled(core
, rxr
.i
) &&
1003 e1000e_has_rxbufs(core
, rxr
.i
, 1)) {
1004 trace_e1000e_rx_can_recv();
1009 trace_e1000e_rx_can_recv_rings_full();
1014 e1000e_receive(E1000ECore
*core
, const uint8_t *buf
, size_t size
)
1016 const struct iovec iov
= {
1017 .iov_base
= (uint8_t *)buf
,
1021 return e1000e_receive_iov(core
, &iov
, 1);
1025 e1000e_rx_l3_cso_enabled(E1000ECore
*core
)
1027 return !!(core
->mac
[RXCSUM
] & E1000_RXCSUM_IPOFLD
);
1031 e1000e_rx_l4_cso_enabled(E1000ECore
*core
)
1033 return !!(core
->mac
[RXCSUM
] & E1000_RXCSUM_TUOFLD
);
1037 e1000e_receive_filter(E1000ECore
*core
, const uint8_t *buf
, int size
)
1039 uint32_t rctl
= core
->mac
[RCTL
];
1041 if (e1000x_is_vlan_packet(buf
, core
->mac
[VET
]) &&
1042 e1000x_vlan_rx_filter_enabled(core
->mac
)) {
1043 uint16_t vid
= lduw_be_p(&PKT_GET_VLAN_HDR(buf
)->h_tci
);
1045 ldl_le_p((uint32_t *)(core
->mac
+ VFTA
) +
1046 ((vid
>> E1000_VFTA_ENTRY_SHIFT
) & E1000_VFTA_ENTRY_MASK
));
1047 if ((vfta
& (1 << (vid
& E1000_VFTA_ENTRY_BIT_SHIFT_MASK
))) == 0) {
1048 trace_e1000e_rx_flt_vlan_mismatch(vid
);
1051 trace_e1000e_rx_flt_vlan_match(vid
);
1055 switch (net_rx_pkt_get_packet_type(core
->rx_pkt
)) {
1057 if (rctl
& E1000_RCTL_UPE
) {
1058 return true; /* promiscuous ucast */
1063 if (rctl
& E1000_RCTL_BAM
) {
1064 return true; /* broadcast enabled */
1069 if (rctl
& E1000_RCTL_MPE
) {
1070 return true; /* promiscuous mcast */
1075 g_assert_not_reached();
1078 return e1000x_rx_group_filter(core
->mac
, buf
);
1082 e1000e_read_lgcy_rx_descr(E1000ECore
*core
, struct e1000_rx_desc
*desc
,
1085 *buff_addr
= le64_to_cpu(desc
->buffer_addr
);
1089 e1000e_read_ext_rx_descr(E1000ECore
*core
, union e1000_rx_desc_extended
*desc
,
1092 *buff_addr
= le64_to_cpu(desc
->read
.buffer_addr
);
1096 e1000e_read_ps_rx_descr(E1000ECore
*core
,
1097 union e1000_rx_desc_packet_split
*desc
,
1098 hwaddr buff_addr
[MAX_PS_BUFFERS
])
1102 for (i
= 0; i
< MAX_PS_BUFFERS
; i
++) {
1103 buff_addr
[i
] = le64_to_cpu(desc
->read
.buffer_addr
[i
]);
1106 trace_e1000e_rx_desc_ps_read(buff_addr
[0], buff_addr
[1],
1107 buff_addr
[2], buff_addr
[3]);
1111 e1000e_read_rx_descr(E1000ECore
*core
, union e1000_rx_desc_union
*desc
,
1112 hwaddr buff_addr
[MAX_PS_BUFFERS
])
1114 if (e1000e_rx_use_legacy_descriptor(core
)) {
1115 e1000e_read_lgcy_rx_descr(core
, &desc
->legacy
, &buff_addr
[0]);
1116 buff_addr
[1] = buff_addr
[2] = buff_addr
[3] = 0;
1118 if (core
->mac
[RCTL
] & E1000_RCTL_DTYP_PS
) {
1119 e1000e_read_ps_rx_descr(core
, &desc
->packet_split
, buff_addr
);
1121 e1000e_read_ext_rx_descr(core
, &desc
->extended
, &buff_addr
[0]);
1122 buff_addr
[1] = buff_addr
[2] = buff_addr
[3] = 0;
1128 e1000e_verify_csum_in_sw(E1000ECore
*core
,
1129 struct NetRxPkt
*pkt
,
1130 uint32_t *status_flags
,
1131 EthL4HdrProto l4hdr_proto
)
1134 uint32_t csum_error
;
1136 if (e1000e_rx_l3_cso_enabled(core
)) {
1137 if (!net_rx_pkt_validate_l3_csum(pkt
, &csum_valid
)) {
1138 trace_e1000e_rx_metadata_l3_csum_validation_failed();
1140 csum_error
= csum_valid
? 0 : E1000_RXDEXT_STATERR_IPE
;
1141 *status_flags
|= E1000_RXD_STAT_IPCS
| csum_error
;
1144 trace_e1000e_rx_metadata_l3_cso_disabled();
1147 if (!e1000e_rx_l4_cso_enabled(core
)) {
1148 trace_e1000e_rx_metadata_l4_cso_disabled();
1152 if (!net_rx_pkt_validate_l4_csum(pkt
, &csum_valid
)) {
1153 trace_e1000e_rx_metadata_l4_csum_validation_failed();
1157 csum_error
= csum_valid
? 0 : E1000_RXDEXT_STATERR_TCPE
;
1158 *status_flags
|= E1000_RXD_STAT_TCPCS
| csum_error
;
1160 if (l4hdr_proto
== ETH_L4_HDR_PROTO_UDP
) {
1161 *status_flags
|= E1000_RXD_STAT_UDPCS
;
1166 e1000e_is_tcp_ack(E1000ECore
*core
, struct NetRxPkt
*rx_pkt
)
1168 if (!net_rx_pkt_is_tcp_ack(rx_pkt
)) {
1172 if (core
->mac
[RFCTL
] & E1000_RFCTL_ACK_DATA_DIS
) {
1173 return !net_rx_pkt_has_tcp_data(rx_pkt
);
1180 e1000e_build_rx_metadata(E1000ECore
*core
,
1181 struct NetRxPkt
*pkt
,
1183 const E1000E_RSSInfo
*rss_info
,
1184 uint32_t *rss
, uint32_t *mrq
,
1185 uint32_t *status_flags
,
1189 struct virtio_net_hdr
*vhdr
;
1190 bool hasip4
, hasip6
;
1191 EthL4HdrProto l4hdr_proto
;
1194 *status_flags
= E1000_RXD_STAT_DD
;
1196 /* No additional metadata needed for non-EOP descriptors */
1201 *status_flags
|= E1000_RXD_STAT_EOP
;
1203 net_rx_pkt_get_protocols(pkt
, &hasip4
, &hasip6
, &l4hdr_proto
);
1204 trace_e1000e_rx_metadata_protocols(hasip4
, hasip6
, l4hdr_proto
);
1207 if (net_rx_pkt_is_vlan_stripped(pkt
)) {
1208 *status_flags
|= E1000_RXD_STAT_VP
;
1209 *vlan_tag
= cpu_to_le16(net_rx_pkt_get_vlan_tag(pkt
));
1210 trace_e1000e_rx_metadata_vlan(*vlan_tag
);
1213 /* Packet parsing results */
1214 if ((core
->mac
[RXCSUM
] & E1000_RXCSUM_PCSD
) != 0) {
1215 if (rss_info
->enabled
) {
1216 *rss
= cpu_to_le32(rss_info
->hash
);
1217 *mrq
= cpu_to_le32(rss_info
->type
| (rss_info
->queue
<< 8));
1218 trace_e1000e_rx_metadata_rss(*rss
, *mrq
);
1220 } else if (hasip4
) {
1221 *status_flags
|= E1000_RXD_STAT_IPIDV
;
1222 *ip_id
= cpu_to_le16(net_rx_pkt_get_ip_id(pkt
));
1223 trace_e1000e_rx_metadata_ip_id(*ip_id
);
1226 if (l4hdr_proto
== ETH_L4_HDR_PROTO_TCP
&& e1000e_is_tcp_ack(core
, pkt
)) {
1227 *status_flags
|= E1000_RXD_STAT_ACK
;
1228 trace_e1000e_rx_metadata_ack();
1231 if (hasip6
&& (core
->mac
[RFCTL
] & E1000_RFCTL_IPV6_DIS
)) {
1232 trace_e1000e_rx_metadata_ipv6_filtering_disabled();
1233 pkt_type
= E1000_RXD_PKT_MAC
;
1234 } else if (l4hdr_proto
== ETH_L4_HDR_PROTO_TCP
||
1235 l4hdr_proto
== ETH_L4_HDR_PROTO_UDP
) {
1236 pkt_type
= hasip4
? E1000_RXD_PKT_IP4_XDP
: E1000_RXD_PKT_IP6_XDP
;
1237 } else if (hasip4
|| hasip6
) {
1238 pkt_type
= hasip4
? E1000_RXD_PKT_IP4
: E1000_RXD_PKT_IP6
;
1240 pkt_type
= E1000_RXD_PKT_MAC
;
1243 *status_flags
|= E1000_RXD_PKT_TYPE(pkt_type
);
1244 trace_e1000e_rx_metadata_pkt_type(pkt_type
);
1246 /* RX CSO information */
1247 if (hasip6
&& (core
->mac
[RFCTL
] & E1000_RFCTL_IPV6_XSUM_DIS
)) {
1248 trace_e1000e_rx_metadata_ipv6_sum_disabled();
1252 vhdr
= net_rx_pkt_get_vhdr(pkt
);
1254 if (!(vhdr
->flags
& VIRTIO_NET_HDR_F_DATA_VALID
) &&
1255 !(vhdr
->flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
)) {
1256 trace_e1000e_rx_metadata_virthdr_no_csum_info();
1257 e1000e_verify_csum_in_sw(core
, pkt
, status_flags
, l4hdr_proto
);
1261 if (e1000e_rx_l3_cso_enabled(core
)) {
1262 *status_flags
|= hasip4
? E1000_RXD_STAT_IPCS
: 0;
1264 trace_e1000e_rx_metadata_l3_cso_disabled();
1267 if (e1000e_rx_l4_cso_enabled(core
)) {
1268 switch (l4hdr_proto
) {
1269 case ETH_L4_HDR_PROTO_TCP
:
1270 *status_flags
|= E1000_RXD_STAT_TCPCS
;
1273 case ETH_L4_HDR_PROTO_UDP
:
1274 *status_flags
|= E1000_RXD_STAT_TCPCS
| E1000_RXD_STAT_UDPCS
;
1281 trace_e1000e_rx_metadata_l4_cso_disabled();
1284 trace_e1000e_rx_metadata_status_flags(*status_flags
);
1287 *status_flags
= cpu_to_le32(*status_flags
);
1291 e1000e_write_lgcy_rx_descr(E1000ECore
*core
, struct e1000_rx_desc
*desc
,
1292 struct NetRxPkt
*pkt
,
1293 const E1000E_RSSInfo
*rss_info
,
1296 uint32_t status_flags
, rss
, mrq
;
1299 assert(!rss_info
->enabled
);
1301 desc
->length
= cpu_to_le16(length
);
1304 e1000e_build_rx_metadata(core
, pkt
, pkt
!= NULL
,
1307 &status_flags
, &ip_id
,
1309 desc
->errors
= (uint8_t) (le32_to_cpu(status_flags
) >> 24);
1310 desc
->status
= (uint8_t) le32_to_cpu(status_flags
);
1314 e1000e_write_ext_rx_descr(E1000ECore
*core
, union e1000_rx_desc_extended
*desc
,
1315 struct NetRxPkt
*pkt
,
1316 const E1000E_RSSInfo
*rss_info
,
1319 memset(&desc
->wb
, 0, sizeof(desc
->wb
));
1321 desc
->wb
.upper
.length
= cpu_to_le16(length
);
1323 e1000e_build_rx_metadata(core
, pkt
, pkt
!= NULL
,
1325 &desc
->wb
.lower
.hi_dword
.rss
,
1326 &desc
->wb
.lower
.mrq
,
1327 &desc
->wb
.upper
.status_error
,
1328 &desc
->wb
.lower
.hi_dword
.csum_ip
.ip_id
,
1329 &desc
->wb
.upper
.vlan
);
1333 e1000e_write_ps_rx_descr(E1000ECore
*core
,
1334 union e1000_rx_desc_packet_split
*desc
,
1335 struct NetRxPkt
*pkt
,
1336 const E1000E_RSSInfo
*rss_info
,
1338 uint16_t(*written
)[MAX_PS_BUFFERS
])
1342 memset(&desc
->wb
, 0, sizeof(desc
->wb
));
1344 desc
->wb
.middle
.length0
= cpu_to_le16((*written
)[0]);
1346 for (i
= 0; i
< PS_PAGE_BUFFERS
; i
++) {
1347 desc
->wb
.upper
.length
[i
] = cpu_to_le16((*written
)[i
+ 1]);
1350 e1000e_build_rx_metadata(core
, pkt
, pkt
!= NULL
,
1352 &desc
->wb
.lower
.hi_dword
.rss
,
1353 &desc
->wb
.lower
.mrq
,
1354 &desc
->wb
.middle
.status_error
,
1355 &desc
->wb
.lower
.hi_dword
.csum_ip
.ip_id
,
1356 &desc
->wb
.middle
.vlan
);
1358 desc
->wb
.upper
.header_status
=
1359 cpu_to_le16(ps_hdr_len
| (ps_hdr_len
? E1000_RXDPS_HDRSTAT_HDRSP
: 0));
1361 trace_e1000e_rx_desc_ps_write((*written
)[0], (*written
)[1],
1362 (*written
)[2], (*written
)[3]);
1366 e1000e_write_rx_descr(E1000ECore
*core
, union e1000_rx_desc_union
*desc
,
1367 struct NetRxPkt
*pkt
, const E1000E_RSSInfo
*rss_info
,
1368 size_t ps_hdr_len
, uint16_t(*written
)[MAX_PS_BUFFERS
])
1370 if (e1000e_rx_use_legacy_descriptor(core
)) {
1371 assert(ps_hdr_len
== 0);
1372 e1000e_write_lgcy_rx_descr(core
, &desc
->legacy
, pkt
, rss_info
,
1375 if (core
->mac
[RCTL
] & E1000_RCTL_DTYP_PS
) {
1376 e1000e_write_ps_rx_descr(core
, &desc
->packet_split
, pkt
, rss_info
,
1377 ps_hdr_len
, written
);
1379 assert(ps_hdr_len
== 0);
1380 e1000e_write_ext_rx_descr(core
, &desc
->extended
, pkt
, rss_info
,
1387 e1000e_pci_dma_write_rx_desc(E1000ECore
*core
, dma_addr_t addr
,
1388 union e1000_rx_desc_union
*desc
, dma_addr_t len
)
1390 PCIDevice
*dev
= core
->owner
;
1392 if (e1000e_rx_use_legacy_descriptor(core
)) {
1393 struct e1000_rx_desc
*d
= &desc
->legacy
;
1394 size_t offset
= offsetof(struct e1000_rx_desc
, status
);
1395 uint8_t status
= d
->status
;
1397 d
->status
&= ~E1000_RXD_STAT_DD
;
1398 pci_dma_write(dev
, addr
, desc
, len
);
1400 if (status
& E1000_RXD_STAT_DD
) {
1402 pci_dma_write(dev
, addr
+ offset
, &status
, sizeof(status
));
1405 if (core
->mac
[RCTL
] & E1000_RCTL_DTYP_PS
) {
1406 union e1000_rx_desc_packet_split
*d
= &desc
->packet_split
;
1407 size_t offset
= offsetof(union e1000_rx_desc_packet_split
,
1408 wb
.middle
.status_error
);
1409 uint32_t status
= d
->wb
.middle
.status_error
;
1411 d
->wb
.middle
.status_error
&= ~E1000_RXD_STAT_DD
;
1412 pci_dma_write(dev
, addr
, desc
, len
);
1414 if (status
& E1000_RXD_STAT_DD
) {
1415 d
->wb
.middle
.status_error
= status
;
1416 pci_dma_write(dev
, addr
+ offset
, &status
, sizeof(status
));
1419 union e1000_rx_desc_extended
*d
= &desc
->extended
;
1420 size_t offset
= offsetof(union e1000_rx_desc_extended
,
1421 wb
.upper
.status_error
);
1422 uint32_t status
= d
->wb
.upper
.status_error
;
1424 d
->wb
.upper
.status_error
&= ~E1000_RXD_STAT_DD
;
1425 pci_dma_write(dev
, addr
, desc
, len
);
1427 if (status
& E1000_RXD_STAT_DD
) {
1428 d
->wb
.upper
.status_error
= status
;
1429 pci_dma_write(dev
, addr
+ offset
, &status
, sizeof(status
));
1435 typedef struct e1000e_ba_state_st
{
1436 uint16_t written
[MAX_PS_BUFFERS
];
1441 e1000e_write_hdr_to_rx_buffers(E1000ECore
*core
,
1442 hwaddr ba
[MAX_PS_BUFFERS
],
1443 e1000e_ba_state
*bastate
,
1445 dma_addr_t data_len
)
1447 assert(data_len
<= core
->rxbuf_sizes
[0] - bastate
->written
[0]);
1449 pci_dma_write(core
->owner
, ba
[0] + bastate
->written
[0], data
, data_len
);
1450 bastate
->written
[0] += data_len
;
1452 bastate
->cur_idx
= 1;
1456 e1000e_write_to_rx_buffers(E1000ECore
*core
,
1457 hwaddr ba
[MAX_PS_BUFFERS
],
1458 e1000e_ba_state
*bastate
,
1460 dma_addr_t data_len
)
1462 while (data_len
> 0) {
1463 uint32_t cur_buf_len
= core
->rxbuf_sizes
[bastate
->cur_idx
];
1464 uint32_t cur_buf_bytes_left
= cur_buf_len
-
1465 bastate
->written
[bastate
->cur_idx
];
1466 uint32_t bytes_to_write
= MIN(data_len
, cur_buf_bytes_left
);
1468 trace_e1000e_rx_desc_buff_write(bastate
->cur_idx
,
1469 ba
[bastate
->cur_idx
],
1470 bastate
->written
[bastate
->cur_idx
],
1474 pci_dma_write(core
->owner
,
1475 ba
[bastate
->cur_idx
] + bastate
->written
[bastate
->cur_idx
],
1476 data
, bytes_to_write
);
1478 bastate
->written
[bastate
->cur_idx
] += bytes_to_write
;
1479 data
+= bytes_to_write
;
1480 data_len
-= bytes_to_write
;
1482 if (bastate
->written
[bastate
->cur_idx
] == cur_buf_len
) {
1486 assert(bastate
->cur_idx
< MAX_PS_BUFFERS
);
1491 e1000e_update_rx_stats(E1000ECore
*core
,
1493 size_t data_fcs_size
)
1495 e1000x_update_rx_total_stats(core
->mac
, data_size
, data_fcs_size
);
1497 switch (net_rx_pkt_get_packet_type(core
->rx_pkt
)) {
1499 e1000x_inc_reg_if_not_full(core
->mac
, BPRC
);
1503 e1000x_inc_reg_if_not_full(core
->mac
, MPRC
);
1512 e1000e_rx_descr_threshold_hit(E1000ECore
*core
, const E1000E_RingInfo
*rxi
)
1514 return e1000e_ring_free_descr_num(core
, rxi
) ==
1515 e1000e_ring_len(core
, rxi
) >> core
->rxbuf_min_shift
;
1519 e1000e_do_ps(E1000ECore
*core
, struct NetRxPkt
*pkt
, size_t *hdr_len
)
1521 bool hasip4
, hasip6
;
1522 EthL4HdrProto l4hdr_proto
;
1525 if (!e1000e_rx_use_ps_descriptor(core
)) {
1529 net_rx_pkt_get_protocols(pkt
, &hasip4
, &hasip6
, &l4hdr_proto
);
1532 fragment
= net_rx_pkt_get_ip4_info(pkt
)->fragment
;
1533 } else if (hasip6
) {
1534 fragment
= net_rx_pkt_get_ip6_info(pkt
)->fragment
;
1539 if (fragment
&& (core
->mac
[RFCTL
] & E1000_RFCTL_IPFRSP_DIS
)) {
1543 if (l4hdr_proto
== ETH_L4_HDR_PROTO_TCP
||
1544 l4hdr_proto
== ETH_L4_HDR_PROTO_UDP
) {
1545 *hdr_len
= net_rx_pkt_get_l5_hdr_offset(pkt
);
1547 *hdr_len
= net_rx_pkt_get_l4_hdr_offset(pkt
);
1550 if ((*hdr_len
> core
->rxbuf_sizes
[0]) ||
1551 (*hdr_len
> net_rx_pkt_get_total_len(pkt
))) {
1559 e1000e_write_packet_to_guest(E1000ECore
*core
, struct NetRxPkt
*pkt
,
1560 const E1000E_RxRing
*rxr
,
1561 const E1000E_RSSInfo
*rss_info
)
1563 PCIDevice
*d
= core
->owner
;
1565 union e1000_rx_desc_union desc
;
1567 size_t desc_offset
= 0;
1570 struct iovec
*iov
= net_rx_pkt_get_iovec(pkt
);
1571 size_t size
= net_rx_pkt_get_total_len(pkt
);
1572 size_t total_size
= size
+ e1000x_fcs_len(core
->mac
);
1573 const E1000E_RingInfo
*rxi
;
1574 size_t ps_hdr_len
= 0;
1575 bool do_ps
= e1000e_do_ps(core
, pkt
, &ps_hdr_len
);
1576 bool is_first
= true;
1581 hwaddr ba
[MAX_PS_BUFFERS
];
1582 e1000e_ba_state bastate
= { { 0 } };
1583 bool is_last
= false;
1585 desc_size
= total_size
- desc_offset
;
1587 if (desc_size
> core
->rx_desc_buf_size
) {
1588 desc_size
= core
->rx_desc_buf_size
;
1591 if (e1000e_ring_empty(core
, rxi
)) {
1595 base
= e1000e_ring_head_descr(core
, rxi
);
1597 pci_dma_read(d
, base
, &desc
, core
->rx_desc_len
);
1599 trace_e1000e_rx_descr(rxi
->idx
, base
, core
->rx_desc_len
);
1601 e1000e_read_rx_descr(core
, &desc
, ba
);
1604 if (desc_offset
< size
) {
1605 static const uint32_t fcs_pad
;
1607 size_t copy_size
= size
- desc_offset
;
1608 if (copy_size
> core
->rx_desc_buf_size
) {
1609 copy_size
= core
->rx_desc_buf_size
;
1612 /* For PS mode copy the packet header first */
1615 size_t ps_hdr_copied
= 0;
1617 iov_copy
= MIN(ps_hdr_len
- ps_hdr_copied
,
1618 iov
->iov_len
- iov_ofs
);
1620 e1000e_write_hdr_to_rx_buffers(core
, ba
, &bastate
,
1621 iov
->iov_base
, iov_copy
);
1623 copy_size
-= iov_copy
;
1624 ps_hdr_copied
+= iov_copy
;
1626 iov_ofs
+= iov_copy
;
1627 if (iov_ofs
== iov
->iov_len
) {
1631 } while (ps_hdr_copied
< ps_hdr_len
);
1635 /* Leave buffer 0 of each descriptor except first */
1636 /* empty as per spec 7.1.5.1 */
1637 e1000e_write_hdr_to_rx_buffers(core
, ba
, &bastate
,
1642 /* Copy packet payload */
1644 iov_copy
= MIN(copy_size
, iov
->iov_len
- iov_ofs
);
1646 e1000e_write_to_rx_buffers(core
, ba
, &bastate
,
1647 iov
->iov_base
+ iov_ofs
, iov_copy
);
1649 copy_size
-= iov_copy
;
1650 iov_ofs
+= iov_copy
;
1651 if (iov_ofs
== iov
->iov_len
) {
1657 if (desc_offset
+ desc_size
>= total_size
) {
1658 /* Simulate FCS checksum presence in the last descriptor */
1659 e1000e_write_to_rx_buffers(core
, ba
, &bastate
,
1660 (const char *) &fcs_pad
, e1000x_fcs_len(core
->mac
));
1663 } else { /* as per intel docs; skip descriptors with null buf addr */
1664 trace_e1000e_rx_null_descriptor();
1666 desc_offset
+= desc_size
;
1667 if (desc_offset
>= total_size
) {
1671 e1000e_write_rx_descr(core
, &desc
, is_last
? core
->rx_pkt
: NULL
,
1672 rss_info
, do_ps
? ps_hdr_len
: 0, &bastate
.written
);
1673 e1000e_pci_dma_write_rx_desc(core
, base
, &desc
, core
->rx_desc_len
);
1675 e1000e_ring_advance(core
, rxi
,
1676 core
->rx_desc_len
/ E1000_MIN_RX_DESC_LEN
);
1678 } while (desc_offset
< total_size
);
1680 e1000e_update_rx_stats(core
, size
, total_size
);
1684 e1000e_rx_fix_l4_csum(E1000ECore
*core
, struct NetRxPkt
*pkt
)
1686 struct virtio_net_hdr
*vhdr
= net_rx_pkt_get_vhdr(pkt
);
1688 if (vhdr
->flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) {
1689 net_rx_pkt_fix_l4_csum(pkt
);
1694 e1000e_receive_iov(E1000ECore
*core
, const struct iovec
*iov
, int iovcnt
)
1696 return e1000e_receive_internal(core
, iov
, iovcnt
, core
->has_vnet
);
1700 e1000e_receive_internal(E1000ECore
*core
, const struct iovec
*iov
, int iovcnt
,
1703 static const int maximum_ethernet_hdr_len
= (ETH_HLEN
+ 4);
1706 uint8_t min_buf
[ETH_ZLEN
];
1707 struct iovec min_iov
;
1708 uint8_t *filter_buf
;
1709 size_t size
, orig_size
;
1712 E1000E_RSSInfo rss_info
;
1717 trace_e1000e_rx_receive_iov(iovcnt
);
1719 if (!e1000x_hw_rx_enabled(core
->mac
)) {
1723 /* Pull virtio header in */
1725 net_rx_pkt_set_vhdr_iovec(core
->rx_pkt
, iov
, iovcnt
);
1726 iov_ofs
= sizeof(struct virtio_net_hdr
);
1728 net_rx_pkt_unset_vhdr(core
->rx_pkt
);
1731 filter_buf
= iov
->iov_base
+ iov_ofs
;
1732 orig_size
= iov_size(iov
, iovcnt
);
1733 size
= orig_size
- iov_ofs
;
1735 /* Pad to minimum Ethernet frame length */
1736 if (size
< sizeof(min_buf
)) {
1737 iov_to_buf(iov
, iovcnt
, iov_ofs
, min_buf
, size
);
1738 memset(&min_buf
[size
], 0, sizeof(min_buf
) - size
);
1739 e1000x_inc_reg_if_not_full(core
->mac
, RUC
);
1740 min_iov
.iov_base
= filter_buf
= min_buf
;
1741 min_iov
.iov_len
= size
= sizeof(min_buf
);
1745 } else if (iov
->iov_len
< maximum_ethernet_hdr_len
) {
1746 /* This is very unlikely, but may happen. */
1747 iov_to_buf(iov
, iovcnt
, iov_ofs
, min_buf
, maximum_ethernet_hdr_len
);
1748 filter_buf
= min_buf
;
1751 /* Discard oversized packets if !LPE and !SBP. */
1752 if (e1000x_is_oversized(core
->mac
, size
)) {
1756 net_rx_pkt_set_packet_type(core
->rx_pkt
,
1757 get_eth_packet_type(PKT_GET_ETH_HDR(filter_buf
)));
1759 if (!e1000e_receive_filter(core
, filter_buf
, size
)) {
1760 trace_e1000e_rx_flt_dropped();
1764 net_rx_pkt_attach_iovec_ex(core
->rx_pkt
, iov
, iovcnt
, iov_ofs
,
1765 e1000x_vlan_enabled(core
->mac
), core
->mac
[VET
]);
1767 e1000e_rss_parse_packet(core
, core
->rx_pkt
, &rss_info
);
1768 e1000e_rx_ring_init(core
, &rxr
, rss_info
.queue
);
1770 total_size
= net_rx_pkt_get_total_len(core
->rx_pkt
) +
1771 e1000x_fcs_len(core
->mac
);
1773 if (e1000e_has_rxbufs(core
, rxr
.i
, total_size
)) {
1774 e1000e_rx_fix_l4_csum(core
, core
->rx_pkt
);
1776 e1000e_write_packet_to_guest(core
, core
->rx_pkt
, &rxr
, &rss_info
);
1780 /* Perform small receive detection (RSRPD) */
1781 if (total_size
< core
->mac
[RSRPD
]) {
1782 n
|= E1000_ICS_SRPD
;
1785 /* Perform ACK receive detection */
1786 if (!(core
->mac
[RFCTL
] & E1000_RFCTL_ACK_DIS
) &&
1787 (e1000e_is_tcp_ack(core
, core
->rx_pkt
))) {
1791 /* Check if receive descriptor minimum threshold hit */
1792 rdmts_hit
= e1000e_rx_descr_threshold_hit(core
, rxr
.i
);
1793 n
|= e1000e_rx_wb_interrupt_cause(core
, rxr
.i
->idx
, rdmts_hit
);
1795 trace_e1000e_rx_written_to_guest(rxr
.i
->idx
);
1800 trace_e1000e_rx_not_written_to_guest(rxr
.i
->idx
);
1803 if (!e1000e_intrmgr_delay_rx_causes(core
, &n
)) {
1804 trace_e1000e_rx_interrupt_set(n
);
1805 e1000e_set_interrupt_cause(core
, n
);
1807 trace_e1000e_rx_interrupt_delayed(n
);
1814 e1000e_have_autoneg(E1000ECore
*core
)
1816 return core
->phy
[0][MII_BMCR
] & MII_BMCR_AUTOEN
;
1819 static void e1000e_update_flowctl_status(E1000ECore
*core
)
1821 if (e1000e_have_autoneg(core
) &&
1822 core
->phy
[0][MII_BMSR
] & MII_BMSR_AN_COMP
) {
1823 trace_e1000e_link_autoneg_flowctl(true);
1824 core
->mac
[CTRL
] |= E1000_CTRL_TFCE
| E1000_CTRL_RFCE
;
1826 trace_e1000e_link_autoneg_flowctl(false);
1831 e1000e_link_down(E1000ECore
*core
)
1833 e1000x_update_regs_on_link_down(core
->mac
, core
->phy
[0]);
1834 e1000e_update_flowctl_status(core
);
1838 e1000e_set_phy_ctrl(E1000ECore
*core
, int index
, uint16_t val
)
1840 /* bits 0-5 reserved; MII_BMCR_[ANRESTART,RESET] are self clearing */
1841 core
->phy
[0][MII_BMCR
] = val
& ~(0x3f |
1843 MII_BMCR_ANRESTART
);
1845 if ((val
& MII_BMCR_ANRESTART
) &&
1846 e1000e_have_autoneg(core
)) {
1847 e1000x_restart_autoneg(core
->mac
, core
->phy
[0], core
->autoneg_timer
);
1852 e1000e_set_phy_oem_bits(E1000ECore
*core
, int index
, uint16_t val
)
1854 core
->phy
[0][PHY_OEM_BITS
] = val
& ~BIT(10);
1856 if (val
& BIT(10)) {
1857 e1000x_restart_autoneg(core
->mac
, core
->phy
[0], core
->autoneg_timer
);
1862 e1000e_set_phy_page(E1000ECore
*core
, int index
, uint16_t val
)
1864 core
->phy
[0][PHY_PAGE
] = val
& PHY_PAGE_RW_MASK
;
1868 e1000e_core_set_link_status(E1000ECore
*core
)
1870 NetClientState
*nc
= qemu_get_queue(core
->owner_nic
);
1871 uint32_t old_status
= core
->mac
[STATUS
];
1873 trace_e1000e_link_status_changed(nc
->link_down
? false : true);
1875 if (nc
->link_down
) {
1876 e1000x_update_regs_on_link_down(core
->mac
, core
->phy
[0]);
1878 if (e1000e_have_autoneg(core
) &&
1879 !(core
->phy
[0][MII_BMSR
] & MII_BMSR_AN_COMP
)) {
1880 e1000x_restart_autoneg(core
->mac
, core
->phy
[0],
1881 core
->autoneg_timer
);
1883 e1000x_update_regs_on_link_up(core
->mac
, core
->phy
[0]);
1884 e1000e_start_recv(core
);
1888 if (core
->mac
[STATUS
] != old_status
) {
1889 e1000e_set_interrupt_cause(core
, E1000_ICR_LSC
);
1894 e1000e_set_ctrl(E1000ECore
*core
, int index
, uint32_t val
)
1896 trace_e1000e_core_ctrl_write(index
, val
);
1898 /* RST is self clearing */
1899 core
->mac
[CTRL
] = val
& ~E1000_CTRL_RST
;
1900 core
->mac
[CTRL_DUP
] = core
->mac
[CTRL
];
1902 trace_e1000e_link_set_params(
1903 !!(val
& E1000_CTRL_ASDE
),
1904 (val
& E1000_CTRL_SPD_SEL
) >> E1000_CTRL_SPD_SHIFT
,
1905 !!(val
& E1000_CTRL_FRCSPD
),
1906 !!(val
& E1000_CTRL_FRCDPX
),
1907 !!(val
& E1000_CTRL_RFCE
),
1908 !!(val
& E1000_CTRL_TFCE
));
1910 if (val
& E1000_CTRL_RST
) {
1911 trace_e1000e_core_ctrl_sw_reset();
1912 e1000e_reset(core
, true);
1915 if (val
& E1000_CTRL_PHY_RST
) {
1916 trace_e1000e_core_ctrl_phy_reset();
1917 core
->mac
[STATUS
] |= E1000_STATUS_PHYRA
;
1922 e1000e_set_rfctl(E1000ECore
*core
, int index
, uint32_t val
)
1924 trace_e1000e_rx_set_rfctl(val
);
1926 if (!(val
& E1000_RFCTL_ISCSI_DIS
)) {
1927 trace_e1000e_wrn_iscsi_filtering_not_supported();
1930 if (!(val
& E1000_RFCTL_NFSW_DIS
)) {
1931 trace_e1000e_wrn_nfsw_filtering_not_supported();
1934 if (!(val
& E1000_RFCTL_NFSR_DIS
)) {
1935 trace_e1000e_wrn_nfsr_filtering_not_supported();
1938 core
->mac
[RFCTL
] = val
;
1942 e1000e_calc_per_desc_buf_size(E1000ECore
*core
)
1945 core
->rx_desc_buf_size
= 0;
1947 for (i
= 0; i
< ARRAY_SIZE(core
->rxbuf_sizes
); i
++) {
1948 core
->rx_desc_buf_size
+= core
->rxbuf_sizes
[i
];
1953 e1000e_parse_rxbufsize(E1000ECore
*core
)
1955 uint32_t rctl
= core
->mac
[RCTL
];
1957 memset(core
->rxbuf_sizes
, 0, sizeof(core
->rxbuf_sizes
));
1959 if (rctl
& E1000_RCTL_DTYP_MASK
) {
1962 bsize
= core
->mac
[PSRCTL
] & E1000_PSRCTL_BSIZE0_MASK
;
1963 core
->rxbuf_sizes
[0] = (bsize
>> E1000_PSRCTL_BSIZE0_SHIFT
) * 128;
1965 bsize
= core
->mac
[PSRCTL
] & E1000_PSRCTL_BSIZE1_MASK
;
1966 core
->rxbuf_sizes
[1] = (bsize
>> E1000_PSRCTL_BSIZE1_SHIFT
) * 1024;
1968 bsize
= core
->mac
[PSRCTL
] & E1000_PSRCTL_BSIZE2_MASK
;
1969 core
->rxbuf_sizes
[2] = (bsize
>> E1000_PSRCTL_BSIZE2_SHIFT
) * 1024;
1971 bsize
= core
->mac
[PSRCTL
] & E1000_PSRCTL_BSIZE3_MASK
;
1972 core
->rxbuf_sizes
[3] = (bsize
>> E1000_PSRCTL_BSIZE3_SHIFT
) * 1024;
1973 } else if (rctl
& E1000_RCTL_FLXBUF_MASK
) {
1974 int flxbuf
= rctl
& E1000_RCTL_FLXBUF_MASK
;
1975 core
->rxbuf_sizes
[0] = (flxbuf
>> E1000_RCTL_FLXBUF_SHIFT
) * 1024;
1977 core
->rxbuf_sizes
[0] = e1000x_rxbufsize(rctl
);
1980 trace_e1000e_rx_desc_buff_sizes(core
->rxbuf_sizes
[0], core
->rxbuf_sizes
[1],
1981 core
->rxbuf_sizes
[2], core
->rxbuf_sizes
[3]);
1983 e1000e_calc_per_desc_buf_size(core
);
1987 e1000e_calc_rxdesclen(E1000ECore
*core
)
1989 if (e1000e_rx_use_legacy_descriptor(core
)) {
1990 core
->rx_desc_len
= sizeof(struct e1000_rx_desc
);
1992 if (core
->mac
[RCTL
] & E1000_RCTL_DTYP_PS
) {
1993 core
->rx_desc_len
= sizeof(union e1000_rx_desc_packet_split
);
1995 core
->rx_desc_len
= sizeof(union e1000_rx_desc_extended
);
1998 trace_e1000e_rx_desc_len(core
->rx_desc_len
);
2002 e1000e_set_rx_control(E1000ECore
*core
, int index
, uint32_t val
)
2004 core
->mac
[RCTL
] = val
;
2005 trace_e1000e_rx_set_rctl(core
->mac
[RCTL
]);
2007 if (val
& E1000_RCTL_EN
) {
2008 e1000e_parse_rxbufsize(core
);
2009 e1000e_calc_rxdesclen(core
);
2010 core
->rxbuf_min_shift
= ((val
/ E1000_RCTL_RDMTS_QUAT
) & 3) + 1 +
2011 E1000_RING_DESC_LEN_SHIFT
;
2013 e1000e_start_recv(core
);
2018 void(*e1000e_phyreg_writeops
[E1000E_PHY_PAGES
][E1000E_PHY_PAGE_SIZE
])
2019 (E1000ECore
*, int, uint16_t) = {
2021 [MII_BMCR
] = e1000e_set_phy_ctrl
,
2022 [PHY_PAGE
] = e1000e_set_phy_page
,
2023 [PHY_OEM_BITS
] = e1000e_set_phy_oem_bits
2028 e1000e_clear_ims_bits(E1000ECore
*core
, uint32_t bits
)
2030 trace_e1000e_irq_clear_ims(bits
, core
->mac
[IMS
], core
->mac
[IMS
] & ~bits
);
2031 core
->mac
[IMS
] &= ~bits
;
2035 e1000e_postpone_interrupt(E1000IntrDelayTimer
*timer
)
2037 if (timer
->running
) {
2038 trace_e1000e_irq_postponed_by_xitr(timer
->delay_reg
<< 2);
2043 if (timer
->core
->mac
[timer
->delay_reg
] != 0) {
2044 e1000e_intrmgr_rearm_timer(timer
);
2051 e1000e_itr_should_postpone(E1000ECore
*core
)
2053 return e1000e_postpone_interrupt(&core
->itr
);
2057 e1000e_eitr_should_postpone(E1000ECore
*core
, int idx
)
2059 return e1000e_postpone_interrupt(&core
->eitr
[idx
]);
2063 e1000e_msix_notify_one(E1000ECore
*core
, uint32_t cause
, uint32_t int_cfg
)
2065 uint32_t effective_eiac
;
2067 if (E1000_IVAR_ENTRY_VALID(int_cfg
)) {
2068 uint32_t vec
= E1000_IVAR_ENTRY_VEC(int_cfg
);
2069 if (vec
< E1000E_MSIX_VEC_NUM
) {
2070 if (!e1000e_eitr_should_postpone(core
, vec
)) {
2071 trace_e1000e_irq_msix_notify_vec(vec
);
2072 msix_notify(core
->owner
, vec
);
2075 trace_e1000e_wrn_msix_vec_wrong(cause
, int_cfg
);
2078 trace_e1000e_wrn_msix_invalid(cause
, int_cfg
);
2081 if (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_EIAME
) {
2082 trace_e1000e_irq_iam_clear_eiame(core
->mac
[IAM
], cause
);
2083 core
->mac
[IAM
] &= ~cause
;
2086 trace_e1000e_irq_icr_clear_eiac(core
->mac
[ICR
], core
->mac
[EIAC
]);
2088 effective_eiac
= core
->mac
[EIAC
] & cause
;
2090 core
->mac
[ICR
] &= ~effective_eiac
;
2091 core
->msi_causes_pending
&= ~effective_eiac
;
2093 if (!(core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_IAME
)) {
2094 core
->mac
[IMS
] &= ~effective_eiac
;
2099 e1000e_msix_notify(E1000ECore
*core
, uint32_t causes
)
2101 if (causes
& E1000_ICR_RXQ0
) {
2102 e1000e_msix_notify_one(core
, E1000_ICR_RXQ0
,
2103 E1000_IVAR_RXQ0(core
->mac
[IVAR
]));
2106 if (causes
& E1000_ICR_RXQ1
) {
2107 e1000e_msix_notify_one(core
, E1000_ICR_RXQ1
,
2108 E1000_IVAR_RXQ1(core
->mac
[IVAR
]));
2111 if (causes
& E1000_ICR_TXQ0
) {
2112 e1000e_msix_notify_one(core
, E1000_ICR_TXQ0
,
2113 E1000_IVAR_TXQ0(core
->mac
[IVAR
]));
2116 if (causes
& E1000_ICR_TXQ1
) {
2117 e1000e_msix_notify_one(core
, E1000_ICR_TXQ1
,
2118 E1000_IVAR_TXQ1(core
->mac
[IVAR
]));
2121 if (causes
& E1000_ICR_OTHER
) {
2122 e1000e_msix_notify_one(core
, E1000_ICR_OTHER
,
2123 E1000_IVAR_OTHER(core
->mac
[IVAR
]));
2128 e1000e_msix_clear_one(E1000ECore
*core
, uint32_t cause
, uint32_t int_cfg
)
2130 if (E1000_IVAR_ENTRY_VALID(int_cfg
)) {
2131 uint32_t vec
= E1000_IVAR_ENTRY_VEC(int_cfg
);
2132 if (vec
< E1000E_MSIX_VEC_NUM
) {
2133 trace_e1000e_irq_msix_pending_clearing(cause
, int_cfg
, vec
);
2134 msix_clr_pending(core
->owner
, vec
);
2136 trace_e1000e_wrn_msix_vec_wrong(cause
, int_cfg
);
2139 trace_e1000e_wrn_msix_invalid(cause
, int_cfg
);
2144 e1000e_msix_clear(E1000ECore
*core
, uint32_t causes
)
2146 if (causes
& E1000_ICR_RXQ0
) {
2147 e1000e_msix_clear_one(core
, E1000_ICR_RXQ0
,
2148 E1000_IVAR_RXQ0(core
->mac
[IVAR
]));
2151 if (causes
& E1000_ICR_RXQ1
) {
2152 e1000e_msix_clear_one(core
, E1000_ICR_RXQ1
,
2153 E1000_IVAR_RXQ1(core
->mac
[IVAR
]));
2156 if (causes
& E1000_ICR_TXQ0
) {
2157 e1000e_msix_clear_one(core
, E1000_ICR_TXQ0
,
2158 E1000_IVAR_TXQ0(core
->mac
[IVAR
]));
2161 if (causes
& E1000_ICR_TXQ1
) {
2162 e1000e_msix_clear_one(core
, E1000_ICR_TXQ1
,
2163 E1000_IVAR_TXQ1(core
->mac
[IVAR
]));
2166 if (causes
& E1000_ICR_OTHER
) {
2167 e1000e_msix_clear_one(core
, E1000_ICR_OTHER
,
2168 E1000_IVAR_OTHER(core
->mac
[IVAR
]));
2173 e1000e_fix_icr_asserted(E1000ECore
*core
)
2175 core
->mac
[ICR
] &= ~E1000_ICR_ASSERTED
;
2176 if (core
->mac
[ICR
]) {
2177 core
->mac
[ICR
] |= E1000_ICR_ASSERTED
;
2180 trace_e1000e_irq_fix_icr_asserted(core
->mac
[ICR
]);
2184 e1000e_send_msi(E1000ECore
*core
, bool msix
)
2186 uint32_t causes
= core
->mac
[ICR
] & core
->mac
[IMS
] & ~E1000_ICR_ASSERTED
;
2188 core
->msi_causes_pending
&= causes
;
2189 causes
^= core
->msi_causes_pending
;
2193 core
->msi_causes_pending
|= causes
;
2196 e1000e_msix_notify(core
, causes
);
2198 if (!e1000e_itr_should_postpone(core
)) {
2199 trace_e1000e_irq_msi_notify(causes
);
2200 msi_notify(core
->owner
, 0);
2206 e1000e_update_interrupt_state(E1000ECore
*core
)
2208 bool interrupts_pending
;
2209 bool is_msix
= msix_enabled(core
->owner
);
2211 /* Set ICR[OTHER] for MSI-X */
2213 if (core
->mac
[ICR
] & E1000_ICR_OTHER_CAUSES
) {
2214 core
->mac
[ICR
] |= E1000_ICR_OTHER
;
2215 trace_e1000e_irq_add_msi_other(core
->mac
[ICR
]);
2219 e1000e_fix_icr_asserted(core
);
2222 * Make sure ICR and ICS registers have the same value.
2223 * The spec says that the ICS register is write-only. However in practice,
2224 * on real hardware ICS is readable, and for reads it has the same value as
2225 * ICR (except that ICS does not have the clear on read behaviour of ICR).
2227 * The VxWorks PRO/1000 driver uses this behaviour.
2229 core
->mac
[ICS
] = core
->mac
[ICR
];
2231 interrupts_pending
= (core
->mac
[IMS
] & core
->mac
[ICR
]) ? true : false;
2232 if (!interrupts_pending
) {
2233 core
->msi_causes_pending
= 0;
2236 trace_e1000e_irq_pending_interrupts(core
->mac
[ICR
] & core
->mac
[IMS
],
2237 core
->mac
[ICR
], core
->mac
[IMS
]);
2239 if (is_msix
|| msi_enabled(core
->owner
)) {
2240 if (interrupts_pending
) {
2241 e1000e_send_msi(core
, is_msix
);
2244 if (interrupts_pending
) {
2245 if (!e1000e_itr_should_postpone(core
)) {
2246 e1000e_raise_legacy_irq(core
);
2249 e1000e_lower_legacy_irq(core
);
2255 e1000e_set_interrupt_cause(E1000ECore
*core
, uint32_t val
)
2257 trace_e1000e_irq_set_cause_entry(val
, core
->mac
[ICR
]);
2259 val
|= e1000e_intmgr_collect_delayed_causes(core
);
2260 core
->mac
[ICR
] |= val
;
2262 trace_e1000e_irq_set_cause_exit(val
, core
->mac
[ICR
]);
2264 e1000e_update_interrupt_state(core
);
2268 e1000e_autoneg_timer(void *opaque
)
2270 E1000ECore
*core
= opaque
;
2271 if (!qemu_get_queue(core
->owner_nic
)->link_down
) {
2272 e1000x_update_regs_on_autoneg_done(core
->mac
, core
->phy
[0]);
2273 e1000e_start_recv(core
);
2275 e1000e_update_flowctl_status(core
);
2276 /* signal link status change to the guest */
2277 e1000e_set_interrupt_cause(core
, E1000_ICR_LSC
);
2281 static inline uint16_t
2282 e1000e_get_reg_index_with_offset(const uint16_t *mac_reg_access
, hwaddr addr
)
2284 uint16_t index
= (addr
& 0x1ffff) >> 2;
2285 return index
+ (mac_reg_access
[index
] & 0xfffe);
2288 static const char e1000e_phy_regcap
[E1000E_PHY_PAGES
][0x20] = {
2290 [MII_BMCR
] = PHY_ANYPAGE
| PHY_RW
,
2291 [MII_BMSR
] = PHY_ANYPAGE
| PHY_R
,
2292 [MII_PHYID1
] = PHY_ANYPAGE
| PHY_R
,
2293 [MII_PHYID2
] = PHY_ANYPAGE
| PHY_R
,
2294 [MII_ANAR
] = PHY_ANYPAGE
| PHY_RW
,
2295 [MII_ANLPAR
] = PHY_ANYPAGE
| PHY_R
,
2296 [MII_ANER
] = PHY_ANYPAGE
| PHY_R
,
2297 [MII_ANNP
] = PHY_ANYPAGE
| PHY_RW
,
2298 [MII_ANLPRNP
] = PHY_ANYPAGE
| PHY_R
,
2299 [MII_CTRL1000
] = PHY_ANYPAGE
| PHY_RW
,
2300 [MII_STAT1000
] = PHY_ANYPAGE
| PHY_R
,
2301 [MII_EXTSTAT
] = PHY_ANYPAGE
| PHY_R
,
2302 [PHY_PAGE
] = PHY_ANYPAGE
| PHY_RW
,
2304 [PHY_COPPER_CTRL1
] = PHY_RW
,
2305 [PHY_COPPER_STAT1
] = PHY_R
,
2306 [PHY_COPPER_CTRL3
] = PHY_RW
,
2307 [PHY_RX_ERR_CNTR
] = PHY_R
,
2308 [PHY_OEM_BITS
] = PHY_RW
,
2309 [PHY_BIAS_1
] = PHY_RW
,
2310 [PHY_BIAS_2
] = PHY_RW
,
2311 [PHY_COPPER_INT_ENABLE
] = PHY_RW
,
2312 [PHY_COPPER_STAT2
] = PHY_R
,
2313 [PHY_COPPER_CTRL2
] = PHY_RW
2316 [PHY_MAC_CTRL1
] = PHY_RW
,
2317 [PHY_MAC_INT_ENABLE
] = PHY_RW
,
2318 [PHY_MAC_STAT
] = PHY_R
,
2319 [PHY_MAC_CTRL2
] = PHY_RW
2322 [PHY_LED_03_FUNC_CTRL1
] = PHY_RW
,
2323 [PHY_LED_03_POL_CTRL
] = PHY_RW
,
2324 [PHY_LED_TIMER_CTRL
] = PHY_RW
,
2325 [PHY_LED_45_CTRL
] = PHY_RW
2328 [PHY_1000T_SKEW
] = PHY_R
,
2329 [PHY_1000T_SWAP
] = PHY_R
2332 [PHY_CRC_COUNTERS
] = PHY_R
2337 e1000e_phy_reg_check_cap(E1000ECore
*core
, uint32_t addr
,
2338 char cap
, uint8_t *page
)
2341 (e1000e_phy_regcap
[0][addr
] & PHY_ANYPAGE
) ? 0
2342 : core
->phy
[0][PHY_PAGE
];
2344 if (*page
>= E1000E_PHY_PAGES
) {
2348 return e1000e_phy_regcap
[*page
][addr
] & cap
;
2352 e1000e_phy_reg_write(E1000ECore
*core
, uint8_t page
,
2353 uint32_t addr
, uint16_t data
)
2355 assert(page
< E1000E_PHY_PAGES
);
2356 assert(addr
< E1000E_PHY_PAGE_SIZE
);
2358 if (e1000e_phyreg_writeops
[page
][addr
]) {
2359 e1000e_phyreg_writeops
[page
][addr
](core
, addr
, data
);
2361 core
->phy
[page
][addr
] = data
;
2366 e1000e_set_mdic(E1000ECore
*core
, int index
, uint32_t val
)
2368 uint32_t data
= val
& E1000_MDIC_DATA_MASK
;
2369 uint32_t addr
= ((val
& E1000_MDIC_REG_MASK
) >> E1000_MDIC_REG_SHIFT
);
2372 if ((val
& E1000_MDIC_PHY_MASK
) >> E1000_MDIC_PHY_SHIFT
!= 1) { /* phy # */
2373 val
= core
->mac
[MDIC
] | E1000_MDIC_ERROR
;
2374 } else if (val
& E1000_MDIC_OP_READ
) {
2375 if (!e1000e_phy_reg_check_cap(core
, addr
, PHY_R
, &page
)) {
2376 trace_e1000e_core_mdic_read_unhandled(page
, addr
);
2377 val
|= E1000_MDIC_ERROR
;
2379 val
= (val
^ data
) | core
->phy
[page
][addr
];
2380 trace_e1000e_core_mdic_read(page
, addr
, val
);
2382 } else if (val
& E1000_MDIC_OP_WRITE
) {
2383 if (!e1000e_phy_reg_check_cap(core
, addr
, PHY_W
, &page
)) {
2384 trace_e1000e_core_mdic_write_unhandled(page
, addr
);
2385 val
|= E1000_MDIC_ERROR
;
2387 trace_e1000e_core_mdic_write(page
, addr
, data
);
2388 e1000e_phy_reg_write(core
, page
, addr
, data
);
2391 core
->mac
[MDIC
] = val
| E1000_MDIC_READY
;
2393 if (val
& E1000_MDIC_INT_EN
) {
2394 e1000e_set_interrupt_cause(core
, E1000_ICR_MDAC
);
2399 e1000e_set_rdt(E1000ECore
*core
, int index
, uint32_t val
)
2401 core
->mac
[index
] = val
& 0xffff;
2402 trace_e1000e_rx_set_rdt(e1000e_mq_queue_idx(RDT0
, index
), val
);
2403 e1000e_start_recv(core
);
2407 e1000e_set_status(E1000ECore
*core
, int index
, uint32_t val
)
2409 if ((val
& E1000_STATUS_PHYRA
) == 0) {
2410 core
->mac
[index
] &= ~E1000_STATUS_PHYRA
;
2415 e1000e_set_ctrlext(E1000ECore
*core
, int index
, uint32_t val
)
2417 trace_e1000e_link_set_ext_params(!!(val
& E1000_CTRL_EXT_ASDCHK
),
2418 !!(val
& E1000_CTRL_EXT_SPD_BYPS
));
2420 /* Zero self-clearing bits */
2421 val
&= ~(E1000_CTRL_EXT_ASDCHK
| E1000_CTRL_EXT_EE_RST
);
2422 core
->mac
[CTRL_EXT
] = val
;
2426 e1000e_set_pbaclr(E1000ECore
*core
, int index
, uint32_t val
)
2430 core
->mac
[PBACLR
] = val
& E1000_PBACLR_VALID_MASK
;
2432 if (!msix_enabled(core
->owner
)) {
2436 for (i
= 0; i
< E1000E_MSIX_VEC_NUM
; i
++) {
2437 if (core
->mac
[PBACLR
] & BIT(i
)) {
2438 msix_clr_pending(core
->owner
, i
);
2444 e1000e_set_fcrth(E1000ECore
*core
, int index
, uint32_t val
)
2446 core
->mac
[FCRTH
] = val
& 0xFFF8;
2450 e1000e_set_fcrtl(E1000ECore
*core
, int index
, uint32_t val
)
2452 core
->mac
[FCRTL
] = val
& 0x8000FFF8;
2455 #define E1000E_LOW_BITS_SET_FUNC(num) \
2457 e1000e_set_##num##bit(E1000ECore *core, int index, uint32_t val) \
2459 core->mac[index] = val & (BIT(num) - 1); \
2462 E1000E_LOW_BITS_SET_FUNC(4)
2463 E1000E_LOW_BITS_SET_FUNC(6)
2464 E1000E_LOW_BITS_SET_FUNC(11)
2465 E1000E_LOW_BITS_SET_FUNC(12)
2466 E1000E_LOW_BITS_SET_FUNC(13)
2467 E1000E_LOW_BITS_SET_FUNC(16)
2470 e1000e_set_vet(E1000ECore
*core
, int index
, uint32_t val
)
2472 core
->mac
[VET
] = val
& 0xffff;
2473 trace_e1000e_vlan_vet(core
->mac
[VET
]);
2477 e1000e_set_dlen(E1000ECore
*core
, int index
, uint32_t val
)
2479 core
->mac
[index
] = val
& E1000_XDLEN_MASK
;
2483 e1000e_set_dbal(E1000ECore
*core
, int index
, uint32_t val
)
2485 core
->mac
[index
] = val
& E1000_XDBAL_MASK
;
2489 e1000e_set_tctl(E1000ECore
*core
, int index
, uint32_t val
)
2492 core
->mac
[index
] = val
;
2494 if (core
->mac
[TARC0
] & E1000_TARC_ENABLE
) {
2495 e1000e_tx_ring_init(core
, &txr
, 0);
2496 e1000e_start_xmit(core
, &txr
);
2499 if (core
->mac
[TARC1
] & E1000_TARC_ENABLE
) {
2500 e1000e_tx_ring_init(core
, &txr
, 1);
2501 e1000e_start_xmit(core
, &txr
);
2506 e1000e_set_tdt(E1000ECore
*core
, int index
, uint32_t val
)
2509 int qidx
= e1000e_mq_queue_idx(TDT
, index
);
2510 uint32_t tarc_reg
= (qidx
== 0) ? TARC0
: TARC1
;
2512 core
->mac
[index
] = val
& 0xffff;
2514 if (core
->mac
[tarc_reg
] & E1000_TARC_ENABLE
) {
2515 e1000e_tx_ring_init(core
, &txr
, qidx
);
2516 e1000e_start_xmit(core
, &txr
);
2521 e1000e_set_ics(E1000ECore
*core
, int index
, uint32_t val
)
2523 trace_e1000e_irq_write_ics(val
);
2524 e1000e_set_interrupt_cause(core
, val
);
2528 e1000e_set_icr(E1000ECore
*core
, int index
, uint32_t val
)
2531 if ((core
->mac
[ICR
] & E1000_ICR_ASSERTED
) &&
2532 (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_IAME
)) {
2533 trace_e1000e_irq_icr_process_iame();
2534 e1000e_clear_ims_bits(core
, core
->mac
[IAM
]);
2537 icr
= core
->mac
[ICR
] & ~val
;
2539 * Windows driver expects that the "receive overrun" bit and other
2540 * ones to be cleared when the "Other" bit (#24) is cleared.
2542 icr
= (val
& E1000_ICR_OTHER
) ? (icr
& ~E1000_ICR_OTHER_CAUSES
) : icr
;
2543 trace_e1000e_irq_icr_write(val
, core
->mac
[ICR
], icr
);
2544 core
->mac
[ICR
] = icr
;
2545 e1000e_update_interrupt_state(core
);
2549 e1000e_set_imc(E1000ECore
*core
, int index
, uint32_t val
)
2551 trace_e1000e_irq_ims_clear_set_imc(val
);
2552 e1000e_clear_ims_bits(core
, val
);
2553 e1000e_update_interrupt_state(core
);
2557 e1000e_set_ims(E1000ECore
*core
, int index
, uint32_t val
)
2559 static const uint32_t ims_ext_mask
=
2560 E1000_IMS_RXQ0
| E1000_IMS_RXQ1
|
2561 E1000_IMS_TXQ0
| E1000_IMS_TXQ1
|
2564 static const uint32_t ims_valid_mask
=
2565 E1000_IMS_TXDW
| E1000_IMS_TXQE
| E1000_IMS_LSC
|
2566 E1000_IMS_RXDMT0
| E1000_IMS_RXO
| E1000_IMS_RXT0
|
2567 E1000_IMS_MDAC
| E1000_IMS_TXD_LOW
| E1000_IMS_SRPD
|
2568 E1000_IMS_ACK
| E1000_IMS_MNG
| E1000_IMS_RXQ0
|
2569 E1000_IMS_RXQ1
| E1000_IMS_TXQ0
| E1000_IMS_TXQ1
|
2572 uint32_t valid_val
= val
& ims_valid_mask
;
2574 trace_e1000e_irq_set_ims(val
, core
->mac
[IMS
], core
->mac
[IMS
] | valid_val
);
2575 core
->mac
[IMS
] |= valid_val
;
2577 if ((valid_val
& ims_ext_mask
) &&
2578 (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_PBA_CLR
) &&
2579 msix_enabled(core
->owner
)) {
2580 e1000e_msix_clear(core
, valid_val
);
2583 if ((valid_val
== ims_valid_mask
) &&
2584 (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_INT_TIMERS_CLEAR_ENA
)) {
2585 trace_e1000e_irq_fire_all_timers(val
);
2586 e1000e_intrmgr_fire_all_timers(core
);
2589 e1000e_update_interrupt_state(core
);
2593 e1000e_set_rdtr(E1000ECore
*core
, int index
, uint32_t val
)
2595 e1000e_set_16bit(core
, index
, val
);
2597 if ((val
& E1000_RDTR_FPD
) && (core
->rdtr
.running
)) {
2598 trace_e1000e_irq_rdtr_fpd_running();
2599 e1000e_intrmgr_fire_delayed_interrupts(core
);
2601 trace_e1000e_irq_rdtr_fpd_not_running();
2606 e1000e_set_tidv(E1000ECore
*core
, int index
, uint32_t val
)
2608 e1000e_set_16bit(core
, index
, val
);
2610 if ((val
& E1000_TIDV_FPD
) && (core
->tidv
.running
)) {
2611 trace_e1000e_irq_tidv_fpd_running();
2612 e1000e_intrmgr_fire_delayed_interrupts(core
);
2614 trace_e1000e_irq_tidv_fpd_not_running();
2619 e1000e_mac_readreg(E1000ECore
*core
, int index
)
2621 return core
->mac
[index
];
2625 e1000e_mac_ics_read(E1000ECore
*core
, int index
)
2627 trace_e1000e_irq_read_ics(core
->mac
[ICS
]);
2628 return core
->mac
[ICS
];
2632 e1000e_mac_ims_read(E1000ECore
*core
, int index
)
2634 trace_e1000e_irq_read_ims(core
->mac
[IMS
]);
2635 return core
->mac
[IMS
];
2639 e1000e_mac_swsm_read(E1000ECore
*core
, int index
)
2641 uint32_t val
= core
->mac
[SWSM
];
2642 core
->mac
[SWSM
] = val
| E1000_SWSM_SMBI
;
2647 e1000e_mac_itr_read(E1000ECore
*core
, int index
)
2649 return core
->itr_guest_value
;
2653 e1000e_mac_eitr_read(E1000ECore
*core
, int index
)
2655 return core
->eitr_guest_value
[index
- EITR
];
2659 e1000e_mac_icr_read(E1000ECore
*core
, int index
)
2661 uint32_t ret
= core
->mac
[ICR
];
2662 trace_e1000e_irq_icr_read_entry(ret
);
2664 if (core
->mac
[IMS
] == 0) {
2665 trace_e1000e_irq_icr_clear_zero_ims();
2669 if (!msix_enabled(core
->owner
)) {
2670 trace_e1000e_irq_icr_clear_nonmsix_icr_read();
2674 if ((core
->mac
[ICR
] & E1000_ICR_ASSERTED
) &&
2675 (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_IAME
)) {
2676 trace_e1000e_irq_icr_clear_iame();
2678 trace_e1000e_irq_icr_process_iame();
2679 e1000e_clear_ims_bits(core
, core
->mac
[IAM
]);
2682 trace_e1000e_irq_icr_read_exit(core
->mac
[ICR
]);
2683 e1000e_update_interrupt_state(core
);
2688 e1000e_mac_read_clr4(E1000ECore
*core
, int index
)
2690 uint32_t ret
= core
->mac
[index
];
2692 core
->mac
[index
] = 0;
2697 e1000e_mac_read_clr8(E1000ECore
*core
, int index
)
2699 uint32_t ret
= core
->mac
[index
];
2701 core
->mac
[index
] = 0;
2702 core
->mac
[index
- 1] = 0;
2707 e1000e_get_ctrl(E1000ECore
*core
, int index
)
2709 uint32_t val
= core
->mac
[CTRL
];
2711 trace_e1000e_link_read_params(
2712 !!(val
& E1000_CTRL_ASDE
),
2713 (val
& E1000_CTRL_SPD_SEL
) >> E1000_CTRL_SPD_SHIFT
,
2714 !!(val
& E1000_CTRL_FRCSPD
),
2715 !!(val
& E1000_CTRL_FRCDPX
),
2716 !!(val
& E1000_CTRL_RFCE
),
2717 !!(val
& E1000_CTRL_TFCE
));
2723 e1000e_get_status(E1000ECore
*core
, int index
)
2725 uint32_t res
= core
->mac
[STATUS
];
2727 if (!(core
->mac
[CTRL
] & E1000_CTRL_GIO_MASTER_DISABLE
)) {
2728 res
|= E1000_STATUS_GIO_MASTER_ENABLE
;
2731 if (core
->mac
[CTRL
] & E1000_CTRL_FRCDPX
) {
2732 res
|= (core
->mac
[CTRL
] & E1000_CTRL_FD
) ? E1000_STATUS_FD
: 0;
2734 res
|= E1000_STATUS_FD
;
2737 if ((core
->mac
[CTRL
] & E1000_CTRL_FRCSPD
) ||
2738 (core
->mac
[CTRL_EXT
] & E1000_CTRL_EXT_SPD_BYPS
)) {
2739 switch (core
->mac
[CTRL
] & E1000_CTRL_SPD_SEL
) {
2740 case E1000_CTRL_SPD_10
:
2741 res
|= E1000_STATUS_SPEED_10
;
2743 case E1000_CTRL_SPD_100
:
2744 res
|= E1000_STATUS_SPEED_100
;
2746 case E1000_CTRL_SPD_1000
:
2748 res
|= E1000_STATUS_SPEED_1000
;
2752 res
|= E1000_STATUS_SPEED_1000
;
2755 trace_e1000e_link_status(
2756 !!(res
& E1000_STATUS_LU
),
2757 !!(res
& E1000_STATUS_FD
),
2758 (res
& E1000_STATUS_SPEED_MASK
) >> E1000_STATUS_SPEED_SHIFT
,
2759 (res
& E1000_STATUS_ASDV
) >> E1000_STATUS_ASDV_SHIFT
);
2765 e1000e_get_tarc(E1000ECore
*core
, int index
)
2767 return core
->mac
[index
] & ((BIT(11) - 1) |
2775 e1000e_mac_writereg(E1000ECore
*core
, int index
, uint32_t val
)
2777 core
->mac
[index
] = val
;
2781 e1000e_mac_setmacaddr(E1000ECore
*core
, int index
, uint32_t val
)
2783 uint32_t macaddr
[2];
2785 core
->mac
[index
] = val
;
2787 macaddr
[0] = cpu_to_le32(core
->mac
[RA
]);
2788 macaddr
[1] = cpu_to_le32(core
->mac
[RA
+ 1]);
2789 qemu_format_nic_info_str(qemu_get_queue(core
->owner_nic
),
2790 (uint8_t *) macaddr
);
2792 trace_e1000e_mac_set_sw(MAC_ARG(macaddr
));
2796 e1000e_set_eecd(E1000ECore
*core
, int index
, uint32_t val
)
2798 static const uint32_t ro_bits
= E1000_EECD_PRES
|
2799 E1000_EECD_AUTO_RD
|
2800 E1000_EECD_SIZE_EX_MASK
;
2802 core
->mac
[EECD
] = (core
->mac
[EECD
] & ro_bits
) | (val
& ~ro_bits
);
2806 e1000e_set_eerd(E1000ECore
*core
, int index
, uint32_t val
)
2808 uint32_t addr
= (val
>> E1000_EERW_ADDR_SHIFT
) & E1000_EERW_ADDR_MASK
;
2812 if ((addr
< E1000E_EEPROM_SIZE
) && (val
& E1000_EERW_START
)) {
2813 data
= core
->eeprom
[addr
];
2814 flags
= E1000_EERW_DONE
;
2817 core
->mac
[EERD
] = flags
|
2818 (addr
<< E1000_EERW_ADDR_SHIFT
) |
2819 (data
<< E1000_EERW_DATA_SHIFT
);
2823 e1000e_set_eewr(E1000ECore
*core
, int index
, uint32_t val
)
2825 uint32_t addr
= (val
>> E1000_EERW_ADDR_SHIFT
) & E1000_EERW_ADDR_MASK
;
2826 uint32_t data
= (val
>> E1000_EERW_DATA_SHIFT
) & E1000_EERW_DATA_MASK
;
2829 if ((addr
< E1000E_EEPROM_SIZE
) && (val
& E1000_EERW_START
)) {
2830 core
->eeprom
[addr
] = data
;
2831 flags
= E1000_EERW_DONE
;
2834 core
->mac
[EERD
] = flags
|
2835 (addr
<< E1000_EERW_ADDR_SHIFT
) |
2836 (data
<< E1000_EERW_DATA_SHIFT
);
2840 e1000e_set_rxdctl(E1000ECore
*core
, int index
, uint32_t val
)
2842 core
->mac
[RXDCTL
] = core
->mac
[RXDCTL1
] = val
;
2846 e1000e_set_itr(E1000ECore
*core
, int index
, uint32_t val
)
2848 uint32_t interval
= val
& 0xffff;
2850 trace_e1000e_irq_itr_set(val
);
2852 core
->itr_guest_value
= interval
;
2853 core
->mac
[index
] = MAX(interval
, E1000E_MIN_XITR
);
2857 e1000e_set_eitr(E1000ECore
*core
, int index
, uint32_t val
)
2859 uint32_t interval
= val
& 0xffff;
2860 uint32_t eitr_num
= index
- EITR
;
2862 trace_e1000e_irq_eitr_set(eitr_num
, val
);
2864 core
->eitr_guest_value
[eitr_num
] = interval
;
2865 core
->mac
[index
] = MAX(interval
, E1000E_MIN_XITR
);
2869 e1000e_set_psrctl(E1000ECore
*core
, int index
, uint32_t val
)
2871 if (core
->mac
[RCTL
] & E1000_RCTL_DTYP_MASK
) {
2873 if ((val
& E1000_PSRCTL_BSIZE0_MASK
) == 0) {
2874 qemu_log_mask(LOG_GUEST_ERROR
,
2875 "e1000e: PSRCTL.BSIZE0 cannot be zero");
2879 if ((val
& E1000_PSRCTL_BSIZE1_MASK
) == 0) {
2880 qemu_log_mask(LOG_GUEST_ERROR
,
2881 "e1000e: PSRCTL.BSIZE1 cannot be zero");
2886 core
->mac
[PSRCTL
] = val
;
2890 e1000e_update_rx_offloads(E1000ECore
*core
)
2892 int cso_state
= e1000e_rx_l4_cso_enabled(core
);
2894 trace_e1000e_rx_set_cso(cso_state
);
2896 if (core
->has_vnet
) {
2897 qemu_set_offload(qemu_get_queue(core
->owner_nic
)->peer
,
2898 cso_state
, 0, 0, 0, 0);
2903 e1000e_set_rxcsum(E1000ECore
*core
, int index
, uint32_t val
)
2905 core
->mac
[RXCSUM
] = val
;
2906 e1000e_update_rx_offloads(core
);
2910 e1000e_set_gcr(E1000ECore
*core
, int index
, uint32_t val
)
2912 uint32_t ro_bits
= core
->mac
[GCR
] & E1000_GCR_RO_BITS
;
2913 core
->mac
[GCR
] = (val
& ~E1000_GCR_RO_BITS
) | ro_bits
;
2916 static uint32_t e1000e_get_systiml(E1000ECore
*core
, int index
)
2918 e1000x_timestamp(core
->mac
, core
->timadj
, SYSTIML
, SYSTIMH
);
2919 return core
->mac
[SYSTIML
];
2922 static uint32_t e1000e_get_rxsatrh(E1000ECore
*core
, int index
)
2924 core
->mac
[TSYNCRXCTL
] &= ~E1000_TSYNCRXCTL_VALID
;
2925 return core
->mac
[RXSATRH
];
2928 static uint32_t e1000e_get_txstmph(E1000ECore
*core
, int index
)
2930 core
->mac
[TSYNCTXCTL
] &= ~E1000_TSYNCTXCTL_VALID
;
2931 return core
->mac
[TXSTMPH
];
2934 static void e1000e_set_timinca(E1000ECore
*core
, int index
, uint32_t val
)
2936 e1000x_set_timinca(core
->mac
, &core
->timadj
, val
);
2939 static void e1000e_set_timadjh(E1000ECore
*core
, int index
, uint32_t val
)
2941 core
->mac
[TIMADJH
] = val
;
2942 core
->timadj
+= core
->mac
[TIMADJL
] | ((int64_t)core
->mac
[TIMADJH
] << 32);
2945 #define e1000e_getreg(x) [x] = e1000e_mac_readreg
2946 typedef uint32_t (*readops
)(E1000ECore
*, int);
2947 static const readops e1000e_macreg_readops
[] = {
2949 e1000e_getreg(WUFC
),
2950 e1000e_getreg(MANC
),
2951 e1000e_getreg(TOTL
),
2952 e1000e_getreg(RDT0
),
2953 e1000e_getreg(RDBAH0
),
2954 e1000e_getreg(TDBAL1
),
2955 e1000e_getreg(RDLEN0
),
2956 e1000e_getreg(RDH1
),
2957 e1000e_getreg(LATECOL
),
2958 e1000e_getreg(SEQEC
),
2959 e1000e_getreg(XONTXC
),
2961 e1000e_getreg(TDFH
),
2962 e1000e_getreg(TDFT
),
2963 e1000e_getreg(TDFHS
),
2964 e1000e_getreg(TDFTS
),
2965 e1000e_getreg(TDFPC
),
2968 e1000e_getreg(RDFH
),
2969 e1000e_getreg(RDFT
),
2970 e1000e_getreg(RDFHS
),
2971 e1000e_getreg(RDFTS
),
2972 e1000e_getreg(RDFPC
),
2973 e1000e_getreg(GORCL
),
2974 e1000e_getreg(MGTPRC
),
2975 e1000e_getreg(EERD
),
2976 e1000e_getreg(EIAC
),
2977 e1000e_getreg(PSRCTL
),
2978 e1000e_getreg(MANC2H
),
2979 e1000e_getreg(RXCSUM
),
2980 e1000e_getreg(GSCL_3
),
2981 e1000e_getreg(GSCN_2
),
2982 e1000e_getreg(RSRPD
),
2983 e1000e_getreg(RDBAL1
),
2984 e1000e_getreg(FCAH
),
2985 e1000e_getreg(FCRTH
),
2986 e1000e_getreg(FLOP
),
2987 e1000e_getreg(FLASHT
),
2988 e1000e_getreg(RXSTMPH
),
2989 e1000e_getreg(TXSTMPL
),
2990 e1000e_getreg(TIMADJL
),
2991 e1000e_getreg(TXDCTL
),
2992 e1000e_getreg(RDH0
),
2993 e1000e_getreg(TDT1
),
2994 e1000e_getreg(TNCRS
),
2997 e1000e_getreg(GSCL_2
),
2998 e1000e_getreg(RDBAH1
),
2999 e1000e_getreg(FLSWDATA
),
3000 e1000e_getreg(TIPG
),
3001 e1000e_getreg(FLMNGCTL
),
3002 e1000e_getreg(FLMNGCNT
),
3003 e1000e_getreg(TSYNCTXCTL
),
3004 e1000e_getreg(EXTCNF_SIZE
),
3005 e1000e_getreg(EXTCNF_CTRL
),
3006 e1000e_getreg(EEMNGDATA
),
3007 e1000e_getreg(CTRL_EXT
),
3008 e1000e_getreg(SYSTIMH
),
3009 e1000e_getreg(EEMNGCTL
),
3010 e1000e_getreg(FLMNGDATA
),
3011 e1000e_getreg(TSYNCRXCTL
),
3013 e1000e_getreg(LEDCTL
),
3014 e1000e_getreg(TCTL
),
3015 e1000e_getreg(TDBAL
),
3016 e1000e_getreg(TDLEN
),
3017 e1000e_getreg(TDH1
),
3018 e1000e_getreg(RADV
),
3019 e1000e_getreg(ECOL
),
3021 e1000e_getreg(RLEC
),
3022 e1000e_getreg(XOFFTXC
),
3024 e1000e_getreg(RNBC
),
3025 e1000e_getreg(MGTPTC
),
3026 e1000e_getreg(TIMINCA
),
3027 e1000e_getreg(RXCFGL
),
3028 e1000e_getreg(MFUTP01
),
3029 e1000e_getreg(FACTPS
),
3030 e1000e_getreg(GSCL_1
),
3031 e1000e_getreg(GSCN_0
),
3032 e1000e_getreg(GCR2
),
3033 e1000e_getreg(RDT1
),
3034 e1000e_getreg(PBACLR
),
3035 e1000e_getreg(FCTTV
),
3036 e1000e_getreg(EEWR
),
3037 e1000e_getreg(FLSWCTL
),
3038 e1000e_getreg(RXDCTL1
),
3039 e1000e_getreg(RXSATRL
),
3040 e1000e_getreg(RXUDP
),
3041 e1000e_getreg(TORL
),
3042 e1000e_getreg(TDLEN1
),
3045 e1000e_getreg(EECD
),
3046 e1000e_getreg(MFUTP23
),
3047 e1000e_getreg(RAID
),
3048 e1000e_getreg(FCRTV
),
3049 e1000e_getreg(TXDCTL1
),
3050 e1000e_getreg(RCTL
),
3052 e1000e_getreg(MDIC
),
3053 e1000e_getreg(FCRUC
),
3055 e1000e_getreg(RDBAL0
),
3056 e1000e_getreg(TDBAH1
),
3057 e1000e_getreg(RDTR
),
3059 e1000e_getreg(COLC
),
3060 e1000e_getreg(CEXTERR
),
3061 e1000e_getreg(XOFFRXC
),
3062 e1000e_getreg(IPAV
),
3063 e1000e_getreg(GOTCL
),
3064 e1000e_getreg(MGTPDC
),
3066 e1000e_getreg(IVAR
),
3067 e1000e_getreg(POEMB
),
3068 e1000e_getreg(MFVAL
),
3069 e1000e_getreg(FUNCTAG
),
3070 e1000e_getreg(GSCL_4
),
3071 e1000e_getreg(GSCN_3
),
3072 e1000e_getreg(MRQC
),
3073 e1000e_getreg(RDLEN1
),
3076 e1000e_getreg(FLOL
),
3077 e1000e_getreg(RXDCTL
),
3078 e1000e_getreg(RXSTMPL
),
3079 e1000e_getreg(TIMADJH
),
3080 e1000e_getreg(FCRTL
),
3081 e1000e_getreg(TDBAH
),
3082 e1000e_getreg(TADV
),
3083 e1000e_getreg(XONRXC
),
3084 e1000e_getreg(TSCTFC
),
3085 e1000e_getreg(RFCTL
),
3086 e1000e_getreg(GSCN_1
),
3087 e1000e_getreg(FCAL
),
3088 e1000e_getreg(FLSWCNT
),
3090 [TOTH
] = e1000e_mac_read_clr8
,
3091 [GOTCH
] = e1000e_mac_read_clr8
,
3092 [PRC64
] = e1000e_mac_read_clr4
,
3093 [PRC255
] = e1000e_mac_read_clr4
,
3094 [PRC1023
] = e1000e_mac_read_clr4
,
3095 [PTC64
] = e1000e_mac_read_clr4
,
3096 [PTC255
] = e1000e_mac_read_clr4
,
3097 [PTC1023
] = e1000e_mac_read_clr4
,
3098 [GPRC
] = e1000e_mac_read_clr4
,
3099 [TPT
] = e1000e_mac_read_clr4
,
3100 [RUC
] = e1000e_mac_read_clr4
,
3101 [BPRC
] = e1000e_mac_read_clr4
,
3102 [MPTC
] = e1000e_mac_read_clr4
,
3103 [IAC
] = e1000e_mac_read_clr4
,
3104 [ICR
] = e1000e_mac_icr_read
,
3105 [STATUS
] = e1000e_get_status
,
3106 [TARC0
] = e1000e_get_tarc
,
3107 [ICS
] = e1000e_mac_ics_read
,
3108 [TORH
] = e1000e_mac_read_clr8
,
3109 [GORCH
] = e1000e_mac_read_clr8
,
3110 [PRC127
] = e1000e_mac_read_clr4
,
3111 [PRC511
] = e1000e_mac_read_clr4
,
3112 [PRC1522
] = e1000e_mac_read_clr4
,
3113 [PTC127
] = e1000e_mac_read_clr4
,
3114 [PTC511
] = e1000e_mac_read_clr4
,
3115 [PTC1522
] = e1000e_mac_read_clr4
,
3116 [GPTC
] = e1000e_mac_read_clr4
,
3117 [TPR
] = e1000e_mac_read_clr4
,
3118 [ROC
] = e1000e_mac_read_clr4
,
3119 [MPRC
] = e1000e_mac_read_clr4
,
3120 [BPTC
] = e1000e_mac_read_clr4
,
3121 [TSCTC
] = e1000e_mac_read_clr4
,
3122 [ITR
] = e1000e_mac_itr_read
,
3123 [CTRL
] = e1000e_get_ctrl
,
3124 [TARC1
] = e1000e_get_tarc
,
3125 [SWSM
] = e1000e_mac_swsm_read
,
3126 [IMS
] = e1000e_mac_ims_read
,
3127 [SYSTIML
] = e1000e_get_systiml
,
3128 [RXSATRH
] = e1000e_get_rxsatrh
,
3129 [TXSTMPH
] = e1000e_get_txstmph
,
3131 [CRCERRS
... MPC
] = e1000e_mac_readreg
,
3132 [IP6AT
... IP6AT
+ 3] = e1000e_mac_readreg
,
3133 [IP4AT
... IP4AT
+ 6] = e1000e_mac_readreg
,
3134 [RA
... RA
+ 31] = e1000e_mac_readreg
,
3135 [WUPM
... WUPM
+ 31] = e1000e_mac_readreg
,
3136 [MTA
... MTA
+ E1000_MC_TBL_SIZE
- 1] = e1000e_mac_readreg
,
3137 [VFTA
... VFTA
+ E1000_VLAN_FILTER_TBL_SIZE
- 1] = e1000e_mac_readreg
,
3138 [FFMT
... FFMT
+ 254] = e1000e_mac_readreg
,
3139 [FFVT
... FFVT
+ 254] = e1000e_mac_readreg
,
3140 [MDEF
... MDEF
+ 7] = e1000e_mac_readreg
,
3141 [FFLT
... FFLT
+ 10] = e1000e_mac_readreg
,
3142 [FTFT
... FTFT
+ 254] = e1000e_mac_readreg
,
3143 [PBM
... PBM
+ 10239] = e1000e_mac_readreg
,
3144 [RETA
... RETA
+ 31] = e1000e_mac_readreg
,
3145 [RSSRK
... RSSRK
+ 31] = e1000e_mac_readreg
,
3146 [MAVTV0
... MAVTV3
] = e1000e_mac_readreg
,
3147 [EITR
...EITR
+ E1000E_MSIX_VEC_NUM
- 1] = e1000e_mac_eitr_read
3149 enum { E1000E_NREADOPS
= ARRAY_SIZE(e1000e_macreg_readops
) };
3151 #define e1000e_putreg(x) [x] = e1000e_mac_writereg
3152 typedef void (*writeops
)(E1000ECore
*, int, uint32_t);
3153 static const writeops e1000e_macreg_writeops
[] = {
3155 e1000e_putreg(SWSM
),
3156 e1000e_putreg(WUFC
),
3157 e1000e_putreg(RDBAH1
),
3158 e1000e_putreg(TDBAH
),
3159 e1000e_putreg(TXDCTL
),
3160 e1000e_putreg(RDBAH0
),
3161 e1000e_putreg(LEDCTL
),
3162 e1000e_putreg(FCAL
),
3163 e1000e_putreg(FCRUC
),
3166 e1000e_putreg(IPAV
),
3167 e1000e_putreg(TDBAH1
),
3169 e1000e_putreg(EIAC
),
3170 e1000e_putreg(IVAR
),
3171 e1000e_putreg(TARC0
),
3172 e1000e_putreg(TARC1
),
3173 e1000e_putreg(FLSWDATA
),
3174 e1000e_putreg(POEMB
),
3175 e1000e_putreg(MFUTP01
),
3176 e1000e_putreg(MFUTP23
),
3177 e1000e_putreg(MANC
),
3178 e1000e_putreg(MANC2H
),
3179 e1000e_putreg(MFVAL
),
3180 e1000e_putreg(EXTCNF_CTRL
),
3181 e1000e_putreg(FACTPS
),
3182 e1000e_putreg(FUNCTAG
),
3183 e1000e_putreg(GSCL_1
),
3184 e1000e_putreg(GSCL_2
),
3185 e1000e_putreg(GSCL_3
),
3186 e1000e_putreg(GSCL_4
),
3187 e1000e_putreg(GSCN_0
),
3188 e1000e_putreg(GSCN_1
),
3189 e1000e_putreg(GSCN_2
),
3190 e1000e_putreg(GSCN_3
),
3191 e1000e_putreg(GCR2
),
3192 e1000e_putreg(MRQC
),
3193 e1000e_putreg(FLOP
),
3194 e1000e_putreg(FLOL
),
3195 e1000e_putreg(FLSWCTL
),
3196 e1000e_putreg(FLSWCNT
),
3198 e1000e_putreg(RXDCTL1
),
3199 e1000e_putreg(TXDCTL1
),
3200 e1000e_putreg(TIPG
),
3201 e1000e_putreg(RXSTMPH
),
3202 e1000e_putreg(RXSTMPL
),
3203 e1000e_putreg(RXSATRL
),
3204 e1000e_putreg(RXSATRH
),
3205 e1000e_putreg(TXSTMPL
),
3206 e1000e_putreg(TXSTMPH
),
3207 e1000e_putreg(SYSTIML
),
3208 e1000e_putreg(SYSTIMH
),
3209 e1000e_putreg(TIMADJL
),
3210 e1000e_putreg(RXUDP
),
3211 e1000e_putreg(RXCFGL
),
3212 e1000e_putreg(TSYNCRXCTL
),
3213 e1000e_putreg(TSYNCTXCTL
),
3214 e1000e_putreg(EXTCNF_SIZE
),
3215 e1000e_putreg(EEMNGCTL
),
3218 [TDH1
] = e1000e_set_16bit
,
3219 [TDT1
] = e1000e_set_tdt
,
3220 [TCTL
] = e1000e_set_tctl
,
3221 [TDT
] = e1000e_set_tdt
,
3222 [MDIC
] = e1000e_set_mdic
,
3223 [ICS
] = e1000e_set_ics
,
3224 [TDH
] = e1000e_set_16bit
,
3225 [RDH0
] = e1000e_set_16bit
,
3226 [RDT0
] = e1000e_set_rdt
,
3227 [IMC
] = e1000e_set_imc
,
3228 [IMS
] = e1000e_set_ims
,
3229 [ICR
] = e1000e_set_icr
,
3230 [EECD
] = e1000e_set_eecd
,
3231 [RCTL
] = e1000e_set_rx_control
,
3232 [CTRL
] = e1000e_set_ctrl
,
3233 [RDTR
] = e1000e_set_rdtr
,
3234 [RADV
] = e1000e_set_16bit
,
3235 [TADV
] = e1000e_set_16bit
,
3236 [ITR
] = e1000e_set_itr
,
3237 [EERD
] = e1000e_set_eerd
,
3238 [AIT
] = e1000e_set_16bit
,
3239 [TDFH
] = e1000e_set_13bit
,
3240 [TDFT
] = e1000e_set_13bit
,
3241 [TDFHS
] = e1000e_set_13bit
,
3242 [TDFTS
] = e1000e_set_13bit
,
3243 [TDFPC
] = e1000e_set_13bit
,
3244 [RDFH
] = e1000e_set_13bit
,
3245 [RDFHS
] = e1000e_set_13bit
,
3246 [RDFT
] = e1000e_set_13bit
,
3247 [RDFTS
] = e1000e_set_13bit
,
3248 [RDFPC
] = e1000e_set_13bit
,
3249 [PBS
] = e1000e_set_6bit
,
3250 [GCR
] = e1000e_set_gcr
,
3251 [PSRCTL
] = e1000e_set_psrctl
,
3252 [RXCSUM
] = e1000e_set_rxcsum
,
3253 [RAID
] = e1000e_set_16bit
,
3254 [RSRPD
] = e1000e_set_12bit
,
3255 [TIDV
] = e1000e_set_tidv
,
3256 [TDLEN1
] = e1000e_set_dlen
,
3257 [TDLEN
] = e1000e_set_dlen
,
3258 [RDLEN0
] = e1000e_set_dlen
,
3259 [RDLEN1
] = e1000e_set_dlen
,
3260 [TDBAL
] = e1000e_set_dbal
,
3261 [TDBAL1
] = e1000e_set_dbal
,
3262 [RDBAL0
] = e1000e_set_dbal
,
3263 [RDBAL1
] = e1000e_set_dbal
,
3264 [RDH1
] = e1000e_set_16bit
,
3265 [RDT1
] = e1000e_set_rdt
,
3266 [STATUS
] = e1000e_set_status
,
3267 [PBACLR
] = e1000e_set_pbaclr
,
3268 [CTRL_EXT
] = e1000e_set_ctrlext
,
3269 [FCAH
] = e1000e_set_16bit
,
3270 [FCT
] = e1000e_set_16bit
,
3271 [FCTTV
] = e1000e_set_16bit
,
3272 [FCRTV
] = e1000e_set_16bit
,
3273 [FCRTH
] = e1000e_set_fcrth
,
3274 [FCRTL
] = e1000e_set_fcrtl
,
3275 [VET
] = e1000e_set_vet
,
3276 [RXDCTL
] = e1000e_set_rxdctl
,
3277 [FLASHT
] = e1000e_set_16bit
,
3278 [EEWR
] = e1000e_set_eewr
,
3279 [CTRL_DUP
] = e1000e_set_ctrl
,
3280 [RFCTL
] = e1000e_set_rfctl
,
3281 [RA
+ 1] = e1000e_mac_setmacaddr
,
3282 [TIMINCA
] = e1000e_set_timinca
,
3283 [TIMADJH
] = e1000e_set_timadjh
,
3285 [IP6AT
... IP6AT
+ 3] = e1000e_mac_writereg
,
3286 [IP4AT
... IP4AT
+ 6] = e1000e_mac_writereg
,
3287 [RA
+ 2 ... RA
+ 31] = e1000e_mac_writereg
,
3288 [WUPM
... WUPM
+ 31] = e1000e_mac_writereg
,
3289 [MTA
... MTA
+ E1000_MC_TBL_SIZE
- 1] = e1000e_mac_writereg
,
3290 [VFTA
... VFTA
+ E1000_VLAN_FILTER_TBL_SIZE
- 1] = e1000e_mac_writereg
,
3291 [FFMT
... FFMT
+ 254] = e1000e_set_4bit
,
3292 [FFVT
... FFVT
+ 254] = e1000e_mac_writereg
,
3293 [PBM
... PBM
+ 10239] = e1000e_mac_writereg
,
3294 [MDEF
... MDEF
+ 7] = e1000e_mac_writereg
,
3295 [FFLT
... FFLT
+ 10] = e1000e_set_11bit
,
3296 [FTFT
... FTFT
+ 254] = e1000e_mac_writereg
,
3297 [RETA
... RETA
+ 31] = e1000e_mac_writereg
,
3298 [RSSRK
... RSSRK
+ 31] = e1000e_mac_writereg
,
3299 [MAVTV0
... MAVTV3
] = e1000e_mac_writereg
,
3300 [EITR
...EITR
+ E1000E_MSIX_VEC_NUM
- 1] = e1000e_set_eitr
3302 enum { E1000E_NWRITEOPS
= ARRAY_SIZE(e1000e_macreg_writeops
) };
3304 enum { MAC_ACCESS_PARTIAL
= 1 };
3307 * The array below combines alias offsets of the index values for the
3308 * MAC registers that have aliases, with the indication of not fully
3309 * implemented registers (lowest bit). This combination is possible
3310 * because all of the offsets are even.
3312 static const uint16_t mac_reg_access
[E1000E_MAC_SIZE
] = {
3313 /* Alias index offsets */
3314 [FCRTL_A
] = 0x07fe, [FCRTH_A
] = 0x0802,
3315 [RDH0_A
] = 0x09bc, [RDT0_A
] = 0x09bc, [RDTR_A
] = 0x09c6,
3316 [RDFH_A
] = 0xe904, [RDFT_A
] = 0xe904,
3317 [TDH_A
] = 0x0cf8, [TDT_A
] = 0x0cf8, [TIDV_A
] = 0x0cf8,
3318 [TDFH_A
] = 0xed00, [TDFT_A
] = 0xed00,
3319 [RA_A
... RA_A
+ 31] = 0x14f0,
3320 [VFTA_A
... VFTA_A
+ E1000_VLAN_FILTER_TBL_SIZE
- 1] = 0x1400,
3321 [RDBAL0_A
... RDLEN0_A
] = 0x09bc,
3322 [TDBAL_A
... TDLEN_A
] = 0x0cf8,
3323 /* Access options */
3324 [RDFH
] = MAC_ACCESS_PARTIAL
, [RDFT
] = MAC_ACCESS_PARTIAL
,
3325 [RDFHS
] = MAC_ACCESS_PARTIAL
, [RDFTS
] = MAC_ACCESS_PARTIAL
,
3326 [RDFPC
] = MAC_ACCESS_PARTIAL
,
3327 [TDFH
] = MAC_ACCESS_PARTIAL
, [TDFT
] = MAC_ACCESS_PARTIAL
,
3328 [TDFHS
] = MAC_ACCESS_PARTIAL
, [TDFTS
] = MAC_ACCESS_PARTIAL
,
3329 [TDFPC
] = MAC_ACCESS_PARTIAL
, [EECD
] = MAC_ACCESS_PARTIAL
,
3330 [PBM
] = MAC_ACCESS_PARTIAL
, [FLA
] = MAC_ACCESS_PARTIAL
,
3331 [FCAL
] = MAC_ACCESS_PARTIAL
, [FCAH
] = MAC_ACCESS_PARTIAL
,
3332 [FCT
] = MAC_ACCESS_PARTIAL
, [FCTTV
] = MAC_ACCESS_PARTIAL
,
3333 [FCRTV
] = MAC_ACCESS_PARTIAL
, [FCRTL
] = MAC_ACCESS_PARTIAL
,
3334 [FCRTH
] = MAC_ACCESS_PARTIAL
, [TXDCTL
] = MAC_ACCESS_PARTIAL
,
3335 [TXDCTL1
] = MAC_ACCESS_PARTIAL
,
3336 [MAVTV0
... MAVTV3
] = MAC_ACCESS_PARTIAL
3340 e1000e_core_write(E1000ECore
*core
, hwaddr addr
, uint64_t val
, unsigned size
)
3342 uint16_t index
= e1000e_get_reg_index_with_offset(mac_reg_access
, addr
);
3344 if (index
< E1000E_NWRITEOPS
&& e1000e_macreg_writeops
[index
]) {
3345 if (mac_reg_access
[index
] & MAC_ACCESS_PARTIAL
) {
3346 trace_e1000e_wrn_regs_write_trivial(index
<< 2);
3348 trace_e1000e_core_write(index
<< 2, size
, val
);
3349 e1000e_macreg_writeops
[index
](core
, index
, val
);
3350 } else if (index
< E1000E_NREADOPS
&& e1000e_macreg_readops
[index
]) {
3351 trace_e1000e_wrn_regs_write_ro(index
<< 2, size
, val
);
3353 trace_e1000e_wrn_regs_write_unknown(index
<< 2, size
, val
);
3358 e1000e_core_read(E1000ECore
*core
, hwaddr addr
, unsigned size
)
3361 uint16_t index
= e1000e_get_reg_index_with_offset(mac_reg_access
, addr
);
3363 if (index
< E1000E_NREADOPS
&& e1000e_macreg_readops
[index
]) {
3364 if (mac_reg_access
[index
] & MAC_ACCESS_PARTIAL
) {
3365 trace_e1000e_wrn_regs_read_trivial(index
<< 2);
3367 val
= e1000e_macreg_readops
[index
](core
, index
);
3368 trace_e1000e_core_read(index
<< 2, size
, val
);
3371 trace_e1000e_wrn_regs_read_unknown(index
<< 2, size
);
3377 e1000e_autoneg_pause(E1000ECore
*core
)
3379 timer_del(core
->autoneg_timer
);
3383 e1000e_autoneg_resume(E1000ECore
*core
)
3385 if (e1000e_have_autoneg(core
) &&
3386 !(core
->phy
[0][MII_BMSR
] & MII_BMSR_AN_COMP
)) {
3387 qemu_get_queue(core
->owner_nic
)->link_down
= false;
3388 timer_mod(core
->autoneg_timer
,
3389 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 500);
3394 e1000e_vm_state_change(void *opaque
, bool running
, RunState state
)
3396 E1000ECore
*core
= opaque
;
3399 trace_e1000e_vm_state_running();
3400 e1000e_intrmgr_resume(core
);
3401 e1000e_autoneg_resume(core
);
3403 trace_e1000e_vm_state_stopped();
3404 e1000e_autoneg_pause(core
);
3405 e1000e_intrmgr_pause(core
);
3410 e1000e_core_pci_realize(E1000ECore
*core
,
3411 const uint16_t *eeprom_templ
,
3412 uint32_t eeprom_size
,
3413 const uint8_t *macaddr
)
3417 core
->autoneg_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
3418 e1000e_autoneg_timer
, core
);
3419 e1000e_intrmgr_pci_realize(core
);
3422 qemu_add_vm_change_state_handler(e1000e_vm_state_change
, core
);
3424 for (i
= 0; i
< E1000E_NUM_QUEUES
; i
++) {
3425 net_tx_pkt_init(&core
->tx
[i
].tx_pkt
, core
->owner
, E1000E_MAX_TX_FRAGS
);
3428 net_rx_pkt_init(&core
->rx_pkt
);
3430 e1000x_core_prepare_eeprom(core
->eeprom
,
3433 PCI_DEVICE_GET_CLASS(core
->owner
)->device_id
,
3435 e1000e_update_rx_offloads(core
);
3439 e1000e_core_pci_uninit(E1000ECore
*core
)
3443 timer_free(core
->autoneg_timer
);
3445 e1000e_intrmgr_pci_unint(core
);
3447 qemu_del_vm_change_state_handler(core
->vmstate
);
3449 for (i
= 0; i
< E1000E_NUM_QUEUES
; i
++) {
3450 net_tx_pkt_reset(core
->tx
[i
].tx_pkt
, core
->owner
);
3451 net_tx_pkt_uninit(core
->tx
[i
].tx_pkt
);
3454 net_rx_pkt_uninit(core
->rx_pkt
);
3457 static const uint16_t
3458 e1000e_phy_reg_init
[E1000E_PHY_PAGES
][E1000E_PHY_PAGE_SIZE
] = {
3460 [MII_BMCR
] = MII_BMCR_SPEED1000
|
3464 [MII_BMSR
] = MII_BMSR_EXTCAP
|
3474 [MII_PHYID1
] = 0x141,
3475 [MII_PHYID2
] = E1000_PHY_ID2_82574x
,
3476 [MII_ANAR
] = MII_ANAR_CSMACD
| MII_ANAR_10
|
3477 MII_ANAR_10FD
| MII_ANAR_TX
|
3478 MII_ANAR_TXFD
| MII_ANAR_PAUSE
|
3479 MII_ANAR_PAUSE_ASYM
,
3480 [MII_ANLPAR
] = MII_ANLPAR_10
| MII_ANLPAR_10FD
|
3481 MII_ANLPAR_TX
| MII_ANLPAR_TXFD
|
3482 MII_ANLPAR_T4
| MII_ANLPAR_PAUSE
,
3483 [MII_ANER
] = MII_ANER_NP
| MII_ANER_NWAY
,
3484 [MII_ANNP
] = 1 | MII_ANNP_MP
,
3485 [MII_CTRL1000
] = MII_CTRL1000_HALF
| MII_CTRL1000_FULL
|
3486 MII_CTRL1000_PORT
| MII_CTRL1000_MASTER
,
3487 [MII_STAT1000
] = MII_STAT1000_HALF
| MII_STAT1000_FULL
|
3488 MII_STAT1000_ROK
| MII_STAT1000_LOK
,
3489 [MII_EXTSTAT
] = MII_EXTSTAT_1000T_HD
| MII_EXTSTAT_1000T_FD
,
3491 [PHY_COPPER_CTRL1
] = BIT(5) | BIT(6) | BIT(8) | BIT(9) |
3493 [PHY_COPPER_STAT1
] = BIT(3) | BIT(10) | BIT(11) | BIT(13) | BIT(15)
3496 [PHY_MAC_CTRL1
] = BIT(3) | BIT(7),
3497 [PHY_MAC_CTRL2
] = BIT(1) | BIT(2) | BIT(6) | BIT(12)
3500 [PHY_LED_TIMER_CTRL
] = BIT(0) | BIT(2) | BIT(14)
3504 static const uint32_t e1000e_mac_reg_init
[] = {
3506 [LEDCTL
] = BIT(1) | BIT(8) | BIT(9) | BIT(15) | BIT(17) | BIT(18),
3507 [EXTCNF_CTRL
] = BIT(3),
3508 [EEMNGCTL
] = BIT(31),
3510 [FLSWCTL
] = BIT(30) | BIT(31),
3513 [RXDCTL1
] = BIT(16),
3514 [TIPG
] = 0x8 | (0x8 << 10) | (0x6 << 20),
3517 [CTRL
] = E1000_CTRL_FD
| E1000_CTRL_SWDPIN2
| E1000_CTRL_SWDPIN0
|
3518 E1000_CTRL_SPD_1000
| E1000_CTRL_SLU
|
3519 E1000_CTRL_ADVD3WUC
,
3520 [STATUS
] = E1000_STATUS_ASDV_1000
| E1000_STATUS_LU
,
3521 [PSRCTL
] = (2 << E1000_PSRCTL_BSIZE0_SHIFT
) |
3522 (4 << E1000_PSRCTL_BSIZE1_SHIFT
) |
3523 (4 << E1000_PSRCTL_BSIZE2_SHIFT
),
3524 [TARC0
] = 0x3 | E1000_TARC_ENABLE
,
3525 [TARC1
] = 0x3 | E1000_TARC_ENABLE
,
3526 [EECD
] = E1000_EECD_AUTO_RD
| E1000_EECD_PRES
,
3527 [EERD
] = E1000_EERW_DONE
,
3528 [EEWR
] = E1000_EERW_DONE
,
3529 [GCR
] = E1000_L0S_ADJUST
|
3530 E1000_L1_ENTRY_LATENCY_MSB
|
3531 E1000_L1_ENTRY_LATENCY_LSB
,
3538 [MANC
] = E1000_MANC_DIS_IP_CHK_ARP
,
3539 [FACTPS
] = E1000_FACTPS_LAN0_ON
| 0x20000000,
3541 [RXCSUM
] = E1000_RXCSUM_IPOFLD
| E1000_RXCSUM_TUOFLD
,
3542 [ITR
] = E1000E_MIN_XITR
,
3543 [EITR
...EITR
+ E1000E_MSIX_VEC_NUM
- 1] = E1000E_MIN_XITR
,
3546 static void e1000e_reset(E1000ECore
*core
, bool sw
)
3550 timer_del(core
->autoneg_timer
);
3552 e1000e_intrmgr_reset(core
);
3554 memset(core
->phy
, 0, sizeof core
->phy
);
3555 memcpy(core
->phy
, e1000e_phy_reg_init
, sizeof e1000e_phy_reg_init
);
3557 for (i
= 0; i
< E1000E_MAC_SIZE
; i
++) {
3558 if (sw
&& (i
== PBA
|| i
== PBS
|| i
== FLA
)) {
3562 core
->mac
[i
] = i
< ARRAY_SIZE(e1000e_mac_reg_init
) ?
3563 e1000e_mac_reg_init
[i
] : 0;
3566 core
->rxbuf_min_shift
= 1 + E1000_RING_DESC_LEN_SHIFT
;
3568 if (qemu_get_queue(core
->owner_nic
)->link_down
) {
3569 e1000e_link_down(core
);
3572 e1000x_reset_mac_addr(core
->owner_nic
, core
->mac
, core
->permanent_mac
);
3574 for (i
= 0; i
< ARRAY_SIZE(core
->tx
); i
++) {
3575 net_tx_pkt_reset(core
->tx
[i
].tx_pkt
, core
->owner
);
3576 memset(&core
->tx
[i
].props
, 0, sizeof(core
->tx
[i
].props
));
3577 core
->tx
[i
].skip_cp
= false;
3582 e1000e_core_reset(E1000ECore
*core
)
3584 e1000e_reset(core
, false);
3587 void e1000e_core_pre_save(E1000ECore
*core
)
3590 NetClientState
*nc
= qemu_get_queue(core
->owner_nic
);
3593 * If link is down and auto-negotiation is supported and ongoing,
3594 * complete auto-negotiation immediately. This allows us to look
3595 * at MII_BMSR_AN_COMP to infer link status on load.
3597 if (nc
->link_down
&& e1000e_have_autoneg(core
)) {
3598 core
->phy
[0][MII_BMSR
] |= MII_BMSR_AN_COMP
;
3599 e1000e_update_flowctl_status(core
);
3602 for (i
= 0; i
< ARRAY_SIZE(core
->tx
); i
++) {
3603 if (net_tx_pkt_has_fragments(core
->tx
[i
].tx_pkt
)) {
3604 core
->tx
[i
].skip_cp
= true;
3610 e1000e_core_post_load(E1000ECore
*core
)
3612 NetClientState
*nc
= qemu_get_queue(core
->owner_nic
);
3615 * nc.link_down can't be migrated, so infer link_down according
3616 * to link status bit in core.mac[STATUS].
3618 nc
->link_down
= (core
->mac
[STATUS
] & E1000_STATUS_LU
) == 0;