![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to SMC16.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / SMC16 / SMC16_reloc.tproj|
Return to SMC16.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / SMC16 / SMC16_reloc.tproj |
1.1 root 1: /*
2: * Copyright (c) 1993 NeXT Computer, Inc.
3: *
4: * Driver class for SMC EtherCard Plus Elite16 adaptors.
5: *
6: * HISTORY
7: *
8: * 19 Apr 1993
9: * Added multicast & promiscuous mode support.
10: *
11: * 26 Jan 1993
12: * Created.
13: */
14:
15: #define MACH_USER_API 1
16:
17: #import <driverkit/generalFuncs.h>
18: #import <driverkit/IONetbufQueue.h>
19:
20: #import "SMC16.h"
21: #import "SMC16IOInline.h"
22: #import "SMC16Private.h"
23:
24: #import <kernserv/kern_server_types.h>
25: #import <kernserv/prototypes.h>
26: #import <kernserv/i386/spl.h>
27:
28: @implementation SMC16
29:
30: /*
31: * Private Instance Methods
32: */
33:
34: /*
35: * _memAvail
36: * Returns the amount of onboard memory not currently in use.
37: * Never returns less than zero.
38: */
39: - (SMC16_len_t)_memAvail
40: {
41: int available;
42:
43: available = (memtotal - memused);
44:
45: return ((SMC16_len_t) ((available < 0)? 0: available));
46: }
47:
48: /*
49: * _memRegion
50: * Returns the next available NIC_PAGE_SIZE chunk of onboard memory.
51: */
52: - (SMC16_off_t)_memRegion:(SMC16_len_t)length
53: {
54: if ([self _memAvail] < length)
55: IOPanic("SMC16: onboard memory exhausted");
56:
57: return ((SMC16_off_t) (memused / NIC_PAGE_SIZE));
58: }
59:
60: /*
61: * _memAlloc
62: * Allocates onboard memory in chunks of NIC_PAGE_SIZE
63: */
64: - (SMC16_off_t)_memAlloc:(SMC16_len_t)length
65: {
66: SMC16_off_t region;
67:
68: /*
69: * Round up to the next multiple of NIC_PAGE_SIZE
70: */
71: length = ((length + NIC_PAGE_SIZE - 1) & ~(NIC_PAGE_SIZE - 1));
72:
73: region = [self _memRegion:length];
74:
75: memused += length;
76:
77: return (region);
78: }
79:
80: /*
81: * _initializeHardware
82: * Resets the SMC adaptor. Disables interrupts, resets the NIC, and
83: * configures the onboard memory.
84: */
85: - (void)_initializeHardware
86: {
87: setIRQ(irq, YES, base);
88:
89: resetNIC(base);
90:
91: memtotal = setupRAM(membase, memsize, base);
92: memused = 0;
93: }
94:
95: /*
96: * _receiveInitialize
97: * Prepares the card for receive operations. Allocates as many NIC_PAGE_SIZE
98: * buffers from the available onboard memory.
99: */
100: - (void)_receiveInitialize
101: {
102: SMC16_len_t avail = [self _memAvail];
103:
104: rstart = [self _memAlloc:avail];
105: rstop = rstart + (avail / NIC_PAGE_SIZE);
106:
107: /*
108: * Setup the receive ring
109: */
110: put_rstart_reg(rstart, base); put_rstop_reg(rstop, base);
111:
112: /*
113: * Reset the boundary buffer pointer
114: */
115: put_bound_reg(rstart, base);
116:
117: rnext = rstart + 1;
118:
119: /*
120: * Reset the current buffer pointer
121: */
122: (void)sel_reg_page(REG_PAGE1, base);
123: put_curr_reg(rnext, base);
124: (void)sel_reg_page(REG_PAGE0, base);
125: }
126:
127: /*
128: * _transmitInitialize
129: * Prepares for transmit operations. We use 1 transmit buffer of maximum
130: * size.
131: */
132: - (void)_transmitInitialize
133: {
134: tstart = [self _memAlloc:ETHERMAXPACKET];
135: }
136:
137: /*
138: * _initializeSoftware
139: * Prepare the adaptor for network operations and start them.
140: */
141: - (void)_initializeSoftware
142: {
143: setStationAddress(&myAddress, base);
144:
145: [self _transmitInitialize];
146: [self _receiveInitialize];
147:
148: startNIC(base, rconsave);
149: }
150:
151: /*
152: * _receiveInterruptOccurred
153: * This method handles the process of moving received frames from
154: * onboard adaptor memory to netbufs and handing them up to the network
155: * object.
156: */
157: - (void)_receiveInterruptOccurred
158: {
159: nic_recv_hdr_t *rhdr;
160: netbuf_t pkt;
161: int pkt_len, pre_wrap_len;
162: void *pkt_data = NULL;
163:
164: #ifdef DEBUG
165:
166: /*
167: * Change this to 1 to be inundated with messages.
168: */
169: boolean_t SMC16_recvTrace = 0;
170:
171: #endif DEBUG
172:
173:
174: /*
175: * Grab buffers until we point to the next available one.
176: */
177: while (rnext != getCurrentBuffer(base)) {
178:
179: /*
180: * Point to the receive header in this buffer.
181: */
182: rhdr = (nic_recv_hdr_t *)nic_page_addr(rnext,membase);
183:
184: #ifdef DEBUG
185: if (SMC16_recvTrace) {
186: IOLog("[rstat %02x next %02x len %03x rnext "
187: "%02x bound %02x curr %02x]\n",
188: *(unsigned char *)&rhdr->rstat,
189: rhdr->next, rhdr->len, rnext,
190: get_bound_reg(base), getCurrentBuffer(base));
191: }
192: #endif DEBUG
193:
194:
195: /*
196: * Display a somewhat cryptic message if the prx bit is set.
197: */
198: if (!rhdr->rstat.prx) {
199: IOLog("rhdr1 rstat %02x next %02x len %x\n",
200: *(unsigned char *)&rhdr->rstat, rhdr->next, rhdr->len);
201: [network incrementInputErrors];
202: rnext = rhdr->next;
203: continue;
204: }
205:
206: /*
207: * Display a slightly different, equally cryptic message
208: * if the pointer to the next buffer in this header is outside
209: * the range configured buffers. If this is the case, force a
210: * reset by invoking -timeoutOccurred.
211: */
212: if (rhdr->next >= rstop || rhdr->next < rstart) {
213: IOLog("rhdr2 rstat %02x next %02x len %x\n",
214: *(unsigned char *)&rhdr->rstat, rhdr->next, rhdr->len);
215: [network incrementInputErrors];
216: [self timeoutOccurred];
217: return;
218: }
219:
220: /*
221: * Get the overall packet length and the length between
222: * the start of the packet and the end of onboard memory.
223: * Any packet data beyond that will wrap back to the start
224: * of onboard memory.
225: */
226: pkt_len = rhdr->len - ETHERCRC;
227: pre_wrap_len = nic_page_addr(rstop,membase) -
228: nic_page_addr(rnext,membase) -
229: sizeof (*rhdr);
230:
231: /*
232: * If the packet length looks reasonable, allocate a net buffer
233: * for it and establish a pointer to the data in that net buffer.
234: */
235: if (pkt_len >= (ETHERMINPACKET - ETHERCRC) &&
236: pkt_len <= ETHERMAXPACKET) {
237: pkt = nb_alloc(pkt_len);
238: if (pkt)
239: pkt_data = nb_map(pkt);
240: }
241: else {
242: [network incrementInputErrors];
243: pkt = 0;
244: }
245:
246: /*
247: * If none of the packet wraps around the ring, just
248: * copy it into the netbuf.
249: */
250: if (pkt_len <= pre_wrap_len) {
251: if (pkt)
252: IOCopyMemory(
253: (void *)nic_page_addr(rnext,membase) + sizeof (*rhdr),
254: pkt_data,
255: pkt_len,
256: sizeof(short));
257: /*
258: * Otherwise, copy up to the end of memory, then copy the remaining
259: * portion from the start of memory.
260: */
261: }
262: else {
263: if (pkt) {
264: IOCopyMemory(
265: (void *)nic_page_addr(rnext,membase) + sizeof (*rhdr),
266: pkt_data,
267: pre_wrap_len,
268: sizeof(short));
269: IOCopyMemory(
270: (void *)nic_page_addr(rstart,membase),
271: pkt_data + pre_wrap_len,
272: pkt_len - pre_wrap_len,
273: sizeof(short));
274: }
275: }
276:
277: /*
278: * Increment the ring buffer pointers.
279: */
280: rnext = rhdr->next;
281: if ((rnext - 1) >= rstart)
282: put_bound_reg(rnext - 1, base);
283: else
284: put_bound_reg(rstop - 1, base);
285:
286: /*
287: * We only pass packets upward if they pass thru multicast filter.
288: */
289: if(pkt) {
290: if(rconsave.prom == 0 && [super
291: isUnwantedMulticastPacket:(ether_header_t *)nb_map(pkt)]) {
292: nb_free(pkt);
293: }
294: else {
295:
296: [network handleInputPacket:pkt extra:0];
297:
298: }
299: }
300: }
301:
302: }
303:
304: /*
305: * _receiveOverwriteOccurred
306: * Called when the adaptor tells us that we haven't fetched frames from
307: * onboard memory fast enough, so it's overwritten an old frame with a new
308: * one. Oh well...
309: */
310: - (void)_receiveOverwriteOccurred
311: {
312: #ifdef DEBUG
313: IOLog("overwrite bound %02x curr %02x rnext %02x\n", get_bound_reg(base), getCurrentBuffer(base), rnext);
314: [network incrementInputErrors];
315: #endif DEBUG
316: }
317:
318: /*
319: * _transmitInterruptOccurred
320: * Called when the adaptor indicated a transmit operation is complete. Check
321: * tstat register and increment the appropriate counters. Clear the
322: * timeout we set when we initiated the transmit and clear the transmitActive
323: * flag. Finally, if there are any outgoing packets in the queue, send the
324: * next one.
325: */
326: - (void)_transmitInterruptOccurred
327: {
328: nic_tstat_reg_t tstat_reg;
329: netbuf_t pkt;
330:
331: if (transmitActive) {
332: tstat_reg = get_tstat_reg(base);
333:
334: /*
335: * Always check transmit status (if available) here. On a
336: * transmit error, increment statistics and reset the
337: * adaptor if necessary (not for SMC). NEVER TRY TO
338: * RETRANSMIT A PACKET. Leave this up to higher level
339: * software, which should insure reliability when
340: * it's needed.
341: */
342: if (tstat_reg.ptx)
343: [network incrementOutputPackets];
344: else
345: [network incrementOutputErrors];
346:
347: if (tstat_reg.abort || tstat_reg.twc)
348: [network incrementCollisions];
349:
350: [self clearTimeout];
351: transmitActive = NO;
352: }
353:
354: if (pkt = [transmitQueue dequeue])
355: [self transmit:pkt];
356: }
357:
358: /*
359: * Public Factory Methods
360: */
361:
362: + (BOOL)probe:(IODeviceDescription *)devDesc
363: {
364: SMC16 *dev = [self alloc];
365: IOEISADeviceDescription
366: *deviceDescription = (IOEISADeviceDescription *)devDesc;
367: IORange *io;
368:
369: if (dev == nil)
370: return NO;
371:
372: /*
373: * Valid configuration?
374: */
375: if ( [deviceDescription numPortRanges] < 1
376: ||
377: [deviceDescription numMemoryRanges] < 1
378: ||
379: [deviceDescription numInterrupts] < 1) {
380: [dev free];
381: return NO;
382: }
383:
384: /*
385: * Make sure we're configured for 16K (even though we can only use 8)
386: */
387: io = [deviceDescription memoryRangeList];
388: if (io->size < 16*1024) {
389: [dev free];
390: return NO;
391: }
392:
393: /*
394: * More configuration validation
395: */
396: io = [deviceDescription portRangeList];
397: if (io->size < 16) {
398: [dev free];
399: return NO;
400: }
401:
402: /*
403: * Configuration checks out so let's actually probe for hardware.
404: */
405: if (!checksumLAR(io->start)) {
406: IOLog("SMC16: Adaptor not present or invalid EEROM checksum.\n");
407: [dev free];
408: return NO;
409: }
410:
411: if (!checkBoardRev(io->start)) {
412: IOLog("SMC16: Unsupported board revision.\n");
413: [dev free];
414: return NO;
415: }
416:
417: return [dev initFromDeviceDescription:devDesc] != nil;
418: }
419:
420: /*
421: * Public Instance Methods
422: */
423:
424: - initFromDeviceDescription:(IODeviceDescription *)devDesc
425: {
426: IOEISADeviceDescription
427: *deviceDescription = (IOEISADeviceDescription *)devDesc;
428: IORange *io;
429:
430: if ([super initFromDeviceDescription:devDesc] == nil)
431: return nil;
432:
433: /*
434: * Initialize ivars
435: */
436: irq = [deviceDescription interrupt];
437:
438: io = [deviceDescription portRangeList];
439: base = io->start;
440:
441: io = [deviceDescription memoryRangeList];
442: membase = io->start;
443: memsize = io->size;
444:
445: /*
446: * Broadcasts should be enabled
447: */
448: rconsave.broad = 1;
449:
450: /*
451: * Reset the adaptor, but don't enable yet. We'll receive
452: * -resetAndEnable:YES as a side effect of calling
453: * -attachToNetworkWithAddress:
454: */
455: [self resetAndEnable:NO];
456:
457: IOLog("SMC16 at port %x irq %d\n",base, irq);
458:
459: transmitQueue = [[IONetbufQueue alloc] initWithMaxCount:32];
460:
461: network = [super attachToNetworkWithAddress:myAddress];
462: return self;
463: }
464:
465: - free
466: {
467: [transmitQueue free];
468:
469: return [super free];
470: }
471:
472: - (IOReturn)enableAllInterrupts
473: {
474: unmaskInterrupts(base);
475:
476: setIRQ(irq, YES, base);
477:
478: return [super enableAllInterrupts];
479: }
480:
481: - (void)disableAllInterrupts
482: {
483: setIRQ(irq, NO, base);
484:
485: [super disableAllInterrupts];
486: }
487:
488: - (BOOL)resetAndEnable:(BOOL)enable
489: {
490: [self disableAllInterrupts];
491:
492: transmitActive = NO;
493:
494: [self _initializeHardware];
495:
496: getStationAddress(&myAddress, base);
497:
498: [self _initializeSoftware];
499:
500: if (enable && [self enableAllInterrupts] != IO_R_SUCCESS) {
501: [self setRunning:NO];
502: return NO;
503: }
504:
505: [self setRunning:enable];
506: return YES;
507: }
508:
509: - (void)timeoutOccurred
510: {
511: netbuf_t pkt = NULL;
512:
513: if ([self isRunning]) {
514: if ([self resetAndEnable:YES]) {
515:
516: if (pkt = [transmitQueue dequeue])
517: [self transmit:pkt];
518: }
519: }
520: /*
521: * Value of [self isRunning] may have been modified by
522: * resetAndEnable:
523: */
524: if (![self isRunning]) {
525: /*
526: * Free any packets in the queue since we're not running.
527: */
528: if ([transmitQueue count]) {
529: transmitActive = NO;
530: while (pkt = [transmitQueue dequeue])
531: nb_free(pkt);
532: }
533: }
534: }
535:
536: /*
537: * Called by our IOThread when it receives a message signifying
538: * an interrupt. We check the istat register and vector off
539: * to the appropriate handler routines.
540: */
541: - (void)interruptOccurred
542: {
543: nic_istat_reg_t istat_reg;
544:
545: istat_reg = get_istat_reg(base);
546: put_istat_reg(istat_reg, base);
547:
548: if (istat_reg.ovw)
549: [self _receiveOverwriteOccurred];
550:
551: if (istat_reg.prx)
552: [self _receiveInterruptOccurred];
553:
554: if (istat_reg.ptx || istat_reg.txe)
555: [self _transmitInterruptOccurred];
556: }
557:
558:
559: /*
560: * Enable promiscuous mode (invoked by superclass).
561: */
562: - (BOOL)enablePromiscuousMode
563: {
564: int old_page = sel_reg_page(REG_PAGE0, base);
565:
566: rconsave.prom = 1;
567: put_rcon_reg(rconsave, base);
568: sel_reg_page(old_page, base);
569:
570: return YES;
571: }
572:
573: /*
574: * Disable promiscuous mode (invoked by superclass).
575: */
576: - (void)disablePromiscuousMode
577: {
578: int old_page = sel_reg_page(REG_PAGE0, base);
579:
580: rconsave.prom = 0;
581: put_rcon_reg(rconsave, base);
582: sel_reg_page(old_page, base);
583:
584: }
585:
586:
587: - (BOOL)enableMulticastMode
588: {
589: int old_page = sel_reg_page(REG_PAGE0, base);
590:
591: rconsave.group = 1;
592: put_rcon_reg(rconsave, base);
593: sel_reg_page(old_page, base);
594:
595: return YES;
596: }
597:
598: - (void)disableMulticastMode
599: {
600: int old_page = sel_reg_page(REG_PAGE0, base);
601:
602: rconsave.group = 0;
603: put_rcon_reg(rconsave, base);
604: sel_reg_page(old_page, base);
605:
606: }
607:
608: - (void)transmit:(netbuf_t)pkt
609: {
610: int pkt_len;
611:
612: /*
613: * If we're already transmitting, just queue up the packet.
614: */
615: if (transmitActive)
616: [transmitQueue enqueue:pkt];
617: else {
618:
619: /*
620: * We execute a softare loopback since this adaptor doesn't
621: * deal with this in hardware.
622: */
623: [self performLoopback:pkt];
624:
625: /*
626: * Copy the packet into our transmit buffer, then free it.
627: */
628: pkt_len = nb_size(pkt);
629: IOCopyMemory(
630: nb_map(pkt),
631: (void *)nic_page_addr(tstart,membase),
632: pkt_len,
633: sizeof(short));
634:
635: /*
636: * Once the packet is copied out to the adaptor's onboard RAM,
637: * always free the packet. DON'T SAVE A REFERENCE FOR
638: * RETRANSMISSION PURPOSES. Retransmission should be handled
639: * at the higher levels.
640: */
641: nb_free(pkt);
642:
643: /*
644: * Setup up and initiate the transmit operation
645: */
646: put_tcnt_reg(pkt_len, base);
647: put_tstart_reg(tstart, base);
648: startTransmit(base);
649:
650: /*
651: * Start a timer whose expiration will call -timeoutOccurred, then
652: * set the transmitActive flag so we don't step on this operation.
653: */
654: [self setRelativeTimeout:3000];
655: transmitActive = YES;
656: }
657: }
658:
659:
660: @end
661:
662: /*
663: * Private Functions
664: */
665:
666: static BOOL
667: checksumLAR(
668: IOEISAPortAddress base
669: )
670: {
671: IOEISAPortAddress offset;
672: unsigned char sum = 0;
673:
674: for (offset = BIC_LAR_OFF; offset <= BIC_LAR_CKSUM_OFF; offset++)
675: sum += inb(base + SMC16_BIC_OFF + offset);
676:
677: return (sum == 0xff);
678: }
679:
680: static void
681: getStationAddress(
682: enet_addr_t *ea,
683: IOEISAPortAddress base
684: )
685: {
686: int i;
687: unsigned char *enaddr = (unsigned char *)ea;
688:
689: for (i = 0; i < sizeof (*ea); i++)
690: *(enaddr + i) = inb(base + SMC16_BIC_OFF + BIC_LAR_OFF + i);
691: }
692:
693: static void
694: setStationAddress(
695: enet_addr_t *ea,
696: IOEISAPortAddress base
697: )
698: {
699: int i, old_page;
700: unsigned char *enaddr = (unsigned char *)ea;
701:
702: old_page = sel_reg_page(REG_PAGE1, base);
703:
704: for (i = 0; i < sizeof (*ea); i++)
705: outb(base + SMC16_NIC_OFF + NIC_STA_REG_OFF + i, *(enaddr + i));
706:
707: (void)sel_reg_page(old_page, base);
708: }
709:
710: static BOOL
711: checkBoardRev(
712: IOEISAPortAddress base
713: )
714: {
715: unsigned int bid;
716:
717: bid = get_bid(base);
718:
719: if (SMC16_REV(bid) < 2)
720: return NO;
721:
722: return YES;
723: }
724:
725: static void
726: resetNIC(
727: IOEISAPortAddress base
728: )
729: {
730: bic_msr_t msr = { 0 };
731: nic_istat_reg_t istat_reg;
732:
733: /*
734: * Perform HW Reset of NIC
735: */
736: msr.rst = 1; put_msr(msr, base);
737: IODelay(500);
738: msr.rst = 0; put_msr(msr, base);
739:
740: /*
741: * Wait for NIC to enter stopped state
742: */
743: do {
744: istat_reg = get_istat_reg(base);
745: } while (istat_reg.rst == 0);
746: }
747:
748: static SMC16_len_t
749: setupRAM(
750: vm_offset_t addr,
751: vm_size_t size,
752: IOEISAPortAddress base
753: )
754: {
755: SMC16_len_t total;
756: SMC16_off_t block_addr;
757: bic_laar_t laar;
758: bic_msr_t msr;
759: #ifdef SIXTEEN_BIT_MODE
760: bic_icr_t icr;
761: #endif SIXTEEN_BIT_MODE
762: union {
763: struct {
764: unsigned int :13,
765: madr :6,
766: ladr :5,
767: :8;
768: } bic_addr;
769: struct {
770: unsigned int :16,
771: block :8,
772: :8;
773: } nic_addr;
774: unsigned int address;
775: } _mconv;
776:
777: /*
778: * NOTE: We cannot put the card into 16-bit (and therefore 16K) mode because
779: * the bus interface chip will behave as though a full 64K is mapped, even
780: * though only 16K exists on the board. Needless to say this causes problems,
781: * whether something else is mapped into the top 3/4 of that 64K or not.
782: * Unless the hardware changes, we're limited to using 8K of onboard memory
783: * and 8-bit transfer mode.
784: */
785:
786: #ifdef SIXTEEN_BIT_MODE
787: icr = get_icr(base);
788:
789: total = (icr.msz ? 16 : 64) * 1024;
790:
791: if (total > 16 * 1024)
792: total = 16 * 1024;
793: #else // SIXTEEN_BIT_MODE
794: total = 8 * 1024;
795: #endif SIXTEEN_BIT_MODE
796:
797: if (total > size)
798: total = size;
799:
800: #ifdef DEBUG
801: IOLog("SMC16: using %d bytes of onboard memory\n",total);
802: #endif DEBUG
803:
804: _mconv.address = addr;
805:
806: laar = get_laar(base);
807: #ifdef SIXTEEN_BIT_MODE
808: laar.zws16 = TRUE;
809: laar.l16en = TRUE;
810: laar.m16en = TRUE;
811: #endif SIXTEEN_BIT_MODE
812: laar.ladr = _mconv.bic_addr.ladr;
813: put_laar(laar, base);
814:
815: msr = get_msr(base);
816: msr.madr = _mconv.bic_addr.madr;
817: msr.menb = TRUE;
818: put_msr(msr, base);
819:
820: block_addr = _mconv.nic_addr.block;
821: put_block_reg(block_addr, base);
822:
823: return (total);
824: }
825:
826: static void
827: startNIC(
828: IOEISAPortAddress base,
829: nic_rcon_reg_t rcon_reg
830: )
831: {
832: nic_cmd_reg_t cmd_reg = { 0 };
833: nic_enh_reg_t enh_reg = { 0 };
834: nic_dcon_reg_t dcon_reg = { 0 };
835: nic_tcon_reg_t tcon_reg = { 0 };
836: nic_istat_reg_t istat_reg;
837:
838: enh_reg.slot = NIC_SLOT_512_BIT;
839: enh_reg.wait = 0;
840: put_enh_reg(enh_reg, base);
841:
842: dcon_reg.bsize = NIC_DMA_BURST_8b;
843: #ifdef SIXTEEN_BIT_MODE
844: dcon_reg.bus16 = TRUE;
845: #endif SIXTEEN_BIT_MODE
846: put_dcon_reg(dcon_reg, base);
847:
848: put_tcon_reg(tcon_reg, base);
849:
850: istat_reg = get_istat_reg(base);
851: put_istat_reg(istat_reg, base);
852:
853: cmd_reg.sta = 1;
854: put_cmd_reg(cmd_reg, base);
855:
856: put_rcon_reg(rcon_reg, base);
857: }
858:
859: static void
860: unmaskInterrupts(
861: IOEISAPortAddress base
862: )
863: {
864: nic_imask_reg_t imask_reg = { 0 };
865:
866: /*
867: * Receive conditions
868: */
869: imask_reg.prxe = imask_reg.rxee = imask_reg.ovwe = TRUE;
870:
871: /*
872: * Transmit conditions
873: */
874: imask_reg.ptxe = imask_reg.txee = TRUE;
875:
876: put_imask_reg(imask_reg, base);
877: }
878:
879: static SMC16_off_t
880: getCurrentBuffer(
881: IOEISAPortAddress base
882: )
883: {
884: SMC16_off_t curr;
885: int old_page;
886:
887: old_page = sel_reg_page(REG_PAGE1, base);
888: curr = get_curr_reg(base);
889: if (old_page != REG_PAGE1)
890: sel_reg_page(old_page, base);
891:
892: return (curr);
893: }
894:
895: static void
896: startTransmit(
897: IOEISAPortAddress base
898: )
899: {
900: nic_cmd_reg_t cmd_reg = { 0 };
901:
902: cmd_reg.txp = 1;
903: cmd_reg.sta = 1;
904: put_cmd_reg(cmd_reg, base);
905: }
906:
907: static void
908: setIRQ(
909: int irq,
910: BOOL enable,
911: IOEISAPortAddress base
912: )
913: {
914: bic_irr_t irr;
915: bic_icr_t icr;
916: static char _irx_map[16] = { -1,
917: -1,
918: -1,
919: BIC_IRX_3,
920: BIC_IRX_4,
921: BIC_IRX_5,
922: -1,
923: BIC_IRX_7,
924: -1,
925: BIC_IRX_9,
926: BIC_IRX_10,
927: BIC_IRX_11,
928: -1,
929: -1,
930: -1,
931: BIC_IRX_15 };
932: static char _ir2_map[16] = { -1,
933: -1,
934: -1,
935: ICR_IR2_3,
936: ICR_IR2_4,
937: ICR_IR2_5,
938: -1,
939: ICR_IR2_7,
940: -1,
941: ICR_IR2_9,
942: ICR_IR2_10,
943: ICR_IR2_11,
944: -1,
945: -1,
946: -1,
947: ICR_IR2_15 };
948:
949: irr = get_irr(base);
950: irr.irx = _irx_map[irq];
951: irr.ien = FALSE;
952: put_irr(irr, base);
953:
954: icr = get_icr(base);
955: icr.ir2 = _ir2_map[irq];
956: put_icr(icr, base);
957:
958: irr.ien = enable;
959: put_irr(irr, base);
960: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.