simple network device driver

//-------------------------------------------------------------------

//      mynetdvr.c

//

//      This module implements a minimal Linux network device-driver

//      for our Intel PRO1000 gibabit ethernet interface controller.

//

//      NOTE: Written and tested with Linux kernel version 2.6.22.5.

//

//      programmer: ALLAN CRUSE

//      written on: 22 FEB 2008

//-------------------------------------------------------------------

 

#include <linux/module.h>       // for init_module()

#include <linux/etherdevice.h>  // for alloc_etherdev()

#include <linux/interrupt.h>    // for request_irq()

#include <linux/proc_fs.h>      // for create_proc_info_entry()

#include <linux/pci.h>          // for pci_get_device()

 

#define VENDOR_ID       0x8086  // Intel Corporation

#define DEVICE_ID       0x109A  // 82573L controller

//#define DEVICE_ID     0x10B9  // 82572EI controller

#define INTR_MASK   0xFFFFFFFF  // nic interrupt mask

#define N_RX_DESC            8  // number of RX Descriptors

#define N_TX_DESC            8  // number of TX Descriptors

#define RX_BUFSIZ         2048  // size of RX packet-buffer

#define TX_BUFSIZ         2048  // size of TX packet-buffer

 

 

typedef struct  {

                unsigned long long      base_address;

                unsigned short          packet_length;

                unsigned short          packet_chksum;

                unsigned char           desc_status;

                unsigned char           desc_errors;

                unsigned short          vlan_tag;

                } RX_DESCRIPTOR;

 

typedef struct  {

                unsigned long long      base_address;

                unsigned short          packet_length;

                unsigned char           cksum_offset;

                unsigned char           desc_command;

                unsigned char           desc_status;

                unsigned char           cksum_origin;

                unsigned short          special_info;

                } TX_DESCRIPTOR;

 

 

typedef struct  {

                RX_DESCRIPTOR   rxring[ N_RX_DESC ];           

                TX_DESCRIPTOR   txring[ N_TX_DESC ];           

                unsigned char   rxbuff[ N_RX_DESC * RX_BUFSIZ ];

                unsigned char   txbuff[ N_TX_DESC * TX_BUFSIZ ];

                unsigned int    rxnext;

                struct tasklet_struct   rx_tasklet;

                } MY_DRIVERDATA;

 

 

 

 

enum    {

        E1000_CTRL      = 0x0000,       // Device Control

        E1000_STATUS    = 0x0008,       // Device Status

        E1000_ICR       = 0x00C0,       // Interrupt Cause Read

        E1000_ICS       = 0x00C8,       // Interrupt Cause Set 

        E1000_IMS       = 0x00D0,       // Interrupt Mask Set  

        E1000_IMC       = 0x00D8,       // Interrupt Mask Clear

        E1000_RCTL      = 0x0100,       // Receive Control

        E1000_TCTL      = 0x0400,       // Transmit Control

        E1000_RDBAL     = 0x2800,       // RX Descriptor Base-Address Low

        E1000_RDBAH     = 0x2804,       // RX Descriptor Base-Address High

        E1000_RDLEN     = 0x2808,       // RX Descriptor-queue Length  

        E1000_RDH       = 0x2810,       // RX Descriptor-queue Head

        E1000_RDT       = 0x2818,       // RX Descriptor-queue Tail

        E1000_RXDCTL    = 0x2828,       // RX Descriptor-queue Control

        E1000_TDBAL     = 0x3800,       // TX Descriptor Base-Address Low

        E1000_TDBAH     = 0x3804,       // TX Descriptor Base-Address High

        E1000_TDLEN     = 0x3808,       // TX Descriptor-queue Length  

        E1000_TDH       = 0x3810,       // TX Descriptor-queue Head

        E1000_TDT       = 0x3818,       // TX Descriptor-queue Tail

        E1000_TXDCTL    = 0x3828,       // TX Descriptor-queue Control

        E1000_RA        = 0x5400,       // Receive-address Array       

        };

 

 

 

// function prototypes

static int __init my_init( void );

static void __exit my_exit( void );

irqreturn_t my_isr( int, void * );

void my_rx_handler( unsigned long );

int my_open( struct net_device * );

int my_stop( struct net_device * );

int my_hard_start_xmit( struct sk_buff *, struct net_device * );

int my_get_info( char *buf, char **start, off_t off, int buflen );

 

module_init( my_init );

module_exit( my_exit );

MODULE_LICENSE("GPL");

 

 

 

// global variables

char modname[] = "mynetdvr";

struct pci_dev  *devp;

unsigned int    mmio_base;

unsigned int    mmio_size;

void            *io;

struct net_device  *my_netdev;

 

 

 

static int __init my_init( void )

{

        u16     pci_cmd;

 

        printk( "<1>\nInstalling \'%s\' module\n", modname );

 

        // detect presence of the Intel Pro1000 controller

        devp = pci_get_device( VENDOR_ID, DEVICE_ID, NULL );

        if ( !devp ) return -ENODEV;

 

        // map the controller's i/o-memory into kernel space

        mmio_base = pci_resource_start( devp, 0 );

        mmio_size = pci_resource_len( devp, 0 );

        io = ioremap_nocache( mmio_base, mmio_size );

        if ( !io ) return -ENOSPC;

 

        // insure the controller's Bus Master capability is enabled

        pci_read_config_word( devp, 4, &pci_cmd );

        pci_cmd |= (1<<2);

        pci_write_config_word( devp, 4, pci_cmd );

 

        // allocate kernel memory for the 'net_device' structure

        my_netdev = alloc_etherdev( sizeof( MY_DRIVERDATA ) );

        if ( !my_netdev ) { iounmap( io ); return -ENOMEM; }

 

        // initialize essential fields in the 'net_device' structure

        memcpy( my_netdev->perm_addr, io + E1000_RA, 6 );

        memcpy( my_netdev->dev_addr,  io + E1000_RA, 6 );

 

        my_netdev->open                 = my_open;

        my_netdev->stop                 = my_stop;

        my_netdev->hard_start_xmit      = my_hard_start_xmit;

        my_netdev->mem_start            = mmio_base;

        my_netdev->mem_end              = mmio_base + mmio_size;

        my_netdev->irq                  = devp->irq;

        my_netdev->flags                |= IFF_PROMISC;

 

        // create our driver's pseudo-file (for debugging)

        create_proc_info_entry( modname, 0, NULL, my_get_info );

 

        // register this driver's 'net_device' structure

        return  register_netdev( my_netdev );

}

 

 

static void __exit my_exit( void )

{

        remove_proc_entry( modname, NULL );

 

        unregister_netdev( my_netdev );

        iounmap( io );

        free_netdev( my_netdev );

 

        printk( "<1>Removing \'%s\' module\n", modname );

}

 

int my_open( struct net_device *dev )

{

        //--------------------------------------------------------

        // The kernel calls this function whenever the 'ifconfig'

        // command is executed to bring up the device interface.

        // This function needs to call 'netif_start_queue()'.

        //--------------------------------------------------------

 

        MY_DRIVERDATA   *mdp = (MY_DRIVERDATA *)dev->priv;     

        RX_DESCRIPTOR   *rxq = mdp->rxring;

        TX_DESCRIPTOR   *txq = mdp->txring;

        unsigned long   rbuf = virt_to_phys( mdp->rxbuff );

        unsigned long   tbuf = virt_to_phys( mdp->txbuff );

        unsigned long   rxdescaddr = virt_to_phys( rxq );

        unsigned long   txdescaddr = virt_to_phys( txq );

        int             i;

 

        printk( " %s: opening the \'%s\' device \n", modname, dev->name );

 

        // reset the network controller

        iowrite32( 0xFFFFFFFF, io + E1000_IMC );       

        iowrite32( 0x00000000, io + E1000_STATUS );

        iowrite32( 0x040C0241, io + E1000_CTRL );

        iowrite32( 0x000C0241, io + E1000_CTRL );

        while ( ( ioread32( io + E1000_STATUS )&3 ) != 3 );

 

        // initialize the RX Descriptor-queues

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

                {

                rxq[ i ].base_address = rbuf + i * RX_BUFSIZ;

                rxq[ i ].packet_length = 0;

                rxq[ i ].packet_chksum = 0;

                rxq[ i ].desc_status = 0;

                rxq[ i ].desc_errors = 0;

                rxq[ i ].vlan_tag = 0;

                }

 

        // initialize the TX Descriptor-queues

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

                {

                txq[ i ].base_address = tbuf + i * TX_BUFSIZ;

                txq[ i ].packet_length = 0;

                txq[ i ].cksum_offset = 0;

                txq[ i ].desc_command = (1<<0)|(1<<1)|(1<<3);   // EOP/IFCS/RS

                txq[ i ].desc_status = 0;

                txq[ i ].cksum_origin = 0;

                txq[ i ].special_info = 0;

                }

 

        // configure the controller's Receive Engine

        iowrite32( 0x0400801C, io + E1000_RCTL );

        iowrite32( rxdescaddr, io + E1000_RDBAL );

        iowrite32( 0x00000000, io + E1000_RDBAH );

        iowrite32( N_RX_DESC * 16, io + E1000_RDLEN );

        iowrite32( 0x01010000, io + E1000_RXDCTL );

 

        // configure the controller's Transmit Engine

        iowrite32( 0x0103F0F8, io + E1000_TCTL );

        iowrite32( txdescaddr, io + E1000_TDBAL );

        iowrite32( 0x00000000, io + E1000_TDBAH );

        iowrite32( N_TX_DESC * 16, io + E1000_TDLEN );

        iowrite32( 0x01010000, io + E1000_TXDCTL );

 

        // initialize our tasklet

        mdp->rxnext = 0;

        tasklet_init( &mdp->rx_tasklet, my_rx_handler, (unsigned long)dev );

 

        // install our driver's interrupt-handler

        i = dev->irq;

        if ( request_irq( i, my_isr, IRQF_SHARED, dev->name, dev ) < 0 )

                return -EBUSY;

 

        // unmask interrupts

        ioread32( io + E1000_ICR );

        iowrite32( INTR_MASK, io + E1000_IMS );

 

        // start the receive engine

        iowrite32( N_RX_DESC, io + E1000_RDT );

        iowrite32( ioread32( io + E1000_RCTL ) | (1<<1), io + E1000_RCTL );

               

        // start the transmit engine

        iowrite32( ioread32( io + E1000_TCTL ) | (1<<1), io + E1000_TCTL );

        netif_start_queue( dev );

        return  0;  // SUCCESS

}

 

 

int my_stop( struct net_device *dev )

{

        //--------------------------------------------------------

        // The kernel calls this function whenever the 'ifconfig'

        // command is executed to shut down the device interface.

        // This function needs to call 'netif_stop_queue()'.

        //--------------------------------------------------------

 

        MY_DRIVERDATA   *mdp = (MY_DRIVERDATA *)dev->priv;     

 

        printk( " %s: stopping the \'%s\' device \n", modname, dev->name );

 

        // stop the controller's transmit and receive engines

        iowrite32( ioread32( io + E1000_RCTL ) & ~(1<<1), io + E1000_RCTL );

        iowrite32( ioread32( io + E1000_TCTL ) & ~(1<<1), io + E1000_TCTL );

 

        // disable controller interrupts and remove interrupt-handler

        iowrite32( 0xFFFFFFFF, io + E1000_IMC );

        free_irq( dev->irq, dev );

 

        // stop our tasklet and the network interface queue

        tasklet_kill( &mdp->rx_tasklet );

        netif_stop_queue( dev );

        return  0;  // SUCCESS

}

 

 

int my_hard_start_xmit( struct sk_buff *skb, struct net_device *dev )

{

        //------------------------------------------------------------

        // The kernel calls this function whenever its protocol layer

        // has a packet that it wants the controller to transmit.  It

        // must either call the 'netif_free_skb()' function itself or

        // else arrange for it to be called by our interrupt-handler.  

        //------------------------------------------------------------

 

        MY_DRIVERDATA   *mdp = (MY_DRIVERDATA*)dev->priv;

        TX_DESCRIPTOR   *txq = mdp->txring;

        unsigned int    curr = ioread32( io + E1000_TDT );

        unsigned int    next = (1 + curr) % N_TX_DESC;

        unsigned char   *src = skb->data;

        unsigned char   *dst = phys_to_virt( txq[ curr ].base_address );

        unsigned short  len  = skb->len;

 

        // save the timestamp

        dev->trans_start = jiffies;

 

        // copy the socket-buffer's data into the next packet-buffer

        if ( len > TX_BUFSIZ ) len = TX_BUFSIZ;

        memcpy( dst, src, len );

 

        // setup the next TX Descriptor

        txq[ curr ].packet_length = len;

        txq[ curr ].cksum_offset = 0;

        txq[ curr ].cksum_origin = 0;

        txq[ curr ].special_info = 0;

        txq[ curr ].desc_status = 0;

        txq[ curr ].desc_command = (1<<0)|(1<<1)|(1<<3);  // EOP/IFCS/RS

               

        // initiate the transmission

        iowrite32( next, io + E1000_TDT );

 

        // update the 'net_device' statistics

        dev->stats.tx_packets += 1;

        dev->stats.tx_bytes += len;

 

        // it is essential to free the socket-buffer structure

        dev_kfree_skb( skb );

        return  0;  // SUCCESS

}

 

 

void my_rx_handler( unsigned long data )

{

        //--------------------------------------------------------------

        // This function is scheduled by our driver's interrupt-handler

        // whenever the controller has received some new packets.

        //--------------------------------------------------------------

 

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

        MY_DRIVERDATA           *mdp = (MY_DRIVERDATA*)dev->priv;

        RX_DESCRIPTOR           *rdq = (RX_DESCRIPTOR*)mdp->rxring;

        unsigned int            curr = mdp->rxnext;

        void                    *src = phys_to_virt( rdq[ curr ].base_address );

        int                     len = rdq[ curr ].packet_length;

        struct sk_buff          *skb = dev_alloc_skb( len + NET_IP_ALIGN );

 

        // allocate a new socket-buffer

        if ( !skb ) { dev->stats.rx_dropped += 1; return; }

 

        // copy received packet-data into this socket-buffer

        memcpy( skb_put( skb, len ), src, len );

 

        // adjust the socket-buffer's parameters

        skb->dev = dev;

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

        skb->ip_summed = CHECKSUM_NONE;

       

        // clear the current descriptor's status

        rdq[ curr ].desc_status = 0;

        rdq[ curr ].desc_errors = 0;

       

        // advance our driver's 'rxnext' index

        mdp->rxnext = (1 + curr) % N_RX_DESC;

 

        // update the 'net_device' statistics

        dev->stats.rx_packets += 1;

        dev->stats.rx_bytes += len;

 

        // record the timestamp

        dev->last_rx = jiffies;

 

        // now hand over the socket-buffer to the kernel

        netif_rx( skb );

}

 

 

irqreturn_t my_isr( int irq, void *dev_id )

{

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

        MY_DRIVERDATA           *mdp = (MY_DRIVERDATA*)dev->priv;

        unsigned int            intr_cause = ioread32( io + E1000_ICR );

 

        if ( intr_cause == 0 ) return IRQ_NONE;

 

        // clear these interrupts

        iowrite32( intr_cause, io + E1000_ICR );

 

        // schedule our interrupt-handler's 'bottom-half'

        if ( intr_cause & (1<<7) ) tasklet_schedule( &mdp->rx_tasklet );

 

        return  IRQ_HANDLED;

}

 

 

 

 

 

int my_get_info( char *buf, char **start, off_t off, int buflen )

{

        MY_DRIVERDATA           *mdp = (MY_DRIVERDATA*)my_netdev->priv;

        RX_DESCRIPTOR           *rdq = mdp->rxring;

        TX_DESCRIPTOR           *tdq = mdp->txring;

        unsigned int            rxhead = ioread32( io + E1000_RDH );

        unsigned int            rxtail = ioread32( io + E1000_RDT );

        unsigned int            txhead = ioread32( io + E1000_TDH );

        unsigned int            txtail = ioread32( io + E1000_TDT );

        int                     i, len = 0;

 

        len += sprintf( buf+len, "\n Receive-Descriptor Queue " );

        len += sprintf( buf+len, "(head=%d, tail=%d) \n\n", rxhead, rxtail );

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

                {

                unsigned int    ba = virt_to_phys( rdq+i );

                len += sprintf( buf+len, " #%-2d ", i );

                len += sprintf( buf+len, "%08X: ", ba );

                len += sprintf( buf+len, "%016llX ", rdq[i].base_address );    

                len += sprintf( buf+len, "%04X ", rdq[i].packet_length );      

                len += sprintf( buf+len, "%04X ", rdq[i].packet_chksum );      

                len += sprintf( buf+len, "%02X ", rdq[i].desc_status );        

                len += sprintf( buf+len, "%02X ", rdq[i].desc_errors );        

                len += sprintf( buf+len, "%04X ", rdq[i].vlan_tag );    

                len += sprintf( buf+len, "\n" );

                }

       

        len += sprintf( buf+len, "\n Transmit-Descriptor Queue " );

        len += sprintf( buf+len, "(head=%d, tail=%d) \n\n", txhead, txtail );

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

                {

                unsigned int    ba = virt_to_phys( tdq+i );

                len += sprintf( buf+len, " #%-2d ", i );

                len += sprintf( buf+len, "%08X: ", ba );

                len += sprintf( buf+len, "%016llX ", tdq[i].base_address );    

                len += sprintf( buf+len, "%04X ", tdq[i].packet_length );      

                len += sprintf( buf+len, "%02X ", tdq[i].cksum_offset );        

                len += sprintf( buf+len, "%02X ", tdq[i].desc_command );        

                len += sprintf( buf+len, "%02X ", tdq[i].desc_status );        

                len += sprintf( buf+len, "%02X ", tdq[i].cksum_origin );        

                len += sprintf( buf+len, "%04X ", tdq[i].special_info );        

                len += sprintf( buf+len, "\n" );

                }

 

        len += sprintf( buf+len, "\n" );

        return  len;

}