首页 / 操作系统 / Linux / 移植Linux-2.6.36内核到s3c2440开发板

网上关于最新内核移植相关的文章几乎找不到。最新的似乎只有“友善之臂”针对mini2440移植2.6.32.2文档，不能照搬在俺的杂牌板上。特意下载了最新的稳定版本的内核linux-2.6.36，在俺的s3c2440开发板上试试。其中用到了”友善之臂“提供的编译器：ARM-Linux GCC 4.3.2和根文件系统：Rootfs-Qtopia-Qt4。下面是过程的大概。

１.解压进入原码顶层目录linux-2.6.36，修改Makefile文件
           "ARCH ？= arm"
           "CROSS_COMPILE ？= /usr/local/arm/4.3.2/bin/arm-linux-"
2. 将原有的arch/arm/mach-s3c2440/mach-mini2440.c删除，将arch/arm/mach-s3c2440/mach- smdk2440.c复制一份，命名为mach-mini2440.c,放在相同的目录下。修改三处mach-mini2440.c的内容先：
1>MACHINE_START（S3C2440, "SMDK2440"） ==> MACHINE_START（MINI2440, "MINI2440"）
2>s3c24xx_init_clocks（16934400） ==> s3c24xx_init_clocks（12000000）
3>将"smdk_machine_init（）;"注释掉，否则链接会报错.

3.修改机器码：将”arch/arm/tools/mach-types“文件中的mini2440相关的机器码改成自己的开发板的机器码，俺的改成：“mini2440        MACH_MINI2440       MINI2440        5244”

４make mini2440_defconfig;make；ok可以启动试一下了。由于不同于mini2440开发板,硬件配置不同，启动后错误很多。搭建开发环境，先不理它。

开发环境必须的网卡驱动。”友善之臂“的mini2440开发板用的是DM9000的网卡，俺的开发板用的是cs8900的网卡。只能“google＋自力更生”了。

5.将准备好的cs8900.c/cs8900.h两个文件复制到drivers/net/arm目录下

6.在include/net/目录下创建文件smdk2410.h，并添加如下代码：
#define pSMDK2410_ETH_IO        __phys_to_pfn（0x19000000）
#define vSMDK2410_ETH_IO        0xE0000000
#define SMDK2410_EHT_IRQ        IRQ_EINT9

7.在arch/arm/mach-s3c2440/mach-mini2440.c中加入"include <net/smdk2410.h>"
在struct map_desc smdk2440_iodesc[]中添加cs8900相应的io空间映射：
{vSMDK2410_ETH_IO, pSMDK2410_ETH_IO, SZ_1M, MT_DEVICE}

8.在drivers/net/arm/目录下的Makefile中加入cs8900相关项：
obj-$（CONFIG_ARM_CS8900）    += cs8900.o
在drivers/net/arm/目录下的Kconfig中加入cs8900相关项：
config ARM_CS8900
    tristate "CS8900 support"
    depends on NET_ETHERNET && ARM && （ARCH_SMDK2410 || ARCH_ZL2440 || MACH_MINI2440）
    help
      Support for CS8900A chipset based Ethernet cards. If you have a
      network （Ethernet） card of this type, say Y and read the
      Ethernet-HOWTO, available from
      <http://www.tldp.org/docs.html#howto> as well as <file:Documentation/networking/cs89x0.txt>.
   
      To compile this driver as a module, choose M here and read
      <file:Documentation/networking/net-modules.txt>.  The module will be called   

8.make menuconfig选中cs8900选项，去掉dm9000选项。

9.make 之后可以启动了。

下面说一下内核中网卡和cs8900驱动相关的话题：
由于内核更新后，struct net_device结构体及相关宏定义有变化，或造成在2.6.16/2.6.22/2.6.24内核工作的cs8900驱动在2.6.36上不能编译通过。主要修改如下：
    1>"IRQT_RISING"改成"IRQ_TYPE_EDGE_RISING"
    2>2.6.36内核的net_device中没有“priv“和"mc_list"项”。代码都要作相应修改。
    3>以前内核（2.6.16/2.6.22/2.6.24）struct net_device中的函数指针域在2.6.36中都放在struct net_device_ops类型的指针netdev_ops指向的结构体中。也要作相应修改。


附件是修改后的cs8900.c和cs8900.h文件。
文件传不上来。贴上吧。
下面是cs8900.c文件：

#define VERSION_STRING "Cirrus Logic CS8900A driver for Linux （Modified for ZL2440）" #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 <linux/irq.h> //#include <asm/hardware.h> #include <asm/io.h> #include <asm/uaccess.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/skbuff.h> // Added BSt #include <asm/mach-types.h> //#ifdef CONFIG_ARCH_SMDK2410 #if 1 //#include "asm/arch-s3c2410/regs-irq.h" #include "mach/regs-mem.h" //#include "asm/arch/smdk2410.h" #include "net/smdk2410.h" #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 ; #define MAX_EEPROM_SIZE        256 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）; } #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 = "";     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 ",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 ",             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）; } #endif     static void cs8900_receive （struct net_device *dev） {     //cs8900_t *priv = （cs8900_t *） dev->priv;     cs8900_t *priv = （cs8900_t *）netdev_priv（dev）;     struct sk_buff *skb;     u16 status,length;     status = cs8900_read （dev,PP_RxStatus）;     length = cs8900_read （dev,PP_RxLength）;     if （！（status & RxOK）） {         priv->stats.rx_errors++;         if （（status & （Runt | Extradata））） priv->stats.rx_length_errors++;         if （（status & CRCerror）） priv->stats.rx_crc_errors++;         return;     }     if （（skb = dev_alloc_skb （length + 4）） == NULL） {         priv->stats.rx_dropped++;         return;     }     skb->dev = dev;     skb_reserve （skb,2）;     cs8900_frame_read （dev,skb,length）; #ifdef FULL_DUPLEX     dump_packet （dev,skb,"recv"）; #endif         skb->protocol = eth_type_trans （skb,dev）;     netif_rx （skb）;     dev->last_rx = jiffies;     priv->stats.rx_packets++;     priv->stats.rx_bytes += length; } static int cs8900_send_start （struct sk_buff *skb,struct net_device *dev） {     //cs8900_t *priv = （cs8900_t *） dev->priv;     cs8900_t *priv = （cs8900_t *）netdev_priv（dev）;     u16 status;     spin_lock_irq（&priv->lock）;     netif_stop_queue （dev）;     cs8900_write （dev,PP_TxCMD,TxStart （After5））;     cs8900_write （dev,PP_TxLength,skb->len）;     status = cs8900_read （dev,PP_BusST）;     if （（status & TxBidErr）） {         spin_unlock_irq（&priv->lock）;         printk （KERN_WARNING "%s: Invalid frame size %d！ ",dev->name,skb->len）;         priv->stats.tx_errors++;         priv->stats.tx_aborted_errors++;         priv->txlen = 0;         return （1）;     }     if （！（status & Rdy4TxNOW）） {         spin_unlock_irq（&priv->lock）;         printk （KERN_WARNING "%s: Transmit buffer not free！ ",dev->name）;         priv->stats.tx_errors++;         priv->txlen = 0;                  return （1）;     }     cs8900_frame_write （dev,skb）;     spin_unlock_irq（&priv->lock）; #ifdef DEBUG     dump_packet （dev,skb,"send"）; #endif         dev->trans_start = jiffies;     dev_kfree_skb （skb）;     priv->txlen = skb->len;     return （0）; } static irqreturn_t cs8900_interrupt （int irq,void *id） {     struct net_device *dev = （struct net_device *） id;     cs8900_t *priv;     volatile u16 status;      irqreturn_t handled = 0; #if 0     if （dev->priv == NULL） {         printk （KERN_WARNING "%s: irq %d for unknown device. ",dev->name,irq）;         return 0;     } #endif     //priv = （cs8900_t *） dev->priv;     priv = （cs8900_t *）netdev_priv（dev）;          while （（status = cs8900_read （dev, PP_ISQ））） {         handled = 1;         switch （RegNum （status）） {         case RxEvent:             cs8900_receive （dev）;             break;         case TxEvent:             priv->stats.collisions += ColCount （cs8900_read （dev,PP_TxCOL））;             if （！（RegContent （status） & TxOK）） {                 priv->stats.tx_errors++;                 if （（RegContent （status） & Out_of_window）） priv->stats.tx_window_errors++;                 if （（RegContent （status） & Jabber）） priv->stats.tx_aborted_errors++;                 break;             } else if （priv->txlen） {                 priv->stats.tx_packets++;                 priv->stats.tx_bytes += priv->txlen;             }             priv->txlen = 0;             netif_wake_queue （dev）;             break;         case BufEvent:             if （（RegContent （status） & RxMiss）） {                 u16 missed = MissCount （cs8900_read （dev,PP_RxMISS））;                 priv->stats.rx_errors += missed;                 priv->stats.rx_missed_errors += missed;             }             if （（RegContent （status） & TxUnderrun）） {                 priv->stats.tx_errors++;                 priv->stats.tx_fifo_errors++;                 priv->txlen = 0;                 netif_wake_queue （dev）;             }                          break;         case TxCOL:             priv->stats.collisions += ColCount （cs8900_read （dev,PP_TxCOL））;             break;         case RxMISS:             status = MissCount （cs8900_read （dev,PP_RxMISS））;             priv->stats.rx_errors += status;             priv->stats.rx_missed_errors += status;             break;         }     }     return IRQ_RETVAL（handled）; } static void cs8900_transmit_timeout （struct net_device *dev） {     //cs8900_t *priv = （cs8900_t *） dev->priv;     cs8900_t *priv = （cs8900_t *）netdev_priv（dev）;     priv->stats.tx_errors++;     priv->stats.tx_heartbeat_errors++;     priv->txlen = 0;     netif_wake_queue （dev）; } static int cs8900_start （struct net_device *dev） {     int result;     //set_irq_type（dev->irq, IRQT_RISING）;     set_irq_type（dev->irq, IRQ_TYPE_EDGE_RISING）;          cs8900_set （dev,PP_RxCFG,RxOKiE | BufferCRC | CRCerroriE | RuntiE | ExtradataiE）;     cs8900_set （dev,PP_RxCTL,RxOKA | IndividualA | BroadcastA）;     cs8900_set （dev,PP_TxCFG,TxOKiE | Out_of_windowiE | JabberiE）;     cs8900_set （dev,PP_BufCFG,Rdy4TxiE | RxMissiE | TxUnderruniE | TxColOvfiE | MissOvfloiE）;     cs8900_set （dev,PP_LineCTL,SerRxON | SerTxON）;     cs8900_set （dev,PP_BusCTL,EnableRQ）; #ifdef FULL_DUPLEX     cs8900_set （dev,PP_TestCTL,FDX）; #endif         udelay（200）;              if （（result = request_irq （dev->irq, &cs8900_interrupt, 0, dev->name, dev）） < 0） {         printk （KERN_ERR "%s: could not register interrupt %d ",dev->name, dev->irq）;         return （result）;     }               netif_start_queue （dev）;     return （0）; } static int cs8900_stop （struct net_device *dev） {          cs8900_write （dev,PP_BusCTL,0）;     cs8900_write （dev,PP_TestCTL,0）;     cs8900_write （dev,PP_SelfCTL,0）;     cs8900_write （dev,PP_LineCTL,0）;     cs8900_write （dev,PP_BufCFG,0）;     cs8900_write （dev,PP_TxCFG,0）;     cs8900_write （dev,PP_RxCTL,0）;     cs8900_write （dev,PP_RxCFG,0）;          free_irq （dev->irq,dev）;          netif_stop_queue （dev）;     return （0）; } static struct net_device_stats *cs8900_get_stats （struct net_device *dev） {     //cs8900_t *priv = （cs8900_t *） dev->priv;     cs8900_t *priv = （cs8900_t *）netdev_priv（dev）;     return （&priv->stats）; } static void cs8900_set_receive_mode （struct net_device *dev） {     if （（dev->flags & IFF_PROMISC））         cs8900_set （dev,PP_RxCTL,PromiscuousA）;     else         cs8900_clear （dev,PP_RxCTL,PromiscuousA）;     //if （（dev->flags & IFF_ALLMULTI） && dev->mc_list）     if （（dev->flags & IFF_ALLMULTI） && ！netdev_mc_empty（dev））         cs8900_set （dev,PP_RxCTL,MulticastA）;     else         cs8900_clear （dev,PP_RxCTL,MulticastA）; } int __init cs8900_probe （struct net_device *dev） {     static cs8900_t *priv;     int i,result;     u16 value;     printk （VERSION_STRING" "）;     memset （&priv,0,sizeof （cs8900_t））;     //+kevin     __raw_writel（0x2211d110,S3C2410_BWSCON）;     __raw_writel（0x1f7c,S3C2410_BANKCON3）; //#if defined（CONFIG_ARCH_SMDK2410） #if 1     dev->dev_addr[0] = 0x00;     dev->dev_addr[1] = 0x00;     dev->dev_addr[2] = 0x3e;     dev->dev_addr[3] = 0x26;     dev->dev_addr[4] = 0x0a;     dev->dev_addr[5] = 0x00; #endif     dev->if_port = IF_PORT_10BASET;     //dev->priv = （void *） &priv;     priv = （cs8900_t *）netdev_priv（dev）;     spin_lock_init（&priv->lock）;     //hejiasheng SET_MODULE_OWNER （dev）; //#if defined（CONFIG_ARCH_SMDK2410） #if 1     dev->base_addr = vSMDK2410_ETH_IO + 0x300;     dev->irq = IRQ_EINT9;     printk（"debug:[%s-%d] ", __func__, __LINE__）; #endif     if （（result = check_mem_region （dev->base_addr, 16））） {         printk （KERN_ERR "%s: can"t get I/O port address 0x%lx ",dev->name,dev->base_addr）;         return （result）;     }     request_mem_region （dev->base_addr, 16, dev->name）;          printk（"debug:[%s-%d] ", __func__, __LINE__）;           if （（value = cs8900_read （dev,PP_ProductID）） ！= EISA_REG_CODE） {         printk （KERN_ERR "%s: incorrect signature 0x%.4x ",dev->name,value）;         return （-ENXIO）;     }     printk（"debug:[%s-%d] ", __func__, __LINE__）;          value = cs8900_read （dev,PP_ProductID + 2）;     if （VERSION （value） ！= CS8900A） {         printk （KERN_ERR "%s: unknown chip version 0x%.8x ",dev->name,VERSION （value））;         return （-ENXIO）;     }          cs8900_write （dev,PP_IntNum,0）;     printk （KERN_INFO "%s: CS8900A rev %c at %#lx irq=%d",         dev->name,"B" + REVISION （value） - REV_B, dev->base_addr, dev->irq）;     for （i = 0; i < ETH_ALEN; i += 2）         cs8900_write （dev,PP_IA + i,dev->dev_addr[i] | （dev->dev_addr[i + 1] << 8））;     printk （", addr:"）;     for （i = 0; i < ETH_ALEN; i += 2）     {         u16 mac = cs8900_read （dev,PP_IA + i）;         printk （"%cX:%2X", （i==0）？" ":":", mac & 0xff, （mac >> 8））;     }     printk （" "）;     return （0）; } static const struct net_device_ops net_ops = {     .ndo_init = cs8900_probe,     .ndo_open        = cs8900_start,     .ndo_stop        = cs8900_stop,     .ndo_tx_timeout        = cs8900_transmit_timeout,     .ndo_start_xmit     = cs8900_send_start,     .ndo_get_stats        = cs8900_get_stats,     .ndo_set_multicast_list = cs8900_set_receive_mode, #if 0     .ndo_set_mac_address     = set_mac_address,     .ndo_poll_controller    = net_poll_controller,     .ndo_change_mtu        = eth_change_mtu,     .ndo_validate_addr    = eth_validate_addr, #endif }; static int __init cs8900_init （void） {     struct net_device *ndev;     ndev = alloc_etherdev（sizeof （cs8900_t））;     if （！ndev） {         printk（"%s: could not allocate device. ", "cs8900"）;         return -ENOMEM;     }     printk（"allocate cs8900 device ok. "）;     cs8900_dev = ndev;     //cs8900_dev->init = cs8900_probe;     ether_setup （ndev）; #if 0     ndev->open = cs8900_start;     ndev->stop = cs8900_stop;     ndev->hard_start_xmit = cs8900_send_start;     ndev->get_stats = cs8900_get_stats;     ndev->set_multicast_list = cs8900_set_receive_mode;     ndev->tx_timeout = cs8900_transmit_timeout; #endif     ndev->netdev_ops = &net_ops;     ndev->watchdog_timeo = HZ;     return （register_netdev （cs8900_dev））; } static void __exit cs8900_cleanup （void） { //    cs8900_t *priv = （cs8900_t *） cs8900_dev->priv;     cs8900_t *priv = （cs8900_t *）netdev_priv（cs8900_dev）;     if（ priv->char_devnum）     {         unregister_chrdev（priv->char_devnum,"cs8900_eeprom"）;     }     release_mem_region （cs8900_dev->base_addr,16）;     unregister_netdev （cs8900_dev）; } MODULE_AUTHOR （"Abraham van der Merwe <abraham at 2d3d.co.za>"）; MODULE_DESCRIPTION （VERSION_STRING）; MODULE_LICENSE （"GPL"）; module_init （cs8900_init）; module_exit （cs8900_cleanup）;