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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ethernet.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：41k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ethernet.c：源码内容
  1. /* $Id: ethernet.c,v 1.30 2002/05/07 18:50:08 johana Exp $
  2.  *
  3.  * e100net.c: A network driver for the ETRAX 100LX network controller.
  4.  *
  5.  * Copyright (c) 1998-2002 Axis Communications AB.
  6.  *
  7.  * The outline of this driver comes from skeleton.c.
  8.  *
  9.  * $Log: ethernet.c,v $
  10.  * Revision 1.30  2002/05/07 18:50:08  johana
  11.  * Correct spelling in comments.
  12.  *
  13.  * Revision 1.29  2002/05/06 05:38:49  starvik
  14.  * Performance improvements:
  15.  *    Large packets are not copied (breakpoint set to 256 bytes)
  16.  *    The cache bug workaround is delayed until half of the receive list
  17.  *      has been used
  18.  *    Added transmit list
  19.  *    Transmit interrupts are only enabled when transmit queue is full
  20.  *
  21.  * Revision 1.28.2.1  2002/04/30 08:15:51  starvik
  22.  * Performance improvements:
  23.  *   Large packets are not copied (breakpoint set to 256 bytes)
  24.  *   The cache bug workaround is delayed until half of the receive list
  25.  *     has been used.
  26.  *   Added transmit list
  27.  *   Transmit interrupts are only enabled when transmit queue is full
  28.  *
  29.  * Revision 1.28  2002/04/22 11:47:21  johana
  30.  * Fix according to 2.4.19-pre7. time_after/time_before and
  31.  * missing end of comment.
  32.  * The patch has a typo for ethernet.c in e100_clear_network_leds(),
  33.  *  that is fixed here.
  34.  *
  35.  * Revision 1.27  2002/04/12 11:55:11  bjornw
  36.  * Added TODO
  37.  *
  38.  * Revision 1.26  2002/03/15 17:11:02  bjornw
  39.  * Use prepare_rx_descriptor after the CPU has touched the receiving descs
  40.  *
  41.  * Revision 1.25  2002/03/08 13:07:53  bjornw
  42.  * Unnecessary spinlock removed
  43.  *
  44.  * Revision 1.24  2002/02/20 12:57:43  fredriks
  45.  * Replaced MIN() with min().
  46.  *
  47.  * Revision 1.23  2002/02/20 10:58:14  fredriks
  48.  * Strip the Ethernet checksum (4 bytes) before forwarding a frame to upper layers.
  49.  *
  50.  * Revision 1.22  2002/01/30 07:48:22  matsfg
  51.  * Initiate R_NETWORK_TR_CTRL
  52.  *
  53.  * Revision 1.21  2001/11/23 11:54:49  starvik
  54.  * Added IFF_PROMISC and IFF_ALLMULTI handling in set_multicast_list
  55.  * Removed compiler warnings
  56.  *
  57.  * Revision 1.20  2001/11/12 19:26:00  pkj
  58.  * * Corrected e100_negotiate() to not assign half to current_duplex when
  59.  *   it was supposed to compare them...
  60.  * * Cleaned up failure handling in e100_open().
  61.  * * Fixed compiler warnings.
  62.  *
  63.  * Revision 1.19  2001/11/09 07:43:09  starvik
  64.  * Added full duplex support
  65.  * Added ioctl to set speed and duplex
  66.  * Clear LED timer only runs when LED is lit
  67.  *
  68.  * Revision 1.18  2001/10/03 14:40:43  jonashg
  69.  * Update rx_bytes counter.
  70.  *
  71.  * Revision 1.17  2001/06/11 12:43:46  olof
  72.  * Modified defines for network LED behavior
  73.  *
  74.  * Revision 1.16  2001/05/30 06:12:46  markusl
  75.  * TxDesc.next should not be set to NULL
  76.  *
  77.  * Revision 1.15  2001/05/29 10:27:04  markusl
  78.  * Updated after review remarks:
  79.  * +Use IO_EXTRACT
  80.  * +Handle underrun
  81.  *
  82.  * Revision 1.14  2001/05/29 09:20:14  jonashg
  83.  * Use driver name on printk output so one can tell which driver that complains.
  84.  *
  85.  * Revision 1.13  2001/05/09 12:35:59  johana
  86.  * Use DMA_NBR and IRQ_NBR defines from dma.h and irq.h
  87.  *
  88.  * Revision 1.12  2001/04/05 11:43:11  tobiasa
  89.  * Check dev before panic.
  90.  *
  91.  * Revision 1.11  2001/04/04 11:21:05  markusl
  92.  * Updated according to review remarks
  93.  *
  94.  * Revision 1.10  2001/03/26 16:03:06  bjornw
  95.  * Needs linux/config.h
  96.  *
  97.  * Revision 1.9  2001/03/19 14:47:48  pkj
  98.  * * Make sure there is always a pause after the network LEDs are
  99.  *   changed so they will not look constantly lit during heavy traffic.
  100.  * * Always use HZ when setting times relative to jiffies.
  101.  * * Use LED_NETWORK_SET() when setting the network LEDs.
  102.  *
  103.  * Revision 1.8  2001/02/27 13:52:48  bjornw
  104.  * malloc.h -> slab.h
  105.  *
  106.  * Revision 1.7  2001/02/23 13:46:38  bjornw
  107.  * Spellling check
  108.  *
  109.  * Revision 1.6  2001/01/26 15:21:04  starvik
  110.  * Don't disable interrupts while reading MDIO registers (MDIO is slow)
  111.  * Corrected promiscuous mode
  112.  * Improved deallocation of IRQs ("ifconfig eth0 down" now works)
  113.  *
  114.  * Revision 1.5  2000/11/29 17:22:22  bjornw
  115.  * Get rid of the udword types legacy stuff
  116.  *
  117.  * Revision 1.4  2000/11/22 16:36:09  bjornw
  118.  * Please marketing by using the correct case when spelling Etrax.
  119.  *
  120.  * Revision 1.3  2000/11/21 16:43:04  bjornw
  121.  * Minor short->int change
  122.  *
  123.  * Revision 1.2  2000/11/08 14:27:57  bjornw
  124.  * 2.4 port
  125.  *
  126.  * Revision 1.1  2000/11/06 13:56:00  bjornw
  127.  * Verbatim copy of the 1.24 version of e100net.c from elinux
  128.  *
  129.  * Revision 1.24  2000/10/04 15:55:23  bjornw
  130.  * * Use virt_to_phys etc. for DMA addresses
  131.  * * Removed bogus CHECKSUM_UNNECESSARY
  132.  *
  133.  *
  134.  */
  136. #include <linux/config.h>
  138. #include <linux/module.h>
  140. #include <linux/kernel.h>
  141. #include <linux/sched.h>
  142. #include <linux/delay.h>
  143. #include <linux/types.h>
  144. #include <linux/fcntl.h>
  145. #include <linux/interrupt.h>
  146. #include <linux/ptrace.h>
  147. #include <linux/ioport.h>
  148. #include <linux/in.h>
  149. #include <linux/slab.h>
  150. #include <linux/string.h>
  151. #include <linux/spinlock.h>
  152. #include <linux/errno.h>
  153. #include <linux/init.h>
  155. #include <linux/netdevice.h>
  156. #include <linux/etherdevice.h>
  157. #include <linux/skbuff.h>
  159. #include <asm/svinto.h>     /* DMA and register descriptions */
  160. #include <asm/io.h>         /* LED_* I/O functions */
  161. #include <asm/irq.h>
  162. #include <asm/dma.h>
  163. #include <asm/system.h>
  164. #include <asm/bitops.h>
  165. #include <asm/ethernet.h>
  167. //#define ETHDEBUG
  168. #define D(x)
  170. /*
  171.  * The name of the card. Is used for messages and in the requests for
  172.  * io regions, irqs and dma channels
  173.  */
  175. static const char* cardname = "ETRAX 100LX built-in ethernet controller";
  177. /* A default ethernet address. Highlevel SW will set the real one later */
  179. static struct sockaddr default_mac = {
  180. 0,
  181. { 0x00, 0x40, 0x8C, 0xCD, 0x00, 0x00 }
  182. };
  184. /* Information that need to be kept for each board. */
  185. struct net_local {
  186. struct net_device_stats stats;
  188. /* Tx control lock.  This protects the transmit buffer ring
  189.  * state along with the "tx full" state of the driver.  This
  190.  * means all netif_queue flow control actions are protected
  191.  * by this lock as well.
  192.  */
  193. spinlock_t lock;
  194. };
  196. typedef struct etrax_eth_descr
  197. {
  198. etrax_dma_descr descr;
  199. struct sk_buff* skb;
  200. } etrax_eth_descr;
  202. /* Duplex settings */
  203. enum duplex
  204. {
  205. half,
  206. full,
  207. autoneg
  208. };
  210. /* Dma descriptors etc. */
  212. #define MAX_MEDIA_DATA_SIZE 1518
  214. #define MIN_PACKET_LEN      46
  215. #define ETHER_HEAD_LEN      14
  217. /* 
  218. ** MDIO constants.
  219. */
  220. #define MDIO_BASE_STATUS_REG                0x1
  221. #define MDIO_BASE_CONTROL_REG               0x0
  222. #define MDIO_BC_NEGOTIATE                0x0200
  223. #define MDIO_BC_FULL_DUPLEX_MASK         0x0100
  224. #define MDIO_BC_AUTO_NEG_MASK            0x1000
  225. #define MDIO_BC_SPEED_SELECT_MASK        0x2000
  226. #define MDIO_ADVERTISMENT_REG               0x4
  227. #define MDIO_ADVERT_100_FD                0x100
  228. #define MDIO_ADVERT_100_HD                0x080
  229. #define MDIO_ADVERT_10_FD                 0x040
  230. #define MDIO_ADVERT_10_HD                 0x020
  231. #define MDIO_LINK_UP_MASK                   0x4
  232. #define MDIO_START                          0x1
  233. #define MDIO_READ                           0x2
  234. #define MDIO_WRITE                          0x1
  235. #define MDIO_PREAMBLE              0xfffffffful
  237. /* Broadcom specific */
  238. #define MDIO_AUX_CTRL_STATUS_REG           0x18
  239. #define MDIO_FULL_DUPLEX_IND                0x1
  240. #define MDIO_SPEED                          0x2
  241. #define MDIO_PHYS_ADDR                      0x0
  243. /* Network flash constants */
  244. #define NET_FLASH_TIME                  (HZ/50) /* 20 ms */
  245. #define NET_FLASH_PAUSE                (HZ/100) /* 10 ms */
  246. #define NET_LINK_UP_CHECK_INTERVAL       (2*HZ) /* 2 s   */
  247. #define NET_DUPLEX_CHECK_INTERVAL        (2*HZ) /* 2 s   */
  249. #define NO_NETWORK_ACTIVITY 0
  250. #define NETWORK_ACTIVITY    1
  252. #define NBR_OF_RX_DESC     64
  253. #define NBR_OF_TX_DESC     256
  255. /* Large packets are sent directly to upper layers while small packets are */
  256. /* copied (to reduce memory waste). The following constant decides the breakpoint */
  257. #define RX_COPYBREAK 256
  259. /* Due to a chip bug we need to flush the cache when descriptors are returned */
  260. /* to the DMA. To decrease performance impact we return descriptors in chunks. */
  261. /* The following constant determines the number of descriptors to return. */
  262. #define RX_QUEUE_THRESHOLD  NBR_OF_RX_DESC/2
  264. #define GET_BIT(bit,val)   (((val) >> (bit)) & 0x01)
  266. /* Define some macros to access ETRAX 100 registers */
  267. #define SETF(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  268.   IO_FIELD(##reg##, field, val)
  269. #define SETS(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  270.   IO_STATE(##reg##, field, val)
  272. static etrax_eth_descr *myNextRxDesc;  /* Points to the next descriptor to
  273.                                           to be processed */
  274. static etrax_eth_descr *myLastRxDesc;  /* The last processed descriptor */
  275. static etrax_eth_descr *myPrevRxDesc;  /* The descriptor right before myNextRxDesc */
  277. static etrax_eth_descr RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned(32)));
  279. static etrax_eth_descr* myFirstTxDesc; /* First packet not yet sent */
  280. static etrax_eth_descr* myLastTxDesc;  /* End of send queue */
  281. static etrax_eth_descr* myNextTxDesc;  /* Next descriptor to use */
  282. static etrax_eth_descr TxDescList[NBR_OF_TX_DESC] __attribute__ ((aligned(32)));
  284. static unsigned int network_rec_config_shadow = 0;
  286. /* Network speed indication. */
  287. static struct timer_list speed_timer;
  288. static struct timer_list clear_led_timer;
  289. static int current_speed; /* Speed read from tranceiver */
  290. static int current_speed_selection; /* Speed selected by user */
  291. static int led_next_time;
  292. static int led_active;
  293. static int rx_queue_len;
  295. /* Duplex */
  296. static struct timer_list duplex_timer;
  297. static int full_duplex;
  298. static enum duplex current_duplex;
  300. /* Index to functions, as function prototypes. */
  302. static int etrax_ethernet_init(struct net_device *dev);
  304. static int e100_open(struct net_device *dev);
  305. static int e100_set_mac_address(struct net_device *dev, void *addr);
  306. static int e100_send_packet(struct sk_buff *skb, struct net_device *dev);
  307. static void e100rx_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  308. static void e100tx_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  309. static void e100nw_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  310. static void e100_rx(struct net_device *dev);
  311. static int e100_close(struct net_device *dev);
  312. static int e100_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
  313. static void e100_tx_timeout(struct net_device *dev);
  314. static struct net_device_stats *e100_get_stats(struct net_device *dev);
  315. static void set_multicast_list(struct net_device *dev);
  316. static void e100_hardware_send_packet(char *buf, int length);
  317. static void update_rx_stats(struct net_device_stats *);
  318. static void update_tx_stats(struct net_device_stats *);
  320. static void e100_check_speed(unsigned long dummy);
  321. static void e100_set_speed(unsigned long speed);
  322. static void e100_check_duplex(unsigned long dummy);
  323. static void e100_set_duplex(enum duplex);
  324. static void e100_negotiate(void);
  326. static unsigned short e100_get_mdio_reg(unsigned char reg_num);
  327. static void e100_send_mdio_cmd(unsigned short cmd, int write_cmd);
  328. static void e100_send_mdio_bit(unsigned char bit);
  329. static unsigned char e100_receive_mdio_bit(void);
  330. static void e100_reset_tranceiver(void);
  332. static void e100_clear_network_leds(unsigned long dummy);
  333. static void e100_set_network_leds(int active);
  335. #define tx_done(dev) (*R_DMA_CH0_CMD == 0)
  337. /*
  338.  * Check for a network adaptor of this type, and return '0' if one exists.
  339.  * If dev->base_addr == 0, probe all likely locations.
  340.  * If dev->base_addr == 1, always return failure.
  341.  * If dev->base_addr == 2, allocate space for the device and return success
  342.  * (detachable devices only).
  343.  */
  345. static int __init
  346. etrax_ethernet_init(struct net_device *dev)
  347. {
  348. int i;
  350. printk("ETRAX 100LX 10/100MBit ethernet v2.0 (c) 2000-2001 Axis Communications ABn");
  352. dev->base_addr = (unsigned int)R_NETWORK_SA_0; /* just to have something to show */
  354. printk("%s initializedn", dev->name);
  356. /* make Linux aware of the new hardware  */
  358. if (!dev) {
  359. printk(KERN_WARNING "%s: dev == NULL. Should this happen?n",
  360.        cardname);
  361. dev = init_etherdev(dev, sizeof(struct net_local));
  362. if (!dev)
  363. panic("init_etherdev failedn");
  364. }
  366. /* setup generic handlers and stuff in the dev struct */
  368. ether_setup(dev);
  370. /* make room for the local structure containing stats etc */
  372. dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
  373. if (dev->priv == NULL)
  374. return -ENOMEM;
  375. memset(dev->priv, 0, sizeof(struct net_local));
  377. /* now setup our etrax specific stuff */
  379. dev->irq = NETWORK_DMA_RX_IRQ_NBR; /* we really use DMATX as well... */
  380. dev->dma = NETWORK_RX_DMA_NBR;
  382. /* fill in our handlers so the network layer can talk to us in the future */
  384. dev->open               = e100_open;
  385. dev->hard_start_xmit    = e100_send_packet;
  386. dev->stop               = e100_close;
  387. dev->get_stats          = e100_get_stats;
  388. dev->set_multicast_list = set_multicast_list;
  389. dev->set_mac_address    = e100_set_mac_address;
  390. dev->do_ioctl           = e100_ioctl;
  391. dev->tx_timeout         = e100_tx_timeout;
  393. /* set the default MAC address */
  395. e100_set_mac_address(dev, &default_mac);
  397. /* Initialise the list of Etrax DMA-descriptors */
  399. /* Initialise receive descriptors */
  401. for (i = 0; i < NBR_OF_RX_DESC; i++) {
  402. RxDescList[i].skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
  403. RxDescList[i].descr.ctrl   = 0;
  404. RxDescList[i].descr.sw_len = MAX_MEDIA_DATA_SIZE;
  405. RxDescList[i].descr.next   = virt_to_phys(&RxDescList[i + 1]);
  406. RxDescList[i].descr.buf    = virt_to_phys(RxDescList[i].skb->data);
  407. RxDescList[i].descr.status = 0;
  408. RxDescList[i].descr.hw_len = 0;
  409.              
  410. prepare_rx_descriptor(&RxDescList[i].descr);
  411. }
  413. RxDescList[NBR_OF_RX_DESC - 1].descr.ctrl   = d_eol;
  414. RxDescList[NBR_OF_RX_DESC - 1].descr.next   = virt_to_phys(&RxDescList[0]);
  415. rx_queue_len = 0;
  417. /* Initialize transmit descriptors */
  418. for (i = 0; i < NBR_OF_TX_DESC; i++) {
  419. TxDescList[i].descr.ctrl   = 0;
  420. TxDescList[i].descr.sw_len = 0;
  421. TxDescList[i].descr.next   = virt_to_phys(&TxDescList[i + 1].descr);
  422. TxDescList[i].descr.buf    = 0;
  423. TxDescList[i].descr.status = 0;
  424. TxDescList[i].descr.hw_len = 0;
  425. TxDescList[i].skb = 0;
  426. }
  428. TxDescList[NBR_OF_TX_DESC - 1].descr.ctrl   = d_eol;
  429. TxDescList[NBR_OF_TX_DESC - 1].descr.next   = virt_to_phys(&TxDescList[0].descr);
  430.         
  431. /* Initialise initial pointers */
  433. myNextRxDesc  = &RxDescList[0];
  434. myLastRxDesc  = &RxDescList[NBR_OF_RX_DESC - 1];
  435. myPrevRxDesc  = &RxDescList[NBR_OF_RX_DESC - 1];
  436. myFirstTxDesc = &TxDescList[0];
  437. myNextTxDesc  = &TxDescList[0];
  438. myLastTxDesc  = &TxDescList[NBR_OF_TX_DESC - 1];
  440. /* Initialize speed indicator stuff. */
  442. current_speed = 10;
  443. current_speed_selection = 0; /* Auto */
  444. speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
  445. speed_timer.function = e100_check_speed;
  446. add_timer(&speed_timer);
  447.         
  448. clear_led_timer.function = e100_clear_network_leds;
  449.         
  450. full_duplex = 0;
  451. current_duplex = autoneg;
  452. duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
  453. duplex_timer.function = e100_check_duplex;
  454. add_timer(&duplex_timer);
  456. return 0;
  457. }
  459. /* set MAC address of the interface. called from the core after a
  460.  * SIOCSIFADDR ioctl, and from the bootup above.
  461.  */
  463. static int
  464. e100_set_mac_address(struct net_device *dev, void *p)
  465. {
  466. struct sockaddr *addr = p;
  467. int i;
  469. /* remember it */
  471. memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
  473. /* Write it to the hardware.
  474.  * Note the way the address is wrapped:
  475.  * *R_NETWORK_SA_0 = a0_0 | (a0_1 << 8) | (a0_2 << 16) | (a0_3 << 24);
  476.  * *R_NETWORK_SA_1 = a0_4 | (a0_5 << 8);
  477.  */
  479. *R_NETWORK_SA_0 = dev->dev_addr[0] | (dev->dev_addr[1] << 8) |
  480. (dev->dev_addr[2] << 16) | (dev->dev_addr[3] << 24);
  481. *R_NETWORK_SA_1 = dev->dev_addr[4] | (dev->dev_addr[5] << 8);
  482. *R_NETWORK_SA_2 = 0;
  484. /* show it in the log as well */
  486. printk("%s: changed MAC to ", dev->name);
  488. for (i = 0; i < 5; i++)
  489. printk("%02X:", dev->dev_addr[i]);
  491. printk("%02Xn", dev->dev_addr[i]);
  493. return 0;
  494. }
  496. /*
  497.  * Open/initialize the board. This is called (in the current kernel)
  498.  * sometime after booting when the 'ifconfig' program is run.
  499.  *
  500.  * This routine should set everything up anew at each open, even
  501.  * registers that "should" only need to be set once at boot, so that
  502.  * there is non-reboot way to recover if something goes wrong.
  503.  */
  505. static int
  506. e100_open(struct net_device *dev)
  507. {
  508. unsigned long flags;
  510. /* disable the ethernet interface while we configure it */
  512. *R_NETWORK_GEN_CONFIG =
  513. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  514. IO_STATE(R_NETWORK_GEN_CONFIG, enable, off);
  516. /* enable the MDIO output pin */
  518. *R_NETWORK_MGM_CTRL = IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable);
  520. *R_IRQ_MASK0_CLR =
  521. IO_STATE(R_IRQ_MASK0_CLR, overrun, clr) |
  522. IO_STATE(R_IRQ_MASK0_CLR, underrun, clr) |
  523. IO_STATE(R_IRQ_MASK0_CLR, excessive_col, clr);
  525. /* clear dma0 and 1 eop and descr irq masks */
  526. *R_IRQ_MASK2_CLR =
  527. IO_STATE(R_IRQ_MASK2_CLR, dma0_descr, clr) |
  528. IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr) |
  529. IO_STATE(R_IRQ_MASK2_CLR, dma1_descr, clr) |
  530. IO_STATE(R_IRQ_MASK2_CLR, dma1_eop, clr);
  532. /* Reset and wait for the DMA channels */
  534. RESET_DMA(NETWORK_TX_DMA_NBR);
  535. RESET_DMA(NETWORK_RX_DMA_NBR);
  536. WAIT_DMA(NETWORK_TX_DMA_NBR);
  537. WAIT_DMA(NETWORK_RX_DMA_NBR);
  539. /* Initialise the etrax network controller */
  541. /* allocate the irq corresponding to the receiving DMA */
  543. if (request_irq(NETWORK_DMA_RX_IRQ_NBR, e100rx_interrupt, 0,
  544. cardname, (void *)dev)) {
  545. goto grace_exit0;
  546. }
  548. /* allocate the irq corresponding to the transmitting DMA */
  550. if (request_irq(NETWORK_DMA_TX_IRQ_NBR, e100tx_interrupt, 0,
  551. cardname, (void *)dev)) {
  552. goto grace_exit1;
  553. }
  555. /* allocate the irq corresponding to the network errors etc */
  557. if (request_irq(NETWORK_STATUS_IRQ_NBR, e100nw_interrupt, 0,
  558. cardname, (void *)dev)) {
  559. goto grace_exit2;
  560. }
  562. /*
  563.  * Always allocate the DMA channels after the IRQ,
  564.  * and clean up on failure.
  565.  */
  567. if (request_dma(NETWORK_TX_DMA_NBR, cardname)) {
  568. goto grace_exit3;
  569. }
  571. if (request_dma(NETWORK_RX_DMA_NBR, cardname)) {
  572. goto grace_exit4;
  573. }
  575. /* give the HW an idea of what MAC address we want */
  577. *R_NETWORK_SA_0 = dev->dev_addr[0] | (dev->dev_addr[1] << 8) |
  578. (dev->dev_addr[2] << 16) | (dev->dev_addr[3] << 24);
  579. *R_NETWORK_SA_1 = dev->dev_addr[4] | (dev->dev_addr[5] << 8);
  580. *R_NETWORK_SA_2 = 0;
  582. #if 0
  583. /* use promiscuous mode for testing */
  584. *R_NETWORK_GA_0 = 0xffffffff;
  585. *R_NETWORK_GA_1 = 0xffffffff;
  587. *R_NETWORK_REC_CONFIG = 0xd; /* broadcast rec, individ. rec, ma0 enabled */
  588. #else
  589. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, broadcast, receive);
  590. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, ma0, enable);
  591. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  592. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  593. #endif
  595. *R_NETWORK_GEN_CONFIG =
  596. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  597. IO_STATE(R_NETWORK_GEN_CONFIG, enable, on);
  599. *R_NETWORK_TR_CTRL = 
  600. IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr) |
  601. IO_STATE(R_NETWORK_TR_CTRL, delay, none) |
  602. IO_STATE(R_NETWORK_TR_CTRL, cancel, dont) |
  603. IO_STATE(R_NETWORK_TR_CTRL, cd, enable) |
  604. IO_STATE(R_NETWORK_TR_CTRL, retry, enable) |
  605. IO_STATE(R_NETWORK_TR_CTRL, pad, enable) |
  606. IO_STATE(R_NETWORK_TR_CTRL, crc, enable);
  608. save_flags(flags);
  609. cli();
  611. /* enable the irq's for ethernet DMA */
  613. *R_IRQ_MASK2_SET =
  614. IO_STATE(R_IRQ_MASK2_SET, dma1_eop, set); 
  616. *R_IRQ_MASK0_SET =
  617. IO_STATE(R_IRQ_MASK0_SET, overrun,       set) |
  618. IO_STATE(R_IRQ_MASK0_SET, underrun,      set) |
  619. IO_STATE(R_IRQ_MASK0_SET, excessive_col, set);
  621. /* make sure the irqs are cleared */
  623. *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
  624. *R_DMA_CH1_CLR_INTR = IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do);
  626. /* make sure the rec and transmit error counters are cleared */
  628. (void)*R_REC_COUNTERS;  /* dummy read */
  629. (void)*R_TR_COUNTERS;   /* dummy read */
  631. /* start the receiving DMA channel so we can receive packets from now on */
  633. *R_DMA_CH1_FIRST = virt_to_phys(myNextRxDesc);
  634. *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, start);
  636. /* Set up transmit DMA channel so it can be restarted later */
  637.         
  638. *R_DMA_CH0_FIRST = 0;
  639. *R_DMA_CH0_DESCR = virt_to_phys(myLastTxDesc);
  641. restore_flags(flags);
  643. /* We are now ready to accept transmit requeusts from
  644.  * the queueing layer of the networking.
  645.  */
  646. netif_start_queue(dev);
  648. return 0;
  650. grace_exit4:
  651. free_dma(NETWORK_TX_DMA_NBR);
  652. grace_exit3:
  653. free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
  654. grace_exit2:
  655. free_irq(NETWORK_DMA_TX_IRQ_NBR, (void *)dev);
  656. grace_exit1:
  657. free_irq(NETWORK_DMA_RX_IRQ_NBR, (void *)dev);
  658. grace_exit0:
  659. return -EAGAIN;
  660. }
  663. static void
  664. e100_check_speed(unsigned long dummy)
  665. {
  666. unsigned long data;
  667. int old_speed = current_speed;
  669. data = e100_get_mdio_reg(MDIO_BASE_STATUS_REG);
  670. if (!(data & MDIO_LINK_UP_MASK)) {
  671. current_speed = 0;
  672. } else {
  673. data = e100_get_mdio_reg(MDIO_AUX_CTRL_STATUS_REG);
  674. current_speed = (data & MDIO_SPEED ? 100 : 10);
  675. }
  677. if (old_speed != current_speed)
  678. e100_set_network_leds(NO_NETWORK_ACTIVITY);
  680. /* Reinitialize the timer. */
  681. speed_timer.expires = jiffies + NET_LINK_UP_CHECK_INTERVAL;
  682. add_timer(&speed_timer);
  683. }
  685. static void
  686. e100_negotiate(void)
  687. {
  688. unsigned short cmd;
  689. unsigned short data = e100_get_mdio_reg(MDIO_ADVERTISMENT_REG);
  690. int bitCounter;
  692. /* Discard old speed and duplex settings */
  693. data &= ~(MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | 
  694.           MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD);
  695.   
  696. switch (current_speed_selection) {
  697. case 10 :
  698. if (current_duplex == full)
  699. data |= MDIO_ADVERT_10_FD;
  700. else if (current_duplex == half)
  701. data |= MDIO_ADVERT_10_HD;
  702. else
  703. data |= MDIO_ADVERT_10_HD |  MDIO_ADVERT_10_FD;
  704. break;
  706. case 100 :
  707.  if (current_duplex == full)
  708. data |= MDIO_ADVERT_100_FD;
  709. else if (current_duplex == half)
  710. data |= MDIO_ADVERT_100_HD;
  711. else
  712. data |= MDIO_ADVERT_100_HD |  MDIO_ADVERT_100_FD;
  713. break;
  715. case 0 : /* Auto */
  716.  if (current_duplex == full)
  717. data |= MDIO_ADVERT_100_FD | MDIO_ADVERT_10_FD;
  718. else if (current_duplex == half)
  719. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_10_HD;
  720. else
  721. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD;
  722. break;
  724. default : /* assume autoneg speed and duplex */
  725. data |= MDIO_ADVERT_100_HD | MDIO_ADVERT_100_FD | 
  726.         MDIO_ADVERT_10_FD | MDIO_ADVERT_10_HD;
  727. }
  729. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) |
  730.       (MDIO_ADVERTISMENT_REG<< 2);
  732. e100_send_mdio_cmd(cmd, 1);
  734. /* Data... */
  735. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  736. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  737. }
  739. /* Renegotiate with link partner */
  740. data = e100_get_mdio_reg(MDIO_BASE_CONTROL_REG);
  741. data |= MDIO_BC_NEGOTIATE;
  743. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) |
  744.       (MDIO_BASE_CONTROL_REG<< 2);
  746. e100_send_mdio_cmd(cmd, 1);
  748. /* Data... */
  749. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  750. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  751. }  
  752. }
  754. static void
  755. e100_set_speed(unsigned long speed)
  756. {
  757. current_speed_selection = speed;
  758. e100_negotiate();
  759. }
  761. static void
  762. e100_check_duplex(unsigned long dummy)
  763. {
  764. unsigned long data;
  766. data = e100_get_mdio_reg(MDIO_AUX_CTRL_STATUS_REG);
  767.         
  768. if (data & MDIO_FULL_DUPLEX_IND) {
  769. if (!full_duplex) { /* Duplex changed to full? */
  770. full_duplex = 1;
  771. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  772. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  773. }
  774. } else { /* half */
  775. if (full_duplex) { /* Duplex changed to half? */
  776. full_duplex = 0;
  777. SETF(network_rec_config_shadow, R_NETWORK_REC_CONFIG, duplex, full_duplex);
  778. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  779. }
  780. }
  782. /* Reinitialize the timer. */
  783. duplex_timer.expires = jiffies + NET_DUPLEX_CHECK_INTERVAL;
  784. add_timer(&duplex_timer);
  785. }
  787. static void 
  788. e100_set_duplex(enum duplex new_duplex)
  789. {
  790. current_duplex = new_duplex;
  791. e100_negotiate();
  792. }
  795. static unsigned short
  796. e100_get_mdio_reg(unsigned char reg_num)
  797. {
  798. unsigned short cmd;    /* Data to be sent on MDIO port */
  799. unsigned short data;   /* Data read from MDIO */
  800. int bitCounter;
  802. /* Start of frame, OP Code, Physical Address, Register Address */
  803. cmd = (MDIO_START << 14) | (MDIO_READ << 12) | (MDIO_PHYS_ADDR << 7) |
  804. (reg_num << 2);
  806. e100_send_mdio_cmd(cmd, 0);
  808. data = 0;
  810. /* Data... */
  811. for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
  812. data |= (e100_receive_mdio_bit() << bitCounter);
  813. }
  815. return data;
  816. }
  818. static void
  819. e100_send_mdio_cmd(unsigned short cmd, int write_cmd)
  820. {
  821. int bitCounter;
  822. unsigned char data = 0x2;
  824. /* Preamble */
  825. for (bitCounter = 31; bitCounter>= 0; bitCounter--)
  826. e100_send_mdio_bit(GET_BIT(bitCounter, MDIO_PREAMBLE));
  828. for (bitCounter = 15; bitCounter >= 2; bitCounter--)
  829. e100_send_mdio_bit(GET_BIT(bitCounter, cmd));
  831. /* Turnaround */
  832. for (bitCounter = 1; bitCounter >= 0 ; bitCounter--)
  833. if (write_cmd)
  834. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  835. else
  836. e100_receive_mdio_bit();
  837. }
  839. static void
  840. e100_send_mdio_bit(unsigned char bit)
  841. {
  842. *R_NETWORK_MGM_CTRL =
  843. IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
  844. IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
  845. udelay(1);
  846. *R_NETWORK_MGM_CTRL =
  847. IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
  848. IO_MASK(R_NETWORK_MGM_CTRL, mdck) |
  849. IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
  850. udelay(1);
  851. }
  853. static unsigned char
  854. e100_receive_mdio_bit()
  855. {
  856. unsigned char bit;
  857. *R_NETWORK_MGM_CTRL = 0;
  858. bit = IO_EXTRACT(R_NETWORK_STAT, mdio, *R_NETWORK_STAT);
  859. udelay(1);
  860. *R_NETWORK_MGM_CTRL = IO_MASK(R_NETWORK_MGM_CTRL, mdck);
  861. udelay(1);
  862. return bit;
  863. }
  865. static void 
  866. e100_reset_tranceiver(void)
  867. {
  868. unsigned short cmd;
  869. unsigned short data;
  870. int bitCounter;
  872. data = e100_get_mdio_reg(MDIO_BASE_CONTROL_REG);
  874. cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) | (MDIO_BASE_CONTROL_REG << 2);
  876. e100_send_mdio_cmd(cmd, 1);
  878. data |= 0x8000;
  880. for (bitCounter = 15; bitCounter >= 0 ; bitCounter--) {
  881. e100_send_mdio_bit(GET_BIT(bitCounter, data));
  882. }
  883. }
  885. /* Called by upper layers if they decide it took too long to complete
  886.  * sending a packet - we need to reset and stuff.
  887.  */
  889. static void
  890. e100_tx_timeout(struct net_device *dev)
  891. {
  892. struct net_local *np = (struct net_local *)dev->priv;
  894. printk(KERN_WARNING "%s: transmit timed out, %s?n", dev->name,
  895.        tx_done(dev) ? "IRQ problem" : "network cable problem");
  897. /* remember we got an error */
  899. np->stats.tx_errors++; 
  901. /* reset the TX DMA in case it has hung on something */
  903. RESET_DMA(NETWORK_TX_DMA_NBR);
  904. WAIT_DMA(NETWORK_TX_DMA_NBR);
  906. /* Reset the tranceiver. */
  908. e100_reset_tranceiver();
  910. /* and get rid of the packets that never got an interrupt */
  911. while (myFirstTxDesc != myNextTxDesc)
  912. {
  913. dev_kfree_skb(myFirstTxDesc->skb);
  914. myFirstTxDesc->skb = 0;
  915. myFirstTxDesc = phys_to_virt(myFirstTxDesc->descr.next);
  916. }
  918. /* Set up transmit DMA channel so it can be restarted later */
  919. *R_DMA_CH0_FIRST = 0;
  920. *R_DMA_CH0_DESCR = virt_to_phys(myLastTxDesc);
  922. /* tell the upper layers we're ok again */
  924. netif_wake_queue(dev);
  925. }
  928. /* This will only be invoked if the driver is _not_ in XOFF state.
  929.  * What this means is that we need not check it, and that this
  930.  * invariant will hold if we make sure that the netif_*_queue()
  931.  * calls are done at the proper times.
  932.  */
  934. static int
  935. e100_send_packet(struct sk_buff *skb, struct net_device *dev)
  936. {
  937. struct net_local *np = (struct net_local *)dev->priv;
  938. int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  939. unsigned char *buf = skb->data;
  941. #ifdef ETHDEBUG
  942. printk("send packet len %dn", length);
  943. #endif
  944. spin_lock_irq(&np->lock);  /* protect from tx_interrupt and ourself */
  946. myNextTxDesc->skb = skb;
  948. dev->trans_start = jiffies;
  950. e100_hardware_send_packet(buf, length);
  952. myNextTxDesc = phys_to_virt(myNextTxDesc->descr.next);
  954. /* Stop queue if full */
  955. if (myNextTxDesc == myFirstTxDesc) {
  956. /* Enable transmit interrupt to wake up queue */
  957. *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
  958. *R_IRQ_MASK2_SET = IO_STATE(R_IRQ_MASK2_SET, dma0_eop, set);
  959. netif_stop_queue(dev);
  960. }
  961. else {
  962.   /* Report any packets that have been sent */
  963. while (myFirstTxDesc != phys_to_virt(*R_DMA_CH0_FIRST) &&
  964.        myFirstTxDesc != myNextTxDesc)
  965. {
  966. np->stats.tx_bytes += myFirstTxDesc->skb->len;
  967. np->stats.tx_packets++;
  969. /* dma is ready with the transmission of the data in tx_skb, so now
  970.    we can release the skb memory */
  971. dev_kfree_skb(myFirstTxDesc->skb);
  972. myFirstTxDesc->skb = 0;
  973. myFirstTxDesc = phys_to_virt(myFirstTxDesc->descr.next);
  974. }
  975. }
  977. spin_unlock_irq(&np->lock);
  979. return 0;
  980. }
  982. /*
  983.  * The typical workload of the driver:
  984.  *   Handle the network interface interrupts.
  985.  */
  987. static void
  988. e100rx_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  989. {
  990. struct net_device *dev = (struct net_device *)dev_id;
  991. unsigned long irqbits = *R_IRQ_MASK2_RD;
  992.  
  993. if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma1_eop, active)) {
  994. /* acknowledge the eop interrupt */
  996. *R_DMA_CH1_CLR_INTR = IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do);
  998. /* check if one or more complete packets were indeed received */
  1000. while (*R_DMA_CH1_FIRST != virt_to_phys(myNextRxDesc)) {
  1001. /* Take out the buffer and give it to the OS, then
  1002.  * allocate a new buffer to put a packet in.
  1003.  */
  1004. e100_rx(dev);
  1005. ((struct net_local *)dev->priv)->stats.rx_packets++;
  1006. /* restart/continue on the channel, for safety */
  1007. *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, restart);
  1008. /* clear dma channel 1 eop/descr irq bits */
  1009. *R_DMA_CH1_CLR_INTR =
  1010. IO_STATE(R_DMA_CH1_CLR_INTR, clr_eop, do) |
  1011. IO_STATE(R_DMA_CH1_CLR_INTR, clr_descr, do);
  1013. /* now, we might have gotten another packet
  1014.    so we have to loop back and check if so */
  1015. }
  1016. }
  1017. }
  1019. /* the transmit dma channel interrupt
  1020.  *
  1021.  * this is supposed to free the skbuff which was pending during transmission,
  1022.  * and inform the kernel that we can send one more buffer
  1023.  */
  1025. static void
  1026. e100tx_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  1027. {
  1028. struct net_device *dev = (struct net_device *)dev_id;
  1029. unsigned long irqbits = *R_IRQ_MASK2_RD;
  1030. struct net_local *np = (struct net_local *)dev->priv;
  1032. /* check for a dma0_eop interrupt */
  1033. if (irqbits & IO_STATE(R_IRQ_MASK2_RD, dma0_eop, active)) {
  1034. /* Report all sent packets */
  1035. do {
  1036. /* acknowledge the eop interrupt */
  1037. *R_DMA_CH0_CLR_INTR = IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do);
  1039. np->stats.tx_bytes += myFirstTxDesc->skb->len;
  1040. np->stats.tx_packets++;
  1042. /* dma is ready with the transmission of the data in tx_skb, so now
  1043.    we can release the skb memory */
  1044. dev_kfree_skb_irq(myFirstTxDesc->skb);
  1045. myFirstTxDesc->skb = 0;
  1047. if (netif_queue_stopped(dev)) {
  1048.    /* Queue is running, disable tx IRQ */
  1049.    *R_IRQ_MASK2_CLR = IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr);
  1050. netif_wake_queue(dev);
  1051. }
  1052. myFirstTxDesc = phys_to_virt(myFirstTxDesc->descr.next);
  1053. } while (myFirstTxDesc != phys_to_virt(*R_DMA_CH0_FIRST) &&
  1054.          myFirstTxDesc != myNextTxDesc);
  1055. }
  1056. }
  1058. static void
  1059. e100nw_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  1060. {
  1061. struct net_device *dev = (struct net_device *)dev_id;
  1062. struct net_local *np = (struct net_local *)dev->priv;
  1063. unsigned long irqbits = *R_IRQ_MASK0_RD;
  1065. /* check for underrun irq */
  1066. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, underrun, active)) { 
  1067. *R_NETWORK_TR_CTRL = IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr);
  1068. np->stats.tx_errors++;
  1069. D(printk("ethernet receiver underrun!n"));
  1070. }
  1072. /* check for overrun irq */
  1073. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, overrun, active)) { 
  1074. update_rx_stats(&np->stats); /* this will ack the irq */
  1075. D(printk("ethernet receiver overrun!n"));
  1076. }
  1077. /* check for excessive collision irq */
  1078. if (irqbits & IO_STATE(R_IRQ_MASK0_RD, excessive_col, active)) { 
  1079. *R_NETWORK_TR_CTRL = IO_STATE(R_NETWORK_TR_CTRL, clr_error, clr);
  1080. np->stats.tx_errors++;
  1081. D(printk("ethernet excessive collisions!n"));
  1082. }
  1083. }
  1085. /* We have a good packet(s), get it/them out of the buffers. */
  1086. static void
  1087. e100_rx(struct net_device *dev)
  1088. {
  1089. struct sk_buff *skb;
  1090. int length = 0;
  1091. struct net_local *np = (struct net_local *)dev->priv;
  1092. unsigned char *skb_data_ptr;
  1093. #ifdef ETHDEBUG
  1094. int i;
  1095. #endif
  1097. if (!led_active && time_after(jiffies, led_next_time)) {
  1098. /* light the network leds depending on the current speed. */
  1099. e100_set_network_leds(NETWORK_ACTIVITY);
  1101. /* Set the earliest time we may clear the LED */
  1102. led_next_time = jiffies + NET_FLASH_TIME;
  1103. led_active = 1;
  1104. mod_timer(&clear_led_timer, jiffies + HZ/10);
  1105. }
  1107. length = myNextRxDesc->descr.hw_len - 4;
  1108. ((struct net_local *)dev->priv)->stats.rx_bytes += length;
  1110. #ifdef ETHDEBUG
  1111. printk("Got a packet of length %d:n", length);
  1112. /* dump the first bytes in the packet */
  1113. skb_data_ptr = (unsigned char *)phys_to_virt(myNextRxDesc->descr.buf);
  1114. for (i = 0; i < 8; i++) {
  1115. printk("%d: %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2xn", i * 8,
  1116.        skb_data_ptr[0],skb_data_ptr[1],skb_data_ptr[2],skb_data_ptr[3],
  1117.        skb_data_ptr[4],skb_data_ptr[5],skb_data_ptr[6],skb_data_ptr[7]);
  1118. skb_data_ptr += 8;
  1119. }
  1120. #endif
  1122. if (length < RX_COPYBREAK) {
  1123. /* Small packet, copy data */
  1124. skb = dev_alloc_skb(length - ETHER_HEAD_LEN);
  1125. if (!skb) {
  1126. np->stats.rx_errors++;
  1127. printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.n", dev->name);
  1128. return;
  1129. }
  1131. skb_put(skb, length - ETHER_HEAD_LEN);        /* allocate room for the packet body */
  1132. skb_data_ptr = skb_push(skb, ETHER_HEAD_LEN); /* allocate room for the header */
  1134. #ifdef ETHDEBUG
  1135. printk("head = 0x%x, data = 0x%x, tail = 0x%x, end = 0x%xn",
  1136.   skb->head, skb->data, skb->tail, skb->end);
  1137. printk("copying packet to 0x%x.n", skb_data_ptr);
  1138. #endif
  1139.           
  1140. memcpy(skb_data_ptr, phys_to_virt(myNextRxDesc->descr.buf), length);
  1141. }
  1142. else {
  1143. /* Large packet, send directly to upper layers and allocate new memory */  
  1144. skb = myNextRxDesc->skb;
  1145. skb_put(skb, length);
  1146. myNextRxDesc->skb = dev_alloc_skb(MAX_MEDIA_DATA_SIZE);
  1147. myNextRxDesc->descr.buf = virt_to_phys(myNextRxDesc->skb->data);
  1148. }
  1150. skb->dev = dev;
  1151. skb->protocol = eth_type_trans(skb, dev);
  1153. /* Send the packet to the upper layers */
  1154. netif_rx(skb);
  1156. /* Prepare for next packet */
  1157. myNextRxDesc->descr.status = 0;
  1158. myPrevRxDesc = myNextRxDesc;
  1159. myNextRxDesc = phys_to_virt(myNextRxDesc->descr.next);
  1161. rx_queue_len++;
  1163. /* Check if descriptors should be returned */
  1164. if (rx_queue_len == RX_QUEUE_THRESHOLD) {
  1165. flush_etrax_cache();
  1166. myPrevRxDesc->descr.ctrl |= d_eol;
  1167. myLastRxDesc->descr.ctrl &= ~d_eol;
  1168. myLastRxDesc = myPrevRxDesc;
  1169. rx_queue_len = 0;
  1170. }
  1171. }
  1173. /* The inverse routine to net_open(). */
  1174. static int
  1175. e100_close(struct net_device *dev)
  1176. {
  1177. struct net_local *np = (struct net_local *)dev->priv;
  1179. printk("Closing %s.n", dev->name);
  1181. netif_stop_queue(dev);
  1183. *R_NETWORK_GEN_CONFIG =
  1184. IO_STATE(R_NETWORK_GEN_CONFIG, phy,    mii_clk) |
  1185. IO_STATE(R_NETWORK_GEN_CONFIG, enable, off);
  1187. *R_IRQ_MASK0_CLR =
  1188. IO_STATE(R_IRQ_MASK0_CLR, overrun, clr) |
  1189. IO_STATE(R_IRQ_MASK0_CLR, underrun, clr) |
  1190. IO_STATE(R_IRQ_MASK0_CLR, excessive_col, clr);
  1192. *R_IRQ_MASK2_CLR =
  1193. IO_STATE(R_IRQ_MASK2_CLR, dma0_descr, clr) |
  1194. IO_STATE(R_IRQ_MASK2_CLR, dma0_eop, clr) |
  1195. IO_STATE(R_IRQ_MASK2_CLR, dma1_descr, clr) |
  1196. IO_STATE(R_IRQ_MASK2_CLR, dma1_eop, clr);
  1198. /* Stop the receiver and the transmitter */
  1200. RESET_DMA(NETWORK_TX_DMA_NBR);
  1201. RESET_DMA(NETWORK_RX_DMA_NBR);
  1203. /* Flush the Tx and disable Rx here. */
  1205. free_irq(NETWORK_DMA_RX_IRQ_NBR, (void *)dev);
  1206. free_irq(NETWORK_DMA_TX_IRQ_NBR, (void *)dev);
  1207. free_irq(NETWORK_STATUS_IRQ_NBR, (void *)dev);
  1209. free_dma(NETWORK_TX_DMA_NBR);
  1210. free_dma(NETWORK_RX_DMA_NBR);
  1212. /* Update the statistics here. */
  1214. update_rx_stats(&np->stats);
  1215. update_tx_stats(&np->stats);
  1217. return 0;
  1218. }
  1220. static int
  1221. e100_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  1222. {
  1223. /* Maybe default should return -EINVAL instead? */
  1224. switch (cmd) {
  1225. case SET_ETH_SPEED_10:                  /* 10 Mbps */
  1226. e100_set_speed(10);
  1227. break;
  1228. case SET_ETH_SPEED_100:                /* 100 Mbps */
  1229. e100_set_speed(100);
  1230. break;
  1231. case SET_ETH_SPEED_AUTO:              /* Auto negotiate speed */
  1232. e100_set_speed(0);
  1233. break;
  1234. case SET_ETH_DUPLEX_HALF:              /* Hhalf duplex. */
  1235. e100_set_duplex(half);
  1236. break;
  1237. case SET_ETH_DUPLEX_FULL:              /* Full duplex. */
  1238. e100_set_duplex(full);
  1239. break;
  1240. case SET_ETH_DUPLEX_AUTO:             /* Autonegotiate duplex*/
  1241. e100_set_duplex(autoneg);
  1242. break;
  1243. default: /* Auto neg */
  1244. e100_set_speed(0);
  1245. e100_set_duplex(autoneg);
  1246. break;
  1247. }
  1248. return 0;
  1249. }
  1251. static void
  1252. update_rx_stats(struct net_device_stats *es)
  1253. {
  1254. unsigned long r = *R_REC_COUNTERS;
  1255. /* update stats relevant to reception errors */
  1256. es->rx_fifo_errors += IO_EXTRACT(R_REC_COUNTERS, congestion, r);
  1257. es->rx_crc_errors += IO_EXTRACT(R_REC_COUNTERS, crc_error, r);
  1258. es->rx_frame_errors += IO_EXTRACT(R_REC_COUNTERS, alignment_error, r);
  1259. es->rx_length_errors += IO_EXTRACT(R_REC_COUNTERS, oversize, r);
  1260. }
  1262. static void
  1263. update_tx_stats(struct net_device_stats *es)
  1264. {
  1265. unsigned long r = *R_TR_COUNTERS;
  1266. /* update stats relevant to transmission errors */
  1267. es->collisions +=
  1268. IO_EXTRACT(R_TR_COUNTERS, single_col, r) +
  1269. IO_EXTRACT(R_TR_COUNTERS, multiple_col, r);
  1270. es->tx_errors += IO_EXTRACT(R_TR_COUNTERS, deferred, r);
  1271. }
  1273. /*
  1274.  * Get the current statistics.
  1275.  * This may be called with the card open or closed.
  1276.  */
  1277. static struct net_device_stats *
  1278. e100_get_stats(struct net_device *dev)
  1279. {
  1280. struct net_local *lp = (struct net_local *)dev->priv;
  1282. update_rx_stats(&lp->stats);
  1283. update_tx_stats(&lp->stats);
  1285. return &lp->stats;
  1286. }
  1288. /*
  1289.  * Set or clear the multicast filter for this adaptor.
  1290.  * num_addrs == -1 Promiscuous mode, receive all packets
  1291.  * num_addrs == 0 Normal mode, clear multicast list
  1292.  * num_addrs > 0 Multicast mode, receive normal and MC packets,
  1293.  * and do best-effort filtering.
  1294.  */
  1295. static void
  1296. set_multicast_list(struct net_device *dev)
  1297. {
  1298. int num_addr = dev->mc_count;
  1299. unsigned long int lo_bits;
  1300. unsigned long int hi_bits;
  1301. if (dev->flags & IFF_PROMISC)
  1302. {
  1303. /* promiscuous mode */
  1304. lo_bits = 0xfffffffful;
  1305. hi_bits = 0xfffffffful;
  1307. /* Enable individual receive */
  1308. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, receive);
  1309. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  1310. } else if (dev->flags & IFF_ALLMULTI) {
  1311. /* enable all multicasts */
  1312. lo_bits = 0xfffffffful;
  1313. hi_bits = 0xfffffffful;
  1315. /* Disable individual receive */
  1316. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1317. *R_NETWORK_REC_CONFIG =  network_rec_config_shadow;
  1318. } else if (num_addr == 0) {
  1319. /* Normal, clear the mc list */
  1320. lo_bits = 0x00000000ul;
  1321. hi_bits = 0x00000000ul;
  1323. /* Disable individual receive */
  1324. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1325. *R_NETWORK_REC_CONFIG =  network_rec_config_shadow;
  1326. } else {
  1327. /* MC mode, receive normal and MC packets */
  1328. char hash_ix;
  1329. struct dev_mc_list *dmi = dev->mc_list;
  1330. int i;
  1331. char *baddr;
  1332. lo_bits = 0x00000000ul;
  1333. hi_bits = 0x00000000ul;
  1334. for (i=0; i<num_addr; i++) {
  1335. /* Calculate the hash index for the GA registers */
  1337. hash_ix = 0;
  1338. baddr = dmi->dmi_addr;
  1339. hash_ix ^= (*baddr) & 0x3f;
  1340. hash_ix ^= ((*baddr) >> 6) & 0x03;
  1341. ++baddr;
  1342. hash_ix ^= ((*baddr) << 2) & 0x03c;
  1343. hash_ix ^= ((*baddr) >> 4) & 0xf;
  1344. ++baddr;
  1345. hash_ix ^= ((*baddr) << 4) & 0x30;
  1346. hash_ix ^= ((*baddr) >> 2) & 0x3f;
  1347. ++baddr;
  1348. hash_ix ^= (*baddr) & 0x3f;
  1349. hash_ix ^= ((*baddr) >> 6) & 0x03;
  1350. ++baddr;
  1351. hash_ix ^= ((*baddr) << 2) & 0x03c;
  1352. hash_ix ^= ((*baddr) >> 4) & 0xf;
  1353. ++baddr;
  1354. hash_ix ^= ((*baddr) << 4) & 0x30;
  1355. hash_ix ^= ((*baddr) >> 2) & 0x3f;
  1357. hash_ix &= 0x3f;
  1359. if (hash_ix > 32) {
  1360. hi_bits |= (1 << (hash_ix-32));
  1361. }
  1362. else {
  1363. lo_bits |= (1 << hash_ix);
  1364. }
  1365. dmi = dmi->next;
  1366. }
  1367. /* Disable individual receive */
  1368. SETS(network_rec_config_shadow, R_NETWORK_REC_CONFIG, individual, discard);
  1369. *R_NETWORK_REC_CONFIG = network_rec_config_shadow;
  1370. }
  1371. *R_NETWORK_GA_0 = lo_bits;
  1372. *R_NETWORK_GA_1 = hi_bits;
  1373. }
  1375. void
  1376. e100_hardware_send_packet(char *buf, int length)
  1377. {
  1378. D(printk("e100 send pack, buf 0x%x len %dn", buf, length));
  1380. if (!led_active && time_after(jiffies, led_next_time)) {
  1381. /* light the network leds depending on the current speed. */
  1382. e100_set_network_leds(NETWORK_ACTIVITY);
  1384. /* Set the earliest time we may clear the LED */
  1385. led_next_time = jiffies + NET_FLASH_TIME;
  1386. led_active = 1;
  1387. mod_timer(&clear_led_timer, jiffies + HZ/10);
  1388. }
  1390. /* configure the tx dma descriptor */
  1391. myNextTxDesc->descr.sw_len = length;
  1392. myNextTxDesc->descr.ctrl = d_eop | d_eol | d_wait;
  1393. myNextTxDesc->descr.buf = virt_to_phys(buf);
  1395.         /* Move end of list */
  1396.         myLastTxDesc->descr.ctrl &= ~d_eol;
  1397.         myLastTxDesc = myNextTxDesc;
  1399. /* Restart DMA channel */
  1400. *R_DMA_CH0_CMD = IO_STATE(R_DMA_CH0_CMD, cmd, restart);
  1401. }
  1403. static void
  1404. e100_clear_network_leds(unsigned long dummy)
  1405. {
  1406. if (led_active && time_after(jiffies, led_next_time)) {
  1407. e100_set_network_leds(NO_NETWORK_ACTIVITY);
  1409. /* Set the earliest time we may set the LED */
  1410. led_next_time = jiffies + NET_FLASH_PAUSE;
  1411. led_active = 0;
  1412. }
  1413. }
  1415. static void
  1416. e100_set_network_leds(int active)
  1417. {
  1418. #if defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK)
  1419. int light_leds = (active == NO_NETWORK_ACTIVITY);
  1420. #elif defined(CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY)
  1421. int light_leds = (active == NETWORK_ACTIVITY);
  1422. #else
  1423. #error "Define either CONFIG_ETRAX_NETWORK_LED_ON_WHEN_LINK or CONFIG_ETRAX_NETWORK_LED_ON_WHEN_ACTIVITY"
  1424. #endif
  1426. if (!current_speed) {
  1427. /* Make LED red, link is down */
  1428. LED_NETWORK_SET(LED_RED);
  1429. }
  1430. else if (light_leds) {
  1431. if (current_speed == 10) {
  1432. LED_NETWORK_SET(LED_ORANGE);
  1433. } else {
  1434. LED_NETWORK_SET(LED_GREEN);
  1435. }
  1436. }
  1437. else {
  1438. LED_NETWORK_SET(LED_OFF);
  1439. }
  1440. }
  1442. static struct net_device dev_etrax_ethernet;  /* only got one */
  1444. static int
  1445. etrax_init_module(void)
  1446. {
  1447. struct net_device *d = &dev_etrax_ethernet;
  1449. d->init = etrax_ethernet_init;
  1451. if (register_netdev(d) == 0)
  1452. return 0;
  1453. else
  1454. return -ENODEV;
  1455. }
  1457. module_init(etrax_init_module);