linux/drivers/net/ethernet/amd/mvme147.c
<<
>>
Prefs
   1/* mvme147.c  : the  Linux/mvme147/lance ethernet driver
   2 *
   3 * Copyright (C) 05/1998 Peter Maydell <pmaydell@chiark.greenend.org.uk>
   4 * Based on the Sun Lance driver and the NetBSD HP Lance driver
   5 * Uses the generic 7990.c LANCE code.
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/kernel.h>
  10#include <linux/types.h>
  11#include <linux/interrupt.h>
  12#include <linux/ioport.h>
  13#include <linux/string.h>
  14#include <linux/delay.h>
  15#include <linux/init.h>
  16#include <linux/errno.h>
  17#include <linux/gfp.h>
  18/* Used for the temporal inet entries and routing */
  19#include <linux/socket.h>
  20#include <linux/route.h>
  21#include <linux/netdevice.h>
  22#include <linux/etherdevice.h>
  23#include <linux/skbuff.h>
  24
  25#include <asm/io.h>
  26#include <asm/pgtable.h>
  27#include <asm/mvme147hw.h>
  28
  29/* We have 32K of RAM for the init block and buffers. This places
  30 * an upper limit on the number of buffers we can use. NetBSD uses 8 Rx
  31 * buffers and 2 Tx buffers, it takes (8 + 2) * 1544 bytes.
  32 */
  33#define LANCE_LOG_TX_BUFFERS 1
  34#define LANCE_LOG_RX_BUFFERS 3
  35
  36#include "7990.h"                                 /* use generic LANCE code */
  37
  38/* Our private data structure */
  39struct m147lance_private {
  40        struct lance_private lance;
  41        unsigned long ram;
  42};
  43
  44/* function prototypes... This is easy because all the grot is in the
  45 * generic LANCE support. All we have to support is probing for boards,
  46 * plus board-specific init, open and close actions.
  47 * Oh, and we need to tell the generic code how to read and write LANCE registers...
  48 */
  49static int m147lance_open(struct net_device *dev);
  50static int m147lance_close(struct net_device *dev);
  51static void m147lance_writerap(struct lance_private *lp, unsigned short value);
  52static void m147lance_writerdp(struct lance_private *lp, unsigned short value);
  53static unsigned short m147lance_readrdp(struct lance_private *lp);
  54
  55typedef void (*writerap_t)(void *, unsigned short);
  56typedef void (*writerdp_t)(void *, unsigned short);
  57typedef unsigned short (*readrdp_t)(void *);
  58
  59static const struct net_device_ops lance_netdev_ops = {
  60        .ndo_open               = m147lance_open,
  61        .ndo_stop               = m147lance_close,
  62        .ndo_start_xmit         = lance_start_xmit,
  63        .ndo_set_rx_mode        = lance_set_multicast,
  64        .ndo_tx_timeout         = lance_tx_timeout,
  65        .ndo_change_mtu         = eth_change_mtu,
  66        .ndo_validate_addr      = eth_validate_addr,
  67        .ndo_set_mac_address    = eth_mac_addr,
  68};
  69
  70/* Initialise the one and only on-board 7990 */
  71struct net_device * __init mvme147lance_probe(int unit)
  72{
  73        struct net_device *dev;
  74        static int called;
  75        static const char name[] = "MVME147 LANCE";
  76        struct m147lance_private *lp;
  77        u_long *addr;
  78        u_long address;
  79        int err;
  80
  81        if (!MACH_IS_MVME147 || called)
  82                return ERR_PTR(-ENODEV);
  83        called++;
  84
  85        dev = alloc_etherdev(sizeof(struct m147lance_private));
  86        if (!dev)
  87                return ERR_PTR(-ENOMEM);
  88
  89        if (unit >= 0)
  90                sprintf(dev->name, "eth%d", unit);
  91
  92        /* Fill the dev fields */
  93        dev->base_addr = (unsigned long)MVME147_LANCE_BASE;
  94        dev->netdev_ops = &lance_netdev_ops;
  95        dev->dma = 0;
  96
  97        addr = (u_long *)ETHERNET_ADDRESS;
  98        address = *addr;
  99        dev->dev_addr[0] = 0x08;
 100        dev->dev_addr[1] = 0x00;
 101        dev->dev_addr[2] = 0x3e;
 102        address = address >> 8;
 103        dev->dev_addr[5] = address&0xff;
 104        address = address >> 8;
 105        dev->dev_addr[4] = address&0xff;
 106        address = address >> 8;
 107        dev->dev_addr[3] = address&0xff;
 108
 109        printk("%s: MVME147 at 0x%08lx, irq %d, Hardware Address %pM\n",
 110               dev->name, dev->base_addr, MVME147_LANCE_IRQ,
 111               dev->dev_addr);
 112
 113        lp = netdev_priv(dev);
 114        lp->ram = __get_dma_pages(GFP_ATOMIC, 3);       /* 32K */
 115        if (!lp->ram) {
 116                printk("%s: No memory for LANCE buffers\n", dev->name);
 117                free_netdev(dev);
 118                return ERR_PTR(-ENOMEM);
 119        }
 120
 121        lp->lance.name = name;
 122        lp->lance.base = dev->base_addr;
 123        lp->lance.init_block = (struct lance_init_block *)(lp->ram); /* CPU addr */
 124        lp->lance.lance_init_block = (struct lance_init_block *)(lp->ram);                 /* LANCE addr of same RAM */
 125        lp->lance.busmaster_regval = LE_C3_BSWP;        /* we're bigendian */
 126        lp->lance.irq = MVME147_LANCE_IRQ;
 127        lp->lance.writerap = (writerap_t)m147lance_writerap;
 128        lp->lance.writerdp = (writerdp_t)m147lance_writerdp;
 129        lp->lance.readrdp = (readrdp_t)m147lance_readrdp;
 130        lp->lance.lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS;
 131        lp->lance.lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS;
 132        lp->lance.rx_ring_mod_mask = RX_RING_MOD_MASK;
 133        lp->lance.tx_ring_mod_mask = TX_RING_MOD_MASK;
 134
 135        err = register_netdev(dev);
 136        if (err) {
 137                free_pages(lp->ram, 3);
 138                free_netdev(dev);
 139                return ERR_PTR(err);
 140        }
 141
 142        return dev;
 143}
 144
 145static void m147lance_writerap(struct lance_private *lp, unsigned short value)
 146{
 147        out_be16(lp->base + LANCE_RAP, value);
 148}
 149
 150static void m147lance_writerdp(struct lance_private *lp, unsigned short value)
 151{
 152        out_be16(lp->base + LANCE_RDP, value);
 153}
 154
 155static unsigned short m147lance_readrdp(struct lance_private *lp)
 156{
 157        return in_be16(lp->base + LANCE_RDP);
 158}
 159
 160static int m147lance_open(struct net_device *dev)
 161{
 162        int status;
 163
 164        status = lance_open(dev);                 /* call generic lance open code */
 165        if (status)
 166                return status;
 167        /* enable interrupts at board level. */
 168        m147_pcc->lan_cntrl = 0;       /* clear the interrupts (if any) */
 169        m147_pcc->lan_cntrl = 0x08 | 0x04;     /* Enable irq 4 */
 170
 171        return 0;
 172}
 173
 174static int m147lance_close(struct net_device *dev)
 175{
 176        /* disable interrupts at boardlevel */
 177        m147_pcc->lan_cntrl = 0x0; /* disable interrupts */
 178        lance_close(dev);
 179        return 0;
 180}
 181
 182#ifdef MODULE
 183MODULE_LICENSE("GPL");
 184
 185static struct net_device *dev_mvme147_lance;
 186int __init init_module(void)
 187{
 188        dev_mvme147_lance = mvme147lance_probe(-1);
 189        return PTR_ERR_OR_ZERO(dev_mvme147_lance);
 190}
 191
 192void __exit cleanup_module(void)
 193{
 194        struct m147lance_private *lp = netdev_priv(dev_mvme147_lance);
 195        unregister_netdev(dev_mvme147_lance);
 196        free_pages(lp->ram, 3);
 197        free_netdev(dev_mvme147_lance);
 198}
 199
 200#endif /* MODULE */
 201