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

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

嵌入式Linux

开发平台：

Unix_Linux

sk_mca.c：源码内容
  1. /* 
  2. net-3-driver for the SKNET MCA-based cards
  4. This is an extension to the Linux operating system, and is covered by the
  5. same GNU General Public License that covers that work.
  7. Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de, aarnold@elsa.de)
  9. This driver is based both on the 3C523 driver and the SK_G16 driver.
  11. paper sources:
  12.   'PC Hardware: Aufbau, Funktionsweise, Programmierung' by 
  13.   Hans-Peter Messmer for the basic Microchannel stuff
  14.   
  15.   'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
  16.   for help on Ethernet driver programming
  18.   'Ethernet/IEEE 802.3 Family 1992 World Network Data Book/Handbook' by AMD
  19.   for documentation on the AM7990 LANCE
  21.   'SKNET Personal Technisches Manual', Version 1.2 by Schneider&Koch
  22.   for documentation on the Junior board
  24.   'SK-NET MC2+ Technical Manual", Version 1.1 by Schneider&Koch for
  25.   documentation on the MC2 bord
  26.   
  27.   A big thank you to the S&K support for providing me so quickly with
  28.   documentation!
  30.   Also see http://www.syskonnect.com/
  32.   Missing things:
  34.   -> set debug level via ioctl instead of compile-time switches
  35.   -> I didn't follow the development of the 2.1.x kernels, so my
  36.      assumptions about which things changed with which kernel version 
  37.      are probably nonsense
  39. History:
  40.   May 16th, 1999
  41.    startup
  42.   May 22st, 1999
  43. added private structure, methods
  44.         begun building data structures in RAM
  45.   May 23nd, 1999
  46. can receive frames, send frames
  47.   May 24th, 1999
  48.         modularized intialization of LANCE
  49.         loadable as module
  50. still Tx problem :-(
  51.   May 26th, 1999
  52.    MC2 works
  53.    support for multiple devices
  54.    display media type for MC2+
  55.   May 28th, 1999
  56. fixed problem in GetLANCE leaving interrupts turned off
  57.         increase TX queue to 4 packets to improve send performance
  58.   May 29th, 1999
  59. a few corrections in statistics, caught rcvr overruns 
  60.         reinitialization of LANCE/board in critical situations
  61.         MCA info implemented
  62. implemented LANCE multicast filter
  63.   Jun 6th, 1999
  64. additions for Linux 2.2
  65.   Dec 25th, 1999
  66.    unfortunately there seem to be newer MC2+ boards that react
  67.    on IRQ 3/5/9/10 instead of 3/5/10/11, so we have to autoprobe
  68.    in questionable cases...
  69.   Dec 28th, 1999
  70. integrated patches from David Weinehall & Bill Wendling for 2.3
  71. kernels (isa_...functions).  Things are defined in a way that
  72.         it still works with 2.0.x 8-)
  73.   Dec 30th, 1999
  74. added handling of the remaining interrupt conditions.  That
  75.         should cure the spurious hangs.
  76.   Jan 30th, 2000
  77. newer kernels automatically probe more than one board, so the
  78. 'startslot' as a variable is also needed here
  79.   June 1st, 2000
  80. added changes for recent 2.3 kernels
  82.  *************************************************************************/
  84. #include <linux/kernel.h>
  85. #include <linux/sched.h>
  86. #include <linux/string.h>
  87. #include <linux/errno.h>
  88. #include <linux/ioport.h>
  89. #include <linux/slab.h>
  90. #include <linux/interrupt.h>
  91. #include <linux/delay.h>
  92. #include <linux/time.h>
  93. #include <linux/mca.h>
  94. #include <linux/init.h>
  95. #include <asm/processor.h>
  96. #include <asm/bitops.h>
  97. #include <asm/io.h>
  99. #include <linux/module.h>
  100. #include <linux/version.h>
  102. #include <linux/netdevice.h>
  103. #include <linux/etherdevice.h>
  104. #include <linux/skbuff.h>
  106. #define _SK_MCA_DRIVER_
  107. #include "sk_mca.h"
  109. /* ------------------------------------------------------------------------
  110.  * global static data - not more since we can handle multiple boards and
  111.  * have to pack all state info into the device struct!
  112.  * ------------------------------------------------------------------------ */
  114. static char *MediaNames[Media_Count] =
  115.     { "10Base2", "10BaseT", "10Base5", "Unknown" };
  117. static unsigned char poly[] =
  118.     { 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0,
  119. 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0
  120. };
  122. /* ------------------------------------------------------------------------
  123.  * private subfunctions
  124.  * ------------------------------------------------------------------------ */
  126. /* dump parts of shared memory - only needed during debugging */
  128. #ifdef DEBUG
  129. static void dumpmem(struct SKMCA_NETDEV *dev, u32 start, u32 len)
  130. {
  131. int z;
  133. for (z = 0; z < len; z++) {
  134. if ((z & 15) == 0)
  135. printk("%04x:", z);
  136. printk(" %02x", SKMCA_READB(dev->mem_start + start + z));
  137. if ((z & 15) == 15)
  138. printk("n");
  139. }
  140. }
  142. /* print exact time - ditto */
  144. static void PrTime(void)
  145. {
  146. struct timeval tv;
  148. do_gettimeofday(&tv);
  149. printk("%9d:%06d: ", tv.tv_sec, tv.tv_usec);
  150. }
  151. #endif
  153. /* deduce resources out of POS registers */
  155. static void __init getaddrs(int slot, int junior, int *base, int *irq,
  156.      skmca_medium * medium)
  157. {
  158. u_char pos0, pos1, pos2;
  160. if (junior) {
  161. pos0 = mca_read_stored_pos(slot, 2);
  162. *base = ((pos0 & 0x0e) << 13) + 0xc0000;
  163. *irq = ((pos0 & 0x10) >> 4) + 10;
  164. *medium = Media_Unknown;
  165. } else {
  166. /* reset POS 104 Bits 0+1 so the shared memory region goes to the
  167.    configured area between 640K and 1M.  Afterwards, enable the MC2.
  168.    I really don't know what rode SK to do this... */
  170. mca_write_pos(slot, 4,
  171.       mca_read_stored_pos(slot, 4) & 0xfc);
  172. mca_write_pos(slot, 2,
  173.       mca_read_stored_pos(slot, 2) | 0x01);
  175. pos1 = mca_read_stored_pos(slot, 3);
  176. pos2 = mca_read_stored_pos(slot, 4);
  177. *base = ((pos1 & 0x07) << 14) + 0xc0000;
  178. switch (pos2 & 0x0c) {
  179. case 0:
  180. *irq = 3;
  181. break;
  182. case 4:
  183. *irq = 5;
  184. break;
  185. case 8:
  186. *irq = -10;
  187. break;
  188. case 12:
  189. *irq = -11;
  190. break;
  191. }
  192. *medium = (pos2 >> 6) & 3;
  193. }
  194. }
  196. /* check for both cards:
  197.    When the MC2 is turned off, it was configured for more than 15MB RAM,
  198.    is disabled and won't get detected using the standard probe.  We
  199.    therefore have to scan the slots manually :-( */
  201. static int __init dofind(int *junior, int firstslot)
  202. {
  203. int slot;
  204. unsigned int id;
  206. for (slot = firstslot; slot < MCA_MAX_SLOT_NR; slot++) {
  207. id = mca_read_stored_pos(slot, 0)
  208.     + (((unsigned int) mca_read_stored_pos(slot, 1)) << 8);
  210. *junior = 0;
  211. if (id == SKNET_MCA_ID)
  212. return slot;
  213. *junior = 1;
  214. if (id == SKNET_JUNIOR_MCA_ID)
  215. return slot;
  216. }
  217. return MCA_NOTFOUND;
  218. }
  220. /* reset the whole board */
  222. static void ResetBoard(struct SKMCA_NETDEV *dev)
  223. {
  224. skmca_priv *priv = (skmca_priv *) dev->priv;
  226. SKMCA_WRITEB(CTRL_RESET_ON, priv->ctrladdr);
  227. udelay(10);
  228. SKMCA_WRITEB(CTRL_RESET_OFF, priv->ctrladdr);
  229. }
  231. /* wait for LANCE interface to become not busy */
  233. static int WaitLANCE(struct SKMCA_NETDEV *dev)
  234. {
  235. skmca_priv *priv = (skmca_priv *) dev->priv;
  236. int t = 0;
  238. while ((SKMCA_READB(priv->ctrladdr) & STAT_IO_BUSY) ==
  239.        STAT_IO_BUSY) {
  240. udelay(1);
  241. if (++t > 1000) {
  242. printk("%s: LANCE access timeout", dev->name);
  243. return 0;
  244. }
  245. }
  247. return 1;
  248. }
  250. /* set LANCE register - must be atomic */
  252. static void SetLANCE(struct SKMCA_NETDEV *dev, u16 addr, u16 value)
  253. {
  254. skmca_priv *priv = (skmca_priv *) dev->priv;
  255. unsigned long flags;
  257. /* disable interrupts */
  259. save_flags(flags);
  260. cli();
  262. /* wait until no transfer is pending */
  264. WaitLANCE(dev);
  266. /* transfer register address to RAP */
  268. SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP,
  269.      priv->ctrladdr);
  270. SKMCA_WRITEW(addr, priv->ioregaddr);
  271. SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
  272. udelay(1);
  273. WaitLANCE(dev);
  275. /* transfer data to register */
  277. SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_DATA,
  278.      priv->ctrladdr);
  279. SKMCA_WRITEW(value, priv->ioregaddr);
  280. SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
  281. udelay(1);
  282. WaitLANCE(dev);
  284. /* reenable interrupts */
  286. restore_flags(flags);
  287. }
  289. /* get LANCE register */
  291. static u16 GetLANCE(struct SKMCA_NETDEV *dev, u16 addr)
  292. {
  293. skmca_priv *priv = (skmca_priv *) dev->priv;
  294. unsigned long flags;
  295. unsigned int res;
  297. /* disable interrupts */
  299. save_flags(flags);
  300. cli();
  302. /* wait until no transfer is pending */
  304. WaitLANCE(dev);
  306. /* transfer register address to RAP */
  308. SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP,
  309.      priv->ctrladdr);
  310. SKMCA_WRITEW(addr, priv->ioregaddr);
  311. SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
  312. udelay(1);
  313. WaitLANCE(dev);
  315. /* transfer data from register */
  317. SKMCA_WRITEB(CTRL_RESET_OFF | CTRL_RW_READ | CTRL_ADR_DATA,
  318.      priv->ctrladdr);
  319. SKMCA_WRITEB(IOCMD_GO, priv->cmdaddr);
  320. udelay(1);
  321. WaitLANCE(dev);
  322. res = SKMCA_READW(priv->ioregaddr);
  324. /* reenable interrupts */
  326. restore_flags(flags);
  328. return res;
  329. }
  331. /* build up descriptors in shared RAM */
  333. static void InitDscrs(struct SKMCA_NETDEV *dev)
  334. {
  335. u32 bufaddr;
  337. /* Set up Tx descriptors. The board has only 16K RAM so bits 16..23
  338.    are always 0. */
  340. bufaddr = RAM_DATABASE;
  341. {
  342. LANCE_TxDescr descr;
  343. int z;
  345. for (z = 0; z < TXCOUNT; z++) {
  346. descr.LowAddr = bufaddr;
  347. descr.Flags = 0;
  348. descr.Len = 0xf000;
  349. descr.Status = 0;
  350. SKMCA_TOIO(dev->mem_start + RAM_TXBASE +
  351.    (z * sizeof(LANCE_TxDescr)), &descr,
  352.    sizeof(LANCE_TxDescr));
  353. SKMCA_SETIO(dev->mem_start + bufaddr, 0,
  354.     RAM_BUFSIZE);
  355. bufaddr += RAM_BUFSIZE;
  356. }
  357. }
  359. /* do the same for the Rx descriptors */
  361. {
  362. LANCE_RxDescr descr;
  363. int z;
  365. for (z = 0; z < RXCOUNT; z++) {
  366. descr.LowAddr = bufaddr;
  367. descr.Flags = RXDSCR_FLAGS_OWN;
  368. descr.MaxLen = -RAM_BUFSIZE;
  369. descr.Len = 0;
  370. SKMCA_TOIO(dev->mem_start + RAM_RXBASE +
  371.    (z * sizeof(LANCE_RxDescr)), &descr,
  372.    sizeof(LANCE_RxDescr));
  373. SKMCA_SETIO(dev->mem_start + bufaddr, 0,
  374.     RAM_BUFSIZE);
  375. bufaddr += RAM_BUFSIZE;
  376. }
  377. }
  378. }
  380. /* calculate the hash bit position for a given multicast address
  381.    taken more or less directly from the AMD datasheet... */
  383. static void UpdateCRC(unsigned char *CRC, int bit)
  384. {
  385. int j;
  387. /* shift CRC one bit */
  389. memmove(CRC + 1, CRC, 32 * sizeof(unsigned char));
  390. CRC[0] = 0;
  392. /* if bit XOR controlbit = 1, set CRC = CRC XOR polynomial */
  394. if (bit ^ CRC[32])
  395. for (j = 0; j < 32; j++)
  396. CRC[j] ^= poly[j];
  397. }
  399. static unsigned int GetHash(char *address)
  400. {
  401. unsigned char CRC[33];
  402. int i, byte, hashcode;
  404. /* a multicast address has bit 0 in the first byte set */
  406. if ((address[0] & 1) == 0)
  407. return -1;
  409. /* initialize CRC */
  411. memset(CRC, 1, sizeof(CRC));
  413. /* loop through address bits */
  415. for (byte = 0; byte < 6; byte++)
  416. for (i = 0; i < 8; i++)
  417. UpdateCRC(CRC, (address[byte] >> i) & 1);
  419. /* hashcode is the 6 least significant bits of the CRC */
  421. hashcode = 0;
  422. for (i = 0; i < 6; i++)
  423. hashcode = (hashcode << 1) + CRC[i];
  424. return hashcode;
  425. }
  427. /* feed ready-built initialization block into LANCE */
  429. static void InitLANCE(struct SKMCA_NETDEV *dev)
  430. {
  431. skmca_priv *priv = (skmca_priv *) dev->priv;
  433. /* build up descriptors. */
  435. InitDscrs(dev);
  437. /* next RX descriptor to be read is the first one.  Since the LANCE
  438.    will start from the beginning after initialization, we have to 
  439.    reset out pointers too. */
  441. priv->nextrx = 0;
  443. /* no TX descriptors active */
  445. priv->nexttxput = priv->nexttxdone = priv->txbusy = 0;
  447. /* set up the LANCE bus control register - constant for SKnet boards */
  449. SetLANCE(dev, LANCE_CSR3,
  450.  CSR3_BSWAP_OFF | CSR3_ALE_LOW | CSR3_BCON_HOLD);
  452. /* write address of initialization block into LANCE */
  454. SetLANCE(dev, LANCE_CSR1, RAM_INITBASE & 0xffff);
  455. SetLANCE(dev, LANCE_CSR2, (RAM_INITBASE >> 16) & 0xff);
  457. /* we don't get ready until the LANCE has read the init block */
  459. #if (LINUX_VERSION_CODE >= 0x02032a)
  460. netif_stop_queue(dev);
  461. #else
  462. dev->tbusy = 1;
  463. #endif
  465. /* let LANCE read the initialization block.  LANCE is ready
  466.    when we receive the corresponding interrupt. */
  468. SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_INIT);
  469. }
  471. /* stop the LANCE so we can reinitialize it */
  473. static void StopLANCE(struct SKMCA_NETDEV *dev)
  474. {
  475. /* can't take frames any more */
  477. #if (LINUX_VERSION_CODE >= 0x02032a)
  478. netif_stop_queue(dev);
  479. #else
  480. dev->tbusy = 1;
  481. #endif
  483. /* disable interrupts, stop it */
  485. SetLANCE(dev, LANCE_CSR0, CSR0_STOP);
  486. }
  488. /* initialize card and LANCE for proper operation */
  490. static void InitBoard(struct SKMCA_NETDEV *dev)
  491. {
  492. LANCE_InitBlock block;
  494. /* Lay out the shared RAM - first we create the init block for the LANCE.
  495.    We do not overwrite it later because we need it again when we switch
  496.    promiscous mode on/off. */
  498. block.Mode = 0;
  499. if (dev->flags & IFF_PROMISC)
  500. block.Mode |= LANCE_INIT_PROM;
  501. memcpy(block.PAdr, dev->dev_addr, 6);
  502. memset(block.LAdrF, 0, sizeof(block.LAdrF));
  503. block.RdrP = (RAM_RXBASE & 0xffffff) | (LRXCOUNT << 29);
  504. block.TdrP = (RAM_TXBASE & 0xffffff) | (LTXCOUNT << 29);
  506. SKMCA_TOIO(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
  508. /* initialize LANCE. Implicitly sets up other structures in RAM. */
  510. InitLANCE(dev);
  511. }
  513. /* deinitialize card and LANCE */
  515. static void DeinitBoard(struct SKMCA_NETDEV *dev)
  516. {
  517. /* stop LANCE */
  519. StopLANCE(dev);
  521. /* reset board */
  523. ResetBoard(dev);
  524. }
  526. /* probe for device's irq */
  528. static int __init ProbeIRQ(struct SKMCA_NETDEV *dev)
  529. {
  530. unsigned long imaskval, njiffies, irq;
  531. u16 csr0val;
  533. /* enable all interrupts */
  535. imaskval = probe_irq_on();
  537. /* initialize the board. Wait for interrupt 'Initialization done'. */
  539. ResetBoard(dev);
  540. InitBoard(dev);
  542. njiffies = jiffies + 100;
  543. do {
  544. csr0val = GetLANCE(dev, LANCE_CSR0);
  545. }
  546. while (((csr0val & CSR0_IDON) == 0) && (jiffies != njiffies));
  548. /* turn of interrupts again */
  550. irq = probe_irq_off(imaskval);
  552. /* if we found something, ack the interrupt */
  554. if (irq)
  555. SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_IDON);
  557. /* back to idle state */
  559. DeinitBoard(dev);
  561. return irq;
  562. }
  564. /* ------------------------------------------------------------------------
  565.  * interrupt handler(s)
  566.  * ------------------------------------------------------------------------ */
  568. /* LANCE has read initialization block -> start it */
  570. static u16 irqstart_handler(struct SKMCA_NETDEV *dev, u16 oldcsr0)
  571. {
  572. /* now we're ready to transmit */
  574. #if (LINUX_VERSION_CODE >= 0x02032a)
  575. netif_wake_queue(dev);
  576. #else
  577. dev->tbusy = 0;
  578. #endif
  580. /* reset IDON bit, start LANCE */
  582. SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_IDON | CSR0_STRT);
  583. return GetLANCE(dev, LANCE_CSR0);
  584. }
  586. /* did we loose blocks due to a FIFO overrun ? */
  588. static u16 irqmiss_handler(struct SKMCA_NETDEV *dev, u16 oldcsr0)
  589. {
  590. skmca_priv *priv = (skmca_priv *) dev->priv;
  592. /* update statistics */
  594. priv->stat.rx_fifo_errors++;
  596. /* reset MISS bit */
  598. SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_MISS);
  599. return GetLANCE(dev, LANCE_CSR0);
  600. }
  602. /* receive interrupt */
  604. static u16 irqrx_handler(struct SKMCA_NETDEV *dev, u16 oldcsr0)
  605. {
  606. skmca_priv *priv = (skmca_priv *) dev->priv;
  607. LANCE_RxDescr descr;
  608. unsigned int descraddr;
  610. /* run through queue until we reach a descriptor we do not own */
  612. descraddr = RAM_RXBASE + (priv->nextrx * sizeof(LANCE_RxDescr));
  613. while (1) {
  614. /* read descriptor */
  615. SKMCA_FROMIO(&descr, dev->mem_start + descraddr,
  616.      sizeof(LANCE_RxDescr));
  618. /* if we reach a descriptor we do not own, we're done */
  619. if ((descr.Flags & RXDSCR_FLAGS_OWN) != 0)
  620. break;
  622. #ifdef DEBUG
  623. PrTime();
  624. printk("Receive packet on descr %d len %dn", priv->nextrx,
  625.        descr.Len);
  626. #endif
  628. /* erroneous packet ? */
  629. if ((descr.Flags & RXDSCR_FLAGS_ERR) != 0) {
  630. priv->stat.rx_errors++;
  631. if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
  632. priv->stat.rx_crc_errors++;
  633. else if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
  634. priv->stat.rx_frame_errors++;
  635. else if ((descr.Flags & RXDSCR_FLAGS_OFLO) != 0)
  636. priv->stat.rx_fifo_errors++;
  637. }
  639. /* good packet ? */
  640. else {
  641. struct sk_buff *skb;
  643. skb = dev_alloc_skb(descr.Len + 2);
  644. if (skb == NULL)
  645. priv->stat.rx_dropped++;
  646. else {
  647. SKMCA_FROMIO(skb_put(skb, descr.Len),
  648.      dev->mem_start +
  649.      descr.LowAddr, descr.Len);
  650. skb->dev = dev;
  651. skb->protocol = eth_type_trans(skb, dev);
  652. skb->ip_summed = CHECKSUM_NONE;
  653. priv->stat.rx_packets++;
  654. #if LINUX_VERSION_CODE >= 0x020119 /* byte counters for >= 2.1.25 */
  655. priv->stat.rx_bytes += descr.Len;
  656. #endif
  657. netif_rx(skb);
  658. dev->last_rx = jiffies;
  659. }
  660. }
  662. /* give descriptor back to LANCE */
  663. descr.Len = 0;
  664. descr.Flags |= RXDSCR_FLAGS_OWN;
  666. /* update descriptor in shared RAM */
  667. SKMCA_TOIO(dev->mem_start + descraddr, &descr,
  668.    sizeof(LANCE_RxDescr));
  670. /* go to next descriptor */
  671. priv->nextrx++;
  672. descraddr += sizeof(LANCE_RxDescr);
  673. if (priv->nextrx >= RXCOUNT) {
  674. priv->nextrx = 0;
  675. descraddr = RAM_RXBASE;
  676. }
  677. }
  679. /* reset RINT bit */
  681. SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_RINT);
  682. return GetLANCE(dev, LANCE_CSR0);
  683. }
  685. /* transmit interrupt */
  687. static u16 irqtx_handler(struct SKMCA_NETDEV *dev, u16 oldcsr0)
  688. {
  689. skmca_priv *priv = (skmca_priv *) dev->priv;
  690. LANCE_TxDescr descr;
  691. unsigned int descraddr;
  693. /* check descriptors at most until no busy one is left */
  695. descraddr =
  696.     RAM_TXBASE + (priv->nexttxdone * sizeof(LANCE_TxDescr));
  697. while (priv->txbusy > 0) {
  698. /* read descriptor */
  699. SKMCA_FROMIO(&descr, dev->mem_start + descraddr,
  700.      sizeof(LANCE_TxDescr));
  702. /* if the LANCE still owns this one, we've worked out all sent packets */
  703. if ((descr.Flags & TXDSCR_FLAGS_OWN) != 0)
  704. break;
  706. #ifdef DEBUG
  707. PrTime();
  708. printk("Send packet done on descr %dn", priv->nexttxdone);
  709. #endif
  711. /* update statistics */
  712. if ((descr.Flags & TXDSCR_FLAGS_ERR) == 0) {
  713. priv->stat.tx_packets++;
  714. #if LINUX_VERSION_CODE >= 0x020119 /* byte counters for >= 2.1.25 */
  715. priv->stat.tx_bytes++;
  716. #endif
  717. } else {
  718. priv->stat.tx_errors++;
  719. if ((descr.Status & TXDSCR_STATUS_UFLO) != 0) {
  720. priv->stat.tx_fifo_errors++;
  721. InitLANCE(dev);
  722. }
  723. else
  724.     if ((descr.Status & TXDSCR_STATUS_LCOL) !=
  725. 0) priv->stat.tx_window_errors++;
  726. else if ((descr.Status & TXDSCR_STATUS_LCAR) != 0)
  727. priv->stat.tx_carrier_errors++;
  728. else if ((descr.Status & TXDSCR_STATUS_RTRY) != 0)
  729. priv->stat.tx_aborted_errors++;
  730. }
  732. /* go to next descriptor */
  733. priv->nexttxdone++;
  734. descraddr += sizeof(LANCE_TxDescr);
  735. if (priv->nexttxdone >= TXCOUNT) {
  736. priv->nexttxdone = 0;
  737. descraddr = RAM_TXBASE;
  738. }
  739. priv->txbusy--;
  740. }
  742. /* reset TX interrupt bit */
  744. SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_TINT);
  745. oldcsr0 = GetLANCE(dev, LANCE_CSR0);
  747. /* at least one descriptor is freed.  Therefore we can accept
  748.    a new one */
  749. /* inform upper layers we're in business again */
  751. #if (LINUX_VERSION_CODE >= 0x02032a)
  752. netif_wake_queue(dev);
  753. #else
  754. dev->tbusy = 0;
  755. mark_bh(NET_BH);
  756. #endif
  758. return oldcsr0;
  759. }
  761. /* general interrupt entry */
  763. static void irq_handler(int irq, void *device, struct pt_regs *regs)
  764. {
  765. struct SKMCA_NETDEV *dev = (struct SKMCA_NETDEV *) device;
  766. u16 csr0val;
  768. /* read CSR0 to get interrupt cause */
  770. csr0val = GetLANCE(dev, LANCE_CSR0);
  772. /* in case we're not meant... */
  774. if ((csr0val & CSR0_INTR) == 0)
  775. return;
  777. #if (LINUX_VERSION_CODE >= 0x02032a)
  778. #if 0
  779. set_bit(LINK_STATE_RXSEM, &dev->state);
  780. #endif
  781. #else
  782. dev->interrupt = 1;
  783. #endif
  785. /* loop through the interrupt bits until everything is clear */
  787. do {
  788. if ((csr0val & CSR0_IDON) != 0)
  789. csr0val = irqstart_handler(dev, csr0val);
  790. if ((csr0val & CSR0_RINT) != 0)
  791. csr0val = irqrx_handler(dev, csr0val);
  792. if ((csr0val & CSR0_MISS) != 0)
  793. csr0val = irqmiss_handler(dev, csr0val);
  794. if ((csr0val & CSR0_TINT) != 0)
  795. csr0val = irqtx_handler(dev, csr0val);
  796. if ((csr0val & CSR0_MERR) != 0) {
  797. SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_MERR);
  798. csr0val = GetLANCE(dev, LANCE_CSR0);
  799. }
  800. if ((csr0val & CSR0_BABL) != 0) {
  801. SetLANCE(dev, LANCE_CSR0, csr0val | CSR0_BABL);
  802. csr0val = GetLANCE(dev, LANCE_CSR0);
  803. }
  804. }
  805. while ((csr0val & CSR0_INTR) != 0);
  807. #if (LINUX_VERSION_CODE >= 0x02032a)
  808. #if 0
  809. clear_bit(LINK_STATE_RXSEM, &dev->state);
  810. #endif
  811. #else
  812. dev->interrupt = 0;
  813. #endif
  814. }
  816. /* ------------------------------------------------------------------------
  817.  * driver methods
  818.  * ------------------------------------------------------------------------ */
  820. /* MCA info */
  822. static int skmca_getinfo(char *buf, int slot, void *d)
  823. {
  824. int len = 0, i;
  825. struct SKMCA_NETDEV *dev = (struct SKMCA_NETDEV *) d;
  826. skmca_priv *priv;
  828. /* can't say anything about an uninitialized device... */
  830. if (dev == NULL)
  831. return len;
  832. if (dev->priv == NULL)
  833. return len;
  834. priv = (skmca_priv *) dev->priv;
  836. /* print info */
  838. len += sprintf(buf + len, "IRQ: %dn", priv->realirq);
  839. len += sprintf(buf + len, "Memory: %#lx-%#lxn", dev->mem_start,
  840.        dev->mem_end - 1);
  841. len +=
  842.     sprintf(buf + len, "Transceiver: %sn",
  843.     MediaNames[priv->medium]);
  844. len += sprintf(buf + len, "Device: %sn", dev->name);
  845. len += sprintf(buf + len, "MAC address:");
  846. for (i = 0; i < 6; i++)
  847. len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
  848. buf[len++] = 'n';
  849. buf[len] = 0;
  851. return len;
  852. }
  854. /* open driver.  Means also initialization and start of LANCE */
  856. static int skmca_open(struct SKMCA_NETDEV *dev)
  857. {
  858. int result;
  859. skmca_priv *priv = (skmca_priv *) dev->priv;
  861. /* register resources - only necessary for IRQ */
  862. result =
  863.     request_irq(priv->realirq, irq_handler,
  864. SA_SHIRQ | SA_SAMPLE_RANDOM, "sk_mca", dev);
  865. if (result != 0) {
  866. printk("%s: failed to register irq %dn", dev->name,
  867.        dev->irq);
  868. return result;
  869. }
  870. dev->irq = priv->realirq;
  872. /* set up the card and LANCE */
  874. InitBoard(dev);
  876. /* set up flags */
  878. #if (LINUX_VERSION_CODE >= 0x02032a)
  879. netif_start_queue(dev);
  880. #else
  881. dev->interrupt = 0;
  882. dev->tbusy = 0;
  883. dev->start = 0;
  884. MOD_INC_USE_COUNT;
  885. #endif
  887. return 0;
  888. }
  890. /* close driver.  Shut down board and free allocated resources */
  892. static int skmca_close(struct SKMCA_NETDEV *dev)
  893. {
  894. /* turn off board */
  895. DeinitBoard(dev);
  897. /* release resources */
  898. if (dev->irq != 0)
  899. free_irq(dev->irq, dev);
  900. dev->irq = 0;
  902. #if (LINUX_VERSION_CODE < 0x02032a)
  903. MOD_DEC_USE_COUNT;
  904. #endif
  906. return 0;
  907. }
  909. /* transmit a block. */
  911. static int skmca_tx(struct sk_buff *skb, struct SKMCA_NETDEV *dev)
  912. {
  913. skmca_priv *priv = (skmca_priv *) dev->priv;
  914. LANCE_TxDescr descr;
  915. unsigned int address;
  916. int tmplen, retval = 0;
  917. unsigned long flags;
  919. /* if we get called with a NULL descriptor, the Ethernet layer thinks 
  920.    our card is stuck an we should reset it.  We'll do this completely: */
  922. if (skb == NULL) {
  923. DeinitBoard(dev);
  924. InitBoard(dev);
  925. return 0; /* don't try to free the block here ;-) */
  926. }
  928. /* is there space in the Tx queue ? If no, the upper layer gave us a
  929.    packet in spite of us not being ready and is really in trouble.
  930.    We'll do the dropping for him: */
  931. if (priv->txbusy >= TXCOUNT) {
  932. priv->stat.tx_dropped++;
  933. retval = -EIO;
  934. goto tx_done;
  935. }
  937. /* get TX descriptor */
  938. address = RAM_TXBASE + (priv->nexttxput * sizeof(LANCE_TxDescr));
  939. SKMCA_FROMIO(&descr, dev->mem_start + address,
  940.      sizeof(LANCE_TxDescr));
  942. /* enter packet length as 2s complement - assure minimum length */
  943. tmplen = skb->len;
  944. if (tmplen < 60)
  945. tmplen = 60;
  946. descr.Len = 65536 - tmplen;
  948. /* copy filler into RAM - in case we're filling up... 
  949.    we're filling a bit more than necessary, but that doesn't harm
  950.    since the buffer is far larger... */
  951. if (tmplen > skb->len) {
  952. char *fill = "NetBSD is a nice OS too! ";
  953. unsigned int destoffs = 0, l = strlen(fill);
  955. while (destoffs < tmplen) {
  956. SKMCA_TOIO(dev->mem_start + descr.LowAddr +
  957.    destoffs, fill, l);
  958. destoffs += l;
  959. }
  960. }
  962. /* do the real data copying */
  963. SKMCA_TOIO(dev->mem_start + descr.LowAddr, skb->data, skb->len);
  965. /* hand descriptor over to LANCE - this is the first and last chunk */
  966. descr.Flags =
  967.     TXDSCR_FLAGS_OWN | TXDSCR_FLAGS_STP | TXDSCR_FLAGS_ENP;
  969. #ifdef DEBUG
  970. PrTime();
  971. printk("Send packet on descr %d len %dn", priv->nexttxput,
  972.        skb->len);
  973. #endif
  975. /* one more descriptor busy */
  976. save_flags(flags);
  977. cli();
  978. priv->nexttxput++;
  979. if (priv->nexttxput >= TXCOUNT)
  980. priv->nexttxput = 0;
  981. priv->txbusy++;
  983. /* are we saturated ? */
  985. if (priv->txbusy >= TXCOUNT)
  986. #if (LINUX_VERSION_CODE >= 0x02032a)
  987. netif_stop_queue(dev);
  988. #else
  989. dev->tbusy = 1;
  990. #endif
  992. /* write descriptor back to RAM */
  993. SKMCA_TOIO(dev->mem_start + address, &descr,
  994.    sizeof(LANCE_TxDescr));
  996. /* if no descriptors were active, give the LANCE a hint to read it
  997.    immediately */
  999. if (priv->txbusy == 0)
  1000. SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_TDMD);
  1002. restore_flags(flags);
  1004.       tx_done:
  1006. /* When did that change exactly ? */
  1008. #if LINUX_VERSION_CODE >= 0x020200
  1009. dev_kfree_skb(skb);
  1010. #else
  1011. dev_kfree_skb(skb, FREE_WRITE);
  1012. #endif
  1013. return retval;
  1014. }
  1016. /* return pointer to Ethernet statistics */
  1018. static struct net_device_stats *skmca_stats(struct SKMCA_NETDEV *dev)
  1019. {
  1020. skmca_priv *priv = (skmca_priv *) dev->priv;
  1022. return &(priv->stat);
  1023. }
  1025. /* we don't support runtime reconfiguration, since an MCA card can
  1026.    be unambigously identified by its POS registers. */
  1028. static int skmca_config(struct SKMCA_NETDEV *dev, struct ifmap *map)
  1029. {
  1030. return 0;
  1031. }
  1033. /* switch receiver mode.  We use the LANCE's multicast filter to prefilter
  1034.    multicast addresses. */
  1036. static void skmca_set_multicast_list(struct SKMCA_NETDEV *dev)
  1037. {
  1038. LANCE_InitBlock block;
  1040. /* first stop the LANCE... */
  1041. StopLANCE(dev);
  1043. /* ...then modify the initialization block... */
  1044. SKMCA_FROMIO(&block, dev->mem_start + RAM_INITBASE, sizeof(block));
  1045. if (dev->flags & IFF_PROMISC)
  1046. block.Mode |= LANCE_INIT_PROM;
  1047. else
  1048. block.Mode &= ~LANCE_INIT_PROM;
  1050. if (dev->flags & IFF_ALLMULTI) { /* get all multicasts */
  1051. memset(block.LAdrF, 8, 0xff);
  1052. } else { /* get selected/no multicasts */
  1054. struct dev_mc_list *mptr;
  1055. int code;
  1057. memset(block.LAdrF, 8, 0x00);
  1058. for (mptr = dev->mc_list; mptr != NULL; mptr = mptr->next) {
  1059. code = GetHash(mptr->dmi_addr);
  1060. block.LAdrF[(code >> 3) & 7] |= 1 << (code & 7);
  1061. }
  1062. }
  1064. SKMCA_TOIO(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
  1066. /* ...then reinit LANCE with the correct flags */
  1067. InitLANCE(dev);
  1068. }
  1070. /* ------------------------------------------------------------------------
  1071.  * hardware check
  1072.  * ------------------------------------------------------------------------ */
  1074. static int startslot; /* counts through slots when probing multiple devices */
  1076. int __init skmca_probe(struct SKMCA_NETDEV *dev)
  1077. {
  1078. int force_detect = 0;
  1079. int junior, slot, i;
  1080. int base = 0, irq = 0;
  1081. skmca_priv *priv;
  1082. skmca_medium medium;
  1084. /* can't work without an MCA bus ;-) */
  1086. if (MCA_bus == 0)
  1087. return -ENODEV;
  1089. SET_MODULE_OWNER(dev);
  1091. /* start address of 1 --> forced detection */
  1093. if (dev->mem_start == 1)
  1094. force_detect = 1;
  1096. /* search through slots */
  1098. if (dev != NULL) {
  1099. base = dev->mem_start;
  1100. irq = dev->irq;
  1101. }
  1102. slot = dofind(&junior, startslot);
  1104. while (slot != -1) {
  1105. /* deduce card addresses */
  1107. getaddrs(slot, junior, &base, &irq, &medium);
  1109. #if LINUX_VERSION_CODE >= 0x020300
  1110. /* slot already in use ? */
  1112. if (mca_is_adapter_used(slot)) {
  1113. slot = dofind(&junior, slot + 1);
  1114. continue;
  1115. }
  1116. #endif
  1118. /* were we looking for something different ? */
  1120. if ((dev->irq != 0) || (dev->mem_start != 0)) {
  1121. if ((dev->irq != 0) && (dev->irq != irq)) {
  1122. slot = dofind(&junior, slot + 1);
  1123. continue;
  1124. }
  1125. if ((dev->mem_start != 0)
  1126.     && (dev->mem_start != base)) {
  1127. slot = dofind(&junior, slot + 1);
  1128. continue;
  1129. }
  1130. }
  1132. /* found something that matches */
  1134. break;
  1135. }
  1137. /* nothing found ? */
  1139. if (slot == -1)
  1140. return ((base != 0) || (irq != 0)) ? ENXIO : ENODEV;
  1142. /* make procfs entries */
  1144. if (junior)
  1145. mca_set_adapter_name(slot,
  1146.      "SKNET junior MC2 Ethernet Adapter");
  1147. else
  1148. mca_set_adapter_name(slot, "SKNET MC2+ Ethernet Adapter");
  1149. mca_set_adapter_procfn(slot, (MCA_ProcFn) skmca_getinfo, dev);
  1151. #if LINUX_VERSION_CODE >= 0x020200
  1152. mca_mark_as_used(slot);
  1153. #endif
  1155. /* announce success */
  1156. printk("%s: SKNet %s adapter found in slot %dn", dev->name,
  1157.        junior ? "Junior MC2" : "MC2+", slot + 1);
  1159. /* allocate structure */
  1160. priv = dev->priv =
  1161.     (skmca_priv *) kmalloc(sizeof(skmca_priv), GFP_KERNEL);
  1162. if (!priv)
  1163. return -ENOMEM;
  1164. priv->slot = slot;
  1165. priv->macbase = base + 0x3fc0;
  1166. priv->ioregaddr = base + 0x3ff0;
  1167. priv->ctrladdr = base + 0x3ff2;
  1168. priv->cmdaddr = base + 0x3ff3;
  1169. priv->medium = medium;
  1170. memset(&(priv->stat), 0, sizeof(struct net_device_stats));
  1172. /* set base + irq for this device (irq not allocated so far) */
  1173. dev->irq = 0;
  1174. dev->mem_start = base;
  1175. dev->mem_end = base + 0x4000;
  1177. /* autoprobe ? */
  1178. if (irq < 0) {
  1179. int nirq;
  1181. printk
  1182.     ("%s: ambigous POS bit combination, must probe for IRQ...n",
  1183.      dev->name);
  1184. nirq = ProbeIRQ(dev);
  1185. if (nirq <= 0)
  1186. printk("%s: IRQ probe failed, assuming IRQ %d",
  1187.        dev->name, priv->realirq = -irq);
  1188. else
  1189. priv->realirq = nirq;
  1190. } else
  1191. priv->realirq = irq;
  1193. /* set methods */
  1194. dev->open = skmca_open;
  1195. dev->stop = skmca_close;
  1196. dev->set_config = skmca_config;
  1197. dev->hard_start_xmit = skmca_tx;
  1198. dev->do_ioctl = NULL;
  1199. dev->get_stats = skmca_stats;
  1200. dev->set_multicast_list = skmca_set_multicast_list;
  1201. dev->flags |= IFF_MULTICAST;
  1203. /* generic setup */
  1204. ether_setup(dev);
  1206. /* copy out MAC address */
  1207. for (i = 0; i < 6; i++)
  1208. dev->dev_addr[i] = SKMCA_READB(priv->macbase + (i << 1));
  1210. /* print config */
  1211. printk("%s: IRQ %d, memory %#lx-%#lx, "
  1212.        "MAC address %02x:%02x:%02x:%02x:%02x:%02x.n",
  1213.        dev->name, priv->realirq, dev->mem_start, dev->mem_end - 1,
  1214.        dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
  1215.        dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
  1216. printk("%s: %s mediumn", dev->name, MediaNames[priv->medium]);
  1218. /* reset board */
  1220. ResetBoard(dev);
  1222. startslot = slot + 1;
  1224. return 0;
  1225. }
  1227. /* ------------------------------------------------------------------------
  1228.  * modularization support
  1229.  * ------------------------------------------------------------------------ */
  1231. #ifdef MODULE
  1232. MODULE_LICENSE("GPL");
  1234. #define DEVMAX 5
  1236. #if (LINUX_VERSION_CODE >= 0x020369)
  1237. static struct SKMCA_NETDEV moddevs[DEVMAX] =
  1238.     { {"    ", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1239. {"    ", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1240. {"    ", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1241. {"    ", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1242. {"    ", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe}
  1243. };
  1244. #else
  1245. static char NameSpace[8 * DEVMAX];
  1246. static struct SKMCA_NETDEV moddevs[DEVMAX] =
  1247.     { {NameSpace + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1248. {NameSpace + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1249. {NameSpace + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1250. {NameSpace + 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
  1251. {NameSpace + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe}
  1252. };
  1253. #endif
  1255. int irq;
  1256. int io;
  1258. int init_module(void)
  1259. {
  1260. int z, res;
  1262. startslot = 0;
  1263. for (z = 0; z < DEVMAX; z++) {
  1264. strcpy(moddevs[z].name, "     ");
  1265. res = register_netdev(moddevs + z);
  1266. if (res != 0)
  1267. return (z > 0) ? 0 : -EIO;
  1268. }
  1270. return 0;
  1271. }
  1273. void cleanup_module(void)
  1274. {
  1275. struct SKMCA_NETDEV *dev;
  1276. skmca_priv *priv;
  1277. int z;
  1279. if (MOD_IN_USE) {
  1280. printk("cannot unload, module in usen");
  1281. return;
  1282. }
  1284. for (z = 0; z < DEVMAX; z++) {
  1285. dev = moddevs + z;
  1286. if (dev->priv != NULL) {
  1287. priv = (skmca_priv *) dev->priv;
  1288. DeinitBoard(dev);
  1289. if (dev->irq != 0)
  1290. free_irq(dev->irq, dev);
  1291. dev->irq = 0;
  1292. unregister_netdev(dev);
  1293. #if LINUX_VERSION_CODE >= 0x020200
  1294. mca_mark_as_unused(priv->slot);
  1295. #endif
  1296. mca_set_adapter_procfn(priv->slot, NULL, NULL);
  1297. kfree(dev->priv);
  1298. dev->priv = NULL;
  1299. }
  1300. }
  1301. }
  1302. #endif /* MODULE */