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

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

Linux/Unix编程

开发平台：

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