ed_device.c

linux下利用串口进行网络通讯

/*
 * ed_device.c embeded software project(1) device file.
 *
 * Copyright (C) 2003 Li Suke,Software School of Peking University.
 * 
 * The data flow of the devices is:
 *
 *          neted
 *     _______|___________
 *     |                  |
 *     |                  |
 *   ed_rec            ed_tx
 *   (recieve)          (transmit)
 *  
 * neted: pseodu network device
 * ed_rec: character device
 * ed_tx:  character device
 * You can modify and distribute this source code freely.   
 * 
 */

#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif

#include <linux/config.h>
#include <linux/module.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#ifdef LINUX_24
#include <linux/mm.h> 
#else
#include <linux/malloc.h>
#endif

#include <linux/string.h>
#include <linux/errno.h>  
#include <linux/types.h>  

#include <linux/in.h>
#include <linux/netdevice.h>  
#include <linux/etherdevice.h> 
#include <linux/ip.h>          
#include <linux/skbuff.h>
#include <linux/ioctl.h>
#ifdef LINUX_20
#include <linux/if_ether.h>
#endif

#include <asm/uaccess.h>

#include "ed_device.h"
#include "ed_ioctl.h"

MODULE_AUTHOR("Li Suke");

/* We must define the htons() function here, for the kernel has no
 * this API if you do not make source code dep
 */ 
#define htons(x) ((x>>8) | (x<<8))

char ed_names[16];
struct ed_device ed[2];
#ifdef LINUX_24
struct net_device ednet_dev;
#else
struct device ednet_dev;
#endif

#ifdef LINUX_24
static int timeout = ED_TIMEOUT;
#endif

#ifdef LINUX_24
void ednet_rx(struct net_device *dev,int len,unsigned char *buf);
#else
void ednet_rx(struct device *dev,int len,unsigned char *buf);
#endif

#ifdef LINUX_24
void ednet_tx_timeout (struct net_device *dev);
#else
void ednet_tx_timeout (struct device *dev);
#endif
      
/* Initialize the ed_rec and ed_tx device,the two devices
   are allocate the initial buffer to store the incoming and
   outgoing data. If the TCP/IP handshake need change the
   MTU,we must reallocte the buffer using the new MTU value.
 */
static int device_init(){
    
    int i;
    int err;
    err = -ENOBUFS;
    strcpy(ed[ED_REC_DEVICE].name, ED_REC_DEVICE_NAME);
    strcpy(ed[ED_TX_DEVICE].name, ED_TX_DEVICE_NAME);
    for (i = 0 ;i < 2; i++ )
    {   
    	ed[i].buffer_size = BUFFER_SIZE;     	
        ed[i].buffer = kmalloc(ed[i].buffer_size + 4 , GFP_KERNEL);
        ed[i].magic = ED_MAGIC;
        ed[i].mtu = ED_MTU;
        ed[i].busy = 0;
        #ifdef LINUX_24
        init_waitqueue_head(&ed[i].rwait);
        #endif
        
	if (ed[i].buffer == NULL)
	    goto err_exit;	    	
	spin_lock_init(&ed[i].lock);     
    }  
    err = 0;
    return err;
    
err_exit:
    printk("There is no enongh memory for buffer allocation. \n");
    return err;		
}
static int ed_realloc(int new_mtu){
    int err;
    int i;
    err = -ENOBUFS;
    char *local_buffer[2];
    int size;
    for (i=0;i<2;i++){
        local_buffer[i] = kmalloc(new_mtu + 4,GFP_KERNEL);
        #ifdef LINUX_20
        if(new_mtu >= ed[i].buffer_size)
            size = new_mtu;
        else 
            size = ed[i].buffer_size;
        #else
        size = min(new_mtu,ed[i].buffer_size);
        #endif

        memcpy(local_buffer[i],ed[i].buffer,size);
        kfree(ed[i].buffer);

        ed[i].buffer = kmalloc(new_mtu + 4,GFP_KERNEL);
        if( ed[i].buffer < 0){
            printk("Can not realloc the buffer from kernel when change mtu.\n");
            return err;
        }
           
    }
    return 0;
	
}
/* Open the two character devices,and let the ed_device's private pointer 
 * point to the file struct */

static int device_open(struct inode *inode,struct file *file)
{
    int Device_Major;
    struct ed_device *edp;
    Device_Major = inode->i_rdev >> 8;
    
    #ifdef _DEBUG
    printk("Get the Device Major Number is %d\n",Device_Major);
    #endif
    if (Device_Major == MAJOR_NUM_REC )
    {
        file->private_data = &ed[ED_REC_DEVICE];
        ed[ED_REC_DEVICE].file = file;
    }    
    else    
    if (Device_Major == MAJOR_NUM_TX){
        file->private_data = &ed[ED_TX_DEVICE];
        ed[ED_TX_DEVICE].file = file;
    }    
    else
        return -NODEV;
    edp = (struct ed_device *)file->private_data;
                    
    if(edp->busy != 0){
       printk("The device is open!\n");	
       return -EBUSY;
    }
    
    edp->busy++;
 
    return 0;
       
}

/* release the devices */
int device_release(struct inode *inode,struct file *file)
{
	
    struct ed_device *edp;
    edp = (struct ed_device *)file->private_data;
    edp->busy = 0;
    
    return 0;	
}

/* read data from ed_tx device */
ssize_t device_read(struct file *file,char *buffer,size_t length, loff_t *offset)
{
    #ifdef _DEBUG
    int i;
    #endif
    struct ed_device *edp;
    edp = (struct ed_device *)file->private_data;
/*    
#ifdef LINUX_24
    DECLARE_WAITQUEUE(wait,current);
    add_wait_queue(&edp->rwait,&wait);
    for(;;){
        
        set_current_state(TASK_INTERRUPTIBLE);
        if ( file->f_flags & O_NONBLOCK)
            break;
        if ( edp->tx_len > 0)
            break;
        
        if ( signal_pending(current))
            break;
        schedule();
        
    }
    set_current_state(TASK_RUNNING);
    remove_wait_queue(&edp->rwait,&wait);
#endif
*/    
    spin_lock(&edp->lock);
    
    if(edp->tx_len == 0) {
         spin_unlock(&edp->lock);
         return 0;

        
    }else
    {
   
        copy_to_user(buffer,edp->buffer,edp->tx_len);
        memset(edp->buffer,0,edp->buffer_size); 
        
        #ifdef _DEBUG
        printk("\n read data from ed_tx \n");
        for(i=0;i<edp->tx_len;i++)
            printk(" %02x",edp->buffer[i]&0xff);
        printk("\n");
        #endif
        
        length = edp->tx_len;
        edp->tx_len = 0;
    }
    spin_unlock(&edp->lock);
    return length;
    
}
/* This function is called by ednet device to write the network data 
 * into the ed_tx character device.
 */
ssize_t kernel_write(const char *buffer,size_t length,int buffer_size)
{
          
    if(length > buffer_size )
        length = buffer_size;
    memset(ed[ED_TX_DEVICE].buffer,0,buffer_size);
    memcpy(ed[ED_TX_DEVICE].buffer,buffer,buffer_size);
    ed[ED_TX_DEVICE].tx_len = length;
  /*  #ifdef LINUX_24
    wake_up_interruptible(&ed[ED_TX_DEVICE].rwait);	
    #endif
    */
    return length;
}

/* Device write is called by server program, to put the user space
 * network data into ed_rec device.
 */
ssize_t device_write(struct file *file,const char *buffer, size_t length,loff_t *offset)
{
    #ifdef _DEBUG
    int i;
    #endif
    struct ed_device *edp;
    edp = (struct ed_device *)file->private_data;
    
    spin_lock(&ed[ED_REC_DEVICE].lock);
    if(length > edp->buffer_size)
        length =  edp->buffer_size;
        
    copy_from_user( ed[ED_REC_DEVICE].buffer,buffer, length);
    ednet_rx(&ednet_dev,length,ed[ED_REC_DEVICE].buffer);
    
    #ifdef _DEBUG
    printk("\nNetwork Device Recieve buffer:\n");
    for(i =0;i< length;i++)
       printk(" %02x",ed[ED_REC_DEVICE].buffer[i]&0xff);
    printk("\n");
    #endif
    spin_unlock(&ed[ED_REC_DEVICE].lock);     
    return length;   
}        
int device_ioctl(struct inode *inode,
                 struct file *file,
                 unsigned int ioctl_num,
                 unsigned long ioctl_param){
    struct ed_device *edp;
    edp = (struct ed_device *)file->private_data;
    switch(ioctl_num)
    {
        case IOCTL_SET_BUSY:
           edp->busy = ioctl_param;
           break;
      
       
    }
    return 0;

}

/* 
 * All the ednet_* functions are for the ednet pseudo network device ednet.
 * ednet_open and ednet_release are the two functions which open and release
 * the device.
 */
 
#ifdef LINUX_20
int ednet_open(struct device *dev)
#else
int ednet_open(struct net_device *dev)
#endif
{
    MOD_INC_USE_COUNT;
    
    /* Assign the hardware pseudo network hardware address,
     * the MAC address's first octet is 00,for the MAC is
     * used for local net,not for the Internet.
     */
    memcpy(dev->dev_addr, "\0ED000", ETH_ALEN);
   
#ifndef LINUX_24                
    dev->start = 1;
    dev->tbusy = 0;             
#endif
             
#ifdef LINUX_24             
    netif_start_queue(dev);
#endif
    return 0;
}
#ifdef LINUX_24
int ednet_release(struct net_device *dev)
#else
int ednet_release(struct device *dev)
#endif
{
    
#ifdef LINUX_24    
    netif_stop_queue(dev); 
#endif

#ifndef LINUX_24                
    dev->start = 0;
    dev->tbusy = 1;             
#endif                          
    MOD_DEC_USE_COUNT;
    
    return 0;
}

/*
 * Used by ifconfig,the io base addr and IRQ can be modified
 * when the net device is not running.
 */
#ifdef LINUX_24
int ednet_config(struct net_device *dev, struct ifmap *map)
#else
int ednet_config(struct device *dev, struct ifmap *map)
#endif
{
    if (dev->flags & IFF_UP) 
        return -EBUSY;

    /* change the io_base addr */
    if (map->base_addr != dev->base_addr) {