Linux-2.6.20的cs8900驱动分析

淩亂°似流年 2022-07-12 07:06 190阅读 0赞

[http://blog.csdn.net/thewayma/archive/2009/08/11/4433167.aspx][http_blog.csdn.net_thewayma_archive_2009_08_11_4433167.aspx]

几经波折，在开发板上终于可以使用网络了。Linux 内核可以通过网络挂接网络文件系统了。首先感谢Internet ，Google 等帮助过我的工具，还要感谢各位嵌友的无私奉献。在移植的过程中尤其感激weibing 的博客文章cs8900 移植linux-2.6.19.2 ，根据他的文章使cs8900  
成功跑起来。此文章可以在[http://weibing.blogbus.com/logs/4467465.html][http_weibing.blogbus.com_logs_4467465.html] 找到。  
   在解释网络驱动前，先说说自己的硬件配置：  
    1. 处理器为s3c2410  
    2. 网络芯片cs8900a  
    3. cs8900a 映射到s3c2410 的bank3 空间  
    4. cs8900a 占用int9 号中断  
    5. Linux 内核版本为2.6.20  
一、初始化阶段  
    网络初始化被调用的路径为：  
init->do\_basic\_setup->do\_initcalls->net\_olddevs\_init->ethif\_probe2->probe\_list2->cs89x0\_probe->cs89x0\_probe1  
真是不容易啊，终于进到cs89x0\_probe1 了，在这里开始探测和初始化cs8900 了。下面就按照这个顺序来说明网络驱动第一阶段的工作。注意：这里的调用顺序是将cs8900 驱动编入内核所产生的，如果将cs8900 驱动选为模块，这个路径：init->do\_basic\_setup->do\_initcalls->net\_olddevs\_init->ethif\_probe2->probe\_list2 也会执行。  
1.1 init 函数  
我们知道当start\_kernel 函数完成后就会启动init 进程执行，在真正的应用程序init 进程（如busybox 的/sbin/init ）之前，Linux 还需要执行一些初始化操作。init 的代码可以在<top\_dir>/init/main.c 中找到，它的代码如下：  
static int init(void \* unused)  
\{  
       lock\_kernel();  
……                                                         // 省略多cpu 的初始化代码先  
       do\_basic\_setup();                                // 我们所关注的初始化函数  
……  
       if (!ramdisk\_execute\_command)  
              ramdisk\_execute\_command = "/init";  
       if (sys\_access((const char \_\_user \*) ramdisk\_execute\_command, 0) != 0) \{  
              ramdisk\_execute\_command = NULL;  
              prepare\_namespace();                           // 挂接根文件系统  
       \}  
……  
       free\_initmem();                                             // 释放初始化代码的空间  
       unlock\_kernel();  
……                                                                 // 这几段没看懂  
   
       if (sys\_open((const char \_\_user \*) "/dev/console", O\_RDWR, 0) < 0)  // 检查控制台  
                                             //console 是否存在  
              printk(KERN\_WARNING "Warning: unable to open an initial console./n");  
……// 这几段没看懂  
       if (ramdisk\_execute\_command) \{  // 运行ramdisk\_execute\_command 指定的init 用户进程  
              run\_init\_process(ramdisk\_execute\_command);  
              printk(KERN\_WARNING "Failed to execute %s/n",  
              ramdisk\_execute\_command);  
       \}  
       ……  
       if (execute\_command) \{      // 判断在启动时是否指定了init 参数，如果指定，  
                    // 此值将赋给execute\_command  
              run\_init\_process(execute\_command); // 开始执行用户init 进程，如果成功将不会  
                                                                        // 返回。  
              printk(KERN\_WARNING "Failed to execute %s.  Attempting "  
                                   "defaults.../n", execute\_command);  
       \}  
// 如果没有指定init 启动参数，则查找下面的目录init 进程，如果找到则不会返回  
       run\_init\_process("/sbin/init");  
       run\_init\_process("/etc/init");  
       run\_init\_process("/bin/init");  
       run\_init\_process("/bin/sh");  
    // 如果上面的程序都出错，则打印下面的信息，如果内核找到init 进程，  
  // 则程序不会指向到此处  
       panic("No init found.  Try passing init= option to kernel.");  
\}  
1.2 do\_basic\_setup 函数  
在这里我们最关心的是do\_basic\_setup 函数，顾名思义该函数的功能就是“做基本设置”，它的实现代码也在<top\_dir>/init/main.c 中。do\_basic\_setup() 完成外设及其驱动程序的加载和初始化。该函数代码如下所示：  
   
static void \_\_init do\_basic\_setup(void)  
\{  
       /\* drivers will send hotplug events \*/  
       init\_workqueues();     // 初始化工作队列  
       usermodehelper\_init();  // 初始化khelper 内核线程，还没弄清楚  
   
       driver\_init();   // 初始化内核的设备管理架构需要的数据结构，  
                            // 很复杂，以后在谈这部分。  
   
\#ifdef CONFIG\_SYSCTL  
       sysctl\_init();          // 没搞懂  
\#endif  
       do\_initcalls();         // 重点函数，初始化的主要工作就靠它了  
\}  
1.3 do\_ initcalls 函数  
       do\_initcalls 函数将会调用内核中所有的初始化函数，它的代码同样在<top\_dir>/init/main.c 中。do\_initcalls 函数调用其他初始化函数相当简洁，它的关键代码如下所示：  
initcall\_t \*call;  
for (call = \_\_initcall\_start; call < \_\_initcall\_end; call++) \{  
……  
       result = (\*call)();  
……  
｝  
       简洁归简洁，但这段代码是什么意思呢？这说来就话长了，最重要的应该是先了解Linux 处理初始化的大体思想，由于Linux 有很多部分需要初始化，每个部分都有自己的初始化函数，如果按照常理一个一个的调用未免显得冗长，而且也不便于扩展。那么Linux 是怎么处理的呢？首先，Linux 将各个部分的初始化函数编译到一个块内存区中，当初始化完了以后释放这块内存区，这就是init 函数中free\_initmem 所要做的事。然后，再在另外的内存区中存放一些函数指针，让每个指针指向一个初始化函数。然后在do\_initcalls 中依次根据这些指针调用初始化函数。  
上面一段就是Linux 实现初始化的大体思想，下面我们看看它最终是怎么实现的。首先要了解的是\_\_define\_initcall 宏，该宏的定义在<top\_dir>/ include/linux/init.h 中，它的原型如下所示：  
   
\#define \_\_define\_initcall(level,fn,id)  static initcall\_t \_\_initcall\_\#\#fn\#\#id \_\_attribute\_used\_\_ /  
       \_\_attribute\_\_((\_\_section\_\_(".initcall" level ".init"))) = fn  
   
\_\_define\_initcall 宏有三个参数，level 表示初始化函数的级别，level 值的大小觉得了调用顺序，level 越小越先被调用，fn 就是具体的初始化函数，id 简单标识初始化函数，现在还没找到有什么用^\_^ 。\_\_define\_initcall 的功能为，首先声明一个initcall\_t 类型的函数指针\_\_initcall\_\#\#fn\#\#id ，initcall\_t 的原型为：  
typedef int (\*initcall\_t)(void);  
该类型可简单理解为函数指针类型^\_^ 。然后，让该函数指针指向fn 。最后，通过编译器的编译参数将此指针放到指定的空间".initcall" level ".init" 中，\_\_attribute\_used 向编译器说明这段代码有用，即使在没用到的时候，编译器也不会警告。\_\_attribute\_\_ 的\_\_section\_\_ 参数表示该段代码放入什么内存区域中，也即指定编译到什么地方，编译参数更详细的地方可以查阅GCC 文档，在gcc 官方网站[http://gcc.gnu.org/onlinedocs/][http_gcc.gnu.org_onlinedocs] 中能找到各个版本的手册。这样说来还是比较抽象，下面举个例子来说明：  
       假如有初始化函数init\_foolish 函数，现在使用\_\_define\_initcall 宏向内核加入该函数。假如调用方式如下：  
\_\_define\_initcall("0",init\_foolish,1) ；  
那么，\_\_define\_initcall 宏首先申请一个initcall\_t 类型的函数指针\_\_initcall\_init\_foolish1 （注意替换关系），且使该指针指向了init\_foolish ，函数指针\_\_initcall\_init\_foolish1 被放到.initcall.0.init 内存区域中，这个标志在连接时会用到。  
       有了上面的基础知识，现在回到do\_initcalls 函数中，首先注意到是\_\_initcall\_start 和\_\_initcall\_end ，它们的作用就是界定了存放初始化函数指针区域的起始地址，也即从\_\_initcall\_start 开始到\_\_initcall\_end 结束的区域中存放了指向各个初始化函数的函数指针。换句话说，只要某段程序代码从\_\_initcall\_start 开始依次调用函数指针，那么就可以完成各个部分的初始化工作，这显得十分优雅而且便于扩充，再看看do\_initcalls ，它何尝不是如此呢。这里还有一个有用的技巧就是\_\_initcall\_start 和\_\_initcall\_end 的原型是initcall\_t 型的数组，以后可以使用这种技巧^\_^ 。  
       现在我们知道了do\_initcalls 函数的实现原理，那么到底它调用了多少初始化函数呢？我们怎样才能知道呢？根据上面的分析，我们知道所有的初始化函数的指针都放在\_\_initcall\_start 和\_\_initcall\_end 区域期间，而函数指针与它指向的函数之间又有固定的关系，如上面的例子，初始化函数名为init\_foolish ，指向它的函数指针就是\_\_initcall\_init\_foolish1 ，即在此函数加上前缀\_\_initcall\_ 和一个数字后缀，反之，从函数指针也可推出初始化函数名。有了这两个信息，我们就可以很方便的找个初始化函数。怎么找呢？？首先打开Linux 完后产生的System.map 文件，然后找到\_\_initcall\_start 和\_\_initcall\_end 字符串，你会发现它们之间有很多类似于\_\_initcall\_xxx1 这样的符号，这些符号就是我们需要的函数指针了，这样就可推出初始化函数的名字。比如，我们这里需要的函数指针\_\_initcall\_net\_olddevs\_init6 ，按照上面的名字规则，很容易推出它所指向的初始化函数名字是net\_olddevs\_init 。  
       得到了初始化函数的名字又怎么样呢？又不知道它在哪个文件里，不要着急！请打开你的浏览器登陆[http://lxr.linux.no/ident][http_lxr.linux.no_ident] 网站，然后选择Linux 版本和架构，然后可以搜索我们想要的信息。比如我输入net\_olddevs\_init ，然后我就会得到该函数所在文件的相关信息。  
1.4 net\_olddevs\_init 函数  
       我们知道net\_olddevs\_init 函数在do\_initcalls 函数中被调用并执行，那么它到底要做什么呢？看看实现代码就知道了，它的实现代码可以在<top\_dir>/drivers/net/Space.c 中找到。对于网络驱动部分的主要实现代码如下：  
static int \_\_init net\_olddevs\_init(void)\{    
 ……  
       int num;  
       for (num = 0; num < 8; ++num)  
              ethif\_probe2(num);  
       ……  
\}  
这段代码就不用讲解了吧，嘿嘿！就是调用了8 次ethif\_probe2 ，赶快去看看ethif\_probe2 长什么样子。  
1.5 ethif\_probe2 函数  
       先看看该函数的实现代码，该代码也在<top\_dir>/drivers/net/Space.c 文件中。  
static void \_\_init ethif\_probe2(int unit)  
\{  
       unsigned long base\_addr = netdev\_boot\_base("eth", unit);   // 由于ethif\_probe2 被  
                                                                                                 //net\_olddevs\_init 调用了8 次，  
                   // 所以unit 的值为0 ～7 ，也即在这里可以注册eth0 ～eth7 八个网络设备  
       if (base\_addr == 1)  
              return;  
   
       (void)(    probe\_list2(unit, m68k\_probes, base\_addr == 0) &&  
              probe\_list2(unit, eisa\_probes, base\_addr == 0) &&  
              probe\_list2(unit, mca\_probes, base\_addr == 0) &&  
              probe\_list2(unit, isa\_probes, base\_addr == 0) &&  
              probe\_list2(unit, parport\_probes, base\_addr == 0));  
\}  
       该函数首先调用netdev\_boot\_base 所给的设备是否已经向内核注册，如果已注册netdev\_boot\_base 返回1 ，随后推出ethif\_probe2 。如果设备没注册，则又调用函数probe\_list2 四次，每次传递的传输不同，注意到每次传递的第二个参数不同，这个参数也是相当重要的，这里拿isa\_probes 参数为例说明，因为这个参数与cs89x0\_probe 有关，isa\_probes 的定义也在<top\_dir>/drivers/net/Space.c 中，它的样子形如：  
static struct devprobe2 isa\_probes\[\] \_\_initdata = \{  
……  
\#ifdef CONFIG\_SEEQ8005  
       \{seeq8005\_probe, 0\},  
\#endif  
\#ifdef CONFIG\_CS89x0  
      \{cs89x0\_probe, 0\},  
\#endif  
\#ifdef CONFIG\_AT1700  
       \{at1700\_probe, 0\},  
\#endif  
       \{NULL, 0\},  
……  
\};  
如果把cs8900 的驱动选为非编译进内核，那么它的探测函数cs89x0\_probe 就不会存在于isa\_probes 数组中，所以在初始阶段就不能被调用。从上面的代码可以知道devprobe2 类型至少包括两个域，至少一个域为函数指针，看看它的原型如下：  
struct devprobe2 \{  
       struct net\_device \*(\*probe)(int unit);                         // 函数指针，指向探测函数  
       int status;       /\* non-zero if autoprobe has failed \*/  
\};  
下面看看probe\_list2 函数是怎么表演的。  
1.6 ethif\_probe2 函数  
       对于ethif\_probe2 函数也没有什么需要说明的，它的主要任务是依次调用devprobe2 类型的probe 域指向的函数。他的实现代码同样在<top\_dir>/drivers/net/Space.c 中，它的关键代码如下：  
   
   
static int \_\_init probe\_list2(int unit, struct devprobe2 \*p, int autoprobe)  
\{  
       struct net\_device \*dev;  
       for (; p->probe; p++) \{  
           ……  
              dev = p->probe(unit);  
              ……  
       \}  
……  
\}  
1.7 cs89x0\_probe 函数  
       从该函数起，真正开始执行与cs8900 驱动初始化程序，该函数在<top\_dir>/drivers/net/cs89x0.c 文件实现。下面依次解释该函数。  
   
struct net\_device \* \_\_init cs89x0\_probe(int unit)  
\{  
       struct net\_device \*dev = alloc\_etherdev(sizeof(struct net\_local));  // 该函数申请一个net\_device ＋  
//sizeof(struct net\_local) 的空间，net\_local 是cs8900 驱动的私有数据空间。  
       unsigned \*port;  
       int err = 0;  
       int irq;  
       int io;  
        
       if (!dev)  
              return ERR\_PTR(-ENODEV);  
       sprintf(dev->name, "eth%d", unit);                 // 初始化dev->name 域  
       netdev\_boot\_setup\_check(dev);                   // 检查是否给定了启动参数，如果给定了  
                                                                           // 启动参数，此函数将初始 化dev 的irq 、  
                                                                          //base\_addr 、mem\_start 和mem\_end 域。  
       io = dev->base\_addr;        //io 实际实质cs8900 所占地址空间的起始地址，  
                                                // 此地址为虚拟地址  
       irq = dev->irq;  
   
       if (net\_debug)  
              printk("cs89x0:cs89x0\_probe(0x%x)/n", io);  
// 下面根据io 的值调用cs89x0\_probe1 函数  
       if (io > 0x1ff) \{/\* Check a single specified location. \*/    // 此段没搞懂，由于没给  
                                                                                            // 启动参数，这里也不会执行  
         err = cs89x0\_probe1(dev, io, 0);  
       \} else if (io != 0) \{ /\* Don't probe at all. \*/  
              err = -ENXIO;  
       \} else \{  
              for (port = netcard\_portlist; \*port; port++) \{// netcard\_portlist 为unsigned int 型数组，在cs89x0.c 文件中定  
// 义，里面列出了cs8900 可能占用空间的起始地址，这些地址  
// 将在cs89x0\_probe1 函数中用于向内核申请。  
                     if (cs89x0\_probe1(dev, \*port, 0) == 0) // cs89x0\_probe1 探测成功就返回0  
                            break;  
                     dev->irq = irq;  
              \}  
              if (!\*port)  
                     err = -ENODEV;  
       \}  
       if (err)  
              goto out;  
       return dev;  
out:  
       free\_netdev(dev);   // 表示探测失败，这里就释放dev 的空间，随后打印些消息  
       printk(KERN\_WARNING "cs89x0: no cs8900 or cs8920 detected.  Be sure to disable PnP with SETUP/n");  
       return ERR\_PTR(err);  
\}  
       从上面的程序清单可以看到该函数还没有真正的开始探测cs8900 ，实质的探测工作是让cs89x0\_probe1 完成的。在解释cs89x0\_probe1 之前先提一下网络驱动程序中非常重要的一些函数。内核需要一个数据结构来管理或者描述每个网络驱动程序，这个数据类型就是struct net\_device ，该数据类型包括很多域，详细的解释可以参见《Linux 设备驱动程序》一书中的描述，也可以参见源代码（在<top\_dir>/include/linux/netdevice.h 中，源码中也有详细的注解）。内核为了编程方便特地实现了函数alloc\_netdev 来完成对net\_device 的空间分配。那么alloc\_etherdev 函数主要针对以太网在alloc\_netdev 基础上封装的一个函数，它除了申请net\_device 空间外，还会初始化net\_device 的相关域。  
1.8 cs89x0\_probe1 函数  
       对于该函数完成了最终的网络芯片cs8900 的探测工作，里面涉及了一些芯片硬件的操作，看这个源码之前应该对cs8900a 芯片比较熟悉，或者在读的时候把它的芯片manual 打开。这函数的代码很长，大约有300 多行，但是它没有什么特别的技巧，只要认真阅读，最多半天就能搞明了^\_^ ，下面给出该函数在ARM 架构下，且没开DMA 情况下的注解。  
static int \_\_init cs89x0\_probe1(struct net\_device \*dev, int ioaddr, int modular)  
\{  
       struct net\_local \*lp = netdev\_priv(dev);  //dev 空间已经在cs89x0\_probe 中申请成功，  
              // 这里lp 从dev 中得到自己的私有数据，也即net\_local 数据域的起始地址，  
             //netdev\_priv 函数为网络驱动中得到私有数据的标准函数，当然也可以直接  
             // 使用dev->priv ，但不鼓励 这种做法。  
   
  // 下面申请些局部变量  
       static unsigned version\_printed;  
       int i;  
       int tmp;  
       unsigned rev\_type = 0;  
       int eeprom\_buff\[CHKSUM\_LEN\];  
       int retval;  
   
       SET\_MODULE\_OWNER(dev);  // 设置模块的属于者, 该宏定义在  
                                                           //include/linux/netdevice 文件中, 实际为 do\{\}while(0)  
        
       /\* Initialize the device structure. \*/  
       if (!modular) \{ // 这里的modular 为0, 由cs89x0\_probe 传入  
              memset(lp, 0, sizeof(\*lp));      // 将lp 填充为0  
              spin\_lock\_init(&lp->lock);  // 初始化自旋锁, 自旋锁用于保护dev 结构的互斥访问  
\#ifndef MODULE      // 在make menuconfig 时确定, 表示是否将网络驱动编译为模块。  
\#if ALLOW\_DMA    // 是否启用了DMA  
              if (g\_cs89x0\_dma) \{  
                     lp->use\_dma = 1;  
                     lp->dma = g\_cs89x0\_dma;  
                     lp->dmasize = 16;   /\* Could make this an option... \*/  
              \}  
   
\#endif  
              lp->force = g\_cs89x0\_media\_\_force;  
\#endif  
        \}  
   
  ......  
   
       /\* Grab the region so we can find another board if autoIRQ fails. \*/  
       /\* WTF is going on here? \*/  
        
       // request\_region 函数向内核注册io 地址空间，这里NETCARD\_IO\_EXTENT ＝16  
       // 所以可以看出cs8900 工作在I/O 模式。cs8900 在memory 模式需要映射4k 空间  
       if (request\_region(ioaddr & ~3, NETCARD\_IO\_EXTENT, DRV\_NAME)==NULL) \{  
              printk(KERN\_ERR "%s: request\_region(0x%x, 0x%x) failed/n",  
                            DRV\_NAME, ioaddr, NETCARD\_IO\_EXTENT);  
              retval = -EBUSY;  
              goto out1;  
       \}  
   
......  
   
       /\* if they give us an odd I/O address, then do ONE write to  
           the address port, to get it back to address zero, where we  
           expect to find the EISA signature word. An IO with a base of 0x3  
          will skip the test for the ADD\_PORT. \*/  
           
  // 下面这段代码比较费解，不是说代码的意思不好解释，而是为什么只在寄地址  
  // 才检查呢？根据数据手册的说明“The CS8900A reads 3000h from IObase+0Ah after  
  //the reset, until the software writes a non-zero value at IObase+0Ah. The  
  //3000h value can be used as part of the CS8900A signature when the system  
  //scans for the CS8900A. ”从这段话可知，这只能作为扫描到cd8900 存在部分的依据;  
 // 从后面的代码中可以看到，还需要确定cs8900 的ID 号后才能真正确保cs8900 存在。  
       if (ioaddr & 1) \{  
              if (net\_debug > 1)  
                     printk(KERN\_INFO "%s: odd ioaddr 0x%x/n", dev->name, ioaddr);  
               if ((ioaddr & 2) != 2)  
                      if ((readword(ioaddr & ~3, ADD\_PORT) & ADD\_MASK) != ADD\_SIG) \{  
                            printk(KERN\_ERR "%s: bad signature 0x%x/n",  
                                   dev->name, readword(ioaddr & ~3, ADD\_PORT));  
                             retval = -ENODEV;  
                            goto out2;  
                     \}  
       \}  
   
       ioaddr &= ~3;  
       printk(KERN\_DEBUG "PP\_addr at %x\[%x\]: 0x%x/n",  
                     ioaddr, ADD\_PORT, readword(ioaddr, ADD\_PORT));  
       writeword(ioaddr, ADD\_PORT, PP\_ChipID);             // 这里表示扫描到cs8900 ，  
                                                                                           // 按照数据手册写0  
   
// 下面这段代码确定cs8900 的EISA ID 号是否为0x630E 。这里DATA\_PORT=0x0C 是  
//cs8900 的数据口, CHIP\_EISA\_ID\_SIG=0x630E ，0x630E 为Crystal 公司在EISA 的注册  
// 号。通过下面的检查以后就真正确定了cs8900 存在，硬件电路ok 。  
// 以及向内核注册的端口地址ok 。  
       tmp = readword(ioaddr, DATA\_PORT);  
       if (tmp != CHIP\_EISA\_ID\_SIG) \{  
              printk(KERN\_DEBUG "%s: incorrect signature at %x\[%x\]: 0x%x!="  
                     CHIP\_EISA\_ID\_SIG\_STR "/n",  
                     dev->name, ioaddr, DATA\_PORT, tmp);  
             retval = -ENODEV;  
             goto out2;  
       \}  
   
       /\* Fill in the 'dev' fields. \*/  
       dev->base\_addr = ioaddr;  
   
       /\* get the chip type \*/  
       rev\_type = readreg(dev, PRODUCT\_ID\_ADD);//rev\_type=0x0a00 ，这个值是实际  
       // 测试出来的，但根据cs8900A 的数据手册，该值应该是0x0700 。???  
       lp->chip\_type = rev\_type &~ REVISON\_BITS;  
       lp->chip\_revision = ((rev\_type & REVISON\_BITS) >> 8) + 'A';  
  // 执行上面赋值后lp->chip\_type=0x0 ，lp->chip\_revision=0x4b 。注意这里的加法运算  
  //rev\_type & REVISON\_BITS)>>8=0x0a ，这个0x0a 是数字，'A' 转换成十  
  // 六进制后为0x41 ，所以，0x41+0x0a=0x4b ，0x4b 在ascii 码中对应的字母为'K'  
   
       /\* Check the chip type and revision in order to set the correct send command  
       CS8920 revision C and CS8900 revision F can use the faster send. \*/  
       lp->send\_cmd = TX\_AFTER\_381;       // 默认每次传输381 字节，  
                                                                     // 根据数据手册可以传输的字节  
       // 选项有5 、381 、1021 、all 四个，但这里的驱动不支持1021 字节的选项。  
       if (lp->chip\_type == CS8900 && lp->chip\_revision >= 'F')// 此条件满足  
              lp->send\_cmd = TX\_NOW;// 选择每次传输5 字节  
       if (lp->chip\_type != CS8900 && lp->chip\_revision >= 'C')  
              lp->send\_cmd = TX\_NOW;  
   
       if (net\_debug  &&  version\_printed++ == 0)  
              printk(version);  
   
       printk(KERN\_INFO "%s: cs89%c0%s rev %c found at %\#3lx ",  
              dev->name,  
              lp->chip\_type==CS8900?'0':'2',  
              lp->chip\_type==CS8920M?"M":"",  
              lp->chip\_revision,  
              dev->base\_addr);// 按照上面的分析，这里打印的应该形如：  
              //cs89x0.c: v2.4.3-pre1 Russell Nelson <[nelson@crynwr.com][nelson_crynwr.com]>,  
              //Andrew Morton <[andrewm@uow.edu.au][andrewm_uow.edu.au]> eth0: cs8900 rev K found at 0xf4000300  
   
       reset\_chip(dev);  // 重新复位cs8900a  
   
     /\* Here we read the current configuration of the chip. If there  
          is no Extended EEPROM then the idea is to not disturb the chip  
          configuration, it should have been correctly setup by automatic  
          EEPROM read on reset. So, if the chip says it read the EEPROM  
          the driver will always do \*something\* instead of complain that  
          adapter\_cnf is 0. \*/  
   
   
......  
// 以下代码一直到printk(KERN\_INFO "cs89x0 media %s%s%s", 功能为  
// 从EEPROM 中读出配置信息，并填充dev 结构的相关域。  
        if ((readreg(dev, PP\_SelfST) & (EEPROM\_OK | EEPROM\_PRESENT)) ==  
             (EEPROM\_OK|EEPROM\_PRESENT)) \{// 读取SelfST 寄存器，并判断EEPROM  
                        // 是否存在 若存在，则判断是否读取操作成功。上述条件满足，  
                        // 则读出EEPROM 中的配置 信息填充dev 相关域。  
               /\* Load the MAC. \*/  
              for (i=0; i < ETH\_ALEN/2; i++) \{// 读取以太网地址  
                       unsigned int Addr;  
                     Addr = readreg(dev, PP\_IA+i\*2);  
                      dev->dev\_addr\[i\*2\] = Addr & 0xFF;  
                      dev->dev\_addr\[i\*2+1\] = Addr >> 8;  
              \}  
   
            /\* Load the Adapter Configuration.  
                 Note:  Barring any more specific information from some  
                 other source (ie EEPROM+Schematics), we would not know  
                 how to operate a 10Base2 interface on the AUI port.  
                 However, since we  do read the status of HCB1 and use  
                 settings that always result in calls to control\_dc\_dc(dev,0)  
                 a BNC interface should work if the enable pin  
                 (dc/dc converter) is on HCB1. It will be called AUI  
                 however. \*/  
   
              lp->adapter\_cnf = 0;  
              i = readreg(dev, PP\_LineCTL);      // 读取LineCTL 寄存器，  
                           // 确定MAC 配置和物理接口  
              /\* Preserve the setting of the HCB1 pin. \*/  
              if ((i & (HCB1 | HCB1\_ENBL)) ==  (HCB1 | HCB1\_ENBL))  
                     lp->adapter\_cnf |= A\_CNF\_DC\_DC\_POLARITY;  
              /\* Save the sqelch bit \*/  
              if ((i & LOW\_RX\_SQUELCH) == LOW\_RX\_SQUELCH)  
                     lp->adapter\_cnf |= A\_CNF\_EXTND\_10B\_2 | A\_CNF\_LOW\_RX\_SQUELCH;  
              /\* Check if the card is in 10Base-t only mode \*/  
              if ((i & (AUI\_ONLY | AUTO\_AUI\_10BASET)) == 0)  
                     lp->adapter\_cnf |=  A\_CNF\_10B\_T | A\_CNF\_MEDIA\_10B\_T;  
              /\* Check if the card is in AUI only mode \*/  
              if ((i & (AUI\_ONLY | AUTO\_AUI\_10BASET)) == AUI\_ONLY)  
                     lp->adapter\_cnf |=  A\_CNF\_AUI | A\_CNF\_MEDIA\_AUI;  
              /\* Check if the card is in Auto mode. \*/  
              if ((i & (AUI\_ONLY | AUTO\_AUI\_10BASET)) == AUTO\_AUI\_10BASET)  
                     lp->adapter\_cnf |=  A\_CNF\_AUI | A\_CNF\_10B\_T |  
                     A\_CNF\_MEDIA\_AUI | A\_CNF\_MEDIA\_10B\_T | A\_CNF\_MEDIA\_AUTO;  
   
              if (net\_debug > 1)  
                     printk(KERN\_INFO "%s: PP\_LineCTL=0x%x, adapter\_cnf=0x%x/n",  
                                   dev->name, i, lp->adapter\_cnf);  
   
              /\* IRQ. Other chips already probe, see below. \*/  
              if (lp->chip\_type == CS8900)  
                     lp->isa\_config = readreg(dev, PP\_CS8900\_ISAINT) & INT\_NO\_MASK;  
   
              printk( "\[Cirrus EEPROM\] ");  
       \}  
   
        printk("/n");  
   
       /\* First check to see if an EEPROM is attached. \*/  
......// 以下检查EEPROM 的相关信息  
       if ((readreg(dev, PP\_SelfST) & EEPROM\_PRESENT) == 0)// 是否EEPROM 存在  
              printk(KERN\_WARNING "cs89x0: No EEPROM, relying on command line..../n");  
       else if (get\_eeprom\_data(dev, START\_EEPROM\_DATA,CHKSUM\_LEN,eeprom\_buff) < 0) \{  
         // 读取RRPROM 失败  
              printk(KERN\_WARNING "/ncs89x0: EEPROM read failed, relying on command line./n");  
        \} else if (get\_eeprom\_cksum(START\_EEPROM\_DATA,CHKSUM\_LEN,eeprom\_buff) < 0) \{  
              /\* Check if the chip was able to read its own configuration starting  
                 at 0 in the EEPROM\*/  
              if ((readreg(dev, PP\_SelfST) & (EEPROM\_OK | EEPROM\_PRESENT)) !=  
                  (EEPROM\_OK|EEPROM\_PRESENT))  
                       printk(KERN\_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line/n");  
   
        \} else \{  
              /\* This reads an extended EEPROM that is not documented  
                 in the CS8900 datasheet. 扩展配置\*/  
   
                /\* get transmission control word  but keep the autonegotiation bits \*/  
                if (!lp->auto\_neg\_cnf) lp->auto\_neg\_cnf = eeprom\_buff\[AUTO\_NEG\_CNF\_OFFSET/2\];  
                /\* Store adapter configuration \*/  
                if (!lp->adapter\_cnf) lp->adapter\_cnf = eeprom\_buff\[ADAPTER\_CNF\_OFFSET/2\];  
                /\* Store ISA configuration \*/  
                lp->isa\_config = eeprom\_buff\[ISA\_CNF\_OFFSET/2\];  
                dev->mem\_start = eeprom\_buff\[PACKET\_PAGE\_OFFSET/2\] << 8;  
   
                /\* eeprom\_buff has 32-bit ints, so we can't just memcpy it \*/  
                /\* store the initial memory base address \*/  
                for (i = 0; i < ETH\_ALEN/2; i++) \{  
                        dev->dev\_addr\[i\*2\] = eeprom\_buff\[i\];  
                        dev->dev\_addr\[i\*2+1\] = eeprom\_buff\[i\] >> 8;  
                \}  
              if (net\_debug > 1)  
                     printk(KERN\_DEBUG "%s: new adapter\_cnf: 0x%x/n",  
                            dev->name, lp->adapter\_cnf);  
        \}  
   
        /\* allow them to force multiple transceivers.  If they force multiple, autosense \*/  
        \{  
              int count = 0;  
              if (lp->force & FORCE\_RJ45)      \{lp->adapter\_cnf |= A\_CNF\_10B\_T; count++; \}  
              if (lp->force & FORCE\_AUI)      \{lp->adapter\_cnf |= A\_CNF\_AUI; count++; \}  
              if (lp->force & FORCE\_BNC)      \{lp->adapter\_cnf |= A\_CNF\_10B\_2; count++; \}  
              if (count > 1)                \{lp->adapter\_cnf |= A\_CNF\_MEDIA\_AUTO; \}  
              else if (lp->force & FORCE\_RJ45)\{lp->adapter\_cnf |= A\_CNF\_MEDIA\_10B\_T; \}  
              else if (lp->force & FORCE\_AUI) \{lp->adapter\_cnf |= A\_CNF\_MEDIA\_AUI; \}  
              else if (lp->force & FORCE\_BNC)       \{lp->adapter\_cnf |= A\_CNF\_MEDIA\_10B\_2; \}  
        \}  
   
       if (net\_debug > 1)  
              printk(KERN\_DEBUG "%s: after force 0x%x, adapter\_cnf=0x%x/n",  
                     dev->name, lp->force, lp->adapter\_cnf);  
   
        /\* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here \*/  
   
        /\* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto\_neg\_cnf here \*/  
   
        /\* FIXME: we don't set the Ethernet address on the command line.  Use  
           ifconfig IFACE hw ether AABBCCDDEEFF \*/  
   
       printk(KERN\_INFO "cs89x0 media %s%s%s",// 如果没有EEPROM ，将打印单个空格  
              (lp->adapter\_cnf & A\_CNF\_10B\_T)?"RJ-45,":"",  
              (lp->adapter\_cnf & A\_CNF\_AUI)?"AUI,":"",  
              (lp->adapter\_cnf & A\_CNF\_10B\_2)?"BNC,":"");  
   
       lp->irq\_map = 0xffff;  
   
       /\* If this is a CS8900 then no pnp soft \*/  
       if (lp->chip\_type != CS8900 &&  
           /\* Check if the ISA IRQ has been set  \*/  
              (i = readreg(dev, PP\_CS8920\_ISAINT) & 0xff,  
               (i != 0 && i < CS8920\_NO\_INTS))) \{// 非cs8900 芯片  
              if (!dev->irq)  
                     dev->irq = i;  
       \} else \{  
              i = lp->isa\_config & INT\_NO\_MASK;// 由于没有EEPROM ，所以lp->isa\_config=0  
              if (lp->chip\_type == CS8900) \{  
   
                     /\* Translate the IRQ using the IRQ mapping table. \*/  
                     if (i >= sizeof(cs8900\_irq\_map)/sizeof(cs8900\_irq\_map\[0\]))  
             //sizeof(cs8900\_irq\_map)/sizeof(cs8900\_irq\_map\[0\]) 求cs8900\_irq\_map 数据元个数  
                            printk("/ncs89x0: invalid ISA interrupt number %d/n", i);  
                     else  
                            i = cs8900\_irq\_map\[i\];//i 保存了中断号  
   
                     lp->irq\_map = CS8900\_IRQ\_MAP; /\* fixed IRQ map for CS8900 \*/  
              \} else \{  
                     int irq\_map\_buff\[IRQ\_MAP\_LEN/2\];  
   
                     if (get\_eeprom\_data(dev, IRQ\_MAP\_EEPROM\_DATA,  
                                       IRQ\_MAP\_LEN/2,  
                                       irq\_map\_buff) >= 0) \{  
                            if ((irq\_map\_buff\[0\] & 0xff) == PNP\_IRQ\_FRMT)  
                                   lp->irq\_map = (irq\_map\_buff\[0\]>>8) | (irq\_map\_buff\[1\] << 8);  
                     \}  
   
              \}  
              if (!dev->irq)  
                     dev->irq = i;// 填充dev->irq ，按照前面的定义该值为53  
       \}  
   
       printk(" IRQ %d", dev->irq);  
   
\#if ALLOW\_DMA  
       if (lp->use\_dma) \{  
              get\_dma\_channel(dev);  
              printk(", DMA %d", dev->dma);  
       \}  
       else  
\#endif  
       \{  
              printk(", programmed I/O");  
       \}  
   
       /\* print the ethernet address. \*/  
       printk(", MAC");  
       for (i = 0; i < ETH\_ALEN; i++)  
       \{  
              printk("%c%02x", i ? ':' : ' ', dev->dev\_addr\[i\]);  
       \}  
   
   
// 指定相关cs8900 支持的相关操作  
       dev->open             = net\_open;      // 打开接口，该函数应该注册所有的系统资源  
       dev->stop              = net\_close;      // 停止接口，该函数执行的操作与open 相反  
       dev->tx\_timeout            = net\_timeout;                     // 传输超时时，将调用此函数  
       dev->watchdog\_timeo= HZ; // 在网络层确定传输超时，调用tx\_timeout 前的最小延时  
       dev->hard\_start\_xmit    = net\_send\_packet;              // 该方法初始化数据包传输。完整的数据包在sk\_buffer 中  
       dev->get\_stats              = net\_get\_stats;                          // 获得接口的统计信息  
       dev->set\_multicast\_list = set\_multicast\_list; // 当组播列表发生改变，或者设备标志发  
                                                                         // 生改变时，将调 用该方法  
       dev->set\_mac\_address = set\_mac\_address;             // 设置硬件的地址  
\#ifdef CONFIG\_NET\_POLL\_CONTROLLER  
       dev->poll\_controller       = net\_poll\_controller;           // 该方法在进制中断的情况下，  
// 要求驱动程序在接口上检 查事件。它被用于特定的内核网络中，比如远程控制台  
// 和内核网络调试。  
\#endif  
   
       printk("/n");  
       if (net\_debug)  
              printk("cs89x0\_probe1() successful/n");  
   
       retval = register\_netdev(dev);// 向内核注册cs8900 驱动程序  
       if (retval)  
              goto out3;  
       return 0;  
out3:  
       writeword(dev->base\_addr, ADD\_PORT, PP\_ChipID);  
out2:  
       release\_region(ioaddr & ~3, NETCARD\_IO\_EXTENT);  
out1:  
       return retval;  
\}  
   
1.9 一些问题总结  
       这里没有讲解cs8900 驱动的移植过程，需要移植的朋友可以参见前面提到的weibing 的博客文章。这里需要补充的是很多朋友在移植成功了以后，发现内核会打印出如下的消息：  
cs89x0\_probe1() successful  
cs89x0:cs89x0\_probe(0x0)  
cs8900a: request\_region(0xf4000300, 0x10) failed  
cs89x0: no cs8900 or cs8920 detected.  Be sure to disable PnP with SETUP  
该消息的很奇怪，先是说cs89x0\_peobe1 成功，后面又提示说失败，而且没有影响网络驱动的功能，这时为什么呢？回忆在net\_olddevs\_init 函数时，它调用了8 次ethif\_probe2 函数，也就是说cs89x0\_peobe1 不被调用了一次，第一次成功了，后面的肯定会失败，如果按照这种思路，那应该会打印7 次失败信息，而这里只有一次，不解ing ！这个问题也可以简单的解决，我采用了下面的方法解决此问题，判断cs89x0\_probe 的参数是否大于0 ，如果大于0 就直接退出，这使得cs89x0\_probe 函数只正常执行一次，这样处理以后就没有提示失败的信息。  
                                                                                          To be continued……  
                                                                                           ------ anmnmnly  
                                                                                           ------ 2007.11.30

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/thewayma/archive/2009/08/11/4433167.aspx][http_blog.csdn.net_thewayma_archive_2009_08_11_4433167.aspx]

2.1 net\_open 与 net\_close

net\_open 函数主要完成的工作有：（这段 net\_open 函数的概要内容总结来源于网络，网址： [http://www.akae.cn/bbs/archiver/?tid-6657.html][http_www.akae.cn_bbs_archiver_tid-6657.html] ）

A ．获取私有数据指针存放于 lp

B ．启动设备总线控制功能和启动存储器

C ．调用 request\_irq() 请求中断并注册 net\_interrupt 为中断服务程序；

D ．写中断号存于设备中 write\_irq()

E ．如果无法申请中断号，则返回错误

F ．如果支持 DMA 则通过以下函数初始化 DMA ：

\_get\_dma\_pages();

get\_order();

dma\_page\_eq();

G ．申请 DMA ， requeset\_dma()

H ．初始化设备结构中关于 DMA 的参数，并使能 DMA ；

I ．设置以太网地址， writereg()

J ．检测链路，从而确定连接媒体类型

K ．配置链路：

a.10B\_T:detect\_tp()

b.AUI:detect\_aui()

c.10B\_2:detect\_bnu()

d.AUTO: 从头检测自动配置

L ．输出信息

M ．启动链路串行接收和发送功能

N ．初始化 lp 相关参数

O ．配置 DMA ， set\_dma\_cfg()

P ．配置芯片相关寄存器

Q ．配置 DMA 缓冲 dma\_bufcfg()

R ．使能芯片中断；

S ．启动网络传输队列， netif\_start\_queue()

这部分内容都与 cs8900 芯片具体操作相关，相对来说和比较简单，下面直接给出 net\_open 与 net\_close 的相关注解

static int net\_open(struct net\_device \*dev)

struct net\_local \*lp = netdev\_priv(dev);

int result = 0;

int i;

int ret;

......// 省略一些信息

/\* FIXME: Cirrus' release had this: \*/

writereg(dev, PP\_BusCTL, readreg(dev,PP\_BusCTL)|ENABLE\_IRQ);// 使能 cs8900 中断

write\_irq(dev, lp->chip\_type, dev->irq);// 该函数选择 cs8900 芯片内部的中断线，

二、 net\_open 、 net\_close 和 net\_interrupt

2.1 net\_open 与 net\_close

A ．获取私有数据指针存放于 lp

B ．启动设备总线控制功能和启动存储器

C ．调用 request\_irq() 请求中断并注册 net\_interrupt 为中断服务程序；

D ．写中断号存于设备中 write\_irq()

E ．如果无法申请中断号，则返回错误

F ．如果支持 DMA 则通过以下函数初始化 DMA ：

\_get\_dma\_pages();

get\_order();

dma\_page\_eq();

G ．申请 DMA ， requeset\_dma()

H ．初始化设备结构中关于 DMA 的参数，并使能 DMA ；

I ．设置以太网地址， writereg()

J ．检测链路，从而确定连接媒体类型

K ．配置链路：

a.10B\_T:detect\_tp()

b.AUI:detect\_aui()

c.10B\_2:detect\_bnu()

d.AUTO: 从头检测自动配置

L ．输出信息

M ．启动链路串行接收和发送功能

N ．初始化 lp 相关参数

O ．配置 DMA ， set\_dma\_cfg()

P ．配置芯片相关寄存器

Q ．配置 DMA 缓冲 dma\_bufcfg()

R ．使能芯片中断；

S ．启动网络传输队列， netif\_start\_queue()

这部分内容都与 cs8900 芯片具体操作相关，相对来说和比较简单，下面直接给出 net\_open 与 net\_close 的相关注解

static int net\_open(struct net\_device \*dev)

struct net\_local \*lp = netdev\_priv(dev);

int result = 0;

int i;

int ret;

......// 省略一些信息

/\* FIXME: Cirrus' release had this: \*/

writereg(dev, PP\_BusCTL, readreg(dev, PP\_BusCTL)|ENABLE\_IRQ );                                                           // 使能 cs8900 中断

write\_irq(dev, lp->chip\_type, dev->irq);     // 该函数选择 cs8900 芯片内部的中断线，

// 见本文件中的 write\_irq 实现

//++++++++++++++++++++++ 这段代码为自己添加，内核原版中没有

\#if defined(CONFIG\_ARCH\_S3C2410)

set\_irq\_type(dev->irq, IRQT\_RISING);  // 该函数在 kernel/irq/chip 实现，

// 可选择的中断类型有 include/linux/interrupt.h 中定义，此处设置为上升沿触发中断

\#endif

//++++++++++++++++++++++

ret = request\_irq(dev->irq, &net\_interrupt, 0, dev->name, dev); // 注册中断

if (ret) \{

if (net\_debug)

printk(KERN\_DEBUG "cs89x0: request\_irq(%d) failed/n", dev->irq);

goto bad\_out;

……

/\* set the Ethernet address \*/// 将 MAC 地址设置到 cs8900 的 Individual Address 寄存器

for (i=0; i < ETH\_ALEN/2; i++)

writereg(dev, PP\_IA+i\*2, dev->dev\_addr\[i\*2\] | (dev->dev\_addr\[i\*2+1\] << 8));

/\* while we're testing the interface, leave interrupts disabled \*/

writereg(dev, PP\_BusCTL, MEMORY\_ON);  // 使 cd8900 工作到 memory 模式，

// 如果 dev->mem\_start 域为 0 ，

// 将关闭该模式

// 以下代码为选择 cs8900 的物理传输媒体的类型

/\* Set the LineCTL quintuplet based on adapter configuration read from EEPROM \*/

// 由于没有 eeprom ， lp->adapter\_cnf 在 cs89x0\_probe1 中未设置，此值为 0.

if ((lp->adapter\_cnf & A\_CNF\_EXTND\_10B\_2) && (lp->adapter\_cnf & A\_CNF\_LOW\_RX\_SQUELCH))

lp->linectl = LOW\_RX\_SQUELCH;

else

lp->linectl = 0;

/\* check to make sure that they have the "right" hardware available \*/

switch(lp->adapter\_cnf & A\_CNF\_MEDIA\_TYPE) \{

case A\_CNF\_MEDIA\_10B\_T: result = lp->adapter\_cnf & A\_CNF\_10B\_T; break;

case A\_CNF\_MEDIA\_AUI:   result = lp->adapter\_cnf & A\_CNF\_AUI; break;

case A\_CNF\_MEDIA\_10B\_2: result = lp->adapter\_cnf & A\_CNF\_10B\_2; break;

default: result = lp->adapter\_cnf & (A\_CNF\_10B\_T | A\_CNF\_AUI | A\_CNF\_10B\_2);

\#if defined(CONFIG\_ARCH\_PNX0105) || defined(CONFIG\_ARCH\_S3C2410)//+++++++++

result = A\_CNF\_10B\_T;     // 上面由于 lp->adapter\_cnf=0 ，导致 result=0 ，

// 这里额外设置 该值可以根据需要实际情况设置，可设置的值可在

// cs89x0.h 中找到 当然这里也可以设置 lp->adapter\_cnf 成想要的值

\#endif

if (!result) \{//result==0 时执行此段代码

printk(KERN\_ERR "%s: EEPROM is configured for unavailable media/n", dev->name);

release\_irq:

......

writereg(dev, PP\_LineCTL, readreg(dev, PP\_LineCTL) & ~(SERIAL\_TX\_ON | SERIAL\_RX\_ON));

free\_irq(dev->irq, dev);

ret = -EAGAIN;

goto bad\_out;

/\* set the hardware to the configured choice \*/

switch(lp->adapter\_cnf & A\_CNF\_MEDIA\_TYPE) \{//lp->adapter\_cnf & A\_CNF\_MEDIA\_TYPE==0,

// 不符合任何 case 情况，将执行 default ，但未实现 default

case A\_CNF\_MEDIA\_10B\_T:

result = detect\_tp(dev);  //detect\_tp 探测物理传输媒体类型是 RJ-45H,

// 还是 RJ-45F

if (result==DETECTED\_NONE) \{

printk(KERN\_WARNING "%s: 10Base-T (RJ-45) has no cable/n", dev->name);

if (lp->auto\_neg\_cnf & IMM\_BIT) /\* check "ignore missing media" bit \*/

result = DETECTED\_RJ45H; /\* Yes! I don't care if I see a link pulse \*/

break;

case A\_CNF\_MEDIA\_AUI:

result = detect\_aui(dev);//detect\_tp 探测物理传输媒体类型是否为 AUI 型

if (result==DETECTED\_NONE) \{

printk(KERN\_WARNING "%s: 10Base-5 (AUI) has no cable/n", dev->name);

if (lp->auto\_neg\_cnf & IMM\_BIT) /\* check "ignore missing media" bit \*/

result = DETECTED\_AUI; /\* Yes! I don't care if I see a carrrier \*/

break;

case A\_CNF\_MEDIA\_10B\_2:

result = detect\_bnc(dev);  //detect\_tp 探测物理传输媒体类型是否为 BNC 型

if (result==DETECTED\_NONE) \{

printk(KERN\_WARNING "%s: 10Base-2 (BNC) has no cable/n", dev->name);

if (lp->auto\_neg\_cnf & IMM\_BIT) /\* check "ignore missing media" bit \*/

result = DETECTED\_BNC; /\* Yes! I don't care if I can xmit a packet \*/

break;

case A\_CNF\_MEDIA\_AUTO:

writereg(dev, PP\_LineCTL, lp->linectl | AUTO\_AUI\_10BASET);

if (lp->adapter\_cnf & A\_CNF\_10B\_T)

if ((result = detect\_tp(dev)) != DETECTED\_NONE)

break;

if (lp->adapter\_cnf & A\_CNF\_AUI)

if ((result = detect\_aui(dev)) != DETECTED\_NONE)

break;

if (lp->adapter\_cnf & A\_CNF\_10B\_2)

if ((result = detect\_bnc(dev)) != DETECTED\_NONE)

break;

printk(KERN\_ERR "%s: no media detected/n", dev->name);

goto release\_irq;

switch(result) \{     // 上面将 result 赋成了 A\_CNF\_10B\_T ，该值为 1 ，刚好等于

// DETECTED\_RJ45H 所以也可以在上面的 result 中直接赋成

// DETECTED\_RJ45H 或者其他类型的接口

case DETECTED\_NONE:

printk(KERN\_ERR "%s: no network cable attached to configured media/n", dev->name);

goto release\_irq;

case DETECTED\_RJ45H:

printk(KERN\_INFO "%s: using half-duplex 10Base-T (RJ-45)/n", dev->name);

break;

case DETECTED\_RJ45F:

printk(KERN\_INFO "%s: using full-duplex 10Base-T (RJ-45)/n", dev->name);

break;

case DETECTED\_AUI:

printk(KERN\_INFO "%s: using 10Base-5 (AUI)/n", dev->name);

break;

case DETECTED\_BNC:

printk(KERN\_INFO "%s: using 10Base-2 (BNC)/n", dev->name);

break;

/\* Turn on both receive and transmit operations \*/

writereg(dev, PP\_LineCTL, readreg(dev, PP\_LineCTL) | SERIAL\_RX\_ON | SERIAL\_TX\_ON);

/\* Receive only error free packets addressed to this card \*/

lp->rx\_mode = 0;// 确定接收模式， 0 表示接收广播 , 非 0 表示全部接收

writereg(dev, PP\_RxCTL, DEF\_RX\_ACCEPT);    // 初始化接收控制器 RxCTL 为默认

// 接收模式。 该模式下，只接收 Broadcast 和 Individual 的 CRC

// 正确的数据包， 具体可查看 cs8900 手册。

lp->curr\_rx\_cfg = RX\_OK\_ENBL | RX\_CRC\_ERROR\_ENBL;   // 接收 OK 产生中断，

// CRC 错产生中断

if (lp->isa\_config & STREAM\_TRANSFER)// 判断是否打开 cs8900 的 stream 传输模式

lp->curr\_rx\_cfg |= RX\_STREAM\_ENBL;// 使用 stream 模式 , 此处没有启用。

writereg(dev, PP\_RxCFG, lp->curr\_rx\_cfg);       // 初始化接收配置控制器 RxCFG ，

// 这里确定了接收中断源

// 初始化发送配置控制器 TxCFG ， TxCFG 寄存器的全部有效位置为 1 ，

// 也确定了发送中断源

writereg(dev, PP\_TxCFG, TX\_LOST\_CRS\_ENBL | TX\_SQE\_ERROR\_ENBL | TX\_OK\_ENBL |

TX\_LATE\_COL\_ENBL | TX\_JBR\_ENBL | TX\_ANY\_COL\_ENBL | TX\_16\_COL\_ENBL);

writereg(dev, PP\_BufCFG, READY\_FOR\_TX\_ENBL | RX\_MISS\_COUNT\_OVRFLOW\_ENBL |

TX\_COL\_COUNT\_OVRFLOW\_ENBL | TX\_UNDERRUN\_ENBL);

/\* now that we've got our act together, enable everything \*/

writereg(dev, PP\_BusCTL, ENABLE\_IRQ          // 开中断

| (dev->mem\_start?MEMORY\_ON : 0)      // 没有设置共享内存空

// 间 dev->mem\_start 为 0 ， memory 模式将被关闭

);

netif\_start\_queue(dev);  // 激活设备发送队列，以便内核可以开始发送数据

if (net\_debug > 1)

printk("cs89x0: net\_open() succeeded/n");

return 0;

bad\_out:

return ret;

net\_close(struct net\_device \*dev)

......// 略去 DMA 部分

netif\_stop\_queue(dev);// 停止设备发送队列，通知内核不能使用该设备发送数据

writereg(dev, PP\_RxCFG, 0);// 禁用接收

writereg(dev, PP\_TxCFG, 0);// 禁用发送

writereg(dev, PP\_BufCFG, 0);// 关闭 cs8900 内部缓冲区

writereg(dev, PP\_BusCTL, 0);// 停止总线

free\_irq(dev->irq, dev);// 释放占用的中断线

......// 略去 DMA 部分

/\* Update the statistics here. \*/

return 0;

2.2 net\_interrupt

该函数的大体流程如下：（此段总结来源同上）

A ．获取设备私有数据 net\_priv() ；

B ．读取 CS8900 的中断端口状态 readword() ；

C ．判断中断类型：

a. 接收事件：调用 net\_rx() 接收数据；

b. 传输事件：调用 netif\_wake\_queue() 唤醒传输队列，进行异常处理；

c. 缓冲区事件：可以发送数据，调用 netif\_wake\_queue() 唤醒传输队列；

d. 接收包丢失事件：初始化相关 error ，错误计数

e. 传输冲突时间：初始化相关 error

D ．返回中断句柄。

net\_interrupt 中断处理函数的实现非常简单，它首先读出 cs8900 的 ISQ 寄存器的值，然后根据 ISQ 的值分别处理各种情况。当中断发生时，这些中断实际反映在相应的寄存器中， ISQ 寄存器用低 6 位记录了当前寄存器的编号，高 10 位记录了当前寄存器的实际内容。这些寄存器有： RxEvent(Register 4) ， TxEvent(Register 8) ， BufEvent(RegisterC) ， RxMISS(Register 10) 和 TxCOL(Register 12) 。比如，传输成功后， cs8900 将 TxEvent 的第 0bit 置为 1 ，如果允许该事件中断，那么 ISQ 寄存器的低 6 位将记录 TxEvent 的编号 8 ，并且将 TxEvent 寄存器的高 10 位 copy 到它的高 10 位中。

net\_interrupt 注解如下：

static irqreturn\_t net\_interrupt(int irq, void \*dev\_id)

struct net\_device \*dev = dev\_id;

struct net\_local \*lp;

int ioaddr, status;

int handled = 0;

ioaddr = dev->base\_addr;

lp = netdev\_priv(dev);

/\* we MUST read all the events out of the ISQ, otherwise we'll never

get interrupted again.  As a consequence, we can't have any limit

on the number of times we loop in the interrupt handler.  The

hardware guarantees that eventually we'll run out of events.  Of

course, if you're on a slow machine, and packets are arriving

faster than you can read them off, you're screwed.  Hasta la

vista, baby!  \*/

while ((status = readword(dev->base\_addr, ISQ\_PORT))) \{

//ISQ\_PORT=08h, 根据 cs8900 的用户手册， 这里再次说明了 cs8900 工作在 I/O 模式

if (net\_debug > 4)printk("%s: event=%04x/n", dev->name, status);

handled = 1;

switch(status & ISQ\_EVENT\_MASK) \{    //ISQ\_EVENT\_MASK=0x3f ，

// 确定 ISQ 的低 6 位， 该 6 位纪录了发生中断的寄存器

case ISQ\_RECEIVER\_EVENT:     //ISQ\_RECEIVER\_EVENT=0x04,

// 中断源来自 RxEvent ， 表示接收到了数据包

/\* Got a packet(s). \*/

net\_rx(dev);

break;

case ISQ\_TRANSMITTER\_EVENT:   //ISQ\_RECEIVER\_EVENT=0x08,

// 中断源来自 TxEvent ，根据 net\_open 中设置，有很多发送事件

// 可以产生中断，需要分别处理

lp->stats.tx\_packets++;    // 累加发送包的总数

netif\_wake\_queue(dev);  /\* Inform upper layers. \*/

if ((status & ( TX\_OK |    //ISQ 的高 10 位描述了 TxEvent 的实际内容，

// 也即实际传输的信息 这里似乎 status 应该右移 6 位？的确应该

// 这样，这里之所以没这样做， 是因为 TX\_OK 等这些值，在设

// 计时已经左移了 6 位

TX\_LOST\_CRS |

TX\_SQE\_ERROR |

TX\_LATE\_COL |

TX\_16\_COL)) != TX\_OK) \{  // 做些错误统计工作

if ((status & TX\_OK) == 0) lp->stats.tx\_errors++;

if (status & TX\_LOST\_CRS) lp->stats.tx\_carrier\_errors++;

if (status & TX\_SQE\_ERROR) lp->stats.tx\_heartbeat\_errors++;

if (status & TX\_LATE\_COL) lp->stats.tx\_window\_errors++;

if (status & TX\_16\_COL) lp->stats.tx\_aborted\_errors++;

break;

case ISQ\_BUFFER\_EVENT:  //ISQ\_RECEIVER\_EVENT=0x0c,

// 中断源来自 BufEvent

if (status & TX\_UNDERRUN) \{    // 这里说明估计的发送长度过短，可能需要做调整

if (net\_debug > 0) printk("%s: transmit underrun/n", dev->name);

lp->send\_underrun++;

if (lp->send\_underrun == 3) lp->send\_cmd = TX\_AFTER\_381; // 此值 cs89x0\_probe1 时初始化为 5 ，这里修正。

else if (lp->send\_underrun == 6) lp->send\_cmd = TX\_AFTER\_ALL;

/\* transmit cycle is done, although

frame wasn't transmitted - this

avoids having to wait for the upper

layers to timeout on us, in the

event of a tx underrun \*/

netif\_wake\_queue(dev); /\* Inform upper layers. \*/

......//DMA 部分

break;

case ISQ\_RX\_MISS\_EVENT:   //ISQ\_RX\_MISS\_EVENT=0x10,

// 中断来自于 RxMISS ， 该寄存器的高 10 位记录丢失的数据包

lp->stats.rx\_missed\_errors += (status >>6);

break;

case ISQ\_TX\_COL\_EVENT:        //ISQ\_TX\_COL\_EVENT=0x12, 中断来自于

// TxCOL ， 该寄存器的高 10 位记录发了生冲突的数据包

lp->stats.collisions += (status >>6);

break;

return IRQ\_RETVAL(handled);

To be continued……

------ anmnmnly

------ 2007.12.5

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/thewayma/archive/2009/08/11/4433176.aspx][http_blog.csdn.net_thewayma_archive_2009_08_11_4433176.aspx]

三、 net\_rx 和 net\_send\_packet  
3.1 net\_rx  
在这部分将介绍cs8900 驱动的两个最重要的函数，内核通过该两个函数实现了数据的收发。net\_rx 函数的主要功能是从cs8900 的片上数据缓冲区中将数据传送给sk\_buff 缓冲区，sk\_buff 是网络驱动程序与Linux 内核通信的缓冲区。该结构可在<top\_dir>/include/linux/skbuff.h 中找到。net\_rx 函数的功能可总结如下：（该总结来源于：[http://www.akae.cn/bbs/archiver/?tid-6657.html][http_www.akae.cn_bbs_archiver_tid-6657.html] ）  
A ．获取私有数据存放于lp 中；  
B ．获取设备缓冲区状态和缓冲长度；  
C ．如果状态不为RX\_OK 则计数接收数据错误次数count\_rx\_error()  
D ．分配一个sk\_buf 区间  
E ．字对齐，skb\_reserve() ；  
F ．插入数据到接收口，insw() ；  
G ．写入数据；  
H ．初始化sk\_buff 结构，eth\_type\_trans()  
I ．进入上层接收函数netif\_rx() ；  
J ．初始化设备的计数；  
net\_rx 函数的注解如下所示：  
static void net\_rx(struct net\_device \*dev)  
\{  
       struct net\_local \*lp = netdev\_priv(dev);             //lp 指向驱动程序的私有数据区  
       struct sk\_buff \*skb;                             // 申请skb\_buff 指针  
       int status, length;  
   
       int ioaddr = dev->base\_addr;                       // 得到cs8900 的基地址  
       status = readword(ioaddr, RX\_FRAME\_PORT);       // 获取cs8900 片上缓冲区的状态  
       length = readword(ioaddr, RX\_FRAME\_PORT);       // 获取cs8900 片上缓冲区的长度  
   
       if ((status & RX\_OK) == 0) \{          // 状态为接收错误，调用count\_rx\_errors 统计错误  
              count\_rx\_errors(status, lp);  
              return;  
       \}  
   
       /\* Malloc up new buffer. \*/  
       skb = dev\_alloc\_skb(length + 2); // 分配一个缓冲区，dev\_alloc\_skb 函数以  
三、 net\_rx 和 net\_send\_packet  
3.1 net\_rx  
在这部分将介绍cs8900 驱动的两个最重要的函数，内核通过该两个函数实现了数据的收发。net\_rx 函数的主要功能是从cs8900 的片上数据缓冲区中将数据传送给sk\_buff 缓冲区，sk\_buff 是网络驱动程序与Linux 内核通信的缓冲区。该结构可在<top\_dir>/include/linux/skbuff.h 中找到。net\_rx 函数的功能可总结如下：（该总结来源于：[http://www.akae.cn/bbs/archiver/?tid-6657.html][http_www.akae.cn_bbs_archiver_tid-6657.html] ）  
A ．获取私有数据存放于lp 中；  
B ．获取设备缓冲区状态和缓冲长度；  
C ．如果状态不为RX\_OK 则计数接收数据错误次数count\_rx\_error()  
D ．分配一个sk\_buf 区间  
E ．字对齐，skb\_reserve() ；  
F ．插入数据到接收口，insw() ；  
G ．写入数据；  
H ．初始化sk\_buff 结构，eth\_type\_trans()  
I ．进入上层接收函数netif\_rx() ；  
J ．初始化设备的计数；  
   
net\_rx 函数的注解如下所示：  
static void net\_rx(struct net\_device \*dev)  
\{  
       struct net\_local \*lp = netdev\_priv(dev);             //lp 指向驱动程序的私有数据区  
       struct sk\_buff \*skb;                             // 申请skb\_buff 指针  
       int status, length;  
   
       int ioaddr = dev->base\_addr;                       // 得到cs8900 的基地址  
       status = readword(ioaddr, RX\_FRAME\_PORT);       // 获取cs8900 片上缓冲区的状态  
       length = readword(ioaddr, RX\_FRAME\_PORT);       // 获取cs8900 片上缓冲区的长度  
   
       if ((status & RX\_OK) == 0) \{    // 状态为接收错误，调用count\_rx\_errors 统计错误  
              count\_rx\_errors(status, lp);  
              return;  
       \}  
   
       /\* Malloc up new buffer. \*/  
       skb = dev\_alloc\_skb(length + 2);             // 分配一个缓冲区，dev\_alloc\_skb 函数以  
                   //GFP\_ATOMIC 优先级调用alloc\_skb 。alloc\_skb 的功能为分配一个缓冲区  
                   // 并初始化skb->data ，skb->tail 和skb\_head 域。dev\_alloc\_skb 和alloc\_skb 的区  
                   // 别为，前者在skb->data 和skb\_head 之间保留了一些空间，网络 层使用这  
                   // 一数据空间进行优化工作，驱动程序不该访问该空间。  
       if (skb == NULL) \{    //skb 缓冲区分配失败？  
……  
              lp->stats.rx\_dropped++;  // 直接将丢包数加1  
              return;  
       \}  
       skb\_reserve(skb, 2);      /\* longword align L3 header \*/    // 该函数增加skb 的data 和tail ，  
               // 该函数可填充缓冲区之 前保留报文头空间，大多数以太网在数据包之前  
               // 保留2 个字节，这样IP 头可在14 字节的以太网头之 后，在16 字节边界上对  
               // 齐。这里也空了两个字节，这两个自己加上14 字节的以太网头刚好16 字  
              // 节。 所以这里的主要作用是字对齐。  
       skb->dev = dev;  
   
       readwords(ioaddr, RX\_FRAME\_PORT, skb\_put(skb, length), length >> 1);  //skb\_put 函  
            // 数的作用是更新skb 的 tail 和len 成员，也即在缓冲区尾部添加数据，该函数返  
            // 回skb->tail 的先前值。整句代码的含义为， 从cs8900 的数据缓冲区中读取  
      //length 个字节数据到skb 缓冲区。由于readwords 是以读取字（两个字 节）为  
            // 单位，所以length 应该保持字对齐，也即length 右移一位。  
       if (length & 1)       // 因为前面length 以字对齐，如果length 为单字节，  
                                   // 所以这里应该补上最后一个字节  
              skb->data\[length-1\] = readword(ioaddr, RX\_FRAME\_PORT);  
……  
        skb->protocol=eth\_type\_trans(skb,dev);  // 该函数定义在 linux/net/ethernet/eth.c 中，  
                                                 // 该处可参见linux 设备 驱动程序相关章节  
       netif\_rx(skb);       // 通知内核已经接收到一个数据包，并封装入一个套接字缓冲区  
       dev->last\_rx = jiffies;                    // 更新最后的接收包时间  
       lp->stats.rx\_packets++;                // 接收的总数据包数加1  
       lp->stats.rx\_bytes += length;         // 接收的字节数加上length  
\}  
   
3.1 net\_send\_packet  
       net\_send\_parcket 为内核提供了数据包发送功能，该函数在cs89x0\_probe1 中被赋予了net\_device 的hard\_start\_xmit 域，当内核需要发送数据包时，将调用dev-> hard\_start\_xmit 完成最后的数据包发送。该函数被调用的前提是，在调用该函数之前，内核已经将数据包放入了skb 缓冲区中。该函数的主要任务有：  
A ．获取设备私有数据指针  
B ．加环形锁，spin\_lock\_irq() ；  
C ．检测缓冲区是否为满，若满则调用netif\_stop\_queue() 暂停发送队列；  
D ．写发送命令和发送长度，writeword() ；  
E ．读取发送总线状态readreg() ；  
F ．解环形锁，spin\_unlock\_irq() ；  
G ．设置传输时钟计数；  
H ．释放相应sk\_buff, dev\_kfree\_skb().  
下面为此函数的简单注释：  
static int net\_send\_packet(struct sk\_buff \*skb, struct net\_device \*dev)  
\{  
       struct net\_local \*lp = netdev\_priv(dev);            // 获得驱动程序的私有数据  
   
……  
   
       spin\_lock\_irq(&lp->lock);         // 获得自旋锁，以便进入临界区  
       netif\_stop\_queue(dev);    // 通知内核暂停内核与驱动程序间的数据传递，也即告诉  
                                              // 内核不要向skb 缓冲区填充数据。  
   
       /\* initiate a transmit sequence \*/  // 初始化cs8900 的发送对列，主要为写命令和数  
                                                         // 据长度，为数据发送做准备  
       writeword(dev->base\_addr, TX\_CMD\_PORT, lp->send\_cmd);  
       writeword(dev->base\_addr, TX\_LEN\_PORT, skb->len);  
   
       /\* Test to see if the chip has allocated memory for the packet \* /       // 查看cs8900 是否为  
                                                                                      // 发送分配了地址空间。  
       if ((readreg(dev, PP\_BusST) & READY\_FOR\_TX\_NOW) == 0) \{  
           …….  
              spin\_unlock\_irq(&lp->lock);  
              if (net\_debug) printk("cs89x0: Tx buffer not free!/n");  
              return 1;  
       \}  
       /\* Write the contents of the packet \*/  
       writewords(dev->base\_addr, TX\_FRAME\_PORT,skb->data,(skb->len+1) >>1);   // 将数  
                                                                                                               // 据交给cs8900 发送  
       spin\_unlock\_irq(&lp->lock);         // 发送结束，释放自旋锁  
       lp->stats.tx\_bytes += skb->len;    // 累加发送的总字节数  
       dev->trans\_start = jiffies;             // 更新最后的传输时间  
       dev\_kfree\_skb (skb);                  // 发送完毕，释放skb 缓冲区  
    ……  
       return 0;  
\}  
总结：  
       在cs8900 驱动中，主要简解了驱动程序中的部分重要函数，包括初始化、打开/ 关闭网络驱动和发送/ 接收数据。对于其余的驱动程序代码，如超时处理、状态获取等函数没做解释，它们的实现也比较简单。由于自己板子上没有EEPROM ，所以也没有分析与EEPROM 相关部分的代码。DMA 部分好像编译进去会错，所以也没有去分析，以后有时间再去弄弄DMA 部分。  
                                                                                              The End  
                                                                                             ------ anmnmnly  
                                                                                             ------ 2007.12.16

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/thewayma/archive/2009/08/11/4433186.aspx][http_blog.csdn.net_thewayma_archive_2009_08_11_4433186.aspx]

[http_blog.csdn.net_thewayma_archive_2009_08_11_4433167.aspx]: http://blog.csdn.net/thewayma/archive/2009/08/11/4433167.aspx
[http_weibing.blogbus.com_logs_4467465.html]: http://weibing.blogbus.com/logs/4467465.html
[http_gcc.gnu.org_onlinedocs]: http://gcc.gnu.org/onlinedocs/
[http_lxr.linux.no_ident]: http://lxr.linux.no/ident
[nelson_crynwr.com]: mailto:nelson@crynwr.com
[andrewm_uow.edu.au]: mailto:andrewm@uow.edu.au
[http_www.akae.cn_bbs_archiver_tid-6657.html]: http://www.akae.cn/bbs/archiver/?tid-6657.html
[http_blog.csdn.net_thewayma_archive_2009_08_11_4433176.aspx]: http://blog.csdn.net/thewayma/archive/2009/08/11/4433176.aspx
[http_blog.csdn.net_thewayma_archive_2009_08_11_4433186.aspx]: http://blog.csdn.net/thewayma/archive/2009/08/11/4433186.aspx