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

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

嵌入式Linux

开发平台：

Unix_Linux

mace.c：源码内容
  1. /*
  2.  * Network device driver for the MACE ethernet controller on
  3.  * Apple Powermacs.  Assumes it's under a DBDMA controller.
  4.  *
  5.  * Copyright (C) 1996 Paul Mackerras.
  6.  */
  8. #include <linux/config.h>
  9. #include <linux/module.h>
  10. #include <linux/version.h>
  11. #include <linux/kernel.h>
  12. #include <linux/netdevice.h>
  13. #include <linux/etherdevice.h>
  14. #include <linux/delay.h>
  15. #include <linux/string.h>
  16. #include <linux/timer.h>
  17. #include <linux/init.h>
  18. #include <asm/prom.h>
  19. #include <asm/dbdma.h>
  20. #include <asm/io.h>
  21. #include <asm/pgtable.h>
  22. #include "mace.h"
  24. static struct net_device *mace_devs;
  25. static int port_aaui = -1;
  27. #define N_RX_RING 8
  28. #define N_TX_RING 6
  29. #define MAX_TX_ACTIVE 1
  30. #define NCMDS_TX 1 /* dma commands per element in tx ring */
  31. #define RX_BUFLEN (ETH_FRAME_LEN + 8)
  32. #define TX_TIMEOUT HZ /* 1 second */
  34. /* Chip rev needs workaround on HW & multicast addr change */
  35. #define BROKEN_ADDRCHG_REV 0x0941
  37. /* Bits in transmit DMA status */
  38. #define TX_DMA_ERR 0x80
  40. struct mace_data {
  41.     volatile struct mace *mace;
  42.     volatile struct dbdma_regs *tx_dma;
  43.     int tx_dma_intr;
  44.     volatile struct dbdma_regs *rx_dma;
  45.     int rx_dma_intr;
  46.     volatile struct dbdma_cmd *tx_cmds; /* xmit dma command list */
  47.     volatile struct dbdma_cmd *rx_cmds; /* recv dma command list */
  48.     struct sk_buff *rx_bufs[N_RX_RING];
  49.     int rx_fill;
  50.     int rx_empty;
  51.     struct sk_buff *tx_bufs[N_TX_RING];
  52.     int tx_fill;
  53.     int tx_empty;
  54.     unsigned char maccc;
  55.     unsigned char tx_fullup;
  56.     unsigned char tx_active;
  57.     unsigned char tx_bad_runt;
  58.     struct net_device_stats stats;
  59.     struct timer_list tx_timeout;
  60.     int timeout_active;
  61.     int port_aaui;
  62.     int chipid;
  63.     struct device_node* of_node;
  64.     struct net_device *next_mace;
  65. };
  67. /*
  68.  * Number of bytes of private data per MACE: allow enough for
  69.  * the rx and tx dma commands plus a branch dma command each,
  70.  * and another 16 bytes to allow us to align the dma command
  71.  * buffers on a 16 byte boundary.
  72.  */
  73. #define PRIV_BYTES (sizeof(struct mace_data) 
  74. + (N_RX_RING + NCMDS_TX * N_TX_RING + 3) * sizeof(struct dbdma_cmd))
  76. static int bitrev(int);
  77. static int mace_probe(void);
  78. static void mace_probe1(struct device_node *mace);
  79. static int mace_open(struct net_device *dev);
  80. static int mace_close(struct net_device *dev);
  81. static int mace_xmit_start(struct sk_buff *skb, struct net_device *dev);
  82. static struct net_device_stats *mace_stats(struct net_device *dev);
  83. static void mace_set_multicast(struct net_device *dev);
  84. static void mace_reset(struct net_device *dev);
  85. static int mace_set_address(struct net_device *dev, void *addr);
  86. static void mace_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  87. static void mace_txdma_intr(int irq, void *dev_id, struct pt_regs *regs);
  88. static void mace_rxdma_intr(int irq, void *dev_id, struct pt_regs *regs);
  89. static void mace_set_timeout(struct net_device *dev);
  90. static void mace_tx_timeout(unsigned long data);
  91. static inline void dbdma_reset(volatile struct dbdma_regs *dma);
  92. static inline void mace_clean_rings(struct mace_data *mp);
  93. static void __mace_set_address(struct net_device *dev, void *addr);
  95. /*
  96.  * If we can't get a skbuff when we need it, we use this area for DMA.
  97.  */
  98. static unsigned char *dummy_buf;
  100. /* Bit-reverse one byte of an ethernet hardware address. */
  101. static inline int
  102. bitrev(int b)
  103. {
  104.     int d = 0, i;
  106.     for (i = 0; i < 8; ++i, b >>= 1)
  107. d = (d << 1) | (b & 1);
  108.     return d;
  109. }
  111. static int __init mace_probe(void)
  112. {
  113. struct device_node *mace;
  115. for (mace = find_devices("mace"); mace != NULL; mace = mace->next)
  116. mace_probe1(mace);
  117. return mace_devs? 0: -ENODEV;
  118. }
  120. static void __init mace_probe1(struct device_node *mace)
  121. {
  122. int j, rev;
  123. struct net_device *dev;
  124. struct mace_data *mp;
  125. unsigned char *addr;
  127. if (mace->n_addrs != 3 || mace->n_intrs != 3) {
  128. printk(KERN_ERR "can't use MACE %s: need 3 addrs and 3 irqsn",
  129.        mace->full_name);
  130. return;
  131. }
  133. addr = get_property(mace, "mac-address", NULL);
  134. if (addr == NULL) {
  135. addr = get_property(mace, "local-mac-address", NULL);
  136. if (addr == NULL) {
  137. printk(KERN_ERR "Can't get mac-address for MACE %sn",
  138.        mace->full_name);
  139. return;
  140. }
  141. }
  143. if (dummy_buf == NULL) {
  144. dummy_buf = kmalloc(RX_BUFLEN+2, GFP_KERNEL);
  145. if (dummy_buf == NULL) {
  146. printk(KERN_ERR "MACE: couldn't allocate dummy buffern");
  147. return;
  148. }
  149. }
  151. dev = init_etherdev(0, PRIV_BYTES);
  152. if (!dev)
  153. return;
  154. SET_MODULE_OWNER(dev);
  156. mp = dev->priv;
  157. mp->of_node = mace;
  159. if (!request_OF_resource(mace, 0, " (mace)")) {
  160. printk(KERN_ERR "MACE: can't request IO resource !n");
  161. goto err_out;
  162. }
  163. if (!request_OF_resource(mace, 1, " (mace tx dma)")) {
  164. printk(KERN_ERR "MACE: can't request TX DMA resource !n");
  165. goto err_out;
  166. }
  168. if (!request_OF_resource(mace, 2, " (mace tx dma)")) {
  169. printk(KERN_ERR "MACE: can't request RX DMA resource !n");
  170. goto err_out;
  171. }
  173. dev->base_addr = mace->addrs[0].address;
  174. mp->mace = (volatile struct mace *)
  175. ioremap(mace->addrs[0].address, 0x1000);
  176. dev->irq = mace->intrs[0].line;
  178. printk(KERN_INFO "%s: MACE at", dev->name);
  179. rev = addr[0] == 0 && addr[1] == 0xA0;
  180. for (j = 0; j < 6; ++j) {
  181. dev->dev_addr[j] = rev? bitrev(addr[j]): addr[j];
  182. printk("%c%.2x", (j? ':': ' '), dev->dev_addr[j]);
  183. }
  184. mp->chipid = (in_8(&mp->mace->chipid_hi) << 8) |
  185. in_8(&mp->mace->chipid_lo);
  186. printk(", chip revision %d.%dn", mp->chipid >> 8, mp->chipid & 0xff);
  189. mp = (struct mace_data *) dev->priv;
  190. mp->maccc = ENXMT | ENRCV;
  191. mp->tx_dma = (volatile struct dbdma_regs *)
  192. ioremap(mace->addrs[1].address, 0x1000);
  193. mp->tx_dma_intr = mace->intrs[1].line;
  194. mp->rx_dma = (volatile struct dbdma_regs *)
  195. ioremap(mace->addrs[2].address, 0x1000);
  196. mp->rx_dma_intr = mace->intrs[2].line;
  198. mp->tx_cmds = (volatile struct dbdma_cmd *) DBDMA_ALIGN(mp + 1);
  199. mp->rx_cmds = mp->tx_cmds + NCMDS_TX * N_TX_RING + 1;
  201. memset(&mp->stats, 0, sizeof(mp->stats));
  202. memset((char *) mp->tx_cmds, 0,
  203.        (NCMDS_TX*N_TX_RING + N_RX_RING + 2) * sizeof(struct dbdma_cmd));
  204. init_timer(&mp->tx_timeout);
  205. mp->timeout_active = 0;
  207. if (port_aaui >= 0)
  208. mp->port_aaui = port_aaui;
  209. else {
  210. /* Apple Network Server uses the AAUI port */
  211. if (machine_is_compatible("AAPL,ShinerESB"))
  212. mp->port_aaui = 1;
  213. else {
  214. #ifdef CONFIG_MACE_AAUI_PORT
  215. mp->port_aaui = 1;
  216. #else
  217. mp->port_aaui = 0;
  218. #endif
  219. }
  220. }
  222. dev->open = mace_open;
  223. dev->stop = mace_close;
  224. dev->hard_start_xmit = mace_xmit_start;
  225. dev->get_stats = mace_stats;
  226. dev->set_multicast_list = mace_set_multicast;
  227. dev->set_mac_address = mace_set_address;
  229. ether_setup(dev);
  231. mace_reset(dev);
  233. if (request_irq(dev->irq, mace_interrupt, 0, "MACE", dev))
  234. printk(KERN_ERR "MACE: can't get irq %dn", dev->irq);
  235. if (request_irq(mace->intrs[1].line, mace_txdma_intr, 0, "MACE-txdma",
  236. dev))
  237. printk(KERN_ERR "MACE: can't get irq %dn", mace->intrs[1].line);
  238. if (request_irq(mace->intrs[2].line, mace_rxdma_intr, 0, "MACE-rxdma",
  239. dev))
  240. printk(KERN_ERR "MACE: can't get irq %dn", mace->intrs[2].line);
  242. mp->next_mace = mace_devs;
  243. mace_devs = dev;
  244. return;
  246. err_out:
  247. unregister_netdev(dev);
  248. if (mp->of_node) {
  249. release_OF_resource(mp->of_node, 0);
  250. release_OF_resource(mp->of_node, 1);
  251. release_OF_resource(mp->of_node, 2);
  252. }
  253. kfree(dev);
  254. }
  256. static void dbdma_reset(volatile struct dbdma_regs *dma)
  257. {
  258.     int i;
  260.     out_le32(&dma->control, (WAKE|FLUSH|PAUSE|RUN) << 16);
  262.     /*
  263.      * Yes this looks peculiar, but apparently it needs to be this
  264.      * way on some machines.
  265.      */
  266.     for (i = 200; i > 0; --i)
  267. if (ld_le32(&dma->control) & RUN)
  268.     udelay(1);
  269. }
  271. static void mace_reset(struct net_device *dev)
  272. {
  273.     struct mace_data *mp = (struct mace_data *) dev->priv;
  274.     volatile struct mace *mb = mp->mace;
  275.     int i;
  277.     /* soft-reset the chip */
  278.     i = 200;
  279.     while (--i) {
  280. out_8(&mb->biucc, SWRST);
  281. if (in_8(&mb->biucc) & SWRST) {
  282.     udelay(10);
  283.     continue;
  284. }
  285. break;
  286.     }
  287.     if (!i) {
  288. printk(KERN_ERR "mace: cannot reset chip!n");
  289. return;
  290.     }
  292.     out_8(&mb->imr, 0xff); /* disable all intrs for now */
  293.     i = in_8(&mb->ir);
  294.     out_8(&mb->maccc, 0); /* turn off tx, rx */
  296.     out_8(&mb->biucc, XMTSP_64);
  297.     out_8(&mb->utr, RTRD);
  298.     out_8(&mb->fifocc, RCVFW_32 | XMTFW_16 | XMTFWU | RCVFWU | XMTBRST);
  299.     out_8(&mb->xmtfc, AUTO_PAD_XMIT); /* auto-pad short frames */
  300.     out_8(&mb->rcvfc, 0);
  302.     /* load up the hardware address */
  303.     __mace_set_address(dev, dev->dev_addr);
  305.     /* clear the multicast filter */
  306.     if (mp->chipid == BROKEN_ADDRCHG_REV)
  307. out_8(&mb->iac, LOGADDR);
  308.     else {
  309. out_8(&mb->iac, ADDRCHG | LOGADDR);
  310. while ((in_8(&mb->iac) & ADDRCHG) != 0)
  311. ;
  312.     }
  313.     for (i = 0; i < 8; ++i)
  314. out_8(&mb->ladrf, 0);
  316.     /* done changing address */
  317.     if (mp->chipid != BROKEN_ADDRCHG_REV)
  318. out_8(&mb->iac, 0);
  320.     if (mp->port_aaui)
  321.      out_8(&mb->plscc, PORTSEL_AUI + ENPLSIO);
  322.     else
  323.      out_8(&mb->plscc, PORTSEL_GPSI + ENPLSIO);
  324. }
  326. static void __mace_set_address(struct net_device *dev, void *addr)
  327. {
  328.     struct mace_data *mp = (struct mace_data *) dev->priv;
  329.     volatile struct mace *mb = mp->mace;
  330.     unsigned char *p = addr;
  331.     int i;
  333.     /* load up the hardware address */
  334.     if (mp->chipid == BROKEN_ADDRCHG_REV)
  335.      out_8(&mb->iac, PHYADDR);
  336.     else {
  337.      out_8(&mb->iac, ADDRCHG | PHYADDR);
  338. while ((in_8(&mb->iac) & ADDRCHG) != 0)
  339.     ;
  340.     }
  341.     for (i = 0; i < 6; ++i)
  342. out_8(&mb->padr, dev->dev_addr[i] = p[i]);
  343.     if (mp->chipid != BROKEN_ADDRCHG_REV)
  344.         out_8(&mb->iac, 0);
  345. }
  347. static int mace_set_address(struct net_device *dev, void *addr)
  348. {
  349.     struct mace_data *mp = (struct mace_data *) dev->priv;
  350.     volatile struct mace *mb = mp->mace;
  351.     unsigned long flags;
  353.     save_flags(flags); cli();
  355.     __mace_set_address(dev, addr);
  357.     /* note: setting ADDRCHG clears ENRCV */
  358.     out_8(&mb->maccc, mp->maccc);
  360.     restore_flags(flags);
  361.     return 0;
  362. }
  364. static int mace_open(struct net_device *dev)
  365. {
  366.     struct mace_data *mp = (struct mace_data *) dev->priv;
  367.     volatile struct mace *mb = mp->mace;
  368.     volatile struct dbdma_regs *rd = mp->rx_dma;
  369.     volatile struct dbdma_regs *td = mp->tx_dma;
  370.     volatile struct dbdma_cmd *cp;
  371.     int i;
  372.     struct sk_buff *skb;
  373.     unsigned char *data;
  375.     /* reset the chip */
  376.     mace_reset(dev);
  378.     /* initialize list of sk_buffs for receiving and set up recv dma */
  379.     mace_clean_rings(mp);
  380.     memset((char *)mp->rx_cmds, 0, N_RX_RING * sizeof(struct dbdma_cmd));
  381.     cp = mp->rx_cmds;
  382.     for (i = 0; i < N_RX_RING - 1; ++i) {
  383. skb = dev_alloc_skb(RX_BUFLEN + 2);
  384. if (skb == 0) {
  385.     data = dummy_buf;
  386. } else {
  387.     skb_reserve(skb, 2); /* so IP header lands on 4-byte bdry */
  388.     data = skb->data;
  389. }
  390. mp->rx_bufs[i] = skb;
  391. st_le16(&cp->req_count, RX_BUFLEN);
  392. st_le16(&cp->command, INPUT_LAST + INTR_ALWAYS);
  393. st_le32(&cp->phy_addr, virt_to_bus(data));
  394. cp->xfer_status = 0;
  395. ++cp;
  396.     }
  397.     mp->rx_bufs[i] = 0;
  398.     st_le16(&cp->command, DBDMA_STOP);
  399.     mp->rx_fill = i;
  400.     mp->rx_empty = 0;
  402.     /* Put a branch back to the beginning of the receive command list */
  403.     ++cp;
  404.     st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
  405.     st_le32(&cp->cmd_dep, virt_to_bus(mp->rx_cmds));
  407.     /* start rx dma */
  408.     out_le32(&rd->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
  409.     out_le32(&rd->cmdptr, virt_to_bus(mp->rx_cmds));
  410.     out_le32(&rd->control, (RUN << 16) | RUN);
  412.     /* put a branch at the end of the tx command list */
  413.     cp = mp->tx_cmds + NCMDS_TX * N_TX_RING;
  414.     st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
  415.     st_le32(&cp->cmd_dep, virt_to_bus(mp->tx_cmds));
  417.     /* reset tx dma */
  418.     out_le32(&td->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
  419.     out_le32(&td->cmdptr, virt_to_bus(mp->tx_cmds));
  420.     mp->tx_fill = 0;
  421.     mp->tx_empty = 0;
  422.     mp->tx_fullup = 0;
  423.     mp->tx_active = 0;
  424.     mp->tx_bad_runt = 0;
  426.     /* turn it on! */
  427.     out_8(&mb->maccc, mp->maccc);
  428.     /* enable all interrupts except receive interrupts */
  429.     out_8(&mb->imr, RCVINT);
  431.     return 0;
  432. }
  434. static inline void mace_clean_rings(struct mace_data *mp)
  435. {
  436.     int i;
  438.     /* free some skb's */
  439.     for (i = 0; i < N_RX_RING; ++i) {
  440. if (mp->rx_bufs[i] != 0) {
  441.     dev_kfree_skb(mp->rx_bufs[i]);
  442.     mp->rx_bufs[i] = 0;
  443. }
  444.     }
  445.     for (i = mp->tx_empty; i != mp->tx_fill; ) {
  446. dev_kfree_skb(mp->tx_bufs[i]);
  447. if (++i >= N_TX_RING)
  448.     i = 0;
  449.     }
  450. }
  452. static int mace_close(struct net_device *dev)
  453. {
  454.     struct mace_data *mp = (struct mace_data *) dev->priv;
  455.     volatile struct mace *mb = mp->mace;
  456.     volatile struct dbdma_regs *rd = mp->rx_dma;
  457.     volatile struct dbdma_regs *td = mp->tx_dma;
  459.     /* disable rx and tx */
  460.     out_8(&mb->maccc, 0);
  461.     out_8(&mb->imr, 0xff); /* disable all intrs */
  463.     /* disable rx and tx dma */
  464.     st_le32(&rd->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
  465.     st_le32(&td->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
  467.     mace_clean_rings(mp);
  469.     return 0;
  470. }
  472. static inline void mace_set_timeout(struct net_device *dev)
  473. {
  474.     struct mace_data *mp = (struct mace_data *) dev->priv;
  475.     unsigned long flags;
  477.     save_flags(flags);
  478.     cli();
  479.     if (mp->timeout_active)
  480. del_timer(&mp->tx_timeout);
  481.     mp->tx_timeout.expires = jiffies + TX_TIMEOUT;
  482.     mp->tx_timeout.function = mace_tx_timeout;
  483.     mp->tx_timeout.data = (unsigned long) dev;
  484.     add_timer(&mp->tx_timeout);
  485.     mp->timeout_active = 1;
  486.     restore_flags(flags);
  487. }
  489. static int mace_xmit_start(struct sk_buff *skb, struct net_device *dev)
  490. {
  491.     struct mace_data *mp = (struct mace_data *) dev->priv;
  492.     volatile struct dbdma_regs *td = mp->tx_dma;
  493.     volatile struct dbdma_cmd *cp, *np;
  494.     unsigned long flags;
  495.     int fill, next, len;
  497.     /* see if there's a free slot in the tx ring */
  498.     save_flags(flags); cli();
  499.     fill = mp->tx_fill;
  500.     next = fill + 1;
  501.     if (next >= N_TX_RING)
  502. next = 0;
  503.     if (next == mp->tx_empty) {
  504. netif_stop_queue(dev);
  505. mp->tx_fullup = 1;
  506. restore_flags(flags);
  507. return 1; /* can't take it at the moment */
  508.     }
  509.     restore_flags(flags);
  511.     /* partially fill in the dma command block */
  512.     len = skb->len;
  513.     if (len > ETH_FRAME_LEN) {
  514. printk(KERN_DEBUG "mace: xmit frame too long (%d)n", len);
  515. len = ETH_FRAME_LEN;
  516.     }
  517.     mp->tx_bufs[fill] = skb;
  518.     cp = mp->tx_cmds + NCMDS_TX * fill;
  519.     st_le16(&cp->req_count, len);
  520.     st_le32(&cp->phy_addr, virt_to_bus(skb->data));
  522.     np = mp->tx_cmds + NCMDS_TX * next;
  523.     out_le16(&np->command, DBDMA_STOP);
  525.     /* poke the tx dma channel */
  526.     save_flags(flags);
  527.     cli();
  528.     mp->tx_fill = next;
  529.     if (!mp->tx_bad_runt && mp->tx_active < MAX_TX_ACTIVE) {
  530. out_le16(&cp->xfer_status, 0);
  531. out_le16(&cp->command, OUTPUT_LAST);
  532. out_le32(&td->control, ((RUN|WAKE) << 16) + (RUN|WAKE));
  533. ++mp->tx_active;
  534. mace_set_timeout(dev);
  535.     }
  536.     if (++next >= N_TX_RING)
  537. next = 0;
  538.     if (next == mp->tx_empty)
  539. netif_stop_queue(dev);
  540.     restore_flags(flags);
  542.     return 0;
  543. }
  545. static struct net_device_stats *mace_stats(struct net_device *dev)
  546. {
  547.     struct mace_data *p = (struct mace_data *) dev->priv;
  549.     return &p->stats;
  550. }
  552. /*
  553.  * CRC polynomial - used in working out multicast filter bits.
  554.  */
  555. #define CRC_POLY 0xedb88320
  557. static void mace_set_multicast(struct net_device *dev)
  558. {
  559.     struct mace_data *mp = (struct mace_data *) dev->priv;
  560.     volatile struct mace *mb = mp->mace;
  561.     int i, j, k, b;
  562.     unsigned long crc;
  564.     mp->maccc &= ~PROM;
  565.     if (dev->flags & IFF_PROMISC) {
  566. mp->maccc |= PROM;
  567.     } else {
  568. unsigned char multicast_filter[8];
  569. struct dev_mc_list *dmi = dev->mc_list;
  571. if (dev->flags & IFF_ALLMULTI) {
  572.     for (i = 0; i < 8; i++)
  573. multicast_filter[i] = 0xff;
  574. } else {
  575.     for (i = 0; i < 8; i++)
  576. multicast_filter[i] = 0;
  577.     for (i = 0; i < dev->mc_count; i++) {
  578. crc = ~0;
  579. for (j = 0; j < 6; ++j) {
  580.     b = dmi->dmi_addr[j];
  581.     for (k = 0; k < 8; ++k) {
  582. if ((crc ^ b) & 1)
  583.     crc = (crc >> 1) ^ CRC_POLY;
  584. else
  585.     crc >>= 1;
  586. b >>= 1;
  587.     }
  588. }
  589. j = crc >> 26; /* bit number in multicast_filter */
  590. multicast_filter[j >> 3] |= 1 << (j & 7);
  591. dmi = dmi->next;
  592.     }
  593. }
  594. #if 0
  595. printk("Multicast filter :");
  596. for (i = 0; i < 8; i++)
  597.     printk("%02x ", multicast_filter[i]);
  598. printk("n");
  599. #endif
  601. if (mp->chipid == BROKEN_ADDRCHG_REV)
  602.     out_8(&mb->iac, LOGADDR);
  603. else {
  604.     out_8(&mb->iac, ADDRCHG | LOGADDR);
  605.     while ((in_8(&mb->iac) & ADDRCHG) != 0)
  606. ;
  607. }
  608. for (i = 0; i < 8; ++i)
  609.     out_8(&mb->ladrf, multicast_filter[i]);
  610. if (mp->chipid != BROKEN_ADDRCHG_REV)
  611.     out_8(&mb->iac, 0);
  612.     }
  613.     /* reset maccc */
  614.     out_8(&mb->maccc, mp->maccc);
  615. }
  617. static void mace_handle_misc_intrs(struct mace_data *mp, int intr)
  618. {
  619.     volatile struct mace *mb = mp->mace;
  620.     static int mace_babbles, mace_jabbers;
  622.     if (intr & MPCO)
  623. mp->stats.rx_missed_errors += 256;
  624.     mp->stats.rx_missed_errors += in_8(&mb->mpc);   /* reading clears it */
  625.     if (intr & RNTPCO)
  626. mp->stats.rx_length_errors += 256;
  627.     mp->stats.rx_length_errors += in_8(&mb->rntpc); /* reading clears it */
  628.     if (intr & CERR)
  629. ++mp->stats.tx_heartbeat_errors;
  630.     if (intr & BABBLE)
  631. if (mace_babbles++ < 4)
  632.     printk(KERN_DEBUG "mace: babbling transmittern");
  633.     if (intr & JABBER)
  634. if (mace_jabbers++ < 4)
  635.     printk(KERN_DEBUG "mace: jabbering transceivern");
  636. }
  638. static void mace_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  639. {
  640.     struct net_device *dev = (struct net_device *) dev_id;
  641.     struct mace_data *mp = (struct mace_data *) dev->priv;
  642.     volatile struct mace *mb = mp->mace;
  643.     volatile struct dbdma_regs *td = mp->tx_dma;
  644.     volatile struct dbdma_cmd *cp;
  645.     int intr, fs, i, stat, x;
  646.     int xcount, dstat;
  647.     /* static int mace_last_fs, mace_last_xcount; */
  649.     intr = in_8(&mb->ir); /* read interrupt register */
  650.     in_8(&mb->xmtrc); /* get retries */
  651.     mace_handle_misc_intrs(mp, intr);
  653.     i = mp->tx_empty;
  654.     while (in_8(&mb->pr) & XMTSV) {
  655. del_timer(&mp->tx_timeout);
  656. mp->timeout_active = 0;
  657. /*
  658.  * Clear any interrupt indication associated with this status
  659.  * word.  This appears to unlatch any error indication from
  660.  * the DMA controller.
  661.  */
  662. intr = in_8(&mb->ir);
  663. if (intr != 0)
  664.     mace_handle_misc_intrs(mp, intr);
  665. if (mp->tx_bad_runt) {
  666.     fs = in_8(&mb->xmtfs);
  667.     mp->tx_bad_runt = 0;
  668.     out_8(&mb->xmtfc, AUTO_PAD_XMIT);
  669.     continue;
  670. }
  671. dstat = ld_le32(&td->status);
  672. /* stop DMA controller */
  673. out_le32(&td->control, RUN << 16);
  674. /*
  675.  * xcount is the number of complete frames which have been
  676.  * written to the fifo but for which status has not been read.
  677.  */
  678. xcount = (in_8(&mb->fifofc) >> XMTFC_SH) & XMTFC_MASK;
  679. if (xcount == 0 || (dstat & DEAD)) {
  680.     /*
  681.      * If a packet was aborted before the DMA controller has
  682.      * finished transferring it, it seems that there are 2 bytes
  683.      * which are stuck in some buffer somewhere.  These will get
  684.      * transmitted as soon as we read the frame status (which
  685.      * reenables the transmit data transfer request).  Turning
  686.      * off the DMA controller and/or resetting the MACE doesn't
  687.      * help.  So we disable auto-padding and FCS transmission
  688.      * so the two bytes will only be a runt packet which should
  689.      * be ignored by other stations.
  690.      */
  691.     out_8(&mb->xmtfc, DXMTFCS);
  692. }
  693. fs = in_8(&mb->xmtfs);
  694. if ((fs & XMTSV) == 0) {
  695.     printk(KERN_ERR "mace: xmtfs not valid! (fs=%x xc=%d ds=%x)n",
  696.    fs, xcount, dstat);
  697.     mace_reset(dev);
  698. /*
  699.  * XXX mace likes to hang the machine after a xmtfs error.
  700.  * This is hard to reproduce, reseting *may* help
  701.  */
  702. }
  703. cp = mp->tx_cmds + NCMDS_TX * i;
  704. stat = ld_le16(&cp->xfer_status);
  705. if ((fs & (UFLO|LCOL|LCAR|RTRY)) || (dstat & DEAD) || xcount == 0) {
  706.     /*
  707.      * Check whether there were in fact 2 bytes written to
  708.      * the transmit FIFO.
  709.      */
  710.     udelay(1);
  711.     x = (in_8(&mb->fifofc) >> XMTFC_SH) & XMTFC_MASK;
  712.     if (x != 0) {
  713. /* there were two bytes with an end-of-packet indication */
  714. mp->tx_bad_runt = 1;
  715. mace_set_timeout(dev);
  716.     } else {
  717. /*
  718.  * Either there weren't the two bytes buffered up, or they
  719.  * didn't have an end-of-packet indication.
  720.  * We flush the transmit FIFO just in case (by setting the
  721.  * XMTFWU bit with the transmitter disabled).
  722.  */
  723. out_8(&mb->maccc, in_8(&mb->maccc) & ~ENXMT);
  724. out_8(&mb->fifocc, in_8(&mb->fifocc) | XMTFWU);
  725. udelay(1);
  726. out_8(&mb->maccc, in_8(&mb->maccc) | ENXMT);
  727. out_8(&mb->xmtfc, AUTO_PAD_XMIT);
  728.     }
  729. }
  730. /* dma should have finished */
  731. if (i == mp->tx_fill) {
  732.     printk(KERN_DEBUG "mace: tx ring ran out? (fs=%x xc=%d ds=%x)n",
  733.    fs, xcount, dstat);
  734.     continue;
  735. }
  736. /* Update stats */
  737. if (fs & (UFLO|LCOL|LCAR|RTRY)) {
  738.     ++mp->stats.tx_errors;
  739.     if (fs & LCAR)
  740. ++mp->stats.tx_carrier_errors;
  741.     if (fs & (UFLO|LCOL|RTRY))
  742. ++mp->stats.tx_aborted_errors;
  743. } else {
  744.     mp->stats.tx_bytes += mp->tx_bufs[i]->len;
  745.     ++mp->stats.tx_packets;
  746. }
  747. dev_kfree_skb_irq(mp->tx_bufs[i]);
  748. --mp->tx_active;
  749. if (++i >= N_TX_RING)
  750.     i = 0;
  751. #if 0
  752. mace_last_fs = fs;
  753. mace_last_xcount = xcount;
  754. #endif
  755.     }
  757.     if (i != mp->tx_empty) {
  758. mp->tx_fullup = 0;
  759. netif_wake_queue(dev);
  760.     }
  761.     mp->tx_empty = i;
  762.     i += mp->tx_active;
  763.     if (i >= N_TX_RING)
  764. i -= N_TX_RING;
  765.     if (!mp->tx_bad_runt && i != mp->tx_fill && mp->tx_active < MAX_TX_ACTIVE) {
  766. do {
  767.     /* set up the next one */
  768.     cp = mp->tx_cmds + NCMDS_TX * i;
  769.     out_le16(&cp->xfer_status, 0);
  770.     out_le16(&cp->command, OUTPUT_LAST);
  771.     ++mp->tx_active;
  772.     if (++i >= N_TX_RING)
  773. i = 0;
  774. } while (i != mp->tx_fill && mp->tx_active < MAX_TX_ACTIVE);
  775. out_le32(&td->control, ((RUN|WAKE) << 16) + (RUN|WAKE));
  776. mace_set_timeout(dev);
  777.     }
  778. }
  780. static void mace_tx_timeout(unsigned long data)
  781. {
  782.     struct net_device *dev = (struct net_device *) data;
  783.     struct mace_data *mp = (struct mace_data *) dev->priv;
  784.     volatile struct mace *mb = mp->mace;
  785.     volatile struct dbdma_regs *td = mp->tx_dma;
  786.     volatile struct dbdma_regs *rd = mp->rx_dma;
  787.     volatile struct dbdma_cmd *cp;
  788.     unsigned long flags;
  789.     int i;
  791.     save_flags(flags);
  792.     cli();
  793.     mp->timeout_active = 0;
  794.     if (mp->tx_active == 0 && !mp->tx_bad_runt)
  795. goto out;
  797.     /* update various counters */
  798.     mace_handle_misc_intrs(mp, in_8(&mb->ir));
  800.     cp = mp->tx_cmds + NCMDS_TX * mp->tx_empty;
  802.     /* turn off both tx and rx and reset the chip */
  803.     out_8(&mb->maccc, 0);
  804.     printk(KERN_ERR "mace: transmit timeout - resettingn");
  805.     dbdma_reset(td);
  806.     mace_reset(dev);
  808.     /* restart rx dma */
  809.     cp = bus_to_virt(ld_le32(&rd->cmdptr));
  810.     dbdma_reset(rd);
  811.     out_le16(&cp->xfer_status, 0);
  812.     out_le32(&rd->cmdptr, virt_to_bus(cp));
  813.     out_le32(&rd->control, (RUN << 16) | RUN);
  815.     /* fix up the transmit side */
  816.     i = mp->tx_empty;
  817.     mp->tx_active = 0;
  818.     ++mp->stats.tx_errors;
  819.     if (mp->tx_bad_runt) {
  820. mp->tx_bad_runt = 0;
  821.     } else if (i != mp->tx_fill) {
  822. dev_kfree_skb(mp->tx_bufs[i]);
  823. if (++i >= N_TX_RING)
  824.     i = 0;
  825. mp->tx_empty = i;
  826.     }
  827.     mp->tx_fullup = 0;
  828.     netif_wake_queue(dev);
  829.     if (i != mp->tx_fill) {
  830. cp = mp->tx_cmds + NCMDS_TX * i;
  831. out_le16(&cp->xfer_status, 0);
  832. out_le16(&cp->command, OUTPUT_LAST);
  833. out_le32(&td->cmdptr, virt_to_bus(cp));
  834. out_le32(&td->control, (RUN << 16) | RUN);
  835. ++mp->tx_active;
  836. mace_set_timeout(dev);
  837.     }
  839.     /* turn it back on */
  840.     out_8(&mb->imr, RCVINT);
  841.     out_8(&mb->maccc, mp->maccc);
  843. out:
  844.     restore_flags(flags);
  845. }
  847. static void mace_txdma_intr(int irq, void *dev_id, struct pt_regs *regs)
  848. {
  849. }
  851. static void mace_rxdma_intr(int irq, void *dev_id, struct pt_regs *regs)
  852. {
  853.     struct net_device *dev = (struct net_device *) dev_id;
  854.     struct mace_data *mp = (struct mace_data *) dev->priv;
  855.     volatile struct dbdma_regs *rd = mp->rx_dma;
  856.     volatile struct dbdma_cmd *cp, *np;
  857.     int i, nb, stat, next;
  858.     struct sk_buff *skb;
  859.     unsigned frame_status;
  860.     static int mace_lost_status;
  861.     unsigned char *data;
  863.     for (i = mp->rx_empty; i != mp->rx_fill; ) {
  864. cp = mp->rx_cmds + i;
  865. stat = ld_le16(&cp->xfer_status);
  866. if ((stat & ACTIVE) == 0) {
  867.     next = i + 1;
  868.     if (next >= N_RX_RING)
  869. next = 0;
  870.     np = mp->rx_cmds + next;
  871.     if (next != mp->rx_fill
  872. && (ld_le16(&np->xfer_status) & ACTIVE) != 0) {
  873. printk(KERN_DEBUG "mace: lost a status wordn");
  874. ++mace_lost_status;
  875.     } else
  876. break;
  877. }
  878. nb = ld_le16(&cp->req_count) - ld_le16(&cp->res_count);
  879. out_le16(&cp->command, DBDMA_STOP);
  880. /* got a packet, have a look at it */
  881. skb = mp->rx_bufs[i];
  882. if (skb == 0) {
  883.     ++mp->stats.rx_dropped;
  884. } else if (nb > 8) {
  885.     data = skb->data;
  886.     frame_status = (data[nb-3] << 8) + data[nb-4];
  887.     if (frame_status & (RS_OFLO|RS_CLSN|RS_FRAMERR|RS_FCSERR)) {
  888. ++mp->stats.rx_errors;
  889. if (frame_status & RS_OFLO)
  890.     ++mp->stats.rx_over_errors;
  891. if (frame_status & RS_FRAMERR)
  892.     ++mp->stats.rx_frame_errors;
  893. if (frame_status & RS_FCSERR)
  894.     ++mp->stats.rx_crc_errors;
  895.     } else {
  896. /* Mace feature AUTO_STRIP_RCV is on by default, dropping the
  897.  * FCS on frames with 802.3 headers. This means that Ethernet
  898.  * frames have 8 extra octets at the end, while 802.3 frames
  899.  * have only 4. We need to correctly account for this. */
  900. if (*(unsigned short *)(data+12) < 1536) /* 802.3 header */
  901.     nb -= 4;
  902. else /* Ethernet header; mace includes FCS */
  903.     nb -= 8;
  904. skb_put(skb, nb);
  905. skb->dev = dev;
  906. skb->protocol = eth_type_trans(skb, dev);
  907. mp->stats.rx_bytes += skb->len;
  908. netif_rx(skb);
  909. dev->last_rx = jiffies;
  910. mp->rx_bufs[i] = 0;
  911. ++mp->stats.rx_packets;
  912.     }
  913. } else {
  914.     ++mp->stats.rx_errors;
  915.     ++mp->stats.rx_length_errors;
  916. }
  918. /* advance to next */
  919. if (++i >= N_RX_RING)
  920.     i = 0;
  921.     }
  922.     mp->rx_empty = i;
  924.     i = mp->rx_fill;
  925.     for (;;) {
  926. next = i + 1;
  927. if (next >= N_RX_RING)
  928.     next = 0;
  929. if (next == mp->rx_empty)
  930.     break;
  931. cp = mp->rx_cmds + i;
  932. skb = mp->rx_bufs[i];
  933. if (skb == 0) {
  934.     skb = dev_alloc_skb(RX_BUFLEN + 2);
  935.     if (skb != 0) {
  936. skb_reserve(skb, 2);
  937. mp->rx_bufs[i] = skb;
  938.     }
  939. }
  940. st_le16(&cp->req_count, RX_BUFLEN);
  941. data = skb? skb->data: dummy_buf;
  942. st_le32(&cp->phy_addr, virt_to_bus(data));
  943. out_le16(&cp->xfer_status, 0);
  944. out_le16(&cp->command, INPUT_LAST + INTR_ALWAYS);
  945. #if 0
  946. if ((ld_le32(&rd->status) & ACTIVE) != 0) {
  947.     out_le32(&rd->control, (PAUSE << 16) | PAUSE);
  948.     while ((in_le32(&rd->status) & ACTIVE) != 0)
  949. ;
  950. }
  951. #endif
  952. i = next;
  953.     }
  954.     if (i != mp->rx_fill) {
  955. out_le32(&rd->control, ((RUN|WAKE) << 16) | (RUN|WAKE));
  956. mp->rx_fill = i;
  957.     }
  958. }
  960. MODULE_AUTHOR("Paul Mackerras");
  961. MODULE_DESCRIPTION("PowerMac MACE driver.");
  962. MODULE_PARM(port_aaui, "i");
  963. MODULE_PARM_DESC(port_aaui, "MACE uses AAUI port (0-1)");
  964. MODULE_LICENSE("GPL");
  965. EXPORT_NO_SYMBOLS;
  967. static void __exit mace_cleanup (void)
  968. {
  969.     struct net_device *dev;
  970.     struct mace_data *mp;
  972.     while ((dev = mace_devs) != 0) {
  973. mp = (struct mace_data *) mace_devs->priv;
  974. mace_devs = mp->next_mace;
  976. unregister_netdev(dev);
  977. free_irq(dev->irq, dev);
  978. free_irq(mp->tx_dma_intr, dev);
  979. free_irq(mp->rx_dma_intr, dev);
  981. release_OF_resource(mp->of_node, 0);
  982. release_OF_resource(mp->of_node, 1);
  983. release_OF_resource(mp->of_node, 2);
  985. kfree(dev);
  986.     }
  987.     if (dummy_buf != NULL) {
  988. kfree(dummy_buf);
  989. dummy_buf = NULL;
  990.     }
  991. }
  993. module_init(mace_probe);
  994. module_exit(mace_cleanup);