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

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

嵌入式Linux

开发平台：

Unix_Linux

ethernet.c：源码内容
  1. /* $Id: ethernet.c,v 1.22 2002/01/30 07:48:22 matsfg Exp $
  2.  *
  3.  * e100net.c: A network driver for the ETRAX 100LX network controller.
  4.  *
  5.  * Copyright (c) 1998-2001 Axis Communications AB.
  6.  *
  7.  * The outline of this driver comes from skeleton.c.
  8.  *
  9.  * $Log: ethernet.c,v $
  10.  * Revision 1.22  2002/01/30 07:48:22  matsfg
  11.  * Initiate R_NETWORK_TR_CTRL
  12.  *
  13.  * Revision 1.21  2001/11/23 11:54:49  starvik
  14.  * Added IFF_PROMISC and IFF_ALLMULTI handling in set_multicast_list
  15.  * Removed compiler warnings
  16.  *
  17.  * Revision 1.20  2001/11/12 19:26:00  pkj
  18.  * * Corrected e100_negotiate() to not assign half to current_duplex when
  19.  *   it was supposed to compare them...
  20.  * * Cleaned up failure handling in e100_open().
  21.  * * Fixed compiler warnings.
  22.  *
  23.  * Revision 1.19  2001/11/09 07:43:09  starvik
  24.  * Added full duplex support
  25.  * Added ioctl to set speed and duplex
  26.  * Clear LED timer only runs when LED is lit
  27.  *
  28.  * Revision 1.18  2001/10/03 14:40:43  jonashg
  29.  * Update rx_bytes counter.
  30.  *
  31.  * Revision 1.17  2001/06/11 12:43:46  olof
  32.  * Modified defines for network LED behavior
  33.  *
  34.  * Revision 1.16  2001/05/30 06:12:46  markusl
  35.  * TxDesc.next should not be set to NULL
  36.  *
  37.  * Revision 1.15  2001/05/29 10:27:04  markusl
  38.  * Updated after review remarks:
  39.  * +Use IO_EXTRACT
  40.  * +Handle underrun
  41.  *
  42.  * Revision 1.14  2001/05/29 09:20:14  jonashg
  43.  * Use driver name on printk output so one can tell which driver that complains.
  44.  *
  45.  * Revision 1.13  2001/05/09 12:35:59  johana
  46.  * Use DMA_NBR and IRQ_NBR defines from dma.h and irq.h
  47.  *
  48.  * Revision 1.12  2001/04/05 11:43:11  tobiasa
  49.  * Check dev before panic.
  50.  *
  51.  * Revision 1.11  2001/04/04 11:21:05  markusl
  52.  * Updated according to review remarks
  53.  *
  54.  * Revision 1.10  2001/03/26 16:03:06  bjornw
  55.  * Needs linux/config.h
  56.  *
  57.  * Revision 1.9  2001/03/19 14:47:48  pkj
  58.  * * Make sure there is always a pause after the network LEDs are
  59.  *   changed so they will not look constantly lit during heavy traffic.
  60.  * * Always use HZ when setting times relative to jiffies.
  61.  * * Use LED_NETWORK_SET() when setting the network LEDs.
  62.  *
  63.  * Revision 1.8  2001/02/27 13:52:48  bjornw
  64.  * malloc.h -> slab.h
  65.  *
  66.  * Revision 1.7  2001/02/23 13:46:38  bjornw
  67.  * Spellling check
  68.  *
  69.  * Revision 1.6  2001/01/26 15:21:04  starvik
  70.  * Don't disable interrupts while reading MDIO registers (MDIO is slow)
  71.  * Corrected promiscuous mode
  72.  * Improved deallocation of IRQs ("ifconfig eth0 down" now works)
  73.  *
  74.  * Revision 1.5  2000/11/29 17:22:22  bjornw
  75.  * Get rid of the udword types legacy stuff
  76.  *
  77.  * Revision 1.4  2000/11/22 16:36:09  bjornw
  78.  * Please marketing by using the correct case when spelling Etrax.
  79.  *
  80.  * Revision 1.3  2000/11/21 16:43:04  bjornw
  81.  * Minor short->int change
  82.  *
  83.  * Revision 1.2  2000/11/08 14:27:57  bjornw
  84.  * 2.4 port
  85.  *
  86.  * Revision 1.1  2000/11/06 13:56:00  bjornw
  87.  * Verbatim copy of the 1.24 version of e100net.c from elinux
  88.  *
  89.  * Revision 1.24  2000/10/04 15:55:23  bjornw
  90.  * * Use virt_to_phys etc. for DMA addresses
  91.  * * Removed bogus CHECKSUM_UNNECESSARY
  92.  *
  93.  *
  94.  */
  96. #include <linux/config.h>
  98. #include <linux/module.h>
  100. #include <linux/kernel.h>
  101. #include <linux/sched.h>
  102. #include <linux/delay.h>
  103. #include <linux/types.h>
  104. #include <linux/fcntl.h>
  105. #include <linux/interrupt.h>
  106. #include <linux/ptrace.h>
  107. #include <linux/ioport.h>
  108. #include <linux/in.h>
  109. #include <linux/slab.h>
  110. #include <linux/string.h>
  111. #include <linux/spinlock.h>
  112. #include <linux/errno.h>
  113. #include <linux/init.h>
  115. #include <linux/netdevice.h>
  116. #include <linux/etherdevice.h>
  117. #include <linux/skbuff.h>
  119. #include <asm/svinto.h>     /* DMA and register descriptions */
  120. #include <asm/io.h>         /* LED_* I/O functions */
  121. #include <asm/irq.h>
  122. #include <asm/dma.h>
  123. #include <asm/system.h>
  124. #include <asm/bitops.h>
  125. #include <asm/ethernet.h>
  127. //#define ETHDEBUG
  128. #define D(x)
  131. /*
  132.  * The name of the card. Is used for messages and in the requests for
  133.  * io regions, irqs and dma channels
  134.  */
  136. static const char* cardname = "ETRAX 100LX built-in ethernet controller";
  138. /* A default ethernet address. Highlevel SW will set the real one later */
  140. static struct sockaddr default_mac = {
  141. 0,
  142. { 0x00, 0x40, 0x8C, 0xCD, 0x00, 0x00 }
  143. };
  145. /* Information that need to be kept for each board. */
  146. struct net_local {
  147. struct net_device_stats stats;
  149. /* Tx control lock.  This protects the transmit buffer ring
  150.  * state along with the "tx full" state of the driver.  This
  151.  * means all netif_queue flow control actions are protected
  152.  * by this lock as well.
  153.  */
  154. spinlock_t lock;
  155. };
  158. /* Duplex settings */
  159. enum duplex
  160. {
  161. half,
  162. full,
  163. autoneg
  164. };
  166. /* Dma descriptors etc. */
  168. #define RX_BUF_SIZE 32768
  170. #define MAX_MEDIA_DATA_SIZE 1518
  172. #define MIN_PACKET_LEN      46
  173. #define ETHER_HEAD_LEN      14
  175. /* 
  176. ** MDIO constants.
  177. */
  178. #define MDIO_BASE_STATUS_REG                0x1
  179. #define MDIO_BASE_CONTROL_REG               0x0
  180. #define MDIO_BC_NEGOTIATE                0x0200
  181. #define MDIO_BC_FULL_DUPLEX_MASK         0x0100
  182. #define MDIO_BC_AUTO_NEG_MASK            0x1000
  183. #define MDIO_BC_SPEED_SELECT_MASK        0x2000
  184. #define MDIO_ADVERTISMENT_REG               0x4
  185. #define MDIO_ADVERT_100_FD                0x100
  186. #define MDIO_ADVERT_100_HD                0x080
  187. #define MDIO_ADVERT_10_FD                 0x040
  188. #define MDIO_ADVERT_10_HD                 0x020
  189. #define MDIO_LINK_UP_MASK                   0x4
  190. #define MDIO_START                          0x1
  191. #define MDIO_READ                           0x2
  192. #define MDIO_WRITE                          0x1
  193. #define MDIO_PREAMBLE              0xfffffffful
  195. /* Broadcom specific */
  196. #define MDIO_AUX_CTRL_STATUS_REG           0x18
  197. #define MDIO_FULL_DUPLEX_IND                0x1
  198. #define MDIO_SPEED                          0x2
  199. #define MDIO_PHYS_ADDR                      0x0
  201. /* Network flash constants */
  202. #define NET_FLASH_TIME                  (HZ/50) /* 20 ms */
  203. #define NET_FLASH_PAUSE                (HZ/100) /* 10 ms */
  204. #define NET_LINK_UP_CHECK_INTERVAL       (2*HZ) /* 2 s   */
  205. #define NET_DUPLEX_CHECK_INTERVAL        (2*HZ) /* 2 s   */
  207. #define NO_NETWORK_ACTIVITY 0
  208. #define NETWORK_ACTIVITY    1
  210. #define RX_DESC_BUF_SIZE   256
  211. #define NBR_OF_RX_DESC     (RX_BUF_SIZE / 
  212.                             RX_DESC_BUF_SIZE)
  214. #define GET_BIT(bit,val)   (((val) >> (bit)) & 0x01)
  216. /* Define some macros to access ETRAX 100 registers */
  217. #define SETF(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  218.   IO_FIELD(##reg##, field, val)
  219. #define SETS(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  220.   IO_STATE(##reg##, field, val)
  222. static etrax_dma_descr *myNextRxDesc;  /* Points to the next descriptor to
  223.                                           to be processed */
  224. static etrax_dma_descr *myLastRxDesc;  /* The last processed descriptor */
  225. static etrax_dma_descr *myPrevRxDesc;  /* The descriptor right before myNextRxDesc */
  227. static unsigned char RxBuf[RX_BUF_SIZE];
  229. static etrax_dma_descr RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned(4)));
  230. static etrax_dma_descr TxDesc __attribute__ ((aligned(4)));
  232. static struct sk_buff *tx_skb;
  234. static unsigned int network_rec_config_shadow = 0;
  236. /* Network speed indication. */
  237. static struct timer_list speed_timer;
  238. static struct timer_list clear_led_timer;
  239. static int current_speed; /* Speed read from tranceiver */
  240. static int current_speed_selection; /* Speed selected by user */
  241. static int led_next_time;
  242. static int led_active;
  244. /* Duplex */
  245. static struct timer_list duplex_timer;
  246. static int full_duplex;
  247. static enum duplex current_duplex;
  249. /* Index to functions, as function prototypes. */
  251. static int etrax_ethernet_init(struct net_device *dev);
  253. static int e100_open(struct net_device *dev);
  254. static int e100_set_mac_address(struct net_device *dev, void *addr);
  255. static int e100_send_packet(struct sk_buff *skb, struct net_device *dev);
  256. static void e100rx_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  257. static void e100tx_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  258. static void e100nw_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  259. static void e100_rx(struct net_device *dev);
  260. static int e100_close(struct net_device *dev);
  261. static int e100_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
  262. static void e100_tx_timeout(struct net_device *dev);
  263. static struct net_device_stats *e100_get_stats(struct net_device *dev);
  264. static void set_multicast_list(struct net_device *dev);
  265. static void e100_hardware_send_packet(char *buf, int length);
  266. static void update_rx_stats(struct net_device_stats *);
  267. static void update_tx_stats(struct net_device_stats *);
  269. static void e100_check_speed(unsigned long dummy);
  270. static void e100_set_speed(unsigned long speed);
  271. static void e100_check_duplex(unsigned long dummy);
  272. static void e100_set_duplex(enum duplex);
  273. static void e100_negotiate(void);
  275. static unsigned short e100_get_mdio_reg(unsigned char reg_num);
  276. static void e100_send_mdio_cmd(unsigned short cmd, int write_cmd);
  277. static void e100_send_mdio_bit(unsigned char bit);
  278. static unsigned char e100_receive_mdio_bit(void);
  279. static void e100_reset_tranceiver(void);
  281. static void e100_clear_network_leds(unsigned long dummy);
  282. static void e100_set_network_leds(int active);
  284. #define tx_done(dev) (*R_DMA_CH0_CMD == 0)
  286. /*
  287.  * Check for a network adaptor of this type, and return '0' if one exists.
  288.  * If dev->base_addr == 0, probe all likely locations.
  289.  * If dev->base_addr == 1, always return failure.
  290.  * If dev->base_addr == 2, allocate space for the device and return success
  291.  * (detachable devices only).
  292.  */
  294. static int __init
  295. etrax_ethernet_init(struct net_device *dev)
  296. {
  297. int i;
  298. int anOffset = 0;
  300. printk("ETRAX 100LX 10/100MBit ethernet v2.0 (c) 2000-2001 Axis Communications ABn");
  302. dev->base_addr = (unsigned int)R_NETWORK_SA_0; /* just to have something to show */
  304. printk("%s initializedn", dev->name);
  306. /* make Linux aware of the new hardware  */
  308. if (!dev) {
  309. printk(KERN_WARNING "%s: dev == NULL. Should this happen?n",
  310.        cardname);
  311. dev = init_etherdev(dev, sizeof(struct net_local));
  312. if (!dev)
  313. panic("init_etherdev failedn");
  314. }
  316. /* setup generic handlers and stuff in the dev struct */
  318. ether_setup(dev);
  320. /* make room for the local structure containing stats etc */
  322. dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
  323. if (dev->priv == NULL)
  324. return -ENOMEM;
  325. memset(dev->priv, 0, sizeof(struct net_local));
  327. /* now setup our etrax specific stuff */
  329. dev->irq = NETWORK_DMA_RX_IRQ_NBR; /* we really use DMATX as well... */
  330. dev->dma = NETWORK_RX_DMA_NBR;
  332. /* fill in our handlers so the network layer can talk to us in the future */
  334. dev->open               = e100_open;
  335. dev->hard_start_xmit    = e100_send_packet;
  336. dev->stop               = e100_close;
  337. dev->get_stats          = e100_get_stats;
  338. dev->set_multicast_list = set_multicast_list;
  339. dev->set_mac_address    = e100_set_mac_address;
  340. dev->do_ioctl           = e100_ioctl;
  341. dev->tx_timeout         = e100_tx_timeout;
  343. /* set the default MAC address */
  345. e100_set_mac_address(dev, &default_mac);
  347. /* Initialise the list of Etrax DMA-descriptors */
  349. /* Initialise receive descriptors */
  351. for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
  352. RxDescList[i].ctrl   = 0;
  353. RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
  354. RxDescList[i].next   = virt_to_phys(&RxDescList[i + 1]);
  355. RxDescList[i].buf    = virt_to_phys(RxBuf + anOffset);
  356. RxDescList[i].status = 0;
  357. RxDescList[i].hw_len = 0;
  358. anOffset += RX_DESC_BUF_SIZE;
  359. }
  361. RxDescList[i].ctrl   = d_eol;
  362. RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
  363. RxDescList[i].next   = virt_to_phys(&RxDescList[0]);
  364. RxDescList[i].buf    = virt_to_phys(RxBuf + anOffset);
  365. RxDescList[i].status = 0;
  366. RxDescList[i].hw_len = 0;
  368. /* Initialise initial pointers */
  370. myNextRxDesc = &RxDescList[0];
  371. myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
  372. myPrevRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
  374. /* Initialize speed indicator stuff. */
  376. current_speed = 10;
  377. current_speed_selection = 0; /* Auto */
  378. speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
  379. speed_timer.function = e100_check_speed;
  380. add_timer(&speed_timer);
  381.         
  382. clear_led_timer.function = e100_clear_network_leds;
  383.         
  384. full_duplex = 0;
  385. current_duplex = autoneg;
  386. duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
  387. duplex_timer.function = e100_check_duplex;
  388. add_timer(&duplex_timer);
  390. return 0;
  391. }
  393. /* set MAC address of the interface. called from the core after a
  394.  * SIOCSIFADDR ioctl, and from the bootup above.
  395.  */
  397. static int
  398. e100_set_mac_address(struct net_device *dev, void *p)
  399. {
  400. struct sockaddr *addr = p;
  401. int i;
  403. /* remember it */
  405. memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
  407. /* Write it to the hardware.
  408.  * Note the way the address is wrapped:
  409.  * *R_NETWORK_SA_0 = a0_0 | (a0_1 << 8) | (a0_2 << 16) | (a0_3 << 24);
  410.  * *R_NETWORK_SA_1 = a0_4 | (a0_5 << 8);
  411.  */
  413. *R_NETWORK_SA_0 = dev->dev_addr[0] | (dev->dev_addr[1] << 8) |
  414. (dev->dev_addr[2] << 16) | (dev->dev_addr[3] << 24);
  415. *R_NETWORK_SA_1 = dev->dev_addr[4] | (dev->dev_addr[5] << 8);
  416. *R_NETWORK_SA_2 = 0;
  418. /* show it in the log as well */
  420. printk("%s: changed MAC to ", dev->name);
  422. for (i = 0; i < 5; i++)
  423. printk("%02X:", dev->dev_addr[i]);
  425. printk("%02Xn", dev->dev_addr[i]);
  427. return 0;
  428. }
  430. /*
  431.  * Open/initialize the board. This is called (in the current kernel)
  432.  * sometime after booting when the 'ifconfig' program is run.
  433.  *
  434.  * This routine should set everything up anew at each open, even
  435.  * registers that "should" only need to be set once at boot, so that
  436.  * there is non-reboot way to recover if something goes wrong.
  437.  */
  439. static int
  440. e100_open(struct net_device *dev)
  441. {
  442. unsigned long flags;
  444. /* disable the ethernet interface while we configure it */
  446. *R_NETWORK_GEN_CONFIG =
  447. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  448. IO_STATE(R_NETWORK_GEN_CONFIG, enable, off);
  450. /* enable the MDIO output pin */
  452. *R_NETWORK_MGM_CTRL = IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable);
  454. *R_IRQ_MASK0_CLR =
  455. IO_STATE(R_IRQ_MASK0_CLR, overrun, clr) |
  456. IO_STATE(R_IRQ_MASK0_CLR, underrun, clr) |
  457. IO_STATE(R_IRQ_MASK0_CLR, excessive_col, clr);
  459. /* clear dma0 and 1 eop and descr irq masks */
  460. *R_IRQ_MASK2_CLR =
  461. IO_STATE(R_IRQ_MASK2_CLR, dma0_descr, clr) |
  462. IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr) |
  463. IO_STATE(R_IRQ_MASK2_CLR, dma1_descr, clr) |
  464. IO_STATE(R_IRQ_MASK2_CLR, dma1_eop, clr);
  466. /* Reset and wait for the DMA channels */
  468. RESET_DMA(NETWORK_TX_DMA_NBR);
  469. RESET_DMA(NETWORK_RX_DMA_NBR);
  470. WAIT_DMA(NETWORK_TX_DMA_NBR);
  471. WAIT_DMA(NETWORK_RX_DMA_NBR);
  473. /* Initialise the etrax network controller */
  475. /* allocate the irq corresponding to the receiving DMA */
  477. if (request_irq(NETWORK_DMA_RX_IRQ_NBR, e100rx_interrupt, 0,
  478. cardname, (void *)dev)) {
  479. goto grace_exit0;
  480. }
  482. /* allocate the irq corresponding to the transmitting DMA */
  484. if (request_irq(NETWORK_DMA_TX_IRQ_NBR, e100tx_interrupt, 0,
  485. cardname, (void *)dev)) {
  486. goto grace_exit1;
  487. }
  489. /* allocate the irq corresponding to the network errors etc */
  491. if (request_irq(NETWORK_STATUS_IRQ_NBR, e100nw_interrupt, 0,
  492. cardname, (void *)dev)) {
  493. goto grace_exit2;
  494. }
  496. /*
  497.  * Always allocate the DMA channels after the IRQ,
  498.  * and clean up on failure.
  499.  */
  501. if (request_dma(NETWORK_TX_DMA_NBR, cardname)) {
  502. goto grace_exit3;
  503. }
  505. if (request_dma(NETWORK_RX_DMA_NBR, cardname)) {
  506. goto grace_exit4;
  507. }
  509. /* give the HW an idea of what MAC address we want */
  511. *R_NETWORK_SA_0 = dev->dev_addr[0] | (dev->dev_addr[1] << 8) |
  512. (dev->dev_addr[2] << 16) | (dev->dev_addr[3] << 24);
  513. *R_NETWORK_SA_1 = dev->dev_addr[4] | (dev->dev_addr[5] << 8);
  514. *R_NETWORK_SA_2 = 0;
  516. #if 0
  517. /* use promiscuous mode for testing */
  518. *R_NETWORK_GA_0 = 0xffffffff;
  519. *R_NETWORK_GA_1 = 0xffffffff;
  521. *R_NETWORK_REC_CONFIG = 0xd; /* broadcast rec, individ. rec, ma0 enabled */
  522. #else
  523. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, broadcast, receive);
  524. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, ma0, enable);
  525. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  526. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  527. #endif
  529. *R_NETWORK_GEN_CONFIG =
  530. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  531. IO_STATE(R_NETWORK_GEN_CONFIG, enable, on);
  533.         *R_NETWORK_TR_CTRL = 
  534.                 IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr) |
  535.                 IO_STATE(R_NETWORK_TR_CTRL, delay, none) |
  536.                 IO_STATE(R_NETWORK_TR_CTRL, cancel, dont) |
  537.                 IO_STATE(R_NETWORK_TR_CTRL, cd, enable) |
  538.                 IO_STATE(R_NETWORK_TR_CTRL, retry, enable) |
  539.                 IO_STATE(R_NETWORK_TR_CTRL, pad, enable) |
  540.                 IO_STATE(R_NETWORK_TR_CTRL, crc, enable);
  542. save_flags(flags);
  543. cli();
  545. /* enable the irq's for ethernet DMA */
  547. *R_IRQ_MASK2_SET =
  548. IO_STATE(R_IRQ_MASK2_SET, dma0_eop, set) |
  549. IO_STATE(R_IRQ_MASK2_SET, dma1_eop, set);
  551. *R_IRQ_MASK0_SET =
  552. IO_STATE(R_IRQ_MASK0_SET, overrun,       set) |
  553. IO_STATE(R_IRQ_MASK0_SET, underrun,      set) |
  554. IO_STATE(R_IRQ_MASK0_SET, excessive_col, set);
  556. tx_skb = 0;
  558. /* make sure the irqs are cleared */
  560. *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
  561. *R_DMA_CH1_CLR_INTR = IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do);
  563. /* make sure the rec and transmit error counters are cleared */
  565. (void)*R_REC_COUNTERS;  /* dummy read */
  566. (void)*R_TR_COUNTERS;   /* dummy read */
  568. /* start the receiving DMA channel so we can receive packets from now on */
  570. *R_DMA_CH1_FIRST = virt_to_phys(myNextRxDesc);
  571. *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, start);
  573. restore_flags(flags);
  575. /* We are now ready to accept transmit requeusts from
  576.  * the queueing layer of the networking.
  577.  */
  578. netif_start_queue(dev);
  580. return 0;
  582. grace_exit4:
  583. free_dma(NETWORK_TX_DMA_NBR);
  584. grace_exit3:
  585. free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
  586. grace_exit2:
  587. free_irq(NETWORK_DMA_TX_IRQ_NBR, (void *)dev);
  588. grace_exit1:
  589. free_irq(NETWORK_DMA_RX_IRQ_NBR, (void *)dev);
  590. grace_exit0:
  591. return -EAGAIN;
  592. }
  595. static void
  596. e100_check_speed(unsigned long dummy)
  597. {
  598. unsigned long data;
  599. int old_speed = current_speed;
  601. data = e100_get_mdio_reg(MDIO_BASE_STATUS_REG);
  602. if (!(data & MDIO_LINK_UP_MASK)) {
  603. current_speed = 0;
  604. } else {
  605. data = e100_get_mdio_reg(MDIO_AUX_CTRL_STATUS_REG);
  606. current_speed = (data & MDIO_SPEED ? 100 : 10);
  607. }
  609. if (old_speed != current_speed)
  610. e100_set_network_leds(NO_NETWORK_ACTIVITY);
  612. /* Reinitialize the timer. */
  613. speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
  614. add_timer(&speed_timer);
  615. }
  617. static void
  618. e100_negotiate(void)
  619. {
  620. unsigned short cmd;
  621. unsigned short data = e100_get_mdio_reg(MDIO_ADVERTISMENT_REG);
  622. int bitCounter;
  624. /* Discard old speed and duplex settings */
  625. data &= ~(MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | 
  626.           MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD);
  627.   
  628. switch (current_speed_selection) {
  629. case 10 :
  630. if (current_duplex == full)
  631. data |= MDIO_ADVERT_10_FD;
  632. else if (current_duplex == half)
  633. data |= MDIO_ADVERT_10_HD;
  634. else
  635. data |= MDIO_ADVERT_10_HD |  MDIO_ADVERT_10_FD;
  636. break;
  638. case 100 :
  639.  if (current_duplex == full)
  640. data |= MDIO_ADVERT_100_FD;
  641. else if (current_duplex == half)
  642. data |= MDIO_ADVERT_100_HD;
  643. else
  644. data |= MDIO_ADVERT_100_HD |  MDIO_ADVERT_100_FD;
  645. break;
  647. case 0 : /* Auto */
  648.  if (current_duplex == full)
  649. data |= MDIO_ADVERT_100_FD | MDIO_ADVERT_10_FD;
  650. else if (current_duplex == half)
  651. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_10_HD;
  652. else
  653. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD;
  654. break;
  656. default : /* assume autoneg speed and duplex */
  657. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | 
  658.         MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD;
  659. }
  661. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) |
  662.       (MDIO_ADVERTISMENT_REG<< 2);
  664. e100_send_mdio_cmd(cmd, 1);
  666. /* Data... */
  667. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  668. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  669. }
  671. /* Renegotiate with link partner */
  672. data = e100_get_mdio_reg(MDIO_BASE_CONTROL_REG);
  673. data |= MDIO_BC_NEGOTIATE;
  675. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) |
  676.       (MDIO_BASE_CONTROL_REG<< 2);
  678. e100_send_mdio_cmd(cmd, 1);
  680. /* Data... */
  681. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  682. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  683. }  
  684. }
  686. static void
  687. e100_set_speed(unsigned long speed)
  688. {
  689. current_speed_selection = speed;
  690. e100_negotiate();
  691. }
  693. static void
  694. e100_check_duplex(unsigned long dummy)
  695. {
  696. unsigned long data;
  698. data = e100_get_mdio_reg(MDIO_AUX_CTRL_STATUS_REG);
  699.         
  700. if (data & MDIO_FULL_DUPLEX_IND) {
  701. if (!full_duplex) { /* Duplex changed to full? */
  702. full_duplex = 1;
  703. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  704. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  705. }
  706. } else { /* half */
  707. if (full_duplex) { /* Duplex changed to half? */
  708. full_duplex = 0;
  709. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  710. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  711. }
  712. }
  714. /* Reinitialize the timer. */
  715. duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
  716. add_timer(&duplex_timer);
  717. }
  719. static void 
  720. e100_set_duplex(enum duplex new_duplex)
  721. {
  722. current_duplex = new_duplex;
  723. e100_negotiate();
  724. }
  727. static unsigned short
  728. e100_get_mdio_reg(unsigned char reg_num)
  729. {
  730. unsigned short cmd;    /* Data to be sent on MDIO port */
  731. unsigned short data;   /* Data read from MDIO */
  732. int bitCounter;
  734. /* Start of frame, OP Code, Physical Address, Register Address */
  735. cmd = (MDIO_START << 14) | (MDIO_READ << 12) | (MDIO_PHYS_ADDR << 7) |
  736. (reg_num << 2);
  738. e100_send_mdio_cmd(cmd, 0);
  740. data = 0;
  742. /* Data... */
  743. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  744. data |= (e100_receive_mdio_bit() << bitCounter);
  745. }
  747. return data;
  748. }
  750. static void
  751. e100_send_mdio_cmd(unsigned short cmd, int write_cmd)
  752. {
  753. int bitCounter;
  754. unsigned char data = 0x2;
  756. /* Preamble */
  757. for (bitCounter = 31; bitCounter>= 0; bitCounter--)
  758. e100_send_mdio_bit(GET_BIT(bitCounter, MDIO_PREAMBLE));
  760. for (bitCounter = 15; bitCounter >= 2; bitCounter--)
  761. e100_send_mdio_bit(GET_BIT(bitCounter, cmd));
  763. /* Turnaround */
  764. for (bitCounter = 1; bitCounter >= 0 ; bitCounter--)
  765. if (write_cmd)
  766. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  767. else
  768. e100_receive_mdio_bit();
  769. }
  771. static void
  772. e100_send_mdio_bit(unsigned char bit)
  773. {
  774. *R_NETWORK_MGM_CTRL =
  775. IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
  776. IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
  777. udelay(1);
  778. *R_NETWORK_MGM_CTRL =
  779. IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
  780. IO_MASK(R_NETWORK_MGM_CTRL, mdck) |
  781. IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
  782. udelay(1);
  783. }
  785. static unsigned char
  786. e100_receive_mdio_bit()
  787. {
  788. unsigned char bit;
  789. *R_NETWORK_MGM_CTRL = 0;
  790. bit = IO_EXTRACT(R_NETWORK_STAT, mdio, *R_NETWORK_STAT);
  791. udelay(1);
  792. *R_NETWORK_MGM_CTRL = IO_MASK(R_NETWORK_MGM_CTRL, mdck);
  793. udelay(1);
  794. return bit;
  795. }
  797. static void 
  798. e100_reset_tranceiver(void)
  799. {
  800. unsigned short cmd;
  801. unsigned short data;
  802. int bitCounter;
  804. data = e100_get_mdio_reg(MDIO_BASE_CONTROL_REG);
  806. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) | (MDIO_BASE_CONTROL_REG << 2);
  808. e100_send_mdio_cmd(cmd, 1);
  810. data |= 0x8000;
  812. for (bitCounter = 15; bitCounter >= 0 ; bitCounter--) {
  813. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  814. }
  815. }
  817. /* Called by upper layers if they decide it took too long to complete
  818.  * sending a packet - we need to reset and stuff.
  819.  */
  821. static void
  822. e100_tx_timeout(struct net_device *dev)
  823. {
  824. struct net_local *np = (struct net_local *)dev->priv;
  826. printk(KERN_WARNING "%s: transmit timed out, %s?n", dev->name,
  827.        tx_done(dev) ? "IRQ problem" : "network cable problem");
  829. /* remember we got an error */
  831. np->stats.tx_errors++; 
  833. /* reset the TX DMA in case it has hung on something */
  835. RESET_DMA(NETWORK_TX_DMA_NBR);
  836. WAIT_DMA(NETWORK_TX_DMA_NBR);
  838. /* Reset the tranceiver. */
  840. e100_reset_tranceiver();
  842. /* and get rid of the packet that never got an interrupt */
  844. dev_kfree_skb(tx_skb);
  845. tx_skb = 0;
  847. /* tell the upper layers we're ok again */
  849. netif_wake_queue(dev);
  850. }
  853. /* This will only be invoked if the driver is _not_ in XOFF state.
  854.  * What this means is that we need not check it, and that this
  855.  * invariant will hold if we make sure that the netif_*_queue()
  856.  * calls are done at the proper times.
  857.  */
  859. static int
  860. e100_send_packet(struct sk_buff *skb, struct net_device *dev)
  861. {
  862. struct net_local *np = (struct net_local *)dev->priv;
  863. int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  864. unsigned char *buf = skb->data;
  866. #ifdef ETHDEBUG
  867. printk("send packet len %dn", length);
  868. #endif
  869. spin_lock_irq(&np->lock);  /* protect from tx_interrupt */
  871. tx_skb = skb; /* remember it so we can free it in the tx irq handler later */
  872. dev->trans_start = jiffies;
  874. e100_hardware_send_packet(buf, length);
  876. /* this simple TX driver has only one send-descriptor so we're full
  877.  * directly. If this had a send-ring instead, we would only do this if
  878.  * the ring got full.
  879.  */
  881. netif_stop_queue(dev);
  883. spin_unlock_irq(&np->lock);
  885. return 0;
  886. }
  888. /*
  889.  * The typical workload of the driver:
  890.  *   Handle the network interface interrupts.
  891.  */
  893. static void
  894. e100rx_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  895. {
  896. struct net_device *dev = (struct net_device *)dev_id;
  897. unsigned long irqbits = *R_IRQ_MASK2_RD;
  898.  
  899. if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma1_eop, active)) {
  900. /* acknowledge the eop interrupt */
  902. *R_DMA_CH1_CLR_INTR = IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do);
  904. /* check if one or more complete packets were indeed received */
  906. while (*R_DMA_CH1_FIRST != virt_to_phys(myNextRxDesc)) {
  907. /* Take out the buffer and give it to the OS, then
  908.  * allocate a new buffer to put a packet in.
  909.  */
  910. e100_rx(dev);
  911. ((struct net_local *)dev->priv)->stats.rx_packets++;
  912. /* restart/continue on the channel, for safety */
  913. *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, restart);
  914. /* clear dma channel 1 eop/descr irq bits */
  915. *R_DMA_CH1_CLR_INTR =
  916. IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do) |
  917. IO_STATE(R_DMA_CH1_CLR_INTR, clr_descr, do);
  919. /* now, we might have gotten another packet
  920.    so we have to loop back and check if so */
  921. }
  922. }
  923. }
  925. /* the transmit dma channel interrupt
  926.  *
  927.  * this is supposed to free the skbuff which was pending during transmission,
  928.  * and inform the kernel that we can send one more buffer
  929.  */
  931. static void
  932. e100tx_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  933. {
  934. struct net_device *dev = (struct net_device *)dev_id;
  935. unsigned long irqbits = *R_IRQ_MASK2_RD;
  936. struct net_local *np = (struct net_local *)dev->priv;
  938. /* check for a dma0_eop interrupt */
  939. if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma0_eop, active)) { 
  940. /* This protects us from concurrent execution of
  941.  * our dev->hard_start_xmit function above.
  942.  */
  944. spin_lock(&np->lock);
  946. /* acknowledge the eop interrupt */
  948. *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
  950. if (*R_DMA_CH0_FIRST == 0 && tx_skb) {
  951. np->stats.tx_bytes += tx_skb->len;
  952. np->stats.tx_packets++;
  953. /* dma is ready with the transmission of the data in tx_skb, so now
  954.    we can release the skb memory */
  955. dev_kfree_skb_irq(tx_skb);
  956. tx_skb = 0;
  957. netif_wake_queue(dev);
  958. } else {
  959. printk(KERN_WARNING "%s: tx weird interruptn",
  960.        cardname);
  961. }
  963. spin_unlock(&np->lock);
  964. }
  965. }
  967. static void
  968. e100nw_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  969. {
  970. struct net_device *dev = (struct net_device *)dev_id;
  971. struct net_local *np = (struct net_local *)dev->priv;
  972. unsigned long irqbits = *R_IRQ_MASK0_RD;
  974. /* check for underrun irq */
  975. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, underrun, active)) { 
  976. *R_NETWORK_TR_CTRL = IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr);
  977. np->stats.tx_errors++;
  978. D(printk("ethernet receiver underrun!n"));
  979. }
  981. /* check for overrun irq */
  982. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, overrun, active)) { 
  983. update_rx_stats(&np->stats); /* this will ack the irq */
  984. D(printk("ethernet receiver overrun!n"));
  985. }
  986. /* check for excessive collision irq */
  987. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, excessive_col, active)) { 
  988. *R_NETWORK_TR_CTRL = IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr);
  989. np->stats.tx_errors++;
  990. D(printk("ethernet excessive collisions!n"));
  991. }
  993. }
  995. /* We have a good packet(s), get it/them out of the buffers. */
  996. static void
  997. e100_rx(struct net_device *dev)
  998. {
  999. struct sk_buff *skb;
  1000. int length = 0;
  1001. struct net_local *np = (struct net_local *)dev->priv;
  1002. struct etrax_dma_descr *mySaveRxDesc = myNextRxDesc;
  1003. unsigned char *skb_data_ptr;
  1004. #ifdef ETHDEBUG
  1005. int i;
  1006. #endif
  1008. if (!led_active && jiffies > led_next_time) {
  1009. /* light the network leds depending on the current speed. */
  1010. e100_set_network_leds(NETWORK_ACTIVITY);
  1012. /* Set the earliest time we may clear the LED */
  1013. led_next_time = jiffies + NET_FLASH_TIME;
  1014. led_active = 1;
  1015. mod_timer(&clear_led_timer, jiffies + HZ/10);
  1016. }
  1018. /* If the packet is broken down in many small packages then merge
  1019.  * count how much space we will need to alloc with skb_alloc() for
  1020.  * it to fit.
  1021.  */
  1023. while (!(myNextRxDesc->status & d_eop)) {
  1024. length += myNextRxDesc->sw_len; /* use sw_len for the first descs */
  1025. myNextRxDesc->status = 0;
  1026. myNextRxDesc = phys_to_virt(myNextRxDesc->next);
  1027. }
  1029. length += myNextRxDesc->hw_len; /* use hw_len for the last descr */
  1030. ((struct net_local *)dev->priv)->stats.rx_bytes += length;
  1032. #ifdef ETHDEBUG
  1033. printk("Got a packet of length %d:n", length);
  1034. /* dump the first bytes in the packet */
  1035. skb_data_ptr = (unsigned char *)phys_to_virt(mySaveRxDesc->buf);
  1036. for (i = 0; i < 8; i++) {
  1037. printk("%d: %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2xn", i * 8,
  1038.        skb_data_ptr[0],skb_data_ptr[1],skb_data_ptr[2],skb_data_ptr[3],
  1039.        skb_data_ptr[4],skb_data_ptr[5],skb_data_ptr[6],skb_data_ptr[7]);
  1040. skb_data_ptr += 8;
  1041. }
  1042. #endif
  1044. skb = dev_alloc_skb(length - ETHER_HEAD_LEN);
  1045. if (!skb) {
  1046. np->stats.rx_errors++;
  1047. printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.n",
  1048.        dev->name);
  1049. return;
  1050. }
  1052. skb_put(skb, length - ETHER_HEAD_LEN);        /* allocate room for the packet body */
  1053. skb_data_ptr = skb_push(skb, ETHER_HEAD_LEN); /* allocate room for the header */
  1055. #ifdef ETHDEBUG
  1056. printk("head = 0x%x, data = 0x%x, tail = 0x%x, end = 0x%xn",
  1057.        skb->head, skb->data, skb->tail, skb->end);
  1058. printk("copying packet to 0x%x.n", skb_data_ptr);
  1059. #endif
  1061. /* this loop can be made using max two memcpy's if optimized */
  1063. while (mySaveRxDesc != myNextRxDesc) {
  1064. memcpy(skb_data_ptr, phys_to_virt(mySaveRxDesc->buf),
  1065.        mySaveRxDesc->sw_len);
  1066. skb_data_ptr += mySaveRxDesc->sw_len;
  1067. mySaveRxDesc = phys_to_virt(mySaveRxDesc->next);
  1068. }
  1070. memcpy(skb_data_ptr, phys_to_virt(mySaveRxDesc->buf),
  1071.        mySaveRxDesc->hw_len);
  1073. skb->dev = dev;
  1074. skb->protocol = eth_type_trans(skb, dev);
  1076. /* Send the packet to the upper layers */
  1078. netif_rx(skb);
  1080. /* Prepare for next packet */
  1082. myNextRxDesc->status = 0;
  1083. myPrevRxDesc = myNextRxDesc;
  1084. myNextRxDesc = phys_to_virt(myNextRxDesc->next);
  1086. myPrevRxDesc->ctrl |= d_eol;
  1087. myLastRxDesc->ctrl &= ~d_eol;
  1088. myLastRxDesc = myPrevRxDesc;
  1090. return;
  1091. }
  1093. /* The inverse routine to net_open(). */
  1094. static int
  1095. e100_close(struct net_device *dev)
  1096. {
  1097. struct net_local *np = (struct net_local *)dev->priv;
  1099. printk("Closing %s.n", dev->name);
  1101. netif_stop_queue(dev);
  1103. *R_NETWORK_GEN_CONFIG =
  1104. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  1105. IO_STATE(R_NETWORK_GEN_CONFIG, enable, off);
  1107. *R_IRQ_MASK0_CLR =
  1108. IO_STATE(R_IRQ_MASK0_CLR, overrun, clr) |
  1109. IO_STATE(R_IRQ_MASK0_CLR, underrun, clr) |
  1110. IO_STATE(R_IRQ_MASK0_CLR, excessive_col, clr);
  1112. *R_IRQ_MASK2_CLR =
  1113. IO_STATE(R_IRQ_MASK2_CLR, dma0_descr, clr) |
  1114. IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr) |
  1115. IO_STATE(R_IRQ_MASK2_CLR, dma1_descr, clr) |
  1116. IO_STATE(R_IRQ_MASK2_CLR, dma1_eop, clr);
  1118. /* Stop the receiver and the transmitter */
  1120. RESET_DMA(NETWORK_TX_DMA_NBR);
  1121. RESET_DMA(NETWORK_RX_DMA_NBR);
  1123. /* Flush the Tx and disable Rx here. */
  1125. free_irq(NETWORK_DMA_RX_IRQ_NBR, (void *)dev);
  1126. free_irq(NETWORK_DMA_TX_IRQ_NBR, (void *)dev);
  1127. free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
  1129. free_dma(NETWORK_TX_DMA_NBR);
  1130. free_dma(NETWORK_RX_DMA_NBR);
  1132. /* Update the statistics here. */
  1134. update_rx_stats(&np->stats);
  1135. update_tx_stats(&np->stats);
  1137. return 0;
  1138. }
  1140. static int
  1141. e100_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  1142. {
  1143. /* Maybe default should return -EINVAL instead? */
  1144. switch (cmd) {
  1145. case SET_ETH_SPEED_10:                  /* 10 Mbps */
  1146. e100_set_speed(10);
  1147. break;
  1148. case SET_ETH_SPEED_100:                /* 100 Mbps */
  1149. e100_set_speed(100);
  1150. break;
  1151. case SET_ETH_SPEED_AUTO:              /* Auto negotiate speed */
  1152. e100_set_speed(0);
  1153. break;
  1154. case SET_ETH_DUPLEX_HALF:              /* Hhalf duplex. */
  1155. e100_set_duplex(half);
  1156. break;
  1157. case SET_ETH_DUPLEX_FULL:              /* Full duplex. */
  1158. e100_set_duplex(full);
  1159. break;
  1160. case SET_ETH_DUPLEX_AUTO:             /* Autonegotiate duplex*/
  1161. e100_set_duplex(autoneg);
  1162. break;
  1163. default: /* Auto neg */
  1164. e100_set_speed(0);
  1165. e100_set_duplex(autoneg);
  1166. break;
  1167. }
  1168. return 0;
  1169. }
  1171. static void
  1172. update_rx_stats(struct net_device_stats *es)
  1173. {
  1174. unsigned long r = *R_REC_COUNTERS;
  1175. /* update stats relevant to reception errors */
  1176. es->rx_fifo_errors += IO_EXTRACT(R_REC_COUNTERS, congestion, r);
  1177. es->rx_crc_errors += IO_EXTRACT(R_REC_COUNTERS, crc_error, r);
  1178. es->rx_frame_errors += IO_EXTRACT(R_REC_COUNTERS, alignment_error, r);
  1179. es->rx_length_errors += IO_EXTRACT(R_REC_COUNTERS, oversize, r);
  1180. }
  1182. static void
  1183. update_tx_stats(struct net_device_stats *es)
  1184. {
  1185. unsigned long r = *R_TR_COUNTERS;
  1186. /* update stats relevant to transmission errors */
  1187. es->collisions +=
  1188. IO_EXTRACT(R_TR_COUNTERS, single_col, r) +
  1189. IO_EXTRACT(R_TR_COUNTERS, multiple_col, r);
  1190. es->tx_errors += IO_EXTRACT(R_TR_COUNTERS, deferred, r);
  1191. }
  1193. /*
  1194.  * Get the current statistics.
  1195.  * This may be called with the card open or closed.
  1196.  */
  1197. static struct net_device_stats *
  1198. e100_get_stats(struct net_device *dev)
  1199. {
  1200. struct net_local *lp = (struct net_local *)dev->priv;
  1202. update_rx_stats(&lp->stats);
  1203. update_tx_stats(&lp->stats);
  1205. return &lp->stats;
  1206. }
  1208. /*
  1209.  * Set or clear the multicast filter for this adaptor.
  1210.  * num_addrs == -1 Promiscuous mode, receive all packets
  1211.  * num_addrs == 0 Normal mode, clear multicast list
  1212.  * num_addrs > 0 Multicast mode, receive normal and MC packets,
  1213.  * and do best-effort filtering.
  1214.  */
  1215. static void
  1216. set_multicast_list(struct net_device *dev)
  1217. {
  1218. int num_addr = dev->mc_count;
  1219. unsigned long int lo_bits;
  1220. unsigned long int hi_bits;
  1221. if (dev->flags & IFF_PROMISC)
  1222. {
  1223. /* promiscuous mode */
  1224. lo_bits = 0xfffffffful;
  1225. hi_bits = 0xfffffffful;
  1227. /* Enable individual receive */
  1228. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, receive);
  1229. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  1230. } else if (dev->flags & IFF_ALLMULTI) {
  1231. /* enable all multicasts */
  1232. lo_bits = 0xfffffffful;
  1233. hi_bits = 0xfffffffful;
  1235. /* Disable individual receive */
  1236. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1237. *R_NETWORK_REC_CONFIG =  network_rec_config_shadow;
  1238. } else if (num_addr == 0) {
  1239. /* Normal, clear the mc list */
  1240. lo_bits = 0x00000000ul;
  1241. hi_bits = 0x00000000ul;
  1243. /* Disable individual receive */
  1244. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1245. *R_NETWORK_REC_CONFIG =  network_rec_config_shadow;
  1246. } else {
  1247. /* MC mode, receive normal and MC packets */
  1248. char hash_ix;
  1249. struct dev_mc_list *dmi = dev->mc_list;
  1250. int i;
  1251. char *baddr;
  1252. lo_bits = 0x00000000ul;
  1253. hi_bits = 0x00000000ul;
  1254. for (i=0; i<num_addr; i++) {
  1255. /* Calculate the hash index for the GA registers */
  1257. hash_ix = 0;
  1258. baddr = dmi->dmi_addr;
  1259. hash_ix ^= (*baddr) & 0x3f;
  1260. hash_ix ^= ((*baddr) >> 6) & 0x03;
  1261. ++baddr;
  1262. hash_ix ^= ((*baddr) << 2) & 0x03c;
  1263. hash_ix ^= ((*baddr) >> 4) & 0xf;
  1264. ++baddr;
  1265. hash_ix ^= ((*baddr) << 4) & 0x30;
  1266. hash_ix ^= ((*baddr) >> 2) & 0x3f;
  1267. ++baddr;
  1268. hash_ix ^= (*baddr) & 0x3f;
  1269. hash_ix ^= ((*baddr) >> 6) & 0x03;
  1270. ++baddr;
  1271. hash_ix ^= ((*baddr) << 2) & 0x03c;
  1272. hash_ix ^= ((*baddr) >> 4) & 0xf;
  1273. ++baddr;
  1274. hash_ix ^= ((*baddr) << 4) & 0x30;
  1275. hash_ix ^= ((*baddr) >> 2) & 0x3f;
  1277. hash_ix &= 0x3f;
  1279. if (hash_ix > 32) {
  1280. hi_bits |= (1 << (hash_ix-32));
  1281. }
  1282. else {
  1283. lo_bits |= (1 << hash_ix);
  1284. }
  1285. dmi = dmi->next;
  1286. }
  1287. /* Disable individual receive */
  1288. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1289. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  1290. }
  1291. *R_NETWORK_GA_0 = lo_bits;
  1292. *R_NETWORK_GA_1 = hi_bits;
  1293. }
  1295. void
  1296. e100_hardware_send_packet(char *buf, int length)
  1297. {
  1298. D(printk("e100 send pack, buf 0x%x len %dn", buf, length));
  1300. if (!led_active && jiffies > led_next_time) {
  1301. /* light the network leds depending on the current speed. */
  1302. e100_set_network_leds(NETWORK_ACTIVITY);
  1304. /* Set the earliest time we may clear the LED */
  1305. led_next_time = jiffies + NET_FLASH_TIME;
  1306. led_active = 1;
  1307. mod_timer(&clear_led_timer, jiffies + HZ/10);
  1308. }
  1310. /* configure the tx dma descriptor */
  1312. TxDesc.sw_len = length;
  1313. TxDesc.ctrl = d_eop | d_eol | d_wait;
  1314. TxDesc.buf = virt_to_phys(buf);
  1316. /* setup the dma channel and start it */
  1318. *R_DMA_CH0_FIRST = virt_to_phys(&TxDesc);
  1319. *R_DMA_CH0_CMD = IO_STATE(R_DMA_CH0_CMD, cmd, start);
  1320. }
  1322. static void
  1323. e100_clear_network_leds(unsigned long dummy)
  1324. {
  1325. if (led_active && jiffies > led_next_time) {
  1326. e100_set_network_leds(NO_NETWORK_ACTIVITY);
  1328. /* Set the earliest time we may set the LED */
  1329. led_next_time = jiffies + NET_FLASH_PAUSE;
  1330. led_active = 0;
  1331. }
  1332. }
  1334. static void
  1335. e100_set_network_leds(int active)
  1336. {
  1337. #if defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK)
  1338. int light_leds = (active == NO_NETWORK_ACTIVITY);
  1339. #elif defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY)
  1340. int light_leds = (active == NETWORK_ACTIVITY);
  1341. #else
  1342. #error "Define either CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK or CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY"
  1343. #endif
  1345. if (!current_speed) {
  1346. /* Make LED red, link is down */
  1347. LED_NETWORK_SET(LED_RED);
  1348. }
  1349. else if (light_leds) {
  1350. if (current_speed == 10) {
  1351. LED_NETWORK_SET(LED_ORANGE);
  1352. } else {
  1353. LED_NETWORK_SET(LED_GREEN);
  1354. }
  1355. }
  1356. else {
  1357. LED_NETWORK_SET(LED_OFF);
  1358. }
  1359. }
  1361. static struct net_device dev_etrax_ethernet;  /* only got one */
  1363. static int
  1364. etrax_init_module(void)
  1365. {
  1366. struct net_device *d = &dev_etrax_ethernet;
  1368. d->init = etrax_ethernet_init;
  1370. if (register_netdev(d) == 0)
  1371. return 0;
  1372. else
  1373. return -ENODEV;
  1374. }
  1376. module_init(etrax_init_module);