root/drivers/net/sk_g16.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. SK_init
  2. SK_probe
  3. SK_open
  4. SK_lance_init
  5. SK_send_packet
  6. SK_interrupt
  7. SK_txintr
  8. SK_rxintr
  9. SK_close
  10. SK_get_stats
  11. set_multicast_list
  12. SK_rom_addr
  13. SK_reset_board
  14. SK_set_RAP
  15. SK_read_reg
  16. SK_rread_reg
  17. SK_write_reg
  18. SK_print_pos
  19. SK_print_dev
  20. SK_print_ram

   1 /*-
   2  * Copyright (C) 1994 by PJD Weichmann & SWS Bern, Switzerland
   3  *
   4  * This software may be used and distributed according to the terms
   5  * of the GNU Public License, incorporated herein by reference.
   6  *
   7  * Module         : sk_g16.c
   8  *
   9  * Version        : $Revision: 1.1 $
  10  *
  11  * Author         : Patrick J.D. Weichmann
  12  *
  13  * Date Created   : 94/05/26
  14  * Last Updated   : $Date: 1994/06/30 16:25:15 $
  15  *
  16  * Description    : Schneider & Koch G16 Ethernet Device Driver for
  17  *                  Linux Kernel >= 1.1.22
  18  * Update History :
  19  *
  20 -*/
  21 
  22 static const char *rcsid = "$Id: sk_g16.c,v 1.1 1994/06/30 16:25:15 root Exp $";
  23 
  24 /*
  25  * The Schneider & Koch (SK) G16 Network device driver is based
  26  * on the 'ni6510' driver from Michael Hipp which can be found at
  27  * ftp://sunsite.unc.edu/pub/Linux/system/Network/drivers/nidrivers.tar.gz
  28  * 
  29  * Sources: 1) ni6510.c by M. Hipp
  30  *          2) depca.c  by D.C. Davies
  31  *          3) skeleton.c by D. Becker
  32  *          4) Am7990 Local Area Network Controller for Ethernet (LANCE),
  33  *             AMD, Pub. #05698, June 1989
  34  *
  35  * Many Thanks for helping me to get things working to: 
  36  *                 
  37  *                 A. Cox (A.Cox@swansea.ac.uk)
  38  *                 M. Hipp (mhipp@student.uni-tuebingen.de)
  39  *                 R. Bolz (Schneider & Koch, Germany)
  40  *
  41  * See README.sk_g16 for details about limitations and bugs for the
  42  * current version.
  43  *
  44  * To Do: 
  45  *        - Support of SK_G8 and other SK Network Cards.
  46  *        - Autoset memory mapped RAM. Check for free memory and then
  47  *          configure RAM correctly. 
  48  *        - SK_close should really set card in to initial state.
  49  *        - Test if IRQ 3 is not switched off. Use autoirq() functionality.
  50  *          (as in /drivers/net/skeleton.c)
  51  *        - Implement Multicast addressing. At minimum something like
  52  *          in depca.c. 
  53  *        - Redo the statistics part.
  54  *        - Try to find out if the board is in 8 Bit or 16 Bit slot.
  55  *          If in 8 Bit mode don't use IRQ 11.
  56  *        - (Try to make it slightly faster.) 
  57  */
  58 
  59 #include <linux/kernel.h>
  60 #include <linux/sched.h>
  61 #include <linux/ptrace.h>
  62 #include <linux/fcntl.h>
  63 #include <linux/ioport.h>
  64 #include <linux/interrupt.h>
  65 #include <linux/malloc.h>
  66 #include <linux/string.h> 
  67 #include <asm/system.h>
  68 #include <asm/io.h>
  69 #include <asm/bitops.h> 
  70 #include <linux/errno.h>
  71 
  72 #include <linux/netdevice.h>
  73 #include <linux/etherdevice.h>
  74 #include <linux/skbuff.h>
  75 
  76 #include "sk_g16.h"
  77 
  78 /* 
  79  * Schneider & Koch Card Definitions 
  80  * =================================
  81  */  
  82 
  83 #define SK_NAME   "SK_G16"
  84 
  85 /*
  86  * SK_G16 Configuration
  87  * --------------------
  88  */ 
  89 
  90 /* 
  91  * Abbreviations
  92  * -------------
  93  *  
  94  * RAM - used for the 16KB shared memory 
  95  * Boot_ROM, ROM - are used for referencing the BootEPROM
  96  *
  97  * SK_BOOT_ROM and SK_ADDR are symbolic constants used to configure
  98  * the behaviour of the driver and the SK_G16.
  99  *
 100  * ! See sk_g16.install on how to install and configure the driver !   
 101  *
 102  * SK_BOOT_ROM defines if the Boot_ROM should be switched off or not.
 103  *
 104  * SK_ADDR defines the address where the RAM will be mapped into the real
 105  *         host memory.
 106  *         valid addresses are from 0xa0000 to 0xfc000 in 16Kbyte steps.
 107  */  
 108  
 109 #define SK_BOOT_ROM     1              /* 1=BootROM on 0=off */
 110 
 111 #define SK_ADDR         0xcc000
 112 
 113 /* 
 114  * In POS3 are bits A14-A19 of the address bus. These bits can be set
 115  * to choose the RAM address. Thats why we only can choose the RAM address
 116  * in 16KB steps.
 117  */
 118 
 119 #define POS_ADDR       (rom_addr>>14)  /* Do not change this line */
 120 
 121 /* 
 122  * SK_G16 I/O PORT's + IRQ's + Boot_ROM locations
 123  * ----------------------------------------------
 124  */
 125 
 126 /* 
 127  * As nearly every card has also SK_G16 a specified I/O Port region and
 128  * only a few possible IRQ's.
 129  * In the Installation Guide from Schneider & Koch is listed a possible
 130  * Interrupt IRQ2. IRQ2 is always IRQ9 in boards with two cascaded interrupt
 131  * controllers. So we use in SK_IRQS IRQ9.
 132  */
 133 
 134 /* Don't touch any of the following #defines. */
 135 
 136 #define SK_IO_PORTS     { 0x100, 0x180, 0x208, 0x220, 0x288, 0x320, 0x328, 0x390, 0 }
 137 
 138 #define SK_IRQS         { 3, 5, 9, 11, 0 }
 139 
 140 #define SK_BOOT_ROM_LOCATIONS { 0xc0000, 0xc4000, 0xc8000, 0xcc000, 0xd0000, 0xd4000, 0xd8000, 0xdc000, 0 }
 141 
 142 #define SK_BOOT_ROM_ID  { 0x55, 0xaa, 0x10, 0x50, 0x06, 0x33 }
 143 
 144 /* 
 145  * SK_G16 POS REGISTERS 
 146  * --------------------
 147  */
 148 
 149 /*
 150  * SK_G16 has a Programmable Option Select (POS) Register.
 151  * The POS is composed of 8 separate registers (POS0-7) which 
 152  * are I/O mapped on an address set by the W1 switch.                    
 153  *
 154  */
 155 
 156 #define SK_POS_SIZE 8           /* 8 I/O Ports are used by SK_G16 */
 157 
 158 #define SK_POS0     ioaddr      /* Card-ID Low (R) */
 159 #define SK_POS1     ioaddr+1    /* Card-ID High (R) */
 160 #define SK_POS2     ioaddr+2    /* Card-Enable, Boot-ROM Disable (RW) */
 161 #define SK_POS3     ioaddr+3    /* Base address of RAM */
 162 #define SK_POS4     ioaddr+4    /* IRQ */
 163 
 164 /* POS5 - POS7 are unused */
 165 
 166 /* 
 167  * SK_G16 MAC PREFIX 
 168  * -----------------
 169  */
 170 
 171 /* 
 172  * Scheider & Koch manufacturer code (00:00:a5).
 173  * This must be checked, that we are sure it is a SK card.
 174  */
 175 
 176 #define SK_MAC0         0x00
 177 #define SK_MAC1         0x00
 178 #define SK_MAC2         0x5a
 179 
 180 /* 
 181  * SK_G16 ID 
 182  * ---------
 183  */ 
 184 
 185 /* 
 186  * If POS0,POS1 contain the following ID, then we know
 187  * at which I/O Port Address we are. 
 188  */
 189 
 190 #define SK_IDLOW  0xfd 
 191 #define SK_IDHIGH 0x6a
 192 
 193 
 194 /* 
 195  * LANCE POS Bit definitions 
 196  * -------------------------
 197  */
 198 
 199 #define SK_ROM_RAM_ON  (POS2_CARD)
 200 #define SK_ROM_RAM_OFF (POS2_EPROM)
 201 #define SK_ROM_ON      (inb(SK_POS2) & POS2_CARD)
 202 #define SK_ROM_OFF     (inb(SK_POS2) | POS2_EPROM)
 203 #define SK_RAM_ON      (inb(SK_POS2) | POS2_CARD)
 204 #define SK_RAM_OFF     (inb(SK_POS2) & POS2_EPROM) 
 205 
 206 #define POS2_CARD  0x0001              /* 1 = SK_G16 on      0 = off */
 207 #define POS2_EPROM 0x0002              /* 1 = Boot EPROM off 0 = on */ 
 208 
 209 /* 
 210  * SK_G16 Memory mapped Registers
 211  * ------------------------------
 212  *
 213  */ 
 214 
 215 #define SK_IOREG        (board->ioreg) /* LANCE data registers.     */ 
 216 #define SK_PORT         (board->port)  /* Control, Status register  */
 217 #define SK_IOCOM        (board->iocom) /* I/O Command               */
 218 
 219 /* 
 220  * SK_G16 Status/Control Register bits
 221  * -----------------------------------
 222  *
 223  * (C) Controlreg (S) Statusreg 
 224  */
 225 
 226 /* 
 227  * Register transfer: 0 = no transfer
 228  *                    1 = transferring data between LANCE and I/O reg 
 229  */
 230 #define SK_IORUN        0x20   
 231 
 232 /* 
 233  * LANCE interrupt: 0 = LANCE interrupt occurred        
 234  *                  1 = no LANCE interrupt occurred
 235  */
 236 #define SK_IRQ          0x10   
 237                         
 238 #define SK_RESET        0x08   /* Reset SK_CARD: 0 = RESET 1 = normal */
 239 #define SK_RW           0x02   /* 0 = write to 1 = read from */
 240 #define SK_ADR          0x01   /* 0 = REG DataPort 1 = RAP Reg addr port */
 241 
 242   
 243 #define SK_RREG         SK_RW  /* Transferdirection to read from lance */
 244 #define SK_WREG         0      /* Transferdirection to write to lance */
 245 #define SK_RAP          SK_ADR /* Destination Register RAP */
 246 #define SK_RDATA        0      /* Destination Register REG DataPort */
 247 
 248 /* 
 249  * SK_G16 I/O Command 
 250  * ------------------
 251  */
 252 
 253 /* 
 254  * Any bitcombination sets the internal I/O bit (transfer will start) 
 255  * when written to I/O Command
 256  */
 257 
 258 #define SK_DOIO         0x80   /* Do Transfer */ 
 259  
 260 /* 
 261  * LANCE RAP (Register Address Port). 
 262  * ---------------------------------
 263  */
 264 
 265 /*   
 266  * The LANCE internal registers are selected through the RAP. 
 267  * The Registers are:
 268  *
 269  * CSR0 - Status and Control flags 
 270  * CSR1 - Low order bits of initialize block (bits 15:00)
 271  * CSR2 - High order bits of initialize block (bits 07:00, 15:08 are reserved)
 272  * CSR3 - Allows redefinition of the Bus Master Interface.
 273  *        This register must be set to 0x0002, which means BSWAP = 0,
 274  *        ACON = 1, BCON = 0;
 275  *
 276  */
 277  
 278 #define CSR0            0x00   
 279 #define CSR1            0x01  
 280 #define CSR2            0x02 
 281 #define CSR3            0x03
 282 
 283 /* 
 284  * General Definitions 
 285  * ===================
 286  */
 287 
 288 /* 
 289  * Set the number of Tx and Rx buffers, using Log_2(# buffers).
 290  * We have 16KB RAM which can be accessed by the LANCE. In the 
 291  * memory are not only the buffers but also the ring descriptors and
 292  * the initialize block. 
 293  * Don't change anything unless you really know what you do.
 294  */
 295 
 296 #define LC_LOG_TX_BUFFERS 1               /* (2 == 2^^1) 2 Transmit buffers */
 297 #define LC_LOG_RX_BUFFERS 3               /* (8 == 2^^3) 8 Receive buffers */
 298 
 299 /* Descriptor ring sizes */
 300 
 301 #define TMDNUM (1 << (LC_LOG_TX_BUFFERS)) /* 2 Transmit descriptor rings */
 302 #define RMDNUM (1 << (LC_LOG_RX_BUFFERS)) /* 8 Receive Buffers */
 303 
 304 /* Define Mask for setting RMD, TMD length in the LANCE init_block */
 305 
 306 #define TMDNUMMASK (LC_LOG_TX_BUFFERS << 29)
 307 #define RMDNUMMASK (LC_LOG_RX_BUFFERS << 29)
 308 
 309 /*
 310  * Data Buffer size is set to maximum packet length.
 311  */
 312 
 313 #define PKT_BUF_SZ              1518 
 314 
 315 /* 
 316  * The number of low I/O ports used by the ethercard. 
 317  */
 318 
 319 #define ETHERCARD_TOTAL_SIZE    SK_POS_SIZE
 320 
 321 /* 
 322  * Portreserve is there to mark the Card I/O Port region as used. 
 323  * Check_region is to check if the region at ioaddr with the size "size" 
 324  * is free or not.
 325  * Snarf_region allocates the I/O Port region.
 326  */
 327 
 328 #ifndef HAVE_PORTRESERVE
 329 
 330 #define check_region(ioaddr, size)              0
 331 #define request_region(ioaddr, size,name)       do ; while (0)
 332 
 333 #endif
 334 
 335 /* 
 336  * SK_DEBUG
 337  *
 338  * Here you can choose what level of debugging wanted.
 339  *
 340  * If SK_DEBUG and SK_DEBUG2 are undefined, then only the
 341  *  necessary messages will be printed.
 342  *
 343  * If SK_DEBUG is defined, there will be many debugging prints
 344  *  which can help to find some mistakes in configuration or even
 345  *  in the driver code.
 346  *
 347  * If SK_DEBUG2 is defined, many many messages will be printed 
 348  *  which normally you don't need. I used this to check the interrupt
 349  *  routine. 
 350  *
 351  * (If you define only SK_DEBUG2 then only the messages for 
 352  *  checking interrupts will be printed!)
 353  *
 354  * Normal way of live is: 
 355  *
 356  * For the whole thing get going let both symbolic constants
 357  * undefined. If you face any problems and you know what's going
 358  * on (you know something about the card and you can interpret some
 359  * hex LANCE register output) then define SK_DEBUG
 360  * 
 361  */
 362 
 363 #undef  SK_DEBUG        /* debugging */
 364 #undef  SK_DEBUG2       /* debugging with more verbose report */
 365 
 366 #ifdef SK_DEBUG
 367 #define PRINTK(x) printk x
 368 #else
 369 #define PRINTK(x) /**/
 370 #endif
 371 
 372 #ifdef SK_DEBUG2
 373 #define PRINTK2(x) printk x
 374 #else
 375 #define PRINTK2(x) /**/
 376 #endif
 377 
 378 /* 
 379  * SK_G16 RAM
 380  *
 381  * The components are memory mapped and can be set in a region from
 382  * 0x00000 through 0xfc000 in 16KB steps. 
 383  *
 384  * The Network components are: dual ported RAM, Prom, I/O Reg, Status-,
 385  * Controlregister and I/O Command.
 386  *
 387  * dual ported RAM: This is the only memory region which the LANCE chip
 388  *      has access to. From the Lance it is addressed from 0x0000 to
 389  *      0x3fbf. The host accesses it normally.
 390  *
 391  * PROM: The PROM obtains the ETHERNET-MAC-Address. It is realised as a
 392  *       8-Bit PROM, this means only the 16 even addresses are used of the
 393  *       32 Byte Address region. Access to a odd address results in invalid
 394  *       data.
 395  * 
 396  * LANCE I/O Reg: The I/O Reg is build of 4 single Registers, Low-Byte Write,
 397  *       Hi-Byte Write, Low-Byte Read, Hi-Byte Read.
 398  *       Transfer from or to the LANCE is always in 16Bit so Low and High
 399  *       registers are always relevant.
 400  *
 401  *       The Data from the Readregister is not the data in the Writeregister!!
 402  *       
 403  * Port: Status- and Controlregister. 
 404  *       Two different registers which share the same address, Status is 
 405  *       read-only, Control is write-only.
 406  *    
 407  * I/O Command: 
 408  *       Any bitcombination written in here starts the transmission between
 409  *       Host and LANCE.
 410  */
 411 
 412 typedef struct
 413 {
 414         unsigned char  ram[0x3fc0];   /* 16KB dual ported ram */
 415         unsigned char  rom[0x0020];   /* 32Byte PROM containing 6Byte MAC */
 416         unsigned char  res1[0x0010];  /* reserved */
 417         unsigned volatile short ioreg;/* LANCE I/O Register */
 418         unsigned volatile char  port; /* Statusregister and Controlregister */
 419         unsigned char  iocom;         /* I/O Command Register */
 420 } SK_RAM;
 421 
 422 /* struct  */
 423 
 424 /* 
 425  * This is the structure for the dual ported ram. We
 426  * have exactly 16 320 Bytes. In here there must be:
 427  *
 428  *     - Initialize Block   (starting at a word boundary)
 429  *     - Receive and Transmit Descriptor Rings (quadword boundary)
 430  *     - Data Buffers (arbitrary boundary)
 431  *
 432  * This is because LANCE has on SK_G16 only access to the dual ported
 433  * RAM and nowhere else.
 434  */
 435 
 436 struct SK_ram
 437 {
 438     struct init_block ib;
 439     struct tmd tmde[TMDNUM];
 440     struct rmd rmde[RMDNUM];
 441     char tmdbuf[TMDNUM][PKT_BUF_SZ];
 442     char rmdbuf[RMDNUM][PKT_BUF_SZ];
 443 };
 444 
 445 /* 
 446  * Structure where all necessary information is for ring buffer 
 447  * management and statistics.
 448  */
 449 
 450 struct priv
 451 {
 452     struct SK_ram *ram;  /* dual ported ram structure */
 453     struct rmd *rmdhead; /* start of receive ring descriptors */
 454     struct tmd *tmdhead; /* start of transmit ring descriptors */
 455     int        rmdnum;   /* actual used ring descriptor */
 456     int        tmdnum;   /* actual transmit descriptor for transmitting data */
 457     int        tmdlast;  /* last sent descriptor used for error handling, etc */
 458     void       *rmdbufs[RMDNUM]; /* pointer to the receive buffers */
 459     void       *tmdbufs[TMDNUM]; /* pointer to the transmit buffers */
 460     struct enet_statistics stats; /* Device driver statistics */
 461 };
 462 
 463 /* global variable declaration */
 464 
 465 /* IRQ map used to reserve a IRQ (see SK_open()) */
 466 
 467 /* extern void *irq2dev_map[16]; */ /* Declared in <linux/ioport.h> */
 468 
 469 /* static variables */
 470 
 471 static SK_RAM *board;  /* pointer to our memory mapped board components */
 472 
 473 /* Macros */
 474 
 475 
 476 /* Function Prototypes */
 477 
 478 /*
 479  * Device Driver functions
 480  * -----------------------
 481  * See for short explanation of each function its definitions header.
 482  */
 483 
 484 int          SK_init(struct device *dev);
 485 static int   SK_probe(struct device *dev, short ioaddr);
 486 
 487 static int   SK_open(struct device *dev);
 488 static int   SK_send_packet(struct sk_buff *skb, struct device *dev);
 489 static void  SK_interrupt(int irq, void *dev_id, struct pt_regs * regs);
 490 static void  SK_rxintr(struct device *dev);
 491 static void  SK_txintr(struct device *dev);
 492 static int   SK_close(struct device *dev);
 493 
 494 static struct enet_statistics *SK_get_stats(struct device *dev);
 495 
 496 unsigned int SK_rom_addr(void);
 497 
 498 static void set_multicast_list(struct device *dev);
 499 
 500 /*
 501  * LANCE Functions
 502  * ---------------
 503  */
 504 
 505 static int SK_lance_init(struct device *dev, unsigned short mode);
 506 void   SK_reset_board(void);
 507 void   SK_set_RAP(int reg_number);
 508 int    SK_read_reg(int reg_number);
 509 int    SK_rread_reg(void);
 510 void   SK_write_reg(int reg_number, int value);
 511 
 512 /* 
 513  * Debugging functions
 514  * -------------------
 515  */
 516 
 517 void SK_print_pos(struct device *dev, char *text);
 518 void SK_print_dev(struct device *dev, char *text);
 519 void SK_print_ram(struct device *dev);
 520 
 521 
 522 /*-
 523  * Function       : SK_init
 524  * Author         : Patrick J.D. Weichmann
 525  * Date Created   : 94/05/26
 526  *
 527  * Description    : Check for a SK_G16 network adaptor and initialize it.
 528  *                  This function gets called by dev_init which initializes
 529  *                  all Network devices.
 530  *
 531  * Parameters     : I : struct device *dev - structure preconfigured 
 532  *                                           from Space.c
 533  * Return Value   : 0 = Driver Found and initialized 
 534  * Errors         : ENODEV - no device found
 535  *                  ENXIO  - not probed
 536  * Globals        : None
 537  * Update History :
 538  *     YY/MM/DD  uid  Description
 539 -*/
 540 
 541 /* 
 542  * Check for a network adaptor of this type, and return '0' if one exists.
 543  * If dev->base_addr == 0, probe all likely locations.
 544  * If dev->base_addr == 1, always return failure.
 545  * If dev->base_addr == 2, allocate space for the device and return success
 546  *                         (detachable devices only).
 547  */
 548 
 549 int SK_init(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 550 {
 551         int ioaddr         = 0;            /* I/O port address used for POS regs */
 552         int *port, ports[] = SK_IO_PORTS;  /* SK_G16 supported ports */
 553 
 554         /* get preconfigured base_addr from dev which is done in Space.c */
 555         int base_addr = dev->base_addr; 
 556 
 557         PRINTK(("%s: %s", SK_NAME, rcsid));
 558         rcsid = NULL;                 /* We do not want to use this further */
 559 
 560         if (base_addr > 0x0ff)        /* Check a single specified address */
 561         {
 562             /* Check if on specified address is a SK_G16 */
 563 
 564             if ( (inb(SK_POS0) == SK_IDLOW) ||
 565                  (inb(SK_POS1) == SK_IDHIGH) )  
 566             {
 567                 return SK_probe(dev, base_addr);  
 568             }
 569 
 570             return ENODEV;            /* Sorry, but on specified address NO SK_G16 */
 571         }
 572         else if (base_addr > 0)       /* Don't probe at all */
 573         {
 574                 return ENXIO;
 575         }
 576 
 577         /* Autoprobe base_addr */
 578 
 579         for (port = &ports[0]; *port; port++) 
 580         {
 581             ioaddr = *port;           /* we need ioaddr for accessing POS regs */
 582 
 583             /* Check if I/O Port region is used by another board */
 584 
 585             if (check_region(ioaddr, ETHERCARD_TOTAL_SIZE))
 586             {
 587                 continue;             /* Try next Port address */
 588             }
 589 
 590             /* Check if at ioaddr is a SK_G16 */
 591 
 592             if ( !(inb(SK_POS0) == SK_IDLOW) ||
 593                  !(inb(SK_POS1) == SK_IDHIGH) )
 594             {
 595                 continue;             /* Try next Port address */
 596             }
 597 
 598             dev->base_addr = ioaddr;  /* Set I/O Port Address */
 599 
 600             if (SK_probe(dev, ioaddr) == 0)  
 601             {
 602                 return 0; /* Card found and initialized */
 603             }
 604         }
 605 
 606         dev->base_addr = base_addr;   /* Write back original base_addr */
 607 
 608         return ENODEV;                /* Failed to find or init driver */
 609 
 610 } /* End of SK_init */
 611 
 612 
 613 /*-
 614  * Function       : SK_probe
 615  * Author         : Patrick J.D. Weichmann
 616  * Date Created   : 94/05/26
 617  *
 618  * Description    : This function is called by SK_init and 
 619  *                  does the main part of initialization.
 620  *                  
 621  * Parameters     : I : struct device *dev - SK_G16 device structure
 622  *                  I : short ioaddr       - I/O Port address where POS is.
 623  * Return Value   : 0 = Initialization done             
 624  * Errors         : ENODEV - No SK_G16 found
 625  *                  -1     - Configuration problem
 626  * Globals        : irq2dev_map - Which device uses which IRQ
 627  *                : board       - pointer to SK_RAM
 628  * Update History :
 629  *     YY/MM/DD  uid  Description
 630  *     94/06/30  pwe  SK_ADDR now checked and at the correct place
 631 -*/
 632 
 633 int SK_probe(struct device *dev, short ioaddr)
     /* [previous][next][first][last][top][bottom][index][help] */
 634 {
 635     int i,j;                /* Counters */
 636     int sk_addr_flag = 0;   /* SK ADDR correct? 1 - no, 0 - yes */
 637     unsigned int rom_addr;  /* used to store RAM address used for POS_ADDR */
 638 
 639     struct priv *p;         /* SK_G16 private structure */
 640 
 641     if (SK_ADDR & 0x3fff || SK_ADDR < 0xa0000)
 642     {
 643       
 644        sk_addr_flag = 1;
 645 
 646        /* 
 647         * Now here we could use a routine which searches for a free
 648         * place in the ram and set SK_ADDR if found. TODO. 
 649         */
 650     }
 651 
 652     if (SK_BOOT_ROM)            /* Shall we keep Boot_ROM on ? */
 653     {
 654         PRINTK(("## %s: SK_BOOT_ROM is set.\n", SK_NAME));
 655 
 656         rom_addr = SK_rom_addr();
 657 
 658         if (rom_addr == 0)      /* No Boot_ROM found */
 659         {
 660             if (sk_addr_flag)   /* No or Invalid SK_ADDR is defined */ 
 661             {
 662                 printk("%s: SK_ADDR %#08x is not valid. Check configuration.\n",
 663                        dev->name, SK_ADDR);
 664                 return -1;
 665             }
 666 
 667             rom_addr = SK_ADDR; /* assign predefined address */
 668 
 669             PRINTK(("## %s: NO Bootrom found \n", SK_NAME));
 670 
 671             outb(SK_ROM_RAM_OFF, SK_POS2); /* Boot_ROM + RAM off */
 672             outb(POS_ADDR, SK_POS3);       /* Set RAM address */
 673             outb(SK_RAM_ON, SK_POS2);      /* enable RAM */
 674         }
 675         else if (rom_addr == SK_ADDR) 
 676         {
 677             printk("%s: RAM + ROM are set to the same address %#08x\n"
 678                    "   Check configuration. Now switching off Boot_ROM\n",
 679                    SK_NAME, rom_addr);
 680 
 681             outb(SK_ROM_RAM_OFF, SK_POS2); /* Boot_ROM + RAM off*/
 682             outb(POS_ADDR, SK_POS3);       /* Set RAM address */
 683             outb(SK_RAM_ON, SK_POS2);      /* enable RAM */
 684         }
 685         else
 686         {
 687             PRINTK(("## %s: Found ROM at %#08x\n", SK_NAME, rom_addr));
 688             PRINTK(("## %s: Keeping Boot_ROM on\n", SK_NAME));
 689 
 690             if (sk_addr_flag)       /* No or Invalid SK_ADDR is defined */ 
 691             {
 692                 printk("%s: SK_ADDR %#08x is not valid. Check configuration.\n",
 693                        dev->name, SK_ADDR);
 694                 return -1;
 695             }
 696 
 697             rom_addr = SK_ADDR;
 698 
 699             outb(SK_ROM_RAM_OFF, SK_POS2); /* Boot_ROM + RAM off */ 
 700             outb(POS_ADDR, SK_POS3);       /* Set RAM address */
 701             outb(SK_ROM_RAM_ON, SK_POS2);  /* RAM on, BOOT_ROM on */
 702         }
 703     }
 704     else /* Don't keep Boot_ROM */
 705     {
 706         PRINTK(("## %s: SK_BOOT_ROM is not set.\n", SK_NAME));
 707 
 708         if (sk_addr_flag)           /* No or Invalid SK_ADDR is defined */ 
 709         {
 710             printk("%s: SK_ADDR %#08x is not valid. Check configuration.\n",
 711                    dev->name, SK_ADDR);
 712             return -1;
 713         }
 714 
 715         rom_addr = SK_rom_addr();          /* Try to find a Boot_ROM */
 716 
 717         /* IF we find a Boot_ROM disable it */
 718 
 719         outb(SK_ROM_RAM_OFF, SK_POS2);     /* Boot_ROM + RAM off */  
 720 
 721         /* We found a Boot_ROM and it's gone. Set RAM address on
 722          * Boot_ROM address. 
 723          */ 
 724 
 725         if (rom_addr) 
 726         {
 727             printk("%s: We found Boot_ROM at %#08x. Now setting RAM on"
 728                    "that address\n", SK_NAME, rom_addr);
 729 
 730             outb(POS_ADDR, SK_POS3);       /* Set RAM on Boot_ROM address */
 731         }
 732         else /* We did not find a Boot_ROM, use predefined SK_ADDR for ram */
 733         {
 734             if (sk_addr_flag)       /* No or Invalid SK_ADDR is defined */ 
 735             {
 736                 printk("%s: SK_ADDR %#08x is not valid. Check configuration.\n",
 737                        dev->name, SK_ADDR);
 738                 return -1;
 739             }
 740 
 741             rom_addr = SK_ADDR;
 742 
 743             outb(POS_ADDR, SK_POS3);       /* Set RAM address */ 
 744         }
 745         outb(SK_RAM_ON, SK_POS2);          /* enable RAM */
 746     }
 747 
 748 #ifdef SK_DEBUG
 749     SK_print_pos(dev, "POS registers after ROM, RAM config");
 750 #endif
 751 
 752     board = (SK_RAM *) rom_addr; 
 753 
 754     /* Read in station address */
 755     for (i = 0, j = 0; i < ETH_ALEN; i++, j+=2)
 756     {
 757         dev->dev_addr[i] = board->rom[j];          
 758     }
 759 
 760     /* Check for manufacturer code */
 761     if (!(dev->dev_addr[0] == SK_MAC0 &&
 762           dev->dev_addr[1] == SK_MAC1 &&
 763           dev->dev_addr[2] == SK_MAC2) )
 764     {
 765         PRINTK(("## %s: We did not find SK_G16 at RAM location.\n",
 766                 SK_NAME)); 
 767         return ENODEV;                     /* NO SK_G16 found */
 768     }
 769 
 770     printk("%s: %s found at %#3x, HW addr: %#04x:%02x:%02x:%02x:%02x:%02x\n",
 771             dev->name,
 772             "Schneider & Koch Netcard",
 773             (unsigned int) dev->base_addr,
 774             dev->dev_addr[0],
 775             dev->dev_addr[1],
 776             dev->dev_addr[2],
 777             dev->dev_addr[3],
 778             dev->dev_addr[4],
 779             dev->dev_addr[5]);
 780 
 781     /* Grab the I/O Port region */
 782     request_region(ioaddr, ETHERCARD_TOTAL_SIZE,"sk_g16");
 783 
 784     /* Initialize device structure */
 785 
 786     /* Allocate memory for private structure */
 787     p = dev->priv = (void *) kmalloc(sizeof(struct priv), GFP_KERNEL);
 788     if (p == NULL)
 789            return -ENOMEM;
 790     memset((char *) dev->priv, 0, sizeof(struct priv)); /* clear memory */
 791 
 792     /* Assign our Device Driver functions */
 793 
 794     dev->open                   = &SK_open;
 795     dev->stop                   = &SK_close;
 796     dev->hard_start_xmit        = &SK_send_packet;
 797     dev->get_stats              = &SK_get_stats;
 798     dev->set_multicast_list     = &set_multicast_list;
 799 
 800 
 801     /* Set the generic fields of the device structure */
 802 
 803     ether_setup(dev);
 804     
 805     dev->flags &= ~IFF_MULTICAST;
 806 
 807     /* Initialize private structure */
 808 
 809     p->ram = (struct SK_ram *) rom_addr; /* Set dual ported RAM addr */
 810     p->tmdhead = &(p->ram)->tmde[0];     /* Set TMD head */
 811     p->rmdhead = &(p->ram)->rmde[0];     /* Set RMD head */
 812 
 813     /* Initialize buffer pointers */
 814 
 815     for (i = 0; i < TMDNUM; i++)
 816     {
 817         p->tmdbufs[i] = &(p->ram)->tmdbuf[i];
 818     }
 819 
 820     for (i = 0; i < RMDNUM; i++)
 821     {
 822         p->rmdbufs[i] = &(p->ram)->rmdbuf[i]; 
 823     }
 824 
 825 #ifdef SK_DEBUG
 826     SK_print_pos(dev, "End of SK_probe");
 827     SK_print_ram(dev);
 828 #endif 
 829 
 830     return 0;                            /* Initialization done */
 831 
 832 } /* End of SK_probe() */
 833 
 834 
 835 /*- 
 836  * Function       : SK_open
 837  * Author         : Patrick J.D. Weichmann
 838  * Date Created   : 94/05/26
 839  *
 840  * Description    : This function is called sometimes after booting 
 841  *                  when ifconfig program is run.
 842  *
 843  *                  This function requests an IRQ, sets the correct
 844  *                  IRQ in the card. Then calls SK_lance_init() to 
 845  *                  init and start the LANCE chip. Then if everything is 
 846  *                  ok returns with 0 (OK), which means SK_G16 is now
 847  *                  opened and operational.
 848  *
 849  *                  (Called by dev_open() /net/inet/dev.c)
 850  *
 851  * Parameters     : I : struct device *dev - SK_G16 device structure
 852  * Return Value   : 0 - Device opened
 853  * Errors         : -EAGAIN - Open failed
 854  * Globals        : irq2dev_map - which device uses which irq
 855  * Side Effects   : None
 856  * Update History :
 857  *     YY/MM/DD  uid  Description
 858 -*/
 859 
 860 static int SK_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 861 {
 862     int i = 0;
 863     int irqval = 0;
 864     int ioaddr = dev->base_addr;
 865 
 866     int irqtab[] = SK_IRQS; 
 867 
 868     struct priv *p = (struct priv *)dev->priv;
 869 
 870     PRINTK(("## %s: At beginning of SK_open(). CSR0: %#06x\n", 
 871            SK_NAME, SK_read_reg(CSR0)));
 872 
 873     if (dev->irq == 0) /* Autoirq */
 874     {
 875         i = 0;
 876 
 877         /* 
 878          * Check if one IRQ out of SK_IRQS is free and install 
 879          * interrupt handler.
 880          * Most done by request_irq(). 
 881          * irqval: 0       - interrupt handler installed for IRQ irqtab[i]
 882          *         -EBUSY  - interrupt busy 
 883          *         -EINVAL - irq > 15 or handler = NULL
 884          */
 885 
 886         do
 887         {
 888           irqval = request_irq(irqtab[i], &SK_interrupt, 0, "sk_g16", NULL);
 889           i++;
 890         } while (irqval && irqtab[i]);
 891 
 892         if (irqval) /* We tried every possible IRQ but no success */
 893         {
 894             printk("%s: unable to get an IRQ\n", dev->name);
 895             return -EAGAIN;
 896         }
 897 
 898         dev->irq = irqtab[--i]; 
 899         
 900         outb(i<<2, SK_POS4);           /* Set Card on probed IRQ */
 901 
 902     }
 903     else if (dev->irq == 2) /* IRQ2 is always IRQ9 */
 904     {
 905         if (request_irq(9, &SK_interrupt, 0, "sk_g16", NULL))
 906         {
 907             printk("%s: unable to get IRQ 9\n", dev->name);
 908             return -EAGAIN;
 909         } 
 910         dev->irq = 9;
 911         
 912         /* 
 913          * Now we set card on IRQ2.
 914          * This can be confusing, but remember that IRQ2 on the network
 915          * card is in reality IRQ9
 916          */
 917         outb(0x08, SK_POS4);           /* set card to IRQ2 */
 918 
 919     }
 920     else  /* Check IRQ as defined in Space.c */
 921     {
 922         int i = 0;
 923 
 924         /* check if IRQ free and valid. Then install Interrupt handler */
 925 
 926         if (request_irq(dev->irq, &SK_interrupt, 0, "sk_g16", NULL))
 927         {
 928             printk("%s: unable to get selected IRQ\n", dev->name);
 929             return -EAGAIN;
 930         }
 931 
 932         switch(dev->irq)
 933         {
 934             case 3: i = 0;
 935                     break;
 936             case 5: i = 1;
 937                     break;
 938             case 2: i = 2;
 939                     break;
 940             case 11:i = 3;
 941                     break;
 942             default: 
 943                 printk("%s: Preselected IRQ %d is invalid for %s boards",
 944                        dev->name,
 945                        dev->irq,
 946                        SK_NAME);
 947                 return -EAGAIN;
 948         }      
 949   
 950         outb(i<<2, SK_POS4);           /* Set IRQ on card */
 951     }
 952 
 953     irq2dev_map[dev->irq] = dev;       /* Set IRQ as used by us */
 954     
 955     printk("%s: Schneider & Koch G16 at %#3x, IRQ %d, shared mem at %#08x\n",
 956             dev->name, (unsigned int)dev->base_addr, 
 957             (int) dev->irq, (unsigned int) p->ram);
 958 
 959     if (!(i = SK_lance_init(dev, 0)))  /* LANCE init OK? */
 960     {
 961 
 962 
 963         dev->tbusy = 0;
 964         dev->interrupt = 0;
 965         dev->start = 1;
 966 
 967 #ifdef SK_DEBUG
 968 
 969         /* 
 970          * This debug block tries to stop LANCE,
 971          * reinit LANCE with transmitter and receiver disabled,
 972          * then stop again and reinit with NORMAL_MODE
 973          */
 974 
 975         printk("## %s: After lance init. CSR0: %#06x\n", 
 976                SK_NAME, SK_read_reg(CSR0));
 977         SK_write_reg(CSR0, CSR0_STOP);
 978         printk("## %s: LANCE stopped. CSR0: %#06x\n", 
 979                SK_NAME, SK_read_reg(CSR0));
 980         SK_lance_init(dev, MODE_DTX | MODE_DRX);
 981         printk("## %s: Reinit with DTX + DRX off. CSR0: %#06x\n", 
 982                SK_NAME, SK_read_reg(CSR0));
 983         SK_write_reg(CSR0, CSR0_STOP);
 984         printk("## %s: LANCE stopped. CSR0: %#06x\n", 
 985                SK_NAME, SK_read_reg(CSR0));
 986         SK_lance_init(dev, MODE_NORMAL);
 987         printk("## %s: LANCE back to normal mode. CSR0: %#06x\n", 
 988                SK_NAME, SK_read_reg(CSR0));
 989         SK_print_pos(dev, "POS regs before returning OK");
 990 
 991 #endif /* SK_DEBUG */
 992        
 993         return 0;              /* SK_open() is successful */
 994     }
 995     else /* LANCE init failed */
 996     {
 997 
 998         PRINTK(("## %s: LANCE init failed: CSR0: %#06x\n", 
 999                SK_NAME, SK_read_reg(CSR0)));
1000 
1001         dev->start = 0;        /* Device not ready */
1002         return -EAGAIN;
1003     }
1004 
1005 } /* End of SK_open() */
1006 
1007 
1008 /*-
1009  * Function       : SK_lance_init
1010  * Author         : Patrick J.D. Weichmann
1011  * Date Created   : 94/05/26
1012  *
1013  * Description    : Reset LANCE chip, fill RMD, TMD structures with
1014  *                  start values and Start LANCE.
1015  *
1016  * Parameters     : I : struct device *dev - SK_G16 device structure
1017  *                  I : int mode - put LANCE into "mode" see data-sheet for
1018  *                                 more info.
1019  * Return Value   : 0  - Init done
1020  * Errors         : -1 - Init failed
1021  * Update History :
1022  *     YY/MM/DD  uid  Description
1023 -*/
1024 
1025 static int SK_lance_init(struct device *dev, unsigned short mode)
     /* [previous][next][first][last][top][bottom][index][help] */
1026 {
1027     int i;
1028     struct priv *p = (struct priv *) dev->priv; 
1029     struct tmd  *tmdp;
1030     struct rmd  *rmdp;
1031 
1032     PRINTK(("## %s: At beginning of LANCE init. CSR0: %#06x\n", 
1033            SK_NAME, SK_read_reg(CSR0)));
1034 
1035     /* Reset LANCE */
1036     SK_reset_board();
1037 
1038     /* Initialize TMD's with start values */
1039     p->tmdnum = 0;                   /* First descriptor for transmitting */ 
1040     p->tmdlast = 0;                  /* First descriptor for reading stats */
1041 
1042     for (i = 0; i < TMDNUM; i++)     /* Init all TMD's */
1043     {
1044         tmdp = p->tmdhead + i; 
1045    
1046         tmdp->u.buffer = (unsigned long) p->tmdbufs[i]; /* assign buffer */
1047         
1048         /* Mark TMD as start and end of packet */
1049         tmdp->u.s.status = TX_STP | TX_ENP;
1050     }
1051 
1052 
1053     /* Initialize RMD's with start values */
1054 
1055     p->rmdnum = 0;                   /* First RMD which will be used */
1056  
1057     for (i = 0; i < RMDNUM; i++)     /* Init all RMD's */
1058     {
1059         rmdp = p->rmdhead + i;
1060 
1061         
1062         rmdp->u.buffer = (unsigned long) p->rmdbufs[i]; /* assign buffer */
1063         
1064         /* 
1065          * LANCE must be owner at beginning so that he can fill in 
1066          * receiving packets, set status and release RMD 
1067          */
1068 
1069         rmdp->u.s.status = RX_OWN;  
1070 
1071         rmdp->blen = -PKT_BUF_SZ;    /* Buffer Size in a two's complement */
1072 
1073         rmdp->mlen = 0;              /* init message length */       
1074         
1075     }
1076 
1077     /* Fill LANCE Initialize Block */
1078 
1079     (p->ram)->ib.mode = mode;        /* Set operation mode */
1080 
1081     for (i = 0; i < ETH_ALEN; i++)   /* Set physical address */
1082     {
1083         (p->ram)->ib.paddr[i] = dev->dev_addr[i]; 
1084     }
1085 
1086     for (i = 0; i < 8; i++)          /* Set multicast, logical address */
1087     {
1088         (p->ram)->ib.laddr[i] = 0;   /* We do not use logical addressing */
1089     } 
1090 
1091     /* Set ring descriptor pointers and set number of descriptors */
1092 
1093     (p->ram)->ib.rdrp = (int)  p->rmdhead | RMDNUMMASK;
1094     (p->ram)->ib.tdrp = (int)  p->tmdhead | TMDNUMMASK;
1095 
1096     /* Prepare LANCE Control and Status Registers */
1097 
1098     cli();
1099 
1100     SK_write_reg(CSR3, CSR3_ACON);   /* Ale Control !!!THIS MUST BE SET!!!! */
1101  
1102     /* 
1103      * LANCE addresses the RAM from 0x0000 to 0x3fbf and has no access to
1104      * PC Memory locations.
1105      *
1106      * In structure SK_ram is defined that the first thing in ram
1107      * is the initialization block. So his address is for LANCE always
1108      * 0x0000
1109      *
1110      * CSR1 contains low order bits 15:0 of initialization block address
1111      * CSR2 is built of: 
1112      *    7:0  High order bits 23:16 of initialization block address
1113      *   15:8  reserved, must be 0
1114      */
1115     
1116     /* Set initialization block address (must be on word boundary) */
1117     SK_write_reg(CSR1, 0);          /* Set low order bits 15:0 */
1118     SK_write_reg(CSR2, 0);          /* Set high order bits 23:16 */ 
1119     
1120 
1121     PRINTK(("## %s: After setting CSR1-3. CSR0: %#06x\n", 
1122            SK_NAME, SK_read_reg(CSR0)));
1123 
1124     /* Initialize LANCE */
1125 
1126     /* 
1127      * INIT = Initialize, when set, causes the LANCE to begin the
1128      * initialization procedure and access the Init Block.
1129      */
1130 
1131     SK_write_reg(CSR0, CSR0_INIT); 
1132 
1133     sti();
1134 
1135     /* Wait until LANCE finished initialization */
1136     
1137     SK_set_RAP(CSR0);              /* Register Address Pointer to CSR0 */
1138 
1139     for (i = 0; (i < 100) && !(SK_rread_reg() & CSR0_IDON); i++) 
1140         ; /* Wait until init done or go ahead if problems (i>=100) */
1141 
1142     if (i >= 100) /* Something is wrong ! */
1143     {
1144         printk("%s: can't init am7990, status: %04x "
1145                "init_block: %#08x\n", 
1146                 dev->name, (int) SK_read_reg(CSR0), 
1147                 (unsigned int) &(p->ram)->ib);
1148 
1149 #ifdef SK_DEBUG
1150         SK_print_pos(dev, "LANCE INIT failed");
1151         SK_print_dev(dev,"Device Structure:");
1152 #endif
1153 
1154         return -1;                 /* LANCE init failed */
1155     }
1156 
1157     PRINTK(("## %s: init done after %d ticks\n", SK_NAME, i));
1158 
1159     /* Clear Initialize done, enable Interrupts, start LANCE */
1160 
1161     SK_write_reg(CSR0, CSR0_IDON | CSR0_INEA | CSR0_STRT);
1162 
1163     PRINTK(("## %s: LANCE started. CSR0: %#06x\n", SK_NAME, 
1164             SK_read_reg(CSR0)));
1165 
1166     return 0;                      /* LANCE is up and running */
1167 
1168 } /* End of SK_lance_init() */
1169 
1170 
1171 
1172 /*-
1173  * Function       : SK_send_packet
1174  * Author         : Patrick J.D. Weichmann
1175  * Date Created   : 94/05/27
1176  *
1177  * Description    : Writes an socket buffer into a transmit descriptor
1178  *                  and starts transmission.
1179  *
1180  * Parameters     : I : struct sk_buff *skb - packet to transfer
1181  *                  I : struct device *dev  - SK_G16 device structure
1182  * Return Value   : 0 - OK
1183  *                  1 - Could not transmit (dev_queue_xmit will queue it)
1184  *                      and try to sent it later
1185  * Globals        : None
1186  * Side Effects   : None
1187  * Update History :
1188  *     YY/MM/DD  uid  Description
1189 -*/
1190 
1191 static int SK_send_packet(struct sk_buff *skb, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1192 {
1193     struct priv *p = (struct priv *) dev->priv;
1194     struct tmd *tmdp;
1195 
1196     if (dev->tbusy)
1197     {
1198         /* if Transmitter more than 150ms busy -> time_out */
1199 
1200         int tickssofar = jiffies - dev->trans_start;
1201         if (tickssofar < 15)
1202         {
1203             return 1;                    /* We have to try transmit later */
1204         }
1205 
1206         printk("%s: xmitter timed out, try to restart!\n", dev->name);
1207 
1208         SK_lance_init(dev, MODE_NORMAL); /* Reinit LANCE */
1209 
1210         dev->tbusy = 0;                  /* Clear Transmitter flag */
1211 
1212         dev->trans_start = jiffies;      /* Mark Start of transmission */
1213 
1214     }
1215 
1216     /* 
1217      * If some upper Layer thinks we missed a transmit done interrupt
1218      * we are passed NULL.
1219      * (dev_queue_xmit net/inet/dev.c 
1220      */
1221 
1222     if (skb == NULL)
1223     {
1224         /* 
1225          * Dequeue packets from transmit queue and send them.
1226          */
1227         dev_tint(dev); 
1228                     
1229         return 0;
1230     }
1231     
1232     PRINTK2(("## %s: SK_send_packet() called, CSR0 %#04x.\n", 
1233             SK_NAME, SK_read_reg(CSR0)));
1234 
1235 
1236     /* 
1237      * Block a timer-based transmit from overlapping. 
1238      * This means check if we are already in. 
1239      */
1240 
1241     if (set_bit(0, (void *) &dev->tbusy) != 0) /* dev->tbusy already set ? */ 
1242     {
1243         printk("%s: Transmitter access conflict.\n", dev->name);
1244     }
1245     else
1246     {
1247         /* Evaluate Packet length */
1248         short len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 
1249        
1250         tmdp = p->tmdhead + p->tmdnum; /* Which descriptor for transmitting */
1251 
1252         /* Fill in Transmit Message Descriptor */
1253 
1254         /* Copy data into dual ported ram */
1255 
1256         memcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
1257                skb->len);
1258 
1259         tmdp->blen = -len;            /* set length to transmit */
1260 
1261         /* 
1262          * Packet start and end is always set because we use the maximum
1263          * packet length as buffer length.
1264          * Relinquish ownership to LANCE
1265          */
1266 
1267         tmdp->u.s.status = TX_OWN | TX_STP | TX_ENP;
1268         
1269         /* Start Demand Transmission */
1270         SK_write_reg(CSR0, CSR0_TDMD | CSR0_INEA);
1271 
1272         dev->trans_start = jiffies;   /* Mark start of transmission */
1273 
1274         /* Set pointer to next transmit buffer */
1275         p->tmdnum++; 
1276         p->tmdnum &= TMDNUM-1; 
1277 
1278         /* Do we own the next transmit buffer ? */
1279         if (! ((p->tmdhead + p->tmdnum)->u.s.status & TX_OWN) )
1280         {
1281            /* 
1282             * We own next buffer and are ready to transmit, so
1283             * clear busy flag
1284             */
1285            dev->tbusy = 0;
1286         }
1287     }
1288     dev_kfree_skb(skb, FREE_WRITE);
1289     return 0;  
1290 } /* End of SK_send_packet */
1291 
1292 
1293 /*-
1294  * Function       : SK_interrupt
1295  * Author         : Patrick J.D. Weichmann
1296  * Date Created   : 94/05/27
1297  *
1298  * Description    : SK_G16 interrupt handler which checks for LANCE
1299  *                  Errors, handles transmit and receive interrupts
1300  *
1301  * Parameters     : I : int irq, void *dev_id, struct pt_regs * regs -
1302  * Return Value   : None
1303  * Errors         : None
1304  * Globals        : None
1305  * Side Effects   : None
1306  * Update History :
1307  *     YY/MM/DD  uid  Description
1308 -*/
1309 
1310 static void SK_interrupt(int irq, void *dev_id, struct pt_regs * regs)
     /* [previous][next][first][last][top][bottom][index][help] */
1311 {
1312     int csr0;
1313     struct device *dev = (struct device *) irq2dev_map[irq];
1314     struct priv *p = (struct priv *) dev->priv;
1315 
1316 
1317     PRINTK2(("## %s: SK_interrupt(). status: %#06x\n", 
1318             SK_NAME, SK_read_reg(CSR0)));
1319 
1320     if (dev == NULL)
1321     {
1322         printk("SK_interrupt(): IRQ %d for unknown device.\n", irq);
1323     }
1324     
1325 
1326     if (dev->interrupt)
1327     {
1328         printk("%s: Re-entering the interrupt handler.\n", dev->name);
1329     }
1330 
1331     csr0 = SK_read_reg(CSR0);      /* store register for checking */
1332 
1333     dev->interrupt = 1;            /* We are handling an interrupt */
1334 
1335     /* 
1336      * Acknowledge all of the current interrupt sources, disable      
1337      * Interrupts (INEA = 0) 
1338      */
1339 
1340     SK_write_reg(CSR0, csr0 & CSR0_CLRALL); 
1341 
1342     if (csr0 & CSR0_ERR) /* LANCE Error */
1343     {
1344         printk("%s: error: %04x\n", dev->name, csr0);
1345       
1346         if (csr0 & CSR0_MISS)      /* No place to store packet ? */
1347         { 
1348             p->stats.rx_dropped++;
1349         }
1350     }
1351 
1352     if (csr0 & CSR0_RINT)          /* Receive Interrupt (packet arrived) */ 
1353     {
1354         SK_rxintr(dev); 
1355     }
1356 
1357     if (csr0 & CSR0_TINT)          /* Transmit interrupt (packet sent) */
1358     {
1359         SK_txintr(dev);
1360     }
1361 
1362     SK_write_reg(CSR0, CSR0_INEA); /* Enable Interrupts */
1363 
1364     dev->interrupt = 0;            /* We are out */
1365 } /* End of SK_interrupt() */ 
1366 
1367 
1368 /*-
1369  * Function       : SK_txintr
1370  * Author         : Patrick J.D. Weichmann
1371  * Date Created   : 94/05/27
1372  *
1373  * Description    : After sending a packet we check status, update
1374  *                  statistics and relinquish ownership of transmit 
1375  *                  descriptor ring.
1376  *
1377  * Parameters     : I : struct device *dev - SK_G16 device structure
1378  * Return Value   : None
1379  * Errors         : None
1380  * Globals        : None
1381  * Update History :
1382  *     YY/MM/DD  uid  Description
1383 -*/
1384 
1385 static void SK_txintr(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1386 {
1387     int tmdstat;
1388     struct tmd *tmdp;
1389     struct priv *p = (struct priv *) dev->priv;
1390 
1391 
1392     PRINTK2(("## %s: SK_txintr() status: %#06x\n", 
1393             SK_NAME, SK_read_reg(CSR0)));
1394 
1395     tmdp = p->tmdhead + p->tmdlast;     /* Which buffer we sent at last ? */
1396 
1397     /* Set next buffer */
1398     p->tmdlast++;
1399     p->tmdlast &= TMDNUM-1;
1400 
1401     tmdstat = tmdp->u.s.status & 0xff00; /* filter out status bits 15:08 */
1402 
1403     /* 
1404      * We check status of transmitted packet.
1405      * see LANCE data-sheet for error explanation
1406      */
1407     if (tmdstat & TX_ERR) /* Error occurred */
1408     {
1409         printk("%s: TX error: %04x %04x\n", dev->name, (int) tmdstat,
1410                 (int) tmdp->status2);
1411 
1412         if (tmdp->status2 & TX_TDR)    /* TDR problems? */
1413         {
1414             printk("%s: tdr-problems \n", dev->name);
1415         }
1416 
1417         if (tmdp->status2 & TX_RTRY)   /* Failed in 16 attempts to transmit ? */
1418             p->stats.tx_aborted_errors++;   
1419         if (tmdp->status2 & TX_LCOL)   /* Late collision ? */
1420             p->stats.tx_window_errors++; 
1421         if (tmdp->status2 & TX_LCAR)   /* Loss of Carrier ? */  
1422             p->stats.tx_carrier_errors++;
1423         if (tmdp->status2 & TX_UFLO)   /* Underflow error ? */
1424         {
1425             p->stats.tx_fifo_errors++;
1426 
1427             /* 
1428              * If UFLO error occurs it will turn transmitter of.
1429              * So we must reinit LANCE
1430              */
1431 
1432             SK_lance_init(dev, MODE_NORMAL);
1433         }
1434         
1435         p->stats.tx_errors++;
1436 
1437         tmdp->status2 = 0;             /* Clear error flags */
1438     }
1439     else if (tmdstat & TX_MORE)        /* Collisions occurred ? */
1440     {
1441         /* 
1442          * Here I have a problem.
1443          * I only know that there must be one or up to 15 collisions.
1444          * Thats why TX_MORE is set, because after 16 attempts TX_RTRY
1445          * will be set which means couldn't send packet aborted transfer.
1446          *
1447          * First I did not have this in but then I thought at minimum
1448          * we see that something was not ok.
1449          * If anyone knows something better than this to handle this
1450          * please report it. (see Email addresses in the README file)
1451          */ 
1452 
1453         p->stats.collisions++; 
1454     }
1455     else   /* Packet sent without any problems */
1456     {
1457         p->stats.tx_packets++; 
1458     }
1459 
1460     /* 
1461      * We mark transmitter not busy anymore, because now we have a free
1462      * transmit descriptor which can be filled by SK_send_packet and
1463      * afterwards sent by the LANCE
1464      */
1465 
1466     dev->tbusy = 0; 
1467 
1468     /* 
1469      * mark_bh(NET_BH);
1470      * This will cause net_bh() to run after this interrupt handler.
1471      *
1472      * The function which do handle slow IRQ parts is do_bottom_half()
1473      * which runs at normal kernel priority, that means all interrupt are
1474      * enabled. (see kernel/irq.c)
1475      *  
1476      * net_bh does something like this:
1477      *  - check if already in net_bh
1478      *  - try to transmit something from the send queue
1479      *  - if something is in the receive queue send it up to higher 
1480      *    levels if it is a known protocol
1481      *  - try to transmit something from the send queue
1482      */
1483 
1484     mark_bh(NET_BH); 
1485 
1486 } /* End of SK_txintr() */
1487 
1488 
1489 /*-
1490  * Function       : SK_rxintr
1491  * Author         : Patrick J.D. Weichmann
1492  * Date Created   : 94/05/27
1493  *
1494  * Description    : Buffer sent, check for errors, relinquish ownership
1495  *                  of the receive message descriptor. 
1496  *
1497  * Parameters     : I : SK_G16 device structure
1498  * Return Value   : None
1499  * Globals        : None
1500  * Update History :
1501  *     YY/MM/DD  uid  Description
1502 -*/
1503 
1504 static void SK_rxintr(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1505 {
1506 
1507     struct rmd *rmdp;
1508     int rmdstat;
1509     struct priv *p = (struct priv *) dev->priv;
1510 
1511     PRINTK2(("## %s: SK_rxintr(). CSR0: %#06x\n", 
1512             SK_NAME, SK_read_reg(CSR0)));
1513 
1514     rmdp = p->rmdhead + p->rmdnum;
1515 
1516     /* As long as we own the next entry, check status and send
1517      * it up to higher layer 
1518      */
1519 
1520     while (!( (rmdstat = rmdp->u.s.status) & RX_OWN))
1521     {
1522         /* 
1523          * Start and end of packet must be set, because we use 
1524          * the ethernet maximum packet length (1518) as buffer size.
1525          * 
1526          * Because our buffers are at maximum OFLO and BUFF errors are
1527          * not to be concerned (see Data sheet)
1528          */
1529 
1530         if ((rmdstat & (RX_STP | RX_ENP)) != (RX_STP | RX_ENP))
1531         {
1532             /* Start of a frame > 1518 Bytes ? */
1533 
1534             if (rmdstat & RX_STP) 
1535             {
1536                 p->stats.rx_errors++;        /* bad packet received */
1537                 p->stats.rx_length_errors++; /* packet too long */
1538 
1539                 printk("%s: packet too long\n", dev->name);
1540             }
1541             
1542             /* 
1543              * All other packets will be ignored until a new frame with
1544              * start (RX_STP) set follows.
1545              * 
1546              * What we do is just give descriptor free for new incoming
1547              * packets. 
1548              */
1549 
1550             rmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */ 
1551 
1552         }
1553         else if (rmdstat & RX_ERR)          /* Receive Error ? */
1554         {
1555             printk("%s: RX error: %04x\n", dev->name, (int) rmdstat);
1556             
1557             p->stats.rx_errors++;
1558 
1559             if (rmdstat & RX_FRAM) p->stats.rx_frame_errors++;
1560             if (rmdstat & RX_CRC)  p->stats.rx_crc_errors++;
1561 
1562             rmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */
1563 
1564         }
1565         else /* We have a packet which can be queued for the upper layers */
1566         {
1567 
1568             int len = (rmdp->mlen & 0x0fff);  /* extract message length from receive buffer */
1569             struct sk_buff *skb;
1570 
1571             skb = dev_alloc_skb(len+2); /* allocate socket buffer */ 
1572 
1573             if (skb == NULL)                /* Could not get mem ? */
1574             {
1575     
1576                 /* 
1577                  * Couldn't allocate sk_buffer so we give descriptor back
1578                  * to Lance, update statistics and go ahead.
1579                  */
1580 
1581                 rmdp->u.s.status = RX_OWN;  /* Relinquish ownership to LANCE */
1582                 printk("%s: Couldn't allocate sk_buff, deferring packet.\n",
1583                        dev->name);
1584                 p->stats.rx_dropped++;
1585 
1586                 break;                      /* Jump out */
1587             }
1588             
1589             /* Prepare sk_buff to queue for upper layers */
1590 
1591             skb->dev = dev;
1592             skb_reserve(skb,2);         /* Align IP header on 16 byte boundary */
1593             
1594             /* 
1595              * Copy data out of our receive descriptor into sk_buff.
1596              *
1597              * (rmdp->u.buffer & 0x00ffffff) -> get address of buffer and 
1598              * ignore status fields) 
1599              */
1600 
1601             memcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
1602                    len);
1603 
1604 
1605             /* 
1606              * Notify the upper protocol layers that there is another packet
1607              * to handle
1608              *
1609              * netif_rx() always succeeds. see /net/inet/dev.c for more.
1610              */
1611 
1612             skb->protocol=eth_type_trans(skb,dev);
1613             netif_rx(skb);                 /* queue packet and mark it for processing */
1614            
1615             /* 
1616              * Packet is queued and marked for processing so we
1617              * free our descriptor and update statistics 
1618              */
1619 
1620             rmdp->u.s.status = RX_OWN;
1621             p->stats.rx_packets++;
1622 
1623 
1624             p->rmdnum++;
1625             p->rmdnum %= RMDNUM;
1626 
1627             rmdp = p->rmdhead + p->rmdnum;
1628         }
1629     }
1630 } /* End of SK_rxintr() */
1631 
1632 
1633 /*-
1634  * Function       : SK_close
1635  * Author         : Patrick J.D. Weichmann
1636  * Date Created   : 94/05/26
1637  *
1638  * Description    : close gets called from dev_close() and should
1639  *                  deinstall the card (free_irq, mem etc).
1640  *
1641  * Parameters     : I : struct device *dev - our device structure
1642  * Return Value   : 0 - closed device driver
1643  * Errors         : None
1644  * Globals        : None
1645  * Update History :
1646  *     YY/MM/DD  uid  Description
1647 -*/
1648 
1649 /* I have tried to set BOOT_ROM on and RAM off but then, after a 'ifconfig
1650  * down' the system stops. So I don't shut set card to init state.
1651  */
1652 
1653 static int SK_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1654 {
1655 
1656     PRINTK(("## %s: SK_close(). CSR0: %#06x\n", 
1657            SK_NAME, SK_read_reg(CSR0)));
1658 
1659     dev->tbusy = 1;                /* Transmitter busy */
1660     dev->start = 0;                /* Card down */
1661 
1662     printk("%s: Shutting %s down CSR0 %#06x\n", dev->name, SK_NAME, 
1663            (int) SK_read_reg(CSR0));
1664 
1665     SK_write_reg(CSR0, CSR0_STOP); /* STOP the LANCE */
1666 
1667     free_irq(dev->irq, NULL);      /* Free IRQ */
1668     irq2dev_map[dev->irq] = 0;     /* Mark IRQ as unused */
1669 
1670     return 0; /* always succeed */
1671     
1672 } /* End of SK_close() */
1673 
1674 
1675 /*-
1676  * Function       : SK_get_stats
1677  * Author         : Patrick J.D. Weichmann
1678  * Date Created   : 94/05/26
1679  *
1680  * Description    : Return current status structure to upper layers.
1681  *                  It is called by sprintf_stats (dev.c).
1682  *
1683  * Parameters     : I : struct device *dev   - our device structure
1684  * Return Value   : struct enet_statistics * - our current statistics
1685  * Errors         : None
1686  * Side Effects   : None
1687  * Update History :
1688  *     YY/MM/DD  uid  Description
1689 -*/
1690 
1691 static struct enet_statistics *SK_get_stats(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1692 {
1693 
1694     struct priv *p = (struct priv *) dev->priv;
1695 
1696     PRINTK(("## %s: SK_get_stats(). CSR0: %#06x\n", 
1697            SK_NAME, SK_read_reg(CSR0)));
1698 
1699     return &p->stats;             /* Return Device status */
1700 
1701 } /* End of SK_get_stats() */
1702 
1703 
1704 /*-
1705  * Function       : set_multicast_list
1706  * Author         : Patrick J.D. Weichmann
1707  * Date Created   : 94/05/26
1708  *
1709  * Description    : This function gets called when a program performs
1710  *                  a SIOCSIFFLAGS call. Ifconfig does this if you call
1711  *                  'ifconfig [-]allmulti' which enables or disables the
1712  *                  Promiscuous mode.
1713  *                  Promiscuous mode is when the Network card accepts all
1714  *                  packets, not only the packets which match our MAC 
1715  *                  Address. It is useful for writing a network monitor,
1716  *                  but it is also a security problem. You have to remember
1717  *                  that all information on the net is not encrypted.
1718  *
1719  * Parameters     : I : struct device *dev - SK_G16 device Structure
1720  * Return Value   : None
1721  * Errors         : None
1722  * Globals        : None
1723  * Update History :
1724  *     YY/MM/DD  uid  Description
1725  *     95/10/18  ACox  New multicast calling scheme
1726 -*/
1727 
1728 
1729 /* Set or clear the multicast filter for SK_G16.
1730  */
1731 
1732 static void set_multicast_list(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1733 {
1734 
1735     if (dev->flags&IFF_PROMISC)
1736     {
1737         /* Reinitialize LANCE with MODE_PROM set */
1738         SK_lance_init(dev, MODE_PROM);
1739     }
1740     else if (dev->mc_count==0 && !(dev->flags&IFF_ALLMULTI))
1741     {
1742         /* Reinitialize LANCE without MODE_PROM */
1743         SK_lance_init(dev, MODE_NORMAL);
1744     }
1745     else
1746     {
1747         /* Multicast with logical address filter on */
1748         /* Reinitialize LANCE without MODE_PROM */
1749         SK_lance_init(dev, MODE_NORMAL);
1750         
1751         /* Not implemented yet. */
1752     }
1753 } /* End of set_multicast_list() */
1754 
1755 
1756 
1757 /*-
1758  * Function       : SK_rom_addr
1759  * Author         : Patrick J.D. Weichmann
1760  * Date Created   : 94/06/01
1761  *
1762  * Description    : Try to find a Boot_ROM at all possible locations
1763  *
1764  * Parameters     : None
1765  * Return Value   : Address where Boot_ROM is
1766  * Errors         : 0 - Did not find Boot_ROM
1767  * Globals        : None
1768  * Update History :
1769  *     YY/MM/DD  uid  Description
1770 -*/
1771 
1772 unsigned int SK_rom_addr(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1773 {
1774     int i,j;
1775     int rom_found = 0;
1776     unsigned int rom_location[] = SK_BOOT_ROM_LOCATIONS;
1777     unsigned char rom_id[] = SK_BOOT_ROM_ID;
1778     unsigned char *test_byte;
1779 
1780     /* Autodetect Boot_ROM */
1781     PRINTK(("## %s: Autodetection of Boot_ROM\n", SK_NAME));
1782 
1783     for (i = 0; (rom_location[i] != 0) && (rom_found == 0); i++)
1784     {
1785         
1786         PRINTK(("##   Trying ROM location %#08x", rom_location[i]));
1787         
1788         rom_found = 1; 
1789         for (j = 0; j < 6; j++)
1790         {
1791             test_byte = (unsigned char *) (rom_location[i]+j);
1792             PRINTK((" %02x ", *test_byte));
1793 
1794             if(!(*test_byte == rom_id[j]))
1795             {
1796                 rom_found = 0;
1797             } 
1798         }
1799         PRINTK(("\n"));
1800     }
1801 
1802     if (rom_found == 1)
1803     {
1804         PRINTK(("## %s: Boot_ROM found at %#08x\n", 
1805                SK_NAME, rom_location[(i-1)]));
1806 
1807         return (rom_location[--i]);
1808     }
1809     else
1810     {
1811         PRINTK(("%s: No Boot_ROM found\n", SK_NAME));
1812         return 0;
1813     }
1814 } /* End of SK_rom_addr() */
1815 
1816 
1817 
1818 /* LANCE access functions 
1819  *
1820  * ! CSR1-3 can only be accessed when in CSR0 the STOP bit is set !
1821  */
1822 
1823 
1824 /*-
1825  * Function       : SK_reset_board
1826  *
1827  * Author         : Patrick J.D. Weichmann
1828  *
1829  * Date Created   : 94/05/25
1830  *
1831  * Description    : This function resets SK_G16 and all components, but
1832  *                  POS registers are not changed
1833  *
1834  * Parameters     : None
1835  * Return Value   : None
1836  * Errors         : None
1837  * Globals        : SK_RAM *board - SK_RAM structure pointer
1838  *
1839  * Update History :
1840  *     YY/MM/DD  uid  Description
1841 -*/
1842 
1843 void SK_reset_board(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1844 {
1845     int i;
1846 
1847     SK_PORT = 0x00;           /* Reset active */
1848     for (i = 0; i < 10 ; i++) /* Delay min 5ms */
1849         ;
1850     SK_PORT = SK_RESET;       /* Set back to normal operation */
1851 
1852 } /* End of SK_reset_board() */
1853 
1854 
1855 /*-
1856  * Function       : SK_set_RAP
1857  * Author         : Patrick J.D. Weichmann
1858  * Date Created   : 94/05/25
1859  *
1860  * Description    : Set LANCE Register Address Port to register
1861  *                  for later data transfer.
1862  *
1863  * Parameters     : I : reg_number - which CSR to read/write from/to
1864  * Return Value   : None
1865  * Errors         : None
1866  * Globals        : SK_RAM *board - SK_RAM structure pointer
1867  * Update History :
1868  *     YY/MM/DD  uid  Description
1869 -*/
1870 
1871 void SK_set_RAP(int reg_number)
     /* [previous][next][first][last][top][bottom][index][help] */
1872 {
1873     SK_IOREG = reg_number;
1874     SK_PORT  = SK_RESET | SK_RAP | SK_WREG;
1875     SK_IOCOM = SK_DOIO;
1876 
1877     while (SK_PORT & SK_IORUN) 
1878         ;
1879 } /* End of SK_set_RAP() */
1880 
1881 
1882 /*-
1883  * Function       : SK_read_reg
1884  * Author         : Patrick J.D. Weichmann
1885  * Date Created   : 94/05/25
1886  *
1887  * Description    : Set RAP and read data from a LANCE CSR register
1888  *
1889  * Parameters     : I : reg_number - which CSR to read from
1890  * Return Value   : Register contents
1891  * Errors         : None
1892  * Globals        : SK_RAM *board - SK_RAM structure pointer
1893  * Update History :
1894  *     YY/MM/DD  uid  Description
1895 -*/
1896 
1897 int SK_read_reg(int reg_number)
     /* [previous][next][first][last][top][bottom][index][help] */
1898 {
1899     SK_set_RAP(reg_number);
1900 
1901     SK_PORT  = SK_RESET | SK_RDATA | SK_RREG;
1902     SK_IOCOM = SK_DOIO;
1903 
1904     while (SK_PORT & SK_IORUN)
1905         ;
1906     return (SK_IOREG);
1907 
1908 } /* End of SK_read_reg() */
1909 
1910 
1911 /*-
1912  * Function       : SK_rread_reg
1913  * Author         : Patrick J.D. Weichmann
1914  * Date Created   : 94/05/28
1915  *
1916  * Description    : Read data from preseted register.
1917  *                  This function requires that you know which
1918  *                  Register is actually set. Be aware that CSR1-3
1919  *                  can only be accessed when in CSR0 STOP is set.
1920  *
1921  * Return Value   : Register contents
1922  * Errors         : None
1923  * Globals        : SK_RAM *board - SK_RAM structure pointer
1924  * Update History :
1925  *     YY/MM/DD  uid  Description
1926 -*/
1927 
1928 int SK_rread_reg(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1929 {
1930     SK_PORT  = SK_RESET | SK_RDATA | SK_RREG;
1931 
1932     SK_IOCOM = SK_DOIO;
1933 
1934     while (SK_PORT & SK_IORUN)
1935         ;
1936     return (SK_IOREG);
1937 
1938 } /* End of SK_rread_reg() */
1939 
1940 
1941 /*-
1942  * Function       : SK_write_reg
1943  * Author         : Patrick J.D. Weichmann
1944  * Date Created   : 94/05/25
1945  *
1946  * Description    : This function sets the RAP then fills in the
1947  *                  LANCE I/O Reg and starts Transfer to LANCE.
1948  *                  It waits until transfer has ended which is max. 7 ms
1949  *                  and then it returns.
1950  *
1951  * Parameters     : I : reg_number - which CSR to write to
1952  *                  I : value      - what value to fill into register 
1953  * Return Value   : None
1954  * Errors         : None
1955  * Globals        : SK_RAM *board - SK_RAM structure pointer
1956  * Update History :
1957  *     YY/MM/DD  uid  Description
1958 -*/
1959 
1960 void SK_write_reg(int reg_number, int value)
     /* [previous][next][first][last][top][bottom][index][help] */
1961 {
1962     SK_set_RAP(reg_number);
1963 
1964     SK_IOREG = value;
1965     SK_PORT  = SK_RESET | SK_RDATA | SK_WREG;
1966     SK_IOCOM = SK_DOIO;
1967 
1968     while (SK_PORT & SK_IORUN)
1969         ;
1970 } /* End of SK_write_reg */
1971 
1972 
1973 
1974 /* 
1975  * Debugging functions
1976  * -------------------
1977  */
1978 
1979 /*-
1980  * Function       : SK_print_pos
1981  * Author         : Patrick J.D. Weichmann
1982  * Date Created   : 94/05/25
1983  *
1984  * Description    : This function prints out the 4 POS (Programmable
1985  *                  Option Select) Registers. Used mainly to debug operation.
1986  *
1987  * Parameters     : I : struct device *dev - SK_G16 device structure
1988  *                  I : char * - Text which will be printed as title
1989  * Return Value   : None
1990  * Errors         : None
1991  * Update History :
1992  *     YY/MM/DD  uid  Description
1993 -*/
1994 
1995 void SK_print_pos(struct device *dev, char *text)
     /* [previous][next][first][last][top][bottom][index][help] */
1996 {
1997     int ioaddr = dev->base_addr;
1998 
1999     unsigned char pos0 = inb(SK_POS0),
2000                   pos1 = inb(SK_POS1),
2001                   pos2 = inb(SK_POS2),
2002                   pos3 = inb(SK_POS3),
2003                   pos4 = inb(SK_POS4);
2004 
2005 
2006     printk("## %s: %s.\n"
2007            "##   pos0=%#4x pos1=%#4x pos2=%#04x pos3=%#08x pos4=%#04x\n",
2008            SK_NAME, text, pos0, pos1, pos2, (pos3<<14), pos4);
2009 
2010 } /* End of SK_print_pos() */
2011 
2012 
2013 
2014 /*-
2015  * Function       : SK_print_dev
2016  * Author         : Patrick J.D. Weichmann
2017  * Date Created   : 94/05/25
2018  *
2019  * Description    : This function simply prints out the important fields
2020  *                  of the device structure.
2021  *
2022  * Parameters     : I : struct device *dev  - SK_G16 device structure
2023  *                  I : char *text - Title for printing
2024  * Return Value   : None
2025  * Errors         : None
2026  * Update History :
2027  *     YY/MM/DD  uid  Description
2028 -*/
2029 
2030 void SK_print_dev(struct device *dev, char *text)
     /* [previous][next][first][last][top][bottom][index][help] */
2031 {
2032     if (dev == NULL)
2033     {
2034         printk("## %s: Device Structure. %s\n", SK_NAME, text);
2035         printk("## DEVICE == NULL\n");
2036     }
2037     else
2038     {
2039         printk("## %s: Device Structure. %s\n", SK_NAME, text);
2040         printk("## Device Name: %s Base Address: %#06lx IRQ: %d\n", 
2041                dev->name, dev->base_addr, dev->irq);
2042                
2043         printk("##   FLAGS: start: %d tbusy: %ld int: %d\n", 
2044                dev->start, dev->tbusy, dev->interrupt);
2045 
2046         printk("## next device: %#08x init function: %#08x\n", 
2047               (int) dev->next, (int) dev->init);
2048     }
2049 
2050 } /* End of SK_print_dev() */
2051 
2052 
2053 
2054 /*-
2055  * Function       : SK_print_ram
2056  * Author         : Patrick J.D. Weichmann
2057  * Date Created   : 94/06/02
2058  *
2059  * Description    : This function is used to check how are things set up
2060  *                  in the 16KB RAM. Also the pointers to the receive and 
2061  *                  transmit descriptor rings and rx and tx buffers locations.
2062  *                  It contains a minor bug in printing, but has no effect to the values
2063  *                  only newlines are not correct.
2064  *
2065  * Parameters     : I : struct device *dev - SK_G16 device structure
2066  * Return Value   : None
2067  * Errors         : None
2068  * Globals        : None
2069  * Update History :
2070  *     YY/MM/DD  uid  Description
2071 -*/
2072 
2073 void SK_print_ram(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
2074 {
2075 
2076     int i;    
2077     struct priv *p = (struct priv *) dev->priv;
2078 
2079     printk("## %s: RAM Details.\n"
2080            "##   RAM at %#08x tmdhead: %#08x rmdhead: %#08x initblock: %#08x\n",
2081            SK_NAME, 
2082            (unsigned int) p->ram,
2083            (unsigned int) p->tmdhead, 
2084            (unsigned int) p->rmdhead, 
2085            (unsigned int) &(p->ram)->ib);
2086            
2087     printk("##   ");
2088 
2089     for(i = 0; i < TMDNUM; i++)
2090     {
2091            if (!(i % 3)) /* Every third line do a newline */
2092            {
2093                printk("\n##   ");
2094            }
2095         printk("tmdbufs%d: %#08x ", (i+1), (int) p->tmdbufs[i]);
2096     }
2097     printk("##   ");
2098 
2099     for(i = 0; i < RMDNUM; i++)
2100     {
2101          if (!(i % 3)) /* Every third line do a newline */
2102            {
2103                printk("\n##   ");
2104            }
2105         printk("rmdbufs%d: %#08x ", (i+1), (int) p->rmdbufs[i]);
2106     } 
2107     printk("\n");
2108 
2109 } /* End of SK_print_ram() */
2110 

/* [previous][next][first][last][top][bottom][index][help] */