From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dor Laor Subject: [PATCH] e1000 emulation code Date: Wed, 09 Jan 2008 18:42:55 +0200 Message-ID: <1199896975.4382.31.camel@localhost.localdomain> Reply-To: dor.laor-atKUWr5tajBWk0Htik3J/w@public.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-5wa1yskDoUb8y2LUJkZE" Cc: ir Peleg To: qemu-devel , kvm-devel Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: kvm-devel-bounces-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f@public.gmane.org Errors-To: kvm-devel-bounces-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f@public.gmane.org List-Id: kvm.vger.kernel.org --=-5wa1yskDoUb8y2LUJkZE Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable It which supports TCP/UDP and IP transmit checksum, as well as TSO. It has been tested with Linux (2.6.18|22|23|24)++ and Windows XP (using the driver supplied at the intel download site). Windows Vista recognizes it but there is no traffic. Checksum calculation is currently na=C3=AFve and unoptimized (the host kernel does it better). But when working in conjuction to tso the performance is drastically better. Some figures: Linux rx 350Mbps, tx 150bps, Windows rx 700mbps, tx 100 mbp= s. The e1000_hw.h is copied from Linux kernel. Also attached is the pxe boot option rom that works with netboot. Signed-off-by: Dor Laor Signed-off-by: Nir Peleg --- qemu/Makefile.target | 1 + qemu/hw/e1000.c | 1000 +++++++++++++++ qemu/hw/e1000_hw.h | 3411 ++++++++++++++++++++++++++++++++++++++++++++= ++++++ qemu/hw/pci.c | 2 + qemu/hw/pci.h | 4 + 5 files changed, 4418 insertions(+), 0 deletions(-) create mode 100644 qemu/hw/e1000.c create mode 100644 qemu/hw/e1000_hw.h diff --git a/qemu/Makefile.target b/qemu/Makefile.target index bb7be0f..a39662c 100644 --- a/qemu/Makefile.target +++ b/qemu/Makefile.target @@ -459,6 +459,7 @@ VL_OBJS +=3D eepro100.o VL_OBJS +=3D ne2000.o VL_OBJS +=3D pcnet.o VL_OBJS +=3D rtl8139.o +VL_OBJS +=3D e1000.o =20 # PCI Hypercall VL_OBJS+=3D hypercall.o diff --git a/qemu/hw/e1000.c b/qemu/hw/e1000.c new file mode 100644 index 0000000..83428ca --- /dev/null +++ b/qemu/hw/e1000.c @@ -0,0 +1,1000 @@ +/* + * QEMU e1000 emulation + * + * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc. + * Based on work done by: + * Copyright (c) 2007 Dan Aloni + * Copyright (c) 2004 Antony T Curtis + * + * Permission is hereby granted, free of charge, to any person obtaining= a copy + * of this software and associated documentation files (the "Software"),= to deal + * in the Software without restriction, including without limitation the= rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or = sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be includ= ed in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRE= SS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI= TY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHA= LL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR = OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISI= NG FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALING= S IN + * THE SOFTWARE. + */ + + +#include "hw.h" +#include "pci.h" +#include "net.h" + +#define __iomem +typedef int boolean_t; +#include "e1000_hw.h" + +#define DEBUG + +#ifdef DEBUG +enum { + DEBUG_GENERAL, DEBUG_IO, DEBUG_MMIO, DEBUG_INTERRUPT, + DEBUG_RX, DEBUG_TX, DEBUG_MDIC, DEBUG_EEPROM, + DEBUG_UNKNOWN, DEBUG_TXSUM, DEBUG_TXERR, DEBUG_RXERR, + DEBUG_RXFILTER, DEBUG_NOTYET, +}; +#define DBGBIT(x) (1<>2) +enum { + defreg(CTRL), defreg(EECD), defreg(EERD), defreg(GPRC), + defreg(GPTC), defreg(ICR), defreg(ICS), defreg(IMC), + defreg(IMS), defreg(LEDCTL), defreg(MANC), defreg(MDIC), + defreg(MPC), defreg(PBA), defreg(RCTL), defreg(RDBAH), + defreg(RDBAL), defreg(RDH), defreg(RDLEN), defreg(RDT), + defreg(STATUS), defreg(SWSM), defreg(TCTL), defreg(TDBAH), + defreg(TDBAL), defreg(TDH), defreg(TDLEN), defreg(TDT), + defreg(TORH), defreg(TORL), defreg(TOTH), defreg(TOTL), + defreg(TPR), defreg(TPT), defreg(TXDCTL), defreg(WUFC), + defreg(RA), defreg(MTA), defreg(CRCERRS), +}; + +enum { PHY_R =3D 1, PHY_W =3D 2, PHY_RW =3D PHY_R | PHY_W }; +static char phy_regcap[0x20] =3D { + [PHY_STATUS] =3D PHY_R, [M88E1000_EXT_PHY_SPEC_CTRL] =3D PHY_RW, + [PHY_ID1] =3D PHY_R, [M88E1000_PHY_SPEC_CTRL] =3D PHY_RW, + [PHY_CTRL] =3D PHY_RW, [PHY_1000T_CTRL] =3D PHY_RW, + [PHY_LP_ABILITY] =3D PHY_R, [PHY_1000T_STATUS] =3D PHY_R, + [PHY_AUTONEG_ADV] =3D PHY_RW, [M88E1000_RX_ERR_CNTR] =3D PHY_R, + [PHY_ID2] =3D PHY_R, +}; + +static void +ioport_map(PCIDevice *pci_dev, int region_num, uint32_t addr, + uint32_t size, int type) +{ + DBGOUT(IO, "e1000_ioport_map addr=3D0x%04x size=3D0x%08x\n", addr, size= ); +} + +static void +set_interrupt_cause(E1000State *s, int index, uint32_t val) +{ + if (val) + val |=3D E1000_ICR_INT_ASSERTED; + s->mac_reg[ICR] =3D val; + qemu_set_irq(s->dev.irq[0], (s->mac_reg[IMS] & s->mac_reg[ICR]) !=3D 0)= ; +} + +static void +set_ics(E1000State *s, int index, uint32_t val) +{ + DBGOUT(INTERRUPT, "set_ics %x, ICR %x, IMR %x\n", val, s->mac_reg[ICR], + s->mac_reg[IMS]); + set_interrupt_cause(s, 0, val | s->mac_reg[ICR]); +} + +static int +rxbufsize(uint32_t v) +{ + v &=3D E1000_RCTL_BSEX | E1000_RCTL_SZ_16384 | E1000_RCTL_SZ_8192 | + E1000_RCTL_SZ_4096 | E1000_RCTL_SZ_2048 | E1000_RCTL_SZ_1024 | + E1000_RCTL_SZ_512 | E1000_RCTL_SZ_256; + switch (v) { + case E1000_RCTL_BSEX | E1000_RCTL_SZ_16384: + return 16384; + case E1000_RCTL_BSEX | E1000_RCTL_SZ_8192: + return 8192; + case E1000_RCTL_BSEX | E1000_RCTL_SZ_4096: + return 4096; + case E1000_RCTL_SZ_1024: + return 1024; + case E1000_RCTL_SZ_512: + return 512; + case E1000_RCTL_SZ_256: + return 256; + } + return 2048; +} + +static void +set_rx_control(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[RCTL] =3D val; + s->rxbuf_size =3D rxbufsize(val); + s->rxbuf_min_shift =3D ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1; + DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] =3D 0x%x\n", s->mac_reg[RDT], + s->mac_reg[RCTL]); +} + +static void +set_mdic(E1000State *s, int index, uint32_t val) +{ + uint32_t data =3D val & E1000_MDIC_DATA_MASK; + uint32_t addr =3D ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT)= ; + + if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT !=3D 1) // phy = # + val =3D s->mac_reg[MDIC] | E1000_MDIC_ERROR; + else if (val & E1000_MDIC_OP_READ) { + DBGOUT(MDIC, "MDIC read reg 0x%x\n", addr); + if (!(phy_regcap[addr] & PHY_R)) { + DBGOUT(MDIC, "MDIC read reg %x unhandled\n", addr); + val |=3D E1000_MDIC_ERROR; + } else + val =3D (val ^ data) | s->phy_reg[addr]; + } else if (val & E1000_MDIC_OP_WRITE) { + DBGOUT(MDIC, "MDIC write reg 0x%x, value 0x%x\n", addr, data); + if (!(phy_regcap[addr] & PHY_W)) { + DBGOUT(MDIC, "MDIC write reg %x unhandled\n", addr); + val |=3D E1000_MDIC_ERROR; + } else + s->phy_reg[addr] =3D data; + } + s->mac_reg[MDIC] =3D val | E1000_MDIC_READY; + set_ics(s, 0, E1000_ICR_MDAC); +} + +static uint32_t +get_eecd(E1000State *s, int index) +{ + uint32_t ret =3D E1000_EECD_PRES|E1000_EECD_GNT | s->eecd_state.old_eec= d; + + DBGOUT(EEPROM, "reading eeprom bit %d (reading %d)\n", + s->eecd_state.bitnum_out, s->eecd_state.reading); + if (!s->eecd_state.reading || + ((s->eeprom_data[(s->eecd_state.bitnum_out >> 4) & 0x3f] >> + (s->eecd_state.bitnum_out & 0xf ^ 0xf))) & 1) + ret |=3D E1000_EECD_DO; + return ret; +} + +static void +set_eecd(E1000State *s, int index, uint32_t val) +{ + uint32_t oldval =3D s->eecd_state.old_eecd; + + s->eecd_state.old_eecd =3D val & (E1000_EECD_SK | E1000_EECD_CS | + E1000_EECD_DI|E1000_EECD_FWE_MASK|E1000_EECD_REQ); + if (!(E1000_EECD_SK & (val ^ oldval))) // no clock edge + return; + if (!(E1000_EECD_SK & val)) { // falling edge + s->eecd_state.bitnum_out++; + return; + } + if (!(val & E1000_EECD_CS)) { // rising, no CS (EEPROM reset) + memset(&s->eecd_state, 0, sizeof s->eecd_state); + return; + } + s->eecd_state.val_in <<=3D 1; + if (val & E1000_EECD_DI) + s->eecd_state.val_in |=3D 1; + if (++s->eecd_state.bitnum_in =3D=3D 9 && !s->eecd_state.reading) { + s->eecd_state.bitnum_out =3D ((s->eecd_state.val_in & 0x3f)<<4)-1; + s->eecd_state.reading =3D (((s->eecd_state.val_in >> 6) & 7) =3D=3D + EEPROM_READ_OPCODE_MICROWIRE); + } + DBGOUT(EEPROM, "eeprom bitnum in %d out %d, reading %d\n", + s->eecd_state.bitnum_in, s->eecd_state.bitnum_out, + s->eecd_state.reading); +} + +static uint32_t +flash_eerd_read(E1000State *s, int x) +{ + unsigned int index, r =3D s->mac_reg[EERD] & ~E1000_EEPROM_RW_REG_START= ; + + if ((index =3D r >> E1000_EEPROM_RW_ADDR_SHIFT) > EEPROM_CHECKSUM_REG) + return 0; + return (s->eeprom_data[index] << E1000_EEPROM_RW_REG_DATA) | + E1000_EEPROM_RW_REG_DONE | r; +} + +static unsigned int +do_cksum(uint8_t *dp, uint8_t *de) +{ + unsigned int bsum[2] =3D {0, 0}, i, sum; + + for (i =3D 1; dp < de; bsum[i^=3D1] +=3D *dp++) + ; + sum =3D (bsum[0] << 8) + bsum[1]; + sum =3D (sum >> 16) + (sum & 0xffff); + return ~(sum + (sum >> 16)); +} + +static void +putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t = cse) +{ + if (cse && cse < n) + n =3D cse + 1; + if (sloc < n-1) + cpu_to_be16wu((uint16_t *)(data + sloc), + do_cksum(data + css, data + n)); +} + +static void +xmit_seg(E1000State *s) +{ + uint16_t len, *sp; + unsigned int frames =3D s->tx.tso_frames, css, sofar, n; + struct e1000_tx *tp =3D &s->tx; + + if (tp->tse) { + css =3D tp->ipcss; + DBGOUT(TXSUM, "frames %d size %d ipcss %d\n", + frames, tp->size, css); + if (tp->ip) { // IPv4 + cpu_to_be16wu((uint16_t *)(tp->data+css+2), + tp->size - css); + cpu_to_be16wu((uint16_t *)(tp->data+css+4), + be16_to_cpup((uint16_t *)(tp->data+css+4))+frames); + } else // IPv6 + cpu_to_be16wu((uint16_t *)(tp->data+css+4), + tp->size - css); + css =3D tp->tucss; + len =3D tp->size - css; + DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", tp->tcp, css, len); + if (tp->tcp) { + sofar =3D frames * tp->mss; + cpu_to_be32wu((uint32_t *)(tp->data+css+4), // seq + be32_to_cpup((uint32_t *)(tp->data+css+4))+sofar); + if (tp->paylen - sofar > tp->mss) + tp->data[css + 13] &=3D ~9; // PSH, FIN + } else // UDP + cpu_to_be16wu((uint16_t *)(tp->data+css+4), len); + if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { + // add pseudo-header length before checksum calculation + sp =3D (uint16_t *)(tp->data + tp->tucso); + cpu_to_be16wu(sp, be16_to_cpup(sp) + len); + } + tp->tso_frames++; + } + + if (tp->sum_needed & E1000_TXD_POPTS_TXSM) + putsum(tp->data, tp->size, tp->tucso, tp->tucss, tp->tucse); + if (tp->sum_needed & E1000_TXD_POPTS_IXSM) + putsum(tp->data, tp->size, tp->ipcso, tp->ipcss, tp->ipcse); + qemu_send_packet(s->vc, tp->data, tp->size); + s->mac_reg[TPT]++; + s->mac_reg[GPTC]++; + n =3D s->mac_reg[TOTL]; + if ((s->mac_reg[TOTL] +=3D s->tx.size) < n) + s->mac_reg[TOTH]++; +} + +static void +process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) +{ + uint32_t txd_lower =3D le32_to_cpu(dp->lower.data); + uint32_t dtype =3D txd_lower & (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D); + unsigned int split_size =3D txd_lower & 0xffff, bytes, sz, op; + unsigned int msh =3D 0xfffff, hdr =3D 0; + uint64_t addr; + struct e1000_context_desc *xp =3D (struct e1000_context_desc *)dp; + struct e1000_tx *tp =3D &s->tx; + + if (dtype =3D=3D E1000_TXD_CMD_DEXT) { // context descriptor + op =3D le32_to_cpu(xp->cmd_and_length); + tp->ipcss =3D xp->lower_setup.ip_fields.ipcss; + tp->ipcso =3D xp->lower_setup.ip_fields.ipcso; + tp->ipcse =3D le16_to_cpu(xp->lower_setup.ip_fields.ipcse); + tp->tucss =3D xp->upper_setup.tcp_fields.tucss; + tp->tucso =3D xp->upper_setup.tcp_fields.tucso; + tp->tucse =3D le16_to_cpu(xp->upper_setup.tcp_fields.tucse); + tp->paylen =3D op & 0xfffff; + tp->hdr_len =3D xp->tcp_seg_setup.fields.hdr_len; + tp->mss =3D le16_to_cpu(xp->tcp_seg_setup.fields.mss); + tp->ip =3D (op & E1000_TXD_CMD_IP) ? 1 : 0; + tp->tcp =3D (op & E1000_TXD_CMD_TCP) ? 1 : 0; + tp->tse =3D (op & E1000_TXD_CMD_TSE) ? 1 : 0; + tp->tso_frames =3D 0; + if (tp->tucso =3D=3D 0) { // this is probably wrong + DBGOUT(TXSUM, "TCP/UDP: cso 0!\n"); + tp->tucso =3D tp->tucss + (tp->tcp ? 16 : 6); + } + return; + } else if (dtype =3D=3D (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) + tp->sum_needed =3D le32_to_cpu(dp->upper.data) >> 8; + + addr =3D le64_to_cpu(dp->buffer_addr); + if (tp->tse) { + hdr =3D tp->hdr_len; + msh =3D hdr + tp->mss; + } + do { + bytes =3D split_size; + if (tp->size + bytes > msh) + bytes =3D msh - tp->size; + cpu_physical_memory_read(addr, tp->data + tp->size, bytes); + if ((sz =3D tp->size + bytes) >=3D hdr && tp->size < hdr) + memmove(tp->header, tp->data, hdr); + tp->size =3D sz; + addr +=3D bytes; + if (sz =3D=3D msh) { + xmit_seg(s); + memmove(tp->data, tp->header, hdr); + tp->size =3D hdr; + } + } while (split_size -=3D bytes); + + if (!(txd_lower & E1000_TXD_CMD_EOP)) + return; + if (tp->size > hdr) + xmit_seg(s); + tp->tso_frames =3D 0; + tp->sum_needed =3D 0; + tp->size =3D 0; +} + +static uint32_t +txdesc_writeback(target_phys_addr_t base, struct e1000_tx_desc *dp) +{ + uint32_t txd_upper, txd_lower =3D le32_to_cpu(dp->lower.data); + + if (!(txd_lower & (E1000_TXD_CMD_RS|E1000_TXD_CMD_RPS))) + return 0; + txd_upper =3D (le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD) & + ~(E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | E1000_TXD_STAT_TU); + dp->upper.data =3D cpu_to_le32(txd_upper); + cpu_physical_memory_write(base + ((char *)&dp->upper - (char *)dp), + (void *)&dp->upper, sizeof(dp->upper)); + return E1000_ICR_TXDW; +} + +static void +start_xmit(E1000State *s) +{ + target_phys_addr_t base; + struct e1000_tx_desc desc; + uint32_t tdh_start =3D s->mac_reg[TDH], cause =3D E1000_ICS_TXQE; + + if (!(s->mac_reg[TCTL] & E1000_TCTL_EN)) { + DBGOUT(TX, "tx disabled\n"); + return; + } + + while (s->mac_reg[TDH] !=3D s->mac_reg[TDT]) { + base =3D ((uint64_t)s->mac_reg[TDBAH] << 32) + s->mac_reg[TDBAL] + + sizeof(struct e1000_tx_desc) * s->mac_reg[TDH]; + cpu_physical_memory_read(base, (void *)&desc, sizeof(desc)); + + DBGOUT(TX, "index %d: %p : %x %x\n", s->mac_reg[TDH], + (void *)desc.buffer_addr, desc.lower.data, + desc.upper.data); + + process_tx_desc(s, &desc); + cause |=3D txdesc_writeback(base, &desc); + + if (++s->mac_reg[TDH] * sizeof(desc) >=3D s->mac_reg[TDLEN]) + s->mac_reg[TDH] =3D 0; + /* + * the following could happen only if guest sw assigns + * bogus values to TDT/TDLEN. + * there's nothing too intelligent we could do about this. + */ + if (s->mac_reg[TDH] =3D=3D tdh_start) { + DBGOUT(TXERR, "TDH wraparound @%x, TDT %x, TDLEN %x\n", + tdh_start, s->mac_reg[TDT], s->mac_reg[TDLEN]); + break; + } + } + set_ics(s, 0, cause); +} + +static int +receive_filter(E1000State *s, const uint8_t *buf, int size) +{ + static uint8_t bcast[] =3D {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; + static int mta_shift[] =3D {4, 3, 2, 0}; + uint32_t f, rctl =3D s->mac_reg[RCTL], ra[2], *rp; + + if (rctl & E1000_RCTL_UPE) // promiscuous + return 1; + + if ((buf[0] & 1) && (rctl & E1000_RCTL_MPE)) // promiscuous mcast + return 1; + + if ((rctl & E1000_RCTL_BAM) && !memcmp(buf, bcast, sizeof bcast)) + return 1; + + for (rp =3D s->mac_reg + RA; rp < s->mac_reg + RA + 32; rp +=3D 2) { + if (!(rp[1] & E1000_RAH_AV)) + continue; + ra[0] =3D cpu_to_le32(rp[0]); + ra[1] =3D cpu_to_le32(rp[1]); + if (!memcmp(buf, (uint8_t *)ra, 6)) { + DBGOUT(RXFILTER, + "unicast match[%d]: %02x:%02x:%02x:%02x:%02x:%02x\n", + (int)(rp - s->mac_reg - RA)/2, + buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]); + return 1; + } + } + DBGOUT(RXFILTER, "unicast mismatch: %02x:%02x:%02x:%02x:%02x:%02x\n", + buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]); + + f =3D mta_shift[(rctl >> E1000_RCTL_MO_SHIFT) & 3]; + f =3D (((buf[5] << 8) | buf[4]) >> f) & 0xfff; + if (s->mac_reg[MTA + (f >> 5)] & (1 << (f & 0x1f))) + return 1; + DBGOUT(RXFILTER, + "dropping, inexact filter mismatch: %02x:%02x:%02x:%02x:%02x:%02x MO %= d MTA[%d] %x\n", + buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], + (rctl >> E1000_RCTL_MO_SHIFT) & 3, f >> 5, + s->mac_reg[MTA + (f >> 5)]); + + return 0; +} + +static int +e1000_can_receive(void *opaque) +{ + E1000State *s =3D opaque; + + return (!(s->mac_reg[RCTL] & E1000_RCTL_EN) || + s->mac_reg[RDH] !=3D s->mac_reg[RDT]); +} + +static void +e1000_receive(void *opaque, const uint8_t *buf, int size) +{ + E1000State *s =3D opaque; + struct e1000_rx_desc desc; + target_phys_addr_t base; + unsigned int n, rdt; + uint32_t rdh_start; + + if (!(s->mac_reg[RCTL] & E1000_RCTL_EN)) + return; + + if (size > s->rxbuf_size) { + DBGOUT(RX, "packet too large for buffers (%d > %d)\n", size, + s->rxbuf_size); + return; + } + + if (!receive_filter(s, buf, size)) + return; + + rdh_start =3D s->mac_reg[RDH]; + size +=3D 4; // for the header + do { + if (s->mac_reg[RDH] =3D=3D s->mac_reg[RDT] && s->check_rxov) { + set_ics(s, 0, E1000_ICS_RXO); + return; + } + base =3D ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] + + sizeof(desc) * s->mac_reg[RDH]; + cpu_physical_memory_read(base, (void *)&desc, sizeof(desc)); + desc.status |=3D E1000_RXD_STAT_DD; + if (desc.buffer_addr) { + cpu_physical_memory_write(le64_to_cpu(desc.buffer_addr), + (void *)buf, size); + desc.length =3D cpu_to_le16(size); + desc.status |=3D E1000_RXD_STAT_EOP|E1000_RXD_STAT_IXSM; + } else // as per intel docs; skip descriptors with null buf addr + DBGOUT(RX, "Null RX descriptor!!\n"); + cpu_physical_memory_write(base, (void *)&desc, sizeof(desc)); + + if (++s->mac_reg[RDH] * sizeof(desc) >=3D s->mac_reg[RDLEN]) + s->mac_reg[RDH] =3D 0; + s->check_rxov =3D 1; + /* see comment in start_xmit; same here */ + if (s->mac_reg[RDH] =3D=3D rdh_start) { + DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n", + rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]); + set_ics(s, 0, E1000_ICS_RXO); + return; + } + } while (desc.buffer_addr =3D=3D 0); + + s->mac_reg[GPRC]++; + s->mac_reg[TPR]++; + n =3D s->mac_reg[TORL]; + if ((s->mac_reg[TORL] +=3D size) < n) + s->mac_reg[TORH]++; + + n =3D E1000_ICS_RXT0; + if ((rdt =3D s->mac_reg[RDT]) < s->mac_reg[RDH]) + rdt +=3D s->mac_reg[RDLEN] / sizeof(desc); + if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) << s->rxbuf_min_shift >=3D + s->mac_reg[RDLEN]) + n |=3D E1000_ICS_RXDMT0; + + set_ics(s, 0, n); +} + +static uint32_t +mac_readreg(E1000State *s, int index) +{ + return s->mac_reg[index]; +} + +static uint32_t +mac_icr_read(E1000State *s, int index) +{ + uint32_t ret =3D s->mac_reg[ICR]; + + DBGOUT(INTERRUPT, "ICR read: %x\n", ret); + set_interrupt_cause(s, 0, 0); + return ret; +} + +static uint32_t +mac_read_clr4(E1000State *s, int index) +{ + uint32_t ret =3D s->mac_reg[index]; + + s->mac_reg[index] =3D 0; + return ret; +} + +static uint32_t +mac_read_clr8(E1000State *s, int index) +{ + uint32_t ret =3D s->mac_reg[index]; + + s->mac_reg[index] =3D 0; + s->mac_reg[index-1] =3D 0; + return ret; +} + +static void +mac_writereg(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[index] =3D val; +} + +static void +set_rdt(E1000State *s, int index, uint32_t val) +{ + s->check_rxov =3D 0; + s->mac_reg[index] =3D val & 0xffff; +} + +static void +set_16bit(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[index] =3D val & 0xffff; +} + +static void +set_dlen(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[index] =3D val & 0xfff80; +} + +static void +set_tctl(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[index] =3D val; + s->mac_reg[TDT] &=3D 0xffff; + start_xmit(s); +} + +static void +set_icr(E1000State *s, int index, uint32_t val) +{ + DBGOUT(INTERRUPT, "set_icr %x\n", val); + set_interrupt_cause(s, 0, s->mac_reg[ICR] & ~val); +} + +static void +set_imc(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[IMS] &=3D ~val; + set_ics(s, 0, 0); +} + +static void +set_ims(E1000State *s, int index, uint32_t val) +{ + s->mac_reg[IMS] |=3D val; + set_ics(s, 0, 0); +} + +#define getreg(x) [x] =3D mac_readreg +static uint32_t (*macreg_readops[])(E1000State *, int) =3D { + getreg(PBA), getreg(RCTL), getreg(TDH), getreg(TXDCTL), + getreg(WUFC), getreg(TDT), getreg(CTRL), getreg(LEDCTL), + getreg(MANC), getreg(MDIC), getreg(SWSM), getreg(STATUS), + getreg(TORL), getreg(TOTL), getreg(IMS), getreg(TCTL), + getreg(RDH), getreg(RDT), + [TOTH] =3D mac_read_clr8, [TORH] =3D mac_read_clr8, [GPRC] =3D mac_read= _clr4, + [GPTC] =3D mac_read_clr4, [TPR] =3D mac_read_clr4, [TPT] =3D mac_read_c= lr4, + [ICR] =3D mac_icr_read, [EECD] =3D get_eecd, [EERD] =3D flash_eerd_read= , + [CRCERRS ... MPC] =3D &mac_readreg, + [RA ... RA+31] =3D &mac_readreg, + [MTA ... MTA+127] =3D &mac_readreg, +}; +enum {NREADOPS =3D sizeof(macreg_readops) / sizeof(*macreg_readops)}; + +#define putreg(x) [x] =3D mac_writereg +static void (*macreg_writeops[])(E1000State *, int, uint32_t) =3D { + putreg(PBA), putreg(EERD), putreg(SWSM), putreg(WUFC), + putreg(TDBAL), putreg(TDBAH), putreg(TXDCTL), putreg(RDBAH), + putreg(RDBAL), putreg(LEDCTL), + [TDLEN] =3D set_dlen, [RDLEN] =3D set_dlen, [TCTL] =3D set_tctl, + [TDT] =3D set_tctl, [MDIC] =3D set_mdic, [ICS] =3D set_ics, + [TDH] =3D set_16bit, [RDH] =3D set_16bit, [RDT] =3D set_rdt, + [IMC] =3D set_imc, [IMS] =3D set_ims, [ICR] =3D set_icr, + [EECD] =3D set_eecd, [RCTL] =3D set_rx_control, + [RA ... RA+31] =3D &mac_writereg, + [MTA ... MTA+127] =3D &mac_writereg, +}; +enum {NWRITEOPS =3D sizeof(macreg_writeops) / sizeof(*macreg_writeops)}; + +static void +e1000_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val) +{ + E1000State *s =3D opaque; + unsigned int index =3D ((addr - s->mmio_base) & 0x1ffff) >> 2; + + if (index < NWRITEOPS && macreg_writeops[index]) + macreg_writeops[index](s, index, le32_to_cpu(val)); + else if (index < NREADOPS && macreg_readops[index]) + DBGOUT(MMIO, "e1000_mmio_writel RO %x: 0x%04x\n", index<<2, val); + else + DBGOUT(UNKNOWN, "MMIO unknown write addr=3D0x%08x,val=3D0x%08x\n", + index<<2, val); +} + +static void +e1000_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val) +{ + // emulate hw without byte enables: no RMW + e1000_mmio_writel(opaque, addr & ~3, + cpu_to_le32(le16_to_cpu(val & 0xffff) << (8*(addr & 3)))); +} + +static void +e1000_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val) +{ + // emulate hw without byte enables: no RMW + e1000_mmio_writel(opaque, addr & ~3, + cpu_to_le32((val & 0xff) << (8*(addr & 3)))); +} + +static uint32_t +e1000_mmio_readl(void *opaque, target_phys_addr_t addr) +{ + E1000State *s =3D opaque; + unsigned int index =3D ((addr - s->mmio_base) & 0x1ffff) >> 2; + + if (index < NREADOPS && macreg_readops[index]) + return cpu_to_le32(macreg_readops[index](s, index)); + DBGOUT(UNKNOWN, "MMIO unknown read addr=3D0x%08x\n", index<<2); + return 0; +} + +static uint32_t +e1000_mmio_readb(void *opaque, target_phys_addr_t addr) +{ + return (le32_to_cpu(e1000_mmio_readl(opaque, addr & ~3)) >> + (8 * (addr & 3))) & 0xff; +} + +static uint32_t +e1000_mmio_readw(void *opaque, target_phys_addr_t addr) +{ + return cpu_to_le16((le32_to_cpu(e1000_mmio_readl(opaque, addr & ~3)) >> + (8 * (addr & 3))) & 0xffff); +} + +int mac_regtosave[] =3D { + CTRL, EECD, EERD, GPRC, GPTC, ICR, ICS, IMC, IMS, + LEDCTL, MANC, MDIC, MPC, PBA, RCTL, RDBAH, RDBAL, RDH, + RDLEN, RDT, STATUS, SWSM, TCTL, TDBAH, TDBAL, TDH, TDLEN, + TDT, TORH, TORL, TOTH, TOTL, TPR, TPT, TXDCTL, WUFC, +}; +enum { MAC_NSAVE =3D sizeof mac_regtosave/sizeof *mac_regtosave }; + +struct { + int size; + int array0; +} mac_regarraystosave[] =3D { {32, RA}, {128, MTA} }; +enum { MAC_NARRAYS =3D sizeof mac_regarraystosave/sizeof *mac_regarrayst= osave }; + +static void +nic_save(QEMUFile *f, void *opaque) +{ + E1000State *s =3D (E1000State *)opaque; + int i, j; + + pci_device_save(&s->dev, f); + qemu_put_be32s(f, &s->instance); + qemu_put_be32s(f, &s->mmio_base); + qemu_put_be32s(f, &s->rxbuf_size); + qemu_put_be32s(f, &s->rxbuf_min_shift); + qemu_put_be32s(f, &s->eecd_state.val_in); + qemu_put_be16s(f, &s->eecd_state.bitnum_in); + qemu_put_be16s(f, &s->eecd_state.bitnum_out); + qemu_put_be16s(f, &s->eecd_state.reading); + qemu_put_be32s(f, &s->eecd_state.old_eecd); + qemu_put_8s(f, &s->tx.ipcss); + qemu_put_8s(f, &s->tx.ipcso); + qemu_put_be16s(f, &s->tx.ipcse); + qemu_put_8s(f, &s->tx.tucss); + qemu_put_8s(f, &s->tx.tucso); + qemu_put_be16s(f, &s->tx.tucse); + qemu_put_be32s(f, &s->tx.paylen); + qemu_put_8s(f, &s->tx.hdr_len); + qemu_put_be16s(f, &s->tx.mss); + qemu_put_be16s(f, &s->tx.size); + qemu_put_be16s(f, &s->tx.tso_frames); + qemu_put_8s(f, &s->tx.sum_needed); + qemu_put_8s(f, &s->tx.ip); + qemu_put_8s(f, &s->tx.tcp); + qemu_put_buffer(f, s->tx.header, sizeof s->tx.header); + qemu_put_buffer(f, s->tx.data, sizeof s->tx.data); + for (i =3D 0; i < 64; i++) + qemu_put_be16s(f, s->eeprom_data + i); + for (i =3D 0; i < 0x20; i++) + qemu_put_be16s(f, s->phy_reg + i); + for (i =3D 0; i < MAC_NSAVE; i++) + qemu_put_be32s(f, s->mac_reg + mac_regtosave[i]); + for (i =3D 0; i < MAC_NARRAYS; i++) + for (j =3D 0; j < mac_regarraystosave[i].size; j++) + qemu_put_be32s(f, + s->mac_reg + mac_regarraystosave[i].array0 + j); +} + +static int +nic_load(QEMUFile *f, void *opaque, int version_id) +{ + E1000State *s =3D (E1000State *)opaque; + int i, j, ret; + + if ((ret =3D pci_device_load(&s->dev, f)) < 0) + return ret; + qemu_get_be32s(f, &s->instance); + qemu_get_be32s(f, &s->mmio_base); + qemu_get_be32s(f, &s->rxbuf_size); + qemu_get_be32s(f, &s->rxbuf_min_shift); + qemu_get_be32s(f, &s->eecd_state.val_in); + qemu_get_be16s(f, &s->eecd_state.bitnum_in); + qemu_get_be16s(f, &s->eecd_state.bitnum_out); + qemu_get_be16s(f, &s->eecd_state.reading); + qemu_get_be32s(f, &s->eecd_state.old_eecd); + qemu_get_8s(f, &s->tx.ipcss); + qemu_get_8s(f, &s->tx.ipcso); + qemu_get_be16s(f, &s->tx.ipcse); + qemu_get_8s(f, &s->tx.tucss); + qemu_get_8s(f, &s->tx.tucso); + qemu_get_be16s(f, &s->tx.tucse); + qemu_get_be32s(f, &s->tx.paylen); + qemu_get_8s(f, &s->tx.hdr_len); + qemu_get_be16s(f, &s->tx.mss); + qemu_get_be16s(f, &s->tx.size); + qemu_get_be16s(f, &s->tx.tso_frames); + qemu_get_8s(f, &s->tx.sum_needed); + qemu_get_8s(f, &s->tx.ip); + qemu_get_8s(f, &s->tx.tcp); + qemu_get_buffer(f, s->tx.header, sizeof s->tx.header); + qemu_get_buffer(f, s->tx.data, sizeof s->tx.data); + for (i =3D 0; i < 64; i++) + qemu_get_be16s(f, s->eeprom_data + i); + for (i =3D 0; i < 0x20; i++) + qemu_get_be16s(f, s->phy_reg + i); + for (i =3D 0; i < MAC_NSAVE; i++) + qemu_get_be32s(f, s->mac_reg + mac_regtosave[i]); + for (i =3D 0; i < MAC_NARRAYS; i++) + for (j =3D 0; j < mac_regarraystosave[i].size; j++) + qemu_get_be32s(f, + s->mac_reg + mac_regarraystosave[i].array0 + j); + return 0; +} + +static uint16_t e1000_eeprom_template[64] =3D { + 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x= 0000, + 0x3000, 0x1000, 0x6403, E1000_DEVID, 0x8086, E1000_DEVID, 0x8086, 0x= 3040, + 0x0008, 0x2000, 0x7e14, 0x0048, 0x1000, 0x00d8, 0x0000, 0x= 2700, + 0x6cc9, 0x3150, 0x0722, 0x040b, 0x0984, 0x0000, 0xc000, 0x= 0706, + 0x1008, 0x0000, 0x0f04, 0x7fff, 0x4d01, 0xffff, 0xffff, 0x= ffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x= ffff, + 0x0100, 0x4000, 0x121c, 0xffff, 0xffff, 0xffff, 0xffff, 0x= ffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x= 0000, +}; + +static uint16_t phy_reg_init[] =3D { + [PHY_CTRL] =3D 0x1140, [PHY_STATUS] =3D 0x796d, // link initially up + [PHY_ID1] =3D 0x141, [PHY_ID2] =3D PHY_ID2_INIT, + [PHY_1000T_CTRL] =3D 0x0e00, [M88E1000_PHY_SPEC_CTRL] =3D 0x360, + [M88E1000_EXT_PHY_SPEC_CTRL] =3D 0x0d60, [PHY_AUTONEG_ADV] =3D 0xde1, + [PHY_LP_ABILITY] =3D 0x1e0, [PHY_1000T_STATUS] =3D 0x3c00, +}; + +static uint32_t mac_reg_init[] =3D { + [PBA] =3D 0x00100030, + [LEDCTL] =3D 0x602, + [CTRL] =3D E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN0 | + E1000_CTRL_SPD_1000 | E1000_CTRL_SLU, + [STATUS] =3D 0x80000000 | E1000_STATUS_GIO_MASTER_ENABLE | + E1000_STATUS_ASDV | E1000_STATUS_MTXCKOK | + E1000_STATUS_SPEED_1000 | E1000_STATUS_FD | + E1000_STATUS_LU, + [MANC] =3D E1000_MANC_EN_MNG2HOST | E1000_MANC_RCV_TCO_EN | + E1000_MANC_ARP_EN | E1000_MANC_0298_EN | + E1000_MANC_RMCP_EN, +}; + +/* PCI interface */ + +static CPUWriteMemoryFunc *e1000_mmio_write[] =3D { + e1000_mmio_writeb, e1000_mmio_writew, e1000_mmio_writel +}; + +static CPUReadMemoryFunc *e1000_mmio_read[] =3D { + e1000_mmio_readb, e1000_mmio_readw, e1000_mmio_readl +}; + +static void +e1000_mmio_map(PCIDevice *pci_dev, int region_num, + uint32_t addr, uint32_t size, int type) +{ + E1000State *d =3D (E1000State *)pci_dev; + + DBGOUT(MMIO, "e1000_mmio_map addr=3D0x%08x 0x%08x\n", addr, size); + + d->mmio_base =3D addr; + cpu_register_physical_memory(addr, PNPMMIO_SIZE, d->mmio_index); +} + +void +pci_e1000_init(PCIBus *bus, NICInfo *nd, int devfn) +{ + E1000State *d; + uint8_t *pci_conf; + static int instance; + uint16_t checksum =3D 0; + char *info_str =3D "e1000"; + int i; + + d =3D (E1000State *)pci_register_device(bus, "e1000", + sizeof(E1000State), devfn, NULL, NULL); + + pci_conf =3D d->dev.config; + memset(pci_conf, 0, 256); + + *(uint16_t *)(pci_conf+0x00) =3D cpu_to_le16(0x8086); + *(uint16_t *)(pci_conf+0x02) =3D cpu_to_le16(E1000_DEVID); + *(uint16_t *)(pci_conf+0x04) =3D cpu_to_le16(0x0407); + *(uint16_t *)(pci_conf+0x06) =3D cpu_to_le16(0x0010); + pci_conf[0x08] =3D 0x03; + pci_conf[0x0a] =3D 0x00; // ethernet network controller + pci_conf[0x0b] =3D 0x02; + pci_conf[0x0c] =3D 0x10; + + pci_conf[0x3d] =3D 1; // interrupt pin 0 + + d->mmio_index =3D cpu_register_io_memory(0, e1000_mmio_read, + e1000_mmio_write, d); + + pci_register_io_region((PCIDevice *)d, 0, PNPMMIO_SIZE, + PCI_ADDRESS_SPACE_MEM, e1000_mmio_map); + + pci_register_io_region((PCIDevice *)d, 1, IOPORT_SIZE, + PCI_ADDRESS_SPACE_IO, ioport_map); + + d->instance =3D instance++; + + d->nd =3D nd; + memmove(d->eeprom_data, e1000_eeprom_template, + sizeof e1000_eeprom_template); + for (i =3D 0; i < 3; i++) + d->eeprom_data[i] =3D (nd->macaddr[2*i+1]<<8) | nd->macaddr[2*i]; + for (i =3D 0; i < EEPROM_CHECKSUM_REG; i++) + checksum +=3D d->eeprom_data[i]; + checksum =3D (uint16_t) EEPROM_SUM - checksum; + d->eeprom_data[EEPROM_CHECKSUM_REG] =3D checksum; + + memset(d->phy_reg, 0, sizeof d->phy_reg); + memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init); + memset(d->mac_reg, 0, sizeof d->mac_reg); + memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init); + d->rxbuf_min_shift =3D 1; + memset(&d->tx, 0, sizeof d->tx); + + d->vc =3D qemu_new_vlan_client(nd->vlan, e1000_receive, + e1000_can_receive, d); + + snprintf(d->vc->info_str, sizeof(d->vc->info_str), + "%s macaddr=3D%02x:%02x:%02x:%02x:%02x:%02x", info_str, + d->nd->macaddr[0], d->nd->macaddr[1], d->nd->macaddr[2], + d->nd->macaddr[3], d->nd->macaddr[4], d->nd->macaddr[5]); + + register_savevm(info_str, d->instance, 1, nic_save, nic_load, d); +} diff --git a/qemu/hw/e1000_hw.h b/qemu/hw/e1000_hw.h new file mode 100644 index 0000000..de6bfb3 --- /dev/null +++ b/qemu/hw/e1000_hw.h @@ -0,0 +1,3411 @@ +/***********************************************************************= ******** + + Intel PRO/1000 Linux driver + Copyright(c) 1999 - 2006 Intel Corporation. + + This program is free software; you can redistribute it and/or modify i= t + under the terms and conditions of the GNU General Public License, + version 2, as published by the Free Software Foundation. + + This program is distributed in the hope it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License = for + more details. + + You should have received a copy of the GNU General Public License alon= g with + this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. + + The full GNU General Public License is included in this distribution i= n + the file called "COPYING". + + Contact Information: + Linux NICS + e1000-devel Mailing List + Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6= 497 + +************************************************************************= *******/ + +/* e1000_hw.h + * Structures, enums, and macros for the MAC + */ + +#ifndef _E1000_HW_H_ +#define _E1000_HW_H_ + +/* + * Comment it out since it clashes with some local definitions + * #include "e1000_osdep.h" + */ + + +/* Forward declarations of structures used by the shared code */ +struct e1000_hw; +struct e1000_hw_stats; + +/* Enumerated types specific to the e1000 hardware */ +/* Media Access Controlers */ +typedef enum { + e1000_undefined =3D 0, + e1000_82542_rev2_0, + e1000_82542_rev2_1, + e1000_82543, + e1000_82544, + e1000_82540, + e1000_82545, + e1000_82545_rev_3, + e1000_82546, + e1000_82546_rev_3, + e1000_82541, + e1000_82541_rev_2, + e1000_82547, + e1000_82547_rev_2, + e1000_82571, + e1000_82572, + e1000_82573, + e1000_80003es2lan, + e1000_ich8lan, + e1000_num_macs +} e1000_mac_type; + +typedef enum { + e1000_eeprom_uninitialized =3D 0, + e1000_eeprom_spi, + e1000_eeprom_microwire, + e1000_eeprom_flash, + e1000_eeprom_ich8, + e1000_eeprom_none, /* No NVM support */ + e1000_num_eeprom_types +} e1000_eeprom_type; + +/* Media Types */ +typedef enum { + e1000_media_type_copper =3D 0, + e1000_media_type_fiber =3D 1, + e1000_media_type_internal_serdes =3D 2, + e1000_num_media_types +} e1000_media_type; + +typedef enum { + e1000_10_half =3D 0, + e1000_10_full =3D 1, + e1000_100_half =3D 2, + e1000_100_full =3D 3 +} e1000_speed_duplex_type; + +/* Flow Control Settings */ +typedef enum { + E1000_FC_NONE =3D 0, + E1000_FC_RX_PAUSE =3D 1, + E1000_FC_TX_PAUSE =3D 2, + E1000_FC_FULL =3D 3, + E1000_FC_DEFAULT =3D 0xFF +} e1000_fc_type; + +struct e1000_shadow_ram { + uint16_t eeprom_word; + boolean_t modified; +}; + +/* PCI bus types */ +typedef enum { + e1000_bus_type_unknown =3D 0, + e1000_bus_type_pci, + e1000_bus_type_pcix, + e1000_bus_type_pci_express, + e1000_bus_type_reserved +} e1000_bus_type; + +/* PCI bus speeds */ +typedef enum { + e1000_bus_speed_unknown =3D 0, + e1000_bus_speed_33, + e1000_bus_speed_66, + e1000_bus_speed_100, + e1000_bus_speed_120, + e1000_bus_speed_133, + e1000_bus_speed_2500, + e1000_bus_speed_reserved +} e1000_bus_speed; + +/* PCI bus widths */ +typedef enum { + e1000_bus_width_unknown =3D 0, + /* These PCIe values should literally match the possible return valu= es + * from config space */ + e1000_bus_width_pciex_1 =3D 1, + e1000_bus_width_pciex_2 =3D 2, + e1000_bus_width_pciex_4 =3D 4, + e1000_bus_width_32, + e1000_bus_width_64, + e1000_bus_width_reserved +} e1000_bus_width; + +/* PHY status info structure and supporting enums */ +typedef enum { + e1000_cable_length_50 =3D 0, + e1000_cable_length_50_80, + e1000_cable_length_80_110, + e1000_cable_length_110_140, + e1000_cable_length_140, + e1000_cable_length_undefined =3D 0xFF +} e1000_cable_length; + +typedef enum { + e1000_gg_cable_length_60 =3D 0, + e1000_gg_cable_length_60_115 =3D 1, + e1000_gg_cable_length_115_150 =3D 2, + e1000_gg_cable_length_150 =3D 4 +} e1000_gg_cable_length; + +typedef enum { + e1000_igp_cable_length_10 =3D 10, + e1000_igp_cable_length_20 =3D 20, + e1000_igp_cable_length_30 =3D 30, + e1000_igp_cable_length_40 =3D 40, + e1000_igp_cable_length_50 =3D 50, + e1000_igp_cable_length_60 =3D 60, + e1000_igp_cable_length_70 =3D 70, + e1000_igp_cable_length_80 =3D 80, + e1000_igp_cable_length_90 =3D 90, + e1000_igp_cable_length_100 =3D 100, + e1000_igp_cable_length_110 =3D 110, + e1000_igp_cable_length_115 =3D 115, + e1000_igp_cable_length_120 =3D 120, + e1000_igp_cable_length_130 =3D 130, + e1000_igp_cable_length_140 =3D 140, + e1000_igp_cable_length_150 =3D 150, + e1000_igp_cable_length_160 =3D 160, + e1000_igp_cable_length_170 =3D 170, + e1000_igp_cable_length_180 =3D 180 +} e1000_igp_cable_length; + +typedef enum { + e1000_10bt_ext_dist_enable_normal =3D 0, + e1000_10bt_ext_dist_enable_lower, + e1000_10bt_ext_dist_enable_undefined =3D 0xFF +} e1000_10bt_ext_dist_enable; + +typedef enum { + e1000_rev_polarity_normal =3D 0, + e1000_rev_polarity_reversed, + e1000_rev_polarity_undefined =3D 0xFF +} e1000_rev_polarity; + +typedef enum { + e1000_downshift_normal =3D 0, + e1000_downshift_activated, + e1000_downshift_undefined =3D 0xFF +} e1000_downshift; + +typedef enum { + e1000_smart_speed_default =3D 0, + e1000_smart_speed_on, + e1000_smart_speed_off +} e1000_smart_speed; + +typedef enum { + e1000_polarity_reversal_enabled =3D 0, + e1000_polarity_reversal_disabled, + e1000_polarity_reversal_undefined =3D 0xFF +} e1000_polarity_reversal; + +typedef enum { + e1000_auto_x_mode_manual_mdi =3D 0, + e1000_auto_x_mode_manual_mdix, + e1000_auto_x_mode_auto1, + e1000_auto_x_mode_auto2, + e1000_auto_x_mode_undefined =3D 0xFF +} e1000_auto_x_mode; + +typedef enum { + e1000_1000t_rx_status_not_ok =3D 0, + e1000_1000t_rx_status_ok, + e1000_1000t_rx_status_undefined =3D 0xFF +} e1000_1000t_rx_status; + +typedef enum { + e1000_phy_m88 =3D 0, + e1000_phy_igp, + e1000_phy_igp_2, + e1000_phy_gg82563, + e1000_phy_igp_3, + e1000_phy_ife, + e1000_phy_undefined =3D 0xFF +} e1000_phy_type; + +typedef enum { + e1000_ms_hw_default =3D 0, + e1000_ms_force_master, + e1000_ms_force_slave, + e1000_ms_auto +} e1000_ms_type; + +typedef enum { + e1000_ffe_config_enabled =3D 0, + e1000_ffe_config_active, + e1000_ffe_config_blocked +} e1000_ffe_config; + +typedef enum { + e1000_dsp_config_disabled =3D 0, + e1000_dsp_config_enabled, + e1000_dsp_config_activated, + e1000_dsp_config_undefined =3D 0xFF +} e1000_dsp_config; + +struct e1000_phy_info { + e1000_cable_length cable_length; + e1000_10bt_ext_dist_enable extended_10bt_distance; + e1000_rev_polarity cable_polarity; + e1000_downshift downshift; + e1000_polarity_reversal polarity_correction; + e1000_auto_x_mode mdix_mode; + e1000_1000t_rx_status local_rx; + e1000_1000t_rx_status remote_rx; +}; + +struct e1000_phy_stats { + uint32_t idle_errors; + uint32_t receive_errors; +}; + +struct e1000_eeprom_info { + e1000_eeprom_type type; + uint16_t word_size; + uint16_t opcode_bits; + uint16_t address_bits; + uint16_t delay_usec; + uint16_t page_size; + boolean_t use_eerd; + boolean_t use_eewr; +}; + +/* Flex ASF Information */ +#define E1000_HOST_IF_MAX_SIZE 2048 + +typedef enum { + e1000_byte_align =3D 0, + e1000_word_align =3D 1, + e1000_dword_align =3D 2 +} e1000_align_type; + + + +/* Error Codes */ +#define E1000_SUCCESS 0 +#define E1000_ERR_EEPROM 1 +#define E1000_ERR_PHY 2 +#define E1000_ERR_CONFIG 3 +#define E1000_ERR_PARAM 4 +#define E1000_ERR_MAC_TYPE 5 +#define E1000_ERR_PHY_TYPE 6 +#define E1000_ERR_RESET 9 +#define E1000_ERR_MASTER_REQUESTS_PENDING 10 +#define E1000_ERR_HOST_INTERFACE_COMMAND 11 +#define E1000_BLK_PHY_RESET 12 +#define E1000_ERR_SWFW_SYNC 13 + +#define E1000_BYTE_SWAP_WORD(_value) ((((_value) & 0x00ff) << 8) | \ + (((_value) & 0xff00) >> 8)) + +/* Function prototypes */ +/* Initialization */ +int32_t e1000_reset_hw(struct e1000_hw *hw); +int32_t e1000_init_hw(struct e1000_hw *hw); +int32_t e1000_set_mac_type(struct e1000_hw *hw); +void e1000_set_media_type(struct e1000_hw *hw); + +/* Link Configuration */ +int32_t e1000_setup_link(struct e1000_hw *hw); +int32_t e1000_phy_setup_autoneg(struct e1000_hw *hw); +void e1000_config_collision_dist(struct e1000_hw *hw); +int32_t e1000_check_for_link(struct e1000_hw *hw); +int32_t e1000_get_speed_and_duplex(struct e1000_hw *hw, uint16_t *speed,= uint16_t *duplex); +int32_t e1000_force_mac_fc(struct e1000_hw *hw); + +/* PHY */ +int32_t e1000_read_phy_reg(struct e1000_hw *hw, uint32_t reg_addr, uint1= 6_t *phy_data); +int32_t e1000_write_phy_reg(struct e1000_hw *hw, uint32_t reg_addr, uint= 16_t data); +int32_t e1000_phy_hw_reset(struct e1000_hw *hw); +int32_t e1000_phy_reset(struct e1000_hw *hw); +int32_t e1000_phy_get_info(struct e1000_hw *hw, struct e1000_phy_info *p= hy_info); +int32_t e1000_validate_mdi_setting(struct e1000_hw *hw); + +void e1000_phy_powerdown_workaround(struct e1000_hw *hw); + +/* EEPROM Functions */ +int32_t e1000_init_eeprom_params(struct e1000_hw *hw); + +/* MNG HOST IF functions */ +uint32_t e1000_enable_mng_pass_thru(struct e1000_hw *hw); + +#define E1000_MNG_DHCP_TX_PAYLOAD_CMD 64 +#define E1000_HI_MAX_MNG_DATA_LENGTH 0x6F8 /* Host Interface data l= ength */ + +#define E1000_MNG_DHCP_COMMAND_TIMEOUT 10 /* Time in ms to process= MNG command */ +#define E1000_MNG_DHCP_COOKIE_OFFSET 0x6F0 /* Cookie offset */ +#define E1000_MNG_DHCP_COOKIE_LENGTH 0x10 /* Cookie length */ +#define E1000_MNG_IAMT_MODE 0x3 +#define E1000_MNG_ICH_IAMT_MODE 0x2 +#define E1000_IAMT_SIGNATURE 0x544D4149 /* Intel(R) Active Ma= nagement Technology signature */ + +#define E1000_MNG_DHCP_COOKIE_STATUS_PARSING_SUPPORT 0x1 /* DHCP parsing= enabled */ +#define E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT 0x2 /* DHCP parsing= enabled */ +#define E1000_VFTA_ENTRY_SHIFT 0x5 +#define E1000_VFTA_ENTRY_MASK 0x7F +#define E1000_VFTA_ENTRY_BIT_SHIFT_MASK 0x1F + +struct e1000_host_mng_command_header { + uint8_t command_id; + uint8_t checksum; + uint16_t reserved1; + uint16_t reserved2; + uint16_t command_length; +}; + +struct e1000_host_mng_command_info { + struct e1000_host_mng_command_header command_header; /* Command Hea= d/Command Result Head has 4 bytes */ + uint8_t command_data[E1000_HI_MAX_MNG_DATA_LENGTH]; /* Command dat= a can length 0..0x658*/ +}; +#ifdef __BIG_ENDIAN +struct e1000_host_mng_dhcp_cookie{ + uint32_t signature; + uint16_t vlan_id; + uint8_t reserved0; + uint8_t status; + uint32_t reserved1; + uint8_t checksum; + uint8_t reserved3; + uint16_t reserved2; +}; +#else +struct e1000_host_mng_dhcp_cookie{ + uint32_t signature; + uint8_t status; + uint8_t reserved0; + uint16_t vlan_id; + uint32_t reserved1; + uint16_t reserved2; + uint8_t reserved3; + uint8_t checksum; +}; +#endif + +int32_t e1000_mng_write_dhcp_info(struct e1000_hw *hw, uint8_t *buffer, + uint16_t length); +boolean_t e1000_check_mng_mode(struct e1000_hw *hw); +boolean_t e1000_enable_tx_pkt_filtering(struct e1000_hw *hw); +int32_t e1000_read_eeprom(struct e1000_hw *hw, uint16_t reg, uint16_t wo= rds, uint16_t *data); +int32_t e1000_validate_eeprom_checksum(struct e1000_hw *hw); +int32_t e1000_update_eeprom_checksum(struct e1000_hw *hw); +int32_t e1000_write_eeprom(struct e1000_hw *hw, uint16_t reg, uint16_t w= ords, uint16_t *data); +int32_t e1000_read_mac_addr(struct e1000_hw * hw); + +/* Filters (multicast, vlan, receive) */ +uint32_t e1000_hash_mc_addr(struct e1000_hw *hw, uint8_t * mc_addr); +void e1000_mta_set(struct e1000_hw *hw, uint32_t hash_value); +void e1000_rar_set(struct e1000_hw *hw, uint8_t * mc_addr, uint32_t rar_= index); +void e1000_write_vfta(struct e1000_hw *hw, uint32_t offset, uint32_t val= ue); + +/* LED functions */ +int32_t e1000_setup_led(struct e1000_hw *hw); +int32_t e1000_cleanup_led(struct e1000_hw *hw); +int32_t e1000_led_on(struct e1000_hw *hw); +int32_t e1000_led_off(struct e1000_hw *hw); +int32_t e1000_blink_led_start(struct e1000_hw *hw); + +/* Adaptive IFS Functions */ + +/* Everything else */ +void e1000_reset_adaptive(struct e1000_hw *hw); +void e1000_update_adaptive(struct e1000_hw *hw); +void e1000_tbi_adjust_stats(struct e1000_hw *hw, struct e1000_hw_stats *= stats, uint32_t frame_len, uint8_t * mac_addr); +void e1000_get_bus_info(struct e1000_hw *hw); +void e1000_pci_set_mwi(struct e1000_hw *hw); +void e1000_pci_clear_mwi(struct e1000_hw *hw); +void e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t * va= lue); +void e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t * v= alue); +int32_t e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint1= 6_t *value); +void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc); +int e1000_pcix_get_mmrbc(struct e1000_hw *hw); +/* Port I/O is only supported on 82544 and newer */ +void e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t va= lue); +int32_t e1000_disable_pciex_master(struct e1000_hw *hw); +int32_t e1000_check_phy_reset_block(struct e1000_hw *hw); + + +#define E1000_READ_REG_IO(a, reg) \ + e1000_read_reg_io((a), E1000_##reg) +#define E1000_WRITE_REG_IO(a, reg, val) \ + e1000_write_reg_io((a), E1000_##reg, val) + +/* PCI Device IDs */ +#define E1000_DEV_ID_82542 0x1000 +#define E1000_DEV_ID_82543GC_FIBER 0x1001 +#define E1000_DEV_ID_82543GC_COPPER 0x1004 +#define E1000_DEV_ID_82544EI_COPPER 0x1008 +#define E1000_DEV_ID_82544EI_FIBER 0x1009 +#define E1000_DEV_ID_82544GC_COPPER 0x100C +#define E1000_DEV_ID_82544GC_LOM 0x100D +#define E1000_DEV_ID_82540EM 0x100E +#define E1000_DEV_ID_82540EM_LOM 0x1015 +#define E1000_DEV_ID_82540EP_LOM 0x1016 +#define E1000_DEV_ID_82540EP 0x1017 +#define E1000_DEV_ID_82540EP_LP 0x101E +#define E1000_DEV_ID_82545EM_COPPER 0x100F +#define E1000_DEV_ID_82545EM_FIBER 0x1011 +#define E1000_DEV_ID_82545GM_COPPER 0x1026 +#define E1000_DEV_ID_82545GM_FIBER 0x1027 +#define E1000_DEV_ID_82545GM_SERDES 0x1028 +#define E1000_DEV_ID_82546EB_COPPER 0x1010 +#define E1000_DEV_ID_82546EB_FIBER 0x1012 +#define E1000_DEV_ID_82546EB_QUAD_COPPER 0x101D +#define E1000_DEV_ID_82541EI 0x1013 +#define E1000_DEV_ID_82541EI_MOBILE 0x1018 +#define E1000_DEV_ID_82541ER_LOM 0x1014 +#define E1000_DEV_ID_82541ER 0x1078 +#define E1000_DEV_ID_82547GI 0x1075 +#define E1000_DEV_ID_82541GI 0x1076 +#define E1000_DEV_ID_82541GI_MOBILE 0x1077 +#define E1000_DEV_ID_82541GI_LF 0x107C +#define E1000_DEV_ID_82546GB_COPPER 0x1079 +#define E1000_DEV_ID_82546GB_FIBER 0x107A +#define E1000_DEV_ID_82546GB_SERDES 0x107B +#define E1000_DEV_ID_82546GB_PCIE 0x108A +#define E1000_DEV_ID_82546GB_QUAD_COPPER 0x1099 +#define E1000_DEV_ID_82547EI 0x1019 +#define E1000_DEV_ID_82547EI_MOBILE 0x101A +#define E1000_DEV_ID_82571EB_COPPER 0x105E +#define E1000_DEV_ID_82571EB_FIBER 0x105F +#define E1000_DEV_ID_82571EB_SERDES 0x1060 +#define E1000_DEV_ID_82571EB_QUAD_COPPER 0x10A4 +#define E1000_DEV_ID_82571PT_QUAD_COPPER 0x10D5 +#define E1000_DEV_ID_82571EB_QUAD_FIBER 0x10A5 +#define E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE 0x10BC +#define E1000_DEV_ID_82571EB_SERDES_DUAL 0x10D9 +#define E1000_DEV_ID_82571EB_SERDES_QUAD 0x10DA +#define E1000_DEV_ID_82572EI_COPPER 0x107D +#define E1000_DEV_ID_82572EI_FIBER 0x107E +#define E1000_DEV_ID_82572EI_SERDES 0x107F +#define E1000_DEV_ID_82572EI 0x10B9 +#define E1000_DEV_ID_82573E 0x108B +#define E1000_DEV_ID_82573E_IAMT 0x108C +#define E1000_DEV_ID_82573L 0x109A +#define E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3 0x10B5 +#define E1000_DEV_ID_80003ES2LAN_COPPER_DPT 0x1096 +#define E1000_DEV_ID_80003ES2LAN_SERDES_DPT 0x1098 +#define E1000_DEV_ID_80003ES2LAN_COPPER_SPT 0x10BA +#define E1000_DEV_ID_80003ES2LAN_SERDES_SPT 0x10BB + +#define E1000_DEV_ID_ICH8_IGP_M_AMT 0x1049 +#define E1000_DEV_ID_ICH8_IGP_AMT 0x104A +#define E1000_DEV_ID_ICH8_IGP_C 0x104B +#define E1000_DEV_ID_ICH8_IFE 0x104C +#define E1000_DEV_ID_ICH8_IFE_GT 0x10C4 +#define E1000_DEV_ID_ICH8_IFE_G 0x10C5 +#define E1000_DEV_ID_ICH8_IGP_M 0x104D + + +#define NODE_ADDRESS_SIZE 6 +#define ETH_LENGTH_OF_ADDRESS 6 + +/* MAC decode size is 128K - This is the size of BAR0 */ +#define MAC_DECODE_SIZE (128 * 1024) + +#define E1000_82542_2_0_REV_ID 2 +#define E1000_82542_2_1_REV_ID 3 +#define E1000_REVISION_0 0 +#define E1000_REVISION_1 1 +#define E1000_REVISION_2 2 +#define E1000_REVISION_3 3 + +#define SPEED_10 10 +#define SPEED_100 100 +#define SPEED_1000 1000 +#define HALF_DUPLEX 1 +#define FULL_DUPLEX 2 + +/* The sizes (in bytes) of a ethernet packet */ +#define ENET_HEADER_SIZE 14 +#define MAXIMUM_ETHERNET_FRAME_SIZE 1518 /* With FCS */ +#define MINIMUM_ETHERNET_FRAME_SIZE 64 /* With FCS */ +#define ETHERNET_FCS_SIZE 4 +#define MAXIMUM_ETHERNET_PACKET_SIZE \ + (MAXIMUM_ETHERNET_FRAME_SIZE - ETHERNET_FCS_SIZE) +#define MINIMUM_ETHERNET_PACKET_SIZE \ + (MINIMUM_ETHERNET_FRAME_SIZE - ETHERNET_FCS_SIZE) +#define CRC_LENGTH ETHERNET_FCS_SIZE +#define MAX_JUMBO_FRAME_SIZE 0x3F00 + + +/* 802.1q VLAN Packet Sizes */ +#define VLAN_TAG_SIZE 4 /* 802.3ac tag (not DMAed) */ + +/* Ethertype field values */ +#define ETHERNET_IEEE_VLAN_TYPE 0x8100 /* 802.3ac packet */ +#define ETHERNET_IP_TYPE 0x0800 /* IP packets */ +#define ETHERNET_ARP_TYPE 0x0806 /* Address Resolution Protocol (= ARP) */ + +/* Packet Header defines */ +#define IP_PROTOCOL_TCP 6 +#define IP_PROTOCOL_UDP 0x11 + +/* This defines the bits that are set in the Interrupt Mask + * Set/Read Register. Each bit is documented below: + * o RXDMT0 =3D Receive Descriptor Minimum Threshold hit (ring 0) + * o RXSEQ =3D Receive Sequence Error + */ +#define POLL_IMS_ENABLE_MASK ( \ + E1000_IMS_RXDMT0 | \ + E1000_IMS_RXSEQ) + +/* This defines the bits that are set in the Interrupt Mask + * Set/Read Register. Each bit is documented below: + * o RXT0 =3D Receiver Timer Interrupt (ring 0) + * o TXDW =3D Transmit Descriptor Written Back + * o RXDMT0 =3D Receive Descriptor Minimum Threshold hit (ring 0) + * o RXSEQ =3D Receive Sequence Error + * o LSC =3D Link Status Change + */ +#define IMS_ENABLE_MASK ( \ + E1000_IMS_RXT0 | \ + E1000_IMS_TXDW | \ + E1000_IMS_RXDMT0 | \ + E1000_IMS_RXSEQ | \ + E1000_IMS_LSC) + +/* Additional interrupts need to be handled for e1000_ich8lan: + DSW =3D The FW changed the status of the DISSW bit in FWSM + PHYINT =3D The LAN connected device generates an interrupt + EPRST =3D Manageability reset event */ +#define IMS_ICH8LAN_ENABLE_MASK (\ + E1000_IMS_DSW | \ + E1000_IMS_PHYINT | \ + E1000_IMS_EPRST) + +/* Number of high/low register pairs in the RAR. The RAR (Receive Addres= s + * Registers) holds the directed and multicast addresses that we monitor= . We + * reserve one of these spots for our directed address, allowing us room= for + * E1000_RAR_ENTRIES - 1 multicast addresses. + */ +#define E1000_RAR_ENTRIES 15 + +#define E1000_RAR_ENTRIES_ICH8LAN 6 + +#define MIN_NUMBER_OF_DESCRIPTORS 8 +#define MAX_NUMBER_OF_DESCRIPTORS 0xFFF8 + +/* Receive Descriptor */ +struct e1000_rx_desc { + uint64_t buffer_addr; /* Address of the descriptor's data buffer */ + uint16_t length; /* Length of data DMAed into data buffer */ + uint16_t csum; /* Packet checksum */ + uint8_t status; /* Descriptor status */ + uint8_t errors; /* Descriptor Errors */ + uint16_t special; +}; + +/* Receive Descriptor - Extended */ +union e1000_rx_desc_extended { + struct { + uint64_t buffer_addr; + uint64_t reserved; + } read; + struct { + struct { + uint32_t mrq; /* Multiple Rx Queues */ + union { + uint32_t rss; /* RSS Hash */ + struct { + uint16_t ip_id; /* IP id */ + uint16_t csum; /* Packet Checksum */ + } csum_ip; + } hi_dword; + } lower; + struct { + uint32_t status_error; /* ext status/error */ + uint16_t length; + uint16_t vlan; /* VLAN tag */ + } upper; + } wb; /* writeback */ +}; + +#define MAX_PS_BUFFERS 4 +/* Receive Descriptor - Packet Split */ +union e1000_rx_desc_packet_split { + struct { + /* one buffer for protocol header(s), three data buffers */ + uint64_t buffer_addr[MAX_PS_BUFFERS]; + } read; + struct { + struct { + uint32_t mrq; /* Multiple Rx Queues */ + union { + uint32_t rss; /* RSS Hash */ + struct { + uint16_t ip_id; /* IP id */ + uint16_t csum; /* Packet Checksum */ + } csum_ip; + } hi_dword; + } lower; + struct { + uint32_t status_error; /* ext status/error */ + uint16_t length0; /* length of buffer 0 */ + uint16_t vlan; /* VLAN tag */ + } middle; + struct { + uint16_t header_status; + uint16_t length[3]; /* length of buffers 1-3 */ + } upper; + uint64_t reserved; + } wb; /* writeback */ +}; + +/* Receive Decriptor bit definitions */ +#define E1000_RXD_STAT_DD 0x01 /* Descriptor Done */ +#define E1000_RXD_STAT_EOP 0x02 /* End of Packet */ +#define E1000_RXD_STAT_IXSM 0x04 /* Ignore checksum */ +#define E1000_RXD_STAT_VP 0x08 /* IEEE VLAN Packet */ +#define E1000_RXD_STAT_UDPCS 0x10 /* UDP xsum caculated */ +#define E1000_RXD_STAT_TCPCS 0x20 /* TCP xsum calculated */ +#define E1000_RXD_STAT_IPCS 0x40 /* IP xsum calculated */ +#define E1000_RXD_STAT_PIF 0x80 /* passed in-exact filter */ +#define E1000_RXD_STAT_IPIDV 0x200 /* IP identification valid */ +#define E1000_RXD_STAT_UDPV 0x400 /* Valid UDP checksum */ +#define E1000_RXD_STAT_ACK 0x8000 /* ACK Packet indication */ +#define E1000_RXD_ERR_CE 0x01 /* CRC Error */ +#define E1000_RXD_ERR_SE 0x02 /* Symbol Error */ +#define E1000_RXD_ERR_SEQ 0x04 /* Sequence Error */ +#define E1000_RXD_ERR_CXE 0x10 /* Carrier Extension Error */ +#define E1000_RXD_ERR_TCPE 0x20 /* TCP/UDP Checksum Error */ +#define E1000_RXD_ERR_IPE 0x40 /* IP Checksum Error */ +#define E1000_RXD_ERR_RXE 0x80 /* Rx Data Error */ +#define E1000_RXD_SPC_VLAN_MASK 0x0FFF /* VLAN ID is in lower 12 bits *= / +#define E1000_RXD_SPC_PRI_MASK 0xE000 /* Priority is in upper 3 bits *= / +#define E1000_RXD_SPC_PRI_SHIFT 13 +#define E1000_RXD_SPC_CFI_MASK 0x1000 /* CFI is bit 12 */ +#define E1000_RXD_SPC_CFI_SHIFT 12 + +#define E1000_RXDEXT_STATERR_CE 0x01000000 +#define E1000_RXDEXT_STATERR_SE 0x02000000 +#define E1000_RXDEXT_STATERR_SEQ 0x04000000 +#define E1000_RXDEXT_STATERR_CXE 0x10000000 +#define E1000_RXDEXT_STATERR_TCPE 0x20000000 +#define E1000_RXDEXT_STATERR_IPE 0x40000000 +#define E1000_RXDEXT_STATERR_RXE 0x80000000 + +#define E1000_RXDPS_HDRSTAT_HDRSP 0x00008000 +#define E1000_RXDPS_HDRSTAT_HDRLEN_MASK 0x000003FF + +/* mask to determine if packets should be dropped due to frame errors */ +#define E1000_RXD_ERR_FRAME_ERR_MASK ( \ + E1000_RXD_ERR_CE | \ + E1000_RXD_ERR_SE | \ + E1000_RXD_ERR_SEQ | \ + E1000_RXD_ERR_CXE | \ + E1000_RXD_ERR_RXE) + + +/* Same mask, but for extended and packet split descriptors */ +#define E1000_RXDEXT_ERR_FRAME_ERR_MASK ( \ + E1000_RXDEXT_STATERR_CE | \ + E1000_RXDEXT_STATERR_SE | \ + E1000_RXDEXT_STATERR_SEQ | \ + E1000_RXDEXT_STATERR_CXE | \ + E1000_RXDEXT_STATERR_RXE) + + +/* Transmit Descriptor */ +struct e1000_tx_desc { + uint64_t buffer_addr; /* Address of the descriptor's data buff= er */ + union { + uint32_t data; + struct { + uint16_t length; /* Data buffer length */ + uint8_t cso; /* Checksum offset */ + uint8_t cmd; /* Descriptor control */ + } flags; + } lower; + union { + uint32_t data; + struct { + uint8_t status; /* Descriptor status */ + uint8_t css; /* Checksum start */ + uint16_t special; + } fields; + } upper; +}; + +/* Transmit Descriptor bit definitions */ +#define E1000_TXD_DTYP_D 0x00100000 /* Data Descriptor */ +#define E1000_TXD_DTYP_C 0x00000000 /* Context Descriptor */ +#define E1000_TXD_POPTS_IXSM 0x01 /* Insert IP checksum */ +#define E1000_TXD_POPTS_TXSM 0x02 /* Insert TCP/UDP checksum */ +#define E1000_TXD_CMD_EOP 0x01000000 /* End of Packet */ +#define E1000_TXD_CMD_IFCS 0x02000000 /* Insert FCS (Ethernet CRC) */ +#define E1000_TXD_CMD_IC 0x04000000 /* Insert Checksum */ +#define E1000_TXD_CMD_RS 0x08000000 /* Report Status */ +#define E1000_TXD_CMD_RPS 0x10000000 /* Report Packet Sent */ +#define E1000_TXD_CMD_DEXT 0x20000000 /* Descriptor extension (0 =3D l= egacy) */ +#define E1000_TXD_CMD_VLE 0x40000000 /* Add VLAN tag */ +#define E1000_TXD_CMD_IDE 0x80000000 /* Enable Tidv register */ +#define E1000_TXD_STAT_DD 0x00000001 /* Descriptor Done */ +#define E1000_TXD_STAT_EC 0x00000002 /* Excess Collisions */ +#define E1000_TXD_STAT_LC 0x00000004 /* Late Collisions */ +#define E1000_TXD_STAT_TU 0x00000008 /* Transmit underrun */ +#define E1000_TXD_CMD_TCP 0x01000000 /* TCP packet */ +#define E1000_TXD_CMD_IP 0x02000000 /* IP packet */ +#define E1000_TXD_CMD_TSE 0x04000000 /* TCP Seg enable */ +#define E1000_TXD_STAT_TC 0x00000004 /* Tx Underrun */ + +/* Offload Context Descriptor */ +struct e1000_context_desc { + union { + uint32_t ip_config; + struct { + uint8_t ipcss; /* IP checksum start */ + uint8_t ipcso; /* IP checksum offset */ + uint16_t ipcse; /* IP checksum end */ + } ip_fields; + } lower_setup; + union { + uint32_t tcp_config; + struct { + uint8_t tucss; /* TCP checksum start */ + uint8_t tucso; /* TCP checksum offset */ + uint16_t tucse; /* TCP checksum end */ + } tcp_fields; + } upper_setup; + uint32_t cmd_and_length; /* */ + union { + uint32_t data; + struct { + uint8_t status; /* Descriptor status */ + uint8_t hdr_len; /* Header length */ + uint16_t mss; /* Maximum segment size */ + } fields; + } tcp_seg_setup; +}; + +/* Offload data descriptor */ +struct e1000_data_desc { + uint64_t buffer_addr; /* Address of the descriptor's buffer ad= dress */ + union { + uint32_t data; + struct { + uint16_t length; /* Data buffer length */ + uint8_t typ_len_ext; /* */ + uint8_t cmd; /* */ + } flags; + } lower; + union { + uint32_t data; + struct { + uint8_t status; /* Descriptor status */ + uint8_t popts; /* Packet Options */ + uint16_t special; /* */ + } fields; + } upper; +}; + +/* Filters */ +#define E1000_NUM_UNICAST 16 /* Unicast filter entries */ +#define E1000_MC_TBL_SIZE 128 /* Multicast Filter Table (4096 = bits) */ +#define E1000_VLAN_FILTER_TBL_SIZE 128 /* VLAN Filter Table (4096 bits)= */ + +#define E1000_NUM_UNICAST_ICH8LAN 7 +#define E1000_MC_TBL_SIZE_ICH8LAN 32 + + +/* Receive Address Register */ +struct e1000_rar { + volatile uint32_t low; /* receive address low */ + volatile uint32_t high; /* receive address high */ +}; + +/* Number of entries in the Multicast Table Array (MTA). */ +#define E1000_NUM_MTA_REGISTERS 128 +#define E1000_NUM_MTA_REGISTERS_ICH8LAN 32 + +/* IPv4 Address Table Entry */ +struct e1000_ipv4_at_entry { + volatile uint32_t ipv4_addr; /* IP Address (RW) */ + volatile uint32_t reserved; +}; + +/* Four wakeup IP addresses are supported */ +#define E1000_WAKEUP_IP_ADDRESS_COUNT_MAX 4 +#define E1000_IP4AT_SIZE E1000_WAKEUP_IP_ADDRESS_COUNT_= MAX +#define E1000_IP4AT_SIZE_ICH8LAN 3 +#define E1000_IP6AT_SIZE 1 + +/* IPv6 Address Table Entry */ +struct e1000_ipv6_at_entry { + volatile uint8_t ipv6_addr[16]; +}; + +/* Flexible Filter Length Table Entry */ +struct e1000_fflt_entry { + volatile uint32_t length; /* Flexible Filter Length (RW) */ + volatile uint32_t reserved; +}; + +/* Flexible Filter Mask Table Entry */ +struct e1000_ffmt_entry { + volatile uint32_t mask; /* Flexible Filter Mask (RW) */ + volatile uint32_t reserved; +}; + +/* Flexible Filter Value Table Entry */ +struct e1000_ffvt_entry { + volatile uint32_t value; /* Flexible Filter Value (RW) */ + volatile uint32_t reserved; +}; + +/* Four Flexible Filters are supported */ +#define E1000_FLEXIBLE_FILTER_COUNT_MAX 4 + +/* Each Flexible Filter is at most 128 (0x80) bytes in length */ +#define E1000_FLEXIBLE_FILTER_SIZE_MAX 128 + +#define E1000_FFLT_SIZE E1000_FLEXIBLE_FILTER_COUNT_MAX +#define E1000_FFMT_SIZE E1000_FLEXIBLE_FILTER_SIZE_MAX +#define E1000_FFVT_SIZE E1000_FLEXIBLE_FILTER_SIZE_MAX + +#define E1000_DISABLE_SERDES_LOOPBACK 0x0400 + +/* Register Set. (82543, 82544) + * + * Registers are defined to be 32 bits and should be accessed as 32 bit= values. + * These registers are physically located on the NIC, but are mapped int= o the + * host memory address space. + * + * RW - register is both readable and writable + * RO - register is read only + * WO - register is write only + * R/clr - register is read only and is cleared when read + * A - register array + */ +#define E1000_CTRL 0x00000 /* Device Control - RW */ +#define E1000_CTRL_DUP 0x00004 /* Device Control Duplicate (Shadow) - R= W */ +#define E1000_STATUS 0x00008 /* Device Status - RO */ +#define E1000_EECD 0x00010 /* EEPROM/Flash Control - RW */ +#define E1000_EERD 0x00014 /* EEPROM Read - RW */ +#define E1000_CTRL_EXT 0x00018 /* Extended Device Control - RW */ +#define E1000_FLA 0x0001C /* Flash Access - RW */ +#define E1000_MDIC 0x00020 /* MDI Control - RW */ +#define E1000_SCTL 0x00024 /* SerDes Control - RW */ +#define E1000_FEXTNVM 0x00028 /* Future Extended NVM register */ +#define E1000_FCAL 0x00028 /* Flow Control Address Low - RW */ +#define E1000_FCAH 0x0002C /* Flow Control Address High -RW */ +#define E1000_FCT 0x00030 /* Flow Control Type - RW */ +#define E1000_VET 0x00038 /* VLAN Ether Type - RW */ +#define E1000_ICR 0x000C0 /* Interrupt Cause Read - R/clr */ +#define E1000_ITR 0x000C4 /* Interrupt Throttling Rate - RW */ +#define E1000_ICS 0x000C8 /* Interrupt Cause Set - WO */ +#define E1000_IMS 0x000D0 /* Interrupt Mask Set - RW */ +#define E1000_IMC 0x000D8 /* Interrupt Mask Clear - WO */ +#define E1000_IAM 0x000E0 /* Interrupt Acknowledge Auto Mask */ +#define E1000_RCTL 0x00100 /* RX Control - RW */ +#define E1000_RDTR1 0x02820 /* RX Delay Timer (1) - RW */ +#define E1000_RDBAL1 0x02900 /* RX Descriptor Base Address Low (1) - = RW */ +#define E1000_RDBAH1 0x02904 /* RX Descriptor Base Address High (1) -= RW */ +#define E1000_RDLEN1 0x02908 /* RX Descriptor Length (1) - RW */ +#define E1000_RDH1 0x02910 /* RX Descriptor Head (1) - RW */ +#define E1000_RDT1 0x02918 /* RX Descriptor Tail (1) - RW */ +#define E1000_FCTTV 0x00170 /* Flow Control Transmit Timer Value - R= W */ +#define E1000_TXCW 0x00178 /* TX Configuration Word - RW */ +#define E1000_RXCW 0x00180 /* RX Configuration Word - RO */ +#define E1000_TCTL 0x00400 /* TX Control - RW */ +#define E1000_TCTL_EXT 0x00404 /* Extended TX Control - RW */ +#define E1000_TIPG 0x00410 /* TX Inter-packet gap -RW */ +#define E1000_TBT 0x00448 /* TX Burst Timer - RW */ +#define E1000_AIT 0x00458 /* Adaptive Interframe Spacing Throttle = - RW */ +#define E1000_LEDCTL 0x00E00 /* LED Control - RW */ +#define E1000_EXTCNF_CTRL 0x00F00 /* Extended Configuration Control */ +#define E1000_EXTCNF_SIZE 0x00F08 /* Extended Configuration Size */ +#define E1000_PHY_CTRL 0x00F10 /* PHY Control Register in CSR */ +#define FEXTNVM_SW_CONFIG 0x0001 +#define E1000_PBA 0x01000 /* Packet Buffer Allocation - RW */ +#define E1000_PBS 0x01008 /* Packet Buffer Size */ +#define E1000_EEMNGCTL 0x01010 /* MNG EEprom Control */ +#define E1000_FLASH_UPDATES 1000 +#define E1000_EEARBC 0x01024 /* EEPROM Auto Read Bus Control */ +#define E1000_FLASHT 0x01028 /* FLASH Timer Register */ +#define E1000_EEWR 0x0102C /* EEPROM Write Register - RW */ +#define E1000_FLSWCTL 0x01030 /* FLASH control register */ +#define E1000_FLSWDATA 0x01034 /* FLASH data register */ +#define E1000_FLSWCNT 0x01038 /* FLASH Access Counter */ +#define E1000_FLOP 0x0103C /* FLASH Opcode Register */ +#define E1000_ERT 0x02008 /* Early Rx Threshold - RW */ +#define E1000_FCRTL 0x02160 /* Flow Control Receive Threshold Low - = RW */ +#define E1000_FCRTH 0x02168 /* Flow Control Receive Threshold High -= RW */ +#define E1000_PSRCTL 0x02170 /* Packet Split Receive Control - RW */ +#define E1000_RDBAL 0x02800 /* RX Descriptor Base Address Low - RW *= / +#define E1000_RDBAH 0x02804 /* RX Descriptor Base Address High - RW = */ +#define E1000_RDLEN 0x02808 /* RX Descriptor Length - RW */ +#define E1000_RDH 0x02810 /* RX Descriptor Head - RW */ +#define E1000_RDT 0x02818 /* RX Descriptor Tail - RW */ +#define E1000_RDTR 0x02820 /* RX Delay Timer - RW */ +#define E1000_RDBAL0 E1000_RDBAL /* RX Desc Base Address Low (0) - RW = */ +#define E1000_RDBAH0 E1000_RDBAH /* RX Desc Base Address High (0) - RW= */ +#define E1000_RDLEN0 E1000_RDLEN /* RX Desc Length (0) - RW */ +#define E1000_RDH0 E1000_RDH /* RX Desc Head (0) - RW */ +#define E1000_RDT0 E1000_RDT /* RX Desc Tail (0) - RW */ +#define E1000_RDTR0 E1000_RDTR /* RX Delay Timer (0) - RW */ +#define E1000_RXDCTL 0x02828 /* RX Descriptor Control queue 0 - RW */ +#define E1000_RXDCTL1 0x02928 /* RX Descriptor Control queue 1 - RW */ +#define E1000_RADV 0x0282C /* RX Interrupt Absolute Delay Timer - R= W */ +#define E1000_RSRPD 0x02C00 /* RX Small Packet Detect - RW */ +#define E1000_RAID 0x02C08 /* Receive Ack Interrupt Delay - RW */ +#define E1000_TXDMAC 0x03000 /* TX DMA Control - RW */ +#define E1000_KABGTXD 0x03004 /* AFE Band Gap Transmit Ref Data */ +#define E1000_TDFH 0x03410 /* TX Data FIFO Head - RW */ +#define E1000_TDFT 0x03418 /* TX Data FIFO Tail - RW */ +#define E1000_TDFHS 0x03420 /* TX Data FIFO Head Saved - RW */ +#define E1000_TDFTS 0x03428 /* TX Data FIFO Tail Saved - RW */ +#define E1000_TDFPC 0x03430 /* TX Data FIFO Packet Count - RW */ +#define E1000_TDBAL 0x03800 /* TX Descriptor Base Address Low - RW *= / +#define E1000_TDBAH 0x03804 /* TX Descriptor Base Address High - RW = */ +#define E1000_TDLEN 0x03808 /* TX Descriptor Length - RW */ +#define E1000_TDH 0x03810 /* TX Descriptor Head - RW */ +#define E1000_TDT 0x03818 /* TX Descripotr Tail - RW */ +#define E1000_TIDV 0x03820 /* TX Interrupt Delay Value - RW */ +#define E1000_TXDCTL 0x03828 /* TX Descriptor Control - RW */ +#define E1000_TADV 0x0382C /* TX Interrupt Absolute Delay Val - RW = */ +#define E1000_TSPMT 0x03830 /* TCP Segmentation PAD & Min Threshold = - RW */ +#define E1000_TARC0 0x03840 /* TX Arbitration Count (0) */ +#define E1000_TDBAL1 0x03900 /* TX Desc Base Address Low (1) - RW */ +#define E1000_TDBAH1 0x03904 /* TX Desc Base Address High (1) - RW */ +#define E1000_TDLEN1 0x03908 /* TX Desc Length (1) - RW */ +#define E1000_TDH1 0x03910 /* TX Desc Head (1) - RW */ +#define E1000_TDT1 0x03918 /* TX Desc Tail (1) - RW */ +#define E1000_TXDCTL1 0x03928 /* TX Descriptor Control (1) - RW */ +#define E1000_TARC1 0x03940 /* TX Arbitration Count (1) */ +#define E1000_CRCERRS 0x04000 /* CRC Error Count - R/clr */ +#define E1000_ALGNERRC 0x04004 /* Alignment Error Count - R/clr */ +#define E1000_SYMERRS 0x04008 /* Symbol Error Count - R/clr */ +#define E1000_RXERRC 0x0400C /* Receive Error Count - R/clr */ +#define E1000_MPC 0x04010 /* Missed Packet Count - R/clr */ +#define E1000_SCC 0x04014 /* Single Collision Count - R/clr */ +#define E1000_ECOL 0x04018 /* Excessive Collision Count - R/clr */ +#define E1000_MCC 0x0401C /* Multiple Collision Count - R/clr */ +#define E1000_LATECOL 0x04020 /* Late Collision Count - R/clr */ +#define E1000_COLC 0x04028 /* Collision Count - R/clr */ +#define E1000_DC 0x04030 /* Defer Count - R/clr */ +#define E1000_TNCRS 0x04034 /* TX-No CRS - R/clr */ +#define E1000_SEC 0x04038 /* Sequence Error Count - R/clr */ +#define E1000_CEXTERR 0x0403C /* Carrier Extension Error Count - R/clr= */ +#define E1000_RLEC 0x04040 /* Receive Length Error Count - R/clr */ +#define E1000_XONRXC 0x04048 /* XON RX Count - R/clr */ +#define E1000_XONTXC 0x0404C /* XON TX Count - R/clr */ +#define E1000_XOFFRXC 0x04050 /* XOFF RX Count - R/clr */ +#define E1000_XOFFTXC 0x04054 /* XOFF TX Count - R/clr */ +#define E1000_FCRUC 0x04058 /* Flow Control RX Unsupported Count- R/= clr */ +#define E1000_PRC64 0x0405C /* Packets RX (64 bytes) - R/clr */ +#define E1000_PRC127 0x04060 /* Packets RX (65-127 bytes) - R/clr */ +#define E1000_PRC255 0x04064 /* Packets RX (128-255 bytes) - R/clr */ +#define E1000_PRC511 0x04068 /* Packets RX (255-511 bytes) - R/clr */ +#define E1000_PRC1023 0x0406C /* Packets RX (512-1023 bytes) - R/clr *= / +#define E1000_PRC1522 0x04070 /* Packets RX (1024-1522 bytes) - R/clr = */ +#define E1000_GPRC 0x04074 /* Good Packets RX Count - R/clr */ +#define E1000_BPRC 0x04078 /* Broadcast Packets RX Count - R/clr */ +#define E1000_MPRC 0x0407C /* Multicast Packets RX Count - R/clr */ +#define E1000_GPTC 0x04080 /* Good Packets TX Count - R/clr */ +#define E1000_GORCL 0x04088 /* Good Octets RX Count Low - R/clr */ +#define E1000_GORCH 0x0408C /* Good Octets RX Count High - R/clr */ +#define E1000_GOTCL 0x04090 /* Good Octets TX Count Low - R/clr */ +#define E1000_GOTCH 0x04094 /* Good Octets TX Count High - R/clr */ +#define E1000_RNBC 0x040A0 /* RX No Buffers Count - R/clr */ +#define E1000_RUC 0x040A4 /* RX Undersize Count - R/clr */ +#define E1000_RFC 0x040A8 /* RX Fragment Count - R/clr */ +#define E1000_ROC 0x040AC /* RX Oversize Count - R/clr */ +#define E1000_RJC 0x040B0 /* RX Jabber Count - R/clr */ +#define E1000_MGTPRC 0x040B4 /* Management Packets RX Count - R/clr *= / +#define E1000_MGTPDC 0x040B8 /* Management Packets Dropped Count - R/= clr */ +#define E1000_MGTPTC 0x040BC /* Management Packets TX Count - R/clr *= / +#define E1000_TORL 0x040C0 /* Total Octets RX Low - R/clr */ +#define E1000_TORH 0x040C4 /* Total Octets RX High - R/clr */ +#define E1000_TOTL 0x040C8 /* Total Octets TX Low - R/clr */ +#define E1000_TOTH 0x040CC /* Total Octets TX High - R/clr */ +#define E1000_TPR 0x040D0 /* Total Packets RX - R/clr */ +#define E1000_TPT 0x040D4 /* Total Packets TX - R/clr */ +#define E1000_PTC64 0x040D8 /* Packets TX (64 bytes) - R/clr */ +#define E1000_PTC127 0x040DC /* Packets TX (65-127 bytes) - R/clr */ +#define E1000_PTC255 0x040E0 /* Packets TX (128-255 bytes) - R/clr */ +#define E1000_PTC511 0x040E4 /* Packets TX (256-511 bytes) - R/clr */ +#define E1000_PTC1023 0x040E8 /* Packets TX (512-1023 bytes) - R/clr *= / +#define E1000_PTC1522 0x040EC /* Packets TX (1024-1522 Bytes) - R/clr = */ +#define E1000_MPTC 0x040F0 /* Multicast Packets TX Count - R/clr */ +#define E1000_BPTC 0x040F4 /* Broadcast Packets TX Count - R/clr */ +#define E1000_TSCTC 0x040F8 /* TCP Segmentation Context TX - R/clr *= / +#define E1000_TSCTFC 0x040FC /* TCP Segmentation Context TX Fail - R/= clr */ +#define E1000_IAC 0x04100 /* Interrupt Assertion Count */ +#define E1000_ICRXPTC 0x04104 /* Interrupt Cause Rx Packet Timer Expir= e Count */ +#define E1000_ICRXATC 0x04108 /* Interrupt Cause Rx Absolute Timer Exp= ire Count */ +#define E1000_ICTXPTC 0x0410C /* Interrupt Cause Tx Packet Timer Expir= e Count */ +#define E1000_ICTXATC 0x04110 /* Interrupt Cause Tx Absolute Timer Exp= ire Count */ +#define E1000_ICTXQEC 0x04118 /* Interrupt Cause Tx Queue Empty Count = */ +#define E1000_ICTXQMTC 0x0411C /* Interrupt Cause Tx Queue Minimum Thre= shold Count */ +#define E1000_ICRXDMTC 0x04120 /* Interrupt Cause Rx Descriptor Minimum= Threshold Count */ +#define E1000_ICRXOC 0x04124 /* Interrupt Cause Receiver Overrun Coun= t */ +#define E1000_RXCSUM 0x05000 /* RX Checksum Control - RW */ +#define E1000_RFCTL 0x05008 /* Receive Filter Control*/ +#define E1000_MTA 0x05200 /* Multicast Table Array - RW Array */ +#define E1000_RA 0x05400 /* Receive Address - RW Array */ +#define E1000_VFTA 0x05600 /* VLAN Filter Table Array - RW Array */ +#define E1000_WUC 0x05800 /* Wakeup Control - RW */ +#define E1000_WUFC 0x05808 /* Wakeup Filter Control - RW */ +#define E1000_WUS 0x05810 /* Wakeup Status - RO */ +#define E1000_MANC 0x05820 /* Management Control - RW */ +#define E1000_IPAV 0x05838 /* IP Address Valid - RW */ +#define E1000_IP4AT 0x05840 /* IPv4 Address Table - RW Array */ +#define E1000_IP6AT 0x05880 /* IPv6 Address Table - RW Array */ +#define E1000_WUPL 0x05900 /* Wakeup Packet Length - RW */ +#define E1000_WUPM 0x05A00 /* Wakeup Packet Memory - RO A */ +#define E1000_FFLT 0x05F00 /* Flexible Filter Length Table - RW Arr= ay */ +#define E1000_HOST_IF 0x08800 /* Host Interface */ +#define E1000_FFMT 0x09000 /* Flexible Filter Mask Table - RW Array= */ +#define E1000_FFVT 0x09800 /* Flexible Filter Value Table - RW Arra= y */ + +#define E1000_KUMCTRLSTA 0x00034 /* MAC-PHY interface - RW */ +#define E1000_MDPHYA 0x0003C /* PHY address - RW */ +#define E1000_MANC2H 0x05860 /* Managment Control To Host - RW */ +#define E1000_SW_FW_SYNC 0x05B5C /* Software-Firmware Synchronization - = RW */ + +#define E1000_GCR 0x05B00 /* PCI-Ex Control */ +#define E1000_GSCL_1 0x05B10 /* PCI-Ex Statistic Control #1 */ +#define E1000_GSCL_2 0x05B14 /* PCI-Ex Statistic Control #2 */ +#define E1000_GSCL_3 0x05B18 /* PCI-Ex Statistic Control #3 */ +#define E1000_GSCL_4 0x05B1C /* PCI-Ex Statistic Control #4 */ +#define E1000_FACTPS 0x05B30 /* Function Active and Power State to MN= G */ +#define E1000_SWSM 0x05B50 /* SW Semaphore */ +#define E1000_FWSM 0x05B54 /* FW Semaphore */ +#define E1000_FFLT_DBG 0x05F04 /* Debug Register */ +#define E1000_HICR 0x08F00 /* Host Inteface Control */ + +/* RSS registers */ +#define E1000_CPUVEC 0x02C10 /* CPU Vector Register - RW */ +#define E1000_MRQC 0x05818 /* Multiple Receive Control - RW */ +#define E1000_RETA 0x05C00 /* Redirection Table - RW Array */ +#define E1000_RSSRK 0x05C80 /* RSS Random Key - RW Array */ +#define E1000_RSSIM 0x05864 /* RSS Interrupt Mask */ +#define E1000_RSSIR 0x05868 /* RSS Interrupt Request */ +/* Register Set (82542) + * + * Some of the 82542 registers are located at different offsets than the= y are + * in more current versions of the 8254x. Despite the difference in loca= tion, + * the registers function in the same manner. + */ +#define E1000_82542_CTRL E1000_CTRL +#define E1000_82542_CTRL_DUP E1000_CTRL_DUP +#define E1000_82542_STATUS E1000_STATUS +#define E1000_82542_EECD E1000_EECD +#define E1000_82542_EERD E1000_EERD +#define E1000_82542_CTRL_EXT E1000_CTRL_EXT +#define E1000_82542_FLA E1000_FLA +#define E1000_82542_MDIC E1000_MDIC +#define E1000_82542_SCTL E1000_SCTL +#define E1000_82542_FEXTNVM E1000_FEXTNVM +#define E1000_82542_FCAL E1000_FCAL +#define E1000_82542_FCAH E1000_FCAH +#define E1000_82542_FCT E1000_FCT +#define E1000_82542_VET E1000_VET +#define E1000_82542_RA 0x00040 +#define E1000_82542_ICR E1000_ICR +#define E1000_82542_ITR E1000_ITR +#define E1000_82542_ICS E1000_ICS +#define E1000_82542_IMS E1000_IMS +#define E1000_82542_IMC E1000_IMC +#define E1000_82542_RCTL E1000_RCTL +#define E1000_82542_RDTR 0x00108 +#define E1000_82542_RDBAL 0x00110 +#define E1000_82542_RDBAH 0x00114 +#define E1000_82542_RDLEN 0x00118 +#define E1000_82542_RDH 0x00120 +#define E1000_82542_RDT 0x00128 +#define E1000_82542_RDTR0 E1000_82542_RDTR +#define E1000_82542_RDBAL0 E1000_82542_RDBAL +#define E1000_82542_RDBAH0 E1000_82542_RDBAH +#define E1000_82542_RDLEN0 E1000_82542_RDLEN +#define E1000_82542_RDH0 E1000_82542_RDH +#define E1000_82542_RDT0 E1000_82542_RDT +#define E1000_82542_SRRCTL(_n) (0x280C + ((_n) << 8)) /* Split and Repli= cation + * RX Control - RW= */ +#define E1000_82542_DCA_RXCTRL(_n) (0x02814 + ((_n) << 8)) +#define E1000_82542_RDBAH3 0x02B04 /* RX Desc Base High Queue 3 - RW *= / +#define E1000_82542_RDBAL3 0x02B00 /* RX Desc Low Queue 3 - RW */ +#define E1000_82542_RDLEN3 0x02B08 /* RX Desc Length Queue 3 - RW */ +#define E1000_82542_RDH3 0x02B10 /* RX Desc Head Queue 3 - RW */ +#define E1000_82542_RDT3 0x02B18 /* RX Desc Tail Queue 3 - RW */ +#define E1000_82542_RDBAL2 0x02A00 /* RX Desc Base Low Queue 2 - RW */ +#define E1000_82542_RDBAH2 0x02A04 /* RX Desc Base High Queue 2 - RW *= / +#define E1000_82542_RDLEN2 0x02A08 /* RX Desc Length Queue 2 - RW */ +#define E1000_82542_RDH2 0x02A10 /* RX Desc Head Queue 2 - RW */ +#define E1000_82542_RDT2 0x02A18 /* RX Desc Tail Queue 2 - RW */ +#define E1000_82542_RDTR1 0x00130 +#define E1000_82542_RDBAL1 0x00138 +#define E1000_82542_RDBAH1 0x0013C +#define E1000_82542_RDLEN1 0x00140 +#define E1000_82542_RDH1 0x00148 +#define E1000_82542_RDT1 0x00150 +#define E1000_82542_FCRTH 0x00160 +#define E1000_82542_FCRTL 0x00168 +#define E1000_82542_FCTTV E1000_FCTTV +#define E1000_82542_TXCW E1000_TXCW +#define E1000_82542_RXCW E1000_RXCW +#define E1000_82542_MTA 0x00200 +#define E1000_82542_TCTL E1000_TCTL +#define E1000_82542_TCTL_EXT E1000_TCTL_EXT +#define E1000_82542_TIPG E1000_TIPG +#define E1000_82542_TDBAL 0x00420 +#define E1000_82542_TDBAH 0x00424 +#define E1000_82542_TDLEN 0x00428 +#define E1000_82542_TDH 0x00430 +#define E1000_82542_TDT 0x00438 +#define E1000_82542_TIDV 0x00440 +#define E1000_82542_TBT E1000_TBT +#define E1000_82542_AIT E1000_AIT +#define E1000_82542_VFTA 0x00600 +#define E1000_82542_LEDCTL E1000_LEDCTL +#define E1000_82542_PBA E1000_PBA +#define E1000_82542_PBS E1000_PBS +#define E1000_82542_EEMNGCTL E1000_EEMNGCTL +#define E1000_82542_EEARBC E1000_EEARBC +#define E1000_82542_FLASHT E1000_FLASHT +#define E1000_82542_EEWR E1000_EEWR +#define E1000_82542_FLSWCTL E1000_FLSWCTL +#define E1000_82542_FLSWDATA E1000_FLSWDATA +#define E1000_82542_FLSWCNT E1000_FLSWCNT +#define E1000_82542_FLOP E1000_FLOP +#define E1000_82542_EXTCNF_CTRL E1000_EXTCNF_CTRL +#define E1000_82542_EXTCNF_SIZE E1000_EXTCNF_SIZE +#define E1000_82542_PHY_CTRL E1000_PHY_CTRL +#define E1000_82542_ERT E1000_ERT +#define E1000_82542_RXDCTL E1000_RXDCTL +#define E1000_82542_RXDCTL1 E1000_RXDCTL1 +#define E1000_82542_RADV E1000_RADV +#define E1000_82542_RSRPD E1000_RSRPD +#define E1000_82542_TXDMAC E1000_TXDMAC +#define E1000_82542_KABGTXD E1000_KABGTXD +#define E1000_82542_TDFHS E1000_TDFHS +#define E1000_82542_TDFTS E1000_TDFTS +#define E1000_82542_TDFPC E1000_TDFPC +#define E1000_82542_TXDCTL E1000_TXDCTL +#define E1000_82542_TADV E1000_TADV +#define E1000_82542_TSPMT E1000_TSPMT +#define E1000_82542_CRCERRS E1000_CRCERRS +#define E1000_82542_ALGNERRC E1000_ALGNERRC +#define E1000_82542_SYMERRS E1000_SYMERRS +#define E1000_82542_RXERRC E1000_RXERRC +#define E1000_82542_MPC E1000_MPC +#define E1000_82542_SCC E1000_SCC +#define E1000_82542_ECOL E1000_ECOL +#define E1000_82542_MCC E1000_MCC +#define E1000_82542_LATECOL E1000_LATECOL +#define E1000_82542_COLC E1000_COLC +#define E1000_82542_DC E1000_DC +#define E1000_82542_TNCRS E1000_TNCRS +#define E1000_82542_SEC E1000_SEC +#define E1000_82542_CEXTERR E1000_CEXTERR +#define E1000_82542_RLEC E1000_RLEC +#define E1000_82542_XONRXC E1000_XONRXC +#define E1000_82542_XONTXC E1000_XONTXC +#define E1000_82542_XOFFRXC E1000_XOFFRXC +#define E1000_82542_XOFFTXC E1000_XOFFTXC +#define E1000_82542_FCRUC E1000_FCRUC +#define E1000_82542_PRC64 E1000_PRC64 +#define E1000_82542_PRC127 E1000_PRC127 +#define E1000_82542_PRC255 E1000_PRC255 +#define E1000_82542_PRC511 E1000_PRC511 +#define E1000_82542_PRC1023 E1000_PRC1023 +#define E1000_82542_PRC1522 E1000_PRC1522 +#define E1000_82542_GPRC E1000_GPRC +#define E1000_82542_BPRC E1000_BPRC +#define E1000_82542_MPRC E1000_MPRC +#define E1000_82542_GPTC E1000_GPTC +#define E1000_82542_GORCL E1000_GORCL +#define E1000_82542_GORCH E1000_GORCH +#define E1000_82542_GOTCL E1000_GOTCL +#define E1000_82542_GOTCH E1000_GOTCH +#define E1000_82542_RNBC E1000_RNBC +#define E1000_82542_RUC E1000_RUC +#define E1000_82542_RFC E1000_RFC +#define E1000_82542_ROC E1000_ROC +#define E1000_82542_RJC E1000_RJC +#define E1000_82542_MGTPRC E1000_MGTPRC +#define E1000_82542_MGTPDC E1000_MGTPDC +#define E1000_82542_MGTPTC E1000_MGTPTC +#define E1000_82542_TORL E1000_TORL +#define E1000_82542_TORH E1000_TORH +#define E1000_82542_TOTL E1000_TOTL +#define E1000_82542_TOTH E1000_TOTH +#define E1000_82542_TPR E1000_TPR +#define E1000_82542_TPT E1000_TPT +#define E1000_82542_PTC64 E1000_PTC64 +#define E1000_82542_PTC127 E1000_PTC127 +#define E1000_82542_PTC255 E1000_PTC255 +#define E1000_82542_PTC511 E1000_PTC511 +#define E1000_82542_PTC1023 E1000_PTC1023 +#define E1000_82542_PTC1522 E1000_PTC1522 +#define E1000_82542_MPTC E1000_MPTC +#define E1000_82542_BPTC E1000_BPTC +#define E1000_82542_TSCTC E1000_TSCTC +#define E1000_82542_TSCTFC E1000_TSCTFC +#define E1000_82542_RXCSUM E1000_RXCSUM +#define E1000_82542_WUC E1000_WUC +#define E1000_82542_WUFC E1000_WUFC +#define E1000_82542_WUS E1000_WUS +#define E1000_82542_MANC E1000_MANC +#define E1000_82542_IPAV E1000_IPAV +#define E1000_82542_IP4AT E1000_IP4AT +#define E1000_82542_IP6AT E1000_IP6AT +#define E1000_82542_WUPL E1000_WUPL +#define E1000_82542_WUPM E1000_WUPM +#define E1000_82542_FFLT E1000_FFLT +#define E1000_82542_TDFH 0x08010 +#define E1000_82542_TDFT 0x08018 +#define E1000_82542_FFMT E1000_FFMT +#define E1000_82542_FFVT E1000_FFVT +#define E1000_82542_HOST_IF E1000_HOST_IF +#define E1000_82542_IAM E1000_IAM +#define E1000_82542_EEMNGCTL E1000_EEMNGCTL +#define E1000_82542_PSRCTL E1000_PSRCTL +#define E1000_82542_RAID E1000_RAID +#define E1000_82542_TARC0 E1000_TARC0 +#define E1000_82542_TDBAL1 E1000_TDBAL1 +#define E1000_82542_TDBAH1 E1000_TDBAH1 +#define E1000_82542_TDLEN1 E1000_TDLEN1 +#define E1000_82542_TDH1 E1000_TDH1 +#define E1000_82542_TDT1 E1000_TDT1 +#define E1000_82542_TXDCTL1 E1000_TXDCTL1 +#define E1000_82542_TARC1 E1000_TARC1 +#define E1000_82542_RFCTL E1000_RFCTL +#define E1000_82542_GCR E1000_GCR +#define E1000_82542_GSCL_1 E1000_GSCL_1 +#define E1000_82542_GSCL_2 E1000_GSCL_2 +#define E1000_82542_GSCL_3 E1000_GSCL_3 +#define E1000_82542_GSCL_4 E1000_GSCL_4 +#define E1000_82542_FACTPS E1000_FACTPS +#define E1000_82542_SWSM E1000_SWSM +#define E1000_82542_FWSM E1000_FWSM +#define E1000_82542_FFLT_DBG E1000_FFLT_DBG +#define E1000_82542_IAC E1000_IAC +#define E1000_82542_ICRXPTC E1000_ICRXPTC +#define E1000_82542_ICRXATC E1000_ICRXATC +#define E1000_82542_ICTXPTC E1000_ICTXPTC +#define E1000_82542_ICTXATC E1000_ICTXATC +#define E1000_82542_ICTXQEC E1000_ICTXQEC +#define E1000_82542_ICTXQMTC E1000_ICTXQMTC +#define E1000_82542_ICRXDMTC E1000_ICRXDMTC +#define E1000_82542_ICRXOC E1000_ICRXOC +#define E1000_82542_HICR E1000_HICR + +#define E1000_82542_CPUVEC E1000_CPUVEC +#define E1000_82542_MRQC E1000_MRQC +#define E1000_82542_RETA E1000_RETA +#define E1000_82542_RSSRK E1000_RSSRK +#define E1000_82542_RSSIM E1000_RSSIM +#define E1000_82542_RSSIR E1000_RSSIR +#define E1000_82542_KUMCTRLSTA E1000_KUMCTRLSTA +#define E1000_82542_SW_FW_SYNC E1000_SW_FW_SYNC +#define E1000_82542_MANC2H E1000_MANC2H + +/* Statistics counters collected by the MAC */ +struct e1000_hw_stats { + uint64_t crcerrs; + uint64_t algnerrc; + uint64_t symerrs; + uint64_t rxerrc; + uint64_t txerrc; + uint64_t mpc; + uint64_t scc; + uint64_t ecol; + uint64_t mcc; + uint64_t latecol; + uint64_t colc; + uint64_t dc; + uint64_t tncrs; + uint64_t sec; + uint64_t cexterr; + uint64_t rlec; + uint64_t xonrxc; + uint64_t xontxc; + uint64_t xoffrxc; + uint64_t xofftxc; + uint64_t fcruc; + uint64_t prc64; + uint64_t prc127; + uint64_t prc255; + uint64_t prc511; + uint64_t prc1023; + uint64_t prc1522; + uint64_t gprc; + uint64_t bprc; + uint64_t mprc; + uint64_t gptc; + uint64_t gorcl; + uint64_t gorch; + uint64_t gotcl; + uint64_t gotch; + uint64_t rnbc; + uint64_t ruc; + uint64_t rfc; + uint64_t roc; + uint64_t rlerrc; + uint64_t rjc; + uint64_t mgprc; + uint64_t mgpdc; + uint64_t mgptc; + uint64_t torl; + uint64_t torh; + uint64_t totl; + uint64_t toth; + uint64_t tpr; + uint64_t tpt; + uint64_t ptc64; + uint64_t ptc127; + uint64_t ptc255; + uint64_t ptc511; + uint64_t ptc1023; + uint64_t ptc1522; + uint64_t mptc; + uint64_t bptc; + uint64_t tsctc; + uint64_t tsctfc; + uint64_t iac; + uint64_t icrxptc; + uint64_t icrxatc; + uint64_t ictxptc; + uint64_t ictxatc; + uint64_t ictxqec; + uint64_t ictxqmtc; + uint64_t icrxdmtc; + uint64_t icrxoc; +}; + +/* Structure containing variables used by the shared code (e1000_hw.c) *= / +struct e1000_hw { + uint8_t __iomem *hw_addr; + uint8_t __iomem *flash_address; + e1000_mac_type mac_type; + e1000_phy_type phy_type; + uint32_t phy_init_script; + e1000_media_type media_type; + void *back; + struct e1000_shadow_ram *eeprom_shadow_ram; + uint32_t flash_bank_size; + uint32_t flash_base_addr; + e1000_fc_type fc; + e1000_bus_speed bus_speed; + e1000_bus_width bus_width; + e1000_bus_type bus_type; + struct e1000_eeprom_info eeprom; + e1000_ms_type master_slave; + e1000_ms_type original_master_slave; + e1000_ffe_config ffe_config_state; + uint32_t asf_firmware_present; + uint32_t eeprom_semaphore_present; + uint32_t swfw_sync_present; + uint32_t swfwhw_semaphore_present; + unsigned long io_base; + uint32_t phy_id; + uint32_t phy_revision; + uint32_t phy_addr; + uint32_t original_fc; + uint32_t txcw; + uint32_t autoneg_failed; + uint32_t max_frame_size; + uint32_t min_frame_size; + uint32_t mc_filter_type; + uint32_t num_mc_addrs; + uint32_t collision_delta; + uint32_t tx_packet_delta; + uint32_t ledctl_default; + uint32_t ledctl_mode1; + uint32_t ledctl_mode2; + boolean_t tx_pkt_filtering; + struct e1000_host_mng_dhcp_cookie mng_cookie; + uint16_t phy_spd_default; + uint16_t autoneg_advertised; + uint16_t pci_cmd_word; + uint16_t fc_high_water; + uint16_t fc_low_water; + uint16_t fc_pause_time; + uint16_t current_ifs_val; + uint16_t ifs_min_val; + uint16_t ifs_max_val; + uint16_t ifs_step_size; + uint16_t ifs_ratio; + uint16_t device_id; + uint16_t vendor_id; + uint16_t subsystem_id; + uint16_t subsystem_vendor_id; + uint8_t revision_id; + uint8_t autoneg; + uint8_t mdix; + uint8_t forced_speed_duplex; + uint8_t wait_autoneg_complete; + uint8_t dma_fairness; + uint8_t mac_addr[NODE_ADDRESS_SIZE]; + uint8_t perm_mac_addr[NODE_ADDRESS_SIZE]; + boolean_t disable_polarity_correction; + boolean_t speed_downgraded; + e1000_smart_speed smart_speed; + e1000_dsp_config dsp_config_state; + boolean_t get_link_status; + boolean_t serdes_link_down; + boolean_t tbi_compatibility_en; + boolean_t tbi_compatibility_on; + boolean_t laa_is_present; + boolean_t phy_reset_disable; + boolean_t initialize_hw_bits_disable; + boolean_t fc_send_xon; + boolean_t fc_strict_ieee; + boolean_t report_tx_early; + boolean_t adaptive_ifs; + boolean_t ifs_params_forced; + boolean_t in_ifs_mode; + boolean_t mng_reg_access_disabled; + boolean_t leave_av_bit_off; + boolean_t kmrn_lock_loss_workaround_disabled; + boolean_t bad_tx_carr_stats_fd; + boolean_t has_manc2h; + boolean_t rx_needs_kicking; + boolean_t has_smbus; +}; + + +#define E1000_EEPROM_SWDPIN0 0x0001 /* SWDPIN 0 EEPROM Value */ +#define E1000_EEPROM_LED_LOGIC 0x0020 /* Led Logic Word */ +#define E1000_EEPROM_RW_REG_DATA 16 /* Offset to data in EEPROM read= /write registers */ +#define E1000_EEPROM_RW_REG_DONE 2 /* Offset to READ/WRITE done bit= */ +#define E1000_EEPROM_RW_REG_START 1 /* First bit for telling part to= start operation */ +#define E1000_EEPROM_RW_ADDR_SHIFT 2 /* Shift to the address bits */ +#define E1000_EEPROM_POLL_WRITE 1 /* Flag for polling for write co= mplete */ +#define E1000_EEPROM_POLL_READ 0 /* Flag for polling for read com= plete */ +/* Register Bit Masks */ +/* Device Control */ +#define E1000_CTRL_FD 0x00000001 /* Full duplex.0=3Dhalf; 1=3Dful= l */ +#define E1000_CTRL_BEM 0x00000002 /* Endian Mode.0=3Dlittle,1=3Dbi= g */ +#define E1000_CTRL_PRIOR 0x00000004 /* Priority on PCI. 0=3Drx,1=3Df= air */ +#define E1000_CTRL_GIO_MASTER_DISABLE 0x00000004 /*Blocks new Master req= uests */ +#define E1000_CTRL_LRST 0x00000008 /* Link reset. 0=3Dnormal,1=3Dre= set */ +#define E1000_CTRL_TME 0x00000010 /* Test mode. 0=3Dnormal,1=3Dtes= t */ +#define E1000_CTRL_SLE 0x00000020 /* Serial Link on 0=3Ddis,1=3Den= */ +#define E1000_CTRL_ASDE 0x00000020 /* Auto-speed detect enable */ +#define E1000_CTRL_SLU 0x00000040 /* Set link up (Force Link) */ +#define E1000_CTRL_ILOS 0x00000080 /* Invert Loss-Of Signal */ +#define E1000_CTRL_SPD_SEL 0x00000300 /* Speed Select Mask */ +#define E1000_CTRL_SPD_10 0x00000000 /* Force 10Mb */ +#define E1000_CTRL_SPD_100 0x00000100 /* Force 100Mb */ +#define E1000_CTRL_SPD_1000 0x00000200 /* Force 1Gb */ +#define E1000_CTRL_BEM32 0x00000400 /* Big Endian 32 mode */ +#define E1000_CTRL_FRCSPD 0x00000800 /* Force Speed */ +#define E1000_CTRL_FRCDPX 0x00001000 /* Force Duplex */ +#define E1000_CTRL_D_UD_EN 0x00002000 /* Dock/Undock enable */ +#define E1000_CTRL_D_UD_POLARITY 0x00004000 /* Defined polarity of Dock/= Undock indication in SDP[0] */ +#define E1000_CTRL_FORCE_PHY_RESET 0x00008000 /* Reset both PHY ports, t= hrough PHYRST_N pin */ +#define E1000_CTRL_EXT_LINK_EN 0x00010000 /* enable link status from ext= ernal LINK_0 and LINK_1 pins */ +#define E1000_CTRL_SWDPIN0 0x00040000 /* SWDPIN 0 value */ +#define E1000_CTRL_SWDPIN1 0x00080000 /* SWDPIN 1 value */ +#define E1000_CTRL_SWDPIN2 0x00100000 /* SWDPIN 2 value */ +#define E1000_CTRL_SWDPIN3 0x00200000 /* SWDPIN 3 value */ +#define E1000_CTRL_SWDPIO0 0x00400000 /* SWDPIN 0 Input or output */ +#define E1000_CTRL_SWDPIO1 0x00800000 /* SWDPIN 1 input or output */ +#define E1000_CTRL_SWDPIO2 0x01000000 /* SWDPIN 2 input or output */ +#define E1000_CTRL_SWDPIO3 0x02000000 /* SWDPIN 3 input or output */ +#define E1000_CTRL_RST 0x04000000 /* Global reset */ +#define E1000_CTRL_RFCE 0x08000000 /* Receive Flow Control enable *= / +#define E1000_CTRL_TFCE 0x10000000 /* Transmit flow control enable = */ +#define E1000_CTRL_RTE 0x20000000 /* Routing tag enable */ +#define E1000_CTRL_VME 0x40000000 /* IEEE VLAN mode enable */ +#define E1000_CTRL_PHY_RST 0x80000000 /* PHY Reset */ +#define E1000_CTRL_SW2FW_INT 0x02000000 /* Initiate an interrupt to man= ageability engine */ + +/* Device Status */ +#define E1000_STATUS_FD 0x00000001 /* Full duplex.0=3Dhalf,= 1=3Dfull */ +#define E1000_STATUS_LU 0x00000002 /* Link up.0=3Dno,1=3Dli= nk */ +#define E1000_STATUS_FUNC_MASK 0x0000000C /* PCI Function Mask */ +#define E1000_STATUS_FUNC_SHIFT 2 +#define E1000_STATUS_FUNC_0 0x00000000 /* Function 0 */ +#define E1000_STATUS_FUNC_1 0x00000004 /* Function 1 */ +#define E1000_STATUS_TXOFF 0x00000010 /* transmission paused *= / +#define E1000_STATUS_TBIMODE 0x00000020 /* TBI mode */ +#define E1000_STATUS_SPEED_MASK 0x000000C0 +#define E1000_STATUS_SPEED_10 0x00000000 /* Speed 10Mb/s */ +#define E1000_STATUS_SPEED_100 0x00000040 /* Speed 100Mb/s */ +#define E1000_STATUS_SPEED_1000 0x00000080 /* Speed 1000Mb/s */ +#define E1000_STATUS_LAN_INIT_DONE 0x00000200 /* Lan Init Completion + by EEPROM/Flash */ +#define E1000_STATUS_ASDV 0x00000300 /* Auto speed detect val= ue */ +#define E1000_STATUS_DOCK_CI 0x00000800 /* Change in Dock/Undock= state. Clear on write '0'. */ +#define E1000_STATUS_GIO_MASTER_ENABLE 0x00080000 /* Status of Master re= quests. */ +#define E1000_STATUS_MTXCKOK 0x00000400 /* MTX clock running OK = */ +#define E1000_STATUS_PCI66 0x00000800 /* In 66Mhz slot */ +#define E1000_STATUS_BUS64 0x00001000 /* In 64 bit slot */ +#define E1000_STATUS_PCIX_MODE 0x00002000 /* PCI-X mode */ +#define E1000_STATUS_PCIX_SPEED 0x0000C000 /* PCI-X bus speed */ +#define E1000_STATUS_BMC_SKU_0 0x00100000 /* BMC USB redirect disabled = */ +#define E1000_STATUS_BMC_SKU_1 0x00200000 /* BMC SRAM disabled */ +#define E1000_STATUS_BMC_SKU_2 0x00400000 /* BMC SDRAM disabled */ +#define E1000_STATUS_BMC_CRYPTO 0x00800000 /* BMC crypto disabled */ +#define E1000_STATUS_BMC_LITE 0x01000000 /* BMC external code executio= n disabled */ +#define E1000_STATUS_RGMII_ENABLE 0x02000000 /* RGMII disabled */ +#define E1000_STATUS_FUSE_8 0x04000000 +#define E1000_STATUS_FUSE_9 0x08000000 +#define E1000_STATUS_SERDES0_DIS 0x10000000 /* SERDES disabled on port = 0 */ +#define E1000_STATUS_SERDES1_DIS 0x20000000 /* SERDES disabled on port = 1 */ + +/* Constants used to intrepret the masked PCI-X bus speed. */ +#define E1000_STATUS_PCIX_SPEED_66 0x00000000 /* PCI-X bus speed 50-66= MHz */ +#define E1000_STATUS_PCIX_SPEED_100 0x00004000 /* PCI-X bus speed 66-10= 0 MHz */ +#define E1000_STATUS_PCIX_SPEED_133 0x00008000 /* PCI-X bus speed 100-13= 3 MHz */ + +/* EEPROM/Flash Control */ +#define E1000_EECD_SK 0x00000001 /* EEPROM Clock */ +#define E1000_EECD_CS 0x00000002 /* EEPROM Chip Select */ +#define E1000_EECD_DI 0x00000004 /* EEPROM Data In */ +#define E1000_EECD_DO 0x00000008 /* EEPROM Data Out */ +#define E1000_EECD_FWE_MASK 0x00000030 +#define E1000_EECD_FWE_DIS 0x00000010 /* Disable FLASH writes */ +#define E1000_EECD_FWE_EN 0x00000020 /* Enable FLASH writes */ +#define E1000_EECD_FWE_SHIFT 4 +#define E1000_EECD_REQ 0x00000040 /* EEPROM Access Request */ +#define E1000_EECD_GNT 0x00000080 /* EEPROM Access Grant */ +#define E1000_EECD_PRES 0x00000100 /* EEPROM Present */ +#define E1000_EECD_SIZE 0x00000200 /* EEPROM Size (0=3D64 word 1=3D= 256 word) */ +#define E1000_EECD_ADDR_BITS 0x00000400 /* EEPROM Addressing bits based = on type + * (0-small, 1-large) */ +#define E1000_EECD_TYPE 0x00002000 /* EEPROM Type (1-SPI, 0-Microwi= re) */ +#ifndef E1000_EEPROM_GRANT_ATTEMPTS +#define E1000_EEPROM_GRANT_ATTEMPTS 1000 /* EEPROM # attempts to gain gr= ant */ +#endif +#define E1000_EECD_AUTO_RD 0x00000200 /* EEPROM Auto Read done= */ +#define E1000_EECD_SIZE_EX_MASK 0x00007800 /* EEprom Size */ +#define E1000_EECD_SIZE_EX_SHIFT 11 +#define E1000_EECD_NVADDS 0x00018000 /* NVM Address Size */ +#define E1000_EECD_SELSHAD 0x00020000 /* Select Shadow RAM */ +#define E1000_EECD_INITSRAM 0x00040000 /* Initialize Shadow RAM */ +#define E1000_EECD_FLUPD 0x00080000 /* Update FLASH */ +#define E1000_EECD_AUPDEN 0x00100000 /* Enable Autonomous FLASH updat= e */ +#define E1000_EECD_SHADV 0x00200000 /* Shadow RAM Data Valid */ +#define E1000_EECD_SEC1VAL 0x00400000 /* Sector One Valid */ +#define E1000_EECD_SECVAL_SHIFT 22 +#define E1000_STM_OPCODE 0xDB00 +#define E1000_HICR_FW_RESET 0xC0 + +#define E1000_SHADOW_RAM_WORDS 2048 +#define E1000_ICH_NVM_SIG_WORD 0x13 +#define E1000_ICH_NVM_SIG_MASK 0xC0 + +/* EEPROM Read */ +#define E1000_EERD_START 0x00000001 /* Start Read */ +#define E1000_EERD_DONE 0x00000010 /* Read Done */ +#define E1000_EERD_ADDR_SHIFT 8 +#define E1000_EERD_ADDR_MASK 0x0000FF00 /* Read Address */ +#define E1000_EERD_DATA_SHIFT 16 +#define E1000_EERD_DATA_MASK 0xFFFF0000 /* Read Data */ + +/* SPI EEPROM Status Register */ +#define EEPROM_STATUS_RDY_SPI 0x01 +#define EEPROM_STATUS_WEN_SPI 0x02 +#define EEPROM_STATUS_BP0_SPI 0x04 +#define EEPROM_STATUS_BP1_SPI 0x08 +#define EEPROM_STATUS_WPEN_SPI 0x80 + +/* Extended Device Control */ +#define E1000_CTRL_EXT_GPI0_EN 0x00000001 /* Maps SDP4 to GPI0 */ +#define E1000_CTRL_EXT_GPI1_EN 0x00000002 /* Maps SDP5 to GPI1 */ +#define E1000_CTRL_EXT_PHYINT_EN E1000_CTRL_EXT_GPI1_EN +#define E1000_CTRL_EXT_GPI2_EN 0x00000004 /* Maps SDP6 to GPI2 */ +#define E1000_CTRL_EXT_GPI3_EN 0x00000008 /* Maps SDP7 to GPI3 */ +#define E1000_CTRL_EXT_SDP4_DATA 0x00000010 /* Value of SW Defineable Pi= n 4 */ +#define E1000_CTRL_EXT_SDP5_DATA 0x00000020 /* Value of SW Defineable Pi= n 5 */ +#define E1000_CTRL_EXT_PHY_INT E1000_CTRL_EXT_SDP5_DATA +#define E1000_CTRL_EXT_SDP6_DATA 0x00000040 /* Value of SW Defineable Pi= n 6 */ +#define E1000_CTRL_EXT_SDP7_DATA 0x00000080 /* Value of SW Defineable Pi= n 7 */ +#define E1000_CTRL_EXT_SDP4_DIR 0x00000100 /* Direction of SDP4 0=3Din = 1=3Dout */ +#define E1000_CTRL_EXT_SDP5_DIR 0x00000200 /* Direction of SDP5 0=3Din = 1=3Dout */ +#define E1000_CTRL_EXT_SDP6_DIR 0x00000400 /* Direction of SDP6 0=3Din = 1=3Dout */ +#define E1000_CTRL_EXT_SDP7_DIR 0x00000800 /* Direction of SDP7 0=3Din = 1=3Dout */ +#define E1000_CTRL_EXT_ASDCHK 0x00001000 /* Initiate an ASD sequence = */ +#define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM = */ +#define E1000_CTRL_EXT_IPS 0x00004000 /* Invert Power State */ +#define E1000_CTRL_EXT_SPD_BYPS 0x00008000 /* Speed Select Bypass */ +#define E1000_CTRL_EXT_RO_DIS 0x00020000 /* Relaxed Ordering disable = */ +#define E1000_CTRL_EXT_LINK_MODE_MASK 0x00C00000 +#define E1000_CTRL_EXT_LINK_MODE_GMII 0x00000000 +#define E1000_CTRL_EXT_LINK_MODE_TBI 0x00C00000 +#define E1000_CTRL_EXT_LINK_MODE_KMRN 0x00000000 +#define E1000_CTRL_EXT_LINK_MODE_SERDES 0x00C00000 +#define E1000_CTRL_EXT_LINK_MODE_SGMII 0x00800000 +#define E1000_CTRL_EXT_WR_WMARK_MASK 0x03000000 +#define E1000_CTRL_EXT_WR_WMARK_256 0x00000000 +#define E1000_CTRL_EXT_WR_WMARK_320 0x01000000 +#define E1000_CTRL_EXT_WR_WMARK_384 0x02000000 +#define E1000_CTRL_EXT_WR_WMARK_448 0x03000000 +#define E1000_CTRL_EXT_DRV_LOAD 0x10000000 /* Driver loaded bit fo= r FW */ +#define E1000_CTRL_EXT_IAME 0x08000000 /* Interrupt acknowledg= e Auto-mask */ +#define E1000_CTRL_EXT_INT_TIMER_CLR 0x20000000 /* Clear Interrupt time= rs after IMS clear */ +#define E1000_CRTL_EXT_PB_PAREN 0x01000000 /* packet buffer parity= error detection enabled */ +#define E1000_CTRL_EXT_DF_PAREN 0x02000000 /* descriptor FIFO pari= ty error detection enable */ +#define E1000_CTRL_EXT_GHOST_PAREN 0x40000000 + +/* MDI Control */ +#define E1000_MDIC_DATA_MASK 0x0000FFFF +#define E1000_MDIC_REG_MASK 0x001F0000 +#define E1000_MDIC_REG_SHIFT 16 +#define E1000_MDIC_PHY_MASK 0x03E00000 +#define E1000_MDIC_PHY_SHIFT 21 +#define E1000_MDIC_OP_WRITE 0x04000000 +#define E1000_MDIC_OP_READ 0x08000000 +#define E1000_MDIC_READY 0x10000000 +#define E1000_MDIC_INT_EN 0x20000000 +#define E1000_MDIC_ERROR 0x40000000 + +#define E1000_KUMCTRLSTA_MASK 0x0000FFFF +#define E1000_KUMCTRLSTA_OFFSET 0x001F0000 +#define E1000_KUMCTRLSTA_OFFSET_SHIFT 16 +#define E1000_KUMCTRLSTA_REN 0x00200000 + +#define E1000_KUMCTRLSTA_OFFSET_FIFO_CTRL 0x00000000 +#define E1000_KUMCTRLSTA_OFFSET_CTRL 0x00000001 +#define E1000_KUMCTRLSTA_OFFSET_INB_CTRL 0x00000002 +#define E1000_KUMCTRLSTA_OFFSET_DIAG 0x00000003 +#define E1000_KUMCTRLSTA_OFFSET_TIMEOUTS 0x00000004 +#define E1000_KUMCTRLSTA_OFFSET_INB_PARAM 0x00000009 +#define E1000_KUMCTRLSTA_OFFSET_HD_CTRL 0x00000010 +#define E1000_KUMCTRLSTA_OFFSET_M2P_SERDES 0x0000001E +#define E1000_KUMCTRLSTA_OFFSET_M2P_MODES 0x0000001F + +/* FIFO Control */ +#define E1000_KUMCTRLSTA_FIFO_CTRL_RX_BYPASS 0x00000008 +#define E1000_KUMCTRLSTA_FIFO_CTRL_TX_BYPASS 0x00000800 + +/* In-Band Control */ +#define E1000_KUMCTRLSTA_INB_CTRL_LINK_STATUS_TX_TIMEOUT_DEFAULT 0x00= 000500 +#define E1000_KUMCTRLSTA_INB_CTRL_DIS_PADDING 0x00000010 + +/* Half-Duplex Control */ +#define E1000_KUMCTRLSTA_HD_CTRL_10_100_DEFAULT 0x00000004 +#define E1000_KUMCTRLSTA_HD_CTRL_1000_DEFAULT 0x00000000 + +#define E1000_KUMCTRLSTA_OFFSET_K0S_CTRL 0x0000001E + +#define E1000_KUMCTRLSTA_DIAG_FELPBK 0x2000 +#define E1000_KUMCTRLSTA_DIAG_NELPBK 0x1000 + +#define E1000_KUMCTRLSTA_K0S_100_EN 0x2000 +#define E1000_KUMCTRLSTA_K0S_GBE_EN 0x1000 +#define E1000_KUMCTRLSTA_K0S_ENTRY_LATENCY_MASK 0x0003 + +#define E1000_KABGTXD_BGSQLBIAS 0x00050000 + +#define E1000_PHY_CTRL_SPD_EN 0x00000001 +#define E1000_PHY_CTRL_D0A_LPLU 0x00000002 +#define E1000_PHY_CTRL_NOND0A_LPLU 0x00000004 +#define E1000_PHY_CTRL_NOND0A_GBE_DISABLE 0x00000008 +#define E1000_PHY_CTRL_GBE_DISABLE 0x00000040 +#define E1000_PHY_CTRL_B2B_EN 0x00000080 + +/* LED Control */ +#define E1000_LEDCTL_LED0_MODE_MASK 0x0000000F +#define E1000_LEDCTL_LED0_MODE_SHIFT 0 +#define E1000_LEDCTL_LED0_BLINK_RATE 0x0000020 +#define E1000_LEDCTL_LED0_IVRT 0x00000040 +#define E1000_LEDCTL_LED0_BLINK 0x00000080 +#define E1000_LEDCTL_LED1_MODE_MASK 0x00000F00 +#define E1000_LEDCTL_LED1_MODE_SHIFT 8 +#define E1000_LEDCTL_LED1_BLINK_RATE 0x0002000 +#define E1000_LEDCTL_LED1_IVRT 0x00004000 +#define E1000_LEDCTL_LED1_BLINK 0x00008000 +#define E1000_LEDCTL_LED2_MODE_MASK 0x000F0000 +#define E1000_LEDCTL_LED2_MODE_SHIFT 16 +#define E1000_LEDCTL_LED2_BLINK_RATE 0x00200000 +#define E1000_LEDCTL_LED2_IVRT 0x00400000 +#define E1000_LEDCTL_LED2_BLINK 0x00800000 +#define E1000_LEDCTL_LED3_MODE_MASK 0x0F000000 +#define E1000_LEDCTL_LED3_MODE_SHIFT 24 +#define E1000_LEDCTL_LED3_BLINK_RATE 0x20000000 +#define E1000_LEDCTL_LED3_IVRT 0x40000000 +#define E1000_LEDCTL_LED3_BLINK 0x80000000 + +#define E1000_LEDCTL_MODE_LINK_10_1000 0x0 +#define E1000_LEDCTL_MODE_LINK_100_1000 0x1 +#define E1000_LEDCTL_MODE_LINK_UP 0x2 +#define E1000_LEDCTL_MODE_ACTIVITY 0x3 +#define E1000_LEDCTL_MODE_LINK_ACTIVITY 0x4 +#define E1000_LEDCTL_MODE_LINK_10 0x5 +#define E1000_LEDCTL_MODE_LINK_100 0x6 +#define E1000_LEDCTL_MODE_LINK_1000 0x7 +#define E1000_LEDCTL_MODE_PCIX_MODE 0x8 +#define E1000_LEDCTL_MODE_FULL_DUPLEX 0x9 +#define E1000_LEDCTL_MODE_COLLISION 0xA +#define E1000_LEDCTL_MODE_BUS_SPEED 0xB +#define E1000_LEDCTL_MODE_BUS_SIZE 0xC +#define E1000_LEDCTL_MODE_PAUSED 0xD +#define E1000_LEDCTL_MODE_LED_ON 0xE +#define E1000_LEDCTL_MODE_LED_OFF 0xF + +/* Receive Address */ +#define E1000_RAH_AV 0x80000000 /* Receive descriptor valid */ + +/* Interrupt Cause Read */ +#define E1000_ICR_TXDW 0x00000001 /* Transmit desc written back= */ +#define E1000_ICR_TXQE 0x00000002 /* Transmit Queue empty */ +#define E1000_ICR_LSC 0x00000004 /* Link Status Change */ +#define E1000_ICR_RXSEQ 0x00000008 /* rx sequence error */ +#define E1000_ICR_RXDMT0 0x00000010 /* rx desc min. threshold (0)= */ +#define E1000_ICR_RXO 0x00000040 /* rx overrun */ +#define E1000_ICR_RXT0 0x00000080 /* rx timer intr (ring 0) */ +#define E1000_ICR_MDAC 0x00000200 /* MDIO access complete */ +#define E1000_ICR_RXCFG 0x00000400 /* RX /c/ ordered set */ +#define E1000_ICR_GPI_EN0 0x00000800 /* GP Int 0 */ +#define E1000_ICR_GPI_EN1 0x00001000 /* GP Int 1 */ +#define E1000_ICR_GPI_EN2 0x00002000 /* GP Int 2 */ +#define E1000_ICR_GPI_EN3 0x00004000 /* GP Int 3 */ +#define E1000_ICR_TXD_LOW 0x00008000 +#define E1000_ICR_SRPD 0x00010000 +#define E1000_ICR_ACK 0x00020000 /* Receive Ack frame */ +#define E1000_ICR_MNG 0x00040000 /* Manageability event */ +#define E1000_ICR_DOCK 0x00080000 /* Dock/Undock */ +#define E1000_ICR_INT_ASSERTED 0x80000000 /* If this bit asserted, the = driver should claim the interrupt */ +#define E1000_ICR_RXD_FIFO_PAR0 0x00100000 /* queue 0 Rx descriptor FIFO= parity error */ +#define E1000_ICR_TXD_FIFO_PAR0 0x00200000 /* queue 0 Tx descriptor FIFO= parity error */ +#define E1000_ICR_HOST_ARB_PAR 0x00400000 /* host arb read buffer parit= y error */ +#define E1000_ICR_PB_PAR 0x00800000 /* packet buffer parity error= */ +#define E1000_ICR_RXD_FIFO_PAR1 0x01000000 /* queue 1 Rx descriptor FIFO= parity error */ +#define E1000_ICR_TXD_FIFO_PAR1 0x02000000 /* queue 1 Tx descriptor FIFO= parity error */ +#define E1000_ICR_ALL_PARITY 0x03F00000 /* all parity error bits */ +#define E1000_ICR_DSW 0x00000020 /* FW changed the status of D= ISSW bit in the FWSM */ +#define E1000_ICR_PHYINT 0x00001000 /* LAN connected device gener= ates an interrupt */ +#define E1000_ICR_EPRST 0x00100000 /* ME handware reset occurs *= / + +/* Interrupt Cause Set */ +#define E1000_ICS_TXDW E1000_ICR_TXDW /* Transmit desc written= back */ +#define E1000_ICS_TXQE E1000_ICR_TXQE /* Transmit Queue empty = */ +#define E1000_ICS_LSC E1000_ICR_LSC /* Link Status Change */ +#define E1000_ICS_RXSEQ E1000_ICR_RXSEQ /* rx sequence error */ +#define E1000_ICS_RXDMT0 E1000_ICR_RXDMT0 /* rx desc min. threshol= d */ +#define E1000_ICS_RXO E1000_ICR_RXO /* rx overrun */ +#define E1000_ICS_RXT0 E1000_ICR_RXT0 /* rx timer intr */ +#define E1000_ICS_MDAC E1000_ICR_MDAC /* MDIO access complete = */ +#define E1000_ICS_RXCFG E1000_ICR_RXCFG /* RX /c/ ordered set */ +#define E1000_ICS_GPI_EN0 E1000_ICR_GPI_EN0 /* GP Int 0 */ +#define E1000_ICS_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ +#define E1000_ICS_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ +#define E1000_ICS_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_ICS_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_ICS_SRPD E1000_ICR_SRPD +#define E1000_ICS_ACK E1000_ICR_ACK /* Receive Ack frame */ +#define E1000_ICS_MNG E1000_ICR_MNG /* Manageability event *= / +#define E1000_ICS_DOCK E1000_ICR_DOCK /* Dock/Undock */ +#define E1000_ICS_RXD_FIFO_PAR0 E1000_ICR_RXD_FIFO_PAR0 /* queue 0 Rx de= scriptor FIFO parity error */ +#define E1000_ICS_TXD_FIFO_PAR0 E1000_ICR_TXD_FIFO_PAR0 /* queue 0 Tx de= scriptor FIFO parity error */ +#define E1000_ICS_HOST_ARB_PAR E1000_ICR_HOST_ARB_PAR /* host arb read= buffer parity error */ +#define E1000_ICS_PB_PAR E1000_ICR_PB_PAR /* packet buffer= parity error */ +#define E1000_ICS_RXD_FIFO_PAR1 E1000_ICR_RXD_FIFO_PAR1 /* queue 1 Rx de= scriptor FIFO parity error */ +#define E1000_ICS_TXD_FIFO_PAR1 E1000_ICR_TXD_FIFO_PAR1 /* queue 1 Tx de= scriptor FIFO parity error */ +#define E1000_ICS_DSW E1000_ICR_DSW +#define E1000_ICS_PHYINT E1000_ICR_PHYINT +#define E1000_ICS_EPRST E1000_ICR_EPRST + +/* Interrupt Mask Set */ +#define E1000_IMS_TXDW E1000_ICR_TXDW /* Transmit desc written= back */ +#define E1000_IMS_TXQE E1000_ICR_TXQE /* Transmit Queue empty = */ +#define E1000_IMS_LSC E1000_ICR_LSC /* Link Status Change */ +#define E1000_IMS_RXSEQ E1000_ICR_RXSEQ /* rx sequence error */ +#define E1000_IMS_RXDMT0 E1000_ICR_RXDMT0 /* rx desc min. threshol= d */ +#define E1000_IMS_RXO E1000_ICR_RXO /* rx overrun */ +#define E1000_IMS_RXT0 E1000_ICR_RXT0 /* rx timer intr */ +#define E1000_IMS_MDAC E1000_ICR_MDAC /* MDIO access complete = */ +#define E1000_IMS_RXCFG E1000_ICR_RXCFG /* RX /c/ ordered set */ +#define E1000_IMS_GPI_EN0 E1000_ICR_GPI_EN0 /* GP Int 0 */ +#define E1000_IMS_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ +#define E1000_IMS_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ +#define E1000_IMS_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_IMS_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_IMS_SRPD E1000_ICR_SRPD +#define E1000_IMS_ACK E1000_ICR_ACK /* Receive Ack frame */ +#define E1000_IMS_MNG E1000_ICR_MNG /* Manageability event *= / +#define E1000_IMS_DOCK E1000_ICR_DOCK /* Dock/Undock */ +#define E1000_IMS_RXD_FIFO_PAR0 E1000_ICR_RXD_FIFO_PAR0 /* queue 0 Rx de= scriptor FIFO parity error */ +#define E1000_IMS_TXD_FIFO_PAR0 E1000_ICR_TXD_FIFO_PAR0 /* queue 0 Tx de= scriptor FIFO parity error */ +#define E1000_IMS_HOST_ARB_PAR E1000_ICR_HOST_ARB_PAR /* host arb read= buffer parity error */ +#define E1000_IMS_PB_PAR E1000_ICR_PB_PAR /* packet buffer= parity error */ +#define E1000_IMS_RXD_FIFO_PAR1 E1000_ICR_RXD_FIFO_PAR1 /* queue 1 Rx de= scriptor FIFO parity error */ +#define E1000_IMS_TXD_FIFO_PAR1 E1000_ICR_TXD_FIFO_PAR1 /* queue 1 Tx de= scriptor FIFO parity error */ +#define E1000_IMS_DSW E1000_ICR_DSW +#define E1000_IMS_PHYINT E1000_ICR_PHYINT +#define E1000_IMS_EPRST E1000_ICR_EPRST + +/* Interrupt Mask Clear */ +#define E1000_IMC_TXDW E1000_ICR_TXDW /* Transmit desc written= back */ +#define E1000_IMC_TXQE E1000_ICR_TXQE /* Transmit Queue empty = */ +#define E1000_IMC_LSC E1000_ICR_LSC /* Link Status Change */ +#define E1000_IMC_RXSEQ E1000_ICR_RXSEQ /* rx sequence error */ +#define E1000_IMC_RXDMT0 E1000_ICR_RXDMT0 /* rx desc min. threshol= d */ +#define E1000_IMC_RXO E1000_ICR_RXO /* rx overrun */ +#define E1000_IMC_RXT0 E1000_ICR_RXT0 /* rx timer intr */ +#define E1000_IMC_MDAC E1000_ICR_MDAC /* MDIO access complete = */ +#define E1000_IMC_RXCFG E1000_ICR_RXCFG /* RX /c/ ordered set */ +#define E1000_IMC_GPI_EN0 E1000_ICR_GPI_EN0 /* GP Int 0 */ +#define E1000_IMC_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ +#define E1000_IMC_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ +#define E1000_IMC_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_IMC_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_IMC_SRPD E1000_ICR_SRPD +#define E1000_IMC_ACK E1000_ICR_ACK /* Receive Ack frame */ +#define E1000_IMC_MNG E1000_ICR_MNG /* Manageability event *= / +#define E1000_IMC_DOCK E1000_ICR_DOCK /* Dock/Undock */ +#define E1000_IMC_RXD_FIFO_PAR0 E1000_ICR_RXD_FIFO_PAR0 /* queue 0 Rx de= scriptor FIFO parity error */ +#define E1000_IMC_TXD_FIFO_PAR0 E1000_ICR_TXD_FIFO_PAR0 /* queue 0 Tx de= scriptor FIFO parity error */ +#define E1000_IMC_HOST_ARB_PAR E1000_ICR_HOST_ARB_PAR /* host arb read= buffer parity error */ +#define E1000_IMC_PB_PAR E1000_ICR_PB_PAR /* packet buffer= parity error */ +#define E1000_IMC_RXD_FIFO_PAR1 E1000_ICR_RXD_FIFO_PAR1 /* queue 1 Rx de= scriptor FIFO parity error */ +#define E1000_IMC_TXD_FIFO_PAR1 E1000_ICR_TXD_FIFO_PAR1 /* queue 1 Tx de= scriptor FIFO parity error */ +#define E1000_IMC_DSW E1000_ICR_DSW +#define E1000_IMC_PHYINT E1000_ICR_PHYINT +#define E1000_IMC_EPRST E1000_ICR_EPRST + +/* Receive Control */ +#define E1000_RCTL_RST 0x00000001 /* Software reset */ +#define E1000_RCTL_EN 0x00000002 /* enable */ +#define E1000_RCTL_SBP 0x00000004 /* store bad packet */ +#define E1000_RCTL_UPE 0x00000008 /* unicast promiscuous e= nable */ +#define E1000_RCTL_MPE 0x00000010 /* multicast promiscuous= enab */ +#define E1000_RCTL_LPE 0x00000020 /* long packet enable */ +#define E1000_RCTL_LBM_NO 0x00000000 /* no loopback mode */ +#define E1000_RCTL_LBM_MAC 0x00000040 /* MAC loopback mode */ +#define E1000_RCTL_LBM_SLP 0x00000080 /* serial link loopback = mode */ +#define E1000_RCTL_LBM_TCVR 0x000000C0 /* tcvr loopback mode */ +#define E1000_RCTL_DTYP_MASK 0x00000C00 /* Descriptor type mask = */ +#define E1000_RCTL_DTYP_PS 0x00000400 /* Packet Split descript= or */ +#define E1000_RCTL_RDMTS_HALF 0x00000000 /* rx desc min threshold= size */ +#define E1000_RCTL_RDMTS_QUAT 0x00000100 /* rx desc min threshold= size */ +#define E1000_RCTL_RDMTS_EIGTH 0x00000200 /* rx desc min threshold= size */ +#define E1000_RCTL_MO_SHIFT 12 /* multicast offset shif= t */ +#define E1000_RCTL_MO_0 0x00000000 /* multicast offset 11:0= */ +#define E1000_RCTL_MO_1 0x00001000 /* multicast offset 12:1= */ +#define E1000_RCTL_MO_2 0x00002000 /* multicast offset 13:2= */ +#define E1000_RCTL_MO_3 0x00003000 /* multicast offset 15:4= */ +#define E1000_RCTL_MDR 0x00004000 /* multicast desc ring 0= */ +#define E1000_RCTL_BAM 0x00008000 /* broadcast enable */ +/* these buffer sizes are valid if E1000_RCTL_BSEX is 0 */ +#define E1000_RCTL_SZ_2048 0x00000000 /* rx buffer size 2048 *= / +#define E1000_RCTL_SZ_1024 0x00010000 /* rx buffer size 1024 *= / +#define E1000_RCTL_SZ_512 0x00020000 /* rx buffer size 512 */ +#define E1000_RCTL_SZ_256 0x00030000 /* rx buffer size 256 */ +/* these buffer sizes are valid if E1000_RCTL_BSEX is 1 */ +#define E1000_RCTL_SZ_16384 0x00010000 /* rx buffer size 16384 = */ +#define E1000_RCTL_SZ_8192 0x00020000 /* rx buffer size 8192 *= / +#define E1000_RCTL_SZ_4096 0x00030000 /* rx buffer size 4096 *= / +#define E1000_RCTL_VFE 0x00040000 /* vlan filter enable */ +#define E1000_RCTL_CFIEN 0x00080000 /* canonical form enable= */ +#define E1000_RCTL_CFI 0x00100000 /* canonical form indica= tor */ +#define E1000_RCTL_DPF 0x00400000 /* discard pause frames = */ +#define E1000_RCTL_PMCF 0x00800000 /* pass MAC control fram= es */ +#define E1000_RCTL_BSEX 0x02000000 /* Buffer size extension= */ +#define E1000_RCTL_SECRC 0x04000000 /* Strip Ethernet CRC */ +#define E1000_RCTL_FLXBUF_MASK 0x78000000 /* Flexible buffer size = */ +#define E1000_RCTL_FLXBUF_SHIFT 27 /* Flexible buffer shift= */ + +/* Use byte values for the following shift parameters + * Usage: + * psrctl |=3D (((ROUNDUP(value0, 128) >> E1000_PSRCTL_BSIZE0_SHIFT)= & + * E1000_PSRCTL_BSIZE0_MASK) | + * ((ROUNDUP(value1, 1024) >> E1000_PSRCTL_BSIZE1_SHIFT) = & + * E1000_PSRCTL_BSIZE1_MASK) | + * ((ROUNDUP(value2, 1024) << E1000_PSRCTL_BSIZE2_SHIFT) = & + * E1000_PSRCTL_BSIZE2_MASK) | + * ((ROUNDUP(value3, 1024) << E1000_PSRCTL_BSIZE3_SHIFT) = |; + * E1000_PSRCTL_BSIZE3_MASK)) + * where value0 =3D [128..16256], default=3D256 + * value1 =3D [1024..64512], default=3D4096 + * value2 =3D [0..64512], default=3D4096 + * value3 =3D [0..64512], default=3D0 + */ + +#define E1000_PSRCTL_BSIZE0_MASK 0x0000007F +#define E1000_PSRCTL_BSIZE1_MASK 0x00003F00 +#define E1000_PSRCTL_BSIZE2_MASK 0x003F0000 +#define E1000_PSRCTL_BSIZE3_MASK 0x3F000000 + +#define E1000_PSRCTL_BSIZE0_SHIFT 7 /* Shift _right_ 7 */ +#define E1000_PSRCTL_BSIZE1_SHIFT 2 /* Shift _right_ 2 */ +#define E1000_PSRCTL_BSIZE2_SHIFT 6 /* Shift _left_ 6 */ +#define E1000_PSRCTL_BSIZE3_SHIFT 14 /* Shift _left_ 14 */ + +/* SW_W_SYNC definitions */ +#define E1000_SWFW_EEP_SM 0x0001 +#define E1000_SWFW_PHY0_SM 0x0002 +#define E1000_SWFW_PHY1_SM 0x0004 +#define E1000_SWFW_MAC_CSR_SM 0x0008 + +/* Receive Descriptor */ +#define E1000_RDT_DELAY 0x0000ffff /* Delay timer (1=3D1024us) */ +#define E1000_RDT_FPDB 0x80000000 /* Flush descriptor block */ +#define E1000_RDLEN_LEN 0x0007ff80 /* descriptor length */ +#define E1000_RDH_RDH 0x0000ffff /* receive descriptor head */ +#define E1000_RDT_RDT 0x0000ffff /* receive descriptor tail */ + +/* Flow Control */ +#define E1000_FCRTH_RTH 0x0000FFF8 /* Mask Bits[15:3] for RTH */ +#define E1000_FCRTH_XFCE 0x80000000 /* External Flow Control Enable = */ +#define E1000_FCRTL_RTL 0x0000FFF8 /* Mask Bits[15:3] for RTL */ +#define E1000_FCRTL_XONE 0x80000000 /* Enable XON frame transmission= */ + +/* Header split receive */ +#define E1000_RFCTL_ISCSI_DIS 0x00000001 +#define E1000_RFCTL_ISCSI_DWC_MASK 0x0000003E +#define E1000_RFCTL_ISCSI_DWC_SHIFT 1 +#define E1000_RFCTL_NFSW_DIS 0x00000040 +#define E1000_RFCTL_NFSR_DIS 0x00000080 +#define E1000_RFCTL_NFS_VER_MASK 0x00000300 +#define E1000_RFCTL_NFS_VER_SHIFT 8 +#define E1000_RFCTL_IPV6_DIS 0x00000400 +#define E1000_RFCTL_IPV6_XSUM_DIS 0x00000800 +#define E1000_RFCTL_ACK_DIS 0x00001000 +#define E1000_RFCTL_ACKD_DIS 0x00002000 +#define E1000_RFCTL_IPFRSP_DIS 0x00004000 +#define E1000_RFCTL_EXTEN 0x00008000 +#define E1000_RFCTL_IPV6_EX_DIS 0x00010000 +#define E1000_RFCTL_NEW_IPV6_EXT_DIS 0x00020000 + +/* Receive Descriptor Control */ +#define E1000_RXDCTL_PTHRESH 0x0000003F /* RXDCTL Prefetch Threshold */ +#define E1000_RXDCTL_HTHRESH 0x00003F00 /* RXDCTL Host Threshold */ +#define E1000_RXDCTL_WTHRESH 0x003F0000 /* RXDCTL Writeback Threshold */ +#define E1000_RXDCTL_GRAN 0x01000000 /* RXDCTL Granularity */ + +/* Transmit Descriptor Control */ +#define E1000_TXDCTL_PTHRESH 0x0000003F /* TXDCTL Prefetch Threshold */ +#define E1000_TXDCTL_HTHRESH 0x00003F00 /* TXDCTL Host Threshold */ +#define E1000_TXDCTL_WTHRESH 0x003F0000 /* TXDCTL Writeback Threshold */ +#define E1000_TXDCTL_GRAN 0x01000000 /* TXDCTL Granularity */ +#define E1000_TXDCTL_LWTHRESH 0xFE000000 /* TXDCTL Low Threshold */ +#define E1000_TXDCTL_FULL_TX_DESC_WB 0x01010000 /* GRAN=3D1, WTHRESH=3D1= */ +#define E1000_TXDCTL_COUNT_DESC 0x00400000 /* Enable the counting of des= c. + still to be processed. */ +/* Transmit Configuration Word */ +#define E1000_TXCW_FD 0x00000020 /* TXCW full duplex */ +#define E1000_TXCW_HD 0x00000040 /* TXCW half duplex */ +#define E1000_TXCW_PAUSE 0x00000080 /* TXCW sym pause reques= t */ +#define E1000_TXCW_ASM_DIR 0x00000100 /* TXCW astm pause direc= tion */ +#define E1000_TXCW_PAUSE_MASK 0x00000180 /* TXCW pause request ma= sk */ +#define E1000_TXCW_RF 0x00003000 /* TXCW remote fault */ +#define E1000_TXCW_NP 0x00008000 /* TXCW next page */ +#define E1000_TXCW_CW 0x0000ffff /* TxConfigWord mask */ +#define E1000_TXCW_TXC 0x40000000 /* Transmit Config contr= ol */ +#define E1000_TXCW_ANE 0x80000000 /* Auto-neg enable */ + +/* Receive Configuration Word */ +#define E1000_RXCW_CW 0x0000ffff /* RxConfigWord mask */ +#define E1000_RXCW_NC 0x04000000 /* Receive config no carrier */ +#define E1000_RXCW_IV 0x08000000 /* Receive config invalid */ +#define E1000_RXCW_CC 0x10000000 /* Receive config change */ +#define E1000_RXCW_C 0x20000000 /* Receive config */ +#define E1000_RXCW_SYNCH 0x40000000 /* Receive config synch */ +#define E1000_RXCW_ANC 0x80000000 /* Auto-neg complete */ + +/* Transmit Control */ +#define E1000_TCTL_RST 0x00000001 /* software reset */ +#define E1000_TCTL_EN 0x00000002 /* enable tx */ +#define E1000_TCTL_BCE 0x00000004 /* busy check enable */ +#define E1000_TCTL_PSP 0x00000008 /* pad short packets */ +#define E1000_TCTL_CT 0x00000ff0 /* collision threshold */ +#define E1000_TCTL_COLD 0x003ff000 /* collision distance */ +#define E1000_TCTL_SWXOFF 0x00400000 /* SW Xoff transmission */ +#define E1000_TCTL_PBE 0x00800000 /* Packet Burst Enable */ +#define E1000_TCTL_RTLC 0x01000000 /* Re-transmit on late collision= */ +#define E1000_TCTL_NRTU 0x02000000 /* No Re-transmit on underrun */ +#define E1000_TCTL_MULR 0x10000000 /* Multiple request support */ +/* Extended Transmit Control */ +#define E1000_TCTL_EXT_BST_MASK 0x000003FF /* Backoff Slot Time */ +#define E1000_TCTL_EXT_GCEX_MASK 0x000FFC00 /* Gigabit Carry Extend Padd= ing */ + +#define DEFAULT_80003ES2LAN_TCTL_EXT_GCEX 0x00010000 + +/* Receive Checksum Control */ +#define E1000_RXCSUM_PCSS_MASK 0x000000FF /* Packet Checksum Start */ +#define E1000_RXCSUM_IPOFL 0x00000100 /* IPv4 checksum offload */ +#define E1000_RXCSUM_TUOFL 0x00000200 /* TCP / UDP checksum offloa= d */ +#define E1000_RXCSUM_IPV6OFL 0x00000400 /* IPv6 checksum offload */ +#define E1000_RXCSUM_IPPCSE 0x00001000 /* IP payload checksum enabl= e */ +#define E1000_RXCSUM_PCSD 0x00002000 /* packet checksum disabled = */ + +/* Multiple Receive Queue Control */ +#define E1000_MRQC_ENABLE_MASK 0x00000003 +#define E1000_MRQC_ENABLE_RSS_2Q 0x00000001 +#define E1000_MRQC_ENABLE_RSS_INT 0x00000004 +#define E1000_MRQC_RSS_FIELD_MASK 0xFFFF0000 +#define E1000_MRQC_RSS_FIELD_IPV4_TCP 0x00010000 +#define E1000_MRQC_RSS_FIELD_IPV4 0x00020000 +#define E1000_MRQC_RSS_FIELD_IPV6_TCP_EX 0x00040000 +#define E1000_MRQC_RSS_FIELD_IPV6_EX 0x00080000 +#define E1000_MRQC_RSS_FIELD_IPV6 0x00100000 +#define E1000_MRQC_RSS_FIELD_IPV6_TCP 0x00200000 + +/* Definitions for power management and wakeup registers */ +/* Wake Up Control */ +#define E1000_WUC_APME 0x00000001 /* APM Enable */ +#define E1000_WUC_PME_EN 0x00000002 /* PME Enable */ +#define E1000_WUC_PME_STATUS 0x00000004 /* PME Status */ +#define E1000_WUC_APMPME 0x00000008 /* Assert PME on APM Wakeup */ +#define E1000_WUC_SPM 0x80000000 /* Enable SPM */ + +/* Wake Up Filter Control */ +#define E1000_WUFC_LNKC 0x00000001 /* Link Status Change Wakeup Enable *= / +#define E1000_WUFC_MAG 0x00000002 /* Magic Packet Wakeup Enable */ +#define E1000_WUFC_EX 0x00000004 /* Directed Exact Wakeup Enable */ +#define E1000_WUFC_MC 0x00000008 /* Directed Multicast Wakeup Enable *= / +#define E1000_WUFC_BC 0x00000010 /* Broadcast Wakeup Enable */ +#define E1000_WUFC_ARP 0x00000020 /* ARP Request Packet Wakeup Enable *= / +#define E1000_WUFC_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Enable= */ +#define E1000_WUFC_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Enable= */ +#define E1000_WUFC_IGNORE_TCO 0x00008000 /* Ignore WakeOn TCO packe= ts */ +#define E1000_WUFC_FLX0 0x00010000 /* Flexible Filter 0 Enable */ +#define E1000_WUFC_FLX1 0x00020000 /* Flexible Filter 1 Enable */ +#define E1000_WUFC_FLX2 0x00040000 /* Flexible Filter 2 Enable */ +#define E1000_WUFC_FLX3 0x00080000 /* Flexible Filter 3 Enable */ +#define E1000_WUFC_ALL_FILTERS 0x000F00FF /* Mask for all wakeup filters= */ +#define E1000_WUFC_FLX_OFFSET 16 /* Offset to the Flexible Filters= bits */ +#define E1000_WUFC_FLX_FILTERS 0x000F0000 /* Mask for the 4 flexible fil= ters */ + +/* Wake Up Status */ +#define E1000_WUS_LNKC 0x00000001 /* Link Status Changed */ +#define E1000_WUS_MAG 0x00000002 /* Magic Packet Received */ +#define E1000_WUS_EX 0x00000004 /* Directed Exact Received */ +#define E1000_WUS_MC 0x00000008 /* Directed Multicast Received */ +#define E1000_WUS_BC 0x00000010 /* Broadcast Received */ +#define E1000_WUS_ARP 0x00000020 /* ARP Request Packet Received */ +#define E1000_WUS_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Receive= d */ +#define E1000_WUS_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Receive= d */ +#define E1000_WUS_FLX0 0x00010000 /* Flexible Filter 0 Match */ +#define E1000_WUS_FLX1 0x00020000 /* Flexible Filter 1 Match */ +#define E1000_WUS_FLX2 0x00040000 /* Flexible Filter 2 Match */ +#define E1000_WUS_FLX3 0x00080000 /* Flexible Filter 3 Match */ +#define E1000_WUS_FLX_FILTERS 0x000F0000 /* Mask for the 4 flexible filt= ers */ + +/* Management Control */ +#define E1000_MANC_SMBUS_EN 0x00000001 /* SMBus Enabled - RO */ +#define E1000_MANC_ASF_EN 0x00000002 /* ASF Enabled - RO */ +#define E1000_MANC_R_ON_FORCE 0x00000004 /* Reset on Force TCO - RO *= / +#define E1000_MANC_RMCP_EN 0x00000100 /* Enable RCMP 026Fh Filteri= ng */ +#define E1000_MANC_0298_EN 0x00000200 /* Enable RCMP 0298h Filteri= ng */ +#define E1000_MANC_IPV4_EN 0x00000400 /* Enable IPv4 */ +#define E1000_MANC_IPV6_EN 0x00000800 /* Enable IPv6 */ +#define E1000_MANC_SNAP_EN 0x00001000 /* Accept LLC/SNAP */ +#define E1000_MANC_ARP_EN 0x00002000 /* Enable ARP Request Filter= ing */ +#define E1000_MANC_NEIGHBOR_EN 0x00004000 /* Enable Neighbor Discovery + * Filtering */ +#define E1000_MANC_ARP_RES_EN 0x00008000 /* Enable ARP response Filte= ring */ +#define E1000_MANC_TCO_RESET 0x00010000 /* TCO Reset Occurred */ +#define E1000_MANC_RCV_TCO_EN 0x00020000 /* Receive TCO Packets Enabl= ed */ +#define E1000_MANC_REPORT_STATUS 0x00040000 /* Status Reporting Enabled = */ +#define E1000_MANC_RCV_ALL 0x00080000 /* Receive All Enabled */ +#define E1000_MANC_BLK_PHY_RST_ON_IDE 0x00040000 /* Block phy resets *= / +#define E1000_MANC_EN_MAC_ADDR_FILTER 0x00100000 /* Enable MAC address + * filtering */ +#define E1000_MANC_EN_MNG2HOST 0x00200000 /* Enable MNG packets to hos= t + * memory */ +#define E1000_MANC_EN_IP_ADDR_FILTER 0x00400000 /* Enable IP address + * filtering */ +#define E1000_MANC_EN_XSUM_FILTER 0x00800000 /* Enable checksum filter= ing */ +#define E1000_MANC_BR_EN 0x01000000 /* Enable broadcast filterin= g */ +#define E1000_MANC_SMB_REQ 0x01000000 /* SMBus Request */ +#define E1000_MANC_SMB_GNT 0x02000000 /* SMBus Grant */ +#define E1000_MANC_SMB_CLK_IN 0x04000000 /* SMBus Clock In */ +#define E1000_MANC_SMB_DATA_IN 0x08000000 /* SMBus Data In */ +#define E1000_MANC_SMB_DATA_OUT 0x10000000 /* SMBus Data Out */ +#define E1000_MANC_SMB_CLK_OUT 0x20000000 /* SMBus Clock Out */ + +#define E1000_MANC_SMB_DATA_OUT_SHIFT 28 /* SMBus Data Out Shift */ +#define E1000_MANC_SMB_CLK_OUT_SHIFT 29 /* SMBus Clock Out Shift */ + +/* SW Semaphore Register */ +#define E1000_SWSM_SMBI 0x00000001 /* Driver Semaphore bit */ +#define E1000_SWSM_SWESMBI 0x00000002 /* FW Semaphore bit */ +#define E1000_SWSM_WMNG 0x00000004 /* Wake MNG Clock */ +#define E1000_SWSM_DRV_LOAD 0x00000008 /* Driver Loaded Bit */ + +/* FW Semaphore Register */ +#define E1000_FWSM_MODE_MASK 0x0000000E /* FW mode */ +#define E1000_FWSM_MODE_SHIFT 1 +#define E1000_FWSM_FW_VALID 0x00008000 /* FW established a valid mod= e */ + +#define E1000_FWSM_RSPCIPHY 0x00000040 /* Reset PHY on PCI reset = */ +#define E1000_FWSM_DISSW 0x10000000 /* FW disable SW Write Acc= ess */ +#define E1000_FWSM_SKUSEL_MASK 0x60000000 /* LAN SKU select */ +#define E1000_FWSM_SKUEL_SHIFT 29 +#define E1000_FWSM_SKUSEL_EMB 0x0 /* Embedded SKU */ +#define E1000_FWSM_SKUSEL_CONS 0x1 /* Consumer SKU */ +#define E1000_FWSM_SKUSEL_PERF_100 0x2 /* Perf & Corp 10/100 SKU */ +#define E1000_FWSM_SKUSEL_PERF_GBE 0x3 /* Perf & Copr GbE SKU */ + +/* FFLT Debug Register */ +#define E1000_FFLT_DBG_INVC 0x00100000 /* Invalid /C/ code handling = */ + +typedef enum { + e1000_mng_mode_none =3D 0, + e1000_mng_mode_asf, + e1000_mng_mode_pt, + e1000_mng_mode_ipmi, + e1000_mng_mode_host_interface_only +} e1000_mng_mode; + +/* Host Inteface Control Register */ +#define E1000_HICR_EN 0x00000001 /* Enable Bit - RO */ +#define E1000_HICR_C 0x00000002 /* Driver sets this bit when= done + * to put command in RAM */ +#define E1000_HICR_SV 0x00000004 /* Status Validity */ +#define E1000_HICR_FWR 0x00000080 /* FW reset. Set by the Host= */ + +/* Host Interface Command Interface - Address range 0x8800-0x8EFF */ +#define E1000_HI_MAX_DATA_LENGTH 252 /* Host Interface data leng= th */ +#define E1000_HI_MAX_BLOCK_BYTE_LENGTH 1792 /* Number of bytes in range= */ +#define E1000_HI_MAX_BLOCK_DWORD_LENGTH 448 /* Number of dwords in rang= e */ +#define E1000_HI_COMMAND_TIMEOUT 500 /* Time in ms to process HI= command */ + +struct e1000_host_command_header { + uint8_t command_id; + uint8_t command_length; + uint8_t command_options; /* I/F bits for command, status for retur= n */ + uint8_t checksum; +}; +struct e1000_host_command_info { + struct e1000_host_command_header command_header; /* Command Head/Co= mmand Result Head has 4 bytes */ + uint8_t command_data[E1000_HI_MAX_DATA_LENGTH]; /* Command data ca= n length 0..252 */ +}; + +/* Host SMB register #0 */ +#define E1000_HSMC0R_CLKIN 0x00000001 /* SMB Clock in */ +#define E1000_HSMC0R_DATAIN 0x00000002 /* SMB Data in */ +#define E1000_HSMC0R_DATAOUT 0x00000004 /* SMB Data out */ +#define E1000_HSMC0R_CLKOUT 0x00000008 /* SMB Clock out */ + +/* Host SMB register #1 */ +#define E1000_HSMC1R_CLKIN E1000_HSMC0R_CLKIN +#define E1000_HSMC1R_DATAIN E1000_HSMC0R_DATAIN +#define E1000_HSMC1R_DATAOUT E1000_HSMC0R_DATAOUT +#define E1000_HSMC1R_CLKOUT E1000_HSMC0R_CLKOUT + +/* FW Status Register */ +#define E1000_FWSTS_FWS_MASK 0x000000FF /* FW Status */ + +/* Wake Up Packet Length */ +#define E1000_WUPL_LENGTH_MASK 0x0FFF /* Only the lower 12 bits are va= lid */ + +#define E1000_MDALIGN 4096 + +/* PCI-Ex registers*/ + +/* PCI-Ex Control Register */ +#define E1000_GCR_RXD_NO_SNOOP 0x00000001 +#define E1000_GCR_RXDSCW_NO_SNOOP 0x00000002 +#define E1000_GCR_RXDSCR_NO_SNOOP 0x00000004 +#define E1000_GCR_TXD_NO_SNOOP 0x00000008 +#define E1000_GCR_TXDSCW_NO_SNOOP 0x00000010 +#define E1000_GCR_TXDSCR_NO_SNOOP 0x00000020 + +#define PCI_EX_NO_SNOOP_ALL (E1000_GCR_RXD_NO_SNOOP | \ + E1000_GCR_RXDSCW_NO_SNOOP | \ + E1000_GCR_RXDSCR_NO_SNOOP | \ + E1000_GCR_TXD_NO_SNOOP | \ + E1000_GCR_TXDSCW_NO_SNOOP | \ + E1000_GCR_TXDSCR_NO_SNOOP) + +#define PCI_EX_82566_SNOOP_ALL PCI_EX_NO_SNOOP_ALL + +#define E1000_GCR_L1_ACT_WITHOUT_L0S_RX 0x08000000 +/* Function Active and Power State to MNG */ +#define E1000_FACTPS_FUNC0_POWER_STATE_MASK 0x00000003 +#define E1000_FACTPS_LAN0_VALID 0x00000004 +#define E1000_FACTPS_FUNC0_AUX_EN 0x00000008 +#define E1000_FACTPS_FUNC1_POWER_STATE_MASK 0x000000C0 +#define E1000_FACTPS_FUNC1_POWER_STATE_SHIFT 6 +#define E1000_FACTPS_LAN1_VALID 0x00000100 +#define E1000_FACTPS_FUNC1_AUX_EN 0x00000200 +#define E1000_FACTPS_FUNC2_POWER_STATE_MASK 0x00003000 +#define E1000_FACTPS_FUNC2_POWER_STATE_SHIFT 12 +#define E1000_FACTPS_IDE_ENABLE 0x00004000 +#define E1000_FACTPS_FUNC2_AUX_EN 0x00008000 +#define E1000_FACTPS_FUNC3_POWER_STATE_MASK 0x000C0000 +#define E1000_FACTPS_FUNC3_POWER_STATE_SHIFT 18 +#define E1000_FACTPS_SP_ENABLE 0x00100000 +#define E1000_FACTPS_FUNC3_AUX_EN 0x00200000 +#define E1000_FACTPS_FUNC4_POWER_STATE_MASK 0x03000000 +#define E1000_FACTPS_FUNC4_POWER_STATE_SHIFT 24 +#define E1000_FACTPS_IPMI_ENABLE 0x04000000 +#define E1000_FACTPS_FUNC4_AUX_EN 0x08000000 +#define E1000_FACTPS_MNGCG 0x20000000 +#define E1000_FACTPS_LAN_FUNC_SEL 0x40000000 +#define E1000_FACTPS_PM_STATE_CHANGED 0x80000000 + +/* PCI-Ex Config Space */ +#define PCI_EX_LINK_STATUS 0x12 +#define PCI_EX_LINK_WIDTH_MASK 0x3F0 +#define PCI_EX_LINK_WIDTH_SHIFT 4 + +/* EEPROM Commands - Microwire */ +#define EEPROM_READ_OPCODE_MICROWIRE 0x6 /* EEPROM read opcode */ +#define EEPROM_WRITE_OPCODE_MICROWIRE 0x5 /* EEPROM write opcode */ +#define EEPROM_ERASE_OPCODE_MICROWIRE 0x7 /* EEPROM erase opcode */ +#define EEPROM_EWEN_OPCODE_MICROWIRE 0x13 /* EEPROM erase/write enable = */ +#define EEPROM_EWDS_OPCODE_MICROWIRE 0x10 /* EEPROM erast/write disable= */ + +/* EEPROM Commands - SPI */ +#define EEPROM_MAX_RETRY_SPI 5000 /* Max wait of 5ms, for RDY sig= nal */ +#define EEPROM_READ_OPCODE_SPI 0x03 /* EEPROM read opcode */ +#define EEPROM_WRITE_OPCODE_SPI 0x02 /* EEPROM write opcode */ +#define EEPROM_A8_OPCODE_SPI 0x08 /* opcode bit-3 =3D address bi= t-8 */ +#define EEPROM_WREN_OPCODE_SPI 0x06 /* EEPROM set Write Enable lat= ch */ +#define EEPROM_WRDI_OPCODE_SPI 0x04 /* EEPROM reset Write Enable l= atch */ +#define EEPROM_RDSR_OPCODE_SPI 0x05 /* EEPROM read Status register= */ +#define EEPROM_WRSR_OPCODE_SPI 0x01 /* EEPROM write Status registe= r */ +#define EEPROM_ERASE4K_OPCODE_SPI 0x20 /* EEPROM ERASE 4KB */ +#define EEPROM_ERASE64K_OPCODE_SPI 0xD8 /* EEPROM ERASE 64KB */ +#define EEPROM_ERASE256_OPCODE_SPI 0xDB /* EEPROM ERASE 256B */ + +/* EEPROM Size definitions */ +#define EEPROM_WORD_SIZE_SHIFT 6 +#define EEPROM_SIZE_SHIFT 10 +#define EEPROM_SIZE_MASK 0x1C00 + +/* EEPROM Word Offsets */ +#define EEPROM_COMPAT 0x0003 +#define EEPROM_ID_LED_SETTINGS 0x0004 +#define EEPROM_VERSION 0x0005 +#define EEPROM_SERDES_AMPLITUDE 0x0006 /* For SERDES output amplit= ude adjustment. */ +#define EEPROM_PHY_CLASS_WORD 0x0007 +#define EEPROM_INIT_CONTROL1_REG 0x000A +#define EEPROM_INIT_CONTROL2_REG 0x000F +#define EEPROM_SWDEF_PINS_CTRL_PORT_1 0x0010 +#define EEPROM_INIT_CONTROL3_PORT_B 0x0014 +#define EEPROM_INIT_3GIO_3 0x001A +#define EEPROM_SWDEF_PINS_CTRL_PORT_0 0x0020 +#define EEPROM_INIT_CONTROL3_PORT_A 0x0024 +#define EEPROM_CFG 0x0012 +#define EEPROM_FLASH_VERSION 0x0032 +#define EEPROM_CHECKSUM_REG 0x003F + +#define E1000_EEPROM_CFG_DONE 0x00040000 /* MNG config cycle d= one */ +#define E1000_EEPROM_CFG_DONE_PORT_1 0x00080000 /* ...for second port= */ + +/* Word definitions for ID LED Settings */ +#define ID_LED_RESERVED_0000 0x0000 +#define ID_LED_RESERVED_FFFF 0xFFFF +#define ID_LED_RESERVED_82573 0xF746 +#define ID_LED_DEFAULT_82573 0x1811 +#define ID_LED_DEFAULT ((ID_LED_OFF1_ON2 << 12) | \ + (ID_LED_OFF1_OFF2 << 8) | \ + (ID_LED_DEF1_DEF2 << 4) | \ + (ID_LED_DEF1_DEF2)) +#define ID_LED_DEFAULT_ICH8LAN ((ID_LED_DEF1_DEF2 << 12) | \ + (ID_LED_DEF1_OFF2 << 8) | \ + (ID_LED_DEF1_ON2 << 4) | \ + (ID_LED_DEF1_DEF2)) +#define ID_LED_DEF1_DEF2 0x1 +#define ID_LED_DEF1_ON2 0x2 +#define ID_LED_DEF1_OFF2 0x3 +#define ID_LED_ON1_DEF2 0x4 +#define ID_LED_ON1_ON2 0x5 +#define ID_LED_ON1_OFF2 0x6 +#define ID_LED_OFF1_DEF2 0x7 +#define ID_LED_OFF1_ON2 0x8 +#define ID_LED_OFF1_OFF2 0x9 + +#define IGP_ACTIVITY_LED_MASK 0xFFFFF0FF +#define IGP_ACTIVITY_LED_ENABLE 0x0300 +#define IGP_LED3_MODE 0x07000000 + + +/* Mask bits for SERDES amplitude adjustment in Word 6 of the EEPROM */ +#define EEPROM_SERDES_AMPLITUDE_MASK 0x000F + +/* Mask bit for PHY class in Word 7 of the EEPROM */ +#define EEPROM_PHY_CLASS_A 0x8000 + +/* Mask bits for fields in Word 0x0a of the EEPROM */ +#define EEPROM_WORD0A_ILOS 0x0010 +#define EEPROM_WORD0A_SWDPIO 0x01E0 +#define EEPROM_WORD0A_LRST 0x0200 +#define EEPROM_WORD0A_FD 0x0400 +#define EEPROM_WORD0A_66MHZ 0x0800 + +/* Mask bits for fields in Word 0x0f of the EEPROM */ +#define EEPROM_WORD0F_PAUSE_MASK 0x3000 +#define EEPROM_WORD0F_PAUSE 0x1000 +#define EEPROM_WORD0F_ASM_DIR 0x2000 +#define EEPROM_WORD0F_ANE 0x0800 +#define EEPROM_WORD0F_SWPDIO_EXT 0x00F0 +#define EEPROM_WORD0F_LPLU 0x0001 + +/* Mask bits for fields in Word 0x10/0x20 of the EEPROM */ +#define EEPROM_WORD1020_GIGA_DISABLE 0x0010 +#define EEPROM_WORD1020_GIGA_DISABLE_NON_D0A 0x0008 + +/* Mask bits for fields in Word 0x1a of the EEPROM */ +#define EEPROM_WORD1A_ASPM_MASK 0x000C + +/* For checksumming, the sum of all words in the EEPROM should equal 0xB= ABA. */ +#define EEPROM_SUM 0xBABA + +/* EEPROM Map defines (WORD OFFSETS)*/ +#define EEPROM_NODE_ADDRESS_BYTE_0 0 +#define EEPROM_PBA_BYTE_1 8 + +#define EEPROM_RESERVED_WORD 0xFFFF + +/* EEPROM Map Sizes (Byte Counts) */ +#define PBA_SIZE 4 + +/* Collision related configuration parameters */ +#define E1000_COLLISION_THRESHOLD 15 +#define E1000_CT_SHIFT 4 +/* Collision distance is a 0-based value that applies to + * half-duplex-capable hardware only. */ +#define E1000_COLLISION_DISTANCE 63 +#define E1000_COLLISION_DISTANCE_82542 64 +#define E1000_FDX_COLLISION_DISTANCE E1000_COLLISION_DISTANCE +#define E1000_HDX_COLLISION_DISTANCE E1000_COLLISION_DISTANCE +#define E1000_COLD_SHIFT 12 + +/* Number of Transmit and Receive Descriptors must be a multiple of 8 */ +#define REQ_TX_DESCRIPTOR_MULTIPLE 8 +#define REQ_RX_DESCRIPTOR_MULTIPLE 8 + +/* Default values for the transmit IPG register */ +#define DEFAULT_82542_TIPG_IPGT 10 +#define DEFAULT_82543_TIPG_IPGT_FIBER 9 +#define DEFAULT_82543_TIPG_IPGT_COPPER 8 + +#define E1000_TIPG_IPGT_MASK 0x000003FF +#define E1000_TIPG_IPGR1_MASK 0x000FFC00 +#define E1000_TIPG_IPGR2_MASK 0x3FF00000 + +#define DEFAULT_82542_TIPG_IPGR1 2 +#define DEFAULT_82543_TIPG_IPGR1 8 +#define E1000_TIPG_IPGR1_SHIFT 10 + +#define DEFAULT_82542_TIPG_IPGR2 10 +#define DEFAULT_82543_TIPG_IPGR2 6 +#define DEFAULT_80003ES2LAN_TIPG_IPGR2 7 +#define E1000_TIPG_IPGR2_SHIFT 20 + +#define DEFAULT_80003ES2LAN_TIPG_IPGT_10_100 0x00000009 +#define DEFAULT_80003ES2LAN_TIPG_IPGT_1000 0x00000008 +#define E1000_TXDMAC_DPP 0x00000001 + +/* Adaptive IFS defines */ +#define TX_THRESHOLD_START 8 +#define TX_THRESHOLD_INCREMENT 10 +#define TX_THRESHOLD_DECREMENT 1 +#define TX_THRESHOLD_STOP 190 +#define TX_THRESHOLD_DISABLE 0 +#define TX_THRESHOLD_TIMER_MS 10000 +#define MIN_NUM_XMITS 1000 +#define IFS_MAX 80 +#define IFS_STEP 10 +#define IFS_MIN 40 +#define IFS_RATIO 4 + +/* Extended Configuration Control and Size */ +#define E1000_EXTCNF_CTRL_PCIE_WRITE_ENABLE 0x00000001 +#define E1000_EXTCNF_CTRL_PHY_WRITE_ENABLE 0x00000002 +#define E1000_EXTCNF_CTRL_D_UD_ENABLE 0x00000004 +#define E1000_EXTCNF_CTRL_D_UD_LATENCY 0x00000008 +#define E1000_EXTCNF_CTRL_D_UD_OWNER 0x00000010 +#define E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP 0x00000020 +#define E1000_EXTCNF_CTRL_MDIO_HW_OWNERSHIP 0x00000040 +#define E1000_EXTCNF_CTRL_EXT_CNF_POINTER 0x0FFF0000 + +#define E1000_EXTCNF_SIZE_EXT_PHY_LENGTH 0x000000FF +#define E1000_EXTCNF_SIZE_EXT_DOCK_LENGTH 0x0000FF00 +#define E1000_EXTCNF_SIZE_EXT_PCIE_LENGTH 0x00FF0000 +#define E1000_EXTCNF_CTRL_LCD_WRITE_ENABLE 0x00000001 +#define E1000_EXTCNF_CTRL_SWFLAG 0x00000020 + +/* PBA constants */ +#define E1000_PBA_8K 0x0008 /* 8KB, default Rx allocation */ +#define E1000_PBA_12K 0x000C /* 12KB, default Rx allocation */ +#define E1000_PBA_16K 0x0010 /* 16KB, default TX allocation */ +#define E1000_PBA_20K 0x0014 +#define E1000_PBA_22K 0x0016 +#define E1000_PBA_24K 0x0018 +#define E1000_PBA_30K 0x001E +#define E1000_PBA_32K 0x0020 +#define E1000_PBA_34K 0x0022 +#define E1000_PBA_38K 0x0026 +#define E1000_PBA_40K 0x0028 +#define E1000_PBA_48K 0x0030 /* 48KB, default RX allocation */ + +#define E1000_PBS_16K E1000_PBA_16K + +/* Flow Control Constants */ +#define FLOW_CONTROL_ADDRESS_LOW 0x00C28001 +#define FLOW_CONTROL_ADDRESS_HIGH 0x00000100 +#define FLOW_CONTROL_TYPE 0x8808 + +/* The historical defaults for the flow control values are given below. = */ +#define FC_DEFAULT_HI_THRESH (0x8000) /* 32KB */ +#define FC_DEFAULT_LO_THRESH (0x4000) /* 16KB */ +#define FC_DEFAULT_TX_TIMER (0x100) /* ~130 us */ + +/* PCIX Config space */ +#define PCIX_COMMAND_REGISTER 0xE6 +#define PCIX_STATUS_REGISTER_LO 0xE8 +#define PCIX_STATUS_REGISTER_HI 0xEA + +#define PCIX_COMMAND_MMRBC_MASK 0x000C +#define PCIX_COMMAND_MMRBC_SHIFT 0x2 +#define PCIX_STATUS_HI_MMRBC_MASK 0x0060 +#define PCIX_STATUS_HI_MMRBC_SHIFT 0x5 +#define PCIX_STATUS_HI_MMRBC_4K 0x3 +#define PCIX_STATUS_HI_MMRBC_2K 0x2 + + +/* Number of bits required to shift right the "pause" bits from the + * EEPROM (bits 13:12) to the "pause" (bits 8:7) field in the TXCW regis= ter. + */ +#define PAUSE_SHIFT 5 + +/* Number of bits required to shift left the "SWDPIO" bits from the + * EEPROM (bits 8:5) to the "SWDPIO" (bits 25:22) field in the CTRL regi= ster. + */ +#define SWDPIO_SHIFT 17 + +/* Number of bits required to shift left the "SWDPIO_EXT" bits from the + * EEPROM word F (bits 7:4) to the bits 11:8 of The Extended CTRL regist= er. + */ +#define SWDPIO__EXT_SHIFT 4 + +/* Number of bits required to shift left the "ILOS" bit from the EEPROM + * (bit 4) to the "ILOS" (bit 7) field in the CTRL register. + */ +#define ILOS_SHIFT 3 + + +#define RECEIVE_BUFFER_ALIGN_SIZE (256) + +/* Number of milliseconds we wait for auto-negotiation to complete */ +#define LINK_UP_TIMEOUT 500 + +/* Number of 100 microseconds we wait for PCI Express master disable */ +#define MASTER_DISABLE_TIMEOUT 800 +/* Number of milliseconds we wait for Eeprom auto read bit done after MA= C reset */ +#define AUTO_READ_DONE_TIMEOUT 10 +/* Number of milliseconds we wait for PHY configuration done after MAC r= eset */ +#define PHY_CFG_TIMEOUT 100 + +#define E1000_TX_BUFFER_SIZE ((uint32_t)1514) + +/* The carrier extension symbol, as received by the NIC. */ +#define CARRIER_EXTENSION 0x0F + +/* TBI_ACCEPT macro definition: + * + * This macro requires: + * adapter =3D a pointer to struct e1000_hw + * status =3D the 8 bit status field of the RX descriptor with EOP = set + * error =3D the 8 bit error field of the RX descriptor with EOP se= t + * length =3D the sum of all the length fields of the RX descriptor= s that + * make up the current frame + * last_byte =3D the last byte of the frame DMAed by the hardware + * max_frame_length =3D the maximum frame length we want to accept. + * min_frame_length =3D the minimum frame length we want to accept. + * + * This macro is a conditional that should be used in the interrupt + * handler's Rx processing routine when RxErrors have been detected. + * + * Typical use: + * ... + * if (TBI_ACCEPT) { + * accept_frame =3D TRUE; + * e1000_tbi_adjust_stats(adapter, MacAddress); + * frame_length--; + * } else { + * accept_frame =3D FALSE; + * } + * ... + */ + +#define TBI_ACCEPT(adapter, status, errors, length, last_byte) \ + ((adapter)->tbi_compatibility_on && \ + (((errors) & E1000_RXD_ERR_FRAME_ERR_MASK) =3D=3D E1000_RXD_ERR_CE)= && \ + ((last_byte) =3D=3D CARRIER_EXTENSION) && \ + (((status) & E1000_RXD_STAT_VP) ? \ + (((length) > ((adapter)->min_frame_size - VLAN_TAG_SIZE)) && \ + ((length) <=3D ((adapter)->max_frame_size + 1))) : \ + (((length) > (adapter)->min_frame_size) && \ + ((length) <=3D ((adapter)->max_frame_size + VLAN_TAG_SIZE + 1= ))))) + + +/* Structures, enums, and macros for the PHY */ + +/* Bit definitions for the Management Data IO (MDIO) and Management Data + * Clock (MDC) pins in the Device Control Register. + */ +#define E1000_CTRL_PHY_RESET_DIR E1000_CTRL_SWDPIO0 +#define E1000_CTRL_PHY_RESET E1000_CTRL_SWDPIN0 +#define E1000_CTRL_MDIO_DIR E1000_CTRL_SWDPIO2 +#define E1000_CTRL_MDIO E1000_CTRL_SWDPIN2 +#define E1000_CTRL_MDC_DIR E1000_CTRL_SWDPIO3 +#define E1000_CTRL_MDC E1000_CTRL_SWDPIN3 +#define E1000_CTRL_PHY_RESET_DIR4 E1000_CTRL_EXT_SDP4_DIR +#define E1000_CTRL_PHY_RESET4 E1000_CTRL_EXT_SDP4_DATA + +/* PHY 1000 MII Register/Bit Definitions */ +/* PHY Registers defined by IEEE */ +#define PHY_CTRL 0x00 /* Control Register */ +#define PHY_STATUS 0x01 /* Status Regiser */ +#define PHY_ID1 0x02 /* Phy Id Reg (word 1) */ +#define PHY_ID2 0x03 /* Phy Id Reg (word 2) */ +#define PHY_AUTONEG_ADV 0x04 /* Autoneg Advertisement */ +#define PHY_LP_ABILITY 0x05 /* Link Partner Ability (Base Page) */ +#define PHY_AUTONEG_EXP 0x06 /* Autoneg Expansion Reg */ +#define PHY_NEXT_PAGE_TX 0x07 /* Next Page TX */ +#define PHY_LP_NEXT_PAGE 0x08 /* Link Partner Next Page */ +#define PHY_1000T_CTRL 0x09 /* 1000Base-T Control Reg */ +#define PHY_1000T_STATUS 0x0A /* 1000Base-T Status Reg */ +#define PHY_EXT_STATUS 0x0F /* Extended Status Reg */ + +#define MAX_PHY_REG_ADDRESS 0x1F /* 5 bit address bus (0-0x1F) *= / +#define MAX_PHY_MULTI_PAGE_REG 0xF /* Registers equal on all pages= */ + +/* M88E1000 Specific Registers */ +#define M88E1000_PHY_SPEC_CTRL 0x10 /* PHY Specific Control Registe= r */ +#define M88E1000_PHY_SPEC_STATUS 0x11 /* PHY Specific Status Register= */ +#define M88E1000_INT_ENABLE 0x12 /* Interrupt Enable Register */ +#define M88E1000_INT_STATUS 0x13 /* Interrupt Status Register */ +#define M88E1000_EXT_PHY_SPEC_CTRL 0x14 /* Extended PHY Specific Contro= l */ +#define M88E1000_RX_ERR_CNTR 0x15 /* Receive Error Counter */ + +#define M88E1000_PHY_EXT_CTRL 0x1A /* PHY extend control register = */ +#define M88E1000_PHY_PAGE_SELECT 0x1D /* Reg 29 for page number setti= ng */ +#define M88E1000_PHY_GEN_CONTROL 0x1E /* Its meaning depends on reg 2= 9 */ +#define M88E1000_PHY_VCO_REG_BIT8 0x100 /* Bits 8 & 11 are adjusted for= */ +#define M88E1000_PHY_VCO_REG_BIT11 0x800 /* improved BER performance = */ + +#define IGP01E1000_IEEE_REGS_PAGE 0x0000 +#define IGP01E1000_IEEE_RESTART_AUTONEG 0x3300 +#define IGP01E1000_IEEE_FORCE_GIGA 0x0140 + +/* IGP01E1000 Specific Registers */ +#define IGP01E1000_PHY_PORT_CONFIG 0x10 /* PHY Specific Port Config Regi= ster */ +#define IGP01E1000_PHY_PORT_STATUS 0x11 /* PHY Specific Status Register = */ +#define IGP01E1000_PHY_PORT_CTRL 0x12 /* PHY Specific Control Register= */ +#define IGP01E1000_PHY_LINK_HEALTH 0x13 /* PHY Link Health Register */ +#define IGP01E1000_GMII_FIFO 0x14 /* GMII FIFO Register */ +#define IGP01E1000_PHY_CHANNEL_QUALITY 0x15 /* PHY Channel Quality Regis= ter */ +#define IGP02E1000_PHY_POWER_MGMT 0x19 +#define IGP01E1000_PHY_PAGE_SELECT 0x1F /* PHY Page Select Core Regi= ster */ + +/* IGP01E1000 AGC Registers - stores the cable length values*/ +#define IGP01E1000_PHY_AGC_A 0x1172 +#define IGP01E1000_PHY_AGC_B 0x1272 +#define IGP01E1000_PHY_AGC_C 0x1472 +#define IGP01E1000_PHY_AGC_D 0x1872 + +/* IGP02E1000 AGC Registers for cable length values */ +#define IGP02E1000_PHY_AGC_A 0x11B1 +#define IGP02E1000_PHY_AGC_B 0x12B1 +#define IGP02E1000_PHY_AGC_C 0x14B1 +#define IGP02E1000_PHY_AGC_D 0x18B1 + +/* IGP01E1000 DSP Reset Register */ +#define IGP01E1000_PHY_DSP_RESET 0x1F33 +#define IGP01E1000_PHY_DSP_SET 0x1F71 +#define IGP01E1000_PHY_DSP_FFE 0x1F35 + +#define IGP01E1000_PHY_CHANNEL_NUM 4 +#define IGP02E1000_PHY_CHANNEL_NUM 4 + +#define IGP01E1000_PHY_AGC_PARAM_A 0x1171 +#define IGP01E1000_PHY_AGC_PARAM_B 0x1271 +#define IGP01E1000_PHY_AGC_PARAM_C 0x1471 +#define IGP01E1000_PHY_AGC_PARAM_D 0x1871 + +#define IGP01E1000_PHY_EDAC_MU_INDEX 0xC000 +#define IGP01E1000_PHY_EDAC_SIGN_EXT_9_BITS 0x8000 + +#define IGP01E1000_PHY_ANALOG_TX_STATE 0x2890 +#define IGP01E1000_PHY_ANALOG_CLASS_A 0x2000 +#define IGP01E1000_PHY_FORCE_ANALOG_ENABLE 0x0004 +#define IGP01E1000_PHY_DSP_FFE_CM_CP 0x0069 + +#define IGP01E1000_PHY_DSP_FFE_DEFAULT 0x002A +/* IGP01E1000 PCS Initialization register - stores the polarity status w= hen + * speed =3D 1000 Mbps. */ +#define IGP01E1000_PHY_PCS_INIT_REG 0x00B4 +#define IGP01E1000_PHY_PCS_CTRL_REG 0x00B5 + +#define IGP01E1000_ANALOG_REGS_PAGE 0x20C0 + +/* Bits... + * 15-5: page + * 4-0: register offset + */ +#define GG82563_PAGE_SHIFT 5 +#define GG82563_REG(page, reg) \ + (((page) << GG82563_PAGE_SHIFT) | ((reg) & MAX_PHY_REG_ADDRESS)) +#define GG82563_MIN_ALT_REG 30 + +/* GG82563 Specific Registers */ +#define GG82563_PHY_SPEC_CTRL \ + GG82563_REG(0, 16) /* PHY Specific Control */ +#define GG82563_PHY_SPEC_STATUS \ + GG82563_REG(0, 17) /* PHY Specific Status */ +#define GG82563_PHY_INT_ENABLE \ + GG82563_REG(0, 18) /* Interrupt Enable */ +#define GG82563_PHY_SPEC_STATUS_2 \ + GG82563_REG(0, 19) /* PHY Specific Status 2 */ +#define GG82563_PHY_RX_ERR_CNTR \ + GG82563_REG(0, 21) /* Receive Error Counter */ +#define GG82563_PHY_PAGE_SELECT \ + GG82563_REG(0, 22) /* Page Select */ +#define GG82563_PHY_SPEC_CTRL_2 \ + GG82563_REG(0, 26) /* PHY Specific Control 2 */ +#define GG82563_PHY_PAGE_SELECT_ALT \ + GG82563_REG(0, 29) /* Alternate Page Select */ +#define GG82563_PHY_TEST_CLK_CTRL \ + GG82563_REG(0, 30) /* Test Clock Control (use reg. 29 to select)= */ + +#define GG82563_PHY_MAC_SPEC_CTRL \ + GG82563_REG(2, 21) /* MAC Specific Control Register */ +#define GG82563_PHY_MAC_SPEC_CTRL_2 \ + GG82563_REG(2, 26) /* MAC Specific Control 2 */ + +#define GG82563_PHY_DSP_DISTANCE \ + GG82563_REG(5, 26) /* DSP Distance */ + +/* Page 193 - Port Control Registers */ +#define GG82563_PHY_KMRN_MODE_CTRL \ + GG82563_REG(193, 16) /* Kumeran Mode Control */ +#define GG82563_PHY_PORT_RESET \ + GG82563_REG(193, 17) /* Port Reset */ +#define GG82563_PHY_REVISION_ID \ + GG82563_REG(193, 18) /* Revision ID */ +#define GG82563_PHY_DEVICE_ID \ + GG82563_REG(193, 19) /* Device ID */ +#define GG82563_PHY_PWR_MGMT_CTRL \ + GG82563_REG(193, 20) /* Power Management Control */ +#define GG82563_PHY_RATE_ADAPT_CTRL \ + GG82563_REG(193, 25) /* Rate Adaptation Control */ + +/* Page 194 - KMRN Registers */ +#define GG82563_PHY_KMRN_FIFO_CTRL_STAT \ + GG82563_REG(194, 16) /* FIFO's Control/Status */ +#define GG82563_PHY_KMRN_CTRL \ + GG82563_REG(194, 17) /* Control */ +#define GG82563_PHY_INBAND_CTRL \ + GG82563_REG(194, 18) /* Inband Control */ +#define GG82563_PHY_KMRN_DIAGNOSTIC \ + GG82563_REG(194, 19) /* Diagnostic */ +#define GG82563_PHY_ACK_TIMEOUTS \ + GG82563_REG(194, 20) /* Acknowledge Timeouts */ +#define GG82563_PHY_ADV_ABILITY \ + GG82563_REG(194, 21) /* Advertised Ability */ +#define GG82563_PHY_LINK_PARTNER_ADV_ABILITY \ + GG82563_REG(194, 23) /* Link Partner Advertised Ability */ +#define GG82563_PHY_ADV_NEXT_PAGE \ + GG82563_REG(194, 24) /* Advertised Next Page */ +#define GG82563_PHY_LINK_PARTNER_ADV_NEXT_PAGE \ + GG82563_REG(194, 25) /* Link Partner Advertised Next page */ +#define GG82563_PHY_KMRN_MISC \ + GG82563_REG(194, 26) /* Misc. */ + +/* PHY Control Register */ +#define MII_CR_SPEED_SELECT_MSB 0x0040 /* bits 6,13: 10=3D1000, 01=3D10= 0, 00=3D10 */ +#define MII_CR_COLL_TEST_ENABLE 0x0080 /* Collision test enable */ +#define MII_CR_FULL_DUPLEX 0x0100 /* FDX =3D1, half duplex =3D0 */ +#define MII_CR_RESTART_AUTO_NEG 0x0200 /* Restart auto negotiation */ +#define MII_CR_ISOLATE 0x0400 /* Isolate PHY from MII */ +#define MII_CR_POWER_DOWN 0x0800 /* Power down */ +#define MII_CR_AUTO_NEG_EN 0x1000 /* Auto Neg Enable */ +#define MII_CR_SPEED_SELECT_LSB 0x2000 /* bits 6,13: 10=3D1000, 01=3D10= 0, 00=3D10 */ +#define MII_CR_LOOPBACK 0x4000 /* 0 =3D normal, 1 =3D loopback = */ +#define MII_CR_RESET 0x8000 /* 0 =3D normal, 1 =3D PHY reset= */ + +/* PHY Status Register */ +#define MII_SR_EXTENDED_CAPS 0x0001 /* Extended register capabilitie= s */ +#define MII_SR_JABBER_DETECT 0x0002 /* Jabber Detected */ +#define MII_SR_LINK_STATUS 0x0004 /* Link Status 1 =3D link */ +#define MII_SR_AUTONEG_CAPS 0x0008 /* Auto Neg Capable */ +#define MII_SR_REMOTE_FAULT 0x0010 /* Remote Fault Detect */ +#define MII_SR_AUTONEG_COMPLETE 0x0020 /* Auto Neg Complete */ +#define MII_SR_PREAMBLE_SUPPRESS 0x0040 /* Preamble may be suppressed */ +#define MII_SR_EXTENDED_STATUS 0x0100 /* Ext. status info in Reg 0x0F = */ +#define MII_SR_100T2_HD_CAPS 0x0200 /* 100T2 Half Duplex Capable */ +#define MII_SR_100T2_FD_CAPS 0x0400 /* 100T2 Full Duplex Capable */ +#define MII_SR_10T_HD_CAPS 0x0800 /* 10T Half Duplex Capable */ +#define MII_SR_10T_FD_CAPS 0x1000 /* 10T Full Duplex Capable */ +#define MII_SR_100X_HD_CAPS 0x2000 /* 100X Half Duplex Capable */ +#define MII_SR_100X_FD_CAPS 0x4000 /* 100X Full Duplex Capable */ +#define MII_SR_100T4_CAPS 0x8000 /* 100T4 Capable */ + +/* Autoneg Advertisement Register */ +#define NWAY_AR_SELECTOR_FIELD 0x0001 /* indicates IEEE 802.3 CSMA/CD = */ +#define NWAY_AR_10T_HD_CAPS 0x0020 /* 10T Half Duplex Capable */ +#define NWAY_AR_10T_FD_CAPS 0x0040 /* 10T Full Duplex Capable */ +#define NWAY_AR_100TX_HD_CAPS 0x0080 /* 100TX Half Duplex Capable */ +#define NWAY_AR_100TX_FD_CAPS 0x0100 /* 100TX Full Duplex Capable */ +#define NWAY_AR_100T4_CAPS 0x0200 /* 100T4 Capable */ +#define NWAY_AR_PAUSE 0x0400 /* Pause operation desired */ +#define NWAY_AR_ASM_DIR 0x0800 /* Asymmetric Pause Direction bi= t */ +#define NWAY_AR_REMOTE_FAULT 0x2000 /* Remote Fault detected */ +#define NWAY_AR_NEXT_PAGE 0x8000 /* Next Page ability supported *= / + +/* Link Partner Ability Register (Base Page) */ +#define NWAY_LPAR_SELECTOR_FIELD 0x0000 /* LP protocol selector field */ +#define NWAY_LPAR_10T_HD_CAPS 0x0020 /* LP is 10T Half Duplex Capab= le */ +#define NWAY_LPAR_10T_FD_CAPS 0x0040 /* LP is 10T Full Duplex Capab= le */ +#define NWAY_LPAR_100TX_HD_CAPS 0x0080 /* LP is 100TX Half Duplex Capab= le */ +#define NWAY_LPAR_100TX_FD_CAPS 0x0100 /* LP is 100TX Full Duplex Capab= le */ +#define NWAY_LPAR_100T4_CAPS 0x0200 /* LP is 100T4 Capable */ +#define NWAY_LPAR_PAUSE 0x0400 /* LP Pause operation desired */ +#define NWAY_LPAR_ASM_DIR 0x0800 /* LP Asymmetric Pause Direction= bit */ +#define NWAY_LPAR_REMOTE_FAULT 0x2000 /* LP has detected Remote Fault = */ +#define NWAY_LPAR_ACKNOWLEDGE 0x4000 /* LP has rx'd link code word */ +#define NWAY_LPAR_NEXT_PAGE 0x8000 /* Next Page ability supported *= / + +/* Autoneg Expansion Register */ +#define NWAY_ER_LP_NWAY_CAPS 0x0001 /* LP has Auto Neg Capability *= / +#define NWAY_ER_PAGE_RXD 0x0002 /* LP is 10T Half Duplex Capa= ble */ +#define NWAY_ER_NEXT_PAGE_CAPS 0x0004 /* LP is 10T Full Duplex Capa= ble */ +#define NWAY_ER_LP_NEXT_PAGE_CAPS 0x0008 /* LP is 100TX Half Duplex Capa= ble */ +#define NWAY_ER_PAR_DETECT_FAULT 0x0010 /* LP is 100TX Full Duplex Capa= ble */ + +/* Next Page TX Register */ +#define NPTX_MSG_CODE_FIELD 0x0001 /* NP msg code or unformatted data */ +#define NPTX_TOGGLE 0x0800 /* Toggles between exchanges + * of different NP + */ +#define NPTX_ACKNOWLDGE2 0x1000 /* 1 =3D will comply with msg + * 0 =3D cannot comply with msg + */ +#define NPTX_MSG_PAGE 0x2000 /* formatted(1)/unformatted(0) pg */ +#define NPTX_NEXT_PAGE 0x8000 /* 1 =3D addition NP will follow + * 0 =3D sending last NP + */ + +/* Link Partner Next Page Register */ +#define LP_RNPR_MSG_CODE_FIELD 0x0001 /* NP msg code or unformatted data= */ +#define LP_RNPR_TOGGLE 0x0800 /* Toggles between exchanges + * of different NP + */ +#define LP_RNPR_ACKNOWLDGE2 0x1000 /* 1 =3D will comply with msg + * 0 =3D cannot comply with msg + */ +#define LP_RNPR_MSG_PAGE 0x2000 /* formatted(1)/unformatted(0) pg= */ +#define LP_RNPR_ACKNOWLDGE 0x4000 /* 1 =3D ACK / 0 =3D NO ACK */ +#define LP_RNPR_NEXT_PAGE 0x8000 /* 1 =3D addition NP will follow + * 0 =3D sending last NP + */ + +/* 1000BASE-T Control Register */ +#define CR_1000T_ASYM_PAUSE 0x0080 /* Advertise asymmetric pause bi= t */ +#define CR_1000T_HD_CAPS 0x0100 /* Advertise 1000T HD capability= */ +#define CR_1000T_FD_CAPS 0x0200 /* Advertise 1000T FD capability= */ +#define CR_1000T_REPEATER_DTE 0x0400 /* 1=3DRepeater/switch device po= rt */ + /* 0=3DDTE device */ +#define CR_1000T_MS_VALUE 0x0800 /* 1=3DConfigure PHY as Master *= / + /* 0=3DConfigure PHY as Slave */ +#define CR_1000T_MS_ENABLE 0x1000 /* 1=3DMaster/Slave manual confi= g value */ + /* 0=3DAutomatic Master/Slave co= nfig */ +#define CR_1000T_TEST_MODE_NORMAL 0x0000 /* Normal Operation */ +#define CR_1000T_TEST_MODE_1 0x2000 /* Transmit Waveform test */ +#define CR_1000T_TEST_MODE_2 0x4000 /* Master Transmit Jitter test *= / +#define CR_1000T_TEST_MODE_3 0x6000 /* Slave Transmit Jitter test */ +#define CR_1000T_TEST_MODE_4 0x8000 /* Transmitter Distortion test *= / + +/* 1000BASE-T Status Register */ +#define SR_1000T_IDLE_ERROR_CNT 0x00FF /* Num idle errors since last r= ead */ +#define SR_1000T_ASYM_PAUSE_DIR 0x0100 /* LP asymmetric pause directio= n bit */ +#define SR_1000T_LP_HD_CAPS 0x0400 /* LP is 1000T HD capable */ +#define SR_1000T_LP_FD_CAPS 0x0800 /* LP is 1000T FD capable */ +#define SR_1000T_REMOTE_RX_STATUS 0x1000 /* Remote receiver OK */ +#define SR_1000T_LOCAL_RX_STATUS 0x2000 /* Local receiver OK */ +#define SR_1000T_MS_CONFIG_RES 0x4000 /* 1=3DLocal TX is Master, 0=3D= Slave */ +#define SR_1000T_MS_CONFIG_FAULT 0x8000 /* Master/Slave config fault */ +#define SR_1000T_REMOTE_RX_STATUS_SHIFT 12 +#define SR_1000T_LOCAL_RX_STATUS_SHIFT 13 +#define SR_1000T_PHY_EXCESSIVE_IDLE_ERR_COUNT 5 +#define FFE_IDLE_ERR_COUNT_TIMEOUT_20 20 +#define FFE_IDLE_ERR_COUNT_TIMEOUT_100 100 + +/* Extended Status Register */ +#define IEEE_ESR_1000T_HD_CAPS 0x1000 /* 1000T HD capable */ +#define IEEE_ESR_1000T_FD_CAPS 0x2000 /* 1000T FD capable */ +#define IEEE_ESR_1000X_HD_CAPS 0x4000 /* 1000X HD capable */ +#define IEEE_ESR_1000X_FD_CAPS 0x8000 /* 1000X FD capable */ + +#define PHY_TX_POLARITY_MASK 0x0100 /* register 10h bit 8 (polarity bi= t) */ +#define PHY_TX_NORMAL_POLARITY 0 /* register 10h bit 8 (normal pola= rity) */ + +#define AUTO_POLARITY_DISABLE 0x0010 /* register 11h bit 4 */ + /* (0=3Denable, 1=3Ddisable) */ + +/* M88E1000 PHY Specific Control Register */ +#define M88E1000_PSCR_JABBER_DISABLE 0x0001 /* 1=3DJabber Function di= sabled */ +#define M88E1000_PSCR_POLARITY_REVERSAL 0x0002 /* 1=3DPolarity Reversal = enabled */ +#define M88E1000_PSCR_SQE_TEST 0x0004 /* 1=3DSQE Test enabled *= / +#define M88E1000_PSCR_CLK125_DISABLE 0x0010 /* 1=3DCLK125 low, + * 0=3DCLK125 toggling + */ +#define M88E1000_PSCR_MDI_MANUAL_MODE 0x0000 /* MDI Crossover Mode bit= s 6:5 */ + /* Manual MDI configurati= on */ +#define M88E1000_PSCR_MDIX_MANUAL_MODE 0x0020 /* Manual MDIX configurat= ion */ +#define M88E1000_PSCR_AUTO_X_1000T 0x0040 /* 1000BASE-T: Auto cross= over, + * 100BASE-TX/10BASE-T: + * MDI Mode + */ +#define M88E1000_PSCR_AUTO_X_MODE 0x0060 /* Auto crossover enabled + * all speeds. + */ +#define M88E1000_PSCR_10BT_EXT_DIST_ENABLE 0x0080 + /* 1=3DEnable Extended 10BASE-T = distance + * (Lower 10BASE-T RX Threshold) + * 0=3DNormal 10BASE-T RX Thresh= old */ +#define M88E1000_PSCR_MII_5BIT_ENABLE 0x0100 + /* 1=3D5-Bit interface in 100BAS= E-TX + * 0=3DMII interface in 100BASE-= TX */ +#define M88E1000_PSCR_SCRAMBLER_DISABLE 0x0200 /* 1=3DScrambler disab= le */ +#define M88E1000_PSCR_FORCE_LINK_GOOD 0x0400 /* 1=3DForce link good= */ +#define M88E1000_PSCR_ASSERT_CRS_ON_TX 0x0800 /* 1=3DAssert CRS on T= ransmit */ + +#define M88E1000_PSCR_POLARITY_REVERSAL_SHIFT 1 +#define M88E1000_PSCR_AUTO_X_MODE_SHIFT 5 +#define M88E1000_PSCR_10BT_EXT_DIST_ENABLE_SHIFT 7 + +/* M88E1000 PHY Specific Status Register */ +#define M88E1000_PSSR_JABBER 0x0001 /* 1=3DJabber */ +#define M88E1000_PSSR_REV_POLARITY 0x0002 /* 1=3DPolarity reversed= */ +#define M88E1000_PSSR_DOWNSHIFT 0x0020 /* 1=3DDownshifted */ +#define M88E1000_PSSR_MDIX 0x0040 /* 1=3DMDIX; 0=3DMDI */ +#define M88E1000_PSSR_CABLE_LENGTH 0x0380 /* 0=3D<50M;1=3D50-80M;2= =3D80-110M; + * 3=3D110-140M;4=3D>140M */ +#define M88E1000_PSSR_LINK 0x0400 /* 1=3DLink up, 0=3DLink= down */ +#define M88E1000_PSSR_SPD_DPLX_RESOLVED 0x0800 /* 1=3DSpeed & Duplex re= solved */ +#define M88E1000_PSSR_PAGE_RCVD 0x1000 /* 1=3DPage received */ +#define M88E1000_PSSR_DPLX 0x2000 /* 1=3DDuplex 0=3DHalf D= uplex */ +#define M88E1000_PSSR_SPEED 0xC000 /* Speed, bits 14:15 */ +#define M88E1000_PSSR_10MBS 0x0000 /* 00=3D10Mbs */ +#define M88E1000_PSSR_100MBS 0x4000 /* 01=3D100Mbs */ +#define M88E1000_PSSR_1000MBS 0x8000 /* 10=3D1000Mbs */ + +#define M88E1000_PSSR_REV_POLARITY_SHIFT 1 +#define M88E1000_PSSR_DOWNSHIFT_SHIFT 5 +#define M88E1000_PSSR_MDIX_SHIFT 6 +#define M88E1000_PSSR_CABLE_LENGTH_SHIFT 7 + +/* M88E1000 Extended PHY Specific Control Register */ +#define M88E1000_EPSCR_FIBER_LOOPBACK 0x4000 /* 1=3DFiber loopback */ +#define M88E1000_EPSCR_DOWN_NO_IDLE 0x8000 /* 1=3DLost lock detect ena= bled. + * Will assert lost lock an= d bring + * link down if idle not se= en + * within 1ms in 1000BASE-T + */ +/* Number of times we will attempt to autonegotiate before downshifting = if we + * are the master */ +#define M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK 0x0C00 +#define M88E1000_EPSCR_MASTER_DOWNSHIFT_1X 0x0000 +#define M88E1000_EPSCR_MASTER_DOWNSHIFT_2X 0x0400 +#define M88E1000_EPSCR_MASTER_DOWNSHIFT_3X 0x0800 +#define M88E1000_EPSCR_MASTER_DOWNSHIFT_4X 0x0C00 +/* Number of times we will attempt to autonegotiate before downshifting = if we + * are the slave */ +#define M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK 0x0300 +#define M88E1000_EPSCR_SLAVE_DOWNSHIFT_DIS 0x0000 +#define M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X 0x0100 +#define M88E1000_EPSCR_SLAVE_DOWNSHIFT_2X 0x0200 +#define M88E1000_EPSCR_SLAVE_DOWNSHIFT_3X 0x0300 +#define M88E1000_EPSCR_TX_CLK_2_5 0x0060 /* 2.5 MHz TX_CLK */ +#define M88E1000_EPSCR_TX_CLK_25 0x0070 /* 25 MHz TX_CLK */ +#define M88E1000_EPSCR_TX_CLK_0 0x0000 /* NO TX_CLK */ + +/* M88EC018 Rev 2 specific DownShift settings */ +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK 0x0E00 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_1X 0x0000 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_2X 0x0200 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_3X 0x0400 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_4X 0x0600 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X 0x0800 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_6X 0x0A00 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_7X 0x0C00 +#define M88EC018_EPSCR_DOWNSHIFT_COUNTER_8X 0x0E00 + +/* IGP01E1000 Specific Port Config Register - R/W */ +#define IGP01E1000_PSCFR_AUTO_MDIX_PAR_DETECT 0x0010 +#define IGP01E1000_PSCFR_PRE_EN 0x0020 +#define IGP01E1000_PSCFR_SMART_SPEED 0x0080 +#define IGP01E1000_PSCFR_DISABLE_TPLOOPBACK 0x0100 +#define IGP01E1000_PSCFR_DISABLE_JABBER 0x0400 +#define IGP01E1000_PSCFR_DISABLE_TRANSMIT 0x2000 + +/* IGP01E1000 Specific Port Status Register - R/O */ +#define IGP01E1000_PSSR_AUTONEG_FAILED 0x0001 /* RO LH SC */ +#define IGP01E1000_PSSR_POLARITY_REVERSED 0x0002 +#define IGP01E1000_PSSR_CABLE_LENGTH 0x007C +#define IGP01E1000_PSSR_FULL_DUPLEX 0x0200 +#define IGP01E1000_PSSR_LINK_UP 0x0400 +#define IGP01E1000_PSSR_MDIX 0x0800 +#define IGP01E1000_PSSR_SPEED_MASK 0xC000 /* speed bits mask= */ +#define IGP01E1000_PSSR_SPEED_10MBPS 0x4000 +#define IGP01E1000_PSSR_SPEED_100MBPS 0x8000 +#define IGP01E1000_PSSR_SPEED_1000MBPS 0xC000 +#define IGP01E1000_PSSR_CABLE_LENGTH_SHIFT 0x0002 /* shift right 2 *= / +#define IGP01E1000_PSSR_MDIX_SHIFT 0x000B /* shift right 11 = */ + +/* IGP01E1000 Specific Port Control Register - R/W */ +#define IGP01E1000_PSCR_TP_LOOPBACK 0x0010 +#define IGP01E1000_PSCR_CORRECT_NC_SCMBLR 0x0200 +#define IGP01E1000_PSCR_TEN_CRS_SELECT 0x0400 +#define IGP01E1000_PSCR_FLIP_CHIP 0x0800 +#define IGP01E1000_PSCR_AUTO_MDIX 0x1000 +#define IGP01E1000_PSCR_FORCE_MDI_MDIX 0x2000 /* 0-MDI, 1-MDIX *= / + +/* IGP01E1000 Specific Port Link Health Register */ +#define IGP01E1000_PLHR_SS_DOWNGRADE 0x8000 +#define IGP01E1000_PLHR_GIG_SCRAMBLER_ERROR 0x4000 +#define IGP01E1000_PLHR_MASTER_FAULT 0x2000 +#define IGP01E1000_PLHR_MASTER_RESOLUTION 0x1000 +#define IGP01E1000_PLHR_GIG_REM_RCVR_NOK 0x0800 /* LH */ +#define IGP01E1000_PLHR_IDLE_ERROR_CNT_OFLOW 0x0400 /* LH */ +#define IGP01E1000_PLHR_DATA_ERR_1 0x0200 /* LH */ +#define IGP01E1000_PLHR_DATA_ERR_0 0x0100 +#define IGP01E1000_PLHR_AUTONEG_FAULT 0x0040 +#define IGP01E1000_PLHR_AUTONEG_ACTIVE 0x0010 +#define IGP01E1000_PLHR_VALID_CHANNEL_D 0x0008 +#define IGP01E1000_PLHR_VALID_CHANNEL_C 0x0004 +#define IGP01E1000_PLHR_VALID_CHANNEL_B 0x0002 +#define IGP01E1000_PLHR_VALID_CHANNEL_A 0x0001 + +/* IGP01E1000 Channel Quality Register */ +#define IGP01E1000_MSE_CHANNEL_D 0x000F +#define IGP01E1000_MSE_CHANNEL_C 0x00F0 +#define IGP01E1000_MSE_CHANNEL_B 0x0F00 +#define IGP01E1000_MSE_CHANNEL_A 0xF000 + +#define IGP02E1000_PM_SPD 0x0001 /* Smart Power= Down */ +#define IGP02E1000_PM_D3_LPLU 0x0004 /* Enable LPLU= in non-D0a modes */ +#define IGP02E1000_PM_D0_LPLU 0x0002 /* Enable LPLU= in D0a mode */ + +/* IGP01E1000 DSP reset macros */ +#define DSP_RESET_ENABLE 0x0 +#define DSP_RESET_DISABLE 0x2 +#define E1000_MAX_DSP_RESETS 10 + +/* IGP01E1000 & IGP02E1000 AGC Registers */ + +#define IGP01E1000_AGC_LENGTH_SHIFT 7 /* Coarse - 13:11, Fine - = 10:7 */ +#define IGP02E1000_AGC_LENGTH_SHIFT 9 /* Coarse - 15:13, Fine - = 12:9 */ + +/* IGP02E1000 AGC Register Length 9-bit mask */ +#define IGP02E1000_AGC_LENGTH_MASK 0x7F + +/* 7 bits (3 Coarse + 4 Fine) --> 128 optional values */ +#define IGP01E1000_AGC_LENGTH_TABLE_SIZE 128 +#define IGP02E1000_AGC_LENGTH_TABLE_SIZE 113 + +/* The precision error of the cable length is +/- 10 meters */ +#define IGP01E1000_AGC_RANGE 10 +#define IGP02E1000_AGC_RANGE 15 + +/* IGP01E1000 PCS Initialization register */ +/* bits 3:6 in the PCS registers stores the channels polarity */ +#define IGP01E1000_PHY_POLARITY_MASK 0x0078 + +/* IGP01E1000 GMII FIFO Register */ +#define IGP01E1000_GMII_FLEX_SPD 0x10 /* Enable flexible s= peed + * on Link-Up */ +#define IGP01E1000_GMII_SPD 0x20 /* Enable SPD */ + +/* IGP01E1000 Analog Register */ +#define IGP01E1000_ANALOG_SPARE_FUSE_STATUS 0x20D1 +#define IGP01E1000_ANALOG_FUSE_STATUS 0x20D0 +#define IGP01E1000_ANALOG_FUSE_CONTROL 0x20DC +#define IGP01E1000_ANALOG_FUSE_BYPASS 0x20DE + +#define IGP01E1000_ANALOG_FUSE_POLY_MASK 0xF000 +#define IGP01E1000_ANALOG_FUSE_FINE_MASK 0x0F80 +#define IGP01E1000_ANALOG_FUSE_COARSE_MASK 0x0070 +#define IGP01E1000_ANALOG_SPARE_FUSE_ENABLED 0x0100 +#define IGP01E1000_ANALOG_FUSE_ENABLE_SW_CONTROL 0x0002 + +#define IGP01E1000_ANALOG_FUSE_COARSE_THRESH 0x0040 +#define IGP01E1000_ANALOG_FUSE_COARSE_10 0x0010 +#define IGP01E1000_ANALOG_FUSE_FINE_1 0x0080 +#define IGP01E1000_ANALOG_FUSE_FINE_10 0x0500 + +/* GG82563 PHY Specific Status Register (Page 0, Register 16 */ +#define GG82563_PSCR_DISABLE_JABBER 0x0001 /* 1=3DDisable Ja= bber */ +#define GG82563_PSCR_POLARITY_REVERSAL_DISABLE 0x0002 /* 1=3DPolarity R= eversal Disabled */ +#define GG82563_PSCR_POWER_DOWN 0x0004 /* 1=3DPower Down= */ +#define GG82563_PSCR_COPPER_TRANSMITER_DISABLE 0x0008 /* 1=3DTransmitte= r Disabled */ +#define GG82563_PSCR_CROSSOVER_MODE_MASK 0x0060 +#define GG82563_PSCR_CROSSOVER_MODE_MDI 0x0000 /* 00=3DManual MD= I configuration */ +#define GG82563_PSCR_CROSSOVER_MODE_MDIX 0x0020 /* 01=3DManual MD= IX configuration */ +#define GG82563_PSCR_CROSSOVER_MODE_AUTO 0x0060 /* 11=3DAutomatic= crossover */ +#define GG82563_PSCR_ENALBE_EXTENDED_DISTANCE 0x0080 /* 1=3DEnable Ext= ended Distance */ +#define GG82563_PSCR_ENERGY_DETECT_MASK 0x0300 +#define GG82563_PSCR_ENERGY_DETECT_OFF 0x0000 /* 00,01=3DOff */ +#define GG82563_PSCR_ENERGY_DETECT_RX 0x0200 /* 10=3DSense on = Rx only (Energy Detect) */ +#define GG82563_PSCR_ENERGY_DETECT_RX_TM 0x0300 /* 11=3DSense and= Tx NLP */ +#define GG82563_PSCR_FORCE_LINK_GOOD 0x0400 /* 1=3DForce Link= Good */ +#define GG82563_PSCR_DOWNSHIFT_ENABLE 0x0800 /* 1=3DEnable Dow= nshift */ +#define GG82563_PSCR_DOWNSHIFT_COUNTER_MASK 0x7000 +#define GG82563_PSCR_DOWNSHIFT_COUNTER_SHIFT 12 + +/* PHY Specific Status Register (Page 0, Register 17) */ +#define GG82563_PSSR_JABBER 0x0001 /* 1=3DJabber */ +#define GG82563_PSSR_POLARITY 0x0002 /* 1=3DPolarity Revers= ed */ +#define GG82563_PSSR_LINK 0x0008 /* 1=3DLink is Up */ +#define GG82563_PSSR_ENERGY_DETECT 0x0010 /* 1=3DSleep, 0=3DActi= ve */ +#define GG82563_PSSR_DOWNSHIFT 0x0020 /* 1=3DDownshift */ +#define GG82563_PSSR_CROSSOVER_STATUS 0x0040 /* 1=3DMDIX, 0=3DMDI *= / +#define GG82563_PSSR_RX_PAUSE_ENABLED 0x0100 /* 1=3DReceive Pause E= nabled */ +#define GG82563_PSSR_TX_PAUSE_ENABLED 0x0200 /* 1=3DTransmit Pause = Enabled */ +#define GG82563_PSSR_LINK_UP 0x0400 /* 1=3DLink Up */ +#define GG82563_PSSR_SPEED_DUPLEX_RESOLVED 0x0800 /* 1=3DResolved */ +#define GG82563_PSSR_PAGE_RECEIVED 0x1000 /* 1=3DPage Received *= / +#define GG82563_PSSR_DUPLEX 0x2000 /* 1-Full-Duplex */ +#define GG82563_PSSR_SPEED_MASK 0xC000 +#define GG82563_PSSR_SPEED_10MBPS 0x0000 /* 00=3D10Mbps */ +#define GG82563_PSSR_SPEED_100MBPS 0x4000 /* 01=3D100Mbps */ +#define GG82563_PSSR_SPEED_1000MBPS 0x8000 /* 10=3D1000Mbps */ + +/* PHY Specific Status Register 2 (Page 0, Register 19) */ +#define GG82563_PSSR2_JABBER 0x0001 /* 1=3DJabber */ +#define GG82563_PSSR2_POLARITY_CHANGED 0x0002 /* 1=3DPolarity Chang= ed */ +#define GG82563_PSSR2_ENERGY_DETECT_CHANGED 0x0010 /* 1=3DEnergy Detect = Changed */ +#define GG82563_PSSR2_DOWNSHIFT_INTERRUPT 0x0020 /* 1=3DDownshift Dete= cted */ +#define GG82563_PSSR2_MDI_CROSSOVER_CHANGE 0x0040 /* 1=3DCrossover Chan= ged */ +#define GG82563_PSSR2_FALSE_CARRIER 0x0100 /* 1=3DFalse Carrier = */ +#define GG82563_PSSR2_SYMBOL_ERROR 0x0200 /* 1=3DSymbol Error *= / +#define GG82563_PSSR2_LINK_STATUS_CHANGED 0x0400 /* 1=3DLink Status Ch= anged */ +#define GG82563_PSSR2_AUTO_NEG_COMPLETED 0x0800 /* 1=3DAuto-Neg Compl= eted */ +#define GG82563_PSSR2_PAGE_RECEIVED 0x1000 /* 1=3DPage Received = */ +#define GG82563_PSSR2_DUPLEX_CHANGED 0x2000 /* 1=3DDuplex Changed= */ +#define GG82563_PSSR2_SPEED_CHANGED 0x4000 /* 1=3DSpeed Changed = */ +#define GG82563_PSSR2_AUTO_NEG_ERROR 0x8000 /* 1=3DAuto-Neg Error= */ + +/* PHY Specific Control Register 2 (Page 0, Register 26) */ +#define GG82563_PSCR2_10BT_POLARITY_FORCE 0x0002 /* 1=3DForce = Negative Polarity */ +#define GG82563_PSCR2_1000MB_TEST_SELECT_MASK 0x000C +#define GG82563_PSCR2_1000MB_TEST_SELECT_NORMAL 0x0000 /* 00,01=3DNo= rmal Operation */ +#define GG82563_PSCR2_1000MB_TEST_SELECT_112NS 0x0008 /* 10=3DSelec= t 112ns Sequence */ +#define GG82563_PSCR2_1000MB_TEST_SELECT_16NS 0x000C /* 11=3DSelec= t 16ns Sequence */ +#define GG82563_PSCR2_REVERSE_AUTO_NEG 0x2000 /* 1=3DRevers= e Auto-Negotiation */ +#define GG82563_PSCR2_1000BT_DISABLE 0x4000 /* 1=3DDisabl= e 1000BASE-T */ +#define GG82563_PSCR2_TRANSMITER_TYPE_MASK 0x8000 +#define GG82563_PSCR2_TRANSMITTER_TYPE_CLASS_B 0x0000 /* 0=3DClass = B */ +#define GG82563_PSCR2_TRANSMITTER_TYPE_CLASS_A 0x8000 /* 1=3DClass = A */ + +/* MAC Specific Control Register (Page 2, Register 21) */ +/* Tx clock speed for Link Down and 1000BASE-T for the following speeds = */ +#define GG82563_MSCR_TX_CLK_MASK 0x0007 +#define GG82563_MSCR_TX_CLK_10MBPS_2_5MHZ 0x0004 +#define GG82563_MSCR_TX_CLK_100MBPS_25MHZ 0x0005 +#define GG82563_MSCR_TX_CLK_1000MBPS_2_5MHZ 0x0006 +#define GG82563_MSCR_TX_CLK_1000MBPS_25MHZ 0x0007 + +#define GG82563_MSCR_ASSERT_CRS_ON_TX 0x0010 /* 1=3DAssert= */ + +/* DSP Distance Register (Page 5, Register 26) */ +#define GG82563_DSPD_CABLE_LENGTH 0x0007 /* 0 =3D <50M; + 1 =3D 50-80M; + 2 =3D 80-110M; + 3 =3D 110-140M= ; + 4 =3D >140M */ + +/* Kumeran Mode Control Register (Page 193, Register 16) */ +#define GG82563_KMCR_PHY_LEDS_EN 0x0020 /* 1=3DPHY LE= Ds, 0=3DKumeran Inband LEDs */ +#define GG82563_KMCR_FORCE_LINK_UP 0x0040 /* 1=3DForce = Link Up */ +#define GG82563_KMCR_SUPPRESS_SGMII_EPD_EXT 0x0080 +#define GG82563_KMCR_MDIO_BUS_SPEED_SELECT_MASK 0x0400 +#define GG82563_KMCR_MDIO_BUS_SPEED_SELECT 0x0400 /* 1=3D6.25MH= z, 0=3D0.8MHz */ +#define GG82563_KMCR_PASS_FALSE_CARRIER 0x0800 + +/* Power Management Control Register (Page 193, Register 20) */ +#define GG82563_PMCR_ENABLE_ELECTRICAL_IDLE 0x0001 /* 1=3DEnalbe= SERDES Electrical Idle */ +#define GG82563_PMCR_DISABLE_PORT 0x0002 /* 1=3DDisabl= e Port */ +#define GG82563_PMCR_DISABLE_SERDES 0x0004 /* 1=3DDisabl= e SERDES */ +#define GG82563_PMCR_REVERSE_AUTO_NEG 0x0008 /* 1=3DEnable= Reverse Auto-Negotiation */ +#define GG82563_PMCR_DISABLE_1000_NON_D0 0x0010 /* 1=3DDisabl= e 1000Mbps Auto-Neg in non D0 */ +#define GG82563_PMCR_DISABLE_1000 0x0020 /* 1=3DDisabl= e 1000Mbps Auto-Neg Always */ +#define GG82563_PMCR_REVERSE_AUTO_NEG_D0A 0x0040 /* 1=3DEnable= D0a Reverse Auto-Negotiation */ +#define GG82563_PMCR_FORCE_POWER_STATE 0x0080 /* 1=3DForce = Power State */ +#define GG82563_PMCR_PROGRAMMED_POWER_STATE_MASK 0x0300 +#define GG82563_PMCR_PROGRAMMED_POWER_STATE_DR 0x0000 /* 00=3DDr */ +#define GG82563_PMCR_PROGRAMMED_POWER_STATE_D0U 0x0100 /* 01=3DD0u *= / +#define GG82563_PMCR_PROGRAMMED_POWER_STATE_D0A 0x0200 /* 10=3DD0a *= / +#define GG82563_PMCR_PROGRAMMED_POWER_STATE_D3 0x0300 /* 11=3DD3 */ + +/* In-Band Control Register (Page 194, Register 18) */ +#define GG82563_ICR_DIS_PADDING 0x0010 /* Disable Pa= dding Use */ + + +/* Bit definitions for valid PHY IDs. */ +/* I =3D Integrated + * E =3D External + */ +#define M88_VENDOR 0x0141 +#define M88E1000_E_PHY_ID 0x01410C50 +#define M88E1000_I_PHY_ID 0x01410C30 +#define M88E1011_I_PHY_ID 0x01410C20 +#define IGP01E1000_I_PHY_ID 0x02A80380 +#define M88E1000_12_PHY_ID M88E1000_E_PHY_ID +#define M88E1000_14_PHY_ID M88E1000_E_PHY_ID +#define M88E1011_I_REV_4 0x04 +#define M88E1111_I_PHY_ID 0x01410CC0 +#define L1LXT971A_PHY_ID 0x001378E0 +#define GG82563_E_PHY_ID 0x01410CA0 + + +/* Bits... + * 15-5: page + * 4-0: register offset + */ +#define PHY_PAGE_SHIFT 5 +#define PHY_REG(page, reg) \ + (((page) << PHY_PAGE_SHIFT) | ((reg) & MAX_PHY_REG_ADDRESS)) + +#define IGP3_PHY_PORT_CTRL \ + PHY_REG(769, 17) /* Port General Configuration */ +#define IGP3_PHY_RATE_ADAPT_CTRL \ + PHY_REG(769, 25) /* Rate Adapter Control Register */ + +#define IGP3_KMRN_FIFO_CTRL_STATS \ + PHY_REG(770, 16) /* KMRN FIFO's control/status register */ +#define IGP3_KMRN_POWER_MNG_CTRL \ + PHY_REG(770, 17) /* KMRN Power Management Control Register */ +#define IGP3_KMRN_INBAND_CTRL \ + PHY_REG(770, 18) /* KMRN Inband Control Register */ +#define IGP3_KMRN_DIAG \ + PHY_REG(770, 19) /* KMRN Diagnostic register */ +#define IGP3_KMRN_DIAG_PCS_LOCK_LOSS 0x0002 /* RX PCS is not synced */ +#define IGP3_KMRN_ACK_TIMEOUT \ + PHY_REG(770, 20) /* KMRN Acknowledge Timeouts register */ + +#define IGP3_VR_CTRL \ + PHY_REG(776, 18) /* Voltage regulator control register */ +#define IGP3_VR_CTRL_MODE_SHUT 0x0200 /* Enter powerdown, shutdown= VRs */ +#define IGP3_VR_CTRL_MODE_MASK 0x0300 /* Shutdown VR Mask */ + +#define IGP3_CAPABILITY \ + PHY_REG(776, 19) /* IGP3 Capability Register */ + +/* Capabilities for SKU Control */ +#define IGP3_CAP_INITIATE_TEAM 0x0001 /* Able to initiate a team *= / +#define IGP3_CAP_WFM 0x0002 /* Support WoL and PXE */ +#define IGP3_CAP_ASF 0x0004 /* Support ASF */ +#define IGP3_CAP_LPLU 0x0008 /* Support Low Power Link Up= */ +#define IGP3_CAP_DC_AUTO_SPEED 0x0010 /* Support AC/DC Auto Link S= peed */ +#define IGP3_CAP_SPD 0x0020 /* Support Smart Power Down = */ +#define IGP3_CAP_MULT_QUEUE 0x0040 /* Support 2 tx & 2 rx queue= s */ +#define IGP3_CAP_RSS 0x0080 /* Support RSS */ +#define IGP3_CAP_8021PQ 0x0100 /* Support 802.1Q & 802.1p *= / +#define IGP3_CAP_AMT_CB 0x0200 /* Support active manageabil= ity and circuit breaker */ + +#define IGP3_PPC_JORDAN_EN 0x0001 +#define IGP3_PPC_JORDAN_GIGA_SPEED 0x0002 + +#define IGP3_KMRN_PMC_EE_IDLE_LINK_DIS 0x0001 +#define IGP3_KMRN_PMC_K0S_ENTRY_LATENCY_MASK 0x001E +#define IGP3_KMRN_PMC_K0S_MODE1_EN_GIGA 0x0020 +#define IGP3_KMRN_PMC_K0S_MODE1_EN_100 0x0040 + +#define IGP3E1000_PHY_MISC_CTRL 0x1B /* Misc. Ctrl regi= ster */ +#define IGP3_PHY_MISC_DUPLEX_MANUAL_SET 0x1000 /* Duplex Manual S= et */ + +#define IGP3_KMRN_EXT_CTRL PHY_REG(770, 18) +#define IGP3_KMRN_EC_DIS_INBAND 0x0080 + +#define IGP03E1000_E_PHY_ID 0x02A80390 +#define IFE_E_PHY_ID 0x02A80330 /* 10/100 PHY */ +#define IFE_PLUS_E_PHY_ID 0x02A80320 +#define IFE_C_E_PHY_ID 0x02A80310 + +#define IFE_PHY_EXTENDED_STATUS_CONTROL 0x10 /* 100BaseTx Extended St= atus, Control and Address */ +#define IFE_PHY_SPECIAL_CONTROL 0x11 /* 100BaseTx PHY special= control register */ +#define IFE_PHY_RCV_FALSE_CARRIER 0x13 /* 100BaseTx Receive Fal= se Carrier Counter */ +#define IFE_PHY_RCV_DISCONNECT 0x14 /* 100BaseTx Receive Dis= connet Counter */ +#define IFE_PHY_RCV_ERROT_FRAME 0x15 /* 100BaseTx Receive Err= or Frame Counter */ +#define IFE_PHY_RCV_SYMBOL_ERR 0x16 /* Receive Symbol Error = Counter */ +#define IFE_PHY_PREM_EOF_ERR 0x17 /* 100BaseTx Receive Pre= mature End Of Frame Error Counter */ +#define IFE_PHY_RCV_EOF_ERR 0x18 /* 10BaseT Receive End O= f Frame Error Counter */ +#define IFE_PHY_TX_JABBER_DETECT 0x19 /* 10BaseT Transmit Jabb= er Detect Counter */ +#define IFE_PHY_EQUALIZER 0x1A /* PHY Equalizer Control= and Status */ +#define IFE_PHY_SPECIAL_CONTROL_LED 0x1B /* PHY special control a= nd LED configuration */ +#define IFE_PHY_MDIX_CONTROL 0x1C /* MDI/MDI-X Control reg= ister */ +#define IFE_PHY_HWI_CONTROL 0x1D /* Hardware Integrity Co= ntrol (HWI) */ + +#define IFE_PESC_REDUCED_POWER_DOWN_DISABLE 0x2000 /* Defaut 1 =3D Dis= able auto reduced power down */ +#define IFE_PESC_100BTX_POWER_DOWN 0x0400 /* Indicates the po= wer state of 100BASE-TX */ +#define IFE_PESC_10BTX_POWER_DOWN 0x0200 /* Indicates the po= wer state of 10BASE-T */ +#define IFE_PESC_POLARITY_REVERSED 0x0100 /* Indicates 10BASE= -T polarity */ +#define IFE_PESC_PHY_ADDR_MASK 0x007C /* Bit 6:2 for samp= led PHY address */ +#define IFE_PESC_SPEED 0x0002 /* Auto-negotiation= speed result 1=3D100Mbs, 0=3D10Mbs */ +#define IFE_PESC_DUPLEX 0x0001 /* Auto-negotiation= duplex result 1=3DFull, 0=3DHalf */ +#define IFE_PESC_POLARITY_REVERSED_SHIFT 8 + +#define IFE_PSC_DISABLE_DYNAMIC_POWER_DOWN 0x0100 /* 1 =3D Dyanmic Po= wer Down disabled */ +#define IFE_PSC_FORCE_POLARITY 0x0020 /* 1=3DReversed Pol= arity, 0=3DNormal */ +#define IFE_PSC_AUTO_POLARITY_DISABLE 0x0010 /* 1=3DAuto Polarit= y Disabled, 0=3DEnabled */ +#define IFE_PSC_JABBER_FUNC_DISABLE 0x0001 /* 1=3DJabber Disab= led, 0=3DNormal Jabber Operation */ +#define IFE_PSC_FORCE_POLARITY_SHIFT 5 +#define IFE_PSC_AUTO_POLARITY_DISABLE_SHIFT 4 + +#define IFE_PMC_AUTO_MDIX 0x0080 /* 1=3Denable MDI/M= DI-X feature, default 0=3Ddisabled */ +#define IFE_PMC_FORCE_MDIX 0x0040 /* 1=3Dforce MDIX-X= , 0=3Dforce MDI */ +#define IFE_PMC_MDIX_STATUS 0x0020 /* 1=3DMDI-X, 0=3DM= DI */ +#define IFE_PMC_AUTO_MDIX_COMPLETE 0x0010 /* Resolution algor= ithm is completed */ +#define IFE_PMC_MDIX_MODE_SHIFT 6 +#define IFE_PHC_MDIX_RESET_ALL_MASK 0x0000 /* Disable auto MDI= -X */ + +#define IFE_PHC_HWI_ENABLE 0x8000 /* Enable the HWI f= eature */ +#define IFE_PHC_ABILITY_CHECK 0x4000 /* 1=3D Test Passed= , 0=3Dfailed */ +#define IFE_PHC_TEST_EXEC 0x2000 /* PHY launch test = pulses on the wire */ +#define IFE_PHC_HIGHZ 0x0200 /* 1 =3D Open Circu= it */ +#define IFE_PHC_LOWZ 0x0400 /* 1 =3D Short Circ= uit */ +#define IFE_PHC_LOW_HIGH_Z_MASK 0x0600 /* Mask for indicat= ion type of problem on the line */ +#define IFE_PHC_DISTANCE_MASK 0x01FF /* Mask for distanc= e to the cable problem, in 80cm granularity */ +#define IFE_PHC_RESET_ALL_MASK 0x0000 /* Disable HWI */ +#define IFE_PSCL_PROBE_MODE 0x0020 /* LED Probe mode *= / +#define IFE_PSCL_PROBE_LEDS_OFF 0x0006 /* Force LEDs 0 and= 2 off */ +#define IFE_PSCL_PROBE_LEDS_ON 0x0007 /* Force LEDs 0 and= 2 on */ + +#define ICH_FLASH_COMMAND_TIMEOUT 5000 /* 5000 uSecs - adj= usted */ +#define ICH_FLASH_ERASE_TIMEOUT 3000000 /* Up to 3 seconds = - worst case */ +#define ICH_FLASH_CYCLE_REPEAT_COUNT 10 /* 10 cycles */ +#define ICH_FLASH_SEG_SIZE_256 256 +#define ICH_FLASH_SEG_SIZE_4K 4096 +#define ICH_FLASH_SEG_SIZE_64K 65536 + +#define ICH_CYCLE_READ 0x0 +#define ICH_CYCLE_RESERVED 0x1 +#define ICH_CYCLE_WRITE 0x2 +#define ICH_CYCLE_ERASE 0x3 + +#define ICH_FLASH_GFPREG 0x0000 +#define ICH_FLASH_HSFSTS 0x0004 +#define ICH_FLASH_HSFCTL 0x0006 +#define ICH_FLASH_FADDR 0x0008 +#define ICH_FLASH_FDATA0 0x0010 +#define ICH_FLASH_FRACC 0x0050 +#define ICH_FLASH_FREG0 0x0054 +#define ICH_FLASH_FREG1 0x0058 +#define ICH_FLASH_FREG2 0x005C +#define ICH_FLASH_FREG3 0x0060 +#define ICH_FLASH_FPR0 0x0074 +#define ICH_FLASH_FPR1 0x0078 +#define ICH_FLASH_SSFSTS 0x0090 +#define ICH_FLASH_SSFCTL 0x0092 +#define ICH_FLASH_PREOP 0x0094 +#define ICH_FLASH_OPTYPE 0x0096 +#define ICH_FLASH_OPMENU 0x0098 + +#define ICH_FLASH_REG_MAPSIZE 0x00A0 +#define ICH_FLASH_SECTOR_SIZE 4096 +#define ICH_GFPREG_BASE_MASK 0x1FFF +#define ICH_FLASH_LINEAR_ADDR_MASK 0x00FFFFFF + +/* ICH8 GbE Flash Hardware Sequencing Flash Status Register bit breakdow= n */ +/* Offset 04h HSFSTS */ +union ich8_hws_flash_status { + struct ich8_hsfsts { +#ifdef E1000_BIG_ENDIAN + uint16_t reserved2 :6; + uint16_t fldesvalid :1; + uint16_t flockdn :1; + uint16_t flcdone :1; + uint16_t flcerr :1; + uint16_t dael :1; + uint16_t berasesz :2; + uint16_t flcinprog :1; + uint16_t reserved1 :2; +#else + uint16_t flcdone :1; /* bit 0 Flash Cycle Done */ + uint16_t flcerr :1; /* bit 1 Flash Cycle Error */ + uint16_t dael :1; /* bit 2 Direct Access error Log *= / + uint16_t berasesz :2; /* bit 4:3 Block/Sector Erase Size= */ + uint16_t flcinprog :1; /* bit 5 flash SPI cycle in Progre= ss */ + uint16_t reserved1 :2; /* bit 13:6 Reserved */ + uint16_t reserved2 :6; /* bit 13:6 Reserved */ + uint16_t fldesvalid :1; /* bit 14 Flash Descriptor Valid *= / + uint16_t flockdn :1; /* bit 15 Flash Configuration Lock= -Down */ +#endif + } hsf_status; + uint16_t regval; +}; + +/* ICH8 GbE Flash Hardware Sequencing Flash control Register bit breakdo= wn */ +/* Offset 06h FLCTL */ +union ich8_hws_flash_ctrl { + struct ich8_hsflctl { +#ifdef E1000_BIG_ENDIAN + uint16_t fldbcount :2; + uint16_t flockdn :6; + uint16_t flcgo :1; + uint16_t flcycle :2; + uint16_t reserved :5; +#else + uint16_t flcgo :1; /* 0 Flash Cycle Go */ + uint16_t flcycle :2; /* 2:1 Flash Cycle */ + uint16_t reserved :5; /* 7:3 Reserved */ + uint16_t fldbcount :2; /* 9:8 Flash Data Byte Count */ + uint16_t flockdn :6; /* 15:10 Reserved */ +#endif + } hsf_ctrl; + uint16_t regval; +}; + +/* ICH8 Flash Region Access Permissions */ +union ich8_hws_flash_regacc { + struct ich8_flracc { +#ifdef E1000_BIG_ENDIAN + uint32_t gmwag :8; + uint32_t gmrag :8; + uint32_t grwa :8; + uint32_t grra :8; +#else + uint32_t grra :8; /* 0:7 GbE region Read Access */ + uint32_t grwa :8; /* 8:15 GbE region Write Access */ + uint32_t gmrag :8; /* 23:16 GbE Master Read Access Gr= ant */ + uint32_t gmwag :8; /* 31:24 GbE Master Write Access G= rant */ +#endif + } hsf_flregacc; + uint16_t regval; +}; + +/* Miscellaneous PHY bit definitions. */ +#define PHY_PREAMBLE 0xFFFFFFFF +#define PHY_SOF 0x01 +#define PHY_OP_READ 0x02 +#define PHY_OP_WRITE 0x01 +#define PHY_TURNAROUND 0x02 +#define PHY_PREAMBLE_SIZE 32 +#define MII_CR_SPEED_1000 0x0040 +#define MII_CR_SPEED_100 0x2000 +#define MII_CR_SPEED_10 0x0000 +#define E1000_PHY_ADDRESS 0x01 +#define PHY_AUTO_NEG_TIME 45 /* 4.5 Seconds */ +#define PHY_FORCE_TIME 20 /* 2.0 Seconds */ +#define PHY_REVISION_MASK 0xFFFFFFF0 +#define DEVICE_SPEED_MASK 0x00000300 /* Device Ctrl Reg Speed Mask */ +#define REG4_SPEED_MASK 0x01E0 +#define REG9_SPEED_MASK 0x0300 +#define ADVERTISE_10_HALF 0x0001 +#define ADVERTISE_10_FULL 0x0002 +#define ADVERTISE_100_HALF 0x0004 +#define ADVERTISE_100_FULL 0x0008 +#define ADVERTISE_1000_HALF 0x0010 +#define ADVERTISE_1000_FULL 0x0020 +#define AUTONEG_ADVERTISE_SPEED_DEFAULT 0x002F /* Everything but 1000-H= alf */ +#define AUTONEG_ADVERTISE_10_100_ALL 0x000F /* All 10/100 speeds*/ +#define AUTONEG_ADVERTISE_10_ALL 0x0003 /* 10Mbps Full & Half spe= eds*/ + +#endif /* _E1000_HW_H_ */ diff --git a/qemu/hw/pci.c b/qemu/hw/pci.c index 545901c..00ddc7c 100644 --- a/qemu/hw/pci.c +++ b/qemu/hw/pci.c @@ -637,6 +637,8 @@ void pci_nic_init(PCIBus *bus, NICInfo *nd, int devfn= ) pci_i82559er_init(bus, nd, devfn); } else if (strcmp(nd->model, "rtl8139") =3D=3D 0) { pci_rtl8139_init(bus, nd, devfn); + } else if (strcmp(nd->model, "e1000") =3D=3D 0) { + pci_e1000_init(bus, nd, devfn); } else if (strcmp(nd->model, "pcnet") =3D=3D 0) { pci_pcnet_init(bus, nd, devfn); } else if (strcmp(nd->model, "virtio") =3D=3D 0) { diff --git a/qemu/hw/pci.h b/qemu/hw/pci.h index 96bb213..32d0b99 100644 --- a/qemu/hw/pci.h +++ b/qemu/hw/pci.h @@ -126,6 +126,10 @@ void pci_ne2000_init(PCIBus *bus, NICInfo *nd, int d= evfn); =20 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd, int devfn); =20 +/* e1000 */ + +void pci_e1000_init(PCIBus *bus, NICInfo *nd, int devfn); + /* pcnet.c */ void pci_pcnet_init(PCIBus *bus, NICInfo *nd, int devfn); =20 --=20 1.5.3.3 --=-5wa1yskDoUb8y2LUJkZE Content-Disposition: attachment; filename=pxe-e1000.bin Content-Type: application/octet-stream; name=pxe-e1000.bin Content-Transfer-Encoding: base64 VapA6wNI60pQHjHAjtihBAM9TOR0HaFkAKMAA6FmAKMCA7g5AKNkAIzIo2YAuEzkowQDH1i4IADL McCO2KMEA6ECA6NmAKEAA6NkAGZQagLrBGoA6wCJ5xZXUB4OLg+2BgIAweAJUGoS6CkBWIzIjtiP BsoFjwbIBR9YUGZqDGoA6WAAU4ngFlBmUFWJ5YtGEIlGAotGEolGBF1oTRBmUFAOLg+2BgIAweAJ UGoU6OQAWC6PBsoFLo8GyAVYZi7HBgADAAAAAGZoAQIAAGZoUHgBAOgQAIPEElsXidxb6DoBygIA agBQZlAPIMCoAWZYWHQrgzwkAHUQh0QkBIkEJLgAAAUAh0QkBFC4NgIAAIXAdAXoHgEAAFjpvgYA AFBVieWDfgYAdRNQi0YGiUYCZsdGBAAABQBYXesCXVgeZlBmuDYCAABmhcB0Lx4GD6APqIPsCFWJ 5Q8BRgIWDuimA+jRAAAA6HwCAABYWA8BVgJdg8QID6kPoQcfZjHAjMiO2GbB4ARmBQADAABmo4sD Zlgf6XMBUGAeBrtAAI7DJoseEwDB4waB61cRwesGJokeEwDB4waM0I7YieY2i0wYhcl4FY2HJxCO wL8AEIPBGinPjtCJ/PzzpGZgjsMOH2a5H2YAAGaJzmaJz2ZB/fNnpPxmYWZQZjHAidhmweAEZiaj AANmJscGBANwFQEAZliJ5YdeFoleFAcfYctQBrhAAI7AJqETAMHgBgWWEcHoBiajEwAHWMNg6AAA AABdge08AgAA/blJYAAAjbQN0wUAAI28DfRbAADzpPyNtfVbAACNvdAFAAC9/////+sFpAHbdQeL HoPu/BHbcvIxwEAB23UHix6D7vwR2xHAAdt1B4seg+78Edtz5jHJg+gDcg3B4AiKBkaD8P90UInF Adt1B4seg+78EdsRyQHbdQeLHoPu/BHbEcl1HUEB23UHix6D7vwR2xHJAdt1B4seg+78Edtz5kFB gf0A8///g9EBVo00L/OkXul0////YcOQkJCQAAAAAAAAAADrAusPUJxVieWMyIdGBodGBF2dnFAP qA+gBh4WDujeAYPsDFVQi0QkKA0AAAYAiUQkEOgAAAAAXYHtPwAAAIuFiwAAAC0AAAAABdwEAACJ RCQIjYVnAAAAiUQkDFhdw+h6AAAAHx8fBw+hD6mDxAJVieVm90YGAAAEAF11Ap3LncoEAAAAAABT VldV6AAAAABdge2YAAAAi527AQAAgeujAgAAj4O3AgAAj4OzAgAAj4OvAgAAj4OrAgAAj4OjAgAA iaOnAgAAi6WzAQAA/7W3AQAA6AYAAACDxATp2QBVU1DoAAAAAF2B7e4AAACNhZsBAACJhZ0BAAAP t0QkEMHgBClEJAyJw8HrBGaJXCQOicPB6wRmU42djgEAACnDZlNoCAAAAI2dhAEAACnDU2aJhaUB AADB6BCIhacBAACIpaoBAAAPt0QkHsHgBGaJha0BAACJw8HrEIidrwEAAIi9sgEAAA8BlZsBAABm uxAAjtMpxI7bjsOO447ryw8gw4Dj/g8iw8tmwegEjtBmWGZbZl3LFwAAAAAAAAD//wAAAJsAAP// AAAAkwAAAAAAAAAAAAAAAAAAMAHoQgDoAAAAAF2B7ckBAACLvbsCAACLjb8CAACJ5vzzpIulpwIA AP+1owIAAIudqwIAAIu1rwIAAIu9swIAAIuttwIAAMP6agBmVWZTZlCJ5WYx2w5bjttmweMEZg+3 Rg5mAdhmiUYMZondZjHb6AAAW2aNh1IAZgHoZomHVABmjYc+AGYB6GaJh2oAZjHAFlhmweAEZg+3 7GYBxWYPAZdSAA8gwAwBDyLAZv+vagBmuBAAjtCJ7I7YjsCO4I7oWFtdwxcAAAAAAAAA//8AAACf zwD//wAAAJPPAG8CAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAb0CAAAA AACQkJCQvKEAAH/7//9YX4PHBl5YW1mO1on8g/gAdQNRU8sHAnUCzRnN3bft/xj7WPnNFZz6+5CQ A7QRFoPgAwgBf7ncLpxYBzHAMORYtA5muwG//f+3AADNEPqDxAZmWxYHiedmuCDoEWa6UEFNdf/t 91NmuRQdFWYJUJz5Mckx0lhVUvfd7r9oUM0SWweaAHwoWA4uXY2eCQAkffv/bctVJy7/Hi0AnHIc ieWBfgJLD4SUAPffftMIAcMAgH4DiAf+AJ1dXcoCAADt///2ZgHBAtpmKcN3A2Yx24X/dBJmOcJ2 KxNubu+2wwfLE4nZ6x4dynLSZvdt537fKDnaduMHAconFYnQHf/u2+7Bw1ahUr6QZi6LHANUBOim /4PGCIfs7e2B/qqj62Za2V7DAABmPXvZ/n/hD4Vz/2Ymg30EAAlpUGZRDd3WfXeLBQNNCFcx/0Vf C4kPid+/3S5mWevpRRMMAJGH2ugGBenCt8LuNv9XMVC/RKdmweEQPOv+trlZ6m9JwekQictZEwoD f9u+beiOXREKKlhFX8NT6Mj/3IWG/1vp+v4tAWZoAQbremgAB28vvNwFUHjoKwCMCMucn1Z1Ew3f vvCduE5WUDZAAAfVHj4A+DWdF77Jbg8uOsZCBFDRZoy7vf3/yIdEJASHBCScg+wIDwEHZg+oAqBm W267/UI/FmYOYI0dOIkDDAe3ffvvRFDoNV2B7RIFBomtuKIFixa3X/hdqbsAdCGNtXCuAI29cBIF OfTxjd3/cgQ5/HYNiea5SDIpz2vzpOjdbW772zSLLTYpLCRLDEQ+ILt/254RD7cKJARcJCZQjYWF X1D6b9u/bY1Ue47TAezLWGGSqQKhZgeF5v7bZh/kDJ2LZCTUnPeVJoGx/+0buZ3LncoHVVZXi3wk ECs9l9zdr7VsCaeuaGgOVei1e7FutxkfW2AOo2IEiXfftv2+viO5synxoi5zFSDq+//du/2BCAC4 EByO2I7AjtCO4I7oX15dwzWbz+9uIOWJNSQFPSgdLFij3wt3vzALJTQFWbts5wADHV9Th7tn3Wgo Q1Hk6KwLiaUMJ9Pmut+lAC+lcClhz+RmdPeabm/8vI6nIGAG7SEaY2+3QjQBti0HF//Qi32LniMj I4uLixWL/4V3R6EcBP/ii0zWixQkiRGJWQTGjxv/iWEIiWkMiXFbeRRqAMPrb9svuB1ACIsKi1oI YgdqDIvSP/36chCLehQSBbjdiQwkw5yYbLGFs7kBTwzJiRjQknDJsbgwGp54D+P9HFhdnS4iNQcr 4YBceHtQfDgAiYV9Q3Kk4fpqlWgHKTT3c2NPKXFTUFOnnF/qXmoYJYlDAgMKGBCIQwTGwpdvAgyI YwcPW1jDOZC9bHpr3SQnKB8EIrr1FWoC3+7HdrIkUAYuUIHq7hNSaAXoX/o2wrEHY/YYGAF1BATr Aw+239a2tsQQHA9TRmo18LtvsHfHcASm87j5SgEtV/XGs99QaAXobUOAO/kNxgPht729qgWgpBCw ABjIbDjwi/8uNNdYElpDVHUCA5hnZMBH+fklBjK2bfbASiwmCm+xv/YzJgXo/gYm+gaD8AM5bIEB lQEvEphNnpEKCs4mCMMeRhmIGB8uFfj+Cm8/FQXomwbRPHBsemhMVwcgTDTHIuPf33DQfjAx9utN uEEvUmoejT/s195uDgZSLVFzBehaQA3/wHYggTcEI3Uwg8MUYwLb/rsvJo1T7HAMUWoUUFLo8nMn Rih79wt8EDn+fT32dKuDfGR1pOsCYcdaBXeJ8EAx64IYZn+7C3R/Fhe7Tl6B63tqCo2/rXVN41e/ dM4jaBPo4bZ/P4QFzwwBdCI0DgCIUWwKHsEc5icjvRAg6y1L9ws4/JaF0nUXZnoKD75N7V98BsHg BgcW6wsOCuThuUfSAdCokGxQw37tDZP4BehhW3C8YwtsVbgM6BeK7bpvF8HE/wBmo4D5JigKo4T/ Nr/fCVNTaiBojBKS/oj5vhCFwHXvtQfvc8cFDOIJIADb24JsCZBjBUiZCmPd992jlAeZiRWY+R+c BQEpoLCDdSMQCaQzoYQxDJtsbKgqrFSwNLrB9yDiMe2he4kB6eD3sBB7rr1VoMz+hYwK7P7vi5WI g/oAd0g9//J3QTzEi2wb8inGHpSN2ov9v4w503IGOcZ2AonGxzYjCZHvEsPDjim1LRnC28jYi41Y nftRYoH5EPaXHNsJB1qxmNKJzonfAy5/3fY5E72D/xoEWzsrFjnBscfG/ncSKcgZ2ol+iVDrIIl0 gz3ssYmrx4WU74WYCf9wRwN374PFFBo5Bg+CE+DV4MCVU+NdR7Y4fdpDDf66E8Usi+ALjbdxPYAC a3r4wecKbbT+38eBPyFGUkV1FANHBGqwwMYbmLgXTwSs3arrxiTj3/j3icGhPIXJdD1edDmNBAEl /wja//a7jZQCBsHqQMGJyOsSx4AA/HRwhe72SEOQBApKTW7/t+H+kuTpe4/+BTCJx8HvCuhqseEp cxCUOcd2H+sbvu3NbcX4h4XQweJcyo/P/9HC7Y6J15DitQyDPbCkiW+4d/Z1KaGsB2R0ICsFIW53 HxwVvJFJXehG/QTHBWp4Z/Affgw4ghBwT/huKRToJiKyJukbKvdu9+7hCOihliLoUAiJw+gCGLGl gX2J2FpZW3TmPVUbayjYdQpe+qF3GjWk3V2H8RIsaF6YEMttBbHfG3vr/gOeoy5wqvx476PN3sO4 /Lrk0cOGErE2B+WkFaJubmh2LCUp2CHpMYHhtbntH2s5ynUnUKg1HB3a2YbQu4Id//AMCQRhDD4F 7FhbBwRznuRsNlxWyDaNsbVGj/0WgeZcxnImMg1the1vSXceifMp02hTimO5m/21MNsnJikdBFta FsrYY15juFwcpFzTDx4TdIIiUN2TJ44LGbZTZvrrzG4AYQ+z3R2oILgBPVtTM8btO8ZMabtUXsM6 UwIAwf5G2wQGC98pwjsVqKRVx268jSsELU4ykJMGgJWC8JE4SBPHBaTxpVkExmFbdF72JEq9h4NS PUhcI0Wo8H56ifmB6UsRN2fdto151lEeAkZNgViZX3s/fmaNmc6NgloYC7huw9hDYC0PQ1gg/Aij VnDxSwihbKlVEl2vral0FBcdUVZJxy6dgSRjmQF/4wXMm6OBwxgDcgoNvwE7+FsU+1JMAQOD4fxc BFUztvhCMinMVFGBFsMYuLvh6D/35dDoZwaJ7F2goaNhCJ17JNkoHC+NdUZrPXMRrhqJwoexa6Qr Foka6ye8BSK80xaM/YMNdsdayZnGe8o+LMUpQo5LuN1OMEIM0Wy4gOPS7pZSUJjvcQi8qTm2+wTX EikwA3AMu4V3MMXnveePW1bod4nfx+Rs0B0SjRxXe/S6buNSO00k/0H/MgbFHgXB3dyJ3k0+cQQa BolY5Lk9wQGmEpKCq1l3BuBmGNM9TrCF2d9HAwaJ6BJn9PGOwZ/aFTkwi0EQeHQGui3NwRZCGCAU CRwDAgJjNzEDLRXoH6brch0+FN4Pd8WkCB9LDnMfMBlToAV7daOLXB6pvdgX+F7/Qhzo+WusFX0z wsl21I8wQIu8JIRBE64eXk83KOJ/4teVLEr3xw50Qo1zGIngTsQu3HAYU96zaz67Xzj9Deh1ZItL GLpejYnWmfe70ECB/oIWCQeTHEbdWlx6lBhC+HzzKgzrPLVMW7dpV1w0P+STr43Ej35qRroOUVHR EOF3NtQdLBHQAgXoifXYbemFMNVkGlJWP2s9GzKkgXS69Qy0a+tjMKO7AQA7i3T7Rt9mr4gxyesH WgQyAcGI3sZoe9p19QrBDRhu6HdvG34dJPR0H5gsEiM1bOD3Xrv1dYH6mwoA6w2F1/d5IXmpaDIc 96Jwuw3rFWz185YaYPbB6Z3aaMHsvBocDwRbjCUa2RfQBAseDosX3IPiE7UculfBCOidW6Qc7VAD BT3cHVj//Mfv6JxHp9sLhkH61xhbNBz1qB0dGLZ+dYXbHqIfrhsf6z5znLzo5/k+wtIPhIMCv1Qo SCmtrYPn8CnHOWim34k9OrmA3Vedc8RemErWYI2TE1ONTe4jdpUECeTXCusUdnfBeMozgRiNbE/l 8Pi2HdgRPStdPb1qBGiTbWu7ZB4qmmkFxl5YAxm2SrkGB1dKQ5AMNjLSBQgODJgDb9MRImEgQxI2 HAV8G+u62GYrFhMQKxYxFAVtpXMQrwUYWRzVXq7bXR0HDR5LE/aDbeuOvFMoAyA6KgIi5CxgXRdG LgMmcCrqLns7MBYyifhuNk5AjXUn6PhDmAxGBUjyjQ3yEkpOBVASUsJNvQ1WBYpDBdojalgA+oVb x4GvKAsriigriFMFx7cMNxTKWQBomB0pfGiME/h/MUYGAQLGRggsxANFhp+YQHnvLAWdBN0KxFro lJgVRgojBHu2MQ5rRhLtM0Z13cG6IAMU5UYiAxYiGPuNjI0oGgUcHh9WJEwVIsFtzwZ+JhL/2/Ed n0Iqg+OWXiiKXgl1aiyjQm+7Y8CCKMOID6GBJmsYh8SMluwSTX+fPnKVBDDoq2cOGGoNJOhkY8a3 jvt+LAeg+P//W4pBINaHwRy5+RX7PmJXoIFVuF8xdhQodR+7iy2QD9lBjL2N6pUEu2ifaBs80+cz AjiB0T3hxx8pibHPgUQVEIHV7TDY/RTHgdMGYADPUy7B3wj3Kfm4sBOviQvHhYwAXgyBgNdWD3C7 kAv6S0z2iMHjSJg6bEIdaKMFmsBbIvhbJJxugF9tuIE4I3YkhYPABE5cgK1OClabZuD06j7YRSI9 ZiYm49vbti0dEQtaBUGNi0AGAxJitQNa7kfgBNy61cCET6rD1612wkt4sMUoW8MqdE0mER42CtK6 BysSF4fNxS0V3EyIAlSxkeEEEEIbrlpiIaEzbjYWwvAHQl0B4l8MA4tCl+i6AywPb1OqxwODpVgs DlhajB+J7ne/FZ12B74SmT8HizSFgJcjaM+0xXsUlRSPVVNBc7mXNSS5JAlXGbsP7i7TG1c96Dlg 8xRPQHUKpfu6CSsCgQYgAgVuz4XsIDBfAAlxGEjtUVPZcgH6/+QG4AOPAQAYaJ+GImNvyd25Qjro xF7hZNQVN7LZmQwLCgBPQPwX7Q1M4PRitBp4CAN0VMStjtFATK1CQFgoEO32/q14BXsQdQjHQhCd ZHoI68ILS7QjHOnAHQCoIBnc2AO4GaVCNsMOFgqcwwcB99UEoft/rD2LEIHi/w/A/4HKAA6JONs1 ZlsRQUY6JVgIKFbtb50TUe76AXQdchEG1mu7t40h+pIxuP3l60ShQNA32JsA5+soCe9KANuIDLYH GA/3UggP8NzsnwkYS3UGKGlwAW+BoYi2bqHs57puA81zE7uh5AsBCLlmaFvwuFMYJaYiEi+aIv25 HbeseL37+WnSMAmBwmCmllrrIgvbeRAvBCpAL6aF3q4IKokVPJzIHbbY3QstEKHEBwUYKE+dDlh4 I88PKAEUl38k0BscUb/t1nQbcgcPD2d37lnrLSjYXQDo6zPB2GBK0BGIPA85O2zCQ24RI8ixUnYY gIIQauF/TbgQ6qXw5tbB5gQDNQiLkWrwgH5/TVs7uIDphrF0T3qNULsDYStxBK7b+wZQOy30Uv93 YP9ilSPTse67sWShTEAkiVbokYNkdRhsg8S0wCQqdrf4jLAMUVJyUBkEQBoRqxmX3x93idw4tuYo 6A7ZpTDu/9ovNRZ1Zc4Cg+b+DRWJMOtOCLbFDyRbifI6+RPYw7ZmSMklASKLAAncGkzgCIue82K7 eWcgc81EgCSWWLZ9Q/57CAR2DS2/KsHeDKYrPJuNeBiewrZ3bD4XqHVticYp/FQNsLMcRwpBmyFj t+Ae0+ggIALs3xle/3iC7v7rLEp1SonGLDDYZAlv0S39kvDIlhxQrniKRguZGnEUg5vjn7At6dka 2YkYoDFBIS871hd+LxhbLcsBEISGXFCe00ZDuDSJ1TMC83qSg5fiMf+yMdHmJUjfNYv12OilyyGN 4vuoCHTN2aGGAzOJViJUR5DYgG9fxTnHdevGPCT80bZixkQKjWicBbaHv2WLVQChBXT3XHpClwo5 XMgIs8lJ8dyhv9MA0+e3bmf4vdtPWYXHdCXKBA8ai0ZoBoRJQUZlRWs3ajXoso0EkMvw6H7GZ4Ll Twiu99HvdaVIYlnAWkbzwOOpQxkZBlVMuLcqEa8Ph8mZAFcHmwHmBtH1Kx3RFjc7GI+wZoXJIKfG RhB2q0sIMK35rA0uCdtHtEDuAV0W35Lxd19qBejDdgAA9BhGhNJ4y9h28BqB/ujOdd6evyOyLZze 6VBWcTEfGfpqBmxbWwImLkhdwHaXZScBV+L8JW4BW3PPCqZu6QgehL1LbWgwwB66d8BSGroIO9ta ngvj/ajvGaIgM/3NVeHGpbaZiBN0DevHC5Zn3wiHEw+Gzi7l++nVcYm/ldb9f3YEsAussAPOdVsb 3gY90B74TQ3ZDhsKEDLR4jsT5Hd3doMEGboQQnEPZsHAI8IHuqMeBHJGVznGBJ39uu/rUPFLLD5S ugYwo3NnN4JUfjUAUpERTi6YCQ4idEoOwHSTueKgUbkQM5Yo0GhKKHG6MwfNbI+/xZnp7CUbtchJ sePCfwjehTbU6SflLrEVaV//SA4CJRrSVtsV3y42AbydDaQXSej2dIcnDdKQIbsSIAAnzh4LGEdK gYsA+je/wKmBzQ5Phe90CoG0ly4ahWQQCIFkCcaj0Uw437XD/U6G6UJdcPpy/wZouEFBCPdkHxjG Fv6u5zLHiX1wi6XThR+zuPzIdls0usH5u/F2Q0wWy/zaHHe8BAne+18gzTHb2GZjZxMMwRAYFqm/ d/Gf3XU4Q4H7gIx127j+Syq5bO6ta/kmyoD46BIQURJdgVj5glAZBRj53DCJdioxwLgI04nPEpcK W+4Mjx/6DzKT4qG3icq6HxhS9N1boBWlCh/RMumiLeG5PBU6Rz5M8owVXkAaFRHtdlqI0xcYQYP7 8sNu35EK6QURfvV2U/L5IVuECFDwGDLoG3OF2gM5RgtDRv86sX3u3um+DRFAXrNMEFz1LiSJAumj HwJt2NzCgQ/pXiDGuQ4hw+Ph/ZX7qMiBDSHhwtP+idDGGHYahGMnq/3GejgB8IJN9u3R5xuPQ4LB lgVaVJjPRBthY9ubS0WJ6Dyrzg9jR4SmbtIyIac6CAWw6GAcRhVWvkAQNm1L/M13FW84Vg8a7vXc uocTQwoxe2sHO+n97El/Q3t0JBKJ8boBfW7+JjfIZO/jDhVYzQ5Ab4Fb9p8SICnCOs4GObuGugQi NaoXDhMa7LCbHReSzqrQuvYQ9sQEj0MPBusBbG1Uz4hcHCWeNlrVFD0OfhrqDlKmmsEQDCqPwvcl bDY0DyAxCSCrK1NPAROyVQxzmnrqtg+VcbbA5HtZEye4wJC+F3UH2TSLh2OZ3PQ2FH0v/NQwuoHH GIDPft+B596/hdx//B23Act1R7oRM3jCZxZ6T82HCA8C4iVMXEaJ+7EDgeN+ZzC3GUkiYFajwDms 23YEdEMGgKFGRggkV/IddURCIB22txIuO2mXAusKC0A0hmNpAwE148AN4YAk9yevIEcCNsfB4pIm H10JwrH/MRZCNJtqAugOcAA0qZD9EVAUi1wy4tiHzeIg1DHcbwAQ+h6AMotsEEAYkqnDJDA2YoI1 Vo7HLci6JYChDemV25M1hrjN9tLDWBsYbgHS74kYLUhLp0dlNWZ9ELn79UhgLWiWGj9vVHaXjMPE +YwKdBMEFpa3recOBAt0CQ2wdcSu1T32WBT+WLlAAjj44EN5QzG0+W7vj6zo8jToPsQQQQmMP16b N5QHXrqVHzWek+5uEjC5Ib0QcQEYpNk8+yF5EPD6ABYwnrMf5991ujEQzhyz7zn7ITIQvQMhlBDn OXmerD+WmwjOvhuuEJUIuZkLcxx+c7jBxnEz0nAN97xwYy+pgN7RICmPG+akW+p0EwhnFNB6i61v jmY8J8hmJYAsynxcFl5icEX6QHYK6sCAi1a3apm8Zi1sOXBo83vhAPAhCcEJ0V4+uWc31Mm63Ef3 +Yarut4umGDOEOacxmtauBVleAiPPVEWqNi+JnfoBHUDQnkWWsljx8zXMk8Wxar5HiODGXUW+1gm vYOug3eI/d0jByQIgKsxihGLPcn6aLfJCdpqF0g+uu/Gy5V1mKw969ISqy7aYQzF9oXvg3jxEj+J zot7fdGJ+uhsahsbV41XrfELYevYFR4jGaljC3cH4O9nuX13EQsOdSYFuh5UDhk2GqVQEAK7CFx6 DZ2r1Hb/6n1jy4B5JgENAMeYfIc0BA0I6MdG8TZNilAKE1EyGLz5WPqgi1ZqGqUFdR6J2YPNYDI/ dDloNA62k47E6SEycU4y+R74D9iuPCbT4KlwDTaprZ14JO4V6yU2eEKwsQ1jPPdR6x99BBhbDXtT musNi1YOmwKXajd4g1xyQAQeCoNnLS616AL9dzMypK0D6Vuwa703EIDOILUQaQRMaMoMicsY8Kws pXsxGX4Rzu6CDwUgWNeA5t87CJ2SD8nnRhX8VggHsZHgEApKJHQQRhiLFg5VWGObbbHdGmruP484 EvU2iMVYIgZHKwyOiFAApXE0hE8PZyFCCvpLddzNCAfCbipGqP2/AbHdiDwL1KYwiE5FC9xKvwNG RsHgCDQIVkhoGFcqsHQPRxCXQRFshHhdSQ5KHl2Ahb1jb2wKWlSDVkCJWNnDJZMZBEQjun8RQR42 TMS8U5CSl716/AAA3cBTyphdqGBtdcbak4xwKVnThNIvQcAgg/AAmhA4Ak2gERbGCYF74w0oLwr4 B3UzdbvIZqUX2A3Hweh04AGE9QuN8IxeSmEvREumudvbylTU+Qw8az++RIthl0w9MulkCy5Au71t OQzBG+dzIB3q9w1Q840MlYIJ2R1Qkf59pOZoBujU+x32jBO4CCJQ2A8YxPHWKbZtK3N5qclr5tNK PPF9gX4U/70mSBaMxLFdGNNuRhTkET2h3WbRKABpjAKJFkE7+/EWmGYU/Xt1FzXwLAtsKoUVQIPC AwJYwOROPWSTn9+7257kdcn5Dg2kKFdo/3GehHq3aIQYVugp+FuFmgltS0GjswUWIomBzIGMHT18 /L1AQ70Sg8g/+xICt8BQlhmQgynh91LIdmCXgiHo/BY7QJDvjFwQVyaj3AqTORRvQHYPwsHiW7NA gOfnh+sVgXANL/YNQBjP5FDeOHBaMGAIGzIM907oCTf4EroCbQb0SBZYMD0YZicSEUIsePLYk6Jq ZywgugPZ829NbkGaL+YJLuDwC35hg2svMkmNUXH6Cw+H3he+Qe8c/ySVjCo9UAxBjDXr/b9b7l49 MAhqPSAPHutOPYADqALsewxq9phQPaAWBw0dO3bsUjR0JwZ3EDJ0GfXZsY9AdT/rECt0JkAv6xIx 2oEie6XeESvD07UnEQoBHNFiNt2sWA/xCP/pCly57ueix/MIDP0ECtwJz9742bpV6e/yFv8Z87Hh AuSJF8AQnRlksCKR3DgQe9ggZxW2xjjhnTuDDJZkYCVVoAdzcns7Dmb4kamj20VsCdG1aAgPajjd 74CwqPX6GQdvsho3SU8m+3NGZIDl32Ea8/EDLINnUj4IBR859rBbP0gQi+w0GCsC8mDJJjsS7AFO IqxE7OSk8e98bxXZmRnkydmH9zh1BhksImu2Pvpg43uwHUcYFxPf7pB5DuT1zgIkDPZswwAxRL3I SvdAgJ9EYxx9D+jTKi6h+zOBfjwgdXbKFH43wvOzwW5HkRSA4X8Ue7OzswPZ8CIkygkVkjxskP4O OOXvjXSQwSKg6wYVFE7EIIcXw9P0g13YwxjrcZmdJa3sQkOzBmBpYA7h/Z7Z2MGOOieFBp4UFe0O O8hfbwae8EBwAS/YwZI9J/zv/z0t/U5uDg32ODZGPKsvrWroUvg8Zs8GHVaCZcA8LzlHO2CHnA0L 3xLjF3+3zdTznHRkMB/+BhL//NsasUQZPONLg0YaPFipII0JQKgEVw2C/dEiEACoCArMLmrg2agg ChIAehQMzdZ11CxyXXQLA16p6/gd8LEaYP/z6xijgMwIgOT77MEaHQZxRQwPt7JswsEGDZpYBXqz INycnfTuGD/pJQU02AgN4c0SL2PPJLBwYDcaH78tGLESsg921nMBQ+se+wQAABU4gRnk1eWC9DP+ CYVqZOg8KJZPdbi4grHbwM+5wyEx/wUmbJDBPZenU4GhhbPBFZFTFD4yNdF1tBsJG5nlCA8I3/ds e4MCbDoOm/qEaw6k7WF06VgEmrdhCUcd4gx+f/8KdYO5+YijA946U7GBmqMMS2a79BvaumLrYRZa EAfW+Qlng5zEdVCPHgacNAsGJ4Hq9PEDnF2yutVb4XQhiX7hD3ztzg5WeHrtpsUrMdvkeRDeENjk ///vGXIeC1btJmhHQwe5IGvYXzTE9wy5oAYF6YDOeNCgXbgBTFiJ+NihD4tgymyJTjQH3zYYPcom sBBTEuACT4htvyXWOdhcVX0SoyatC5IRdnwCHrT0RpgvdzJ13QU4cUZvI7ReRvsBdfwKpKIhQpQg CIHcbSE3XfJqPpKALnbKaAiC5C+77PkZ7EB4ywLbpRW1IMXChy8EskMsgzHIh9+54/8EjOM7CLMC TUd9AixM3uTshHiEegLpBVlLhDtIHFsCiqng1gpWm602LVBMAsonq28O8tfi+4kQxekv2M7tYlQm hSUJFQEALV6hV03KUOcmNoywGRaeyFk7DXVV20aNri/7NlTlBD3CEJbc98I4AjWzJ4dYfdU0k38y kmCDxRbHQYfprxuB3d2rJ+mtAcxD/+mhC9vebrv2wUCzmAiB4lELjE1uzJIxDE9wv4m7MboXhwLp bhK43F0Juv0dRt89ujiF0g+IsskoX+yzXRCAwgssxwDbCzAmdbYA2ojvcGIvqa3xgKLPPttgISxJ fR2eCAlohh3ZSSa5aGDrPD10A8kDQACAgODRAzgIf3sPhqyJKDhU8ANoMa5UAQGH1AmNko2/GkaV YE7uHD4PGLrqhS5xCheGnmTgYEwt6AjyBUVxTnGhKRGyO1n0USATu5oGa6fpA2A6Ag/GaxXVGfDp TO4Xz1zG+njpph4ojtAdAabpoA25cUr/RxGs6B7I8ngRgBGApgwVloRnuxAy6woLMARFJBEyIBcY OGyEveQQKCABSSTwJgEGKDsNJAlOIE14NB25TwCHu5vYuMAn6H7vCY3FGmd6BOsJSQSQwZKcWQAP BH6MYNcsEApY6S4iAAD6l0Egumx0JDSF9nUaFrqLBev4YVdXU9UJ2wjxrbgAo+ikUH4Zv39HCH5/ uVRIiTUNxwXUBNlmFCMJ+CbitkQwEDzMPAaNFDTfWFoLXSvbHbF7BvCSu4ZQUGVAPMeODQbpFXWq OA/2xBswbEBcdb8GBnUUwG2G1bsa8SoUeMT/bzT8iUVoikYYiEVsuQKlzVg5R9wSLOHbDTmCAmZ3 GxBoBBVBF8JdOhlQBOv7V7KbEH8Muf6k5Snx4PG90d+hOmY9FxuHlgAJFd327wZJVwEJDRB3QgUM DzizbW4jBAmEH3cZCwC/r9tY4i8BCYWfOQQkLQjGvi8H4TuMEgA3EBnrBusrKTcOC/k3D/25sa9n JPYOEhhBD4Lm3djTjQ8THkgHQ3UeId3ZrntDkR0L2QBPGAvlN/Y0YzAZF+4OHhgeWL5fkAktJpEC +mCVvm7bxhx72Q8FedmdFLCvG+tGfDGmCZZKzBjTDR66uwSgSjzICjypWcHCV7ZOD/PIgeSLEePp sgLtDqPkmeSZA5QEhZPn7JsFR3kLBm05eU6eB2EIVQmek+fkSQo9CzHkOXlODCUNGdo9hOIOLiOZ hNYCmyJIQ3pLg/kNf6QXCx+3W4ji9sIedRK/wYMGQrZKgOY8dVnNNtjY6Zm72OhmCtxAXayLfQje 7QjgzAjiyUa2NTJpmzIp3YI3ZiDqAuskoXVABFtokSV1C2/s2cAuc+tAenHrNT+wrvveuy0UGeQP ICI2ZLDlEBITCAhgE2KtpDTUdxNadsgIAeJ8WAZikCYStJDq0EHotOB/dXh71U4tUSGKHBIIwm3u C4h0RXcOB4xTBemnm1ubVrcHFHQ5GHQIP9YOu8So6xbWIMIKkA/bGnEqCgjrH2Fh2NbvFAozCQ1s Kp4liLjaGQylZyfsJwEx9jHbsonaJgRU7cJhr3gMA3SmjPEG8N/V7bq6dB48QLfY4wVANtH6Dnm2 rPZHRb7fRpvtr8f1iIMFQMHoCAkGg8Om+uOvAri+ixVijUL4ZRFbsoIbMSgCLvDe6sJygDUKsjUG aHYF2v9C/3Vc6O8+BzoJaF6Ih23liwc8daLpX2eKwXspjlIKsXHKfN+Jma8JkS+fe7CIH+/pLAKl jYIgXPGFcLyoD3QG6RMp0KPgHAZPAiaNFBCkADCDDhjuIASbEgN2YccEIiQRjAzYEQgkKICKJAJI NoA7ZfDC6ejnAOYKAQZhHwdhiyz/2A/sJTIIS2J2FsCQWCBH5LsBWyAcEAEWIhmwEcIUARYkGFgi sBiATebDcMMdElrD6IgH5H/v/pJ99cdFAKw3GUVIMxoGTNdAgmEUP1DJGXIuGhqQGyCnPBmmbaOL QCFEnv8JPAYSS5iIGjdIS7db9442DBb9OP9wXBkgFTWPt0I0huw4Kos9YDeKFoehpQi1jRwGKEjE H0DOz2wbbEB/4OnHBkA4QO9EtCcJVCyBiw0NGL2xR7gPQwTpQwgOBgwNu2OfBXQvx0ccgc4EE4kM A8TadwgPHm8+AAUOi7kHbRY7jnopUydEGHFAf9QO4QF06AGQADDopx9QsqIfahjo+7mm6oA1oUqk RKvgI1O3DBQl/L5y6v4//Y3JAUaJ04oC4I1SATw6dfC/vJdh8YbviBdQVv83SSDoLTv4fuLut7HH CIH/xB5y4emsUGoDD+uAtguctAgkdXvfcMMWqAN4jVgDXBSAeAMv4xah0HRAanUm2xbKD7ddtwQD iiQtgDhuG0CmUmEJKlQQ2FKYB7ytaGCoo6Bp0Ou+ORkjL3Uoi7qjw/Fm2L2JVWgJcOhkLP9o4k/3 C3xCU1D/V3MfUVX/NSYVa5nvaBUjQJ0jHlLfUrsqUixgoRC5DdEZKdL8HqMUDKvdXbFaaNBoZPk6 pMMN/8JvFePk8P9x/EdRixmLUQS42+3ghpCb6wTGZT1wZnL1NBUwwW1S1BZUzT96g4oRD/50HmjW BDCL5+ZQB7rHftvCWySRrjci6EVRDP12N6gbC+ht1JSOxgQ3/jTM2YnHfwaMB4zFK6mlt9rqB0w4 Qj3edWXnanQD/u81BMf2dFGF235NTn9IbkeRSs4hiKEAHK9QmOj/UATKYCo/BjT0g3gU/90Djxtq AWjUQOxuHWpq9iz9doYpCdoHjJHcrwIobIz9FrV/GaZ0NA+PxhX9EsR2S4DqCOnRDYW2t/vRRwWM FQ6B+5Qfypc49Hn1PdRhRuiUiu3ofuxU/eeGxccFF9+G26wHGMIX9PznGPRswfiM55vHBQTLCQju w8Nk1RAhTEpjNgSI8NSHE6ZYNvcNMz3C7i2yh6QCGVET3urpfpjqBv+G41+NQ+CFXneoYE3DLrB2 E0taaQx4E7D9+0Z0VH8f+2r7RHWW4b+9leIGTnQfBFF1iusHuzAz+iwIvaxCi7sDyhCMBuSZMCAx fB5WTRYQMvj0EoZnu69jDBi7BNjpxzrwoRHj6DL8BMUM6C/BGDHBFrU2oIyKfYgOIUKJBhRSG8Dv oUjT6I/jIbH3P/jgB6P4GfoCfgzHBQqphG81oiHmTPgDdQ1ysUYx6vj0WSzgA/+W+REXAuhIFIvp atEMdz2R+I2QxKpuH9Dv+0qLgAujkcdAVImQarv0SBDB685YHA8gnTkJJ2EUHunz4eAVOxl/B4sd PokcJJxDFNNhCTpY5IN6Dw/6THB4L+mi3T9EXcdzGPZR92OPBTvdj2fbQiAVhmNobBVNNDSpQLAX hP5ERmYEhQYcY937z/CFkW2YXx32y//pd5YQhE2cBfQwOkHg94q4XPAztsI2W3oZaReLCA7DhYda KOa7GQI94A1jSwf/o0tj6yLo2Zu+8CY5w41An34ZD4ZvBOltv4L9dgS7CuF3/ayD6MH0rRO6T5MU DFmrjWH8wx8YGBZhDG6K671AwxXAhIgtB8YFCWbV3Jq+0IH6SGlmDgdQeB/Ovi3VggmquBRIb+s4 JgGOdTe2qlH5KPuRIwpzzp7v/24YUyWqUMHqCFJoguQLyEMV6z4aimKIbLEiWIADZy7RF0w0vBe4 zjnKdiIxAY6In5z3FwL+wwfPjZi+Odl2HY2IwfbYnkhMM3NheFaGqrH7VGivMutBDEKzpajEOd4C rAImox0A2nIcC8ELv0GzwECcEOg3YGPVakLhrlwy4BGIz0Ig6ZGPGIO4wFbxAfF1NnuAnc/vA5aR kAW5lKmY3/4BwGbgEjnBcg4JAfgR6qkuAHQNGZIV/4qw2xacRmtEfzkMdaq1k+q2STtvBHdULG5g d7sEEwQrAxQrFonxm383tmSwUxVQlRBoDp3GMb2wCEbYpyyDd0/cuDREMwLJBDo0L0hogBbfM5ro p1mBPQ1/7pu63cZGO6UjoYQOJWYAPerxdbQBAFCQFJAe4OlIUJW2fgQTlJLb3PYOHnEMQ6gMBgh2 RN0gLmHPoZLo6DY50Pl0CgUGlQRbgPnO00SpHMVJA3fDfAsQTBWsL7ol3MKvqgav0IycCLPd91a4 EZ+2RHYKO08v6/i+H22v+sx2GhFvQc5D96wbA7j5UNBjBeVSRoz6bXBIAcj/wOe/MnE/tATvPcSf wP8FxOzxKgwC6URPVfGNgWuVkt49jOsvAe9vIsrB4gWDukPSjZqMDNGGX4xDQJ4Edp4AFtwtUYLU Er9zW2u7la4YUDs+dpUEjQvba+9BAaNcxAXUx+98NwK027OLF0iFA0OHthi3CG7pRHPLAxihey8i UYb79+U8tjBRy4ItqsejqWammgXW6mJ1waDZBySzMy5VMYiag7uIjIzxQhDfi4uIm7cSheqMv+zY gdYF8PAR+oxUDM73hkJ7MTtMamJoKHMEiwv7nRlsO0QPFAU56XYGOejmBXbdrekFdggXEAvoi07/ W8VCPhgw99ghwjnRcggpdC+Au9FIGHMZJZgUoxHQcLLNoBQUWHCFoUz6aPNhpEbXSLcDQP6/wRJK VI26weEFAZGHA+GBzCEFRQWUIfzgDUngARWYCgXcv5p6dbI76QZ6OAUtFngUQdPYQCmj0OHDhesZ iMS86VIb2I2HT8LVAEOoQ0ODukABz3h0IFN+OEJAHNTph4f+jU+WKsW3KReNQgNapgHdPnYq8Qs8 Azt8Lndv717aqtY9YFoIaOTTUehyMPAAHEaVSzMCG/QlAy4IIUh1OxqAye7o0nwDWXUxphzrKw9f 6DH7IYnd6x2PgtgDZqPgzy3RdgwrXJiy5Alqxbuu4A+Cb5V8n3QXhe1pE9WoM5i/aOwGQAYh9sct djUVCTFY6MIp5WdlRhA2PGiJ0WeNkSYvf59wo2uBzCKBwYQIWUCNVAEu/DQTV1eLeTMMOOrRwagL 8nH6S4T3r0FFiBk+rZ/7ucD1OcN3Dcp2uAAAiE5odgJ8h4RsyCaZbBLCzAnQ1GV4kEnYuEBS5V34 OwzDlUCBODYTAxvgSgE164NnWgWeyyzU7gN/1PP/FoZNARW/QH4EFiLQuSydqhAFotzYXxPooS6e SgtIdz992BVI79CjUAajXOiNi7eAiWJOaAZUJmGhQji8+QfvG9GLLypEWxQPYgQXTDs1FJGsoL8b BSwgArs060OLWHhrlPs2GghWVk0Lf1zSNUtEJKqBRwj2zrbY/0cDBHUwAcMPtgdNLpdJ+O8rEXyA Pyz2BVK9L/b3Ocdyqy90cVKXz6Gt7GSfRZToyi2YgeJFb62qVD/d4gIDBZZ4hX4nAcJdB6dlB1ds 8A2+VcngIB8+DUkLdyt6YPk0CJjumVEgmmoseqACRiavbLYNA9U0mEtHNihBJpukRiwJIB5Gu9tR UTXoYP6jMGV1FLBE5vl2EQBnr71W7xGVRm1CY6sraG7W/rEbaIft9ob79nVaB3VWFSXl9a/AsTlb cke5BznvczCao9e4qSn5yBtPOMjYFwg4wxnWiU+JXjAVioQRjA+JDapO4v0zKS0FazpuqsZeY+AJ A1NSLSnFVRn7trY3B7YVr6NDFRQMatnSOnCpCEIlQ2r+xSngCFTPtfP4Z79LU2gr3yAq89t0Eui5 8CngFotjFT5GPziEgAMUZdk5YNsq1I2DCG8uaAAOA7AOQRgAkagM6KdjEXxyEhC4ZmYAJRwAdwEM Vi21CCYVH38F6Pa9cjTlFGgBFLRWXbbbCDjgc3wFFDPmwoWi0DGlt9joYVuBwYq3BrDL61YsGoti aRioCot6b8NrpQE1O/WYHvbCRpxKtegT/9ADwSziURnfxa3bGCR46MMv0A5awCY16qictikFHjxh icAN1QQvn7SweMFRjLBZW17AKVarwIhqNCpXe8VqoYwjuR/VAPGF3QnQdD5IKUHQlnCJwoNCcGTs v+TCchUp2hnxiSiJ6VSvNsDaogHVX09fBDFYR71HR9Ppx+K2DQJNVlNG6FChwOxY/30bLnG/AR0R oTYp2KPY7Fi/hgArDgHd4q9jYAi1Sv+h6w1h4m1pzJA/4ovF9iEW9LMO6+a/lPixnWdDCNBUdDqy W1gCHrOE6AwDMgJBR6YTLyIxHTQB7x6hYMUL7DvuYh+/sChzCSKjeQiDxyAYtvuA+zkLfKIvPfA/ WECt0cbB5gWLhu+jNgIB+8iLjmmUE6gOIxQ+KcEZ0z1DHSygEd/ZMtDvO/Mt4mDajWVCM8TYsZNi JlSLLAMNSM7vhc4dihHaow6JFYRHmhDA0MGj0OyS4t12DFFIAKxFASyAYNRw7iQkVAtiBoeTet7q GT2VUjTRIANkCAaRVm4bRDziYAIHA53emwHAjK4v6D0FKvBj48sojXA0ZjHy60P8UBeHizaqt+KL h8xVwg4IWroCTIQu9i15BEsDKkBFe5xon0HwxXyywA+HeC9ERHQZVy+YanLErzEKFSZOXFbw0YnH P+jV+xT5QNnYsRkB1e8/bwN+7baHpoUs2SqIwRiJw3uhASelA0wIU2hhWPBJHfG8JYNTUE6x/1Ao bL33rMoJSAlsqf4qcyG5HN6APWWwMIMxdh8Qyv77dJd4Vj6+AQvugccF8KmN1hflTz9EJNwm4AdR 6UJ9BWQzAkNgIZWEC3KMfjuKID1ESnlM1WIBUxFCUDXx+y1xWdKjyzVM4OWvWHGwHXdYWr3+JHEA L/DhBUWFdAQqdQW7TrT3d+JVVVPrG1doRjmmIbCDwT/KlVtecNRTkfhesP//CqIr3sgA0Y5UO3ZS 6LYPtoYab4rciAMbrQALNESyik4fuvqEXRWjYLyIyCSzPBqBBRb8Dl9Y6Wi4wCW+DBuAdQsWKdDi wRvlNigHoVQ023rf1yUcoQSjECujM8RW4vCIDQ7GVgsOeJKIyMUUkAPCLLQwEniAeAv3GLUY4G5i 6UPaw6zx/iooO3LjCqGP1IEJeByv7gfourDQEjieMic58JzzwkIVWwpXd3sMUP9ab8Pc8CkdMpoV Kd4B30AT2AANTv5MuRAIlrdiIlygsEA2wWaw4AhaAQxbFIFKXLdTwQYOVncEHMvuuH1BOdl12g/3 0PBbXsM/LPAG/+sCRkOKDoTJyIoThD0MC7y1KDpgdeLfOJHmlmiu/YPh3w++wRcOB3zQ7hpgzjhM rsoUCnRs75oKgh4DC2vSCiPDWvG/LaYCaooZjUPQPAl27FwYOujd5A6JN2ce0xccqzAMJcQMnj7W 4NS7KUQZdAfoK0GxouAIHAxApIK/qPsNdQKzClOgDcVHIrY0HRBAPUZs4/sKjw3o4nObcO3zFxt6 6Q5DGMlj55ILwKMkLui9u6PBsHfkro1YEv7EArV95GDkZLnADwTRu+JLPQno+q4LcuhYWvevpUnU AOimdRno3xo2CtBoD79bx1dEv8Jz5AVhG+8FuaQ1ARig0XvJyIbct/8KKctp006cB2nAsy8NqqXg N3gloXkLjYKrnuOSeGM6oQQlENFhqZaoJGkM2v+elg0qhfD+EINrL2io1cKlwp//JsBwdDvkGDOD /wJ/CoA49g2a6C51KQ4MFAgJ1kcUA9p/o4TAifCGxMHIEATYXItqQAv3HyMI1CUZ6wIoSrTxTFQ6 FRf2NaJtw2c/Aiz3EPGO0dECwDc9RgUtBlwgIIw5w1d9KP5EN8UjtSvoMzX4G3QFyEEt/QRz78Wt CAFRz8j/nYSftMRQ0ous//9+lK10RHexDGvnEo0cyaSAETZAYICtefIFDtSk65A8lWiGX0yxIFkN D/CxuBHd6byeGGgBJJU6WHwTreF0GowR/C3dhrDR5rYbCN/mYKHAPdsED/51kJAzg/oNUvQEOj8u dfo5EavgfaJ18iT1pVdVwtxG2IUErdxDcechBwpeiDinsvN15iQIArHEe+yXBgkmFNwYLo140UNN BPiBVwCwIG64I3cG2xjrAmWGjgJDb0aJgSAYQQOGDLwjgkVFjiCQgviCB3yLmAWw72M39SU/a4H7 U2OLkJQYWyMvz4iY+VKB+kqmE/79pduNS3/h8LzwOcpzBboWOfpyMV3a6CAuEM0Rlin4x36PUGkM geoHgeIiynL76Bu8Dhr0cwaJ1az/nQi6Cq6DjI/2Oe4YELubhWD5FDke9OAAw3Q4KMFdLCMYqRJn /x+CAlus+Oid5aIZFNIj/lHbqQtYFhs7AADhbDAQLAvrCKG7eyFDJoqNSPy2Ow0cDWLVU4FXF8fr 7wuNJVKJGIkNJY1BBI4HhgOBIa3+GxuNNZwXKS74qSHNIJP9wY1Z+DsdQCHYMGiv2G06/AY4iT9T MHRRsw81i5GdFFDqRyNlfUAFCkCrh6owUJKBDxCmOdCy8HyYEL42w/uos424j2JJOPjaMSMVF0K8 oYXsDLiw4oCY6Yh9cgQj4UjsYeQvLC2wzBPPc13Jrt92JPvub/w5zXMgOd1fOc9zNusUBQyJyin6 7bixq6DomInpc4n7QLffbTzYO4F3CHUSO1yNdgxFEB74i0wkNhTigmgwfLkE1OJqiPfwztyjyOuj yPXhaayoHBq45xgdFHAsYhss4eQOIcKLjDAl31PVJUy9ZZmqQvwNG0e4lgMNXFr4oRiqwmthJGwG EV7YMWoCS/XjFFRoADj/c2TIHoijHBVQIh4GHTHA6+hIlwpXcS9rVH4FCvibgrln0+O5x3EcBw6D G+xf+SmkQxJQZrsFFp6dBhNS5GRLKXah22+BSctgVMMOGnsGK2J7bXR1OGcENjQOBQwGXKFdHuoh HuzircsSCFBriQoFC4FggNkdHENkpYjn4FtBhwzg/4SNI4FARxA7UBB1FGaLQSxkMGBqUZNxlIME 8U4RxJssEC4iUY/Roo39D9GNQEWIA8ZDPyg26x7AC7w4BQYntgcsFA1DXAYJQbyRCvOhbuP9IGhW QkMQSsxFi+hgFEfCamYyKhdCKBx8uAgeDmmpxihoqH2ZiklhGZaA92bvcYPoFHYYatZw6whtFOt7 92XGHTRDQWFMNCKYpN5tlkMZYff//1jGghYsUT33lyV1saqHViRf4CAMG+A2tiRXC94RXo8muIPQ LOj9zH6E0Pj5vjRuRgk4RwKD2CSKbRNzXwTeR2SovRtE1D7/yw+RANokTAhFGjx+HyM1/2jToxl5 lrcmYVgRCO0A22IPggG8oV4CAZuiQClnvuYYSROCIH/fGQvuFDQtWPwAXKPZd/kYGy1FKtUHt/YY NhgFnysaLjHCZSREDxA2rPyqhXd6MzsKFuBMEvyebhIx0BljAU9iizAuVP81VaUz3o0QzSgm69eD 7PoaLqv66L+1//+4ID8ojAzS+wNTBB1MICY6ABwqGwhWfQgB7+nk9luw6A2mnyg2oA+WPKgApiCW igT3AIDFBR6TCOmuB/i47gJ8rjypSwJ72JI4PYh/t3bN6TthOsapcYNXdr3lPMxccOvoQgyHZgda DeSgZnI3rAlEBGotA2j13UUdAS0hlWx0b/S/jWoOilIOjUK7PD6Hev920HjDK0bgnmlV6BH1/WEz RD/jOlnw90UGPz7VBrDlKdLtKkT/PYCHEyE1SIcieqAP4Bn7qYZFl6u6T2s93AUvj32RfdgS9IPq FLoBwCnRofE/WOK8tCKLjXQYDjn33FgAKja06/J0Dn4btG+XfA///Qw7FSzpMx1y1oE6M1UiBILD vmpTBIbWcNJVc3UVnIefLYNRuF60M3yJ6OiFX9B0Hf64Khb9t88X+UnCVS1afCMLB5yoF7IAU1U5 MHhBlDMDVKKL5uFtDo+93VYGPehrgoXZkVowwS2V2HJVGMVdoMRWHaH+gu/odxlHgX3TI8G2iwE1 B/wYOwUwFLoCtg/3wMdhjaK9FRhdDlc1rbdTsLlFMUIICER9Enq3WKFX70MOBGg0t5kH21MjDwZo RDETD5eKVmhVaruWZuhZ9u4YEUPpnAeAfQkRZF4BXcUhuL6mGBXLKrhVI8ZM9WijXpszHDuG2BQE nItVbx+/6KIofRRuRGjWaLarHNHkl11AZO8EqUJsg04jyHL3qIYaUpflKNjqLWUQU7gbrTltC9xd LoQBMkaDwgfAAv58uFVLLOzYaIOJRRaUi4JBWXMdxK6hWBSzCENA6/B2qhiJZr4BYX6Ab7eBKRAG BBEEEBKxgiAUKQMpfCIGwgsYJ17o97xQgDDorrQuidmx3TNArB4ZMFAEHNDtSlseswF9jRIdpVgQ Q+QINFkbPPP1X1NotCQNMp5W2xThw2jYMSr8ZbAIQ6lh8BJ+FXW/6y8la8ajijEowczRo+kEvFYu fogVSAEPsLMVHSw2Nh34YDccowsoZkI3DC0DWglqPOFtJ0YgqjVlGzQYjsBG9zDY6VHPAh66P66B 7GgCsp9L+esodlzQoAiFooCEBAn9dhHugQRDooIIoQZ7EB7yE4OEpB0kuUBFP90GgyBdQAEEQUIG 6B444cFboXhVRqNod7Iy7JvoobTuAwUTwzIa3qME+kSZL54O4UJYAnUWlXTvhNbIQdHgi54WjIxd CHLqlxYsR83Y2YMNaHwtSBYwxkErwGwMWcV7EhxNmDqy/pwkYr74MMaSGQlMv/65KDj2TYKejlMm 6Or8G2ML2lgraO5qQ2pENFYlCvdbshiq4U+8QSToJmbD6GagqzwbuiPdPBhTImFw8jmB6E16BBZy GNwpqtt/4XyVoFf/aVBXvmGssz6BdxNXsq90EjsAW5BzyjoMj4RT0AMJVBWwAeFn8i1oIJgJPRaS kbFbLQjtFjEmCDIycmDvNw8ywrFJN1kW+BQ3apgSJjHbJAB6YRh2qoyfCjgJh4P0GPZiATf55bBL wfLNsADeBeBEG8ijABbpHpmr6rvUU+toFCM4sM+mB2hN61HKh1+L3Z5WVgo/aM1N7suWgil7Wa5o qw+zPCzSs0Qh6MSBq2z1bw7phIv4nlAUdErruN2wvaUHrPzs6IaeBCnwdKvUq3Agn/fxncHuJ204 RYP9IqH94PFHvCz+gqYRAAAdN50a5cAKd4HEXI0QbPy2W0C9he33ko6c+oLWiQ/XBVwypVsRsa1b Bpw6da6Q626hAqDLXhoZXerc0gIRH/EkDS8itkj3CkAIIAccaw2feAJUDXpHQaYHjMXtFlBVBAoV eHEUAeCRKxwlAHkn4UFoyUvopfut3QKsu8UOlkoM0AJXB2a2C/xaE28BGX3gfoU2F75SFXvIeFKQ HfSFV6AITpFufsQ+hN09X60291RtZosp0OBsW0gBuyAnti37uzmHaqmheqRbB9AL950d3qMRUacF 7FAH5GDnZHikerbu+mLRQTyFE5sh8S80dSRZwQ7GGKqNWPYFhJ9yCCGjeKQtRqFi0RQceCKOTtQN wRVCdDJmeHwZu6v96R0BIx5TjVEgpQxjAKUZiqNohw6DD4K1IiHD/seATtMB0I1w9sZA/816DycH mmzkL0v6ffQX6ZgFdkzrUqEtSBXsbCoYhP8nY4B6QuMRL2d1HVBTwisDDt3CCFcsIaOJAv59hGIo NxiKEEBwhNJ18RrxCv8OOfByrl0jchm7eOxmfgw+1I66GxuYboxUBQhebVDk+XxsfDVQYBEPISEM w9HhGW0YKTANgNKTu3oNFUZAURxONezIcGsRT/x3dUYKwm2rV3KQcAIPdzYhcWZ4qw0HjUb6KMCl iq1U9t3+4qFgiXAL15wBsGB08UcMDArCuXuHtxG4oTa+wBYIOxmfqyAgaiCsxXY8adPTgz/FQP24 ZkCk2AqVwGD7uiqa2EUoQzT9iQrfXxh1JyRFAAYmrGEOeIPVIOs2XgOxgI8w07N+MTHSJTwYH74U ikPQqA0Z6xRQYYOFTv7YUmP85Gc9KA62uQJMXU10dXVgBmTFaAps+vhbtIMlGo00M+nFADJ1uQVh I2IECQlw7zDyIQ8M/GgCAVJIdYMgM81eDyO+tft0MsLDBE/rcKQBdR9Q+OSSySU4DIPuBGt0f9hA EK8EMj0AVnd9o/tuFVu56/MDNRiJBW8kuBDUFO09HPHwOSqeYLauFsawVCN1MMAQhQG2wG4jFxBE TgaKA5F7A26oC4QCQ+k+D9v9ezOT6g2JHd6J3ukqE6AMC3Atep0iPBwWrfXtWuE7mPfrHRQDNolL b+iAewGahvMSHnB29zBU5kWl6doAWBL7xr5AU9/pzwBNRxE1TdgPtkZdLKNv6bYm+2teNjZiCO26 FAx1TRF2rXOwo+CfMQEGGemEWHJ/7zH+yHUzIIB1LIPCQAWXYnxM4JffougNhJdqg3QoHZh1Iv+u EOT3d+tNMoF1E1MM/LUK3va060w97zD9Gnz/IpZ1I8YFDwE1I1BqQDBznFfUshhBX3qLnRmNXANP 8w+Cqj4OEw63l3othUS7bTeZRVUkRz6NRzzU3gUDtOkrDXUShw1uLJkEpVle+Y2x0Y8P0AQLO7Bt DPz8MAIegm/VCSaC9kjbDUwe6RinH8CNyuQSCDeEcjBWDzSONV2ByhXp0ddD/VzcoYSkux0juDtC Ai2NXt5+Kgwi9COiPVEEO/b7xFncDi4B01TQRj7oQ7+HcacMkIQSN35Gp7GHnVRXVIsbdBkUfU82 QpZ2MIXhAFsUp6EH1B8URcxOxhoRkwbIGlTx7UBOWFNA0nRsiYw+9Aj4QxCjHonQo30raBTsTn9/ B7jgnnsTxOsTPb8GDQ5gqUfXIv8Ho5vcwMjwqTazUy3ovFjWEi4EdRBeSDbsF906qKOKv2KHbz8K WrmJ2PyGlkYcCx7Ze3ELqrqSKBYttBEkigfDHMwMXaYMtJd0CilI10U5Lm5DJ8mRqoXuEPYYEGGH HCr3F8QNuhvY6KbLVyCWaEQN039FGn7YnH0PdBO6NByJvi8BS7oUxVL9+wbrKg/rR4hx/NscEBuo D3IT0it0tVSmXfcOhCaua+8Nzjn4dNNMCiVCH3x3oZo9TiV0CCUPPD93uz+BYUAPEWyLtCTiFq5O bUc8i0aljQ2OjNd1DEQbKe5229EGMY7rLU1+GgNeGeXimwiWXw5J+FBX6Km3OwCV2c89RhoD0fUD UBlb/eki4PdsdLBjvXUeM1dVvx6zvtAnWBaJVolABOkQlaYWHm91D4nZgEpYyNSSw3QozPo3QgIO LX6b+P2ylU+zfe9NHsHqEAcgKQiiTAaqgS7B6bQoj64j6KMuIk7EZhIaPfsD7yS6PKJ5W4vJXwBa H/Q5AnN5EYtKEO4PBnUjOHvrLjnTdTTwS93/URLB4AMDQgxmST5dCLtw6Vq5CDxIAsw8/wCuI1eR e4s5B26LEsF80LcFVGXY7xjBcp0wSblz6zpwRSlYYFwsFTYqFb8ey3Uk6yCU6hyiaBUveiVoC5hY tRS9mE4RW1Nfqi1GCOsNYsFP+T+2wiO+g35gcrgZ+YjfU1T4ThmJ6IhqJA7tHuHWRbRmMdYgB04G an3FhqVMMBeKHf9culY0LE8KDVwzG2Tp7aRZFG50FAy7ECPSlSo3HJEbUhTw43Bgxmt0C3+w0LBE B29QsxCy+yh1qi2AhtKoXkU9QA2mkULca8VeHeakKywUPMdvXn9Ahm+rGOskR1/Cgf/+kCPiQ52G 4bbt7VQL1P2q89/r5XBOSMGCbPBtwRzihQWD4BdcHYcmJqOzFMsg5z4iXACC/rZMMLYJt8n/C8LQ 7SpWAJwMF/+LtmtyhyWoDJ4Q4YNkIMS3w/f86wUG8Pv899oh0KIpWxY1YlPWgiLMCB8mPf4u1dI6 FAbpdSttjVMEQDw06SQuYRXUHtzCbZ1orwslRFSoBxLCV+WA2Ozj8JmjGFSK3MDuzRO0wyeg2Fwk nTgSHbAKuVttGwb6iWJho8q5OdB0EObCmgnCJf2RA7KNMhcYDfEaE1boDbUXH3cWyByMcTAoZjXo CLt3gwX6husV/HM8EZy9pQwRTzrDdVkgGMAYo+MUfWiDJgEYgCSuaM5BpoD36Q4rCLyDQG2GFdVG JDaFdnAR76caQm/UShX0GoWDAxD7VbhgFSquAz0qFnrs/3NWiwA7RhB10ywD/0YoUPbrt90a/3CQ 4WSpA4AIAhKgWNDtWlkUDFac26LW5Xvrfk9JiU9RDQJ1McD7yJirGo4H64SDW7TnKHkeyTxSAxio dtnv5oImA+cdvDQn0Jq6AAYaQ0NpWQ6s7xsgFXRgbQm//3YQ6M0aDUM9wiVbtiEcYvDf2X6Ri2MA BGYJBhk44RsGrggFo3TNBcKtoBkcUwAgFRDesSfH32npcHED0R+DVB+J/deJzmpd73b46SRSPCV0 K9MMjHANbir0EIgCVQZbdUQKgLa+tOjFLmKweE70kvqKrQtotYVCeun1SK9V/Fa5LnUBR4phEJ/O Wv/2gPpzdTaLHhNRDYuIAclhDdxBiQbjTikN7qjRQ8FM1oPGKX/4hZ+b+iN0w+3rBke9HooHPGwW h0v9dQNH6wQ8Xwe7aC4eAG+jeD8MBvBf+twmuwQXiMbIIDx4dU+NTmirmS4oNomE3NkgB10tYLwv bGcu+OquqW8gMCVYMCETIusaES/Rm9mI2dPodIqAAwLtVi+YCdCInkWDbsWL9v39eeLp2wCPZHVT UxZP0dd6mm14TEwLLTsMgyABfSGJzbsKvR83UWpbYVU/r1npictj+7ZVfAvqEYpD//yIAt6AukRP SUOz7emDvbfhx1dAdS6LBn9Iu+ikgKFQd/REHEtf5zABG6KksQHFdcJbgxeOBXXjrTIhdTFVdyJq rXM1CYiSke1SFs2+AzD9o2sNb1XjGHLkUk3jNZrr2m9jpnULbPggFN3YDLQuWyC34EEmy5WwTaL/ A6QDhLCw8JPdOety1t8HqQ8SD5y9BP3//zQHGcbEoxPgOAwpLbTb6rpCBIZ2JE0YGbRQPN5YgtVs d5CzGSgki5ToZhsmwBEdkJBiagAdG4WKMYJBGfYDVFM1lcM2DOzK1dLbVB9Jg/mSDPndVPSGfQRC Q+teCFvDbIsbhzvrmYA6k/pDsLdVI5IgRydWor7UmkJJdQWlCIMN5r5UQzFRU1IMkqHFd0rDKhpC hE0DqQBXCtpBcu9xqi3Yucci6wgvA26/79/DQIoQOMp18ooEYonIZEBK6kt0ibZ0BUx19CnIvcnh vgN8yKKqDjjLdIna7b9+igqEyXX16ww+HDhjtJoEHHry6+y74W1BumasGygUJhgXs4KDJe8x0Kca 8BO5KvHD6wpMG1AXjumLOfSK324QTf8BnIA7gQ7HBRTpGpoB5AEbHZiqua6AUDgJoT0kEL+GpKMi idgqb7O53R5JFv9fLmlZWmciEMV+KYkGJqpQ41IQK5SKQfH7Fmi81EtBQrkn8ptbIoVhESYMeSKe DOHsYSIIW2wUpa1gW2qEDhMCATsjtkH80HUJQ0FOQu3uDCvYCgmzIwIShf1CYQbD13XzidBbH1x4 4cJKOYpC6DjYdRjQ63sFFWI73amr39DCwDhAjgjyrvfR2u7Cv0mGAcg4EApIOwpz9R5VGNykP1Cs FHMFdQHRwixbxReuQG/VJ23fLnCoZxLO652b6DClDTGAcCfdTj1iFl3q7n3oYon4YTgSEAx9HnUK wg2Ug94e6yiKF8QGseMTRn908o0afQsXG4UTeCfAIPbCq41G+wfCIBJmq9gCwzQGsQ+2k5AzhVXY Wb1mxwAD1MMOnTgJOAAArQQgPsZnFYqakABwKIuKlKHdC7zPxDuCmAhyBQJbWwToJ3sVC1PyGN7v SOwQoTYBsCxaQagDQ+q/WokiOkGEBB8LCgGRwYgJERwIttqCA0DpxZGKlgUI6Iei3RKCDgMPAKrq V3REuEZzhA+huhD0WVI5AVnZIBAHmd48GBA7VuXMnkSN6SAwyIPd3A0G6RUzAehlwCDBbVC+AKbq ntDNbqR2FTmaBizp5hbwFs6fAjyhJXYue3vdBAMGpqJSUP/cBTJTPwAS6NpND6toEtSRLyh4gDoM 1kNqQQtYvAyQsIBz+wVXPQYIdBIFNYBVuLulexL7AesQBRFwuGsfBQPrBA0O+1XUd1gCnPy9lZ2A Zxch60LSqN2IL2IIfxDoht0SN5vs2ewC6IsQ2+sQ42zei+rwcBf/LQO844SDEBsMu6R2IVNRFOzu SkDoRODYUtEkiA55AlHtIws6d1aDzbUr4A93Q4A9P6J1DFAxi8C0fHgv0btkPUAUJ8gBoxbDfgGm LRas7r4VDdhHBRRyAlsyiCVy50ls+ELxvfVnLTKuHejVk24U/Qn64wGD/gDoYmD/biLGFuggBg/o Gf8cBL5A9ejdlL7YWVtezCuOEJs1wDOd/5HAFxYGDB8HA7AB6Qwj+D50957VxoYFAs5IFcptAQMC BkAuWwwDKqdNgHmwYAS/BxChSgypRh4UoVQYaSXaOBWsOaCmF7zgbUos3e3mw4lGthz8g8MiPbdD OGY3GHwBatFS4UMVRwoMLEeloI7gSUknNcLYohRmHtiA26U7clcIRwYwBOs2MlcTVaSqBikCaA1F Y4H5ayy5Gvayin4GBFFTZCnwaxk8BuP++UgHMNrtMGCIVyslav70OeFT6G2+OdsGBeMVdUbLBxJl BXRnNL0YNixDNrjgr8VyKv6l4HZ7LFDrc55eCjKKS0sQJ7cxdHHf0+82BcUJDo14HIH/r35hBse6 0iBZjRwSr1YQ8GgIUBUdoGsRLXocXLxZE7QBGdf8xTBBqFupznTS4X8Awb65CUtIsAHrEKqsoA0b 9hXM64hyyM5QBNCrfv0FNNcMAxsGPUgdN6Ls1gyRxl2FIkhdY5hTB2RM0gWMF0Y3CUzIAYspWlkN scnAlRMcJQWj5IQc7F81W1rX/IlqkKZoUJA2KMhkB4CYCZTU0EC3/hl/ugrz5zhY9IeOFseDigB3 AwGxsbFBdhhPizuJILItI2DqHotLR4ojBwZpUNZeAkGpRopT050NO1jQg4mGhgDpiYKs2DF42xGC Yo7HgqqTLRF5WViqVqcMwK2MCMh2iw0Juy4LLIu/+75ewPt/n3WBupDAVHhQdTKNgpxvHkTMBF5t XcaeUMR9CgwBiZDpU8BB6x7nEFAKQ9+BsDnjdzvrOUAPTjmI9l9GS0UuBzy9TQgEnuQYslMG6Jb2 lQ9hSZDd1AL7qB5SGDT+VxiyhxOMPP/653Bk0K/PMx87BYx0FwuUOsN7AqMY+eQcf+BGACLQySAN zZ4AOIWcZlK6F1zACQZXV/QEKNj3lN26P+L5U2aLMYk9eBryhGfHgp6JGOFERF/mX1EOJzCpifsF hiV8IdxYgvUTJFtfFCQd2IVx7fl3BEnJhwl0V/8/wvnPorZNM8Nobawh8yuq3QXSEoCWiz0mPBbU mxq5ECM2MAPFVZWAVQAIMslsDBYoHnwKoRjbMFjZz+IOKQKhKEMDZqEqCcT+FPUFoSSNCIhDBwrx 3ahQBRQVPhTi6xxwB38FPaTRKgtBLD5oaAkVCl4N5Pco6mAP0SiFXNONBVsDDwPCBwMI1g8EXwkp C7NDAgBXiSnhBbX4DBQBIWsgPFXVcFj6zr6yfjZvoWjSArVs8sTlECzH3AUWAVzIQSNo9jVcpGUx uDxsDKvz1xPu+zbLHJehWECLQyw3JLDssS49MAEAkUo7uCk77PeRKmrRWkUwkD7oY/MMcAhSzm0G FBWyONZhlnwinPcAJvEgmKdyLX6JSCVwtVGNDBAp8Y+9mSVuefe3QQQWUQKNbQXelhzzCCmAfylv uWclTA+66+x6NgR8IeojilcCgMcOchqAD271tg4EA3UiQrgAdZ+Ape8quAYGI5IMgInZEOgK/Y1b DoPtDjqObHz08DfwuDVAU1VQUei21q4HW4QMkh+y7stgPAKD9muh9hMthXFbQ0HTExwtIaywamCr KYGd8ZBAdBFrL5srkXULOgX2/BHsEdgB2/WOsfV9EyZBiaEBAMCUwYX1xWyMlt7CO/hmwevEwtek ny7Ffzgdw3UIOMApYgtidDQQgwOTIA4Y/n0tWFEn8vUYd+x7kETGBT8JiEOIFUFgQQWDyIh0xjuI 3InDAx2NQBzdG9VJfIno77QE5QVrdrslSs0JDYsELn3XGCd+X/cNzgTNCccE+s9t0cEDAArThw5b UC3Imlb0z5fVraGFyRwHAv9VjBKqpoT0JEASigGzuhLiF7MJARZ3YAAWHVkABIQUsaPAdxVtFc/4 Eg+E8raPoA0zj6ZcCA63Ad8HbH9NAXUKHDAQsU38hE4kk307ggbJNY6xAjEF5ftQsA1klVMBDga6 rYCxYAgHQgIlXQHU3cYNDRaCAkwmtrGxrUcKXzBxPwsOaG3k2cYIDDBfTQ8WWxX7StclSxwoQNu3 jH1zPQ0wu5pOCiBCxfIsah0UpXu2sS0yL0EVTw89DWVsZBsiHF5KDiO3yW5nmCUl6QGmcRaoAduL bWemMgpzMKwOM2fbYgBrCHAwuPtKAGcNdccwDgoYOytic+t1GHbmYFeo+wg9TcgYHd3wzoZOgFLo GF7rhz2hsQkK46fpbxuoGXnGmvztCnPiLc9Ic+TX+PvMtsFpjjwjgbai+qtIc+QZSqCt+ZVdFCPP a4qpTHzk2SJADw1Ebmke0jyo72D+91I0D3kOBUTN9jaahzyHAihn9RrPIc1DzvQMiv7zkGeQ/lLw /fN5yHNI4jfU9PIa0jykxqzxuIcL6AAS6Y/fbRgbK1cYFjZA6ZMWdTCYFoUPt1SU9BAIihbxdQRw qtQ7hhqFXkPBKEIoLQlcCd+iUxyiaiPoqsBv4BqgnAVR5uiQgbNmdUFkA/jOylUNBBIci++joikm hSwGMCA22Po7RxB1edBWdNZGRYgaygvls7mqtv91Y4tHDIlGAhABUbXbY9AXBJeNWPgYEIk9AG+A 7ikZDKE52HMHAwR4+5rrLZKNQQiZDknA7+iv65ZeDsWQkC9FMKo2pbgIsXZ3d1SHCAtcszV09fUs ddr17t83Dv/W+vzoUQlyAjDkPRyIyWZBXcW2xLw8IIeckgnvdBSm5AA7Zok9CrEDbMlJ1nQ8MmUv Vc8cuAtAcOfKgkyVOotIJpmSDDVacsgpuQ36cx9MUgAXMU5s0fWOEByDPTEga5gFwFNhcME/o2KD yw4d616BOwDDVv1fMzJfdVOECdWNCkGFcQllG7RA8AIMGkJZ+Nw44S5QoYrwABVWI0SA7hYSHqGE r6EENbZAGD1VdYK2LcDI8g9sh+Bb9bqooxWruPD/DwC89hP5OcN2k8IXRbwhLu6EvP8kUENJunOT LS0o0U0JagY8gMU2CBo8EiuJ8yeA0gZnNl6VxmJ3v2gzaJSD6w9SjxC2Hoo9+ZQaxwX1U2LDljA0 jj8hcmAAjmjC7HIyD3dvUQf1EFkIgfpCIHRJLfvXEbbdSNHm//9FgDDP9+cZG2W1DRwwdjoedTwk dA8DgKI66ZUfiS0PMzR7iYMTC96Q2/97QwfkYSX9UcgB5mGwsOZDwMJrri/b5kIExsPD6du4INM9 VgGblgVTw2lESMULsTOpwLroA4qXv3Y3iRLpwMUqG9w0EgDKpMoMyJo7pEeqg1UQ4OnXSzSD2nFX kze/YLEhgID6xAOqxDPbvw0HsB8OCYQWkeliW3WI/giKKtcooL7+B6RrFGBY/gkEB9gZYJTUCWoK czgD4MdomKGj53sFmey7KyejpPUpqD2sWKzoJrAJBgNALADMc7RimchNMvYdwD3EyAmxEoEhD96X IcYzYT3QJAauwnzdXyVogPkE3BYNYQ+hLUX4uGz4UiN3Yd1wCQJIdBJ1zE42RgaAMYT4rjQfrDMb CQMxBmgtoozSTTLyqZSYCQfzPFgznAExB2gzoEI3ych3qKwJgByQrEhy+EJwyJGvHzRCNPk4N+Fh FW48+VtmuAao+wFoEpkxQJgQMSUODxswaNpo7bsVhwsEH2aj4xWIIJxmCfLABgod+CBaW7stV9eN me7pJXYEem4TVBcDAGmWTRzBLcrRJWiGZNromv8U+YnsPW0AAORFdGj//3/3bwYBOQIF3DwNEWVy Ym9vdC01LjQ3BAEDDPa9rbArPzUDNgQIMgXunwMsQQkRgIGCliw/9ih4IFoARkFUQUy+8f//OiBO byByZWFsLW1vZGUgc3RhY2sqQ2Fubs5eNtdAFxR2UFhFGCHJ2q7bGSEMAANOVpdp9jf+myAuMyAo R1BMKSBQdHA6Ly9lHP92+x8ub3JnCkRyaUhyc20AICBJbWFnlSBau2UKTkKJNQV7e4teAEV4cCh0 czoO2r/7tmNyOm9jb2wRREhDUCBURlQE9r/0339uaWMAZGlza61sb3BweQBlMTAA9va3tyJVbmuw d24gTUFDKXlwZShv7d/aVH5TRVBST00gQwq7c3Vts7fNbXlz7a1W7WlkCr427O23bqcgYWRkckIl IQpNIG3hsD0gTGlUIAYXdEC29pNtAmQfSGFyZHcDYEn3bdvdjnRpLHphBm99RmFpbCYD9s/ORSwt ODI1NDILM+aGrP1nYy1maWJ5E2POFMgWyBM0ZWk9W3AJ5DQUIW0RrBzYATBlDTU0sreyrzZlYhQp clg7sjcoEzGabbayKVt/cBE/IfvAEg03ZWlvLLaywnF1p51VOMoOYA81Z9g1Z8MDW2jfE3MR3HN2 TSM7kGcxDSRiE0LCDOK1F2deyQMIQDZnYmdi6w72ynwxcG5fOAQzG6PdtHQybIcASwBMb/uN97JG Y2ejwAtAOg6/cWuP4EnLZW6oJSNoeCAas0ZrnhzZC6J62ugWcWMKeJNCp2YobbxUVAUoTinQd2y2 jbfW3AMMUSl1wz9HV+muNdcaVFiSLDxhYoyclkqtPghXN3CYbttLb9YgQVCvIiVjASIXdGa2byiV 5IIKc3ogPiB8bXX/sNYHFIZbJWxYLCAEKclqm6lh9cRwpw5riyxgHTEvBbGETVgsCi0syW2R2mRv gKKKdLvJreC2d255jK95+q7RV2t3bTUoYgApLgDibKXWrblV4fZvdWril2FruWU3lDliJfWtHfYu cmdyYW0jdK0ZWqx27GlnCjdiYX0ocDwb29Rx8Wduiml+YSAsgP0tI3dWZiAyLyIZ3IJrdhxWbHN2 tEOsu3x6ZdZkLJrdXHcgIOMqvDoLZqA14MAnKQUWBbEGu7UXonI6cnal6BbagWlNJQluBQqHC9YR WyBj8EAEYYcLbSE9EPZwdcMZa7i1LS9TDTdkYS5w+7cZuAWvdHUUKSWbPzpKbTxzrl8GUkdhdDyc sX2eX0Z4SDqIeLVlhdJ4KwwuiMFhoSeOX79du922Rcj0dWguoU1le0AAbiMWgSzVCoMmBnbBDrgp EuMdcWF5xmu3wQtHeWV3DQyPodBchEJukC6+sD3nmgxUZAkbbUXY3sAD00VSVDlnI+Cgi7GnYTPQ cMCtbc417C3i9C9n50jDUDC0eZaMVnHstQiTsERQICBqE6F1DKFz415tgytaO3xby3SDIT0NL+O1 YR8UZm9FzNdvNjeM35VJUAP5Lm4Wgx0R4GZ4edMYYO1trdQbdM5nMkpdhNlTRi9+c249trYVeb50 BnNrNYZYJDaAZAAMoadCMENrciV0H6vGbNb6RkMxN04eKRzaI0KJGi8HuritsdBOU2IOMk9pGs59 TUd323adTgxepW3X3RxmZhkh8QVsT1bnspoKd0JPT1ItRoRHcwQwpHmpb2JpYZxogGQBIDY0Ykjv 202QQkFSFzA4eDoEXiPmFt5iQE9hLlMztCFPdnNdF3BjadQt8N8oC6BoWDoAMDEyM6o2c5fFv9A5 QUJDREVGdAAvNwFr+3hvc19tIIF1qtAMsQtYdmmcHdC3ZuoyAERtf94Zd0B2uzUXVSbMby4pdQpG g8nREkUrDQ9WC9YF12doSztKAc7Q3nahX2YrvbDFoUXtimV6ZCkgEOYMJ5Bw5j0hmty2pFeLPwD4 UtEutQW6UhjcT1MtZ4BGoz3fZpsPZslchJ5UEDEWww7mqaVubzebeAsRWoNMQxjbUTAK97e9OAMH MGpqwIMgPzcAcrab0WCiDwSfzweTbGWDDZsXkx8A3S5FAq6GgAW+mcgjj/wHARDKBBDeCBDzRx75 +QkQCJoMEBwNEDEOEFZq5JFDDxBRELgHyCOPPBEQexIQjxMQoyOPPPIVELEWEMMXENUYjzzyyBDj GRDxHRD/HhAZeeSRn5smEConED8oEFPkkUcedRBodhB2dxCEkUceeXgQmXkQp3oQvGobeeR7ENB8 EOWW35tG1RHMqBxch4GC2e0rZgOxYBPy2AUIBxKZSgEL7FDYD/////8AAHReAwQuoLcA9Ev9yjbC gu8rY4JTY+HQgFMd+weWC68Fd7ECnwAAAAAAAEAC//////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////8= --=-5wa1yskDoUb8y2LUJkZE Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline ------------------------------------------------------------------------- Check out the new SourceForge.net Marketplace. It's the best place to buy or sell services for just about anything Open Source. http://ad.doubleclick.net/clk;164216239;13503038;w?http://sf.net/marketplace --=-5wa1yskDoUb8y2LUJkZE Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ kvm-devel mailing list kvm-devel-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f@public.gmane.org https://lists.sourceforge.net/lists/listinfo/kvm-devel --=-5wa1yskDoUb8y2LUJkZE--