Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
seeq8005.c
Go to the documentation of this file.
1 /* seeq8005.c: A network driver for linux. */
2 /*
3  Based on skeleton.c,
4  Written 1993-94 by Donald Becker.
5  See the skeleton.c file for further copyright information.
6 
7  This software may be used and distributed according to the terms
8  of the GNU General Public License, incorporated herein by reference.
9 
10  The author may be reached as [email protected]
11 
12  This file is a network device driver for the SEEQ 8005 chipset and
13  the Linux operating system.
14 
15 */
16 
17 static const char version[] =
18  "seeq8005.c:v1.00 8/07/95 Hamish Coleman ([email protected])\n";
19 
20 /*
21  Sources:
22  SEEQ 8005 databook
23 
24  Version history:
25  1.00 Public release. cosmetic changes (no warnings now)
26  0.68 Turning per- packet,interrupt debug messages off - testing for release.
27  0.67 timing problems/bad buffer reads seem to be fixed now
28  0.63 *!@$ protocol=eth_type_trans -- now packets flow
29  0.56 Send working
30  0.48 Receive working
31 */
32 
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/types.h>
36 #include <linux/fcntl.h>
37 #include <linux/interrupt.h>
38 #include <linux/ioport.h>
39 #include <linux/in.h>
40 #include <linux/string.h>
41 #include <linux/init.h>
42 #include <linux/delay.h>
43 #include <linux/errno.h>
44 #include <linux/netdevice.h>
45 #include <linux/etherdevice.h>
46 #include <linux/skbuff.h>
47 #include <linux/bitops.h>
48 #include <linux/jiffies.h>
49 
50 #include <asm/io.h>
51 #include <asm/dma.h>
52 
53 #include "seeq8005.h"
54 
55 /* First, a few definitions that the brave might change. */
56 /* A zero-terminated list of I/O addresses to be probed. */
57 static unsigned int seeq8005_portlist[] __initdata =
58  { 0x300, 0x320, 0x340, 0x360, 0};
59 
60 /* use 0 for production, 1 for verification, >2 for debug */
61 #ifndef NET_DEBUG
62 #define NET_DEBUG 1
63 #endif
64 static unsigned int net_debug = NET_DEBUG;
65 
66 /* Information that need to be kept for each board. */
67 struct net_local {
68  unsigned short receive_ptr; /* What address in packet memory do we expect a recv_pkt_header? */
69  long open_time; /* Useless example local info. */
70 };
71 
72 /* The station (ethernet) address prefix, used for IDing the board. */
73 #define SA_ADDR0 0x00
74 #define SA_ADDR1 0x80
75 #define SA_ADDR2 0x4b
76 
77 /* Index to functions, as function prototypes. */
78 
79 static int seeq8005_probe1(struct net_device *dev, int ioaddr);
80 static int seeq8005_open(struct net_device *dev);
81 static void seeq8005_timeout(struct net_device *dev);
82 static netdev_tx_t seeq8005_send_packet(struct sk_buff *skb,
83  struct net_device *dev);
84 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id);
85 static void seeq8005_rx(struct net_device *dev);
86 static int seeq8005_close(struct net_device *dev);
87 static void set_multicast_list(struct net_device *dev);
88 
89 /* Example routines you must write ;->. */
90 #define tx_done(dev) (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
91 static void hardware_send_packet(struct net_device *dev, char *buf, int length);
92 extern void seeq8005_init(struct net_device *dev, int startp);
93 static inline void wait_for_buffer(struct net_device *dev);
94 
95 
96 /* Check for a network adaptor of this type, and return '0' iff one exists.
97  If dev->base_addr == 0, probe all likely locations.
98  If dev->base_addr == 1, always return failure.
99  */
100 
101 static int io = 0x320;
102 static int irq = 10;
103 
105 {
106  struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
107  unsigned *port;
108  int err = 0;
109 
110  if (!dev)
111  return ERR_PTR(-ENODEV);
112 
113  if (unit >= 0) {
114  sprintf(dev->name, "eth%d", unit);
116  io = dev->base_addr;
117  irq = dev->irq;
118  }
119 
120  if (io > 0x1ff) { /* Check a single specified location. */
121  err = seeq8005_probe1(dev, io);
122  } else if (io != 0) { /* Don't probe at all. */
123  err = -ENXIO;
124  } else {
125  for (port = seeq8005_portlist; *port; port++) {
126  if (seeq8005_probe1(dev, *port) == 0)
127  break;
128  }
129  if (!*port)
130  err = -ENODEV;
131  }
132  if (err)
133  goto out;
134  err = register_netdev(dev);
135  if (err)
136  goto out1;
137  return dev;
138 out1:
140 out:
141  free_netdev(dev);
142  return ERR_PTR(err);
143 }
144 
145 static const struct net_device_ops seeq8005_netdev_ops = {
146  .ndo_open = seeq8005_open,
147  .ndo_stop = seeq8005_close,
148  .ndo_start_xmit = seeq8005_send_packet,
149  .ndo_tx_timeout = seeq8005_timeout,
150  .ndo_set_rx_mode = set_multicast_list,
151  .ndo_change_mtu = eth_change_mtu,
152  .ndo_set_mac_address = eth_mac_addr,
153  .ndo_validate_addr = eth_validate_addr,
154 };
155 
156 /* This is the real probe routine. Linux has a history of friendly device
157  probes on the ISA bus. A good device probes avoids doing writes, and
158  verifies that the correct device exists and functions. */
159 
160 static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
161 {
162  static unsigned version_printed;
163  int i,j;
164  unsigned char SA_prom[32];
165  int old_cfg1;
166  int old_cfg2;
167  int old_stat;
168  int old_dmaar;
169  int old_rear;
170  int retval;
171 
172  if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
173  return -ENODEV;
174 
175  if (net_debug>1)
176  printk("seeq8005: probing at 0x%x\n",ioaddr);
177 
178  old_stat = inw(SEEQ_STATUS); /* read status register */
179  if (old_stat == 0xffff) {
180  retval = -ENODEV;
181  goto out; /* assume that 0xffff == no device */
182  }
183  if ( (old_stat & 0x1800) != 0x1800 ) { /* assume that unused bits are 1, as my manual says */
184  if (net_debug>1) {
185  printk("seeq8005: reserved stat bits != 0x1800\n");
186  printk(" == 0x%04x\n",old_stat);
187  }
188  retval = -ENODEV;
189  goto out;
190  }
191 
192  old_rear = inw(SEEQ_REA);
193  if (old_rear == 0xffff) {
194  outw(0,SEEQ_REA);
195  if (inw(SEEQ_REA) == 0xffff) { /* assume that 0xffff == no device */
196  retval = -ENODEV;
197  goto out;
198  }
199  } else if ((old_rear & 0xff00) != 0xff00) { /* assume that unused bits are 1 */
200  if (net_debug>1) {
201  printk("seeq8005: unused rear bits != 0xff00\n");
202  printk(" == 0x%04x\n",old_rear);
203  }
204  retval = -ENODEV;
205  goto out;
206  }
207 
208  old_cfg2 = inw(SEEQ_CFG2); /* read CFG2 register */
209  old_cfg1 = inw(SEEQ_CFG1);
210  old_dmaar = inw(SEEQ_DMAAR);
211 
212  if (net_debug>4) {
213  printk("seeq8005: stat = 0x%04x\n",old_stat);
214  printk("seeq8005: cfg1 = 0x%04x\n",old_cfg1);
215  printk("seeq8005: cfg2 = 0x%04x\n",old_cfg2);
216  printk("seeq8005: raer = 0x%04x\n",old_rear);
217  printk("seeq8005: dmaar= 0x%04x\n",old_dmaar);
218  }
219 
220  outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD); /* setup for reading PROM */
221  outw( 0, SEEQ_DMAAR); /* set starting PROM address */
222  outw( SEEQCFG1_BUFFER_PROM, SEEQ_CFG1); /* set buffer to look at PROM */
223 
224 
225  j=0;
226  for(i=0; i <32; i++) {
227  j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
228  }
229 
230 #if 0
231  /* untested because I only have the one card */
232  if ( (j&0xff) != 0 ) { /* checksum appears to be 8bit = 0 */
233  if (net_debug>1) { /* check this before deciding that we have a card */
234  printk("seeq8005: prom sum error\n");
235  }
236  outw( old_stat, SEEQ_STATUS);
237  outw( old_dmaar, SEEQ_DMAAR);
238  outw( old_cfg1, SEEQ_CFG1);
239  retval = -ENODEV;
240  goto out;
241  }
242 #endif
243 
244  outw( SEEQCFG2_RESET, SEEQ_CFG2); /* reset the card */
245  udelay(5);
247 
248  if (net_debug) {
249  printk("seeq8005: prom sum = 0x%08x\n",j);
250  for(j=0; j<32; j+=16) {
251  printk("seeq8005: prom %02x: ",j);
252  for(i=0;i<16;i++) {
253  printk("%02x ",SA_prom[j|i]);
254  }
255  printk(" ");
256  for(i=0;i<16;i++) {
257  if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
258  printk("%c", SA_prom[j|i]);
259  } else {
260  printk(" ");
261  }
262  }
263  printk("\n");
264  }
265  }
266 
267 #if 0
268  /*
269  * testing the packet buffer memory doesn't work yet
270  * but all other buffer accesses do
271  * - fixing is not a priority
272  */
273  if (net_debug>1) { /* test packet buffer memory */
274  printk("seeq8005: testing packet buffer ... ");
277  outw( 0 , SEEQ_DMAAR);
278  for(i=0;i<32768;i++) {
279  outw(0x5a5a, SEEQ_BUFFER);
280  }
281  j=jiffies+HZ;
282  while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
283  mb();
284  outw( 0 , SEEQ_DMAAR);
285  while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
286  mb();
287  if ( (inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
290  j=0;
291  for(i=0;i<32768;i++) {
292  if (inw(SEEQ_BUFFER) != 0x5a5a)
293  j++;
294  }
295  if (j) {
296  printk("%i\n",j);
297  } else {
298  printk("ok.\n");
299  }
300  }
301 #endif
302 
303  if (net_debug && version_printed++ == 0)
304  printk(version);
305 
306  printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
307 
308  /* Fill in the 'dev' fields. */
309  dev->base_addr = ioaddr;
310  dev->irq = irq;
311 
312  /* Retrieve and print the ethernet address. */
313  for (i = 0; i < 6; i++)
314  dev->dev_addr[i] = SA_prom[i+6];
315  printk("%pM", dev->dev_addr);
316 
317  if (dev->irq == 0xff)
318  ; /* Do nothing: a user-level program will set it. */
319  else if (dev->irq < 2) { /* "Auto-IRQ" */
320  unsigned long cookie = probe_irq_on();
321 
323 
324  dev->irq = probe_irq_off(cookie);
325 
326  if (net_debug >= 2)
327  printk(" autoirq is %d\n", dev->irq);
328  } else if (dev->irq == 2)
329  /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
330  * or don't know which one to set.
331  */
332  dev->irq = 9;
333 
334 #if 0
335  {
336  int irqval = request_irq(dev->irq, seeq8005_interrupt, 0, "seeq8005", dev);
337  if (irqval) {
338  printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
339  dev->irq, irqval);
340  retval = -EAGAIN;
341  goto out;
342  }
343  }
344 #endif
345  dev->netdev_ops = &seeq8005_netdev_ops;
346  dev->watchdog_timeo = HZ/20;
347  dev->flags &= ~IFF_MULTICAST;
348 
349  return 0;
350 out:
352  return retval;
353 }
354 
355 
356 /* Open/initialize the board. This is called (in the current kernel)
357  sometime after booting when the 'ifconfig' program is run.
358 
359  This routine should set everything up anew at each open, even
360  registers that "should" only need to be set once at boot, so that
361  there is non-reboot way to recover if something goes wrong.
362  */
363 static int seeq8005_open(struct net_device *dev)
364 {
365  struct net_local *lp = netdev_priv(dev);
366 
367  {
368  int irqval = request_irq(dev->irq, seeq8005_interrupt, 0, "seeq8005", dev);
369  if (irqval) {
370  printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
371  dev->irq, irqval);
372  return -EAGAIN;
373  }
374  }
375 
376  /* Reset the hardware here. Don't forget to set the station address. */
377  seeq8005_init(dev, 1);
378 
379  lp->open_time = jiffies;
380 
381  netif_start_queue(dev);
382  return 0;
383 }
384 
385 static void seeq8005_timeout(struct net_device *dev)
386 {
387  int ioaddr = dev->base_addr;
388  printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
389  tx_done(dev) ? "IRQ conflict" : "network cable problem");
390  /* Try to restart the adaptor. */
391  seeq8005_init(dev, 1);
392  dev->trans_start = jiffies; /* prevent tx timeout */
393  netif_wake_queue(dev);
394 }
395 
396 static netdev_tx_t seeq8005_send_packet(struct sk_buff *skb,
397  struct net_device *dev)
398 {
399  short length = skb->len;
400  unsigned char *buf;
401 
402  if (length < ETH_ZLEN) {
403  if (skb_padto(skb, ETH_ZLEN))
404  return NETDEV_TX_OK;
405  length = ETH_ZLEN;
406  }
407  buf = skb->data;
408 
409  /* Block a timer-based transmit from overlapping */
410  netif_stop_queue(dev);
411 
412  hardware_send_packet(dev, buf, length);
413  dev->stats.tx_bytes += length;
414  dev_kfree_skb (skb);
415  /* You might need to clean up and record Tx statistics here. */
416 
417  return NETDEV_TX_OK;
418 }
419 
420 /*
421  * wait_for_buffer
422  *
423  * This routine waits for the SEEQ chip to assert that the FIFO is ready
424  * by checking for a window interrupt, and then clearing it. This has to
425  * occur in the interrupt handler!
426  */
427 inline void wait_for_buffer(struct net_device * dev)
428 {
429  int ioaddr = dev->base_addr;
430  unsigned long tmp;
431  int status;
432 
433  tmp = jiffies + HZ;
434  while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
435  cpu_relax();
436 
437  if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
439 }
440 
441 /* The typical workload of the driver:
442  Handle the network interface interrupts. */
443 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id)
444 {
445  struct net_device *dev = dev_id;
446  struct net_local *lp;
447  int ioaddr, status, boguscount = 0;
448  int handled = 0;
449 
450  ioaddr = dev->base_addr;
451  lp = netdev_priv(dev);
452 
453  status = inw(SEEQ_STATUS);
454  do {
455  if (net_debug >2) {
456  printk("%s: int, status=0x%04x\n",dev->name,status);
457  }
458 
459  if (status & SEEQSTAT_WINDOW_INT) {
460  handled = 1;
462  if (net_debug) {
463  printk("%s: window int!\n",dev->name);
464  }
465  }
466  if (status & SEEQSTAT_TX_INT) {
467  handled = 1;
469  dev->stats.tx_packets++;
470  netif_wake_queue(dev); /* Inform upper layers. */
471  }
472  if (status & SEEQSTAT_RX_INT) {
473  handled = 1;
474  /* Got a packet(s). */
475  seeq8005_rx(dev);
476  }
477  status = inw(SEEQ_STATUS);
478  } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
479 
480  if(net_debug>2) {
481  printk("%s: eoi\n",dev->name);
482  }
483  return IRQ_RETVAL(handled);
484 }
485 
486 /* We have a good packet(s), get it/them out of the buffers. */
487 static void seeq8005_rx(struct net_device *dev)
488 {
489  struct net_local *lp = netdev_priv(dev);
490  int boguscount = 10;
491  int pkt_hdr;
492  int ioaddr = dev->base_addr;
493 
494  do {
495  int next_packet;
496  int pkt_len;
497  int i;
498  int status;
499 
500  status = inw(SEEQ_STATUS);
501  outw( lp->receive_ptr, SEEQ_DMAAR);
503  wait_for_buffer(dev);
504  next_packet = ntohs(inw(SEEQ_BUFFER));
505  pkt_hdr = inw(SEEQ_BUFFER);
506 
507  if (net_debug>2) {
508  printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
509  }
510 
511  if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) { /* Read all the frames? */
512  return; /* Done for now */
513  }
514 
515  if ((pkt_hdr & SEEQPKTS_DONE)==0)
516  break;
517 
518  if (next_packet < lp->receive_ptr) {
519  pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
520  } else {
521  pkt_len = next_packet - lp->receive_ptr - 4;
522  }
523 
524  if (next_packet < ((DEFAULT_TEA+1)<<8)) { /* is the next_packet address sane? */
525  printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
526  seeq8005_init(dev,1);
527  return;
528  }
529 
530  lp->receive_ptr = next_packet;
531 
532  if (net_debug>2) {
533  printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
534  }
535 
536  if (pkt_hdr & SEEQPKTS_ANY_ERROR) { /* There was an error. */
537  dev->stats.rx_errors++;
538  if (pkt_hdr & SEEQPKTS_SHORT) dev->stats.rx_frame_errors++;
539  if (pkt_hdr & SEEQPKTS_DRIB) dev->stats.rx_frame_errors++;
540  if (pkt_hdr & SEEQPKTS_OVERSIZE) dev->stats.rx_over_errors++;
541  if (pkt_hdr & SEEQPKTS_CRC_ERR) dev->stats.rx_crc_errors++;
542  /* skip over this packet */
544  outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
545  } else {
546  /* Malloc up new buffer. */
547  struct sk_buff *skb;
548  unsigned char *buf;
549 
550  skb = netdev_alloc_skb(dev, pkt_len);
551  if (skb == NULL) {
552  printk("%s: Memory squeeze, dropping packet.\n", dev->name);
553  dev->stats.rx_dropped++;
554  break;
555  }
556  skb_reserve(skb, 2); /* align data on 16 byte */
557  buf = skb_put(skb,pkt_len);
558 
559  insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
560 
561  if (net_debug>2) {
562  char * p = buf;
563  printk("%s: recv ",dev->name);
564  for(i=0;i<14;i++) {
565  printk("%02x ",*(p++)&0xff);
566  }
567  printk("\n");
568  }
569 
570  skb->protocol=eth_type_trans(skb,dev);
571  netif_rx(skb);
572  dev->stats.rx_packets++;
573  dev->stats.rx_bytes += pkt_len;
574  }
575  } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
576 
577  /* If any worth-while packets have been received, netif_rx()
578  has done a mark_bh(NET_BH) for us and will work on them
579  when we get to the bottom-half routine. */
580 }
581 
582 /* The inverse routine to net_open(). */
583 static int seeq8005_close(struct net_device *dev)
584 {
585  struct net_local *lp = netdev_priv(dev);
586  int ioaddr = dev->base_addr;
587 
588  lp->open_time = 0;
589 
590  netif_stop_queue(dev);
591 
592  /* Flush the Tx and disable Rx here. */
594 
595  free_irq(dev->irq, dev);
596 
597  /* Update the statistics here. */
598 
599  return 0;
600 
601 }
602 
603 /* Set or clear the multicast filter for this adaptor.
604  num_addrs == -1 Promiscuous mode, receive all packets
605  num_addrs == 0 Normal mode, clear multicast list
606  num_addrs > 0 Multicast mode, receive normal and MC packets, and do
607  best-effort filtering.
608  */
609 static void set_multicast_list(struct net_device *dev)
610 {
611 /*
612  * I _could_ do up to 6 addresses here, but won't (yet?)
613  */
614 
615 #if 0
616  int ioaddr = dev->base_addr;
617 /*
618  * hmm, not even sure if my matching works _anyway_ - seem to be receiving
619  * _everything_ . . .
620  */
621 
622  if (num_addrs) { /* Enable promiscuous mode */
624  dev->flags|=IFF_PROMISC;
625  } else { /* Disable promiscuous mode, use normal mode */
627  }
628 #endif
629 }
630 
631 void seeq8005_init(struct net_device *dev, int startp)
632 {
633  struct net_local *lp = netdev_priv(dev);
634  int ioaddr = dev->base_addr;
635  int i;
636 
637  outw(SEEQCFG2_RESET, SEEQ_CFG2); /* reset device */
638  udelay(5);
639 
641  outw( 0, SEEQ_DMAAR); /* load start address into both low and high byte */
642 /* wait_for_buffer(dev); */ /* I think that you only need a wait for memory buffer */
644 
645  for(i=0;i<6;i++) { /* set Station address */
646  outb(dev->dev_addr[i], SEEQ_BUFFER);
647  udelay(2);
648  }
649 
650  outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1); /* set xmit end area pointer to 16K */
651  outb( DEFAULT_TEA, SEEQ_BUFFER); /* this gives us 16K of send buffer and 48K of recv buffer */
652 
653  lp->receive_ptr = (DEFAULT_TEA+1)<<8; /* so we can find our packet_header */
654  outw( lp->receive_ptr, SEEQ_RPR); /* Receive Pointer Register is set to recv buffer memory */
655 
656  outw( 0x00ff, SEEQ_REA); /* Receive Area End */
657 
658  if (net_debug>4) {
659  printk("%s: SA0 = ",dev->name);
660 
662  outw( 0, SEEQ_DMAAR);
664 
665  for(i=0;i<6;i++) {
666  printk("%02x ",inb(SEEQ_BUFFER));
667  }
668  printk("\n");
669  }
670 
674 
675  if (net_debug>4) {
676  int old_cfg1;
677  old_cfg1 = inw(SEEQ_CFG1);
678  printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
679  printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
680  printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
681  printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
682  printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
683 
684  }
685 }
686 
687 
688 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
689 {
690  int ioaddr = dev->base_addr;
691  int status = inw(SEEQ_STATUS);
692  int transmit_ptr = 0;
693  unsigned long tmp;
694 
695  if (net_debug>4) {
696  printk("%s: send 0x%04x\n",dev->name,length);
697  }
698 
699  /* Set FIFO to writemode and set packet-buffer address */
701  outw( transmit_ptr, SEEQ_DMAAR);
702 
703  /* output SEEQ Packet header barfage */
704  outw( htons(length + 4), SEEQ_BUFFER);
706 
707  /* blat the buffer */
708  outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
709  /* paranoia !! */
710  outw( 0, SEEQ_BUFFER);
711  outw( 0, SEEQ_BUFFER);
712 
713  /* set address of start of transmit chain */
714  outw( transmit_ptr, SEEQ_TPR);
715 
716  /* drain FIFO */
717  tmp = jiffies;
718  while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && time_before(jiffies, tmp + HZ))
719  mb();
720 
721  /* doit ! */
723 
724 }
725 
726 
727 #ifdef MODULE
728 
729 static struct net_device *dev_seeq;
730 MODULE_LICENSE("GPL");
731 module_param(io, int, 0);
732 module_param(irq, int, 0);
733 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
734 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
735 
736 int __init init_module(void)
737 {
738  dev_seeq = seeq8005_probe(-1);
739  return PTR_RET(dev_seeq);
740 }
741 
742 void __exit cleanup_module(void)
743 {
744  unregister_netdev(dev_seeq);
746  free_netdev(dev_seeq);
747 }
748 
749 #endif /* MODULE */