git.oblomov.eu Git - linux-2.6/blob - drivers/net/sk_g16.c

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