pci驱动程序设计

驱动描述

struct pci_driver

{

.........................

const struct pci_device_id *id_table;一个pci驱动可以支持很多pci设备。驱动所支持的设备都放在这个表中。它其实是个数组，数组的每一行代表一个设备。其中包括设备的厂商号，设备号，子厂商号，子设备号。若子设备号为PCI_ANY_ID,表示支持各种子类型。

int (*probe) (struct pci_dev *dev,const struct pci_device_id *id);注册驱动程序的时候，会探测所有的设备是否驱动支持这个设备。

void (*remove) (struct pci_dev *dev);拔掉设备时，会调用这个设备。

................................................

}

注册驱动

pci_register_driver(struct pci_driver *drv)

注册时先match 再调用自己的probe函数，在函数中使能设备，获取基地址，获取中断号，映射物理地址到虚拟地址等初始化。

当注册驱动时，它会遍历这个驱动所属总线的所有设备，通过match看驱动和设备是否匹配，若成功，调用probe函数。这个match是由总线决定的，match是通过看设备的设备标识，制造商标识，子设备标识，子设备制造商标识，类设备标识与id table中驱动已支持的设备进行匹配。

使能设备---

在pci驱动使用pci设备的任何资源（i/o区或中断）之前，驱动必须调用如下函数来使能设备:

int pci_enable_device(struct pci_dev *dev)

一般在probe函数中使能设备。

获取基地址-----获取的是物理地址-------一般在probe函数中获取

一个pci设备最多可以实现6个地址区域，大多数pci设备在这些区域实现I/O寄存器。linux提供了一组函数来获取这些区间的基地址：

pci_resourc_start(struct pci_dev *dev,int bar)

返回指定区域的起始地址，这个区域通关参数bar指定，范围从0-5，表示pci区域的一个。

pci_resource_end(struct pci_dev *dev,int bar)

返回指定区域的末地址。

中断---

中断号存放于配置寄存器PCI_INTERRUPT_LINE中，驱动不必去检查它，因为从PCI_INTERRUPT_LINE找到的值保证是正确的。如果设备不支持中断，寄存器PCI_INTERRUPT_PIN中的值是0，否则它是非零的值。但因为驱动开发者通常知道设备是否支持中断，所以常常不需要访问PCI_INTERRUPT_PIN。

pci网卡驱动程序分析--------------drivers/net/hamachi.c-------GNIC-II的千兆以太网卡

#define DRV_NAME "hamachi"

#define DRV_VERSION "1.01+LK1.0.1"

#define DRV_RELDATE "5/18/2001"

static int debug = 1;

#define final_version

#define hamachi_debug debug

static int max_interrupt_work = 40;

static int mtu;

static int max_rx_latency = 0x11;

static int max_rx_gap = 0x05;

static int min_rx_pkt = 0x18;

static int max_tx_latency = 0x00;

static int max_tx_gap = 0x00;

static int min_tx_pkt = 0x30;

static int rx_copybreak;

static int force32;

#define MAX_UNITS 8

static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

static int rx_params[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

static int tx_params[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};

#define TX_RING_SIZE 64

#define RX_RING_SIZE 512

#define TX_TOTAL_SIZE TX_RING_SIZE*sizeof(struct hamachi_desc)

#define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct hamachi_desc)

#undef TX_CHECKSUM

#define RX_CHECKSUM

#define TX_TIMEOUT (5*HZ)

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/string.h>

#include <linux/timer.h>

#include <linux/time.h>

#include <linux/ptrace.h>

#include <linux/errno.h>

#include <linux/ioport.h>

#include <linux/slab.h>

#include <linux/interrupt.h>

#include <linux/pci.h>

#include <linux/init.h>

#include <linux/ethtool.h>

#include <linux/mii.h>

#include <asm/uaccess.h>

#include <asm/processor.h>

#include <asm/bitops.h>

#include <asm/io.h>

#include <asm/unaligned.h>

#include <asm/cache.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

#include <linux/ip.h>

#include <linux/delay.h>

static char version[] __initdata =

KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n"

KERN_INFO " Some modifications by Eric kasten <[email protected]>\n"

KERN_INFO " Further modifications by Keith Underwood <[email protected]>\n";

#ifndef IP_MF

#define IP_MF 0x2000

#endif

#ifndef IP_OFFSET

#ifdef IPOPT_OFFSET

#define IP_OFFSET IPOPT_OFFSET

#else

#define IP_OFFSET 2

#endif

#define RUN_AT(x) (jiffies + (x))

#if ADDRLEN == 64

#define cpu_to_leXX(addr) cpu_to_le64(addr)

#else

#define cpu_to_leXX(addr) cpu_to_le32(addr)

#endif

#define PKT_BUF_SZ 1538

#define MAX_FRAME_SIZE 1518

static void hamachi_timer(unsigned long data);

enum capability_flags {CanHaveMII=1, };

static struct chip_info {

u16 vendor_id, device_id, device_id_mask, pad;

const char *name;

void (*media_timer)(unsigned long data);

int flags;

} chip_tbl[] = {

{0x1318, 0x0911, 0xffff, 0, "Hamachi GNIC-II", hamachi_timer, 0},

{0,},

};

enum hamachi_offsets {

TxDMACtrl=0x00, TxCmd=0x04, TxStatus=0x06, TxPtr=0x08, TxCurPtr=0x10,

RxDMACtrl=0x20, RxCmd=0x24, RxStatus=0x26, RxPtr=0x28, RxCurPtr=0x30,

PCIClkMeas=0x060, MiscStatus=0x066, ChipRev=0x68, ChipReset=0x06B,

LEDCtrl=0x06C, VirtualJumpers=0x06D, GPIO=0x6E,

TxChecksum=0x074, RxChecksum=0x076,

TxIntrCtrl=0x078, RxIntrCtrl=0x07C,

InterruptEnable=0x080, InterruptClear=0x084, IntrStatus=0x088,

EventStatus=0x08C,

MACCnfg=0x0A0, FrameGap0=0x0A2, FrameGap1=0x0A4,

MACCnfg2=0x0B0, RxDepth=0x0B8, FlowCtrl=0x0BC, MaxFrameSize=0x0CE,

AddrMode=0x0D0, StationAddr=0x0D2,

ANCtrl=0x0E0, ANStatus=0x0E2, ANXchngCtrl=0x0E4, ANAdvertise=0x0E8,

ANLinkPartnerAbility=0x0EA,

EECmdStatus=0x0F0, EEData=0x0F1, EEAddr=0x0F2,

FIFOcfg=0x0F8,

};

enum MII_offsets {

MII_Cmd=0xA6, MII_Addr=0xA8, MII_Wr_Data=0xAA, MII_Rd_Data=0xAC,

MII_Status=0xAE,

};

enum intr_status_bits {

IntrRxDone=0x01, IntrRxPCIFault=0x02, IntrRxPCIErr=0x04,

IntrTxDone=0x100, IntrTxPCIFault=0x200, IntrTxPCIErr=0x400,

LinkChange=0x10000, NegotiationChange=0x20000, StatsMax=0x40000, };

struct hamachi_desc {

u32 status_n_length;

#if ADDRLEN == 64

u32 pad;

u64 addr;

#else

u32 addr;

#endif

};

enum desc_status_bits {

DescOwn=0x80000000, DescEndPacket=0x40000000, DescEndRing=0x20000000,

DescIntr=0x10000000,

};

#define PRIV_ALIGN 15

#define MII_CNT 4

struct hamachi_private {

struct hamachi_desc *rx_ring;

struct hamachi_desc *tx_ring;

struct sk_buff* rx_skbuff[RX_RING_SIZE];

struct sk_buff* tx_skbuff[TX_RING_SIZE];

dma_addr_t tx_ring_dma;

dma_addr_t rx_ring_dma;

struct net_device_stats stats;

struct timer_list timer;

spinlock_t lock;

int chip_id;

unsigned int cur_rx, dirty_rx;

unsigned int cur_tx, dirty_tx;

unsigned int rx_buf_sz;

unsigned int tx_full:1;

unsigned int full_duplex:1;

unsigned int duplex_lock:1;

unsigned int medialock:1;

unsigned int default_port:4;

int mii_cnt;

u16 advertising;

unsigned char phys[MII_CNT];

u32 rx_int_var, tx_int_var;

u32 option;

struct pci_dev *pci_dev;

};

MODULE_AUTHOR("Donald Becker <[email protected]>, Eric Kasten <[email protected]>, Keith Underwood <[email protected]>");

MODULE_DESCRIPTION("Packet Engines 'Hamachi' GNIC-II Gigabit Ethernet driver");

MODULE_LICENSE("GPL");

MODULE_PARM(max_interrupt_work, "i");

MODULE_PARM(mtu, "i");

MODULE_PARM(debug, "i");

MODULE_PARM(min_rx_pkt, "i");

MODULE_PARM(max_rx_gap, "i");

MODULE_PARM(max_rx_latency, "i");

MODULE_PARM(min_tx_pkt, "i");

MODULE_PARM(max_tx_gap, "i");

MODULE_PARM(max_tx_latency, "i");

MODULE_PARM(rx_copybreak, "i");

MODULE_PARM(rx_params, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(tx_params, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(force32, "i");

MODULE_PARM_DESC(max_interrupt_work, "GNIC-II maximum events handled per interrupt");

MODULE_PARM_DESC(mtu, "GNIC-II MTU (all boards)");

MODULE_PARM_DESC(debug, "GNIC-II debug level (0-7)");

MODULE_PARM_DESC(min_rx_pkt, "GNIC-II minimum Rx packets processed between interrupts");

MODULE_PARM_DESC(max_rx_gap, "GNIC-II maximum Rx inter-packet gap in 8.192 microsecond units");

MODULE_PARM_DESC(max_rx_latency, "GNIC-II time between Rx interrupts in 8.192 microsecond units");

MODULE_PARM_DESC(min_tx_pkt, "GNIC-II minimum Tx packets processed between interrupts");

MODULE_PARM_DESC(max_tx_gap, "GNIC-II maximum Tx inter-packet gap in 8.192 microsecond units");

MODULE_PARM_DESC(max_tx_latency, "GNIC-II time between Tx interrupts in 8.192 microsecond units");

MODULE_PARM_DESC(rx_copybreak, "GNIC-II copy breakpoint for copy-only-tiny-frames");

MODULE_PARM_DESC(rx_params, "GNIC-II min_rx_pkt+max_rx_gap+max_rx_latency");

MODULE_PARM_DESC(tx_params, "GNIC-II min_tx_pkt+max_tx_gap+max_tx_latency");

MODULE_PARM_DESC(options, "GNIC-II Bits 0-3: media type, bits 4-6: as force32, bit 7: half duplex, bit 9 full duplex");

MODULE_PARM_DESC(full_duplex, "GNIC-II full duplex setting(s) (1)");

MODULE_PARM_DESC(force32, "GNIC-II: Bit 0: 32 bit PCI, bit 1: disable parity, bit 2: 64 bit PCI (all boards)");

static int read_eeprom(long ioaddr, int location);

static int mdio_read(long ioaddr, int phy_id, int location);

static void mdio_write(long ioaddr, int phy_id, int location, int value);

static int hamachi_open(struct net_device *dev);

static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);

static void hamachi_timer(unsigned long data);

static void hamachi_tx_timeout(struct net_device *dev);

static void hamachi_init_ring(struct net_device *dev);

static int hamachi_start_xmit(struct sk_buff *skb, struct net_device *dev);

static void hamachi_interrupt(int irq, void *dev_instance, struct pt_regs *regs);

static inline int hamachi_rx(struct net_device *dev);

static inline int hamachi_tx(struct net_device *dev);

static void hamachi_error(struct net_device *dev, int intr_status);

static int hamachi_close(struct net_device *dev);

static struct net_device_stats *hamachi_get_stats(struct net_device *dev);

static void set_rx_mode(struct net_device *dev);

static int __init hamachi_init_one (struct pci_dev *pdev,

const struct pci_device_id *ent)

{

struct hamachi_private *hmp;

int option, i, rx_int_var, tx_int_var, boguscnt;

int chip_id = ent->driver_data;

int irq;

long ioaddr;

static int card_idx;

struct net_device *dev;

void *ring_space;

dma_addr_t ring_dma;

int ret = -ENOMEM;

#ifndef MODULE

static int printed_version;

if (!printed_version++)

printk(version);

#endif

if (pci_enable_device(pdev)) {

ret = -EIO;

goto err_out;

}

ioaddr = pci_resource_start(pdev, 0);

#ifdef __alpha__

ioaddr |= (pci_resource_start(pdev, 1) << 32);

#endif

pci_set_master(pdev);

i = pci_request_regions(pdev, DRV_NAME);

if (i) return i;

irq = pdev->irq;

ioaddr = (long) ioremap(ioaddr, 0x400);

if (!ioaddr)

goto err_out_release;

dev = alloc_etherdev(sizeof(struct hamachi_private));

if (!dev)

goto err_out_iounmap;

SET_MODULE_OWNER(dev);

#ifdef TX_CHECKSUM

printk("check that skbcopy in ip_queue_xmit isn't happening\n");

dev->hard_header_len += 8;

#endif

for (i = 0; i < 6; i++)

dev->dev_addr[i] = 1 ? read_eeprom(ioaddr, 4 + i)

: readb(ioaddr + StationAddr + i);

#if ! defined(final_version)

if (hamachi_debug > 4)

for (i = 0; i < 0x10; i++)

printk("%2.2x%s",

read_eeprom(ioaddr, i), i % 16 != 15 ? " " : "\n");

#endif

hmp = dev->priv;

spin_lock_init(&hmp->lock);

ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);

if (!ring_space)

goto err_out_cleardev;

hmp->tx_ring = (struct hamachi_desc *)ring_space;

hmp->tx_ring_dma = ring_dma;

ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);

if (!ring_space)

goto err_out_unmap_tx;

hmp->rx_ring = (struct hamachi_desc *)ring_space;

hmp->rx_ring_dma = ring_dma;

option = card_idx < MAX_UNITS ? options[card_idx] : 0;

if (dev->mem_start)

option = dev->mem_start;

force32 = force32 ? force32 :

((option >= 0) ? ((option & 0x00000070) >> 4) : 0 );

if (force32)

writeb(force32, ioaddr + VirtualJumpers);

writeb(0x01, ioaddr + ChipReset);

udelay(10);

i = readb(ioaddr + PCIClkMeas);

for (boguscnt = 0; (!(i & 0x080)) && boguscnt < 1000; boguscnt++){

udelay(10);

i = readb(ioaddr + PCIClkMeas);

}

dev->base_addr = ioaddr;

dev->irq = irq;

pci_set_drvdata(pdev, dev);

hmp->chip_id = chip_id;

hmp->pci_dev = pdev;

if (option > 0) {

hmp->option = option;

if (option & 0x200)

hmp->full_duplex = 1;

else if (option & 0x080)

hmp->full_duplex = 0;

hmp->default_port = option & 15;

if (hmp->default_port)

hmp->medialock = 1;

}

if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)

hmp->full_duplex = 1;

if (hmp->full_duplex || (option & 0x080))

hmp->duplex_lock = 1;

max_rx_latency = max_rx_latency & 0x00ff;

max_rx_gap = max_rx_gap & 0x00ff;

min_rx_pkt = min_rx_pkt & 0x00ff;

max_tx_latency = max_tx_latency & 0x00ff;

max_tx_gap = max_tx_gap & 0x00ff;

min_tx_pkt = min_tx_pkt & 0x00ff;

rx_int_var = card_idx < MAX_UNITS ? rx_params[card_idx] : -1;

tx_int_var = card_idx < MAX_UNITS ? tx_params[card_idx] : -1;

hmp->rx_int_var = rx_int_var >= 0 ? rx_int_var :

(min_rx_pkt << 16 | max_rx_gap << 8 | max_rx_latency);

hmp->tx_int_var = tx_int_var >= 0 ? tx_int_var :

(min_tx_pkt << 16 | max_tx_gap << 8 | max_tx_latency);

dev->open = &hamachi_open;

dev->hard_start_xmit = &hamachi_start_xmit;

dev->stop = &hamachi_close;

dev->get_stats = &hamachi_get_stats;

dev->set_multicast_list = &set_rx_mode;

dev->do_ioctl = &netdev_ioctl;

dev->tx_timeout = &hamachi_tx_timeout;

dev->watchdog_timeo = TX_TIMEOUT;

if (mtu)

dev->mtu = mtu;

i = register_netdev(dev);

if (i) {

ret = i;

goto err_out_unmap_rx;

}

printk(KERN_INFO "%s: %s type %x at 0x%lx, ",

dev->name, chip_tbl[chip_id].name, readl(ioaddr + ChipRev),

ioaddr);

for (i = 0; i < 5; i++)

printk("%2.2x:", dev->dev_addr[i]);

printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);

i = readb(ioaddr + PCIClkMeas);

printk(KERN_INFO "%s: %d-bit %d Mhz PCI bus (%d), Virtual Jumpers "

"%2.2x, LPA %4.4x.\n",

dev->name, readw(ioaddr + MiscStatus) & 1 ? 64 : 32,

i ? 2000/(i&0x7f) : 0, i&0x7f, (int)readb(ioaddr + VirtualJumpers),

readw(ioaddr + ANLinkPartnerAbility));

if (chip_tbl[hmp->chip_id].flags & CanHaveMII) {

int phy, phy_idx = 0;

for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {

int mii_status = mdio_read(ioaddr, phy, 1);

if (mii_status != 0xffff &&

mii_status != 0x0000) {

hmp->phys[phy_idx++] = phy;

hmp->advertising = mdio_read(ioaddr, phy, 4);

printk(KERN_INFO "%s: MII PHY found at address %d, status "

"0x%4.4x advertising %4.4x.\n",

dev->name, phy, mii_status, hmp->advertising);

}

hmp->mii_cnt = phy_idx;

}

writew(0x0400, ioaddr + ANXchngCtrl);

writew(0x08e0, ioaddr + ANAdvertise);

writew(0x1000, ioaddr + ANCtrl);

card_idx++;

return 0;

err_out_unmap_rx:

pci_free_consistent(pdev, RX_TOTAL_SIZE, hmp->rx_ring,

hmp->rx_ring_dma);

err_out_unmap_tx:

pci_free_consistent(pdev, TX_TOTAL_SIZE, hmp->tx_ring,

hmp->tx_ring_dma);

err_out_cleardev:

kfree (dev);

err_out_iounmap:

iounmap((char *)ioaddr);

err_out_release:

pci_release_regions(pdev);

err_out:

return ret;

}

static int __init read_eeprom(long ioaddr, int location)

{

int bogus_cnt = 1000;

while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);

writew(location, ioaddr + EEAddr);

writeb(0x02, ioaddr + EECmdStatus);

bogus_cnt = 1000;

while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);

if (hamachi_debug > 5)

printk(" EEPROM status is %2.2x after %d ticks.\n",

(int)readb(ioaddr + EECmdStatus), 1000- bogus_cnt);

return readb(ioaddr + EEData);

}

static int mdio_read(long ioaddr, int phy_id, int location)

{

int i;

for (i = 10000; i >= 0; i--)

if ((readw(ioaddr + MII_Status) & 1) == 0)

break;

writew((phy_id<<8) + location, ioaddr + MII_Addr);

writew(0x0001, ioaddr + MII_Cmd);

for (i = 10000; i >= 0; i--)

if ((readw(ioaddr + MII_Status) & 1) == 0)

break;

return readw(ioaddr + MII_Rd_Data);

}

static void mdio_write(long ioaddr, int phy_id, int location, int value)

{

int i;

for (i = 10000; i >= 0; i--)

if ((readw(ioaddr + MII_Status) & 1) == 0)

break;

writew((phy_id<<8) + location, ioaddr + MII_Addr);

writew(value, ioaddr + MII_Wr_Data);

for (i = 10000; i >= 0; i--)

if ((readw(ioaddr + MII_Status) & 1) == 0)

break;

return;

}

static int hamachi_open(struct net_device *dev)

{

struct hamachi_private *hmp = dev->priv;

long ioaddr = dev->base_addr;

int i;

u32 rx_int_var, tx_int_var;

u16 fifo_info;

i = request_irq(dev->irq, &hamachi_interrupt, SA_SHIRQ, dev->name, dev);

if (i)

return i;

if (hamachi_debug > 1)

printk(KERN_DEBUG "%s: hamachi_open() irq %d.\n",

dev->name, dev->irq);

hamachi_init_ring(dev);

#if ADDRLEN == 64

writel(cpu_to_le64(hmp->rx_ring_dma), ioaddr + RxPtr);

writel(cpu_to_le64(hmp->rx_ring_dma) >> 32, ioaddr + RxPtr + 4);

writel(cpu_to_le64(hmp->tx_ring_dma), ioaddr + TxPtr);

writel(cpu_to_le64(hmp->tx_ring_dma) >> 32, ioaddr + TxPtr + 4);

#else

writel(cpu_to_le32(hmp->rx_ring_dma), ioaddr + RxPtr);

writel(cpu_to_le32(hmp->tx_ring_dma), ioaddr + TxPtr);

#endif

for (i = 0; i < 6; i++)

writeb(dev->dev_addr[i], ioaddr + StationAddr + i);

fifo_info = (readw(ioaddr + GPIO) & 0x00C0) >> 6;

switch (fifo_info){

case 0 :

writew(0x0000, ioaddr + FIFOcfg);

break;

case 1 :

writew(0x0028, ioaddr + FIFOcfg);

break;

case 2 :

writew(0x004C, ioaddr + FIFOcfg);

break;

case 3 :

writew(0x006C, ioaddr + FIFOcfg);

break;

default :

printk(KERN_WARNING "%s: Unsupported external memory config!\n",

dev->name);

writew(0x0000, ioaddr + FIFOcfg);

break;

}

if (dev->if_port == 0)

dev->if_port = hmp->default_port;

if (hmp->duplex_lock != 1)

hmp->full_duplex = 1;

writew(0x0001, ioaddr + RxChecksum);

#ifdef TX_CHECKSUM

writew(0x0001, ioaddr + TxChecksum);

#else

writew(0x0000, ioaddr + TxChecksum);

#endif

writew(0x8000, ioaddr + MACCnfg);

writew(0x215F, ioaddr + MACCnfg);

writew(0x000C, ioaddr + FrameGap0);

writew(0x1018, ioaddr + FrameGap1);

writew(0x0780, ioaddr + MACCnfg2);

writel(0x0030FFFF, ioaddr + FlowCtrl);

writew(MAX_FRAME_SIZE, ioaddr + MaxFrameSize);

writew(0x0400, ioaddr + ANXchngCtrl);

writeb(0x03, ioaddr + LEDCtrl);

rx_int_var = hmp->rx_int_var;

tx_int_var = hmp->tx_int_var;

if (hamachi_debug > 1) {

printk("max_tx_latency: %d, max_tx_gap: %d, min_tx_pkt: %d\n",

tx_int_var & 0x00ff, (tx_int_var & 0x00ff00) >> 8,

(tx_int_var & 0x00ff0000) >> 16);

printk("max_rx_latency: %d, max_rx_gap: %d, min_rx_pkt: %d\n",

rx_int_var & 0x00ff, (rx_int_var & 0x00ff00) >> 8,

(rx_int_var & 0x00ff0000) >> 16);

printk("rx_int_var: %x, tx_int_var: %x\n", rx_int_var, tx_int_var);

}

writel(tx_int_var, ioaddr + TxIntrCtrl);

writel(rx_int_var, ioaddr + RxIntrCtrl);

set_rx_mode(dev);

netif_start_queue(dev);

writel(0x80878787, ioaddr + InterruptEnable);

writew(0x0000, ioaddr + EventStatus);

#if ADDRLEN == 64

writew(0x005D, ioaddr + RxDMACtrl);

writew(0x005D, ioaddr + TxDMACtrl);

#else

writew(0x001D, ioaddr + RxDMACtrl);

writew(0x001D, ioaddr + TxDMACtrl);

#endif

writew(0x0001, dev->base_addr + RxCmd);

if (hamachi_debug > 2) {

printk(KERN_DEBUG "%s: Done hamachi_open(), status: Rx %x Tx %x.\n",

dev->name, readw(ioaddr + RxStatus), readw(ioaddr + TxStatus));

}

init_timer(&hmp->timer);

hmp->timer.expires = RUN_AT((24*HZ)/10);

hmp->timer.data = (unsigned long)dev;

hmp->timer.function = &hamachi_timer;

add_timer(&hmp->timer);

return 0;

}

static inline int hamachi_tx(struct net_device *dev)

{

struct hamachi_private *hmp = dev->priv;

for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++) {

int entry = hmp->dirty_tx % TX_RING_SIZE;

struct sk_buff *skb;

if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))

break;

skb = hmp->tx_skbuff[entry];

if (skb != 0) {

pci_unmap_single(hmp->pci_dev,

hmp->tx_ring[entry].addr, skb->len,

PCI_DMA_TODEVICE);

dev_kfree_skb(skb);

hmp->tx_skbuff[entry] = 0;

}

hmp->tx_ring[entry].status_n_length = 0;

if (entry >= TX_RING_SIZE-1)

hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=

cpu_to_le32(DescEndRing);

hmp->stats.tx_packets++;

}

return 0;

}

static void hamachi_timer(unsigned long data)

{

struct net_device *dev = (struct net_device *)data;

struct hamachi_private *hmp = dev->priv;

long ioaddr = dev->base_addr;

int next_tick = 10*HZ;

if (hamachi_debug > 2) {

printk(KERN_INFO "%s: Hamachi Autonegotiation status %4.4x, LPA "

"%4.4x.\n", dev->name, readw(ioaddr + ANStatus),

readw(ioaddr + ANLinkPartnerAbility));

printk(KERN_INFO "%s: Autonegotiation regs %4.4x %4.4x %4.4x "

"%4.4x %4.4x %4.4x.\n", dev->name,

readw(ioaddr + 0x0e0),

readw(ioaddr + 0x0e2),

readw(ioaddr + 0x0e4),

readw(ioaddr + 0x0e6),

readw(ioaddr + 0x0e8),

readw(ioaddr + 0x0eA));

}

hmp->timer.expires = RUN_AT(next_tick);

add_timer(&hmp->timer);

}

static void hamachi_tx_timeout(struct net_device *dev)

{

int i;

struct hamachi_private *hmp = dev->priv;

long ioaddr = dev->base_addr;

printk(KERN_WARNING "%s: Hamachi transmit timed out, status %8.8x,"

" resetting...\n", dev->name, (int)readw(ioaddr + TxStatus));

{

int i;

printk(KERN_DEBUG " Rx ring %p: ", hmp->rx_ring);

for (i = 0; i < RX_RING_SIZE; i++)

printk(" %8.8x", (unsigned int)hmp->rx_ring[i].status_n_length);

printk("\n"KERN_DEBUG" Tx ring %p: ", hmp->tx_ring);

for (i = 0; i < TX_RING_SIZE; i++)

printk(" %4.4x", hmp->tx_ring[i].status_n_length);

printk("\n");

}

dev->if_port = 0;

for (i = 0; i < RX_RING_SIZE; i++)

hmp->rx_ring[i].status_n_length &= cpu_to_le32(~DescOwn);

for (i = 0; i < TX_RING_SIZE; i++){

struct sk_buff *skb;

if (i >= TX_RING_SIZE - 1)

hmp->tx_ring[i].status_n_length = cpu_to_le32(

DescEndRing |

(hmp->tx_ring[i].status_n_length & 0x0000FFFF));

else

hmp->tx_ring[i].status_n_length &= 0x0000ffff;

skb = hmp->tx_skbuff[i];

if (skb){

pci_unmap_single(hmp->pci_dev, hmp->tx_ring[i].addr,

skb->len, PCI_DMA_TODEVICE);

dev_kfree_skb(skb);

hmp->tx_skbuff[i] = 0;

}

udelay(60);

writew(0x0002, dev->base_addr + RxCmd);

writeb(0x01, ioaddr + ChipReset);

hmp->tx_full = 0;

hmp->cur_rx = hmp->cur_tx = 0;

hmp->dirty_rx = hmp->dirty_tx = 0;

for (i = 0; i < RX_RING_SIZE; i++){

struct sk_buff *skb = hmp->rx_skbuff[i];

if (skb){

pci_unmap_single(hmp->pci_dev, hmp->rx_ring[i].addr,

hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);

dev_kfree_skb(skb);

hmp->rx_skbuff[i] = 0;

}

for (i = 0; i < RX_RING_SIZE; i++) {

struct sk_buff *skb = dev_alloc_skb(hmp->rx_buf_sz);

hmp->rx_skbuff[i] = skb;

if (skb == NULL)

break;

skb->dev = dev;

skb_reserve(skb, 2);

hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,

skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));

hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |

DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));

}

hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);

hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);

dev->trans_start = jiffies;

hmp->stats.tx_errors++;

writew(0x0002, dev->base_addr + TxCmd);

writew(0x0001, dev->base_addr + TxCmd);

writew(0x0001, dev->base_addr + RxCmd);

netif_wake_queue(dev);

}

static void hamachi_init_ring(struct net_device *dev)

{

struct hamachi_private *hmp = dev->priv;

int i;

hmp->tx_full = 0;

hmp->cur_rx = hmp->cur_tx = 0;

hmp->dirty_rx = hmp->dirty_tx = 0;

#if 0

hmp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);

#endif

hmp->rx_buf_sz = (dev->mtu <= 1492 ? PKT_BUF_SZ :

(((dev->mtu+26+7) & ~7) + 2 + 16));

for (i = 0; i < RX_RING_SIZE; i++) {

hmp->rx_ring[i].status_n_length = 0;

hmp->rx_skbuff[i] = 0;

}

for (i = 0; i < RX_RING_SIZE; i++) {

struct sk_buff *skb = dev_alloc_skb(hmp->rx_buf_sz);

hmp->rx_skbuff[i] = skb;

if (skb == NULL)

break;

skb->dev = dev;

skb_reserve(skb, 2);

hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,

skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));

hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |

DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));

}

hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);

hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);

for (i = 0; i < TX_RING_SIZE; i++) {

hmp->tx_skbuff[i] = 0;

hmp->tx_ring[i].status_n_length = 0;

}

hmp->tx_ring[TX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);

return;

}

#ifdef TX_CHECKSUM

#define csum_add(it, val) \

do { \

it += (u16) (val); \

if (it & 0xffff0000) { \

it &= 0xffff; \

++it; \

} \

} while (0)

#define pseudo_csum_udp(sum,ih,uh) do { \

sum = 0; \

csum_add(sum, (ih)->saddr >> 16); \

csum_add(sum, (ih)->saddr & 0xffff); \

csum_add(sum, (ih)->daddr >> 16); \

csum_add(sum, (ih)->daddr & 0xffff); \

csum_add(sum, __constant_htons(IPPROTO_UDP)); \

csum_add(sum, (uh)->len); \

} while (0)

#define pseudo_csum_tcp(sum,ih,len) do { \

sum = 0; \

csum_add(sum, (ih)->saddr >> 16); \

csum_add(sum, (ih)->saddr & 0xffff); \

csum_add(sum, (ih)->daddr >> 16); \

csum_add(sum, (ih)->daddr & 0xffff); \

csum_add(sum, __constant_htons(IPPROTO_TCP)); \

csum_add(sum, htons(len)); \

} while (0)

#endif

static int hamachi_start_xmit(struct sk_buff *skb, struct net_device *dev)

{

struct hamachi_private *hmp = dev->priv;

unsigned entry;

u16 status;

if (hmp->tx_full) {

printk(KERN_WARNING "%s: Hamachi transmit queue full at slot %d.\n",dev->name, hmp->cur_tx);

status=readw(dev->base_addr + TxStatus);

if( !(status & 0x0001) || (status & 0x0002))

writew(0x0001, dev->base_addr + TxCmd);

return 1;

}

entry = hmp->cur_tx % TX_RING_SIZE;

hmp->tx_skbuff[entry] = skb;

#ifdef TX_CHECKSUM

{

u32 tagval = 0;

struct ethhdr *eh = (struct ethhdr *)skb->data;

if (eh->h_proto == __constant_htons(ETH_P_IP)) {

struct iphdr *ih = (struct iphdr *)((char *)eh + ETH_HLEN);

if (ih->protocol == IPPROTO_UDP) {

struct udphdr *uh

= (struct udphdr *)((char *)ih + ih->ihl*4);

u32 offset = ((unsigned char *)uh + 6) - skb->data;

u32 pseudo;

pseudo_csum_udp(pseudo, ih, uh);

pseudo = htons(pseudo);

printk("udp cksum was %04x, sending pseudo %04x\n",

uh->check, pseudo);

uh->check = 0;

tagval = (14 << 24) | (offset << 16) | pseudo;

} else if (ih->protocol == IPPROTO_TCP) {

printk("tcp, no auto cksum\n");

}

*(u32 *)skb_push(skb, 8) = tagval;

}

#endif

hmp->tx_ring[entry].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,

skb->data, skb->len, PCI_DMA_TODEVICE));

if (entry >= TX_RING_SIZE-1)

hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |

DescEndPacket | DescEndRing | DescIntr | skb->len);

else

hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |

DescEndPacket | DescIntr | skb->len);

hmp->cur_tx++;

status=readw(dev->base_addr + TxStatus);

if( !(status & 0x0001) || (status & 0x0002))

writew(0x0001, dev->base_addr + TxCmd);

hamachi_tx(dev);

if ((hmp->cur_tx - hmp->dirty_tx) < (TX_RING_SIZE - 4))

netif_wake_queue(dev);

else {

hmp->tx_full = 1;

netif_stop_queue(dev);

}

dev->trans_start = jiffies;

if (hamachi_debug > 4) {

printk(KERN_DEBUG "%s: Hamachi transmit frame #%d queued in slot %d.\n",

dev->name, hmp->cur_tx, entry);

}

return 0;

}

static void hamachi_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)

{

struct net_device *dev = dev_instance;

struct hamachi_private *hmp;

long ioaddr, boguscnt = max_interrupt_work;

#ifndef final_version

if (dev == NULL) {

printk (KERN_ERR "hamachi_interrupt(): irq %d for unknown device.\n", irq);

return;

}

#endif

ioaddr = dev->base_addr;

hmp = dev->priv;

spin_lock(&hmp->lock);

do {

u32 intr_status = readl(ioaddr + InterruptClear);

if (hamachi_debug > 4)

printk(KERN_DEBUG "%s: Hamachi interrupt, status %4.4x.\n",

dev->name, intr_status);

if (intr_status == 0)

break;

if (intr_status & IntrRxDone)

hamachi_rx(dev);

if (intr_status & IntrTxDone){

if (hmp->tx_full){

for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++){

int entry = hmp->dirty_tx % TX_RING_SIZE;

struct sk_buff *skb;

if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))

break;

skb = hmp->tx_skbuff[entry];

if (skb){

pci_unmap_single(hmp->pci_dev,

hmp->tx_ring[entry].addr,

skb->len,

PCI_DMA_TODEVICE);

dev_kfree_skb_irq(skb);

hmp->tx_skbuff[entry] = 0;

}

hmp->tx_ring[entry].status_n_length = 0;

if (entry >= TX_RING_SIZE-1)

hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=

cpu_to_le32(DescEndRing);

hmp->stats.tx_packets++;

}

if (hmp->cur_tx - hmp->dirty_tx < TX_RING_SIZE - 4){

hmp->tx_full = 0;

netif_wake_queue(dev);

}

} else {

netif_wake_queue(dev);

}

if (intr_status &

(IntrTxPCIFault | IntrTxPCIErr | IntrRxPCIFault | IntrRxPCIErr |

LinkChange | NegotiationChange | StatsMax))

hamachi_error(dev, intr_status);

if (--boguscnt < 0) {

printk(KERN_WARNING "%s: Too much work at interrupt, status=0x%4.4x.\n",

dev->name, intr_status);

break;

}

} while (1);

if (hamachi_debug > 3)

printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",

dev->name, readl(ioaddr + IntrStatus));

#ifndef final_version

{

static int stopit = 10;

if (dev->start == 0 && --stopit < 0) {

printk(KERN_ERR "%s: Emergency stop, looping startup interrupt.\n",

dev->name);

free_irq(irq, dev);

}

#endif

spin_unlock(&hmp->lock);

}

#ifdef TX_CHECKSUM

static unsigned short hamachi_eth_type_trans(struct sk_buff *skb,

struct net_device *dev)

{

struct ethhdr *eth;

unsigned char *rawp;

skb->mac.raw=skb->data;

skb_pull(skb,dev->hard_header_len-8);

eth= skb->mac.ethernet;

if(*eth->h_dest&1)

{

if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)

skb->pkt_type=PACKET_BROADCAST;

else

skb->pkt_type=PACKET_MULTICAST;

}

else if(dev->flags&(IFF_PROMISC))

{

if(memcmp(eth->h_dest,dev->dev_addr, ETH_ALEN))

skb->pkt_type=PACKET_OTHERHOST;

}

if (ntohs(eth->h_proto) >= 1536)

return eth->h_proto;

rawp = skb->data;

if (*(unsigned short *)rawp == 0xFFFF)

return htons(ETH_P_802_3);

return htons(ETH_P_802_2);

}

#endif

static int hamachi_rx(struct net_device *dev)

{

struct hamachi_private *hmp = dev->priv;

int entry = hmp->cur_rx % RX_RING_SIZE;

int boguscnt = (hmp->dirty_rx + RX_RING_SIZE) - hmp->cur_rx;

if (hamachi_debug > 4) {

printk(KERN_DEBUG " In hamachi_rx(), entry %d status %4.4x.\n",

entry, hmp->rx_ring[entry].status_n_length);

}

while (1) {

struct hamachi_desc *desc = &(hmp->rx_ring[entry]);

u32 desc_status = le32_to_cpu(desc->status_n_length);

u16 data_size = desc_status;

u8 *buf_addr;

s32 frame_status;

if (desc_status & DescOwn)

break;

pci_dma_sync_single(hmp->pci_dev, desc->addr, hmp->rx_buf_sz,

PCI_DMA_FROMDEVICE);

buf_addr = (u8 *)hmp->rx_ring + entry*sizeof(*desc);

frame_status = le32_to_cpu(get_unaligned((s32*)&(buf_addr[data_size - 12])));

if (hamachi_debug > 4)

printk(KERN_DEBUG " hamachi_rx() status was %8.8x.\n",

frame_status);

if (--boguscnt < 0)

break;

if ( ! (desc_status & DescEndPacket)) {

printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "

"multiple buffers, entry %#x length %d status %4.4x!\n",

dev->name, hmp->cur_rx, data_size, desc_status);

printk(KERN_WARNING "%s: Oversized Ethernet frame %p vs %p.\n",

dev->name, desc, &hmp->rx_ring[hmp->cur_rx % RX_RING_SIZE]);

printk(KERN_WARNING "%s: Oversized Ethernet frame -- next status %x/%x last status %x.\n",

dev->name,

hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length & 0xffff0000,

hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length & 0x0000ffff,

hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length);

hmp->stats.rx_length_errors++;

}

if (frame_status & 0x00380000) {

if (hamachi_debug > 2)

printk(KERN_DEBUG " hamachi_rx() Rx error was %8.8x.\n",

frame_status);

hmp->stats.rx_errors++;

if (frame_status & 0x00600000) hmp->stats.rx_length_errors++;

if (frame_status & 0x00080000) hmp->stats.rx_frame_errors++;

if (frame_status & 0x00100000) hmp->stats.rx_crc_errors++;

if (frame_status < 0) hmp->stats.rx_dropped++;

} else {

struct sk_buff *skb;

u16 pkt_len = (frame_status & 0x07ff) - 4;

#ifdef RX_CHECKSUM

u32 pfck = *(u32 *) &buf_addr[data_size - 8];

#endif

#ifndef final_version

if (hamachi_debug > 4)

printk(KERN_DEBUG " hamachi_rx() normal Rx pkt length %d"

" of %d, bogus_cnt %d.\n",

pkt_len, data_size, boguscnt);

if (hamachi_debug > 5)

printk(KERN_DEBUG"%s: rx status %8.8x %8.8x %8.8x %8.8x %8.8x.\n",

dev->name,

*(s32*)&(buf_addr[data_size - 20]),

*(s32*)&(buf_addr[data_size - 16]),

*(s32*)&(buf_addr[data_size - 12]),

*(s32*)&(buf_addr[data_size - 8]),

*(s32*)&(buf_addr[data_size - 4]));

#endif

if (pkt_len < rx_copybreak

&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {

#ifdef RX_CHECKSUM

printk(KERN_ERR "%s: rx_copybreak non-zero "

"not good with RX_CHECKSUM\n", dev->name);

#endif

skb->dev = dev;

skb_reserve(skb, 2);

#if 1 || USE_IP_COPYSUM

eth_copy_and_sum(skb,

hmp->rx_skbuff[entry]->data, pkt_len, 0);

skb_put(skb, pkt_len);

#else

memcpy(skb_put(skb, pkt_len), hmp->rx_ring_dma

+ entry*sizeof(*desc), pkt_len);

#endif

} else {

pci_unmap_single(hmp->pci_dev,

hmp->rx_ring[entry].addr,

hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);

skb_put(skb = hmp->rx_skbuff[entry], pkt_len);

hmp->rx_skbuff[entry] = NULL;

}

#ifdef TX_CHECKSUM

skb->protocol = hamachi_eth_type_trans(skb, dev);

#else

skb->protocol = eth_type_trans(skb, dev);

#endif

#ifdef RX_CHECKSUM

if (pfck>>24 == 0x91 || pfck>>24 == 0x51) {

struct iphdr *ih = (struct iphdr *) skb->data;

if (ntohs(ih->tot_len) >= 46){

if (!(ih->frag_off & __constant_htons(IP_MF|IP_OFFSET))) {

u32 inv = *(u32 *) &buf_addr[data_size - 16];

u32 *p = (u32 *) &buf_addr[data_size - 20];

if (inv & 4) {

inv &= ~4;

--p;

}

p_r = *p;

p_r1 = *(p-1);

switch (inv) {

case 0:

crc = (p_r & 0xffff) + (p_r >> 16);

break;

case 1:

crc = (p_r >> 16) + (p_r & 0xffff)

+ (p_r1 >> 16 & 0xff00);

break;

case 2:

crc = p_r + (p_r1 >> 16);

break;

case 3:

crc = p_r + (p_r1 & 0xff00) + (p_r1 >> 16);

break;

default: crc = 0;

}

if (crc & 0xffff0000) {

crc &= 0xffff;

++crc;

}

skb->csum = ntohs(pfck & 0xffff);

if (skb->csum > crc)

skb->csum -= crc;

else

skb->csum += (~crc & 0xffff);

skb->ip_summed = CHECKSUM_HW;

}

#endif

netif_rx(skb);

dev->last_rx = jiffies;

hmp->stats.rx_packets++;

}

entry = (++hmp->cur_rx) % RX_RING_SIZE;

}

for (; hmp->cur_rx - hmp->dirty_rx > 0; hmp->dirty_rx++) {

struct hamachi_desc *desc;

entry = hmp->dirty_rx % RX_RING_SIZE;

desc = &(hmp->rx_ring[entry]);

if (hmp->rx_skbuff[entry] == NULL) {

struct sk_buff *skb = dev_alloc_skb(hmp->rx_buf_sz);

hmp->rx_skbuff[entry] = skb;

if (skb == NULL)

break;

skb->dev = dev;

skb_reserve(skb, 2);

desc->addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,

skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));

}

desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);

if (entry >= RX_RING_SIZE-1)

desc->status_n_length |= cpu_to_le32(DescOwn |

DescEndPacket | DescEndRing | DescIntr);

else

desc->status_n_length |= cpu_to_le32(DescOwn |

DescEndPacket | DescIntr);

}

if (readw(dev->base_addr + RxStatus) & 0x0002)

writew(0x0001, dev->base_addr + RxCmd);

return 0;

}

static void hamachi_error(struct net_device *dev, int intr_status)

{

long ioaddr = dev->base_addr;

struct hamachi_private *hmp = dev->priv;

if (intr_status & (LinkChange|NegotiationChange)) {

if (hamachi_debug > 1)

printk(KERN_INFO "%s: Link changed: AutoNegotiation Ctrl"

" %4.4x, Status %4.4x %4.4x Intr status %4.4x.\n",

dev->name, readw(ioaddr + 0x0E0), readw(ioaddr + 0x0E2),

readw(ioaddr + ANLinkPartnerAbility),

readl(ioaddr + IntrStatus));

if (readw(ioaddr + ANStatus) & 0x20)

writeb(0x01, ioaddr + LEDCtrl);

else

writeb(0x03, ioaddr + LEDCtrl);

}

if (intr_status & StatsMax) {

hamachi_get_stats(dev);

readl(ioaddr + 0x370);

readl(ioaddr + 0x3F0);

}

if ((intr_status & ~(LinkChange|StatsMax|NegotiationChange|IntrRxDone|IntrTxDone))

&& hamachi_debug)

printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",

dev->name, intr_status);

if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))

hmp->stats.tx_fifo_errors++;

if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))

hmp->stats.rx_fifo_errors++;

}

static int hamachi_close(struct net_device *dev)

{

long ioaddr = dev->base_addr;

struct hamachi_private *hmp = dev->priv;

struct sk_buff *skb;

int i;

netif_stop_queue(dev);

if (hamachi_debug > 1) {

printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %4.4x Rx %4.4x Int %2.2x.\n",

dev->name, readw(ioaddr + TxStatus),

readw(ioaddr + RxStatus), readl(ioaddr + IntrStatus));

printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",

dev->name, hmp->cur_tx, hmp->dirty_tx, hmp->cur_rx, hmp->dirty_rx);

}

writel(0x0000, ioaddr + InterruptEnable);

writel(2, ioaddr + RxCmd);

writew(2, ioaddr + TxCmd);

#ifdef __i386__

if (hamachi_debug > 2) {

printk("\n"KERN_DEBUG" Tx ring at %8.8x:\n",

(int)hmp->tx_ring_dma);

for (i = 0; i < TX_RING_SIZE; i++)

printk(" %c #%d desc. %8.8x %8.8x.\n",

readl(ioaddr + TxCurPtr) == (long)&hmp->tx_ring[i] ? '>' : ' ',

i, hmp->tx_ring[i].status_n_length, hmp->tx_ring[i].addr);

printk("\n"KERN_DEBUG " Rx ring %8.8x:\n",

(int)hmp->rx_ring_dma);

for (i = 0; i < RX_RING_SIZE; i++) {

printk(KERN_DEBUG " %c #%d desc. %4.4x %8.8x\n",

readl(ioaddr + RxCurPtr) == (long)&hmp->rx_ring[i] ? '>' : ' ',

i, hmp->rx_ring[i].status_n_length, hmp->rx_ring[i].addr);

if (hamachi_debug > 6) {

if (*(u8*)hmp->rx_skbuff[i]->tail != 0x69) {

u16 *addr = (u16 *)

hmp->rx_skbuff[i]->tail;

int j;

for (j = 0; j < 0x50; j++)

printk(" %4.4x", addr[j]);

printk("\n");

}

#endif

free_irq(dev->irq, dev);

del_timer_sync(&hmp->timer);

for (i = 0; i < RX_RING_SIZE; i++) {

skb = hmp->rx_skbuff[i];

hmp->rx_ring[i].status_n_length = 0;

hmp->rx_ring[i].addr = 0xBADF00D0;

if (skb) {

pci_unmap_single(hmp->pci_dev,

hmp->rx_ring[i].addr, hmp->rx_buf_sz,

PCI_DMA_FROMDEVICE);

dev_kfree_skb(skb);

hmp->rx_skbuff[i] = 0;

}

for (i = 0; i < TX_RING_SIZE; i++) {

skb = hmp->tx_skbuff[i];

if (skb) {

pci_unmap_single(hmp->pci_dev,

hmp->tx_ring[i].addr, skb->len,

PCI_DMA_TODEVICE);

dev_kfree_skb(skb);

hmp->tx_skbuff[i] = 0;

}

writeb(0x00, ioaddr + LEDCtrl);

return 0;

}

static struct net_device_stats *hamachi_get_stats(struct net_device *dev)

{

long ioaddr = dev->base_addr;

struct hamachi_private *hmp = dev->priv;

hmp->stats.rx_bytes = readl(ioaddr + 0x330);

hmp->stats.tx_bytes = readl(ioaddr + 0x3B0);

hmp->stats.multicast = readl(ioaddr + 0x320);

hmp->stats.rx_length_errors = readl(ioaddr + 0x368);

hmp->stats.rx_over_errors = readl(ioaddr + 0x35C);

hmp->stats.rx_crc_errors = readl(ioaddr + 0x360);

hmp->stats.rx_frame_errors = readl(ioaddr + 0x364);

hmp->stats.rx_missed_errors = readl(ioaddr + 0x36C);

return &hmp->stats;

}

static void set_rx_mode(struct net_device *dev)

{

long ioaddr = dev->base_addr;

if (dev->flags & IFF_PROMISC) {

printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);

writew(0x000F, ioaddr + AddrMode);

} else if ((dev->mc_count > 63) || (dev->flags & IFF_ALLMULTI)) {

writew(0x000B, ioaddr + AddrMode);

} else if (dev->mc_count > 0) {

struct dev_mc_list *mclist;

int i;

for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;

i++, mclist = mclist->next) {

writel(*(u32*)(mclist->dmi_addr), ioaddr + 0x100 + i*8);

writel(0x20000 | (*(u16*)&mclist->dmi_addr[4]),

ioaddr + 0x104 + i*8);

}

for (; i < 64; i++)

writel(0, ioaddr + 0x104 + i*8);

writew(0x0003, ioaddr + AddrMode);

} else {

writew(0x0001, ioaddr + AddrMode);

}

static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)

{

struct hamachi_private *hmp = dev->priv;

u32 ethcmd;

if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))

return -EFAULT;

switch (ethcmd) {

case ETHTOOL_GDRVINFO: {

struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};

strcpy(info.driver, DRV_NAME);

strcpy(info.version, DRV_VERSION);

strcpy(info.bus_info, hmp->pci_dev->slot_name);

if (copy_to_user(useraddr, &info, sizeof(info)))

return -EFAULT;

return 0;

}

return -EOPNOTSUPP;

}

static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)

{

long ioaddr = dev->base_addr;

struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;

switch(cmd) {

case SIOCETHTOOL:

return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);

case SIOCGMIIPHY:

case SIOCDEVPRIVATE:

data->phy_id = ((struct hamachi_private *)dev->priv)->phys[0] & 0x1f;

case SIOCGMIIREG:

case SIOCDEVPRIVATE+1:

data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f);

return 0;

case SIOCSMIIREG:

case SIOCDEVPRIVATE+2:

if (!capable(CAP_NET_ADMIN))

return -EPERM;

mdio_write(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);

return 0;

case SIOCDEVPRIVATE+3: {

u32 *d = (u32 *)&rq->ifr_data;

if (!capable(CAP_NET_ADMIN))

return -EPERM;

writel(d[0], dev->base_addr + TxIntrCtrl);

writel(d[1], dev->base_addr + RxIntrCtrl);

printk(KERN_NOTICE "%s: tx %08x, rx %08x intr\n", dev->name,

(u32) readl(dev->base_addr + TxIntrCtrl),

(u32) readl(dev->base_addr + RxIntrCtrl));

return 0;

}

default:

return -EOPNOTSUPP;

}

static void __devexit hamachi_remove_one (struct pci_dev *pdev)

{

struct net_device *dev = pci_get_drvdata(pdev);

if (dev) {

struct hamachi_private *hmp = dev->priv;

pci_free_consistent(pdev, RX_TOTAL_SIZE, hmp->rx_ring,

hmp->rx_ring_dma);

pci_free_consistent(pdev, TX_TOTAL_SIZE, hmp->tx_ring,

hmp->tx_ring_dma);

unregister_netdev(dev);

iounmap((char *)dev->base_addr);

kfree(dev);

pci_release_regions(pdev);

pci_set_drvdata(pdev, NULL);

}

static struct pci_device_id hamachi_pci_tbl[] __initdata = {

{ 0x1318, 0x0911, PCI_ANY_ID, PCI_ANY_ID, },

{ 0, }

};

MODULE_DEVICE_TABLE(pci, hamachi_pci_tbl);

static struct pci_driver hamachi_driver = {

name: DRV_NAME,

id_table: hamachi_pci_tbl,

probe: hamachi_init_one,

remove: __devexit_p(hamachi_remove_one),

};

static int __init hamachi_init (void)

{

#ifdef MODULE

printk(version);

#endif

if (pci_register_driver(&hamachi_driver) > 0)

return 0;

pci_unregister_driver(&hamachi_driver);

return -ENODEV;

}在模块初始化的时候

static void __exit hamachi_exit (void)

{

pci_unregister_driver(&hamachi_driver);

}

module_init(hamachi_init);

module_exit(hamachi_exit);

pci驱动程序设计

继续阅读

What are training set, validation set and test set?

【Ubuntu报错】ModuleNotFoundError: No module named 'gdbm'

浅谈自制MFC控件浅谈自制MFC控件

华为笔试软件

probe()函数是什么时候被调用，设备和驱动是怎么联系起来的

批处理编程- -介绍DOS/BAT

二叉树先序、中序、后序三种遍历的非递归算法

C/C++头文件、函数使用说明

设置某一行背景颜色的CListCtrl

BMP文件结构及图像每行字节计算方法

linux网络编程----发送与接收文件

处理PCX文件

SIP Presence (二)RFC 3265 - Session Initiation Protocol (SIP)-Specific Event Notification

坐标系统和投影变换在桌面产品中的应用

Small tricks

Linux设备模型（中）之上层容器