原标题：ARM-Linux驱动--DM9000网卡驱动分析(四)

硬件平台：FL2440 (S3C2440)

内核版本：2.6.35

主机平台：Ubuntu 11.04

内核版本：2.6.39

交叉编译器： -linux-gcc 4.3.2

原创作品，转载请标明出处

本文接上文

- -- 分析(一)

ARM-Linux驱动--DM9000网卡驱动分析(二)

ARM-Linux驱动--DM9000网卡驱动分析(三)

1、接下来接着分析DM9000网卡驱动的数据接收函数

view plainprint?

static void

dm9000_rx(struct net_device *dev)

{

board_info_t *db = netdev_priv(dev);

struct dm9000_rxhdr rxhdr;

struct sk_buff *skb;

u8 rxbyte, *rdptr;

bool GoodPacket;

int RxLen;

do {

ior(db, DM9000_MRCMDX);

rxbyte = readb(db->io_data);

if (rxbyte & DM9000_PKT_ERR) {

dev_warn(db->dev, "status check fail: %d\n", rxbyte);

iow(db, DM9000_RCR, 0x00);

iow(db, DM9000_ISR, IMR_PAR);

return;

}

if (!(rxbyte & DM9000_PKT_RDY))

return;

GoodPacket = true;

writeb(DM9000_MRCMD, db->io_addr);

(db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));

RxLen = le16_to_cpu(rxhdr.RxLen);

if (netif_msg_rx_status(db))

dev_dbg(db->dev, "RX: status x, length x\n",

rxhdr.RxStatus, RxLen);

if (RxLen < 0x40) {

GoodPacket = false;

if (netif_msg_rx_err(db))

dev_dbg(db->dev, "RX: Bad Packet (runt)\n");

}

if (RxLen > DM9000_PKT_MAX) {

dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);

}

if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |

RSR_PLE | RSR_RWTO |

RSR_LCS | RSR_RF)) {

GoodPacket = false;

if (rxhdr.RxStatus & RSR_FOE) {

if (netif_msg_rx_err(db))

dev_dbg(db->dev, "fifo error\n");

dev->stats.rx_fifo_errors++;

}

if (rxhdr.RxStatus & RSR_CE) {

if (netif_msg_rx_err(db))

dev_dbg(db->dev, "crc error\n");

dev->stats.rx_crc_errors++;

}

if (rxhdr.RxStatus & RSR_RF) {

if (netif_msg_rx_err(db))

dev_dbg(db->dev, "length error\n");

dev->stats.rx_length_errors++;

}

}

if (GoodPacket &&

((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {

skb_reserve(skb, 2);

rdptr = (u8 *) skb_put(skb, RxLen - 4);

(db->inblk)(db->io_data, rdptr, RxLen);

dev->stats.rx_bytes += RxLen;

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

if (db->rx_csum) {

if ((((rxbyte & 0x1c) << 3) & rxbyte) == 0)

skb->ip_summed = CHECKSUM_UNNECESSARY;

else

skb->ip_summed = CHECKSUM_NONE;

}

netif_rx(skb);

dev->stats.rx_packets++;

} else {

(db->dumpblk)(db->io_data, RxLen);

}

} while (rxbyte & DM9000_PKT_RDY);

}

2、下面是完整的DM9000驱动代码，可以完整的查看

view plainprint?

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include "dm9000.h"

#include

#include

#include

#define DM9000_PHY 0x40

#define CARDNAME "dm9000"

#define DRV_VERSION "1.31"

static int watchdog = 5000;

module_param(watchdog, int, 0400);

MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");

enum dm9000_type {

TYPE_DM9000E,

TYPE_DM9000A,

TYPE_DM9000B

};

typedef struct board_info {

void __iomem *io_addr;

void __iomem *io_data;

u16 irq;

u16 tx_pkt_cnt;

u16 queue_pkt_len;

u16 queue_start_addr;

u16 queue_ip_summed;

u16 dbug_cnt;

u8 io_mode;

u8 phy_addr;

u8 imr_all;

unsigned int flags;

unsigned int in_suspend :1;

unsigned int wake_supported :1;

int debug_level;

enum dm9000_type type;

void (*inblk)(void __iomem *port, void *data, int length);

void (*outblk)(void __iomem *port, void *data, int length);

void (*dumpblk)(void __iomem *port, int length);

struct device *dev;

struct resource *addr_res;

struct resource *data_res;

struct resource *addr_req;

struct resource *data_req;

struct resource *irq_res;

int irq_wake;

struct mutex addr_lock;

struct delayed_work phy_poll;

struct net_device *ndev;

spinlock_t lock;

struct mii_if_info mii;

u32 msg_enable;

u32 wake_state;

int rx_csum;

int can_csum;

int ip_summed;

} board_info_t;

#define dm9000_dbg(db, lev, msg...) do { \

if ((lev) < CONFIG_DM9000_DEBUGLEVEL && \

(lev) < db->debug_level) { \

dev_dbg(db->dev, msg); \

} \

} while (0)

static inline board_info_t *to_dm9000_board(struct net_device *dev)

{

return netdev_priv(dev);

}

static void

dm9000_reset(board_info_t * db)

{

dev_dbg(db->dev, "resetting device\n");

writeb(DM9000_NCR, db->io_addr);

udelay(200);

writeb(NCR_RST, db->io_data);

udelay(200);

}

static u8

ior(board_info_t * db, int reg)

{

writeb(reg, db->io_addr);

return readb(db->io_data);

}

static void

iow(board_info_t * db, int reg, int value)

{

writeb(reg, db->io_addr);

writeb(value, db->io_data);

}

static void dm9000_outblk_8bit(void __iomem *reg, void *data, int count)

{

writesb(reg, data, count);

}

static void dm9000_outblk_16bit(void __iomem *reg, void *data, int count)

{

writesw(reg, data, (count+1) >> 1);

}

static void dm9000_outblk_32bit(void __iomem *reg, void *data, int count)

{

writesl(reg, data, (count+3) >> 2);

}

static void dm9000_inblk_8bit(void __iomem *reg, void *data, int count)

{

readsb(reg, data, count);

}

static void dm9000_inblk_16bit(void __iomem *reg, void *data, int count)

{

readsw(reg, data, (count+1) >> 1);

}

static void dm9000_inblk_32bit(void __iomem *reg, void *data, int count)

{

readsl(reg, data, (count+3) >> 2);

}

static void dm9000_dumpblk_8bit(void __iomem *reg, int count)

{

int i;

int tmp;

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

tmp = readb(reg);

}

static void dm9000_dumpblk_16bit(void __iomem *reg, int count)

{

int i;

int tmp;

count = (count + 1) >> 1;

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

tmp = readw(reg);

}

static void dm9000_dumpblk_32bit(void __iomem *reg, int count)

{

int i;

int tmp;

count = (count + 3) >> 2;

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

tmp = readl(reg);

}

static void dm9000_set_io(struct board_info *db, int byte_width)

{

switch (byte_width) {

case 1:

db->dumpblk = dm9000_dumpblk_8bit;

db->outblk = dm9000_outblk_8bit;

db->inblk = dm9000_inblk_8bit;

break;

case 3:

dev_dbg(db->dev, ": 3 byte IO, falling back to 16bit\n");

case 2:

db->dumpblk = dm9000_dumpblk_16bit;

db->outblk = dm9000_outblk_16bit;

db->inblk = dm9000_inblk_16bit;

break;

case 4:

default:

db->dumpblk = dm9000_dumpblk_32bit;

db->outblk = dm9000_outblk_32bit;

db->inblk = dm9000_inblk_32bit;

break;

}

}

static void dm9000_schedule_poll(board_info_t *db)

{

if (db->type == TYPE_DM9000E)

schedule_delayed_work(&db->phy_poll, HZ * 2);

}

static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd)

{

board_info_t *dm = to_dm9000_board(dev);

if (!netif_running(dev))

return -EINVAL;

return generic_mii_ioctl(&dm->mii, if_mii(req), cmd, NULL);

}

static unsigned int

dm9000_read_locked(board_info_t *db, int reg)

{

unsigned long flags;

unsigned int ret;

spin_lock_irqsave(&db->lock, flags);

ret = ior(db, reg);

spin_unlock_irqrestore(&db->lock, flags);

return ret;

}

static int dm9000_wait_eeprom(board_info_t *db)

{

unsigned int status;

int timeout = 8;

while (1) {

status = dm9000_read_locked(db, DM9000_EPCR);

if ((status & EPCR_ERRE) == 0)

break;

msleep(1);

if (timeout-- < 0) {

dev_dbg(db->dev, "timeout waiting EEPROM\n");

break;

}

}

return 0;

}

static void

dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)

{

unsigned long flags;

if (db->flags & DM9000_PLATF_NO_EEPROM) {

to[0] = 0xff;

to[1] = 0xff;

return;

}

mutex_lock(&db->addr_lock);

spin_lock_irqsave(&db->lock, flags);

iow(db, DM9000_EPAR, offset);

iow(db, DM9000_EPCR, EPCR_ERPRR);

spin_unlock_irqrestore(&db->lock, flags);

dm9000_wait_eeprom(db);

msleep(1);

spin_lock_irqsave(&db->lock, flags);

iow(db, DM9000_EPCR, 0x0);

to[0] = ior(db, DM9000_EPDRL);

to[1] = ior(db, DM9000_EPDRH);

spin_unlock_irqrestore(&db->lock, flags);

mutex_unlock(&db->addr_lock);

}

static void

dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)

{

unsigned long flags;

if (db->flags & DM9000_PLATF_NO_EEPROM)

return;

mutex_lock(&db->addr_lock);

spin_lock_irqsave(&db->lock, flags);

iow(db, DM9000_EPAR, offset);

iow(db, DM9000_EPDRH, data[1]);

iow(db, DM9000_EPDRL, data[0]);

iow(db, DM9000_EPCR, EPCR_WEP | EPCR_ERPRW);

spin_unlock_irqrestore(&db->lock, flags);

dm9000_wait_eeprom(db);

mdelay(1);

spin_lock_irqsave(&db->lock, flags);

iow(db, DM9000_EPCR, 0);

spin_unlock_irqrestore(&db->lock, flags);

mutex_unlock(&db->addr_lock);

}

static void dm9000_get_drvinfo(struct net_device *dev,

struct ethtool_drvinfo *info)

{

board_info_t *dm = to_dm9000_board(dev);

strcpy(info->driver, CARDNAME);

strcpy(info->version, DRV_VERSION);

strcpy(info->bus_info, to_platform_device(dm->dev)->name);

}

static u32 dm9000_get_msglevel(struct net_device *dev)

{

board_info_t *dm = to_dm9000_board(dev);

return dm->msg_enable;

}

static void dm9000_set_msglevel(struct net_device *dev, u32 value)

{

board_info_t *dm = to_dm9000_board(dev);

dm->msg_enable = value;

}

static int dm9000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)

{

board_info_t *dm = to_dm9000_board(dev);

mii_ethtool_gset(&dm->mii, cmd);

return 0;

}

static int dm9000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)

{

board_info_t *dm = to_dm9000_board(dev);

return mii_ethtool_sset(&dm->mii, cmd);

}

static int dm9000_nway_reset(struct net_device *dev)

{

board_info_t *dm = to_dm9000_board(dev);

return mii_nway_restart(&dm->mii);

}

static uint32_t dm9000_get_rx_csum(struct net_device *dev)

{

board_info_t *dm = to_dm9000_board(dev);

return dm->rx_csum;

}

static int dm9000_set_rx_csum_unlocked(struct net_device *dev, uint32_t data)

{

board_info_t *dm = to_dm9000_board(dev);

if (dm->can_csum) {

dm->rx_csum = data;

iow(dm, DM9000_RCSR, dm->rx_csum ? RCSR_CSUM : 0);

return 0;

}

return -EOPNOTSUPP;

}

static int dm9000_set_rx_csum(struct net_device *dev, uint32_t data)

{

board_info_t *dm = to_dm9000_board(dev);

unsigned long flags;

int ret;

spin_lock_irqsave(&dm->lock, flags);

ret = dm9000_set_rx_csum_unlocked(dev, data);

spin_unlock_irqrestore(&dm->lock, flags);

return ret;

}

static int dm9000_set_tx_csum(struct net_device *dev, uint32_t data)

{

board_info_t *dm = to_dm9000_board(dev);

int ret = -EOPNOTSUPP;

if (dm->can_csum)

ret = ethtool_op_set_tx_csum(dev, data);

return ret;

}

static u32 dm9000_get_link(struct net_device *dev)

{

board_info_t *dm = to_dm9000_board(dev);

u32 ret;

if (dm->flags & DM9000_PLATF_EXT_PHY)

ret = mii_link_ok(&dm->mii);

else

ret = dm9000_read_locked(dm, DM9000_NSR) & NSR_LINKST ? 1 : 0;

return ret;

}

#define DM_EEPROM_MAGIC (0x444D394B)

static int dm9000_get_eeprom_len(struct net_device *dev)

{

return 128;

}

static int dm9000_get_eeprom(struct net_device *dev,

struct ethtool_eeprom *ee, u8 *data)

{

board_info_t *dm = to_dm9000_board(dev);

int offset = ee->offset;

int len = ee->len;

int i;

if ((len & 1) != 0 || (offset & 1) != 0)

return -EINVAL;

if (dm->flags & DM9000_PLATF_NO_EEPROM)

return -ENOENT;

ee->magic = DM_EEPROM_MAGIC;

for (i = 0; i < len; i += 2)

dm9000_read_eeprom(dm, (offset + i) / 2, data + i);

return 0;

}

static int dm9000_set_eeprom(struct net_device *dev,

struct ethtool_eeprom *ee, u8 *data)

{

board_info_t *dm = to_dm9000_board(dev);

int offset = ee->offset;

int len = ee->len;

int i;

if ((len & 1) != 0 || (offset & 1) != 0)

return -EINVAL;

if (dm->flags & DM9000_PLATF_NO_EEPROM)

return -ENOENT;

if (ee->magic != DM_EEPROM_MAGIC)

return -EINVAL;

for (i = 0; i < len; i += 2)

dm9000_write_eeprom(dm, (offset + i) / 2, data + i);

return 0;

}

static void dm9000_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)

{

board_info_t *dm = to_dm9000_board(dev);

memset(w, 0, sizeof(struct ethtool_wolinfo));

w->supported = dm->wake_supported ? WAKE_MAGIC : 0;

w->wolopts = dm->wake_state;

}

static int dm9000_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)

{

board_info_t *dm = to_dm9000_board(dev);

unsigned long flags;

u32 opts = w->wolopts;

u32 wcr = 0;

if (!dm->wake_supported)

return -EOPNOTSUPP;

if (opts & ~WAKE_MAGIC)

return -EINVAL;

if (opts & WAKE_MAGIC)

wcr |= WCR_MAGICEN;

mutex_lock(&dm->addr_lock);

spin_lock_irqsave(&dm->lock, flags);

iow(dm, DM9000_WCR, wcr);

spin_unlock_irqrestore(&dm->lock, flags);

mutex_unlock(&dm->addr_lock);

if (dm->wake_state != opts) {

if (!dm->wake_state)

set_irq_wake(dm->irq_wake, 1);

else if (dm->wake_state & !opts)

set_irq_wake(dm->irq_wake, 0);

}

dm->wake_state = opts;

return 0;

}

static const struct ethtool_ops dm9000_ethtool_ops = {

.get_drvinfo = dm9000_get_drvinfo,

.get_settings = dm9000_get_settings,

.set_settings = dm9000_set_settings,

.get_msglevel = dm9000_get_msglevel,

.set_msglevel = dm9000_set_msglevel,

.nway_reset = dm9000_nway_reset,

.get_link = dm9000_get_link,

.get_wol = dm9000_get_wol,

.set_wol = dm9000_set_wol,

.get_eeprom_len = dm9000_get_eeprom_len,

.get_eeprom = dm9000_get_eeprom,

.set_eeprom = dm9000_set_eeprom,

.get_rx_csum = dm9000_get_rx_csum,

.set_rx_csum = dm9000_set_rx_csum,

.get_tx_csum = ethtool_op_get_tx_csum,

.set_tx_csum = dm9000_set_tx_csum,

};

static void dm9000_show_carrier(board_info_t *db,

unsigned carrier, unsigned nsr)

{

struct net_device *ndev = db->ndev;

unsigned ncr = dm9000_read_locked(db, DM9000_NCR);

if (carrier)

dev_info(db->dev, "%s: link up, %dMbps, %s-duplex, no LPA\n",

ndev->name, (nsr & NSR_SPEED) ? 10 : 100,

(ncr & NCR_FDX) ? "full" : "half");

else

dev_info(db->dev, "%s: link down\n", ndev->name);

}

static void

dm9000_poll_work(struct work_struct *w)

{

struct delayed_work *dw = to_delayed_work(w);

board_info_t *db = container_of(dw, board_info_t, phy_poll);

struct net_device *ndev = db->ndev;

if (db->flags & DM9000_PLATF_SIMPLE_PHY &&

!(db->flags & DM9000_PLATF_EXT_PHY)) {

unsigned nsr = dm9000_read_locked(db, DM9000_NSR);

unsigned old_carrier = netif_carrier_ok(ndev) ? 1 : 0;

unsigned new_carrier;

new_carrier = (nsr & NSR_LINKST) ? 1 : 0;

if (old_carrier != new_carrier) {

if (netif_msg_link(db))

dm9000_show_carrier(db, new_carrier, nsr);

if (!new_carrier)

netif_carrier_off(ndev);

else

netif_carrier_on(ndev);

}

} else

mii_check_media(&db->mii, netif_msg_link(db), 0);

if (netif_running(ndev))

dm9000_schedule_poll(db);

}

static void

dm9000_release_board(struct platform_device *pdev, struct board_info *db)

{

iounmap(db->io_addr);

iounmap(db->io_data);

release_resource(db->data_req);

kfree(db->data_req);

release_resource(db->addr_req);

kfree(db->addr_req);

}

static unsigned char dm9000_type_to_char(enum dm9000_type type)

{

switch (type) {

case TYPE_DM9000E: return 'e';

case TYPE_DM9000A: return 'a';

case TYPE_DM9000B: return 'b';

}

return '?';

}

static void

dm9000_hash_table_unlocked(struct net_device *dev)

{

board_info_t *db = netdev_priv(dev);

struct netdev_hw_addr *ha;

int i, oft;

u32 hash_val;

u16 hash_table[4];

u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN;

dm9000_dbg(db, 1, "entering %s\n", __func__);

for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)

iow(db, oft, dev->dev_addr[i]);

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

hash_table[i] = 0x0;

hash_table[3] = 0x8000;

if (dev->flags & IFF_PROMISC)

rcr |= RCR_PRMSC;

if (dev->flags & IFF_ALLMULTI)

rcr |= RCR_ALL;

netdev_for_each_mc_addr(ha, dev) {

hash_val = ether_crc_le(6, ha->addr) & 0x3f;

hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);

}

for (i = 0, oft = DM9000_MAR; i < 4; i++) {

iow(db, oft++, hash_table[i]);

iow(db, oft++, hash_table[i] >> 8);

}

iow(db, DM9000_RCR, rcr);

}

static void

dm9000_hash_table(struct net_device *dev)

{

board_info_t *db = netdev_priv(dev);

unsigned long flags;

spin_lock_irqsave(&db->lock, flags);

dm9000_hash_table_unlocked(dev);

spin_unlock_irqrestore(&db->lock, flags);

}

static void

dm9000_init_dm9000(struct net_device *dev)

{

board_info_t *db = netdev_priv(dev);

unsigned int imr;

unsigned int ncr;

dm9000_dbg(db, 1, "entering %s\n", __func__);

db->io_mode = ior(db, DM9000_ISR) >> 6;

dm9000_set_rx_csum_unlocked(dev, db->rx_csum);

iow(db, DM9000_GPR, 0);

iow(db, DM9000_GPCR, GPCR_GEP_CNTL);

iow(db, DM9000_GPR, 0);

ncr = (db->flags & DM9000_PLATF_EXT_PHY) ? NCR_EXT_PHY : 0;

if (db->wake_supported)

ncr |= NCR_WAKEEN;

iow(db, DM9000_NCR, ncr);

iow(db, DM9000_TCR, 0);

iow(db, DM9000_BPTR, 0x3f);

iow(db, DM9000_FCR, 0xff);

责任编辑：