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