Changeset 914cc24 in libbsdport


Ignore:
Timestamp:
Jul 21, 2011, 11:24:55 PM (8 years ago)
Author:
cvs2git <rtems-devel@…>
Parents:
a8bf95d
Message:

This commit was manufactured by cvs2svn to create tag
'ssrlApps_R20110804_p0'.

Sprout from base 2009-04-22 22:06:58 UTC Till Straumann <strauman@…> ' - importing updated version from SLAC as of 20090422'
Cherrypick from master 2011-07-21 23:24:54 UTC Till Straumann <strauman@…> '2011-07-21 Till Straumann <Till.Straumann@…>':

bsd_eth_drivers/.cvsignore
bsd_eth_drivers/ChangeLog
bsd_eth_drivers/Makefile.am
bsd_eth_drivers/if_bge/.cvsignore
bsd_eth_drivers/if_bge/Makefile.am
bsd_eth_drivers/if_bge/if_bge.c
bsd_eth_drivers/if_bge/if_bgereg.h
bsd_eth_drivers/if_em/.cvsignore
bsd_eth_drivers/if_em/Makefile.am
bsd_eth_drivers/if_em/e1000_manage.c
bsd_eth_drivers/if_em/e1000_manage.h
bsd_eth_drivers/if_em/e1000_osdep.c
bsd_eth_drivers/if_em/e1000_osdep.h
bsd_eth_drivers/if_em/if_em.c
bsd_eth_drivers/if_fxp/.cvsignore
bsd_eth_drivers/if_fxp/Makefile.am
bsd_eth_drivers/if_fxp/if_fxp.c
bsd_eth_drivers/if_fxp/if_fxpvar.h
bsd_eth_drivers/if_le/.cvsignore
bsd_eth_drivers/if_pcn/.cvsignore
bsd_eth_drivers/if_pcn/if_pcn.c
bsd_eth_drivers/if_re/.cvsignore
bsd_eth_drivers/if_re/Makefile.am
bsd_eth_drivers/if_re/if_re.c
bsd_eth_drivers/if_re/if_rl.c
bsd_eth_drivers/if_re/if_rlreg.h
bsd_eth_drivers/libbsdport/.cvsignore
bsd_eth_drivers/libbsdport/Makefile.am
bsd_eth_drivers/libbsdport/alldrv.c
bsd_eth_drivers/libbsdport/bus.h
bsd_eth_drivers/libbsdport/callout.h
bsd_eth_drivers/libbsdport/devicet.c
bsd_eth_drivers/libbsdport/ifmedia.c
bsd_eth_drivers/libbsdport/libbsdport.h
bsd_eth_drivers/libbsdport/libbsdport_api.h
bsd_eth_drivers/libbsdport/libbsdport_post.h
bsd_eth_drivers/libbsdport/miistuff.c
bsd_eth_drivers/libbsdport/misc.c
bsd_eth_drivers/libbsdport/mutex.h
bsd_eth_drivers/libbsdport/rtems_callout.c
bsd_eth_drivers/libbsdport/sysbus.c
bsd_eth_drivers/libbsdport/taskqueue.h
bsd_eth_drivers/links.am

Cherrypick from freebsd_orig 2009-04-23 04:52:05 UTC Till Straumann <strauman@…> ' - importing original 'releng_7_1' version of FXP driver from FreeBSD.':

bsd_eth_drivers/if_fxp/if_fxpreg.h
bsd_eth_drivers/if_fxp/rcvbundl.h

Delete:

INSTALL
Makefile.am
bootstrap
config.h.in
configure.ac
m4/acinclude.m4
m4/config-if-present.m4
m4/cvstag.m4
m4/multilib-fix.m4
m4/multilib-installdir.m4
m4/rtems-bsp-postlink.m4
m4/rtems-bsplist.m4
m4/rtems-check-libargs.m4
m4/rtems-checkprog.m4
m4/rtems-checktool.m4
m4/rtems-checktop.m4
m4/rtems-fixup-prefix.m4
m4/rtems-isml.m4
m4/rtems-ismultibsp.m4
m4/rtems-isrtems.m4
m4/rtems-makevars.m4
m4/rtems-multilib.m4
m4/rtems-options.m4
m4/rtems-setup-recurse.m4
m4/rtems-tools.m4
m4/rtems-trim-builddir.m4
m4/rtems-verscheck.m4
makefile.top.am
makefile.top.in
rtems-pre.am
rtems.am
ssrlApps.components.in

Files:
20 added
32 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • bsd_eth_drivers/ChangeLog

    ra8bf95d r914cc24  
     12011-07-21 Till Straumann <Till.Straumann@TU-Berlin.de>
     2
     3        * if_em/e1000_osdep.h, if_em/e1000_osdep.c, if_em/if_em.c:
     4        added e1000_register()/e1000_unregister() to keep track of
     5        devices that are 'in-use'. This allows for sharing the low-level
     6        code between bsdnet and standalone drivers (e.g., for PtP
     7        GigE links).
     8
     92011-07-20 Till Straumann <Till.Straumann@TU-Berlin.de>
     10       
     11        * if_em/Makefile.am, if_em/e1000_osdep.h, if_em/e1000_osdep.c,
     12        if_em/if_em.c: added e1000_osdep.c which implements all
     13        os-dependent parts in a bsdnet-agnostic fashion. Hence, the
     14        low-level driver can be used w/o bsdnet.
     15        FIXES: dependency on bsdnet initialization; PCI bus header
     16        was not initialized when not used via bsdnet (lanIpBasic driver
     17        crashed).
     18
     192010-07-23 Till Straumann <Till.Straumann@TU-Berlin.de>
     20
     21        * libbsdport/devicet.c: Initialize libbspExt.
     22
     232010-06-30  Till Straumann <Till.Straumann@TU-Berlin.de>
     24
     25        * libbsdport/bus.h: PPC's inlines from libcpu/io.h still have
     26        un-intuitive argument types (e.g., unsigned instead of uint32_t).
     27        Added additional 'iotype' arg to BUS_SPACE_DECL macro (ppc only)
     28        so that we can cast to the correct type as expected by libcpu/io.h.
     29        Hopefully that doesn't bring us into C99 alias hell.
     30
     31        * libbsdport/devicet.c: Silence compiler warnings by casting (char)
     32        argument passed to 'ctype.h' functions [toupper + friends] ->
     33        (unsigned char) as these functions expect 'int'.
     34       
     352010-03-07  Till Straumann <Till.Straumann@TU-Berlin.de>
     36
     37        * links.am: POSIXified sed commands for sake of portability.
     38
     392010-02-12  Till Straumann <Till.Straumann@TU-Berlin.de>
     40
     41        * libbsdport/Makefile.am: Removed obsolete (and commented)
     42        stuff.
     43
     442009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     45
     46        * libbsdport/libbsdport.h, if_em/e1000_osdep.h:
     47        We need __BSD_VISIBLE defined. Some things in the rtems headers
     48        changed with 4.10 (can't pinpoint the details). We now
     49        #define __INSIDE_RTEMS_BSD_TCPIP_STACK__ before explicitly
     50        including <rtems/rtems_bsdnet.h> and this seemed to fix
     51        things for 4.10.
     52
     532009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     54
     55        * libbsdport/libbsdport_post.h: added missing declaration
     56        of m_defrag() (Chris replaced the dummy #define a while
     57        ago and provided an implementation instead [thanks!] but
     58        we also need a declaration).
     59
     602009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     61
     62        * libbsdport/ifmedia.c: fixed 'unused variable' warning
     63        by removing unused var.
     64
     652009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     66
     67        * if_re/if_re.c: fixed 'unused variable' warning by
     68        commenting via #ifndef __rtems__ (since code which uses
     69        the 'msi_disable' var is commented the same way).
     70
     712009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     72
     73        * if_pcn/if_pcn.c: fixed 'type-punned pointer' warning.
     74        Use 'memcpy' to copy 2 bytes to a short. This requires
     75        another #ifdef __rtems__, however.
     76
     772009-10-20  Till Straumann <Till.Straumann@TU-Berlin.de>
     78
     79        * if_bge/if_bge.c: bge_intr must be passed as a 'handler'
     80        to bus_setup_intr(). However, the irq_check_dis and irq_enable
     81        methods seem to still be skeletons so this driver won't work...
     82        (I have no hardware or emulation available to test).
     83       
     842009-10-20      Joel Sherrill <joel.sherrill@OARcorp.com>
     85
     86        * libbsdport/alldrv.c: Revert.
     87
     882009-10-20      Joel Sherrill <joel.sherrill@OARcorp.com>
     89
     90        * if_bge/if_bge.c, libbsdport/alldrv.c: Add local changes (untested).
     91
     922009-09-12  Chris Johns <chrisj@rtems.org>
     93
     94        * links.am: Fixed the links so they work with absolute paths.
     95
     962009-08-15  Till Straumann <Till.Straumann@TU-Berlin.de>
     97
     98        * if_re/Makefile.am: added 'if_rlreg.h' to SOURCES so
     99        that it is 'distributed'.
     100
     1012009-08-15  Till Straumann <Till.Straumann@TU-Berlin.de>
     102
     103        * if_em/31000_osdep.h: added missing 'void' return
     104        type of __out_le32() inline function.
     105
     1062009-08-06  Till Straumann <Till.Straumann@TU-Berlin.de>
     107
     108        * libbsdport/rtems_callout.c: fixed possible race
     109        condition. callout_stop() must check again from
     110        critical/protected section of code if callout is still on
     111        the list/active. Otherwise, the callout-task could
     112        have executed and removed the callout between
     113        callout_stop() checking the p_prev pointer and
     114        entering the critical section.
     115
     1162009-08-05  Till Straumann <Till.Straumann@TU-Berlin.de>
     117
     118        * if_em/Makefile.am, if_em/e1000_osdep.h, if_em/if_em.c:
     119        Changed 'e1000_osdep.h' to provide stdalone I/O methods for
     120        select architectures (x86 and PPC -- others fall back on
     121        libbsdport/bus.h). This lets the low-level driver (everything
     122        except for 'if_em.c/if_em.h') API be independent of
     123        BSD networking and libbsdport which is desirable since
     124        certain applications may wish to just use the low-level
     125        API for implementing dedicated 'raw-ethernet' drivers
     126        for BSD-independent, proprietary GigE communication.
     127
     1282009-08-05  Till Straumann <Till.Straumann@TU-Berlin.de>
     129
     130        * libbsdport/alldrv.c: reactivate weak aliases for all
     131        known/supported drivers. This magic allows the user to
     132        just link the desired (sub-)set of drivers.
     133
     1342009-08-05  Till Straumann <Till.Straumann@TU-Berlin.de>
     135
     136        * libbsdport/libbsdport.h: define _KERNEL only if not defined already
     137        (e.g., from Makefile).
     138
     1392009-06-04      Joel Sherrill <joel.sherrill@oarcorp.com>
     140
     141        * libbsdport/alldrv.c, libbsdport/libbsdport_api.h: Add include
     142        <stdio.h> for FILE *.
     143
     144        2009/05/12 (TS)
     145        - bugfix: bus_write_2() must map to bus_space_write_2 (not 4)
     146        2009/04/22 (TS)
     147        - imported SLAC version into OAR repository; added FXP driver.
    1148        2008/03/22 (TS)
    2149        - silence more compiler warnings:
  • bsd_eth_drivers/Makefile.am

    ra8bf95d r914cc24  
    11AUTOMAKE_OPTIONS=foreign
    22
    3 SUBDIRS=libbsdport if_pcn if_le if_em
     3SUBDIRS=libbsdport if_bge if_em if_le if_pcn if_re if_fxp
  • bsd_eth_drivers/if_em/Makefile.am

    ra8bf95d r914cc24  
    55
    66libif_em_a_SOURCES               = if_em.c
     7libif_em_a_SOURCES              += e1000_osdep.c
    78libif_em_a_SOURCES              += e1000_80003es2lan.c e1000_82540.c e1000_82541.c
    89libif_em_a_SOURCES              += e1000_82543.c e1000_82571.c e1000_82575.c
     
    1516libif_em_a_SOURCES              += e1000_mac.h e1000_manage.h e1000_nvm.h
    1617libif_em_a_SOURCES              += e1000_osdep.h e1000_phy.h e1000_regs.h if_em.h
     18
     19if_em.$(OBJEXT): AM_SRC_CPPFLAGS=-D_KERNEL
    1720
    1821EXTRA_libif_em_a_SOURCES         = e1000_82542.c e1000_ich8lan.c
     
    3639AM_CPPFLAGS                     += $(CPPFLAGS_82542_SUPPORT_$(ENBL_82542_SUPPORT))
    3740AM_CPPFLAGS                     += $(CPPFLAGS_ICH8LAN_SUPPORT_$(ENBL_ICH8LAN_SUPPORT))
     41AM_CPPFLAGS                     += $(AM_SRC_CPPFLAGS)
    3842
    3943include $(top_srcdir)/rtems.am
  • bsd_eth_drivers/if_em/e1000_osdep.h

    ra8bf95d r914cc24  
    3838
    3939#include <rtems.h>
    40 #define _KERNEL
    41 #include <rtems/rtems_bsdnet_internal.h>
    4240#include <bsp.h>
    43 
    44 #include <sys/types.h>
    45 #include <sys/param.h>
    46 #include <sys/systm.h>
    47 #include <sys/mbuf.h>
    48 #include <sys/protosw.h>
    49 #include <sys/socket.h>
    50 #include <sys/malloc.h>
    51 #include <sys/kernel.h>
    52 #include <sys/bus.h>
    5341#include <rtems/pci.h>
    54 
    55 #define ASSERT(x) if(!(x)) panic("EM: x")
     42#include <vm/vm.h> /* for non-_KERNEL boolean_t :-( */
    5643
    5744/* The happy-fun DELAY macro is defined in /usr/src/sys/i386/include/clock.h */
    58 #define usec_delay(x) DELAY(x)
    59 #define msec_delay(x) DELAY(1000*(x))
     45#define usec_delay(x) e1000_udelay(x)
     46#define msec_delay(x) e1000_udelay(1000*(x))
    6047/* TODO: Should we be paranoid about delaying in interrupt context? */
    61 #define msec_delay_irq(x) DELAY(1000*(x))
    62 #include <rtems_udelay.h>
     48#define msec_delay_irq(x) msec_delay(x)
     49
     50void e1000_udelay(unsigned);
    6351
    6452#define MSGOUT(S, A, B)     printf(S "\n", A, B)
     
    7058        #define DEBUGOUT7(S,A,B,C,D,E,F,G)
    7159
     60
    7261#define STATIC                          static
     62
    7363#ifndef FALSE
    7464#define FALSE               0
     
    7767#define TRUE                1
    7868#endif
     69
    7970#define CMD_MEM_WRT_INVALIDATE          0x0010  /* BIT_4 */
    8071#define PCI_COMMAND_REGISTER            PCIR_COMMAND
     
    9384typedef int8_t          s8 ;
    9485
     86typedef volatile uint32_t __uint32_va_t __attribute__((may_alias));
     87typedef volatile uint16_t __uint16_va_t __attribute__((may_alias));
     88
     89struct e1000_pcisig {
     90        uint32_t sig;
     91};
     92
     93/* Register an instance; if this returns nonzero
     94 * then registration failed and the device with
     95 * the pci signature passed in MUST NOT be used
     96 * (since it is already in use by another driver).
     97 */
     98int
     99e1000_register(struct e1000_pcisig *sig_p_out, unsigned bus, unsigned dev, unsigned fun);
     100
     101void
     102e1000_unregister(struct e1000_pcisig *sig_p);
     103
     104#ifdef NO_82542_SUPPORT
     105#define E1000_REGISTER(hw, reg) reg
     106#else
     107#define E1000_REGISTER(hw, reg) (((hw)->mac.type >= e1000_82543) \
     108    ? reg : e1000_translate_register_82542(reg))
     109#endif
     110
     111#define E1000_WRITE_FLUSH(a) E1000_READ_REG(a, E1000_STATUS)
     112
     113/* Provide our own I/O so that the low-level driver API can
     114 * be used independently from the BSD stuff.
     115 * This is useful for people who want to use an e1000 adapter
     116 * for special ethernet links that do not use BSD TCP/IP.
     117 */
     118#ifdef __PPC__
     119
     120#include <libcpu/io.h>
     121
     122static inline uint16_t __in_le16(uint8_t *base, uint32_t offset)
     123{
     124uint16_t     rval;
     125    __asm__ __volatile__(
     126        "lhbrx %0,%2,%1; eieio\n"
     127            : "=r" (rval)
     128            : "r"(base), "b"(offset), "m"(*(__uint16_va_t*)(base + offset))
     129    );
     130    return rval;
     131}
     132
     133static inline void __out_le16(uint8_t *base, uint32_t offset, uint16_t val)
     134{
     135    __asm__ __volatile__(
     136        "sthbrx %1,%3,%2; eieio"
     137            : "=o"(*(__uint16_va_t*)(base+offset))
     138            : "r"(val), "r"(base), "b"(offset)
     139    );
     140}
     141
     142static inline uint32_t __in_le32(uint8_t *base, uint32_t offset)
     143{
     144uint32_t     rval;
     145    __asm__ __volatile__(
     146        "lwbrx %0,%2,%1; eieio\n"
     147            : "=r" (rval)
     148            : "r"(base), "b"(offset), "m"(*(__uint32_va_t*)(base + offset))
     149    );
     150    return rval;
     151}
     152
     153static inline void __out_le32(uint8_t *base, uint32_t offset, uint32_t val)
     154{
     155    __asm__ __volatile__(
     156        "stwbrx %1,%3,%2; eieio"
     157            : "=o"(*(__uint32_va_t*)(base+offset))
     158            : "r"(val), "r"(base), "b"(offset)
     159    );
     160}
     161
     162#ifdef _IO_BASE
     163static inline void __outport_dword(unsigned long base, uint32_t off, uint32_t val)
     164{
     165        __out_le32((uint8_t*)(_IO_BASE+base), off, val);
     166}
     167#else
     168#error "_IO_BASE needs to be defined by BSP (bsp.h)"
     169#endif
     170
     171#elif defined(__i386__)
     172#include <libcpu/cpu.h>
     173
     174static inline uint16_t __in_le16(uint8_t *base, uint32_t offset)
     175{
     176        return *(__uint16_va_t*)(base + offset);
     177}
     178
     179static inline void __out_le16(uint8_t *base, uint32_t offset, uint16_t val)
     180{
     181        *(__uint16_va_t*)(base + offset) = val;
     182}
     183
     184static inline uint32_t __in_le32(uint8_t *base, uint32_t offset)
     185{
     186        return *(__uint32_va_t*)(base + offset);
     187}
     188
     189static inline void __out_le32(uint8_t *base, uint32_t offset, uint32_t val)
     190{
     191        *(__uint32_va_t*)(base + offset) = val;
     192}
     193
     194static inline void __outport_dword(unsigned long base, uint32_t off, uint32_t val)
     195{
     196        i386_outport_long( (base + off), val );
     197}
     198
     199#else
     200#warning "not ported to this CPU architecture yet -- using libbsdport I/O"
     201#define  USE_LIBBSDPORT_IO
     202#endif
     203
     204#if defined(USE_LIBBSDPORT_IO) && !defined(_KERNEL)
     205#define _KERNEL
     206#endif
     207
     208#ifdef   _KERNEL
     209#ifndef __INSIDE_RTEMS_BSD_TCPIP_STACK__
     210#define __INSIDE_RTEMS_BSD_TCPIP_STACK__
     211#endif
     212#include <rtems/rtems_bsdnet.h>
     213#include <rtems/rtems_bsdnet_internal.h>
     214
     215#include <sys/types.h>
     216#include <sys/param.h>
     217#include <sys/systm.h>
     218#include <sys/mbuf.h>
     219#include <sys/protosw.h>
     220#include <sys/socket.h>
     221#include <sys/malloc.h>
     222#include <sys/kernel.h>
     223#include <sys/bus.h>
     224
     225#define ASSERT(x) if(!(x)) panic("EM: x")
     226
    95227#include <devicet.h>
    96228
    97229struct e1000_osdep
    98230{
     231        /* struct e1000_pcisig MUST be first since
     232         * 'back' pointer is cast to (struct e1000_pcisig *)
     233         * in e1000_osdep.c!
     234         */
     235        struct e1000_pcisig pcisig;
    99236        uint32_t mem_bus_space_handle;
    100237        uint32_t io_bus_space_handle;
     
    106243        device_t dev;   
    107244};
    108 
    109 typedef volatile uint32_t __attribute__((may_alias)) *__uint32_a_p_t;
    110 typedef volatile uint16_t __attribute__((may_alias)) *__uint16_a_p_t;
    111 typedef volatile uint8_t  __attribute__((may_alias)) * __uint8_a_p_t;
    112 
    113 #ifdef __PPC__
    114 #include <libcpu/io.h>
    115 static inline uint8_t __in_8(uint32_t base, uint32_t offset)
    116 {
    117 __uint8_a_p_t a = (__uint8_a_p_t)(base+offset);
    118 uint8_t     rval;
    119         __asm__ __volatile__(
    120                 "sync;\n"
    121                 "lbz%U1%X1 %0,%1;\n"
    122                 "twi 0,%0,0;\n"
    123                 "isync" : "=r" (rval) : "m"(*a));
    124         return rval;
    125 }
    126 
    127 static inline void __out_8(uint32_t base, uint32_t offset, uint8_t val)
    128 {
    129 __uint8_a_p_t a = (__uint8_a_p_t)(base+offset);
    130         __asm__ __volatile__(
    131                 "stb%U0%X0 %1,%0; eieio" : "=m" (*a) : "r"(val)
    132         );
    133 }
    134 
    135 static inline uint16_t __in_le16(uint32_t base, uint32_t offset)
    136 {
    137 __uint16_a_p_t a = (__uint16_a_p_t)(base+offset);
    138 uint16_t     rval;
    139         __asm__ __volatile__(
    140                 "sync;\n"
    141                 "lhbrx %0,0,%1;\n"
    142                 "twi 0,%0,0;\n"
    143                 "isync" : "=r" (rval) : "r"(a), "m"(*a));
    144         return rval;
    145 }
    146 
    147 static inline void __out_le16(uint32_t base, uint32_t offset, uint16_t val)
    148 {
    149 __uint16_a_p_t a = (__uint16_a_p_t)(base+offset);
    150         __asm__ __volatile__(
    151                 "sync; sthbrx %1,0,%2" : "=m" (*a) : "r"(val), "r"(a)
    152         );
    153 }
    154 
    155 static inline uint32_t __in_le32(uint32_t base, uint32_t offset)
    156 {
    157 __uint32_a_p_t a = (__uint32_a_p_t)(base+offset);
    158 uint32_t     rval;
    159         __asm__ __volatile__(
    160                 "sync;\n"
    161                 "lwbrx %0,0,%1;\n"
    162                 "twi 0,%0,0;\n"
    163                 "isync" : "=r" (rval) : "r"(a), "m"(*a));
    164         return rval;
    165 }
    166 
    167 static inline void __out_le32(uint32_t base, uint32_t offset, uint32_t val)
    168 {
    169 __uint32_a_p_t a = (__uint32_a_p_t)(base+offset);
    170         __asm__ __volatile__(
    171                 "sync; stwbrx %1,0,%2" : "=m" (*a) : "r"(val), "r"(a)
    172         );
    173 }
    174 
    175 #ifdef _IO_BASE
    176 static inline void __outport_dword(uint32_t base, uint32_t off, uint32_t val)
    177 {
    178         __out_le32(_IO_BASE+base+off,0,val);
    179 }
    180 #else
    181 #error "_IO_BASE needs to be defined by BSP (bsp.h)"
    182 #endif
    183 
    184 #elif defined(__i386__)
    185 #include <libcpu/cpu.h>
    186 static inline uint8_t __in_8(uint32_t base, uint32_t offset)
    187 {
    188 __uint8_a_p_t a = (__uint8_a_p_t)(base+offset);
    189         return *a;
    190 }
    191 
    192 static inline void __out_8(uint32_t base, uint32_t offset, uint8_t val)
    193 {
    194 __uint8_a_p_t a = (__uint8_a_p_t)(base+offset);
    195         *a = val;
    196 }
    197 
    198 static inline uint16_t __in_le16(uint32_t base, uint32_t offset)
    199 {
    200 __uint16_a_p_t a = (__uint16_a_p_t)(base+offset);
    201         return *a;
    202 }
    203 
    204 static inline void __out_le16(uint32_t base, uint32_t offset, uint16_t val)
    205 {
    206 __uint16_a_p_t a = (__uint16_a_p_t)(base+offset);
    207         *a = val;
    208 }
    209 
    210 static inline uint32_t __in_le32(uint32_t base, uint32_t offset)
    211 {
    212 __uint32_a_p_t a = (__uint32_a_p_t)(base+offset);
    213         return *a;
    214 }
    215 
    216 static inline void __out_le32(uint32_t base, uint32_t offset, uint32_t val)
    217 {
    218 __uint32_a_p_t a = (__uint32_a_p_t)(base+offset);
    219         *a = val;
    220 }
    221 
    222 
    223 static inline void __outport_dword(uint32_t base, uint32_t off, uint32_t val)
    224 {
    225         i386_outport_long( (base + off), val );
    226 }
    227 
    228 #else
    229 #error "not ported to this CPU architecture yet"
    230 #endif
    231 
    232 #ifdef NO_82542_SUPPORT
    233 #define E1000_REGISTER(hw, reg) reg
    234 #else
    235 #define E1000_REGISTER(hw, reg) (((hw)->mac.type >= e1000_82543) \
    236     ? reg : e1000_translate_register_82542(reg))
    237 #endif
    238 
    239 #define E1000_WRITE_FLUSH(a) E1000_READ_REG(a, E1000_STATUS)
     245#endif
     246
     247#ifdef USE_LIBBSDPORT_IO
    240248
    241249#define USE_EXPLICIT_BUSTAGS
     
    394402#endif /* USE_EXPLICIT_BUSTAGS */
    395403
     404#else /* USE_LIBBSDPORT_IO */
     405
     406/* Read from an absolute offset in the adapter's memory space */
     407#define E1000_READ_OFFSET(hw, offset) \
     408        __in_le32((hw)->hw_addr, offset)
     409
     410/* Write to an absolute offset in the adapter's memory space */
     411#define E1000_WRITE_OFFSET(hw, offset, value) \
     412        __out_le32((hw)->hw_addr, offset, value)
     413
     414/* Register READ/WRITE macros */
     415
     416#define E1000_READ_REG(hw, reg) \
     417        __in_le32((hw)->hw_addr, E1000_REGISTER(hw, reg))
     418
     419#define E1000_WRITE_REG(hw, reg, value) \
     420        __out_le32((hw)->hw_addr, E1000_REGISTER(hw, reg), value)
     421
     422#define E1000_READ_REG_ARRAY(hw, reg, index) \
     423        __in_le32((hw)->hw_addr, E1000_REGISTER(hw, reg) + ((index)<< 2))
     424
     425#define E1000_WRITE_REG_ARRAY(hw, reg, index, value) \
     426        __out_le32((hw)->hw_addr, E1000_REGISTER(hw, reg) + ((index)<< 2), value)
     427
     428#define E1000_READ_REG_ARRAY_DWORD E1000_READ_REG_ARRAY
     429#define E1000_WRITE_REG_ARRAY_DWORD E1000_WRITE_REG_ARRAY
     430
     431#define E1000_WRITE_REG_IO(hw, reg, value) do { \
     432        __outport_dword((hw)->io_base, 0, reg);     \
     433        __outport_dword((hw)->io_base, 4, value);   \
     434        } while (0)
     435
     436#define E1000_READ_FLASH_REG(hw, reg) \
     437        __in_le32( (hw)->flash_address, reg )
     438
     439#define E1000_READ_FLASH_REG16(hw, reg) \
     440        __in_le16( (hw)->flash_address, reg )
     441
     442#define E1000_WRITE_FLASH_REG(hw, reg, value) \
     443        __out_le32( (hw)->flash_address, reg, value )
     444
     445#define E1000_WRITE_FLASH_REG16(hw, reg, value) \
     446        __out_le16( (hw)->flash_address, reg, value )
     447
     448#endif /* USE_LIBBSDPORT_IO */
     449
     450
    396451#endif  /* _FREEBSD_OS_H_ */
    397452
  • bsd_eth_drivers/if_em/if_em.c

    ra8bf95d r914cc24  
    414414
    415415#ifdef __rtems__
    416 int em_bootverbose = 0;
    417 #define bootverbose em_bootverbose
    418416#undef static
    419417#define static static
     
    462460                    ((pci_subdevice_id == ent->subdevice_id) ||
    463461                    (ent->subdevice_id == PCI_ANY_ID))) {
     462#ifdef __rtems__
     463                        /* Copy PCI signature to the low-level (bsd-agnostic)
     464                         * support struct and register with ll-support. This
     465                         * step also detects if the device is already in use.
     466                         */
     467                        {
     468                                struct adapter *adapter = device_get_softc(dev);
     469
     470                                if ( e1000_register( &adapter->osdep.pcisig,
     471                                                     dev->bushdr.pci.bus,
     472                                                     dev->bushdr.pci.dev,
     473                                                     dev->bushdr.pci.fun ) ) {
     474                                        return (EBUSY);
     475                                }
     476                        }
     477#endif
    464478                        sprintf(adapter_name, "%s %s",
    465479                                em_strings[ent->index],
     
    826840        EM_LOCK_DESTROY(adapter);
    827841
     842#ifdef __rtems__
     843        e1000_unregister( &adapter->osdep.pcisig );
     844#endif
     845
    828846        return (error);
    829847}
     
    900918
    901919        EM_LOCK_DESTROY(adapter);
     920
     921#ifdef __rtems__
     922        e1000_unregister( &adapter->osdep.pcisig );
     923#endif
    902924
    903925        return (0);
     
    26642686        adapter->osdep.mem_bus_space_handle =
    26652687            rman_get_bushandle(adapter->res_memory);
     2688#ifndef __rtems__
    26662689        adapter->hw.hw_addr = (uint8_t*)&adapter->osdep.mem_bus_space_handle;
     2690#else
     2691        adapter->hw.hw_addr = (uint8_t*)adapter->res_memory;
     2692#endif
    26672693
    26682694        /* Only older adapters use IO mapping */
     
    26922718                        return (ENXIO);
    26932719                }
     2720#ifndef __rtems__
    26942721                adapter->hw.io_base = 0;
     2722#else
     2723                adapter->hw.io_base =   (unsigned long)adapter->res_ioport
     2724                              & PCI_BASE_ADDRESS_IO_MASK;
     2725#endif
    26952726                adapter->osdep.io_bus_space_tag =
    26962727                    rman_get_bustag(adapter->res_ioport);
     
    32823313        E1000_WRITE_REG(&adapter->hw, E1000_TDH, 0);
    32833314
     3315#ifndef __rtems__
    32843316        HW_DEBUGOUT2("Base = %x, Length = %x\n",
    32853317            E1000_READ_REG(&adapter->hw, E1000_TDBAL),
    32863318            E1000_READ_REG(&adapter->hw, E1000_TDLEN));
     3319#else
     3320        HW_DEBUGOUT2("Base = %x, Length = %x\n",
     3321            (unsigned)E1000_READ_REG(&adapter->hw, E1000_TDBAL),
     3322            (unsigned)E1000_READ_REG(&adapter->hw, E1000_TDLEN));
     3323#endif
    32873324
    32883325        /* Set the default values for the Tx Inter Packet Gap timer */
     
    47704807}
    47714808
     4809#ifndef __rtems__
    47724810/*
    47734811 * NOTE: the following routines using the e1000
     
    48524890        return;
    48534891}
     4892#endif
    48544893
    48554894/*
  • bsd_eth_drivers/if_pcn/if_pcn.c

    ra8bf95d r914cc24  
    15101510        mii = device_get_softc(sc->pcn_miibus);
    15111511        ife = mii->mii_media.ifm_cur;
    1512 #endif
    15131512
    15141513        /* Set MAC address */
     
    15221521        pcn_csr_write(sc, PCN_CSR_PAR2, tmp);
    15231522        }
     1523#else
     1524        /* Set MAC address */
     1525        { unsigned tmp;
     1526        u_int16_t  s;
     1527        /* fix endinanness; LLADDR gets swapped on a BE machine */
     1528        memcpy(&s, IF_LLADDR(sc->pcn_ifp) + 0, sizeof(s));
     1529        tmp = htole16(s);
     1530        pcn_csr_write(sc, PCN_CSR_PAR0, tmp);
     1531        memcpy(&s, IF_LLADDR(sc->pcn_ifp) + 2, sizeof(s));
     1532        tmp = htole16(s);
     1533        pcn_csr_write(sc, PCN_CSR_PAR1, tmp);
     1534        memcpy(&s, IF_LLADDR(sc->pcn_ifp) + 4, sizeof(s));
     1535        tmp = htole16(s);
     1536        pcn_csr_write(sc, PCN_CSR_PAR2, tmp);
     1537        }
     1538#endif
    15241539
    15251540        /* Init circular RX list. */
  • bsd_eth_drivers/if_re/Makefile.am

    ra8bf95d r914cc24  
    44include $(top_srcdir)/rtems-pre.am
    55
    6 libif_re_a_SOURCES               = if_re.c
     6libif_re_a_SOURCES               = if_re.c if_rl.c if_rlreg.h
    77
    88##EXTRA_libif_re_a_SOURCES         =
  • bsd_eth_drivers/if_re/if_re.c

    ra8bf95d r914cc24  
    3333#ifdef __rtems__
    3434#include <libbsdport.h>
     35#define M_ASSERTPKTHDR(_h)
    3536#endif
    3637
    3738#include <sys/cdefs.h>
    38 __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.46.2.39.2.1 2008/10/02 02:57:24 kensmith Exp $");
     39__FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.161 2009/08/24 18:58:13 yongari Exp $");
    3940
    4041/*
     
    151152#include <dev/pci/pcivar.h>
    152153
    153 MODULE_DEPEND(re, pci, 1, 1, 1);
    154 MODULE_DEPEND(re, ether, 1, 1, 1);
    155 MODULE_DEPEND(re, miibus, 1, 1, 1);
    156 
    157 /* "device miibus" required.  See GENERIC if you get errors here. */
    158 #include "miibus_if.h"
    159 
    160 #ifdef __rtems__
    161 #include <libbsdport_post.h>
    162 #endif
    163 
    164154/*
    165155 * Default to using PIO access for this driver.
     
    173163#endif
    174164
     165MODULE_DEPEND(re, pci, 1, 1, 1);
     166MODULE_DEPEND(re, ether, 1, 1, 1);
     167MODULE_DEPEND(re, miibus, 1, 1, 1);
     168
     169/* "device miibus" required.  See GENERIC if you get errors here. */
     170#include "miibus_if.h"
     171
     172#ifdef __rtems__
     173#include <libbsdport_post.h>
     174#define TUNABLE_INT(_t, _v)
     175#endif
     176
     177/* Tunables. */
     178#ifndef __rtems__
     179static int msi_disable = 0;
     180TUNABLE_INT("hw.re.msi_disable", &msi_disable);
     181#endif
     182static int prefer_iomap = 0;
     183TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap);
     184
    175185#define RE_CSUM_FEATURES    (CSUM_IP | CSUM_TCP | CSUM_UDP)
    176186
     
    179189 */
    180190static struct rl_type re_devs[] = {
    181         { DLINK_VENDORID, DLINK_DEVICEID_528T, RL_HWREV_8169S,
    182                 "D-Link DGE-528(T) Gigabit Ethernet Adapter" },
    183         { DLINK_VENDORID, DLINK_DEVICEID_528T, RL_HWREV_8169_8110SB,
    184                 "D-Link DGE-528(T) Rev.B1 Gigabit Ethernet Adapter" },
    185         { RT_VENDORID, RT_DEVICEID_8139, RL_HWREV_8139CPLUS,
    186                 "RealTek 8139C+ 10/100BaseTX" },
    187         { RT_VENDORID, RT_DEVICEID_8101E, RL_HWREV_8101E,
    188                 "RealTek 8101E PCIe 10/100baseTX" },
    189         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN1,
    190                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    191         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN2,
    192                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    193         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN3,
    194                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    195         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169,
    196                 "RealTek 8169 Gigabit Ethernet" },
    197         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169S,
    198                 "RealTek 8169S Single-chip Gigabit Ethernet" },
    199         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169_8110SB,
    200                 "RealTek 8169SB/8110SB Single-chip Gigabit Ethernet" },
    201         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169_8110SC,
    202                 "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
    203         { RT_VENDORID, RT_DEVICEID_8169SC, RL_HWREV_8169_8110SC,
    204                 "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
    205         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8110S,
    206                 "RealTek 8110S Single-chip Gigabit Ethernet" },
    207         { COREGA_VENDORID, COREGA_DEVICEID_CGLAPCIGT, RL_HWREV_8169S,
    208                 "Corega CG-LAPCIGT (RTL8169S) Gigabit Ethernet" },
    209         { LINKSYS_VENDORID, LINKSYS_DEVICEID_EG1032, RL_HWREV_8169S,
    210                 "Linksys EG1032 (RTL8169S) Gigabit Ethernet" },
    211         { USR_VENDORID, USR_DEVICEID_997902, RL_HWREV_8169S,
    212                 "US Robotics 997902 (RTL8169S) Gigabit Ethernet" },
    213         { 0, 0, 0, NULL }
     191        { DLINK_VENDORID, DLINK_DEVICEID_528T, 0,
     192            "D-Link DGE-528(T) Gigabit Ethernet Adapter" },
     193        { RT_VENDORID, RT_DEVICEID_8139, 0,
     194            "RealTek 8139C+ 10/100BaseTX" },
     195        { RT_VENDORID, RT_DEVICEID_8101E, 0,
     196            "RealTek 8101E/8102E/8102EL PCIe 10/100baseTX" },
     197        { RT_VENDORID, RT_DEVICEID_8168, 0,
     198            "RealTek 8168/8168B/8168C/8168CP/8168D/8168DP/"
     199            "8111B/8111C/8111CP/8111DP PCIe Gigabit Ethernet" },
     200        { RT_VENDORID, RT_DEVICEID_8169, 0,
     201            "RealTek 8169/8169S/8169SB(L)/8110S/8110SB(L) Gigabit Ethernet" },
     202        { RT_VENDORID, RT_DEVICEID_8169SC, 0,
     203            "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
     204        { COREGA_VENDORID, COREGA_DEVICEID_CGLAPCIGT, 0,
     205            "Corega CG-LAPCIGT (RTL8169S) Gigabit Ethernet" },
     206        { LINKSYS_VENDORID, LINKSYS_DEVICEID_EG1032, 0,
     207            "Linksys EG1032 (RTL8169S) Gigabit Ethernet" },
     208        { USR_VENDORID, USR_DEVICEID_997902, 0,
     209            "US Robotics 997902 (RTL8169S) Gigabit Ethernet" }
    214210};
    215211
     
    227223        { RL_HWREV_8169S, RL_8169, "8169S"},
    228224        { RL_HWREV_8110S, RL_8169, "8110S"},
    229         { RL_HWREV_8169_8110SB, RL_8169, "8169SB"},
    230         { RL_HWREV_8169_8110SC, RL_8169, "8169SC"},
     225        { RL_HWREV_8169_8110SB, RL_8169, "8169SB/8110SB"},
     226        { RL_HWREV_8169_8110SC, RL_8169, "8169SC/8110SC"},
     227        { RL_HWREV_8169_8110SBL, RL_8169, "8169SBL/8110SBL"},
     228        { RL_HWREV_8169_8110SCE, RL_8169, "8169SC/8110SC"},
    231229        { RL_HWREV_8100, RL_8139, "8100"},
    232230        { RL_HWREV_8101, RL_8139, "8101"},
    233231        { RL_HWREV_8100E, RL_8169, "8100E"},
    234232        { RL_HWREV_8101E, RL_8169, "8101E"},
     233        { RL_HWREV_8102E, RL_8169, "8102E"},
     234        { RL_HWREV_8102EL, RL_8169, "8102EL"},
     235        { RL_HWREV_8102EL_SPIN1, RL_8169, "8102EL"},
    235236        { RL_HWREV_8168_SPIN2, RL_8169, "8168"},
    236237        { RL_HWREV_8168_SPIN3, RL_8169, "8168"},
     238        { RL_HWREV_8168C, RL_8169, "8168C/8111C"},
     239        { RL_HWREV_8168C_SPIN2, RL_8169, "8168C/8111C"},
     240        { RL_HWREV_8168CP, RL_8169, "8168CP/8111CP"},
     241        { RL_HWREV_8168D, RL_8169, "8168D/8111D"},
     242        { RL_HWREV_8168DP, RL_8169, "8168DP/8111DP"},
    237243        { 0, 0, NULL }
    238244};
     
    242248static int re_detach            (device_t);
    243249
    244 static int re_encap             (struct rl_softc *, struct mbuf **, int *);
     250static int re_encap             (struct rl_softc *, struct mbuf **);
    245251
    246252static void re_dma_map_addr     (void *, bus_dma_segment_t *, int, int);
    247 static void re_dma_map_desc     (void *, bus_dma_segment_t *, int,
    248                                     bus_size_t, int);
    249253static int re_allocmem          (device_t, struct rl_softc *);
    250 static int re_newbuf            (struct rl_softc *, int, struct mbuf *);
     254static __inline void re_discard_rxbuf
     255                                (struct rl_softc *, int);
     256static int re_newbuf            (struct rl_softc *, int);
    251257static int re_rx_list_init      (struct rl_softc *);
    252258static int re_tx_list_init      (struct rl_softc *);
     
    255261                                (struct mbuf *);
    256262#endif
    257 static int re_rxeof             (struct rl_softc *);
     263static int re_rxeof             (struct rl_softc *, int *);
    258264static void re_txeof            (struct rl_softc *);
    259265#ifdef DEVICE_POLLING
    260 static void re_poll             (struct ifnet *, enum poll_cmd, int);
    261 static void re_poll_locked      (struct ifnet *, enum poll_cmd, int);
    262 #endif
    263 static void re_intr             (void *);
     266static int re_poll              (struct ifnet *, enum poll_cmd, int);
     267static int re_poll_locked       (struct ifnet *, enum poll_cmd, int);
     268#endif
     269static int re_intr              (void *);
    264270static void re_tick             (void *);
    265271static void re_tx_task          (void *, int);
     
    279285static int re_resume            (device_t);
    280286#endif
    281 static void re_shutdown         (device_t);
     287#ifndef __rtems__
     288static int re_shutdown          (device_t);
     289#else
     290static void re_shutdown   (device_t);
     291#endif
    282292#ifndef __rtems__
    283293static int re_ifmedia_upd       (struct ifnet *);
     
    288298static void re_eeprom_getword   (struct rl_softc *, int, u_int16_t *);
    289299static void re_read_eeprom      (struct rl_softc *, caddr_t, int, int);
    290 #ifndef __rtems__
    291300static int re_gmii_readreg      (device_t, int, int);
    292 #endif
    293301static int re_gmii_writereg     (device_t, int, int, int);
    294302
    295 #ifndef __rtems__
    296303static int re_miibus_readreg    (device_t, int, int);
    297304static int re_miibus_writereg   (device_t, int, int, int);
     305#ifndef __rtems__
    298306static void re_miibus_statchg   (device_t);
    299307#endif
    300308
    301 static void re_setmulti         (struct rl_softc *);
     309static void re_set_rxmode               (struct rl_softc *);
    302310static void re_reset            (struct rl_softc *);
     311#ifndef __rtems__
     312static void re_setwol           (struct rl_softc *);
     313static void re_clrwol           (struct rl_softc *);
     314#endif
    303315
    304316#ifdef RE_DIAG
     
    345357
    346358DRIVER_MODULE(re, pci, re_driver, re_devclass, 0, 0);
    347 DRIVER_MODULE(re, cardbus, re_driver, re_devclass, 0, 0);
    348359DRIVER_MODULE(miibus, re, miibus_driver, miibus_devclass, 0, 0);
    349360#else
    350 
    351 static int
    352 re_irq_check_dis(device_t d)
    353 {
    354   // struct re_softc *sc = device_get_softc(d);
    355   printk( "check_dis\n" );
    356   return 0;
    357 }
    358 
    359 static void
    360 re_irq_en(device_t d)
    361 {
    362   // struct re_softc *sc = device_get_softc(d);
    363   /* This can be called from IRQ context -- since all register accesses
    364    * involve RAP we must take care to preserve it across this routine!
    365    */
    366   printk( "irq_en\n" );
    367 }
    368 
    369361
    370362static device_method_t re_methods = {
     
    373365        shutdown:       re_shutdown,
    374366        detach:         re_detach,
    375         irq_check_dis:  re_irq_check_dis,
    376         irq_en:         re_irq_en,
     367        irq_check_dis:  0,
     368        irq_en:         0,
    377369};
    378370
     
    384376};
    385377
     378static int
     379mdio_r(int phy, void *uarg, unsigned reg, uint32_t *pval)
     380{
     381struct rl_softc *sc = uarg;
     382
     383        if ( phy != 0 )
     384                return EINVAL;
     385
     386        *pval = (uint32_t) re_miibus_readreg(sc->rl_dev, phy, reg);
     387
     388        return 0;
     389}
     390
     391static int
     392mdio_w(int phy, void *uarg, unsigned reg, uint32_t val)
     393{
     394struct rl_softc *sc = uarg;
     395
     396        if ( phy != 0 )
     397                return EINVAL;
     398
     399        re_miibus_writereg(sc->rl_dev, phy, reg, val);
     400
     401        return 0;
     402}
     403
     404struct rtems_mdio_info re_mdio_100 = {
     405        mdio_r   : mdio_r,
     406        mdio_w   : mdio_w,
     407        has_gmii : 0
     408};
     409
     410struct rtems_mdio_info re_mdio_1000 = {
     411        mdio_r   : mdio_r,
     412        mdio_w   : mdio_w,
     413        has_gmii : 1
     414};
     415
     416#define RE_MDIO(sc) ((sc)->rl_type == RL_8169 ? &re_mdio_1000 : & re_mdio_100)
    386417
    387418#endif
     
    399430 */
    400431static void
    401 re_eeprom_putbyte(sc, addr)
    402         struct rl_softc         *sc;
    403         int                     addr;
    404 {
    405         register int            d, i;
     432re_eeprom_putbyte(struct rl_softc *sc, int addr)
     433{
     434        int                     d, i;
    406435
    407436        d = addr | (RL_9346_READ << sc->rl_eewidth);
     
    423452                DELAY(100);
    424453        }
    425 
    426         return;
    427454}
    428455
     
    431458 */
    432459static void
    433 re_eeprom_getword(sc, addr, dest)
    434         struct rl_softc         *sc;
    435         int                     addr;
    436         u_int16_t               *dest;
    437 {
    438         register int            i;
     460re_eeprom_getword(struct rl_softc *sc, int addr, u_int16_t *dest)
     461{
     462        int                     i;
    439463        u_int16_t               word = 0;
    440464
     
    457481
    458482        *dest = word;
    459 
    460         return;
    461483}
    462484
     
    465487 */
    466488static void
    467 re_read_eeprom(sc, dest, off, cnt)
    468         struct rl_softc         *sc;
    469         caddr_t                 dest;
    470         int                     off;
    471         int                     cnt;
     489re_read_eeprom(struct rl_softc *sc, caddr_t dest, int off, int cnt)
    472490{
    473491        int                     i;
     
    487505
    488506        CSR_CLRBIT_1(sc, RL_EECMD, RL_EEMODE_PROGRAM);
    489 
    490         return;
    491 }
    492 
    493 #ifndef __rtems__
     507}
     508
    494509static int
    495 re_gmii_readreg(dev, phy, reg)
    496         device_t                dev;
    497         int                     phy, reg;
     510re_gmii_readreg(device_t dev, int phy, int reg)
    498511{
    499512        struct rl_softc         *sc;
     
    516529        DELAY(1000);
    517530
    518         for (i = 0; i < RL_TIMEOUT; i++) {
     531        for (i = 0; i < RL_PHY_TIMEOUT; i++) {
    519532                rval = CSR_READ_4(sc, RL_PHYAR);
    520533                if (rval & RL_PHYAR_BUSY)
     
    523536        }
    524537
    525         if (i == RL_TIMEOUT) {
     538        if (i == RL_PHY_TIMEOUT) {
    526539                device_printf(sc->rl_dev, "PHY read failed\n");
    527540                return (0);
     
    530543        return (rval & RL_PHYAR_PHYDATA);
    531544}
    532 #endif
    533545
    534546static int
    535 re_gmii_writereg(dev, phy, reg, data)
    536         device_t                dev;
    537         int                     phy, reg, data;
     547re_gmii_writereg(device_t dev, int phy, int reg, int data)
    538548{
    539549        struct rl_softc         *sc;
     
    547557        DELAY(1000);
    548558
    549         for (i = 0; i < RL_TIMEOUT; i++) {
     559        for (i = 0; i < RL_PHY_TIMEOUT; i++) {
    550560                rval = CSR_READ_4(sc, RL_PHYAR);
    551561                if (!(rval & RL_PHYAR_BUSY))
     
    554564        }
    555565
    556         if (i == RL_TIMEOUT) {
     566        if (i == RL_PHY_TIMEOUT) {
    557567                device_printf(sc->rl_dev, "PHY write failed\n");
    558568                return (0);
     
    562572}
    563573
    564 #ifndef __rtems__
    565574static int
    566 re_miibus_readreg(dev, phy, reg)
    567         device_t                dev;
    568         int                     phy, reg;
     575re_miibus_readreg(device_t dev, int phy, int reg)
    569576{
    570577        struct rl_softc         *sc;
     
    622629        return (rval);
    623630}
    624 #endif
    625 
    626 #ifndef __rtems__
     631
    627632static int
    628 re_miibus_writereg(dev, phy, reg, data)
    629         device_t                dev;
    630         int                     phy, reg, data;
     633re_miibus_writereg(device_t dev, int phy, int reg, int data)
    631634{
    632635        struct rl_softc         *sc;
     
    676679        return (0);
    677680}
    678 #endif
    679681
    680682#ifndef __rtems__
    681683static void
    682 re_miibus_statchg(dev)
    683         device_t                dev;
    684 {
    685 
     684re_miibus_statchg(device_t dev)
     685{
     686        struct rl_softc         *sc;
     687        struct ifnet            *ifp;
     688        struct mii_data         *mii;
     689
     690        sc = device_get_softc(dev);
     691        mii = device_get_softc(sc->rl_miibus);
     692        ifp = sc->rl_ifp;
     693        if (mii == NULL || ifp == NULL ||
     694            (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
     695                return;
     696
     697        sc->rl_flags &= ~RL_FLAG_LINK;
     698        if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
     699            (IFM_ACTIVE | IFM_AVALID)) {
     700                switch (IFM_SUBTYPE(mii->mii_media_active)) {
     701                case IFM_10_T:
     702                case IFM_100_TX:
     703                        sc->rl_flags |= RL_FLAG_LINK;
     704                        break;
     705                case IFM_1000_T:
     706                        if ((sc->rl_flags & RL_FLAG_FASTETHER) != 0)
     707                                break;
     708                        sc->rl_flags |= RL_FLAG_LINK;
     709                        break;
     710                default:
     711                        break;
     712                }
     713        }
     714        /*
     715         * RealTek controllers does not provide any interface to
     716         * Tx/Rx MACs for resolved speed, duplex and flow-control
     717         * parameters.
     718         */
    686719}
    687720#endif
    688721
    689722/*
    690  * Program the 64-bit multicast hash filter.
     723 * Set the RX configuration and 64-bit multicast hash filter.
    691724 */
    692725static void
    693 re_setmulti(sc)
    694         struct rl_softc         *sc;
     726re_set_rxmode(struct rl_softc *sc)
    695727{
    696728        struct ifnet            *ifp;
    697729#ifndef __rtems__
    698         int                     h = 0;
    699730        struct ifmultiaddr      *ifma;
    700731#endif
    701         u_int32_t               hashes[2] = { 0, 0 };
    702         u_int32_t               rxfilt;
    703         int                     mcnt = 0;
    704         u_int32_t               hwrev;
     732        uint32_t                hashes[2] = { 0, 0 };
     733        uint32_t                h, rxfilt;
    705734
    706735        RL_LOCK_ASSERT(sc);
     
    708737        ifp = sc->rl_ifp;
    709738
    710 
    711         rxfilt = CSR_READ_4(sc, RL_RXCFG);
    712         rxfilt &= ~(RL_RXCFG_RX_ALLPHYS | RL_RXCFG_RX_MULTI);
    713         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
     739        rxfilt = RL_RXCFG_CONFIG | RL_RXCFG_RX_INDIV | RL_RXCFG_RX_BROAD;
     740
     741        if (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)) {
    714742                if (ifp->if_flags & IFF_PROMISC)
    715743                        rxfilt |= RL_RXCFG_RX_ALLPHYS;
     
    720748                 */
    721749                rxfilt |= RL_RXCFG_RX_MULTI;
    722                 CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
    723                 CSR_WRITE_4(sc, RL_MAR0, 0xFFFFFFFF);
    724                 CSR_WRITE_4(sc, RL_MAR4, 0xFFFFFFFF);
    725                 return;
    726         }
    727 
    728         /* first, zot all the existing hash bits */
    729         CSR_WRITE_4(sc, RL_MAR0, 0);
    730         CSR_WRITE_4(sc, RL_MAR4, 0);
    731 
    732         /* now program new ones */
    733 #ifndef __rtems__
    734         IF_ADDR_LOCK(ifp);
     750                hashes[0] = hashes[1] = 0xffffffff;
     751                goto done;
     752        }
     753
     754#ifndef __rtems__
     755        if_maddr_rlock(ifp);
    735756        TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
    736757                if (ifma->ifma_addr->sa_family != AF_LINK)
     
    742763                else
    743764                        hashes[1] |= (1 << (h - 32));
    744                 mcnt++;
    745         }
    746         IF_ADDR_UNLOCK(ifp);
    747 #endif
    748 
    749         if (mcnt)
     765        }
     766        if_maddr_runlock(ifp);
     767#else
     768        {
     769        /* UNTESTED */
     770        struct ether_multi     *enm;
     771        struct ether_multistep step;
     772        ETHER_FIRST_MULTI(step, (struct arpcom*)ifp, enm);
     773        while ( enm != NULL ) {
     774                h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26;
     775                if (h < 32)
     776                        hashes[0] |= (1 << h);
     777                else
     778                        hashes[1] |= (1 << (h - 32));
     779        }
     780        }
     781#endif
     782 
     783        if (hashes[0] != 0 || hashes[1] != 0) {
     784                /*
     785                 * For some unfathomable reason, RealTek decided to
     786                 * reverse the order of the multicast hash registers
     787                 * in the PCI Express parts.  This means we have to
     788                 * write the hash pattern in reverse order for those
     789                 * devices.
     790                 */
     791                if ((sc->rl_flags & RL_FLAG_PCIE) != 0) {
     792                        h = bswap32(hashes[0]);
     793                        hashes[0] = bswap32(hashes[1]);
     794                        hashes[1] = h;
     795                }
    750796                rxfilt |= RL_RXCFG_RX_MULTI;
    751         else
    752                 rxfilt &= ~RL_RXCFG_RX_MULTI;
    753 
     797        }
     798
     799done:
     800        CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
     801        CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
    754802        CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
    755 
    756         /*
    757          * For some unfathomable reason, RealTek decided to reverse
    758          * the order of the multicast hash registers in the PCI Express
    759          * parts. This means we have to write the hash pattern in reverse
    760          * order for those devices.
    761          */
    762 
    763         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
    764 
    765         switch (hwrev) {
    766         case RL_HWREV_8100E:
    767         case RL_HWREV_8101E:
    768         case RL_HWREV_8168_SPIN1:
    769         case RL_HWREV_8168_SPIN2:
    770         case RL_HWREV_8168_SPIN3:
    771                 CSR_WRITE_4(sc, RL_MAR0, bswap32(hashes[1]));
    772                 CSR_WRITE_4(sc, RL_MAR4, bswap32(hashes[0]));
    773                 break;
    774         default:
    775                 CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
    776                 CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
    777                 break;
    778         }
    779803}
    780804
    781805static void
    782 re_reset(sc)
    783         struct rl_softc         *sc;
    784 {
    785         register int            i;
     806re_reset(struct rl_softc *sc)
     807{
     808        int                     i;
    786809
    787810        RL_LOCK_ASSERT(sc);
     
    797820                device_printf(sc->rl_dev, "reset never completed!\n");
    798821
    799         CSR_WRITE_1(sc, 0x82, 1);
     822        if ((sc->rl_flags & RL_FLAG_MACRESET) != 0)
     823                CSR_WRITE_1(sc, 0x82, 1);
     824        if (sc->rl_hwrev == RL_HWREV_8169S)
     825                re_gmii_writereg(sc->rl_dev, 1, 0x0b, 0);
    800826}
    801827
     
    823849
    824850static int
    825 re_diag(sc)
    826         struct rl_softc         *sc;
     851re_diag(struct rl_softc *sc)
    827852{
    828853        struct ifnet            *ifp = sc->rl_ifp;
     
    854879        ifp->if_flags |= IFF_PROMISC;
    855880        sc->rl_testmode = 1;
    856         re_reset(sc);
    857881        re_init_locked(sc);
    858         sc->rl_link = 1;
     882        sc->rl_flags |= RL_FLAG_LINK;
    859883        if (sc->rl_type == RL_8169)
    860884                phyaddr = 1;
     
    922946            sc->rl_ldata.rl_rx_list_map,
    923947            BUS_DMASYNC_POSTREAD);
    924         bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    925             sc->rl_ldata.rl_rx_dmamap[0],
    926             BUS_DMASYNC_POSTWRITE);
    927         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    928             sc->rl_ldata.rl_rx_dmamap[0]);
    929 
    930         m0 = sc->rl_ldata.rl_rx_mbuf[0];
    931         sc->rl_ldata.rl_rx_mbuf[0] = NULL;
     948        bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag,
     949            sc->rl_ldata.rl_rx_desc[0].rx_dmamap,
     950            BUS_DMASYNC_POSTREAD);
     951        bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag,
     952            sc->rl_ldata.rl_rx_desc[0].rx_dmamap);
     953
     954        m0 = sc->rl_ldata.rl_rx_desc[0].rx_m;
     955        sc->rl_ldata.rl_rx_desc[0].rx_m = NULL;
    932956        eh = mtod(m0, struct ether_header *);
    933957
     
    967991
    968992        sc->rl_testmode = 0;
    969         sc->rl_link = 0;
     993        sc->rl_flags &= ~RL_FLAG_LINK;
    970994        ifp->if_flags &= ~IFF_PROMISC;
    971995        re_stop(sc);
     
    9851009 */
    9861010static int
    987 re_probe(dev)
    988         device_t                dev;
     1011re_probe(device_t dev)
    9891012{
    9901013        struct rl_type          *t;
    991         struct rl_softc         *sc;
    992         int                     rid;
    993         u_int32_t               hwrev;
    994 
    995         t = re_devs;
    996         sc = device_get_softc(dev);
    997 
    998         while (t->rl_name != NULL) {
    999                 if ((pci_get_vendor(dev) == t->rl_vid) &&
    1000                     (pci_get_device(dev) == t->rl_did)) {
     1014        uint16_t                devid, vendor;
     1015        uint16_t                revid, sdevid;
     1016        int                     i;
     1017       
     1018        vendor = pci_get_vendor(dev);
     1019        devid = pci_get_device(dev);
     1020        revid = pci_get_revid(dev);
     1021        sdevid = pci_get_subdevice(dev);
     1022
     1023        if (vendor == LINKSYS_VENDORID && devid == LINKSYS_DEVICEID_EG1032) {
     1024                if (sdevid != LINKSYS_SUBDEVICE_EG1032_REV3) {
    10011025                        /*
    10021026                         * Only attach to rev. 3 of the Linksys EG1032 adapter.
    1003                          * Rev. 2 i supported by sk(4).
     1027                         * Rev. 2 is supported by sk(4).
    10041028                         */
    1005                         if ((t->rl_vid == LINKSYS_VENDORID) &&
    1006                                 (t->rl_did == LINKSYS_DEVICEID_EG1032) &&
    1007                                 (pci_get_subdevice(dev) !=
    1008                                 LINKSYS_SUBDEVICE_EG1032_REV3)) {
    1009                                 t++;
    1010                                 continue;
    1011                         }
    1012 
    1013                         /*
    1014                          * Temporarily map the I/O space
    1015                          * so we can read the chip ID register.
    1016                          */
    1017                         rid = RL_RID;
    1018                         sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
    1019                             RF_ACTIVE);
    1020                         if (sc->rl_res == NULL) {
    1021                                 device_printf(dev,
    1022                                     "couldn't map ports/memory\n");
    1023                                 return (ENXIO);
    1024                         }
    1025                         sc->rl_btag = rman_get_bustag(sc->rl_res);
    1026                         sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
    1027                         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
    1028                         bus_release_resource(dev, RL_RES,
    1029                             RL_RID, sc->rl_res);
    1030                         if (t->rl_basetype == hwrev) {
    1031                                 device_set_desc(dev, t->rl_name);
    1032                                 return (BUS_PROBE_DEFAULT);
    1033                         }
    1034                 }
    1035                 t++;
     1029                        return (ENXIO);
     1030                }
     1031        }
     1032
     1033        if (vendor == RT_VENDORID && devid == RT_DEVICEID_8139) {
     1034                if (revid != 0x20) {
     1035                        /* 8139, let rl(4) take care of this device. */
     1036      printf ("need rl driver: %0x %0x %0x\n", vendor, devid, revid);
     1037                        return (ENXIO);
     1038                }
     1039        }
     1040
     1041        t = re_devs;
     1042        for (i = 0; i < sizeof(re_devs) / sizeof(re_devs[0]); i++, t++) {
     1043                if (vendor == t->rl_vid && devid == t->rl_did) {
     1044                        device_set_desc(dev, t->rl_name);
     1045                        return (BUS_PROBE_DEFAULT);
     1046                }
    10361047        }
    10371048
    10381049        return (ENXIO);
    1039 }
    1040 
    1041 /*
    1042  * This routine takes the segment list provided as the result of
    1043  * a bus_dma_map_load() operation and assigns the addresses/lengths
    1044  * to RealTek DMA descriptors. This can be called either by the RX
    1045  * code or the TX code. In the RX case, we'll probably wind up mapping
    1046  * at most one segment. For the TX case, there could be any number of
    1047  * segments since TX packets may span multiple mbufs. In either case,
    1048  * if the number of segments is larger than the rl_maxsegs limit
    1049  * specified by the caller, we abort the mapping operation. Sadly,
    1050  * whoever designed the buffer mapping API did not provide a way to
    1051  * return an error from here, so we have to fake it a bit.
    1052  */
    1053 
    1054 static void
    1055 re_dma_map_desc(arg, segs, nseg, mapsize, error)
    1056         void                    *arg;
    1057         bus_dma_segment_t       *segs;
    1058         int                     nseg;
    1059         bus_size_t              mapsize;
    1060         int                     error;
    1061 {
    1062         struct rl_dmaload_arg   *ctx;
    1063         struct rl_desc          *d = NULL;
    1064         int                     i = 0, idx;
    1065         u_int32_t               cmdstat;
    1066         int                     totlen = 0;
    1067 
    1068         if (error)
    1069                 return;
    1070 
    1071         ctx = arg;
    1072 
    1073         /* Signal error to caller if there's too many segments */
    1074         if (nseg > ctx->rl_maxsegs) {
    1075                 ctx->rl_maxsegs = 0;
    1076                 return;
    1077         }
    1078 
    1079         /*
    1080          * Map the segment array into descriptors. Note that we set the
    1081          * start-of-frame and end-of-frame markers for either TX or RX, but
    1082          * they really only have meaning in the TX case. (In the RX case,
    1083          * it's the chip that tells us where packets begin and end.)
    1084          * We also keep track of the end of the ring and set the
    1085          * end-of-ring bits as needed, and we set the ownership bits
    1086          * in all except the very first descriptor. (The caller will
    1087          * set this descriptor later when it start transmission or
    1088          * reception.)
    1089          */
    1090         idx = ctx->rl_idx;
    1091         for (;;) {
    1092                 d = &ctx->rl_ring[idx];
    1093                 if (le32toh(d->rl_cmdstat) & RL_RDESC_STAT_OWN) {
    1094                         ctx->rl_maxsegs = 0;
    1095                         return;
    1096                 }
    1097                 cmdstat = segs[i].ds_len;
    1098                 totlen += segs[i].ds_len;
    1099                 d->rl_vlanctl = 0;
    1100                 d->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[i].ds_addr));
    1101                 d->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[i].ds_addr));
    1102                 if (i == 0)
    1103                         cmdstat |= RL_TDESC_CMD_SOF;
    1104                 else
    1105                         cmdstat |= RL_TDESC_CMD_OWN;
    1106                 if (idx == (RL_RX_DESC_CNT - 1))
    1107                         cmdstat |= RL_TDESC_CMD_EOR;
    1108                 d->rl_cmdstat = htole32(cmdstat | ctx->rl_flags);
    1109                 i++;
    1110                 if (i == nseg)
    1111                         break;
    1112                 RL_DESC_INC(idx);
    1113         }
    1114 
    1115         d->rl_cmdstat |= htole32(RL_TDESC_CMD_EOF);
    1116         ctx->rl_maxsegs = nseg;
    1117         ctx->rl_idx = idx;
    11181050}
    11191051
     
    11231055
    11241056static void
    1125 re_dma_map_addr(arg, segs, nseg, error)
    1126         void                    *arg;
    1127         bus_dma_segment_t       *segs;
    1128         int                     nseg;
    1129         int                     error;
     1057re_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
    11301058{
    11311059        bus_addr_t              *addr;
     
    11401068
    11411069static int
    1142 re_allocmem(dev, sc)
    1143         device_t                dev;
    1144         struct rl_softc         *sc;
    1145 {
     1070re_allocmem(device_t dev, struct rl_softc *sc)
     1071{
     1072        bus_size_t              rx_list_size, tx_list_size;
    11461073        int                     error;
    1147         int                     nseg;
    11481074        int                     i;
    11491075
     1076        rx_list_size = sc->rl_ldata.rl_rx_desc_cnt * sizeof(struct rl_desc);
     1077        tx_list_size = sc->rl_ldata.rl_tx_desc_cnt * sizeof(struct rl_desc);
     1078
     1079        /*
     1080         * Allocate the parent bus DMA tag appropriate for PCI.
     1081         * In order to use DAC, RL_CPLUSCMD_PCI_DAC bit of RL_CPLUS_CMD
     1082         * register should be set. However some RealTek chips are known
     1083         * to be buggy on DAC handling, therefore disable DAC by limiting
     1084         * DMA address space to 32bit. PCIe variants of RealTek chips
     1085         * may not have the limitation but I took safer path.
     1086         */
     1087        error = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0,
     1088            BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
     1089            BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT, 0,
     1090            NULL, NULL, &sc->rl_parent_tag);
     1091        if (error) {
     1092                device_printf(dev, "could not allocate parent DMA tag\n");
     1093                return (error);
     1094        }
     1095
     1096        /*
     1097         * Allocate map for TX mbufs.
     1098         */
     1099        error = bus_dma_tag_create(sc->rl_parent_tag, 1, 0,
     1100            BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
     1101            NULL, MCLBYTES * RL_NTXSEGS, RL_NTXSEGS, 4096, 0,
     1102            NULL, NULL, &sc->rl_ldata.rl_tx_mtag);
     1103        if (error) {
     1104                device_printf(dev, "could not allocate TX DMA tag\n");
     1105                return (error);
     1106        }
     1107
    11501108        /*
    11511109         * Allocate map for RX mbufs.
    11521110         */
    1153         nseg = 32;
    1154         error = bus_dma_tag_create(sc->rl_parent_tag, ETHER_ALIGN, 0,
    1155             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1156             NULL, MCLBYTES * nseg, nseg, MCLBYTES, BUS_DMA_ALLOCNOW,
    1157             NULL, NULL, &sc->rl_ldata.rl_mtag);
     1111
     1112        error = bus_dma_tag_create(sc->rl_parent_tag, sizeof(uint64_t), 0,
     1113            BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
     1114            MCLBYTES, 1, MCLBYTES, 0, NULL, NULL, &sc->rl_ldata.rl_rx_mtag);
    11581115        if (error) {
    1159                 device_printf(dev, "could not allocate dma tag\n");
    1160                 return (ENOMEM);
     1116                device_printf(dev, "could not allocate RX DMA tag\n");
     1117                return (error);
    11611118        }
    11621119
     
    11661123        error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
    11671124            0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1168             NULL, RL_TX_LIST_SZ, 1, RL_TX_LIST_SZ, 0,
     1125            NULL, tx_list_size, 1, tx_list_size, 0,
    11691126            NULL, NULL, &sc->rl_ldata.rl_tx_list_tag);
    11701127        if (error) {
    1171                 device_printf(dev, "could not allocate dma tag\n");
     1128                device_printf(dev, "could not allocate TX DMA ring tag\n");
     1129                return (error);
     1130        }
     1131
     1132        /* Allocate DMA'able memory for the TX ring */
     1133
     1134        error = bus_dmamem_alloc(sc->rl_ldata.rl_tx_list_tag,
     1135            (void **)&sc->rl_ldata.rl_tx_list,
     1136            BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
     1137            &sc->rl_ldata.rl_tx_list_map);
     1138        if (error) {
     1139                device_printf(dev, "could not allocate TX DMA ring\n");
     1140                return (error);
     1141        }
     1142
     1143        /* Load the map for the TX ring. */
     1144
     1145        sc->rl_ldata.rl_tx_list_addr = 0;
     1146        error = bus_dmamap_load(sc->rl_ldata.rl_tx_list_tag,
     1147             sc->rl_ldata.rl_tx_list_map, sc->rl_ldata.rl_tx_list,
     1148             tx_list_size, re_dma_map_addr,
     1149             &sc->rl_ldata.rl_tx_list_addr, BUS_DMA_NOWAIT);
     1150        if (error != 0 || sc->rl_ldata.rl_tx_list_addr == 0) {
     1151                device_printf(dev, "could not load TX DMA ring\n");
    11721152                return (ENOMEM);
    11731153        }
    11741154
    1175         /* Allocate DMA'able memory for the TX ring */
    1176 
    1177         error = bus_dmamem_alloc(sc->rl_ldata.rl_tx_list_tag,
    1178             (void **)&sc->rl_ldata.rl_tx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
    1179             &sc->rl_ldata.rl_tx_list_map);
    1180         if (error)
    1181                 return (ENOMEM);
    1182 
    1183         /* Load the map for the TX ring. */
    1184 
    1185         error = bus_dmamap_load(sc->rl_ldata.rl_tx_list_tag,
    1186              sc->rl_ldata.rl_tx_list_map, (caddr_t) sc->rl_ldata.rl_tx_list,
    1187              RL_TX_LIST_SZ, re_dma_map_addr,
    1188              &sc->rl_ldata.rl_tx_list_addr, BUS_DMA_NOWAIT);
    1189 
    11901155        /* Create DMA maps for TX buffers */
    11911156
    1192         for (i = 0; i < RL_TX_DESC_CNT; i++) {
    1193                 error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
    1194                             &sc->rl_ldata.rl_tx_dmamap[i]);
     1157        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++) {
     1158                error = bus_dmamap_create(sc->rl_ldata.rl_tx_mtag, 0,
     1159                    &sc->rl_ldata.rl_tx_desc[i].tx_dmamap);
    11951160                if (error) {
    1196                         device_printf(dev, "can't create DMA map for TX\n");
    1197                         return (ENOMEM);
     1161                        device_printf(dev, "could not create DMA map for TX\n");
     1162                        return (error);
    11981163                }
    11991164        }
     
    12041169        error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
    12051170            0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1206             NULL, RL_RX_LIST_SZ, 1, RL_RX_LIST_SZ, 0,
     1171            NULL, rx_list_size, 1, rx_list_size, 0,
    12071172            NULL, NULL, &sc->rl_ldata.rl_rx_list_tag);
    12081173        if (error) {
    1209                 device_printf(dev, "could not allocate dma tag\n");
     1174                device_printf(dev, "could not create RX DMA ring tag\n");
     1175                return (error);
     1176        }
     1177
     1178        /* Allocate DMA'able memory for the RX ring */
     1179
     1180        error = bus_dmamem_alloc(sc->rl_ldata.rl_rx_list_tag,
     1181            (void **)&sc->rl_ldata.rl_rx_list,
     1182            BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
     1183            &sc->rl_ldata.rl_rx_list_map);
     1184        if (error) {
     1185                device_printf(dev, "could not allocate RX DMA ring\n");
     1186                return (error);
     1187        }
     1188
     1189        /* Load the map for the RX ring. */
     1190
     1191        sc->rl_ldata.rl_rx_list_addr = 0;
     1192        error = bus_dmamap_load(sc->rl_ldata.rl_rx_list_tag,
     1193             sc->rl_ldata.rl_rx_list_map, sc->rl_ldata.rl_rx_list,
     1194             rx_list_size, re_dma_map_addr,
     1195             &sc->rl_ldata.rl_rx_list_addr, BUS_DMA_NOWAIT);
     1196        if (error != 0 || sc->rl_ldata.rl_rx_list_addr == 0) {
     1197                device_printf(dev, "could not load RX DMA ring\n");
    12101198                return (ENOMEM);
    12111199        }
    12121200
    1213         /* Allocate DMA'able memory for the RX ring */
    1214 
    1215         error = bus_dmamem_alloc(sc->rl_ldata.rl_rx_list_tag,
    1216             (void **)&sc->rl_ldata.rl_rx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
    1217             &sc->rl_ldata.rl_rx_list_map);
    1218         if (error)
    1219                 return (ENOMEM);
    1220 
    1221         /* Load the map for the RX ring. */
    1222 
    1223         error = bus_dmamap_load(sc->rl_ldata.rl_rx_list_tag,
    1224              sc->rl_ldata.rl_rx_list_map, (caddr_t) sc->rl_ldata.rl_rx_list,
    1225              RL_RX_LIST_SZ, re_dma_map_addr,
    1226              &sc->rl_ldata.rl_rx_list_addr, BUS_DMA_NOWAIT);
    1227 
    12281201        /* Create DMA maps for RX buffers */
    12291202
    1230         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    1231                 error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
    1232                             &sc->rl_ldata.rl_rx_dmamap[i]);
     1203        error = bus_dmamap_create(sc->rl_ldata.rl_rx_mtag, 0,
     1204            &sc->rl_ldata.rl_rx_sparemap);
     1205        if (error) {
     1206                device_printf(dev, "could not create spare DMA map for RX\n");
     1207                return (error);
     1208        }
     1209        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     1210                error = bus_dmamap_create(sc->rl_ldata.rl_rx_mtag, 0,
     1211                    &sc->rl_ldata.rl_rx_desc[i].rx_dmamap);
    12331212                if (error) {
    1234                         device_printf(dev, "can't create DMA map for RX\n");
    1235                         return (ENOMEM);
     1213                        device_printf(dev, "could not create DMA map for RX\n");
     1214                        return (error);
    12361215                }
    12371216        }
     
    12451224 */
    12461225static int
    1247 re_attach(dev)
    1248         device_t                dev;
     1226re_attach(device_t dev)
    12491227{
    12501228        u_char                  eaddr[ETHER_ADDR_LEN];
     
    12541232        struct rl_hwrev         *hw_rev;
    12551233        int                     hwrev;
    1256         u_int16_t               re_did = 0;
     1234        u_int16_t               devid, re_did = 0;
    12571235        int                     error = 0, rid, i;
     1236#ifndef __rtems__
     1237        int                     msic, reg;
     1238#else
     1239        int                     msic;
     1240#endif
     1241        uint8_t                 cfg;
    12581242
    12591243        sc = device_get_softc(dev);
     
    12691253        pci_enable_busmaster(dev);
    12701254
    1271         rid = RL_RID;
    1272         sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
    1273             RF_ACTIVE);
    1274 
     1255        devid = pci_get_device(dev);
     1256        /*
     1257         * Prefer memory space register mapping over IO space.
     1258         * Because RTL8169SC does not seem to work when memory mapping
     1259         * is used always activate io mapping.
     1260         */
     1261        if (devid == RT_DEVICEID_8169SC)
     1262                prefer_iomap = 1;
     1263        if (prefer_iomap == 0) {
     1264                sc->rl_res_id = PCIR_BAR(1);
     1265                sc->rl_res_type = SYS_RES_MEMORY;
     1266                /* RTL8168/8101E seems to use different BARs. */
     1267                if (devid == RT_DEVICEID_8168 || devid == RT_DEVICEID_8101E)
     1268                        sc->rl_res_id = PCIR_BAR(2);
     1269        } else {
     1270                sc->rl_res_id = PCIR_BAR(0);
     1271                sc->rl_res_type = SYS_RES_IOPORT;
     1272        }
     1273        sc->rl_res = bus_alloc_resource_any(dev, sc->rl_res_type,
     1274            &sc->rl_res_id, RF_ACTIVE);
     1275        if (sc->rl_res == NULL && prefer_iomap == 0) {
     1276                sc->rl_res_id = PCIR_BAR(0);
     1277                sc->rl_res_type = SYS_RES_IOPORT;
     1278                sc->rl_res = bus_alloc_resource_any(dev, sc->rl_res_type,
     1279                    &sc->rl_res_id, RF_ACTIVE);
     1280        }
    12751281        if (sc->rl_res == NULL) {
    12761282                device_printf(dev, "couldn't map ports/memory\n");
     
    12821288        sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
    12831289
     1290        msic = 0;
     1291#ifndef __rtems__
     1292        if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
     1293                sc->rl_flags |= RL_FLAG_PCIE;
     1294                msic = pci_msi_count(dev);
     1295                if (bootverbose)
     1296                        device_printf(dev, "MSI count : %d\n", msic);
     1297        }
     1298        if (msic > 0 && msi_disable == 0) {
     1299                msic = 1;
     1300                if (pci_alloc_msi(dev, &msic) == 0) {
     1301                        if (msic == RL_MSI_MESSAGES) {
     1302                                device_printf(dev, "Using %d MSI messages\n",
     1303                                    msic);
     1304                                sc->rl_flags |= RL_FLAG_MSI;
     1305                                /* Explicitly set MSI enable bit. */
     1306                                CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1307                                cfg = CSR_READ_1(sc, RL_CFG2);
     1308                                cfg |= RL_CFG2_MSI;
     1309                                CSR_WRITE_1(sc, RL_CFG2, cfg);
     1310                                CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     1311                        } else
     1312                                pci_release_msi(dev);
     1313                }
     1314        }
     1315#endif
     1316 
    12841317        /* Allocate interrupt */
    1285         rid = 0;
    1286         sc->rl_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
    1287             RF_SHAREABLE | RF_ACTIVE);
    1288 
    1289         if (sc->rl_irq == NULL) {
    1290                 device_printf(dev, "couldn't map interrupt\n");
    1291                 error = ENXIO;
    1292                 goto fail;
     1318        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1319                rid = 0;
     1320                sc->rl_irq[0] = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
     1321                    RF_SHAREABLE | RF_ACTIVE);
     1322                if (sc->rl_irq[0] == NULL) {
     1323                        device_printf(dev, "couldn't allocate IRQ resources\n");
     1324                        error = ENXIO;
     1325                        goto fail;
     1326                }
     1327        } else {
     1328                for (i = 0, rid = 1; i < RL_MSI_MESSAGES; i++, rid++) {
     1329                        sc->rl_irq[i] = bus_alloc_resource_any(dev,
     1330                            SYS_RES_IRQ, &rid, RF_ACTIVE);
     1331                        if (sc->rl_irq[i] == NULL) {
     1332                                device_printf(dev,
     1333                                    "couldn't llocate IRQ resources for "
     1334                                    "message %d\n", rid);
     1335                                error = ENXIO;
     1336                                goto fail;
     1337                        }
     1338                }
     1339        }
     1340
     1341        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1342                CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1343                cfg = CSR_READ_1(sc, RL_CFG2);
     1344                if ((cfg & RL_CFG2_MSI) != 0) {
     1345                        device_printf(dev, "turning off MSI enable bit.\n");
     1346                        cfg &= ~RL_CFG2_MSI;
     1347                        CSR_WRITE_1(sc, RL_CFG2, cfg);
     1348                }
     1349                CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
    12931350        }
    12941351
     
    12991356
    13001357        hw_rev = re_hwrevs;
    1301         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
     1358        hwrev = CSR_READ_4(sc, RL_TXCFG);
     1359        switch (hwrev & 0x70000000) {
     1360        case 0x00000000:
     1361        case 0x10000000:
     1362                device_printf(dev, "Chip rev. 0x%08x\n", hwrev & 0xfc800000);
     1363                hwrev &= (RL_TXCFG_HWREV | 0x80000000);
     1364                break;
     1365        default:
     1366                device_printf(dev, "Chip rev. 0x%08x\n", hwrev & 0x7c800000);
     1367                hwrev &= RL_TXCFG_HWREV;
     1368                break;
     1369        }
     1370        device_printf(dev, "MAC rev. 0x%08x\n", hwrev & 0x00700000);
    13021371        while (hw_rev->rl_desc != NULL) {
    13031372                if (hw_rev->rl_rev == hwrev) {
    13041373                        sc->rl_type = hw_rev->rl_type;
     1374                        sc->rl_hwrev = hw_rev->rl_rev;
    13051375                        break;
    13061376                }
    13071377                hw_rev++;
    13081378        }
    1309 
    1310         sc->rl_eewidth = RL_9356_ADDR_LEN;
    1311         re_read_eeprom(sc, (caddr_t)&re_did, 0, 1);
    1312         if (re_did != 0x8129)
    1313                 sc->rl_eewidth = RL_9346_ADDR_LEN;
    1314 
    1315         /*
    1316          * Get station address from the EEPROM.
    1317          */
    1318         re_read_eeprom(sc, (caddr_t)as, RL_EE_EADDR, 3);
    1319         for (i = 0; i < ETHER_ADDR_LEN / 2; i++)
    1320                 as[i] = le16toh(as[i]);
    1321         bcopy(as, eaddr, sizeof(eaddr));
     1379        if (hw_rev->rl_desc == NULL) {
     1380                device_printf(dev, "Unknown H/W revision: 0x%08x\n", hwrev);
     1381                error = ENXIO;
     1382                goto fail;
     1383        }
     1384
     1385        switch (hw_rev->rl_rev) {
     1386        case RL_HWREV_8139CPLUS:
     1387                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_FASTETHER |
     1388                    RL_FLAG_AUTOPAD;
     1389                break;
     1390        case RL_HWREV_8100E:
     1391        case RL_HWREV_8101E:
     1392                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_PHYWAKE |
     1393                    RL_FLAG_FASTETHER;
     1394                break;
     1395        case RL_HWREV_8102E:
     1396        case RL_HWREV_8102EL:
     1397        case RL_HWREV_8102EL_SPIN1:
     1398                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_PHYWAKE |
     1399                    RL_FLAG_PAR | RL_FLAG_DESCV2 | RL_FLAG_MACSTAT |
     1400                    RL_FLAG_FASTETHER | RL_FLAG_CMDSTOP | RL_FLAG_AUTOPAD;
     1401                break;
     1402        case RL_HWREV_8168_SPIN1:
     1403        case RL_HWREV_8168_SPIN2:
     1404                sc->rl_flags |= RL_FLAG_WOLRXENB;
     1405                /* FALLTHROUGH */
     1406        case RL_HWREV_8168_SPIN3:
     1407                sc->rl_flags |= RL_FLAG_PHYWAKE | RL_FLAG_MACSTAT;
     1408                break;
     1409        case RL_HWREV_8168C_SPIN2:
     1410                sc->rl_flags |= RL_FLAG_MACSLEEP;
     1411                /* FALLTHROUGH */
     1412        case RL_HWREV_8168C:
     1413                if ((hwrev & 0x00700000) == 0x00200000)
     1414                        sc->rl_flags |= RL_FLAG_MACSLEEP;
     1415                /* FALLTHROUGH */
     1416        case RL_HWREV_8168CP:
     1417        case RL_HWREV_8168D:
     1418        case RL_HWREV_8168DP:
     1419                sc->rl_flags |= RL_FLAG_PHYWAKE | RL_FLAG_PAR |
     1420                    RL_FLAG_DESCV2 | RL_FLAG_MACSTAT | RL_FLAG_CMDSTOP |
     1421                    RL_FLAG_AUTOPAD;
     1422                /*
     1423                 * These controllers support jumbo frame but it seems
     1424                 * that enabling it requires touching additional magic
     1425                 * registers. Depending on MAC revisions some
     1426                 * controllers need to disable checksum offload. So
     1427                 * disable jumbo frame until I have better idea what
     1428                 * it really requires to make it support.
     1429                 * RTL8168C/CP : supports up to 6KB jumbo frame.
     1430                 * RTL8111C/CP : supports up to 9KB jumbo frame.
     1431                 */
     1432                sc->rl_flags |= RL_FLAG_NOJUMBO;
     1433                break;
     1434        case RL_HWREV_8169_8110SB:
     1435        case RL_HWREV_8169_8110SBL:
     1436        case RL_HWREV_8169_8110SC:
     1437        case RL_HWREV_8169_8110SCE:
     1438                sc->rl_flags |= RL_FLAG_PHYWAKE;
     1439                /* FALLTHROUGH */
     1440        case RL_HWREV_8169:
     1441        case RL_HWREV_8169S:
     1442        case RL_HWREV_8110S:
     1443                sc->rl_flags |= RL_FLAG_MACRESET;
     1444                break;
     1445        default:
     1446                break;
     1447        }
     1448
     1449        /* Enable PME. */
     1450        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1451        cfg = CSR_READ_1(sc, RL_CFG1);
     1452        cfg |= RL_CFG1_PME;
     1453        CSR_WRITE_1(sc, RL_CFG1, cfg);
     1454        cfg = CSR_READ_1(sc, RL_CFG5);
     1455        cfg &= RL_CFG5_PME_STS;
     1456        CSR_WRITE_1(sc, RL_CFG5, cfg);
     1457        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     1458
     1459        if ((sc->rl_flags & RL_FLAG_PAR) != 0) {
     1460                /*
     1461                 * XXX Should have a better way to extract station
     1462                 * address from EEPROM.
     1463                 */
     1464                for (i = 0; i < ETHER_ADDR_LEN; i++)
     1465                        eaddr[i] = CSR_READ_1(sc, RL_IDR0 + i);
     1466        } else {
     1467                sc->rl_eewidth = RL_9356_ADDR_LEN;
     1468                re_read_eeprom(sc, (caddr_t)&re_did, 0, 1);
     1469                if (re_did != 0x8129)
     1470                        sc->rl_eewidth = RL_9346_ADDR_LEN;
     1471
     1472                /*
     1473                 * Get station address from the EEPROM.
     1474                 */
     1475                re_read_eeprom(sc, (caddr_t)as, RL_EE_EADDR, 3);
     1476                for (i = 0; i < ETHER_ADDR_LEN / 2; i++)
     1477                        as[i] = le16toh(as[i]);
     1478                bcopy(as, eaddr, sizeof(eaddr));
     1479        }
    13221480
    13231481        if (sc->rl_type == RL_8169) {
    1324                 /* Set RX length mask */
     1482                /* Set RX length mask and number of descriptors. */
    13251483                sc->rl_rxlenmask = RL_RDESC_STAT_GFRAGLEN;
    13261484                sc->rl_txstart = RL_GTXSTART;
     1485                sc->rl_ldata.rl_tx_desc_cnt = RL_8169_TX_DESC_CNT;
     1486                sc->rl_ldata.rl_rx_desc_cnt = RL_8169_RX_DESC_CNT;
    13271487        } else {
    1328                 /* Set RX length mask */
     1488                /* Set RX length mask and number of descriptors. */
    13291489                sc->rl_rxlenmask = RL_RDESC_STAT_FRAGLEN;
    13301490                sc->rl_txstart = RL_TXSTART;
    1331         }
    1332 
    1333         /*
    1334          * Allocate the parent bus DMA tag appropriate for PCI.
    1335          */
    1336 #define RL_NSEG_NEW 32
    1337         error = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0,
    1338             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
    1339             MAXBSIZE, RL_NSEG_NEW, BUS_SPACE_MAXSIZE_32BIT, 0,
    1340             NULL, NULL, &sc->rl_parent_tag);
    1341         if (error)
    1342                 goto fail;
     1491                sc->rl_ldata.rl_tx_desc_cnt = RL_8139_TX_DESC_CNT;
     1492                sc->rl_ldata.rl_rx_desc_cnt = RL_8139_RX_DESC_CNT;
     1493        }
    13431494
    13441495        error = re_allocmem(dev, sc);
    1345 
    13461496        if (error)
    13471497                goto fail;
     
    13541504        }
    13551505
     1506        /* Take controller out of deep sleep mode. */
     1507        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     1508                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     1509                        CSR_WRITE_1(sc, RL_GPIO,
     1510                            CSR_READ_1(sc, RL_GPIO) | 0x01);
     1511                else
     1512                        CSR_WRITE_1(sc, RL_GPIO,
     1513                            CSR_READ_1(sc, RL_GPIO) & ~0x01);
     1514        }
     1515
     1516        /* Take PHY out of power down mode. */
     1517        if ((sc->rl_flags & RL_FLAG_PHYWAKE) != 0) {
     1518                re_gmii_writereg(dev, 1, 0x1f, 0);
     1519                re_gmii_writereg(dev, 1, 0x0e, 0);
     1520        }
     1521
    13561522        /* Do MII setup */
    13571523#ifndef __rtems__
     
    13641530#endif
    13651531
    1366         /* Take PHY out of power down mode. */
    1367         if (sc->rl_type == RL_8169) {
    1368                 uint32_t rev;
    1369 
    1370                 rev = CSR_READ_4(sc, RL_TXCFG);
    1371                 /* HWVERID 0, 1 and 2 :  bit26-30, bit23 */
    1372                 rev &= 0x7c800000;
    1373                 if (rev != 0) {
    1374                         /* RTL8169S single chip */
    1375                         switch (rev) {
    1376                         case RL_HWREV_8169_8110SB:
    1377                         case RL_HWREV_8169_8110SC:
    1378                         case RL_HWREV_8168_SPIN2:
    1379                         case RL_HWREV_8168_SPIN3:
    1380                                 re_gmii_writereg(dev, 1, 0x1f, 0);
    1381                                 re_gmii_writereg(dev, 1, 0x0e, 0);
    1382                                 break;
    1383                         default:
    1384                                 break;
    1385                         }
    1386                 }
    1387         }
    1388 
    13891532        ifp->if_softc = sc;
    13901533        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
     
    14051548        TASK_INIT(&sc->rl_inttask, 0, re_int_task, sc);
    14061549
     1550#ifdef __rtems__
     1551        taskqueue_create_fast("re_taskq", M_NOWAIT,
     1552            taskqueue_thread_enqueue, &taskqueue_fast);
     1553        taskqueue_start_threads(&taskqueue_fast, 1, PI_NET, "%s taskq",
     1554            device_get_nameunit(dev));
     1555#endif
     1556
     1557        /*
     1558         * XXX
     1559         * Still have no idea how to make TSO work on 8168C, 8168CP,
     1560         * 8111C and 8111CP.
     1561         */
     1562#ifndef __rtems__
     1563        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     1564                ifp->if_hwassist |= CSUM_TSO;
     1565                ifp->if_capabilities |= IFCAP_TSO4;
     1566        }
     1567#endif
     1568 
    14071569        /*
    14081570         * Call MI attach routine.
     
    14131575        /* VLAN capability setup */
    14141576        ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING;
    1415 #ifdef IFCAP_VLAN_HWCSUM
    14161577        if (ifp->if_capabilities & IFCAP_HWCSUM)
    14171578                ifp->if_capabilities |= IFCAP_VLAN_HWCSUM;
    1418 #endif
     1579        /* Enable WOL if PM is supported. */
     1580        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &reg) == 0)
     1581                ifp->if_capabilities |= IFCAP_WOL;
    14191582        ifp->if_capenable = ifp->if_capabilities;
     1583        /*
     1584         * Don't enable TSO by default. Under certain
     1585         * circumtances the controller generated corrupted
     1586         * packets in TSO size.
     1587         */
     1588        ifp->if_hwassist &= ~CSUM_TSO;
     1589        ifp->if_capenable &= ~IFCAP_TSO4;
    14201590#ifdef DEVICE_POLLING
    14211591        ifp->if_capabilities |= IFCAP_POLLING;
     
    14281598        ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
    14291599#endif
    1430 
     1600 
    14311601#ifdef RE_DIAG
    14321602        /*
     
    14481618
    14491619        /* Hook interrupt last to avoid having to lock softc */
    1450         error = bus_setup_intr(dev, sc->rl_irq, INTR_TYPE_NET | INTR_MPSAFE |
    1451             INTR_FAST, NULL, re_intr, sc, &sc->rl_intrhand);
     1620        if ((sc->rl_flags & RL_FLAG_MSI) == 0)
     1621                error = bus_setup_intr(dev, sc->rl_irq[0],
     1622                    INTR_TYPE_NET | INTR_MPSAFE, re_intr, NULL, sc,
     1623                    &sc->rl_intrhand[0]);
     1624        else {
     1625                for (i = 0; i < RL_MSI_MESSAGES; i++) {
     1626                        error = bus_setup_intr(dev, sc->rl_irq[i],
     1627                            INTR_TYPE_NET | INTR_MPSAFE, re_intr, NULL, sc,
     1628                            &sc->rl_intrhand[i]);
     1629                        if (error != 0)
     1630                                break;
     1631                }
     1632        }
    14521633        if (error) {
    14531634                device_printf(dev, "couldn't set up irq\n");
     
    14711652 */
    14721653static int
    1473 re_detach(dev)
    1474         device_t                dev;
     1654re_detach(device_t dev)
    14751655{
    14761656        struct rl_softc         *sc;
    14771657        struct ifnet            *ifp;
    1478         int                     i;
     1658        int                     i, rid;
    14791659
    14801660        sc = device_get_softc(dev);
     
    14821662        KASSERT(mtx_initialized(&sc->rl_mtx), ("re mutex not initialized"));
    14831663
    1484 #ifdef DEVICE_POLLING
    1485         if (ifp->if_capenable & IFCAP_POLLING)
    1486                 ether_poll_deregister(ifp);
    1487 #endif
    14881664        /* These should only be active if attach succeeded */
    14891665        if (device_is_attached(dev)) {
     1666#ifdef DEVICE_POLLING
     1667                if (ifp->if_capenable & IFCAP_POLLING)
     1668                        ether_poll_deregister(ifp);
     1669#endif
    14901670                RL_LOCK(sc);
    14911671#if 0
     
    15211701         */
    15221702
    1523         if (sc->rl_intrhand)
    1524                 bus_teardown_intr(dev, sc->rl_irq, sc->rl_intrhand);
     1703        for (i = 0; i < RL_MSI_MESSAGES; i++) {
     1704                if (sc->rl_intrhand[i] != NULL) {
     1705                        bus_teardown_intr(dev, sc->rl_irq[i],
     1706                            sc->rl_intrhand[i]);
     1707                        sc->rl_intrhand[i] = NULL;
     1708                }
     1709        }
    15251710        if (ifp != NULL)
    15261711                if_free(ifp);
    1527         if (sc->rl_irq)
    1528                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->rl_irq);
     1712        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1713                if (sc->rl_irq[0] != NULL) {
     1714                        bus_release_resource(dev, SYS_RES_IRQ, 0,
     1715                            sc->rl_irq[0]);
     1716                        sc->rl_irq[0] = NULL;
     1717                }
     1718        } else {
     1719                for (i = 0, rid = 1; i < RL_MSI_MESSAGES; i++, rid++) {
     1720                        if (sc->rl_irq[i] != NULL) {
     1721                                bus_release_resource(dev, SYS_RES_IRQ, rid,
     1722                                    sc->rl_irq[i]);
     1723                                sc->rl_irq[i] = NULL;
     1724                        }
     1725                }
     1726                pci_release_msi(dev);
     1727        }
    15291728        if (sc->rl_res)
    1530                 bus_release_resource(dev, RL_RES, RL_RID, sc->rl_res);
     1729                bus_release_resource(dev, sc->rl_res_type, sc->rl_res_id,
     1730                    sc->rl_res);
    15311731
    15321732        /* Unload and free the RX DMA ring memory and map */
     
    15541754        /* Destroy all the RX and TX buffer maps */
    15551755
    1556         if (sc->rl_ldata.rl_mtag) {
    1557                 for (i = 0; i < RL_TX_DESC_CNT; i++)
    1558                         bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
    1559                             sc->rl_ldata.rl_tx_dmamap[i]);
    1560                 for (i = 0; i < RL_RX_DESC_CNT; i++)
    1561                         bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
    1562                             sc->rl_ldata.rl_rx_dmamap[i]);
    1563                 bus_dma_tag_destroy(sc->rl_ldata.rl_mtag);
     1756        if (sc->rl_ldata.rl_tx_mtag) {
     1757                for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++)
     1758                        bus_dmamap_destroy(sc->rl_ldata.rl_tx_mtag,
     1759                            sc->rl_ldata.rl_tx_desc[i].tx_dmamap);
     1760                bus_dma_tag_destroy(sc->rl_ldata.rl_tx_mtag);
     1761        }
     1762        if (sc->rl_ldata.rl_rx_mtag) {
     1763                for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++)
     1764                        bus_dmamap_destroy(sc->rl_ldata.rl_rx_mtag,
     1765                            sc->rl_ldata.rl_rx_desc[i].rx_dmamap);
     1766                if (sc->rl_ldata.rl_rx_sparemap)
     1767                        bus_dmamap_destroy(sc->rl_ldata.rl_rx_mtag,
     1768                            sc->rl_ldata.rl_rx_sparemap);
     1769                bus_dma_tag_destroy(sc->rl_ldata.rl_rx_mtag);
    15641770        }
    15651771
     
    15831789}
    15841790
     1791static __inline void
     1792re_discard_rxbuf(struct rl_softc *sc, int idx)
     1793{
     1794        struct rl_desc          *desc;
     1795        struct rl_rxdesc        *rxd;
     1796        uint32_t                cmdstat;
     1797
     1798        rxd = &sc->rl_ldata.rl_rx_desc[idx];
     1799        desc = &sc->rl_ldata.rl_rx_list[idx];
     1800        desc->rl_vlanctl = 0;
     1801        cmdstat = rxd->rx_size;
     1802        if (idx == sc->rl_ldata.rl_rx_desc_cnt - 1)
     1803                cmdstat |= RL_RDESC_CMD_EOR;
     1804        desc->rl_cmdstat = htole32(cmdstat | RL_RDESC_CMD_OWN);
     1805}
     1806
    15851807static int
    1586 re_newbuf(sc, idx, m)
    1587         struct rl_softc         *sc;
    1588         int                     idx;
     1808re_newbuf(struct rl_softc *sc, int idx)
     1809{
    15891810        struct mbuf             *m;
    1590 {
    1591         struct rl_dmaload_arg   arg;
    1592         struct mbuf             *n = NULL;
    1593         int                     error;
    1594 
    1595         if (m == NULL) {
    1596                 n = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
    1597                 if (n == NULL)
    1598                         return (ENOBUFS);
    1599                 m = n;
    1600         } else
    1601                 m->m_data = m->m_ext.ext_buf;
     1811        struct rl_rxdesc        *rxd;
     1812        bus_dma_segment_t       segs[1];
     1813        bus_dmamap_t            map;
     1814        struct rl_desc          *desc;
     1815        uint32_t                cmdstat;
     1816        int                     error, nsegs;
     1817
     1818        m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
     1819        if (m == NULL)
     1820                return (ENOBUFS);
    16021821
    16031822        m->m_len = m->m_pkthdr.len = MCLBYTES;
     
    16151834        m_adj(m, RE_ETHER_ALIGN);
    16161835#endif
    1617         arg.rl_idx = idx;
    1618         arg.rl_maxsegs = 1;
    1619         arg.rl_flags = 0;
    1620         arg.rl_ring = sc->rl_ldata.rl_rx_list;
    1621 
    1622         error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag,
    1623             sc->rl_ldata.rl_rx_dmamap[idx], m, re_dma_map_desc,
    1624             &arg, BUS_DMA_NOWAIT);
    1625         if (error || arg.rl_maxsegs != 1) {
    1626                 if (n != NULL)
    1627                         m_freem(n);
    1628                 if (arg.rl_maxsegs == 0)
    1629                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1630                             sc->rl_ldata.rl_rx_dmamap[idx]);
    1631                 return (ENOMEM);
    1632         }
    1633 
    1634         sc->rl_ldata.rl_rx_list[idx].rl_cmdstat |= htole32(RL_RDESC_CMD_OWN);
    1635         sc->rl_ldata.rl_rx_mbuf[idx] = m;
    1636 
    1637         bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    1638             sc->rl_ldata.rl_rx_dmamap[idx],
     1836        error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_rx_mtag,
     1837            sc->rl_ldata.rl_rx_sparemap, m, segs, &nsegs, BUS_DMA_NOWAIT);
     1838        if (error != 0) {
     1839                m_freem(m);
     1840                return (ENOBUFS);
     1841        }
     1842        KASSERT(nsegs == 1, ("%s: %d segment returned!", __func__, nsegs));
     1843
     1844        rxd = &sc->rl_ldata.rl_rx_desc[idx];
     1845        if (rxd->rx_m != NULL) {
     1846                bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap,
     1847                    BUS_DMASYNC_POSTREAD);
     1848                bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap);
     1849        }
     1850
     1851        rxd->rx_m = m;
     1852        map = rxd->rx_dmamap;
     1853        rxd->rx_dmamap = sc->rl_ldata.rl_rx_sparemap;
     1854        rxd->rx_size = segs[0].ds_len;
     1855        sc->rl_ldata.rl_rx_sparemap = map;
     1856        bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap,
    16391857            BUS_DMASYNC_PREREAD);
     1858
     1859        desc = &sc->rl_ldata.rl_rx_list[idx];
     1860        desc->rl_vlanctl = 0;
     1861        desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[0].ds_addr));
     1862        desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[0].ds_addr));
     1863        cmdstat = segs[0].ds_len;
     1864        if (idx == sc->rl_ldata.rl_rx_desc_cnt - 1)
     1865                cmdstat |= RL_RDESC_CMD_EOR;
     1866        desc->rl_cmdstat = htole32(cmdstat | RL_RDESC_CMD_OWN);
    16401867
    16411868        return (0);
     
    16441871#ifdef RE_FIXUP_RX
    16451872static __inline void
    1646 re_fixup_rx(m)
    1647         struct mbuf             *m;
     1873re_fixup_rx(struct mbuf *m)
    16481874{
    16491875        int                     i;
     
    16571883
    16581884        m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
    1659 
    1660         return;
    16611885}
    16621886#endif
    16631887
    16641888static int
    1665 re_tx_list_init(sc)
    1666         struct rl_softc         *sc;
    1667 {
     1889re_tx_list_init(struct rl_softc *sc)
     1890{
     1891        struct rl_desc          *desc;
     1892        int                     i;
    16681893
    16691894        RL_LOCK_ASSERT(sc);
    16701895
    1671         bzero ((char *)sc->rl_ldata.rl_tx_list, RL_TX_LIST_SZ);
    1672         bzero ((char *)&sc->rl_ldata.rl_tx_mbuf,
    1673             (RL_TX_DESC_CNT * sizeof(struct mbuf *)));
     1896        bzero(sc->rl_ldata.rl_tx_list,
     1897            sc->rl_ldata.rl_tx_desc_cnt * sizeof(struct rl_desc));
     1898        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++)
     1899                sc->rl_ldata.rl_tx_desc[i].tx_m = NULL;
     1900        /* Set EOR. */
     1901        desc = &sc->rl_ldata.rl_tx_list[sc->rl_ldata.rl_tx_desc_cnt - 1];
     1902        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_EOR);
    16741903
    16751904        bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
    1676             sc->rl_ldata.rl_tx_list_map, BUS_DMASYNC_PREWRITE);
     1905            sc->rl_ldata.rl_tx_list_map,
     1906            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
     1907
    16771908        sc->rl_ldata.rl_tx_prodidx = 0;
    16781909        sc->rl_ldata.rl_tx_considx = 0;
    1679         sc->rl_ldata.rl_tx_free = RL_TX_DESC_CNT;
     1910        sc->rl_ldata.rl_tx_free = sc->rl_ldata.rl_tx_desc_cnt;
    16801911
    16811912        return (0);
     
    16831914
    16841915static int
    1685 re_rx_list_init(sc)
    1686         struct rl_softc         *sc;
    1687 {
    1688         int                     i;
    1689 
    1690         bzero ((char *)sc->rl_ldata.rl_rx_list, RL_RX_LIST_SZ);
    1691         bzero ((char *)&sc->rl_ldata.rl_rx_mbuf,
    1692             (RL_RX_DESC_CNT * sizeof(struct mbuf *)));
    1693 
    1694         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    1695                 if (re_newbuf(sc, i, NULL) == ENOBUFS)
    1696                         return (ENOBUFS);
     1916re_rx_list_init(struct rl_softc *sc)
     1917{
     1918        int                     error, i;
     1919
     1920        bzero(sc->rl_ldata.rl_rx_list,
     1921            sc->rl_ldata.rl_rx_desc_cnt * sizeof(struct rl_desc));
     1922        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     1923                sc->rl_ldata.rl_rx_desc[i].rx_m = NULL;
     1924                if ((error = re_newbuf(sc, i)) != 0)
     1925                        return (error);
    16971926        }
    16981927
     
    17151944 */
    17161945static int
    1717 re_rxeof(sc)
    1718         struct rl_softc         *sc;
     1946re_rxeof(struct rl_softc *sc, int *rx_npktsp)
    17191947{
    17201948        struct mbuf             *m;
     
    17231951        struct rl_desc          *cur_rx;
    17241952        u_int32_t               rxstat, rxvlan;
    1725         int                     maxpkt = 16;
     1953        int                     maxpkt = 16, rx_npkts = 0;
    17261954
    17271955        RL_LOCK_ASSERT(sc);
    17281956
    17291957        ifp = sc->rl_ifp;
    1730         i = sc->rl_ldata.rl_rx_prodidx;
    17311958
    17321959        /* Invalidate the descriptor memory */
     
    17341961        bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
    17351962            sc->rl_ldata.rl_rx_list_map,
    1736             BUS_DMASYNC_POSTREAD);
    1737 
    1738         while (!RL_OWN(&sc->rl_ldata.rl_rx_list[i]) && maxpkt) {
     1963            BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
     1964
     1965        for (i = sc->rl_ldata.rl_rx_prodidx; maxpkt > 0;
     1966            i = RL_RX_DESC_NXT(sc, i)) {
    17391967                cur_rx = &sc->rl_ldata.rl_rx_list[i];
    1740                 m = sc->rl_ldata.rl_rx_mbuf[i];
    1741                 total_len = RL_RXBYTES(cur_rx);
    17421968                rxstat = le32toh(cur_rx->rl_cmdstat);
     1969                if ((rxstat & RL_RDESC_STAT_OWN) != 0)
     1970                        break;
     1971                total_len = rxstat & sc->rl_rxlenmask;
    17431972                rxvlan = le32toh(cur_rx->rl_vlanctl);
    1744 
    1745                 /* Invalidate the RX mbuf and unload its map */
    1746 
    1747                 bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    1748                     sc->rl_ldata.rl_rx_dmamap[i],
    1749                     BUS_DMASYNC_POSTWRITE);
    1750                 bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1751                     sc->rl_ldata.rl_rx_dmamap[i]);
     1973                m = sc->rl_ldata.rl_rx_desc[i].rx_m;
    17521974
    17531975                if (!(rxstat & RL_RDESC_STAT_EOF)) {
     1976                        if (re_newbuf(sc, i) != 0) {
     1977                                /*
     1978                                 * If this is part of a multi-fragment packet,
     1979                                 * discard all the pieces.
     1980                                 */
     1981                                if (sc->rl_head != NULL) {
     1982                                        m_freem(sc->rl_head);
     1983                                        sc->rl_head = sc->rl_tail = NULL;
     1984                                }
     1985                                re_discard_rxbuf(sc, i);
     1986                                continue;
     1987                        }
    17541988                        m->m_len = RE_RX_DESC_BUFLEN;
    17551989                        if (sc->rl_head == NULL)
     
    17601994                                sc->rl_tail = m;
    17611995                        }
    1762                         re_newbuf(sc, i, NULL);
    1763                         RL_DESC_INC(i);
    17641996                        continue;
    17651997                }
     
    17992031                                sc->rl_head = sc->rl_tail = NULL;
    18002032                        }
    1801                         re_newbuf(sc, i, m);
    1802                         RL_DESC_INC(i);
     2033                        re_discard_rxbuf(sc, i);
    18032034                        continue;
    18042035                }
     
    18092040                 */
    18102041
    1811                 if (re_newbuf(sc, i, NULL)) {
    1812                         ifp->if_ierrors++;
     2042                if (re_newbuf(sc, i) != 0) {
     2043                        ifp->if_iqdrops++;
    18132044                        if (sc->rl_head != NULL) {
    18142045                                m_freem(sc->rl_head);
    18152046                                sc->rl_head = sc->rl_tail = NULL;
    18162047                        }
    1817                         re_newbuf(sc, i, m);
    1818                         RL_DESC_INC(i);
     2048                        re_discard_rxbuf(sc, i);
    18192049                        continue;
    18202050                }
    1821 
    1822                 RL_DESC_INC(i);
    18232051
    18242052                if (sc->rl_head != NULL) {
     
    18582086#ifndef __rtems__
    18592087                if (ifp->if_capenable & IFCAP_RXCSUM) {
    1860 
    1861                         /* Check IP header checksum */
    1862                         if (rxstat & RL_RDESC_STAT_PROTOID)
    1863                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
    1864                         if (!(rxstat & RL_RDESC_STAT_IPSUMBAD))
    1865                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
    1866 
    1867                         /* Check TCP/UDP checksum */
    1868                         if ((RL_TCPPKT(rxstat) &&
    1869                             !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
    1870                             (RL_UDPPKT(rxstat) &&
    1871                             !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
    1872                                 m->m_pkthdr.csum_flags |=
    1873                                     CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
    1874                                 m->m_pkthdr.csum_data = 0xffff;
     2088                        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     2089                                /* Check IP header checksum */
     2090                                if (rxstat & RL_RDESC_STAT_PROTOID)
     2091                                        m->m_pkthdr.csum_flags |=
     2092                                            CSUM_IP_CHECKED;
     2093                                if (!(rxstat & RL_RDESC_STAT_IPSUMBAD))
     2094                                        m->m_pkthdr.csum_flags |=
     2095                                            CSUM_IP_VALID;
     2096
     2097                                /* Check TCP/UDP checksum */
     2098                                if ((RL_TCPPKT(rxstat) &&
     2099                                    !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
     2100                                    (RL_UDPPKT(rxstat) &&
     2101                                     !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
     2102                                        m->m_pkthdr.csum_flags |=
     2103                                                CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
     2104                                        m->m_pkthdr.csum_data = 0xffff;
     2105                                }
     2106                        } else {
     2107                                /*
     2108                                 * RTL8168C/RTL816CP/RTL8111C/RTL8111CP
     2109                                 */
     2110                                if ((rxstat & RL_RDESC_STAT_PROTOID) &&
     2111                                    (rxvlan & RL_RDESC_IPV4))
     2112                                        m->m_pkthdr.csum_flags |=
     2113                                            CSUM_IP_CHECKED;
     2114                                if (!(rxstat & RL_RDESC_STAT_IPSUMBAD) &&
     2115                                    (rxvlan & RL_RDESC_IPV4))
     2116                                        m->m_pkthdr.csum_flags |=
     2117                                            CSUM_IP_VALID;
     2118                                if (((rxstat & RL_RDESC_STAT_TCP) &&
     2119                                    !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
     2120                                    ((rxstat & RL_RDESC_STAT_UDP) &&
     2121                                    !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
     2122                                        m->m_pkthdr.csum_flags |=
     2123                                                CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
     2124                                        m->m_pkthdr.csum_data = 0xffff;
     2125                                }
    18752126                        }
    18762127                }
     
    18792130#ifndef __rtems__
    18802131                if (rxvlan & RL_RDESC_VLANCTL_TAG) {
    1881                         VLAN_INPUT_TAG_NEW(ifp, m,
    1882                             ntohs((rxvlan & RL_RDESC_VLANCTL_DATA)));
    1883                         if (m == NULL)
    1884                                 continue;
     2132                        m->m_pkthdr.ether_vtag =
     2133                            bswap16((rxvlan & RL_RDESC_VLANCTL_DATA));
     2134                        m->m_flags |= M_VLANTAG;
    18852135                }
    18862136#endif
     
    18922142#endif
    18932143                RL_LOCK(sc);
     2144                rx_npkts++;
    18942145        }
    18952146
     
    19022153        sc->rl_ldata.rl_rx_prodidx = i;
    19032154
     2155        if (rx_npktsp != NULL)
     2156                *rx_npktsp = rx_npkts;
    19042157        if (maxpkt)
    19052158                return(EAGAIN);
     
    19092162
    19102163static void
    1911 re_txeof(sc)
    1912         struct rl_softc         *sc;
     2164re_txeof(struct rl_softc *sc)
    19132165{
    19142166        struct ifnet            *ifp;
     2167        struct rl_txdesc        *txd;
    19152168        u_int32_t               txstat;
    1916         int                     idx;
     2169        int                     cons;
     2170
     2171        cons = sc->rl_ldata.rl_tx_considx;
     2172        if (cons == sc->rl_ldata.rl_tx_prodidx)
     2173                return;
    19172174
    19182175        ifp = sc->rl_ifp;
    1919         idx = sc->rl_ldata.rl_tx_considx;
    1920 
    19212176        /* Invalidate the TX descriptor list */
    19222177        bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
    19232178            sc->rl_ldata.rl_tx_list_map,
    1924             BUS_DMASYNC_POSTREAD);
    1925 
    1926         while (sc->rl_ldata.rl_tx_free < RL_TX_DESC_CNT) {
    1927                 txstat = le32toh(sc->rl_ldata.rl_tx_list[idx].rl_cmdstat);
    1928                 if (txstat & RL_TDESC_CMD_OWN)
     2179            BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
     2180
     2181        for (; cons != sc->rl_ldata.rl_tx_prodidx;
     2182            cons = RL_TX_DESC_NXT(sc, cons)) {
     2183                txstat = le32toh(sc->rl_ldata.rl_tx_list[cons].rl_cmdstat);
     2184                if (txstat & RL_TDESC_STAT_OWN)
    19292185                        break;
    1930 
    1931                 sc->rl_ldata.rl_tx_list[idx].rl_bufaddr_lo = 0;
    1932 
    19332186                /*
    19342187                 * We only stash mbufs in the last descriptor
     
    19382191                 */
    19392192                if (txstat & RL_TDESC_CMD_EOF) {
    1940                         m_freem(sc->rl_ldata.rl_tx_mbuf[idx]);
    1941                         sc->rl_ldata.rl_tx_mbuf[idx] = NULL;
    1942                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1943                             sc->rl_ldata.rl_tx_dmamap[idx]);
     2193                        txd = &sc->rl_ldata.rl_tx_desc[cons];
     2194                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     2195                            txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
     2196                        bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag,
     2197                            txd->tx_dmamap);
     2198                        KASSERT(txd->tx_m != NULL,
     2199                            ("%s: freeing NULL mbufs!", __func__));
     2200                        m_freem(txd->tx_m);
     2201                        txd->tx_m = NULL;
    19442202                        if (txstat & (RL_TDESC_STAT_EXCESSCOL|
    19452203                            RL_TDESC_STAT_COLCNT))
     
    19512209                }
    19522210                sc->rl_ldata.rl_tx_free++;
    1953                 RL_DESC_INC(idx);
    1954         }
    1955         sc->rl_ldata.rl_tx_considx = idx;
     2211                ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
     2212        }
     2213        sc->rl_ldata.rl_tx_considx = cons;
    19562214
    19572215        /* No changes made to the TX ring, so no flush needed */
    19582216
    1959         if (sc->rl_ldata.rl_tx_free > RL_TX_DESC_THLD)
    1960                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    1961 
    1962         if (sc->rl_ldata.rl_tx_free < RL_TX_DESC_CNT) {
    1963                 /*
    1964                  * Some chips will ignore a second TX request issued
    1965                  * while an existing transmission is in progress. If
    1966                  * the transmitter goes idle but there are still
    1967                  * packets waiting to be sent, we need to restart the
    1968                  * channel here to flush them out. This only seems to
    1969                  * be required with the PCIe devices.
    1970                  */
    1971                 CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
    1972 
     2217        if (sc->rl_ldata.rl_tx_free != sc->rl_ldata.rl_tx_desc_cnt) {
    19732218#ifdef RE_TX_MODERATION
    19742219                /*
     
    19852230
    19862231static void
    1987 re_tick(xsc)
    1988         void                    *xsc;
     2232re_tick(void *xsc)
    19892233{
    19902234        struct rl_softc         *sc;
    19912235        struct mii_data         *mii;
    1992         struct ifnet            *ifp;
    19932236
    19942237        sc = xsc;
    1995         ifp = sc->rl_ifp;
    19962238
    19972239        RL_LOCK_ASSERT(sc);
    19982240
     2241        mii = device_get_softc(sc->rl_miibus);
     2242#ifndef __rtems__
     2243        mii_tick(mii);
     2244        if ((sc->rl_flags & RL_FLAG_LINK) == 0)
     2245                re_miibus_statchg(sc->rl_dev);
     2246#else
     2247        {
     2248        struct ifnet *ifp;
     2249        int med, err;
     2250
     2251  ifp = sc->rl_ifp;
     2252 
     2253        med = IFM_MAKEWORD(0,0,0,0);
     2254
     2255        if ( (err = rtems_mii_ioctl( RE_MDIO(sc), sc, SIOCGIFMEDIA, &med)) ) {
     2256                device_printf(sc->rl_dev, "WARNING: mii ioctl failed; unable to determine link status -- fake ON\n");
     2257                med = IFM_LINK_OK;
     2258        }
     2259
     2260        /* link just died */
     2261        if ( (sc->rl_flags & RL_FLAG_LINK) & !(IFM_LINK_OK & med) ) {
     2262                sc->rl_flags &= ~RL_FLAG_LINK;
     2263        }
     2264
     2265        /* link just came up, restart */
     2266        if ( ((sc->rl_flags & RL_FLAG_LINK) == 0)  && (IFM_LINK_OK & med) ) {
     2267                sc->rl_flags |= RL_FLAG_LINK;
     2268                if ( ifp->if_snd.ifq_head != NULL ) {
     2269                        taskqueue_enqueue_fast(taskqueue_fast,
     2270                            &sc->rl_txtask);
     2271                }
     2272        }
     2273        }
     2274#endif
     2275        /*
     2276         * Reclaim transmitted frames here. Technically it is not
     2277         * necessary to do here but it ensures periodic reclamation
     2278         * regardless of Tx completion interrupt which seems to be
     2279         * lost on PCIe based controllers under certain situations.
     2280         */
     2281        re_txeof(sc);
    19992282        re_watchdog(sc);
    2000 
    2001         mii = device_get_softc(sc->rl_miibus);
    2002 #ifndef __rtems__
    2003         mii_tick(mii);
    2004         if (sc->rl_link) {
    2005                 if (!(mii->mii_media_status & IFM_ACTIVE))
    2006                         sc->rl_link = 0;
    2007         } else {
    2008                 if (mii->mii_media_status & IFM_ACTIVE &&
    2009                     IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
    2010                         sc->rl_link = 1;
    2011                         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
    2012                                 taskqueue_enqueue_fast(taskqueue_fast,
    2013                                     &sc->rl_txtask);
    2014                 }
    2015         }
    2016 
    2017 #endif
    20182283        callout_reset(&sc->rl_stat_callout, hz, re_tick, sc);
    20192284}
    20202285
    20212286#ifdef DEVICE_POLLING
    2022 static void
     2287static int
    20232288re_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
    20242289{
    20252290        struct rl_softc *sc = ifp->if_softc;
     2291        int rx_npkts = 0;
    20262292
    20272293        RL_LOCK(sc);
    20282294        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
    2029                 re_poll_locked(ifp, cmd, count);
     2295                rx_npkts = re_poll_locked(ifp, cmd, count);
    20302296        RL_UNLOCK(sc);
    2031 }
    2032 
    2033 static void
     2297        return (rx_npkts);
     2298}
     2299
     2300static int
    20342301re_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
    20352302{
    20362303        struct rl_softc *sc = ifp->if_softc;
     2304        int rx_npkts;
    20372305
    20382306        RL_LOCK_ASSERT(sc);
    20392307
    20402308        sc->rxcycles = count;
    2041         re_rxeof(sc);
     2309        re_rxeof(sc, &rx_npkts);
    20422310        re_txeof(sc);
    20432311
     
    20502318                status = CSR_READ_2(sc, RL_ISR);
    20512319                if (status == 0xffff)
    2052                         return;
     2320                        return (rx_npkts);
    20532321                if (status)
    20542322                        CSR_WRITE_2(sc, RL_ISR, status);
     2323                if ((status & (RL_ISR_TX_OK | RL_ISR_TX_DESC_UNAVAIL)) &&
     2324                    (sc->rl_flags & RL_FLAG_PCIE))
     2325                        CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
    20552326
    20562327                /*
     
    20582329                 */
    20592330
    2060                 if (status & RL_ISR_SYSTEM_ERR) {
    2061                         re_reset(sc);
     2331                if (status & RL_ISR_SYSTEM_ERR)
    20622332                        re_init_locked(sc);
    2063                 }
    2064         }
     2333        }
     2334        return (rx_npkts);
    20652335}
    20662336#endif /* DEVICE_POLLING */
    20672337
    2068 static void
    2069 re_intr(arg)
    2070         void                    *arg;
     2338static int
     2339re_intr(void *arg)
    20712340{
    20722341        struct rl_softc         *sc;
     
    20752344        sc = arg;
    20762345
    2077 printk( "re_intr " );
    20782346        status = CSR_READ_2(sc, RL_ISR);
    20792347        if (status == 0xFFFF || (status & RL_INTRS_CPLUS) == 0)
    2080                 return;
     2348                return (FILTER_STRAY);
    20812349        CSR_WRITE_2(sc, RL_IMR, 0);
    20822350
    20832351        taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_inttask);
    20842352
    2085         return;
     2353        return (FILTER_HANDLED);
    20862354}
    20872355
    20882356static void
    2089 re_int_task(arg, npending)
    2090         void                    *arg;
    2091         int                     npending;
     2357re_int_task(void *arg, int npending)
    20922358{
    20932359        struct rl_softc         *sc;
     
    20992365        ifp = sc->rl_ifp;
    21002366
    2101         NET_LOCK_GIANT();
    21022367        RL_LOCK(sc);
    21032368
     
    21052370        CSR_WRITE_2(sc, RL_ISR, status);
    21062371
    2107         if (sc->suspended || !(ifp->if_flags & IFF_UP)) {
     2372        if (sc->suspended ||
     2373            (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
    21082374                RL_UNLOCK(sc);
    2109                 NET_UNLOCK_GIANT();
    21102375                return;
    21112376        }
     
    21142379        if  (ifp->if_capenable & IFCAP_POLLING) {
    21152380                RL_UNLOCK(sc);
    2116                 NET_UNLOCK_GIANT();
    21172381                return;
    21182382        }
     
    21202384
    21212385        if (status & (RL_ISR_RX_OK|RL_ISR_RX_ERR|RL_ISR_FIFO_OFLOW))
    2122                 rval = re_rxeof(sc);
    2123 
     2386                rval = re_rxeof(sc, NULL);
     2387
     2388        /*
     2389         * Some chips will ignore a second TX request issued
     2390         * while an existing transmission is in progress. If
     2391         * the transmitter goes idle but there are still
     2392         * packets waiting to be sent, we need to restart the
     2393         * channel here to flush them out. This only seems to
     2394         * be required with the PCIe devices.
     2395         */
     2396        if ((status & (RL_ISR_TX_OK | RL_ISR_TX_DESC_UNAVAIL)) &&
     2397            (sc->rl_flags & RL_FLAG_PCIE))
     2398                CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
     2399        if (status & (
    21242400#ifdef RE_TX_MODERATION
    2125         if (status & (RL_ISR_TIMEOUT_EXPIRED|
     2401            RL_ISR_TIMEOUT_EXPIRED|
    21262402#else
    2127         if (status & (RL_ISR_TX_OK|
     2403            RL_ISR_TX_OK|
    21282404#endif
    21292405            RL_ISR_TX_ERR|RL_ISR_TX_DESC_UNAVAIL))
    21302406                re_txeof(sc);
    21312407
    2132         if (status & RL_ISR_SYSTEM_ERR) {
    2133                 re_reset(sc);
     2408        if (status & RL_ISR_SYSTEM_ERR)
    21342409                re_init_locked(sc);
    2135         }
    2136 
    2137         if (status & RL_ISR_LINKCHG) {
    2138                 callout_stop(&sc->rl_stat_callout);
    2139                 re_tick(sc);
    2140         }
    21412410
    21422411        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     
    21442413
    21452414        RL_UNLOCK(sc);
    2146         NET_UNLOCK_GIANT();
    21472415
    21482416        if ((CSR_READ_2(sc, RL_ISR) & RL_INTRS_CPLUS) || rval) {
     
    21522420
    21532421        CSR_WRITE_2(sc, RL_IMR, RL_INTRS_CPLUS);
    2154 
    2155         return;
    21562422}
    21572423
    21582424static int
    2159 re_encap(sc, m_head, idx)
    2160         struct rl_softc         *sc;
    2161         struct mbuf             **m_head;
    2162         int                     *idx;
    2163 {
    2164         struct mbuf             *m_new = NULL;
    2165         struct rl_dmaload_arg   arg;
     2425re_encap(struct rl_softc *sc, struct mbuf **m_head)
     2426{
     2427        struct rl_txdesc        *txd, *txd_last;
     2428        bus_dma_segment_t       segs[RL_NTXSEGS];
    21662429        bus_dmamap_t            map;
    2167         int                     error;
    2168 #ifndef __rtems__
    2169         struct m_tag            *mtag;
    2170 #endif
    2171 
     2430        struct mbuf             *m_new;
     2431        struct rl_desc          *desc;
     2432        int                     nsegs, prod;
     2433        int                     i, error, ei, si;
     2434#ifndef __rtems__
     2435        int                     padlen;
     2436#endif
     2437        uint32_t                cmdstat, csum_flags, vlanctl;
     2438 
    21722439        RL_LOCK_ASSERT(sc);
    2173 
    2174         if (sc->rl_ldata.rl_tx_free <= RL_TX_DESC_THLD)
    2175                 return (EFBIG);
    2176 
    2177         /*
    2178          * Set up checksum offload. Note: checksum offload bits must
    2179          * appear in all descriptors of a multi-descriptor transmit
    2180          * attempt. This is according to testing done with an 8169
    2181          * chip. This is a requirement.
    2182          */
    2183 
    2184         arg.rl_flags = 0;
    2185 
    2186 #ifndef __rtems__
    2187         if ((*m_head)->m_pkthdr.csum_flags & CSUM_IP)
    2188                 arg.rl_flags |= RL_TDESC_CMD_IPCSUM;
    2189         if ((*m_head)->m_pkthdr.csum_flags & CSUM_TCP)
    2190                 arg.rl_flags |= RL_TDESC_CMD_TCPCSUM;
    2191         if ((*m_head)->m_pkthdr.csum_flags & CSUM_UDP)
    2192                 arg.rl_flags |= RL_TDESC_CMD_UDPCSUM;
    2193 #endif
    2194 
    2195         arg.rl_idx = *idx;
    2196         arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
    2197         if (arg.rl_maxsegs > RL_TX_DESC_THLD)
    2198                 arg.rl_maxsegs -= RL_TX_DESC_THLD;
    2199         arg.rl_ring = sc->rl_ldata.rl_tx_list;
    2200 
    2201         map = sc->rl_ldata.rl_tx_dmamap[*idx];
     2440        M_ASSERTPKTHDR((*m_head));
    22022441
    22032442        /*
     
    22082447         * bytes in size, and IP header checksumming is enabled, the
    22092448         * resulting ethernet frame that appears on the wire will
    2210          * have garbled payload. To work around this, if TX checksum
     2449         * have garbled payload. To work around this, if TX IP checksum
    22112450         * offload is enabled, we always manually pad short frames out
    2212          * to the minimum ethernet frame size. We do this by pretending
    2213          * the mbuf chain has too many fragments so the coalescing code
    2214          * below can assemble the packet into a single buffer that's
    2215          * padded out to the mininum frame size.
    2216          *
    2217          * Note: this appears unnecessary for TCP, and doing it for TCP
    2218          * with PCIe adapters seems to result in bad checksums.
    2219          */
    2220 
    2221         if (arg.rl_flags && !(arg.rl_flags & RL_TDESC_CMD_TCPCSUM) &&
    2222             (*m_head)->m_pkthdr.len < RL_MIN_FRAMELEN)
    2223                 error = EFBIG;
    2224         else
    2225                 error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
    2226                     *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
    2227 
    2228         if (error && error != EFBIG) {
    2229                 device_printf(sc->rl_dev, "can't map mbuf (error %d)\n", error);
    2230                 return (ENOBUFS);
    2231         }
    2232 
    2233         /* Too many segments to map, coalesce into a single mbuf */
    2234 
    2235         if (error || arg.rl_maxsegs == 0) {
    2236                 if (arg.rl_maxsegs == 0)
    2237                         bus_dmamap_unload(sc->rl_ldata.rl_mtag, map);
    2238                 m_new = m_defrag(*m_head, M_DONTWAIT);
     2451         * to the minimum ethernet frame size.
     2452         */
     2453#ifndef __rtems__
     2454        if ((sc->rl_flags & RL_FLAG_AUTOPAD) == 0 &&
     2455            (*m_head)->m_pkthdr.len < RL_IP4CSUMTX_PADLEN &&
     2456            ((*m_head)->m_pkthdr.csum_flags & CSUM_IP) != 0) {
     2457                padlen = RL_MIN_FRAMELEN - (*m_head)->m_pkthdr.len;
     2458                if (M_WRITABLE(*m_head) == 0) {
     2459                        /* Get a writable copy. */
     2460                        m_new = m_dup(*m_head, M_DONTWAIT);
     2461                        m_freem(*m_head);
     2462                        if (m_new == NULL) {
     2463                                *m_head = NULL;
     2464                                return (ENOBUFS);
     2465                        }
     2466                        *m_head = m_new;
     2467                }
     2468                if ((*m_head)->m_next != NULL ||
     2469                    M_TRAILINGSPACE(*m_head) < padlen) {
     2470                        m_new = m_defrag(*m_head, M_DONTWAIT);
     2471                        if (m_new == NULL) {
     2472                                m_freem(*m_head);
     2473                                *m_head = NULL;
     2474                                return (ENOBUFS);
     2475                        }
     2476                } else
     2477                        m_new = *m_head;
     2478
     2479                /*
     2480                 * Manually pad short frames, and zero the pad space
     2481                 * to avoid leaking data.
     2482                 */
     2483                bzero(mtod(m_new, char *) + m_new->m_pkthdr.len, padlen);
     2484                m_new->m_pkthdr.len += padlen;
     2485                m_new->m_len = m_new->m_pkthdr.len;
     2486                *m_head = m_new;
     2487        }
     2488#endif
     2489 
     2490        prod = sc->rl_ldata.rl_tx_prodidx;
     2491        txd = &sc->rl_ldata.rl_tx_desc[prod];
     2492        error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap,
     2493            *m_head, segs, &nsegs, BUS_DMA_NOWAIT);
     2494        if (error == EFBIG) {
     2495#ifndef __rtems__
     2496                m_new = m_collapse(*m_head, M_DONTWAIT, RL_NTXSEGS);
     2497#else
     2498    m_new = m_defrag(*m_head, M_DONTWAIT);
     2499#endif
    22392500                if (m_new == NULL) {
    22402501                        m_freem(*m_head);
     
    22432504                }
    22442505                *m_head = m_new;
    2245 
     2506                error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_tx_mtag,
     2507                    txd->tx_dmamap, *m_head, segs, &nsegs, BUS_DMA_NOWAIT);
     2508                if (error != 0) {
     2509                        m_freem(*m_head);
     2510                        *m_head = NULL;
     2511                        return (error);
     2512                }
     2513        } else if (error != 0)
     2514                return (error);
     2515        if (nsegs == 0) {
     2516                m_freem(*m_head);
     2517                *m_head = NULL;
     2518                return (EIO);
     2519        }
     2520
     2521        /* Check for number of available descriptors. */
     2522        if (sc->rl_ldata.rl_tx_free - nsegs <= 1) {
     2523                bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap);
     2524                return (ENOBUFS);
     2525        }
     2526
     2527        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap,
     2528            BUS_DMASYNC_PREWRITE);
     2529
     2530        /*
     2531         * Set up checksum offload. Note: checksum offload bits must
     2532         * appear in all descriptors of a multi-descriptor transmit
     2533         * attempt. This is according to testing done with an 8169
     2534         * chip. This is a requirement.
     2535         */
     2536        vlanctl = 0;
     2537        csum_flags = 0;
     2538#ifndef __rtems__
     2539        if (((*m_head)->m_pkthdr.csum_flags & CSUM_TSO) != 0)
     2540                csum_flags = RL_TDESC_CMD_LGSEND |
     2541                    ((uint32_t)(*m_head)->m_pkthdr.tso_segsz <<
     2542                    RL_TDESC_CMD_MSSVAL_SHIFT);
     2543        else {
    22462544                /*
    2247                  * Manually pad short frames, and zero the pad space
    2248                  * to avoid leaking data.
     2545                 * Unconditionally enable IP checksum if TCP or UDP
     2546                 * checksum is required. Otherwise, TCP/UDP checksum
     2547                 * does't make effects.
    22492548                 */
    2250                 if (m_new->m_pkthdr.len < RL_MIN_FRAMELEN) {
    2251                         bzero(mtod(m_new, char *) + m_new->m_pkthdr.len,
    2252                             RL_MIN_FRAMELEN - m_new->m_pkthdr.len);
    2253                         m_new->m_pkthdr.len += RL_MIN_FRAMELEN -
    2254                             m_new->m_pkthdr.len;
    2255                         m_new->m_len = m_new->m_pkthdr.len;
    2256                 }
    2257 
    2258                 /* Note that we'll run over RL_TX_DESC_THLD here. */
    2259                 arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
    2260                 error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
    2261                     *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
    2262                 if (error || arg.rl_maxsegs == 0) {
    2263                         device_printf(sc->rl_dev,
    2264                             "can't map defragmented mbuf (error %d)\n", error);
    2265                         m_freem(m_new);
    2266                         *m_head = NULL;
    2267                         if (arg.rl_maxsegs == 0)
    2268                                 bus_dmamap_unload(sc->rl_ldata.rl_mtag, map);
    2269                         return (EFBIG);
    2270                 }
    2271         }
     2549                if (((*m_head)->m_pkthdr.csum_flags & RE_CSUM_FEATURES) != 0) {
     2550                        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     2551                                csum_flags |= RL_TDESC_CMD_IPCSUM;
     2552                                if (((*m_head)->m_pkthdr.csum_flags &
     2553                                    CSUM_TCP) != 0)
     2554                                        csum_flags |= RL_TDESC_CMD_TCPCSUM;
     2555                                if (((*m_head)->m_pkthdr.csum_flags &
     2556                                    CSUM_UDP) != 0)
     2557                                        csum_flags |= RL_TDESC_CMD_UDPCSUM;
     2558                        } else {
     2559                                vlanctl |= RL_TDESC_CMD_IPCSUMV2;
     2560                                if (((*m_head)->m_pkthdr.csum_flags &
     2561                                    CSUM_TCP) != 0)
     2562                                        vlanctl |= RL_TDESC_CMD_TCPCSUMV2;
     2563                                if (((*m_head)->m_pkthdr.csum_flags &
     2564                                    CSUM_UDP) != 0)
     2565                                        vlanctl |= RL_TDESC_CMD_UDPCSUMV2;
     2566                        }
     2567                }
     2568        }
     2569#endif
     2570
     2571        /*
     2572         * Set up hardware VLAN tagging. Note: vlan tag info must
     2573         * appear in all descriptors of a multi-descriptor
     2574         * transmission attempt.
     2575         */
     2576#ifndef __rtems__
     2577        if ((*m_head)->m_flags & M_VLANTAG)
     2578                vlanctl |= bswap16((*m_head)->m_pkthdr.ether_vtag) |
     2579                    RL_TDESC_VLANCTL_TAG;
     2580#endif
     2581 
     2582        si = prod;
     2583        for (i = 0; i < nsegs; i++, prod = RL_TX_DESC_NXT(sc, prod)) {
     2584                desc = &sc->rl_ldata.rl_tx_list[prod];
     2585                desc->rl_vlanctl = htole32(vlanctl);
     2586                desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[i].ds_addr));
     2587                desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[i].ds_addr));
     2588                cmdstat = segs[i].ds_len;
     2589                if (i != 0)
     2590                        cmdstat |= RL_TDESC_CMD_OWN;
     2591                if (prod == sc->rl_ldata.rl_tx_desc_cnt - 1)
     2592                        cmdstat |= RL_TDESC_CMD_EOR;
     2593                desc->rl_cmdstat = htole32(cmdstat | csum_flags);
     2594                sc->rl_ldata.rl_tx_free--;
     2595        }
     2596        /* Update producer index. */
     2597        sc->rl_ldata.rl_tx_prodidx = prod;
     2598
     2599        /* Set EOF on the last descriptor. */
     2600        ei = RL_TX_DESC_PRV(sc, prod);
     2601        desc = &sc->rl_ldata.rl_tx_list[ei];
     2602        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_EOF);
     2603
     2604        desc = &sc->rl_ldata.rl_tx_list[si];
     2605        /* Set SOF and transfer ownership of packet to the chip. */
     2606        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_OWN | RL_TDESC_CMD_SOF);
    22722607
    22732608        /*
     
    22762611         * in this chain.  (Swap last and first dmamaps.)
    22772612         */
    2278         sc->rl_ldata.rl_tx_dmamap[*idx] =
    2279             sc->rl_ldata.rl_tx_dmamap[arg.rl_idx];
    2280         sc->rl_ldata.rl_tx_dmamap[arg.rl_idx] = map;
    2281 
    2282         sc->rl_ldata.rl_tx_mbuf[arg.rl_idx] = *m_head;
    2283         sc->rl_ldata.rl_tx_free -= arg.rl_maxsegs;
    2284 
    2285         /*
    2286          * Set up hardware VLAN tagging. Note: vlan tag info must
    2287          * appear in the first descriptor of a multi-descriptor
    2288          * transmission attempt.
    2289          */
    2290 
    2291 #ifndef __rtems__
    2292         mtag = VLAN_OUTPUT_TAG(sc->rl_ifp, *m_head);
    2293         if (mtag != NULL)
    2294                 sc->rl_ldata.rl_tx_list[*idx].rl_vlanctl =
    2295                     htole32(htons(VLAN_TAG_VALUE(mtag)) | RL_TDESC_VLANCTL_TAG);
    2296 #endif
    2297 
    2298         /* Transfer ownership of packet to the chip. */
    2299 
    2300         sc->rl_ldata.rl_tx_list[arg.rl_idx].rl_cmdstat |=
    2301             htole32(RL_TDESC_CMD_OWN);
    2302         if (*idx != arg.rl_idx)
    2303                 sc->rl_ldata.rl_tx_list[*idx].rl_cmdstat |=
    2304                     htole32(RL_TDESC_CMD_OWN);
    2305 
    2306         RL_DESC_INC(arg.rl_idx);
    2307         *idx = arg.rl_idx;
     2613        txd_last = &sc->rl_ldata.rl_tx_desc[ei];
     2614        map = txd->tx_dmamap;
     2615        txd->tx_dmamap = txd_last->tx_dmamap;
     2616        txd_last->tx_dmamap = map;
     2617        txd_last->tx_m = *m_head;
    23082618
    23092619        return (0);
     
    23112621
    23122622static void
    2313 re_tx_task(arg, npending)
    2314         void                    *arg;
    2315         int                     npending;
     2623re_tx_task(void *arg, int npending)
    23162624{
    23172625        struct ifnet            *ifp;
    23182626
    23192627        ifp = arg;
    2320         NET_LOCK_GIANT();
    23212628        re_start(ifp);
    2322         NET_UNLOCK_GIANT();
    2323 
    2324         return;
    23252629}
    23262630
     
    23292633 */
    23302634static void
    2331 re_start(ifp)
    2332         struct ifnet            *ifp;
     2635re_start(struct ifnet *ifp)
    23332636{
    23342637        struct rl_softc         *sc;
    2335         struct mbuf             *m_head = NULL;
    2336         int                     idx, queued = 0;
     2638        struct mbuf             *m_head;
     2639        int                     queued;
    23372640
    23382641        sc = ifp->if_softc;
     
    23402643        RL_LOCK(sc);
    23412644
    2342         if (!sc->rl_link || ifp->if_drv_flags & IFF_DRV_OACTIVE) {
     2645        if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
     2646            IFF_DRV_RUNNING || (sc->rl_flags & RL_FLAG_LINK) == 0) {
    23432647                RL_UNLOCK(sc);
    23442648                return;
    23452649        }
    23462650
    2347         idx = sc->rl_ldata.rl_tx_prodidx;
    2348 
    2349         while (sc->rl_ldata.rl_tx_mbuf[idx] == NULL) {
     2651        for (queued = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd) &&
     2652            sc->rl_ldata.rl_tx_free > 1;) {
    23502653                IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
    23512654                if (m_head == NULL)
    23522655                        break;
    23532656
    2354                 if (re_encap(sc, &m_head, &idx)) {
     2657                if (re_encap(sc, &m_head) != 0) {
    23552658                        if (m_head == NULL)
    23562659                                break;
     
    23712674        if (queued == 0) {
    23722675#ifdef RE_TX_MODERATION
    2373                 if (sc->rl_ldata.rl_tx_free != RL_TX_DESC_CNT)
     2676                if (sc->rl_ldata.rl_tx_free != sc->rl_ldata.rl_tx_desc_cnt)
    23742677                        CSR_WRITE_4(sc, RL_TIMERCNT, 1);
    23752678#endif
     
    23832686            sc->rl_ldata.rl_tx_list_map,
    23842687            BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
    2385 
    2386         sc->rl_ldata.rl_tx_prodidx = idx;
    23872688
    23882689        CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
     
    24062707
    24072708        RL_UNLOCK(sc);
    2408 
    2409         return;
    24102709}
    24112710
    24122711static void
    2413 re_init(xsc)
    2414         void                    *xsc;
     2712re_init(void *xsc)
    24152713{
    24162714        struct rl_softc         *sc = xsc;
     
    24222720
    24232721static void
    2424 re_init_locked(sc)
    2425         struct rl_softc         *sc;
     2722re_init_locked(struct rl_softc *sc)
    24262723{
    24272724        struct ifnet            *ifp = sc->rl_ifp;
    24282725        struct mii_data         *mii;
    2429         u_int32_t               rxcfg = 0;
     2726        uint32_t                reg;
     2727        uint16_t                cfg;
     2728#ifndef __rtems__
    24302729        union {
    24312730                uint32_t align_dummy;
    24322731                u_char eaddr[ETHER_ADDR_LEN];
    24332732        } eaddr;
    2434 
     2733#else
     2734  uint32_t eaddr[2];
     2735#endif
     2736 
    24352737        RL_LOCK_ASSERT(sc);
    24362738
     
    24412743         */
    24422744        re_stop(sc);
     2745
     2746        /* Put controller into known state. */
     2747        re_reset(sc);
    24432748
    24442749        /*
     
    24472752         * before all others.
    24482753         */
    2449         CSR_WRITE_2(sc, RL_CPLUS_CMD, RL_CPLUSCMD_RXENB|
    2450             RL_CPLUSCMD_TXENB|RL_CPLUSCMD_PCI_MRW|
    2451             RL_CPLUSCMD_VLANSTRIP|RL_CPLUSCMD_RXCSUM_ENB);
    2452 
     2754        cfg = RL_CPLUSCMD_PCI_MRW;
     2755#ifndef __rtems__
     2756        if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
     2757                cfg |= RL_CPLUSCMD_RXCSUM_ENB;
     2758        if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
     2759                cfg |= RL_CPLUSCMD_VLANSTRIP;
     2760        if ((sc->rl_flags & RL_FLAG_MACSTAT) != 0) {
     2761                cfg |= RL_CPLUSCMD_MACSTAT_DIS;
     2762                /* XXX magic. */
     2763                cfg |= 0x0001;
     2764        } else
     2765#endif
     2766                cfg |= RL_CPLUSCMD_RXENB | RL_CPLUSCMD_TXENB;
     2767        CSR_WRITE_2(sc, RL_CPLUS_CMD, cfg);
     2768        if (sc->rl_hwrev == RL_HWREV_8169_8110SC ||
     2769            sc->rl_hwrev == RL_HWREV_8169_8110SCE) {
     2770                reg = 0x000fff00;
     2771                if ((CSR_READ_1(sc, RL_CFG2) & RL_CFG2_PCI66MHZ) != 0)
     2772                        reg |= 0x000000ff;
     2773                if (sc->rl_hwrev == RL_HWREV_8169_8110SCE)
     2774                        reg |= 0x00f00000;
     2775                CSR_WRITE_4(sc, 0x7c, reg);
     2776                /* Disable interrupt mitigation. */
     2777                CSR_WRITE_2(sc, 0xe2, 0);
     2778        }
     2779        /*
     2780         * Disable TSO if interface MTU size is greater than MSS
     2781         * allowed in controller.
     2782         */
     2783#ifndef __rtems__
     2784        if (ifp->if_mtu > RL_TSO_MTU && (ifp->if_capenable & IFCAP_TSO4) != 0) {
     2785                ifp->if_capenable &= ~IFCAP_TSO4;
     2786                ifp->if_hwassist &= ~CSUM_TSO;
     2787        }
     2788#endif
     2789 
    24532790        /*
    24542791         * Init our MAC address.  Even though the chipset
     
    24572794         */
    24582795        /* Copy MAC address on stack to align. */
     2796#ifndef __rtems__
    24592797        bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
    24602798        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_WRITECFG);
     
    24632801        CSR_WRITE_4(sc, RL_IDR4,
    24642802            htole32(*(u_int32_t *)(&eaddr.eaddr[4])));
     2803#else
     2804        bzero(eaddr, sizeof(eaddr));
     2805        bcopy(IF_LLADDR(ifp), eaddr, ETHER_ADDR_LEN);
     2806        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_WRITECFG);
     2807        CSR_WRITE_4(sc, RL_IDR0, htole32(eaddr[0]));
     2808        CSR_WRITE_4(sc, RL_IDR4, htole32(eaddr[1]));
     2809#endif
    24652810        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
    24662811
     
    24912836
    24922837        /*
    2493          * Set the initial TX and RX configuration.
     2838         * Set the initial TX configuration.
    24942839         */
    24952840        if (sc->rl_testmode) {
     
    25052850        CSR_WRITE_1(sc, RL_EARLY_TX_THRESH, 16);
    25062851
    2507         CSR_WRITE_4(sc, RL_RXCFG, RL_RXCFG_CONFIG);
    2508 
    2509         /* Set the individual bit to receive frames for this host only. */
    2510         rxcfg = CSR_READ_4(sc, RL_RXCFG);
    2511         rxcfg |= RL_RXCFG_RX_INDIV;
    2512 
    2513         /* If we want promiscuous mode, set the allframes bit. */
    2514         if (ifp->if_flags & IFF_PROMISC)
    2515                 rxcfg |= RL_RXCFG_RX_ALLPHYS;
    2516         else
    2517                 rxcfg &= ~RL_RXCFG_RX_ALLPHYS;
    2518         CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
    2519 
    2520         /*
    2521          * Set capture broadcast bit to capture broadcast frames.
    2522          */
    2523         if (ifp->if_flags & IFF_BROADCAST)
    2524                 rxcfg |= RL_RXCFG_RX_BROAD;
    2525         else
    2526                 rxcfg &= ~RL_RXCFG_RX_BROAD;
    2527         CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
    2528 
    2529         /*
    2530          * Program the multicast filter, if necessary.
    2531          */
    2532         re_setmulti(sc);
     2852        /*
     2853         * Set the initial RX configuration.
     2854         */
     2855        re_set_rxmode(sc);
    25332856
    25342857#ifdef DEVICE_POLLING
     
    25912914        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    25922915
    2593         sc->rl_link = 0;
     2916        sc->rl_flags &= ~RL_FLAG_LINK;
    25942917        sc->rl_watchdog_timer = 0;
    25952918        callout_reset(&sc->rl_stat_callout, hz, re_tick, sc);
     
    26012924#ifndef __rtems__
    26022925static int
    2603 re_ifmedia_upd(ifp)
    2604         struct ifnet            *ifp;
     2926re_ifmedia_upd(struct ifnet *ifp)
    26052927{
    26062928        struct rl_softc         *sc;
    26072929        struct mii_data         *mii;
     2930        int                     error;
    26082931
    26092932        sc = ifp->if_softc;
    26102933        mii = device_get_softc(sc->rl_miibus);
    26112934        RL_LOCK(sc);
    2612         mii_mediachg(mii);
     2935        error = mii_mediachg(mii);
    26132936        RL_UNLOCK(sc);
    26142937
    2615         return (0);
     2938        return (error);
    26162939}
    26172940#endif
     
    26222945#ifndef __rtems__
    26232946static void
    2624 re_ifmedia_sts(ifp, ifmr)
    2625         struct ifnet            *ifp;
    2626         struct ifmediareq       *ifmr;
     2947re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
    26272948{
    26282949        struct rl_softc         *sc;
     
    26542975        switch (command) {
    26552976        case SIOCSIFMTU:
     2977                if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > RL_JUMBO_MTU) {
     2978                        error = EINVAL;
     2979                        break;
     2980                }
     2981                if ((sc->rl_flags & RL_FLAG_NOJUMBO) != 0 &&
     2982                    ifr->ifr_mtu > RL_MAX_FRAMELEN) {
     2983                        error = EINVAL;
     2984                        break;
     2985                }
    26562986                RL_LOCK(sc);
    2657                 if (ifr->ifr_mtu > RL_JUMBO_MTU)
    2658                         error = EINVAL;
    2659                 ifp->if_mtu = ifr->ifr_mtu;
     2987                if (ifp->if_mtu != ifr->ifr_mtu)
     2988                        ifp->if_mtu = ifr->ifr_mtu;
     2989#ifndef __rtems__
     2990                if (ifp->if_mtu > RL_TSO_MTU &&
     2991                    (ifp->if_capenable & IFCAP_TSO4) != 0) {
     2992                        ifp->if_capenable &= ~IFCAP_TSO4;
     2993                        ifp->if_hwassist &= ~CSUM_TSO;
     2994                }
     2995#endif
    26602996                RL_UNLOCK(sc);
    26612997                break;
     
    26653001                        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
    26663002                                if (((ifp->if_flags ^ sc->rl_if_flags)
    2667                                     & IFF_PROMISC) != 0)
    2668                                         re_setmulti(sc);
     3003                                    & (IFF_PROMISC | IFF_ALLMULTI)) != 0)
     3004                                        re_set_rxmode(sc);
    26693005                        } else
    26703006                                re_init_locked(sc);
     
    26793015        case SIOCDELMULTI:
    26803016                RL_LOCK(sc);
    2681                 re_setmulti(sc);
     3017                re_set_rxmode(sc);
    26823018                RL_UNLOCK(sc);
    26833019                break;
     
    26873023#ifndef __rtems__
    26883024                error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
     3025#else
     3026                error = rtems_mii_ioctl( RE_MDIO(sc), sc, command, &ifr->ifr_media);
    26893027#endif
    26903028                break;
     
    27203058                        ifp->if_capenable ^= IFCAP_HWCSUM;
    27213059                        if (ifp->if_capenable & IFCAP_TXCSUM)
    2722                                 ifp->if_hwassist = RE_CSUM_FEATURES;
     3060                                ifp->if_hwassist |= RE_CSUM_FEATURES;
    27233061                        else
    2724                                 ifp->if_hwassist = 0;
     3062                                ifp->if_hwassist &= ~RE_CSUM_FEATURES;
    27253063                        reinit = 1;
    27263064                }
     
    27293067                        reinit = 1;
    27303068                }
     3069                if (mask & IFCAP_TSO4) {
     3070                        ifp->if_capenable ^= IFCAP_TSO4;
     3071                        if ((IFCAP_TSO4 & ifp->if_capenable) &&
     3072                            (IFCAP_TSO4 & ifp->if_capabilities))
     3073                                ifp->if_hwassist |= CSUM_TSO;
     3074                        else
     3075                                ifp->if_hwassist &= ~CSUM_TSO;
     3076                        if (ifp->if_mtu > RL_TSO_MTU &&
     3077                            (ifp->if_capenable & IFCAP_TSO4) != 0) {
     3078                                ifp->if_capenable &= ~IFCAP_TSO4;
     3079                                ifp->if_hwassist &= ~CSUM_TSO;
     3080                        }
     3081                }
     3082                if ((mask & IFCAP_WOL) != 0 &&
     3083                    (ifp->if_capabilities & IFCAP_WOL) != 0) {
     3084                        if ((mask & IFCAP_WOL_UCAST) != 0)
     3085                                ifp->if_capenable ^= IFCAP_WOL_UCAST;
     3086                        if ((mask & IFCAP_WOL_MCAST) != 0)
     3087                                ifp->if_capenable ^= IFCAP_WOL_MCAST;
     3088                        if ((mask & IFCAP_WOL_MAGIC) != 0)
     3089                                ifp->if_capenable ^= IFCAP_WOL_MAGIC;
     3090                }
    27313091                if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING)
    27323092                        re_init(sc);
    2733 #ifdef VLAN_CAPABILITIES
    27343093                VLAN_CAPABILITIES(ifp);
    2735 #endif
    27363094            }
    2737 #endif
    27383095                break;
     3096#endif
    27393097        default:
    27403098                error = ether_ioctl(ifp, command, data);
     
    27463104
    27473105static void
    2748 re_watchdog(sc)
    2749         struct rl_softc         *sc;
    2750 {
     3106re_watchdog(struct rl_softc *sc)
     3107{
     3108        struct ifnet            *ifp;
    27513109
    27523110        RL_LOCK_ASSERT(sc);
     
    27553113                return;
    27563114
    2757         device_printf(sc->rl_dev, "watchdog timeout\n");
    2758         sc->rl_ifp->if_oerrors++;
    2759 
     3115        ifp = sc->rl_ifp;
    27603116        re_txeof(sc);
    2761         re_rxeof(sc);
     3117        if (sc->rl_ldata.rl_tx_free == sc->rl_ldata.rl_tx_desc_cnt) {
     3118                if_printf(ifp, "watchdog timeout (missed Tx interrupts) "
     3119                    "-- recovering\n");
     3120                if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     3121                        taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_txtask);
     3122                return;
     3123        }
     3124
     3125        if_printf(ifp, "watchdog timeout\n");
     3126        ifp->if_oerrors++;
     3127
     3128        re_rxeof(sc, NULL);
    27623129        re_init_locked(sc);
     3130        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     3131                taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_txtask);
    27633132}
    27643133
     
    27683137 */
    27693138static void
    2770 re_stop(sc)
    2771         struct rl_softc         *sc;
    2772 {
    2773         register int            i;
     3139re_stop(struct rl_softc *sc)
     3140{
     3141        int                     i;
    27743142        struct ifnet            *ifp;
     3143        struct rl_txdesc        *txd;
     3144        struct rl_rxdesc        *rxd;
    27753145
    27763146        RL_LOCK_ASSERT(sc);
     
    27823152        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
    27833153
    2784         CSR_WRITE_1(sc, RL_COMMAND, 0x00);
     3154        if ((sc->rl_flags & RL_FLAG_CMDSTOP) != 0)
     3155                CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_STOPREQ | RL_CMD_TX_ENB |
     3156                    RL_CMD_RX_ENB);
     3157        else
     3158                CSR_WRITE_1(sc, RL_COMMAND, 0x00);
     3159        DELAY(1000);
    27853160        CSR_WRITE_2(sc, RL_IMR, 0x0000);
    27863161        CSR_WRITE_2(sc, RL_ISR, 0xFFFF);
     
    27933168        /* Free the TX list buffers. */
    27943169
    2795         for (i = 0; i < RL_TX_DESC_CNT; i++) {
    2796                 if (sc->rl_ldata.rl_tx_mbuf[i] != NULL) {
    2797                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    2798                             sc->rl_ldata.rl_tx_dmamap[i]);
    2799                         m_freem(sc->rl_ldata.rl_tx_mbuf[i]);
    2800                         sc->rl_ldata.rl_tx_mbuf[i] = NULL;
     3170        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++) {
     3171                txd = &sc->rl_ldata.rl_tx_desc[i];
     3172                if (txd->tx_m != NULL) {
     3173                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     3174                            txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
     3175                        bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag,
     3176                            txd->tx_dmamap);
     3177                        m_freem(txd->tx_m);
     3178                        txd->tx_m = NULL;
    28013179                }
    28023180        }
     
    28043182        /* Free the RX list buffers. */
    28053183
    2806         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    2807                 if (sc->rl_ldata.rl_rx_mbuf[i] != NULL) {
    2808                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    2809                             sc->rl_ldata.rl_rx_dmamap[i]);
    2810                         m_freem(sc->rl_ldata.rl_rx_mbuf[i]);
    2811                         sc->rl_ldata.rl_rx_mbuf[i] = NULL;
     3184        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     3185                rxd = &sc->rl_ldata.rl_rx_desc[i];
     3186                if (rxd->rx_m != NULL) {
     3187                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     3188                            rxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
     3189                        bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag,
     3190                            rxd->rx_dmamap);
     3191                        m_freem(rxd->rx_m);
     3192                        rxd->rx_m = NULL;
    28123193                }
    28133194        }
     
    28213202#ifndef __rtems__
    28223203static int
    2823 re_suspend(dev)
    2824         device_t                dev;
     3204re_suspend(device_t dev)
    28253205{
    28263206        struct rl_softc         *sc;
     
    28303210        RL_LOCK(sc);
    28313211        re_stop(sc);
     3212        re_setwol(sc);
    28323213        sc->suspended = 1;
    28333214        RL_UNLOCK(sc);
     
    28443225#ifndef __rtems__
    28453226static int
    2846 re_resume(dev)
    2847         device_t                dev;
     3227re_resume(device_t dev)
    28483228{
    28493229        struct rl_softc         *sc;
     
    28553235
    28563236        ifp = sc->rl_ifp;
     3237        /* Take controller out of sleep mode. */
     3238        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     3239                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     3240                        CSR_WRITE_1(sc, RL_GPIO,
     3241                            CSR_READ_1(sc, RL_GPIO) | 0x01);
     3242        }
    28573243
    28583244        /* reinitialize interface if necessary */
     
    28603246                re_init_locked(sc);
    28613247
     3248        /*
     3249         * Clear WOL matching such that normal Rx filtering
     3250         * wouldn't interfere with WOL patterns.
     3251         */
     3252        re_clrwol(sc);
    28623253        sc->suspended = 0;
    28633254        RL_UNLOCK(sc);
     
    28713262 * get confused by errant DMAs when rebooting.
    28723263 */
     3264#ifndef __rtems__
     3265static int
     3266#else
    28733267static void
    2874 re_shutdown(dev)
    2875         device_t                dev;
     3268#endif
     3269re_shutdown(device_t dev)
    28763270{
    28773271        struct rl_softc         *sc;
     
    28873281         */
    28883282        sc->rl_ifp->if_flags &= ~IFF_UP;
     3283#ifndef __rtems__
     3284        re_setwol(sc);
     3285#endif
    28893286        RL_UNLOCK(sc);
    2890 }
     3287
     3288#ifndef __rtems__
     3289        return (0);
     3290#endif
     3291}
     3292
     3293#ifndef __rtems__
     3294static void
     3295re_setwol(struct rl_softc *sc)
     3296{
     3297        struct ifnet            *ifp;
     3298        int                     pmc;
     3299        uint16_t                pmstat;
     3300        uint8_t                 v;
     3301
     3302        RL_LOCK_ASSERT(sc);
     3303
     3304        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &pmc) != 0)
     3305                return;
     3306
     3307        ifp = sc->rl_ifp;
     3308        /* Put controller into sleep mode. */
     3309        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     3310                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     3311                        CSR_WRITE_1(sc, RL_GPIO,
     3312                            CSR_READ_1(sc, RL_GPIO) & ~0x01);
     3313        }
     3314        if ((ifp->if_capenable & IFCAP_WOL) != 0 &&
     3315            (sc->rl_flags & RL_FLAG_WOLRXENB) != 0)
     3316                CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_RX_ENB);
     3317        /* Enable config register write. */
     3318        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     3319
     3320        /* Enable PME. */
     3321        v = CSR_READ_1(sc, RL_CFG1);
     3322        v &= ~RL_CFG1_PME;
     3323        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3324                v |= RL_CFG1_PME;
     3325        CSR_WRITE_1(sc, RL_CFG1, v);
     3326
     3327        v = CSR_READ_1(sc, RL_CFG3);
     3328        v &= ~(RL_CFG3_WOL_LINK | RL_CFG3_WOL_MAGIC);
     3329        if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
     3330                v |= RL_CFG3_WOL_MAGIC;
     3331        CSR_WRITE_1(sc, RL_CFG3, v);
     3332
     3333        /* Config register write done. */
     3334        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     3335
     3336        v = CSR_READ_1(sc, RL_CFG5);
     3337        v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
     3338        v &= ~RL_CFG5_WOL_LANWAKE;
     3339        if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0)
     3340                v |= RL_CFG5_WOL_UCAST;
     3341        if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
     3342                v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST;
     3343        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3344                v |= RL_CFG5_WOL_LANWAKE;
     3345        CSR_WRITE_1(sc, RL_CFG5, v);
     3346
     3347        /*
     3348         * It seems that hardware resets its link speed to 100Mbps in
     3349         * power down mode so switching to 100Mbps in driver is not
     3350         * needed.
     3351         */
     3352
     3353        /* Request PME if WOL is requested. */
     3354        pmstat = pci_read_config(sc->rl_dev, pmc + PCIR_POWER_STATUS, 2);
     3355        pmstat &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
     3356        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3357                pmstat |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
     3358        pci_write_config(sc->rl_dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
     3359}
     3360
     3361static void
     3362re_clrwol(struct rl_softc *sc)
     3363{
     3364        int                     pmc;
     3365        uint8_t                 v;
     3366
     3367        RL_LOCK_ASSERT(sc);
     3368
     3369        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &pmc) != 0)
     3370                return;
     3371
     3372        /* Enable config register write. */
     3373        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     3374
     3375        v = CSR_READ_1(sc, RL_CFG3);
     3376        v &= ~(RL_CFG3_WOL_LINK | RL_CFG3_WOL_MAGIC);
     3377        CSR_WRITE_1(sc, RL_CFG3, v);
     3378
     3379        /* Config register write done. */
     3380        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     3381
     3382        v = CSR_READ_1(sc, RL_CFG5);
     3383        v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
     3384        v &= ~RL_CFG5_WOL_LANWAKE;
     3385        CSR_WRITE_1(sc, RL_CFG5, v);
     3386}
     3387#endif
  • bsd_eth_drivers/if_re/if_rlreg.h

    ra8bf95d r914cc24  
    3030 * THE POSSIBILITY OF SUCH DAMAGE.
    3131 *
    32  * $FreeBSD: src/sys/pci/if_rlreg.h,v 1.51.2.14.2.1 2008/10/02 02:57:24 kensmith Exp $
     32 * $FreeBSD: src/sys/pci/if_rlreg.h,v 1.98 2009/08/24 18:58:13 yongari Exp $
    3333 */
    3434
     
    7777#define RL_CFG0         0x0051          /* config register #0 */
    7878#define RL_CFG1         0x0052          /* config register #1 */
    79                                         /* 0053-0057 reserved */   
     79#define RL_CFG2         0x0053          /* config register #2 */
     80#define RL_CFG3         0x0054          /* config register #3 */
     81#define RL_CFG4         0x0055          /* config register #4 */
     82#define RL_CFG5         0x0056          /* config register #5 */
     83                                        /* 0057 reserved */
    8084#define RL_MEDIASTAT    0x0058          /* media status register (8139) */
    8185                                        /* 0059-005A reserved */
     
    128132#define RL_TBI_LPAR             0x006A
    129133#define RL_GMEDIASTAT           0x006C  /* 8 bits */
     134#define RL_MACDBG               0x006D  /* 8 bits, 8168C SPIN2 only */
     135#define RL_GPIO                 0x006E  /* 8 bits, 8168C SPIN2 only */
    130136#define RL_MAXRXPKTLEN          0x00DA  /* 16 bits, chip multiplies by 8 */
    131 #define RL_GTXSTART             0x0038  /* 16 bits */
     137#define RL_GTXSTART             0x0038  /* 8 bits */
    132138
    133139/*
     
    149155
    150156#define RL_HWREV_8169           0x00000000
    151 #define RL_HWREV_8110S          0x00800000
    152 #define RL_HWREV_8169S          0x04000000
     157#define RL_HWREV_8169S          0x00800000
     158#define RL_HWREV_8110S          0x04000000
    153159#define RL_HWREV_8169_8110SB    0x10000000
    154160#define RL_HWREV_8169_8110SC    0x18000000
     161#define RL_HWREV_8102EL         0x24800000
     162#define RL_HWREV_8102EL_SPIN1   0x24c00000
     163#define RL_HWREV_8168D          0x28000000
     164#define RL_HWREV_8168DP         0x28800000
    155165#define RL_HWREV_8168_SPIN1     0x30000000
    156166#define RL_HWREV_8100E          0x30800000
    157167#define RL_HWREV_8101E          0x34000000
     168#define RL_HWREV_8102E          0x34800000
    158169#define RL_HWREV_8168_SPIN2     0x38000000
    159170#define RL_HWREV_8168_SPIN3     0x38400000
     171#define RL_HWREV_8168C          0x3C000000
     172#define RL_HWREV_8168C_SPIN2    0x3C400000
     173#define RL_HWREV_8168CP         0x3C800000
    160174#define RL_HWREV_8139           0x60000000
    161175#define RL_HWREV_8139A          0x70000000
     
    168182#define RL_HWREV_8101           0x74c00000
    169183#define RL_HWREV_8100           0x78800000
     184#define RL_HWREV_8169_8110SBL   0x7CC00000
     185#define RL_HWREV_8169_8110SCE   0x98000000
    170186
    171187#define RL_TXDMA_16BYTES        0x00000000
     
    298314#define RL_CMD_RX_ENB           0x0008
    299315#define RL_CMD_RESET            0x0010
    300 
     316#define RL_CMD_STOPREQ          0x0080
     317
     318/*
     319 * Twister register values.  These are completely undocumented and derived
     320 * from public sources.
     321 */
     322#define RL_CSCFG_LINK_OK        0x0400
     323#define RL_CSCFG_CHANGE         0x0800
     324#define RL_CSCFG_STATUS         0xf000
     325#define RL_CSCFG_ROW3           0x7000
     326#define RL_CSCFG_ROW2           0x3000
     327#define RL_CSCFG_ROW1           0x1000
     328#define RL_CSCFG_LINK_DOWN_OFF_CMD 0x03c0
     329#define RL_CSCFG_LINK_DOWN_CMD  0xf3c0
     330
     331#define RL_NWAYTST_RESET        0
     332#define RL_NWAYTST_CBL_TEST     0x20
     333
     334#define RL_PARA78               0x78
     335#define RL_PARA78_DEF           0x78fa8388
     336#define RL_PARA7C               0x7C
     337#define RL_PARA7C_DEF           0xcb38de43
     338#define RL_PARA7C_RETUNE        0xfb38de03
    301339/*
    302340 * EEPROM control register
     
    360398 */
    361399#define RL_CFG1_PWRDWN          0x01
     400#define RL_CFG1_PME             0x01   
    362401#define RL_CFG1_SLEEP           0x02
     402#define RL_CFG1_VPDEN           0x02
    363403#define RL_CFG1_IOMAP           0x04
    364404#define RL_CFG1_MEMMAP          0x08
    365405#define RL_CFG1_RSVD            0x10
     406#define RL_CFG1_LWACT           0x10
    366407#define RL_CFG1_DRVLOAD         0x20
    367408#define RL_CFG1_LED0            0x40
    368409#define RL_CFG1_FULLDUPLEX      0x40    /* 8129 only */
    369410#define RL_CFG1_LED1            0x80
     411
     412/*
     413 * Config 2 register
     414 */
     415#define RL_CFG2_PCI33MHZ        0x00
     416#define RL_CFG2_PCI66MHZ        0x01
     417#define RL_CFG2_PCI64BIT        0x08
     418#define RL_CFG2_AUXPWR          0x10
     419#define RL_CFG2_MSI             0x20
     420
     421/*
     422 * Config 3 register
     423 */
     424#define RL_CFG3_GRANTSEL        0x80
     425#define RL_CFG3_WOL_MAGIC       0x20
     426#define RL_CFG3_WOL_LINK        0x10
     427#define RL_CFG3_FAST_B2B        0x01
     428
     429/*
     430 * Config 4 register
     431 */
     432#define RL_CFG4_LWPTN           0x04
     433#define RL_CFG4_LWPME           0x10
     434
     435/*
     436 * Config 5 register
     437 */
     438#define RL_CFG5_WOL_BCAST       0x40
     439#define RL_CFG5_WOL_MCAST       0x20
     440#define RL_CFG5_WOL_UCAST       0x10
     441#define RL_CFG5_WOL_LANWAKE     0x02
     442#define RL_CFG5_PME_STS         0x01
    370443
    371444/*
     
    404477#define RL_CPLUSCMD_RXCSUM_ENB  0x0020  /* enable RX checksum offload */
    405478#define RL_CPLUSCMD_VLANSTRIP   0x0040  /* enable VLAN tag stripping */
     479#define RL_CPLUSCMD_MACSTAT_DIS 0x0080  /* 8168B/C/CP */
     480#define RL_CPLUSCMD_ASF         0x0100  /* 8168C/CP */
     481#define RL_CPLUSCMD_DBG_SEL     0x0200  /* 8168C/CP */
     482#define RL_CPLUSCMD_FORCE_TXFC  0x0400  /* 8168C/CP */
     483#define RL_CPLUSCMD_FORCE_RXFC  0x0800  /* 8168C/CP */
     484#define RL_CPLUSCMD_FORCE_HDPX  0x1000  /* 8168C/CP */
     485#define RL_CPLUSCMD_NORMAL_MODE 0x2000  /* 8168C/CP */
     486#define RL_CPLUSCMD_DBG_ENB     0x4000  /* 8168C/CP */
     487#define RL_CPLUSCMD_BIST_ENB    0x8000  /* 8168C/CP */
    406488
    407489/* C+ early transmit threshold */
     
    448530#define RL_TX_LIST_CNT          4
    449531#define RL_MIN_FRAMELEN         60
     532#define RL_TX_8139_BUF_ALIGN    4
     533#define RL_RX_8139_BUF_ALIGN    8
     534#define RL_RX_8139_BUF_RESERVE  sizeof(int64_t)
     535#define RL_RX_8139_BUF_GUARD_SZ \
     536        (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN + RL_RX_8139_BUF_RESERVE)
    450537#define RL_TXTHRESH(x)          ((x) << 11)
    451538#define RL_TX_THRESH_INIT       96
     
    457544#define RL_TXCFG_CONFIG (RL_TXCFG_IFG|RL_TX_MAXDMA)
    458545
     546#ifndef __rtems__
    459547#define RL_ETHER_ALIGN  2
     548#else
     549#define RL_ETHER_ALIGN  0
     550#endif
     551
     552/*
     553 * re(4) hardware ip4csum-tx could be mangled with 28 bytes or less IP packets.
     554 */
     555#define RL_IP4CSUMTX_MINLEN     28
     556#define RL_IP4CSUMTX_PADLEN     (ETHER_HDR_LEN + RL_IP4CSUMTX_MINLEN)
    460557
    461558struct rl_chain_data {
     
    463560        uint8_t                 *rl_rx_buf;
    464561        uint8_t                 *rl_rx_buf_ptr;
    465         bus_dmamap_t            rl_rx_dmamap;
    466562
    467563        struct mbuf             *rl_tx_chain[RL_TX_LIST_CNT];
    468564        bus_dmamap_t            rl_tx_dmamap[RL_TX_LIST_CNT];
     565        bus_dma_tag_t           rl_tx_tag;
     566        bus_dma_tag_t           rl_rx_tag;
     567        bus_dmamap_t            rl_rx_dmamap;
     568        bus_addr_t              rl_rx_buf_paddr;
    469569        uint8_t                 last_tx;
    470570        uint8_t                 cur_tx;
     
    545645#define RL_TDESC_CMD_IPCSUM     0x00040000      /* IP header checksum enable */
    546646#define RL_TDESC_CMD_MSSVAL     0x07FF0000      /* Large send MSS value */
     647#define RL_TDESC_CMD_MSSVAL_SHIFT       16      /* Large send MSS value shift */
    547648#define RL_TDESC_CMD_LGSEND     0x08000000      /* TCP large send enb */
    548649#define RL_TDESC_CMD_EOF        0x10000000      /* end of frame marker */
     
    553654#define RL_TDESC_VLANCTL_TAG    0x00020000      /* Insert VLAN tag */
    554655#define RL_TDESC_VLANCTL_DATA   0x0000FFFF      /* TAG data */
     656/* RTL8168C/RTL8168CP/RTL8111C/RTL8111CP */
     657#define RL_TDESC_CMD_UDPCSUMV2  0x80000000
     658#define RL_TDESC_CMD_TCPCSUMV2  0x40000000     
     659#define RL_TDESC_CMD_IPCSUMV2   0x20000000     
    555660
    556661/*
     
    590695#define RL_RDESC_STAT_CRCERR    0x00040000      /* CRC error */
    591696#define RL_RDESC_STAT_PROTOID   0x00030000      /* Protocol type */
     697#define RL_RDESC_STAT_UDP       0x00020000      /* UDP, 8168C/CP, 8111C/CP */
     698#define RL_RDESC_STAT_TCP       0x00010000      /* TCP, 8168C/CP, 8111C/CP */
    592699#define RL_RDESC_STAT_IPSUMBAD  0x00008000      /* IP header checksum bad */
    593700#define RL_RDESC_STAT_UDPSUMBAD 0x00004000      /* UDP checksum bad */
     
    601708                                                   (rl_vlandata valid)*/
    602709#define RL_RDESC_VLANCTL_DATA   0x0000FFFF      /* TAG data */
     710/* RTL8168C/RTL8168CP/RTL8111C/RTL8111CP */
     711#define RL_RDESC_IPV6           0x80000000
     712#define RL_RDESC_IPV4           0x40000000
    603713
    604714#define RL_PROTOID_NONIP        0x00000000
     
    636746 * Rx/Tx descriptor parameters (8139C+ and 8169 only)
    637747 *
    638  * Tx/Rx count must be equal.  Shared code like re_dma_map_desc assumes this.
    639  * Buffers must be a multiple of 8 bytes.  Currently limit to 64 descriptors
    640  * due to the 8139C+.  We need to put the number of descriptors in the ring
    641  * structure and use that value instead.
    642  */
    643 #if !defined(__i386__) && !defined(__amd64__)
     748 * 8139C+
     749 *  Number of descriptors supported : up to 64
     750 *  Descriptor alignment : 256 bytes
     751 *  Tx buffer : At least 4 bytes in length.
     752 *  Rx buffer : At least 8 bytes in length and 8 bytes alignment required.
     753 * 
     754 * 8169
     755 *  Number of descriptors supported : up to 1024
     756 *  Descriptor alignment : 256 bytes
     757 *  Tx buffer : At least 4 bytes in length.
     758 *  Rx buffer : At least 8 bytes in length and 8 bytes alignment required.
     759 */
     760#ifndef __NO_STRICT_ALIGNMENT
    644761#define RE_FIXUP_RX     1
    645762#endif
    646763
    647 #define RL_TX_DESC_CNT          64
    648 #define RL_TX_DESC_THLD         4
    649 #define RL_RX_DESC_CNT          RL_TX_DESC_CNT
    650 
    651 #define RL_RX_LIST_SZ           (RL_RX_DESC_CNT * sizeof(struct rl_desc))
    652 #define RL_TX_LIST_SZ           (RL_TX_DESC_CNT * sizeof(struct rl_desc))
     764#define RL_8169_TX_DESC_CNT     256
     765#define RL_8169_RX_DESC_CNT     256
     766#define RL_8139_TX_DESC_CNT     64
     767#define RL_8139_RX_DESC_CNT     64
     768#define RL_TX_DESC_CNT          RL_8169_TX_DESC_CNT
     769#define RL_RX_DESC_CNT          RL_8169_RX_DESC_CNT
     770#define RL_NTXSEGS              32
     771
    653772#define RL_RING_ALIGN           256
    654773#define RL_IFQ_MAXLEN           512
    655 #define RL_DESC_INC(x)          (x = (x + 1) % RL_TX_DESC_CNT)
     774#define RL_TX_DESC_NXT(sc,x)    ((x + 1) & ((sc)->rl_ldata.rl_tx_desc_cnt - 1))
     775#define RL_TX_DESC_PRV(sc,x)    ((x - 1) & ((sc)->rl_ldata.rl_tx_desc_cnt - 1))
     776#define RL_RX_DESC_NXT(sc,x)    ((x + 1) & ((sc)->rl_ldata.rl_rx_desc_cnt - 1))
    656777#define RL_OWN(x)               (le32toh((x)->rl_cmdstat) & RL_RDESC_STAT_OWN)
    657778#define RL_RXBYTES(x)           (le32toh((x)->rl_cmdstat) & sc->rl_rxlenmask)
     
    665786#endif
    666787
     788#define RL_MSI_MESSAGES 1
     789
    667790#define RL_ADDR_LO(y)           ((uint64_t) (y) & 0xFFFFFFFF)
    668791#define RL_ADDR_HI(y)           ((uint64_t) (y) >> 32)
     792
     793/*
     794 * The number of bits reserved for MSS in RealTek controllers is
     795 * 11bits. This limits the maximum interface MTU size in TSO case
     796 * as upper stack should not generate TCP segments with MSS greater
     797 * than the limit.
     798 */
     799#define RL_TSO_MTU              (2047 - ETHER_HDR_LEN - ETHER_CRC_LEN)
    669800
    670801/* see comment in dev/re/if_re.c */
    671802#define RL_JUMBO_FRAMELEN       7440
    672803#define RL_JUMBO_MTU            (RL_JUMBO_FRAMELEN-ETHER_HDR_LEN-ETHER_CRC_LEN)
    673 
    674 struct rl_softc;
    675 
    676 struct rl_dmaload_arg {
    677         int                     rl_idx;
    678         int                     rl_maxsegs;
    679         uint32_t                rl_flags;
    680         struct rl_desc          *rl_ring;
     804#define RL_MAX_FRAMELEN         \
     805        (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN)
     806
     807struct rl_txdesc {
     808        struct mbuf             *tx_m;
     809        bus_dmamap_t            tx_dmamap;
    681810};
    682811
     812struct rl_rxdesc {
     813        struct mbuf             *rx_m;
     814        bus_dmamap_t            rx_dmamap;
     815        bus_size_t              rx_size;
     816};
     817
    683818struct rl_list_data {
    684         struct mbuf             *rl_tx_mbuf[RL_TX_DESC_CNT];
    685         struct mbuf             *rl_rx_mbuf[RL_RX_DESC_CNT];
     819        struct rl_txdesc        rl_tx_desc[RL_TX_DESC_CNT];
     820        struct rl_rxdesc        rl_rx_desc[RL_RX_DESC_CNT];
     821        int                     rl_tx_desc_cnt;
     822        int                     rl_rx_desc_cnt;
    686823        int                     rl_tx_prodidx;
    687824        int                     rl_rx_prodidx;
    688825        int                     rl_tx_considx;
    689826        int                     rl_tx_free;
    690         bus_dmamap_t            rl_tx_dmamap[RL_TX_DESC_CNT];
    691         bus_dmamap_t            rl_rx_dmamap[RL_RX_DESC_CNT];
    692         bus_dma_tag_t           rl_mtag;        /* mbuf mapping tag */
     827        bus_dma_tag_t           rl_tx_mtag;     /* mbuf TX mapping tag */
     828        bus_dma_tag_t           rl_rx_mtag;     /* mbuf RX mapping tag */
     829        bus_dmamap_t            rl_rx_sparemap;
    693830        bus_dma_tag_t           rl_stag;        /* stats mapping tag */
    694831        bus_dmamap_t            rl_smap;        /* stats map */
     
    705842};
    706843
     844enum rl_twist { DONE, CHK_LINK, FIND_ROW, SET_PARAM, RECHK_LONG, RETUNE };
     845
    707846struct rl_softc {
    708847        struct ifnet            *rl_ifp;        /* interface info */
     
    711850        device_t                rl_dev;
    712851        struct resource         *rl_res;
    713         struct resource         *rl_irq;
    714         void                    *rl_intrhand;
     852        int                     rl_res_id;
     853        int                     rl_res_type;
     854        struct resource         *rl_irq[RL_MSI_MESSAGES];
     855        void                    *rl_intrhand[RL_MSI_MESSAGES];
    715856        device_t                rl_miibus;
    716857        bus_dma_tag_t           rl_parent_tag;
    717         bus_dma_tag_t           rl_tag;
    718858        uint8_t                 rl_type;
    719859        int                     rl_eecmd_read;
     
    732872        int                     rl_testmode;
    733873        int                     rl_if_flags;
     874        int                     rl_twister_enable;
     875        enum rl_twist           rl_twister;
     876        int                     rl_twist_row;
     877        int                     rl_twist_col;
    734878        int                     suspended;      /* 0 = normal  1 = suspended */
    735879#ifdef DEVICE_POLLING
     
    740884        struct task             rl_inttask;
    741885
    742         struct mtx              rl_intlock;
    743886        int                     rl_txstart;
    744         int                     rl_link;
     887        uint32_t                rl_flags;
     888#define RL_FLAG_MSI             0x0001
     889#define RL_FLAG_AUTOPAD         0x0002
     890#define RL_FLAG_PHYWAKE         0x0008
     891#define RL_FLAG_NOJUMBO         0x0010
     892#define RL_FLAG_PAR             0x0020
     893#define RL_FLAG_DESCV2          0x0040
     894#define RL_FLAG_MACSTAT         0x0080
     895#define RL_FLAG_FASTETHER       0x0100
     896#define RL_FLAG_CMDSTOP         0x0200
     897#define RL_FLAG_MACRESET        0x0400
     898#define RL_FLAG_WOLRXENB        0x1000
     899#define RL_FLAG_MACSLEEP        0x2000
     900#define RL_FLAG_PCIE            0x4000
     901#define RL_FLAG_LINK            0x8000
    745902};
    746903
     
    787944
    788945#define RL_TIMEOUT              1000
     946#define RL_PHY_TIMEOUT          2000
    789947
    790948/*
  • bsd_eth_drivers/libbsdport/Makefile.am

    ra8bf95d r914cc24  
    66libbsdport_a_SOURCES     = rtems_callout.c rtems_taskqueue.c rtems_udelay.c
    77libbsdport_a_SOURCES    += ifstuff.c devicet.c alldrv.c contigmalloc.c
    8 libbsdport_a_SOURCES    += sysbus.c malloc.c ifmedia.c
     8libbsdport_a_SOURCES    += sysbus.c malloc.c ifmedia.c misc.c miistuff.c
    99
    1010libbsdport_a_SOURCES    += rtems_verscheck.h bus.h callout.h devicet.h
     
    3939DUMMYHEADERS+=dummyheaders/miibus_if.h
    4040
     41DUMMYHEADERS+=dummyheaders/miidevs.h
     42DUMMYHEADERS+=dummyheaders/dev/mii/brgphyreg.h
     43
    4144BUILT_SOURCES=
    4245
     
    4952$(libbsdport_a_OBJECTS): $(DUMMYHEADERS) $(LINKS)
    5053
    51 if FALSE
    52 CLOBBER_ADDITIONS  =
    53 CLOBBER_ADDITIONS += $(srcdir)/dummyheaders
    54 CLOBBER_ADDITIONS += $(addprefix $(srcdir)/,$(sort $(foreach n,$(LINKS),$(firstword $(subst /, ,$(n))))))
    55 
    56 dummyheaders/%:
    57         @if [ ! -d $(srcdir)/`dirname $@` ] ; then mkdir -p $(srcdir)/`dirname $@`; fi
    58         @touch $(srcdir)/$@
    59 
    60 # for each name listed in LINKS, create parent directories (if needed)
    61 # and a symlink to file in .
    62 # E.g., LINKS=a/b/c.h
    63 # creates a/b/c.h -> ../../c.h
    64 $(LINKS):
    65         @if [ ! -d $(srcdir)/$(dir $@) ] ; then mkdir -p $(srcdir)/$(dir $@); fi
    66         @ln -s `echo $@ | sed -e 's%[^/]\+[/]\+%../%g'` $(srcdir)/$@
    67 
    68 
    69 distclean-local:
    70         $(RM) -r $(CLOBBER_ADDITIONS)
    71 endif
    72 
  • bsd_eth_drivers/libbsdport/alldrv.c

    ra8bf95d r914cc24  
    11#include <stdio.h>
    22#include "libbsdport_api.h"
     3#include "devicet.h"
    34
    45driver_t *libbsdport_netdriver_table_all[] = {
     
    67        &libbsdport_pcn_driver,
    78        &libbsdport_le_pci_driver,
     9        &libbsdport_fxp_driver,
     10        &libbsdport_bge_driver,
     11        &libbsdport_re_driver,
     12        &libbsdport_rl_driver,
    813        0
    914};
    1015
    11 /* weak alias defaults to a table that includes all currently supported drivers */
     16driver_t libbsdport_null_driver = {0};
     17
     18extern driver_t libbsdport_em_driver
     19        __attribute__((weak,alias("libbsdport_null_driver")));
     20extern driver_t libbsdport_pcn_driver
     21        __attribute__((weak,alias("libbsdport_null_driver")));
     22extern driver_t libbsdport_le_pci_driver
     23        __attribute__((weak,alias("libbsdport_null_driver")));
     24extern driver_t libbsdport_fxp_driver
     25        __attribute__((weak,alias("libbsdport_null_driver")));
     26extern driver_t libbsdport_bge_driver
     27        __attribute__((weak,alias("libbsdport_null_driver")));
     28extern driver_t libbsdport_re_driver
     29        __attribute__((weak,alias("libbsdport_null_driver")));
     30extern driver_t libbsdport_rl_driver
     31        __attribute__((weak,alias("libbsdport_null_driver")));
     32
     33
     34/* weak alias defaults to a table that includes
     35 * all currently supported drivers.
     36 *
     37 * However, the individual entires are weak aliases
     38 * themselves so that you don't have to link all drivers...
     39 */
    1240extern driver_t *libbsdport_netdriver_table
    1341        [
  • bsd_eth_drivers/libbsdport/bus.h

    ra8bf95d r914cc24  
    1717
    1818struct resource;
     19
     20struct resource_spec {
     21        int type;
     22        int rid;
     23        int flags;
     24};
    1925
    2026typedef bus_addr_t bus_space_handle_t;
     
    6066        }\
    6167}
    62 
    6368BUS_SPACE_DECL(u_int32_t, long, 4)
    6469BUS_SPACE_DECL(u_int16_t, word, 2)
     
    8287
    8388
    84 #define BUS_SPACE_DECL(type, width, nwidth, op) \
     89#define BUS_SPACE_DECL(type, iotype, width, nwidth, op) \
    8590static inline type \
    8691bus_space_read_##nwidth(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o) \
     
    8994        if ( !BUS_SPACE_ALWAYS_MEM && bus_space_io == t ) { \
    9095                /* this is a macro setting the second argument */ \
    91                 v = in_##op((volatile type *)(_IO_BASE+h+o)); \
     96                v = in_##op((volatile iotype *)(_IO_BASE+h+o)); \
    9297        } else { \
    93                 v = in_##op((volatile type *)(h+o)); \
     98                v = in_##op((volatile iotype *)(h+o)); \
    9499        } \
    95100        return v; \
     
    100105{ \
    101106        if ( !BUS_SPACE_ALWAYS_MEM && bus_space_io == t ) { \
    102                 out_##op((volatile type *)(_IO_BASE+h+o), v); \
     107                out_##op((volatile iotype *)(_IO_BASE+h+o), v); \
    103108        } else { \
    104                 out_##op((volatile type *)(h+o), v); \
     109                out_##op((volatile iotype *)(h+o), v); \
    105110        }\
    106111}
    107112
    108 BUS_SPACE_DECL(u_int32_t, long, 4, le32)
    109 BUS_SPACE_DECL(u_int16_t, word, 2, le16)
    110 BUS_SPACE_DECL(u_int8_t,  byte, 1, 8)
     113BUS_SPACE_DECL(u_int32_t, unsigned,       long, 4, le32)
     114BUS_SPACE_DECL(u_int16_t, unsigned short, word, 2, le16)
     115BUS_SPACE_DECL(u_int8_t,  unsigned char,  byte, 1, 8)
    111116
    112117#undef BUS_SPACE_ALWAYS_MEM
     
    116121#endif
    117122
     123#define bus_space_write_stream_4(_t, _h, _o, _v) \
     124  bus_space_write_4(_t, _h, _o, htole32(_v))
    118125
    119126#undef BUS_SPACE_DECL
     
    141148#define RF_ACTIVE       (1<<1)
    142149#define RF_SHAREABLE    (1<<2)
     150#define RF_OPTIONAL     (1<<3)
    143151
    144152struct resource *
    145153bus_alloc_resource_any(device_t dev, int type, int *prid, unsigned flags);
     154
     155int
     156bus_alloc_resources(device_t dev, struct resource_spec *rs, struct resource **res);
     157
     158void
     159bus_release_resources(device_t dev, const struct resource_spec *rs, struct resource **res);
    146160
    147161#define FILTER_STRAY 1
     
    158172#define INTR_TYPE_NET   0
    159173
     174/*
     175 * INTR_FAST handlers are already more like 'filters',
     176 * i.e., they disable interrupts and schedule work
     177 * on a task queue.
     178 *
     179 * During porting the fast handler has to be slightly
     180 * rewritten (must return an int value, FILTER_HANDLED
     181 * if a valid IRQ was detected and work has been scheduled
     182 * and FILTER_STRAY if this device didn't interrupt).
     183 *
     184 * You need to then remove INTR_FAST from the flags,
     185 * pass the converted handler as the 'filter' argument
     186 * and a NULL handler argument to bus_setup_intr().
     187 *
     188 */
     189extern int __INTR_FAST() __attribute__((
     190        error("\n\n==> you need to convert bus_setup_intr(INTR_FAST) to new API;\n"
     191              "    consult <sys/bus.h>\n\n")
     192));
     193
     194/* Barf at compile time if they try to use INTR_FAST */
     195#define INTR_FAST       (__INTR_FAST())
     196
    160197int
    161198bus_teardown_intr(device_t dev, struct resource *r, void *cookiep);
     
    177214bus_space_tag_t
    178215rman_get_bustag(struct resource *r);
     216
     217/* Newer API (releng 7_1) */
     218static inline u_int8_t bus_read_1(struct resource *r, bus_size_t o)
     219{
     220        return bus_space_read_1(rman_get_bustag(r), rman_get_bushandle(r), o);
     221}
     222
     223static inline u_int16_t bus_read_2(struct resource *r, bus_size_t o)
     224{
     225        return bus_space_read_2(rman_get_bustag(r), rman_get_bushandle(r), o);
     226}
     227
     228static inline u_int32_t bus_read_4(struct resource *r, bus_size_t o)
     229{
     230        return bus_space_read_4(rman_get_bustag(r), rman_get_bushandle(r), o);
     231}
     232
     233static inline void bus_write_1(struct resource *r, bus_size_t o, u_int8_t v)
     234{
     235        bus_space_write_1(rman_get_bustag(r), rman_get_bushandle(r), o, v);
     236}
     237
     238static inline void bus_write_2(struct resource *r, bus_size_t o, u_int16_t v)
     239{
     240        bus_space_write_2(rman_get_bustag(r), rman_get_bushandle(r), o, v);
     241}
     242
     243static inline void bus_write_4(struct resource *r, bus_size_t o, u_int32_t v)
     244{
     245        bus_space_write_4(rman_get_bustag(r), rman_get_bushandle(r), o, v);
     246}
    179247
    180248#ifndef BUS_DMA_NOWAIT 
     
    191259/* ignored anyways */
    192260#define BUS_DMA_COHERENT 0
     261#endif
     262
     263#ifndef BUS_DMA_ZERO   
     264/* ignored anyways */
     265#define BUS_DMA_ZERO 0
     266#endif
     267
     268#ifndef BUS_DMA_ALLOCNOW       
     269/* ignored anyways */
     270#define BUS_DMA_ALLOCNOW 0
     271#endif
     272
     273#ifndef BUS_DMA_ZERO
     274#define BUS_DMA_ZERO 1
    193275#endif
    194276
     
    223305int
    224306bus_dma_tag_create(void *parent, unsigned alignment, unsigned bounds, uint32_t lowadd, uint32_t hiaddr, void (*filter)(void*), void *filterarg, unsigned maxsize, int nsegs, unsigned maxsegsize, unsigned flags, void (*lockfunc)(void*), void *lockarg, bus_dma_tag_t *ptag);
     307
     308/* Dummy NULL fcn pointer */
     309#define busdma_lock_mutex 0
     310
     311extern uint32_t __busdma_dummy_Giant;
     312#define Giant __busdma_dummy_Giant
    225313
    226314void
     
    266354}
    267355
    268 typedef void bus_dmamap_callback_t (void *, bus_dma_segment_t *, int, int);
     356typedef void bus_dmamap_callback_t (void *arg, bus_dma_segment_t *segs, int nseg, int error);
    269357
    270358static inline int
    271 bus_dmamap_load(bus_dma_tag_t tag, bus_dmamap_t map, caddr_t vaddr, bus_size_t size, void (*cb)(void *arg, bus_dma_segment_t *segs, int nseg, int error), void *arg, unsigned flags)
     359bus_dmamap_load(bus_dma_tag_t tag, bus_dmamap_t map, void *vaddr, bus_size_t size, bus_dmamap_callback_t cb, void *arg, unsigned flags)
    272360{
    273361bus_dma_segment_t segs[1];
     
    278366}
    279367
     368typedef void bus_dmamap_callback2_t (void *arg, bus_dma_segment_t *segs, int nsegs, bus_size_t mapsize, int error);
     369
     370static inline int
     371bus_dmamap_load_mbuf(bus_dma_tag_t tag, bus_dmamap_t map, struct mbuf *m_head, bus_dmamap_callback2_t cb, void *arg, unsigned flags)
     372{
     373/* hopefully there's enough stack ... */
     374bus_dma_segment_t segs[tag->maxsegs];
     375struct mbuf *m;
     376int          n;
     377bus_size_t   sz;
     378        for ( m=m_head, sz=0, n=0; m; m=m->m_next, n++ ) {
     379                if ( n >= tag->maxsegs ) {
     380                        cb(arg, segs, n, sz, EFBIG);
     381                        return EFBIG;
     382                }
     383                segs[n].ds_addr = CPU2BUSADDR(mtod(m, unsigned));
     384                sz += (segs[n].ds_len  = m->m_len);
     385        }
     386        cb(arg, segs, n, sz, 0);
     387        return 0;
     388}
     389
    280390#define bus_dmamap_unload(tag, map) do {} while (0)
    281391
     
    286396#define bus_dmamap_destroy(tag, map) do {} while (0)
    287397
    288 #endif
     398int
     399resource_int_value(const char *name, int unit, const char *resname, int *result);
     400int
     401resource_long_value(const char *name, int unit, const char *resname, long *result);
     402
     403#endif
  • bsd_eth_drivers/libbsdport/callout.h

    ra8bf95d r914cc24  
    1919        struct mtx      *c_mtx;
    2020        callout_time_t   c_time;
     21        unsigned         c_flags;
    2122};
     23
     24#define CALLOUT_PENDING (1<<0)
     25#define CALLOUT_ACTIVE  (1<<1)
     26
     27/*
     28 * Strictly, we don't need any protection
     29 * because the global network semaphore
     30 * takes care; however we want to
     31 */
     32static inline int
     33callout_active(struct callout *p_c)
     34{
     35int rval;
     36rtems_interrupt_level l;
     37        rtems_interrupt_disable(l);
     38                rval = p_c->c_flags & CALLOUT_ACTIVE;
     39        rtems_interrupt_enable(l);
     40        return rval;   
     41}
     42
     43static inline int
     44callout_pending(struct callout *p_c)
     45{
     46int rval;
     47rtems_interrupt_level l;
     48        rtems_interrupt_disable(l);
     49                rval = p_c->c_flags & CALLOUT_PENDING;
     50        rtems_interrupt_enable(l);
     51        return rval;   
     52}
     53
     54static inline void
     55callout_decativate(struct callout *p_c)
     56{
     57rtems_interrupt_level l;
     58        rtems_interrupt_disable(l);
     59                p_c->c_flags &= ~CALLOUT_ACTIVE;
     60        rtems_interrupt_enable(l);
     61}
    2262
    2363/* We cannot stop a callout that's in progress */
    2464
    25 void
     65int
    2666callout_stop(struct callout *c);
    2767
    2868#define callout_drain callout_stop
    2969
    30 void
     70int
    3171callout_reset(struct callout *c, int ticks, void (*fn)(void*), void *arg);
    3272
  • bsd_eth_drivers/libbsdport/devicet.c

    ra8bf95d r914cc24  
    11#define DEVICET_EXTERN_INLINE
     2
     3#ifdef HAVE_CONFIG_H
     4#include <config.h>
     5#endif
    26
    37#include "devicet.h"
     
    1317#include "libbsdport_api.h"
    1418
    15 #undef  DEBUG
     19#ifdef HAVE_LIBBSPEXT
     20#include <bsp/bspExt.h>
     21#endif
     22
     23#define  DEBUG 0
     24int libbsdportAttachVerbose = DEBUG;
    1625
    1726extern void real_libc_free(void*);
     
    6675int error;
    6776
    68 #ifdef DEBUG
    69         printf("Now attaching %s%d: (0x%x:%x.%x)\n",
    70                 dev->name, unit,
    71                 dev->bushdr.pci.bus, dev->bushdr.pci.dev, dev->bushdr.pci.fun);
    72 #endif
     77        if ( libbsdportAttachVerbose ) {
     78                printf("Now attaching %s%d: (0x%x:%x.%x)\n",
     79                        dev->name, unit,
     80                        dev->bushdr.pci.bus, dev->bushdr.pci.dev, dev->bushdr.pci.fun);
     81        }
    7382
    7483        dev->unit     = unit;
     
    145154int i;
    146155        if ( l > 0 ) {
    147                 for ( i=l-1; i>=0 && isdigit(drvnam[i]); i-- )
     156                for ( i=l-1; i>=0 && isdigit(((unsigned char)drvnam[i])); i-- )
    148157                        /* nothing else to do */;
    149158                if ( 1 != sscanf(drvnam+i,"%d",punit) )
     
    248257int      bdfunit;
    249258
     259int      n_bus;
     260
    250261                if ( !attaching )
    251262                        return ENOTSUP;
     263
     264#ifdef HAVE_LIBBSPEXT
     265                bspExtInit();
     266#endif
    252267
    253268                if ( (wantedunit = get_pci_triple(cfg->name)) < 0 ) {
     
    257272                        nm[0]=0;
    258273                }
    259 #ifdef DEBUG
    260                 printf("Wanted unit is 0x%x, pattern '%s'\n", wantedunit, nm);
     274                if ( libbsdportAttachVerbose )
     275                        printf("Wanted unit is 0x%x, pattern '%s'\n", wantedunit, nm);
     276
     277                n_bus = pci_bus_count();
     278#ifdef __i386__
     279                /* ugliest of all hacks -- RTEMS routine is currently (4.9)
     280         * still broken; it reports the (0-based) highest bus number
     281         * instead of the count.
     282         */
     283                n_bus++;
    261284#endif
    262285
    263286                unit = 0;
    264287                for ( i=0; (dr=libbsdport_netdriver_table[i]); i++ ) {
     288
     289                        /* unused slot ? */
     290                        if ( 0 == dr->name && 0 == dr->methods )
     291                                continue;
     292
    265293                        /* Find matching driver */
    266 #ifdef DEBUG
    267                         printf("Trying driver '%s' ...", dr->name);
    268 #endif
     294                        if ( libbsdportAttachVerbose )
     295                                printf("Trying driver '%s' ...", dr->name);
     296
    269297                        if ( matches(dr, nm) ) {
    270 #ifdef DEBUG
    271                         printf("MATCH\n");
    272 #endif
     298
     299                                if ( libbsdportAttachVerbose )
     300                                        printf("MATCH\n");
    273301
    274302                                assert( dr->methods );
     
    282310
    283311                                dev = devalloc(dr);
    284                                 for ( b=0; b<pci_bus_count(); b++)
     312                                for ( b=0; b<n_bus; b++ )
    285313                                        for ( d=0; d<PCI_MAX_DEVICES; d++ ) {
    286314                                                for ( f=0; f<pci_num_functions(b,d); f++ ) {
     
    294322                                                        bdfunit = (b<<8) | PCI_DEVFN(d,f);
    295323
    296 #ifdef DEBUG
    297                                                         printf("Probing PCI 0x%x:%x.%x\n",
    298                                                                 bdfunit>>8, PCI_SLOT(bdfunit), PCI_FUNC(bdfunit));
    299 #endif
     324                                                        if ( libbsdportAttachVerbose ) {
     325                                                                printf("Probing PCI 0x%x:%x.%x\n",
     326                                                                                bdfunit>>8, PCI_SLOT(bdfunit), PCI_FUNC(bdfunit));
     327                                                        }
    300328
    301329                                                        /* has this device been attached already ? */
     
    320348                                                                                 * unit is acceptable.
    321349                                                                                 */
    322 #ifdef DEBUG
    323                                                                                 printf("->SUCCESS\n");
    324 #endif
     350                                                                                if ( libbsdportAttachVerbose )
     351                                                                                        printf("->SUCCESS\n");
     352
    325353                                                                                if ( 0 == wantedunit || UNITMATCH(wantedunit, unit, bdfunit) ) {
    326354                                                                                                error = devattach(dev, thisunit, cfg);
     
    332360
    333361                                                                        default:
    334 #ifdef DEBUG
    335                                                                                 printf("->FAILED\n");
    336 #endif
     362                                                                                if ( libbsdportAttachVerbose )
     363                                                                                        printf("->FAILED\n");
    337364                                                                                /* probe failed */
    338365                                                                                break;
     
    344371                                devfree(dev); dev = 0;
    345372                        } /* matching driver */
    346 #ifdef DEBUG
    347                         else printf("NO MATCH\n");
    348 #endif
     373                        else
     374                        {
     375                                if ( libbsdportAttachVerbose )
     376                                        printf("NO MATCH\n");
     377                        }
    349378                } /* for all drivers */
    350379
  • bsd_eth_drivers/libbsdport/ifmedia.c

    ra8bf95d r914cc24  
    5151}
    5252
     53void
     54ifmedia_removeall(struct ifmedia *ifm)
     55{
     56struct ifmedia_entry *ifmen, *ifmep;
     57                for ( ifmep = LIST_FIRST(&ifm->ifm_list); ifmep; ifmep = ifmen ) {
     58                        ifmen = LIST_NEXT(ifmep, ifm_list);
     59                        free(ifmep, M_DEVBUF);
     60                }
     61}
     62
    5363int
    5464ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm, u_long cmd)
  • bsd_eth_drivers/libbsdport/libbsdport.h

    ra8bf95d r914cc24  
    33
    44#include <rtems.h>
    5 #include <sys/param.h>
    6 
     5
     6#ifndef _KERNEL
    77#define _KERNEL
     8#endif
     9#ifndef __INSIDE_RTEMS_BSD_TCPIP_STACK__
     10#define __INSIDE_RTEMS_BSD_TCPIP_STACK__
     11#endif
     12
    813#include <rtems/rtems_bsdnet.h>
    914#include <rtems/rtems_bsdnet_internal.h>
     15
     16#include <sys/param.h>
    1017
    1118#include <inttypes.h>
     
    3138
    3239#include <rtems_udelay.h>
     40
     41#ifndef bswap32
     42#define bswap32(_x) CPU_swap_u32(_x)
     43#endif
    3344
    3445#if defined(__LITTLE_ENDIAN__) || defined(__i386__)
     
    129140#endif
    130141
     142static __inline void
     143le32enc(void *pp, uint32_t u)
     144{
     145  unsigned char *p = (unsigned char *)pp;
     146
     147  p[0] = u & 0xff;
     148  p[1] = (u >> 8) & 0xff;
     149  p[2] = (u >> 16) & 0xff;
     150  p[3] = (u >> 24) & 0xff;
     151}
     152
    131153#include <mutex.h>
    132154#include <callout.h>
     
    176198#endif
    177199
     200#ifndef PCIR_CACHELNSZ
     201#define PCIR_CACHELNSZ PCI_CACHE_LINE_SIZE
     202#endif
     203
    178204#ifndef PCIM_PSTAT_PME
    179205#define PCIM_PSTAT_PME       0x8000
     
    184210#endif
    185211
     212#ifndef PCIM_CMD_MWRICEN
     213#define PCIM_CMD_MWRICEN PCI_COMMAND_INVALIDATE
     214#endif
     215
    186216#ifndef PCIY_PMG
    187217#define PCIY_PMG             0x01
    188218#endif
    189219
     220#ifndef PCI_RF_DENSE
     221#define PCI_RF_DENSE         0
     222#endif
    190223
    191224static inline uint32_t
     
    258291{
    259292        return pci_read_config(dev, PCIR_SUBDEV_0, 2);
     293}
     294
     295static inline uint8_t
     296pci_get_revid(device_t dev)
     297{
     298  return pci_read_config(dev, PCIR_REVID, 1);
    260299}
    261300
     
    325364
    326365#define if_link_state_change(ifp, state) do {} while (0)
     366
     367#define if_maddr_rlock(ifp) do {} while (0)
     368#define if_maddr_runlock(ifp) do {} while (0)
    327369
    328370/* if_name should probably be const char * but isn't */
     
    363405#define MODULE_DEPEND(x1,x2,x3,x4,x5)
    364406
    365 #define mii_mediachg(mii) do {} while (0)
    366 
    367407void *
    368408real_libc_malloc(size_t);
     
    371411real_libc_free(void*);
    372412
    373 #endif
     413extern int libbsdport_bootverbose;
     414/* Try not to pollute global namespace */
     415#define bootverbose libbsdport_bootverbose
     416
     417#endif
  • bsd_eth_drivers/libbsdport/libbsdport_api.h

    ra8bf95d r914cc24  
    44#include <rtems.h>
    55#include <rtems/rtems_bsdnet.h>
     6#include <stdio.h>
    67
    78/* $Id$ */
     
    2122
    2223/* Drivers ported so far: */
     24
     25/* Broadcom BCM57xx PCI */
     26extern driver_t libbsdport_bge_driver;
     27
    2328/* Intel E1000 chips */
    2429extern driver_t libbsdport_em_driver;       
     30
    2531/* AMD 79C971..976 pcnet PCI */
    2632extern driver_t libbsdport_pcn_driver;
     33
     34/* RealTek RTL8139C+, 8168, 8169, 8169S, 8110, 8101E, and 8111 PCI */
     35extern driver_t libbsdport_re_driver;
     36
     37/* RealTek RTL8139 PCI */
     38extern driver_t libbsdport_rl_driver;
     39
    2740/* AMD/Lance older (and later) chips; this driver also supports what 'pcn'
    2841 * does but might not be as efficient.
     
    3144 */
    3245extern driver_t libbsdport_le_pci_driver;
    33 
     46/* Intel E100 chips */
     47extern driver_t libbsdport_fxp_driver;
    3448
    3549/* Generic driver attach function (can be used in rtems_bsdnet_ifconfig).
  • bsd_eth_drivers/libbsdport/libbsdport_post.h

    ra8bf95d r914cc24  
    1111#undef  SYSCTL_ADD_INT
    1212#define SYSCTL_ADD_INT(unused...)  do { } while (0)
     13
     14#define RTEMS_SYSCTL_NOTYETSUP
    1315#endif
    1416
     
    2224#define IFF_DRV_RUNNING IFF_RUNNING
    2325#define IFF_DRV_OACTIVE IFF_OACTIVE
    24 
    25 /* FIXME: should implement m_defrag() */
    26 #define m_defrag(m_headp, opt) NULL
    2726
    2827static inline struct mbuf *
     
    8887
    8988#define ETHER_SIOCMULTIFRAG(e, c, ifr, ifp)                    \
    90         ( ENETRESET != (e = (SIOCADDMULTI == (c) ?                 \
     89        ( ((e) = (SIOCADDMULTI == (c) ?                            \
    9190                        ether_addmulti((ifr), (struct arpcom*)(ifp)) :     \
    92                         ether_delmulti((ifr), (struct arpcom*)(ifp)) )))   \
     91                        ether_delmulti((ifr), (struct arpcom*)(ifp)) )),   \
     92          ((e) = ENETRESET == (e) ? 0 : (e)) )
    9393
    9494#define arp_ifinit(ifp, ifa) arp_ifinit((struct arpcom *)ifp, ifa)
    9595
     96
     97#define mii_mediachg(mii) do {} while (0)
     98
     99/* find the currently active PHY; assume bootloader or firmware
     100 * has set it up already.
     101 *
     102 * RETURNS: phy idx 0..31 or -1 on error
     103 */
     104int
     105rtems_mii_phy_probe(struct rtems_mdio_info *mdio, void *if_softc);
     106
     107/*
     108 * Defragment a mbuf chain, returning the shortest possible
     109 * chain of mbufs and clusters.  If allocation fails and
     110 * this cannot be completed, NULL will be returned, but
     111 * the passed in chain will be unchanged.  Upon success,
     112 * the original chain will be freed, and the new chain
     113 * will be returned.
     114 *
     115 * If a non-packet header is passed in, the original
     116 * mbuf (chain?) will be returned unharmed.
     117 */
     118struct mbuf *
     119m_defrag(struct mbuf *m0, int how);
     120
  • bsd_eth_drivers/libbsdport/mutex.h

    ra8bf95d r914cc24  
    4747
    4848/* what ? */
    49 #define MA_OWNED   1
     49#define MA_OWNED    1
     50#define MA_NOTOWNED 0
    5051static inline void
    5152mtx_assert(struct mtx *m, int what)
  • bsd_eth_drivers/libbsdport/rtems_callout.c

    ra8bf95d r914cc24  
    101101                        if ( c->c_time <= 0 ) {
    102102                                /* this one expired */
     103                                rtems_interrupt_disable(k1);
     104                                        c->c_flags &= ~ CALLOUT_PENDING;
     105                                rtems_interrupt_enable(k1);
    103106                                c_deq(c);
    104107                                if ( c->c_func )
     
    174177/* We cannot stop a callout that's in progress */
    175178
    176 void
     179int
    177180callout_stop(struct callout *c)
    178181{
     182rtems_interrupt_level l;
    179183LIST_KEY_DECL(k);
    180184
    181185        if ( !c->c_pprev )
    182                 return; /* not currently on a list */
     186                return 0;       /* not currently on a list */
    183187
    184188        LIST_LOCK(k);
     189                /* have to check again */
     190                if ( ! c->c_pprev ) {
     191                        LIST_UNLOCK(k);
     192                        return 0;
     193                }
    185194                /* remove from list */
    186195                c_deq(c);
     196                rtems_interrupt_disable(l);
     197                c->c_flags &= ~(CALLOUT_ACTIVE | CALLOUT_PENDING);
     198                rtems_interrupt_enable(l);
    187199        LIST_UNLOCK(k);
    188 }
    189 
    190 
    191 void
     200
     201        return 1;
     202}
     203
     204
     205int
    192206callout_reset(struct callout *c, int ticks, timeout_t fn, void *arg)
    193207{
     208rtems_interrupt_level l;
    194209LIST_KEY_DECL(k);
    195 int                 i;
     210int                 i, rval;
    196211
    197212        if ( ticks <= 0 )
    198213                ticks = 1;
    199214
    200         callout_stop(c);
     215        rval = callout_stop(c);
    201216
    202217        c->c_func = fn;
     
    210225        c_enq(&c_wheel[i], c);
    211226
     227        rtems_interrupt_disable(l);
     228                c->c_flags |= (CALLOUT_ACTIVE | CALLOUT_PENDING);
     229        rtems_interrupt_enable(l);
     230
    212231        LIST_UNLOCK(k);
     232
     233        return rval;