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

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

嵌入式Linux

开发平台：

Unix_Linux

cerf89x0.c：源码内容
  1. /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
  2.  *  driver for linux.
  3.  */
  5. /*
  6. Written 1996 by Russell Nelson, with reference to skeleton.c
  7. written 1993-1994 by Donald Becker.
  9. This software may be used and distributed according to the terms
  10. of the GNU Public License, incorporated herein by reference.
  12.         The author may be reached at nelson@crynwr.com, Crynwr
  13.         Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
  15.   Changelog:
  17.   Mike Cruse        : mcruse@cti-ltd.com
  18.   Russ Nelson       : Jul 13 1998.  Added RxOnly DMA support.
  19.   Melody Lee        : Aug 10 1999.  Changes for Linux 2.2.5 compatibility. 
  20.   Alan Cox          : Removed 1.2 support, added 2.1 extra counters.
  21.   Andrew Morton     : andrewm@uow.edu.au
  22.   Sangwook Lee      : hitchcar@sec.samsung.com
  23. */
  25. static char *version =
  26. "cerf89x0.c: (kernel 2.3.99) Russell Nelson, Andrew Mortonn";
  28. /* ======================= end of configuration ======================= */
  30. /* Always include 'config.h' first in case the user wants to turn on
  31.    or override something. */
  32. #ifdef MODULE
  33. #include <linux/module.h>
  34. #include <linux/version.h>
  35. #else
  36. #define MOD_INC_USE_COUNT
  37. #define MOD_DEC_USE_COUNT
  38. #endif
  40. /*
  41.  * Set this to zero to remove all the debug statements via
  42.  * dead code elimination
  43.  */
  44. #define DEBUGGING 1
  46. /*
  47.   Sources:
  49. Crynwr packet driver epktisa.
  51. Crystal Semiconductor data sheets.
  53. */
  55. #include <linux/kernel.h>
  56. #include <linux/sched.h>
  57. #include <linux/types.h>
  58. #include <linux/fcntl.h>
  59. #include <linux/interrupt.h>
  60. #include <linux/ptrace.h>
  61. #include <linux/ioport.h>
  62. #include <linux/in.h>
  63. #include <linux/slab.h>
  64. #include <linux/string.h>
  65. #include <asm/system.h>
  66. #include <asm/bitops.h>
  67. #include <asm/io.h>
  68. #include <linux/errno.h>
  69. #include <linux/init.h>
  70. #include <linux/spinlock.h>
  72. #include <linux/netdevice.h>
  73. #include <linux/etherdevice.h>
  74. #include <linux/skbuff.h>
  76. #include <asm/irq.h>
  77. #include <asm/hardware.h>
  78. #define IRQ_LAN IRQ_EINT8_23
  80. #include "cs89x0.h"
  82. /* First, a few definitions that the brave might change. */
  83. /* A zero-terminated list of I/O addresses to be probed. */
  84. static unsigned int netcard_portlist[] __initdata =
  85.    { (0xd0000000+0x00000300), 0};
  87. #ifdef  DEBUGGING
  88. static unsigned int net_debug = 4;
  89. #else
  90. #define net_debug 0 /* gcc will remove all the debug code for us */
  91. #endif
  93. /* The number of low I/O ports used by the ethercard. */
  94. #define NETCARD_IO_EXTENT 16
  96. /* Information that need to be kept for each board. */
  97. struct net_local {
  98. struct net_device_stats stats;
  99. int chip_type; /* one of: CS8900, CS8920, CS8920M */
  100. char chip_revision; /* revision letter of the chip ('A'...) */
  101. int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
  102. int auto_neg_cnf; /* auto-negotiation word from EEPROM */
  103. int adapter_cnf; /* adapter configuration from EEPROM */
  104. int isa_config; /* ISA configuration from EEPROM */
  105. int irq_map; /* IRQ map from EEPROM */
  106. int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
  107. int curr_rx_cfg; /* a copy of PP_RxCFG */
  108. int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
  109. int send_underrun; /* keep track of how many underruns in a row we get */
  110.         struct sk_buff * Gskb; /* pinnter to TX buff waiting for Ready4Tx */
  111. spinlock_t lock;
  112. };
  114. /* Index to functions, as function prototypes. */
  116. extern int cerf89x0_probe(struct net_device *dev);
  117. static int S3C2410_HWinit(void);
  118. static int cerf89x0_probe1(struct net_device *dev, int ioaddr);
  119. static int net_open(struct net_device *dev);
  120. static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
  121. static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  122. static void set_multicast_list(struct net_device *dev);
  123. static void net_timeout(struct net_device *dev);
  124. static void net_rx(struct net_device *dev);
  125. static int net_close(struct net_device *dev);
  126. static struct net_device_stats *net_get_stats(struct net_device *dev);
  127. static void reset_chip(struct net_device *dev);
  128. static int set_mac_address(struct net_device *dev, void *addr);
  129. static void count_rx_errors(int status, struct net_local *lp);
  131. /* Example routines you must write ;->. */
  132. #define tx_done(dev) 1
  135. /* Check for a network chip of this type, and return '0' if one exists.
  136.  * Return ENODEV on Failure.
  137.  */
  139. #ifdef CONFIG_S3C2410_SMDK
  141. #define CS8900_Tacs    (0x0)   // 0clk
  142. #define CS8900_Tcos    (0x3)   // 4clk
  143. #define CS8900_Tacc    (0x7)   // 14clk
  144. #define CS8900_Tcoh    (0x1)   // 1clk
  145. #define CS8900_Tah (0x3)   // 4clk
  146. #define CS8900_Tacp    (0x3)   // 6clk
  147. #define CS8900_PMC (0x0)   // normal(1data)
  149. int __init S3C2410_HWinit()
  150. {
  151. // initialize CS8900
  152.     BWSCON  = (BWSCON&~(0xf<<12))|(0xd<<12);  /*  nWAIT */
  153.     //  rGSTATUS0;      /* Read Only */
  154. GPGCON &= ~(3 << 2);
  155.     GPGCON |= (2 << 2); /* GPG1 set to EINT9 */
  156.     BANKCON3=((CS8900_Tacs<<13)+(CS8900_Tcos<<11)+(CS8900_Tacc<<8)
  157.         +(CS8900_Tcoh<<6)+(CS8900_Tah<<4)+(CS8900_Tacp<<2)+(CS8900_PMC));
  158. EXTINT1 &= ~(7 << 4);
  159.     EXTINT1 |= (4 << 4); /* EINT9 rising edge */
  160. return 0;
  161. }
  162. #endif
  164. int __init cerf89x0_probe(struct net_device *dev)
  165. {
  166. static int initialised = 0;
  167. int i;
  169. if (initialised)
  170. return -ENODEV;
  171. initialised = 1;
  172. #ifdef CONFIG_S3C2410_SMDK
  173. S3C2410_HWinit();
  174. #endif
  175. if (net_debug)
  176. printk("cerf89x0:cerf89x0_probe()n");
  178. #ifdef CONFIG_S3C2410_SMDK
  179.     GPGUP  |= (1 << 1); /* GPG1 pull-up disable */
  180.     GPGCON &= ~(3 << 2);
  181.     GPGCON |= (2 << 2); /* GPG1 set to EINT9 */
  182. #endif
  184. for (i = 0; netcard_portlist[i]; i++) {
  185. int ioaddr = netcard_portlist[i];
  186. if (cerf89x0_probe1(dev, ioaddr) == 0)
  187. return 0;
  188. }
  189. printk(KERN_WARNING "cerf89x0: no cs8900 detected.n");
  190. return ENODEV;
  191. }
  193. extern u8 inline
  194. raw_readb(u32 addr)
  195. {
  196. return (*(volatile u8 *)(addr));
  197. }
  199. extern u16 inline
  200. raw_readw(u32 addr)
  201. {
  202. return (*(volatile u16 *)(addr));
  203. }
  205. extern void inline
  206. raw_writeb(u8 value, u32 addr)
  207. {
  208. (*(volatile u8 *)(addr)) = value;
  209. }
  211. extern void inline
  212. raw_writew(u16 value, u32 addr)
  213. {
  214. (*(volatile u16 *)(addr)) = value;
  215. }
  217. extern u16 inline
  218. readreg(struct net_device *dev, int portno)
  219. {
  220. raw_writew(portno, dev->base_addr + ADD_PORT);
  221. return raw_readw(dev->base_addr + DATA_PORT);
  222. }
  224. extern void inline
  225. writereg(struct net_device *dev, int portno, u16 value)
  226. {
  227. raw_writew(portno, dev->base_addr + ADD_PORT);
  228. raw_writew(value,  dev->base_addr + DATA_PORT);
  229. }
  231. extern u16 inline
  232. readword(struct net_device *dev, int portno)
  233. {
  234. return raw_readw(dev->base_addr + portno);
  235. }
  237. extern void inline
  238. writeword(struct net_device *dev, int portno, u16 value)
  239. {
  240. raw_writew(value,  dev->base_addr + portno);
  241. }
  243. static void writeblock(struct net_device *dev, char *pData, int Length)
  244. {
  245. int i;
  247. for (i = 0 ; i < (Length / 2); i++)
  248. {   
  249. writeword(dev, TX_FRAME_PORT, *(u16 *)pData );
  250. pData += 2;
  251. }
  252.    
  253. if (Length % 2) 
  254. {
  255. u16 OddWordValue = *pData;
  256. writeword(dev, TX_FRAME_PORT, OddWordValue);
  257. }
  258. }
  260. static void readblock(struct net_device *dev, char *pData, int Length)
  261. {
  262. #if 0
  263. u16 wOddWord;
  264. int i;
  265.    
  266. u16 StartOffset = PP_RxFrame | AUTOINCREMENT;
  268.     writeword(dev, ADD_PORT, StartOffset);
  270. if ((u32) pData % 2)
  271. {
  272. for (i=0; i < (Length/2); i++) 
  273. {
  274. wOddWord = readword(dev, DATA_PORT);
  275.                
  276. *(u8*)pData++ = (u8) wOddWord & 0xFF;
  277. *(u8*)pData++ = (u8) (wOddWord >> 8) & 0xFF;
  278. }
  279. }
  280. else
  281. {
  282. for (i=0; i < (Length/2); i++) 
  283. {
  284. *(u16*) pData = readword(dev, DATA_PORT);
  285. pData += 2;
  286. }
  287. }
  289. switch (Length % 2) 
  290.     {
  291. case 1:
  292. *pData = (u8) (readword(dev, DATA_PORT) & 0xff);
  293. }
  294. #endif
  295. u16 InputWord;
  296. int i;
  297.    
  298. for (i=0; i < (Length>>1); i++) 
  299. {
  300. InputWord = readword(dev, RX_FRAME_PORT);
  301. *(u8*)pData++ = (u8) InputWord & 0xFF;
  302. *(u8*)pData++ = (u8) (InputWord >> 8) & 0xFF;
  303. }
  305. switch (Length & 0x1) 
  306.     {
  307. case 1:
  308. *pData = (u8) (readword(dev, RX_FRAME_PORT) & 0xff);
  309. }
  310. }
  313. /* This is the real probe routine.  Linux has a history of friendly device
  314.    probes on the ISA bus.  A good device probes avoids doing writes, and
  315.    verifies that the correct device exists and functions.
  316.    Return 0 on success.
  317.  */
  318. char chip_version(int PID)
  319. {
  320.   switch(PID) {
  321.   case 0x7:
  322.     return 'B';
  323.   case 0x8:
  324.     return 'C';
  325.   case 0x9:
  326.     return 'D';
  327.   default :
  328.     return '?';
  329.  }
  331. }
  333. static int __init
  334. cerf89x0_probe1(struct net_device *dev, int ioaddr)
  335. {
  336. struct net_local *lp;
  337. static unsigned version_printed = 0;
  338. int i;
  339. unsigned rev_type = 0;
  340. u16 MacAddr[3] = {0,0,0};
  341. int retval;
  342. unsigned short wData;
  344. /* Initialize the device structure. */
  345. if (dev->priv == NULL)
  346. {
  347. dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
  348. if (dev->priv == 0)
  349. {
  350. retval = ENOMEM;
  351. goto out;
  352. }
  353. memset(dev->priv, 0, sizeof(struct net_local));
  354. }
  355. lp = (struct net_local *)dev->priv;
  357. /*  Bus Reset Consideration  */
  358. wData = raw_readw(ioaddr + ADD_PORT);
  360. if ((wData & ADD_MASK) != ADD_SIG )
  361. {
  362.   // if (net_debug)
  363. printk("cerf89x0:cerf89x0_probe1() 0x%08Xn", wData);
  364. // printk(" BWSCON 0x%08Xn", rBWSCON);
  366. retval = ENODEV;
  367. goto out1;
  368. }
  371. /* Fill in the 'dev' fields. */
  372. dev->base_addr = ioaddr;
  374. /* get the chip type */
  375. rev_type = readreg(dev, PRODUCT_ID_ADD);
  376. lp->chip_type = rev_type &~ REVISON_BITS;
  377. lp->chip_revision = chip_version((rev_type & REVISON_BITS) >> 8);
  380. /* Check the chip type and revision in order to set the correct send command
  381.    CS8920 revision C and CS8900 revision F can use the faster send.
  382. */
  383. /*   lp->send_cmd = TX_AFTER_381; */
  384.    lp->send_cmd = TX_AFTER_ALL; 
  387. /*
  388. if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
  389. lp->send_cmd = TX_NOW;
  390. if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
  391. lp->send_cmd = TX_NOW;
  393. */
  394. reset_chip(dev);
  396. if (net_debug  &&  version_printed++ == 0)
  397. printk(version);
  399. printk(KERN_INFO "%s: cs89%c0%s rev %c Base %x",
  400.        dev->name,
  401.        lp->chip_type==CS8900 ? '0' : '2',
  402.        lp->chip_type==CS8920M ? "M" : "",
  403.        lp->chip_revision,
  404.        (unsigned int )dev->base_addr);
  407. MacAddr[0] = 0x0000;
  408. MacAddr[1] = 0x24f0;
  409. MacAddr[2] = 0x5b05;
  410.    
  411. for (i = 0; i < ETH_ALEN/2; i++)
  412. {
  413. dev->dev_addr[i*2]   = MacAddr[i];
  414. dev->dev_addr[i*2+1] = MacAddr[i] >> 8;
  415. }
  417. dev->irq = IRQ_LAN;
  418. printk(KERN_INFO ", IRQ %d", dev->irq);
  420. /* print the ethernet address. */
  421. printk(", MAC ");
  422. for (i = 0; i < ETH_ALEN; i++)
  423. {
  424. printk("%s%02X", i ? ":" : "", dev->dev_addr[i]);
  425. }
  426. printk("n");
  428. dev->open = net_open;
  429. dev->stop = net_close;
  430. dev->tx_timeout = net_timeout;
  431. dev->watchdog_timeo = 3 * HZ ;
  432. dev->hard_start_xmit  = net_send_packet;
  433. dev->get_stats = net_get_stats;
  434. dev->set_multicast_list = set_multicast_list;
  435. dev->set_mac_address  = set_mac_address;
  437. /* Fill in the fields of the device structure with ethernet values. */
  438. ether_setup(dev);
  440. return 0;
  441. out1:
  442. kfree(dev->priv);
  443. dev->priv = 0;
  444. out:
  445. return retval;
  446. }
  449. void  __init reset_chip(struct net_device *dev)
  450. {
  451. int reset_start_time;
  453. writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
  455. /* wait 30 ms */
  456. current->state = TASK_INTERRUPTIBLE;
  457. schedule_timeout(30*HZ/1000);
  459. /* Wait until the chip is reset */
  460. reset_start_time = jiffies;
  461. while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
  462. jiffies - reset_start_time < 4)
  463. ;
  464. }
  466. /* Open/initialize the board.  This is called (in the current kernel)
  467.    sometime after booting when the 'ifconfig' program is run.
  469.    This routine should set everything up anew at each open, even
  470.    registers that "should" only need to be set once at boot, so that
  471.    there is non-reboot way to recover if something goes wrong.
  472.    */
  474. /* AKPM: do we need to do any locking here? */
  476. static int
  477. net_open(struct net_device *dev)
  478. {
  479. struct net_local *lp = (struct net_local *)dev->priv;
  480. int i;
  482. #ifdef CONFIG_S3C2410_SMDK
  483.     EINTPEND |= (1 << 9); /* External Interrupt Pending clear */
  485.     SRCPND |= (1 << 5); /* EINT8_23 source pending clear */
  486.     INTPND |= (1 << 5); /* EINT8_23 interrupt pending clear */
  488.     INTMOD &= ~(1 << 5); /* IRQ interrupt mode */
  489.     INTMSK &= ~(1 << 5); /* interrupt service available */
  491.     EXTINT1 &= ~(7 << 4);
  492.     EXTINT1 |= (4 << 4); /* EINT9 rising edge */
  494.     EINTMASK &= ~(1 << 9); /* External Interrupt Enable */
  495. #endif
  497. /* Prevent the crystal chip from generating interrupts */
  498. writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
  499.         enable_irq(IRQ_EINT8_23);
  500. /* Grab the interrupt */
  501. if (request_irq(dev->irq, &net_interrupt, SA_SHIRQ, "cs89x0", dev))
  502. {
  503. if (net_debug)
  504. printk("cerf89x0: request_irq(%d) failedn", dev->irq);
  505. return -EAGAIN;
  506. }
  508. /* Set up the IRQ - Apparently magic */
  509. if (lp->chip_type == CS8900)
  510. writereg(dev, PP_CS8900_ISAINT, 0);
  511. else
  512. writereg(dev, PP_CS8920_ISAINT, 0);
  514. /* set the Ethernet address */
  515. for (i=0; i < ETH_ALEN/2; i++)
  516. writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
  518. /* Receive only error free packets addressed to this card */
  519. lp->rx_mode = 0;//RX_OK_ACCEPT | RX_IA_ACCEPT;
  520. lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
  522. writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
  524.   writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
  526. writereg(dev, PP_TxCFG,
  527. TX_LOST_CRS_ENBL |
  528. TX_SQE_ERROR_ENBL |
  529. TX_OK_ENBL |
  530. TX_LATE_COL_ENBL |
  531. TX_JBR_ENBL |
  532. TX_ANY_COL_ENBL |
  533. TX_16_COL_ENBL);
  535. writereg(dev, PP_BufCFG,
  536. READY_FOR_TX_ENBL |
  537. RX_MISS_COUNT_OVRFLOW_ENBL |
  538. TX_COL_COUNT_OVRFLOW_ENBL |
  539. TX_UNDERRUN_ENBL);
  541. /* Turn on both receive and transmit operations */
  542. writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) |
  543. SERIAL_RX_ON |
  544. SERIAL_TX_ON);
  546. /* now that we've got our act together, enable everything */
  547. writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | IO_CHANNEL_READY_ON);
  548. writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
  550. enable_irq(dev->irq);
  552. MOD_INC_USE_COUNT;
  553. netif_start_queue(dev);
  555. return 0;
  556. }
  558. static void net_timeout(struct net_device *dev)
  559. {
  560. /* If we get here, some higher level has decided we are broken.
  561.    There should really be a "kick me" function call instead. */
  562.         printk(KERN_INFO " CS8900A device is not stable or unplugged n ");
  563. if (net_debug > 0)
  564. printk("%s: transmit timed out, %s?n", dev->name,
  565.     tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
  566. /* Try to restart the adaptor. */
  567. netif_wake_queue(dev);
  568. }
  570. static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
  571. {
  572. struct net_local *lp = (struct net_local *)dev->priv;
  573. writereg(dev, PP_BusCTL, 0x0);
  574. writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
  576. if (net_debug > 4)
  577. {
  578. printk("%s: sent %d byte packet of type %xn",
  579. dev->name, skb->len,
  580. (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
  581. }
  583. /* keep the upload from being interrupted, since we
  584.                   ask the chip to start transmitting before the
  585.                   whole packet has been completely uploaded. */
  588. spin_lock_irq(&lp->lock);
  589. netif_stop_queue(dev);
  591. /* initiate a transmit sequence */
  593. writeword(dev, TX_CMD_PORT, lp->send_cmd); /* SW.LEE */
  594. writeword(dev, TX_LEN_PORT, skb->len); 
  597. /* Test to see if the chip has allocated memory for the packet */
  599. if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0)
  600. {
  601. /*
  602.  * Gasp!  It hasn't.  But that shouldn't happen since
  603.  * we're waiting for TxOk, so return 1 and requeue this packet.
  604.  */
  605.   lp->Gskb = skb;
  606.   spin_unlock_irq(&lp->lock);
  607.   return 0;
  608. /*   if (net_debug) */
  609.   /*   printk("cs89x0: Tx buffer not free!n"); */
  611.   /*   return 1; */
  612. }
  614. /* Write the contents of the packet */
  615. writeblock(dev, skb->data, skb->len);
  617. spin_unlock_irq(&lp->lock);
  618. dev->trans_start = jiffies;
  620. /*  
  621. netif_start_queue(dev);
  622. It NETDEV WATCHDOG time not happens , It will stop 
  624. */
  625. dev_kfree_skb(skb);
  627. /*
  628.  * We DO NOT call netif_wake_queue() here.
  629.  * We also DO NOT call netif_start_queue().
  630.  *
  631.  * Either of these would cause another bottom half run through
  632.  * net_send_packet() before this packet has fully gone out.  That causes
  633.  * us to hit the "Gasp!" above and the send is rescheduled.  it runs like
  634.  * a dog.  We just return and wait for the Tx completion interrupt handler
  635.  * to restart the netdevice layer
  636.  */
  638. return 0;
  639. }
  641. /* The typical workload of the driver:
  642.    Handle the network interface interrupts. */
  643.    
  644. static void net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  645. {
  646. struct net_device *dev = dev_id;
  647. struct net_local *lp;
  648. int ioaddr, status;
  650. #ifdef CONFIG_S3C2410_SMDK
  651.     EINTPEND |= (1 << 9); /* External Interrupt Pending clear */
  653.     SRCPND |= (1 << 5); /* EINT8_23 source pending clear */
  654.     INTPND |= (1 << 5); /* EINT8_23 interrupt pending clear */
  655. #endif
  657. ioaddr = dev->base_addr;
  658. lp = (struct net_local *)dev->priv;
  660. /* we MUST read all the events out of the ISQ, otherwise we'll never
  661. get interrupted again.  As a consequence, we can't have any limit
  662. on the number of times we loop in the interrupt handler.  The
  663. hardware guarantees that eventually we'll run out of events.  Of
  664. course, if you're on a slow machine, and packets are arriving
  665. faster than you can read them off, you're screwed.  Hasta la
  666. vista, baby!
  667. */
  668. while ((status = readword(dev, ISQ_PORT)))
  669. {
  670. if (net_debug > 4)
  671. printk("%s: event=%04xn", dev->name, status);
  673. switch(status & ISQ_EVENT_MASK)
  674. {
  675. case ISQ_RECEIVER_EVENT:
  676. /* Got a packet(s). */
  677. net_rx(dev);
  678. break;
  680. case ISQ_TRANSMITTER_EVENT:
  681. lp->stats.tx_packets++;
  682. netif_wake_queue(dev); /* Inform upper layers. */
  683. if ((status & ( TX_OK |
  684. TX_LOST_CRS |
  685. TX_SQE_ERROR |
  686. TX_LATE_COL |
  687. TX_16_COL)) != TX_OK)
  688. {
  689. if ((status & TX_OK) == 0) lp->stats.tx_errors++;
  690. if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
  691. if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
  692. if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
  693. if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
  694. }
  695. break;
  697. case ISQ_BUFFER_EVENT:
  698. if (status & READY_FOR_TX)
  699. {
  700.     /* we tried to transmit a packet earlier, but inexplicably ran out of buffers.
  701.      * That shouldn't happen since we only ever load one packet.
  702.      * Shrug. Do the right thing anyway. 
  703.      */
  704.   if ( lp->Gskb ) {
  705.     writeblock(dev,lp->Gskb->data,lp->Gskb->len);
  706.     dev->trans_start = jiffies;
  707.     dev_kfree_skb(lp->Gskb);
  708.     lp->Gskb= NULL;
  709. /*      printk(" ------------> Gskb --------> n"); */
  710.   } else {
  711.        
  712. netif_wake_queue(dev); /* Inform upper layers. */
  713.   }
  714. }
  715. if (status & TX_UNDERRUN)
  716. {
  717. if (net_debug > 0)
  718. printk("%s: transmit underrunn", dev->name);
  719. lp->send_underrun++;
  720. if (lp->send_underrun == 3)
  721. lp->send_cmd = TX_AFTER_381;
  722. else if (lp->send_underrun == 6)
  723. lp->send_cmd = TX_AFTER_ALL;
  724. /*
  725.  * transmit cycle is done, although frame wasn't transmitted - this
  726.    * avoids having to wait for the upper layers to timeout on us,
  727.    * in the event of a tx underrun
  728.    */
  729. netif_wake_queue(dev); /* Inform upper layers. */
  730. }
  731. break;
  733. case ISQ_RX_MISS_EVENT:
  734. lp->stats.rx_missed_errors += (status >>6);
  735. break;
  737. case ISQ_TX_COL_EVENT:
  738. lp->stats.collisions += (status >>6);
  739. break;
  740. default:
  741. if (net_debug > 3)
  742. printk("%s: event=%04xn", dev->name, status);
  743. }
  744. }
  746. writereg(dev, PP_BusCTL,0x0); /* DISABLE_IRQ */
  747. writereg(dev, PP_BusCTL,ENABLE_IRQ);
  748. }
  750. static void
  751. count_rx_errors(int status, struct net_local *lp)
  752. {
  753. lp->stats.rx_errors++;
  754. if (status & RX_RUNT) lp->stats.rx_length_errors++;
  755. if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
  756. if (status & RX_CRC_ERROR)
  757. if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
  758. /* per str 172 */
  759. lp->stats.rx_crc_errors++;
  760. if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
  761. return;
  762. }
  764. /* We have a good packet(s), get it/them out of the buffers. */
  765. static void
  766. net_rx(struct net_device *dev)
  767. {
  768. struct net_local *lp = (struct net_local *)dev->priv;
  769. struct sk_buff *skb;
  770. int status = 0, length = 0;
  772. /*  status = readreg(dev, PP_RxStatus); */
  773. status = readword(dev, RX_FRAME_PORT);
  774. if ((status & RX_OK) == 0) {
  775. count_rx_errors(status, lp);
  776. return;
  777. }
  779. /*   length = readreg(dev, PP_RxLength); */
  780. length = readword(dev, RX_FRAME_PORT);
  782. /* Malloc up new buffer. */
  783. skb = alloc_skb(length+2, GFP_ATOMIC);
  784. skb_reserve(skb, 2);
  786. if (skb == NULL)
  787. {
  788. lp->stats.rx_dropped++;
  789. return;
  790. }
  791. skb->len = length;
  792. skb->dev = dev;
  794. readblock(dev, skb->data, skb->len);
  796. if (net_debug > 4)
  797. {
  798. printk("%s: received %d byte packet of type %xn",
  799. dev->name, length,
  800. (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
  801. }
  803. skb->protocol=eth_type_trans(skb,dev);
  804. netif_rx(skb);
  805. lp->stats.rx_packets++;
  806. lp->stats.rx_bytes+=skb->len;
  807. return;
  808. }
  810. /* The inverse routine to net_open(). */
  811. static int
  812. net_close(struct net_device *dev)
  813. {
  814. netif_stop_queue(dev);
  816. writereg(dev, PP_RxCFG, 0);
  817. writereg(dev, PP_TxCFG, 0);
  818. writereg(dev, PP_BufCFG, 0);
  819. writereg(dev, PP_BusCTL, 0);
  821. free_irq(dev->irq, dev);
  823. /* Update the statistics here. */
  824. MOD_DEC_USE_COUNT;
  825. return 0;
  826. }
  828. /* Get the current statistics. This may be called with the card open or
  829.    closed. */
  830. static struct net_device_stats *
  831. net_get_stats(struct net_device *dev)
  832. {
  833. struct net_local *lp = (struct net_local *)dev->priv;
  834. unsigned long flags;
  836. spin_lock_irqsave(&lp->lock, flags);
  837. /* Update the statistics from the device registers. */
  838. lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
  839. lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
  840. spin_unlock_irqrestore(&lp->lock, flags);
  842. return &lp->stats;
  843. }
  845. static void set_multicast_list(struct net_device *dev)
  846. {
  847. struct net_local *lp = (struct net_local *)dev->priv;
  848. unsigned long flags;
  850. spin_lock_irqsave(&lp->lock, flags);
  851. if(dev->flags&IFF_PROMISC)
  852. {
  853. lp->rx_mode = RX_ALL_ACCEPT;
  854. }
  855. else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
  856. {
  857. /* The multicast-accept list is initialized to accept-all, and we
  858.    rely on higher-level filtering for now. */
  859. lp->rx_mode = RX_MULTCAST_ACCEPT;
  860. } 
  861. else
  862. lp->rx_mode = 0;
  864. writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
  866. /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
  867. writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
  868.      (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
  869. spin_unlock_irqrestore(&lp->lock, flags);
  870. }
  873. static int set_mac_address(struct net_device *dev, void *addr)
  874. {
  875. int i;
  877. if (netif_running(dev))
  878. return -EBUSY;
  879. if (net_debug)
  880. {
  881. printk("%s: Setting MAC address to ", dev->name);
  882. for (i = 0; i < 6; i++)
  883. printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
  884. printk(".n");
  885. }
  886. /* set the Ethernet address */
  887. for (i=0; i < ETH_ALEN/2; i++)
  888. writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
  890. return 0;
  891. }
  895. static char namespace[16] = "";
  896. static struct net_device dev_cs89x0 = {
  897.         "",
  898.         0, 0, 0, 0,
  899.         0, 0,
  900.         0, 0, 0, NULL, NULL };
  902. /*
  903.  * Support the 'debug' module parm even if we're compiled for non-debug to 
  904.  * avoid breaking someone's startup scripts 
  905.  */
  907. static int debug = 1;
  908. static char media[8];
  909. static int duplex = 0;
  912. int
  913. init_s3c2410(void)
  914. {
  915. struct net_local *lp;
  917. #if DEBUGGING
  918. net_debug = debug;
  919. #endif
  921. dev_cs89x0.init = cerf89x0_probe;
  922. dev_cs89x0.priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
  923. if (dev_cs89x0.priv == 0)
  924. {
  925. printk(KERN_ERR "cs89x0.c: Out of memory.n");
  926. return -ENOMEM;
  927. }
  928. memset(dev_cs89x0.priv, 0, sizeof(struct net_local));
  929. lp = (struct net_local *)dev_cs89x0.priv;
  931. spin_lock_init(&lp->lock);
  933. if (register_netdev(&dev_cs89x0) != 0) {
  934. printk(KERN_ERR "cerf89x0.c: No chip found n");
  935. return -ENXIO;
  936. }
  937.     return 0;
  938. }
  940. void
  941. cleanup_s3c2410(void) 
  942. {
  943. writeword(&dev_cs89x0, ADD_PORT, PP_ChipID);
  944. if (dev_cs89x0.priv != NULL) {
  945. /* Free up the private structure, or leak memory :-)  */
  946. unregister_netdev(&dev_cs89x0);
  947. kfree(dev_cs89x0.priv);
  948. dev_cs89x0.priv = NULL; /* gets re-allocated by cerf89x0_probe1 */
  949. /* If we don't do this, we can't re-insmod it later. */
  950. release_region(dev_cs89x0.base_addr, NETCARD_IO_EXTENT);
  951. }
  952. }
  955. module_init(init_s3c2410);
  956. module_exit(cleanup_s3c2410);