Make isa_probe_addr a simple integer rather than a struct, to facilitate
[people/sha0/gpxe.git] / src / drivers / net / eepro.c
1 #ifdef ALLMULTI
2 #error multicast support is not yet implemented
3 #endif
4 /**************************************************************************
5 Etherboot -  BOOTP/TFTP Bootstrap Program
6 Intel EEPRO/10 NIC driver for Etherboot
7 Adapted from Linux eepro.c from kernel 2.2.17
8
9 This board accepts a 32 pin EEPROM (29C256), however a test with a
10 27C010 shows that this EPROM also works in the socket, but it's not clear
11 how repeatably. The two top address pins appear to be held low, thus
12 the bottom 32kB of the 27C010 is visible in the CPU's address space.
13 To be sure you could put 4 copies of the code in the 27C010, then
14 it doesn't matter whether the extra lines are held low or high, just
15 hopefully not floating as CMOS chips don't like floating inputs.
16
17 Be careful with seating the EPROM as the socket on my board actually
18 has 34 pins, the top row of 2 are not used.
19 ***************************************************************************/
20
21 /*
22  * This program is free software; you can redistribute it and/or
23  * modify it under the terms of the GNU General Public License as
24  * published by the Free Software Foundation; either version 2, or (at
25  * your option) any later version.
26  */
27
28 /* to get some global routines like printf */
29 #include "etherboot.h"
30 /* to get the interface to the body of the program */
31 #include "nic.h"
32 #include "isa.h"
33 /* we use timer2 for microsecond waits */
34 #include "timer.h"
35
36 /* Different 82595 chips */
37 #define LAN595          0
38 #define LAN595TX        1
39 #define LAN595FX        2
40 #define LAN595FX_10ISA  3
41
42 #define SLOW_DOWN       inb(0x80);
43
44 /* The station (ethernet) address prefix, used for IDing the board. */
45 #define SA_ADDR0 0x00   /* Etherexpress Pro/10 */
46 #define SA_ADDR1 0xaa
47 #define SA_ADDR2 0x00
48
49 #define GetBit(x,y) ((x & (1<<y))>>y)
50
51 /* EEPROM Word 0: */
52 #define ee_PnP       0  /* Plug 'n Play enable bit */
53 #define ee_Word1     1  /* Word 1? */
54 #define ee_BusWidth  2  /* 8/16 bit */
55 #define ee_FlashAddr 3  /* Flash Address */
56 #define ee_FlashMask 0x7   /* Mask */
57 #define ee_AutoIO    6  /* */
58 #define ee_reserved0 7  /* =0! */
59 #define ee_Flash     8  /* Flash there? */
60 #define ee_AutoNeg   9  /* Auto Negotiation enabled? */
61 #define ee_IO0       10 /* IO Address LSB */
62 #define ee_IO0Mask   0x /*...*/
63 #define ee_IO1       15 /* IO MSB */
64
65 /* EEPROM Word 1: */
66 #define ee_IntSel    0   /* Interrupt */
67 #define ee_IntMask   0x7
68 #define ee_LI        3   /* Link Integrity 0= enabled */
69 #define ee_PC        4   /* Polarity Correction 0= enabled */
70 #define ee_TPE_AUI   5   /* PortSelection 1=TPE */
71 #define ee_Jabber    6   /* Jabber prevention 0= enabled */
72 #define ee_AutoPort  7   /* Auto Port Selection 1= Disabled */
73 #define ee_SMOUT     8   /* SMout Pin Control 0= Input */
74 #define ee_PROM      9   /* Flash EPROM / PROM 0=Flash */
75 #define ee_reserved1 10  /* .. 12 =0! */
76 #define ee_AltReady  13  /* Alternate Ready, 0=normal */
77 #define ee_reserved2 14  /* =0! */
78 #define ee_Duplex    15
79
80 /* Word2,3,4: */
81 #define ee_IA5       0 /*bit start for individual Addr Byte 5 */
82 #define ee_IA4       8 /*bit start for individual Addr Byte 5 */
83 #define ee_IA3       0 /*bit start for individual Addr Byte 5 */
84 #define ee_IA2       8 /*bit start for individual Addr Byte 5 */
85 #define ee_IA1       0 /*bit start for individual Addr Byte 5 */
86 #define ee_IA0       8 /*bit start for individual Addr Byte 5 */
87
88 /* Word 5: */
89 #define ee_BNC_TPE   0 /* 0=TPE */
90 #define ee_BootType  1 /* 00=None, 01=IPX, 10=ODI, 11=NDIS */
91 #define ee_BootTypeMask 0x3 
92 #define ee_NumConn   3  /* Number of Connections 0= One or Two */
93 #define ee_FlashSock 4  /* Presence of Flash Socket 0= Present */
94 #define ee_PortTPE   5
95 #define ee_PortBNC   6
96 #define ee_PortAUI   7
97 #define ee_PowerMgt  10 /* 0= disabled */
98 #define ee_CP        13 /* Concurrent Processing */
99 #define ee_CPMask    0x7
100
101 /* Word 6: */
102 #define ee_Stepping  0 /* Stepping info */
103 #define ee_StepMask  0x0F
104 #define ee_BoardID   4 /* Manucaturer Board ID, reserved */
105 #define ee_BoardMask 0x0FFF
106
107 /* Word 7: */
108 #define ee_INT_TO_IRQ 0 /* int to IRQ Mapping  = 0x1EB8 for Pro/10+ */
109 #define ee_FX_INT2IRQ 0x1EB8 /* the _only_ mapping allowed for FX chips */
110
111 /*..*/
112 #define ee_SIZE 0x40 /* total EEprom Size */
113 #define ee_Checksum 0xBABA /* initial and final value for adding checksum */
114
115
116 /* Card identification via EEprom:   */
117 #define ee_addr_vendor 0x10  /* Word offset for EISA Vendor ID */
118 #define ee_addr_id 0x11      /* Word offset for Card ID */
119 #define ee_addr_SN 0x12      /* Serial Number */
120 #define ee_addr_CRC_8 0x14   /* CRC over last thee Bytes */
121
122
123 #define ee_vendor_intel0 0x25  /* Vendor ID Intel */
124 #define ee_vendor_intel1 0xD4
125 #define ee_id_eepro10p0 0x10   /* ID for eepro/10+ */
126 #define ee_id_eepro10p1 0x31
127
128 /* now this section could be used by both boards: the oldies and the ee10:
129  * ee10 uses tx buffer before of rx buffer and the oldies the inverse.
130  * (aris)
131  */
132 #define RAM_SIZE        0x8000
133
134 #define RCV_HEADER      8
135 #define RCV_DEFAULT_RAM 0x6000
136 #define RCV_RAM         rcv_ram
137
138 static unsigned rcv_ram = RCV_DEFAULT_RAM;
139
140 #define XMT_HEADER      8
141 #define XMT_RAM         (RAM_SIZE - RCV_RAM)
142
143 #define XMT_START       ((rcv_start + RCV_RAM) % RAM_SIZE)
144
145 #define RCV_LOWER_LIMIT (rcv_start >> 8)
146 #define RCV_UPPER_LIMIT (((rcv_start + RCV_RAM) - 2) >> 8)
147 #define XMT_LOWER_LIMIT (XMT_START >> 8)
148 #define XMT_UPPER_LIMIT (((XMT_START + XMT_RAM) - 2) >> 8)
149
150 #define RCV_START_PRO   0x00
151 #define RCV_START_10    XMT_RAM
152                                         /* by default the old driver */
153 static unsigned rcv_start = RCV_START_PRO;
154
155 #define RCV_DONE        0x0008
156 #define RX_OK           0x2000
157 #define RX_ERROR        0x0d81
158
159 #define TX_DONE_BIT     0x0080
160 #define CHAIN_BIT       0x8000
161 #define XMT_STATUS      0x02
162 #define XMT_CHAIN       0x04
163 #define XMT_COUNT       0x06
164
165 #define BANK0_SELECT    0x00            
166 #define BANK1_SELECT    0x40            
167 #define BANK2_SELECT    0x80            
168
169 /* Bank 0 registers */
170 #define COMMAND_REG     0x00    /* Register 0 */
171 #define MC_SETUP        0x03
172 #define XMT_CMD         0x04
173 #define DIAGNOSE_CMD    0x07
174 #define RCV_ENABLE_CMD  0x08
175 #define RCV_DISABLE_CMD 0x0a
176 #define STOP_RCV_CMD    0x0b
177 #define RESET_CMD       0x0e
178 #define POWER_DOWN_CMD  0x18
179 #define RESUME_XMT_CMD  0x1c
180 #define SEL_RESET_CMD   0x1e
181 #define STATUS_REG      0x01    /* Register 1 */
182 #define RX_INT          0x02
183 #define TX_INT          0x04
184 #define EXEC_STATUS     0x30
185 #define ID_REG          0x02    /* Register 2   */
186 #define R_ROBIN_BITS    0xc0    /* round robin counter */
187 #define ID_REG_MASK     0x2c
188 #define ID_REG_SIG      0x24
189 #define AUTO_ENABLE     0x10
190 #define INT_MASK_REG    0x03    /* Register 3   */
191 #define RX_STOP_MASK    0x01
192 #define RX_MASK         0x02
193 #define TX_MASK         0x04
194 #define EXEC_MASK       0x08
195 #define ALL_MASK        0x0f
196 #define IO_32_BIT       0x10
197 #define RCV_BAR         0x04    /* The following are word (16-bit) registers */
198 #define RCV_STOP        0x06
199
200 #define XMT_BAR_PRO     0x0a
201 #define XMT_BAR_10      0x0b
202 static unsigned xmt_bar = XMT_BAR_PRO;
203
204 #define HOST_ADDRESS_REG        0x0c
205 #define IO_PORT         0x0e
206 #define IO_PORT_32_BIT  0x0c
207
208 /* Bank 1 registers */
209 #define REG1    0x01
210 #define WORD_WIDTH      0x02
211 #define INT_ENABLE      0x80
212 #define INT_NO_REG      0x02
213 #define RCV_LOWER_LIMIT_REG     0x08
214 #define RCV_UPPER_LIMIT_REG     0x09
215
216 #define XMT_LOWER_LIMIT_REG_PRO 0x0a
217 #define XMT_UPPER_LIMIT_REG_PRO 0x0b
218 #define XMT_LOWER_LIMIT_REG_10  0x0b
219 #define XMT_UPPER_LIMIT_REG_10  0x0a
220 static unsigned xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_PRO;
221 static unsigned xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_PRO;
222
223 /* Bank 2 registers */
224 #define XMT_Chain_Int   0x20    /* Interrupt at the end of the transmit chain */
225 #define XMT_Chain_ErrStop       0x40 /* Interrupt at the end of the chain even if there are errors */
226 #define RCV_Discard_BadFrame    0x80 /* Throw bad frames away, and continue to receive others */
227 #define REG2            0x02
228 #define PRMSC_Mode      0x01
229 #define Multi_IA        0x20
230 #define REG3            0x03
231 #define TPE_BIT         0x04
232 #define BNC_BIT         0x20
233 #define REG13           0x0d
234 #define FDX             0x00
235 #define A_N_ENABLE      0x02
236         
237 #define I_ADD_REG0      0x04
238 #define I_ADD_REG1      0x05
239 #define I_ADD_REG2      0x06
240 #define I_ADD_REG3      0x07
241 #define I_ADD_REG4      0x08
242 #define I_ADD_REG5      0x09
243
244 #define EEPROM_REG_PRO  0x0a
245 #define EEPROM_REG_10   0x0b
246 static unsigned eeprom_reg = EEPROM_REG_PRO;
247
248 #define EESK 0x01
249 #define EECS 0x02
250 #define EEDI 0x04
251 #define EEDO 0x08
252
253 /* The horrible routine to read a word from the serial EEPROM. */
254 /* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */
255
256 /* The delay between EEPROM clock transitions. */
257 #define eeprom_delay() { udelay(40); }
258 #define EE_READ_CMD (6 << 6)
259
260 /* do a full reset */
261 #define eepro_full_reset(ioaddr)        outb(RESET_CMD, ioaddr); udelay(40);
262
263 /* do a nice reset */
264 #define eepro_sel_reset(ioaddr)         { \
265                                         outb(SEL_RESET_CMD, ioaddr); \
266                                         SLOW_DOWN; \
267                                         SLOW_DOWN; \
268                                         }
269
270 /* clear all interrupts */
271 #define eepro_clear_int(ioaddr) outb(ALL_MASK, ioaddr + STATUS_REG)
272
273 /* enable rx */
274 #define eepro_en_rx(ioaddr)     outb(RCV_ENABLE_CMD, ioaddr)
275
276 /* disable rx */
277 #define eepro_dis_rx(ioaddr)    outb(RCV_DISABLE_CMD, ioaddr)
278
279 /* switch bank */
280 #define eepro_sw2bank0(ioaddr) outb(BANK0_SELECT, ioaddr)
281 #define eepro_sw2bank1(ioaddr) outb(BANK1_SELECT, ioaddr)
282 #define eepro_sw2bank2(ioaddr) outb(BANK2_SELECT, ioaddr)
283
284 static unsigned int     rx_start, tx_start;
285 static int              tx_last;
286 static unsigned int     tx_end;
287 static int              eepro = 0;
288 static unsigned int     mem_start, mem_end = RCV_DEFAULT_RAM / 1024;
289
290 /**************************************************************************
291 RESET - Reset adapter
292 ***************************************************************************/
293 static void eepro_reset(struct nic *nic)
294 {
295         int             temp_reg, i;
296
297         /* put the card in its initial state */
298         eepro_sw2bank2(nic->ioaddr);    /* be careful, bank2 now */
299         temp_reg = inb(nic->ioaddr + eeprom_reg);
300         DBG("Stepping %d\n", temp_reg >> 5);
301         if (temp_reg & 0x10)    /* check the TurnOff Enable bit */
302                 outb(temp_reg & 0xEF, nic->ioaddr + eeprom_reg);
303         for (i = 0; i < ETH_ALEN; i++)  /* fill the MAC address */
304                 outb(nic->node_addr[i], nic->ioaddr + I_ADD_REG0 + i);
305         temp_reg = inb(nic->ioaddr + REG1);
306         /* setup Transmit Chaining and discard bad RCV frames */
307         outb(temp_reg | XMT_Chain_Int | XMT_Chain_ErrStop
308                 | RCV_Discard_BadFrame, nic->ioaddr + REG1);
309         temp_reg = inb(nic->ioaddr + REG2);             /* match broadcast */
310         outb(temp_reg | 0x14, nic->ioaddr + REG2);
311         temp_reg = inb(nic->ioaddr + REG3);
312         outb(temp_reg & 0x3F, nic->ioaddr + REG3);      /* clear test mode */
313         /* set the receiving mode */
314         eepro_sw2bank1(nic->ioaddr);    /* be careful, bank1 now */
315         /* initialise the RCV and XMT upper and lower limits */
316         outb(RCV_LOWER_LIMIT, nic->ioaddr + RCV_LOWER_LIMIT_REG);
317         outb(RCV_UPPER_LIMIT, nic->ioaddr + RCV_UPPER_LIMIT_REG);
318         outb(XMT_LOWER_LIMIT, nic->ioaddr + xmt_lower_limit_reg);
319         outb(XMT_UPPER_LIMIT, nic->ioaddr + xmt_upper_limit_reg);
320         eepro_sw2bank0(nic->ioaddr);    /* Switch back to bank 0 */
321         eepro_clear_int(nic->ioaddr);
322         /* Initialise RCV */
323         rx_start = (unsigned int)bus_to_virt(RCV_LOWER_LIMIT << 8);
324         outw(RCV_LOWER_LIMIT << 8, nic->ioaddr + RCV_BAR);
325         outw(((RCV_UPPER_LIMIT << 8) | 0xFE), nic->ioaddr + RCV_STOP);
326         /* Intialise XMT */
327         outw((XMT_LOWER_LIMIT << 8), nic->ioaddr + xmt_bar);
328         eepro_sel_reset(nic->ioaddr);
329         tx_start = tx_end = (unsigned int)bus_to_virt(XMT_LOWER_LIMIT << 8);
330         tx_last = 0;
331         eepro_en_rx(nic->ioaddr);
332 }
333
334 /**************************************************************************
335 POLL - Wait for a frame
336 ***************************************************************************/
337 static int eepro_poll(struct nic *nic, int retrieve)
338 {
339         unsigned int    rcv_car = virt_to_bus((void *)rx_start);
340         unsigned int    rcv_event, rcv_status, rcv_next_frame, rcv_size;
341
342         /* return true if there's an ethernet packet ready to read */
343         /* nic->packet should contain data on return */
344         /* nic->packetlen should contain length of data */
345 #if     0
346         if ((inb(nic->ioaddr + STATUS_REG) & 0x40) == 0)
347                 return (0);
348         outb(0x40, nic->ioaddr + STATUS_REG);
349 #endif
350         outw(rcv_car, nic->ioaddr + HOST_ADDRESS_REG);
351         rcv_event = inw(nic->ioaddr + IO_PORT);
352         if (rcv_event != RCV_DONE)
353                 return (0);
354
355         /* FIXME: I'm guessing this might not work with this card, since
356            it looks like once a rcv_event is started it must be completed.
357            maybe there's another way. */
358         if ( ! retrieve ) return 1;
359
360         rcv_status = inw(nic->ioaddr + IO_PORT);
361         rcv_next_frame = inw(nic->ioaddr + IO_PORT);
362         rcv_size = inw(nic->ioaddr + IO_PORT);
363 #if     0
364         printf("%hX %hX %d %hhX\n", rcv_status, rcv_next_frame, rcv_size,
365                 inb(nic->ioaddr + STATUS_REG));
366 #endif
367         if ((rcv_status & (RX_OK|RX_ERROR)) != RX_OK) {
368                 printf("Receive error %hX\n", rcv_status);
369                 return (0);
370         }
371         rcv_size &= 0x3FFF;
372         insw(nic->ioaddr + IO_PORT, nic->packet, ((rcv_size + 3) >> 1));
373 #if     0
374 {
375         int i;
376         for (i = 0; i < 48; i++) {
377                 printf("%hhX", nic->packet[i]);
378                 putchar(i % 16 == 15 ? '\n' : ' ');
379         }
380 }
381 #endif
382         nic->packetlen = rcv_size;
383         rcv_car  = virt_to_bus((void *) (rx_start + RCV_HEADER + rcv_size));
384         rx_start = (unsigned int)bus_to_virt(rcv_next_frame << 8);
385         if (rcv_car == 0)
386                 rcv_car = ((RCV_UPPER_LIMIT << 8) | 0xff);
387         outw(rcv_car - 1, nic->ioaddr + RCV_STOP);
388         return (1);
389 }
390
391 /**************************************************************************
392 TRANSMIT - Transmit a frame
393 ***************************************************************************/
394 static void eepro_transmit(
395         struct nic *nic,
396         const char *d,                  /* Destination */
397         unsigned int t,                 /* Type */
398         unsigned int s,                 /* size */
399         const char *p)                  /* Packet */
400 {
401         unsigned int    status, tx_available, last, end, length;
402         unsigned short  type;
403         int             boguscount = 20;
404
405         length = s + ETH_HLEN;
406         if (tx_end > tx_start)
407                 tx_available = XMT_RAM - (tx_end - tx_start);
408         else if (tx_end < tx_start)
409                 tx_available = tx_start - tx_end;
410         else
411                 tx_available = XMT_RAM;
412         last = tx_end;
413         end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
414         if (end >= (XMT_UPPER_LIMIT << 8)) {
415                 last = (XMT_LOWER_LIMIT << 8);
416                 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
417         }
418         outw(last, nic->ioaddr + HOST_ADDRESS_REG);
419         outw(XMT_CMD, nic->ioaddr + IO_PORT);
420         outw(0, nic->ioaddr + IO_PORT);
421         outw(end, nic->ioaddr + IO_PORT);
422         outw(length, nic->ioaddr + IO_PORT);
423         outsw(nic->ioaddr + IO_PORT, d, ETH_ALEN / 2);
424         outsw(nic->ioaddr + IO_PORT, nic->node_addr, ETH_ALEN / 2);
425         type = htons(t);
426         outsw(nic->ioaddr + IO_PORT, &type, sizeof(type) / 2);
427         outsw(nic->ioaddr + IO_PORT, p, (s + 3) >> 1);
428         /* A dummy read to flush the DRAM write pipeline */
429         status = inw(nic->ioaddr + IO_PORT);
430         outw(last, nic->ioaddr + xmt_bar);
431         outb(XMT_CMD, nic->ioaddr);
432         tx_start = last;
433         tx_last = last;
434         tx_end = end;
435 #if     0
436         printf("%d %d\n", tx_start, tx_end);
437 #endif
438         while (boguscount > 0) {
439                 if (((status = inw(nic->ioaddr + IO_PORT)) & TX_DONE_BIT) == 0) {
440                         udelay(40);
441                         boguscount--;
442                         continue;
443                 }
444                 if ((status & 0x2000) == 0) {
445                         DBG("Transmit status %hX\n", status);
446                 }
447         }
448 }
449
450 /**************************************************************************
451 DISABLE - Turn off ethernet interface
452 ***************************************************************************/
453 static void eepro_disable ( struct nic *nic ) {
454         eepro_sw2bank0(nic->ioaddr);    /* Switch to bank 0 */
455         /* Flush the Tx and disable Rx */
456         outb(STOP_RCV_CMD, nic->ioaddr);
457         tx_start = tx_end = (unsigned int) (bus_to_virt(XMT_LOWER_LIMIT << 8));
458         tx_last = 0;
459         /* Reset the 82595 */
460         eepro_full_reset(nic->ioaddr);
461 }
462
463 /**************************************************************************
464 DISABLE - Enable, Disable, or Force interrupts
465 ***************************************************************************/
466 static void eepro_irq(struct nic *nic __unused, irq_action_t action __unused)
467 {
468   switch ( action ) {
469   case DISABLE :
470     break;
471   case ENABLE :
472     break;
473   case FORCE :
474     break;
475   }
476 }
477
478 static int read_eeprom(uint16_t ioaddr, int location)
479 {
480         int             i;
481         unsigned short  retval = 0;
482         int             ee_addr = ioaddr + eeprom_reg;
483         int             read_cmd = location | EE_READ_CMD;
484         int             ctrl_val = EECS;
485
486         if (eepro == LAN595FX_10ISA) {
487                 eepro_sw2bank1(ioaddr);
488                 outb(0x00, ioaddr + STATUS_REG);
489         }
490         eepro_sw2bank2(ioaddr);
491         outb(ctrl_val, ee_addr);
492         /* shift the read command bits out */
493         for (i = 8; i >= 0; i--) {
494                 short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI : ctrl_val;
495                 outb(outval, ee_addr);
496                 outb(outval | EESK, ee_addr);   /* EEPROM clock tick */
497                 eeprom_delay();
498                 outb(outval, ee_addr);          /* finish EEPROM clock tick */
499                 eeprom_delay();
500         }
501         outb(ctrl_val, ee_addr);
502         for (i = 16; i > 0; i--) {
503                 outb(ctrl_val | EESK, ee_addr);
504                 eeprom_delay();
505                 retval = (retval << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0);
506                 outb(ctrl_val, ee_addr);
507                 eeprom_delay();
508         }
509         /* terminate the EEPROM access */
510         ctrl_val &= ~EECS;
511         outb(ctrl_val | EESK, ee_addr);
512         eeprom_delay();
513         outb(ctrl_val, ee_addr);
514         eeprom_delay();
515         eepro_sw2bank0(ioaddr);
516         return (retval);
517 }
518
519 static int eepro_probe1 ( isa_probe_addr_t ioaddr ) {
520         int             id, counter;
521
522         id = inb(ioaddr + ID_REG);
523         if ((id & ID_REG_MASK) != ID_REG_SIG)
524                 return (0);
525         counter = id & R_ROBIN_BITS;
526         if (((id = inb(ioaddr + ID_REG)) & R_ROBIN_BITS) != (counter + 0x40))
527                 return (0);
528         /* yes the 82595 has been found */
529         return (1);
530 }
531
532 static struct nic_operations eepro_operations = {
533         .connect        = dummy_connect,
534         .poll           = eepro_poll,
535         .transmit       = eepro_transmit,
536         .irq            = eepro_irq,
537         .disable        = eepro_disable,
538 };
539
540 /**************************************************************************
541 PROBE - Look for an adapter, this routine's visible to the outside
542 ***************************************************************************/
543 static int eepro_probe ( struct dev *dev, struct isa_device *isa ) {
544         struct nic *nic = nic_device ( dev );
545         int             i, l_eepro = 0;
546         union {
547                 unsigned char   caddr[ETH_ALEN];
548                 unsigned short  saddr[ETH_ALEN/2];
549         } station_addr;
550
551         nic->irqno  = 0;
552         nic->ioaddr = isa->ioaddr;
553
554         station_addr.saddr[2] = read_eeprom(nic->ioaddr,2);
555         if ( ( station_addr.saddr[2] == 0x0000 ) ||
556              ( station_addr.saddr[2] == 0xFFFF ) ) {
557                 l_eepro = 3;
558                 eepro = LAN595FX_10ISA;
559                 eeprom_reg= EEPROM_REG_10;
560                 rcv_start = RCV_START_10;
561                 xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_10;
562                 xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_10;
563                 station_addr.saddr[2] = read_eeprom(nic->ioaddr,2);
564         }
565         station_addr.saddr[1] = read_eeprom(nic->ioaddr,3);
566         station_addr.saddr[0] = read_eeprom(nic->ioaddr,4);
567         if (l_eepro)
568                 dev->name = "Intel EtherExpress 10 ISA";
569         else if (read_eeprom(nic->ioaddr,7) == ee_FX_INT2IRQ) {
570                 dev->name = "Intel EtherExpress Pro/10+ ISA";
571                 l_eepro = 2;
572         } else if (station_addr.saddr[0] == SA_ADDR1) {
573                 dev->name = "Intel EtherExpress Pro/10 ISA";
574                 l_eepro = 1;
575         } else {
576                 l_eepro = 0;
577                 dev->name = "Intel 82595-based LAN card";
578         }
579         station_addr.saddr[0] = swap16(station_addr.saddr[0]);
580         station_addr.saddr[1] = swap16(station_addr.saddr[1]);
581         station_addr.saddr[2] = swap16(station_addr.saddr[2]);
582         for (i = 0; i < ETH_ALEN; i++) {
583                 nic->node_addr[i] = station_addr.caddr[i];
584         }
585         DBG("%s ioaddr %#hX, addr %!", dev->name, nic->ioaddr, nic->node_addr);
586         mem_start = RCV_LOWER_LIMIT << 8;
587         if ((mem_end & 0x3F) < 3 || (mem_end & 0x3F) > 29)
588                 mem_end = RCV_UPPER_LIMIT << 8;
589         else {
590                 mem_end = mem_end * 1024 + (RCV_LOWER_LIMIT << 8);
591                 rcv_ram = mem_end - (RCV_LOWER_LIMIT << 8);
592         }
593         printf(", Rx mem %dK, if %s\n", (mem_end - mem_start) >> 10,
594                 GetBit(read_eeprom(nic->ioaddr,5), ee_BNC_TPE) ? "BNC" : "TP");
595
596         eepro_reset(nic);
597
598         /* point to NIC specific routines */
599         nic->nic_op     = &eepro_operations;
600         return 1;
601 }
602
603 static isa_probe_addr_t eepro_probe_addrs[] = {
604         0x300, 0x210, 0x240, 0x280, 0x2C0, 0x200, 0x320, 0x340, 0x360,
605 };
606
607 static struct isa_driver eepro_driver =
608         ISA_DRIVER ( "eepro", eepro_probe_addrs, eepro_probe1,
609                      GENERIC_ISAPNP_VENDOR, 0x828a );
610
611 BOOT_DRIVER ( "eepro", find_isa_boot_device, eepro_driver, eepro_probe );
612
613 ISA_ROM ( "eepro", "Intel Etherexpress Pro/10" );