linux下移植好的CS8900驱动源文件

/* * linux/drivers/net/cs8900.c * * Author: Abraham van der Merwe <abraham at 2d3d.co.za> * * A Cirrus Logic CS8900A driver for Linux * based on the cs89x0 driver written by Russell Nelson, * Donald Becker, and others. * * This source code is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * version 2 as published by the Free Software Foundation. * * History: * 22-May-2002 Initial version (Abraham vd Merwe) * 30-May-2002 Added char device support for eeprom (Frank Becker) * 24-Jan-2004 Fixups for 2.6 (Frank Becker) * 15-July-2004 Modified for SMDK2410 (Roc Wu pwu at jadechip.com) * * 05-June-2011 Modified for reille2440(guoyirong) */ #define VERSION_STRING "Cirrus Logic CS8900A driver for Linux (Modified for reille2440)" /* * At the moment the driver does not support memory mode operation. * It is trivial to implement this, but not worth the effort. */ /* * TODO: * * 1. Sort out ethernet checksum * 2. If !ready in send_start(), queue buffer and send it in interrupt handler * when we receive a BufEvent with Rdy4Tx, send it again. dangerous! * 3. how do we prevent interrupt handler destroying integrity of get_stats()? * 4. Change reset code to check status. * 5. Implement set_mac_address and remove fake mac address * 7. Link status detection stuff * 8. Write utility to write EEPROM, do self testing, etc. * 9. Implement DMA routines (I need a board w/ DMA support for that) * 10. Power management * 11. Add support for multiple ethernet chips */ // added BSt //#include <linux/config.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/types.h> #include <linux/version.h> #include <linux/errno.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/ioport.h> #include <linux/pm.h> #include <asm/irq.h> //#include <asm/hardware.h> // del by guoyirong 2011.6.4 #include <asm/io.h> #include <asm/uaccess.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/skbuff.h> #include <linux/fs.h> // Added BSt #include <asm/mach-types.h> #ifdef CONFIG_SA1100_CERF #include "asm/arch/cerf.h" #endif #if defined(CONFIG_ARCH_UTU2440) #include "asm/arch/bit-map.h" #include <asm/arch/regs-mem.h> #endif #ifdef CONFIG_ARCH_SMDK2410 //#include "asm/arch/smdk2410.h" #include <asm/arch/regs-mem.h> #endif // added by guoyirong 2011.6.4 #if defined(CONFIG_ARCH_REILLE2440) #include <mach/hardware.h> #include <mach/regs-mem.h> #include <mach/regs-irq.h> #include <linux/irq.h> #define IRQT_RISING IRQ_TYPE_EDGE_RISING #endif #include "cs8900.h" //#define FULL_DUPLEX //#define DEBUG typedef struct { struct net_device_stats stats; u16 txlen; int char_devnum; spinlock_t lock; } cs8900_t; int cs8900_probe (struct net_device *dev); /* static struct net_device cs8900_dev = { // init: cs8900_probe // del by guoyirong 2011.6.4 }; */ static struct net_device *cs8900_dev = NULL; /* * There seems to be no way to determine the exact size of the eeprom, * so we use the largest size. * FIXME: Verify it's safe to read/write past the end of a 64/128 * byte eeprom. * * Possible eeprom sizes: * Cx46 - 64 bytes * Cx56 - 128 bytes * Cx66 - 256 bytes */ #define MAX_EEPROM_SIZE 256 static int cs8900_eeprom_fopen(struct inode *inode, struct file *file); static int cs8900_eeprom_frelease(struct inode *inode, struct file *file); static loff_t cs8900_eeprom_fllseek(struct file * file,loff_t offset, int flags); static ssize_t cs8900_eeprom_fread(struct file *file, char *buf, size_t count, loff_t *f_pos); static ssize_t cs8900_eeprom_fwrite(struct file *file, const char *buf, size_t count, loff_t *f_pos); static struct file_operations cs8900_eeprom_fops = { owner: THIS_MODULE, open: cs8900_eeprom_fopen, release: cs8900_eeprom_frelease, llseek: cs8900_eeprom_fllseek, read: cs8900_eeprom_fread, write: cs8900_eeprom_fwrite, }; static u16 cs8900_eeprom_cache[MAX_EEPROM_SIZE/2]; /* * I/O routines */ static inline u16 cs8900_read (struct net_device *dev,u16 reg) { outw (reg,dev->base_addr + PP_Address); return (inw (dev->base_addr + PP_Data)); } static inline void cs8900_write (struct net_device *dev,u16 reg,u16 value) { outw (reg,dev->base_addr + PP_Address); outw (value,dev->base_addr + PP_Data); } static inline void cs8900_set (struct net_device *dev,u16 reg,u16 value) { cs8900_write (dev,reg,cs8900_read (dev,reg) | value); } static inline void cs8900_clear (struct net_device *dev,u16 reg,u16 value) { cs8900_write (dev,reg,cs8900_read (dev,reg) & ~value); } static inline void cs8900_frame_read (struct net_device *dev,struct sk_buff *skb,u16 length) { insw (dev->base_addr,skb_put (skb,length),(length + 1) / 2); } static inline void cs8900_frame_write (struct net_device *dev,struct sk_buff *skb) { outsw (dev->base_addr,skb->data,(skb->len + 1) / 2); } /* * EEPROM I/O routines */ static int cs8900_eeprom_wait (struct net_device *dev) { int i; for (i = 0; i < 3000; i++) { if (!(cs8900_read (dev,PP_SelfST) & SIBUSY)) return (0); udelay (1); } return (-1); } static int cs8900_eeprom_read (struct net_device *dev,u16 *value,u16 offset) { if (cs8900_eeprom_wait (dev) < 0) return (-1); cs8900_write (dev,PP_EEPROMCommand,offset | EEReadRegister); if (cs8900_eeprom_wait (dev) < 0) return (-1); *value = cs8900_read (dev,PP_EEPROMData); return (0); } static int cs8900_eeprom_write (struct net_device *dev,u16 *value,u16 offset) { cs8900_eeprom_wait(dev); cs8900_write(dev, PP_EEPROMCommand, (EEWriteEnable)); cs8900_eeprom_wait(dev); cs8900_write(dev, PP_EEPROMData, *value); cs8900_eeprom_wait(dev); cs8900_write(dev, PP_EEPROMCommand, (offset | EEWriteRegister)); cs8900_eeprom_wait(dev); cs8900_write(dev, PP_EEPROMCommand, (EEWriteDisable)); cs8900_eeprom_wait(dev); return 0; } /* * Debugging functions */ #ifdef DEBUG static inline int printable (int c) { return ((c >= 32 && c <= 126) || (c >= 174 && c <= 223) || (c >= 242 && c <= 243) || (c >= 252 && c <= 253)); } static void dump16 (struct net_device *dev,const u8 *s,size_t len) { int i; char str[128]; if (!len) return; *str = '\0'; for (i = 0; i < len; i++) { if (i && !(i % 4)) strcat (str," "); sprintf (str,"%s%.2x ",str,s[i]); } for ( ; i < 16; i++) { if (i && !(i % 4)) strcat (str," "); strcat (str," "); } strcat (str," "); for (i = 0; i < len; i++) sprintf (str,"%s%c",str,printable (s[i]) ? s[i] : '.'); printk (KERN_DEBUG "%s: %s\n",dev->name,str); } static void hexdump (struct net_device *dev,const void *ptr,size_t size) { const u8 *s = (u8 *) ptr; int i; for (i = 0; i < size / 16; i++, s += 16) dump16 (dev,s,16); dump16 (dev,s,size % 16); } static void dump_packet (struct net_device *dev,struct sk_buff *skb,const char *type) { printk (KERN_INFO "%s: %s %d byte frame %.2x:%.2x:%.2x:%.2x:%.2x:%.2x to %.2x:%.2x:%.2x:%.2x:%.2x:%.2x type %.4x\n", dev->name, type, skb->len, skb->data[0],skb->data[1],skb->data[2],skb->data[3],skb->data[4],skb->data[5], skb->data[6],skb->data[7],skb->data[8],skb->data[9],skb->data[10],skb->data[11], (skb->data[12] << 8) | skb->data[13]); if (skb->len < 0x100) hexdump (dev,skb->data,skb->len); } static void eepromdump( struct net_device *dev) { u16 buf[0x80]; u16 i; int count; int total; if( cs8900_read( dev, PP_SelfST) & EEPROMpresent) { printk (KERN_INFO "%s: EEPROM present\n",dev->name); } else { printk (KERN_INFO "%s: NO EEPROM present\n",dev->name); return; } if( cs8900_read( dev, PP_SelfST) & EEPROMOK) { printk (KERN_INFO "%s: EEPROM OK\n",dev->name); } else { printk (KERN_INFO "%s: EEPROM checksum mismatch - fixing...\n",dev->name); } printk (KERN_INFO "%s: Hexdump\n",dev->name); for( i=0; i<0x80; i++) {