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

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

Linux/Unix编程

开发平台：

Unix_Linux

fec.c：源码内容
  1. /*
  2.  * BK Id: %F% %I% %G% %U% %#%
  3.  */
  4. /*
  5.  * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
  6.  * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
  7.  *
  8.  * This version of the driver is specific to the FADS implementation,
  9.  * since the board contains control registers external to the processor
  10.  * for the control of the LevelOne LXT970 transceiver.  The MPC860T manual
  11.  * describes connections using the internal parallel port I/O, which
  12.  * is basically all of Port D.
  13.  *
  14.  * Includes support for the following PHYs: QS6612, LXT970, LXT971/2.
  15.  *
  16.  * Right now, I am very wasteful with the buffers.  I allocate memory
  17.  * pages and then divide them into 2K frame buffers.  This way I know I
  18.  * have buffers large enough to hold one frame within one buffer descriptor.
  19.  * Once I get this working, I will use 64 or 128 byte CPM buffers, which
  20.  * will be much more memory efficient and will easily handle lots of
  21.  * small packets.
  22.  *
  23.  * Much better multiple PHY support by Magnus Damm.
  24.  * Copyright (c) 2000 Ericsson Radio Systems AB.
  25.  *
  26.  * Make use of MII for PHY control configurable.
  27.  * Some fixes.
  28.  * Copyright (c) 2000 Wolfgang Denk, DENX Software Engineering.
  29.  */
  31. /* List of PHYs we wish to support.
  32. */
  33. #undef CONFIG_FEC_LXT970
  34. #define CONFIG_FEC_LXT971
  35. #undef CONFIG_FEC_QS6612
  36. #undef CONFIG_FEC_DP83843
  37. #undef CONFIG_FEC_DP83846A
  39. #include <linux/config.h>
  40. #include <linux/kernel.h>
  41. #include <linux/sched.h>
  42. #include <linux/string.h>
  43. #include <linux/ptrace.h>
  44. #include <linux/errno.h>
  45. #include <linux/ioport.h>
  46. #include <linux/slab.h>
  47. #include <linux/interrupt.h>
  48. #include <linux/pci.h>
  49. #include <linux/init.h>
  50. #include <linux/delay.h>
  51. #include <linux/netdevice.h>
  52. #include <linux/etherdevice.h>
  53. #include <linux/skbuff.h>
  54. #include <linux/spinlock.h>
  55. #include <linux/mii.h>
  56. #include <linux/ethtool.h>
  58. #include <asm/8xx_immap.h>
  59. #include <asm/pgtable.h>
  60. #include <asm/mpc8xx.h>
  61. #include <asm/irq.h>
  62. #include <asm/bitops.h>
  63. #include <asm/uaccess.h>
  64. #include <asm/commproc.h>
  66. #ifdef CONFIG_USE_MDIO
  67. /* Forward declarations of some structures to support different PHYs
  68. */
  70. typedef struct {
  71. uint mii_data;
  72. void (*funct)(uint mii_reg, struct net_device *dev, uint data);
  73. } phy_cmd_t;
  75. typedef struct {
  76. uint id;
  77. char *name;
  79. const phy_cmd_t *config;
  80. const phy_cmd_t *startup;
  81. const phy_cmd_t *ack_int;
  82. const phy_cmd_t *shutdown;
  83. } phy_info_t;
  84. #endif /* CONFIG_USE_MDIO */
  86. /* The number of Tx and Rx buffers.  These are allocated from the page
  87.  * pool.  The code may assume these are power of two, so it is best
  88.  * to keep them that size.
  89.  * We don't need to allocate pages for the transmitter.  We just use
  90.  * the skbuffer directly.
  91.  */
  92. #ifdef CONFIG_ENET_BIG_BUFFERS
  93. #define FEC_ENET_RX_PAGES 16
  94. #define FEC_ENET_RX_FRSIZE 2048
  95. #define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
  96. #define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
  97. #define TX_RING_SIZE 16 /* Must be power of two */
  98. #define TX_RING_MOD_MASK 15 /*   for this to work */
  99. #else
  100. #define FEC_ENET_RX_PAGES 4
  101. #define FEC_ENET_RX_FRSIZE 2048
  102. #define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
  103. #define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
  104. #define TX_RING_SIZE 8 /* Must be power of two */
  105. #define TX_RING_MOD_MASK 7 /*   for this to work */
  106. #endif
  108. /* Interrupt events/masks.
  109. */
  110. #define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */
  111. #define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */
  112. #define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */
  113. #define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */
  114. #define FEC_ENET_TXF ((uint)0x08000000) /* Full frame transmitted */
  115. #define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */
  116. #define FEC_ENET_RXF ((uint)0x02000000) /* Full frame received */
  117. #define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */
  118. #define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */
  119. #define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */
  121. /*
  122. */
  123. #define FEC_ECNTRL_PINMUX 0x00000004
  124. #define FEC_ECNTRL_ETHER_EN 0x00000002
  125. #define FEC_ECNTRL_RESET 0x00000001
  127. #define FEC_RCNTRL_BC_REJ 0x00000010
  128. #define FEC_RCNTRL_PROM 0x00000008
  129. #define FEC_RCNTRL_MII_MODE 0x00000004
  130. #define FEC_RCNTRL_DRT 0x00000002
  131. #define FEC_RCNTRL_LOOP 0x00000001
  133. #define FEC_TCNTRL_FDEN 0x00000004
  134. #define FEC_TCNTRL_HBC 0x00000002
  135. #define FEC_TCNTRL_GTS 0x00000001
  137. /* Delay to wait for FEC reset command to complete (in us)
  138. */
  139. #define FEC_RESET_DELAY 50
  141. /* The FEC stores dest/src/type, data, and checksum for receive packets.
  142.  */
  143. #define PKT_MAXBUF_SIZE 1518
  144. #define PKT_MINBUF_SIZE 64
  145. #define PKT_MAXBLR_SIZE 1520
  147. /* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
  148.  * tx_bd_base always point to the base of the buffer descriptors.  The
  149.  * cur_rx and cur_tx point to the currently available buffer.
  150.  * The dirty_tx tracks the current buffer that is being sent by the
  151.  * controller.  The cur_tx and dirty_tx are equal under both completely
  152.  * empty and completely full conditions.  The empty/ready indicator in
  153.  * the buffer descriptor determines the actual condition.
  154.  */
  155. struct fec_enet_private {
  156. /* The saved address of a sent-in-place packet/buffer, for skfree(). */
  157. struct sk_buff* tx_skbuff[TX_RING_SIZE];
  158. ushort skb_cur;
  159. ushort skb_dirty;
  161. /* CPM dual port RAM relative addresses.
  162. */
  163. cbd_t *rx_bd_base; /* Address of Rx and Tx buffers. */
  164. cbd_t *tx_bd_base;
  165. cbd_t *cur_rx, *cur_tx; /* The next free ring entry */
  166. cbd_t *dirty_tx; /* The ring entries to be free()ed. */
  167. scc_t *sccp;
  168. struct net_device_stats stats;
  169. uint tx_full;
  170. spinlock_t lock;
  172. #ifdef CONFIG_USE_MDIO
  173. uint phy_id;
  174. uint phy_id_done;
  175. uint phy_status;
  176. uint phy_speed;
  177. phy_info_t *phy;
  178. struct tq_struct phy_task;
  180. uint sequence_done;
  182. uint phy_addr;
  184. struct timer_list phy_timer_list;
  185. u16 old_status;
  186. #endif /* CONFIG_USE_MDIO */
  188. int link;
  189. int old_link;
  190. int full_duplex;
  191. };
  193. static int fec_enet_open(struct net_device *dev);
  194. static int fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev);
  195. #ifdef CONFIG_USE_MDIO
  196. static void fec_enet_mii(struct net_device *dev);
  197. #endif /* CONFIG_USE_MDIO */
  198. static void fec_enet_interrupt(int irq, void * dev_id, struct pt_regs * regs);
  199. static void  fec_enet_tx(struct net_device *dev);
  200. static void  fec_enet_rx(struct net_device *dev);
  201. static int fec_enet_close(struct net_device *dev);
  202. static struct net_device_stats *fec_enet_get_stats(struct net_device *dev);
  203. static void set_multicast_list(struct net_device *dev);
  204. static void fec_restart(struct net_device *dev, int duplex);
  205. static void fec_stop(struct net_device *dev);
  206. static ushort my_enet_addr[3];
  208. #ifdef CONFIG_USE_MDIO
  209. static int fec_enet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  210. static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr);
  212. static void mdio_callback(uint regval, struct net_device *dev, uint data);
  213. static int mdio_read(struct net_device *dev, int phy_id, int location);
  215. #if defined(CONFIG_FEC_DP83846A)
  216. static void mdio_timer_callback(unsigned long data);
  217. #endif /* CONFIG_FEC_DP83846A */
  219. /* MII processing.  We keep this as simple as possible.  Requests are
  220.  * placed on the list (if there is room).  When the request is finished
  221.  * by the MII, an optional function may be called.
  222.  */
  223. typedef struct mii_list {
  224. uint mii_regval;
  225. void (*mii_func)(uint val, struct net_device *dev, uint data);
  226. struct mii_list *mii_next;
  227. uint mii_data;
  228. } mii_list_t;
  230. #define NMII 20
  231. mii_list_t mii_cmds[NMII];
  232. mii_list_t *mii_free;
  233. mii_list_t *mii_head;
  234. mii_list_t *mii_tail;
  236. typedef struct mdio_read_data {
  237. u16 regval;
  238. struct task_struct *sleeping_task;
  239. } mdio_read_data_t;
  241. static int mii_queue(struct net_device *dev, int request,
  242. void (*func)(uint, struct net_device *, uint), uint data);
  243. static void mii_queue_relink(uint mii_reg, struct net_device *dev, uint data);
  245. /* Make MII read/write commands for the FEC.
  246. */
  247. #define mk_mii_read(REG) (0x60020000 | ((REG & 0x1f) << 18))
  248. #define mk_mii_write(REG, VAL) (0x50020000 | ((REG & 0x1f) << 18) | 
  249. (VAL & 0xffff))
  250. #define mk_mii_end 0
  251. #endif /* CONFIG_USE_MDIO */
  253. /* Transmitter timeout.
  254. */
  255. #define TX_TIMEOUT (2*HZ)
  257. #ifdef CONFIG_USE_MDIO
  258. /* Register definitions for the PHY.
  259. */
  261. #define MII_REG_CR          0  /* Control Register                         */
  262. #define MII_REG_SR          1  /* Status Register                          */
  263. #define MII_REG_PHYIR1      2  /* PHY Identification Register 1            */
  264. #define MII_REG_PHYIR2      3  /* PHY Identification Register 2            */
  265. #define MII_REG_ANAR        4  /* A-N Advertisement Register               */
  266. #define MII_REG_ANLPAR      5  /* A-N Link Partner Ability Register        */
  267. #define MII_REG_ANER        6  /* A-N Expansion Register                   */
  268. #define MII_REG_ANNPTR      7  /* A-N Next Page Transmit Register          */
  269. #define MII_REG_ANLPRNPR    8  /* A-N Link Partner Received Next Page Reg. */
  271. /* values for phy_status */
  273. #define PHY_CONF_ANE 0x0001  /* 1 auto-negotiation enabled */
  274. #define PHY_CONF_LOOP 0x0002  /* 1 loopback mode enabled */
  275. #define PHY_CONF_SPMASK 0x00f0  /* mask for speed */
  276. #define PHY_CONF_10HDX 0x0010  /* 10 Mbit half duplex supported */
  277. #define PHY_CONF_10FDX 0x0020  /* 10 Mbit full duplex supported */
  278. #define PHY_CONF_100HDX 0x0040  /* 100 Mbit half duplex supported */
  279. #define PHY_CONF_100FDX 0x0080  /* 100 Mbit full duplex supported */
  281. #define PHY_STAT_LINK 0x0100  /* 1 up - 0 down */
  282. #define PHY_STAT_FAULT 0x0200  /* 1 remote fault */
  283. #define PHY_STAT_ANC 0x0400  /* 1 auto-negotiation complete */
  284. #define PHY_STAT_SPMASK 0xf000  /* mask for speed */
  285. #define PHY_STAT_10HDX 0x1000  /* 10 Mbit half duplex selected */
  286. #define PHY_STAT_10FDX 0x2000  /* 10 Mbit full duplex selected */
  287. #define PHY_STAT_100HDX 0x4000  /* 100 Mbit half duplex selected */
  288. #define PHY_STAT_100FDX 0x8000  /* 100 Mbit full duplex selected */
  289. #endif /* CONFIG_USE_MDIO */
  291. static int
  292. fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
  293. {
  294. struct fec_enet_private *fep;
  295. volatile fec_t *fecp;
  296. volatile cbd_t *bdp;
  298. fep = dev->priv;
  299. fecp = (volatile fec_t*)dev->base_addr;
  301. if (!fep->link) {
  302. /* Link is down or autonegotiation is in progress. */
  303. return 1;
  304. }
  306. /* Fill in a Tx ring entry */
  307. bdp = fep->cur_tx;
  309. #ifndef final_version
  310. if (bdp->cbd_sc & BD_ENET_TX_READY) {
  311. /* Ooops.  All transmit buffers are full.  Bail out.
  312.  * This should not happen, since dev->tbusy should be set.
  313.  */
  314. printk("%s: tx queue full!.n", dev->name);
  315. return 1;
  316. }
  317. #endif
  319. /* Clear all of the status flags.
  320.  */
  321. bdp->cbd_sc &= ~BD_ENET_TX_STATS;
  323. /* Set buffer length and buffer pointer.
  324. */
  325. bdp->cbd_bufaddr = __pa(skb->data);
  326. bdp->cbd_datlen = skb->len;
  328. /* Save skb pointer.
  329. */
  330. fep->tx_skbuff[fep->skb_cur] = skb;
  332. fep->stats.tx_bytes += skb->len;
  333. fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
  335. /* Push the data cache so the CPM does not get stale memory
  336.  * data.
  337.  */
  338. flush_dcache_range((unsigned long)skb->data,
  339.    (unsigned long)skb->data + skb->len);
  341. spin_lock_irq(&fep->lock);
  343. /* Send it on its way.  Tell FEC its ready, interrupt when done,
  344.  * its the last BD of the frame, and to put the CRC on the end.
  345.  */
  347. bdp->cbd_sc |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
  348. | BD_ENET_TX_LAST | BD_ENET_TX_TC);
  350. dev->trans_start = jiffies;
  352. /* Trigger transmission start */
  353. fecp->fec_x_des_active = 0x01000000;
  355. /* If this was the last BD in the ring, start at the beginning again.
  356. */
  357. if (bdp->cbd_sc & BD_ENET_TX_WRAP) {
  358. bdp = fep->tx_bd_base;
  359. } else {
  360. bdp++;
  361. }
  363. if (bdp->cbd_sc & BD_ENET_TX_READY) {
  364. netif_stop_queue(dev);
  365. fep->tx_full = 1;
  366. }
  368. fep->cur_tx = (cbd_t *)bdp;
  370. spin_unlock_irq(&fep->lock);
  372. return 0;
  373. }
  375. static void
  376. fec_timeout(struct net_device *dev)
  377. {
  378. struct fec_enet_private *fep = dev->priv;
  380. printk("%s: transmit timed out.n", dev->name);
  381. fep->stats.tx_errors++;
  382. #ifndef final_version
  383. {
  384. int i;
  385. cbd_t *bdp;
  387. printk("Ring data dump: cur_tx %lx%s, dirty_tx %lx cur_rx: %lxn",
  388.        (unsigned long)fep->cur_tx, fep->tx_full ? " (full)" : "",
  389.        (unsigned long)fep->dirty_tx,
  390.        (unsigned long)fep->cur_rx);
  392. bdp = fep->tx_bd_base;
  393. printk(" tx: %u buffersn",  TX_RING_SIZE);
  394. for (i = 0 ; i < TX_RING_SIZE; i++) {
  395. printk("  %08x: %04x %04x %08xn",
  396.        (uint) bdp,
  397.        bdp->cbd_sc,
  398.        bdp->cbd_datlen,
  399.        bdp->cbd_bufaddr);
  400. bdp++;
  401. }
  403. bdp = fep->rx_bd_base;
  404. printk(" rx: %lu buffersn",  RX_RING_SIZE);
  405. for (i = 0 ; i < RX_RING_SIZE; i++) {
  406. printk("  %08x: %04x %04x %08xn",
  407.        (uint) bdp,
  408.        bdp->cbd_sc,
  409.        bdp->cbd_datlen,
  410.        bdp->cbd_bufaddr);
  411. bdp++;
  412. }
  413. }
  414. #endif
  415. if (!fep->tx_full)
  416. netif_wake_queue(dev);
  417. }
  419. /* The interrupt handler.
  420.  * This is called from the MPC core interrupt.
  421.  */
  422. static void
  423. fec_enet_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  424. {
  425. struct net_device *dev = dev_id;
  426. volatile fec_t *fecp;
  427. uint int_events;
  428. fecp = (volatile fec_t*)dev->base_addr;
  430. /* Get the interrupt events that caused us to be here.
  431. */
  432. while ((int_events = fecp->fec_ievent) != 0) {
  433. fecp->fec_ievent = int_events;
  434. if ((int_events & (FEC_ENET_HBERR | FEC_ENET_BABR |
  435.    FEC_ENET_BABT | FEC_ENET_EBERR)) != 0) {
  436. printk("FEC ERROR %xn", int_events);
  437. }
  439. /* Handle receive event in its own function.
  440.  */
  441. if (int_events & FEC_ENET_RXF)
  442. fec_enet_rx(dev);
  444. /* Transmit OK, or non-fatal error. Update the buffer
  445.    descriptors. FEC handles all errors, we just discover
  446.    them as part of the transmit process.
  447. */
  448. if (int_events & FEC_ENET_TXF)
  449. fec_enet_tx(dev);
  451. if (int_events & FEC_ENET_MII) {
  452. #ifdef CONFIG_USE_MDIO
  453. fec_enet_mii(dev);
  454. #else
  455. printk("%s[%d] %s: unexpected FEC_ENET_MII eventn", __FILE__,__LINE__,__FUNCTION__);
  456. #endif /* CONFIG_USE_MDIO */
  457. }
  459. }
  460. }
  463. static void
  464. fec_enet_tx(struct net_device *dev)
  465. {
  466. struct fec_enet_private *fep;
  467. volatile cbd_t *bdp;
  468. struct sk_buff *skb;
  470. fep = dev->priv;
  471. spin_lock(&fep->lock);
  472. bdp = fep->dirty_tx;
  474. while ((bdp->cbd_sc&BD_ENET_TX_READY) == 0) {
  475. if (bdp == fep->cur_tx && fep->tx_full == 0) break;
  477. skb = fep->tx_skbuff[fep->skb_dirty];
  478. /* Check for errors. */
  479. if (bdp->cbd_sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
  480.    BD_ENET_TX_RL | BD_ENET_TX_UN |
  481.    BD_ENET_TX_CSL)) {
  482. fep->stats.tx_errors++;
  483. if (bdp->cbd_sc & BD_ENET_TX_HB)  /* No heartbeat */
  484. fep->stats.tx_heartbeat_errors++;
  485. if (bdp->cbd_sc & BD_ENET_TX_LC)  /* Late collision */
  486. fep->stats.tx_window_errors++;
  487. if (bdp->cbd_sc & BD_ENET_TX_RL)  /* Retrans limit */
  488. fep->stats.tx_aborted_errors++;
  489. if (bdp->cbd_sc & BD_ENET_TX_UN)  /* Underrun */
  490. fep->stats.tx_fifo_errors++;
  491. if (bdp->cbd_sc & BD_ENET_TX_CSL) /* Carrier lost */
  492. fep->stats.tx_carrier_errors++;
  493. } else
  494. fep->stats.tx_packets++;
  496. #ifndef final_version
  497. if (bdp->cbd_sc & BD_ENET_TX_READY)
  498. printk("HEY! Enet xmit interrupt and TX_READY.n");
  499. #endif
  500. /* Deferred means some collisions occurred during transmit,
  501.  * but we eventually sent the packet OK.
  502.  */
  503. if (bdp->cbd_sc & BD_ENET_TX_DEF)
  504. fep->stats.collisions++;
  506. /* Free the sk buffer associated with this last transmit.
  507.  */
  508. #if 0
  509. printk("TXI: %x %x %xn", bdp, skb, fep->skb_dirty);
  510. #endif
  511. dev_kfree_skb_irq (skb/*, FREE_WRITE*/);
  512. fep->tx_skbuff[fep->skb_dirty] = NULL;
  513. fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
  515. /* Update pointer to next buffer descriptor to be transmitted.
  516.  */
  517. if (bdp->cbd_sc & BD_ENET_TX_WRAP)
  518. bdp = fep->tx_bd_base;
  519. else
  520. bdp++;
  522. /* Since we have freed up a buffer, the ring is no longer
  523.  * full.
  524.  */
  525. if (fep->tx_full) {
  526. fep->tx_full = 0;
  527. if (netif_queue_stopped(dev))
  528. netif_wake_queue(dev);
  529. }
  530. }
  531. fep->dirty_tx = (cbd_t *)bdp;
  532. spin_unlock(&fep->lock);
  533. }
  536. /* During a receive, the cur_rx points to the current incoming buffer.
  537.  * When we update through the ring, if the next incoming buffer has
  538.  * not been given to the system, we just set the empty indicator,
  539.  * effectively tossing the packet.
  540.  */
  541. static void
  542. fec_enet_rx(struct net_device *dev)
  543. {
  544. struct fec_enet_private *fep;
  545. volatile fec_t *fecp;
  546. volatile cbd_t *bdp;
  547. struct sk_buff *skb;
  548. ushort pkt_len;
  549. __u8 *data;
  551. fep = dev->priv;
  552. fecp = (volatile fec_t*)dev->base_addr;
  554. /* First, grab all of the stats for the incoming packet.
  555.  * These get messed up if we get called due to a busy condition.
  556.  */
  557. bdp = fep->cur_rx;
  559. while (!(bdp->cbd_sc & BD_ENET_RX_EMPTY)) {
  561. #ifndef final_version
  562. /* Since we have allocated space to hold a complete frame,
  563.  * the last indicator should be set.
  564.  */
  565. if ((bdp->cbd_sc & BD_ENET_RX_LAST) == 0)
  566. printk("FEC ENET: rcv is not +lastn");
  567. #endif
  569. /* Check for errors. */
  570. if (bdp->cbd_sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
  571.    BD_ENET_RX_CR | BD_ENET_RX_OV)) {
  572. fep->stats.rx_errors++;
  573. if (bdp->cbd_sc & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
  574. /* Frame too long or too short. */
  575. fep->stats.rx_length_errors++;
  576. }
  577. if (bdp->cbd_sc & BD_ENET_RX_NO) /* Frame alignment */
  578. fep->stats.rx_frame_errors++;
  579. if (bdp->cbd_sc & BD_ENET_RX_CR) /* CRC Error */
  580. fep->stats.rx_crc_errors++;
  581. if (bdp->cbd_sc & BD_ENET_RX_OV) /* FIFO overrun */
  582. fep->stats.rx_crc_errors++;
  583. }
  585. /* Report late collisions as a frame error.
  586.  * On this error, the BD is closed, but we don't know what we
  587.  * have in the buffer.  So, just drop this frame on the floor.
  588.  */
  589. if (bdp->cbd_sc & BD_ENET_RX_CL) {
  590. fep->stats.rx_errors++;
  591. fep->stats.rx_frame_errors++;
  592. goto rx_processing_done;
  593. }
  595. /* Process the incoming frame.
  596.  */
  597. fep->stats.rx_packets++;
  598. pkt_len = bdp->cbd_datlen;
  599. fep->stats.rx_bytes += pkt_len;
  600. data = (__u8*)__va(bdp->cbd_bufaddr);
  602. /* This does 16 byte alignment, exactly what we need.
  603.  * The packet length includes FCS, but we don't want to
  604.  * include that when passing upstream as it messes up
  605.  * bridging applications.
  606.  */
  607. skb = dev_alloc_skb(pkt_len-4);
  609. if (skb == NULL) {
  610. printk("%s: Memory squeeze, dropping packet.n", dev->name);
  611. fep->stats.rx_dropped++;
  612. } else {
  613. skb->dev = dev;
  614. skb_put(skb,pkt_len-4); /* Make room */
  615. eth_copy_and_sum(skb,
  616.  (unsigned char *)__va(bdp->cbd_bufaddr),
  617.  pkt_len-4, 0);
  618. skb->protocol=eth_type_trans(skb,dev);
  619. netif_rx(skb);
  620. }
  621.   rx_processing_done:
  623. /* Clear the status flags for this buffer.
  624. */
  625. bdp->cbd_sc &= ~BD_ENET_RX_STATS;
  627. /* Mark the buffer empty.
  628. */
  629. bdp->cbd_sc |= BD_ENET_RX_EMPTY;
  631. /* Update BD pointer to next entry.
  632. */
  633. if (bdp->cbd_sc & BD_ENET_RX_WRAP)
  634. bdp = fep->rx_bd_base;
  635. else
  636. bdp++;
  638. #if 1
  639. /* Doing this here will keep the FEC running while we process
  640.  * incoming frames.  On a heavily loaded network, we should be
  641.  * able to keep up at the expense of system resources.
  642.  */
  643. fecp->fec_r_des_active = 0x01000000;
  644. #endif
  645.    } /* while (!(bdp->cbd_sc & BD_ENET_RX_EMPTY)) */
  646. fep->cur_rx = (cbd_t *)bdp;
  648. #if 0
  649. /* Doing this here will allow us to process all frames in the
  650.  * ring before the FEC is allowed to put more there.  On a heavily
  651.  * loaded network, some frames may be lost.  Unfortunately, this
  652.  * increases the interrupt overhead since we can potentially work
  653.  * our way back to the interrupt return only to come right back
  654.  * here.
  655.  */
  656. fecp->fec_r_des_active = 0x01000000;
  657. #endif
  658. }
  661. #ifdef CONFIG_USE_MDIO
  662. static void
  663. fec_enet_mii(struct net_device *dev)
  664. {
  665. struct fec_enet_private *fep;
  666. volatile fec_t *ep;
  667. mii_list_t *mip;
  668. uint mii_reg;
  670. fep = (struct fec_enet_private *)dev->priv;
  671. ep = &(((immap_t *)IMAP_ADDR)->im_cpm.cp_fec);
  672. mii_reg = ep->fec_mii_data;
  674. if ((mip = mii_head) == NULL) {
  675. printk("MII and no head!n");
  676. return;
  677. }
  679. if (mip->mii_func != NULL)
  680. (*(mip->mii_func))(mii_reg, dev, mip->mii_data);
  682. mii_head = mip->mii_next;
  683. mip->mii_next = mii_free;
  684. mii_free = mip;
  686. if ((mip = mii_head) != NULL) {
  687. ep->fec_mii_data = mip->mii_regval;
  688. }
  689. }
  691. static int
  692. mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_device *, uint), uint data)
  693. {
  694. struct fec_enet_private *fep;
  695. unsigned long flags;
  696. mii_list_t *mip;
  697. int retval;
  699. /* Add PHY address to register command.
  700. */
  701. fep = dev->priv;
  702. regval |= fep->phy_addr << 23;
  704. retval = 0;
  706. save_flags(flags);
  707. cli();
  709. if ((mip = mii_free) != NULL) {
  710. mii_free = mip->mii_next;
  711. mip->mii_regval = regval;
  712. mip->mii_func = func;
  713. mip->mii_next = NULL;
  714. mip->mii_data = data;
  715. if (mii_head) {
  716. mii_tail->mii_next = mip;
  717. mii_tail = mip;
  718. } else {
  719. mii_head = mii_tail = mip;
  720. (&(((immap_t *)IMAP_ADDR)->im_cpm.cp_fec))->fec_mii_data = regval;
  721. }
  722. } else {
  723. retval = 1;
  724. }
  726. restore_flags(flags);
  728. return(retval);
  729. }
  731. static void mii_do_cmd(struct net_device *dev, const phy_cmd_t *c)
  732. {
  733. int k;
  735. if(!c)
  736. return;
  738. for(k = 0; (c+k)->mii_data != mk_mii_end; k++)
  739. mii_queue(dev, (c+k)->mii_data, (c+k)->funct, 0);
  740. }
  742. static void mii_parse_sr(uint mii_reg, struct net_device *dev, uint data)
  743. {
  744. struct fec_enet_private *fep = dev->priv;
  745. volatile uint *s = &(fep->phy_status);
  747. *s &= ~(PHY_STAT_LINK | PHY_STAT_FAULT | PHY_STAT_ANC);
  749. if (mii_reg & 0x0004)
  750. *s |= PHY_STAT_LINK;
  751. if (mii_reg & 0x0010)
  752. *s |= PHY_STAT_FAULT;
  753. if (mii_reg & 0x0020)
  754. *s |= PHY_STAT_ANC;
  756. fep->link = (*s & PHY_STAT_LINK) ? 1 : 0;
  757. }
  759. static void mii_parse_cr(uint mii_reg, struct net_device *dev, uint data)
  760. {
  761. struct fec_enet_private *fep = dev->priv;
  762. volatile uint *s = &(fep->phy_status);
  764. *s &= ~(PHY_CONF_ANE | PHY_CONF_LOOP);
  766. if (mii_reg & 0x1000)
  767. *s |= PHY_CONF_ANE;
  768. if (mii_reg & 0x4000)
  769. *s |= PHY_CONF_LOOP;
  770. }
  772. static void mii_parse_anar(uint mii_reg, struct net_device *dev, uint data)
  773. {
  774. struct fec_enet_private *fep = dev->priv;
  775. volatile uint *s = &(fep->phy_status);
  777. *s &= ~(PHY_CONF_SPMASK);
  779. if (mii_reg & 0x0020)
  780. *s |= PHY_CONF_10HDX;
  781. if (mii_reg & 0x0040)
  782. *s |= PHY_CONF_10FDX;
  783. if (mii_reg & 0x0080)
  784. *s |= PHY_CONF_100HDX;
  785. if (mii_reg & 0x00100)
  786. *s |= PHY_CONF_100FDX;
  787. }
  788. #if 0
  789. static void mii_disp_reg(uint mii_reg, struct net_device *dev)
  790. {
  791. printk("reg %u = 0x%04xn", (mii_reg >> 18) & 0x1f, mii_reg & 0xffff);
  792. }
  793. #endif
  795. /* ------------------------------------------------------------------------- */
  796. /* The Level one LXT970 is used by many boards      */
  798. #ifdef CONFIG_FEC_LXT970
  800. #define MII_LXT970_MIRROR    16  /* Mirror register           */
  801. #define MII_LXT970_IER       17  /* Interrupt Enable Register */
  802. #define MII_LXT970_ISR       18  /* Interrupt Status Register */
  803. #define MII_LXT970_CONFIG    19  /* Configuration Register    */
  804. #define MII_LXT970_CSR       20  /* Chip Status Register      */
  806. static void mii_parse_lxt970_csr(uint mii_reg, struct net_device *dev, uint data)
  807. {
  808. struct fec_enet_private *fep = dev->priv;
  809. volatile uint *s = &(fep->phy_status);
  811. *s &= ~(PHY_STAT_SPMASK);
  813. if (mii_reg & 0x0800) {
  814. if (mii_reg & 0x1000)
  815. *s |= PHY_STAT_100FDX;
  816. else
  817. *s |= PHY_STAT_100HDX;
  818. }
  819. else {
  820. if (mii_reg & 0x1000)
  821. *s |= PHY_STAT_10FDX;
  822. else
  823. *s |= PHY_STAT_10HDX;
  824. }
  825. }
  827. static phy_info_t phy_info_lxt970 = {
  828. 0x07810000,
  829. "LXT970",
  831. (const phy_cmd_t []) {  /* config */
  832. #if 0
  833. // { mk_mii_write(MII_REG_ANAR, 0x0021), NULL },
  835. /* Set default operation of 100-TX....for some reason
  836.  * some of these bits are set on power up, which is wrong.
  837.  */
  838. { mk_mii_write(MII_LXT970_CONFIG, 0), NULL },
  839. #endif
  840. { mk_mii_read(MII_REG_CR), mii_parse_cr },
  841. { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
  842. { mk_mii_end, }
  843. },
  844. (const phy_cmd_t []) {  /* startup - enable interrupts */
  845. { mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
  846. { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
  847. { mk_mii_end, }
  848. },
  849. (const phy_cmd_t []) { /* ack_int */
  850. /* read SR and ISR to acknowledge */
  852. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  853. { mk_mii_read(MII_LXT970_ISR), NULL },
  855. /* find out the current status */
  857. { mk_mii_read(MII_LXT970_CSR), mii_parse_lxt970_csr },
  858. { mk_mii_end, }
  859. },
  860. (const phy_cmd_t []) {  /* shutdown - disable interrupts */
  861. { mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
  862. { mk_mii_end, }
  863. },
  864. };
  866. #endif /* CONFIG_FEC_LXT970 */
  868. /* ------------------------------------------------------------------------- */
  869. /* The Level one LXT971 is used on some of my custom boards                  */
  871. #ifdef CONFIG_FEC_LXT971
  873. /* register definitions for the 971 */
  875. #define MII_LXT971_PCR       16  /* Port Control Register     */
  876. #define MII_LXT971_SR2       17  /* Status Register 2         */
  877. #define MII_LXT971_IER       18  /* Interrupt Enable Register */
  878. #define MII_LXT971_ISR       19  /* Interrupt Status Register */
  879. #define MII_LXT971_LCR       20  /* LED Control Register      */
  880. #define MII_LXT971_TCR       30  /* Transmit Control Register */
  882. /*
  883.  * I had some nice ideas of running the MDIO faster...
  884.  * The 971 should support 8MHz and I tried it, but things acted really
  885.  * weird, so 2.5 MHz ought to be enough for anyone...
  886.  */
  888. static void mii_parse_lxt971_sr2(uint mii_reg, struct net_device *dev, uint data)
  889. {
  890. struct fec_enet_private *fep = dev->priv;
  891. volatile uint *s = &(fep->phy_status);
  893. *s &= ~(PHY_STAT_SPMASK);
  895. if (mii_reg & 0x4000) {
  896. if (mii_reg & 0x0200)
  897. *s |= PHY_STAT_100FDX;
  898. else
  899. *s |= PHY_STAT_100HDX;
  900. }
  901. else {
  902. if (mii_reg & 0x0200)
  903. *s |= PHY_STAT_10FDX;
  904. else
  905. *s |= PHY_STAT_10HDX;
  906. }
  907. if (mii_reg & 0x0008)
  908. *s |= PHY_STAT_FAULT;
  909. }
  911. static phy_info_t phy_info_lxt971 = {
  912. 0x0001378e,
  913. "LXT971",
  915. (const phy_cmd_t []) {  /* config */
  916. // { mk_mii_write(MII_REG_ANAR, 0x021), NULL }, /* 10  Mbps, HD */
  917. { mk_mii_read(MII_REG_CR), mii_parse_cr },
  918. { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
  919. { mk_mii_end, }
  920. },
  921. (const phy_cmd_t []) {  /* startup - enable interrupts */
  922. { mk_mii_write(MII_LXT971_IER, 0x00f2), NULL },
  923. { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
  925. /* Somehow does the 971 tell me that the link is down
  926.  * the first read after power-up.
  927.  * read here to get a valid value in ack_int */
  929. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  930. { mk_mii_end, }
  931. },
  932. (const phy_cmd_t []) { /* ack_int */
  933. /* find out the current status */
  935. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  936. { mk_mii_read(MII_LXT971_SR2), mii_parse_lxt971_sr2 },
  938. /* we only need to read ISR to acknowledge */
  940. { mk_mii_read(MII_LXT971_ISR), NULL },
  941. { mk_mii_end, }
  942. },
  943. (const phy_cmd_t []) {  /* shutdown - disable interrupts */
  944. { mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
  945. { mk_mii_end, }
  946. },
  947. };
  949. #endif /* CONFIG_FEC_LXT970 */
  952. /* ------------------------------------------------------------------------- */
  953. /* The Quality Semiconductor QS6612 is used on the RPX CLLF                  */
  955. #ifdef CONFIG_FEC_QS6612
  957. /* register definitions */
  959. #define MII_QS6612_MCR       17  /* Mode Control Register      */
  960. #define MII_QS6612_FTR       27  /* Factory Test Register      */
  961. #define MII_QS6612_MCO       28  /* Misc. Control Register     */
  962. #define MII_QS6612_ISR       29  /* Interrupt Source Register  */
  963. #define MII_QS6612_IMR       30  /* Interrupt Mask Register    */
  964. #define MII_QS6612_PCR       31  /* 100BaseTx PHY Control Reg. */
  966. static void mii_parse_qs6612_pcr(uint mii_reg, struct net_device *dev, uint data)
  967. {
  968. struct fec_enet_private *fep = dev->priv;
  969. volatile uint *s = &(fep->phy_status);
  971. *s &= ~(PHY_STAT_SPMASK);
  973. switch((mii_reg >> 2) & 7) {
  974. case 1: *s |= PHY_STAT_10HDX; break;
  975. case 2: *s |= PHY_STAT_100HDX; break;
  976. case 5: *s |= PHY_STAT_10FDX; break;
  977. case 6: *s |= PHY_STAT_100FDX; break;
  978. }
  979. }
  981. static phy_info_t phy_info_qs6612 = {
  982. 0x00181440,
  983. "QS6612",
  985. (const phy_cmd_t []) {  /* config */
  986. // { mk_mii_write(MII_REG_ANAR, 0x061), NULL }, /* 10  Mbps */
  988. /* The PHY powers up isolated on the RPX,
  989.  * so send a command to allow operation.
  990.  */
  992. { mk_mii_write(MII_QS6612_PCR, 0x0dc0), NULL },
  994. /* parse cr and anar to get some info */
  996. { mk_mii_read(MII_REG_CR), mii_parse_cr },
  997. { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
  998. { mk_mii_end, }
  999. },
  1000. (const phy_cmd_t []) {  /* startup - enable interrupts */
  1001. { mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
  1002. { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
  1003. { mk_mii_end, }
  1004. },
  1005. (const phy_cmd_t []) { /* ack_int */
  1007. /* we need to read ISR, SR and ANER to acknowledge */
  1009. { mk_mii_read(MII_QS6612_ISR), NULL },
  1010. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  1011. { mk_mii_read(MII_REG_ANER), NULL },
  1013. /* read pcr to get info */
  1015. { mk_mii_read(MII_QS6612_PCR), mii_parse_qs6612_pcr },
  1016. { mk_mii_end, }
  1017. },
  1018. (const phy_cmd_t []) {  /* shutdown - disable interrupts */
  1019. { mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
  1020. { mk_mii_end, }
  1021. },
  1022. };
  1025. #endif /* CONFIG_FEC_QS6612 */
  1028. /* -------------------------------------------------------------------- */
  1029. /* The National Semiconductor DP83843BVJE is used on a Mediatrix board  */
  1030. /* -------------------------------------------------------------------- */
  1032. #ifdef CONFIG_FEC_DP83843
  1034. /* Register definitions */
  1035. #define MII_DP83843_PHYSTS 0x10  /* PHY Status Register */
  1036. #define MII_DP83843_MIPSCR 0x11  /* Specific Status Register */
  1037. #define MII_DP83843_MIPGSR 0x12  /* Generic Status Register */
  1039. static void mii_parse_dp83843_physts(uint mii_reg, struct net_device *dev, uint data)
  1040. {
  1041. struct fec_enet_private *fep = dev->priv;
  1042. volatile uint *s = &(fep->phy_status);
  1044. *s &= ~(PHY_STAT_SPMASK);
  1046. if (mii_reg & 0x0002)
  1047. {
  1048. if (mii_reg & 0x0004)
  1049. *s |= PHY_STAT_10FDX;
  1050. else
  1051. *s |= PHY_STAT_10HDX;
  1052. }
  1053. else
  1054. {
  1055. if (mii_reg & 0x0004)
  1056. *s |= PHY_STAT_100FDX;
  1057. else
  1058. *s |= PHY_STAT_100HDX;
  1059. }
  1060. }
  1062. static phy_info_t phy_info_dp83843 = {
  1063. 0x020005c1,
  1064. "DP83843BVJE",
  1066. (const phy_cmd_t []) {  /* config */  
  1067. { mk_mii_write(MII_REG_ANAR, 0x01E1), NULL  }, /* Auto-Negociation Register Control set to    */
  1068.                                                /* auto-negociate 10/100MBps, Half/Full duplex */
  1069. { mk_mii_read(MII_REG_CR),   mii_parse_cr   },
  1070. { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
  1071. { mk_mii_end, }
  1072. },
  1073. (const phy_cmd_t []) {  /* startup */
  1074. { mk_mii_write(MII_DP83843_MIPSCR, 0x0002), NULL }, /* Enable interrupts */
  1075. { mk_mii_write(MII_REG_CR, 0x1200), NULL         }, /* Enable and Restart Auto-Negotiation */
  1076. { mk_mii_read(MII_REG_SR), mii_parse_sr          },
  1077. { mk_mii_read(MII_REG_CR), mii_parse_cr },
  1078. { mk_mii_read(MII_DP83843_PHYSTS), mii_parse_dp83843_physts },
  1079. { mk_mii_end, }
  1080. },
  1081. (const phy_cmd_t []) { /* ack_int */
  1082. { mk_mii_read(MII_DP83843_MIPGSR), NULL },  /* Acknowledge interrupts */
  1083. { mk_mii_read(MII_REG_SR), mii_parse_sr },  /* Find out the current status */
  1084. { mk_mii_read(MII_REG_CR), mii_parse_cr },
  1085. { mk_mii_read(MII_DP83843_PHYSTS), mii_parse_dp83843_physts },
  1086. { mk_mii_end, }
  1087. },
  1088. (const phy_cmd_t []) {  /* shutdown - disable interrupts */
  1089. { mk_mii_end, }
  1090. }
  1091. };
  1093. #endif /* CONFIG_FEC_DP83843 */
  1096. /* ----------------------------------------------------------------- */
  1097. /* The National Semiconductor DP83846A is used on a Mediatrix board  */
  1098. /* ----------------------------------------------------------------- */
  1100. #ifdef CONFIG_FEC_DP83846A
  1102. /* Register definitions */
  1103. #define MII_DP83846A_PHYSTS 0x10  /* PHY Status Register */
  1105. static void mii_parse_dp83846a_physts(uint mii_reg, struct net_device *dev, uint data)
  1106. {
  1107. struct fec_enet_private *fep = (struct fec_enet_private *)dev->priv;
  1108. volatile uint *s = &(fep->phy_status);
  1109. int link_change_mask;
  1111. *s &= ~(PHY_STAT_SPMASK);
  1113. if (mii_reg & 0x0002) {
  1114. if (mii_reg & 0x0004)
  1115. *s |= PHY_STAT_10FDX;
  1116. else
  1117. *s |= PHY_STAT_10HDX;
  1118. }
  1119. else {
  1120. if (mii_reg & 0x0004)
  1121. *s |= PHY_STAT_100FDX;
  1122. else
  1123. *s |= PHY_STAT_100HDX;
  1124. }
  1126. link_change_mask = PHY_STAT_LINK | PHY_STAT_10FDX | PHY_STAT_10HDX | PHY_STAT_100FDX | PHY_STAT_100HDX;
  1127. if(fep->old_status != (link_change_mask & *s))
  1128. {
  1129. fep->old_status = (link_change_mask & *s);
  1130. mii_queue_relink(mii_reg, dev, 0);
  1131. }
  1132. }
  1134. static phy_info_t phy_info_dp83846a = {
  1135. 0x020005c2,
  1136. "DP83846A",
  1138. (const phy_cmd_t []) {  /* config */  
  1139. { mk_mii_write(MII_REG_ANAR, 0x01E1), NULL  }, /* Auto-Negociation Register Control set to    */
  1140.                                                /* auto-negociate 10/100MBps, Half/Full duplex */
  1141. { mk_mii_read(MII_REG_CR),   mii_parse_cr   },
  1142. { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
  1143. { mk_mii_end, }
  1144. },
  1145. (const phy_cmd_t []) {  /* startup */
  1146. { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* Enable and Restart Auto-Negotiation */
  1147. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  1148. { mk_mii_read(MII_REG_CR), mii_parse_cr   },
  1149. { mk_mii_read(MII_DP83846A_PHYSTS), mii_parse_dp83846a_physts },
  1150. { mk_mii_end, }
  1151. },
  1152. (const phy_cmd_t []) { /* ack_int */
  1153. { mk_mii_read(MII_REG_SR), mii_parse_sr },
  1154. { mk_mii_read(MII_REG_CR), mii_parse_cr   },
  1155. { mk_mii_read(MII_DP83846A_PHYSTS), mii_parse_dp83846a_physts },
  1156. { mk_mii_end, }
  1157. },
  1158. (const phy_cmd_t []) {  /* shutdown - disable interrupts */
  1159. { mk_mii_end, }
  1160. }
  1161. };
  1163. #endif /* CONFIG_FEC_DP83846A */
  1166. static phy_info_t *phy_info[] = {
  1168. #ifdef CONFIG_FEC_LXT970
  1169. &phy_info_lxt970,
  1170. #endif /* CONFIG_FEC_LXT970 */
  1172. #ifdef CONFIG_FEC_LXT971
  1173. &phy_info_lxt971,
  1174. #endif /* CONFIG_FEC_LXT971 */
  1176. #ifdef CONFIG_FEC_QS6612
  1177. &phy_info_qs6612,
  1178. #endif /* CONFIG_FEC_LXT971 */
  1180. #ifdef CONFIG_FEC_DP83843
  1181. &phy_info_dp83843,
  1182. #endif /* CONFIG_FEC_DP83843 */
  1184. #ifdef CONFIG_FEC_DP83846A
  1185. &phy_info_dp83846a,
  1186. #endif /* CONFIG_FEC_DP83846A */
  1188. NULL
  1189. };
  1191. static void mii_display_status(struct net_device *dev)
  1192. {
  1193. struct fec_enet_private *fep = dev->priv;
  1194. volatile uint *s = &(fep->phy_status);
  1196. if (!fep->link && !fep->old_link) {
  1197. /* Link is still down - don't print anything */
  1198. return;
  1199. }
  1201. printk("%s: status: ", dev->name);
  1203. if (!fep->link) {
  1204. printk("link down");
  1205. } else {
  1206. printk("link up");
  1208. switch(*s & PHY_STAT_SPMASK) {
  1209. case PHY_STAT_100FDX: printk(", 100 Mbps Full Duplex"); break;
  1210. case PHY_STAT_100HDX: printk(", 100 Mbps Half Duplex"); break;
  1211. case PHY_STAT_10FDX: printk(", 10 Mbps Full Duplex"); break;
  1212. case PHY_STAT_10HDX: printk(", 10 Mbps Half Duplex"); break;
  1213. default:
  1214. printk(", Unknown speed/duplex");
  1215. }
  1217. if (*s & PHY_STAT_ANC)
  1218. printk(", auto-negotiation complete");
  1219. }
  1221. if (*s & PHY_STAT_FAULT)
  1222. printk(", remote fault");
  1224. printk(".n");
  1225. }
  1227. static void mii_display_config(struct net_device *dev)
  1228. {
  1229. struct fec_enet_private *fep = dev->priv;
  1230. volatile uint *s = &(fep->phy_status);
  1232. printk("%s: config: auto-negotiation ", dev->name);
  1234. if (*s & PHY_CONF_ANE)
  1235. printk("on");
  1236. else
  1237. printk("off");
  1239. if (*s & PHY_CONF_100FDX)
  1240. printk(", 100FDX");
  1241. if (*s & PHY_CONF_100HDX)
  1242. printk(", 100HDX");
  1243. if (*s & PHY_CONF_10FDX)
  1244. printk(", 10FDX");
  1245. if (*s & PHY_CONF_10HDX)
  1246. printk(", 10HDX");
  1247. if (!(*s & PHY_CONF_SPMASK))
  1248. printk(", No speed/duplex selected?");
  1250. if (*s & PHY_CONF_LOOP)
  1251. printk(", loopback enabled");
  1253. printk(".n");
  1255. fep->sequence_done = 1;
  1256. }
  1258. static void mii_relink(struct net_device *dev)
  1259. {
  1260. struct fec_enet_private *fep = dev->priv;
  1261. int duplex;
  1263. fep->link = (fep->phy_status & PHY_STAT_LINK) ? 1 : 0;
  1264. mii_display_status(dev);
  1265. fep->old_link = fep->link;
  1267. if (fep->link) {
  1268. duplex = 0;
  1269. if (fep->phy_status
  1270.     & (PHY_STAT_100FDX | PHY_STAT_10FDX))
  1271. duplex = 1;
  1272. fec_restart(dev, duplex);
  1273. }
  1274. else
  1275. fec_stop(dev);
  1277. #if 0
  1278. enable_irq(fep->mii_irq);
  1279. #endif
  1281. }
  1283. static void mii_queue_relink(uint mii_reg, struct net_device *dev, uint data)
  1284. {
  1285. struct fec_enet_private *fep = dev->priv;
  1287. fep->phy_task.routine = (void *)mii_relink;
  1288. fep->phy_task.data = dev;
  1289. schedule_task(&fep->phy_task);
  1290. }
  1292. static void mii_queue_config(uint mii_reg, struct net_device *dev, uint data)
  1293. {
  1294. struct fec_enet_private *fep = dev->priv;
  1296. fep->phy_task.routine = (void *)mii_display_config;
  1297. fep->phy_task.data = dev;
  1298. schedule_task(&fep->phy_task);
  1299. }
  1303. phy_cmd_t phy_cmd_relink[] = { { mk_mii_read(MII_REG_CR), mii_queue_relink },
  1304.        { mk_mii_end, } };
  1305. phy_cmd_t phy_cmd_config[] = { { mk_mii_read(MII_REG_CR), mii_queue_config },
  1306.        { mk_mii_end, } };
  1310. /* Read remainder of PHY ID.
  1311. */
  1312. static void
  1313. mii_discover_phy3(uint mii_reg, struct net_device *dev, uint data)
  1314. {
  1315. struct fec_enet_private *fep;
  1316. int i;
  1318. fep = dev->priv;
  1319. fep->phy_id |= (mii_reg & 0xffff);
  1321. for(i = 0; phy_info[i]; i++)
  1322. if(phy_info[i]->id == (fep->phy_id >> 4))
  1323. break;
  1325. if(!phy_info[i])
  1326. panic("%s: PHY id 0x%08x is not supported!n",
  1327.       dev->name, fep->phy_id);
  1329. fep->phy = phy_info[i];
  1330. fep->phy_id_done = 1;
  1332. printk("%s: Phy @ 0x%x, type %s (0x%08x)n",
  1333. dev->name, fep->phy_addr, fep->phy->name, fep->phy_id);
  1334. }
  1336. /* Scan all of the MII PHY addresses looking for someone to respond
  1337.  * with a valid ID.  This usually happens quickly.
  1338.  */
  1339. static void
  1340. mii_discover_phy(uint mii_reg, struct net_device *dev, uint data)
  1341. {
  1342. struct fec_enet_private *fep;
  1343. uint phytype;
  1345. fep = dev->priv;
  1347. if ((phytype = (mii_reg & 0xffff)) != 0xffff) {
  1349. /* Got first part of ID, now get remainder.
  1350. */
  1351. fep->phy_id = phytype << 16;
  1352. mii_queue(dev, mk_mii_read(MII_REG_PHYIR2), mii_discover_phy3, 0);
  1353. } else {
  1354. fep->phy_addr++;
  1355. if (fep->phy_addr < 32) {
  1356. mii_queue(dev, mk_mii_read(MII_REG_PHYIR1),
  1357. mii_discover_phy, 0);
  1358. } else {
  1359. printk("fec: No PHY device found.n");
  1360. }
  1361. }
  1362. }
  1363. #endif /* CONFIG_USE_MDIO */
  1365. /* This interrupt occurs when the PHY detects a link change.
  1366. */
  1367. static void
  1368. #ifdef CONFIG_RPXCLASSIC
  1369. mii_link_interrupt(void *dev_id)
  1370. #else
  1371. mii_link_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  1372. #endif
  1373. {
  1374. #ifdef CONFIG_USE_MDIO
  1375. struct net_device *dev = dev_id;
  1376. struct fec_enet_private *fep = dev->priv;
  1377. volatile immap_t *immap = (immap_t *)IMAP_ADDR;
  1378. volatile fec_t *fecp = &(immap->im_cpm.cp_fec);
  1379. unsigned int ecntrl = fecp->fec_ecntrl;
  1381. /* We need the FEC enabled to access the MII
  1382. */
  1383. if ((ecntrl & FEC_ECNTRL_ETHER_EN) == 0) {
  1384. fecp->fec_ecntrl |= FEC_ECNTRL_ETHER_EN;
  1385. }
  1386. #endif /* CONFIG_USE_MDIO */
  1388. #if 0
  1389. disable_irq(fep->mii_irq);  /* disable now, enable later */
  1390. #endif
  1393. #ifdef CONFIG_USE_MDIO
  1394. mii_do_cmd(dev, fep->phy->ack_int);
  1395. mii_do_cmd(dev, phy_cmd_relink);  /* restart and display status */
  1397. if ((ecntrl & FEC_ECNTRL_ETHER_EN) == 0) {
  1398. fecp->fec_ecntrl = ecntrl; /* restore old settings */
  1399. }
  1400. #else
  1401. printk("%s[%d] %s: unexpected Link interruptn", __FILE__,__LINE__,__FUNCTION__);
  1402. #endif /* CONFIG_USE_MDIO */
  1404. }
  1406. static int
  1407. fec_enet_open(struct net_device *dev)
  1408. {
  1409. struct fec_enet_private *fep = dev->priv;
  1411. /* I should reset the ring buffers here, but I don't yet know
  1412.  * a simple way to do that.
  1413.  */
  1415. #ifdef CONFIG_USE_MDIO
  1416. fep->sequence_done = 0;
  1417. fep->link = 0;
  1419. if (fep->phy) {
  1420. mii_do_cmd(dev, fep->phy->config);
  1421. mii_do_cmd(dev, phy_cmd_config);  /* display configuration */
  1422. while(!fep->sequence_done)
  1423. schedule();
  1425. mii_do_cmd(dev, fep->phy->startup);
  1427. #if defined(CONFIG_USE_MDIO) && defined(CONFIG_FEC_DP83846A)
  1428. if(fep->phy == &phy_info_dp83846a)
  1429. {
  1430. /* Initializing timers
  1431.  */
  1432. init_timer( &fep->phy_timer_list ); 
  1434. /* Starting timer for periodic link status check
  1435.  * After 100 milli-seconds, mdio_timer_callback function is called.
  1436.  */
  1437. fep->phy_timer_list.expires  = jiffies + (100 * HZ / 1000);
  1438. fep->phy_timer_list.data     = (unsigned long)dev;
  1439. fep->phy_timer_list.function = mdio_timer_callback;
  1440. add_timer( &fep->phy_timer_list );
  1441. }
  1443. #if defined(CONFIG_IP_PNP)
  1444.         printk("%s: Waiting for the link to be up...n", dev->name);
  1446.         while(fep->link == 0 || ((((volatile fec_t*)dev->base_addr)->fec_ecntrl & FEC_ECNTRL_ETHER_EN) == 0))
  1447.         {
  1448.             schedule();
  1449.         }
  1450. #endif /* CONFIG_IP_PNP */
  1452. #endif /* CONFIG_USE_MDIO && CONFIG_FEC_DP83846A */
  1454. netif_start_queue(dev);
  1455. return 0; /* Success */
  1456. }
  1457. return -ENODEV; /* No PHY we understand */
  1458. #else
  1459. fep->link = 1;
  1460. netif_start_queue(dev);
  1461. return 0; /* Success */
  1462. #endif /* CONFIG_USE_MDIO */
  1464. }
  1466. static int
  1467. fec_enet_close(struct net_device *dev)
  1468. {
  1469. /* Don't know what to do yet.
  1470. */
  1471. netif_stop_queue(dev);
  1472. fec_stop(dev);
  1474. return 0;
  1475. }
  1477. static struct net_device_stats *fec_enet_get_stats(struct net_device *dev)
  1478. {
  1479. struct fec_enet_private *fep = (struct fec_enet_private *)dev->priv;
  1481. return &fep->stats;
  1482. }
  1484. #ifdef CONFIG_USE_MDIO
  1486. #if defined(CONFIG_FEC_DP83846A)
  1487. /* Execute the ack_int command set and schedules next timer call back.  */
  1488. static void mdio_timer_callback(unsigned long data)
  1489. {
  1490. struct net_device *dev = (struct net_device *)data;
  1491. struct fec_enet_private *fep = (struct fec_enet_private *)(dev->priv);
  1492. mii_do_cmd(dev, fep->phy->ack_int);
  1494. if(fep->link == 0)
  1495. {
  1496. fep->phy_timer_list.expires  = jiffies + (100 * HZ / 1000); /* Sleep for 100ms */
  1497. }
  1498. else
  1499. {
  1500. fep->phy_timer_list.expires  = jiffies + (1 * HZ); /* Sleep for 1 sec. */
  1501. }
  1502. add_timer( &fep->phy_timer_list ); 
  1503. }
  1504. #endif /* CONFIG_FEC_DP83846A */
  1506. static void mdio_callback(uint regval, struct net_device *dev, uint data)
  1507. {
  1508. mdio_read_data_t* mrd = (mdio_read_data_t *)data;
  1509. mrd->regval = 0xFFFF & regval;
  1510. wake_up_process(mrd->sleeping_task);
  1511. }
  1513. static int mdio_read(struct net_device *dev, int phy_id, int location)
  1514. {
  1515. uint retval;
  1516. mdio_read_data_t* mrd = (mdio_read_data_t *)kmalloc(sizeof(*mrd), GFP_KERNEL);
  1518. mrd->sleeping_task = current;
  1519. set_current_state(TASK_INTERRUPTIBLE);
  1520. mii_queue(dev, mk_mii_read(location), mdio_callback, (unsigned int) mrd);
  1521. schedule();
  1523. retval = mrd->regval;
  1525. kfree(mrd);
  1527. return retval;
  1528. }
  1530. void mdio_write(struct net_device *dev, int phy_id, int location, int value)
  1531. {
  1532. mii_queue(dev, mk_mii_write(location, value), NULL, 0);
  1533. }
  1535. static int fec_enet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1536. {
  1537. struct fec_enet_private *cep = (struct fec_enet_private *)dev->priv;
  1538. struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1540. int phy = cep->phy_addr & 0x1f;
  1541. int retval;
  1543. if (data == NULL)
  1544. {
  1545. retval = -EINVAL;
  1546. }
  1547. else
  1548. {
  1549. switch(cmd)
  1550. {
  1551. case SIOCETHTOOL:
  1552. return netdev_ethtool_ioctl(dev, (void*)rq->ifr_data);
  1553. break;
  1555. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1556. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  1557. data->phy_id = phy;
  1559. case SIOCGMIIREG: /* Read MII PHY register. */
  1560. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  1561. data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
  1562. retval = 0;
  1563. break;
  1565. case SIOCSMIIREG: /* Write MII PHY register. */
  1566. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  1567. if (!capable(CAP_NET_ADMIN))
  1568. {
  1569. retval = -EPERM;
  1570. }
  1571. else
  1572. {
  1573. mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
  1574. retval = 0;
  1575. }
  1576. break;
  1578. default:
  1579. retval = -EOPNOTSUPP;
  1580. break;
  1581. }
  1582. }
  1583. return retval;
  1584. }
  1587. static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1588. {
  1589. u32 ethcmd;
  1591. /* dev_ioctl() in ../../net/core/dev.c has already checked
  1592.    capable(CAP_NET_ADMIN), so don't bother with that here.  */
  1594. if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
  1595. return -EFAULT;
  1597. switch (ethcmd) {
  1598. case ETHTOOL_GDRVINFO:
  1599. {
  1600. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1601. strcpy (info.driver, dev->name);
  1602. strcpy (info.version, "0.2");
  1603. strcpy (info.bus_info, "");
  1604. if (copy_to_user (useraddr, &info, sizeof (info)))
  1605. return -EFAULT;
  1606. return 0;
  1607. }
  1608. default:
  1609. break;
  1610. }
  1612. return -EOPNOTSUPP;
  1613. }
  1615. #endif /* CONFIG_USE_MDIO */
  1617. /* Set or clear the multicast filter for this adaptor.
  1618.  * Skeleton taken from sunlance driver.
  1619.  * The CPM Ethernet implementation allows Multicast as well as individual
  1620.  * MAC address filtering.  Some of the drivers check to make sure it is
  1621.  * a group multicast address, and discard those that are not.  I guess I
  1622.  * will do the same for now, but just remove the test if you want
  1623.  * individual filtering as well (do the upper net layers want or support
  1624.  * this kind of feature?).
  1625.  */
  1627. static void set_multicast_list(struct net_device *dev)
  1628. {
  1629. struct fec_enet_private *fep;
  1630. volatile fec_t *ep;
  1632. fep = (struct fec_enet_private *)dev->priv;
  1633. ep = &(((immap_t *)IMAP_ADDR)->im_cpm.cp_fec);
  1635. if (dev->flags&IFF_PROMISC) {
  1637. /* Log any net taps. */
  1638. printk("%s: Promiscuous mode enabled.n", dev->name);
  1639. ep->fec_r_cntrl |= FEC_RCNTRL_PROM;
  1640. } else {
  1642. ep->fec_r_cntrl &= ~FEC_RCNTRL_PROM;
  1644. if (dev->flags & IFF_ALLMULTI) {
  1645. /* Catch all multicast addresses, so set the
  1646.  * filter to all 1's.
  1647.  */
  1648. ep->fec_hash_table_high = 0xffffffff;
  1649. ep->fec_hash_table_low = 0xffffffff;
  1650. }
  1651. #if 0
  1652. else {
  1653. /* Clear filter and add the addresses in the list.
  1654. */
  1655. ep->sen_gaddr1 = 0;
  1656. ep->sen_gaddr2 = 0;
  1657. ep->sen_gaddr3 = 0;
  1658. ep->sen_gaddr4 = 0;
  1660. dmi = dev->mc_list;
  1662. for (i=0; i<dev->mc_count; i++) {
  1664. /* Only support group multicast for now.
  1665. */
  1666. if (!(dmi->dmi_addr[0] & 1))
  1667. continue;
  1669. /* The address in dmi_addr is LSB first,
  1670.  * and taddr is MSB first.  We have to
  1671.  * copy bytes MSB first from dmi_addr.
  1672.  */
  1673. mcptr = (u_char *)dmi->dmi_addr + 5;
  1674. tdptr = (u_char *)&ep->sen_taddrh;
  1675. for (j=0; j<6; j++)
  1676. *tdptr++ = *mcptr--;
  1678. /* Ask CPM to run CRC and set bit in
  1679.  * filter mask.
  1680.  */
  1681. cpmp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SCC1, CPM_CR_SET_GADDR) | CPM_CR_FLG;
  1682. /* this delay is necessary here -- Cort */
  1683. udelay(10);
  1684. while (cpmp->cp_cpcr & CPM_CR_FLG);
  1685. }
  1686. }
  1687. #endif
  1688. }
  1689. }
  1691. /* Initialize the FEC Ethernet on 860T.
  1692.  */
  1693. int __init fec_enet_init(void)
  1694. {
  1695. struct net_device *dev;
  1696. struct fec_enet_private *fep;
  1697. int i, j;
  1698. unsigned char *eap, *iap;
  1699. unsigned long mem_addr;
  1700. pte_t *pte;
  1701. volatile cbd_t *bdp;
  1702. cbd_t *cbd_base;
  1703. volatile immap_t *immap;
  1704. volatile fec_t *fecp;
  1705. bd_t *bd;
  1706. #ifdef CONFIG_SCC_ENET
  1707. unsigned char tmpaddr[6];
  1708. #endif
  1710. immap = (immap_t *)IMAP_ADDR; /* pointer to internal registers */
  1712. bd = (bd_t *)__res;
  1714. /* Allocate some private information.
  1715. */
  1716. fep = (struct fec_enet_private *)kmalloc(sizeof(*fep), GFP_KERNEL);
  1717. if (fep == NULL)
  1718. return -ENOMEM;
  1720. __clear_user(fep,sizeof(*fep));
  1722. /* Create an Ethernet device instance.
  1723. */
  1724. dev = init_etherdev(0, 0);
  1726. fecp = &(immap->im_cpm.cp_fec);
  1728. /* Whack a reset.  We should wait for this.
  1729. */
  1730. fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET;
  1731. for (i = 0;
  1732.      (fecp->fec_ecntrl & FEC_ECNTRL_RESET) && (i < FEC_RESET_DELAY);
  1733.      ++i) {
  1734. udelay(1);
  1735. }
  1736. if (i == FEC_RESET_DELAY) {
  1737. printk ("FEC Reset timeout!n");
  1738. }
  1740. /* Set the Ethernet address.  If using multiple Enets on the 8xx,
  1741.  * this needs some work to get unique addresses.
  1742.  */
  1743. eap = (unsigned char *)my_enet_addr;
  1744. iap = bd->bi_enetaddr;
  1746. #ifdef CONFIG_SCC_ENET
  1747. /*
  1748.          * If a board has Ethernet configured both on a SCC and the
  1749.          * FEC, it needs (at least) 2 MAC addresses (we know that Sun
  1750.          * disagrees, but anyway). For the FEC port, we create
  1751.          * another address by setting one of the address bits above
  1752.          * something that would have (up to now) been allocated.
  1753.  */
  1754. for (i=0; i<6; i++)
  1755. tmpaddr[i] = *iap++;
  1756. tmpaddr[3] |= 0x80;
  1757. iap = tmpaddr;
  1758. #endif
  1760. for (i=0; i<6; i++) {
  1761. dev->dev_addr[i] = *eap++ = *iap++;
  1762. }
  1764. /* Allocate memory for buffer descriptors.
  1765. */
  1766. if (((RX_RING_SIZE + TX_RING_SIZE) * sizeof(cbd_t)) > PAGE_SIZE) {
  1767. printk("FEC init error.  Need more space.n");
  1768. printk("FEC initialization failed.n");
  1769. return 1;
  1770. }
  1771. mem_addr = __get_free_page(GFP_KERNEL);
  1772. cbd_base = (cbd_t *)mem_addr;
  1774. /* Make it uncached.
  1775. */
  1776. pte = va_to_pte(mem_addr);
  1777. pte_val(*pte) |= _PAGE_NO_CACHE;
  1778. flush_tlb_page(init_mm.mmap, mem_addr);
  1780. /* Set receive and transmit descriptor base.
  1781. */
  1782. fep->rx_bd_base = cbd_base;
  1783. fep->tx_bd_base = cbd_base + RX_RING_SIZE;
  1785. fep->skb_cur = fep->skb_dirty = 0;
  1787. /* Initialize the receive buffer descriptors.
  1788. */
  1789. bdp = fep->rx_bd_base;
  1790. for (i=0; i<FEC_ENET_RX_PAGES; i++) {
  1792. /* Allocate a page.
  1793. */
  1794. mem_addr = __get_free_page(GFP_KERNEL);
  1796. /* Make it uncached.
  1797. */
  1798. pte = va_to_pte(mem_addr);
  1799. pte_val(*pte) |= _PAGE_NO_CACHE;
  1800. flush_tlb_page(init_mm.mmap, mem_addr);
  1802. /* Initialize the BD for every fragment in the page.
  1803. */
  1804. for (j=0; j<FEC_ENET_RX_FRPPG; j++) {
  1805. bdp->cbd_sc = BD_ENET_RX_EMPTY;
  1806. bdp->cbd_bufaddr = __pa(mem_addr);
  1807. mem_addr += FEC_ENET_RX_FRSIZE;
  1808. bdp++;
  1809. }
  1810. }
  1812. /* Set the last buffer to wrap.
  1813. */
  1814. bdp--;
  1815. bdp->cbd_sc |= BD_SC_WRAP;
  1817. /* Install our interrupt handler. */
  1818. if (request_8xxirq(FEC_INTERRUPT, fec_enet_interrupt, 0, "fec", dev) != 0)
  1819. panic("Could not allocate FEC IRQ!");
  1821. #ifdef CONFIG_RPXCLASSIC
  1822. /* Make Port C, bit 15 an input that causes interrupts.
  1823. */
  1824. immap->im_ioport.iop_pcpar &= ~0x0001;
  1825. immap->im_ioport.iop_pcdir &= ~0x0001;
  1826. immap->im_ioport.iop_pcso  &= ~0x0001;
  1827. immap->im_ioport.iop_pcint |=  0x0001;
  1828. cpm_install_handler(CPMVEC_PIO_PC15, mii_link_interrupt, dev);
  1830. /* Make LEDS reflect Link status.
  1831. */
  1832. *((uint *) RPX_CSR_ADDR) &= ~BCSR2_FETHLEDMODE;
  1833. #endif
  1835. #ifdef PHY_INTERRUPT
  1836. ((immap_t *)IMAP_ADDR)->im_siu_conf.sc_siel |=
  1837. (0x80000000 >> PHY_INTERRUPT);
  1839. if (request_8xxirq(PHY_INTERRUPT, mii_link_interrupt, 0, "mii", dev) != 0)
  1840. panic("Could not allocate MII IRQ!");
  1841. #endif
  1843. dev->base_addr = (unsigned long)fecp;
  1844. dev->priv = fep;
  1846. /* The FEC Ethernet specific entries in the device structure. */
  1847. dev->open = fec_enet_open;
  1848. dev->hard_start_xmit = fec_enet_start_xmit;
  1849. dev->tx_timeout = fec_timeout;
  1850. dev->watchdog_timeo = TX_TIMEOUT;
  1851. dev->stop = fec_enet_close;
  1852. dev->get_stats = fec_enet_get_stats;
  1853. dev->set_multicast_list = set_multicast_list;
  1855. #ifdef CONFIG_USE_MDIO
  1856. dev->do_ioctl = fec_enet_ioctl;
  1858. for (i=0; i<NMII-1; i++)
  1859. mii_cmds[i].mii_next = &mii_cmds[i+1];
  1860. mii_free = mii_cmds;
  1861. #endif /* CONFIG_USE_MDIO */
  1863. /* Configure all of port D for MII.
  1864. */
  1865. immap->im_ioport.iop_pdpar = 0x1fff;
  1867. /* Bits moved from Rev. D onward.
  1868. */
  1869. if ((mfspr(IMMR) & 0xffff) < 0x0501)
  1870. immap->im_ioport.iop_pddir = 0x1c58; /* Pre rev. D */
  1871. else
  1872. immap->im_ioport.iop_pddir = 0x1fff; /* Rev. D and later */
  1874. #ifdef CONFIG_USE_MDIO
  1875. /* Set MII speed to 2.5 MHz
  1876. */
  1877. fecp->fec_mii_speed = fep->phy_speed =
  1878. (( (bd->bi_intfreq + 500000) / 2500000 / 2 ) & 0x3F ) << 1;
  1879. #else
  1880. fecp->fec_mii_speed = 0; /* turn off MDIO */
  1881. #endif /* CONFIG_USE_MDIO */
  1883. printk ("%s: FEC ENET Version 0.2, FEC irq %d"
  1884. #ifdef PHY_INTERRUPT
  1885. ", MII irq %d"
  1886. #endif
  1887. ", addr ",
  1888. dev->name, FEC_INTERRUPT
  1889. #ifdef PHY_INTERRUPT
  1890. , PHY_INTERRUPT
  1891. #endif
  1892. );
  1893. for (i=0; i<6; i++)
  1894. printk("%02x%c", dev->dev_addr[i], (i==5) ? 'n' : ':');
  1896. #ifdef CONFIG_USE_MDIO /* start in full duplex mode, and negotiate speed */
  1897. fec_restart (dev, 1);
  1898. #else /* always use half duplex mode only */
  1899. fec_restart (dev, 0);
  1900. #endif
  1902. #ifdef CONFIG_USE_MDIO
  1903. /* Queue up command to detect the PHY and initialize the
  1904.  * remainder of the interface.
  1905.  */
  1906. fep->phy_id_done = 0;
  1907. fep->phy_addr = 0;
  1908. mii_queue(dev, mk_mii_read(MII_REG_PHYIR1), mii_discover_phy, 0);
  1909. #endif /* CONFIG_USE_MDIO */
  1911. fep->old_status = 0;
  1913. return 0;
  1914. }
  1916. /* This function is called to start or restart the FEC during a link
  1917.  * change.  This only happens when switching between half and full
  1918.  * duplex.
  1919.  */
  1920. static void
  1921. fec_restart(struct net_device *dev, int duplex)
  1922. {
  1923. struct fec_enet_private *fep;
  1924. int i;
  1925. volatile cbd_t *bdp;
  1926. volatile immap_t *immap;
  1927. volatile fec_t *fecp;
  1929. immap = (immap_t *)IMAP_ADDR; /* pointer to internal registers */
  1931. fecp = &(immap->im_cpm.cp_fec);
  1933. fep = dev->priv;
  1935. /* Whack a reset.  We should wait for this.
  1936. */
  1937. fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET;
  1938. for (i = 0;
  1939.      (fecp->fec_ecntrl & FEC_ECNTRL_RESET) && (i < FEC_RESET_DELAY);
  1940.      ++i) {
  1941. udelay(1);
  1942. }
  1943. if (i == FEC_RESET_DELAY) {
  1944. printk ("FEC Reset timeout!n");
  1945. }
  1947. /* Set station address.
  1948. */
  1949. fecp->fec_addr_low  = (my_enet_addr[0] << 16) | my_enet_addr[1];
  1950. fecp->fec_addr_high =  my_enet_addr[2];
  1952. /* Reset all multicast.
  1953. */
  1954. fecp->fec_hash_table_high = 0;
  1955. fecp->fec_hash_table_low  = 0;
  1957. /* Set maximum receive buffer size.
  1958. */
  1959. fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
  1960. fecp->fec_r_hash = PKT_MAXBUF_SIZE;
  1962. /* Set receive and transmit descriptor base.
  1963. */
  1964. fecp->fec_r_des_start = __pa((uint)(fep->rx_bd_base));
  1965. fecp->fec_x_des_start = __pa((uint)(fep->tx_bd_base));
  1967. fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
  1968. fep->cur_rx = fep->rx_bd_base;
  1970. /* Reset SKB transmit buffers.
  1971. */
  1972. fep->skb_cur = fep->skb_dirty = 0;
  1973. for (i=0; i<=TX_RING_MOD_MASK; i++) {
  1974. if (fep->tx_skbuff[i] != NULL) {
  1975. dev_kfree_skb(fep->tx_skbuff[i]);
  1976. fep->tx_skbuff[i] = NULL;
  1977. }
  1978. }
  1980. /* Initialize the receive buffer descriptors.
  1981. */
  1982. bdp = fep->rx_bd_base;
  1983. for (i=0; i<RX_RING_SIZE; i++) {
  1985. /* Initialize the BD for every fragment in the page.
  1986. */
  1987. bdp->cbd_sc = BD_ENET_RX_EMPTY;
  1988. bdp++;
  1989. }
  1991. /* Set the last buffer to wrap.
  1992. */
  1993. bdp--;
  1994. bdp->cbd_sc |= BD_SC_WRAP;
  1996. /* ...and the same for transmmit.
  1997. */
  1998. bdp = fep->tx_bd_base;
  1999. for (i=0; i<TX_RING_SIZE; i++) {
  2001. /* Initialize the BD for every fragment in the page.
  2002. */
  2003. bdp->cbd_sc = 0;
  2004. bdp->cbd_bufaddr = 0;
  2005. bdp++;
  2006. }
  2008. /* Set the last buffer to wrap.
  2009. */
  2010. bdp--;
  2011. bdp->cbd_sc |= BD_SC_WRAP;
  2013. /* Enable MII mode.
  2014. */
  2015. if (duplex) {
  2016. fecp->fec_r_cntrl = FEC_RCNTRL_MII_MODE; /* MII enable */
  2017. fecp->fec_x_cntrl = FEC_TCNTRL_FDEN; /* FD enable */
  2018. }
  2019. else {
  2020. fecp->fec_r_cntrl = FEC_RCNTRL_MII_MODE | FEC_RCNTRL_DRT;
  2021. fecp->fec_x_cntrl = 0;
  2022. }
  2023. fep->full_duplex = duplex;
  2025. /* Enable big endian and don't care about SDMA FC.
  2026. */
  2027. fecp->fec_fun_code = 0x78000000;
  2029. #ifdef CONFIG_USE_MDIO
  2030. /* Set MII speed.
  2031. */
  2032. fecp->fec_mii_speed = fep->phy_speed;
  2033. #endif /* CONFIG_USE_MDIO */
  2035. /* Clear any outstanding interrupt.
  2036. */
  2037. fecp->fec_ievent = 0xffc0;
  2039. fecp->fec_ivec = (FEC_INTERRUPT/2) << 29;
  2041. /* Enable interrupts we wish to service.
  2042. */
  2043. fecp->fec_imask = ( FEC_ENET_TXF | FEC_ENET_TXB |
  2044.     FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_MII );
  2046. /* And last, enable the transmit and receive processing.
  2047. */
  2048. fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN;
  2049. fecp->fec_r_des_active = 0x01000000;
  2051. /* The tx ring is no longer full. */
  2052. if(fep->tx_full)
  2053. {
  2054. fep->tx_full = 0;
  2055. netif_wake_queue(dev);
  2056. }
  2057. }
  2059. static void
  2060. fec_stop(struct net_device *dev)
  2061. {
  2062. volatile immap_t *immap;
  2063. volatile fec_t *fecp;
  2064. struct fec_enet_private *fep;
  2065. int i;
  2067. immap = (immap_t *)IMAP_ADDR; /* pointer to internal registers */
  2069. fecp = &(immap->im_cpm.cp_fec);
  2071. if ((fecp->fec_ecntrl & FEC_ECNTRL_ETHER_EN) == 0)
  2072. return; /* already down */
  2074. fep = dev->priv;
  2077. fecp->fec_x_cntrl = 0x01; /* Graceful transmit stop */
  2079. for (i = 0;
  2080.      ((fecp->fec_ievent & 0x10000000) == 0) && (i < FEC_RESET_DELAY);
  2081.      ++i) {
  2082. udelay(1);
  2083. }
  2084. if (i == FEC_RESET_DELAY) {
  2085. printk ("FEC timeout on graceful transmit stopn");
  2086. }
  2088. /* Clear outstanding MII command interrupts.
  2089. */
  2090. fecp->fec_ievent = FEC_ENET_MII;
  2092. /* Enable MII command finished interrupt
  2093. */
  2094. fecp->fec_ivec = (FEC_INTERRUPT/2) << 29;
  2095. fecp->fec_imask = FEC_ENET_MII;
  2097. #ifdef CONFIG_USE_MDIO
  2098. /* Set MII speed.
  2099. */
  2100. fecp->fec_mii_speed = fep->phy_speed;
  2101. #endif /* CONFIG_USE_MDIO */
  2103. /* Disable FEC
  2104. */
  2105. fecp->fec_ecntrl &= ~(FEC_ECNTRL_ETHER_EN);
  2106. }