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

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

Linux/Unix编程

开发平台：

Unix_Linux

ni65.c：源码内容
  1. /*
  2.  * ni6510 (am7990 'lance' chip) driver for Linux-net-3
  3.  * BETAcode v0.71 (96/09/29) for 2.0.0 (or later)
  4.  * copyrights (c) 1994,1995,1996 by M.Hipp
  5.  *
  6.  * This driver can handle the old ni6510 board and the newer ni6510
  7.  * EtherBlaster. (probably it also works with every full NE2100
  8.  * compatible card)
  9.  *
  10.  * To compile as module, type:
  11.  *     gcc -O2 -fomit-frame-pointer -m486 -D__KERNEL__ -DMODULE -c ni65.c
  12.  * driver probes: io: 0x360,0x300,0x320,0x340 / dma: 3,5,6,7
  13.  *
  14.  * This is an extension to the Linux operating system, and is covered by the
  15.  * same GNU General Public License that covers the Linux-kernel.
  16.  *
  17.  * comments/bugs/suggestions can be sent to:
  18.  *   Michael Hipp
  19.  *   email: hippm@informatik.uni-tuebingen.de
  20.  *
  21.  * sources:
  22.  *   some things are from the 'ni6510-packet-driver for dos by Russ Nelson'
  23.  *   and from the original drivers by D.Becker
  24.  *
  25.  * known problems:
  26.  *   - on some PCI boards (including my own) the card/board/ISA-bridge has
  27.  *     problems with bus master DMA. This results in lotsa overruns.
  28.  *     It may help to '#define RCV_PARANOIA_CHECK' or try to #undef
  29.  *     the XMT and RCV_VIA_SKB option .. this reduces driver performance.
  30.  *     Or just play with your BIOS options to optimize ISA-DMA access.
  31.  *     Maybe you also wanna play with the LOW_PERFORAMCE and MID_PERFORMANCE
  32.  *     defines -> please report me your experience then
  33.  *   - Harald reported for ASUS SP3G mainboards, that you should use
  34.  *     the 'optimal settings' from the user's manual on page 3-12!
  35.  *
  36.  * credits:
  37.  *   thanx to Jason Sullivan for sending me a ni6510 card!
  38.  *   lot of debug runs with ASUS SP3G Boards (Intel Saturn) by Harald Koenig
  39.  *
  40.  * simple performance test: (486DX-33/Ni6510-EB receives from 486DX4-100/Ni6510-EB)
  41.  *    average: FTP -> 8384421 bytes received in 8.5 seconds
  42.  *           (no RCV_VIA_SKB,no XMT_VIA_SKB,PARANOIA_CHECK,4 XMIT BUFS, 8 RCV_BUFFS)
  43.  *    peak: FTP -> 8384421 bytes received in 7.5 seconds
  44.  *           (RCV_VIA_SKB,XMT_VIA_SKB,no PARANOIA_CHECK,1(!) XMIT BUF, 16 RCV BUFFS)
  45.  */
  47. /*
  48.  * 99.Jun.8: added support for /proc/net/dev byte count for xosview (HK)
  49.  * 96.Sept.29: virt_to_bus stuff added for new memory modell
  50.  * 96.April.29: Added Harald Koenig's Patches (MH)
  51.  * 96.April.13: enhanced error handling .. more tests (MH)
  52.  * 96.April.5/6: a lot of performance tests. Got it stable now (hopefully) (MH)
  53.  * 96.April.1: (no joke ;) .. added EtherBlaster and Module support (MH)
  54.  * 96.Feb.19: fixed a few bugs .. cleanups .. tested for 1.3.66 (MH)
  55.  *            hopefully no more 16MB limit
  56.  *
  57.  * 95.Nov.18: multicast tweaked (AC).
  58.  *
  59.  * 94.Aug.22: changes in xmit_intr (ack more than one xmitted-packet), ni65_send_packet (p->lock) (MH)
  60.  *
  61.  * 94.July.16: fixed bugs in recv_skb and skb-alloc stuff  (MH)
  62.  */
  64. #include <linux/kernel.h>
  65. #include <linux/sched.h>
  66. #include <linux/string.h>
  67. #include <linux/ptrace.h>
  68. #include <linux/errno.h>
  69. #include <linux/ioport.h>
  70. #include <linux/slab.h>
  71. #include <linux/interrupt.h>
  72. #include <linux/delay.h>
  73. #include <linux/init.h>
  74. #include <asm/bitops.h>
  75. #include <asm/io.h>
  76. #include <asm/dma.h>
  78. #include <linux/netdevice.h>
  79. #include <linux/etherdevice.h>
  80. #include <linux/skbuff.h>
  82. #include <linux/version.h>
  83. #include <linux/module.h>
  85. #include "ni65.h"
  87. /*
  88.  * the current setting allows an acceptable performance
  89.  * for 'RCV_PARANOIA_CHECK' read the 'known problems' part in
  90.  * the header of this file
  91.  * 'invert' the defines for max. performance. This may cause DMA problems
  92.  * on some boards (e.g on my ASUS SP3G)
  93.  */
  94. #undef XMT_VIA_SKB
  95. #undef RCV_VIA_SKB
  96. #define RCV_PARANOIA_CHECK
  98. #define MID_PERFORMANCE
  100. #if   defined( LOW_PERFORMANCE )
  101.  static int isa0=7,isa1=7,csr80=0x0c10;
  102. #elif defined( MID_PERFORMANCE )
  103.  static int isa0=5,isa1=5,csr80=0x2810;
  104. #else /* high performance */
  105.  static int isa0=4,isa1=4,csr80=0x0017;
  106. #endif
  108. /*
  109.  * a few card/vendor specific defines
  110.  */
  111. #define NI65_ID0    0x00
  112. #define NI65_ID1    0x55
  113. #define NI65_EB_ID0 0x52
  114. #define NI65_EB_ID1 0x44
  115. #define NE2100_ID0  0x57
  116. #define NE2100_ID1  0x57
  118. #define PORT p->cmdr_addr
  120. /*
  121.  * buffer configuration
  122.  */
  123. #if 1
  124. #define RMDNUM 16
  125. #define RMDNUMMASK 0x80000000
  126. #else
  127. #define RMDNUM 8
  128. #define RMDNUMMASK 0x60000000 /* log2(RMDNUM)<<29 */
  129. #endif
  131. #if 0
  132. #define TMDNUM 1
  133. #define TMDNUMMASK 0x00000000
  134. #else
  135. #define TMDNUM 4
  136. #define TMDNUMMASK 0x40000000 /* log2(TMDNUM)<<29 */
  137. #endif
  139. /* slightly oversized */
  140. #define R_BUF_SIZE 1544
  141. #define T_BUF_SIZE 1544
  143. /*
  144.  * lance register defines
  145.  */
  146. #define L_DATAREG 0x00
  147. #define L_ADDRREG 0x02
  148. #define L_RESET   0x04
  149. #define L_CONFIG  0x05
  150. #define L_BUSIF   0x06
  152. /*
  153.  * to access the lance/am7990-regs, you have to write
  154.  * reg-number into L_ADDRREG, then you can access it using L_DATAREG
  155.  */
  156. #define CSR0  0x00
  157. #define CSR1  0x01
  158. #define CSR2  0x02
  159. #define CSR3  0x03
  161. #define INIT_RING_BEFORE_START 0x1
  162. #define FULL_RESET_ON_ERROR 0x2
  164. #if 0
  165. #define writereg(val,reg) {outw(reg,PORT+L_ADDRREG);inw(PORT+L_ADDRREG); 
  166.                            outw(val,PORT+L_DATAREG);inw(PORT+L_DATAREG);}
  167. #define readreg(reg) (outw(reg,PORT+L_ADDRREG),inw(PORT+L_ADDRREG),
  168.                        inw(PORT+L_DATAREG))
  169. #if 0
  170. #define writedatareg(val) {outw(val,PORT+L_DATAREG);inw(PORT+L_DATAREG);}
  171. #else
  172. #define writedatareg(val) {  writereg(val,CSR0); }
  173. #endif
  174. #else
  175. #define writereg(val,reg) {outw(reg,PORT+L_ADDRREG);outw(val,PORT+L_DATAREG);}
  176. #define readreg(reg) (outw(reg,PORT+L_ADDRREG),inw(PORT+L_DATAREG))
  177. #define writedatareg(val) { writereg(val,CSR0); }
  178. #endif
  180. static unsigned char ni_vendor[] = { 0x02,0x07,0x01 };
  182. static struct card {
  183. unsigned char id0,id1;
  184. short id_offset;
  185. short total_size;
  186. short cmd_offset;
  187. short addr_offset;
  188. unsigned char *vendor_id;
  189. char *cardname;
  190. unsigned char config;
  191. } cards[] = {
  192. { NI65_ID0,NI65_ID1,0x0e,0x10,0x0,0x8,ni_vendor,"ni6510", 0x1 } ,
  193. { NI65_EB_ID0,NI65_EB_ID1,0x0e,0x18,0x10,0x0,ni_vendor,"ni6510 EtherBlaster", 0x2 } ,
  194. { NE2100_ID0,NE2100_ID1,0x0e,0x18,0x10,0x0,NULL,"generic NE2100", 0x0 }
  195. };
  196. #define NUM_CARDS 3
  198. struct priv
  199. {
  200. struct rmd rmdhead[RMDNUM];
  201. struct tmd tmdhead[TMDNUM];
  202. struct init_block ib;
  203. int rmdnum;
  204. int tmdnum,tmdlast;
  205. #ifdef RCV_VIA_SKB
  206. struct sk_buff *recv_skb[RMDNUM];
  207. #else
  208. void *recvbounce[RMDNUM];
  209. #endif
  210. #ifdef XMT_VIA_SKB
  211. struct sk_buff *tmd_skb[TMDNUM];
  212. #endif
  213. void *tmdbounce[TMDNUM];
  214. int tmdbouncenum;
  215. int lock,xmit_queued;
  216. struct net_device_stats stats;
  217. void *self;
  218. int cmdr_addr;
  219. int cardno;
  220. int features;
  221. };
  223. static int  ni65_probe1(struct net_device *dev,int);
  224. static void ni65_interrupt(int irq, void * dev_id, struct pt_regs *regs);
  225. static void ni65_recv_intr(struct net_device *dev,int);
  226. static void ni65_xmit_intr(struct net_device *dev,int);
  227. static int  ni65_open(struct net_device *dev);
  228. static int  ni65_lance_reinit(struct net_device *dev);
  229. static void ni65_init_lance(struct priv *p,unsigned char*,int,int);
  230. static int  ni65_send_packet(struct sk_buff *skb, struct net_device *dev);
  231. static void  ni65_timeout(struct net_device *dev);
  232. static int  ni65_close(struct net_device *dev);
  233. static int  ni65_alloc_buffer(struct net_device *dev);
  234. static void ni65_free_buffer(struct priv *p);
  235. static struct net_device_stats *ni65_get_stats(struct net_device *);
  236. static void set_multicast_list(struct net_device *dev);
  238. static int irqtab[] __initdata = { 9,12,15,5 }; /* irq config-translate */
  239. static int dmatab[] __initdata = { 0,3,5,6,7 }; /* dma config-translate and autodetect */
  241. static int debuglevel = 1;
  243. /*
  244.  * set 'performance' registers .. we must STOP lance for that
  245.  */
  246. static void ni65_set_performance(struct priv *p)
  247. {
  248. writereg(CSR0_STOP | CSR0_CLRALL,CSR0); /* STOP */
  250. if( !(cards[p->cardno].config & 0x02) )
  251. return;
  253. outw(80,PORT+L_ADDRREG);
  254. if(inw(PORT+L_ADDRREG) != 80)
  255. return;
  257. writereg( (csr80 & 0x3fff) ,80); /* FIFO watermarks */
  258. outw(0,PORT+L_ADDRREG);
  259. outw((short)isa0,PORT+L_BUSIF); /* write ISA 0: DMA_R : isa0 * 50ns */
  260. outw(1,PORT+L_ADDRREG);
  261. outw((short)isa1,PORT+L_BUSIF); /* write ISA 1: DMA_W : isa1 * 50ns */
  263. outw(CSR0,PORT+L_ADDRREG); /* switch back to CSR0 */
  264. }
  266. /*
  267.  * open interface (up)
  268.  */
  269. static int ni65_open(struct net_device *dev)
  270. {
  271. struct priv *p = (struct priv *) dev->priv;
  272. int irqval = request_irq(dev->irq, &ni65_interrupt,0,
  273.                         cards[p->cardno].cardname,dev);
  274. if (irqval) {
  275. printk ("%s: unable to get IRQ %d (irqval=%d).n",
  276.           dev->name,dev->irq, irqval);
  277. return -EAGAIN;
  278. }
  280. if(ni65_lance_reinit(dev))
  281. {
  282. netif_start_queue(dev);
  283. MOD_INC_USE_COUNT;
  284. return 0;
  285. }
  286. else
  287. {
  288. free_irq(dev->irq,dev);
  289. return -EAGAIN;
  290. }
  291. }
  293. /*
  294.  * close interface (down)
  295.  */
  296. static int ni65_close(struct net_device *dev)
  297. {
  298. struct priv *p = (struct priv *) dev->priv;
  300. netif_stop_queue(dev);
  302. outw(inw(PORT+L_RESET),PORT+L_RESET); /* that's the hard way */
  304. #ifdef XMT_VIA_SKB
  305. {
  306. int i;
  307. for(i=0;i<TMDNUM;i++)
  308. {
  309. if(p->tmd_skb[i]) {
  310. dev_kfree_skb(p->tmd_skb[i]);
  311. p->tmd_skb[i] = NULL;
  312. }
  313. }
  314. }
  315. #endif
  316. free_irq(dev->irq,dev);
  317. MOD_DEC_USE_COUNT;
  318. return 0;
  319. }
  321. /*
  322.  * Probe The Card (not the lance-chip)
  323.  */
  324. #ifdef MODULE
  325. static
  326. #endif
  327. int __init ni65_probe(struct net_device *dev)
  328. {
  329. int *port;
  330. static int ports[] = {0x360,0x300,0x320,0x340, 0};
  332. if (dev->base_addr > 0x1ff)          /* Check a single specified location. */
  333.  return ni65_probe1(dev, dev->base_addr);
  334. else if (dev->base_addr > 0)         /* Don't probe at all. */
  335.  return -ENXIO;
  337. for (port = ports; *port; port++)
  338. {
  339. if (ni65_probe1(dev, *port) == 0)
  340.  return 0;
  341. }
  343. return -ENODEV;
  344. }
  346. /*
  347.  * this is the real card probe ..
  348.  */
  349. static int __init ni65_probe1(struct net_device *dev,int ioaddr)
  350. {
  351. int i,j;
  352. struct priv *p;
  353. unsigned long flags;
  355. for(i=0;i<NUM_CARDS;i++) {
  356. if(!request_region(ioaddr, cards[i].total_size, cards[i].cardname))
  357. continue;
  358. if(cards[i].id_offset >= 0) {
  359. if(inb(ioaddr+cards[i].id_offset+0) != cards[i].id0 ||
  360.  inb(ioaddr+cards[i].id_offset+1) != cards[i].id1) {
  361.  release_region(ioaddr, cards[i].total_size);
  362.  continue;
  363. }
  364. }
  365. if(cards[i].vendor_id) {
  366. for(j=0;j<3;j++)
  367. if(inb(ioaddr+cards[i].addr_offset+j) != cards[i].vendor_id[j]) {
  368. release_region(ioaddr, cards[i].total_size);
  369. continue;
  370.   }
  371. }
  372. break;
  373. }
  374. if(i == NUM_CARDS)
  375. return -ENODEV;
  377. for(j=0;j<6;j++)
  378. dev->dev_addr[j] = inb(ioaddr+cards[i].addr_offset+j);
  380. if( (j=ni65_alloc_buffer(dev)) < 0) {
  381. release_region(ioaddr, cards[i].total_size);
  382. return j;
  383. }
  384. p = (struct priv *) dev->priv;
  385. p->cmdr_addr = ioaddr + cards[i].cmd_offset;
  386. p->cardno = i;
  388. printk("%s: %s found at %#3x, ", dev->name, cards[p->cardno].cardname , ioaddr);
  390. outw(inw(PORT+L_RESET),PORT+L_RESET); /* first: reset the card */
  391. if( (j=readreg(CSR0)) != 0x4) {
  392.  printk(KERN_ERR "can't RESET card: %04xn",j);
  393.  ni65_free_buffer(p);
  394.  release_region(ioaddr, cards[p->cardno].total_size);
  395.  return -EAGAIN;
  396. }
  398. outw(88,PORT+L_ADDRREG);
  399. if(inw(PORT+L_ADDRREG) == 88) {
  400. unsigned long v;
  401. v = inw(PORT+L_DATAREG);
  402. v <<= 16;
  403. outw(89,PORT+L_ADDRREG);
  404. v |= inw(PORT+L_DATAREG);
  405. printk("Version %#08lx, ",v);
  406. p->features = INIT_RING_BEFORE_START;
  407. }
  408. else {
  409. printk("ancient LANCE, ");
  410. p->features = 0x0;
  411. }
  413. if(test_bit(0,&cards[i].config)) {
  414. dev->irq = irqtab[(inw(ioaddr+L_CONFIG)>>2)&3];
  415. dev->dma = dmatab[inw(ioaddr+L_CONFIG)&3];
  416. printk("IRQ %d (from card), DMA %d (from card).n",dev->irq,dev->dma);
  417. }
  418. else {
  419. if(dev->dma == 0) {
  420. /* 'stuck test' from lance.c */
  421. int dma_channels = ((inb(DMA1_STAT_REG) >> 4) & 0x0f) | (inb(DMA2_STAT_REG) & 0xf0);
  422. for(i=1;i<5;i++) {
  423. int dma = dmatab[i];
  424. if(test_bit(dma,&dma_channels) || request_dma(dma,"ni6510"))
  425. continue;
  427. flags=claim_dma_lock();
  428. disable_dma(dma);
  429. set_dma_mode(dma,DMA_MODE_CASCADE);
  430. enable_dma(dma);
  431. release_dma_lock(flags);
  433. ni65_init_lance(p,dev->dev_addr,0,0); /* trigger memory access */
  435. flags=claim_dma_lock();
  436. disable_dma(dma);
  437. free_dma(dma);
  438. release_dma_lock(flags);
  440. if(readreg(CSR0) & CSR0_IDON)
  441. break;
  442. }
  443. if(i == 5) {
  444. printk("Can't detect DMA channel!n");
  445. ni65_free_buffer(p);
  446. release_region(ioaddr, cards[p->cardno].total_size);
  447. return -EAGAIN;
  448. }
  449. dev->dma = dmatab[i];
  450. printk("DMA %d (autodetected), ",dev->dma);
  451. }
  452. else
  453. printk("DMA %d (assigned), ",dev->dma);
  455. if(dev->irq < 2)
  456. {
  457. ni65_init_lance(p,dev->dev_addr,0,0);
  458. autoirq_setup(0);
  459. writereg(CSR0_INIT|CSR0_INEA,CSR0); /* trigger interrupt */
  461. if(!(dev->irq = autoirq_report(2)))
  462. {
  463. printk("Failed to detect IRQ line!n");
  464. ni65_free_buffer(p);
  465. release_region(ioaddr, cards[p->cardno].total_size);
  466. return -EAGAIN;
  467. }
  468. printk("IRQ %d (autodetected).n",dev->irq);
  469. }
  470. else
  471. printk("IRQ %d (assigned).n",dev->irq);
  472. }
  474. if(request_dma(dev->dma, cards[p->cardno].cardname ) != 0)
  475. {
  476. printk("%s: Can't request dma-channel %dn",dev->name,(int) dev->dma);
  477. ni65_free_buffer(p);
  478. release_region(ioaddr, cards[p->cardno].total_size);
  479. return -EAGAIN;
  480. }
  482. dev->base_addr = ioaddr;
  484. dev->open = ni65_open;
  485. dev->stop = ni65_close;
  486. dev->hard_start_xmit = ni65_send_packet;
  487. dev->tx_timeout = ni65_timeout;
  488. dev->watchdog_timeo = HZ/2;
  489. dev->get_stats = ni65_get_stats;
  490. dev->set_multicast_list = set_multicast_list;
  492. ether_setup(dev);
  494. return 0; /* everything is OK */
  495. }
  497. /*
  498.  * set lance register and trigger init
  499.  */
  500. static void ni65_init_lance(struct priv *p,unsigned char *daddr,int filter,int mode)
  501. {
  502. int i;
  503. u32 pib;
  505. writereg(CSR0_CLRALL|CSR0_STOP,CSR0);
  507. for(i=0;i<6;i++)
  508. p->ib.eaddr[i] = daddr[i];
  510. for(i=0;i<8;i++)
  511. p->ib.filter[i] = filter;
  512. p->ib.mode = mode;
  514. p->ib.trp = (u32) virt_to_bus(p->tmdhead) | TMDNUMMASK;
  515. p->ib.rrp = (u32) virt_to_bus(p->rmdhead) | RMDNUMMASK;
  516. writereg(0,CSR3); /* busmaster/no word-swap */
  517. pib = (u32) virt_to_bus(&p->ib);
  518. writereg(pib & 0xffff,CSR1);
  519. writereg(pib >> 16,CSR2);
  521. writereg(CSR0_INIT,CSR0); /* this changes L_ADDRREG to CSR0 */
  523. for(i=0;i<32;i++)
  524. {
  525. mdelay(4);
  526. if(inw(PORT+L_DATAREG) & (CSR0_IDON | CSR0_MERR) )
  527. break; /* init ok ? */
  528. }
  529. }
  531. /*
  532.  * allocate memory area and check the 16MB border
  533.  */
  534. static void *ni65_alloc_mem(struct net_device *dev,char *what,int size,int type)
  535. {
  536. struct sk_buff *skb=NULL;
  537. unsigned char *ptr;
  538. void *ret;
  540. if(type) {
  541. ret = skb = alloc_skb(2+16+size,GFP_KERNEL|GFP_DMA);
  542. if(!skb) {
  543. printk("%s: unable to allocate %s memory.n",dev->name,what);
  544. return NULL;
  545. }
  546. skb->dev = dev;
  547. skb_reserve(skb,2+16);
  548. skb_put(skb,R_BUF_SIZE);  /* grab the whole space .. (not necessary) */
  549. ptr = skb->data;
  550. }
  551. else {
  552. ret = ptr = kmalloc(T_BUF_SIZE,GFP_KERNEL | GFP_DMA);
  553. if(!ret) {
  554. printk("%s: unable to allocate %s memory.n",dev->name,what);
  555. return NULL;
  556. }
  557. }
  558. if( (u32) virt_to_bus(ptr+size) > 0x1000000) {
  559. printk("%s: unable to allocate %s memory in lower 16MB!n",dev->name,what);
  560. if(type)
  561. kfree_skb(skb);
  562. else
  563. kfree(ptr);
  564. return NULL;
  565. }
  566. return ret;
  567. }
  569. /*
  570.  * allocate all memory structures .. send/recv buffers etc ...
  571.  */
  572. static int ni65_alloc_buffer(struct net_device *dev)
  573. {
  574. unsigned char *ptr;
  575. struct priv *p;
  576. int i;
  578. /*
  579.  * we need 8-aligned memory ..
  580.  */
  581. ptr = ni65_alloc_mem(dev,"BUFFER",sizeof(struct priv)+8,0);
  582. if(!ptr)
  583. return -ENOMEM;
  585. p = dev->priv = (struct priv *) (((unsigned long) ptr + 7) & ~0x7);
  586. memset((char *) dev->priv,0,sizeof(struct priv));
  587. p->self = ptr;
  589. for(i=0;i<TMDNUM;i++)
  590. {
  591. #ifdef XMT_VIA_SKB
  592. p->tmd_skb[i] = NULL;
  593. #endif
  594. p->tmdbounce[i] = ni65_alloc_mem(dev,"XMIT",T_BUF_SIZE,0);
  595. if(!p->tmdbounce[i]) {
  596. ni65_free_buffer(p);
  597. return -ENOMEM;
  598. }
  599. }
  601. for(i=0;i<RMDNUM;i++)
  602. {
  603. #ifdef RCV_VIA_SKB
  604. p->recv_skb[i] = ni65_alloc_mem(dev,"RECV",R_BUF_SIZE,1);
  605. if(!p->recv_skb[i]) {
  606. ni65_free_buffer(p);
  607. return -ENOMEM;
  608. }
  609. #else
  610. p->recvbounce[i] = ni65_alloc_mem(dev,"RECV",R_BUF_SIZE,0);
  611. if(!p->recvbounce[i]) {
  612. ni65_free_buffer(p);
  613. return -ENOMEM;
  614. }
  615. #endif
  616. }
  618. return 0; /* everything is OK */
  619. }
  621. /*
  622.  * free buffers and private struct
  623.  */
  624. static void ni65_free_buffer(struct priv *p)
  625. {
  626. int i;
  628. if(!p)
  629. return;
  631. for(i=0;i<TMDNUM;i++) {
  632. if(p->tmdbounce[i])
  633. kfree(p->tmdbounce[i]);
  634. #ifdef XMT_VIA_SKB
  635. if(p->tmd_skb[i])
  636. dev_kfree_skb(p->tmd_skb[i]);
  637. #endif
  638. }
  640. for(i=0;i<RMDNUM;i++)
  641. {
  642. #ifdef RCV_VIA_SKB
  643. if(p->recv_skb[i])
  644. dev_kfree_skb(p->recv_skb[i]);
  645. #else
  646. if(p->recvbounce[i])
  647. kfree(p->recvbounce[i]);
  648. #endif
  649. }
  650. if(p->self)
  651. kfree(p->self);
  652. }
  655. /*
  656.  * stop and (re)start lance .. e.g after an error
  657.  */
  658. static void ni65_stop_start(struct net_device *dev,struct priv *p)
  659. {
  660. int csr0 = CSR0_INEA;
  662. writedatareg(CSR0_STOP);
  664. if(debuglevel > 1)
  665. printk("ni65_stop_startn");
  667. if(p->features & INIT_RING_BEFORE_START) {
  668. int i;
  669. #ifdef XMT_VIA_SKB
  670. struct sk_buff *skb_save[TMDNUM];
  671. #endif
  672. unsigned long buffer[TMDNUM];
  673. short blen[TMDNUM];
  675. if(p->xmit_queued) {
  676. while(1) {
  677. if((p->tmdhead[p->tmdlast].u.s.status & XMIT_OWN))
  678. break;
  679. p->tmdlast = (p->tmdlast + 1) & (TMDNUM-1);
  680. if(p->tmdlast == p->tmdnum)
  681. break;
  682. }
  683. }
  685. for(i=0;i<TMDNUM;i++) {
  686. struct tmd *tmdp = p->tmdhead + i;
  687. #ifdef XMT_VIA_SKB
  688. skb_save[i] = p->tmd_skb[i];
  689. #endif
  690. buffer[i] = (u32) bus_to_virt(tmdp->u.buffer);
  691. blen[i] = tmdp->blen;
  692. tmdp->u.s.status = 0x0;
  693. }
  695. for(i=0;i<RMDNUM;i++) {
  696. struct rmd *rmdp = p->rmdhead + i;
  697. rmdp->u.s.status = RCV_OWN;
  698. }
  699. p->tmdnum = p->xmit_queued = 0;
  700. writedatareg(CSR0_STRT | csr0);
  702. for(i=0;i<TMDNUM;i++) {
  703. int num = (i + p->tmdlast) & (TMDNUM-1);
  704. p->tmdhead[i].u.buffer = (u32) virt_to_bus((char *)buffer[num]); /* status is part of buffer field */
  705. p->tmdhead[i].blen = blen[num];
  706. if(p->tmdhead[i].u.s.status & XMIT_OWN) {
  707.  p->tmdnum = (p->tmdnum + 1) & (TMDNUM-1);
  708.  p->xmit_queued = 1;
  709.  writedatareg(CSR0_TDMD | CSR0_INEA | csr0);
  710. }
  711. #ifdef XMT_VIA_SKB
  712. p->tmd_skb[i] = skb_save[num];
  713. #endif
  714. }
  715. p->rmdnum = p->tmdlast = 0;
  716. if(!p->lock)
  717. if (p->tmdnum || !p->xmit_queued)
  718. netif_wake_queue(dev);
  719. dev->trans_start = jiffies;
  720. }
  721. else
  722. writedatareg(CSR0_STRT | csr0);
  723. }
  725. /*
  726.  * init lance (write init-values .. init-buffers) (open-helper)
  727.  */
  728. static int ni65_lance_reinit(struct net_device *dev)
  729. {
  730.  int i;
  731.  struct priv *p = (struct priv *) dev->priv;
  732.  unsigned long flags;
  734.  p->lock = 0;
  735.  p->xmit_queued = 0;
  737.  flags=claim_dma_lock();
  738.  disable_dma(dev->dma); /* I've never worked with dma, but we do it like the packetdriver */
  739.  set_dma_mode(dev->dma,DMA_MODE_CASCADE);
  740.  enable_dma(dev->dma);
  741.  release_dma_lock(flags);
  743.  outw(inw(PORT+L_RESET),PORT+L_RESET); /* first: reset the card */
  744.  if( (i=readreg(CSR0) ) != 0x4)
  745.  {
  746.  printk(KERN_ERR "%s: can't RESET %s card: %04xn",dev->name,
  747. cards[p->cardno].cardname,(int) i);
  748.  flags=claim_dma_lock();
  749.  disable_dma(dev->dma);
  750.  release_dma_lock(flags);
  751.  return 0;
  752.  }
  754.  p->rmdnum = p->tmdnum = p->tmdlast = p->tmdbouncenum = 0;
  755.  for(i=0;i<TMDNUM;i++)
  756.  {
  757.  struct tmd *tmdp = p->tmdhead + i;
  758. #ifdef XMT_VIA_SKB
  759.  if(p->tmd_skb[i]) {
  760.  dev_kfree_skb(p->tmd_skb[i]);
  761.  p->tmd_skb[i] = NULL;
  762.  }
  763. #endif
  764.  tmdp->u.buffer = 0x0;
  765.  tmdp->u.s.status = XMIT_START | XMIT_END;
  766.  tmdp->blen = tmdp->status2 = 0;
  767.  }
  769.  for(i=0;i<RMDNUM;i++)
  770.  {
  771.  struct rmd *rmdp = p->rmdhead + i;
  772. #ifdef RCV_VIA_SKB
  773.  rmdp->u.buffer = (u32) virt_to_bus(p->recv_skb[i]->data);
  774. #else
  775.  rmdp->u.buffer = (u32) virt_to_bus(p->recvbounce[i]);
  776. #endif
  777.  rmdp->blen = -(R_BUF_SIZE-8);
  778.  rmdp->mlen = 0;
  779.  rmdp->u.s.status = RCV_OWN;
  780.  }
  782.  if(dev->flags & IFF_PROMISC)
  783.  ni65_init_lance(p,dev->dev_addr,0x00,M_PROM);
  784.  else if(dev->mc_count || dev->flags & IFF_ALLMULTI)
  785.  ni65_init_lance(p,dev->dev_addr,0xff,0x0);
  786.  else
  787.  ni65_init_lance(p,dev->dev_addr,0x00,0x00);
  789. /*
  790.  * ni65_set_lance_mem() sets L_ADDRREG to CSR0
  791.  * NOW, WE WILL NEVER CHANGE THE L_ADDRREG, CSR0 IS ALWAYS SELECTED
  792.  */
  794.  if(inw(PORT+L_DATAREG) & CSR0_IDON) {
  795.  ni65_set_performance(p);
  796.  /* init OK: start lance , enable interrupts */
  797.  writedatareg(CSR0_CLRALL | CSR0_INEA | CSR0_STRT);
  798.  return 1; /* ->OK */
  799.  }
  800.  printk(KERN_ERR "%s: can't init lance, status: %04xn",dev->name,(int) inw(PORT+L_DATAREG));
  801.  flags=claim_dma_lock();
  802.  disable_dma(dev->dma);
  803.  release_dma_lock(flags);
  804.  return 0; /* ->Error */
  805. }
  807. /*
  808.  * interrupt handler
  809.  */
  810. static void ni65_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  811. {
  812. int csr0 = 0;
  813. struct net_device *dev = dev_id;
  814. struct priv *p;
  815. int bcnt = 32;
  817. p = (struct priv *) dev->priv;
  819. while(--bcnt) {
  820. csr0 = inw(PORT+L_DATAREG);
  822. #if 0
  823. writedatareg( (csr0 & CSR0_CLRALL) ); /* ack interrupts, disable int. */
  824. #else
  825. writedatareg( (csr0 & CSR0_CLRALL) | CSR0_INEA ); /* ack interrupts, interrupts enabled */
  826. #endif
  828. if(!(csr0 & (CSR0_ERR | CSR0_RINT | CSR0_TINT)))
  829. break;
  831. if(csr0 & CSR0_RINT) /* RECV-int? */
  832. ni65_recv_intr(dev,csr0);
  833. if(csr0 & CSR0_TINT) /* XMIT-int? */
  834. ni65_xmit_intr(dev,csr0);
  836. if(csr0 & CSR0_ERR)
  837. {
  838. struct priv *p = (struct priv *) dev->priv;
  839. if(debuglevel > 1)
  840. printk("%s: general error: %04x.n",dev->name,csr0);
  841. if(csr0 & CSR0_BABL)
  842. p->stats.tx_errors++;
  843. if(csr0 & CSR0_MISS) {
  844. int i;
  845. for(i=0;i<RMDNUM;i++)
  846. printk("%02x ",p->rmdhead[i].u.s.status);
  847. printk("n");
  848. p->stats.rx_errors++;
  849. }
  850. if(csr0 & CSR0_MERR) {
  851. if(debuglevel > 1)
  852. printk("%s: Ooops .. memory error: %04x.n",dev->name,csr0);
  853. ni65_stop_start(dev,p);
  854. }
  855. }
  856. }
  858. #ifdef RCV_PARANOIA_CHECK
  859. {
  860.  int j;
  861.  for(j=0;j<RMDNUM;j++)
  862.  {
  863. struct priv *p = (struct priv *) dev->priv;
  864. int i,k,num1,num2;
  865. for(i=RMDNUM-1;i>0;i--) {
  866.  num2 = (p->rmdnum + i) & (RMDNUM-1);
  867.  if(!(p->rmdhead[num2].u.s.status & RCV_OWN))
  868. break;
  869. }
  871. if(i) {
  872. for(k=0;k<RMDNUM;k++) {
  873. num1 = (p->rmdnum + k) & (RMDNUM-1);
  874. if(!(p->rmdhead[num1].u.s.status & RCV_OWN))
  875. break;
  876. }
  877. if(!k)
  878. break;
  880. if(debuglevel > 0)
  881. {
  882. char buf[256],*buf1;
  883. int k;
  884. buf1 = buf;
  885. for(k=0;k<RMDNUM;k++) {
  886. sprintf(buf1,"%02x ",(p->rmdhead[k].u.s.status)); /* & RCV_OWN) ); */
  887. buf1 += 3;
  888. }
  889. *buf1 = 0;
  890. printk(KERN_ERR "%s: Ooops, receive ring corrupted %2d %2d | %sn",dev->name,p->rmdnum,i,buf);
  891. }
  893. p->rmdnum = num1;
  894. ni65_recv_intr(dev,csr0);
  895. if((p->rmdhead[num2].u.s.status & RCV_OWN))
  896. break; /* ok, we are 'in sync' again */
  897. }
  898. else
  899. break;
  900.  }
  901. }
  902. #endif
  904. if( (csr0 & (CSR0_RXON | CSR0_TXON)) != (CSR0_RXON | CSR0_TXON) ) {
  905. printk("%s: RX or TX was offline -> restartn",dev->name);
  906. ni65_stop_start(dev,p);
  907. }
  908. else
  909. writedatareg(CSR0_INEA);
  911. return;
  912. }
  914. /*
  915.  * We have received an Xmit-Interrupt ..
  916.  * send a new packet if necessary
  917.  */
  918. static void ni65_xmit_intr(struct net_device *dev,int csr0)
  919. {
  920. struct priv *p = (struct priv *) dev->priv;
  922. while(p->xmit_queued)
  923. {
  924. struct tmd *tmdp = p->tmdhead + p->tmdlast;
  925. int tmdstat = tmdp->u.s.status;
  927. if(tmdstat & XMIT_OWN)
  928. break;
  930. if(tmdstat & XMIT_ERR)
  931. {
  932. #if 0
  933. if(tmdp->status2 & XMIT_TDRMASK && debuglevel > 3)
  934. printk(KERN_ERR "%s: tdr-problems (e.g. no resistor)n",dev->name);
  935. #endif
  936.  /* checking some errors */
  937. if(tmdp->status2 & XMIT_RTRY)
  938. p->stats.tx_aborted_errors++;
  939. if(tmdp->status2 & XMIT_LCAR)
  940. p->stats.tx_carrier_errors++;
  941. if(tmdp->status2 & (XMIT_BUFF | XMIT_UFLO )) {
  942. /* this stops the xmitter */
  943. p->stats.tx_fifo_errors++;
  944. if(debuglevel > 0)
  945. printk(KERN_ERR "%s: Xmit FIFO/BUFF errorn",dev->name);
  946. if(p->features & INIT_RING_BEFORE_START) {
  947. tmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END; /* test: resend this frame */
  948. ni65_stop_start(dev,p);
  949. break; /* no more Xmit processing .. */
  950. }
  951. else
  952.  ni65_stop_start(dev,p);
  953. }
  954. if(debuglevel > 2)
  955. printk(KERN_ERR "%s: xmit-error: %04x %02x-%04xn",dev->name,csr0,(int) tmdstat,(int) tmdp->status2);
  956. if(!(csr0 & CSR0_BABL)) /* don't count errors twice */
  957. p->stats.tx_errors++;
  958. tmdp->status2 = 0;
  959. }
  960. else {
  961. p->stats.tx_bytes -= (short)(tmdp->blen);
  962. p->stats.tx_packets++;
  963. }
  965. #ifdef XMT_VIA_SKB
  966. if(p->tmd_skb[p->tmdlast]) {
  967.  dev_kfree_skb_irq(p->tmd_skb[p->tmdlast]);
  968.  p->tmd_skb[p->tmdlast] = NULL;
  969. }
  970. #endif
  972. p->tmdlast = (p->tmdlast + 1) & (TMDNUM-1);
  973. if(p->tmdlast == p->tmdnum)
  974. p->xmit_queued = 0;
  975. }
  976. netif_wake_queue(dev);
  977. }
  979. /*
  980.  * We have received a packet
  981.  */
  982. static void ni65_recv_intr(struct net_device *dev,int csr0)
  983. {
  984. struct rmd *rmdp;
  985. int rmdstat,len;
  986. int cnt=0;
  987. struct priv *p = (struct priv *) dev->priv;
  989. rmdp = p->rmdhead + p->rmdnum;
  990. while(!( (rmdstat = rmdp->u.s.status) & RCV_OWN))
  991. {
  992. cnt++;
  993. if( (rmdstat & (RCV_START | RCV_END | RCV_ERR)) != (RCV_START | RCV_END) ) /* error or oversized? */
  994. {
  995. if(!(rmdstat & RCV_ERR)) {
  996. if(rmdstat & RCV_START)
  997. {
  998. p->stats.rx_length_errors++;
  999. printk(KERN_ERR "%s: recv, packet too long: %dn",dev->name,rmdp->mlen & 0x0fff);
  1000. }
  1001. }
  1002. else {
  1003. if(debuglevel > 2)
  1004. printk(KERN_ERR "%s: receive-error: %04x, lance-status: %04x/%04xn",
  1005. dev->name,(int) rmdstat,csr0,(int) inw(PORT+L_DATAREG) );
  1006. if(rmdstat & RCV_FRAM)
  1007. p->stats.rx_frame_errors++;
  1008. if(rmdstat & RCV_OFLO)
  1009. p->stats.rx_over_errors++;
  1010. if(rmdstat & RCV_CRC)
  1011. p->stats.rx_crc_errors++;
  1012. if(rmdstat & RCV_BUF_ERR)
  1013. p->stats.rx_fifo_errors++;
  1014. }
  1015. if(!(csr0 & CSR0_MISS)) /* don't count errors twice */
  1016. p->stats.rx_errors++;
  1017. }
  1018. else if( (len = (rmdp->mlen & 0x0fff) - 4) >= 60)
  1019. {
  1020. #ifdef RCV_VIA_SKB
  1021. struct sk_buff *skb = alloc_skb(R_BUF_SIZE+2+16,GFP_ATOMIC);
  1022. if (skb)
  1023. skb_reserve(skb,16);
  1024. #else
  1025. struct sk_buff *skb = dev_alloc_skb(len+2);
  1026. #endif
  1027. if(skb)
  1028. {
  1029. skb_reserve(skb,2);
  1030. skb->dev = dev;
  1031. #ifdef RCV_VIA_SKB
  1032. if( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000) {
  1033. skb_put(skb,len);
  1034. eth_copy_and_sum(skb, (unsigned char *)(p->recv_skb[p->rmdnum]->data),len,0);
  1035. }
  1036. else {
  1037. struct sk_buff *skb1 = p->recv_skb[p->rmdnum];
  1038. skb_put(skb,R_BUF_SIZE);
  1039. p->recv_skb[p->rmdnum] = skb;
  1040. rmdp->u.buffer = (u32) virt_to_bus(skb->data);
  1041. skb = skb1;
  1042. skb_trim(skb,len);
  1043. }
  1044. #else
  1045. skb_put(skb,len);
  1046. eth_copy_and_sum(skb, (unsigned char *) p->recvbounce[p->rmdnum],len,0);
  1047. #endif
  1048. p->stats.rx_packets++;
  1049. p->stats.rx_bytes += len;
  1050. skb->protocol=eth_type_trans(skb,dev);
  1051. netif_rx(skb);
  1052. dev->last_rx = jiffies;
  1053. }
  1054. else
  1055. {
  1056. printk(KERN_ERR "%s: can't alloc new sk_buffn",dev->name);
  1057. p->stats.rx_dropped++;
  1058. }
  1059. }
  1060. else {
  1061. printk(KERN_INFO "%s: received runt packetn",dev->name);
  1062. p->stats.rx_errors++;
  1063. }
  1064. rmdp->blen = -(R_BUF_SIZE-8);
  1065. rmdp->mlen = 0;
  1066. rmdp->u.s.status = RCV_OWN; /* change owner */
  1067. p->rmdnum = (p->rmdnum + 1) & (RMDNUM-1);
  1068. rmdp = p->rmdhead + p->rmdnum;
  1069. }
  1070. }
  1072. /*
  1073.  * kick xmitter ..
  1074.  */
  1075.  
  1076. static void ni65_timeout(struct net_device *dev)
  1077. {
  1078. int i;
  1079. struct priv *p = (struct priv *) dev->priv;
  1081. printk(KERN_ERR "%s: xmitter timed out, try to restart!n",dev->name);
  1082. for(i=0;i<TMDNUM;i++)
  1083. printk("%02x ",p->tmdhead[i].u.s.status);
  1084. printk("n");
  1085. ni65_lance_reinit(dev);
  1086. dev->trans_start = jiffies;
  1087. netif_wake_queue(dev);
  1088. }
  1090. /*
  1091.  * Send a packet
  1092.  */
  1094. static int ni65_send_packet(struct sk_buff *skb, struct net_device *dev)
  1095. {
  1096. struct priv *p = (struct priv *) dev->priv;
  1098. netif_stop_queue(dev);
  1100. if (test_and_set_bit(0, (void*)&p->lock)) {
  1101. printk(KERN_ERR "%s: Queue was locked.n", dev->name);
  1102. return 1;
  1103. }
  1105. {
  1106. short len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  1107. struct tmd *tmdp;
  1108. unsigned long flags;
  1110. #ifdef XMT_VIA_SKB
  1111. if( (unsigned long) (skb->data + skb->len) > 0x1000000) {
  1112. #endif
  1114. memcpy((char *) p->tmdbounce[p->tmdbouncenum] ,(char *)skb->data,
  1115.  (skb->len > T_BUF_SIZE) ? T_BUF_SIZE : skb->len);
  1116. dev_kfree_skb (skb);
  1118. save_flags(flags);
  1119. cli();
  1121. tmdp = p->tmdhead + p->tmdnum;
  1122. tmdp->u.buffer = (u32) virt_to_bus(p->tmdbounce[p->tmdbouncenum]);
  1123. p->tmdbouncenum = (p->tmdbouncenum + 1) & (TMDNUM - 1);
  1125. #ifdef XMT_VIA_SKB
  1126. }
  1127. else {
  1128. save_flags(flags);
  1129. cli();
  1131. tmdp = p->tmdhead + p->tmdnum;
  1132. tmdp->u.buffer = (u32) virt_to_bus(skb->data);
  1133. p->tmd_skb[p->tmdnum] = skb;
  1134. }
  1135. #endif
  1136. tmdp->blen = -len;
  1138. tmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END;
  1139. writedatareg(CSR0_TDMD | CSR0_INEA); /* enable xmit & interrupt */
  1141. p->xmit_queued = 1;
  1142. p->tmdnum = (p->tmdnum + 1) & (TMDNUM-1);
  1144. if(p->tmdnum != p->tmdlast)
  1145. netif_wake_queue(dev);
  1147. p->lock = 0;
  1148. dev->trans_start = jiffies;
  1150. restore_flags(flags);
  1151. }
  1153. return 0;
  1154. }
  1156. static struct net_device_stats *ni65_get_stats(struct net_device *dev)
  1157. {
  1159. #if 0
  1160. int i;
  1161. struct priv *p = (struct priv *) dev->priv;
  1162. for(i=0;i<RMDNUM;i++)
  1163. {
  1164. struct rmd *rmdp = p->rmdhead + ((p->rmdnum + i) & (RMDNUM-1));
  1165. printk("%02x ",rmdp->u.s.status);
  1166. }
  1167. printk("n");
  1168. #endif
  1170. return &((struct priv *) dev->priv)->stats;
  1171. }
  1173. static void set_multicast_list(struct net_device *dev)
  1174. {
  1175. if(!ni65_lance_reinit(dev))
  1176. printk(KERN_ERR "%s: Can't switch card into MC mode!n",dev->name);
  1177. netif_wake_queue(dev);
  1178. }
  1180. #ifdef MODULE
  1181. static struct net_device dev_ni65 = { base_addr: 0x360, irq: 9, init: ni65_probe };
  1183. /* set: io,irq,dma or set it when calling insmod */
  1184. static int irq;
  1185. static int io;
  1186. static int dma;
  1188. MODULE_PARM(irq, "i");
  1189. MODULE_PARM(io, "i");
  1190. MODULE_PARM(dma, "i");
  1191. MODULE_PARM_DESC(irq, "ni6510 IRQ number (ignored for some cards)");
  1192. MODULE_PARM_DESC(io, "ni6510 I/O base address");
  1193. MODULE_PARM_DESC(dma, "ni6510 ISA DMA channel (ignored for some cards)");
  1195. int init_module(void)
  1196. {
  1197. dev_ni65.irq = irq;
  1198. dev_ni65.dma = dma;
  1199. dev_ni65.base_addr = io;
  1200. if (register_netdev(&dev_ni65) != 0)
  1201. return -EIO;
  1202. return 0;
  1203. }
  1205. void cleanup_module(void)
  1206. {
  1207. struct priv *p;
  1208. p = (struct priv *) dev_ni65.priv;
  1209. if(!p) {
  1210. printk("Ooops .. no private structn");
  1211. return;
  1212. }
  1213. disable_dma(dev_ni65.dma);
  1214. free_dma(dev_ni65.dma);
  1215. unregister_netdev(&dev_ni65);
  1216. release_region(dev_ni65.base_addr,cards[p->cardno].total_size);
  1217. ni65_free_buffer(p);
  1218. dev_ni65.priv = NULL;
  1219. }
  1220. #endif /* MODULE */
  1221. MODULE_LICENSE("GPL");
  1223. /*
  1224.  * END of ni65.c
  1225.  */