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

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

Linux/Unix编程

开发平台：

Unix_Linux

a2065.c：源码内容
  1. /*
  2.  * Amiga Linux/68k A2065 Ethernet Driver
  3.  *
  4.  * (C) Copyright 1995 by Geert Uytterhoeven <geert@linux-m68k.org>
  5.  *
  6.  * Fixes and tips by:
  7.  * - Janos Farkas (CHEXUM@sparta.banki.hu)
  8.  * - Jes Degn Soerensen (jds@kom.auc.dk)
  9.  * - Matt Domsch (Matt_Domsch@dell.com)
  10.  *
  11.  * ----------------------------------------------------------------------------
  12.  *
  13.  * This program is based on
  14.  *
  15.  * ariadne.?: Amiga Linux/68k Ariadne Ethernet Driver
  16.  * (C) Copyright 1995 by Geert Uytterhoeven,
  17.  *                                            Peter De Schrijver
  18.  *
  19.  * lance.c: An AMD LANCE ethernet driver for linux.
  20.  * Written 1993-94 by Donald Becker.
  21.  *
  22.  * Am79C960: PCnet(tm)-ISA Single-Chip Ethernet Controller
  23.  * Advanced Micro Devices
  24.  * Publication #16907, Rev. B, Amendment/0, May 1994
  25.  *
  26.  * ----------------------------------------------------------------------------
  27.  *
  28.  * This file is subject to the terms and conditions of the GNU General Public
  29.  * License.  See the file COPYING in the main directory of the Linux
  30.  * distribution for more details.
  31.  *
  32.  * ----------------------------------------------------------------------------
  33.  *
  34.  * The A2065 is a Zorro-II board made by Commodore/Ameristar. It contains:
  35.  *
  36.  * - an Am7990 Local Area Network Controller for Ethernet (LANCE) with
  37.  *   both 10BASE-2 (thin coax) and AUI (DB-15) connectors
  38.  */
  40. #include <linux/module.h>
  41. #include <linux/stddef.h>
  42. #include <linux/kernel.h>
  43. #include <linux/sched.h>
  44. #include <linux/interrupt.h>
  45. #include <linux/ptrace.h>
  46. #include <linux/ioport.h>
  47. #include <linux/slab.h>
  48. #include <linux/string.h>
  49. #include <linux/config.h>
  50. #include <linux/init.h>
  51. #include <linux/crc32.h>
  53. #include <asm/bitops.h>
  55. #include <asm/irq.h>
  56. #include <linux/errno.h>
  58. #include <asm/amigaints.h>
  59. #include <asm/amigahw.h>
  60. #include <linux/zorro.h>
  62. #include <linux/netdevice.h>
  63. #include <linux/etherdevice.h>
  64. #include <linux/skbuff.h>
  65. #include "a2065.h"
  68. /*
  69.  * Transmit/Receive Ring Definitions
  70.  */
  72. #define LANCE_LOG_TX_BUFFERS (2)
  73. #define LANCE_LOG_RX_BUFFERS (4)
  75. #define TX_RING_SIZE (1<<LANCE_LOG_TX_BUFFERS)
  76. #define RX_RING_SIZE (1<<LANCE_LOG_RX_BUFFERS)
  78. #define TX_RING_MOD_MASK (TX_RING_SIZE-1)
  79. #define RX_RING_MOD_MASK (RX_RING_SIZE-1)
  81. #define PKT_BUF_SIZE (1544)
  82. #define RX_BUFF_SIZE            PKT_BUF_SIZE
  83. #define TX_BUFF_SIZE            PKT_BUF_SIZE
  86. /*
  87.  * Layout of the Lance's RAM Buffer
  88.  */
  91. struct lance_init_block {
  92. unsigned short mode; /* Pre-set mode (reg. 15) */
  93. unsigned char phys_addr[6];     /* Physical ethernet address */
  94. unsigned filter[2]; /* Multicast filter. */
  96. /* Receive and transmit ring base, along with extra bits. */
  97. unsigned short rx_ptr; /* receive descriptor addr */
  98. unsigned short rx_len; /* receive len and high addr */
  99. unsigned short tx_ptr; /* transmit descriptor addr */
  100. unsigned short tx_len; /* transmit len and high addr */
  101.     
  102. /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
  103. struct lance_rx_desc brx_ring[RX_RING_SIZE];
  104. struct lance_tx_desc btx_ring[TX_RING_SIZE];
  106. char   rx_buf [RX_RING_SIZE][RX_BUFF_SIZE];
  107. char   tx_buf [TX_RING_SIZE][TX_BUFF_SIZE];
  108. };
  111. /*
  112.  * Private Device Data
  113.  */
  115. struct lance_private {
  116. char *name;
  117. volatile struct lance_regs *ll;
  118. volatile struct lance_init_block *init_block;     /* Hosts view */
  119. volatile struct lance_init_block *lance_init_block; /* Lance view */
  121. int rx_new, tx_new;
  122. int rx_old, tx_old;
  123.     
  124. int lance_log_rx_bufs, lance_log_tx_bufs;
  125. int rx_ring_mod_mask, tx_ring_mod_mask;
  127. struct net_device_stats stats;
  128. int tpe;       /* cable-selection is TPE */
  129. int auto_select;       /* cable-selection by carrier */
  130. unsigned short busmaster_regval;
  132. #ifdef CONFIG_SUNLANCE
  133. struct Linux_SBus_DMA *ledma; /* if set this points to ledma and arch=4m */
  134. int burst_sizes;       /* ledma SBus burst sizes */
  135. #endif
  136. struct timer_list         multicast_timer;
  137. struct net_device *dev; /* Backpointer */
  138. struct lance_private *next_module;
  139. };
  141. #ifdef MODULE
  142. static struct lance_private *root_a2065_dev;
  143. #endif
  145. #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?
  146. lp->tx_old+lp->tx_ring_mod_mask-lp->tx_new:
  147. lp->tx_old - lp->tx_new-1)
  150. #define LANCE_ADDR(x) ((int)(x) & ~0xff000000)
  152. /* Load the CSR registers */
  153. static void load_csrs (struct lance_private *lp)
  154. {
  155. volatile struct lance_regs *ll = lp->ll;
  156. volatile struct lance_init_block *aib = lp->lance_init_block;
  157. int leptr;
  159. leptr = LANCE_ADDR (aib);
  161. ll->rap = LE_CSR1;
  162. ll->rdp = (leptr & 0xFFFF);
  163. ll->rap = LE_CSR2;
  164. ll->rdp = leptr >> 16;
  165. ll->rap = LE_CSR3;
  166. ll->rdp = lp->busmaster_regval;
  168. /* Point back to csr0 */
  169. ll->rap = LE_CSR0;
  170. }
  172. #define ZERO 0
  174. /* Setup the Lance Rx and Tx rings */
  175. static void lance_init_ring (struct net_device *dev)
  176. {
  177. struct lance_private *lp = (struct lance_private *) dev->priv;
  178. volatile struct lance_init_block *ib = lp->init_block;
  179. volatile struct lance_init_block *aib; /* for LANCE_ADDR computations */
  180. int leptr;
  181. int i;
  183. aib = lp->lance_init_block;
  185. /* Lock out other processes while setting up hardware */
  186. netif_stop_queue(dev);
  187. lp->rx_new = lp->tx_new = 0;
  188. lp->rx_old = lp->tx_old = 0;
  190. ib->mode = 0;
  192. /* Copy the ethernet address to the lance init block
  193.  * Note that on the sparc you need to swap the ethernet address.
  194.  */
  195. ib->phys_addr [0] = dev->dev_addr [1];
  196. ib->phys_addr [1] = dev->dev_addr [0];
  197. ib->phys_addr [2] = dev->dev_addr [3];
  198. ib->phys_addr [3] = dev->dev_addr [2];
  199. ib->phys_addr [4] = dev->dev_addr [5];
  200. ib->phys_addr [5] = dev->dev_addr [4];
  202. if (ZERO)
  203. printk ("TX rings:n");
  204.     
  205. /* Setup the Tx ring entries */
  206. for (i = 0; i <= (1<<lp->lance_log_tx_bufs); i++) {
  207. leptr = LANCE_ADDR(&aib->tx_buf[i][0]);
  208. ib->btx_ring [i].tmd0      = leptr;
  209. ib->btx_ring [i].tmd1_hadr = leptr >> 16;
  210. ib->btx_ring [i].tmd1_bits = 0;
  211. ib->btx_ring [i].length    = 0xf000; /* The ones required by tmd2 */
  212. ib->btx_ring [i].misc      = 0;
  213. if (i < 3)
  214. if (ZERO) printk ("%d: 0x%8.8xn", i, leptr);
  215. }
  217. /* Setup the Rx ring entries */
  218. if (ZERO)
  219. printk ("RX rings:n");
  220. for (i = 0; i < (1<<lp->lance_log_rx_bufs); i++) {
  221. leptr = LANCE_ADDR(&aib->rx_buf[i][0]);
  223. ib->brx_ring [i].rmd0      = leptr;
  224. ib->brx_ring [i].rmd1_hadr = leptr >> 16;
  225. ib->brx_ring [i].rmd1_bits = LE_R1_OWN;
  226. ib->brx_ring [i].length    = -RX_BUFF_SIZE | 0xf000;
  227. ib->brx_ring [i].mblength  = 0;
  228. if (i < 3 && ZERO)
  229. printk ("%d: 0x%8.8xn", i, leptr);
  230. }
  232. /* Setup the initialization block */
  233.     
  234. /* Setup rx descriptor pointer */
  235. leptr = LANCE_ADDR(&aib->brx_ring);
  236. ib->rx_len = (lp->lance_log_rx_bufs << 13) | (leptr >> 16);
  237. ib->rx_ptr = leptr;
  238. if (ZERO)
  239. printk ("RX ptr: %8.8xn", leptr);
  240.     
  241. /* Setup tx descriptor pointer */
  242. leptr = LANCE_ADDR(&aib->btx_ring);
  243. ib->tx_len = (lp->lance_log_tx_bufs << 13) | (leptr >> 16);
  244. ib->tx_ptr = leptr;
  245. if (ZERO)
  246. printk ("TX ptr: %8.8xn", leptr);
  248. /* Clear the multicast filter */
  249. ib->filter [0] = 0;
  250. ib->filter [1] = 0;
  251. }
  253. static int init_restart_lance (struct lance_private *lp)
  254. {
  255. volatile struct lance_regs *ll = lp->ll;
  256. int i;
  258. ll->rap = LE_CSR0;
  259. ll->rdp = LE_C0_INIT;
  261. /* Wait for the lance to complete initialization */
  262. for (i = 0; (i < 100) && !(ll->rdp & (LE_C0_ERR | LE_C0_IDON)); i++)
  263. barrier();
  264. if ((i == 100) || (ll->rdp & LE_C0_ERR)) {
  265. printk ("LANCE unopened after %d ticks, csr0=%4.4x.n", i, ll->rdp);
  266. return -EIO;
  267. }
  269. /* Clear IDON by writing a "1", enable interrupts and start lance */
  270. ll->rdp = LE_C0_IDON;
  271. ll->rdp = LE_C0_INEA | LE_C0_STRT;
  273. return 0;
  274. }
  276. static int lance_rx (struct net_device *dev)
  277. {
  278. struct lance_private *lp = (struct lance_private *) dev->priv;
  279. volatile struct lance_init_block *ib = lp->init_block;
  280. volatile struct lance_regs *ll = lp->ll;
  281. volatile struct lance_rx_desc *rd;
  282. unsigned char bits;
  283. int len = 0; /* XXX shut up gcc warnings */
  284. struct sk_buff *skb = 0; /* XXX shut up gcc warnings */
  286. #ifdef TEST_HITS
  287. printk ("[");
  288. for (i = 0; i < RX_RING_SIZE; i++) {
  289. if (i == lp->rx_new)
  290. printk ("%s",
  291. ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "_" : "X");
  292. else
  293. printk ("%s",
  294. ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "." : "1");
  295. }
  296. printk ("]");
  297. #endif
  298.     
  299. ll->rdp = LE_C0_RINT|LE_C0_INEA;
  300. for (rd = &ib->brx_ring [lp->rx_new];
  301.      !((bits = rd->rmd1_bits) & LE_R1_OWN);
  302.      rd = &ib->brx_ring [lp->rx_new]) {
  304. /* We got an incomplete frame? */
  305. if ((bits & LE_R1_POK) != LE_R1_POK) {
  306. lp->stats.rx_over_errors++;
  307. lp->stats.rx_errors++;
  308. continue;
  309. } else if (bits & LE_R1_ERR) {
  310. /* Count only the end frame as a rx error,
  311.  * not the beginning
  312.  */
  313. if (bits & LE_R1_BUF) lp->stats.rx_fifo_errors++;
  314. if (bits & LE_R1_CRC) lp->stats.rx_crc_errors++;
  315. if (bits & LE_R1_OFL) lp->stats.rx_over_errors++;
  316. if (bits & LE_R1_FRA) lp->stats.rx_frame_errors++;
  317. if (bits & LE_R1_EOP) lp->stats.rx_errors++;
  318. } else {
  319. len = (rd->mblength & 0xfff) - 4;
  320. skb = dev_alloc_skb (len+2);
  322. if (skb == 0) {
  323. printk ("%s: Memory squeeze, deferring packet.n",
  324. dev->name);
  325. lp->stats.rx_dropped++;
  326. rd->mblength = 0;
  327. rd->rmd1_bits = LE_R1_OWN;
  328. lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
  329. return 0;
  330. }
  331.     
  332. skb->dev = dev;
  333. skb_reserve (skb, 2); /* 16 byte align */
  334. skb_put (skb, len); /* make room */
  335. eth_copy_and_sum(skb,
  336.  (unsigned char *)&(ib->rx_buf [lp->rx_new][0]),
  337.  len, 0);
  338. skb->protocol = eth_type_trans (skb, dev);
  339. netif_rx (skb);
  340. dev->last_rx = jiffies;
  341. lp->stats.rx_packets++;
  342. lp->stats.rx_bytes += len;
  343. }
  345. /* Return the packet to the pool */
  346. rd->mblength = 0;
  347. rd->rmd1_bits = LE_R1_OWN;
  348. lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
  349. }
  350. return 0;
  351. }
  353. static int lance_tx (struct net_device *dev)
  354. {
  355. struct lance_private *lp = (struct lance_private *) dev->priv;
  356. volatile struct lance_init_block *ib = lp->init_block;
  357. volatile struct lance_regs *ll = lp->ll;
  358. volatile struct lance_tx_desc *td;
  359. int i, j;
  360. int status;
  362. /* csr0 is 2f3 */
  363. ll->rdp = LE_C0_TINT | LE_C0_INEA;
  364. /* csr0 is 73 */
  366. j = lp->tx_old;
  367. for (i = j; i != lp->tx_new; i = j) {
  368. td = &ib->btx_ring [i];
  370. /* If we hit a packet not owned by us, stop */
  371. if (td->tmd1_bits & LE_T1_OWN)
  372. break;
  374. if (td->tmd1_bits & LE_T1_ERR) {
  375. status = td->misc;
  376.     
  377. lp->stats.tx_errors++;
  378. if (status & LE_T3_RTY)  lp->stats.tx_aborted_errors++;
  379. if (status & LE_T3_LCOL) lp->stats.tx_window_errors++;
  381. if (status & LE_T3_CLOS) {
  382. lp->stats.tx_carrier_errors++;
  383. if (lp->auto_select) {
  384. lp->tpe = 1 - lp->tpe;
  385. printk("%s: Carrier Lost, trying %sn",
  386.        dev->name, lp->tpe?"TPE":"AUI");
  387. /* Stop the lance */
  388. ll->rap = LE_CSR0;
  389. ll->rdp = LE_C0_STOP;
  390. lance_init_ring (dev);
  391. load_csrs (lp);
  392. init_restart_lance (lp);
  393. return 0;
  394. }
  395. }
  397. /* buffer errors and underflows turn off the transmitter */
  398. /* Restart the adapter */
  399. if (status & (LE_T3_BUF|LE_T3_UFL)) {
  400. lp->stats.tx_fifo_errors++;
  402. printk ("%s: Tx: ERR_BUF|ERR_UFL, restartingn",
  403. dev->name);
  404. /* Stop the lance */
  405. ll->rap = LE_CSR0;
  406. ll->rdp = LE_C0_STOP;
  407. lance_init_ring (dev);
  408. load_csrs (lp);
  409. init_restart_lance (lp);
  410. return 0;
  411. }
  412. } else if ((td->tmd1_bits & LE_T1_POK) == LE_T1_POK) {
  413. /*
  414.  * So we don't count the packet more than once.
  415.  */
  416. td->tmd1_bits &= ~(LE_T1_POK);
  418. /* One collision before packet was sent. */
  419. if (td->tmd1_bits & LE_T1_EONE)
  420. lp->stats.collisions++;
  422. /* More than one collision, be optimistic. */
  423. if (td->tmd1_bits & LE_T1_EMORE)
  424. lp->stats.collisions += 2;
  426. lp->stats.tx_packets++;
  427. }
  429. j = (j + 1) & lp->tx_ring_mod_mask;
  430. }
  431. lp->tx_old = j;
  432. ll->rdp = LE_C0_TINT | LE_C0_INEA;
  433. return 0;
  434. }
  436. static void lance_interrupt (int irq, void *dev_id, struct pt_regs *regs)
  437. {
  438. struct net_device *dev;
  439. struct lance_private *lp;
  440. volatile struct lance_regs *ll;
  441. int csr0;
  443. dev = (struct net_device *) dev_id;
  445. lp = (struct lance_private *) dev->priv;
  446. ll = lp->ll;
  448. ll->rap = LE_CSR0; /* LANCE Controller Status */
  449. csr0 = ll->rdp;
  451. if (!(csr0 & LE_C0_INTR)) /* Check if any interrupt has */
  452. return; /* been generated by the Lance. */
  454. /* Acknowledge all the interrupt sources ASAP */
  455. ll->rdp = csr0 & ~(LE_C0_INEA|LE_C0_TDMD|LE_C0_STOP|LE_C0_STRT|
  456.    LE_C0_INIT);
  458. if ((csr0 & LE_C0_ERR)) {
  459. /* Clear the error condition */
  460. ll->rdp = LE_C0_BABL|LE_C0_ERR|LE_C0_MISS|LE_C0_INEA;
  461. }
  462.     
  463. if (csr0 & LE_C0_RINT)
  464. lance_rx (dev);
  466. if (csr0 & LE_C0_TINT)
  467. lance_tx (dev);
  469. /* Log misc errors. */
  470. if (csr0 & LE_C0_BABL)
  471. lp->stats.tx_errors++;       /* Tx babble. */
  472. if (csr0 & LE_C0_MISS)
  473. lp->stats.rx_errors++;       /* Missed a Rx frame. */
  474. if (csr0 & LE_C0_MERR) {
  475. printk("%s: Bus master arbitration failure, status %4.4x.n", dev->name, csr0);
  476. /* Restart the chip. */
  477. ll->rdp = LE_C0_STRT;
  478. }
  480. if (netif_queue_stopped(dev) && TX_BUFFS_AVAIL > 0)
  481. netif_wake_queue(dev);
  483. ll->rap = LE_CSR0;
  484. ll->rdp = LE_C0_BABL|LE_C0_CERR|LE_C0_MISS|LE_C0_MERR|
  485. LE_C0_IDON|LE_C0_INEA;
  487. }
  489. struct net_device *last_dev = 0;
  491. static int lance_open (struct net_device *dev)
  492. {
  493. struct lance_private *lp = (struct lance_private *)dev->priv;
  494. volatile struct lance_regs *ll = lp->ll;
  495. int ret;
  497. last_dev = dev;
  499. /* Stop the Lance */
  500. ll->rap = LE_CSR0;
  501. ll->rdp = LE_C0_STOP;
  503. /* Install the Interrupt handler */
  504. ret = request_irq(IRQ_AMIGA_PORTS, lance_interrupt, SA_SHIRQ,
  505.   dev->name, dev);
  506. if (ret) return ret;
  508. load_csrs (lp);
  509. lance_init_ring (dev);
  511. netif_start_queue(dev);
  513. return init_restart_lance (lp);
  514. }
  516. static int lance_close (struct net_device *dev)
  517. {
  518. struct lance_private *lp = (struct lance_private *) dev->priv;
  519. volatile struct lance_regs *ll = lp->ll;
  521. netif_stop_queue(dev);
  522. del_timer_sync(&lp->multicast_timer);
  524. /* Stop the card */
  525. ll->rap = LE_CSR0;
  526. ll->rdp = LE_C0_STOP;
  528. free_irq(IRQ_AMIGA_PORTS, dev);
  529. return 0;
  530. }
  532. static inline int lance_reset (struct net_device *dev)
  533. {
  534. struct lance_private *lp = (struct lance_private *)dev->priv;
  535. volatile struct lance_regs *ll = lp->ll;
  536. int status;
  537.     
  538. /* Stop the lance */
  539. ll->rap = LE_CSR0;
  540. ll->rdp = LE_C0_STOP;
  542. load_csrs (lp);
  544. lance_init_ring (dev);
  545. dev->trans_start = jiffies;
  546. netif_start_queue(dev);
  548. status = init_restart_lance (lp);
  549. #ifdef DEBUG_DRIVER
  550. printk ("Lance restart=%dn", status);
  551. #endif
  552. return status;
  553. }
  555. static void lance_tx_timeout(struct net_device *dev)
  556. {
  557. struct lance_private *lp = (struct lance_private *) dev->priv;
  558. volatile struct lance_regs *ll = lp->ll;
  560. printk(KERN_ERR "%s: transmit timed out, status %04x, resetn",
  561.        dev->name, ll->rdp);
  562. lance_reset(dev);
  563. netif_wake_queue(dev);
  564. }
  566. static int lance_start_xmit (struct sk_buff *skb, struct net_device *dev)
  567. {
  568. struct lance_private *lp = (struct lance_private *)dev->priv;
  569. volatile struct lance_regs *ll = lp->ll;
  570. volatile struct lance_init_block *ib = lp->init_block;
  571. int entry, skblen, len;
  572. int status = 0;
  573. static int outs;
  574. unsigned long flags;
  576. skblen = skb->len;
  578. save_flags(flags);
  579. cli();
  581. if (!TX_BUFFS_AVAIL){
  582. restore_flags(flags);
  583. return -1;
  584. }
  586. #ifdef DEBUG_DRIVER
  587. /* dump the packet */
  588. {
  589. int i;
  591. for (i = 0; i < 64; i++) {
  592. if ((i % 16) == 0)
  593. printk ("n");
  594. printk ("%2.2x ", skb->data [i]);
  595. }
  596. }
  597. #endif
  598. len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
  599. entry = lp->tx_new & lp->tx_ring_mod_mask;
  600. ib->btx_ring [entry].length = (-len) | 0xf000;
  601. ib->btx_ring [entry].misc = 0;
  602.     
  603. memcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
  605. /* Clear the slack of the packet, do I need this? */
  606. if (len != skblen)
  607. memset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
  608.     
  609. /* Now, give the packet to the lance */
  610. ib->btx_ring [entry].tmd1_bits = (LE_T1_POK|LE_T1_OWN);
  611. lp->tx_new = (lp->tx_new+1) & lp->tx_ring_mod_mask;
  613. outs++;
  615. if (TX_BUFFS_AVAIL <= 0)
  616. netif_stop_queue(dev);
  618. /* Kick the lance: transmit now */
  619. ll->rdp = LE_C0_INEA | LE_C0_TDMD;
  620. dev->trans_start = jiffies;
  621. dev_kfree_skb (skb);
  622.     
  623. restore_flags(flags);
  625. return status;
  626. }
  628. static struct net_device_stats *lance_get_stats (struct net_device *dev)
  629. {
  630. struct lance_private *lp = (struct lance_private *) dev->priv;
  632. return &lp->stats;
  633. }
  635. /* taken from the depca driver */
  636. static void lance_load_multicast (struct net_device *dev)
  637. {
  638. struct lance_private *lp = (struct lance_private *) dev->priv;
  639. volatile struct lance_init_block *ib = lp->init_block;
  640. volatile u16 *mcast_table = (u16 *)&ib->filter;
  641. struct dev_mc_list *dmi=dev->mc_list;
  642. char *addrs;
  643. int i;
  644. u32 crc;
  646. /* set all multicast bits */
  647. if (dev->flags & IFF_ALLMULTI){ 
  648. ib->filter [0] = 0xffffffff;
  649. ib->filter [1] = 0xffffffff;
  650. return;
  651. }
  652. /* clear the multicast filter */
  653. ib->filter [0] = 0;
  654. ib->filter [1] = 0;
  656. /* Add addresses */
  657. for (i = 0; i < dev->mc_count; i++){
  658. addrs = dmi->dmi_addr;
  659. dmi   = dmi->next;
  661. /* multicast address? */
  662. if (!(*addrs & 1))
  663. continue;
  665. crc = ether_crc_le(6, addrs);
  666. crc = crc >> 26;
  667. mcast_table [crc >> 4] |= 1 << (crc & 0xf);
  668. }
  669. return;
  670. }
  672. static void lance_set_multicast (struct net_device *dev)
  673. {
  674. struct lance_private *lp = (struct lance_private *) dev->priv;
  675. volatile struct lance_init_block *ib = lp->init_block;
  676. volatile struct lance_regs *ll = lp->ll;
  678. if (!netif_running(dev))
  679. return;
  681. if (lp->tx_old != lp->tx_new) {
  682. mod_timer(&lp->multicast_timer, jiffies + 4);
  683. netif_wake_queue(dev);
  684. return;
  685. }
  687. netif_stop_queue(dev);
  689. ll->rap = LE_CSR0;
  690. ll->rdp = LE_C0_STOP;
  691. lance_init_ring (dev);
  693. if (dev->flags & IFF_PROMISC) {
  694. ib->mode |= LE_MO_PROM;
  695. } else {
  696. ib->mode &= ~LE_MO_PROM;
  697. lance_load_multicast (dev);
  698. }
  699. load_csrs (lp);
  700. init_restart_lance (lp);
  701. netif_wake_queue(dev);
  702. }
  704. static int __init a2065_probe(void)
  705. {
  706. struct zorro_dev *z = NULL;
  707. struct net_device *dev;
  708. struct lance_private *priv;
  709. int res = -ENODEV;
  711. while ((z = zorro_find_device(ZORRO_WILDCARD, z))) {
  712. unsigned long board, base_addr, mem_start;
  713. struct resource *r1, *r2;
  714. int is_cbm;
  716. if (z->id == ZORRO_PROD_CBM_A2065_1 ||
  717.     z->id == ZORRO_PROD_CBM_A2065_2)
  718. is_cbm = 1;
  719. else if (z->id == ZORRO_PROD_AMERISTAR_A2065)
  720. is_cbm = 0;
  721. else
  722. continue;
  724. board = z->resource.start;
  725. base_addr = board+A2065_LANCE;
  726. mem_start = board+A2065_RAM;
  728. r1 = request_mem_region(base_addr, sizeof(struct lance_regs),
  729. "Am7990");
  730. if (!r1) continue;
  731. r2 = request_mem_region(mem_start, A2065_RAM_SIZE, "RAM");
  732. if (!r2) {
  733. release_resource(r1);
  734. continue;
  735. }
  737. dev = init_etherdev(NULL, sizeof(struct lance_private));
  739. if (dev == NULL) {
  740. release_resource(r1);
  741. release_resource(r2);
  742. return -ENOMEM;
  743. }
  744. SET_MODULE_OWNER(dev);
  745. priv = dev->priv;
  747. r1->name = dev->name;
  748. r2->name = dev->name;
  750. priv->dev = dev;
  751. dev->dev_addr[0] = 0x00;
  752. if (is_cbm) { /* Commodore */
  753. dev->dev_addr[1] = 0x80;
  754. dev->dev_addr[2] = 0x10;
  755. } else { /* Ameristar */
  756. dev->dev_addr[1] = 0x00;
  757. dev->dev_addr[2] = 0x9f;
  758. }
  759. dev->dev_addr[3] = (z->rom.er_SerialNumber>>16) & 0xff;
  760. dev->dev_addr[4] = (z->rom.er_SerialNumber>>8) & 0xff;
  761. dev->dev_addr[5] = z->rom.er_SerialNumber & 0xff;
  762. printk("%s: A2065 at 0x%08lx, Ethernet Address "
  763.        "%02x:%02x:%02x:%02x:%02x:%02xn", dev->name, board,
  764.        dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
  765.        dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
  767. dev->base_addr = ZTWO_VADDR(base_addr);
  768. dev->mem_start = ZTWO_VADDR(mem_start);
  769. dev->mem_end = dev->mem_start+A2065_RAM_SIZE;
  771. priv->ll = (volatile struct lance_regs *)dev->base_addr;
  772. priv->init_block = (struct lance_init_block *)dev->mem_start;
  773. priv->lance_init_block = (struct lance_init_block *)A2065_RAM;
  774. priv->auto_select = 0;
  775. priv->busmaster_regval = LE_C3_BSWP;
  777. priv->lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS;
  778. priv->lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS;
  779. priv->rx_ring_mod_mask = RX_RING_MOD_MASK;
  780. priv->tx_ring_mod_mask = TX_RING_MOD_MASK;
  782. dev->open = &lance_open;
  783. dev->stop = &lance_close;
  784. dev->hard_start_xmit = &lance_start_xmit;
  785. dev->tx_timeout = &lance_tx_timeout;
  786. dev->watchdog_timeo = 5*HZ;
  787. dev->get_stats = &lance_get_stats;
  788. dev->set_multicast_list = &lance_set_multicast;
  789. dev->dma = 0;
  791. #ifdef MODULE
  792. priv->next_module = root_a2065_dev;
  793. root_a2065_dev = priv;
  794. #endif
  795. ether_setup(dev);
  796. init_timer(&priv->multicast_timer);
  797. priv->multicast_timer.data = (unsigned long) dev;
  798. priv->multicast_timer.function =
  799. (void (*)(unsigned long)) &lance_set_multicast;
  801. res = 0;
  802. }
  803. return res;
  804. }
  807. static void __exit a2065_cleanup(void)
  808. {
  809. #ifdef MODULE
  810. struct lance_private *next;
  811. struct net_device *dev;
  813. while (root_a2065_dev) {
  814. next = root_a2065_dev->next_module;
  815. dev = root_a2065_dev->dev;
  816. unregister_netdev(dev);
  817. release_mem_region(ZTWO_PADDR(dev->base_addr),
  818.    sizeof(struct lance_regs));
  819. release_mem_region(ZTWO_PADDR(dev->mem_start), A2065_RAM_SIZE);
  820. kfree(dev);
  821. root_a2065_dev = next;
  822. }
  823. #endif
  824. }
  826. module_init(a2065_probe);
  827. module_exit(a2065_cleanup);
  828. MODULE_LICENSE("GPL");