Updated to general ISA bus API.
[people/lynusvaz/gpxe.git] / src / drivers / net / sk_g16.c
1 /* Uses lance chip, not fixed for relocation */
2 #ifdef ALLMULTI
3 #error multicast support is not yet implemented
4 #endif
5 /**************************************************************************
6 Etherboot -  BOOTP/TFTP Bootstrap Program
7 Schneider & Koch G16 NIC driver for Etherboot
8 heavily based on SK G16 driver from Linux 2.0.36
9 Changes to make it work with Etherboot by Georg Baum <Georg.Baum@gmx.de>
10 ***************************************************************************/
11
12 /*-
13  * Copyright (C) 1994 by PJD Weichmann & SWS Bern, Switzerland
14  *
15  * This software may be used and distributed according to the terms
16  * of the GNU Public License, incorporated herein by reference.
17  *
18  * Module         : sk_g16.c
19  *
20  * Version        : $Revision$
21  *
22  * Author         : Patrick J.D. Weichmann
23  *
24  * Date Created   : 94/05/26
25  * Last Updated   : $Date$
26  *
27  * Description    : Schneider & Koch G16 Ethernet Device Driver for
28  *                  Linux Kernel >= 1.1.22
29  * Update History :
30  *
31 -*/
32
33 /*
34  * The Schneider & Koch (SK) G16 Network device driver is based
35  * on the 'ni6510' driver from Michael Hipp which can be found at
36  * ftp://sunsite.unc.edu/pub/Linux/system/Network/drivers/nidrivers.tar.gz
37  *
38  * Sources: 1) ni6510.c by M. Hipp
39  *          2) depca.c  by D.C. Davies
40  *          3) skeleton.c by D. Becker
41  *          4) Am7990 Local Area Network Controller for Ethernet (LANCE),
42  *             AMD, Pub. #05698, June 1989
43  *
44  * Many Thanks for helping me to get things working to:
45  *
46  *                 A. Cox (A.Cox@swansea.ac.uk)
47  *                 M. Hipp (mhipp@student.uni-tuebingen.de)
48  *                 R. Bolz (Schneider & Koch, Germany)
49  *
50  * See README.sk_g16 for details about limitations and bugs for the
51  * current version.
52  *
53  * To Do:
54  *        - Support of SK_G8 and other SK Network Cards.
55  *        - Autoset memory mapped RAM. Check for free memory and then
56  *          configure RAM correctly.
57  *        - SK_close should really set card in to initial state.
58  *        - Test if IRQ 3 is not switched off. Use autoirq() functionality.
59  *          (as in /drivers/net/skeleton.c)
60  *        - Implement Multicast addressing. At minimum something like
61  *          in depca.c.
62  *        - Redo the statistics part.
63  *        - Try to find out if the board is in 8 Bit or 16 Bit slot.
64  *          If in 8 Bit mode don't use IRQ 11.
65  *        - (Try to make it slightly faster.)
66  */
67
68 /* to get some global routines like printf */
69 #include "etherboot.h"
70 /* to get the interface to the body of the program */
71 #include "nic.h"
72 #include "isa.h"
73
74 /* From linux/if_ether.h: */
75 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
76
77 #include "sk_g16.h"
78
79 /*
80  * Schneider & Koch Card Definitions
81  * =================================
82  */
83
84 #define SK_NAME   "SK_G16"
85
86 /*
87  * SK_G16 Configuration
88  * --------------------
89  */
90
91 /*
92  * Abbreviations
93  * -------------
94  *
95  * RAM - used for the 16KB shared memory
96  * Boot_ROM, ROM - are used for referencing the BootEPROM
97  *
98  * SK_ADDR is a symbolic constant used to configure
99  * the behaviour of the driver and the SK_G16.
100  *
101  * SK_ADDR defines the address where the RAM will be mapped into the real
102  *         host memory.
103  *         valid addresses are from 0xa0000 to 0xfc000 in 16Kbyte steps.
104  */
105
106 #define SK_ADDR         0xcc000
107
108 /*
109  * In POS3 are bits A14-A19 of the address bus. These bits can be set
110  * to choose the RAM address. That's why we only can choose the RAM address
111  * in 16KB steps.
112  */
113
114 #define POS_ADDR       (rom_addr>>14)  /* Do not change this line */
115
116 /*
117  * SK_G16 I/O PORT's + IRQ's + Boot_ROM locations
118  * ----------------------------------------------
119  */
120
121 /*
122  * As nearly every card has also SK_G16 a specified I/O Port region and
123  * only a few possible IRQ's.
124  * In the Installation Guide from Schneider & Koch is listed a possible
125  * Interrupt IRQ2. IRQ2 is always IRQ9 in boards with two cascaded interrupt
126  * controllers. So we use in SK_IRQS IRQ9.
127  */
128
129 /* Don't touch any of the following #defines. */
130
131 #define SK_IO_PORTS     { 0x100, 0x180, 0x208, 0x220, 0x288, 0x320, 0x328, 0x390, 0 }
132
133 /*
134  * SK_G16 POS REGISTERS
135  * --------------------
136  */
137
138 /*
139  * SK_G16 has a Programmable Option Select (POS) Register.
140  * The POS is composed of 8 separate registers (POS0-7) which
141  * are I/O mapped on an address set by the W1 switch.
142  *
143  */
144
145 #define SK_POS_SIZE 8           /* 8 I/O Ports are used by SK_G16 */
146
147 #define SK_POS0     ioaddr      /* Card-ID Low (R) */
148 #define SK_POS1     ioaddr+1    /* Card-ID High (R) */
149 #define SK_POS2     ioaddr+2    /* Card-Enable, Boot-ROM Disable (RW) */
150 #define SK_POS3     ioaddr+3    /* Base address of RAM */
151 #define SK_POS4     ioaddr+4    /* IRQ */
152
153 /* POS5 - POS7 are unused */
154
155 /*
156  * SK_G16 MAC PREFIX
157  * -----------------
158  */
159
160 /*
161  * Scheider & Koch manufacturer code (00:00:a5).
162  * This must be checked, that we are sure it is a SK card.
163  */
164
165 #define SK_MAC0         0x00
166 #define SK_MAC1         0x00
167 #define SK_MAC2         0x5a
168
169 /*
170  * SK_G16 ID
171  * ---------
172  */
173
174 /*
175  * If POS0,POS1 contain the following ID, then we know
176  * at which I/O Port Address we are.
177  */
178
179 #define SK_IDLOW  0xfd
180 #define SK_IDHIGH 0x6a
181
182
183 /*
184  * LANCE POS Bit definitions
185  * -------------------------
186  */
187
188 #define SK_ROM_RAM_ON  (POS2_CARD)
189 #define SK_ROM_RAM_OFF (POS2_EPROM)
190 #define SK_ROM_ON      (inb(SK_POS2) & POS2_CARD)
191 #define SK_ROM_OFF     (inb(SK_POS2) | POS2_EPROM)
192 #define SK_RAM_ON      (inb(SK_POS2) | POS2_CARD)
193 #define SK_RAM_OFF     (inb(SK_POS2) & POS2_EPROM)
194
195 #define POS2_CARD  0x0001              /* 1 = SK_G16 on      0 = off */
196 #define POS2_EPROM 0x0002              /* 1 = Boot EPROM off 0 = on */
197
198 /*
199  * SK_G16 Memory mapped Registers
200  * ------------------------------
201  *
202  */
203
204 #define SK_IOREG        (board->ioreg) /* LANCE data registers.     */
205 #define SK_PORT         (board->port)  /* Control, Status register  */
206 #define SK_IOCOM        (board->iocom) /* I/O Command               */
207
208 /*
209  * SK_G16 Status/Control Register bits
210  * -----------------------------------
211  *
212  * (C) Controlreg (S) Statusreg
213  */
214
215 /*
216  * Register transfer: 0 = no transfer
217  *                    1 = transferring data between LANCE and I/O reg
218  */
219 #define SK_IORUN        0x20
220
221 /*
222  * LANCE interrupt: 0 = LANCE interrupt occurred
223  *                  1 = no LANCE interrupt occurred
224  */
225 #define SK_IRQ          0x10
226
227 #define SK_RESET        0x08   /* Reset SK_CARD: 0 = RESET 1 = normal */
228 #define SK_RW           0x02   /* 0 = write to 1 = read from */
229 #define SK_ADR          0x01   /* 0 = REG DataPort 1 = RAP Reg addr port */
230
231
232 #define SK_RREG         SK_RW  /* Transferdirection to read from lance */
233 #define SK_WREG         0      /* Transferdirection to write to lance */
234 #define SK_RAP          SK_ADR /* Destination Register RAP */
235 #define SK_RDATA        0      /* Destination Register REG DataPort */
236
237 /*
238  * SK_G16 I/O Command
239  * ------------------
240  */
241
242 /*
243  * Any bitcombination sets the internal I/O bit (transfer will start)
244  * when written to I/O Command
245  */
246
247 #define SK_DOIO         0x80   /* Do Transfer */
248
249 /*
250  * LANCE RAP (Register Address Port).
251  * ---------------------------------
252  */
253
254 /*
255  * The LANCE internal registers are selected through the RAP.
256  * The Registers are:
257  *
258  * CSR0 - Status and Control flags
259  * CSR1 - Low order bits of initialize block (bits 15:00)
260  * CSR2 - High order bits of initialize block (bits 07:00, 15:08 are reserved)
261  * CSR3 - Allows redefinition of the Bus Master Interface.
262  *        This register must be set to 0x0002, which means BSWAP = 0,
263  *        ACON = 1, BCON = 0;
264  *
265  */
266
267 #define CSR0            0x00
268 #define CSR1            0x01
269 #define CSR2            0x02
270 #define CSR3            0x03
271
272 /*
273  * General Definitions
274  * ===================
275  */
276
277 /*
278  * Set the number of Tx and Rx buffers, using Log_2(# buffers).
279  * We have 16KB RAM which can be accessed by the LANCE. In the
280  * memory are not only the buffers but also the ring descriptors and
281  * the initialize block.
282  * Don't change anything unless you really know what you do.
283  */
284
285 #define LC_LOG_TX_BUFFERS 1               /* (2 == 2^^1) 2 Transmit buffers */
286 #define LC_LOG_RX_BUFFERS 2               /* (8 == 2^^3) 8 Receive buffers */
287
288 /* Descriptor ring sizes */
289
290 #define TMDNUM (1 << (LC_LOG_TX_BUFFERS)) /* 2 Transmit descriptor rings */
291 #define RMDNUM (1 << (LC_LOG_RX_BUFFERS)) /* 8 Receive Buffers */
292
293 /* Define Mask for setting RMD, TMD length in the LANCE init_block */
294
295 #define TMDNUMMASK (LC_LOG_TX_BUFFERS << 29)
296 #define RMDNUMMASK (LC_LOG_RX_BUFFERS << 29)
297
298 /*
299  * Data Buffer size is set to maximum packet length.
300  */
301
302 #define PKT_BUF_SZ              1518
303
304 /*
305  * The number of low I/O ports used by the ethercard.
306  */
307
308 #define ETHERCARD_TOTAL_SIZE    SK_POS_SIZE
309
310 /*
311  * Portreserve is there to mark the Card I/O Port region as used.
312  * Check_region is to check if the region at ioaddr with the size "size"
313  * is free or not.
314  * Snarf_region allocates the I/O Port region.
315  */
316
317 #ifndef HAVE_PORTRESERVE
318
319 #define check_region(ioaddr1, size)              0
320 #define request_region(ioaddr1, size,name)       do ; while (0)
321
322 #endif
323
324 /*
325  * SK_DEBUG
326  *
327  * Here you can choose what level of debugging wanted.
328  *
329  * If SK_DEBUG and SK_DEBUG2 are undefined, then only the
330  *  necessary messages will be printed.
331  *
332  * If SK_DEBUG is defined, there will be many debugging prints
333  *  which can help to find some mistakes in configuration or even
334  *  in the driver code.
335  *
336  * If SK_DEBUG2 is defined, many many messages will be printed
337  *  which normally you don't need. I used this to check the interrupt
338  *  routine.
339  *
340  * (If you define only SK_DEBUG2 then only the messages for
341  *  checking interrupts will be printed!)
342  *
343  * Normal way of live is:
344  *
345  * For the whole thing get going let both symbolic constants
346  * undefined. If you face any problems and you know what's going
347  * on (you know something about the card and you can interpret some
348  * hex LANCE register output) then define SK_DEBUG
349  *
350  */
351
352 #undef  SK_DEBUG        /* debugging */
353 #undef  SK_DEBUG2       /* debugging with more verbose report */
354
355 #ifdef  SK_DEBUG
356 #define PRINTF(x) printf x
357 #else
358 #define PRINTF(x) /**/
359 #endif
360
361 #ifdef  SK_DEBUG2
362 #define PRINTF2(x) printf x
363 #else
364 #define PRINTF2(x) /**/
365 #endif
366
367 /*
368  * SK_G16 RAM
369  *
370  * The components are memory mapped and can be set in a region from
371  * 0x00000 through 0xfc000 in 16KB steps.
372  *
373  * The Network components are: dual ported RAM, Prom, I/O Reg, Status-,
374  * Controlregister and I/O Command.
375  *
376  * dual ported RAM: This is the only memory region which the LANCE chip
377  *      has access to. From the Lance it is addressed from 0x0000 to
378  *      0x3fbf. The host accesses it normally.
379  *
380  * PROM: The PROM obtains the ETHERNET-MAC-Address. It is realised as a
381  *       8-Bit PROM, this means only the 16 even addresses are used of the
382  *       32 Byte Address region. Access to a odd address results in invalid
383  *       data.
384  *
385  * LANCE I/O Reg: The I/O Reg is build of 4 single Registers, Low-Byte Write,
386  *       Hi-Byte Write, Low-Byte Read, Hi-Byte Read.
387  *       Transfer from or to the LANCE is always in 16Bit so Low and High
388  *       registers are always relevant.
389  *
390  *       The Data from the Readregister is not the data in the Writeregister!!
391  *
392  * Port: Status- and Controlregister.
393  *       Two different registers which share the same address, Status is
394  *       read-only, Control is write-only.
395  *
396  * I/O Command:
397  *       Any bitcombination written in here starts the transmission between
398  *       Host and LANCE.
399  */
400
401 typedef struct
402 {
403         unsigned char  ram[0x3fc0];   /* 16KB dual ported ram */
404         unsigned char  rom[0x0020];   /* 32Byte PROM containing 6Byte MAC */
405         unsigned char  res1[0x0010];  /* reserved */
406         unsigned volatile short ioreg;/* LANCE I/O Register */
407         unsigned volatile char  port; /* Statusregister and Controlregister */
408         unsigned char  iocom;         /* I/O Command Register */
409 } SK_RAM;
410
411 /* struct  */
412
413 /*
414  * This is the structure for the dual ported ram. We
415  * have exactly 16 320 Bytes. In here there must be:
416  *
417  *     - Initialize Block   (starting at a word boundary)
418  *     - Receive and Transmit Descriptor Rings (quadword boundary)
419  *     - Data Buffers (arbitrary boundary)
420  *
421  * This is because LANCE has on SK_G16 only access to the dual ported
422  * RAM and nowhere else.
423  */
424
425 struct SK_ram
426 {
427     struct init_block ib;
428     struct tmd tmde[TMDNUM];
429     struct rmd rmde[RMDNUM];
430     char tmdbuf[TMDNUM][PKT_BUF_SZ];
431     char rmdbuf[RMDNUM][PKT_BUF_SZ];
432 };
433
434 /*
435  * Structure where all necessary information is for ring buffer
436  * management and statistics.
437  */
438
439 struct priv
440 {
441     struct SK_ram *ram;  /* dual ported ram structure */
442     struct rmd *rmdhead; /* start of receive ring descriptors */
443     struct tmd *tmdhead; /* start of transmit ring descriptors */
444     int        rmdnum;   /* actual used ring descriptor */
445     int        tmdnum;   /* actual transmit descriptor for transmitting data */
446     int        tmdlast;  /* last sent descriptor used for error handling, etc */
447     void       *rmdbufs[RMDNUM]; /* pointer to the receive buffers */
448     void       *tmdbufs[TMDNUM]; /* pointer to the transmit buffers */
449 };
450
451 /* global variable declaration */
452
453 /* static variables */
454
455 static SK_RAM *board;  /* pointer to our memory mapped board components */
456 static unsigned short   ioaddr; /* base io address */
457 static struct priv      p_data;
458
459 /* Macros */
460
461
462 /* Function Prototypes */
463
464 /*
465  * Device Driver functions
466  * -----------------------
467  * See for short explanation of each function its definitions header.
468  */
469
470 static int   SK_probe1(struct nic *nic, short ioaddr1);
471
472 static int SK_poll(struct nic *nic, int retrieve);
473 static void SK_transmit(
474 struct nic *nic,
475 const char *d,                  /* Destination */
476 unsigned int t,                 /* Type */
477 unsigned int s,                 /* size */
478 const char *p);                 /* Packet */
479 static void SK_disable(struct nic *nic);
480 static int  SK_probe(struct dev *dev);
481
482 /*
483  * LANCE Functions
484  * ---------------
485  */
486
487 static int SK_lance_init(struct nic *nic, unsigned short mode);
488 static void SK_reset_board(void);
489 static void SK_set_RAP(int reg_number);
490 static int SK_read_reg(int reg_number);
491 static int SK_rread_reg(void);
492 static void SK_write_reg(int reg_number, int value);
493
494 /*
495  * Debugging functions
496  * -------------------
497  */
498
499 #ifdef  SK_DEBUG
500 static void SK_print_pos(struct nic *nic, char *text);
501 static void SK_print_ram(struct nic *nic);
502 #endif
503
504
505 /**************************************************************************
506 POLL - Wait for a frame
507 ***************************************************************************/
508 static int SK_poll(struct nic *nic, int retrieve)
509 {
510         /* return true if there's an ethernet packet ready to read */
511         struct priv *p;         /* SK_G16 private structure */
512         struct rmd *rmdp;
513         int csr0, rmdstat, packet_there;
514     PRINTF2(("## %s: At beginning of SK_poll(). CSR0: %#hX\n",
515            SK_NAME, SK_read_reg(CSR0)));
516
517         p = nic->priv_data;
518     csr0 = SK_read_reg(CSR0);      /* store register for checking */
519
520     rmdp = p->rmdhead + p->rmdnum;
521     packet_there = 0;
522
523     if ( !(rmdp->u.s.status & RX_OWN) && !retrieve ) return 1;
524       
525     /*
526      * Acknowledge all of the current interrupt sources, disable
527      * Interrupts (INEA = 0)
528      */
529
530     SK_write_reg(CSR0, csr0 & CSR0_CLRALL);
531
532     if (csr0 & CSR0_ERR) /* LANCE Error */
533     {
534         printf("%s: error: %#hX", SK_NAME, csr0);
535
536         if (csr0 & CSR0_MISS)      /* No place to store packet ? */
537         {
538                 printf(", Packet dropped.");
539         }
540         putchar('\n');
541     }
542
543     /* As long as we own the next entry, check status and send
544      * it up to higher layer
545      */
546
547     while (!( (rmdstat = rmdp->u.s.status) & RX_OWN))
548     {
549         /*
550          * Start and end of packet must be set, because we use
551          * the ethernet maximum packet length (1518) as buffer size.
552          *
553          * Because our buffers are at maximum OFLO and BUFF errors are
554          * not to be concerned (see Data sheet)
555          */
556
557         if ((rmdstat & (RX_STP | RX_ENP)) != (RX_STP | RX_ENP))
558         {
559             /* Start of a frame > 1518 Bytes ? */
560
561             if (rmdstat & RX_STP)
562             {
563                 printf("%s: packet too long\n", SK_NAME);
564             }
565
566             /*
567              * All other packets will be ignored until a new frame with
568              * start (RX_STP) set follows.
569              *
570              * What we do is just give descriptor free for new incoming
571              * packets.
572              */
573
574             rmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */
575
576         }
577         else if (rmdstat & RX_ERR)          /* Receive Error ? */
578         {
579             printf("%s: RX error: %#hX\n", SK_NAME, (int) rmdstat);
580             rmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */
581         }
582         else /* We have a packet which can be queued for the upper layers */
583         {
584
585             int len = (rmdp->mlen & 0x0fff);  /* extract message length from receive buffer */
586
587             /*
588              * Copy data out of our receive descriptor into nic->packet.
589              *
590              * (rmdp->u.buffer & 0x00ffffff) -> get address of buffer and
591              * ignore status fields)
592              */
593
594             memcpy(nic->packet, (unsigned char *) (rmdp->u.buffer & 0x00ffffff), nic->packetlen = len);
595             packet_there = 1;
596
597
598             /*
599              * Packet is queued and marked for processing so we
600              * free our descriptor
601              */
602
603             rmdp->u.s.status = RX_OWN;
604
605             p->rmdnum++;
606             p->rmdnum %= RMDNUM;
607
608             rmdp = p->rmdhead + p->rmdnum;
609         }
610     }
611     SK_write_reg(CSR0, CSR0_INEA); /* Enable Interrupts */
612         return (packet_there);
613 }
614
615 /**************************************************************************
616 TRANSMIT - Transmit a frame
617 ***************************************************************************/
618 static void SK_transmit(
619 struct nic *nic,
620 const char *d,                  /* Destination */
621 unsigned int t,                 /* Type */
622 unsigned int s,                 /* size */
623 const char *pack)               /* Packet */
624 {
625         /* send the packet to destination */
626     struct priv *p;         /* SK_G16 private structure */
627     struct tmd *tmdp;
628     short len;
629     int csr0, tmdstat;
630
631     PRINTF2(("## %s: At beginning of SK_transmit(). CSR0: %#hX\n",
632            SK_NAME, SK_read_reg(CSR0)));
633         p = nic->priv_data;
634         tmdp = p->tmdhead + p->tmdnum; /* Which descriptor for transmitting */
635
636         /* Copy data into dual ported ram */
637
638         memcpy(&p->ram->tmdbuf[p->tmdnum][0], d, ETH_ALEN);     /* dst */
639         memcpy(&p->ram->tmdbuf[p->tmdnum][ETH_ALEN], nic->node_addr, ETH_ALEN); /* src */
640         p->ram->tmdbuf[p->tmdnum][ETH_ALEN + ETH_ALEN] = t >> 8;        /* type */
641         p->ram->tmdbuf[p->tmdnum][ETH_ALEN + ETH_ALEN + 1] = t; /* type */
642         memcpy(&p->ram->tmdbuf[p->tmdnum][ETH_HLEN], pack, s);
643         s += ETH_HLEN;
644         while (s < ETH_ZLEN)    /* pad to min length */
645                 p->ram->tmdbuf[p->tmdnum][s++] = 0;
646         p->ram->tmde[p->tmdnum].status2 = 0x0;
647
648         /* Evaluate Packet length */
649         len = ETH_ZLEN < s ? s : ETH_ZLEN;
650
651         /* Fill in Transmit Message Descriptor */
652
653         tmdp->blen = -len;            /* set length to transmit */
654
655         /*
656          * Packet start and end is always set because we use the maximum
657          * packet length as buffer length.
658          * Relinquish ownership to LANCE
659          */
660
661         tmdp->u.s.status = TX_OWN | TX_STP | TX_ENP;
662
663         /* Start Demand Transmission */
664         SK_write_reg(CSR0, CSR0_TDMD | CSR0_INEA);
665
666     csr0 = SK_read_reg(CSR0);      /* store register for checking */
667
668     /*
669      * Acknowledge all of the current interrupt sources, disable
670      * Interrupts (INEA = 0)
671      */
672
673     SK_write_reg(CSR0, csr0 & CSR0_CLRALL);
674
675     if (csr0 & CSR0_ERR) /* LANCE Error */
676     {
677         printf("%s: error: %#hX", SK_NAME, csr0);
678
679         if (csr0 & CSR0_MISS)      /* No place to store packet ? */
680         {
681                 printf(", Packet dropped.");
682         }
683         putchar('\n');
684     }
685
686
687     /* Set next buffer */
688     p->tmdlast++;
689     p->tmdlast &= TMDNUM-1;
690
691     tmdstat = tmdp->u.s.status & 0xff00; /* filter out status bits 15:08 */
692
693     /*
694      * We check status of transmitted packet.
695      * see LANCE data-sheet for error explanation
696      */
697     if (tmdstat & TX_ERR) /* Error occurred */
698     {
699         printf("%s: TX error: %#hX %#hX\n", SK_NAME, (int) tmdstat,
700                 (int) tmdp->status2);
701
702         if (tmdp->status2 & TX_TDR)    /* TDR problems? */
703         {
704             printf("%s: tdr-problems \n", SK_NAME);
705         }
706
707         if (tmdp->status2 & TX_UFLO)   /* Underflow error ? */
708         {
709             /*
710              * If UFLO error occurs it will turn transmitter of.
711              * So we must reinit LANCE
712              */
713
714             SK_lance_init(nic, MODE_NORMAL);
715         }
716
717         tmdp->status2 = 0;             /* Clear error flags */
718     }
719
720     SK_write_reg(CSR0, CSR0_INEA); /* Enable Interrupts */
721
722         /* Set pointer to next transmit buffer */
723         p->tmdnum++;
724         p->tmdnum &= TMDNUM-1;
725
726 }
727
728 /**************************************************************************
729 DISABLE - Turn off ethernet interface
730 ***************************************************************************/
731 static void SK_disable ( struct nic *nic ) {
732
733         /* put the card in its initial state */
734         SK_lance_init(nic, MODE_NORMAL);        /* reset and disable merge */
735         
736         PRINTF(("## %s: At beginning of SK_disable(). CSR0: %#hX\n",
737                 SK_NAME, SK_read_reg(CSR0)));
738         PRINTF(("%s: Shutting %s down CSR0 %#hX\n", SK_NAME, SK_NAME,
739                 (int) SK_read_reg(CSR0)));
740
741         SK_write_reg(CSR0, CSR0_STOP); /* STOP the LANCE */
742 }
743
744 /**************************************************************************
745 IRQ - Enable, Disable, or Force interrupts
746 ***************************************************************************/
747 static void SK_irq(struct nic *nic __unused, irq_action_t action __unused)
748 {
749   switch ( action ) {
750   case DISABLE :
751     break;
752   case ENABLE :
753     break;
754   case FORCE :
755     break;
756   }
757 }
758
759 /**************************************************************************
760 PROBE - Look for an adapter, this routine's visible to the outside
761 ***************************************************************************/
762 static int SK_probe(struct dev *dev, unsigned short *probe_addrs)
763 {
764         struct nic *nic = (struct nic *)dev;
765         unsigned short          *p;
766         static unsigned short   io_addrs[] = SK_IO_PORTS;
767         /* if probe_addrs is 0, then routine can use a hardwired default */
768         nic->priv_data = &p_data;
769         if (probe_addrs == 0)
770                 probe_addrs = io_addrs;
771         for (p = probe_addrs; (ioaddr = *p) != 0; ++p)
772         {
773                 long            offset1, offset0 = inb(ioaddr);
774                 if ((offset0 == SK_IDLOW) &&
775                  ((offset1 = inb(ioaddr + 1)) == SK_IDHIGH))
776                         if (SK_probe1(nic, ioaddr) >= 0)
777                                 break;
778         }
779         /* if board found */
780         if (ioaddr != 0)
781         {
782                 nic->ioaddr = ioaddr & ~3;
783                 nic->irqno  = 0;
784                 /* point to NIC specific routines */
785 static struct nic_operations SK_operations;
786 static struct nic_operations SK_operations = {
787         .connect        = dummy_connect,
788         .poll           = SK_poll,
789         .transmit       = SK_transmit,
790         .irq            = SK_irq,
791         .disable        = SK_disable,
792 };              nic->nic_op     = &SK_operations;
793                 /* FIXME set dev->devid */
794                 return 1;
795         }
796         /* else */
797         {
798                 return 0;
799         }
800 }
801
802 int SK_probe1(struct nic *nic, short ioaddr1 __unused)
803 {
804     int i,j;                /* Counters */
805     unsigned int rom_addr;  /* used to store RAM address used for POS_ADDR */
806
807     struct priv *p;         /* SK_G16 private structure */
808
809     if (SK_ADDR & 0x3fff || SK_ADDR < 0xa0000)
810     {
811        /*
812         * Now here we could use a routine which searches for a free
813         * place in the ram and set SK_ADDR if found. TODO.
814         */
815             printf("%s: SK_ADDR %#hX is not valid. Check configuration.\n",
816                     SK_NAME, SK_ADDR);
817             return -1;
818     }
819
820     rom_addr = SK_ADDR;
821
822     outb(SK_ROM_RAM_OFF, SK_POS2); /* Boot_ROM + RAM off */
823     outb(POS_ADDR, SK_POS3);       /* Set RAM address */
824     outb(SK_ROM_RAM_ON, SK_POS2);  /* RAM on, BOOT_ROM on */
825 #ifdef  SK_DEBUG
826     SK_print_pos(nic, "POS registers after ROM, RAM config");
827 #endif
828
829     board = (SK_RAM *) rom_addr;
830         PRINTF(("adr[0]: %hX, adr[1]: %hX, adr[2]: %hX\n",
831         board->rom[0], board->rom[2], board->rom[4]));
832
833     /* Read in station address */
834     for (i = 0, j = 0; i < ETH_ALEN; i++, j+=2)
835     {
836         *(nic->node_addr+i) = board->rom[j];
837     }
838
839     /* Check for manufacturer code */
840 #ifdef  SK_DEBUG
841     if (!(*(nic->node_addr+0) == SK_MAC0 &&
842           *(nic->node_addr+1) == SK_MAC1 &&
843           *(nic->node_addr+2) == SK_MAC2) )
844     {
845         PRINTF(("## %s: We did not find SK_G16 at RAM location.\n",
846                 SK_NAME));
847         return -1;                     /* NO SK_G16 found */
848     }
849 #endif
850
851     p = nic->priv_data;
852
853     /* Initialize private structure */
854
855     p->ram = (struct SK_ram *) rom_addr; /* Set dual ported RAM addr */
856     p->tmdhead = &(p->ram)->tmde[0];     /* Set TMD head */
857     p->rmdhead = &(p->ram)->rmde[0];     /* Set RMD head */
858
859     printf("Schneider & Koch G16 at %#hX, mem at %#hX, HW addr: %!\n",
860             (unsigned int) ioaddr, (unsigned int) p->ram, nic->node_addr);
861
862     /* Initialize buffer pointers */
863
864     for (i = 0; i < TMDNUM; i++)
865     {
866         p->tmdbufs[i] = p->ram->tmdbuf[i];
867     }
868
869     for (i = 0; i < RMDNUM; i++)
870     {
871         p->rmdbufs[i] = p->ram->rmdbuf[i];
872     }
873     i = 0;
874
875     if (!(i = SK_lance_init(nic, MODE_NORMAL)))  /* LANCE init OK? */
876     {
877
878 #ifdef  SK_DEBUG
879         /*
880          * This debug block tries to stop LANCE,
881          * reinit LANCE with transmitter and receiver disabled,
882          * then stop again and reinit with NORMAL_MODE
883          */
884
885         printf("## %s: After lance init. CSR0: %#hX\n",
886                SK_NAME, SK_read_reg(CSR0));
887         SK_write_reg(CSR0, CSR0_STOP);
888         printf("## %s: LANCE stopped. CSR0: %#hX\n",
889                SK_NAME, SK_read_reg(CSR0));
890         SK_lance_init(nic, MODE_DTX | MODE_DRX);
891         printf("## %s: Reinit with DTX + DRX off. CSR0: %#hX\n",
892                SK_NAME, SK_read_reg(CSR0));
893         SK_write_reg(CSR0, CSR0_STOP);
894         printf("## %s: LANCE stopped. CSR0: %#hX\n",
895                SK_NAME, SK_read_reg(CSR0));
896         SK_lance_init(nic, MODE_NORMAL);
897         printf("## %s: LANCE back to normal mode. CSR0: %#hX\n",
898                SK_NAME, SK_read_reg(CSR0));
899         SK_print_pos(nic, "POS regs before returning OK");
900
901 #endif  /* SK_DEBUG */
902
903     }
904     else /* LANCE init failed */
905     {
906
907         PRINTF(("## %s: LANCE init failed: CSR0: %#hX\n",
908                SK_NAME, SK_read_reg(CSR0)));
909         return -1;
910     }
911
912 #ifdef  SK_DEBUG
913     SK_print_pos(nic, "End of SK_probe1");
914     SK_print_ram(nic);
915 #endif
916
917     return 0;                            /* Initialization done */
918
919 } /* End of SK_probe1() */
920
921 static int SK_lance_init(struct nic *nic, unsigned short mode)
922 {
923     int i;
924     struct priv *p = (struct priv *) nic->priv_data;
925     struct tmd  *tmdp;
926     struct rmd  *rmdp;
927
928     PRINTF(("## %s: At beginning of LANCE init. CSR0: %#hX\n",
929            SK_NAME, SK_read_reg(CSR0)));
930
931     /* Reset LANCE */
932     SK_reset_board();
933
934     /* Initialize TMD's with start values */
935     p->tmdnum = 0;                   /* First descriptor for transmitting */
936     p->tmdlast = 0;                  /* First descriptor for reading stats */
937
938     for (i = 0; i < TMDNUM; i++)     /* Init all TMD's */
939     {
940         tmdp = p->tmdhead + i;
941
942         tmdp->u.buffer = (unsigned long) p->tmdbufs[i]; /* assign buffer */
943
944         /* Mark TMD as start and end of packet */
945         tmdp->u.s.status = TX_STP | TX_ENP;
946     }
947
948
949     /* Initialize RMD's with start values */
950
951     p->rmdnum = 0;                   /* First RMD which will be used */
952
953     for (i = 0; i < RMDNUM; i++)     /* Init all RMD's */
954     {
955         rmdp = p->rmdhead + i;
956
957
958         rmdp->u.buffer = (unsigned long) p->rmdbufs[i]; /* assign buffer */
959
960         /*
961          * LANCE must be owner at beginning so that he can fill in
962          * receiving packets, set status and release RMD
963          */
964
965         rmdp->u.s.status = RX_OWN;
966
967         rmdp->blen = -PKT_BUF_SZ;    /* Buffer Size in a two's complement */
968
969         rmdp->mlen = 0;              /* init message length */
970
971     }
972
973     /* Fill LANCE Initialize Block */
974
975     (p->ram)->ib.mode = mode;        /* Set operation mode */
976
977     for (i = 0; i < ETH_ALEN; i++)   /* Set physical address */
978     {
979         (p->ram)->ib.paddr[i] = *(nic->node_addr+i);
980     }
981
982     for (i = 0; i < 8; i++)          /* Set multicast, logical address */
983     {
984         (p->ram)->ib.laddr[i] = 0;   /* We do not use logical addressing */
985     }
986
987     /* Set ring descriptor pointers and set number of descriptors */
988
989     (p->ram)->ib.rdrp = (int)  p->rmdhead | RMDNUMMASK;
990     (p->ram)->ib.tdrp = (int)  p->tmdhead | TMDNUMMASK;
991
992     /* Prepare LANCE Control and Status Registers */
993
994     SK_write_reg(CSR3, CSR3_ACON);   /* Ale Control !!!THIS MUST BE SET!!!! */
995
996     /*
997      * LANCE addresses the RAM from 0x0000 to 0x3fbf and has no access to
998      * PC Memory locations.
999      *
1000      * In structure SK_ram is defined that the first thing in ram
1001      * is the initialization block. So his address is for LANCE always
1002      * 0x0000
1003      *
1004      * CSR1 contains low order bits 15:0 of initialization block address
1005      * CSR2 is built of:
1006      *    7:0  High order bits 23:16 of initialization block address
1007      *   15:8  reserved, must be 0
1008      */
1009
1010     /* Set initialization block address (must be on word boundary) */
1011     SK_write_reg(CSR1, 0);          /* Set low order bits 15:0 */
1012     SK_write_reg(CSR2, 0);          /* Set high order bits 23:16 */
1013
1014
1015     PRINTF(("## %s: After setting CSR1-3. CSR0: %#hX\n",
1016            SK_NAME, SK_read_reg(CSR0)));
1017
1018     /* Initialize LANCE */
1019
1020     /*
1021      * INIT = Initialize, when set, causes the LANCE to begin the
1022      * initialization procedure and access the Init Block.
1023      */
1024
1025     SK_write_reg(CSR0, CSR0_INIT);
1026
1027     /* Wait until LANCE finished initialization */
1028
1029     SK_set_RAP(CSR0);              /* Register Address Pointer to CSR0 */
1030
1031     for (i = 0; (i < 100) && !(SK_rread_reg() & CSR0_IDON); i++)
1032         ; /* Wait until init done or go ahead if problems (i>=100) */
1033
1034     if (i >= 100) /* Something is wrong ! */
1035     {
1036         printf("%s: can't init am7990, status: %#hX "
1037                "init_block: %#hX\n",
1038                 SK_NAME, (int) SK_read_reg(CSR0),
1039                 (unsigned int) &(p->ram)->ib);
1040
1041 #ifdef  SK_DEBUG
1042         SK_print_pos(nic, "LANCE INIT failed");
1043 #endif
1044
1045         return -1;                 /* LANCE init failed */
1046     }
1047
1048     PRINTF(("## %s: init done after %d ticks\n", SK_NAME, i));
1049
1050     /* Clear Initialize done, enable Interrupts, start LANCE */
1051
1052     SK_write_reg(CSR0, CSR0_IDON | CSR0_INEA | CSR0_STRT);
1053
1054     PRINTF(("## %s: LANCE started. CSR0: %#hX\n", SK_NAME,
1055             SK_read_reg(CSR0)));
1056
1057     return 0;                      /* LANCE is up and running */
1058
1059 } /* End of SK_lance_init() */
1060
1061 /* LANCE access functions
1062  *
1063  * ! CSR1-3 can only be accessed when in CSR0 the STOP bit is set !
1064  */
1065
1066 static void SK_reset_board(void)
1067 {
1068     int i;
1069
1070         PRINTF(("## %s: At beginning of SK_reset_board.\n", SK_NAME));
1071     SK_PORT = 0x00;           /* Reset active */
1072     for (i = 0; i < 10 ; i++) /* Delay min 5ms */
1073         ;
1074     SK_PORT = SK_RESET;       /* Set back to normal operation */
1075
1076 } /* End of SK_reset_board() */
1077
1078 static void SK_set_RAP(int reg_number)
1079 {
1080     SK_IOREG = reg_number;
1081     SK_PORT  = SK_RESET | SK_RAP | SK_WREG;
1082     SK_IOCOM = SK_DOIO;
1083
1084     while (SK_PORT & SK_IORUN)
1085         ;
1086 } /* End of SK_set_RAP() */
1087
1088 static int SK_read_reg(int reg_number)
1089 {
1090     SK_set_RAP(reg_number);
1091
1092     SK_PORT  = SK_RESET | SK_RDATA | SK_RREG;
1093     SK_IOCOM = SK_DOIO;
1094
1095     while (SK_PORT & SK_IORUN)
1096         ;
1097     return (SK_IOREG);
1098
1099 } /* End of SK_read_reg() */
1100
1101 static int SK_rread_reg(void)
1102 {
1103     SK_PORT  = SK_RESET | SK_RDATA | SK_RREG;
1104
1105     SK_IOCOM = SK_DOIO;
1106
1107     while (SK_PORT & SK_IORUN)
1108         ;
1109     return (SK_IOREG);
1110
1111 } /* End of SK_rread_reg() */
1112
1113 static void SK_write_reg(int reg_number, int value)
1114 {
1115     SK_set_RAP(reg_number);
1116
1117     SK_IOREG = value;
1118     SK_PORT  = SK_RESET | SK_RDATA | SK_WREG;
1119     SK_IOCOM = SK_DOIO;
1120
1121     while (SK_PORT & SK_IORUN)
1122         ;
1123 } /* End of SK_write_reg */
1124
1125 /*
1126  * Debugging functions
1127  * -------------------
1128  */
1129
1130 #ifdef  SK_DEBUG
1131 static void SK_print_pos(struct nic *nic, char *text)
1132 {
1133
1134     unsigned char pos0 = inb(SK_POS0),
1135                   pos1 = inb(SK_POS1),
1136                   pos2 = inb(SK_POS2),
1137                   pos3 = inb(SK_POS3),
1138                   pos4 = inb(SK_POS4);
1139
1140
1141     printf("## %s: %s.\n"
1142            "##   pos0=%#hX pos1=%#hX pos2=%#hX pos3=%#hX pos4=%#hX\n",
1143            SK_NAME, text, pos0, pos1, pos2, (pos3<<14), pos4);
1144
1145 } /* End of SK_print_pos() */
1146
1147 static void SK_print_ram(struct nic *nic)
1148 {
1149
1150     int i;
1151     struct priv *p = (struct priv *) nic->priv_data;
1152
1153     printf("## %s: RAM Details.\n"
1154            "##   RAM at %#hX tmdhead: %#hX rmdhead: %#hX initblock: %#hX\n",
1155            SK_NAME,
1156            (unsigned int) p->ram,
1157            (unsigned int) p->tmdhead,
1158            (unsigned int) p->rmdhead,
1159            (unsigned int) &(p->ram)->ib);
1160
1161     printf("##   ");
1162
1163     for(i = 0; i < TMDNUM; i++)
1164     {
1165            if (!(i % 3)) /* Every third line do a newline */
1166            {
1167                printf("\n##   ");
1168            }
1169         printf("tmdbufs%d: %#hX ", (i+1), (int) p->tmdbufs[i]);
1170     }
1171     printf("##   ");
1172
1173     for(i = 0; i < RMDNUM; i++)
1174     {
1175          if (!(i % 3)) /* Every third line do a newline */
1176            {
1177                printf("\n##   ");
1178            }
1179         printf("rmdbufs%d: %#hX ", (i+1), (int) p->rmdbufs[i]);
1180     }
1181     putchar('\n');
1182
1183 } /* End of SK_print_ram() */
1184 #endif
1185
1186 static struct isa_driver SK_driver __isa_driver = {
1187         .type    = NIC_DRIVER,
1188         .name    = "SK_G16",
1189         .probe   = SK_probe,
1190         .ioaddrs = 0,
1191 };
1192 ISA_ROM("sk_g16","Schneider and Koch G16");