rtemscompat1.h

#ifndef RTEMS_COMPAT1_BSD_NET_H
#define RTEMS_COMPAT1_BSD_NET_H
 
/* BSD -> RTEMS conversion wrappers; stuff that must be defined
 *        after most BSD headers are included.
 */
 
#include <netinet/in.h>
#include <netinet/if_ether.h>
 
/* Copyright: Till Straumann <strauman@slac.stanford.edu>, 2005;
 * License:   see LICENSE file.
 */
 
typedef struct device {
    struct NET_SOFTC d_softc;   /* MUST BE FIRST FIELD */
    char             *d_name;
    char             *d_desc;
    int              d_unit;
    int              flags;
    /* pointer to ifconfig only valid during excution of
     * the n_attach/n_detach methods (see below)
     */
    struct rtems_bsdnet_ifconfig *d_ifconfig;
} netdev_t;
 
#define THEDEVS NET_EMBEMB(the_,NETDRIVER_PREFIX,_devs)
#define NETDEV_DECL netdev_t THEDEVS[NETDRIVER_SLOTS]
 
extern NETDEV_DECL;
 
typedef struct _net_drv_tbl {
    int (*n_probe)(device_t);
    int (*n_attach)(device_t);
    int (*n_detach)(device_t);
    void (*n_intr)(void *);
} net_drv_tbl_t;
 
static inline netdev_t *
net_dev_get(struct rtems_bsdnet_ifconfig *config)
{
    int     unitNo;
    char *unitName;
 
    unitNo = rtems_bsdnet_parse_driver_name(config, &unitName);
    if ( unitNo < 0 )
        return 0;
 
    if ( unitNo <=0 || unitNo > NETDRIVER_SLOTS ) {
        device_printf(dev, "Bad "NETDRIVER" unit number.\n");
        return 0;
    }
 
    if ( THEDEVS[unitNo-1].d_unit && THEDEVS[unitNo-1].d_unit != unitNo ) {
        device_printf(dev, "Unit # mismatch !!??\n");
        return 0;
    }
 
    THEDEVS[unitNo-1].d_unit = unitNo;
    THEDEVS[unitNo-1].d_name = unitName;
    THEDEVS[unitNo-1].d_ifconfig = config;
    
    return &THEDEVS[unitNo - 1];
}
 
/* kludge; that's why softc needs to be first */
static inline netdev_t *
softc_get_device(struct NET_SOFTC *sc)
{
    return (netdev_t *)sc;
}
 
static inline struct NET_SOFTC *
device_get_softc(netdev_t *dev)
{ return &dev->d_softc; }
 
static inline int
device_get_unit(netdev_t *dev)
{ return dev->d_unit; }
 
static inline char *
device_get_name(netdev_t *dev)
{ return dev->d_name; }
 
static inline void
if_initname(struct ifnet *ifp, char *name, int unit)
{
    ifp->if_name = name;
    ifp->if_unit = unit;
}
 
static inline void
device_set_desc(netdev_t *dev, char *str)
{
    dev->d_desc = str;
}
 
static inline void
device_set_desc_copy(netdev_t *dev, char *str)
{
    dev->d_desc = strdup(str);
}
 
 
static inline int
device_is_attached(netdev_t *dev)
{
    return dev->d_softc.arpcom.ac_if.if_addrlist && dev->d_softc.arpcom.ac_if.if_init;
}
 
#ifdef NETDRIVER_PCI
#include NETDRIVER_PCI
#include "pcireg.h"
 
static inline unsigned
pci_read_config(device_t dev, unsigned addr, unsigned width)
{
rtemscompat_32_t d;
unsigned short   s;
unsigned char    b;
struct NET_SOFTC *sc = device_get_softc(dev);
    switch (width) {
        case 1: pci_read_config_byte(sc->b, sc->d, sc->f, addr, &b);
                return b;
        case 2: pci_read_config_word(sc->b, sc->d, sc->f, addr, &s);
                return s;
        case 4: pci_read_config_dword(sc->b, sc->d, sc->f, addr, &d);
                return d;
        default:
                break;
    }
    return 0xdeadbeef;
}
 
static inline void
pci_write_config(device_t dev, unsigned addr, unsigned width, unsigned val)
{
struct NET_SOFTC *sc = device_get_softc(dev);
    switch (width) {
        case 1: pci_write_config_byte(sc->b, sc->d, sc->f, addr, val);
                return ;
        case 2: pci_write_config_word(sc->b, sc->d, sc->f, addr, val);
                return ;
        case 4: pci_write_config_dword(sc->b, sc->d, sc->f, addr, val);
                return ;
        default:
                break;
    }
}
 
 
static inline unsigned short
pci_get_vendor(device_t dev)
{
    return pci_read_config(dev, PCIR_VENDOR, 2);
}
 
static inline unsigned short
pci_get_device(device_t dev)
{
    return pci_read_config(dev, PCIR_DEVICE, 2);
}
 
static inline unsigned short
pci_get_subvendor(device_t dev)
{
    return pci_read_config(dev, PCIR_SUBVEND_0, 2);
}
 
static inline unsigned short
pci_get_subdevice(device_t dev)
{
    return pci_read_config(dev, PCIR_SUBDEV_0, 2);
}
 
 
static inline void
pci_enable_busmaster(device_t dev)
{
    pci_write_config(
        dev,
        PCIR_COMMAND,
        2,
        pci_read_config(dev, PCIR_COMMAND, 2)
        | PCIM_CMD_BUSMASTEREN);
}
 
#define mtx_init(a,b,c,d)   do {} while(0)
#define mtx_initialized(ma) (1)
#define mtx_destroy(ma)     do {} while(0)
#define mtx_lock(a)         do {} while(0)
#define mtx_unlock(a)       do {} while(0)
#define mtx_assert(a,b)     do {} while(0)
 
#define callout_handle_init(x) do {} while (0)
#define untimeout(a...) do {} while (0)
 
#if !ISMINVERSION(4,6,99)
#define pci_bus_count BusCountPCI
#endif
 
#endif
 
/* Ugly hack to allow unloading/reloading the driver core.
 * Needed because rtems' bsdnet release doesn't implement
 * if_detach(). Therefore, we bring the interface down but
 * keep the device record alive...
 */
static inline void
__ether_ifdetach(struct ifnet *ifp)
{
        ifp->if_flags = 0;
        ifp->if_ioctl = 0;
        ifp->if_start = 0;
        ifp->if_watchdog = 0;
        ifp->if_init  = 0;
}
 
#endif