![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ne2k_isa.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net|
Return to ne2k_isa.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net |
1.1 root 1: /**************************************************************************
2: ETHERBOOT - BOOTP/TFTP Bootstrap Program
3:
4: Author: Martin Renters
5: Date: May/94
6:
7: This code is based heavily on David Greenman's if_ed.c driver
8:
9: Copyright (C) 1993-1994, David Greenman, Martin Renters.
10: This software may be used, modified, copied, distributed, and sold, in
11: both source and binary form provided that the above copyright and these
12: terms are retained. Under no circumstances are the authors responsible for
13: the proper functioning of this software, nor do the authors assume any
14: responsibility for damages incurred with its use.
15:
16: Multicast support added by Timothy Legge ([email protected]) 09/28/2003
17: Relocation support added by Ken Yap ([email protected]) 28/12/02
18: Card Detect support adapted from the eCos driver (Christian Plessl <[email protected]>)
19: Extracted from ns8390.c and adapted by Pantelis Koukousoulas <[email protected]>
20: **************************************************************************/
21:
22: FILE_LICENCE ( BSD2 );
23:
24: #include "ns8390.h"
25: #include "etherboot.h"
26: #include "nic.h"
27: #include <ipxe/ethernet.h>
28: #include <ipxe/isa.h>
29: #include <errno.h>
30:
31: #define ASIC_PIO NE_DATA
32:
33: static unsigned char eth_vendor, eth_flags;
34: static unsigned short eth_nic_base, eth_asic_base;
35: static unsigned char eth_memsize, eth_rx_start, eth_tx_start;
36: static Address eth_bmem, eth_rmem;
37: static unsigned char eth_drain_receiver;
38:
39: static struct nic_operations ne_operations;
40: static void ne_reset(struct nic *nic, struct isa_device *isa);
41:
42: static isa_probe_addr_t ne_probe_addrs[] = { 0x300, 0x280, 0x320, 0x340, 0x380, 0x220, };
43:
44: /**************************************************************************
45: ETH_PIO_READ - Read a frame via Programmed I/O
46: **************************************************************************/
47: static void eth_pio_read(unsigned int src, unsigned char *dst, unsigned int cnt) {
48: outb(D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
49: outb(cnt, eth_nic_base + D8390_P0_RBCR0);
50: outb(cnt >> 8, eth_nic_base + D8390_P0_RBCR1);
51: outb(src, eth_nic_base + D8390_P0_RSAR0);
52: outb(src >> 8, eth_nic_base + D8390_P0_RSAR1);
53: outb(D8390_COMMAND_RD0 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
54: if (eth_flags & FLAG_16BIT)
55: cnt = (cnt + 1) >> 1;
56:
57: while (cnt--) {
58: if (eth_flags & FLAG_16BIT) {
59: *((unsigned short *) dst) = inw(eth_asic_base + ASIC_PIO);
60: dst += 2;
61: } else
62: *(dst++) = inb(eth_asic_base + ASIC_PIO);
63: }
64: }
65:
66: /**************************************************************************
67: ETH_PIO_WRITE - Write a frame via Programmed I/O
68: **************************************************************************/
69: static void eth_pio_write(const unsigned char *src, unsigned int dst,
70: unsigned int cnt) {
71: outb(D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
72: outb(D8390_ISR_RDC, eth_nic_base + D8390_P0_ISR);
73: outb(cnt, eth_nic_base + D8390_P0_RBCR0);
74: outb(cnt >> 8, eth_nic_base + D8390_P0_RBCR1);
75: outb(dst, eth_nic_base + D8390_P0_RSAR0);
76: outb(dst >> 8, eth_nic_base + D8390_P0_RSAR1);
77: outb(D8390_COMMAND_RD1 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
78: if (eth_flags & FLAG_16BIT)
79: cnt = (cnt + 1) >> 1;
80:
81: while (cnt--) {
82:
83: if (eth_flags & FLAG_16BIT) {
84: outw(*((unsigned short *) src), eth_asic_base + ASIC_PIO);
85: src += 2;
86: } else
87: outb(*(src++), eth_asic_base + ASIC_PIO);
88: }
89: }
90:
91: /**************************************************************************
92: enable_multicast - Enable Multicast
93: **************************************************************************/
94: static void enable_multicast(unsigned short eth_nic_base) {
95: unsigned char mcfilter[8];
96: int i;
97:
98: memset(mcfilter, 0xFF, 8);
99: outb(4, eth_nic_base + D8390_P0_RCR);
100: outb(D8390_COMMAND_RD2 + D8390_COMMAND_PS1, eth_nic_base + D8390_P0_COMMAND);
101: for (i = 0; i < 8; i++) {
102: outb(mcfilter[i], eth_nic_base + 8 + i);
103: if (inb(eth_nic_base + 8 + i) != mcfilter[i])
104: DBG("Error SMC 83C690 Multicast filter read/write mishap %d\n",
105: i);
106: }
107: outb(D8390_COMMAND_RD2 + D8390_COMMAND_PS0, eth_nic_base + D8390_P0_COMMAND);
108: outb(4 | 0x08, eth_nic_base + D8390_P0_RCR);
109: }
110:
111: /**************************************************************************
112: NE_PROBE1 - Look for an adapter on the ISA bus
113: **************************************************************************/
114: static int ne_probe1(isa_probe_addr_t ioaddr) {
115: //From the eCos driver
116: unsigned int regd;
117: unsigned int state;
118:
119: state = inb(ioaddr);
120: outb(ioaddr, D8390_COMMAND_RD2 | D8390_COMMAND_PS1 | D8390_COMMAND_STP);
121: regd = inb(ioaddr + D8390_P0_TCR);
122:
123: if (inb(ioaddr + D8390_P0_TCR)) {
124: outb(ioaddr, state);
125: outb(ioaddr + 0x0d, regd);
126: return 0;
127: }
128:
129: return 1;
130: }
131:
132: /**************************************************************************
133: NE_PROBE - Initialize an adapter ???
134: **************************************************************************/
135: static int ne_probe(struct nic *nic, struct isa_device *isa) {
136: int i;
137: unsigned char c;
138: unsigned char romdata[16];
139: unsigned char testbuf[32];
140:
141: eth_vendor = VENDOR_NONE;
142: eth_drain_receiver = 0;
143:
144: nic->irqno = 0;
145: nic->ioaddr = isa->ioaddr;
146: eth_nic_base = isa->ioaddr;
147:
148: /******************************************************************
149: Search for NE1000/2000 if no WD/SMC or 3com cards
150: ******************************************************************/
151: if (eth_vendor == VENDOR_NONE) {
152:
153: static unsigned char test[] = "NE*000 memory";
154:
155: eth_bmem = 0; /* No shared memory */
156:
157: eth_flags = FLAG_PIO;
158: eth_asic_base = eth_nic_base + NE_ASIC_OFFSET;
159: eth_memsize = MEM_16384;
160: eth_tx_start = 32;
161: eth_rx_start = 32 + D8390_TXBUF_SIZE;
162: c = inb(eth_asic_base + NE_RESET);
163: outb(c, eth_asic_base + NE_RESET);
164: (void) inb(0x84);
165: outb(D8390_COMMAND_STP | D8390_COMMAND_RD2, eth_nic_base
166: + D8390_P0_COMMAND);
167: outb(D8390_RCR_MON, eth_nic_base + D8390_P0_RCR);
168: outb(D8390_DCR_FT1 | D8390_DCR_LS, eth_nic_base + D8390_P0_DCR);
169: outb(MEM_8192, eth_nic_base + D8390_P0_PSTART);
170: outb(MEM_16384, eth_nic_base + D8390_P0_PSTOP);
171: eth_pio_write((unsigned char *) test, 8192, sizeof(test));
172: eth_pio_read(8192, testbuf, sizeof(test));
173: if (!memcmp(test, testbuf, sizeof(test)))
174: goto out;
175: eth_flags |= FLAG_16BIT;
176: eth_memsize = MEM_32768;
177: eth_tx_start = 64;
178: eth_rx_start = 64 + D8390_TXBUF_SIZE;
179: outb(D8390_DCR_WTS | D8390_DCR_FT1 | D8390_DCR_LS, eth_nic_base
180: + D8390_P0_DCR);
181: outb(MEM_16384, eth_nic_base + D8390_P0_PSTART);
182: outb(MEM_32768, eth_nic_base + D8390_P0_PSTOP);
183: eth_pio_write((unsigned char *) test, 16384, sizeof(test));
184: eth_pio_read(16384, testbuf, sizeof(test));
185: if (!memcmp(testbuf, test, sizeof(test)))
186: goto out;
187:
188:
189: out:
190: if (eth_nic_base == 0)
191: return (0);
192: if (eth_nic_base > ISA_MAX_ADDR) /* PCI probably */
193: eth_flags |= FLAG_16BIT;
194: eth_vendor = VENDOR_NOVELL;
195: eth_pio_read(0, romdata, sizeof(romdata));
196: for (i = 0; i < ETH_ALEN; i++) {
197: nic->node_addr[i] = romdata[i + ((eth_flags & FLAG_16BIT) ? i : 0)];
198: }
199: nic->ioaddr = eth_nic_base;
200: DBG("\nNE%c000 base %4.4x, MAC Addr %s\n",
201: (eth_flags & FLAG_16BIT) ? '2' : '1', eth_nic_base, eth_ntoa(
202: nic->node_addr));
203: }
204:
205: if (eth_vendor == VENDOR_NONE)
206: return (0);
207:
208: if (eth_vendor != VENDOR_3COM)
209: eth_rmem = eth_bmem;
210:
211: ne_reset(nic, isa);
212: nic->nic_op = &ne_operations;
213: return 1;
214: }
215:
216:
217: /**************************************************************************
218: NE_DISABLE - Turn off adapter
219: **************************************************************************/
220: static void ne_disable(struct nic *nic, struct isa_device *isa) {
221: ne_reset(nic, isa);
222: }
223:
224:
225: /**************************************************************************
226: NE_RESET - Reset adapter
227: **************************************************************************/
228: static void ne_reset(struct nic *nic, struct isa_device *isa __unused)
229: {
230: int i;
231:
232: eth_drain_receiver = 0;
233: outb(D8390_COMMAND_PS0 | D8390_COMMAND_RD2 |
234: D8390_COMMAND_STP, eth_nic_base+D8390_P0_COMMAND);
235: if (eth_flags & FLAG_16BIT)
236: outb(0x49, eth_nic_base+D8390_P0_DCR);
237: else
238: outb(0x48, eth_nic_base+D8390_P0_DCR);
239: outb(0, eth_nic_base+D8390_P0_RBCR0);
240: outb(0, eth_nic_base+D8390_P0_RBCR1);
241: outb(0x20, eth_nic_base+D8390_P0_RCR); /* monitor mode */
242: outb(2, eth_nic_base+D8390_P0_TCR);
243: outb(eth_tx_start, eth_nic_base+D8390_P0_TPSR);
244: outb(eth_rx_start, eth_nic_base+D8390_P0_PSTART);
245:
246: outb(eth_memsize, eth_nic_base+D8390_P0_PSTOP);
247: outb(eth_memsize - 1, eth_nic_base+D8390_P0_BOUND);
248: outb(0xFF, eth_nic_base+D8390_P0_ISR);
249: outb(0, eth_nic_base+D8390_P0_IMR);
250: outb(D8390_COMMAND_PS1 |
251: D8390_COMMAND_RD2 | D8390_COMMAND_STP, eth_nic_base+D8390_P0_COMMAND);
252:
253: for (i=0; i<ETH_ALEN; i++)
254: outb(nic->node_addr[i], eth_nic_base+D8390_P1_PAR0+i);
255: for (i=0; i<ETH_ALEN; i++)
256: outb(0xFF, eth_nic_base+D8390_P1_MAR0+i);
257: outb(eth_rx_start, eth_nic_base+D8390_P1_CURR);
258: outb(D8390_COMMAND_PS0 |
259: D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base+D8390_P0_COMMAND);
260: outb(0xFF, eth_nic_base+D8390_P0_ISR);
261: outb(0, eth_nic_base+D8390_P0_TCR); /* transmitter on */
262: outb(4, eth_nic_base+D8390_P0_RCR); /* allow rx broadcast frames */
263:
264: enable_multicast(eth_nic_base);
265: }
266:
267:
268: /**************************************************************************
269: NE_POLL - Wait for a frame
270: **************************************************************************/
271: static int ne_poll(struct nic *nic __unused, int retrieve __unused)
272: {
273: int ret = 0;
274: unsigned char rstat, curr, next;
275: unsigned short len, frag;
276: unsigned short pktoff;
277: unsigned char *p;
278: struct ringbuffer pkthdr;
279:
280: rstat = inb(eth_nic_base+D8390_P0_RSR);
281: if (!(rstat & D8390_RSTAT_PRX)) return(0);
282: next = inb(eth_nic_base+D8390_P0_BOUND)+1;
283: if (next >= eth_memsize) next = eth_rx_start;
284: outb(D8390_COMMAND_PS1, eth_nic_base+D8390_P0_COMMAND);
285: curr = inb(eth_nic_base+D8390_P1_CURR);
286: outb(D8390_COMMAND_PS0, eth_nic_base+D8390_P0_COMMAND);
287: if (curr >= eth_memsize) curr=eth_rx_start;
288: if (curr == next) return(0);
289:
290: if ( ! retrieve ) return 1;
291:
292: pktoff = next << 8;
293: if (eth_flags & FLAG_PIO)
294: eth_pio_read(pktoff, (unsigned char *)&pkthdr, 4);
295: else
296: memcpy(&pkthdr, bus_to_virt(eth_rmem + pktoff), 4);
297: pktoff += sizeof(pkthdr);
298: /* incoming length includes FCS so must sub 4 */
299: len = pkthdr.len - 4;
300: if ((pkthdr.status & D8390_RSTAT_PRX) == 0 || len < ETH_ZLEN
301: || len> ETH_FRAME_LEN) {
302: DBG("Bogus packet, ignoring\n");
303: return (0);
304: }
305: else {
306: p = nic->packet;
307: nic->packetlen = len; /* available to caller */
308: frag = (eth_memsize << 8) - pktoff;
309: if (len> frag) { /* We have a wrap-around */
310: /* read first part */
311: if (eth_flags & FLAG_PIO)
312: eth_pio_read(pktoff, p, frag);
313: else
314: memcpy(p, bus_to_virt(eth_rmem + pktoff), frag);
315: pktoff = eth_rx_start << 8;
316: p += frag;
317: len -= frag;
318: }
319: /* read second part */
320: if (eth_flags & FLAG_PIO)
321: eth_pio_read(pktoff, p, len);
322: else
323: memcpy(p, bus_to_virt(eth_rmem + pktoff), len);
324: ret = 1;
325: }
326: next = pkthdr.next; /* frame number of next packet */
327: if (next == eth_rx_start)
328: next = eth_memsize;
329: outb(next-1, eth_nic_base+D8390_P0_BOUND);
330: return(ret);
331: }
332:
333:
334: /**************************************************************************
335: NE_TRANSMIT - Transmit a frame
336: **************************************************************************/
337: static void ne_transmit(struct nic *nic, const char *d, /* Destination */
338: unsigned int t, /* Type */
339: unsigned int s, /* size */
340: const char *p) { /* Packet */
341:
342: /* Programmed I/O */
343: unsigned short type;
344: type = (t >> 8) | (t << 8);
345: eth_pio_write((unsigned char *) d, eth_tx_start << 8, ETH_ALEN);
346: eth_pio_write(nic->node_addr, (eth_tx_start << 8) + ETH_ALEN, ETH_ALEN);
347: /* bcc generates worse code without (const+const) below */
348: eth_pio_write((unsigned char *) &type, (eth_tx_start << 8) + (ETH_ALEN
349: + ETH_ALEN), 2);
350: eth_pio_write((unsigned char *) p, (eth_tx_start << 8) + ETH_HLEN, s);
351: s += ETH_HLEN;
352: if (s < ETH_ZLEN)
353: s = ETH_ZLEN;
354:
355: outb(D8390_COMMAND_PS0 | D8390_COMMAND_RD2 | D8390_COMMAND_STA,
356: eth_nic_base + D8390_P0_COMMAND);
357: outb(eth_tx_start, eth_nic_base + D8390_P0_TPSR);
358: outb(s, eth_nic_base + D8390_P0_TBCR0);
359: outb(s >> 8, eth_nic_base + D8390_P0_TBCR1);
360:
361: outb(D8390_COMMAND_PS0 | D8390_COMMAND_TXP | D8390_COMMAND_RD2
362: | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
363: }
364:
365: static struct nic_operations ne_operations = { .connect = dummy_connect,
366: .poll = ne_poll, .transmit = ne_transmit, .irq = dummy_irq,
367: };
368:
369: ISA_DRIVER ( ne_driver, ne_probe_addrs, ne_probe1,
370: GENERIC_ISAPNP_VENDOR, 0x0600 );
371:
372: DRIVER ( "ne", nic_driver, isapnp_driver, ne_driver,
373: ne_probe, ne_disable );
374:
375: ISA_ROM("ne","NE1000/2000 and clones");
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.