1 /* 2 ** File: ne.c Jun. 08, 2000 3 ** 4 ** Driver for the NE*000 ethernet cards and derivates. 5 ** This file contains only the ne specific code, 6 ** the rest is in 8390.c Code specific for ISA bus only 7 ** 8 ** Created: March 15, 1994 by Philip Homburg <philip@cs.vu.nl> 9 ** PchId: ne2000.c,v 1.4 1996/01/19 23:30:34 philip Exp 10 ** 11 ** Modified: Jun. 08, 2000 by Giovanni Falzoni <gfalzoni@inwind.it> 12 ** Adapted to interface new main network task. 13 */ 14 15 #include <minix/drivers.h> 16 #include <minix/netdriver.h> 17 #include <net/gen/ether.h> 18 #include <net/gen/eth_io.h> 19 #include "dp.h" 20 21 #if (ENABLE_NE2000 == 1) 22 23 #include "8390.h" 24 #include "ne.h" 25 26 /* 27 ** Name: ne_reset 28 ** Function: Resets the board and checks if reset cycle completes 29 */ 30 static int ne_reset(dpeth_t * dep) 31 { 32 int count = 0; 33 34 /* Reset the ethernet card */ 35 outb_ne(dep, NE_RESET, inb_ne(dep, NE_RESET)); 36 do { 37 if (++count > 10) return FALSE; /* 20 mSecs. timeout */ 38 micro_delay(2000); 39 } while ((inb_ne(dep, DP_ISR) & ISR_RST) == 0); 40 return TRUE; 41 } 42 43 /* 44 ** Name: ne_close 45 ** Function: Stops the board by resetting it and masking interrupts. 46 */ 47 static void ne_close(dpeth_t * dep) 48 { 49 50 (void)ne_reset(dep); 51 outb_ne(dep, DP_ISR, 0xFF); 52 sys_irqdisable(&dep->de_hook); 53 } 54 55 /* 56 ** Name: ne_init 57 ** Function: Initialize the board making it ready to work. 58 */ 59 static void ne_init(dpeth_t * dep) 60 { 61 int ix; 62 63 dep->de_data_port = dep->de_base_port + NE_DATA; 64 if (dep->de_16bit) { 65 dep->de_ramsize = NE2000_SIZE; 66 dep->de_offset_page = NE2000_START / DP_PAGESIZE; 67 } else { 68 dep->de_ramsize = NE1000_SIZE; 69 dep->de_offset_page = NE1000_START / DP_PAGESIZE; 70 } 71 72 /* Allocates two send buffers from onboard RAM */ 73 dep->de_sendq_nr = SENDQ_NR; 74 for (ix = 0; ix < SENDQ_NR; ix += 1) { 75 dep->de_sendq[ix].sq_sendpage = dep->de_offset_page + ix * SENDQ_PAGES; 76 } 77 78 /* Remaining onboard RAM allocated for receiving */ 79 dep->de_startpage = dep->de_offset_page + ix * SENDQ_PAGES; 80 dep->de_stoppage = dep->de_offset_page + dep->de_ramsize / DP_PAGESIZE; 81 82 /* Can't override the default IRQ. */ 83 dep->de_irq &= NOT(DEI_DEFAULT); 84 85 ns_init(dep); /* Initialize DP controller */ 86 87 printf("%s: NE%d000 (%dkB RAM) at %X:%d - ", 88 dep->de_name, 89 dep->de_16bit ? 2 : 1, 90 dep->de_ramsize / 1024, 91 dep->de_base_port, dep->de_irq); 92 for (ix = 0; ix < SA_ADDR_LEN; ix += 1) 93 printf("%02X%c", dep->de_address.ea_addr[ix], 94 ix < SA_ADDR_LEN - 1 ? ':' : '\n'); 95 } 96 97 /* 98 ** Name: ne_probe 99 ** Function: Probe for the presence of a NE*000 card by testing 100 ** whether the board is reachable through the dp8390. 101 ** Note that the NE1000 is an 8bit card and has a memory 102 ** region distict from the 16bit NE2000. 103 */ 104 int ne_probe(dpeth_t * dep) 105 { 106 int ix, wd, loc1, loc2; 107 char EPROM[32]; 108 static const struct { 109 unsigned char offset; 110 unsigned char value; 111 } InitSeq[] = 112 { 113 { /* Selects page 0. */ 114 DP_CR, (CR_NO_DMA | CR_PS_P0 | CR_STP), 115 }, 116 { /* Set byte-wide access and 8 bytes burst mode. */ 117 DP_DCR, (DCR_8BYTES | DCR_BMS), 118 }, 119 { /* Clears the count registers. */ 120 DP_RBCR0, 0x00, }, { DP_RBCR1, 0x00, 121 }, 122 { /* Mask completion irq. */ 123 DP_IMR, 0x00, }, { DP_ISR, 0xFF, 124 }, 125 { /* Set receiver to monitor */ 126 DP_RCR, RCR_MON, 127 }, 128 { /* and transmitter to loopback mode. */ 129 DP_TCR, TCR_INTERNAL, 130 }, 131 { /* Transmit 32 bytes */ 132 DP_RBCR0, 32, }, { DP_RBCR1, 0, 133 }, 134 { /* DMA starting at 0x0000. */ 135 DP_RSAR0, 0x00, }, { DP_RSAR1, 0x00, 136 }, 137 { /* Start board (reads) */ 138 DP_CR, (CR_PS_P0 | CR_DM_RR | CR_STA), 139 }, 140 }; 141 142 dep->de_dp8390_port = dep->de_base_port + NE_DP8390; 143 144 if ((loc1 = inb_ne(dep, NE_DP8390)) == 0xFF) return FALSE; 145 146 /* Check if the dp8390 is really there */ 147 outb_ne(dep, DP_CR, CR_STP | CR_NO_DMA | CR_PS_P1); 148 loc2 = inb_ne(dep, DP_MAR5); /* Saves one byte of the address */ 149 outb_ne(dep, DP_MAR5, 0xFF); /* Write 0xFF to it (same offset as DP_CNTR0) */ 150 outb_ne(dep, DP_CR, CR_NO_DMA | CR_PS_P0); /* Back to page 0 */ 151 inb_ne(dep, DP_CNTR0); /* Reading counter resets it */ 152 if (inb_ne(dep, DP_CNTR0) != 0) { 153 outb_ne(dep, NE_DP8390, loc1); /* Try to restore modified bytes */ 154 outb_ne(dep, DP_TCR, loc2); 155 return FALSE; 156 } 157 158 /* Try to reset the board */ 159 if (ne_reset(dep) == FALSE) return FALSE; 160 161 /* Checks whether the board is 8/16bits and a real NE*000 or clone */ 162 for (ix = 0; ix < sizeof(InitSeq)/sizeof(InitSeq[0]); ix += 1) { 163 outb_ne(dep, InitSeq[ix].offset, InitSeq[ix].value); 164 } 165 for (ix = 0, wd = 1; ix < 32; ix += 2) { 166 EPROM[ix + 0] = inb_ne(dep, NE_DATA); 167 EPROM[ix + 1] = inb_ne(dep, NE_DATA); 168 /* NE2000s and clones read same value for even and odd addresses */ 169 if (EPROM[ix + 0] != EPROM[ix + 1]) wd = 0; 170 } 171 if (wd == 1) { /* Normalize EPROM contents for NE2000 */ 172 for (ix = 0; ix < 16; ix += 1) EPROM[ix] = EPROM[ix * 2]; 173 } 174 /* Real NE*000 and good clones have '0x57' at locations 14 and 15 */ 175 if (EPROM[14] != 0x57 || EPROM[15] != 0x57) return FALSE; 176 177 /* Setup the ethernet address. */ 178 for (ix = 0; ix < SA_ADDR_LEN; ix += 1) { 179 dep->de_address.ea_addr[ix] = EPROM[ix]; 180 } 181 dep->de_16bit = wd; 182 dep->de_linmem = 0; /* Uses Programmed I/O only */ 183 dep->de_prog_IO = 1; 184 dep->de_initf = ne_init; 185 dep->de_stopf = ne_close; 186 return TRUE; 187 } 188 189 #endif /* ENABLE_NE2000 */ 190 191 /** ne.c **/ 192