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

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

嵌入式Linux

开发平台：

Unix_Linux

bmac.c：源码内容
  1. /*
  2.  * Network device driver for the BMAC ethernet controller on
  3.  * Apple Powermacs.  Assumes it's under a DBDMA controller.
  4.  *
  5.  * Copyright (C) 1998 Randy Gobbel.
  6.  *
  7.  * May 1999, Al Viro: proper release of /proc/net/bmac entry, switched to
  8.  * dynamic procfs inode.
  9.  */
  10. #include <linux/config.h>
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/netdevice.h>
  14. #include <linux/etherdevice.h>
  15. #include <linux/delay.h>
  16. #include <linux/string.h>
  17. #include <linux/timer.h>
  18. #include <linux/proc_fs.h>
  19. #include <linux/init.h>
  20. #include <asm/prom.h>
  21. #include <asm/dbdma.h>
  22. #include <asm/io.h>
  23. #include <asm/page.h>
  24. #include <asm/pgtable.h>
  25. #include <asm/machdep.h>
  26. #include <asm/pmac_feature.h>
  27. #ifdef CONFIG_PMAC_PBOOK
  28. #include <linux/adb.h>
  29. #include <linux/pmu.h>
  30. #include <asm/irq.h>
  31. #endif
  32. #include "bmac.h"
  34. #define trunc_page(x) ((void *)(((unsigned long)(x)) & ~((unsigned long)(PAGE_SIZE - 1))))
  35. #define round_page(x) trunc_page(((unsigned long)(x)) + ((unsigned long)(PAGE_SIZE - 1)))
  37. /*
  38.  * CRC polynomial - used in working out multicast filter bits.
  39.  */
  40. #define ENET_CRCPOLY 0x04c11db7
  42. /* switch to use multicast code lifted from sunhme driver */
  43. #define SUNHME_MULTICAST
  45. #define N_RX_RING 64
  46. #define N_TX_RING 32
  47. #define MAX_TX_ACTIVE 1
  48. #define ETHERCRC 4
  49. #define ETHERMINPACKET 64
  50. #define ETHERMTU 1500
  51. #define RX_BUFLEN (ETHERMTU + 14 + ETHERCRC + 2)
  52. #define TX_TIMEOUT HZ /* 1 second */
  54. /* Bits in transmit DMA status */
  55. #define TX_DMA_ERR 0x80
  57. #define XXDEBUG(args)
  59. struct bmac_data {
  60. /* volatile struct bmac *bmac; */
  61. struct sk_buff_head *queue;
  62. volatile struct dbdma_regs *tx_dma;
  63. int tx_dma_intr;
  64. volatile struct dbdma_regs *rx_dma;
  65. int rx_dma_intr;
  66. volatile struct dbdma_cmd *tx_cmds; /* xmit dma command list */
  67. volatile struct dbdma_cmd *rx_cmds; /* recv dma command list */
  68. struct device_node *node;
  69. int is_bmac_plus;
  70. struct sk_buff *rx_bufs[N_RX_RING];
  71. int rx_fill;
  72. int rx_empty;
  73. struct sk_buff *tx_bufs[N_TX_RING];
  74. int tx_fill;
  75. int tx_empty;
  76. unsigned char tx_fullup;
  77. struct net_device_stats stats;
  78. struct timer_list tx_timeout;
  79. int timeout_active;
  80. int sleeping;
  81. int opened;
  82. unsigned short hash_use_count[64];
  83. unsigned short hash_table_mask[4];
  84. struct net_device *next_bmac;
  85. };
  87. typedef struct bmac_reg_entry {
  88. char *name;
  89. unsigned short reg_offset;
  90. } bmac_reg_entry_t;
  92. #define N_REG_ENTRIES 31
  94. static bmac_reg_entry_t reg_entries[N_REG_ENTRIES] = {
  95. {"MEMADD", MEMADD},
  96. {"MEMDATAHI", MEMDATAHI},
  97. {"MEMDATALO", MEMDATALO},
  98. {"TXPNTR", TXPNTR},
  99. {"RXPNTR", RXPNTR},
  100. {"IPG1", IPG1},
  101. {"IPG2", IPG2},
  102. {"ALIMIT", ALIMIT},
  103. {"SLOT", SLOT},
  104. {"PALEN", PALEN},
  105. {"PAPAT", PAPAT},
  106. {"TXSFD", TXSFD},
  107. {"JAM", JAM},
  108. {"TXCFG", TXCFG},
  109. {"TXMAX", TXMAX},
  110. {"TXMIN", TXMIN},
  111. {"PAREG", PAREG},
  112. {"DCNT", DCNT},
  113. {"NCCNT", NCCNT},
  114. {"NTCNT", NTCNT},
  115. {"EXCNT", EXCNT},
  116. {"LTCNT", LTCNT},
  117. {"TXSM", TXSM},
  118. {"RXCFG", RXCFG},
  119. {"RXMAX", RXMAX},
  120. {"RXMIN", RXMIN},
  121. {"FRCNT", FRCNT},
  122. {"AECNT", AECNT},
  123. {"FECNT", FECNT},
  124. {"RXSM", RXSM},
  125. {"RXCV", RXCV}
  126. };
  128. static struct net_device *bmac_devs;
  129. static unsigned char *bmac_emergency_rxbuf;
  131. #ifdef CONFIG_PMAC_PBOOK
  132. static int bmac_sleep_notify(struct pmu_sleep_notifier *self, int when);
  133. static struct pmu_sleep_notifier bmac_sleep_notifier = {
  134. bmac_sleep_notify, SLEEP_LEVEL_NET,
  135. };
  136. #endif
  138. /*
  139.  * Number of bytes of private data per BMAC: allow enough for
  140.  * the rx and tx dma commands plus a branch dma command each,
  141.  * and another 16 bytes to allow us to align the dma command
  142.  * buffers on a 16 byte boundary.
  143.  */
  144. #define PRIV_BYTES (sizeof(struct bmac_data) 
  145. + (N_RX_RING + N_TX_RING + 4) * sizeof(struct dbdma_cmd) 
  146. + sizeof(struct sk_buff_head))
  148. static unsigned char bitrev(unsigned char b);
  149. static void bmac_probe1(struct device_node *bmac, int is_bmac_plus);
  150. static int bmac_open(struct net_device *dev);
  151. static int bmac_close(struct net_device *dev);
  152. static int bmac_transmit_packet(struct sk_buff *skb, struct net_device *dev);
  153. static struct net_device_stats *bmac_stats(struct net_device *dev);
  154. static void bmac_set_multicast(struct net_device *dev);
  155. static void bmac_reset_and_enable(struct net_device *dev);
  156. static void bmac_start_chip(struct net_device *dev);
  157. static void bmac_init_chip(struct net_device *dev);
  158. static void bmac_init_registers(struct net_device *dev);
  159. static void bmac_enable_and_reset_chip(struct net_device *dev);
  160. static int bmac_set_address(struct net_device *dev, void *addr);
  161. static void bmac_misc_intr(int irq, void *dev_id, struct pt_regs *regs);
  162. static void bmac_txdma_intr(int irq, void *dev_id, struct pt_regs *regs);
  163. static void bmac_rxdma_intr(int irq, void *dev_id, struct pt_regs *regs);
  164. static void bmac_set_timeout(struct net_device *dev);
  165. static void bmac_tx_timeout(unsigned long data);
  166. static int bmac_proc_info ( char *buffer, char **start, off_t offset, int length);
  167. static int bmac_output(struct sk_buff *skb, struct net_device *dev);
  168. static void bmac_start(struct net_device *dev);
  170. #define DBDMA_SET(x) ( ((x) | (x) << 16) )
  171. #define DBDMA_CLEAR(x) ( (x) << 16)
  173. static inline void
  174. dbdma_st32(volatile unsigned long *a, unsigned long x)
  175. {
  176. __asm__ volatile( "stwbrx %0,0,%1" : : "r" (x), "r" (a) : "memory");
  177. return;
  178. }
  180. static inline unsigned long
  181. dbdma_ld32(volatile unsigned long *a)
  182. {
  183. unsigned long swap;
  184. __asm__ volatile ("lwbrx %0,0,%1" :  "=r" (swap) : "r" (a));
  185. return swap;
  186. }
  188. static void
  189. dbdma_continue(volatile struct dbdma_regs *dmap)
  190. {
  191. dbdma_st32((volatile unsigned long *)&dmap->control,
  192.    DBDMA_SET(RUN|WAKE) | DBDMA_CLEAR(PAUSE|DEAD));
  193. eieio();
  194. }
  196. static void
  197. dbdma_reset(volatile struct dbdma_regs *dmap)
  198. {
  199. dbdma_st32((volatile unsigned long *)&dmap->control,
  200.    DBDMA_CLEAR(ACTIVE|DEAD|WAKE|FLUSH|PAUSE|RUN));
  201. eieio();
  202. while (dbdma_ld32((volatile unsigned long *)&dmap->status) & RUN)
  203. eieio();
  204. }
  206. static void
  207. dbdma_setcmd(volatile struct dbdma_cmd *cp,
  208.      unsigned short cmd, unsigned count, unsigned long addr,
  209.      unsigned long cmd_dep)
  210. {
  211. out_le16(&cp->command, cmd);
  212. out_le16(&cp->req_count, count);
  213. out_le32(&cp->phy_addr, addr);
  214. out_le32(&cp->cmd_dep, cmd_dep);
  215. out_le16(&cp->xfer_status, 0);
  216. out_le16(&cp->res_count, 0);
  217. }
  219. static inline
  220. void bmwrite(struct net_device *dev, unsigned long reg_offset, unsigned data )
  221. {
  222. out_le16((void *)dev->base_addr + reg_offset, data);
  223. }
  226. static inline
  227. volatile unsigned short bmread(struct net_device *dev, unsigned long reg_offset )
  228. {
  229. return in_le16((void *)dev->base_addr + reg_offset);
  230. }
  232. static void
  233. bmac_enable_and_reset_chip(struct net_device *dev)
  234. {
  235. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  236. volatile struct dbdma_regs *rd = bp->rx_dma;
  237. volatile struct dbdma_regs *td = bp->tx_dma;
  239. if (rd)
  240. dbdma_reset(rd);
  241. if (td)
  242. dbdma_reset(td);
  244. pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 1);
  245. }
  247. #define MIFDELAY udelay(10)
  249. static unsigned int
  250. bmac_mif_readbits(struct net_device *dev, int nb)
  251. {
  252. unsigned int val = 0;
  254. while (--nb >= 0) {
  255. bmwrite(dev, MIFCSR, 0);
  256. MIFDELAY;
  257. if (bmread(dev, MIFCSR) & 8)
  258. val |= 1 << nb;
  259. bmwrite(dev, MIFCSR, 1);
  260. MIFDELAY;
  261. }
  262. bmwrite(dev, MIFCSR, 0);
  263. MIFDELAY;
  264. bmwrite(dev, MIFCSR, 1);
  265. MIFDELAY;
  266. return val;
  267. }
  269. static void
  270. bmac_mif_writebits(struct net_device *dev, unsigned int val, int nb)
  271. {
  272. int b;
  274. while (--nb >= 0) {
  275. b = (val & (1 << nb))? 6: 4;
  276. bmwrite(dev, MIFCSR, b);
  277. MIFDELAY;
  278. bmwrite(dev, MIFCSR, b|1);
  279. MIFDELAY;
  280. }
  281. }
  283. static unsigned int
  284. bmac_mif_read(struct net_device *dev, unsigned int addr)
  285. {
  286. unsigned int val;
  288. bmwrite(dev, MIFCSR, 4);
  289. MIFDELAY;
  290. bmac_mif_writebits(dev, ~0U, 32);
  291. bmac_mif_writebits(dev, 6, 4);
  292. bmac_mif_writebits(dev, addr, 10);
  293. bmwrite(dev, MIFCSR, 2);
  294. MIFDELAY;
  295. bmwrite(dev, MIFCSR, 1);
  296. MIFDELAY;
  297. val = bmac_mif_readbits(dev, 17);
  298. bmwrite(dev, MIFCSR, 4);
  299. MIFDELAY;
  300. return val;
  301. }
  303. static void
  304. bmac_mif_write(struct net_device *dev, unsigned int addr, unsigned int val)
  305. {
  306. bmwrite(dev, MIFCSR, 4);
  307. MIFDELAY;
  308. bmac_mif_writebits(dev, ~0U, 32);
  309. bmac_mif_writebits(dev, 5, 4);
  310. bmac_mif_writebits(dev, addr, 10);
  311. bmac_mif_writebits(dev, 2, 2);
  312. bmac_mif_writebits(dev, val, 16);
  313. bmac_mif_writebits(dev, 3, 2);
  314. }
  316. static void
  317. bmac_init_registers(struct net_device *dev)
  318. {
  319. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  320. volatile unsigned short regValue;
  321. unsigned short *pWord16;
  322. int i;
  324. /* XXDEBUG(("bmac: enter init_registersn")); */
  326. bmwrite(dev, RXRST, RxResetValue);
  327. bmwrite(dev, TXRST, TxResetBit);
  329. i = 100;
  330. do {
  331. --i;
  332. udelay(10000);
  333. regValue = bmread(dev, TXRST); /* wait for reset to clear..acknowledge */
  334. } while ((regValue & TxResetBit) && i > 0);
  336. if (!bp->is_bmac_plus) {
  337. regValue = bmread(dev, XCVRIF);
  338. regValue |= ClkBit | SerialMode | COLActiveLow;
  339. bmwrite(dev, XCVRIF, regValue);
  340. udelay(10000);
  341. }
  343. bmwrite(dev, RSEED, (unsigned short)0x1968);
  345. regValue = bmread(dev, XIFC);
  346. regValue |= TxOutputEnable;
  347. bmwrite(dev, XIFC, regValue);
  349. bmread(dev, PAREG);
  351. /* set collision counters to 0 */
  352. bmwrite(dev, NCCNT, 0);
  353. bmwrite(dev, NTCNT, 0);
  354. bmwrite(dev, EXCNT, 0);
  355. bmwrite(dev, LTCNT, 0);
  357. /* set rx counters to 0 */
  358. bmwrite(dev, FRCNT, 0);
  359. bmwrite(dev, LECNT, 0);
  360. bmwrite(dev, AECNT, 0);
  361. bmwrite(dev, FECNT, 0);
  362. bmwrite(dev, RXCV, 0);
  364. /* set tx fifo information */
  365. bmwrite(dev, TXTH, 4); /* 4 octets before tx starts */
  367. bmwrite(dev, TXFIFOCSR, 0); /* first disable txFIFO */
  368. bmwrite(dev, TXFIFOCSR, TxFIFOEnable );
  370. /* set rx fifo information */
  371. bmwrite(dev, RXFIFOCSR, 0); /* first disable rxFIFO */
  372. bmwrite(dev, RXFIFOCSR, RxFIFOEnable );
  374. //bmwrite(dev, TXCFG, TxMACEnable);         /* TxNeverGiveUp maybe later */
  375. bmread(dev, STATUS); /* read it just to clear it */
  377. /* zero out the chip Hash Filter registers */
  378. for (i=0; i<4; i++) bp->hash_table_mask[i] = 0;
  379. bmwrite(dev, BHASH3, bp->hash_table_mask[0]);  /* bits 15 - 0 */
  380. bmwrite(dev, BHASH2, bp->hash_table_mask[1]);  /* bits 31 - 16 */
  381. bmwrite(dev, BHASH1, bp->hash_table_mask[2]);  /* bits 47 - 32 */
  382. bmwrite(dev, BHASH0, bp->hash_table_mask[3]);  /* bits 63 - 48 */
  384. pWord16 = (unsigned short *)dev->dev_addr;
  385. bmwrite(dev, MADD0, *pWord16++);
  386. bmwrite(dev, MADD1, *pWord16++);
  387. bmwrite(dev, MADD2, *pWord16);
  389. bmwrite(dev, RXCFG, RxCRCNoStrip | RxHashFilterEnable | RxRejectOwnPackets);
  391. bmwrite(dev, INTDISABLE, EnableNormal);
  393. return;
  394. }
  396. #if 0
  397. static void
  398. bmac_disable_interrupts(struct net_device *dev)
  399. {
  400. bmwrite(dev, INTDISABLE, DisableAll);
  401. }
  403. static void
  404. bmac_enable_interrupts(struct net_device *dev)
  405. {
  406. bmwrite(dev, INTDISABLE, EnableNormal);
  407. }
  408. #endif
  411. static void
  412. bmac_start_chip(struct net_device *dev)
  413. {
  414. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  415. volatile struct dbdma_regs *rd = bp->rx_dma;
  416. unsigned short oldConfig;
  418. /* enable rx dma channel */
  419. dbdma_continue(rd);
  421. oldConfig = bmread(dev, TXCFG);
  422. bmwrite(dev, TXCFG, oldConfig | TxMACEnable );
  424. /* turn on rx plus any other bits already on (promiscuous possibly) */
  425. oldConfig = bmread(dev, RXCFG);
  426. bmwrite(dev, RXCFG, oldConfig | RxMACEnable );
  427. udelay(20000);
  428. }
  430. static void
  431. bmac_init_phy(struct net_device *dev)
  432. {
  433. unsigned int addr;
  434. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  436. printk(KERN_DEBUG "phy registers:");
  437. for (addr = 0; addr < 32; ++addr) {
  438. if ((addr & 7) == 0)
  439. printk("n" KERN_DEBUG);
  440. printk(" %.4x", bmac_mif_read(dev, addr));
  441. }
  442. printk("n");
  443. if (bp->is_bmac_plus) {
  444. unsigned int capable, ctrl;
  446. ctrl = bmac_mif_read(dev, 0);
  447. capable = ((bmac_mif_read(dev, 1) & 0xf800) >> 6) | 1;
  448. if (bmac_mif_read(dev, 4) != capable
  449.     || (ctrl & 0x1000) == 0) {
  450. bmac_mif_write(dev, 4, capable);
  451. bmac_mif_write(dev, 0, 0x1200);
  452. } else
  453. bmac_mif_write(dev, 0, 0x1000);
  454. }
  455. }
  457. static void
  458. bmac_init_chip(struct net_device *dev)
  459. {
  460. bmac_init_phy(dev);
  461. bmac_init_registers(dev);
  462. }
  464. #ifdef CONFIG_PMAC_PBOOK
  465. static int
  466. bmac_sleep_notify(struct pmu_sleep_notifier *self, int when)
  467. {
  468. struct bmac_data *bp;
  469. unsigned long flags;
  470. unsigned short config;
  471. struct net_device* dev = bmac_devs;
  472. int i;
  474. if (bmac_devs == 0)
  475. return PBOOK_SLEEP_OK;
  477. bp = (struct bmac_data *) dev->priv;
  479. switch (when) {
  480. case PBOOK_SLEEP_REQUEST:
  481. break;
  482. case PBOOK_SLEEP_REJECT:
  483. break;
  484. case PBOOK_SLEEP_NOW:
  485. netif_device_detach(dev);
  486. /* prolly should wait for dma to finish & turn off the chip */
  487. save_flags(flags); cli();
  488. if (bp->timeout_active) {
  489. del_timer(&bp->tx_timeout);
  490. bp->timeout_active = 0;
  491. }
  492. disable_irq(dev->irq);
  493. disable_irq(bp->tx_dma_intr);
  494. disable_irq(bp->rx_dma_intr);
  495. bp->sleeping = 1;
  496. restore_flags(flags);
  497. if (bp->opened) {
  498. volatile struct dbdma_regs *rd = bp->rx_dma;
  499. volatile struct dbdma_regs *td = bp->tx_dma;
  501. config = bmread(dev, RXCFG);
  502. bmwrite(dev, RXCFG, (config & ~RxMACEnable));
  503. config = bmread(dev, TXCFG);
  504. bmwrite(dev, TXCFG, (config & ~TxMACEnable));
  505. bmwrite(dev, INTDISABLE, DisableAll); /* disable all intrs */
  506. /* disable rx and tx dma */
  507. st_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE)); /* clear run bit */
  508. st_le32(&td->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE)); /* clear run bit */
  509. /* free some skb's */
  510. for (i=0; i<N_RX_RING; i++) {
  511. if (bp->rx_bufs[i] != NULL) {
  512. dev_kfree_skb(bp->rx_bufs[i]);
  513. bp->rx_bufs[i] = NULL;
  514. }
  515. }
  516. for (i = 0; i<N_TX_RING; i++) {
  517. if (bp->tx_bufs[i] != NULL) {
  518. dev_kfree_skb(bp->tx_bufs[i]);
  519. bp->tx_bufs[i] = NULL;
  520. }
  521. }
  522. }
  523. pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 0);
  524. break;
  525. case PBOOK_WAKE:
  526. /* see if this is enough */
  527. if (bp->opened)
  528. bmac_reset_and_enable(dev);
  529. enable_irq(dev->irq);
  530. enable_irq(bp->tx_dma_intr);
  531. enable_irq(bp->rx_dma_intr);
  532. netif_device_attach(dev);
  533. break;
  534. }
  535. return PBOOK_SLEEP_OK;
  536. }
  537. #endif
  539. static int bmac_set_address(struct net_device *dev, void *addr)
  540. {
  541. unsigned char *p = addr;
  542. unsigned short *pWord16;
  543. unsigned long flags;
  544. int i;
  546. XXDEBUG(("bmac: enter set_addressn"));
  547. save_flags(flags); cli();
  549. for (i = 0; i < 6; ++i) {
  550. dev->dev_addr[i] = p[i];
  551. }
  552. /* load up the hardware address */
  553. pWord16  = (unsigned short *)dev->dev_addr;
  554. bmwrite(dev, MADD0, *pWord16++);
  555. bmwrite(dev, MADD1, *pWord16++);
  556. bmwrite(dev, MADD2, *pWord16);
  558. restore_flags(flags);
  559. XXDEBUG(("bmac: exit set_addressn"));
  560. return 0;
  561. }
  563. static inline void bmac_set_timeout(struct net_device *dev)
  564. {
  565. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  566. unsigned long flags;
  568. save_flags(flags);
  569. cli();
  570. if (bp->timeout_active)
  571. del_timer(&bp->tx_timeout);
  572. bp->tx_timeout.expires = jiffies + TX_TIMEOUT;
  573. bp->tx_timeout.function = bmac_tx_timeout;
  574. bp->tx_timeout.data = (unsigned long) dev;
  575. add_timer(&bp->tx_timeout);
  576. bp->timeout_active = 1;
  577. restore_flags(flags);
  578. }
  580. static void
  581. bmac_construct_xmt(struct sk_buff *skb, volatile struct dbdma_cmd *cp)
  582. {
  583. void *vaddr;
  584. unsigned long baddr;
  585. unsigned long len;
  587. len = skb->len;
  588. vaddr = skb->data;
  589. baddr = virt_to_bus(vaddr);
  591. dbdma_setcmd(cp, (OUTPUT_LAST | INTR_ALWAYS | WAIT_IFCLR), len, baddr, 0);
  592. }
  594. static void
  595. bmac_construct_rxbuff(struct sk_buff *skb, volatile struct dbdma_cmd *cp)
  596. {
  597. unsigned char *addr = skb? skb->data: bmac_emergency_rxbuf;
  599. dbdma_setcmd(cp, (INPUT_LAST | INTR_ALWAYS), RX_BUFLEN,
  600.      virt_to_bus(addr), 0);
  601. }
  603. /* Bit-reverse one byte of an ethernet hardware address. */
  604. static unsigned char
  605. bitrev(unsigned char b)
  606. {
  607. int d = 0, i;
  609. for (i = 0; i < 8; ++i, b >>= 1)
  610. d = (d << 1) | (b & 1);
  611. return d;
  612. }
  615. static void
  616. bmac_init_tx_ring(struct bmac_data *bp)
  617. {
  618. volatile struct dbdma_regs *td = bp->tx_dma;
  620. memset((char *)bp->tx_cmds, 0, (N_TX_RING+1) * sizeof(struct dbdma_cmd));
  622. bp->tx_empty = 0;
  623. bp->tx_fill = 0;
  624. bp->tx_fullup = 0;
  626. /* put a branch at the end of the tx command list */
  627. dbdma_setcmd(&bp->tx_cmds[N_TX_RING],
  628.      (DBDMA_NOP | BR_ALWAYS), 0, 0, virt_to_bus(bp->tx_cmds));
  630. /* reset tx dma */
  631. dbdma_reset(td);
  632. out_le32(&td->wait_sel, 0x00200020);
  633. out_le32(&td->cmdptr, virt_to_bus(bp->tx_cmds));
  634. }
  636. static int
  637. bmac_init_rx_ring(struct bmac_data *bp)
  638. {
  639. volatile struct dbdma_regs *rd = bp->rx_dma;
  640. int i;
  641. struct sk_buff *skb;
  643. /* initialize list of sk_buffs for receiving and set up recv dma */
  644. memset((char *)bp->rx_cmds, 0,
  645.        (N_RX_RING + 1) * sizeof(struct dbdma_cmd));
  646. for (i = 0; i < N_RX_RING; i++) {
  647. if ((skb = bp->rx_bufs[i]) == NULL) {
  648. bp->rx_bufs[i] = skb = dev_alloc_skb(RX_BUFLEN+2);
  649. if (skb != NULL)
  650. skb_reserve(skb, 2);
  651. }
  652. bmac_construct_rxbuff(skb, &bp->rx_cmds[i]);
  653. }
  655. bp->rx_empty = 0;
  656. bp->rx_fill = i;
  658. /* Put a branch back to the beginning of the receive command list */
  659. dbdma_setcmd(&bp->rx_cmds[N_RX_RING],
  660.      (DBDMA_NOP | BR_ALWAYS), 0, 0, virt_to_bus(bp->rx_cmds));
  662. /* start rx dma */
  663. dbdma_reset(rd);
  664. out_le32(&rd->cmdptr, virt_to_bus(bp->rx_cmds));
  666. return 1;
  667. }
  670. static int bmac_transmit_packet(struct sk_buff *skb, struct net_device *dev)
  671. {
  672. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  673. volatile struct dbdma_regs *td = bp->tx_dma;
  674. int i;
  676. /* see if there's a free slot in the tx ring */
  677. /* XXDEBUG(("bmac_xmit_start: empty=%d fill=%dn", */
  678. /*       bp->tx_empty, bp->tx_fill)); */
  679. i = bp->tx_fill + 1;
  680. if (i >= N_TX_RING)
  681. i = 0;
  682. if (i == bp->tx_empty) {
  683. netif_stop_queue(dev);
  684. bp->tx_fullup = 1;
  685. XXDEBUG(("bmac_transmit_packet: tx ring fulln"));
  686. return -1; /* can't take it at the moment */
  687. }
  689. dbdma_setcmd(&bp->tx_cmds[i], DBDMA_STOP, 0, 0, 0);
  691. bmac_construct_xmt(skb, &bp->tx_cmds[bp->tx_fill]);
  693. bp->tx_bufs[bp->tx_fill] = skb;
  694. bp->tx_fill = i;
  696. bp->stats.tx_bytes += skb->len;
  698. dbdma_continue(td);
  700. return 0;
  701. }
  703. static int rxintcount;
  705. static void bmac_rxdma_intr(int irq, void *dev_id, struct pt_regs *regs)
  706. {
  707. struct net_device *dev = (struct net_device *) dev_id;
  708. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  709. volatile struct dbdma_regs *rd = bp->rx_dma;
  710. volatile struct dbdma_cmd *cp;
  711. int i, nb, stat;
  712. struct sk_buff *skb;
  713. unsigned int residual;
  714. int last;
  715. unsigned long flags;
  717. save_flags(flags); cli();
  719. if (++rxintcount < 10) {
  720. XXDEBUG(("bmac_rxdma_intrn"));
  721. }
  723. last = -1;
  724. i = bp->rx_empty;
  726. while (1) {
  727. cp = &bp->rx_cmds[i];
  728. stat = ld_le16(&cp->xfer_status);
  729. residual = ld_le16(&cp->res_count);
  730. if ((stat & ACTIVE) == 0)
  731. break;
  732. nb = RX_BUFLEN - residual - 2;
  733. if (nb < (ETHERMINPACKET - ETHERCRC)) {
  734. skb = NULL;
  735. bp->stats.rx_length_errors++;
  736. bp->stats.rx_errors++;
  737. } else {
  738. skb = bp->rx_bufs[i];
  739. bp->rx_bufs[i] = NULL;
  740. }
  741. if (skb != NULL) {
  742. nb -= ETHERCRC;
  743. skb_put(skb, nb);
  744. skb->dev = dev;
  745. skb->protocol = eth_type_trans(skb, dev);
  746. netif_rx(skb);
  747. dev->last_rx = jiffies;
  748. ++bp->stats.rx_packets;
  749. bp->stats.rx_bytes += nb;
  750. } else {
  751. ++bp->stats.rx_dropped;
  752. }
  753. dev->last_rx = jiffies;
  754. if ((skb = bp->rx_bufs[i]) == NULL) {
  755. bp->rx_bufs[i] = skb = dev_alloc_skb(RX_BUFLEN+2);
  756. if (skb != NULL)
  757. skb_reserve(bp->rx_bufs[i], 2);
  758. }
  759. bmac_construct_rxbuff(skb, &bp->rx_cmds[i]);
  760. st_le16(&cp->res_count, 0);
  761. st_le16(&cp->xfer_status, 0);
  762. last = i;
  763. if (++i >= N_RX_RING) i = 0;
  764. }
  766. if (last != -1) {
  767. bp->rx_fill = last;
  768. bp->rx_empty = i;
  769. }
  771. restore_flags(flags);
  773. dbdma_continue(rd);
  775. if (rxintcount < 10) {
  776. XXDEBUG(("bmac_rxdma_intr donen"));
  777. }
  778. }
  780. static int txintcount;
  782. static void bmac_txdma_intr(int irq, void *dev_id, struct pt_regs *regs)
  783. {
  784. struct net_device *dev = (struct net_device *) dev_id;
  785. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  786. volatile struct dbdma_cmd *cp;
  787. int stat;
  788. unsigned long flags;
  790. save_flags(flags); cli();
  792. if (txintcount++ < 10) {
  793. XXDEBUG(("bmac_txdma_intrn"));
  794. }
  796. /*     del_timer(&bp->tx_timeout); */
  797. /*     bp->timeout_active = 0; */
  799. while (1) {
  800. cp = &bp->tx_cmds[bp->tx_empty];
  801. stat = ld_le16(&cp->xfer_status);
  802. if (txintcount < 10) {
  803. XXDEBUG(("bmac_txdma_xfer_stat=%#0xn", stat));
  804. }
  805. if (!(stat & ACTIVE)) {
  806. /*
  807.  * status field might not have been filled by DBDMA
  808.  */
  809. if (cp == bus_to_virt(in_le32(&bp->tx_dma->cmdptr)))
  810. break;
  811. }
  813. if (bp->tx_bufs[bp->tx_empty]) {
  814. ++bp->stats.tx_packets;
  815. dev_kfree_skb_irq(bp->tx_bufs[bp->tx_empty]);
  816. }
  817. bp->tx_bufs[bp->tx_empty] = NULL;
  818. bp->tx_fullup = 0;
  819. netif_wake_queue(dev);
  820. if (++bp->tx_empty >= N_TX_RING)
  821. bp->tx_empty = 0;
  822. if (bp->tx_empty == bp->tx_fill)
  823. break;
  824. }
  826. restore_flags(flags);
  828. if (txintcount < 10) {
  829. XXDEBUG(("bmac_txdma_intr done->bmac_startn"));
  830. }
  832. bmac_start(dev);
  833. }
  835. static struct net_device_stats *bmac_stats(struct net_device *dev)
  836. {
  837. struct bmac_data *p = (struct bmac_data *) dev->priv;
  839. return &p->stats;
  840. }
  842. #ifndef SUNHME_MULTICAST
  843. /* Real fast bit-reversal algorithm, 6-bit values */
  844. static int reverse6[64] = {
  845. 0x0,0x20,0x10,0x30,0x8,0x28,0x18,0x38,
  846. 0x4,0x24,0x14,0x34,0xc,0x2c,0x1c,0x3c,
  847. 0x2,0x22,0x12,0x32,0xa,0x2a,0x1a,0x3a,
  848. 0x6,0x26,0x16,0x36,0xe,0x2e,0x1e,0x3e,
  849. 0x1,0x21,0x11,0x31,0x9,0x29,0x19,0x39,
  850. 0x5,0x25,0x15,0x35,0xd,0x2d,0x1d,0x3d,
  851. 0x3,0x23,0x13,0x33,0xb,0x2b,0x1b,0x3b,
  852. 0x7,0x27,0x17,0x37,0xf,0x2f,0x1f,0x3f
  853. };
  855. static unsigned int
  856. crc416(unsigned int curval, unsigned short nxtval)
  857. {
  858. register unsigned int counter, cur = curval, next = nxtval;
  859. register int high_crc_set, low_data_set;
  861. /* Swap bytes */
  862. next = ((next & 0x00FF) << 8) | (next >> 8);
  864. /* Compute bit-by-bit */
  865. for (counter = 0; counter < 16; ++counter) {
  866. /* is high CRC bit set? */
  867. if ((cur & 0x80000000) == 0) high_crc_set = 0;
  868. else high_crc_set = 1;
  870. cur = cur << 1;
  872. if ((next & 0x0001) == 0) low_data_set = 0;
  873. else low_data_set = 1;
  875. next = next >> 1;
  877. /* do the XOR */
  878. if (high_crc_set ^ low_data_set) cur = cur ^ ENET_CRCPOLY;
  879. }
  880. return cur;
  881. }
  883. static unsigned int
  884. bmac_crc(unsigned short *address)
  885. {
  886. unsigned int newcrc;
  888. XXDEBUG(("bmac_crc: addr=%#04x, %#04x, %#04xn", *address, address[1], address[2]));
  889. newcrc = crc416(0xffffffff, *address); /* address bits 47 - 32 */
  890. newcrc = crc416(newcrc, address[1]); /* address bits 31 - 16 */
  891. newcrc = crc416(newcrc, address[2]); /* address bits 15 - 0  */
  893. return(newcrc);
  894. }
  896. /*
  897.  * Add requested mcast addr to BMac's hash table filter.
  898.  *
  899.  */
  901. static void
  902. bmac_addhash(struct bmac_data *bp, unsigned char *addr)
  903. {
  904. unsigned int  crc;
  905. unsigned short  mask;
  907. if (!(*addr)) return;
  908. crc = bmac_crc((unsigned short *)addr) & 0x3f; /* Big-endian alert! */
  909. crc = reverse6[crc]; /* Hyperfast bit-reversing algorithm */
  910. if (bp->hash_use_count[crc]++) return; /* This bit is already set */
  911. mask = crc % 16;
  912. mask = (unsigned char)1 << mask;
  913. bp->hash_use_count[crc/16] |= mask;
  914. }
  916. static void
  917. bmac_removehash(struct bmac_data *bp, unsigned char *addr)
  918. {
  919. unsigned int crc;
  920. unsigned char mask;
  922. /* Now, delete the address from the filter copy, as indicated */
  923. crc = bmac_crc((unsigned short *)addr) & 0x3f; /* Big-endian alert! */
  924. crc = reverse6[crc]; /* Hyperfast bit-reversing algorithm */
  925. if (bp->hash_use_count[crc] == 0) return; /* That bit wasn't in use! */
  926. if (--bp->hash_use_count[crc]) return; /* That bit is still in use */
  927. mask = crc % 16;
  928. mask = ((unsigned char)1 << mask) ^ 0xffff; /* To turn off bit */
  929. bp->hash_table_mask[crc/16] &= mask;
  930. }
  932. /*
  933.  * Sync the adapter with the software copy of the multicast mask
  934.  *  (logical address filter).
  935.  */
  937. static void
  938. bmac_rx_off(struct net_device *dev)
  939. {
  940. unsigned short rx_cfg;
  942. rx_cfg = bmread(dev, RXCFG);
  943. rx_cfg &= ~RxMACEnable;
  944. bmwrite(dev, RXCFG, rx_cfg);
  945. do {
  946. rx_cfg = bmread(dev, RXCFG);
  947. }  while (rx_cfg & RxMACEnable);
  948. }
  950. unsigned short
  951. bmac_rx_on(struct net_device *dev, int hash_enable, int promisc_enable)
  952. {
  953. unsigned short rx_cfg;
  955. rx_cfg = bmread(dev, RXCFG);
  956. rx_cfg |= RxMACEnable;
  957. if (hash_enable) rx_cfg |= RxHashFilterEnable;
  958. else rx_cfg &= ~RxHashFilterEnable;
  959. if (promisc_enable) rx_cfg |= RxPromiscEnable;
  960. else rx_cfg &= ~RxPromiscEnable;
  961. bmwrite(dev, RXRST, RxResetValue);
  962. bmwrite(dev, RXFIFOCSR, 0); /* first disable rxFIFO */
  963. bmwrite(dev, RXFIFOCSR, RxFIFOEnable );
  964. bmwrite(dev, RXCFG, rx_cfg );
  965. return rx_cfg;
  966. }
  968. static void
  969. bmac_update_hash_table_mask(struct net_device *dev, struct bmac_data *bp)
  970. {
  971. bmwrite(dev, BHASH3, bp->hash_table_mask[0]); /* bits 15 - 0 */
  972. bmwrite(dev, BHASH2, bp->hash_table_mask[1]); /* bits 31 - 16 */
  973. bmwrite(dev, BHASH1, bp->hash_table_mask[2]); /* bits 47 - 32 */
  974. bmwrite(dev, BHASH0, bp->hash_table_mask[3]); /* bits 63 - 48 */
  975. }
  977. #if 0
  978. static void
  979. bmac_add_multi(struct net_device *dev,
  980.        struct bmac_data *bp, unsigned char *addr)
  981. {
  982. /* XXDEBUG(("bmac: enter bmac_add_multin")); */
  983. bmac_addhash(bp, addr);
  984. bmac_rx_off(dev);
  985. bmac_update_hash_table_mask(dev, bp);
  986. bmac_rx_on(dev, 1, (dev->flags & IFF_PROMISC)? 1 : 0);
  987. /* XXDEBUG(("bmac: exit bmac_add_multin")); */
  988. }
  990. static void
  991. bmac_remove_multi(struct net_device *dev,
  992.   struct bmac_data *bp, unsigned char *addr)
  993. {
  994. bmac_removehash(bp, addr);
  995. bmac_rx_off(dev);
  996. bmac_update_hash_table_mask(dev, bp);
  997. bmac_rx_on(dev, 1, (dev->flags & IFF_PROMISC)? 1 : 0);
  998. }
  999. #endif
  1001. /* Set or clear the multicast filter for this adaptor.
  1002.     num_addrs == -1 Promiscuous mode, receive all packets
  1003.     num_addrs == 0 Normal mode, clear multicast list
  1004.     num_addrs > 0 Multicast mode, receive normal and MC packets, and do
  1005. best-effort filtering.
  1006.  */
  1007. static void bmac_set_multicast(struct net_device *dev)
  1008. {
  1009. struct dev_mc_list *dmi;
  1010. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  1011. int num_addrs = dev->mc_count;
  1012. unsigned short rx_cfg;
  1013. int i;
  1015. if (bp->sleeping)
  1016. return;
  1018. XXDEBUG(("bmac: enter bmac_set_multicast, n_addrs=%dn", num_addrs));
  1020. if((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 64)) {
  1021. for (i=0; i<4; i++) bp->hash_table_mask[i] = 0xffff;
  1022. bmac_update_hash_table_mask(dev, bp);
  1023. rx_cfg = bmac_rx_on(dev, 1, 0);
  1024. XXDEBUG(("bmac: all multi, rx_cfg=%#08xn"));
  1025. } else if ((dev->flags & IFF_PROMISC) || (num_addrs < 0)) {
  1026. rx_cfg = bmread(dev, RXCFG);
  1027. rx_cfg |= RxPromiscEnable;
  1028. bmwrite(dev, RXCFG, rx_cfg);
  1029. rx_cfg = bmac_rx_on(dev, 0, 1);
  1030. XXDEBUG(("bmac: promisc mode enabled, rx_cfg=%#08xn", rx_cfg));
  1031. } else {
  1032. for (i=0; i<4; i++) bp->hash_table_mask[i] = 0;
  1033. for (i=0; i<64; i++) bp->hash_use_count[i] = 0;
  1034. if (num_addrs == 0) {
  1035. rx_cfg = bmac_rx_on(dev, 0, 0);
  1036. XXDEBUG(("bmac: multi disabled, rx_cfg=%#08xn", rx_cfg));
  1037. } else {
  1038. for (dmi=dev->mc_list; dmi!=NULL; dmi=dmi->next)
  1039. bmac_addhash(bp, dmi->dmi_addr);
  1040. bmac_update_hash_table_mask(dev, bp);
  1041. rx_cfg = bmac_rx_on(dev, 1, 0);
  1042. XXDEBUG(("bmac: multi enabled, rx_cfg=%#08xn", rx_cfg));
  1043. }
  1044. }
  1045. /* XXDEBUG(("bmac: exit bmac_set_multicastn")); */
  1046. }
  1047. #else /* ifdef SUNHME_MULTICAST */
  1049. /* The version of set_multicast below was lifted from sunhme.c */
  1051. #define CRC_POLYNOMIAL_BE 0x04c11db7UL  /* Ethernet CRC, big endian */
  1052. #define CRC_POLYNOMIAL_LE 0xedb88320UL  /* Ethernet CRC, little endian */
  1054. static void bmac_set_multicast(struct net_device *dev)
  1055. {
  1056. struct dev_mc_list *dmi = dev->mc_list;
  1057. char *addrs;
  1058. int i, j, bit, byte;
  1059. unsigned short rx_cfg;
  1060. u32 crc, poly = CRC_POLYNOMIAL_LE;
  1062. if((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 64)) {
  1063. bmwrite(dev, BHASH0, 0xffff);
  1064. bmwrite(dev, BHASH1, 0xffff);
  1065. bmwrite(dev, BHASH2, 0xffff);
  1066. bmwrite(dev, BHASH3, 0xffff);
  1067. } else if(dev->flags & IFF_PROMISC) {
  1068. rx_cfg = bmread(dev, RXCFG);
  1069. rx_cfg |= RxPromiscEnable;
  1070. bmwrite(dev, RXCFG, rx_cfg);
  1071. } else {
  1072. u16 hash_table[4];
  1074. rx_cfg = bmread(dev, RXCFG);
  1075. rx_cfg &= ~RxPromiscEnable;
  1076. bmwrite(dev, RXCFG, rx_cfg);
  1078. for(i = 0; i < 4; i++) hash_table[i] = 0;
  1080. for(i = 0; i < dev->mc_count; i++) {
  1081. addrs = dmi->dmi_addr;
  1082. dmi = dmi->next;
  1084. if(!(*addrs & 1))
  1085. continue;
  1087. crc = 0xffffffffU;
  1088. for(byte = 0; byte < 6; byte++) {
  1089. for(bit = *addrs++, j = 0; j < 8; j++, bit >>= 1) {
  1090. int test;
  1092. test = ((bit ^ crc) & 0x01);
  1093. crc >>= 1;
  1094. if(test)
  1095. crc = crc ^ poly;
  1096. }
  1097. }
  1098. crc >>= 26;
  1099. hash_table[crc >> 4] |= 1 << (crc & 0xf);
  1100. }
  1101. bmwrite(dev, BHASH0, hash_table[0]);
  1102. bmwrite(dev, BHASH1, hash_table[1]);
  1103. bmwrite(dev, BHASH2, hash_table[2]);
  1104. bmwrite(dev, BHASH3, hash_table[3]);
  1105. }
  1106. }
  1107. #endif /* SUNHME_MULTICAST */
  1109. static int miscintcount;
  1111. static void bmac_misc_intr(int irq, void *dev_id, struct pt_regs *regs)
  1112. {
  1113. struct net_device *dev = (struct net_device *) dev_id;
  1114. struct bmac_data *bp = (struct bmac_data *)dev->priv;
  1115. unsigned int status = bmread(dev, STATUS);
  1116. if (miscintcount++ < 10) {
  1117. XXDEBUG(("bmac_misc_intrn"));
  1118. }
  1119. /* XXDEBUG(("bmac_misc_intr, status=%#08xn", status)); */
  1120. /*     bmac_txdma_intr_inner(irq, dev_id, regs); */
  1121. /*   if (status & FrameReceived) bp->stats.rx_dropped++; */
  1122. if (status & RxErrorMask) bp->stats.rx_errors++;
  1123. if (status & RxCRCCntExp) bp->stats.rx_crc_errors++;
  1124. if (status & RxLenCntExp) bp->stats.rx_length_errors++;
  1125. if (status & RxOverFlow) bp->stats.rx_over_errors++;
  1126. if (status & RxAlignCntExp) bp->stats.rx_frame_errors++;
  1128. /*   if (status & FrameSent) bp->stats.tx_dropped++; */
  1129. if (status & TxErrorMask) bp->stats.tx_errors++;
  1130. if (status & TxUnderrun) bp->stats.tx_fifo_errors++;
  1131. if (status & TxNormalCollExp) bp->stats.collisions++;
  1132. }
  1134. /*
  1135.  * Procedure for reading EEPROM
  1136.  */
  1137. #define SROMAddressLength 5
  1138. #define DataInOn 0x0008
  1139. #define DataInOff 0x0000
  1140. #define Clk 0x0002
  1141. #define ChipSelect 0x0001
  1142. #define SDIShiftCount 3
  1143. #define SD0ShiftCount 2
  1144. #define DelayValue 1000 /* number of microseconds */
  1145. #define SROMStartOffset 10 /* this is in words */
  1146. #define SROMReadCount 3 /* number of words to read from SROM */
  1147. #define SROMAddressBits 6
  1148. #define EnetAddressOffset 20
  1150. static unsigned char
  1151. bmac_clock_out_bit(struct net_device *dev)
  1152. {
  1153. unsigned short         data;
  1154. unsigned short         val;
  1156. bmwrite(dev, SROMCSR, ChipSelect | Clk);
  1157. udelay(DelayValue);
  1159. data = bmread(dev, SROMCSR);
  1160. udelay(DelayValue);
  1161. val = (data >> SD0ShiftCount) & 1;
  1163. bmwrite(dev, SROMCSR, ChipSelect);
  1164. udelay(DelayValue);
  1166. return val;
  1167. }
  1169. static void
  1170. bmac_clock_in_bit(struct net_device *dev, unsigned int val)
  1171. {
  1172. unsigned short data;
  1174. if (val != 0 && val != 1) return;
  1176. data = (val << SDIShiftCount);
  1177. bmwrite(dev, SROMCSR, data | ChipSelect  );
  1178. udelay(DelayValue);
  1180. bmwrite(dev, SROMCSR, data | ChipSelect | Clk );
  1181. udelay(DelayValue);
  1183. bmwrite(dev, SROMCSR, data | ChipSelect);
  1184. udelay(DelayValue);
  1185. }
  1187. static void
  1188. reset_and_select_srom(struct net_device *dev)
  1189. {
  1190. /* first reset */
  1191. bmwrite(dev, SROMCSR, 0);
  1192. udelay(DelayValue);
  1194. /* send it the read command (110) */
  1195. bmac_clock_in_bit(dev, 1);
  1196. bmac_clock_in_bit(dev, 1);
  1197. bmac_clock_in_bit(dev, 0);
  1198. }
  1200. static unsigned short
  1201. read_srom(struct net_device *dev, unsigned int addr, unsigned int addr_len)
  1202. {
  1203. unsigned short data, val;
  1204. int i;
  1206. /* send out the address we want to read from */
  1207. for (i = 0; i < addr_len; i++) {
  1208. val = addr >> (addr_len-i-1);
  1209. bmac_clock_in_bit(dev, val & 1);
  1210. }
  1212. /* Now read in the 16-bit data */
  1213. data = 0;
  1214. for (i = 0; i < 16; i++) {
  1215. val = bmac_clock_out_bit(dev);
  1216. data <<= 1;
  1217. data |= val;
  1218. }
  1219. bmwrite(dev, SROMCSR, 0);
  1221. return data;
  1222. }
  1224. /*
  1225.  * It looks like Cogent and SMC use different methods for calculating
  1226.  * checksums. What a pain..
  1227.  */
  1229. static int
  1230. bmac_verify_checksum(struct net_device *dev)
  1231. {
  1232. unsigned short data, storedCS;
  1234. reset_and_select_srom(dev);
  1235. data = read_srom(dev, 3, SROMAddressBits);
  1236. storedCS = ((data >> 8) & 0x0ff) | ((data << 8) & 0xff00);
  1238. return 0;
  1239. }
  1242. static void
  1243. bmac_get_station_address(struct net_device *dev, unsigned char *ea)
  1244. {
  1245. int i;
  1246. unsigned short data;
  1248. for (i = 0; i < 6; i++)
  1249. {
  1250. reset_and_select_srom(dev);
  1251. data = read_srom(dev, i + EnetAddressOffset/2, SROMAddressBits);
  1252. ea[2*i]   = bitrev(data & 0x0ff);
  1253. ea[2*i+1] = bitrev((data >> 8) & 0x0ff);
  1254. }
  1255. }
  1257. static void bmac_reset_and_enable(struct net_device *dev)
  1258. {
  1259. struct bmac_data *bp = dev->priv;
  1260. unsigned long flags;
  1261. struct sk_buff *skb;
  1262. unsigned char *data;
  1264. save_flags(flags); cli();
  1265. bmac_enable_and_reset_chip(dev);
  1266. bmac_init_tx_ring(bp);
  1267. bmac_init_rx_ring(bp);
  1268. bmac_init_chip(dev);
  1269. bmac_start_chip(dev);
  1270. bmwrite(dev, INTDISABLE, EnableNormal);
  1271. bp->sleeping = 0;
  1273. /*
  1274.  * It seems that the bmac can't receive until it's transmitted
  1275.  * a packet.  So we give it a dummy packet to transmit.
  1276.  */
  1277. skb = dev_alloc_skb(ETHERMINPACKET);
  1278. if (skb != NULL) {
  1279. data = skb_put(skb, ETHERMINPACKET);
  1280. memset(data, 0, ETHERMINPACKET);
  1281. memcpy(data, dev->dev_addr, 6);
  1282. memcpy(data+6, dev->dev_addr, 6);
  1283. bmac_transmit_packet(skb, dev);
  1284. }
  1285. restore_flags(flags);
  1286. }
  1288. static int __init bmac_probe(void)
  1289. {
  1290. struct device_node *bmac;
  1292. MOD_INC_USE_COUNT;
  1294. for (bmac = find_devices("bmac"); bmac != 0; bmac = bmac->next)
  1295. bmac_probe1(bmac, 0);
  1296. for (bmac = find_compatible_devices("network", "bmac+"); bmac != 0;
  1297.      bmac = bmac->next)
  1298. bmac_probe1(bmac, 1);
  1300. if (bmac_devs != 0) {
  1301. proc_net_create ("bmac", 0, bmac_proc_info);
  1302. #ifdef CONFIG_PMAC_PBOOK
  1303. pmu_register_sleep_notifier(&bmac_sleep_notifier);
  1304. #endif
  1305. }
  1307. MOD_DEC_USE_COUNT;
  1309. return bmac_devs? 0: -ENODEV;
  1310. }
  1312. static void __init bmac_probe1(struct device_node *bmac, int is_bmac_plus)
  1313. {
  1314. int j, rev, ret;
  1315. struct bmac_data *bp;
  1316. unsigned char *addr;
  1317. struct net_device *dev;
  1319. if (bmac->n_addrs != 3 || bmac->n_intrs != 3) {
  1320. printk(KERN_ERR "can't use BMAC %s: need 3 addrs and 3 intrsn",
  1321.        bmac->full_name);
  1322. return;
  1323. }
  1324. addr = get_property(bmac, "mac-address", NULL);
  1325. if (addr == NULL) {
  1326. addr = get_property(bmac, "local-mac-address", NULL);
  1327. if (addr == NULL) {
  1328. printk(KERN_ERR "Can't get mac-address for BMAC %sn",
  1329.        bmac->full_name);
  1330. return;
  1331. }
  1332. }
  1334. if (bmac_emergency_rxbuf == NULL) {
  1335. bmac_emergency_rxbuf = kmalloc(RX_BUFLEN, GFP_KERNEL);
  1336. if (bmac_emergency_rxbuf == NULL) {
  1337. printk(KERN_ERR "BMAC: can't allocate emergency RX buffern");
  1338. return;
  1339. }
  1340. }
  1342. dev = init_etherdev(NULL, PRIV_BYTES);
  1343. if (!dev) {
  1344. printk(KERN_ERR "init_etherdev failed, out of memory for BMAC %sn",
  1345.        bmac->full_name);
  1346. return;
  1347. }
  1348. bp = (struct bmac_data *) dev->priv;
  1349. SET_MODULE_OWNER(dev);
  1350. bp->node = bmac;
  1352. if (!request_OF_resource(bmac, 0, " (bmac)")) {
  1353. printk(KERN_ERR "BMAC: can't request IO resource !n");
  1354. goto err_out;
  1355. }
  1356. if (!request_OF_resource(bmac, 1, " (bmac tx dma)")) {
  1357. printk(KERN_ERR "BMAC: can't request TX DMA resource !n");
  1358. goto err_out;
  1359. }
  1361. if (!request_OF_resource(bmac, 2, " (bmac rx dma)")) {
  1362. printk(KERN_ERR "BMAC: can't request RX DMA resource !n");
  1363. goto err_out;
  1364. }
  1365. dev->base_addr = (unsigned long)
  1366. ioremap(bmac->addrs[0].address, bmac->addrs[0].size);
  1367. if (!dev->base_addr)
  1368. goto err_out;
  1369. dev->irq = bmac->intrs[0].line;
  1371. bmac_enable_and_reset_chip(dev);
  1372. bmwrite(dev, INTDISABLE, DisableAll);
  1374. printk(KERN_INFO "%s: BMAC%s at", dev->name, (is_bmac_plus? "+": ""));
  1375. rev = addr[0] == 0 && addr[1] == 0xA0;
  1376. for (j = 0; j < 6; ++j) {
  1377. dev->dev_addr[j] = rev? bitrev(addr[j]): addr[j];
  1378. printk("%c%.2x", (j? ':': ' '), dev->dev_addr[j]);
  1379. }
  1380. XXDEBUG((", base_addr=%#0lx", dev->base_addr));
  1381. printk("n");
  1383. /* Enable chip without interrupts for now */
  1384. bmac_enable_and_reset_chip(dev);
  1385. bmwrite(dev, INTDISABLE, DisableAll);
  1387. dev->open = bmac_open;
  1388. dev->stop = bmac_close;
  1389. dev->hard_start_xmit = bmac_output;
  1390. dev->get_stats = bmac_stats;
  1391. dev->set_multicast_list = bmac_set_multicast;
  1392. dev->set_mac_address = bmac_set_address;
  1394. bmac_get_station_address(dev, addr);
  1395. if (bmac_verify_checksum(dev) != 0)
  1396. goto err_out_iounmap;
  1398. bp->is_bmac_plus = is_bmac_plus;
  1399. bp->tx_dma = (volatile struct dbdma_regs *)
  1400. ioremap(bmac->addrs[1].address, bmac->addrs[1].size);
  1401. if (!bp->tx_dma)
  1402. goto err_out_iounmap;
  1403. bp->tx_dma_intr = bmac->intrs[1].line;
  1404. bp->rx_dma = (volatile struct dbdma_regs *)
  1405. ioremap(bmac->addrs[2].address, bmac->addrs[2].size);
  1406. if (!bp->rx_dma)
  1407. goto err_out_iounmap_tx;
  1408. bp->rx_dma_intr = bmac->intrs[2].line;
  1410. bp->tx_cmds = (volatile struct dbdma_cmd *) DBDMA_ALIGN(bp + 1);
  1411. bp->rx_cmds = bp->tx_cmds + N_TX_RING + 1;
  1413. bp->queue = (struct sk_buff_head *)(bp->rx_cmds + N_RX_RING + 1);
  1414. skb_queue_head_init(bp->queue);
  1416. memset((char *) bp->tx_cmds, 0,
  1417.        (N_TX_RING + N_RX_RING + 2) * sizeof(struct dbdma_cmd));
  1418. /*     init_timer(&bp->tx_timeout); */
  1419. /*     bp->timeout_active = 0; */
  1421. ret = request_irq(dev->irq, bmac_misc_intr, 0, "BMAC-misc", dev);
  1422. if (ret) {
  1423. printk(KERN_ERR "BMAC: can't get irq %dn", dev->irq);
  1424. goto err_out_iounmap_rx;
  1425. }
  1426. ret = request_irq(bmac->intrs[1].line, bmac_txdma_intr, 0, "BMAC-txdma", dev);
  1427. if (ret) {
  1428. printk(KERN_ERR "BMAC: can't get irq %dn", bmac->intrs[1].line);
  1429. goto err_out_irq0;
  1430. }
  1431. ret = request_irq(bmac->intrs[2].line, bmac_rxdma_intr, 0, "BMAC-rxdma", dev);
  1432. if (ret) {
  1433. printk(KERN_ERR "BMAC: can't get irq %dn", bmac->intrs[2].line);
  1434. goto err_out_irq1;
  1435. }
  1437. /* Mask chip interrupts and disable chip, will be
  1438.  * re-enabled on open()
  1439.  */
  1440. disable_irq(dev->irq);
  1441. pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 0);
  1443. bp->next_bmac = bmac_devs;
  1444. bmac_devs = dev;
  1445. return;
  1447. err_out_irq1:
  1448. free_irq(bmac->intrs[1].line, dev);
  1449. err_out_irq0:
  1450. free_irq(dev->irq, dev);
  1451. err_out_iounmap_rx:
  1452. iounmap((void *)bp->rx_dma);
  1453. err_out_iounmap_tx:
  1454. iounmap((void *)bp->tx_dma);
  1455. err_out_iounmap:
  1456. iounmap((void *)dev->base_addr);
  1457. err_out:
  1458. if (bp->node) {
  1459. release_OF_resource(bp->node, 0);
  1460. release_OF_resource(bp->node, 1);
  1461. release_OF_resource(bp->node, 2);
  1462. pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 0);
  1463. }
  1464. unregister_netdev(dev);
  1465. kfree(dev);
  1466. }
  1468. static int bmac_open(struct net_device *dev)
  1469. {
  1470. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  1471. /* XXDEBUG(("bmac: enter openn")); */
  1472. /* reset the chip */
  1473. bp->opened = 1;
  1474. bmac_reset_and_enable(dev);
  1475. enable_irq(dev->irq);
  1476. dev->flags |= IFF_RUNNING;
  1477. return 0;
  1478. }
  1480. static int bmac_close(struct net_device *dev)
  1481. {
  1482. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  1483. volatile struct dbdma_regs *rd = bp->rx_dma;
  1484. volatile struct dbdma_regs *td = bp->tx_dma;
  1485. unsigned short config;
  1486. int i;
  1488. bp->sleeping = 1;
  1489. dev->flags &= ~(IFF_UP | IFF_RUNNING);
  1491. /* disable rx and tx */
  1492. config = bmread(dev, RXCFG);
  1493. bmwrite(dev, RXCFG, (config & ~RxMACEnable));
  1495. config = bmread(dev, TXCFG);
  1496. bmwrite(dev, TXCFG, (config & ~TxMACEnable));
  1498. bmwrite(dev, INTDISABLE, DisableAll); /* disable all intrs */
  1500. /* disable rx and tx dma */
  1501. st_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE)); /* clear run bit */
  1502. st_le32(&td->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE)); /* clear run bit */
  1504. /* free some skb's */
  1505. XXDEBUG(("bmac: free rx bufsn"));
  1506. for (i=0; i<N_RX_RING; i++) {
  1507. if (bp->rx_bufs[i] != NULL) {
  1508. dev_kfree_skb(bp->rx_bufs[i]);
  1509. bp->rx_bufs[i] = NULL;
  1510. }
  1511. }
  1512. XXDEBUG(("bmac: free tx bufsn"));
  1513. for (i = 0; i<N_TX_RING; i++) {
  1514. if (bp->tx_bufs[i] != NULL) {
  1515. dev_kfree_skb(bp->tx_bufs[i]);
  1516. bp->tx_bufs[i] = NULL;
  1517. }
  1518. }
  1519. XXDEBUG(("bmac: all bufs freedn"));
  1521. bp->opened = 0;
  1522. disable_irq(dev->irq);
  1523. pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 0);
  1525. return 0;
  1526. }
  1528. static void
  1529. bmac_start(struct net_device *dev)
  1530. {
  1531. struct bmac_data *bp = dev->priv;
  1532. int i;
  1533. struct sk_buff *skb;
  1534. unsigned long flags;
  1536. if (bp->sleeping)
  1537. return;
  1539. save_flags(flags); cli();
  1540. while (1) {
  1541. i = bp->tx_fill + 1;
  1542. if (i >= N_TX_RING)
  1543. i = 0;
  1544. if (i == bp->tx_empty)
  1545. break;
  1546. skb = skb_dequeue(bp->queue);
  1547. if (skb == NULL)
  1548. break;
  1549. bmac_transmit_packet(skb, dev);
  1550. }
  1551. restore_flags(flags);
  1552. }
  1554. static int
  1555. bmac_output(struct sk_buff *skb, struct net_device *dev)
  1556. {
  1557. struct bmac_data *bp = dev->priv;
  1558. skb_queue_tail(bp->queue, skb);
  1559. bmac_start(dev);
  1560. return 0;
  1561. }
  1563. static void bmac_tx_timeout(unsigned long data)
  1564. {
  1565. struct net_device *dev = (struct net_device *) data;
  1566. struct bmac_data *bp = (struct bmac_data *) dev->priv;
  1567. volatile struct dbdma_regs *td = bp->tx_dma;
  1568. volatile struct dbdma_regs *rd = bp->rx_dma;
  1569. volatile struct dbdma_cmd *cp;
  1570. unsigned long flags;
  1571. unsigned short config, oldConfig;
  1572. int i;
  1574. XXDEBUG(("bmac: tx_timeout calledn"));
  1575. save_flags(flags); cli();
  1576. bp->timeout_active = 0;
  1578. /* update various counters */
  1579. /*      bmac_handle_misc_intrs(bp, 0); */
  1581. cp = &bp->tx_cmds[bp->tx_empty];
  1582. /* XXDEBUG((KERN_DEBUG "bmac: tx dmastat=%x %x runt=%d pr=%x fs=%x fc=%xn", */
  1583. /*     ld_le32(&td->status), ld_le16(&cp->xfer_status), bp->tx_bad_runt, */
  1584. /*     mb->pr, mb->xmtfs, mb->fifofc)); */
  1586. /* turn off both tx and rx and reset the chip */
  1587. config = bmread(dev, RXCFG);
  1588. bmwrite(dev, RXCFG, (config & ~RxMACEnable));
  1589. config = bmread(dev, TXCFG);
  1590. bmwrite(dev, TXCFG, (config & ~TxMACEnable));
  1591. out_le32(&td->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE|ACTIVE|DEAD));
  1592. printk(KERN_ERR "bmac: transmit timeout - resettingn");
  1593. bmac_enable_and_reset_chip(dev);
  1595. /* restart rx dma */
  1596. cp = bus_to_virt(ld_le32(&rd->cmdptr));
  1597. out_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE|ACTIVE|DEAD));
  1598. out_le16(&cp->xfer_status, 0);
  1599. out_le32(&rd->cmdptr, virt_to_bus(cp));
  1600. out_le32(&rd->control, DBDMA_SET(RUN|WAKE));
  1602. /* fix up the transmit side */
  1603. XXDEBUG((KERN_DEBUG "bmac: tx empty=%d fill=%d fullup=%dn",
  1604.  bp->tx_empty, bp->tx_fill, bp->tx_fullup));
  1605. i = bp->tx_empty;
  1606. ++bp->stats.tx_errors;
  1607. if (i != bp->tx_fill) {
  1608. dev_kfree_skb(bp->tx_bufs[i]);
  1609. bp->tx_bufs[i] = NULL;
  1610. if (++i >= N_TX_RING) i = 0;
  1611. bp->tx_empty = i;
  1612. }
  1613. bp->tx_fullup = 0;
  1614. netif_wake_queue(dev);
  1615. if (i != bp->tx_fill) {
  1616. cp = &bp->tx_cmds[i];
  1617. out_le16(&cp->xfer_status, 0);
  1618. out_le16(&cp->command, OUTPUT_LAST);
  1619. out_le32(&td->cmdptr, virt_to_bus(cp));
  1620. out_le32(&td->control, DBDMA_SET(RUN));
  1621. /*  bmac_set_timeout(dev); */
  1622. XXDEBUG((KERN_DEBUG "bmac: starting %dn", i));
  1623. }
  1625. /* turn it back on */
  1626. oldConfig = bmread(dev, RXCFG);
  1627. bmwrite(dev, RXCFG, oldConfig | RxMACEnable );
  1628. oldConfig = bmread(dev, TXCFG);
  1629. bmwrite(dev, TXCFG, oldConfig | TxMACEnable );
  1631. restore_flags(flags);
  1632. }
  1634. #if 0
  1635. static void dump_dbdma(volatile struct dbdma_cmd *cp,int count)
  1636. {
  1637. int i,*ip;
  1639. for (i=0;i< count;i++) {
  1640. ip = (int*)(cp+i);
  1642. printk("dbdma req 0x%x addr 0x%x baddr 0x%x xfer/res 0x%xn",
  1643.        ld_le32(ip+0),
  1644.        ld_le32(ip+1),
  1645.        ld_le32(ip+2),
  1646.        ld_le32(ip+3));
  1647. }
  1649. }
  1650. #endif
  1652. static int
  1653. bmac_proc_info(char *buffer, char **start, off_t offset, int length)
  1654. {
  1655. int len = 0;
  1656. off_t pos   = 0;
  1657. off_t begin = 0;
  1658. int i;
  1660. if (bmac_devs == NULL)
  1661. return (-ENOSYS);
  1663. len += sprintf(buffer, "BMAC counters & registersn");
  1665. for (i = 0; i<N_REG_ENTRIES; i++) {
  1666. len += sprintf(buffer + len, "%s: %#08xn",
  1667.        reg_entries[i].name,
  1668.        bmread(bmac_devs, reg_entries[i].reg_offset));
  1669. pos = begin + len;
  1671. if (pos < offset) {
  1672. len = 0;
  1673. begin = pos;
  1674. }
  1676. if (pos > offset+length) break;
  1677. }
  1679. *start = buffer + (offset - begin);
  1680. len -= (offset - begin);
  1682. if (len > length) len = length;
  1684. return len;
  1685. }
  1688. MODULE_AUTHOR("Randy Gobbel/Paul Mackerras");
  1689. MODULE_DESCRIPTION("PowerMac BMAC ethernet driver.");
  1690. MODULE_LICENSE("GPL");
  1691. EXPORT_NO_SYMBOLS;
  1693. static void __exit bmac_cleanup (void)
  1694. {
  1695. struct bmac_data *bp;
  1696. struct net_device *dev;
  1698. if (bmac_emergency_rxbuf != NULL) {
  1699. kfree(bmac_emergency_rxbuf);
  1700. bmac_emergency_rxbuf = NULL;
  1701. }
  1703. if (bmac_devs == 0)
  1704. return;
  1705. #ifdef CONFIG_PMAC_PBOOK
  1706. pmu_unregister_sleep_notifier(&bmac_sleep_notifier);
  1707. #endif
  1708. proc_net_remove("bmac");
  1710. do {
  1711. dev = bmac_devs;
  1712. bp = (struct bmac_data *) dev->priv;
  1713. bmac_devs = bp->next_bmac;
  1715. unregister_netdev(dev);
  1717. release_OF_resource(bp->node, 0);
  1718. release_OF_resource(bp->node, 1);
  1719. release_OF_resource(bp->node, 2);
  1720. free_irq(dev->irq, dev);
  1721. free_irq(bp->tx_dma_intr, dev);
  1722. free_irq(bp->rx_dma_intr, dev);
  1724. kfree(dev);
  1725. } while (bmac_devs != NULL);
  1726. }
  1728. module_init(bmac_probe);
  1729. module_exit(bmac_cleanup);