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