1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17static const char version[] =
18 "seeq8005.c:v1.00 8/07/95 Hamish Coleman (hamish@zot.apana.org.au)\n";
19
20
21
22
23
24
25
26
27
28
29
30
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/slab.h>
41#include <linux/string.h>
42#include <linux/init.h>
43#include <linux/delay.h>
44#include <linux/errno.h>
45#include <linux/netdevice.h>
46#include <linux/etherdevice.h>
47#include <linux/skbuff.h>
48#include <linux/bitops.h>
49#include <linux/jiffies.h>
50
51#include <asm/system.h>
52#include <asm/io.h>
53#include <asm/dma.h>
54
55#include "seeq8005.h"
56
57
58
59static unsigned int seeq8005_portlist[] __initdata =
60 { 0x300, 0x320, 0x340, 0x360, 0};
61
62
63#ifndef NET_DEBUG
64#define NET_DEBUG 1
65#endif
66static unsigned int net_debug = NET_DEBUG;
67
68
69struct net_local {
70 unsigned short receive_ptr;
71 long open_time;
72};
73
74
75#define SA_ADDR0 0x00
76#define SA_ADDR1 0x80
77#define SA_ADDR2 0x4b
78
79
80
81static int seeq8005_probe1(struct net_device *dev, int ioaddr);
82static int seeq8005_open(struct net_device *dev);
83static void seeq8005_timeout(struct net_device *dev);
84static netdev_tx_t seeq8005_send_packet(struct sk_buff *skb,
85 struct net_device *dev);
86static irqreturn_t seeq8005_interrupt(int irq, void *dev_id);
87static void seeq8005_rx(struct net_device *dev);
88static int seeq8005_close(struct net_device *dev);
89static void set_multicast_list(struct net_device *dev);
90
91
92#define tx_done(dev) (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
93static void hardware_send_packet(struct net_device *dev, char *buf, int length);
94extern void seeq8005_init(struct net_device *dev, int startp);
95static inline void wait_for_buffer(struct net_device *dev);
96
97
98
99
100
101
102
103static int io = 0x320;
104static int irq = 10;
105
106struct net_device * __init seeq8005_probe(int unit)
107{
108 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
109 unsigned *port;
110 int err = 0;
111
112 if (!dev)
113 return ERR_PTR(-ENODEV);
114
115 if (unit >= 0) {
116 sprintf(dev->name, "eth%d", unit);
117 netdev_boot_setup_check(dev);
118 io = dev->base_addr;
119 irq = dev->irq;
120 }
121
122 if (io > 0x1ff) {
123 err = seeq8005_probe1(dev, io);
124 } else if (io != 0) {
125 err = -ENXIO;
126 } else {
127 for (port = seeq8005_portlist; *port; port++) {
128 if (seeq8005_probe1(dev, *port) == 0)
129 break;
130 }
131 if (!*port)
132 err = -ENODEV;
133 }
134 if (err)
135 goto out;
136 err = register_netdev(dev);
137 if (err)
138 goto out1;
139 return dev;
140out1:
141 release_region(dev->base_addr, SEEQ8005_IO_EXTENT);
142out:
143 free_netdev(dev);
144 return ERR_PTR(err);
145}
146
147static const struct net_device_ops seeq8005_netdev_ops = {
148 .ndo_open = seeq8005_open,
149 .ndo_stop = seeq8005_close,
150 .ndo_start_xmit = seeq8005_send_packet,
151 .ndo_tx_timeout = seeq8005_timeout,
152 .ndo_set_multicast_list = set_multicast_list,
153 .ndo_change_mtu = eth_change_mtu,
154 .ndo_set_mac_address = eth_mac_addr,
155 .ndo_validate_addr = eth_validate_addr,
156};
157
158
159
160
161
162static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
163{
164 static unsigned version_printed;
165 int i,j;
166 unsigned char SA_prom[32];
167 int old_cfg1;
168 int old_cfg2;
169 int old_stat;
170 int old_dmaar;
171 int old_rear;
172 int retval;
173
174 if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
175 return -ENODEV;
176
177 if (net_debug>1)
178 printk("seeq8005: probing at 0x%x\n",ioaddr);
179
180 old_stat = inw(SEEQ_STATUS);
181 if (old_stat == 0xffff) {
182 retval = -ENODEV;
183 goto out;
184 }
185 if ( (old_stat & 0x1800) != 0x1800 ) {
186 if (net_debug>1) {
187 printk("seeq8005: reserved stat bits != 0x1800\n");
188 printk(" == 0x%04x\n",old_stat);
189 }
190 retval = -ENODEV;
191 goto out;
192 }
193
194 old_rear = inw(SEEQ_REA);
195 if (old_rear == 0xffff) {
196 outw(0,SEEQ_REA);
197 if (inw(SEEQ_REA) == 0xffff) {
198 retval = -ENODEV;
199 goto out;
200 }
201 } else if ((old_rear & 0xff00) != 0xff00) {
202 if (net_debug>1) {
203 printk("seeq8005: unused rear bits != 0xff00\n");
204 printk(" == 0x%04x\n",old_rear);
205 }
206 retval = -ENODEV;
207 goto out;
208 }
209
210 old_cfg2 = inw(SEEQ_CFG2);
211 old_cfg1 = inw(SEEQ_CFG1);
212 old_dmaar = inw(SEEQ_DMAAR);
213
214 if (net_debug>4) {
215 printk("seeq8005: stat = 0x%04x\n",old_stat);
216 printk("seeq8005: cfg1 = 0x%04x\n",old_cfg1);
217 printk("seeq8005: cfg2 = 0x%04x\n",old_cfg2);
218 printk("seeq8005: raer = 0x%04x\n",old_rear);
219 printk("seeq8005: dmaar= 0x%04x\n",old_dmaar);
220 }
221
222 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
223 outw( 0, SEEQ_DMAAR);
224 outw( SEEQCFG1_BUFFER_PROM, SEEQ_CFG1);
225
226
227 j=0;
228 for(i=0; i <32; i++) {
229 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
230 }
231
232#if 0
233
234 if ( (j&0xff) != 0 ) {
235 if (net_debug>1) {
236 printk("seeq8005: prom sum error\n");
237 }
238 outw( old_stat, SEEQ_STATUS);
239 outw( old_dmaar, SEEQ_DMAAR);
240 outw( old_cfg1, SEEQ_CFG1);
241 retval = -ENODEV;
242 goto out;
243 }
244#endif
245
246 outw( SEEQCFG2_RESET, SEEQ_CFG2);
247 udelay(5);
248 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
249
250 if (net_debug) {
251 printk("seeq8005: prom sum = 0x%08x\n",j);
252 for(j=0; j<32; j+=16) {
253 printk("seeq8005: prom %02x: ",j);
254 for(i=0;i<16;i++) {
255 printk("%02x ",SA_prom[j|i]);
256 }
257 printk(" ");
258 for(i=0;i<16;i++) {
259 if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
260 printk("%c", SA_prom[j|i]);
261 } else {
262 printk(" ");
263 }
264 }
265 printk("\n");
266 }
267 }
268
269#if 0
270
271
272
273
274
275 if (net_debug>1) {
276 printk("seeq8005: testing packet buffer ... ");
277 outw( SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
278 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
279 outw( 0 , SEEQ_DMAAR);
280 for(i=0;i<32768;i++) {
281 outw(0x5a5a, SEEQ_BUFFER);
282 }
283 j=jiffies+HZ;
284 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
285 mb();
286 outw( 0 , SEEQ_DMAAR);
287 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
288 mb();
289 if ( (inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
290 outw( SEEQCMD_WINDOW_INT_ACK | (inw(SEEQ_STATUS)& SEEQCMD_INT_MASK), SEEQ_CMD);
291 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
292 j=0;
293 for(i=0;i<32768;i++) {
294 if (inw(SEEQ_BUFFER) != 0x5a5a)
295 j++;
296 }
297 if (j) {
298 printk("%i\n",j);
299 } else {
300 printk("ok.\n");
301 }
302 }
303#endif
304
305 if (net_debug && version_printed++ == 0)
306 printk(version);
307
308 printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
309
310
311 dev->base_addr = ioaddr;
312 dev->irq = irq;
313
314
315 for (i = 0; i < 6; i++)
316 dev->dev_addr[i] = SA_prom[i+6];
317 printk("%pM", dev->dev_addr);
318
319 if (dev->irq == 0xff)
320 ;
321 else if (dev->irq < 2) {
322 unsigned long cookie = probe_irq_on();
323
324 outw( SEEQCMD_RX_INT_EN | SEEQCMD_SET_RX_ON | SEEQCMD_SET_RX_OFF, SEEQ_CMD );
325
326 dev->irq = probe_irq_off(cookie);
327
328 if (net_debug >= 2)
329 printk(" autoirq is %d\n", dev->irq);
330 } else if (dev->irq == 2)
331
332
333
334 dev->irq = 9;
335
336#if 0
337 {
338 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
339 if (irqval) {
340 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
341 dev->irq, irqval);
342 retval = -EAGAIN;
343 goto out;
344 }
345 }
346#endif
347 dev->netdev_ops = &seeq8005_netdev_ops;
348 dev->watchdog_timeo = HZ/20;
349 dev->flags &= ~IFF_MULTICAST;
350
351 return 0;
352out:
353 release_region(ioaddr, SEEQ8005_IO_EXTENT);
354 return retval;
355}
356
357
358
359
360
361
362
363
364
365static int seeq8005_open(struct net_device *dev)
366{
367 struct net_local *lp = netdev_priv(dev);
368
369 {
370 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
371 if (irqval) {
372 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
373 dev->irq, irqval);
374 return -EAGAIN;
375 }
376 }
377
378
379 seeq8005_init(dev, 1);
380
381 lp->open_time = jiffies;
382
383 netif_start_queue(dev);
384 return 0;
385}
386
387static void seeq8005_timeout(struct net_device *dev)
388{
389 int ioaddr = dev->base_addr;
390 printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
391 tx_done(dev) ? "IRQ conflict" : "network cable problem");
392
393 seeq8005_init(dev, 1);
394 dev->trans_start = jiffies;
395 netif_wake_queue(dev);
396}
397
398static netdev_tx_t seeq8005_send_packet(struct sk_buff *skb,
399 struct net_device *dev)
400{
401 short length = skb->len;
402 unsigned char *buf;
403
404 if (length < ETH_ZLEN) {
405 if (skb_padto(skb, ETH_ZLEN))
406 return NETDEV_TX_OK;
407 length = ETH_ZLEN;
408 }
409 buf = skb->data;
410
411
412 netif_stop_queue(dev);
413
414 hardware_send_packet(dev, buf, length);
415 dev->trans_start = jiffies;
416 dev->stats.tx_bytes += length;
417 dev_kfree_skb (skb);
418
419
420 return NETDEV_TX_OK;
421}
422
423
424
425
426
427
428
429
430inline void wait_for_buffer(struct net_device * dev)
431{
432 int ioaddr = dev->base_addr;
433 unsigned long tmp;
434 int status;
435
436 tmp = jiffies + HZ;
437 while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
438 cpu_relax();
439
440 if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
441 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
442}
443
444
445
446static irqreturn_t seeq8005_interrupt(int irq, void *dev_id)
447{
448 struct net_device *dev = dev_id;
449 struct net_local *lp;
450 int ioaddr, status, boguscount = 0;
451 int handled = 0;
452
453 ioaddr = dev->base_addr;
454 lp = netdev_priv(dev);
455
456 status = inw(SEEQ_STATUS);
457 do {
458 if (net_debug >2) {
459 printk("%s: int, status=0x%04x\n",dev->name,status);
460 }
461
462 if (status & SEEQSTAT_WINDOW_INT) {
463 handled = 1;
464 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
465 if (net_debug) {
466 printk("%s: window int!\n",dev->name);
467 }
468 }
469 if (status & SEEQSTAT_TX_INT) {
470 handled = 1;
471 outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
472 dev->stats.tx_packets++;
473 netif_wake_queue(dev);
474 }
475 if (status & SEEQSTAT_RX_INT) {
476 handled = 1;
477
478 seeq8005_rx(dev);
479 }
480 status = inw(SEEQ_STATUS);
481 } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
482
483 if(net_debug>2) {
484 printk("%s: eoi\n",dev->name);
485 }
486 return IRQ_RETVAL(handled);
487}
488
489
490static void seeq8005_rx(struct net_device *dev)
491{
492 struct net_local *lp = netdev_priv(dev);
493 int boguscount = 10;
494 int pkt_hdr;
495 int ioaddr = dev->base_addr;
496
497 do {
498 int next_packet;
499 int pkt_len;
500 int i;
501 int status;
502
503 status = inw(SEEQ_STATUS);
504 outw( lp->receive_ptr, SEEQ_DMAAR);
505 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
506 wait_for_buffer(dev);
507 next_packet = ntohs(inw(SEEQ_BUFFER));
508 pkt_hdr = inw(SEEQ_BUFFER);
509
510 if (net_debug>2) {
511 printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
512 }
513
514 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) {
515 return;
516 }
517
518 if ((pkt_hdr & SEEQPKTS_DONE)==0)
519 break;
520
521 if (next_packet < lp->receive_ptr) {
522 pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
523 } else {
524 pkt_len = next_packet - lp->receive_ptr - 4;
525 }
526
527 if (next_packet < ((DEFAULT_TEA+1)<<8)) {
528 printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
529 seeq8005_init(dev,1);
530 return;
531 }
532
533 lp->receive_ptr = next_packet;
534
535 if (net_debug>2) {
536 printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
537 }
538
539 if (pkt_hdr & SEEQPKTS_ANY_ERROR) {
540 dev->stats.rx_errors++;
541 if (pkt_hdr & SEEQPKTS_SHORT) dev->stats.rx_frame_errors++;
542 if (pkt_hdr & SEEQPKTS_DRIB) dev->stats.rx_frame_errors++;
543 if (pkt_hdr & SEEQPKTS_OVERSIZE) dev->stats.rx_over_errors++;
544 if (pkt_hdr & SEEQPKTS_CRC_ERR) dev->stats.rx_crc_errors++;
545
546 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
547 outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
548 } else {
549
550 struct sk_buff *skb;
551 unsigned char *buf;
552
553 skb = dev_alloc_skb(pkt_len);
554 if (skb == NULL) {
555 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
556 dev->stats.rx_dropped++;
557 break;
558 }
559 skb_reserve(skb, 2);
560 buf = skb_put(skb,pkt_len);
561
562 insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
563
564 if (net_debug>2) {
565 char * p = buf;
566 printk("%s: recv ",dev->name);
567 for(i=0;i<14;i++) {
568 printk("%02x ",*(p++)&0xff);
569 }
570 printk("\n");
571 }
572
573 skb->protocol=eth_type_trans(skb,dev);
574 netif_rx(skb);
575 dev->stats.rx_packets++;
576 dev->stats.rx_bytes += pkt_len;
577 }
578 } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
579
580
581
582
583 return;
584}
585
586
587static int seeq8005_close(struct net_device *dev)
588{
589 struct net_local *lp = netdev_priv(dev);
590 int ioaddr = dev->base_addr;
591
592 lp->open_time = 0;
593
594 netif_stop_queue(dev);
595
596
597 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
598
599 free_irq(dev->irq, dev);
600
601
602
603 return 0;
604
605}
606
607
608
609
610
611
612
613static void set_multicast_list(struct net_device *dev)
614{
615
616
617
618
619#if 0
620 int ioaddr = dev->base_addr;
621
622
623
624
625
626 if (num_addrs) {
627 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL, SEEQ_CFG1);
628 dev->flags|=IFF_PROMISC;
629 } else {
630 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
631 }
632#endif
633}
634
635void seeq8005_init(struct net_device *dev, int startp)
636{
637 struct net_local *lp = netdev_priv(dev);
638 int ioaddr = dev->base_addr;
639 int i;
640
641 outw(SEEQCFG2_RESET, SEEQ_CFG2);
642 udelay(5);
643
644 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
645 outw( 0, SEEQ_DMAAR);
646
647 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
648
649 for(i=0;i<6;i++) {
650 outb(dev->dev_addr[i], SEEQ_BUFFER);
651 udelay(2);
652 }
653
654 outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1);
655 outb( DEFAULT_TEA, SEEQ_BUFFER);
656
657 lp->receive_ptr = (DEFAULT_TEA+1)<<8;
658 outw( lp->receive_ptr, SEEQ_RPR);
659
660 outw( 0x00ff, SEEQ_REA);
661
662 if (net_debug>4) {
663 printk("%s: SA0 = ",dev->name);
664
665 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
666 outw( 0, SEEQ_DMAAR);
667 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
668
669 for(i=0;i<6;i++) {
670 printk("%02x ",inb(SEEQ_BUFFER));
671 }
672 printk("\n");
673 }
674
675 outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
676 outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
677 outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
678
679 if (net_debug>4) {
680 int old_cfg1;
681 old_cfg1 = inw(SEEQ_CFG1);
682 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
683 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
684 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
685 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
686 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
687
688 }
689}
690
691
692static void hardware_send_packet(struct net_device * dev, char *buf, int length)
693{
694 int ioaddr = dev->base_addr;
695 int status = inw(SEEQ_STATUS);
696 int transmit_ptr = 0;
697 unsigned long tmp;
698
699 if (net_debug>4) {
700 printk("%s: send 0x%04x\n",dev->name,length);
701 }
702
703
704 outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
705 outw( transmit_ptr, SEEQ_DMAAR);
706
707
708 outw( htons(length + 4), SEEQ_BUFFER);
709 outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
710
711
712 outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
713
714 outw( 0, SEEQ_BUFFER);
715 outw( 0, SEEQ_BUFFER);
716
717
718 outw( transmit_ptr, SEEQ_TPR);
719
720
721 tmp = jiffies;
722 while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && time_before(jiffies, tmp + HZ))
723 mb();
724
725
726 outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
727
728}
729
730
731#ifdef MODULE
732
733static struct net_device *dev_seeq;
734MODULE_LICENSE("GPL");
735module_param(io, int, 0);
736module_param(irq, int, 0);
737MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
738MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
739
740int __init init_module(void)
741{
742 dev_seeq = seeq8005_probe(-1);
743 if (IS_ERR(dev_seeq))
744 return PTR_ERR(dev_seeq);
745 return 0;
746}
747
748void __exit cleanup_module(void)
749{
750 unregister_netdev(dev_seeq);
751 release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
752 free_netdev(dev_seeq);
753}
754
755#endif
756