开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ether00.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ether00.c：源码内容
  1. /*
  2.  *  drivers/net/ether00.c
  3.  *
  4.  *  Copyright (C) 2001 Altera Corporation
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  21. /* includes */
  23. #include <linux/pci.h>
  24. #include <linux/netdevice.h>
  25. #include <linux/sched.h>
  26. #include <linux/netdevice.h>
  27. #include <linux/skbuff.h>
  28. #include <linux/etherdevice.h>
  29. #include <linux/module.h>
  30. #include <linux/tqueue.h>
  31. #include <linux/mtd/mtd.h>
  32. #include <asm/arch/excalibur.h>
  33. #include <asm/arch/hardware.h>
  34. #include <asm/irq.h>
  35. #include <asm/io.h>
  36. #include <asm/sizes.h>
  37. #include <asm/arch/ether00.h>
  38. #include <asm/arch/tdkphy.h>
  41. MODULE_AUTHOR("Clive Davies");
  42. MODULE_DESCRIPTION("Altera Ether00 IP core driver");
  43. MODULE_LICENSE("GPL");
  45. static long base=0x60000000;
  46. static int irq=0x1;
  47. static int phy_irq=0x2;
  48. MODULE_PARM(base,"l");
  49. MODULE_PARM(irq,"i");
  50. MODULE_PARM(phy_irq,"i");
  52. #define PKT_BUF_SZ 1536 /* Size of each rx buffer */
  54. #define DEBUG(x)
  56. #define __dma_va(x) (unsigned int)((unsigned int)priv->dma_data+(((unsigned int)(x))&(EXC_SPSRAM_BLOCK0_SIZE-1)))
  57. #define __dma_pa(x) (unsigned int)(EXC_SPSRAM_BLOCK0_BASE+(((unsigned int)(x))-(unsigned int)priv->dma_data))
  59. #define ETHER00_BASE 0
  60. #define ETHER00_TYPE
  61. #define ETHER00_PHYS_BASE 0x80000000
  62. #define ETHER00_IRQ  0x1
  66. /* typedefs */
  68. /* The definition of the driver control structure */
  69. #define RX_NUM_BUFF     10
  70. #define RX_NUM_FDESC    10
  71. #define TX_NUM_FDESC    10
  73. struct tx_fda_ent{
  74. FDA_DESC  fd;
  75. BUF_DESC  bd;
  76. BUF_DESC  pad;
  77. };
  78. struct rx_fda_ent{
  79. FDA_DESC  fd;
  80. BUF_DESC  bd;
  81. BUF_DESC  pad;
  82. };
  83. struct rx_blist_ent{
  84. FDA_DESC  fd;
  85. BUF_DESC  bd;
  86. BUF_DESC  pad;
  87. };
  88. struct net_priv
  89. {
  90. struct net_device_stats stats;
  91. struct sk_buff* skb;
  92. void* dma_data;
  93. struct rx_blist_ent*  rx_blist_vp;
  94. struct rx_fda_ent* rx_fda_ptr;
  95. struct tx_fda_ent* tx_fdalist_vp;
  96. struct tq_struct  tq_memupdate;
  97. unsigned char   memupdate_scheduled;
  98. unsigned char   rx_disabled;
  99. unsigned char   queue_stopped;
  100. };
  102. static const char vendor_id[2]={0x07,0xed};
  104. static int ether00_write_phy(struct net_device *dev, short address, short value)
  105. {
  106. volatile int count = 1024;
  107. writew(value,ETHER_MD_DATA(dev->base_addr));
  108. writew( ETHER_MD_CA_BUSY_MSK |
  109. ETHER_MD_CA_WR_MSK |
  110. (address & ETHER_MD_CA_ADDR_MSK),
  111. ETHER_MD_CA(dev->base_addr));
  113. /* Wait for the command to complete */
  114. while((readw(ETHER_MD_CA(dev->base_addr)) & ETHER_MD_CA_BUSY_MSK)&&count){
  115. count--;
  116. }
  117. if (!count){
  118. printk("Write to phy failed, addr=%#x, data=%#xn",address, value);
  119. return -EIO;
  120. }
  121. return 0;
  122. }
  124. static int ether00_read_phy(struct net_device *dev, short address)
  125. {
  126. volatile int count = 1024;
  127. writew( ETHER_MD_CA_BUSY_MSK |
  128. (address & ETHER_MD_CA_ADDR_MSK),
  129. ETHER_MD_CA(dev->base_addr));
  131. /* Wait for the command to complete */
  132. while((readw(ETHER_MD_CA(dev->base_addr)) & ETHER_MD_CA_BUSY_MSK)&&count){
  133. count--;
  134. }
  135. if (!count){
  136. printk(KERN_WARNING "Read from phy timed outn");
  137. return -EIO;
  138. }
  139. return readw(ETHER_MD_DATA(dev->base_addr));
  140. }
  142. static void ether00_phy_int(int irq_num, void* dev_id, struct pt_regs* regs)
  143. {
  144. struct net_device* dev=dev_id;
  145. int irq_status;
  147. irq_status=ether00_read_phy(dev, PHY_IRQ_CONTROL);
  149. if(irq_status & PHY_IRQ_CONTROL_ANEG_COMP_INT_MSK){
  150. /*
  151.  * Autonegotiation complete on epxa10db the mac doesn't
  152.  * twig if we're in full duplex so we need to check the
  153.  * phy status register and configure the mac accordingly
  154.  */
  155. if(ether00_read_phy(dev, PHY_STATUS)&(PHY_STATUS_10T_F_MSK|PHY_STATUS_100_X_F_MSK)){
  156. int tmp;
  157. tmp=readl(ETHER_MAC_CTL(dev->base_addr));
  158. writel(tmp|ETHER_MAC_CTL_FULLDUP_MSK,ETHER_MAC_CTL(dev->base_addr));
  159. }
  160. }
  162. if(irq_status&PHY_IRQ_CONTROL_LS_CHG_INT_MSK){
  164. if(ether00_read_phy(dev, PHY_STATUS)& PHY_STATUS_LINK_MSK){
  165. /* Link is up */
  166. netif_carrier_on(dev);
  167. //printk("Carrier onn");
  168. }else{
  169. netif_carrier_off(dev);
  170. //printk("Carrier offn");
  172. }
  173. }
  175. }
  176. static int ether00_mem_init(struct net_device* dev)
  177. {
  178. struct net_priv* priv=dev->priv;
  179. struct tx_fda_ent *tx_fd_ptr,*tx_end_ptr;
  180. struct rx_blist_ent* blist_ent_ptr;
  181. int i;
  183. /*
  184.  * Grab a block of on chip SRAM to contain the control stuctures for
  185.  * the ethernet MAC. This uncached becuase it needs to be accesses by both
  186.  * bus masters (cpu + mac). However, it shouldn't matter too much in terms
  187.  * of speed as its on chip memory
  188.  */
  189. priv->dma_data=ioremap_nocache(EXC_SPSRAM_BLOCK0_BASE,EXC_SPSRAM_BLOCK0_SIZE );
  190. if (!priv->dma_data)
  191. return -ENOMEM;
  193. priv->rx_fda_ptr=(struct rx_fda_ent*)priv->dma_data;
  194. /*
  195.  * Now share it out amongst the Frame descriptors and the buffer list
  196.  */
  197. priv->rx_blist_vp=(struct rx_blist_ent*)((unsigned int)priv->dma_data+RX_NUM_FDESC*sizeof(struct rx_fda_ent));
  199. /*
  200.  *Initalise the FDA list
  201.  */
  202. /* set ownership to the controller */
  203. memset(priv->rx_fda_ptr,0x80,RX_NUM_FDESC*sizeof(struct rx_fda_ent));
  205. /*
  206.  *Initialise the buffer list
  207.  */
  208. blist_ent_ptr=priv->rx_blist_vp;
  209. i=0;
  210. while(blist_ent_ptr<(priv->rx_blist_vp+RX_NUM_BUFF)){
  211. struct sk_buff *skb;
  212. blist_ent_ptr->fd.FDLength=1;
  213. blist_ent_ptr->fd.FDCtl=0x8000;
  214. skb=dev_alloc_skb(PKT_BUF_SZ);
  215. if(skb){
  216. /* Make the buffer consistent with the cache as the mac is going to write
  217. * directly into it*/
  218. blist_ent_ptr->fd.FDSystem=(unsigned int)skb;
  219. blist_ent_ptr->bd.BuffData=(char*)__pa(skb->data);
  220. consistent_sync(skb->data,PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
  221. skb_reserve(skb,2); /* align IP on 16 Byte (DMA_CTL set to skip 2 bytes) */
  222. blist_ent_ptr->bd.BuffLength=PKT_BUF_SZ-2;
  223. blist_ent_ptr->bd.BDCtl=0x80;
  224. blist_ent_ptr->bd.BDStat=i++;
  225. blist_ent_ptr->fd.FDNext=(FDA_DESC*)__dma_pa(blist_ent_ptr+1);
  226. blist_ent_ptr++;
  227. }
  228. else
  229. {
  230. printk("Failed to initalise buffer listn");
  231. }
  233. }
  234. blist_ent_ptr--;
  235. blist_ent_ptr->fd.FDNext=(FDA_DESC*)__dma_pa(priv->rx_blist_vp);
  237. priv->tx_fdalist_vp=(struct tx_fda_ent*)(priv->rx_blist_vp+RX_NUM_BUFF);
  239. /* Initialise the buffers to be a circular list. The mac will then go poll
  240.  * the list until it fonds a frame ready to transmit */
  241. tx_end_ptr=priv->tx_fdalist_vp+TX_NUM_FDESC;
  242. for(tx_fd_ptr=priv->tx_fdalist_vp;tx_fd_ptr<tx_end_ptr;tx_fd_ptr++){
  243. tx_fd_ptr->fd.FDNext=(FDA_DESC*)__dma_pa((tx_fd_ptr+1));
  244. tx_fd_ptr->fd.FDCtl=1;
  245. tx_fd_ptr->fd.FDStat=0;
  246. tx_fd_ptr->fd.FDLength=1;
  248. }
  249. /* Change the last FDNext pointer to make a circular list */
  250. tx_fd_ptr--;
  251. tx_fd_ptr->fd.FDNext=(FDA_DESC*)__dma_pa(priv->tx_fdalist_vp);
  253. /* Point the device at the chain of Rx and Tx Buffers */
  254. writel((unsigned int)__dma_pa(priv->rx_fda_ptr),ETHER_FDA_BAS(dev->base_addr));
  255. writel((RX_NUM_FDESC-1)*sizeof(struct rx_fda_ent),ETHER_FDA_LIM(dev->base_addr));
  256. writel((unsigned int)__dma_pa(priv->rx_blist_vp),ETHER_BLFRMPTR(dev->base_addr));
  258. writel((unsigned int)__dma_pa(priv->tx_fdalist_vp),ETHER_TXFRMPTR(dev->base_addr));
  260. return 0;
  261. }
  264. void ether00_mem_update(void* dev_id)
  265. {
  266. struct net_device* dev=dev_id;
  267. struct net_priv* priv=dev->priv;
  268. struct sk_buff* skb;
  269. struct tx_fda_ent *fda_ptr=priv->tx_fdalist_vp;
  270. struct rx_blist_ent* blist_ent_ptr;
  272. priv->tq_memupdate.sync=0;
  273. //priv->tq_memupdate.list=
  274. priv->memupdate_scheduled=0;
  276. /* Transmit interrupt */
  277. while(fda_ptr<(priv->tx_fdalist_vp+TX_NUM_FDESC)){
  278. if(!(FDCTL_COWNSFD_MSK&fda_ptr->fd.FDCtl) && (ETHER_TX_STAT_COMP_MSK&fda_ptr->fd.FDStat)){
  279. priv->stats.tx_packets++;
  280. priv->stats.tx_bytes+=fda_ptr->bd.BuffLength;
  281. skb=(struct sk_buff*)fda_ptr->fd.FDSystem;
  282. //printk("%d:txcln:fda=%#x skb=%#xn",jiffies,fda_ptr,skb);
  283. dev_kfree_skb(skb);
  284. fda_ptr->fd.FDSystem=0;
  285. fda_ptr->fd.FDStat=0;
  286. fda_ptr->fd.FDCtl=0;
  287. }
  288. fda_ptr++;
  289. }
  290. /* Fill in any missing buffers from the received queue */
  291. /*
  292.  *Initialise the buffer list
  293.  */
  294. blist_ent_ptr=priv->rx_blist_vp;
  295. while(blist_ent_ptr<(priv->rx_blist_vp+RX_NUM_BUFF)){
  296. /* BuffData of 0 indicates we failed to allocate the buffer in the ISR */
  297. if(!blist_ent_ptr->bd.BuffData){
  298. struct sk_buff *skb;
  299. skb=dev_alloc_skb(PKT_BUF_SZ);
  300. if(skb){
  301. /* Make the buffer consistent with the cache as the mac is going to write
  302.  * directly into it*/
  303. blist_ent_ptr->fd.FDSystem=(unsigned int)skb;
  304. blist_ent_ptr->bd.BuffData=(char*)__pa(skb->data);
  305. consistent_sync(skb->data,PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
  306. skb_reserve(skb,2); /* align IP on 16 Byte (DMA_CTL set to skip 2 bytes) */
  307. blist_ent_ptr->bd.BuffLength=PKT_BUF_SZ-2;
  308. blist_ent_ptr->fd.FDLength=1;
  309. blist_ent_ptr->bd.BDCtl=BDCTL_COWNSBD_MSK;
  310. blist_ent_ptr->fd.FDCtl=FDCTL_COWNSFD_MSK;
  311. }
  312. else
  313. {
  314. break;
  315. }
  316. }
  317. blist_ent_ptr++;
  318. }
  320. if(priv->queue_stopped){
  321. //printk("%d:cln:start qn",jiffies);
  322. netif_start_queue(dev);
  323. }
  324. if(priv->rx_disabled){
  325. //printk("%d:enable_irqn",jiffies);
  326. priv->rx_disabled=0;
  327. writel(ETHER_RX_CTL_RXEN_MSK,ETHER_RX_CTL(dev->base_addr));
  329. }
  330. }
  333. static void ether00_int( int irq_num, void* dev_id, struct pt_regs* regs)
  334. {
  335. struct net_device* dev=dev_id;
  336. struct net_priv* priv=dev->priv;
  338. unsigned int   interruptValue;
  340. interruptValue=readl(ETHER_INT_SRC(dev->base_addr));
  342. //printk("INT_SRC=%xn",interruptValue);
  344. if(!(readl(ETHER_INT_SRC(dev->base_addr)) & ETHER_INT_SRC_IRQ_MSK))
  345. {
  346. return; /* Interrupt wasn't caused by us!! */
  347. }
  349. if(readl(ETHER_INT_SRC(dev->base_addr))&
  350.    (ETHER_INT_SRC_INTMACRX_MSK |
  351.     ETHER_INT_SRC_FDAEX_MSK |
  352.     ETHER_INT_SRC_BLEX_MSK)) {
  353. struct rx_blist_ent* blist_ent_ptr;
  354. struct rx_fda_ent* fda_ent_ptr;
  355. struct sk_buff* skb;
  357. fda_ent_ptr=priv->rx_fda_ptr;
  358. while(fda_ent_ptr<(priv->rx_fda_ptr+RX_NUM_FDESC)){
  359. int result;
  361. if(!(fda_ent_ptr->fd.FDCtl&FDCTL_COWNSFD_MSK))
  362. {
  363. /* This frame is ready for processing */
  364. /*find the corresponding buffer in the bufferlist */
  365. blist_ent_ptr=priv->rx_blist_vp+fda_ent_ptr->bd.BDStat;
  366. skb=(struct sk_buff*)fda_ent_ptr->fd.FDSystem;
  368. /* Pass this skb up the stack */
  369. skb->dev=dev;
  370. skb_put(skb,fda_ent_ptr->fd.FDLength);
  371. skb->protocol=eth_type_trans(skb,dev);
  372. skb->ip_summed=CHECKSUM_UNNECESSARY;
  373. result=netif_rx(skb);
  374. /* Update statistics */
  375. priv->stats.rx_packets++;
  376. priv->stats.rx_bytes+=fda_ent_ptr->fd.FDLength;
  377. /* Free the FDA entry */
  378. fda_ent_ptr->bd.BDStat=0xff;
  379. fda_ent_ptr->fd.FDCtl=FDCTL_COWNSFD_MSK;
  381. /* Allocate a new skb and point the bd entry to it */
  382. skb=dev_alloc_skb(PKT_BUF_SZ);
  383. if(skb){
  384. blist_ent_ptr->bd.BuffData=(char*)__pa(skb->data);
  385. consistent_sync(skb->data,PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
  386. skb_reserve(skb,2); /* align IP on 16 Byte (DMA_CTL set to skip 2 bytes) */
  387. blist_ent_ptr->bd.BuffLength=PKT_BUF_SZ-2;
  388. blist_ent_ptr->fd.FDSystem=(unsigned int)skb;
  389. /* Pass it to the controller */
  390. blist_ent_ptr->bd.BDCtl=BDCTL_COWNSBD_MSK;
  391. blist_ent_ptr->fd.FDCtl=FDCTL_COWNSFD_MSK;
  393. }
  394. else if(!priv->memupdate_scheduled){
  395. int tmp;
  396. /* There are no buffers at the moment, so schedule */
  397. /* the background task to sort this out */
  398. schedule_task(&priv->tq_memupdate);
  399. priv->memupdate_scheduled=1;
  400. /* If this interrupt was due to a lack of buffers then
  401.  * we'd better stop the receiver too */
  402. if(interruptValue&ETHER_INT_SRC_BLEX_MSK){
  403. priv->rx_disabled=1;
  404. tmp=readl(ETHER_INT_SRC(dev->base_addr));
  405. writel(tmp&~ETHER_RX_CTL_RXEN_MSK,ETHER_RX_CTL(dev->base_addr));
  406. }
  408. }
  409. }
  410. fda_ent_ptr++;
  411. }
  412. /* Clear the  interrupts */
  413. writel(ETHER_INT_SRC_INTMACRX_MSK | ETHER_INT_SRC_FDAEX_MSK
  414.        | ETHER_INT_SRC_BLEX_MSK,ETHER_INT_SRC(dev->base_addr));
  416. }
  418. if(readl(ETHER_INT_SRC(dev->base_addr))&ETHER_INT_SRC_INTMACTX_MSK){
  420. if(!priv->memupdate_scheduled){
  421. schedule_task(&priv->tq_memupdate);
  422. priv->memupdate_scheduled=1;
  423. }
  424. /* Clear the interrupt */
  425. writel(ETHER_INT_SRC_INTMACTX_MSK,ETHER_INT_SRC(dev->base_addr));
  426. }
  428. if (readl(ETHER_INT_SRC(dev->base_addr)) & (ETHER_INT_SRC_SWINT_MSK|
  429.     ETHER_INT_SRC_INTEARNOT_MSK|
  430.     ETHER_INT_SRC_INTLINK_MSK|
  431.     ETHER_INT_SRC_INTEXBD_MSK|
  432.     ETHER_INT_SRC_INTTXCTLCMP_MSK))
  433. {
  434. /*
  435.  * Not using any of these so they shouldn't happen
  436.  *
  437.  * In the cased of INTEXBD - I only allocated 16 descriptors
  438.  * if you allocate more than 28 you may need to think about this
  439.  */
  440. printk("Not using this interruptn");
  441. }
  443. if (readl(ETHER_INT_SRC(dev->base_addr)) &
  444.     (ETHER_INT_SRC_INTSBUS_MSK |
  445.      ETHER_INT_SRC_INTNRABT_MSK
  446.      |ETHER_INT_SRC_DMPARERR_MSK))
  447. {
  448. /*
  449.  * Hardware errors, we can either ignore them and hope they go away
  450.  *or reset the device, I'll try the first for now to see if they happen
  451.  */
  452. printk("Hardware errorn");
  453. }
  454. }
  456. static void ether00_setup_ethernet_address(struct net_device* dev)
  457. {
  458. int tmp;
  460. dev->addr_len=6;
  461. writew(0,ETHER_ARC_ADR(dev->base_addr));
  462. writel((dev->dev_addr[0]<<24) |
  463. (dev->dev_addr[1]<<16) |
  464. (dev->dev_addr[2]<<8) |
  465. dev->dev_addr[3],
  466. ETHER_ARC_DATA(dev->base_addr));
  468. writew(4,ETHER_ARC_ADR(dev->base_addr));
  469. tmp=readl(ETHER_ARC_DATA(dev->base_addr));
  470. tmp&=0xffff;
  471. tmp|=(dev->dev_addr[4]<<24) | (dev->dev_addr[5]<<16);
  472. writel(tmp, ETHER_ARC_DATA(dev->base_addr));
  473. /* Enable this entry in the ARC */
  475. writel(1,ETHER_ARC_ENA(dev->base_addr));
  477. return;
  478. }
  481. static void ether00_reset(struct net_device *dev)
  482. {
  483. /* reset the controller */
  484. writew(ETHER_MAC_CTL_RESET_MSK,ETHER_MAC_CTL(dev->base_addr));
  486. /*
  487.  * Make sure we're not going to send anything
  488.  */
  490. writew(ETHER_TX_CTL_TXHALT_MSK,ETHER_TX_CTL(dev->base_addr));
  492. /*
  493.  * Make sure we're not going to receive anything
  494.  */
  495. writew(ETHER_RX_CTL_RXHALT_MSK,ETHER_RX_CTL(dev->base_addr));
  497. /*
  498.  * Disable Interrupts for now, and set the burst size to 8 bytes
  499.  */
  501. writel(ETHER_DMA_CTL_INTMASK_MSK |
  502.        ((8 << ETHER_DMA_CTL_DMBURST_OFST) & ETHER_DMA_CTL_DMBURST_MSK)
  503.        |(2<<ETHER_DMA_CTL_RXALIGN_OFST),
  504.        ETHER_DMA_CTL(dev->base_addr));
  507. /*
  508.  * Set TxThrsh - start transmitting a packet after 1514
  509.  * bytes or when a packet is complete, whichever comes first
  510.  */
  511.  writew(1514,ETHER_TXTHRSH(dev->base_addr));
  513. /*
  514.  * Set TxPollCtr.  Each cycle is
  515.  * 61.44 microseconds with a 33 MHz bus
  516.  */
  517.  writew(1,ETHER_TXPOLLCTR(dev->base_addr));
  519. /*
  520.  * Set Rx_Ctl - Turn off reception and let RxData turn it
  521.  * on later
  522.  */
  523.  writew(ETHER_RX_CTL_RXHALT_MSK,ETHER_RX_CTL(dev->base_addr));
  525. }
  528. static void ether00_set_multicast(struct net_device* dev)
  529. {
  530. int count=dev->mc_count;
  532. /* Set promiscuous mode if it's asked for. */
  534. if (dev->flags&IFF_PROMISC){
  536. writew( ETHER_ARC_CTL_COMPEN_MSK |
  537. ETHER_ARC_CTL_BROADACC_MSK |
  538. ETHER_ARC_CTL_GROUPACC_MSK |
  539. ETHER_ARC_CTL_STATIONACC_MSK,
  540. ETHER_ARC_CTL(dev->base_addr));
  541. return;
  542. }
  544. /*
  545.  * Get all multicast packets if required, or if there are too
  546.  * many addresses to fit in hardware
  547.  */
  548. if (dev->flags & IFF_ALLMULTI){
  549. writew( ETHER_ARC_CTL_COMPEN_MSK |
  550. ETHER_ARC_CTL_GROUPACC_MSK |
  551. ETHER_ARC_CTL_BROADACC_MSK,
  552. ETHER_ARC_CTL(dev->base_addr));
  553. return;
  554. }
  555. if (dev->mc_count > (ETHER_ARC_SIZE - 1)){
  557. printk(KERN_WARNING "Too many multicast addresses for hardware to filter - receiving all multicast packetsn");
  558. writew( ETHER_ARC_CTL_COMPEN_MSK |
  559. ETHER_ARC_CTL_GROUPACC_MSK |
  560. ETHER_ARC_CTL_BROADACC_MSK,
  561. ETHER_ARC_CTL(dev->base_addr));
  562. return;
  563. }
  565. if(dev->mc_count){
  566. struct dev_mc_list *mc_list_ent=dev->mc_list;
  567. unsigned int temp,i;
  568. DEBUG(printk("mc_count=%d mc_list=%#xn",dev-> mc_count, dev->mc_list));
  569. DEBUG(printk("mc addr=%02#x%02x%02x%02x%02x%02xn",
  570.      mc_list_ent->dmi_addr[5],
  571.      mc_list_ent->dmi_addr[4],
  572.      mc_list_ent->dmi_addr[3],
  573.      mc_list_ent->dmi_addr[2],
  574.      mc_list_ent->dmi_addr[1],
  575.      mc_list_ent->dmi_addr[0]);)
  577. /*
  578.  * The first 6 bytes are the MAC address, so
  579.  * don't change them!
  580.  */
  581. writew(4,ETHER_ARC_ADR(dev->base_addr));
  582. temp=readl(ETHER_ARC_DATA(dev->base_addr));
  583. temp&=0xffff0000;
  585. /* Disable the current multicast stuff */
  586. writel(1,ETHER_ARC_ENA(dev->base_addr));
  588. for(;;){
  589. temp|=mc_list_ent->dmi_addr[1] |
  590. mc_list_ent->dmi_addr[0]<<8;
  591. writel(temp,ETHER_ARC_DATA(dev->base_addr));
  593. i=readl(ETHER_ARC_ADR(dev->base_addr));
  594. writew(i+4,ETHER_ARC_ADR(dev->base_addr));
  596. temp=mc_list_ent->dmi_addr[5]|
  597. mc_list_ent->dmi_addr[4]<<8 |
  598. mc_list_ent->dmi_addr[3]<<16 |
  599. mc_list_ent->dmi_addr[2]<<24;
  600. writel(temp,ETHER_ARC_DATA(dev->base_addr));
  602. count--;
  603. if(!mc_list_ent->next || !count){
  604. break;
  605. }
  606. DEBUG(printk("mc_list_next=%#xn",mc_list_ent->next);)
  607. mc_list_ent=mc_list_ent->next;
  610. i=readl(ETHER_ARC_ADR(dev->base_addr));
  611. writel(i+4,ETHER_ARC_ADR(dev->base_addr));
  613. temp=mc_list_ent->dmi_addr[3]|
  614. mc_list_ent->dmi_addr[2]<<8 |
  615. mc_list_ent->dmi_addr[1]<<16 |
  616. mc_list_ent->dmi_addr[0]<<24;
  617. writel(temp,ETHER_ARC_DATA(dev->base_addr));
  619. i=readl(ETHER_ARC_ADR(dev->base_addr));
  620. writel(i+4,ETHER_ARC_ADR(dev->base_addr));
  622. temp=mc_list_ent->dmi_addr[4]<<16 |
  623. mc_list_ent->dmi_addr[5]<<24;
  625. writel(temp,ETHER_ARC_DATA(dev->base_addr));
  627. count--;
  628. if(!mc_list_ent->next || !count){
  629. break;
  630. }
  631. mc_list_ent=mc_list_ent->next;
  632. }
  635. if(count)
  636. printk(KERN_WARNING "Multicast list size errorn");
  639. writew( ETHER_ARC_CTL_BROADACC_MSK|
  640. ETHER_ARC_CTL_COMPEN_MSK,
  641. ETHER_ARC_CTL(dev->base_addr));
  643. }
  645. /* enable the active ARC enties */
  646. writew((1<<(count+2))-1,ETHER_ARC_ENA(dev->base_addr));;
  647. }
  650. static int ether00_open(struct net_device* dev)
  651. {
  652. int result,tmp;
  653. struct net_priv* priv;
  655. dev->base_addr=ioremap_nocache(base,SZ_4K);
  657. dev->irq=irq;
  659. dev->priv=kmalloc(sizeof(struct net_priv),GFP_KERNEL);
  660. if(!dev->priv)
  661. return -ENOMEM;
  662. memset(dev->priv,0,sizeof(struct net_priv));
  663. priv=(struct net_priv*)dev->priv;
  664. priv->tq_memupdate.routine=ether00_mem_update;
  665. priv->tq_memupdate.data=(void*) dev;
  667. if (!is_valid_ether_addr(dev->dev_addr))
  668. return -EINVAL;
  670. /* Install interrupt handlers */
  671. result=request_irq(dev->irq,ether00_int,0,"ether00",dev);
  672. if(result)
  673. return result;
  675. result=request_irq(phy_irq,ether00_phy_int,0,"ether00_phy",dev);
  676. if(result)
  677. return result;
  680. ether00_reset(dev);
  681. result=ether00_mem_init(dev);
  682. if(result) return result;
  685. ether00_setup_ethernet_address(dev);
  687. ether00_set_multicast(dev);
  689. result=ether00_write_phy(dev,PHY_CONTROL, PHY_CONTROL_ANEGEN_MSK | PHY_CONTROL_RANEG_MSK);
  690. if(result) return result;
  691. result=ether00_write_phy(dev,PHY_IRQ_CONTROL, PHY_IRQ_CONTROL_LS_CHG_IE_MSK |
  692.  PHY_IRQ_CONTROL_ANEG_COMP_IE_MSK);
  693. if(result) return result;
  695. /* Start the device enable interrupts */
  696. writew(ETHER_RX_CTL_RXEN_MSK
  697.        | ETHER_RX_CTL_STRIPCRC_MSK
  698.        | ETHER_RX_CTL_ENGOOD_MSK
  699.        | ETHER_RX_CTL_ENRXPAR_MSK| ETHER_RX_CTL_ENLONGERR_MSK
  700.        | ETHER_RX_CTL_ENOVER_MSK| ETHER_RX_CTL_ENCRCERR_MSK,
  701.        ETHER_RX_CTL(dev->base_addr));
  703. writew(ETHER_TX_CTL_TXEN_MSK|
  704.        ETHER_TX_CTL_ENEXDEFER_MSK|
  705.        ETHER_TX_CTL_ENLCARR_MSK|
  706.        ETHER_TX_CTL_ENEXCOLL_MSK|
  707.        ETHER_TX_CTL_ENLATECOLL_MSK|
  708.        ETHER_TX_CTL_ENTXPAR_MSK|
  709.        ETHER_TX_CTL_ENCOMP_MSK,
  710.        ETHER_TX_CTL(dev->base_addr));
  712. tmp=readl(ETHER_DMA_CTL(dev->base_addr));
  713. writel(tmp&~ETHER_DMA_CTL_INTMASK_MSK,ETHER_DMA_CTL(dev->base_addr));
  715. return 0;
  716. }
  719. static int ether00_tx(struct sk_buff* skb, struct net_device* dev)
  720. {
  721. struct net_priv *priv=dev->priv;
  722. struct tx_fda_ent *fda_ptr;
  723. int i;
  726. /*
  727.  * Find an empty slot in which to stick the frame
  728.  */
  729. fda_ptr=(struct tx_fda_ent*)__dma_va(readl(ETHER_TXFRMPTR(dev->base_addr)));
  730. i=0;
  731. while(i<TX_NUM_FDESC){
  732. if (fda_ptr->fd.FDStat||(fda_ptr->fd.FDCtl & FDCTL_COWNSFD_MSK)){
  733. fda_ptr =(struct tx_fda_ent*) __dma_va((struct tx_fda_ent*)fda_ptr->fd.FDNext);
  734. }
  735. else {
  736. break;
  737. }
  738. i++;
  739. }
  741. /* Write the skb data from the cache*/
  742. consistent_sync(skb->data,skb->len,PCI_DMA_TODEVICE);
  743. fda_ptr->bd.BuffData=(char*)__pa(skb->data);
  744. fda_ptr->bd.BuffLength=(unsigned short)skb->len;
  745. /* Save the pointer to the skb for freeing later */
  746. fda_ptr->fd.FDSystem=(unsigned int)skb;
  747. fda_ptr->fd.FDStat=0;
  748. /* Pass ownership of the buffers to the controller */
  749. fda_ptr->fd.FDCtl=1;
  750. fda_ptr->fd.FDCtl|=FDCTL_COWNSFD_MSK;
  752. /* If the next buffer in the list is full, stop the queue */
  753. fda_ptr=(struct tx_fda_ent*)__dma_va(fda_ptr->fd.FDNext);
  754. if ((fda_ptr->fd.FDStat)||(fda_ptr->fd.FDCtl & FDCTL_COWNSFD_MSK)){
  755. netif_stop_queue(dev);
  756. priv->queue_stopped=1;
  757. }
  759. return 0;
  760. }
  762. static struct net_device_stats *ether00_stats(struct net_device* dev)
  763. {
  764. struct net_priv *priv=dev->priv;
  765. return &priv->stats;
  766. }
  769. static int ether00_stop(struct net_device* dev)
  770. {
  771. struct net_priv *priv=dev->priv;
  772. int tmp;
  774. /* Stop/disable the device. */
  775. tmp=readw(ETHER_RX_CTL(dev->base_addr));
  776. tmp&=~(ETHER_RX_CTL_RXEN_MSK | ETHER_RX_CTL_ENGOOD_MSK);
  777. tmp|=ETHER_RX_CTL_RXHALT_MSK;
  778. writew(tmp,ETHER_RX_CTL(dev->base_addr));
  780. tmp=readl(ETHER_TX_CTL(dev->base_addr));
  781. tmp&=~ETHER_TX_CTL_TXEN_MSK;
  782. tmp|=ETHER_TX_CTL_TXHALT_MSK;
  783. writel(tmp,ETHER_TX_CTL(dev->base_addr));
  785. /* Free up system resources */
  786. free_irq(dev->irq,dev);
  787. free_irq(phy_irq,dev);
  788. iounmap(priv->dma_data);
  789. kfree(priv);
  791. return 0;
  792. }
  795. static void ether00_get_ethernet_address(struct net_device* dev)
  796. {
  797. struct mtd_info *mymtd=NULL;
  798. int i;
  799. size_t retlen;
  801. /*
  802.  * For the Epxa10 dev board (camelot), the ethernet MAC
  803.  * address is of the form  00:aa:aa:00:xx:xx where
  804.  * 00:aa:aa is the Altera vendor ID and xx:xx is the
  805.  * last 2 bytes of the board serial number, as programmed
  806.  * into the OTP area of the flash device on EBI1. If this
  807.  * isn't an expa10 dev board, or there's no mtd support to
  808.  * read the serial number from flash then we'll force the
  809.  * use to set their own mac address using ifconfig.
  810.  */
  812. #ifdef CONFIG_ARCH_CAMELOT
  813. #ifdef CONFIG_MTD
  814. /* get the mtd_info structure for the first mtd device*/
  815. for(i=0;i<MAX_MTD_DEVICES;i++){
  816. mymtd=get_mtd_device(NULL,i);
  817. if(mymtd && !strcmp(mymtd->name,"master"))
  818. break;
  819. }
  821. if(!mymtd || !mymtd->read_oob){
  822. printk(KERN_WARNING "%s: Failed to read MAC address from flashn",dev->name);
  823. }else{
  824. mymtd->read_oob(mymtd,10,1,&retlen,&dev->dev_addr[5]);
  825. mymtd->read_oob(mymtd,11,1,&retlen,&dev->dev_addr[4]);
  826. dev->dev_addr[3]=0;
  827. dev->dev_addr[2]=vendor_id[1];
  828. dev->dev_addr[1]=vendor_id[0];
  829. dev->dev_addr[0]=0;
  830. }
  831. #else
  832. printk(KERN_WARNING "%s: MTD support required to read MAC address from EPXA10 dev boardn", dev->name);
  833. #endif
  834. #endif
  836. if (!is_valid_ether_addr(dev->dev_addr))
  837. printk("%s: Invalid ethernet MAC address.  Please set using "
  838. "ifconfign", dev->name);
  840. }
  842. static int ether00_init(struct net_device* dev)
  843. {
  844. ether_setup(dev);
  846. dev->open=ether00_open;
  847. dev->stop=ether00_stop;
  848. dev->set_multicast_list=ether00_set_multicast;
  849. dev->hard_start_xmit=ether00_tx;
  850. dev->get_stats=ether00_stats;
  852. ether00_get_ethernet_address(dev);
  854. SET_MODULE_OWNER(dev);
  856. return 0;
  857. }
  859. struct net_device ether00_dev={
  860. init:ether00_init,
  861. name:"eth%d",
  862. };
  865. static void __exit ether00_cleanup_module(void)
  866. {
  867. unregister_netdev(&ether00_dev);
  868. }
  869. module_exit(ether00_cleanup_module);
  872. static int __init ether00_mod_init(void)
  873. {
  874. int result;
  876. result=register_netdev(&ether00_dev);
  877. if(result)
  878. printk("Ether00: Error %i registering drivern",result);
  879. return result;
  880. }
  882. module_init(ether00_mod_init);