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

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

嵌入式Linux

开发平台：

Unix_Linux

gmac.c：源码内容
  1. /*
  2.  * Network device driver for the GMAC ethernet controller on
  3.  * Apple G4 Powermacs.
  4.  *
  5.  * Copyright (C) 2000 Paul Mackerras & Ben. Herrenschmidt
  6.  * 
  7.  * portions based on sunhme.c by David S. Miller
  8.  *
  9.  * Changes:
  10.  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 08/06/2000
  11.  * - check init_etherdev return in gmac_probe1
  12.  * BenH <benh@kernel.crashing.org> - 03/09/2000
  13.  * - Add support for new PHYs
  14.  * - Add some PowerBook sleep code
  15.  * BenH <benh@kernel.crashing.org> - ??/??/????
  16.  *  - PHY updates
  17.  * BenH <benh@kernel.crashing.org> - 08/08/2001
  18.  * - Add more PHYs, fixes to sleep code
  19.  */
  21. #include <linux/module.h>
  23. #include <linux/config.h>
  24. #include <linux/kernel.h>
  25. #include <linux/sched.h>
  26. #include <linux/types.h>
  27. #include <linux/fcntl.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/netdevice.h>
  30. #include <linux/etherdevice.h>
  31. #include <linux/delay.h>
  32. #include <linux/string.h>
  33. #include <linux/timer.h>
  34. #include <linux/init.h>
  35. #include <linux/pci.h>
  36. #include <asm/prom.h>
  37. #include <asm/io.h>
  38. #include <asm/pgtable.h>
  39. #include <asm/machdep.h>
  40. #include <asm/pmac_feature.h>
  41. #include <asm/keylargo.h>
  42. #include <asm/pci-bridge.h>
  43. #ifdef CONFIG_PMAC_PBOOK
  44. #include <linux/adb.h>
  45. #include <linux/pmu.h>
  46. #include <asm/irq.h>
  47. #endif
  49. #include "gmac.h"
  51. #define DEBUG_PHY
  53. /* Driver version 1.5, kernel 2.4.x */
  54. #define GMAC_VERSION "v1.5k4"
  56. #define DUMMY_BUF_LEN RX_BUF_ALLOC_SIZE + RX_OFFSET + GMAC_BUFFER_ALIGN
  57. static unsigned char *dummy_buf;
  58. static struct net_device *gmacs;
  60. /* Prototypes */
  61. static int mii_read(struct gmac *gm, int phy, int r);
  62. static int mii_write(struct gmac *gm, int phy, int r, int v);
  63. static void mii_poll_start(struct gmac *gm);
  64. static void mii_poll_stop(struct gmac *gm);
  65. static void mii_interrupt(struct gmac *gm);
  66. static int mii_lookup_and_reset(struct gmac *gm);
  67. static void mii_setup_phy(struct gmac *gm);
  68. static int mii_do_reset_phy(struct gmac *gm, int phy_addr);
  69. static void mii_init_BCM5400(struct gmac *gm);
  70. static void mii_init_BCM5401(struct gmac *gm);
  72. static void gmac_set_power(struct gmac *gm, int power_up);
  73. static int gmac_powerup_and_reset(struct net_device *dev);
  74. static void gmac_set_gigabit_mode(struct gmac *gm, int gigabit);
  75. static void gmac_set_duplex_mode(struct gmac *gm, int full_duplex);
  76. static void gmac_mac_init(struct gmac *gm, unsigned char *mac_addr);
  77. static void gmac_init_rings(struct gmac *gm, int from_irq);
  78. static void gmac_start_dma(struct gmac *gm);
  79. static void gmac_stop_dma(struct gmac *gm);
  80. static void gmac_set_multicast(struct net_device *dev);
  81. static int gmac_open(struct net_device *dev);
  82. static int gmac_close(struct net_device *dev);
  83. static void gmac_tx_timeout(struct net_device *dev);
  84. static int gmac_xmit_start(struct sk_buff *skb, struct net_device *dev);
  85. static void gmac_tx_cleanup(struct net_device *dev, int force_cleanup);
  86. static void gmac_receive(struct net_device *dev);
  87. static void gmac_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  88. static struct net_device_stats *gmac_stats(struct net_device *dev);
  89. static int gmac_probe(void);
  90. static void gmac_probe1(struct device_node *gmac);
  92. #ifdef CONFIG_PMAC_PBOOK
  93. int gmac_sleep_notify(struct pmu_sleep_notifier *self, int when);
  94. static struct pmu_sleep_notifier gmac_sleep_notifier = {
  95. gmac_sleep_notify, SLEEP_LEVEL_NET,
  96. };
  97. #endif
  99. /*
  100.  * Read via the mii interface from a PHY register
  101.  */
  102. static int
  103. mii_read(struct gmac *gm, int phy, int r)
  104. {
  105. int timeout;
  107. GM_OUT(GM_MIF_FRAME_CTL_DATA,
  108. (0x01 << GM_MIF_FRAME_START_SHIFT) |
  109. (0x02 << GM_MIF_FRAME_OPCODE_SHIFT) |
  110. GM_MIF_FRAME_TURNAROUND_HI |
  111. (phy << GM_MIF_FRAME_PHY_ADDR_SHIFT) |
  112. (r << GM_MIF_FRAME_REG_ADDR_SHIFT));
  114. for (timeout = 1000; timeout > 0; --timeout) {
  115. udelay(20);
  116. if (GM_IN(GM_MIF_FRAME_CTL_DATA) & GM_MIF_FRAME_TURNAROUND_LO)
  117. return GM_IN(GM_MIF_FRAME_CTL_DATA) & GM_MIF_FRAME_DATA_MASK;
  118. }
  119. return -1;
  120. }
  122. /*
  123.  * Write on the mii interface to a PHY register
  124.  */
  125. static int
  126. mii_write(struct gmac *gm, int phy, int r, int v)
  127. {
  128. int timeout;
  130. GM_OUT(GM_MIF_FRAME_CTL_DATA,
  131. (0x01 << GM_MIF_FRAME_START_SHIFT) |
  132. (0x01 << GM_MIF_FRAME_OPCODE_SHIFT) |
  133. GM_MIF_FRAME_TURNAROUND_HI |
  134. (phy << GM_MIF_FRAME_PHY_ADDR_SHIFT) |
  135. (r << GM_MIF_FRAME_REG_ADDR_SHIFT) |
  136. (v & GM_MIF_FRAME_DATA_MASK));
  138. for (timeout = 1000; timeout > 0; --timeout) {
  139. udelay(20);
  140. if (GM_IN(GM_MIF_FRAME_CTL_DATA) & GM_MIF_FRAME_TURNAROUND_LO)
  141. return 0;
  142. }
  143. return -1;
  144. }
  146. /*
  147.  * Start MIF autopolling of the PHY status register
  148.  */
  149. static void 
  150. mii_poll_start(struct gmac *gm)
  151. {
  152. unsigned int tmp;
  154. /* Start the MIF polling on the external transceiver. */
  155. tmp = GM_IN(GM_MIF_CFG);
  156. tmp &= ~(GM_MIF_CFGPR_MASK | GM_MIF_CFGPD_MASK);
  157. tmp |= ((gm->phy_addr & 0x1f) << GM_MIF_CFGPD_SHIFT);
  158. tmp |= (MII_SR << GM_MIF_CFGPR_SHIFT);
  159. tmp |= GM_MIF_CFGPE;
  160. GM_OUT(GM_MIF_CFG, tmp);
  162. /* Let the bits set. */
  163. udelay(GM_MIF_POLL_DELAY);
  165. GM_OUT(GM_MIF_IRQ_MASK, 0xffc0);
  166. }
  168. /*
  169.  * Stop MIF autopolling of the PHY status register
  170.  */
  171. static void 
  172. mii_poll_stop(struct gmac *gm)
  173. {
  174. GM_OUT(GM_MIF_IRQ_MASK, 0xffff);
  175. GM_BIC(GM_MIF_CFG, GM_MIF_CFGPE);
  176. udelay(GM_MIF_POLL_DELAY);
  177. }
  179. /*
  180.  * Called when the MIF detect a change of the PHY status
  181.  * 
  182.  * handles monitoring the link and updating GMAC with the correct
  183.  * duplex mode.
  184.  * 
  185.  * Note: Are we missing status changes ? In this case, we'll have to
  186.  * a timer and control the autoneg. process more closely. Also, we may
  187.  * want to stop rx and tx side when the link is down.
  188.  */
  190. /* Link modes of the BCM5400 PHY */
  191. static int phy_BCM5400_link_table[8][3] = {
  192. { 0, 0, 0 }, /* No link */
  193. { 0, 0, 0 }, /* 10BT Half Duplex */
  194. { 1, 0, 0 }, /* 10BT Full Duplex */
  195. { 0, 1, 0 }, /* 100BT Half Duplex */
  196. { 0, 1, 0 }, /* 100BT Half Duplex */
  197. { 1, 1, 0 }, /* 100BT Full Duplex*/
  198. { 1, 0, 1 }, /* 1000BT */
  199. { 1, 0, 1 }, /* 1000BT */
  200. };
  202. static void
  203. mii_interrupt(struct gmac *gm)
  204. {
  205. int phy_status;
  206. int lpar_ability;
  208. mii_poll_stop(gm);
  210. /* May the status change before polling is re-enabled ? */
  211. mii_poll_start(gm);
  213. /* We read the Auxilliary Status Summary register */
  214. phy_status = mii_read(gm, gm->phy_addr, MII_SR);
  215. if ((phy_status ^ gm->phy_status) & (MII_SR_ASSC | MII_SR_LKS)) {
  216. int full_duplex = 0;
  217. int link_100 = 0;
  218. int gigabit = 0;
  219. #ifdef DEBUG_PHY
  220. printk(KERN_INFO "%s: Link state change, phy_status: 0x%04xn",
  221. gm->dev->name, phy_status);
  222. #endif
  223. gm->phy_status = phy_status;
  225. /* Should we enable that in generic mode ? */
  226. lpar_ability = mii_read(gm, gm->phy_addr, MII_ANLPA);
  227. if (lpar_ability & MII_ANLPA_PAUS)
  228. GM_BIS(GM_MAC_CTRL_CONFIG, GM_MAC_CTRL_CONF_SND_PAUSE_EN);
  229. else
  230. GM_BIC(GM_MAC_CTRL_CONFIG, GM_MAC_CTRL_CONF_SND_PAUSE_EN);
  232. /* Link ? Check for speed and duplex */
  233. if ((phy_status & MII_SR_LKS) && (phy_status & MII_SR_ASSC)) {
  234.     int restart = 0;
  235.     int aux_stat, link;
  236.     switch (gm->phy_type) {
  237.       case PHY_B5201:
  238.       case PHY_B5221:
  239.      aux_stat = mii_read(gm, gm->phy_addr, MII_BCM5201_AUXCTLSTATUS);
  240. #ifdef DEBUG_PHY
  241. printk(KERN_INFO "%s:    Link up ! BCM5201/5221 aux_stat: 0x%04xn",
  242. gm->dev->name, aux_stat);
  243. #endif
  244.      full_duplex = ((aux_stat & MII_BCM5201_AUXCTLSTATUS_DUPLEX) != 0);
  245.      link_100 = ((aux_stat & MII_BCM5201_AUXCTLSTATUS_SPEED) != 0);
  246.         break;
  247.       case PHY_B5400:
  248.       case PHY_B5401:
  249.       case PHY_B5411:
  250.      aux_stat = mii_read(gm, gm->phy_addr, MII_BCM5400_AUXSTATUS);
  251.      link = (aux_stat & MII_BCM5400_AUXSTATUS_LINKMODE_MASK) >>
  252.      MII_BCM5400_AUXSTATUS_LINKMODE_SHIFT;
  253. #ifdef DEBUG_PHY
  254. printk(KERN_INFO "%s:    Link up ! BCM54xx aux_stat: 0x%04x (link mode: %d)n",
  255. gm->dev->name, aux_stat, link);
  256. #endif
  257.      full_duplex = phy_BCM5400_link_table[link][0];
  258.      link_100 = phy_BCM5400_link_table[link][1];
  259.      gigabit = phy_BCM5400_link_table[link][2];
  260.      break;
  261.       case PHY_LXT971:
  262.      aux_stat = mii_read(gm, gm->phy_addr, MII_LXT971_STATUS2);
  263. #ifdef DEBUG_PHY
  264. printk(KERN_INFO "%s:    Link up ! LXT971 stat2: 0x%04xn",
  265. gm->dev->name, aux_stat);
  266. #endif
  267.      full_duplex = ((aux_stat & MII_LXT971_STATUS2_FULLDUPLEX) != 0);
  268.      link_100 = ((aux_stat & MII_LXT971_STATUS2_SPEED) != 0);
  269.      break;
  270.       default:
  271.      full_duplex = (lpar_ability & MII_ANLPA_FDAM) != 0;
  272.      link_100 = (lpar_ability & MII_ANLPA_100M) != 0;
  273.      break;
  274.     }
  275. #ifdef DEBUG_PHY
  276.     printk(KERN_INFO "%s:    Full Duplex: %d, Speed: %sn",
  277.      gm->dev->name, full_duplex,
  278.      gigabit ? "1000" : (link_100 ? "100" : "10"));
  279. #endif
  280.                     if (gigabit != gm->gigabit) {
  281.                      gm->gigabit = gigabit;
  282.                      gmac_set_gigabit_mode(gm, gm->gigabit);
  283.                      restart = 1;
  284.                     }
  285.     if (full_duplex != gm->full_duplex) {
  286. gm->full_duplex = full_duplex;
  287. gmac_set_duplex_mode(gm, gm->full_duplex);
  288. restart = 1;
  289.     }
  290.     if (restart)
  291. gmac_start_dma(gm);
  292. } else if (!(phy_status & MII_SR_LKS)) {
  293. #ifdef DEBUG_PHY
  294.     printk(KERN_INFO "%s:    Link down !n", gm->dev->name);
  295. #endif
  296. }
  297. }
  298. }
  300. #ifdef CONFIG_PMAC_PBOOK
  301. /* Power management: stop PHY chip for suspend mode
  302.  * 
  303.  * TODO: This will have to be modified is WOL is to be supported.
  304.  */
  305. static void
  306. gmac_suspend(struct gmac* gm)
  307. {
  308. int data, timeout;
  309. unsigned long flags;
  311. gm->sleeping = 1;
  312. netif_device_detach(gm->dev);
  315. spin_lock_irqsave(&gm->lock, flags);
  316. if (gm->opened) {
  317. disable_irq(gm->dev->irq);
  318. /* Stop polling PHY */
  319. mii_poll_stop(gm);
  320. }
  321. /* Mask out all chips interrupts */
  322. GM_OUT(GM_IRQ_MASK, 0xffffffff);
  323. spin_unlock_irqrestore(&gm->lock, flags);
  325. if (gm->opened) {
  326. int i;
  327. /* Empty Tx ring of any remaining gremlins */
  328. gmac_tx_cleanup(gm->dev, 1);
  330. /* Empty Rx ring of any remaining gremlins */
  331. for (i = 0; i < NRX; ++i) {
  332. if (gm->rx_buff[i] != 0) {
  333. dev_kfree_skb_irq(gm->rx_buff[i]);
  334. gm->rx_buff[i] = 0;
  335. }
  336. }
  337. }
  339. /* Clear interrupts on 5201 */
  340. if (gm->phy_type == PHY_B5201 || gm->phy_type == PHY_B5221)
  341. mii_write(gm, gm->phy_addr, MII_BCM5201_INTERRUPT, 0);
  343. /* Drive MDIO high */
  344. GM_OUT(GM_MIF_CFG, 0);
  346. /* Unchanged, don't ask me why */
  347. data = mii_read(gm, gm->phy_addr, MII_ANLPA);
  348. mii_write(gm, gm->phy_addr, MII_ANLPA, data);
  350. /* Stop everything */
  351. GM_OUT(GM_MAC_RX_CONFIG, 0);
  352. GM_OUT(GM_MAC_TX_CONFIG, 0);
  353. GM_OUT(GM_MAC_XIF_CONFIG, 0);
  354. GM_OUT(GM_TX_CONF, 0);
  355. GM_OUT(GM_RX_CONF, 0);
  357. /* Set MAC in reset state */
  358. GM_OUT(GM_RESET, GM_RESET_TX | GM_RESET_RX);
  359. for (timeout = 100; timeout > 0; --timeout) {
  360. mdelay(10);
  361. if ((GM_IN(GM_RESET) & (GM_RESET_TX | GM_RESET_RX)) == 0)
  362. break;
  363. }
  364. GM_OUT(GM_MAC_TX_RESET, GM_MAC_TX_RESET_NOW);
  365. GM_OUT(GM_MAC_RX_RESET, GM_MAC_RX_RESET_NOW);
  367. /* Superisolate PHY */
  368. if (gm->phy_type == PHY_B5201 || gm->phy_type == PHY_B5221)
  369. mii_write(gm, gm->phy_addr, MII_BCM5201_MULTIPHY,
  370. MII_BCM5201_MULTIPHY_SUPERISOLATE);
  372. /* Put MDIO in sane electric state. According to an obscure
  373.  * Apple comment, not doing so may let them drive some current
  374.  * during sleep and possibly damage BCM PHYs.
  375.  */
  376. GM_OUT(GM_MIF_CFG, GM_MIF_CFGBB);
  377. GM_OUT(GM_MIF_BB_CLOCK, 0);
  378. GM_OUT(GM_MIF_BB_DATA, 0);
  379. GM_OUT(GM_MIF_BB_OUT_ENABLE, 0);
  380. GM_OUT(GM_MAC_XIF_CONFIG,
  381. GM_MAC_XIF_CONF_GMII_MODE|GM_MAC_XIF_CONF_MII_INT_LOOP);
  382. (void)GM_IN(GM_MAC_XIF_CONFIG);
  384. /* Unclock the GMAC chip */
  385. gmac_set_power(gm, 0);
  386. }
  388. static void
  389. gmac_resume(struct gmac *gm)
  390. {
  391. int data;
  393. if (gmac_powerup_and_reset(gm->dev)) {
  394. printk(KERN_ERR "%s: Couldn't revive gmac ethernet !n", gm->dev->name);
  395. return;
  396. }
  398. gm->sleeping = 0;
  400. if (gm->opened) {
  401. /* Create fresh rings */
  402. gmac_init_rings(gm, 1);
  403. /* re-initialize the MAC */
  404. gmac_mac_init(gm, gm->dev->dev_addr);
  405. /* re-initialize the multicast tables & promisc mode if any */
  406. gmac_set_multicast(gm->dev);
  407. }
  409. /* Early enable Tx and Rx so that we are clocked */
  410. GM_BIS(GM_TX_CONF, GM_TX_CONF_DMA_EN);
  411. mdelay(20);
  412. GM_BIS(GM_RX_CONF, GM_RX_CONF_DMA_EN);
  413. mdelay(20);
  414. GM_BIS(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_ENABLE);
  415. mdelay(20);
  416. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_ENABLE);
  417. mdelay(20);
  418. if (gm->phy_type == PHY_B5201 || gm->phy_type == PHY_B5221) {
  419. data = mii_read(gm, gm->phy_addr, MII_BCM5201_MULTIPHY);
  420. mii_write(gm, gm->phy_addr, MII_BCM5201_MULTIPHY,
  421. data & ~MII_BCM5201_MULTIPHY_SUPERISOLATE);
  422. }
  423. mdelay(1);
  425. if (gm->opened) {
  426. /* restart polling PHY */
  427. mii_interrupt(gm);
  428. /* restart DMA operations */
  429. gmac_start_dma(gm);
  430. netif_device_attach(gm->dev);
  431. enable_irq(gm->dev->irq);
  432. } else {
  433. /* Driver not opened, just leave things off. Note that
  434.  * we could be smart and superisolate the PHY when the
  435.  * driver is closed, but I won't do that unless I have
  436.  * a better understanding of some electrical issues with
  437.  * this PHY chip --BenH
  438.  */
  439. GM_OUT(GM_MAC_RX_CONFIG, 0);
  440. GM_OUT(GM_MAC_TX_CONFIG, 0);
  441. GM_OUT(GM_MAC_XIF_CONFIG, 0);
  442. GM_OUT(GM_TX_CONF, 0);
  443. GM_OUT(GM_RX_CONF, 0);
  444. }
  445. }
  446. #endif
  448. static int
  449. mii_do_reset_phy(struct gmac *gm, int phy_addr)
  450. {
  451. int mii_control, timeout;
  453. mii_control = mii_read(gm, phy_addr, MII_CR);
  454. mii_write(gm, phy_addr, MII_CR, mii_control | MII_CR_RST);
  455. mdelay(10);
  456. for (timeout = 100; timeout > 0; --timeout) {
  457. mii_control = mii_read(gm, phy_addr, MII_CR);
  458. if (mii_control == -1) {
  459. printk(KERN_ERR "%s PHY died after reset !n",
  460. gm->dev->name);
  461. return 1;
  462. }
  463. if ((mii_control & MII_CR_RST) == 0)
  464. break;
  465. mdelay(10);
  466. }
  467. if (mii_control & MII_CR_RST) {
  468. printk(KERN_ERR "%s PHY reset timeout !n", gm->dev->name);
  469. return 1;
  470. }
  471. mii_write(gm, phy_addr, MII_CR, mii_control & ~MII_CR_ISOL);
  472. return 0;
  473. }
  475. /* Here's a bunch of configuration routines for
  476.  * Broadcom PHYs used on various Mac models. Unfortunately,
  477.  * except for the 5201, Broadcom never sent me any documentation,
  478.  * so this is from my understanding of Apple's Open Firmware
  479.  * drivers and Darwin's implementation
  480.  */
  481.  
  482. static void
  483. mii_init_BCM5400(struct gmac *gm)
  484. {
  485. int data;
  487. /* Configure for gigabit full duplex */
  488. data = mii_read(gm, gm->phy_addr, MII_BCM5400_AUXCONTROL);
  489. data |= MII_BCM5400_AUXCONTROL_PWR10BASET;
  490. mii_write(gm, gm->phy_addr, MII_BCM5400_AUXCONTROL, data);
  492. data = mii_read(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL);
  493. data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
  494. mii_write(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL, data);
  496. mdelay(10);
  498. /* Reset and configure cascaded 10/100 PHY */
  499. mii_do_reset_phy(gm, 0x1f);
  501. data = mii_read(gm, 0x1f, MII_BCM5201_MULTIPHY);
  502. data |= MII_BCM5201_MULTIPHY_SERIALMODE;
  503. mii_write(gm, 0x1f, MII_BCM5201_MULTIPHY, data);
  505. data = mii_read(gm, gm->phy_addr, MII_BCM5400_AUXCONTROL);
  506. data &= ~MII_BCM5400_AUXCONTROL_PWR10BASET;
  507. mii_write(gm, gm->phy_addr, MII_BCM5400_AUXCONTROL, data);
  508. }
  510. static void
  511. mii_init_BCM5401(struct gmac *gm)
  512. {
  513. int data;
  514. int rev;
  516. rev = mii_read(gm, gm->phy_addr, MII_ID1) & 0x000f;
  517. if (rev == 0 || rev == 3) {
  518. /* Some revisions of 5401 appear to need this
  519.  * initialisation sequence to disable, according
  520.  * to OF, "tap power management"
  521.  * 
  522.  * WARNING ! OF and Darwin don't agree on the
  523.  * register addresses. OF seem to interpret the
  524.  * register numbers below as decimal
  525.  */
  526. mii_write(gm, gm->phy_addr, 0x18, 0x0c20);
  527. mii_write(gm, gm->phy_addr, 0x17, 0x0012);
  528. mii_write(gm, gm->phy_addr, 0x15, 0x1804);
  529. mii_write(gm, gm->phy_addr, 0x17, 0x0013);
  530. mii_write(gm, gm->phy_addr, 0x15, 0x1204);
  531. mii_write(gm, gm->phy_addr, 0x17, 0x8006);
  532. mii_write(gm, gm->phy_addr, 0x15, 0x0132);
  533. mii_write(gm, gm->phy_addr, 0x17, 0x8006);
  534. mii_write(gm, gm->phy_addr, 0x15, 0x0232);
  535. mii_write(gm, gm->phy_addr, 0x17, 0x201f);
  536. mii_write(gm, gm->phy_addr, 0x15, 0x0a20);
  537. }
  539. /* Configure for gigabit full duplex */
  540. data = mii_read(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL);
  541. data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
  542. mii_write(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL, data);
  544. mdelay(10);
  546. /* Reset and configure cascaded 10/100 PHY */
  547. mii_do_reset_phy(gm, 0x1f);
  549. data = mii_read(gm, 0x1f, MII_BCM5201_MULTIPHY);
  550. data |= MII_BCM5201_MULTIPHY_SERIALMODE;
  551. mii_write(gm, 0x1f, MII_BCM5201_MULTIPHY, data);
  552. }
  554. static void
  555. mii_init_BCM5411(struct gmac *gm)
  556. {
  557. int data;
  559. /* Here's some more Apple black magic to setup
  560.  * some voltage stuffs.
  561.  */
  562. mii_write(gm, gm->phy_addr, 0x1c, 0x8c23);
  563. mii_write(gm, gm->phy_addr, 0x1c, 0x8ca3);
  564. mii_write(gm, gm->phy_addr, 0x1c, 0x8c23);
  566. /* Here, Apple seems to want to reset it, do
  567.  * it as well
  568.  */
  569. mii_write(gm, gm->phy_addr, MII_CR, MII_CR_RST);
  571. /* Start autoneg */
  572. mii_write(gm, gm->phy_addr, MII_CR,
  573. MII_CR_ASSE|MII_CR_FDM| /* Autospeed, full duplex */
  574. MII_CR_RAN|
  575. MII_CR_SPEEDSEL2 /* chip specific, gigabit enable ? */);
  577. data = mii_read(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL);
  578. data |= MII_BCM5400_GB_CONTROL_FULLDUPLEXCAP;
  579. mii_write(gm, gm->phy_addr, MII_BCM5400_GB_CONTROL, data);
  580. }
  582. static int
  583. mii_lookup_and_reset(struct gmac *gm)
  584. {
  585. int i, mii_status, mii_control;
  587. gm->phy_addr = -1;
  588. gm->phy_type = PHY_UNKNOWN;
  590. /* Hard reset the PHY */
  591. pmac_call_feature(PMAC_FTR_GMAC_PHY_RESET, gm->of_node, 0, 0);
  593. /* Find the PHY */
  594. for(i=0; i<=31; i++) {
  595. mii_control = mii_read(gm, i, MII_CR);
  596. mii_status = mii_read(gm, i, MII_SR);
  597. if (mii_control != -1  && mii_status != -1 &&
  598. (mii_control != 0xffff || mii_status != 0xffff))
  599. break;
  600. }
  601. gm->phy_addr = i;
  602. if (gm->phy_addr > 31)
  603. return 0;
  605. /* Reset it */
  606. if (mii_do_reset_phy(gm, gm->phy_addr))
  607. goto fail;
  609. /* Read the PHY ID */
  610. gm->phy_id = (mii_read(gm, gm->phy_addr, MII_ID0) << 16) |
  611. mii_read(gm, gm->phy_addr, MII_ID1);
  612. #ifdef DEBUG_PHY
  613. printk(KERN_INFO "%s: PHY ID: 0x%08xn", gm->dev->name, gm->phy_id);
  614. #endif
  615. if ((gm->phy_id & MII_BCM5400_MASK) == MII_BCM5400_ID) {
  616. gm->phy_type = PHY_B5400;
  617. printk(KERN_INFO  "%s: Found Broadcom BCM5400 PHY (Gigabit)n",
  618. gm->dev->name);
  619. mii_init_BCM5400(gm);
  620. } else if ((gm->phy_id & MII_BCM5401_MASK) == MII_BCM5401_ID) {
  621. gm->phy_type = PHY_B5401;
  622. printk(KERN_INFO  "%s: Found Broadcom BCM5401 PHY (Gigabit)n",
  623. gm->dev->name);
  624. mii_init_BCM5401(gm);
  625. } else if ((gm->phy_id & MII_BCM5411_MASK) == MII_BCM5411_ID) {
  626. gm->phy_type = PHY_B5411;
  627. printk(KERN_INFO  "%s: Found Broadcom BCM5411 PHY (Gigabit)n",
  628. gm->dev->name);
  629. mii_init_BCM5411(gm);
  630. } else if ((gm->phy_id & MII_BCM5201_MASK) == MII_BCM5201_ID) {
  631. gm->phy_type = PHY_B5201;
  632. printk(KERN_INFO "%s: Found Broadcom BCM5201 PHYn", gm->dev->name);
  633. } else if ((gm->phy_id & MII_BCM5221_MASK) == MII_BCM5221_ID) {
  634. gm->phy_type = PHY_B5221;
  635. printk(KERN_INFO "%s: Found Broadcom BCM5221 PHYn", gm->dev->name);
  636. } else if ((gm->phy_id & MII_LXT971_MASK) == MII_LXT971_ID) {
  637. gm->phy_type = PHY_LXT971;
  638. printk(KERN_INFO "%s: Found LevelOne LX971 PHYn", gm->dev->name);
  639. } else {
  640. printk(KERN_WARNING "%s: Warning ! Unknown PHY ID 0x%08x, using generic mode...n",
  641. gm->dev->name, gm->phy_id);
  642. }
  644. return 1;
  646. fail:
  647. gm->phy_addr = -1;
  648. return 0;
  649. }
  651. /* 
  652.  * Setup the PHY autonegociation parameters
  653.  * 
  654.  * Code to force the PHY duplex mode and speed should be
  655.  * added here
  656.  */
  657. static void
  658. mii_setup_phy(struct gmac *gm)
  659. {
  660. int data;
  662. /* Stop auto-negociation */
  663. data = mii_read(gm, gm->phy_addr, MII_CR);
  664. mii_write(gm, gm->phy_addr, MII_CR, data & ~MII_CR_ASSE);
  666. /* Set advertisement to 10/100 and Half/Full duplex
  667.  * (full capabilities) */
  668. data = mii_read(gm, gm->phy_addr, MII_ANA);
  669. data |= MII_ANA_TXAM | MII_ANA_FDAM | MII_ANA_10M;
  670. mii_write(gm, gm->phy_addr, MII_ANA, data);
  672. /* Restart auto-negociation */
  673. data = mii_read(gm, gm->phy_addr, MII_CR);
  674. data |= MII_CR_ASSE;
  675. mii_write(gm, gm->phy_addr, MII_CR, data);
  676. data |= MII_CR_RAN;
  677. mii_write(gm, gm->phy_addr, MII_CR, data);
  678. }
  680. /* 
  681.  * Turn On/Off the gmac cell inside Uni-N
  682.  * 
  683.  * ToDo: Add code to support powering down of the PHY.
  684.  */
  685. static void
  686. gmac_set_power(struct gmac *gm, int power_up)
  687. {
  688. if (power_up) {
  689. pmac_call_feature(PMAC_FTR_GMAC_ENABLE, gm->of_node, 0, 1);
  690. if (gm->pci_devfn != 0xff) {
  691. u16 cmd;
  693. /*
  694.  * Make sure PCI is correctly configured
  695.  *
  696.  * We use old pci_bios versions of the function since, by
  697.  * default, gmac is not powered up, and so will be absent
  698.  * from the kernel initial PCI lookup. 
  699.  * 
  700.  * Should be replaced by 2.4 new PCI mecanisms and really
  701.  * regiser the device.
  702.  */
  703. pcibios_read_config_word(gm->pci_bus, gm->pci_devfn,
  704. PCI_COMMAND, &cmd);
  705. cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
  706.      pcibios_write_config_word(gm->pci_bus, gm->pci_devfn,
  707.      PCI_COMMAND, cmd);
  708.      pcibios_write_config_byte(gm->pci_bus, gm->pci_devfn,
  709.      PCI_LATENCY_TIMER, 16);
  710.      pcibios_write_config_byte(gm->pci_bus, gm->pci_devfn,
  711.      PCI_CACHE_LINE_SIZE, 8);
  712. }
  713. } else {
  714. pmac_call_feature(PMAC_FTR_GMAC_ENABLE, gm->of_node, 0, 0);
  715. }
  716. }
  718. /*
  719.  * Makes sure the GMAC cell is powered up, and reset it
  720.  */
  721. static int
  722. gmac_powerup_and_reset(struct net_device *dev)
  723. {
  724. struct gmac *gm = (struct gmac *) dev->priv;
  725. int timeout;
  727. /* turn on GB clock */
  728. gmac_set_power(gm, 1);
  729. /* Perform a software reset */
  730. GM_OUT(GM_RESET, GM_RESET_TX | GM_RESET_RX);
  731. for (timeout = 100; timeout > 0; --timeout) {
  732. mdelay(10);
  733. if ((GM_IN(GM_RESET) & (GM_RESET_TX | GM_RESET_RX)) == 0) {
  734. /* Mask out all chips interrupts */
  735. GM_OUT(GM_IRQ_MASK, 0xffffffff);
  736. GM_OUT(GM_MAC_TX_RESET, GM_MAC_TX_RESET_NOW);
  737. GM_OUT(GM_MAC_RX_RESET, GM_MAC_RX_RESET_NOW);
  738. return 0;
  739. }
  740. }
  741. printk(KERN_ERR "%s reset failed!n", dev->name);
  742. gmac_set_power(gm, 0);
  743. gm->phy_type = 0;
  744. return -1;
  745. }
  747. /*
  748.  * Set the MAC duplex mode.
  749.  * 
  750.  * Side effect: stops Tx MAC
  751.  */
  752. static void
  753. gmac_set_duplex_mode(struct gmac *gm, int full_duplex)
  754. {
  755. /* Stop Tx MAC */
  756. GM_BIC(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_ENABLE);
  757. while(GM_IN(GM_MAC_TX_CONFIG) & GM_MAC_TX_CONF_ENABLE)
  758. ;
  760. if (full_duplex) {
  761. GM_BIS(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_IGNORE_CARRIER
  762. | GM_MAC_TX_CONF_IGNORE_COLL);
  763. GM_BIC(GM_MAC_XIF_CONFIG, GM_MAC_XIF_CONF_DISABLE_ECHO);
  764. } else {
  765. GM_BIC(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_IGNORE_CARRIER
  766. | GM_MAC_TX_CONF_IGNORE_COLL);
  767. GM_BIS(GM_MAC_XIF_CONFIG, GM_MAC_XIF_CONF_DISABLE_ECHO);
  768. }
  769. }
  771. /* Set the MAC gigabit mode. Side effect: stops Tx MAC */
  772. static void
  773. gmac_set_gigabit_mode(struct gmac *gm, int gigabit)
  774. {
  775. /* Stop Tx MAC */
  776. GM_BIC(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_ENABLE);
  777. while(GM_IN(GM_MAC_TX_CONFIG) & GM_MAC_TX_CONF_ENABLE)
  778. ;
  780. if (gigabit) {
  781. GM_BIS(GM_MAC_XIF_CONFIG, GM_MAC_XIF_CONF_GMII_MODE);
  782. } else {
  783. GM_BIC(GM_MAC_XIF_CONFIG, GM_MAC_XIF_CONF_GMII_MODE);
  784. }
  785. }
  787. /*
  788.  * Initialize a bunch of registers to put the chip into a known
  789.  * and hopefully happy state
  790.  */
  791. static void
  792. gmac_mac_init(struct gmac *gm, unsigned char *mac_addr)
  793. {
  794. int i, fifo_size;
  796. /* Set random seed to low bits of MAC address */
  797. GM_OUT(GM_MAC_RANDOM_SEED, mac_addr[5] | (mac_addr[4] << 8));
  799. /* Configure the data path mode to MII/GII */
  800. GM_OUT(GM_PCS_DATAPATH_MODE, GM_PCS_DATAPATH_MII);
  802. /* Configure XIF to MII mode. Full duplex led is set
  803.  * by Apple, so...
  804.  */
  805. GM_OUT(GM_MAC_XIF_CONFIG, GM_MAC_XIF_CONF_TX_MII_OUT_EN
  806. | GM_MAC_XIF_CONF_FULL_DPLX_LED);
  808. /* Mask out all MAC interrupts */
  809. GM_OUT(GM_MAC_TX_MASK, 0xffff);
  810. GM_OUT(GM_MAC_RX_MASK, 0xffff);
  811. GM_OUT(GM_MAC_CTRLSTAT_MASK, 0xff);
  813. /* Setup bits of MAC */
  814. GM_OUT(GM_MAC_SND_PAUSE, GM_MAC_SND_PAUSE_DEFAULT);
  815. GM_OUT(GM_MAC_CTRL_CONFIG, GM_MAC_CTRL_CONF_RCV_PAUSE_EN);
  817. /* Configure GEM DMA */
  818. GM_OUT(GM_GCONF, GM_GCONF_BURST_SZ |
  819. (31 << GM_GCONF_TXDMA_LIMIT_SHIFT) |
  820. (31 << GM_GCONF_RXDMA_LIMIT_SHIFT));
  821. GM_OUT(GM_TX_CONF,
  822. (GM_TX_CONF_FIFO_THR_DEFAULT << GM_TX_CONF_FIFO_THR_SHIFT) |
  823. NTX_CONF);
  825. /* 34 byte offset for checksum computation.  This works because ip_input() will clear out
  826.  * the skb->csum and skb->ip_summed fields and recompute the csum if IP options are
  827.  * present in the header.  34 == (ethernet header len) + sizeof(struct iphdr)
  828.   */
  829. GM_OUT(GM_RX_CONF,
  830. (RX_OFFSET << GM_RX_CONF_FBYTE_OFF_SHIFT) |
  831. (0x22 << GM_RX_CONF_CHK_START_SHIFT) |
  832. (GM_RX_CONF_DMA_THR_DEFAULT << GM_RX_CONF_DMA_THR_SHIFT) |
  833. NRX_CONF);
  835. /* Configure other bits of MAC */
  836. GM_OUT(GM_MAC_INTR_PKT_GAP0, GM_MAC_INTR_PKT_GAP0_DEFAULT);
  837. GM_OUT(GM_MAC_INTR_PKT_GAP1, GM_MAC_INTR_PKT_GAP1_DEFAULT);
  838. GM_OUT(GM_MAC_INTR_PKT_GAP2, GM_MAC_INTR_PKT_GAP2_DEFAULT);
  839. GM_OUT(GM_MAC_MIN_FRAME_SIZE, GM_MAC_MIN_FRAME_SIZE_DEFAULT);
  840. GM_OUT(GM_MAC_MAX_FRAME_SIZE, GM_MAC_MAX_FRAME_SIZE_DEFAULT);
  841. GM_OUT(GM_MAC_PREAMBLE_LEN, GM_MAC_PREAMBLE_LEN_DEFAULT);
  842. GM_OUT(GM_MAC_JAM_SIZE, GM_MAC_JAM_SIZE_DEFAULT);
  843. GM_OUT(GM_MAC_ATTEMPT_LIMIT, GM_MAC_ATTEMPT_LIMIT_DEFAULT);
  844. GM_OUT(GM_MAC_SLOT_TIME, GM_MAC_SLOT_TIME_DEFAULT);
  845. GM_OUT(GM_MAC_CONTROL_TYPE, GM_MAC_CONTROL_TYPE_DEFAULT);
  847. /* Setup MAC addresses, clear filters, clear hash table */
  848. GM_OUT(GM_MAC_ADDR_NORMAL0, (mac_addr[4] << 8) + mac_addr[5]);
  849. GM_OUT(GM_MAC_ADDR_NORMAL1, (mac_addr[2] << 8) + mac_addr[3]);
  850. GM_OUT(GM_MAC_ADDR_NORMAL2, (mac_addr[0] << 8) + mac_addr[1]);
  851. GM_OUT(GM_MAC_ADDR_ALT0, 0);
  852. GM_OUT(GM_MAC_ADDR_ALT1, 0);
  853. GM_OUT(GM_MAC_ADDR_ALT2, 0);
  854. GM_OUT(GM_MAC_ADDR_CTRL0, 0x0001);
  855. GM_OUT(GM_MAC_ADDR_CTRL1, 0xc200);
  856. GM_OUT(GM_MAC_ADDR_CTRL2, 0x0180);
  857. GM_OUT(GM_MAC_ADDR_FILTER0, 0);
  858. GM_OUT(GM_MAC_ADDR_FILTER1, 0);
  859. GM_OUT(GM_MAC_ADDR_FILTER2, 0);
  860. GM_OUT(GM_MAC_ADDR_FILTER_MASK1_2, 0);
  861. GM_OUT(GM_MAC_ADDR_FILTER_MASK0, 0);
  862. for (i = 0; i < 27; ++i)
  863. GM_OUT(GM_MAC_ADDR_FILTER_HASH0 + i, 0);
  865. /* Clear stat counters */
  866. GM_OUT(GM_MAC_COLLISION_CTR, 0);
  867. GM_OUT(GM_MAC_FIRST_COLLISION_CTR, 0);
  868. GM_OUT(GM_MAC_EXCS_COLLISION_CTR, 0);
  869. GM_OUT(GM_MAC_LATE_COLLISION_CTR, 0);
  870. GM_OUT(GM_MAC_DEFER_TIMER_COUNTER, 0);
  871. GM_OUT(GM_MAC_PEAK_ATTEMPTS, 0);
  872. GM_OUT(GM_MAC_RX_FRAME_CTR, 0);
  873. GM_OUT(GM_MAC_RX_LEN_ERR_CTR, 0);
  874. GM_OUT(GM_MAC_RX_ALIGN_ERR_CTR, 0);
  875. GM_OUT(GM_MAC_RX_CRC_ERR_CTR, 0);
  876. GM_OUT(GM_MAC_RX_CODE_VIOLATION_CTR, 0);
  878. /* default to half duplex */
  879. GM_OUT(GM_MAC_TX_CONFIG, 0);
  880. GM_OUT(GM_MAC_RX_CONFIG, 0);
  881. gmac_set_duplex_mode(gm, gm->full_duplex);
  883. /* Setup pause thresholds */
  884. fifo_size = GM_IN(GM_RX_FIFO_SIZE);
  885. GM_OUT(GM_RX_PTH,
  886. ((fifo_size - ((GM_MAC_MAX_FRAME_SIZE_ALIGN + 8) * 2 / GM_RX_PTH_UNITS))
  887. << GM_RX_PTH_OFF_SHIFT) |
  888. ((fifo_size - ((GM_MAC_MAX_FRAME_SIZE_ALIGN + 8) * 3 / GM_RX_PTH_UNITS))
  889. << GM_RX_PTH_ON_SHIFT));
  891. /* Setup interrupt blanking */
  892. if (GM_IN(GM_BIF_CFG) & GM_BIF_CFG_M66EN)
  893. GM_OUT(GM_RX_BLANK, (5 << GM_RX_BLANK_INTR_PACKETS_SHIFT)
  894. | (8 << GM_RX_BLANK_INTR_TIME_SHIFT));
  895. else
  896. GM_OUT(GM_RX_BLANK, (5 << GM_RX_BLANK_INTR_PACKETS_SHIFT)
  897. | (4 << GM_RX_BLANK_INTR_TIME_SHIFT));
  898. }
  900. /*
  901.  * Fill the Rx and Tx rings with good initial values, alloc
  902.  * fresh Rx skb's.
  903.  */
  904. static void
  905. gmac_init_rings(struct gmac *gm, int from_irq)
  906. {
  907. int i;
  908. struct sk_buff *skb;
  909. unsigned char *data;
  910. struct gmac_dma_desc *ring;
  911. int gfp_flags = GFP_KERNEL;
  913. if (from_irq || in_interrupt())
  914. gfp_flags = GFP_ATOMIC;
  916. /* init rx ring */
  917. ring = (struct gmac_dma_desc *) gm->rxring;
  918. memset(ring, 0, NRX * sizeof(struct gmac_dma_desc));
  919. for (i = 0; i < NRX; ++i, ++ring) {
  920. data = dummy_buf;
  921. gm->rx_buff[i] = skb = gmac_alloc_skb(RX_BUF_ALLOC_SIZE, gfp_flags);
  922. if (skb != 0) {
  923. skb->dev = gm->dev;
  924. skb_put(skb, ETH_FRAME_LEN + RX_OFFSET);
  925. skb_reserve(skb, RX_OFFSET);
  926. data = skb->data - RX_OFFSET;
  927. }
  928. st_le32(&ring->lo_addr, virt_to_bus(data));
  929. st_le32(&ring->size, RX_SZ_OWN | ((RX_BUF_ALLOC_SIZE-RX_OFFSET) << RX_SZ_SHIFT));
  930. }
  932. /* init tx ring */
  933. ring = (struct gmac_dma_desc *) gm->txring;
  934. memset(ring, 0, NTX * sizeof(struct gmac_dma_desc));
  936. gm->next_rx = 0;
  937. gm->next_tx = 0;
  938. gm->tx_gone = 0;
  940. /* set pointers in chip */
  941. mb();
  942. GM_OUT(GM_RX_DESC_HI, 0);
  943. GM_OUT(GM_RX_DESC_LO, virt_to_bus(gm->rxring));
  944. GM_OUT(GM_TX_DESC_HI, 0);
  945. GM_OUT(GM_TX_DESC_LO, virt_to_bus(gm->txring));
  946. }
  948. /*
  949.  * Start the Tx and Rx DMA engines and enable interrupts
  950.  * 
  951.  * Note: The various mdelay(20); come from Darwin implentation. Some
  952.  * tests (doc ?) are needed to replace those with something more intrusive.
  953.  */
  954. static void
  955. gmac_start_dma(struct gmac *gm)
  956. {
  957. /* Enable Tx and Rx */
  958. GM_BIS(GM_TX_CONF, GM_TX_CONF_DMA_EN);
  959. mdelay(20);
  960. GM_BIS(GM_RX_CONF, GM_RX_CONF_DMA_EN);
  961. mdelay(20);
  962. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_ENABLE);
  963. mdelay(20);
  964. GM_BIS(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_ENABLE);
  965. mdelay(20);
  966. /* Kick the receiver and enable interrupts */
  967. GM_OUT(GM_RX_KICK, NRX);
  968. GM_BIC(GM_IRQ_MASK,  GM_IRQ_TX_INT_ME |
  969. GM_IRQ_TX_ALL |
  970. GM_IRQ_RX_DONE |
  971. GM_IRQ_RX_TAG_ERR |
  972. GM_IRQ_MAC_RX |
  973. GM_IRQ_MIF |
  974. GM_IRQ_BUS_ERROR);
  975. }
  977. /*
  978.  * Stop the Tx and Rx DMA engines after disabling interrupts
  979.  * 
  980.  * Note: The various mdelay(20); come from Darwin implentation. Some
  981.  * tests (doc ?) are needed to replace those with something more intrusive.
  982.  */
  983. static void
  984. gmac_stop_dma(struct gmac *gm)
  985. {
  986. /* disable interrupts */
  987. GM_OUT(GM_IRQ_MASK, 0xffffffff);
  988. /* Enable Tx and Rx */
  989. GM_BIC(GM_TX_CONF, GM_TX_CONF_DMA_EN);
  990. mdelay(20);
  991. GM_BIC(GM_RX_CONF, GM_RX_CONF_DMA_EN);
  992. mdelay(20);
  993. GM_BIC(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_ENABLE);
  994. mdelay(20);
  995. GM_BIC(GM_MAC_TX_CONFIG, GM_MAC_TX_CONF_ENABLE);
  996. mdelay(20);
  997. }
  999. /*
  1000.  * Configure promisc mode and setup multicast hash table
  1001.  * filter
  1002.  */
  1003. #define CRC_POLY 0xedb88320
  1004. static void
  1005. gmac_set_multicast(struct net_device *dev)
  1006. {
  1007. struct gmac *gm = (struct gmac *) dev->priv;
  1008. struct dev_mc_list *dmi = dev->mc_list;
  1009. int i,j,k,b;
  1010. unsigned long crc;
  1011. int multicast_hash = 0;
  1012. int multicast_all = 0;
  1013. int promisc = 0;
  1015. if (gm->sleeping)
  1016. return;
  1018. /* Lock out others. */
  1019. netif_stop_queue(dev);
  1022. if (dev->flags & IFF_PROMISC)
  1023. promisc = 1;
  1024. else if ((dev->flags & IFF_ALLMULTI) /* || (dev->mc_count > XXX) */) {
  1025. multicast_all = 1;
  1026. } else {
  1027. u16 hash_table[16];
  1029. for(i = 0; i < 16; i++)
  1030. hash_table[i] = 0;
  1032.      for (i = 0; i < dev->mc_count; i++) {
  1033. crc = ~0;
  1034. for (j = 0; j < 6; ++j) {
  1035.     b = dmi->dmi_addr[j];
  1036.     for (k = 0; k < 8; ++k) {
  1037. if ((crc ^ b) & 1)
  1038.     crc = (crc >> 1) ^ CRC_POLY;
  1039. else
  1040.     crc >>= 1;
  1041. b >>= 1;
  1042.     }
  1043. }
  1044. j = crc >> 24; /* bit number in multicast_filter */
  1045. hash_table[j >> 4] |= 1 << (15 - (j & 0xf));
  1046. dmi = dmi->next;
  1047.      }
  1049.      for (i = 0; i < 16; i++)
  1050.      GM_OUT(GM_MAC_ADDR_FILTER_HASH0 + (i*4), hash_table[i]);
  1051. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_HASH_ENABLE);
  1052.      multicast_hash = 1;
  1053. }
  1055. if (promisc)
  1056. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_RX_ALL);
  1057. else
  1058. GM_BIC(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_RX_ALL);
  1060. if (multicast_hash)
  1061. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_HASH_ENABLE);
  1062. else
  1063. GM_BIC(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_HASH_ENABLE);
  1065. if (multicast_all)
  1066. GM_BIS(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_RX_ALL_MULTI);
  1067. else
  1068. GM_BIC(GM_MAC_RX_CONFIG, GM_MAC_RX_CONF_RX_ALL_MULTI);
  1070. /* Let us get going again. */
  1071. netif_wake_queue(dev);
  1072. }
  1074. /*
  1075.  * Open the interface
  1076.  */
  1077. static int
  1078. gmac_open(struct net_device *dev)
  1079. {
  1080. int ret;
  1081. struct gmac *gm = (struct gmac *) dev->priv;
  1083. /* Power up and reset chip */
  1084. if (gmac_powerup_and_reset(dev))
  1085. return -EIO;
  1087. /* Get our interrupt */
  1088. ret = request_irq(dev->irq, gmac_interrupt, 0, dev->name, dev);
  1089. if (ret) {
  1090. printk(KERN_ERR "%s can't get irq %dn", dev->name, dev->irq);
  1091. return ret;
  1092. }
  1094. gm->full_duplex = 0;
  1095. gm->phy_status = 0;
  1097. /* Find a PHY */
  1098. if (!mii_lookup_and_reset(gm))
  1099. printk(KERN_WARNING "%s WARNING ! Can't find PHYn", dev->name);
  1101. /* Configure the PHY */
  1102. mii_setup_phy(gm);
  1104. /* Initialize the descriptor rings */
  1105. gmac_init_rings(gm, 0);
  1107. /* Initialize the MAC */
  1108. gmac_mac_init(gm, dev->dev_addr);
  1110. /* Initialize the multicast tables & promisc mode if any */
  1111. gmac_set_multicast(dev);
  1113. /*
  1114.  * Check out PHY status and start auto-poll
  1115.  * 
  1116.  * Note: do this before enabling interrutps
  1117.  */
  1118. mii_interrupt(gm);
  1120. /* Start the chip */
  1121. gmac_start_dma(gm);
  1123. gm->opened = 1;
  1125. return 0;
  1126. }
  1128. /* 
  1129.  * Close the interface
  1130.  */
  1131. static int
  1132. gmac_close(struct net_device *dev)
  1133. {
  1134. struct gmac *gm = (struct gmac *) dev->priv;
  1135. int i;
  1137. gm->opened = 0;
  1139. /* Stop chip and interrupts */
  1140. gmac_stop_dma(gm);
  1142. /* Stop polling PHY */
  1143. mii_poll_stop(gm);
  1145. /* Free interrupt */
  1146. free_irq(dev->irq, dev);
  1148. /* Shut down chip */
  1149. gmac_set_power(gm, 0);
  1150. gm->phy_type = 0;
  1152. /* Empty rings of any remaining gremlins */
  1153. for (i = 0; i < NRX; ++i) {
  1154. if (gm->rx_buff[i] != 0) {
  1155. dev_kfree_skb(gm->rx_buff[i]);
  1156. gm->rx_buff[i] = 0;
  1157. }
  1158. }
  1159. for (i = 0; i < NTX; ++i) {
  1160. if (gm->tx_buff[i] != 0) {
  1161. dev_kfree_skb(gm->tx_buff[i]);
  1162. gm->tx_buff[i] = 0;
  1163. }
  1164. }
  1166. return 0;
  1167. }
  1169. #ifdef CONFIG_PMAC_PBOOK
  1170. int
  1171. gmac_sleep_notify(struct pmu_sleep_notifier *self, int when)
  1172. {
  1173. struct gmac *gm;
  1175. /* XXX should handle more than one */
  1176. if (gmacs == NULL)
  1177. return PBOOK_SLEEP_OK;
  1179. gm = (struct gmac *) gmacs->priv;
  1180. if (!gm->opened)
  1181. return PBOOK_SLEEP_OK;
  1183. switch (when) {
  1184. case PBOOK_SLEEP_REQUEST:
  1185. break;
  1186. case PBOOK_SLEEP_REJECT:
  1187. break;
  1188. case PBOOK_SLEEP_NOW:
  1189. gmac_suspend(gm);
  1190. break;
  1191. case PBOOK_WAKE:
  1192. gmac_resume(gm);
  1193. break;
  1194. }
  1195. return PBOOK_SLEEP_OK;
  1196. }
  1197. #endif /* CONFIG_PMAC_PBOOK */
  1199. /*
  1200.  * Handle a transmit timeout
  1201.  */
  1202. static void
  1203. gmac_tx_timeout(struct net_device *dev)
  1204. {
  1205. struct gmac *gm = (struct gmac *) dev->priv;
  1206. int i, timeout;
  1207. unsigned long flags;
  1209. if (gm->sleeping)
  1210. return;
  1212. printk (KERN_ERR "%s: transmit timed out, resettingn", dev->name);
  1214. spin_lock_irqsave(&gm->lock, flags);
  1216. /* Stop chip */
  1217. gmac_stop_dma(gm);
  1218. /* Empty Tx ring of any remaining gremlins */
  1219. gmac_tx_cleanup(dev, 1);
  1220. /* Empty Rx ring of any remaining gremlins */
  1221. for (i = 0; i < NRX; ++i) {
  1222. if (gm->rx_buff[i] != 0) {
  1223. dev_kfree_skb_irq(gm->rx_buff[i]);
  1224. gm->rx_buff[i] = 0;
  1225. }
  1226. }
  1227. /* Perform a software reset */
  1228. GM_OUT(GM_RESET, GM_RESET_TX | GM_RESET_RX);
  1229. for (timeout = 100; timeout > 0; --timeout) {
  1230. mdelay(10);
  1231. if ((GM_IN(GM_RESET) & (GM_RESET_TX | GM_RESET_RX)) == 0) {
  1232. /* Mask out all chips interrupts */
  1233. GM_OUT(GM_IRQ_MASK, 0xffffffff);
  1234. GM_OUT(GM_MAC_TX_RESET, GM_MAC_TX_RESET_NOW);
  1235. GM_OUT(GM_MAC_RX_RESET, GM_MAC_RX_RESET_NOW);
  1236. break;
  1237. }
  1238. }
  1239. if (!timeout)
  1240. printk(KERN_ERR "%s reset chip failed !n", dev->name);
  1241. /* Create fresh rings */
  1242. gmac_init_rings(gm, 1);
  1243. /* re-initialize the MAC */
  1244. gmac_mac_init(gm, dev->dev_addr);
  1245. /* re-initialize the multicast tables & promisc mode if any */
  1246. gmac_set_multicast(dev);
  1247. /* Restart PHY auto-poll */
  1248. mii_interrupt(gm);
  1249. /* Restart chip */
  1250. gmac_start_dma(gm);
  1252. spin_unlock_irqrestore(&gm->lock, flags);
  1254. netif_wake_queue(dev);
  1255. }
  1257. /*
  1258.  * Add a packet to the transmit ring
  1259.  */
  1260. static int
  1261. gmac_xmit_start(struct sk_buff *skb, struct net_device *dev)
  1262. {
  1263. struct gmac *gm = (struct gmac *) dev->priv;
  1264. volatile struct gmac_dma_desc *dp;
  1265. unsigned long flags;
  1266. int i;
  1268. if (gm->sleeping)
  1269. return 1;
  1271. spin_lock_irqsave(&gm->lock, flags);
  1273. i = gm->next_tx;
  1274. if (gm->tx_buff[i] != 0) {
  1275. /* 
  1276.  * Buffer is full, can't send this packet at the moment
  1277.  * 
  1278.  * Can this ever happen in 2.4 ?
  1279.  */
  1280. netif_stop_queue(dev);
  1281. spin_unlock_irqrestore(&gm->lock, flags);
  1282. return 1;
  1283. }
  1284. gm->next_tx = (i + 1) & (NTX - 1);
  1285. gm->tx_buff[i] = skb;
  1287. dp = &gm->txring[i];
  1288. /* FIXME: Interrupt on all packet for now, change this to every N packet,
  1289.  * with N to be adjusted
  1290.  */
  1291. dp->flags = TX_FL_INTERRUPT;
  1292. dp->hi_addr = 0;
  1293. st_le32(&dp->lo_addr, virt_to_bus(skb->data));
  1294. mb();
  1295. st_le32(&dp->size, TX_SZ_SOP | TX_SZ_EOP | skb->len);
  1296. mb();
  1298. GM_OUT(GM_TX_KICK, gm->next_tx);
  1300. if (gm->tx_buff[gm->next_tx] != 0)
  1301. netif_stop_queue(dev);
  1303. spin_unlock_irqrestore(&gm->lock, flags);
  1305. dev->trans_start = jiffies;
  1307. return 0;
  1308. }
  1310. /*
  1311.  * Handle servicing of the transmit ring by deallocating used
  1312.  * Tx packets and restoring flow control when necessary
  1313.  */
  1314. static void
  1315. gmac_tx_cleanup(struct net_device *dev, int force_cleanup)
  1316. {
  1317. struct gmac *gm = (struct gmac *) dev->priv;
  1318. volatile struct gmac_dma_desc *dp;
  1319. struct sk_buff *skb;
  1320. int gone, i;
  1322. i = gm->tx_gone;
  1324. /* Note: If i==gone, we empty the entire ring. This works because
  1325.  * if the ring was empty, we wouldn't have received the interrupt
  1326.  */
  1327. do {
  1328. gone = GM_IN(GM_TX_COMP);
  1329. skb = gm->tx_buff[i];
  1330. if (skb == NULL)
  1331. break;
  1332. dp = &gm->txring[i];
  1333. if (force_cleanup)
  1334. ++gm->stats.tx_errors;
  1335. else {
  1336. ++gm->stats.tx_packets;
  1337. gm->stats.tx_bytes += skb->len;
  1338. }
  1339. gm->tx_buff[i] = NULL;
  1340. dev_kfree_skb_irq(skb);
  1341. if (++i >= NTX)
  1342. i = 0;
  1343. } while (force_cleanup || i != gone);
  1344. gm->tx_gone = i;
  1346. if (!force_cleanup && netif_queue_stopped(dev) &&
  1347.     (gm->tx_buff[gm->next_tx] == 0))
  1348. netif_wake_queue(dev);
  1349. }
  1351. /*
  1352.  * Handle servicing of receive ring
  1353.  */
  1354. static void
  1355. gmac_receive(struct net_device *dev)
  1356. {
  1357. struct gmac *gm = (struct gmac *) dev->priv;
  1358. int i = gm->next_rx;
  1359. volatile struct gmac_dma_desc *dp;
  1360. struct sk_buff *skb, *new_skb;
  1361. int len, flags, drop, last;
  1362. unsigned char *data;
  1363. u16 csum;
  1365. last = -1;
  1366. for (;;) {
  1367. dp = &gm->rxring[i];
  1368. /* Buffer not yet filled, no more Rx buffers to handle */
  1369. if (ld_le32(&dp->size) & RX_SZ_OWN)
  1370. break;
  1371. /* Get packet length, flags, etc... */
  1372. len = (ld_le32(&dp->size) >> 16) & 0x7fff;
  1373. flags = ld_le32(&dp->flags);
  1374. skb = gm->rx_buff[i];
  1375. drop = 0;
  1376. new_skb = NULL;
  1377. csum = ld_le32(&dp->size) & RX_SZ_CKSUM_MASK;
  1379. /* Handle errors */
  1380. if ((len < ETH_ZLEN)||(flags & RX_FL_CRC_ERROR)||(!skb)) {
  1381. ++gm->stats.rx_errors;
  1382. if (len < ETH_ZLEN)
  1383. ++gm->stats.rx_length_errors;
  1384. if (flags & RX_FL_CRC_ERROR)
  1385. ++gm->stats.rx_crc_errors;
  1386. if (!skb) {
  1387. ++gm->stats.rx_dropped;
  1388. skb = gmac_alloc_skb(RX_BUF_ALLOC_SIZE, GFP_ATOMIC);
  1389. if (skb) {
  1390. gm->rx_buff[i] = skb;
  1391.      skb->dev = dev;
  1392.      skb_put(skb, ETH_FRAME_LEN + RX_OFFSET);
  1393.      skb_reserve(skb, RX_OFFSET);
  1394. }
  1395. }
  1396. drop = 1;
  1397. } else {
  1398. /* Large packet, alloc a new skb for the ring */
  1399. if (len > RX_COPY_THRESHOLD) {
  1400.     new_skb = gmac_alloc_skb(RX_BUF_ALLOC_SIZE, GFP_ATOMIC);
  1401.     if(!new_skb) {
  1402.      printk(KERN_INFO "%s: Out of SKBs in Rx, packet dropped !n",
  1403.      dev->name);
  1404.      drop = 1;
  1405.      ++gm->stats.rx_dropped;
  1406.      goto finish;
  1407.     }
  1409.     gm->rx_buff[i] = new_skb;
  1410.     new_skb->dev = dev;
  1411.     skb_put(new_skb, ETH_FRAME_LEN + RX_OFFSET);
  1412.     skb_reserve(new_skb, RX_OFFSET);
  1413.     skb_trim(skb, len);
  1414. } else {
  1415.     /* Small packet, copy it to a new small skb */
  1416.     struct sk_buff *copy_skb = dev_alloc_skb(len + RX_OFFSET);
  1418.     if(!copy_skb) {
  1419. printk(KERN_INFO "%s: Out of SKBs in Rx, packet dropped !n",
  1420. dev->name);
  1421. drop = 1;
  1422. ++gm->stats.rx_dropped;
  1423.      goto finish;
  1424.     }
  1426.     copy_skb->dev = dev;
  1427.     skb_reserve(copy_skb, RX_OFFSET);
  1428.     skb_put(copy_skb, len);
  1429.     memcpy(copy_skb->data, skb->data, len);
  1431.     new_skb = skb;
  1432.     skb = copy_skb;
  1433. }
  1434. }
  1435. finish:
  1436. /* Need to drop packet ? */
  1437. if (drop) {
  1438. new_skb = skb;
  1439. skb = NULL;
  1440. }
  1442. /* Put back ring entry */
  1443. data = new_skb ? (new_skb->data - RX_OFFSET) : dummy_buf;
  1444. dp->hi_addr = 0;
  1445. st_le32(&dp->lo_addr, virt_to_bus(data));
  1446. mb();
  1447. st_le32(&dp->size, RX_SZ_OWN | ((RX_BUF_ALLOC_SIZE-RX_OFFSET) << RX_SZ_SHIFT));
  1449. /* Got Rx packet ? */
  1450. if (skb) {
  1451. /* Yes, baby, keep that hot ;) */
  1452. if(!(csum ^ 0xffff))
  1453. skb->ip_summed = CHECKSUM_UNNECESSARY;
  1454. else
  1455. skb->ip_summed = CHECKSUM_NONE;
  1456. skb->ip_summed = CHECKSUM_NONE;
  1457. skb->protocol = eth_type_trans(skb, dev);
  1458. gm->stats.rx_bytes += skb->len;
  1459. netif_rx(skb);
  1460. dev->last_rx = jiffies;
  1461. ++gm->stats.rx_packets;
  1462. }
  1464. last = i;
  1465. if (++i >= NRX)
  1466. i = 0;
  1467. }
  1468. gm->next_rx = i;
  1469. if (last >= 0) {
  1470. mb();
  1471. GM_OUT(GM_RX_KICK, last & 0xfffffffc);
  1472. }
  1473. }
  1475. /*
  1476.  * Service chip interrupts
  1477.  */
  1478. static void
  1479. gmac_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1480. {
  1481. struct net_device *dev = (struct net_device *) dev_id;
  1482. struct gmac *gm = (struct gmac *) dev->priv;
  1483. unsigned int status;
  1485. status = GM_IN(GM_IRQ_STATUS);
  1486. if (status & (GM_IRQ_BUS_ERROR | GM_IRQ_MIF))
  1487. GM_OUT(GM_IRQ_ACK, status & (GM_IRQ_BUS_ERROR | GM_IRQ_MIF));
  1489. if (status & (GM_IRQ_RX_TAG_ERR | GM_IRQ_BUS_ERROR)) {
  1490. printk(KERN_ERR "%s: IRQ Error status: 0x%08xn",
  1491. dev->name, status);
  1492. }
  1494. if (status & GM_IRQ_MIF) {
  1495. spin_lock(&gm->lock);
  1496. mii_interrupt(gm);
  1497. spin_unlock(&gm->lock);
  1498. }
  1500. if (status & GM_IRQ_RX_DONE) {
  1501. spin_lock(&gm->lock);
  1502. gmac_receive(dev);
  1503. spin_unlock(&gm->lock);
  1504. }
  1506. if (status & (GM_IRQ_TX_INT_ME | GM_IRQ_TX_ALL)) {
  1507. spin_lock(&gm->lock);
  1508. gmac_tx_cleanup(dev, 0);
  1509. spin_unlock(&gm->lock);
  1510. }
  1511. }
  1513. /*
  1514.  * Retreive some error stats from chip and return them
  1515.  * to above layer
  1516.  */
  1517. static struct net_device_stats *
  1518. gmac_stats(struct net_device *dev)
  1519. {
  1520. struct gmac *gm = (struct gmac *) dev->priv;
  1521. struct net_device_stats *stats = &gm->stats;
  1523. if (gm && gm->opened && !gm->sleeping) {
  1524. stats->rx_crc_errors += GM_IN(GM_MAC_RX_CRC_ERR_CTR);
  1525. GM_OUT(GM_MAC_RX_CRC_ERR_CTR, 0);
  1527. stats->rx_frame_errors += GM_IN(GM_MAC_RX_ALIGN_ERR_CTR);
  1528. GM_OUT(GM_MAC_RX_ALIGN_ERR_CTR, 0);
  1530. stats->rx_length_errors += GM_IN(GM_MAC_RX_LEN_ERR_CTR);
  1531. GM_OUT(GM_MAC_RX_LEN_ERR_CTR, 0);
  1533. stats->tx_aborted_errors += GM_IN(GM_MAC_EXCS_COLLISION_CTR);
  1535. stats->collisions +=
  1536. (GM_IN(GM_MAC_EXCS_COLLISION_CTR) +
  1537.  GM_IN(GM_MAC_LATE_COLLISION_CTR));
  1538. GM_OUT(GM_MAC_EXCS_COLLISION_CTR, 0);
  1539. GM_OUT(GM_MAC_LATE_COLLISION_CTR, 0);
  1540. }
  1542. return stats;
  1543. }
  1545. static int __init
  1546. gmac_probe(void)
  1547. {
  1548. struct device_node *gmac;
  1550. /* We bump use count during probe since get_free_page can sleep
  1551.  * which can be a race condition if module is unloaded at this
  1552.  * point.
  1553.  */
  1554. MOD_INC_USE_COUNT;
  1556. /*
  1557.  * We don't use PCI scanning on pmac since the GMAC cell is disabled
  1558.  * by default, and thus absent from kernel original PCI probing.
  1559.  */
  1560. for (gmac = find_compatible_devices("network", "gmac"); gmac != 0;
  1561.      gmac = gmac->next)
  1562. gmac_probe1(gmac);
  1564. #ifdef CONFIG_PMAC_PBOOK
  1565. if (gmacs)
  1566. pmu_register_sleep_notifier(&gmac_sleep_notifier);
  1567. #endif
  1569. MOD_DEC_USE_COUNT;
  1571. return gmacs? 0: -ENODEV;
  1572. }
  1574. static void
  1575. gmac_probe1(struct device_node *gmac)
  1576. {
  1577. struct gmac *gm;
  1578. unsigned long tx_descpage, rx_descpage;
  1579. unsigned char *addr;
  1580. struct net_device *dev;
  1581. int i;
  1583. if (gmac->n_addrs < 1 || gmac->n_intrs < 1) {
  1584. printk(KERN_ERR "can't use GMAC %s: %d addrs and %d intrsn",
  1585.        gmac->full_name, gmac->n_addrs, gmac->n_intrs);
  1586. return;
  1587. }
  1589. addr = get_property(gmac, "local-mac-address", NULL);
  1590. if (addr == NULL) {
  1591. printk(KERN_ERR "Can't get mac-address for GMAC %sn",
  1592.        gmac->full_name);
  1593. return;
  1594. }
  1596. if (dummy_buf == NULL) {
  1597. dummy_buf = kmalloc(DUMMY_BUF_LEN, GFP_KERNEL);
  1598. if (dummy_buf == NULL) {
  1599. printk(KERN_ERR "GMAC: failed to allocated dummy buffern");
  1600. return;
  1601. }
  1602. }
  1604. tx_descpage = get_free_page(GFP_KERNEL);
  1605. if (tx_descpage == 0) {
  1606. printk(KERN_ERR "GMAC: can't get a page for tx descriptorsn");
  1607. return;
  1608. }
  1609. rx_descpage = get_free_page(GFP_KERNEL);
  1610. if (rx_descpage == 0) {
  1611. printk(KERN_ERR "GMAC: can't get a page for rx descriptorsn");
  1612. goto out_txdesc;
  1613. }
  1615. dev = init_etherdev(NULL, sizeof(struct gmac));
  1616. if (!dev) {
  1617. printk(KERN_ERR "GMAC: init_etherdev failed, out of memoryn");
  1618. goto out_rxdesc;
  1619. }
  1620. SET_MODULE_OWNER(dev);
  1622. gm = dev->priv;
  1623. gm->of_node = gmac;
  1624. if (!request_OF_resource(gmac, 0, " (gmac)")) {
  1625. printk(KERN_ERR "GMAC: can't request IO resource !n");
  1626. goto out_unreg;
  1627. }
  1628. dev->base_addr = gmac->addrs[0].address;
  1629. gm->regs = (volatile unsigned int *)
  1630. ioremap(gmac->addrs[0].address, 0x10000);
  1631. if (!gm->regs) {
  1632. printk(KERN_ERR "GMAC: unable to map I/O registersn");
  1633. goto out_unreg;
  1634. }
  1635. dev->irq = gmac->intrs[0].line;
  1636. gm->dev = dev;
  1638. spin_lock_init(&gm->lock);
  1640. if (pci_device_from_OF_node(gmac, &gm->pci_bus, &gm->pci_devfn)) {
  1641. gm->pci_bus = gm->pci_devfn = 0xff;
  1642. printk(KERN_ERR "Can't locate GMAC PCI entryn");
  1643. }
  1645. printk(KERN_INFO "%s: GMAC at", dev->name);
  1646. for (i = 0; i < 6; ++i) {
  1647. dev->dev_addr[i] = addr[i];
  1648. printk("%c%.2x", (i? ':': ' '), addr[i]);
  1649. }
  1650. printk(", driver " GMAC_VERSION "n");
  1652. gm->tx_desc_page = tx_descpage;
  1653. gm->rx_desc_page = rx_descpage;
  1654. gm->rxring = (volatile struct gmac_dma_desc *) rx_descpage;
  1655. gm->txring = (volatile struct gmac_dma_desc *) tx_descpage;
  1657. gm->phy_addr = 0;
  1658. gm->opened = 0;
  1659. gm->sleeping = 0;
  1661. dev->open = gmac_open;
  1662. dev->stop = gmac_close;
  1663. dev->hard_start_xmit = gmac_xmit_start;
  1664. dev->get_stats = gmac_stats;
  1665. dev->set_multicast_list = &gmac_set_multicast;
  1666. dev->tx_timeout = &gmac_tx_timeout;
  1667. dev->watchdog_timeo = 5*HZ;
  1669. ether_setup(dev);
  1671. gm->next_gmac = gmacs;
  1672. gmacs = dev;
  1673. return;
  1675. out_unreg:
  1676. unregister_netdev(dev);
  1677. if (gm->of_node)
  1678. release_OF_resource(gm->of_node, 0);
  1679. kfree(dev);
  1680. out_rxdesc:
  1681. free_page(rx_descpage);
  1682. out_txdesc:
  1683. free_page(tx_descpage);
  1684. }
  1686. MODULE_AUTHOR("Paul Mackerras/Ben Herrenschmidt");
  1687. MODULE_DESCRIPTION("PowerMac GMAC driver.");
  1688. MODULE_LICENSE("GPL");
  1689. EXPORT_NO_SYMBOLS;
  1691. static void __exit gmac_cleanup_module(void)
  1692. {
  1693. struct gmac *gm;
  1694. struct net_device *dev;
  1696. #ifdef CONFIG_PMAC_PBOOK
  1697. if (gmacs)
  1698. pmu_unregister_sleep_notifier(&gmac_sleep_notifier);
  1699. #endif
  1701. while ((dev = gmacs) != NULL) {
  1702. gm = (struct gmac *) dev->priv;
  1703. unregister_netdev(dev);
  1704. iounmap((void *) gm->regs);
  1705. free_page(gm->tx_desc_page);
  1706. free_page(gm->rx_desc_page);
  1707. release_OF_resource(gm->of_node, 0);
  1708. gmacs = gm->next_gmac;
  1709. kfree(dev);
  1710. }
  1711. if (dummy_buf != NULL) {
  1712. kfree(dummy_buf);
  1713. dummy_buf = NULL;
  1714. }
  1715. }
  1717. module_init(gmac_probe);
  1718. module_exit(gmac_cleanup_module);