1 /*------------------------------------------------------------------------
2 * smc9000.c
3 * This is a Etherboot driver for SMC's 9000 series of Ethernet cards.
4 *
5 * Copyright (C) 1998 Daniel Engstr�m <daniel.engstrom@riksnett.no>
6 * Based on the Linux SMC9000 driver, smc9194.c by Eric Stahlman
7 * Copyright (C) 1996 by Erik Stahlman <eric@vt.edu>
8 *
9 * This software may be used and distributed according to the terms
10 * of the GNU Public License, incorporated herein by reference.
11 *
12 * "Features" of the SMC chip:
13 * 4608 byte packet memory. ( for the 91C92/4. Others have more )
14 * EEPROM for configuration
15 * AUI/TP selection
16 *
17 * Authors
18 * Erik Stahlman <erik@vt.edu>
19 * Daniel Engstr�m <daniel.engstrom@riksnett.no>
20 *
21 * History
22 * 98-09-25 Daniel Engstr�m Etherboot driver crated from Eric's
23 * Linux driver.
24 *
25 *---------------------------------------------------------------------------*/
26 #define LINUX_OUT_MACROS 1
27 #define SMC9000_VERBOSE 1
28 #define SMC9000_DEBUG 0
29
30 #include "etherboot.h"
31 #include "nic.h"
32 #include "cards.h"
33 #include "smc9000.h"
34
35 # define _outb outb
36 # define _outw outw
37
38 static const char smc9000_version[] = "Version 0.99 98-09-30";
39 static unsigned int smc9000_base=0;
40 static const char *interfaces[ 2 ] = { "TP", "AUI" };
41 static const char *chip_ids[ 15 ] = {
42 NULL, NULL, NULL,
43 /* 3 */ "SMC91C90/91C92",
44 /* 4 */ "SMC91C94",
45 /* 5 */ "SMC91C95",
46 NULL,
47 /* 7 */ "SMC91C100",
48 /* 8 */ "SMC91C100FD",
49 NULL, NULL, NULL,
50 NULL, NULL, NULL
51 };
52 static const char smc91c96_id[] = "SMC91C96";
53
54 /*
55 * Function: smc_reset( int ioaddr )
56 * Purpose:
57 * This sets the SMC91xx chip to its normal state, hopefully from whatever
58 * mess that any other DOS driver has put it in.
59 *
60 * Maybe I should reset more registers to defaults in here? SOFTRESET should
61 * do that for me.
62 *
63 * Method:
64 * 1. send a SOFT RESET
65 * 2. wait for it to finish
66 * 3. reset the memory management unit
67 * 4. clear all interrupts
68 *
69 */
smc_reset(int ioaddr)70 static void smc_reset(int ioaddr)
71 {
72 /* This resets the registers mostly to defaults, but doesn't
73 * affect EEPROM. That seems unnecessary */
74 SMC_SELECT_BANK(ioaddr, 0);
75 _outw( RCR_SOFTRESET, ioaddr + RCR );
76
77 /* this should pause enough for the chip to be happy */
78 SMC_DELAY(ioaddr);
79
80 /* Set the transmit and receive configuration registers to
81 * default values */
82 _outw(RCR_CLEAR, ioaddr + RCR);
83 _outw(TCR_CLEAR, ioaddr + TCR);
84
85 /* Reset the MMU */
86 SMC_SELECT_BANK(ioaddr, 2);
87 _outw( MC_RESET, ioaddr + MMU_CMD );
88
89 /* Note: It doesn't seem that waiting for the MMU busy is needed here,
90 * but this is a place where future chipsets _COULD_ break. Be wary
91 * of issuing another MMU command right after this */
92 _outb(0, ioaddr + INT_MASK);
93 }
94
95
96 /*----------------------------------------------------------------------
97 * Function: smc_probe( int ioaddr )
98 *
99 * Purpose:
100 * Tests to see if a given ioaddr points to an SMC9xxx chip.
101 * Returns a 0 on success
102 *
103 * Algorithm:
104 * (1) see if the high byte of BANK_SELECT is 0x33
105 * (2) compare the ioaddr with the base register's address
106 * (3) see if I recognize the chip ID in the appropriate register
107 *
108 * ---------------------------------------------------------------------
109 */
smc_probe(int ioaddr)110 static int smc_probe( int ioaddr )
111 {
112 word bank;
113 word revision_register;
114 word base_address_register;
115
116 /* First, see if the high byte is 0x33 */
117 bank = inw(ioaddr + BANK_SELECT);
118 if ((bank & 0xFF00) != 0x3300) {
119 return -1;
120 }
121 /* The above MIGHT indicate a device, but I need to write to further
122 * test this. */
123 _outw(0x0, ioaddr + BANK_SELECT);
124 bank = inw(ioaddr + BANK_SELECT);
125 if ((bank & 0xFF00) != 0x3300) {
126 return -1;
127 }
128
129 /* well, we've already written once, so hopefully another time won't
130 * hurt. This time, I need to switch the bank register to bank 1,
131 * so I can access the base address register */
132 SMC_SELECT_BANK(ioaddr, 1);
133 base_address_register = inw(ioaddr + BASE);
134
135 if (ioaddr != (base_address_register >> 3 & 0x3E0)) {
136 #ifdef SMC9000_VERBOSE
137 printf("SMC9000: IOADDR %hX doesn't match configuration (%hX)."
138 "Probably not a SMC chip\n",
139 ioaddr, base_address_register >> 3 & 0x3E0);
140 #endif
141 /* well, the base address register didn't match. Must not have
142 * been a SMC chip after all. */
143 return -1;
144 }
145
146
147 /* check if the revision register is something that I recognize.
148 * These might need to be added to later, as future revisions
149 * could be added. */
150 SMC_SELECT_BANK(ioaddr, 3);
151 revision_register = inw(ioaddr + REVISION);
152 if (!chip_ids[(revision_register >> 4) & 0xF]) {
153 /* I don't recognize this chip, so... */
154 #ifdef SMC9000_VERBOSE
155 printf("SMC9000: IO %hX: Unrecognized revision register:"
156 " %hX, Contact author.\n", ioaddr, revision_register);
157 #endif
158 return -1;
159 }
160
161 /* at this point I'll assume that the chip is an SMC9xxx.
162 * It might be prudent to check a listing of MAC addresses
163 * against the hardware address, or do some other tests. */
164 return 0;
165 }
166
167
168 /**************************************************************************
169 * ETH_RESET - Reset adapter
170 ***************************************************************************/
171
smc9000_reset(struct nic * nic)172 static void smc9000_reset(struct nic *nic)
173 {
174 smc_reset(smc9000_base);
175 }
176
177 /**************************************************************************
178 * ETH_TRANSMIT - Transmit a frame
179 ***************************************************************************/
smc9000_transmit(struct nic * nic,const char * d,unsigned int t,unsigned int s,const char * p)180 static void smc9000_transmit(
181 struct nic *nic,
182 const char *d, /* Destination */
183 unsigned int t, /* Type */
184 unsigned int s, /* size */
185 const char *p) /* Packet */
186 {
187 word length; /* real, length incl. header */
188 word numPages;
189 unsigned long time_out;
190 byte packet_no;
191 word status;
192 int i;
193
194 /* We dont pad here since we can have the hardware doing it for us */
195 length = (s + ETH_HLEN + 1)&~1;
196
197 /* convert to MMU pages */
198 numPages = length / 256;
199
200 if (numPages > 7 ) {
201 #ifdef SMC9000_VERBOSE
202 printf("SMC9000: Far too big packet error. \n");
203 #endif
204 return;
205 }
206
207 /* dont try more than, say 30 times */
208 for (i=0;i<30;i++) {
209 /* now, try to allocate the memory */
210 SMC_SELECT_BANK(smc9000_base, 2);
211 _outw(MC_ALLOC | numPages, smc9000_base + MMU_CMD);
212
213 status = 0;
214 /* wait for the memory allocation to finnish */
215 for (time_out = currticks() + 5*TICKS_PER_SEC; currticks() < time_out; ) {
216 status = inb(smc9000_base + INTERRUPT);
217 if ( status & IM_ALLOC_INT ) {
218 /* acknowledge the interrupt */
219 _outb(IM_ALLOC_INT, smc9000_base + INTERRUPT);
220 break;
221 }
222 }
223
224 if ((status & IM_ALLOC_INT) != 0 ) {
225 /* We've got the memory */
226 break;
227 } else {
228 printf("SMC9000: Memory allocation timed out, resetting MMU.\n");
229 _outw(MC_RESET, smc9000_base + MMU_CMD);
230 }
231 }
232
233 /* If I get here, I _know_ there is a packet slot waiting for me */
234 packet_no = inb(smc9000_base + PNR_ARR + 1);
235 if (packet_no & 0x80) {
236 /* or isn't there? BAD CHIP! */
237 printf("SMC9000: Memory allocation failed. \n");
238 return;
239 }
240
241 /* we have a packet address, so tell the card to use it */
242 _outb(packet_no, smc9000_base + PNR_ARR);
243
244 /* point to the beginning of the packet */
245 _outw(PTR_AUTOINC, smc9000_base + POINTER);
246
247 #if SMC9000_DEBUG > 2
248 printf("Trying to xmit packet of length %hX\n", length );
249 #endif
250
251 /* send the packet length ( +6 for status, length and ctl byte )
252 * and the status word ( set to zeros ) */
253 _outw(0, smc9000_base + DATA_1 );
254
255 /* send the packet length ( +6 for status words, length, and ctl) */
256 _outb((length+6) & 0xFF, smc9000_base + DATA_1);
257 _outb((length+6) >> 8 , smc9000_base + DATA_1);
258
259 /* Write the contents of the packet */
260
261 /* The ethernet header first... */
262 outsw(smc9000_base + DATA_1, d, ETH_ALEN >> 1);
263 outsw(smc9000_base + DATA_1, nic->node_addr, ETH_ALEN >> 1);
264 _outw(htons(t), smc9000_base + DATA_1);
265
266 /* ... the data ... */
267 outsw(smc9000_base + DATA_1 , p, s >> 1);
268
269 /* ... and the last byte, if there is one. */
270 if ((s & 1) == 0) {
271 _outw(0, smc9000_base + DATA_1);
272 } else {
273 _outb(p[s-1], smc9000_base + DATA_1);
274 _outb(0x20, smc9000_base + DATA_1);
275 }
276
277 /* and let the chipset deal with it */
278 _outw(MC_ENQUEUE , smc9000_base + MMU_CMD);
279
280 status = 0; time_out = currticks() + 5*TICKS_PER_SEC;
281 do {
282 status = inb(smc9000_base + INTERRUPT);
283
284 if ((status & IM_TX_INT ) != 0) {
285 word tx_status;
286
287 /* ack interrupt */
288 _outb(IM_TX_INT, smc9000_base + INTERRUPT);
289
290 packet_no = inw(smc9000_base + FIFO_PORTS);
291 packet_no &= 0x7F;
292
293 /* select this as the packet to read from */
294 _outb( packet_no, smc9000_base + PNR_ARR );
295
296 /* read the first word from this packet */
297 _outw( PTR_AUTOINC | PTR_READ, smc9000_base + POINTER );
298
299 tx_status = inw( smc9000_base + DATA_1 );
300
301 if (0 == (tx_status & TS_SUCCESS)) {
302 #ifdef SMC9000_VERBOSE
303 printf("SMC9000: TX FAIL STATUS: %hX \n", tx_status);
304 #endif
305 /* re-enable transmit */
306 SMC_SELECT_BANK(smc9000_base, 0);
307 _outw(inw(smc9000_base + TCR ) | TCR_ENABLE, smc9000_base + TCR );
308 }
309
310 /* kill the packet */
311 SMC_SELECT_BANK(smc9000_base, 2);
312 _outw(MC_FREEPKT, smc9000_base + MMU_CMD);
313
314 return;
315 }
316 }while(currticks() < time_out);
317
318 printf("SMC9000: Waring TX timed out, resetting board\n");
319 smc_reset(smc9000_base);
320 return;
321 }
322
323 /**************************************************************************
324 * ETH_POLL - Wait for a frame
325 ***************************************************************************/
smc9000_poll(struct nic * nic)326 static int smc9000_poll(struct nic *nic)
327 {
328 if(!smc9000_base)
329 return 0;
330
331 SMC_SELECT_BANK(smc9000_base, 2);
332 if (inw(smc9000_base + FIFO_PORTS) & FP_RXEMPTY)
333 return 0;
334
335 /* start reading from the start of the packet */
336 _outw(PTR_READ | PTR_RCV | PTR_AUTOINC, smc9000_base + POINTER);
337
338 /* First read the status and check that we're ok */
339 if (!(inw(smc9000_base + DATA_1) & RS_ERRORS)) {
340 /* Next: read the packet length and mask off the top bits */
341 nic->packetlen = (inw(smc9000_base + DATA_1) & 0x07ff);
342
343 /* the packet length includes the 3 extra words */
344 nic->packetlen -= 6;
345 #if SMC9000_DEBUG > 2
346 printf(" Reading %d words (and %d byte(s))\n",
347 (nic->packetlen >> 1), nic->packetlen & 1);
348 #endif
349 /* read the packet (and the last "extra" word) */
350 insw(smc9000_base + DATA_1, nic->packet, (nic->packetlen+2) >> 1);
351 /* is there an odd last byte ? */
352 if (nic->packet[nic->packetlen+1] & 0x20)
353 nic->packetlen++;
354
355 /* error or good, tell the card to get rid of this packet */
356 _outw(MC_RELEASE, smc9000_base + MMU_CMD);
357 return 1;
358 }
359
360 printf("SMC9000: RX error\n");
361 /* error or good, tell the card to get rid of this packet */
362 _outw(MC_RELEASE, smc9000_base + MMU_CMD);
363 return 0;
364 }
365
smc9000_disable(struct nic * nic)366 static void smc9000_disable(struct nic *nic)
367 {
368 if(!smc9000_base)
369 return;
370
371 /* no more interrupts for me */
372 SMC_SELECT_BANK(smc9000_base, 2);
373 _outb( 0, smc9000_base + INT_MASK);
374
375 /* and tell the card to stay away from that nasty outside world */
376 SMC_SELECT_BANK(smc9000_base, 0);
377 _outb( RCR_CLEAR, smc9000_base + RCR );
378 _outb( TCR_CLEAR, smc9000_base + TCR );
379 }
380
381 /**************************************************************************
382 * ETH_PROBE - Look for an adapter
383 ***************************************************************************/
384
smc9000_probe(struct nic * nic,unsigned short * probe_addrs)385 struct nic *smc9000_probe(struct nic *nic, unsigned short *probe_addrs)
386 {
387 unsigned short revision;
388 int memory;
389 int media;
390 const char * version_string;
391 const char * if_string;
392 int i;
393
394 /*
395 * the SMC9000 can be at any of the following port addresses. To change,
396 * for a slightly different card, you can add it to the array. Keep in
397 * mind that the array must end in zero.
398 */
399 static unsigned short portlist[] = {
400 #ifdef SMC9000_SCAN
401 SMC9000_SCAN,
402 #else
403 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
404 0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0,
405 #endif
406 0 };
407
408 printf("\nSMC9000 %s\n", smc9000_version);
409 #ifdef SMC9000_VERBOSE
410 printf("Copyright (C) 1998 Daniel Engstr\x94m\n");
411 printf("Copyright (C) 1996 Eric Stahlman\n");
412 #endif
413 /* if no addresses supplied, fall back on defaults */
414 if (probe_addrs == 0 || probe_addrs[0] == 0)
415 probe_addrs = portlist;
416
417 /* check every ethernet address */
418 for (i = 0; probe_addrs[i]; i++) {
419 /* check this specific address */
420 if (smc_probe(probe_addrs[i]) == 0)
421 smc9000_base = probe_addrs[i];
422 }
423
424 /* couldn't find anything */
425 if(0 == smc9000_base)
426 goto out;
427
428 /*
429 * Get the MAC address ( bank 1, regs 4 - 9 )
430 */
431 SMC_SELECT_BANK(smc9000_base, 1);
432 for ( i = 0; i < 6; i += 2 ) {
433 word address;
434
435 address = inw(smc9000_base + ADDR0 + i);
436 nic->node_addr[i+1] = address >> 8;
437 nic->node_addr[i] = address & 0xFF;
438 }
439
440
441 /* get the memory information */
442 SMC_SELECT_BANK(smc9000_base, 0);
443 memory = ( inw(smc9000_base + MCR) >> 9 ) & 0x7; /* multiplier */
444 memory *= 256 * (inw(smc9000_base + MIR) & 0xFF);
445
446 /*
447 * Now, I want to find out more about the chip. This is sort of
448 * redundant, but it's cleaner to have it in both, rather than having
449 * one VERY long probe procedure.
450 */
451 SMC_SELECT_BANK(smc9000_base, 3);
452 revision = inw(smc9000_base + REVISION);
453 version_string = chip_ids[(revision >> 4) & 0xF];
454
455 if (((revision & 0xF0) >> 4 == CHIP_9196) &&
456 ((revision & 0x0F) >= REV_9196)) {
457 /* This is a 91c96. 'c96 has the same chip id as 'c94 (4) but
458 * a revision starting at 6 */
459 version_string = smc91c96_id;
460 }
461
462 if ( !version_string ) {
463 /* I shouldn't get here because this call was done before.... */
464 goto out;
465 }
466
467 /* is it using AUI or 10BaseT ? */
468 SMC_SELECT_BANK(smc9000_base, 1);
469 if (inw(smc9000_base + CONFIG) & CFG_AUI_SELECT)
470 media = 2;
471 else
472 media = 1;
473
474 if_string = interfaces[media - 1];
475
476 /* now, reset the chip, and put it into a known state */
477 smc_reset(smc9000_base);
478
479 printf("%s rev:%d I/O port:%hX Interface:%s RAM:%d bytes \n",
480 version_string, revision & 0xF,
481 smc9000_base, if_string, memory );
482 /*
483 * Print the Ethernet address
484 */
485 printf("Ethernet MAC address: %!\n", nic->node_addr);
486
487 SMC_SELECT_BANK(smc9000_base, 0);
488
489 /* see the header file for options in TCR/RCR NORMAL*/
490 _outw(TCR_NORMAL, smc9000_base + TCR);
491 _outw(RCR_NORMAL, smc9000_base + RCR);
492
493 /* Select which interface to use */
494 SMC_SELECT_BANK(smc9000_base, 1);
495 if ( media == 1 ) {
496 _outw( inw( smc9000_base + CONFIG ) & ~CFG_AUI_SELECT,
497 smc9000_base + CONFIG );
498 }
499 else if ( media == 2 ) {
500 _outw( inw( smc9000_base + CONFIG ) | CFG_AUI_SELECT,
501 smc9000_base + CONFIG );
502 }
503
504 nic->reset = smc9000_reset;
505 nic->poll = smc9000_poll;
506 nic->transmit = smc9000_transmit;
507 nic->disable = smc9000_disable;
508
509
510 return nic;
511
512 out:
513 #ifdef SMC9000_VERBOSE
514 printf("No SMC9000 adapters found\n");
515 #endif
516 smc9000_base = 0;
517
518 return (0);
519 }
520
521
522
523