err.no Git - linux-2.6/blob - drivers/net/tulip/de4x5.c

   1 /*  de4x5.c: A DIGITAL DC21x4x DECchip and DE425/DE434/DE435/DE450/DE500
   2              ethernet driver for Linux.
   3
   4     Copyright 1994, 1995 Digital Equipment Corporation.
   5
   6     Testing resources for this driver have been made available
   7     in part by NASA Ames Research Center (mjacob@nas.nasa.gov).
   8
   9     The author may be reached at davies@maniac.ultranet.com.
  10
  11     This program is free software; you can redistribute  it and/or modify it
  12     under  the terms of  the GNU General  Public License as published by the
  13     Free Software Foundation;  either version 2 of the  License, or (at your
  14     option) any later version.
  15
  16     THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR   IMPLIED
  17     WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  18     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  19     NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT,  INDIRECT,
  20     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21     NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
  22     USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  23     ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  24     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27     You should have received a copy of the  GNU General Public License along
  28     with this program; if not, write  to the Free Software Foundation, Inc.,
  29     675 Mass Ave, Cambridge, MA 02139, USA.
  30
  31     Originally,   this  driver  was    written  for the  Digital   Equipment
  32     Corporation series of EtherWORKS ethernet cards:
  33
  34         DE425 TP/COAX EISA
  35         DE434 TP PCI
  36         DE435 TP/COAX/AUI PCI
  37         DE450 TP/COAX/AUI PCI
  38         DE500 10/100 PCI Fasternet
  39
  40     but it  will  now attempt  to  support all  cards which   conform to the
  41     Digital Semiconductor   SROM   Specification.    The  driver   currently
  42     recognises the following chips:
  43
  44         DC21040  (no SROM)
  45         DC21041[A]
  46         DC21140[A]
  47         DC21142
  48         DC21143
  49
  50     So far the driver is known to work with the following cards:
  51
  52         KINGSTON
  53         Linksys
  54         ZNYX342
  55         SMC8432
  56         SMC9332 (w/new SROM)
  57         ZNYX31[45]
  58         ZNYX346 10/100 4 port (can act as a 10/100 bridge!)
  59
  60     The driver has been tested on a relatively busy network using the DE425,
  61     DE434, DE435 and DE500 cards and benchmarked with 'ttcp': it transferred
  62     16M of data to a DECstation 5000/200 as follows:
  63
  64                 TCP           UDP
  65              TX     RX     TX     RX
  66     DE425   1030k  997k   1170k  1128k
  67     DE434   1063k  995k   1170k  1125k
  68     DE435   1063k  995k   1170k  1125k
  69     DE500   1063k  998k   1170k  1125k  in 10Mb/s mode
  70
  71     All  values are typical (in   kBytes/sec) from a  sample  of 4 for  each
  72     measurement. Their error is +/-20k on a quiet (private) network and also
  73     depend on what load the CPU has.
  74
  75     =========================================================================
  76     This driver  has been written substantially  from  scratch, although its
  77     inheritance of style and stack interface from 'ewrk3.c' and in turn from
  78     Donald Becker's 'lance.c' should be obvious. With the module autoload of
  79     every  usable DECchip board,  I  pinched Donald's 'next_module' field to
  80     link my modules together.
  81
  82     Upto 15 EISA cards can be supported under this driver, limited primarily
  83     by the available IRQ lines.  I have  checked different configurations of
  84     multiple depca, EtherWORKS 3 cards and de4x5 cards and  have not found a
  85     problem yet (provided you have at least depca.c v0.38) ...
  86
  87     PCI support has been added  to allow the driver  to work with the DE434,
  88     DE435, DE450 and DE500 cards. The I/O accesses are a bit of a kludge due
  89     to the differences in the EISA and PCI CSR address offsets from the base
  90     address.
  91
  92     The ability to load this  driver as a loadable  module has been included
  93     and used extensively  during the driver development  (to save those long
  94     reboot sequences).  Loadable module support  under PCI and EISA has been
  95     achieved by letting the driver autoprobe as if it were compiled into the
  96     kernel. Do make sure  you're not sharing  interrupts with anything  that
  97     cannot accommodate  interrupt  sharing!
  98
  99     To utilise this ability, you have to do 8 things:
 100
 101     0) have a copy of the loadable modules code installed on your system.
 102     1) copy de4x5.c from the  /linux/drivers/net directory to your favourite
 103     temporary directory.
 104     2) for fixed  autoprobes (not  recommended),  edit the source code  near
 105     line 5594 to reflect the I/O address  you're using, or assign these when
 106     loading by:
 107
 108                    insmod de4x5 io=0xghh           where g = bus number
 109                                                         hh = device number
 110
 111        NB: autoprobing for modules is now supported by default. You may just
 112            use:
 113
 114                    insmod de4x5
 115
 116            to load all available boards. For a specific board, still use
 117            the 'io=?' above.
 118     3) compile  de4x5.c, but include -DMODULE in  the command line to ensure
 119     that the correct bits are compiled (see end of source code).
 120     4) if you are wanting to add a new  card, goto 5. Otherwise, recompile a
 121     kernel with the de4x5 configuration turned off and reboot.
 122     5) insmod de4x5 [io=0xghh]
 123     6) run the net startup bits for your new eth?? interface(s) manually
 124     (usually /etc/rc.inet[12] at boot time).
 125     7) enjoy!
 126
 127     To unload a module, turn off the associated interface(s)
 128     'ifconfig eth?? down' then 'rmmod de4x5'.
 129
 130     Automedia detection is included so that in  principal you can disconnect
 131     from, e.g.  TP, reconnect  to BNC  and  things will still work  (after a
 132     pause whilst the   driver figures out   where its media went).  My tests
 133     using ping showed that it appears to work....
 134
 135     By  default,  the driver will  now   autodetect any  DECchip based card.
 136     Should you have a need to restrict the driver to DIGITAL only cards, you
 137     can compile with a  DEC_ONLY define, or if  loading as a module, use the
 138     'dec_only=1'  parameter.
 139
 140     I've changed the timing routines to  use the kernel timer and scheduling
 141     functions  so that the  hangs  and other assorted problems that occurred
 142     while autosensing the  media  should be gone.  A  bonus  for the DC21040
 143     auto  media sense algorithm is  that it can now  use one that is more in
 144     line with the  rest (the DC21040  chip doesn't  have a hardware  timer).
 145     The downside is the 1 'jiffies' (10ms) resolution.
 146
 147     IEEE 802.3u MII interface code has  been added in anticipation that some
 148     products may use it in the future.
 149
 150     The SMC9332 card  has a non-compliant SROM  which needs fixing -  I have
 151     patched this  driver to detect it  because the SROM format used complies
 152     to a previous DEC-STD format.
 153
 154     I have removed the buffer copies needed for receive on Intels.  I cannot
 155     remove them for   Alphas since  the  Tulip hardware   only does longword
 156     aligned  DMA transfers  and  the  Alphas get   alignment traps with  non
 157     longword aligned data copies (which makes them really slow). No comment.
 158
 159     I  have added SROM decoding  routines to make this  driver work with any
 160     card that  supports the Digital  Semiconductor SROM spec. This will help
 161     all  cards running the dc2114x  series chips in particular.  Cards using
 162     the dc2104x  chips should run correctly with  the basic  driver.  I'm in
 163     debt to <mjacob@feral.com> for the  testing and feedback that helped get
 164     this feature working.  So far we have  tested KINGSTON, SMC8432, SMC9332
 165     (with the latest SROM complying  with the SROM spec  V3: their first was
 166     broken), ZNYX342  and  LinkSys. ZYNX314 (dual  21041  MAC) and  ZNYX 315
 167     (quad 21041 MAC)  cards also  appear  to work despite their  incorrectly
 168     wired IRQs.
 169
 170     I have added a temporary fix for interrupt problems when some SCSI cards
 171     share the same interrupt as the DECchip based  cards. The problem occurs
 172     because  the SCSI card wants to  grab the interrupt  as a fast interrupt
 173     (runs the   service routine with interrupts turned   off) vs.  this card
 174     which really needs to run the service routine with interrupts turned on.
 175     This driver will  now   add the interrupt service   routine  as  a  fast
 176     interrupt if it   is bounced from the   slow interrupt.  THIS IS NOT   A
 177     RECOMMENDED WAY TO RUN THE DRIVER  and has been done  for a limited time
 178     until  people   sort  out their  compatibility    issues and the  kernel
 179     interrupt  service code  is  fixed.   YOU  SHOULD SEPARATE OUT  THE FAST
 180     INTERRUPT CARDS FROM THE SLOW INTERRUPT CARDS to ensure that they do not
 181     run on the same interrupt. PCMCIA/CardBus is another can of worms...
 182
 183     Finally, I think  I have really  fixed  the module  loading problem with
 184     more than one DECchip based  card.  As a  side effect, I don't mess with
 185     the  device structure any  more which means that  if more than 1 card in
 186     2.0.x is    installed (4  in   2.1.x),  the  user   will have   to  edit
 187     linux/drivers/net/Space.c  to make room for  them. Hence, module loading
 188     is  the preferred way to use   this driver, since  it  doesn't have this
 189     limitation.
 190
 191     Where SROM media  detection is used and  full duplex is specified in the
 192     SROM,  the feature is  ignored unless  lp->params.fdx  is set at compile
 193     time  OR during  a   module load  (insmod  de4x5   args='eth??:fdx' [see
 194     below]).  This is because there  is no way  to automatically detect full
 195     duplex   links  except through   autonegotiation.    When I  include the
 196     autonegotiation feature in  the SROM autoconf  code, this detection will
 197     occur automatically for that case.
 198
 199     Command  line arguments are  now  allowed, similar  to passing arguments
 200     through LILO. This will allow a per adapter board  set up of full duplex
 201     and media. The only lexical constraints  are: the board name (dev->name)
 202     appears in the list before its  parameters.  The list of parameters ends
 203     either at the end of the parameter list or with another board name.  The
 204     following parameters are allowed:
 205
 206             fdx        for full duplex
 207             autosense  to set the media/speed; with the following
 208                        sub-parameters:
 209                        TP, TP_NW, BNC, AUI, BNC_AUI, 100Mb, 10Mb, AUTO
 210
 211     Case sensitivity is important  for  the sub-parameters. They *must*   be
 212     upper case. Examples:
 213
 214         insmod de4x5 args='eth1:fdx autosense=BNC eth0:autosense=100Mb'.
 215
 216     For a compiled in driver, at or above line 548, place e.g.
 217         #define DE4X5_PARM "eth0:fdx autosense=AUI eth2:autosense=TP"
 218
 219     Yes,  I know full duplex isn't  permissible on BNC  or AUI; they're just
 220     examples. By default, full duplex is turned off and  AUTO is the default
 221     autosense setting.  In reality, I expect only  the full duplex option to
 222     be used. Note the use of single quotes in the two examples above and the
 223     lack of commas to separate items. ALSO, you must get the requested media
 224     correct in relation to what the adapter SROM says it has. There's no way
 225     to  determine this in  advance other than by  trial and error and common
 226     sense, e.g. call a BNC connectored port 'BNC', not '10Mb'.
 227
 228     Changed the bus probing.  EISA used to be  done first,  followed by PCI.
 229     Most people probably don't even know  what a de425 is today and the EISA
 230     probe has messed  up some SCSI cards  in the past,  so now PCI is always
 231     probed  first  followed by  EISA if  a) the architecture allows EISA and
 232     either  b) there have been no PCI cards detected or  c) an EISA probe is
 233     forced by  the user.  To force  a probe  include  "force_eisa"  in  your
 234     insmod "args" line;  for built-in kernels either change the driver to do
 235     this  automatically  or include  #define DE4X5_FORCE_EISA  on or  before
 236     line 1040 in the driver.
 237
 238     TO DO:
 239     ------
 240
 241     Revision History
 242     ----------------
 243
 244     Version   Date        Description
 245
 246       0.1     17-Nov-94   Initial writing. ALPHA code release.
 247       0.2     13-Jan-95   Added PCI support for DE435's.
 248       0.21    19-Jan-95   Added auto media detection.
 249       0.22    10-Feb-95   Fix interrupt handler call <chris@cosy.sbg.ac.at>.
 250                           Fix recognition bug reported by <bkm@star.rl.ac.uk>.
 251                           Add request/release_region code.
 252                           Add loadable modules support for PCI.
 253                           Clean up loadable modules support.
 254       0.23    28-Feb-95   Added DC21041 and DC21140 support.
 255                           Fix missed frame counter value and initialisation.
 256                           Fixed EISA probe.
 257       0.24    11-Apr-95   Change delay routine to use <linux/udelay>.
 258                           Change TX_BUFFS_AVAIL macro.
 259                           Change media autodetection to allow manual setting.
 260                           Completed DE500 (DC21140) support.
 261       0.241   18-Apr-95   Interim release without DE500 Autosense Algorithm.
 262       0.242   10-May-95   Minor changes.
 263       0.30    12-Jun-95   Timer fix for DC21140.
 264                           Portability changes.
 265                           Add ALPHA changes from <jestabro@ant.tay1.dec.com>.
 266                           Add DE500 semi automatic autosense.
 267                           Add Link Fail interrupt TP failure detection.
 268                           Add timer based link change detection.
 269                           Plugged a memory leak in de4x5_queue_pkt().
 270       0.31    13-Jun-95   Fixed PCI stuff for 1.3.1.
 271       0.32    26-Jun-95   Added verify_area() calls in de4x5_ioctl() from a
 272                           suggestion by <heiko@colossus.escape.de>.
 273       0.33     8-Aug-95   Add shared interrupt support (not released yet).
 274       0.331   21-Aug-95   Fix de4x5_open() with fast CPUs.
 275                           Fix de4x5_interrupt().
 276                           Fix dc21140_autoconf() mess.
 277                           No shared interrupt support.
 278       0.332   11-Sep-95   Added MII management interface routines.
 279       0.40     5-Mar-96   Fix setup frame timeout <maartenb@hpkuipc.cern.ch>.
 280                           Add kernel timer code (h/w is too flaky).
 281                           Add MII based PHY autosense.
 282                           Add new multicasting code.
 283                           Add new autosense algorithms for media/mode
 284                           selection using kernel scheduling/timing.
 285                           Re-formatted.
 286                           Made changes suggested by <jeff@router.patch.net>:
 287                             Change driver to detect all DECchip based cards
 288                             with DEC_ONLY restriction a special case.
 289                             Changed driver to autoprobe as a module. No irq
 290                             checking is done now - assume BIOS is good!
 291                           Added SMC9332 detection <manabe@Roy.dsl.tutics.ac.jp>
 292       0.41    21-Mar-96   Don't check for get_hw_addr checksum unless DEC card
 293                           only <niles@axp745gsfc.nasa.gov>
 294                           Fix for multiple PCI cards reported by <jos@xos.nl>
 295                           Duh, put the IRQF_SHARED flag into request_interrupt().
 296                           Fix SMC ethernet address in enet_det[].
 297                           Print chip name instead of "UNKNOWN" during boot.
 298       0.42    26-Apr-96   Fix MII write TA bit error.
 299                           Fix bug in dc21040 and dc21041 autosense code.
 300                           Remove buffer copies on receive for Intels.
 301                           Change sk_buff handling during media disconnects to
 302                            eliminate DUP packets.
 303                           Add dynamic TX thresholding.
 304                           Change all chips to use perfect multicast filtering.
 305                           Fix alloc_device() bug <jari@markkus2.fimr.fi>
 306       0.43   21-Jun-96    Fix unconnected media TX retry bug.
 307                           Add Accton to the list of broken cards.
 308                           Fix TX under-run bug for non DC21140 chips.
 309                           Fix boot command probe bug in alloc_device() as
 310                            reported by <koen.gadeyne@barco.com> and
 311                            <orava@nether.tky.hut.fi>.
 312                           Add cache locks to prevent a race condition as
 313                            reported by <csd@microplex.com> and
 314                            <baba@beckman.uiuc.edu>.
 315                           Upgraded alloc_device() code.
 316       0.431  28-Jun-96    Fix potential bug in queue_pkt() from discussion
 317                           with <csd@microplex.com>
 318       0.44   13-Aug-96    Fix RX overflow bug in 2114[023] chips.
 319                           Fix EISA probe bugs reported by <os2@kpi.kharkov.ua>
 320                           and <michael@compurex.com>.
 321       0.441   9-Sep-96    Change dc21041_autoconf() to probe quiet BNC media
 322                            with a loopback packet.
 323       0.442   9-Sep-96    Include AUI in dc21041 media printout. Bug reported
 324                            by <bhat@mundook.cs.mu.OZ.AU>
 325       0.45    8-Dec-96    Include endian functions for PPC use, from work
 326                            by <cort@cs.nmt.edu> and <g.thomas@opengroup.org>.
 327       0.451  28-Dec-96    Added fix to allow autoprobe for modules after
 328                            suggestion from <mjacob@feral.com>.
 329       0.5    30-Jan-97    Added SROM decoding functions.
 330                           Updated debug flags.
 331                           Fix sleep/wakeup calls for PCI cards, bug reported
 332                            by <cross@gweep.lkg.dec.com>.
 333                           Added multi-MAC, one SROM feature from discussion
 334                            with <mjacob@feral.com>.
 335                           Added full module autoprobe capability.
 336                           Added attempt to use an SMC9332 with broken SROM.
 337                           Added fix for ZYNX multi-mac cards that didn't
 338                            get their IRQs wired correctly.
 339       0.51   13-Feb-97    Added endian fixes for the SROM accesses from
 340                            <paubert@iram.es>
 341                           Fix init_connection() to remove extra device reset.
 342                           Fix MAC/PHY reset ordering in dc21140m_autoconf().
 343                           Fix initialisation problem with lp->timeout in
 344                            typeX_infoblock() from <paubert@iram.es>.
 345                           Fix MII PHY reset problem from work done by
 346                            <paubert@iram.es>.
 347       0.52   26-Apr-97    Some changes may not credit the right people -
 348                            a disk crash meant I lost some mail.
 349                           Change RX interrupt routine to drop rather than
 350                            defer packets to avoid hang reported by
 351                            <g.thomas@opengroup.org>.
 352                           Fix srom_exec() to return for COMPACT and type 1
 353                            infoblocks.
 354                           Added DC21142 and DC21143 functions.
 355                           Added byte counters from <phil@tazenda.demon.co.uk>
 356                           Added IRQF_DISABLED temporary fix from
 357                            <mjacob@feral.com>.
 358       0.53   12-Nov-97    Fix the *_probe() to include 'eth??' name during
 359                            module load: bug reported by
 360                            <Piete.Brooks@cl.cam.ac.uk>
 361                           Fix multi-MAC, one SROM, to work with 2114x chips:
 362                            bug reported by <cmetz@inner.net>.
 363                           Make above search independent of BIOS device scan
 364                            direction.
 365                           Completed DC2114[23] autosense functions.
 366       0.531  21-Dec-97    Fix DE500-XA 100Mb/s bug reported by
 367                            <robin@intercore.com
 368                           Fix type1_infoblock() bug introduced in 0.53, from
 369                            problem reports by
 370                            <parmee@postecss.ncrfran.france.ncr.com> and
 371                            <jo@ice.dillingen.baynet.de>.
 372                           Added argument list to set up each board from either
 373                            a module's command line or a compiled in #define.
 374                           Added generic MII PHY functionality to deal with
 375                            newer PHY chips.
 376                           Fix the mess in 2.1.67.
 377       0.532   5-Jan-98    Fix bug in mii_get_phy() reported by
 378                            <redhat@cococo.net>.
 379                           Fix bug in pci_probe() for 64 bit systems reported
 380                            by <belliott@accessone.com>.
 381       0.533   9-Jan-98    Fix more 64 bit bugs reported by <jal@cs.brown.edu>.
 382       0.534  24-Jan-98    Fix last (?) endian bug from <geert@linux-m68k.org>
 383       0.535  21-Feb-98    Fix Ethernet Address PROM reset bug for DC21040.
 384       0.536  21-Mar-98    Change pci_probe() to use the pci_dev structure.
 385                           **Incompatible with 2.0.x from here.**
 386       0.540   5-Jul-98    Atomicize assertion of dev->interrupt for SMP
 387                            from <lma@varesearch.com>
 388                           Add TP, AUI and BNC cases to 21140m_autoconf() for
 389                            case where a 21140 under SROM control uses, e.g. AUI
 390                            from problem report by <delchini@lpnp09.in2p3.fr>
 391                           Add MII parallel detection to 2114x_autoconf() for
 392                            case where no autonegotiation partner exists from
 393                            problem report by <mlapsley@ndirect.co.uk>.
 394                           Add ability to force connection type directly even
 395                            when using SROM control from problem report by
 396                            <earl@exis.net>.
 397                           Updated the PCI interface to conform with the latest
 398                            version. I hope nothing is broken...
 399                           Add TX done interrupt modification from suggestion
 400                            by <Austin.Donnelly@cl.cam.ac.uk>.
 401                           Fix is_anc_capable() bug reported by
 402                            <Austin.Donnelly@cl.cam.ac.uk>.
 403                           Fix type[13]_infoblock() bug: during MII search, PHY
 404                            lp->rst not run because lp->ibn not initialised -
 405                            from report & fix by <paubert@iram.es>.
 406                           Fix probe bug with EISA & PCI cards present from
 407                            report by <eirik@netcom.com>.
 408       0.541  24-Aug-98    Fix compiler problems associated with i386-string
 409                            ops from multiple bug reports and temporary fix
 410                            from <paubert@iram.es>.
 411                           Fix pci_probe() to correctly emulate the old
 412                            pcibios_find_class() function.
 413                           Add an_exception() for old ZYNX346 and fix compile
 414                            warning on PPC & SPARC, from <ecd@skynet.be>.
 415                           Fix lastPCI to correctly work with compiled in
 416                            kernels and modules from bug report by
 417                            <Zlatko.Calusic@CARNet.hr> et al.
 418       0.542  15-Sep-98    Fix dc2114x_autoconf() to stop multiple messages
 419                            when media is unconnected.
 420                           Change dev->interrupt to lp->interrupt to ensure
 421                            alignment for Alpha's and avoid their unaligned
 422                            access traps. This flag is merely for log messages:
 423                            should do something more definitive though...
 424       0.543  30-Dec-98    Add SMP spin locking.
 425       0.544   8-May-99    Fix for buggy SROM in Motorola embedded boards using
 426                            a 21143 by <mmporter@home.com>.
 427                           Change PCI/EISA bus probing order.
 428       0.545  28-Nov-99    Further Moto SROM bug fix from
 429                            <mporter@eng.mcd.mot.com>
 430                           Remove double checking for DEBUG_RX in de4x5_dbg_rx()
 431                            from report by <geert@linux-m68k.org>
 432       0.546  22-Feb-01    Fixes Alpha XP1000 oops.  The srom_search function
 433                            was causing a page fault when initializing the
 434                            variable 'pb', on a non de4x5 PCI device, in this
 435                            case a PCI bridge (DEC chip 21152). The value of
 436                            'pb' is now only initialized if a de4x5 chip is
 437                            present.
 438                            <france@handhelds.org>
 439       0.547  08-Nov-01    Use library crc32 functions by <Matt_Domsch@dell.com>
 440       0.548  30-Aug-03    Big 2.6 cleanup. Ported to PCI/EISA probing and
 441                            generic DMA APIs. Fixed DE425 support on Alpha.
 442                            <maz@wild-wind.fr.eu.org>
 443     =========================================================================
 444 */
 445
 446 #include <linux/module.h>
 447 #include <linux/kernel.h>
 448 #include <linux/string.h>
 449 #include <linux/interrupt.h>
 450 #include <linux/ptrace.h>
 451 #include <linux/errno.h>
 452 #include <linux/ioport.h>
 453 #include <linux/slab.h>
 454 #include <linux/pci.h>
 455 #include <linux/eisa.h>
 456 #include <linux/delay.h>
 457 #include <linux/init.h>
 458 #include <linux/spinlock.h>
 459 #include <linux/crc32.h>
 460 #include <linux/netdevice.h>
 461 #include <linux/etherdevice.h>
 462 #include <linux/skbuff.h>
 463 #include <linux/time.h>
 464 #include <linux/types.h>
 465 #include <linux/unistd.h>
 466 #include <linux/ctype.h>
 467 #include <linux/dma-mapping.h>
 468 #include <linux/moduleparam.h>
 469 #include <linux/bitops.h>
 470
 471 #include <asm/io.h>
 472 #include <asm/dma.h>
 473 #include <asm/byteorder.h>
 474 #include <asm/unaligned.h>
 475 #include <asm/uaccess.h>
 476 #ifdef CONFIG_PPC_PMAC
 477 #include <asm/machdep.h>
 478 #endif /* CONFIG_PPC_PMAC */
 479
 480 #include "de4x5.h"
 481
 482 static char version[] __devinitdata = "de4x5.c:V0.546 2001/02/22 davies@maniac.ultranet.com\n";
 483
 484 #define c_char const char
 485
 486 /*
 487 ** MII Information
 488 */
 489 struct phy_table {
 490     int reset;              /* Hard reset required?                         */
 491     int id;                 /* IEEE OUI                                     */
 492     int ta;                 /* One cycle TA time - 802.3u is confusing here */
 493     struct {                /* Non autonegotiation (parallel) speed det.    */
 494         int reg;
 495         int mask;
 496         int value;
 497     } spd;
 498 };
 499
 500 struct mii_phy {
 501     int reset;              /* Hard reset required?                      */
 502     int id;                 /* IEEE OUI                                  */
 503     int ta;                 /* One cycle TA time                         */
 504     struct {                /* Non autonegotiation (parallel) speed det. */
 505         int reg;
 506         int mask;
 507         int value;
 508     } spd;
 509     int addr;               /* MII address for the PHY                   */
 510     u_char  *gep;           /* Start of GEP sequence block in SROM       */
 511     u_char  *rst;           /* Start of reset sequence in SROM           */
 512     u_int mc;               /* Media Capabilities                        */
 513     u_int ana;              /* NWay Advertisement                        */
 514     u_int fdx;              /* Full DupleX capabilities for each media   */
 515     u_int ttm;              /* Transmit Threshold Mode for each media    */
 516     u_int mci;              /* 21142 MII Connector Interrupt info        */
 517 };
 518
 519 #define DE4X5_MAX_PHY 8     /* Allow upto 8 attached PHY devices per board */
 520
 521 struct sia_phy {
 522     u_char mc;              /* Media Code                                */
 523     u_char ext;             /* csr13-15 valid when set                   */
 524     int csr13;              /* SIA Connectivity Register                 */
 525     int csr14;              /* SIA TX/RX Register                        */
 526     int csr15;              /* SIA General Register                      */
 527     int gepc;               /* SIA GEP Control Information               */
 528     int gep;                /* SIA GEP Data                              */
 529 };
 530
 531 /*
 532 ** Define the know universe of PHY devices that can be
 533 ** recognised by this driver.
 534 */
 535 static struct phy_table phy_info[] = {
 536     {0, NATIONAL_TX, 1, {0x19, 0x40, 0x00}},       /* National TX      */
 537     {1, BROADCOM_T4, 1, {0x10, 0x02, 0x02}},       /* Broadcom T4      */
 538     {0, SEEQ_T4    , 1, {0x12, 0x10, 0x10}},       /* SEEQ T4          */
 539     {0, CYPRESS_T4 , 1, {0x05, 0x20, 0x20}},       /* Cypress T4       */
 540     {0, 0x7810     , 1, {0x14, 0x0800, 0x0800}}    /* Level One LTX970 */
 541 };
 542
 543 /*
 544 ** These GENERIC values assumes that the PHY devices follow 802.3u and
 545 ** allow parallel detection to set the link partner ability register.
 546 ** Detection of 100Base-TX [H/F Duplex] and 100Base-T4 is supported.
 547 */
 548 #define GENERIC_REG   0x05      /* Autoneg. Link Partner Advertisement Reg. */
 549 #define GENERIC_MASK  MII_ANLPA_100M /* All 100Mb/s Technologies            */
 550 #define GENERIC_VALUE MII_ANLPA_100M /* 100B-TX, 100B-TX FDX, 100B-T4       */
 551
 552 /*
 553 ** Define special SROM detection cases
 554 */
 555 static c_char enet_det[][ETH_ALEN] = {
 556     {0x00, 0x00, 0xc0, 0x00, 0x00, 0x00},
 557     {0x00, 0x00, 0xe8, 0x00, 0x00, 0x00}
 558 };
 559
 560 #define SMC    1
 561 #define ACCTON 2
 562
 563 /*
 564 ** SROM Repair definitions. If a broken SROM is detected a card may
 565 ** use this information to help figure out what to do. This is a
 566 ** "stab in the dark" and so far for SMC9332's only.
 567 */
 568 static c_char srom_repair_info[][100] = {
 569     {0x00,0x1e,0x00,0x00,0x00,0x08,             /* SMC9332 */
 570      0x1f,0x01,0x8f,0x01,0x00,0x01,0x00,0x02,
 571      0x01,0x00,0x00,0x78,0xe0,0x01,0x00,0x50,
 572      0x00,0x18,}
 573 };
 574
 575
 576 #ifdef DE4X5_DEBUG
 577 static int de4x5_debug = DE4X5_DEBUG;
 578 #else
 579 /*static int de4x5_debug = (DEBUG_MII | DEBUG_SROM | DEBUG_PCICFG | DEBUG_MEDIA | DEBUG_VERSION);*/
 580 static int de4x5_debug = (DEBUG_MEDIA | DEBUG_VERSION);
 581 #endif
 582
 583 /*
 584 ** Allow per adapter set up. For modules this is simply a command line
 585 ** parameter, e.g.:
 586 ** insmod de4x5 args='eth1:fdx autosense=BNC eth0:autosense=100Mb'.
 587 **
 588 ** For a compiled in driver, place e.g.
 589 **     #define DE4X5_PARM "eth0:fdx autosense=AUI eth2:autosense=TP"
 590 ** here
 591 */
 592 #ifdef DE4X5_PARM
 593 static char *args = DE4X5_PARM;
 594 #else
 595 static char *args;
 596 #endif
 597
 598 struct parameters {
 599     bool fdx;
 600     int autosense;
 601 };
 602
 603 #define DE4X5_AUTOSENSE_MS 250      /* msec autosense tick (DE500) */
 604
 605 #define DE4X5_NDA 0xffe0            /* No Device (I/O) Address */
 606
 607 /*
 608 ** Ethernet PROM defines
 609 */
 610 #define PROBE_LENGTH    32
 611 #define ETH_PROM_SIG    0xAA5500FFUL
 612
 613 /*
 614 ** Ethernet Info
 615 */
 616 #define PKT_BUF_SZ      1536            /* Buffer size for each Tx/Rx buffer */
 617 #define IEEE802_3_SZ    1518            /* Packet + CRC */
 618 #define MAX_PKT_SZ      1514            /* Maximum ethernet packet length */
 619 #define MAX_DAT_SZ      1500            /* Maximum ethernet data length */
 620 #define MIN_DAT_SZ      1               /* Minimum ethernet data length */
 621 #define PKT_HDR_LEN     14              /* Addresses and data length info */
 622 #define FAKE_FRAME_LEN  (MAX_PKT_SZ + 1)
 623 #define QUEUE_PKT_TIMEOUT (3*HZ)        /* 3 second timeout */
 624
 625
 626 /*
 627 ** EISA bus defines
 628 */
 629 #define DE4X5_EISA_IO_PORTS   0x0c00    /* I/O port base address, slot 0 */
 630 #define DE4X5_EISA_TOTAL_SIZE 0x100     /* I/O address extent */
 631
 632 #define EISA_ALLOWED_IRQ_LIST  {5, 9, 10, 11}
 633
 634 #define DE4X5_SIGNATURE {"DE425","DE434","DE435","DE450","DE500"}
 635 #define DE4X5_NAME_LENGTH 8
 636
 637 static c_char *de4x5_signatures[] = DE4X5_SIGNATURE;
 638
 639 /*
 640 ** Ethernet PROM defines for DC21040
 641 */
 642 #define PROBE_LENGTH    32
 643 #define ETH_PROM_SIG    0xAA5500FFUL
 644
 645 /*
 646 ** PCI Bus defines
 647 */
 648 #define PCI_MAX_BUS_NUM      8
 649 #define DE4X5_PCI_TOTAL_SIZE 0x80       /* I/O address extent */
 650 #define DE4X5_CLASS_CODE     0x00020000 /* Network controller, Ethernet */
 651
 652 /*
 653 ** Memory Alignment. Each descriptor is 4 longwords long. To force a
 654 ** particular alignment on the TX descriptor, adjust DESC_SKIP_LEN and
 655 ** DESC_ALIGN. ALIGN aligns the start address of the private memory area
 656 ** and hence the RX descriptor ring's first entry.
 657 */
 658 #define DE4X5_ALIGN4      ((u_long)4 - 1)     /* 1 longword align */
 659 #define DE4X5_ALIGN8      ((u_long)8 - 1)     /* 2 longword align */
 660 #define DE4X5_ALIGN16     ((u_long)16 - 1)    /* 4 longword align */
 661 #define DE4X5_ALIGN32     ((u_long)32 - 1)    /* 8 longword align */
 662 #define DE4X5_ALIGN64     ((u_long)64 - 1)    /* 16 longword align */
 663 #define DE4X5_ALIGN128    ((u_long)128 - 1)   /* 32 longword align */
 664
 665 #define DE4X5_ALIGN         DE4X5_ALIGN32           /* Keep the DC21040 happy... */
 666 #define DE4X5_CACHE_ALIGN   CAL_16LONG
 667 #define DESC_SKIP_LEN DSL_0             /* Must agree with DESC_ALIGN */
 668 /*#define DESC_ALIGN    u32 dummy[4];  / * Must agree with DESC_SKIP_LEN */
 669 #define DESC_ALIGN
 670
 671 #ifndef DEC_ONLY                        /* See README.de4x5 for using this */
 672 static int dec_only;
 673 #else
 674 static int dec_only = 1;
 675 #endif
 676
 677 /*
 678 ** DE4X5 IRQ ENABLE/DISABLE
 679 */
 680 #define ENABLE_IRQs { \
 681     imr |= lp->irq_en;\
 682     outl(imr, DE4X5_IMR);               /* Enable the IRQs */\
 683 }
 684
 685 #define DISABLE_IRQs {\
 686     imr = inl(DE4X5_IMR);\
 687     imr &= ~lp->irq_en;\
 688     outl(imr, DE4X5_IMR);               /* Disable the IRQs */\
 689 }
 690
 691 #define UNMASK_IRQs {\
 692     imr |= lp->irq_mask;\
 693     outl(imr, DE4X5_IMR);               /* Unmask the IRQs */\
 694 }
 695
 696 #define MASK_IRQs {\
 697     imr = inl(DE4X5_IMR);\
 698     imr &= ~lp->irq_mask;\
 699     outl(imr, DE4X5_IMR);               /* Mask the IRQs */\
 700 }
 701
 702 /*
 703 ** DE4X5 START/STOP
 704 */
 705 #define START_DE4X5 {\
 706     omr = inl(DE4X5_OMR);\
 707     omr |= OMR_ST | OMR_SR;\
 708     outl(omr, DE4X5_OMR);               /* Enable the TX and/or RX */\
 709 }
 710
 711 #define STOP_DE4X5 {\
 712     omr = inl(DE4X5_OMR);\
 713     omr &= ~(OMR_ST|OMR_SR);\
 714     outl(omr, DE4X5_OMR);               /* Disable the TX and/or RX */ \
 715 }
 716
 717 /*
 718 ** DE4X5 SIA RESET
 719 */
 720 #define RESET_SIA outl(0, DE4X5_SICR);  /* Reset SIA connectivity regs */
 721
 722 /*
 723 ** DE500 AUTOSENSE TIMER INTERVAL (MILLISECS)
 724 */
 725 #define DE4X5_AUTOSENSE_MS  250
 726
 727 /*
 728 ** SROM Structure
 729 */
 730 struct de4x5_srom {
 731     char sub_vendor_id[2];
 732     char sub_system_id[2];
 733     char reserved[12];
 734     char id_block_crc;
 735     char reserved2;
 736     char version;
 737     char num_controllers;
 738     char ieee_addr[6];
 739     char info[100];
 740     short chksum;
 741 };
 742 #define SUB_VENDOR_ID 0x500a
 743
 744 /*
 745 ** DE4X5 Descriptors. Make sure that all the RX buffers are contiguous
 746 ** and have sizes of both a power of 2 and a multiple of 4.
 747 ** A size of 256 bytes for each buffer could be chosen because over 90% of
 748 ** all packets in our network are <256 bytes long and 64 longword alignment
 749 ** is possible. 1536 showed better 'ttcp' performance. Take your pick. 32 TX
 750 ** descriptors are needed for machines with an ALPHA CPU.
 751 */
 752 #define NUM_RX_DESC 8                   /* Number of RX descriptors   */
 753 #define NUM_TX_DESC 32                  /* Number of TX descriptors   */
 754 #define RX_BUFF_SZ  1536                /* Power of 2 for kmalloc and */
 755                                         /* Multiple of 4 for DC21040  */
 756                                         /* Allows 512 byte alignment  */
 757 struct de4x5_desc {
 758     volatile __le32 status;
 759     __le32 des1;
 760     __le32 buf;
 761     __le32 next;
 762     DESC_ALIGN
 763 };
 764
 765 /*
 766 ** The DE4X5 private structure
 767 */
 768 #define DE4X5_PKT_STAT_SZ 16
 769 #define DE4X5_PKT_BIN_SZ  128            /* Should be >=100 unless you
 770                                             increase DE4X5_PKT_STAT_SZ */
 771
 772 struct pkt_stats {
 773         u_int bins[DE4X5_PKT_STAT_SZ];      /* Private stats counters       */
 774         u_int unicast;
 775         u_int multicast;
 776         u_int broadcast;
 777         u_int excessive_collisions;
 778         u_int tx_underruns;
 779         u_int excessive_underruns;
 780         u_int rx_runt_frames;
 781         u_int rx_collision;
 782         u_int rx_dribble;
 783         u_int rx_overflow;
 784 };
 785
 786 struct de4x5_private {
 787     char adapter_name[80];                  /* Adapter name                 */
 788     u_long interrupt;                       /* Aligned ISR flag             */
 789     struct de4x5_desc *rx_ring;             /* RX descriptor ring           */
 790     struct de4x5_desc *tx_ring;             /* TX descriptor ring           */
 791     struct sk_buff *tx_skb[NUM_TX_DESC];    /* TX skb for freeing when sent */
 792     struct sk_buff *rx_skb[NUM_RX_DESC];    /* RX skb's                     */
 793     int rx_new, rx_old;                     /* RX descriptor ring pointers  */
 794     int tx_new, tx_old;                     /* TX descriptor ring pointers  */
 795     char setup_frame[SETUP_FRAME_LEN];      /* Holds MCA and PA info.       */
 796     char frame[64];                         /* Min sized packet for loopback*/
 797     spinlock_t lock;                        /* Adapter specific spinlock    */
 798     struct net_device_stats stats;          /* Public stats                 */
 799     struct pkt_stats pktStats;              /* Private stats counters       */
 800     char rxRingSize;
 801     char txRingSize;
 802     int  bus;                               /* EISA or PCI                  */
 803     int  bus_num;                           /* PCI Bus number               */
 804     int  device;                            /* Device number on PCI bus     */
 805     int  state;                             /* Adapter OPENED or CLOSED     */
 806     int  chipset;                           /* DC21040, DC21041 or DC21140  */
 807     s32  irq_mask;                          /* Interrupt Mask (Enable) bits */
 808     s32  irq_en;                            /* Summary interrupt bits       */
 809     int  media;                             /* Media (eg TP), mode (eg 100B)*/
 810     int  c_media;                           /* Remember the last media conn */
 811     bool fdx;                               /* media full duplex flag       */
 812     int  linkOK;                            /* Link is OK                   */
 813     int  autosense;                         /* Allow/disallow autosensing   */
 814     bool tx_enable;                         /* Enable descriptor polling    */
 815     int  setup_f;                           /* Setup frame filtering type   */
 816     int  local_state;                       /* State within a 'media' state */
 817     struct mii_phy phy[DE4X5_MAX_PHY];      /* List of attached PHY devices */
 818     struct sia_phy sia;                     /* SIA PHY Information          */
 819     int  active;                            /* Index to active PHY device   */
 820     int  mii_cnt;                           /* Number of attached PHY's     */
 821     int  timeout;                           /* Scheduling counter           */
 822     struct timer_list timer;                /* Timer info for kernel        */
 823     int tmp;                                /* Temporary global per card    */
 824     struct {
 825         u_long lock;                        /* Lock the cache accesses      */
 826         s32 csr0;                           /* Saved Bus Mode Register      */
 827         s32 csr6;                           /* Saved Operating Mode Reg.    */
 828         s32 csr7;                           /* Saved IRQ Mask Register      */
 829         s32 gep;                            /* Saved General Purpose Reg.   */
 830         s32 gepc;                           /* Control info for GEP         */
 831         s32 csr13;                          /* Saved SIA Connectivity Reg.  */
 832         s32 csr14;                          /* Saved SIA TX/RX Register     */
 833         s32 csr15;                          /* Saved SIA General Register   */
 834         int save_cnt;                       /* Flag if state already saved  */
 835         struct sk_buff *skb;                /* Save the (re-ordered) skb's  */
 836     } cache;
 837     struct de4x5_srom srom;                 /* A copy of the SROM           */
 838     int cfrv;                               /* Card CFRV copy */
 839     int rx_ovf;                             /* Check for 'RX overflow' tag  */
 840     bool useSROM;                           /* For non-DEC card use SROM    */
 841     bool useMII;                            /* Infoblock using the MII      */
 842     int asBitValid;                         /* Autosense bits in GEP?       */
 843     int asPolarity;                         /* 0 => asserted high           */
 844     int asBit;                              /* Autosense bit number in GEP  */
 845     int defMedium;                          /* SROM default medium          */
 846     int tcount;                             /* Last infoblock number        */
 847     int infoblock_init;                     /* Initialised this infoblock?  */
 848     int infoleaf_offset;                    /* SROM infoleaf for controller */
 849     s32 infoblock_csr6;                     /* csr6 value in SROM infoblock */
 850     int infoblock_media;                    /* infoblock media              */
 851     int (*infoleaf_fn)(struct net_device *);    /* Pointer to infoleaf function */
 852     u_char *rst;                            /* Pointer to Type 5 reset info */
 853     u_char  ibn;                            /* Infoblock number             */
 854     struct parameters params;               /* Command line/ #defined params */
 855     struct device *gendev;                  /* Generic device */
 856     dma_addr_t dma_rings;                   /* DMA handle for rings         */
 857     int dma_size;                           /* Size of the DMA area         */
 858     char *rx_bufs;                          /* rx bufs on alpha, sparc, ... */
 859 };
 860
 861 /*
 862 ** To get around certain poxy cards that don't provide an SROM
 863 ** for the second and more DECchip, I have to key off the first
 864 ** chip's address. I'll assume there's not a bad SROM iff:
 865 **
 866 **      o the chipset is the same
 867 **      o the bus number is the same and > 0
 868 **      o the sum of all the returned hw address bytes is 0 or 0x5fa
 869 **
 870 ** Also have to save the irq for those cards whose hardware designers
 871 ** can't follow the PCI to PCI Bridge Architecture spec.
 872 */
 873 static struct {
 874     int chipset;
 875     int bus;
 876     int irq;
 877     u_char addr[ETH_ALEN];
 878 } last = {0,};
 879
 880 /*
 881 ** The transmit ring full condition is described by the tx_old and tx_new
 882 ** pointers by:
 883 **    tx_old            = tx_new    Empty ring
 884 **    tx_old            = tx_new+1  Full ring
 885 **    tx_old+txRingSize = tx_new+1  Full ring  (wrapped condition)
 886 */
 887 #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
 888                         lp->tx_old+lp->txRingSize-lp->tx_new-1:\
 889                         lp->tx_old               -lp->tx_new-1)
 890
 891 #define TX_PKT_PENDING (lp->tx_old != lp->tx_new)
 892
 893 /*
 894 ** Public Functions
 895 */
 896 static int     de4x5_open(struct net_device *dev);
 897 static int     de4x5_queue_pkt(struct sk_buff *skb, struct net_device *dev);
 898 static irqreturn_t de4x5_interrupt(int irq, void *dev_id);
 899 static int     de4x5_close(struct net_device *dev);
 900 static struct  net_device_stats *de4x5_get_stats(struct net_device *dev);
 901 static void    de4x5_local_stats(struct net_device *dev, char *buf, int pkt_len);
 902 static void    set_multicast_list(struct net_device *dev);
 903 static int     de4x5_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 904
 905 /*
 906 ** Private functions
 907 */
 908 static int     de4x5_hw_init(struct net_device *dev, u_long iobase, struct device *gendev);
 909 static int     de4x5_init(struct net_device *dev);
 910 static int     de4x5_sw_reset(struct net_device *dev);
 911 static int     de4x5_rx(struct net_device *dev);
 912 static int     de4x5_tx(struct net_device *dev);
 913 static void    de4x5_ast(struct net_device *dev);
 914 static int     de4x5_txur(struct net_device *dev);
 915 static int     de4x5_rx_ovfc(struct net_device *dev);
 916
 917 static int     autoconf_media(struct net_device *dev);
 918 static void    create_packet(struct net_device *dev, char *frame, int len);
 919 static void    load_packet(struct net_device *dev, char *buf, u32 flags, struct sk_buff *skb);
 920 static int     dc21040_autoconf(struct net_device *dev);
 921 static int     dc21041_autoconf(struct net_device *dev);
 922 static int     dc21140m_autoconf(struct net_device *dev);
 923 static int     dc2114x_autoconf(struct net_device *dev);
 924 static int     srom_autoconf(struct net_device *dev);
 925 static int     de4x5_suspect_state(struct net_device *dev, int timeout, int prev_state, int (*fn)(struct net_device *, int), int (*asfn)(struct net_device *));
 926 static int     dc21040_state(struct net_device *dev, int csr13, int csr14, int csr15, int timeout, int next_state, int suspect_state, int (*fn)(struct net_device *, int));
 927 static int     test_media(struct net_device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec);
 928 static int     test_for_100Mb(struct net_device *dev, int msec);
 929 static int     wait_for_link(struct net_device *dev);
 930 static int     test_mii_reg(struct net_device *dev, int reg, int mask, bool pol, long msec);
 931 static int     is_spd_100(struct net_device *dev);
 932 static int     is_100_up(struct net_device *dev);
 933 static int     is_10_up(struct net_device *dev);
 934 static int     is_anc_capable(struct net_device *dev);
 935 static int     ping_media(struct net_device *dev, int msec);
 936 static struct sk_buff *de4x5_alloc_rx_buff(struct net_device *dev, int index, int len);
 937 static void    de4x5_free_rx_buffs(struct net_device *dev);
 938 static void    de4x5_free_tx_buffs(struct net_device *dev);
 939 static void    de4x5_save_skbs(struct net_device *dev);
 940 static void    de4x5_rst_desc_ring(struct net_device *dev);
 941 static void    de4x5_cache_state(struct net_device *dev, int flag);
 942 static void    de4x5_put_cache(struct net_device *dev, struct sk_buff *skb);
 943 static void    de4x5_putb_cache(struct net_device *dev, struct sk_buff *skb);
 944 static struct  sk_buff *de4x5_get_cache(struct net_device *dev);
 945 static void    de4x5_setup_intr(struct net_device *dev);
 946 static void    de4x5_init_connection(struct net_device *dev);
 947 static int     de4x5_reset_phy(struct net_device *dev);
 948 static void    reset_init_sia(struct net_device *dev, s32 sicr, s32 strr, s32 sigr);
 949 static int     test_ans(struct net_device *dev, s32 irqs, s32 irq_mask, s32 msec);
 950 static int     test_tp(struct net_device *dev, s32 msec);
 951 static int     EISA_signature(char *name, struct device *device);
 952 static int     PCI_signature(char *name, struct de4x5_private *lp);
 953 static void    DevicePresent(struct net_device *dev, u_long iobase);
 954 static void    enet_addr_rst(u_long aprom_addr);
 955 static int     de4x5_bad_srom(struct de4x5_private *lp);
 956 static short   srom_rd(u_long address, u_char offset);
 957 static void    srom_latch(u_int command, u_long address);
 958 static void    srom_command(u_int command, u_long address);
 959 static void    srom_address(u_int command, u_long address, u_char offset);
 960 static short   srom_data(u_int command, u_long address);
 961 /*static void    srom_busy(u_int command, u_long address);*/
 962 static void    sendto_srom(u_int command, u_long addr);
 963 static int     getfrom_srom(u_long addr);
 964 static int     srom_map_media(struct net_device *dev);
 965 static int     srom_infoleaf_info(struct net_device *dev);
 966 static void    srom_init(struct net_device *dev);
 967 static void    srom_exec(struct net_device *dev, u_char *p);
 968 static int     mii_rd(u_char phyreg, u_char phyaddr, u_long ioaddr);
 969 static void    mii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr);
 970 static int     mii_rdata(u_long ioaddr);
 971 static void    mii_wdata(int data, int len, u_long ioaddr);
 972 static void    mii_ta(u_long rw, u_long ioaddr);
 973 static int     mii_swap(int data, int len);
 974 static void    mii_address(u_char addr, u_long ioaddr);
 975 static void    sendto_mii(u32 command, int data, u_long ioaddr);
 976 static int     getfrom_mii(u32 command, u_long ioaddr);
 977 static int     mii_get_oui(u_char phyaddr, u_long ioaddr);
 978 static int     mii_get_phy(struct net_device *dev);
 979 static void    SetMulticastFilter(struct net_device *dev);
 980 static int     get_hw_addr(struct net_device *dev);
 981 static void    srom_repair(struct net_device *dev, int card);
 982 static int     test_bad_enet(struct net_device *dev, int status);
 983 static int     an_exception(struct de4x5_private *lp);
 984 static char    *build_setup_frame(struct net_device *dev, int mode);
 985 static void    disable_ast(struct net_device *dev);
 986 static long    de4x5_switch_mac_port(struct net_device *dev);
 987 static int     gep_rd(struct net_device *dev);
 988 static void    gep_wr(s32 data, struct net_device *dev);
 989 static void    yawn(struct net_device *dev, int state);
 990 static void    de4x5_parse_params(struct net_device *dev);
 991 static void    de4x5_dbg_open(struct net_device *dev);
 992 static void    de4x5_dbg_mii(struct net_device *dev, int k);
 993 static void    de4x5_dbg_media(struct net_device *dev);
 994 static void    de4x5_dbg_srom(struct de4x5_srom *p);
 995 static void    de4x5_dbg_rx(struct sk_buff *skb, int len);
 996 static int     de4x5_strncmp(char *a, char *b, int n);
 997 static int     dc21041_infoleaf(struct net_device *dev);
 998 static int     dc21140_infoleaf(struct net_device *dev);
 999 static int     dc21142_infoleaf(struct net_device *dev);
1000 static int     dc21143_infoleaf(struct net_device *dev);
1001 static int     type0_infoblock(struct net_device *dev, u_char count, u_char *p);
1002 static int     type1_infoblock(struct net_device *dev, u_char count, u_char *p);
1003 static int     type2_infoblock(struct net_device *dev, u_char count, u_char *p);
1004 static int     type3_infoblock(struct net_device *dev, u_char count, u_char *p);
1005 static int     type4_infoblock(struct net_device *dev, u_char count, u_char *p);
1006 static int     type5_infoblock(struct net_device *dev, u_char count, u_char *p);
1007 static int     compact_infoblock(struct net_device *dev, u_char count, u_char *p);
1008
1009 /*
1010 ** Note now that module autoprobing is allowed under EISA and PCI. The
1011 ** IRQ lines will not be auto-detected; instead I'll rely on the BIOSes
1012 ** to "do the right thing".
1013 */
1014
1015 static int io=0x0;/* EDIT THIS LINE FOR YOUR CONFIGURATION IF NEEDED        */
1016
1017 module_param(io, int, 0);
1018 module_param(de4x5_debug, int, 0);
1019 module_param(dec_only, int, 0);
1020 module_param(args, charp, 0);
1021
1022 MODULE_PARM_DESC(io, "de4x5 I/O base address");
1023 MODULE_PARM_DESC(de4x5_debug, "de4x5 debug mask");
1024 MODULE_PARM_DESC(dec_only, "de4x5 probe only for Digital boards (0-1)");
1025 MODULE_PARM_DESC(args, "de4x5 full duplex and media type settings; see de4x5.c for details");
1026 MODULE_LICENSE("GPL");
1027
1028 /*
1029 ** List the SROM infoleaf functions and chipsets
1030 */
1031 struct InfoLeaf {
1032     int chipset;
1033     int (*fn)(struct net_device *);
1034 };
1035 static struct InfoLeaf infoleaf_array[] = {
1036     {DC21041, dc21041_infoleaf},
1037     {DC21140, dc21140_infoleaf},
1038     {DC21142, dc21142_infoleaf},
1039     {DC21143, dc21143_infoleaf}
1040 };
1041 #define INFOLEAF_SIZE ARRAY_SIZE(infoleaf_array)
1042
1043 /*
1044 ** List the SROM info block functions
1045 */
1046 static int (*dc_infoblock[])(struct net_device *dev, u_char, u_char *) = {
1047     type0_infoblock,
1048     type1_infoblock,
1049     type2_infoblock,
1050     type3_infoblock,
1051     type4_infoblock,
1052     type5_infoblock,
1053     compact_infoblock
1054 };
1055
1056 #define COMPACT (ARRAY_SIZE(dc_infoblock) - 1)
1057
1058 /*
1059 ** Miscellaneous defines...
1060 */
1061 #define RESET_DE4X5 {\
1062     int i;\
1063     i=inl(DE4X5_BMR);\
1064     mdelay(1);\
1065     outl(i | BMR_SWR, DE4X5_BMR);\
1066     mdelay(1);\
1067     outl(i, DE4X5_BMR);\
1068     mdelay(1);\
1069     for (i=0;i<5;i++) {inl(DE4X5_BMR); mdelay(1);}\
1070     mdelay(1);\
1071 }
1072
1073 #define PHY_HARD_RESET {\
1074     outl(GEP_HRST, DE4X5_GEP);           /* Hard RESET the PHY dev. */\
1075     mdelay(1);                           /* Assert for 1ms */\
1076     outl(0x00, DE4X5_GEP);\
1077     mdelay(2);                           /* Wait for 2ms */\
1078 }
1079
1080
1081 static int __devinit
1082 de4x5_hw_init(struct net_device *dev, u_long iobase, struct device *gendev)
1083 {
1084     char name[DE4X5_NAME_LENGTH + 1];
1085     struct de4x5_private *lp = netdev_priv(dev);
1086     struct pci_dev *pdev = NULL;
1087     int i, status=0;
1088     DECLARE_MAC_BUF(mac);
1089
1090     gendev->driver_data = dev;
1091
1092     /* Ensure we're not sleeping */
1093     if (lp->bus == EISA) {
1094         outb(WAKEUP, PCI_CFPM);
1095     } else {
1096         pdev = to_pci_dev (gendev);
1097         pci_write_config_byte(pdev, PCI_CFDA_PSM, WAKEUP);
1098     }
1099     mdelay(10);
1100
1101     RESET_DE4X5;
1102
1103     if ((inl(DE4X5_STS) & (STS_TS | STS_RS)) != 0) {
1104         return -ENXIO;                       /* Hardware could not reset */
1105     }
1106
1107     /*
1108     ** Now find out what kind of DC21040/DC21041/DC21140 board we have.
1109     */
1110     lp->useSROM = false;
1111     if (lp->bus == PCI) {
1112         PCI_signature(name, lp);
1113     } else {
1114         EISA_signature(name, gendev);
1115     }
1116
1117     if (*name == '\0') {                     /* Not found a board signature */
1118         return -ENXIO;
1119     }
1120
1121     dev->base_addr = iobase;
1122     printk ("%s: %s at 0x%04lx", gendev->bus_id, name, iobase);
1123
1124     status = get_hw_addr(dev);
1125     printk(", h/w address %s\n", print_mac(mac, dev->dev_addr));
1126
1127     if (status != 0) {
1128         printk("      which has an Ethernet PROM CRC error.\n");
1129         return -ENXIO;
1130     } else {
1131         lp->cache.gepc = GEP_INIT;
1132         lp->asBit = GEP_SLNK;
1133         lp->asPolarity = GEP_SLNK;
1134         lp->asBitValid = ~0;
1135         lp->timeout = -1;
1136         lp->gendev = gendev;
1137         spin_lock_init(&lp->lock);
1138         init_timer(&lp->timer);
1139         lp->timer.function = (void (*)(unsigned long))de4x5_ast;
1140         lp->timer.data = (unsigned long)dev;
1141         de4x5_parse_params(dev);
1142
1143         /*
1144         ** Choose correct autosensing in case someone messed up
1145         */
1146         lp->autosense = lp->params.autosense;
1147         if (lp->chipset != DC21140) {
1148             if ((lp->chipset==DC21040) && (lp->params.autosense&TP_NW)) {
1149                 lp->params.autosense = TP;
1150             }
1151             if ((lp->chipset==DC21041) && (lp->params.autosense&BNC_AUI)) {
1152                 lp->params.autosense = BNC;
1153             }
1154         }
1155         lp->fdx = lp->params.fdx;
1156         sprintf(lp->adapter_name,"%s (%s)", name, gendev->bus_id);
1157
1158         lp->dma_size = (NUM_RX_DESC + NUM_TX_DESC) * sizeof(struct de4x5_desc);
1159 #if defined(__alpha__) || defined(__powerpc__) || defined(CONFIG_SPARC) || defined(DE4X5_DO_MEMCPY)
1160         lp->dma_size += RX_BUFF_SZ * NUM_RX_DESC + DE4X5_ALIGN;
1161 #endif
1162         lp->rx_ring = dma_alloc_coherent(gendev, lp->dma_size,
1163                                          &lp->dma_rings, GFP_ATOMIC);
1164         if (lp->rx_ring == NULL) {
1165             return -ENOMEM;
1166         }
1167
1168         lp->tx_ring = lp->rx_ring + NUM_RX_DESC;
1169
1170         /*
1171         ** Set up the RX descriptor ring (Intels)
1172         ** Allocate contiguous receive buffers, long word aligned (Alphas)
1173         */
1174 #if !defined(__alpha__) && !defined(__powerpc__) && !defined(CONFIG_SPARC) && !defined(DE4X5_DO_MEMCPY)
1175         for (i=0; i<NUM_RX_DESC; i++) {
1176             lp->rx_ring[i].status = 0;
1177             lp->rx_ring[i].des1 = cpu_to_le32(RX_BUFF_SZ);
1178             lp->rx_ring[i].buf = 0;
1179             lp->rx_ring[i].next = 0;
1180             lp->rx_skb[i] = (struct sk_buff *) 1;     /* Dummy entry */
1181         }
1182
1183 #else
1184         {
1185                 dma_addr_t dma_rx_bufs;
1186
1187                 dma_rx_bufs = lp->dma_rings + (NUM_RX_DESC + NUM_TX_DESC)
1188                         * sizeof(struct de4x5_desc);
1189                 dma_rx_bufs = (dma_rx_bufs + DE4X5_ALIGN) & ~DE4X5_ALIGN;
1190                 lp->rx_bufs = (char *)(((long)(lp->rx_ring + NUM_RX_DESC
1191                         + NUM_TX_DESC) + DE4X5_ALIGN) & ~DE4X5_ALIGN);
1192                 for (i=0; i<NUM_RX_DESC; i++) {
1193                         lp->rx_ring[i].status = 0;
1194                         lp->rx_ring[i].des1 = cpu_to_le32(RX_BUFF_SZ);
1195                         lp->rx_ring[i].buf =
1196                                 cpu_to_le32(dma_rx_bufs+i*RX_BUFF_SZ);
1197                         lp->rx_ring[i].next = 0;
1198                         lp->rx_skb[i] = (struct sk_buff *) 1; /* Dummy entry */
1199                 }
1200
1201         }
1202 #endif
1203
1204         barrier();
1205
1206         lp->rxRingSize = NUM_RX_DESC;
1207         lp->txRingSize = NUM_TX_DESC;
1208
1209         /* Write the end of list marker to the descriptor lists */
1210         lp->rx_ring[lp->rxRingSize - 1].des1 |= cpu_to_le32(RD_RER);
1211         lp->tx_ring[lp->txRingSize - 1].des1 |= cpu_to_le32(TD_TER);
1212
1213         /* Tell the adapter where the TX/RX rings are located. */
1214         outl(lp->dma_rings, DE4X5_RRBA);
1215         outl(lp->dma_rings + NUM_RX_DESC * sizeof(struct de4x5_desc),
1216              DE4X5_TRBA);
1217
1218         /* Initialise the IRQ mask and Enable/Disable */
1219         lp->irq_mask = IMR_RIM | IMR_TIM | IMR_TUM | IMR_UNM;
1220         lp->irq_en   = IMR_NIM | IMR_AIM;
1221
1222         /* Create a loopback packet frame for later media probing */
1223         create_packet(dev, lp->frame, sizeof(lp->frame));
1224
1225         /* Check if the RX overflow bug needs testing for */
1226         i = lp->cfrv & 0x000000fe;
1227         if ((lp->chipset == DC21140) && (i == 0x20)) {
1228             lp->rx_ovf = 1;
1229         }
1230
1231         /* Initialise the SROM pointers if possible */
1232         if (lp->useSROM) {
1233             lp->state = INITIALISED;
1234             if (srom_infoleaf_info(dev)) {
1235                 dma_free_coherent (gendev, lp->dma_size,
1236                                lp->rx_ring, lp->dma_rings);
1237                 return -ENXIO;
1238             }
1239             srom_init(dev);
1240         }
1241
1242         lp->state = CLOSED;
1243
1244         /*
1245         ** Check for an MII interface
1246         */
1247         if ((lp->chipset != DC21040) && (lp->chipset != DC21041)) {
1248             mii_get_phy(dev);
1249         }
1250
1251         printk("      and requires IRQ%d (provided by %s).\n", dev->irq,
1252                ((lp->bus == PCI) ? "PCI BIOS" : "EISA CNFG"));
1253     }
1254
1255     if (de4x5_debug & DEBUG_VERSION) {
1256         printk(version);
1257     }
1258
1259     /* The DE4X5-specific entries in the device structure. */
1260     SET_NETDEV_DEV(dev, gendev);
1261     dev->open = &de4x5_open;
1262     dev->hard_start_xmit = &de4x5_queue_pkt;
1263     dev->stop = &de4x5_close;
1264     dev->get_stats = &de4x5_get_stats;
1265     dev->set_multicast_list = &set_multicast_list;
1266     dev->do_ioctl = &de4x5_ioctl;
1267
1268     dev->mem_start = 0;
1269
1270     /* Fill in the generic fields of the device structure. */
1271     if ((status = register_netdev (dev))) {
1272             dma_free_coherent (gendev, lp->dma_size,
1273                                lp->rx_ring, lp->dma_rings);
1274             return status;
1275     }
1276
1277     /* Let the adapter sleep to save power */
1278     yawn(dev, SLEEP);
1279
1280     return status;
1281 }
1282
1283
1284 static int
1285 de4x5_open(struct net_device *dev)
1286 {
1287     struct de4x5_private *lp = netdev_priv(dev);
1288     u_long iobase = dev->base_addr;
1289     int i, status = 0;
1290     s32 omr;
1291
1292     /* Allocate the RX buffers */
1293     for (i=0; i<lp->rxRingSize; i++) {
1294         if (de4x5_alloc_rx_buff(dev, i, 0) == NULL) {
1295             de4x5_free_rx_buffs(dev);
1296             return -EAGAIN;
1297         }
1298     }
1299
1300     /*
1301     ** Wake up the adapter
1302     */
1303     yawn(dev, WAKEUP);
1304
1305     /*
1306     ** Re-initialize the DE4X5...
1307     */
1308     status = de4x5_init(dev);
1309     spin_lock_init(&lp->lock);
1310     lp->state = OPEN;
1311     de4x5_dbg_open(dev);
1312
1313     if (request_irq(dev->irq, de4x5_interrupt, IRQF_SHARED,
1314                                                      lp->adapter_name, dev)) {
1315         printk("de4x5_open(): Requested IRQ%d is busy - attemping FAST/SHARE...", dev->irq);
1316         if (request_irq(dev->irq, de4x5_interrupt, IRQF_DISABLED | IRQF_SHARED,
1317                                                      lp->adapter_name, dev)) {
1318             printk("\n              Cannot get IRQ- reconfigure your hardware.\n");
1319             disable_ast(dev);
1320             de4x5_free_rx_buffs(dev);
1321             de4x5_free_tx_buffs(dev);
1322             yawn(dev, SLEEP);
1323             lp->state = CLOSED;
1324             return -EAGAIN;
1325         } else {
1326             printk("\n              Succeeded, but you should reconfigure your hardware to avoid this.\n");
1327             printk("WARNING: there may be IRQ related problems in heavily loaded systems.\n");
1328         }
1329     }
1330
1331     lp->interrupt = UNMASK_INTERRUPTS;
1332     dev->trans_start = jiffies;
1333
1334     START_DE4X5;
1335
1336     de4x5_setup_intr(dev);
1337
1338     if (de4x5_debug & DEBUG_OPEN) {
1339         printk("\tsts:  0x%08x\n", inl(DE4X5_STS));
1340         printk("\tbmr:  0x%08x\n", inl(DE4X5_BMR));
1341         printk("\timr:  0x%08x\n", inl(DE4X5_IMR));
1342         printk("\tomr:  0x%08x\n", inl(DE4X5_OMR));
1343         printk("\tsisr: 0x%08x\n", inl(DE4X5_SISR));
1344         printk("\tsicr: 0x%08x\n", inl(DE4X5_SICR));
1345         printk("\tstrr: 0x%08x\n", inl(DE4X5_STRR));
1346         printk("\tsigr: 0x%08x\n", inl(DE4X5_SIGR));
1347     }
1348
1349     return status;
1350 }
1351
1352 /*
1353 ** Initialize the DE4X5 operating conditions. NB: a chip problem with the
1354 ** DC21140 requires using perfect filtering mode for that chip. Since I can't
1355 ** see why I'd want > 14 multicast addresses, I have changed all chips to use
1356 ** the perfect filtering mode. Keep the DMA burst length at 8: there seems
1357 ** to be data corruption problems if it is larger (UDP errors seen from a
1358 ** ttcp source).
1359 */
1360 static int
1361 de4x5_init(struct net_device *dev)
1362 {
1363     /* Lock out other processes whilst setting up the hardware */
1364     netif_stop_queue(dev);
1365
1366     de4x5_sw_reset(dev);
1367
1368     /* Autoconfigure the connected port */
1369     autoconf_media(dev);
1370
1371     return 0;
1372 }
1373
1374 static int
1375 de4x5_sw_reset(struct net_device *dev)
1376 {
1377     struct de4x5_private *lp = netdev_priv(dev);
1378     u_long iobase = dev->base_addr;
1379     int i, j, status = 0;
1380     s32 bmr, omr;
1381
1382     /* Select the MII or SRL port now and RESET the MAC */
1383     if (!lp->useSROM) {
1384         if (lp->phy[lp->active].id != 0) {
1385             lp->infoblock_csr6 = OMR_SDP | OMR_PS | OMR_HBD;
1386         } else {
1387             lp->infoblock_csr6 = OMR_SDP | OMR_TTM;
1388         }
1389         de4x5_switch_mac_port(dev);
1390     }
1391
1392     /*
1393     ** Set the programmable burst length to 8 longwords for all the DC21140
1394     ** Fasternet chips and 4 longwords for all others: DMA errors result
1395     ** without these values. Cache align 16 long.
1396     */
1397     bmr = (lp->chipset==DC21140 ? PBL_8 : PBL_4) | DESC_SKIP_LEN | DE4X5_CACHE_ALIGN;
1398     bmr |= ((lp->chipset & ~0x00ff)==DC2114x ? BMR_RML : 0);
1399     outl(bmr, DE4X5_BMR);
1400
1401     omr = inl(DE4X5_OMR) & ~OMR_PR;             /* Turn off promiscuous mode */
1402     if (lp->chipset == DC21140) {
1403         omr |= (OMR_SDP | OMR_SB);
1404     }
1405     lp->setup_f = PERFECT;
1406     outl(lp->dma_rings, DE4X5_RRBA);
1407     outl(lp->dma_rings + NUM_RX_DESC * sizeof(struct de4x5_desc),
1408          DE4X5_TRBA);
1409
1410     lp->rx_new = lp->rx_old = 0;
1411     lp->tx_new = lp->tx_old = 0;
1412
1413     for (i = 0; i < lp->rxRingSize; i++) {
1414         lp->rx_ring[i].status = cpu_to_le32(R_OWN);
1415     }
1416
1417     for (i = 0; i < lp->txRingSize; i++) {
1418         lp->tx_ring[i].status = cpu_to_le32(0);
1419     }
1420
1421     barrier();
1422
1423     /* Build the setup frame depending on filtering mode */
1424     SetMulticastFilter(dev);
1425
1426     load_packet(dev, lp->setup_frame, PERFECT_F|TD_SET|SETUP_FRAME_LEN, (struct sk_buff *)1);
1427     outl(omr|OMR_ST, DE4X5_OMR);
1428
1429     /* Poll for setup frame completion (adapter interrupts are disabled now) */
1430
1431     for (j=0, i=0;(i<500) && (j==0);i++) {       /* Upto 500ms delay */
1432         mdelay(1);
1433         if ((s32)le32_to_cpu(lp->tx_ring[lp->tx_new].status) >= 0) j=1;
1434     }
1435     outl(omr, DE4X5_OMR);                        /* Stop everything! */
1436
1437     if (j == 0) {
1438         printk("%s: Setup frame timed out, status %08x\n", dev->name,
1439                inl(DE4X5_STS));
1440         status = -EIO;
1441     }
1442
1443     lp->tx_new = (++lp->tx_new) % lp->txRingSize;
1444     lp->tx_old = lp->tx_new;
1445
1446     return status;
1447 }
1448
1449 /*
1450 ** Writes a socket buffer address to the next available transmit descriptor.
1451 */
1452 static int
1453 de4x5_queue_pkt(struct sk_buff *skb, struct net_device *dev)
1454 {
1455     struct de4x5_private *lp = netdev_priv(dev);
1456     u_long iobase = dev->base_addr;
1457     int status = 0;
1458     u_long flags = 0;
1459
1460     netif_stop_queue(dev);
1461     if (!lp->tx_enable) {                   /* Cannot send for now */
1462         return -1;
1463     }
1464
1465     /*
1466     ** Clean out the TX ring asynchronously to interrupts - sometimes the
1467     ** interrupts are lost by delayed descriptor status updates relative to
1468     ** the irq assertion, especially with a busy PCI bus.
1469     */
1470     spin_lock_irqsave(&lp->lock, flags);
1471     de4x5_tx(dev);
1472     spin_unlock_irqrestore(&lp->lock, flags);
1473
1474     /* Test if cache is already locked - requeue skb if so */
1475     if (test_and_set_bit(0, (void *)&lp->cache.lock) && !lp->interrupt)
1476         return -1;
1477
1478     /* Transmit descriptor ring full or stale skb */
1479     if (netif_queue_stopped(dev) || (u_long) lp->tx_skb[lp->tx_new] > 1) {
1480         if (lp->interrupt) {
1481             de4x5_putb_cache(dev, skb);          /* Requeue the buffer */
1482         } else {
1483             de4x5_put_cache(dev, skb);
1484         }
1485         if (de4x5_debug & DEBUG_TX) {
1486             printk("%s: transmit busy, lost media or stale skb found:\n  STS:%08x\n  tbusy:%d\n  IMR:%08x\n  OMR:%08x\n Stale skb: %s\n",dev->name, inl(DE4X5_STS), netif_queue_stopped(dev), inl(DE4X5_IMR), inl(DE4X5_OMR), ((u_long) lp->tx_skb[lp->tx_new] > 1) ? "YES" : "NO");
1487         }
1488     } else if (skb->len > 0) {
1489         /* If we already have stuff queued locally, use that first */
1490         if (lp->cache.skb && !lp->interrupt) {
1491             de4x5_put_cache(dev, skb);
1492             skb = de4x5_get_cache(dev);
1493         }
1494
1495         while (skb && !netif_queue_stopped(dev) &&
1496                (u_long) lp->tx_skb[lp->tx_new] <= 1) {
1497             spin_lock_irqsave(&lp->lock, flags);
1498             netif_stop_queue(dev);
1499             load_packet(dev, skb->data, TD_IC | TD_LS | TD_FS | skb->len, skb);
1500             lp->stats.tx_bytes += skb->len;
1501             outl(POLL_DEMAND, DE4X5_TPD);/* Start the TX */
1502
1503             lp->tx_new = (++lp->tx_new) % lp->txRingSize;
1504             dev->trans_start = jiffies;
1505
1506             if (TX_BUFFS_AVAIL) {
1507                 netif_start_queue(dev);         /* Another pkt may be queued */
1508             }
1509             skb = de4x5_get_cache(dev);
1510             spin_unlock_irqrestore(&lp->lock, flags);
1511         }
1512         if (skb) de4x5_putb_cache(dev, skb);
1513     }
1514
1515     lp->cache.lock = 0;
1516
1517     return status;
1518 }
1519
1520 /*
1521 ** The DE4X5 interrupt handler.
1522 **
1523 ** I/O Read/Writes through intermediate PCI bridges are never 'posted',
1524 ** so that the asserted interrupt always has some real data to work with -
1525 ** if these I/O accesses are ever changed to memory accesses, ensure the
1526 ** STS write is read immediately to complete the transaction if the adapter
1527 ** is not on bus 0. Lost interrupts can still occur when the PCI bus load
1528 ** is high and descriptor status bits cannot be set before the associated
1529 ** interrupt is asserted and this routine entered.
1530 */
1531 static irqreturn_t
1532 de4x5_interrupt(int irq, void *dev_id)
1533 {
1534     struct net_device *dev = dev_id;
1535     struct de4x5_private *lp;
1536     s32 imr, omr, sts, limit;
1537     u_long iobase;
1538     unsigned int handled = 0;
1539
1540     lp = netdev_priv(dev);
1541     spin_lock(&lp->lock);
1542     iobase = dev->base_addr;
1543
1544     DISABLE_IRQs;                        /* Ensure non re-entrancy */
1545
1546     if (test_and_set_bit(MASK_INTERRUPTS, (void*) &lp->interrupt))
1547         printk("%s: Re-entering the interrupt handler.\n", dev->name);
1548
1549     synchronize_irq(dev->irq);
1550
1551     for (limit=0; limit<8; limit++) {
1552         sts = inl(DE4X5_STS);            /* Read IRQ status */
1553         outl(sts, DE4X5_STS);            /* Reset the board interrupts */
1554
1555         if (!(sts & lp->irq_mask)) break;/* All done */
1556         handled = 1;
1557
1558         if (sts & (STS_RI | STS_RU))     /* Rx interrupt (packet[s] arrived) */
1559           de4x5_rx(dev);
1560
1561         if (sts & (STS_TI | STS_TU))     /* Tx interrupt (packet sent) */
1562           de4x5_tx(dev);
1563
1564         if (sts & STS_LNF) {             /* TP Link has failed */
1565             lp->irq_mask &= ~IMR_LFM;
1566         }
1567
1568         if (sts & STS_UNF) {             /* Transmit underrun */
1569             de4x5_txur(dev);
1570         }
1571
1572         if (sts & STS_SE) {              /* Bus Error */
1573             STOP_DE4X5;
1574             printk("%s: Fatal bus error occurred, sts=%#8x, device stopped.\n",
1575                    dev->name, sts);
1576             spin_unlock(&lp->lock);
1577             return IRQ_HANDLED;
1578         }
1579     }
1580
1581     /* Load the TX ring with any locally stored packets */
1582     if (!test_and_set_bit(0, (void *)&lp->cache.lock)) {
1583         while (lp->cache.skb && !netif_queue_stopped(dev) && lp->tx_enable) {
1584             de4x5_queue_pkt(de4x5_get_cache(dev), dev);
1585         }
1586         lp->cache.lock = 0;
1587     }
1588
1589     lp->interrupt = UNMASK_INTERRUPTS;
1590     ENABLE_IRQs;
1591     spin_unlock(&lp->lock);
1592
1593     return IRQ_RETVAL(handled);
1594 }
1595
1596 static int
1597 de4x5_rx(struct net_device *dev)
1598 {
1599     struct de4x5_private *lp = netdev_priv(dev);
1600     u_long iobase = dev->base_addr;
1601     int entry;
1602     s32 status;
1603
1604     for (entry=lp->rx_new; (s32)le32_to_cpu(lp->rx_ring[entry].status)>=0;
1605                                                             entry=lp->rx_new) {
1606         status = (s32)le32_to_cpu(lp->rx_ring[entry].status);
1607
1608         if (lp->rx_ovf) {
1609             if (inl(DE4X5_MFC) & MFC_FOCM) {
1610                 de4x5_rx_ovfc(dev);
1611                 break;
1612             }
1613         }
1614
1615         if (status & RD_FS) {                 /* Remember the start of frame */
1616             lp->rx_old = entry;
1617         }
1618
1619         if (status & RD_LS) {                 /* Valid frame status */
1620             if (lp->tx_enable) lp->linkOK++;
1621             if (status & RD_ES) {             /* There was an error. */
1622                 lp->stats.rx_errors++;        /* Update the error stats. */
1623                 if (status & (RD_RF | RD_TL)) lp->stats.rx_frame_errors++;
1624                 if (status & RD_CE)           lp->stats.rx_crc_errors++;
1625                 if (status & RD_OF)           lp->stats.rx_fifo_errors++;
1626                 if (status & RD_TL)           lp->stats.rx_length_errors++;
1627                 if (status & RD_RF)           lp->pktStats.rx_runt_frames++;
1628                 if (status & RD_CS)           lp->pktStats.rx_collision++;
1629                 if (status & RD_DB)           lp->pktStats.rx_dribble++;
1630                 if (status & RD_OF)           lp->pktStats.rx_overflow++;
1631             } else {                          /* A valid frame received */
1632                 struct sk_buff *skb;
1633                 short pkt_len = (short)(le32_to_cpu(lp->rx_ring[entry].status)
1634                                                                     >> 16) - 4;
1635
1636                 if ((skb = de4x5_alloc_rx_buff(dev, entry, pkt_len)) == NULL) {
1637                     printk("%s: Insufficient memory; nuking packet.\n",
1638                                                                     dev->name);
1639                     lp->stats.rx_dropped++;
1640                 } else {
1641                     de4x5_dbg_rx(skb, pkt_len);
1642
1643                     /* Push up the protocol stack */
1644                     skb->protocol=eth_type_trans(skb,dev);
1645                     de4x5_local_stats(dev, skb->data, pkt_len);
1646                     netif_rx(skb);
1647
1648                     /* Update stats */
1649                     dev->last_rx = jiffies;
1650                     lp->stats.rx_packets++;
1651                     lp->stats.rx_bytes += pkt_len;
1652                 }
1653             }
1654
1655             /* Change buffer ownership for this frame, back to the adapter */
1656             for (;lp->rx_old!=entry;lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
1657                 lp->rx_ring[lp->rx_old].status = cpu_to_le32(R_OWN);
1658                 barrier();
1659             }
1660             lp->rx_ring[entry].status = cpu_to_le32(R_OWN);
1661             barrier();
1662         }
1663
1664         /*
1665         ** Update entry information
1666         */
1667         lp->rx_new = (++lp->rx_new) % lp->rxRingSize;
1668     }
1669
1670     return 0;
1671 }
1672
1673 static inline void
1674 de4x5_free_tx_buff(struct de4x5_private *lp, int entry)
1675 {
1676     dma_unmap_single(lp->gendev, le32_to_cpu(lp->tx_ring[entry].buf),
1677                      le32_to_cpu(lp->tx_ring[entry].des1) & TD_TBS1,
1678                      DMA_TO_DEVICE);
1679     if ((u_long) lp->tx_skb[entry] > 1)
1680         dev_kfree_skb_irq(lp->tx_skb[entry]);
1681     lp->tx_skb[entry] = NULL;
1682 }
1683
1684 /*
1685 ** Buffer sent - check for TX buffer errors.
1686 */
1687 static int
1688 de4x5_tx(struct net_device *dev)
1689 {
1690     struct de4x5_private *lp = netdev_priv(dev);
1691     u_long iobase = dev->base_addr;
1692     int entry;
1693     s32 status;
1694
1695     for (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
1696         status = (s32)le32_to_cpu(lp->tx_ring[entry].status);
1697         if (status < 0) {                     /* Buffer not sent yet */
1698             break;
1699         } else if (status != 0x7fffffff) {    /* Not setup frame */
1700             if (status & TD_ES) {             /* An error happened */
1701                 lp->stats.tx_errors++;
1702                 if (status & TD_NC) lp->stats.tx_carrier_errors++;
1703                 if (status & TD_LC) lp->stats.tx_window_errors++;
1704                 if (status & TD_UF) lp->stats.tx_fifo_errors++;
1705                 if (status & TD_EC) lp->pktStats.excessive_collisions++;
1706                 if (status & TD_DE) lp->stats.tx_aborted_errors++;
1707
1708                 if (TX_PKT_PENDING) {
1709                     outl(POLL_DEMAND, DE4X5_TPD);/* Restart a stalled TX */
1710                 }
1711             } else {                      /* Packet sent */
1712                 lp->stats.tx_packets++;
1713                 if (lp->tx_enable) lp->linkOK++;
1714             }
1715             /* Update the collision counter */
1716             lp->stats.collisions += ((status & TD_EC) ? 16 :
1717                                                       ((status & TD_CC) >> 3));
1718
1719             /* Free the buffer. */
1720             if (lp->tx_skb[entry] != NULL)
1721                 de4x5_free_tx_buff(lp, entry);
1722         }
1723
1724         /* Update all the pointers */
1725         lp->tx_old = (++lp->tx_old) % lp->txRingSize;
1726     }
1727
1728     /* Any resources available? */
1729     if (TX_BUFFS_AVAIL && netif_queue_stopped(dev)) {
1730         if (lp->interrupt)
1731             netif_wake_queue(dev);
1732         else
1733             netif_start_queue(dev);
1734     }
1735
1736     return 0;
1737 }
1738
1739 static void
1740 de4x5_ast(struct net_device *dev)
1741 {
1742         struct de4x5_private *lp = netdev_priv(dev);
1743         int next_tick = DE4X5_AUTOSENSE_MS;
1744         int dt;
1745
1746         if (lp->useSROM)
1747                 next_tick = srom_autoconf(dev);
1748         else if (lp->chipset == DC21140)
1749                 next_tick = dc21140m_autoconf(dev);
1750         else if (lp->chipset == DC21041)
1751                 next_tick = dc21041_autoconf(dev);
1752         else if (lp->chipset == DC21040)
1753                 next_tick = dc21040_autoconf(dev);
1754         lp->linkOK = 0;
1755
1756         dt = (next_tick * HZ) / 1000;
1757
1758         if (!dt)
1759                 dt = 1;
1760
1761         mod_timer(&lp->timer, jiffies + dt);
1762 }
1763
1764 static int
1765 de4x5_txur(struct net_device *dev)
1766 {
1767     struct de4x5_private *lp = netdev_priv(dev);
1768     u_long iobase = dev->base_addr;
1769     int omr;
1770
1771     omr = inl(DE4X5_OMR);
1772     if (!(omr & OMR_SF) || (lp->chipset==DC21041) || (lp->chipset==DC21040)) {
1773         omr &= ~(OMR_ST|OMR_SR);
1774         outl(omr, DE4X5_OMR);
1775         while (inl(DE4X5_STS) & STS_TS);
1776         if ((omr & OMR_TR) < OMR_TR) {
1777             omr += 0x4000;
1778         } else {
1779             omr |= OMR_SF;
1780         }
1781         outl(omr | OMR_ST | OMR_SR, DE4X5_OMR);
1782     }
1783
1784     return 0;
1785 }
1786
1787 static int
1788 de4x5_rx_ovfc(struct net_device *dev)
1789 {
1790     struct de4x5_private *lp = netdev_priv(dev);
1791     u_long iobase = dev->base_addr;
1792     int omr;
1793
1794     omr = inl(DE4X5_OMR);
1795     outl(omr & ~OMR_SR, DE4X5_OMR);
1796     while (inl(DE4X5_STS) & STS_RS);
1797
1798     for (; (s32)le32_to_cpu(lp->rx_ring[lp->rx_new].status)>=0;) {
1799         lp->rx_ring[lp->rx_new].status = cpu_to_le32(R_OWN);
1800         lp->rx_new = (++lp->rx_new % lp->rxRingSize);
1801     }
1802
1803     outl(omr, DE4X5_OMR);
1804
1805     return 0;
1806 }
1807
1808 static int
1809 de4x5_close(struct net_device *dev)
1810 {
1811     struct de4x5_private *lp = netdev_priv(dev);
1812     u_long iobase = dev->base_addr;
1813     s32 imr, omr;
1814
1815     disable_ast(dev);
1816
1817     netif_stop_queue(dev);
1818
1819     if (de4x5_debug & DEBUG_CLOSE) {
1820         printk("%s: Shutting down ethercard, status was %8.8x.\n",
1821                dev->name, inl(DE4X5_STS));
1822     }
1823
1824     /*
1825     ** We stop the DE4X5 here... mask interrupts and stop TX & RX
1826     */
1827     DISABLE_IRQs;
1828     STOP_DE4X5;
1829
1830     /* Free the associated irq */
1831     free_irq(dev->irq, dev);
1832     lp->state = CLOSED;
1833
1834     /* Free any socket buffers */
1835     de4x5_free_rx_buffs(dev);
1836     de4x5_free_tx_buffs(dev);
1837
1838     /* Put the adapter to sleep to save power */
1839     yawn(dev, SLEEP);
1840
1841     return 0;
1842 }
1843
1844 static struct net_device_stats *
1845 de4x5_get_stats(struct net_device *dev)
1846 {
1847     struct de4x5_private *lp = netdev_priv(dev);
1848     u_long iobase = dev->base_addr;
1849
1850     lp->stats.rx_missed_errors = (int)(inl(DE4X5_MFC) & (MFC_OVFL | MFC_CNTR));
1851
1852     return &lp->stats;
1853 }
1854
1855 static void
1856 de4x5_local_stats(struct net_device *dev, char *buf, int pkt_len)
1857 {
1858     struct de4x5_private *lp = netdev_priv(dev);
1859     int i;
1860
1861     for (i=1; i<DE4X5_PKT_STAT_SZ-1; i++) {
1862         if (pkt_len < (i*DE4X5_PKT_BIN_SZ)) {
1863             lp->pktStats.bins[i]++;
1864             i = DE4X5_PKT_STAT_SZ;
1865         }
1866     }
1867     if (buf[0] & 0x01) {          /* Multicast/Broadcast */
1868         if ((*(s32 *)&buf[0] == -1) && (*(s16 *)&buf[4] == -1)) {
1869             lp->pktStats.broadcast++;
1870         } else {
1871             lp->pktStats.multicast++;
1872         }
1873     } else if ((*(s32 *)&buf[0] == *(s32 *)&dev->dev_addr[0]) &&
1874                (*(s16 *)&buf[4] == *(s16 *)&dev->dev_addr[4])) {
1875         lp->pktStats.unicast++;
1876     }
1877
1878     lp->pktStats.bins[0]++;       /* Duplicates stats.rx_packets */
1879     if (lp->pktStats.bins[0] == 0) { /* Reset counters */
1880         memset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
1881     }
1882
1883     return;
1884 }
1885
1886 /*
1887 ** Removes the TD_IC flag from previous descriptor to improve TX performance.
1888 ** If the flag is changed on a descriptor that is being read by the hardware,
1889 ** I assume PCI transaction ordering will mean you are either successful or
1890 ** just miss asserting the change to the hardware. Anyway you're messing with
1891 ** a descriptor you don't own, but this shouldn't kill the chip provided
1892 ** the descriptor register is read only to the hardware.
1893 */
1894 static void
1895 load_packet(struct net_device *dev, char *buf, u32 flags, struct sk_buff *skb)
1896 {
1897     struct de4x5_private *lp = netdev_priv(dev);
1898     int entry = (lp->tx_new ? lp->tx_new-1 : lp->txRingSize-1);
1899     dma_addr_t buf_dma = dma_map_single(lp->gendev, buf, flags & TD_TBS1, DMA_TO_DEVICE);
1900
1901     lp->tx_ring[lp->tx_new].buf = cpu_to_le32(buf_dma);
1902     lp->tx_ring[lp->tx_new].des1 &= cpu_to_le32(TD_TER);
1903     lp->tx_ring[lp->tx_new].des1 |= cpu_to_le32(flags);
1904     lp->tx_skb[lp->tx_new] = skb;
1905     lp->tx_ring[entry].des1 &= cpu_to_le32(~TD_IC);
1906     barrier();
1907
1908     lp->tx_ring[lp->tx_new].status = cpu_to_le32(T_OWN);
1909     barrier();
1910 }
1911
1912 /*
1913 ** Set or clear the multicast filter for this adaptor.
1914 */
1915 static void
1916 set_multicast_list(struct net_device *dev)
1917 {
1918     struct de4x5_private *lp = netdev_priv(dev);
1919     u_long iobase = dev->base_addr;
1920
1921     /* First, double check that the adapter is open */
1922     if (lp->state == OPEN) {
1923         if (dev->flags & IFF_PROMISC) {         /* set promiscuous mode */
1924             u32 omr;
1925             omr = inl(DE4X5_OMR);
1926             omr |= OMR_PR;
1927             outl(omr, DE4X5_OMR);
1928         } else {
1929             SetMulticastFilter(dev);
1930             load_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET |
1931                                                         SETUP_FRAME_LEN, (struct sk_buff *)1);
1932
1933             lp->tx_new = (++lp->tx_new) % lp->txRingSize;
1934             outl(POLL_DEMAND, DE4X5_TPD);       /* Start the TX */
1935             dev->trans_start = jiffies;
1936         }
1937     }
1938 }
1939
1940 /*
1941 ** Calculate the hash code and update the logical address filter
1942 ** from a list of ethernet multicast addresses.
1943 ** Little endian crc one liner from Matt Thomas, DEC.
1944 */
1945 static void
1946 SetMulticastFilter(struct net_device *dev)
1947 {
1948     struct de4x5_private *lp = netdev_priv(dev);
1949     struct dev_mc_list *dmi=dev->mc_list;
1950     u_long iobase = dev->base_addr;
1951     int i, j, bit, byte;
1952     u16 hashcode;
1953     u32 omr, crc;
1954     char *pa;
1955     unsigned char *addrs;
1956
1957     omr = inl(DE4X5_OMR);
1958     omr &= ~(OMR_PR | OMR_PM);
1959     pa = build_setup_frame(dev, ALL);        /* Build the basic frame */
1960
1961     if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 14)) {
1962         omr |= OMR_PM;                       /* Pass all multicasts */
1963     } else if (lp->setup_f == HASH_PERF) {   /* Hash Filtering */
1964         for (i=0;i<dev->mc_count;i++) {      /* for each address in the list */
1965             addrs=dmi->dmi_addr;
1966             dmi=dmi->next;
1967             if ((*addrs & 0x01) == 1) {      /* multicast address? */
1968                 crc = ether_crc_le(ETH_ALEN, addrs);
1969                 hashcode = crc & HASH_BITS;  /* hashcode is 9 LSb of CRC */
1970
1971                 byte = hashcode >> 3;        /* bit[3-8] -> byte in filter */
1972                 bit = 1 << (hashcode & 0x07);/* bit[0-2] -> bit in byte */
1973
1974                 byte <<= 1;                  /* calc offset into setup frame */
1975                 if (byte & 0x02) {
1976                     byte -= 1;
1977                 }
1978                 lp->setup_frame[byte] |= bit;
1979             }
1980         }
1981     } else {                                 /* Perfect filtering */
1982         for (j=0; j<dev->mc_count; j++) {
1983             addrs=dmi->dmi_addr;
1984             dmi=dmi->next;
1985             for (i=0; i<ETH_ALEN; i++) {
1986                 *(pa + (i&1)) = *addrs++;
1987                 if (i & 0x01) pa += 4;
1988             }
1989         }
1990     }
1991     outl(omr, DE4X5_OMR);
1992
1993     return;
1994 }
1995
1996 #ifdef CONFIG_EISA
1997
1998 static u_char de4x5_irq[] = EISA_ALLOWED_IRQ_LIST;
1999
2000 static int __init de4x5_eisa_probe (struct device *gendev)
2001 {
2002         struct eisa_device *edev;
2003         u_long iobase;
2004         u_char irq, regval;
2005         u_short vendor;
2006         u32 cfid;
2007         int status, device;
2008         struct net_device *dev;
2009         struct de4x5_private *lp;
2010
2011         edev = to_eisa_device (gendev);
2012         iobase = edev->base_addr;
2013
2014         if (!request_region (iobase, DE4X5_EISA_TOTAL_SIZE, "de4x5"))
2015                 return -EBUSY;
2016
2017         if (!request_region (iobase + DE4X5_EISA_IO_PORTS,
2018                              DE4X5_EISA_TOTAL_SIZE, "de4x5")) {
2019                 status = -EBUSY;
2020                 goto release_reg_1;
2021         }
2022
2023         if (!(dev = alloc_etherdev (sizeof (struct de4x5_private)))) {
2024                 status = -ENOMEM;
2025                 goto release_reg_2;
2026         }
2027         lp = netdev_priv(dev);
2028
2029         cfid = (u32) inl(PCI_CFID);
2030         lp->cfrv = (u_short) inl(PCI_CFRV);
2031         device = (cfid >> 8) & 0x00ffff00;
2032         vendor = (u_short) cfid;
2033
2034         /* Read the EISA Configuration Registers */
2035         regval = inb(EISA_REG0) & (ER0_INTL | ER0_INTT);
2036 #ifdef CONFIG_ALPHA
2037         /* Looks like the Jensen firmware (rev 2.2) doesn't really
2038          * care about the EISA configuration, and thus doesn't
2039          * configure the PLX bridge properly. Oh well... Simply mimic
2040          * the EISA config file to sort it out. */
2041
2042         /* EISA REG1: Assert DecChip 21040 HW Reset */
2043         outb (ER1_IAM | 1, EISA_REG1);
2044         mdelay (1);
2045
2046         /* EISA REG1: Deassert DecChip 21040 HW Reset */
2047         outb (ER1_IAM, EISA_REG1);
2048         mdelay (1);
2049
2050         /* EISA REG3: R/W Burst Transfer Enable */
2051         outb (ER3_BWE | ER3_BRE, EISA_REG3);
2052
2053         /* 32_bit slave/master, Preempt Time=23 bclks, Unlatched Interrupt */
2054         outb (ER0_BSW | ER0_BMW | ER0_EPT | regval, EISA_REG0);
2055 #endif
2056         irq = de4x5_irq[(regval >> 1) & 0x03];
2057
2058         if (is_DC2114x) {
2059             device = ((lp->cfrv & CFRV_RN) < DC2114x_BRK ? DC21142 : DC21143);
2060         }
2061         lp->chipset = device;
2062         lp->bus = EISA;
2063
2064         /* Write the PCI Configuration Registers */
2065         outl(PCI_COMMAND_IO | PCI_COMMAND_MASTER, PCI_CFCS);
2066         outl(0x00006000, PCI_CFLT);
2067         outl(iobase, PCI_CBIO);
2068
2069         DevicePresent(dev, EISA_APROM);
2070
2071         dev->irq = irq;
2072
2073         if (!(status = de4x5_hw_init (dev, iobase, gendev))) {
2074                 return 0;
2075         }
2076
2077         free_netdev (dev);
2078  release_reg_2:
2079         release_region (iobase + DE4X5_EISA_IO_PORTS, DE4X5_EISA_TOTAL_SIZE);
2080  release_reg_1:
2081         release_region (iobase, DE4X5_EISA_TOTAL_SIZE);
2082
2083         return status;
2084 }
2085
2086 static int __devexit de4x5_eisa_remove (struct device *device)
2087 {
2088         struct net_device *dev;
2089         u_long iobase;
2090
2091         dev = device->driver_data;
2092         iobase = dev->base_addr;
2093
2094         unregister_netdev (dev);
2095         free_netdev (dev);
2096         release_region (iobase + DE4X5_EISA_IO_PORTS, DE4X5_EISA_TOTAL_SIZE);
2097         release_region (iobase, DE4X5_EISA_TOTAL_SIZE);
2098
2099         return 0;
2100 }
2101
2102 static struct eisa_device_id de4x5_eisa_ids[] = {
2103         { "DEC4250", 0 },       /* 0 is the board name index... */
2104         { "" }
2105 };
2106 MODULE_DEVICE_TABLE(eisa, de4x5_eisa_ids);
2107
2108 static struct eisa_driver de4x5_eisa_driver = {
2109         .id_table = de4x5_eisa_ids,
2110         .driver   = {
2111                 .name    = "de4x5",
2112                 .probe   = de4x5_eisa_probe,
2113                 .remove  = __devexit_p (de4x5_eisa_remove),
2114         }
2115 };
2116 MODULE_DEVICE_TABLE(eisa, de4x5_eisa_ids);
2117 #endif
2118
2119 #ifdef CONFIG_PCI
2120
2121 /*
2122 ** This function searches the current bus (which is >0) for a DECchip with an
2123 ** SROM, so that in multiport cards that have one SROM shared between multiple
2124 ** DECchips, we can find the base SROM irrespective of the BIOS scan direction.
2125 ** For single port cards this is a time waster...
2126 */
2127 static void __devinit
2128 srom_search(struct net_device *dev, struct pci_dev *pdev)
2129 {
2130     u_char pb;
2131     u_short vendor, status;
2132     u_int irq = 0, device;
2133     u_long iobase = 0;                     /* Clear upper 32 bits in Alphas */
2134     int i, j;
2135     struct de4x5_private *lp = netdev_priv(dev);
2136     struct list_head *walk;
2137
2138     list_for_each(walk, &pdev->bus_list) {
2139         struct pci_dev *this_dev = pci_dev_b(walk);
2140
2141         /* Skip the pci_bus list entry */
2142         if (list_entry(walk, struct pci_bus, devices) == pdev->bus) continue;
2143
2144         vendor = this_dev->vendor;
2145         device = this_dev->device << 8;
2146         if (!(is_DC21040 || is_DC21041 || is_DC21140 || is_DC2114x)) continue;
2147
2148         /* Get the chip configuration revision register */
2149         pb = this_dev->bus->number;
2150
2151         /* Set the device number information */
2152         lp->device = PCI_SLOT(this_dev->devfn);
2153         lp->bus_num = pb;
2154
2155         /* Set the chipset information */
2156         if (is_DC2114x) {
2157             device = ((this_dev->revision & CFRV_RN) < DC2114x_BRK
2158                       ? DC21142 : DC21143);
2159         }
2160         lp->chipset = device;
2161
2162         /* Get the board I/O address (64 bits on sparc64) */
2163         iobase = pci_resource_start(this_dev, 0);
2164
2165         /* Fetch the IRQ to be used */
2166         irq = this_dev->irq;
2167         if ((irq == 0) || (irq == 0xff) || ((int)irq == -1)) continue;
2168
2169         /* Check if I/O accesses are enabled */
2170         pci_read_config_word(this_dev, PCI_COMMAND, &status);
2171         if (!(status & PCI_COMMAND_IO)) continue;
2172
2173         /* Search for a valid SROM attached to this DECchip */
2174         DevicePresent(dev, DE4X5_APROM);
2175         for (j=0, i=0; i<ETH_ALEN; i++) {
2176             j += (u_char) *((u_char *)&lp->srom + SROM_HWADD + i);
2177         }
2178         if (j != 0 && j != 6 * 0xff) {
2179             last.chipset = device;
2180             last.bus = pb;
2181             last.irq = irq;
2182             for (i=0; i<ETH_ALEN; i++) {
2183                 last.addr[i] = (u_char)*((u_char *)&lp->srom + SROM_HWADD + i);
2184             }
2185             return;
2186         }
2187     }
2188
2189     return;
2190 }
2191
2192 /*
2193 ** PCI bus I/O device probe
2194 ** NB: PCI I/O accesses and Bus Mastering are enabled by the PCI BIOS, not
2195 ** the driver. Some PCI BIOS's, pre V2.1, need the slot + features to be
2196 ** enabled by the user first in the set up utility. Hence we just check for
2197 ** enabled features and silently ignore the card if they're not.
2198 **
2199 ** STOP PRESS: Some BIOS's __require__ the driver to enable the bus mastering
2200 ** bit. Here, check for I/O accesses and then set BM. If you put the card in
2201 ** a non BM slot, you're on your own (and complain to the PC vendor that your
2202 ** PC doesn't conform to the PCI standard)!
2203 **
2204 ** This function is only compatible with the *latest* 2.1.x kernels. For 2.0.x
2205 ** kernels use the V0.535[n] drivers.
2206 */
2207
2208 static int __devinit de4x5_pci_probe (struct pci_dev *pdev,
2209                                    const struct pci_device_id *ent)
2210 {
2211         u_char pb, pbus = 0, dev_num, dnum = 0, timer;
2212         u_short vendor, status;
2213         u_int irq = 0, device;
2214         u_long iobase = 0;      /* Clear upper 32 bits in Alphas */
2215         int error;
2216         struct net_device *dev;
2217         struct de4x5_private *lp;
2218
2219         dev_num = PCI_SLOT(pdev->devfn);
2220         pb = pdev->bus->number;
2221
2222         if (io) { /* probe a single PCI device */
2223                 pbus = (u_short)(io >> 8);
2224                 dnum = (u_short)(io & 0xff);
2225                 if ((pbus != pb) || (dnum != dev_num))
2226                         return -ENODEV;
2227         }
2228
2229         vendor = pdev->vendor;
2230         device = pdev->device << 8;
2231         if (!(is_DC21040 || is_DC21041 || is_DC21140 || is_DC2114x))
2232                 return -ENODEV;
2233
2234         /* Ok, the device seems to be for us. */
2235         if ((error = pci_enable_device (pdev)))
2236                 return error;
2237
2238         if (!(dev = alloc_etherdev (sizeof (struct de4x5_private)))) {
2239                 error = -ENOMEM;
2240                 goto disable_dev;
2241         }
2242
2243         lp = netdev_priv(dev);
2244         lp->bus = PCI;
2245         lp->bus_num = 0;
2246
2247         /* Search for an SROM on this bus */
2248         if (lp->bus_num != pb) {
2249             lp->bus_num = pb;
2250             srom_search(dev, pdev);
2251         }
2252
2253         /* Get the chip configuration revision register */
2254         lp->cfrv = pdev->revision;
2255
2256         /* Set the device number information */
2257         lp->device = dev_num;
2258         lp->bus_num = pb;
2259
2260         /* Set the chipset information */
2261         if (is_DC2114x) {
2262             device = ((lp->cfrv & CFRV_RN) < DC2114x_BRK ? DC21142 : DC21143);
2263         }
2264         lp->chipset = device;
2265
2266         /* Get the board I/O address (64 bits on sparc64) */
2267         iobase = pci_resource_start(pdev, 0);
2268
2269         /* Fetch the IRQ to be used */
2270         irq = pdev->irq;
2271         if ((irq == 0) || (irq == 0xff) || ((int)irq == -1)) {
2272                 error = -ENODEV;
2273                 goto free_dev;
2274         }
2275
2276         /* Check if I/O accesses and Bus Mastering are enabled */
2277         pci_read_config_word(pdev, PCI_COMMAND, &status);
2278 #ifdef __powerpc__
2279         if (!(status & PCI_COMMAND_IO)) {
2280             status |= PCI_COMMAND_IO;
2281             pci_write_config_word(pdev, PCI_COMMAND, status);
2282             pci_read_config_word(pdev, PCI_COMMAND, &status);
2283         }
2284 #endif /* __powerpc__ */
2285         if (!(status & PCI_COMMAND_IO)) {
2286                 error = -ENODEV;
2287                 goto free_dev;
2288         }
2289
2290         if (!(status & PCI_COMMAND_MASTER)) {
2291             status |= PCI_COMMAND_MASTER;
2292             pci_write_config_word(pdev, PCI_COMMAND, status);
2293             pci_read_config_word(pdev, PCI_COMMAND, &status);
2294         }
2295         if (!(status & PCI_COMMAND_MASTER)) {
2296                 error = -ENODEV;
2297                 goto free_dev;
2298         }
2299
2300         /* Check the latency timer for values >= 0x60 */
2301         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &timer);
2302         if (timer < 0x60) {
2303             pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x60);
2304         }
2305
2306         DevicePresent(dev, DE4X5_APROM);
2307
2308         if (!request_region (iobase, DE4X5_PCI_TOTAL_SIZE, "de4x5")) {
2309                 error = -EBUSY;
2310                 goto free_dev;
2311         }
2312
2313         dev->irq = irq;
2314
2315         if ((error = de4x5_hw_init(dev, iobase, &pdev->dev))) {
2316                 goto release;
2317         }
2318
2319         return 0;
2320
2321  release:
2322         release_region (iobase, DE4X5_PCI_TOTAL_SIZE);
2323  free_dev:
2324         free_netdev (dev);
2325  disable_dev:
2326         pci_disable_device (pdev);
2327         return error;
2328 }
2329
2330 static void __devexit de4x5_pci_remove (struct pci_dev *pdev)
2331 {
2332         struct net_device *dev;
2333         u_long iobase;
2334
2335         dev = pdev->dev.driver_data;
2336         iobase = dev->base_addr;
2337
2338         unregister_netdev (dev);
2339         free_netdev (dev);
2340         release_region (iobase, DE4X5_PCI_TOTAL_SIZE);
2341         pci_disable_device (pdev);
2342 }
2343
2344 static struct pci_device_id de4x5_pci_tbl[] = {
2345         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
2346           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2347         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
2348           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
2349         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_FAST,
2350           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
2351         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21142,
2352           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
2353         { },
2354 };
2355
2356 static struct pci_driver de4x5_pci_driver = {
2357         .name           = "de4x5",
2358         .id_table       = de4x5_pci_tbl,
2359         .probe          = de4x5_pci_probe,
2360         .remove         = __devexit_p (de4x5_pci_remove),
2361 };
2362
2363 #endif
2364
2365 /*
2366 ** Auto configure the media here rather than setting the port at compile
2367 ** time. This routine is called by de4x5_init() and when a loss of media is
2368 ** detected (excessive collisions, loss of carrier, no carrier or link fail
2369 ** [TP] or no recent receive activity) to check whether the user has been
2370 ** sneaky and changed the port on us.
2371 */
2372 static int
2373 autoconf_media(struct net_device *dev)
2374 {
2375         struct de4x5_private *lp = netdev_priv(dev);
2376         u_long iobase = dev->base_addr;
2377
2378         disable_ast(dev);
2379
2380         lp->c_media = AUTO;                     /* Bogus last media */
2381         inl(DE4X5_MFC);                         /* Zero the lost frames counter */
2382         lp->media = INIT;
2383         lp->tcount = 0;
2384
2385         de4x5_ast(dev);
2386
2387         return lp->media;
2388 }
2389
2390 /*
2391 ** Autoconfigure the media when using the DC21040. AUI cannot be distinguished
2392 ** from BNC as the port has a jumper to set thick or thin wire. When set for
2393 ** BNC, the BNC port will indicate activity if it's not terminated correctly.
2394 ** The only way to test for that is to place a loopback packet onto the
2395 ** network and watch for errors. Since we're messing with the interrupt mask
2396 ** register, disable the board interrupts and do not allow any more packets to
2397 ** be queued to the hardware. Re-enable everything only when the media is
2398 ** found.
2399 ** I may have to "age out" locally queued packets so that the higher layer
2400 ** timeouts don't effectively duplicate packets on the network.
2401 */
2402 static int
2403 dc21040_autoconf(struct net_device *dev)
2404 {
2405     struct de4x5_private *lp = netdev_priv(dev);
2406     u_long iobase = dev->base_addr;
2407     int next_tick = DE4X5_AUTOSENSE_MS;
2408     s32 imr;
2409
2410     switch (lp->media) {
2411     case INIT:
2412         DISABLE_IRQs;
2413         lp->tx_enable = false;
2414         lp->timeout = -1;
2415         de4x5_save_skbs(dev);
2416         if ((lp->autosense == AUTO) || (lp->autosense == TP)) {
2417             lp->media = TP;
2418         } else if ((lp->autosense == BNC) || (lp->autosense == AUI) || (lp->autosense == BNC_AUI)) {
2419             lp->media = BNC_AUI;
2420         } else if (lp->autosense == EXT_SIA) {
2421             lp->media = EXT_SIA;
2422         } else {
2423             lp->media = NC;
2424         }
2425         lp->local_state = 0;
2426         next_tick = dc21040_autoconf(dev);
2427         break;
2428
2429     case TP:
2430         next_tick = dc21040_state(dev, 0x8f01, 0xffff, 0x0000, 3000, BNC_AUI,
2431                                                          TP_SUSPECT, test_tp);
2432         break;
2433
2434     case TP_SUSPECT:
2435         next_tick = de4x5_suspect_state(dev, 1000, TP, test_tp, dc21040_autoconf);
2436         break;
2437
2438     case BNC:
2439     case AUI:
2440     case BNC_AUI:
2441         next_tick = dc21040_state(dev, 0x8f09, 0x0705, 0x0006, 3000, EXT_SIA,
2442                                                   BNC_AUI_SUSPECT, ping_media);
2443         break;
2444
2445     case BNC_AUI_SUSPECT:
2446         next_tick = de4x5_suspect_state(dev, 1000, BNC_AUI, ping_media, dc21040_autoconf);
2447         break;
2448
2449     case EXT_SIA:
2450         next_tick = dc21040_state(dev, 0x3041, 0x0000, 0x0006, 3000,
2451                                               NC, EXT_SIA_SUSPECT, ping_media);
2452         break;
2453
2454     case EXT_SIA_SUSPECT:
2455         next_tick = de4x5_suspect_state(dev, 1000, EXT_SIA, ping_media, dc21040_autoconf);
2456         break;
2457
2458     case NC:
2459         /* default to TP for all */
2460         reset_init_sia(dev, 0x8f01, 0xffff, 0x0000);
2461         if (lp->media != lp->c_media) {
2462             de4x5_dbg_media(dev);
2463             lp->c_media = lp->media;
2464         }
2465         lp->media = INIT;
2466         lp->tx_enable = false;
2467         break;
2468     }
2469
2470     return next_tick;
2471 }
2472
2473 static int
2474 dc21040_state(struct net_device *dev, int csr13, int csr14, int csr15, int timeout,
2475               int next_state, int suspect_state,
2476               int (*fn)(struct net_device *, int))
2477 {
2478     struct de4x5_private *lp = netdev_priv(dev);
2479     int next_tick = DE4X5_AUTOSENSE_MS;
2480     int linkBad;
2481
2482     switch (lp->local_state) {
2483     case 0:
2484         reset_init_sia(dev, csr13, csr14, csr15);
2485         lp->local_state++;
2486         next_tick = 500;
2487         break;
2488
2489     case 1:
2490         if (!lp->tx_enable) {
2491             linkBad = fn(dev, timeout);
2492             if (linkBad < 0) {
2493                 next_tick = linkBad & ~TIMER_CB;
2494             } else {
2495                 if (linkBad && (lp->autosense == AUTO)) {
2496                     lp->local_state = 0;
2497                     lp->media = next_state;
2498                 } else {
2499                     de4x5_init_connection(dev);
2500                 }
2501             }
2502         } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2503             lp->media = suspect_state;
2504             next_tick = 3000;
2505         }
2506         break;
2507     }
2508
2509     return next_tick;
2510 }
2511
2512 static int
2513 de4x5_suspect_state(struct net_device *dev, int timeout, int prev_state,
2514                       int (*fn)(struct net_device *, int),
2515                       int (*asfn)(struct net_device *))
2516 {
2517     struct de4x5_private *lp = netdev_priv(dev);
2518     int next_tick = DE4X5_AUTOSENSE_MS;
2519     int linkBad;
2520
2521     switch (lp->local_state) {
2522     case 1:
2523         if (lp->linkOK) {
2524             lp->media = prev_state;
2525         } else {
2526             lp->local_state++;
2527             next_tick = asfn(dev);
2528         }
2529         break;
2530
2531     case 2:
2532         linkBad = fn(dev, timeout);
2533         if (linkBad < 0) {
2534             next_tick = linkBad & ~TIMER_CB;
2535         } else if (!linkBad) {
2536             lp->local_state--;
2537             lp->media = prev_state;
2538         } else {
2539             lp->media = INIT;
2540             lp->tcount++;
2541         }
2542     }
2543
2544     return next_tick;
2545 }
2546
2547 /*
2548 ** Autoconfigure the media when using the DC21041. AUI needs to be tested
2549 ** before BNC, because the BNC port will indicate activity if it's not
2550 ** terminated correctly. The only way to test for that is to place a loopback
2551 ** packet onto the network and watch for errors. Since we're messing with
2552 ** the interrupt mask register, disable the board interrupts and do not allow
2553 ** any more packets to be queued to the hardware. Re-enable everything only
2554 ** when the media is found.
2555 */
2556 static int
2557 dc21041_autoconf(struct net_device *dev)
2558 {
2559     struct de4x5_private *lp = netdev_priv(dev);
2560     u_long iobase = dev->base_addr;
2561     s32 sts, irqs, irq_mask, imr, omr;
2562     int next_tick = DE4X5_AUTOSENSE_MS;
2563
2564     switch (lp->media) {
2565     case INIT:
2566         DISABLE_IRQs;
2567         lp->tx_enable = false;
2568         lp->timeout = -1;
2569         de4x5_save_skbs(dev);          /* Save non transmitted skb's */
2570         if ((lp->autosense == AUTO) || (lp->autosense == TP_NW)) {
2571             lp->media = TP;            /* On chip auto negotiation is broken */
2572         } else if (lp->autosense == TP) {
2573             lp->media = TP;
2574         } else if (lp->autosense == BNC) {
2575             lp->media = BNC;
2576         } else if (lp->autosense == AUI) {
2577             lp->media = AUI;
2578         } else {
2579             lp->media = NC;
2580         }
2581         lp->local_state = 0;
2582         next_tick = dc21041_autoconf(dev);
2583         break;
2584
2585     case TP_NW:
2586         if (lp->timeout < 0) {
2587             omr = inl(DE4X5_OMR);/* Set up full duplex for the autonegotiate */
2588             outl(omr | OMR_FDX, DE4X5_OMR);
2589         }
2590         irqs = STS_LNF | STS_LNP;
2591         irq_mask = IMR_LFM | IMR_LPM;
2592         sts = test_media(dev, irqs, irq_mask, 0xef01, 0xffff, 0x0008, 2400);
2593         if (sts < 0) {
2594             next_tick = sts & ~TIMER_CB;
2595         } else {
2596             if (sts & STS_LNP) {
2597                 lp->media = ANS;
2598             } else {
2599                 lp->media = AUI;
2600             }
2601             next_tick = dc21041_autoconf(dev);
2602         }
2603         break;
2604
2605     case ANS:
2606         if (!lp->tx_enable) {
2607             irqs = STS_LNP;
2608             irq_mask = IMR_LPM;
2609             sts = test_ans(dev, irqs, irq_mask, 3000);
2610             if (sts < 0) {
2611                 next_tick = sts & ~TIMER_CB;
2612             } else {
2613                 if (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
2614                     lp->media = TP;
2615                     next_tick = dc21041_autoconf(dev);
2616                 } else {
2617                     lp->local_state = 1;
2618                     de4x5_init_connection(dev);
2619                 }
2620             }
2621         } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2622             lp->media = ANS_SUSPECT;
2623             next_tick = 3000;
2624         }
2625         break;
2626
2627     case ANS_SUSPECT:
2628         next_tick = de4x5_suspect_state(dev, 1000, ANS, test_tp, dc21041_autoconf);
2629         break;
2630
2631     case TP:
2632         if (!lp->tx_enable) {
2633             if (lp->timeout < 0) {
2634                 omr = inl(DE4X5_OMR);          /* Set up half duplex for TP */
2635                 outl(omr & ~OMR_FDX, DE4X5_OMR);
2636             }
2637             irqs = STS_LNF | STS_LNP;
2638             irq_mask = IMR_LFM | IMR_LPM;
2639             sts = test_media(dev,irqs, irq_mask, 0xef01, 0xff3f, 0x0008, 2400);
2640             if (sts < 0) {
2641                 next_tick = sts & ~TIMER_CB;
2642             } else {
2643                 if (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
2644                     if (inl(DE4X5_SISR) & SISR_NRA) {
2645                         lp->media = AUI;       /* Non selected port activity */
2646                     } else {
2647                         lp->media = BNC;
2648                     }
2649                     next_tick = dc21041_autoconf(dev);
2650                 } else {
2651                     lp->local_state = 1;
2652                     de4x5_init_connection(dev);
2653                 }
2654             }
2655         } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2656             lp->media = TP_SUSPECT;
2657             next_tick = 3000;
2658         }
2659         break;
2660
2661     case TP_SUSPECT:
2662         next_tick = de4x5_suspect_state(dev, 1000, TP, test_tp, dc21041_autoconf);
2663         break;
2664
2665     case AUI:
2666         if (!lp->tx_enable) {
2667             if (lp->timeout < 0) {
2668                 omr = inl(DE4X5_OMR);          /* Set up half duplex for AUI */
2669                 outl(omr & ~OMR_FDX, DE4X5_OMR);
2670             }
2671             irqs = 0;
2672             irq_mask = 0;
2673             sts = test_media(dev,irqs, irq_mask, 0xef09, 0xf73d, 0x000e, 1000);
2674             if (sts < 0) {
2675                 next_tick = sts & ~TIMER_CB;
2676             } else {
2677                 if (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
2678                     lp->media = BNC;
2679                     next_tick = dc21041_autoconf(dev);
2680                 } else {
2681                     lp->local_state = 1;
2682                     de4x5_init_connection(dev);
2683                 }
2684             }
2685         } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2686             lp->media = AUI_SUSPECT;
2687             next_tick = 3000;
2688         }
2689         break;
2690
2691     case AUI_SUSPECT:
2692         next_tick = de4x5_suspect_state(dev, 1000, AUI, ping_media, dc21041_autoconf);
2693         break;
2694
2695     case BNC:
2696         switch (lp->local_state) {
2697         case 0:
2698             if (lp->timeout < 0) {
2699                 omr = inl(DE4X5_OMR);          /* Set up half duplex for BNC */
2700                 outl(omr & ~OMR_FDX, DE4X5_OMR);
2701             }
2702             irqs = 0;
2703             irq_mask = 0;
2704             sts = test_media(dev,irqs, irq_mask, 0xef09, 0xf73d, 0x0006, 1000);
2705             if (sts < 0) {
2706                 next_tick = sts & ~TIMER_CB;
2707             } else {
2708                 lp->local_state++;             /* Ensure media connected */
2709                 next_tick = dc21041_autoconf(dev);
2710             }
2711             break;
2712
2713         case 1:
2714             if (!lp->tx_enable) {
2715                 if ((sts = ping_media(dev, 3000)) < 0) {
2716                     next_tick = sts & ~TIMER_CB;
2717                 } else {
2718                     if (sts) {
2719                         lp->local_state = 0;
2720                         lp->media = NC;
2721                     } else {
2722                         de4x5_init_connection(dev);
2723                     }
2724                 }
2725             } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2726                 lp->media = BNC_SUSPECT;
2727                 next_tick = 3000;
2728             }
2729             break;
2730         }
2731         break;
2732
2733     case BNC_SUSPECT:
2734         next_tick = de4x5_suspect_state(dev, 1000, BNC, ping_media, dc21041_autoconf);
2735         break;
2736
2737     case NC:
2738         omr = inl(DE4X5_OMR);    /* Set up full duplex for the autonegotiate */
2739         outl(omr | OMR_FDX, DE4X5_OMR);
2740         reset_init_sia(dev, 0xef01, 0xffff, 0x0008);/* Initialise the SIA */
2741         if (lp->media != lp->c_media) {
2742             de4x5_dbg_media(dev);
2743             lp->c_media = lp->media;
2744         }
2745         lp->media = INIT;
2746         lp->tx_enable = false;
2747         break;
2748     }
2749
2750     return next_tick;
2751 }
2752
2753 /*
2754 ** Some autonegotiation chips are broken in that they do not return the
2755 ** acknowledge bit (anlpa & MII_ANLPA_ACK) in the link partner advertisement
2756 ** register, except at the first power up negotiation.
2757 */
2758 static int
2759 dc21140m_autoconf(struct net_device *dev)
2760 {
2761     struct de4x5_private *lp = netdev_priv(dev);
2762     int ana, anlpa, cap, cr, slnk, sr;
2763     int next_tick = DE4X5_AUTOSENSE_MS;
2764     u_long imr, omr, iobase = dev->base_addr;
2765
2766     switch(lp->media) {
2767     case INIT:
2768         if (lp->timeout < 0) {
2769             DISABLE_IRQs;
2770             lp->tx_enable = false;
2771             lp->linkOK = 0;
2772             de4x5_save_skbs(dev);          /* Save non transmitted skb's */
2773         }
2774         if ((next_tick = de4x5_reset_phy(dev)) < 0) {
2775             next_tick &= ~TIMER_CB;
2776         } else {
2777             if (lp->useSROM) {
2778                 if (srom_map_media(dev) < 0) {
2779                     lp->tcount++;
2780                     return next_tick;
2781                 }
2782                 srom_exec(dev, lp->phy[lp->active].gep);
2783                 if (lp->infoblock_media == ANS) {
2784                     ana = lp->phy[lp->active].ana | MII_ANA_CSMA;
2785                     mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2786                 }
2787             } else {
2788                 lp->tmp = MII_SR_ASSC;     /* Fake out the MII speed set */
2789                 SET_10Mb;
2790                 if (lp->autosense == _100Mb) {
2791                     lp->media = _100Mb;
2792                 } else if (lp->autosense == _10Mb) {
2793                     lp->media = _10Mb;
2794                 } else if ((lp->autosense == AUTO) &&
2795                                     ((sr=is_anc_capable(dev)) & MII_SR_ANC)) {
2796                     ana = (((sr >> 6) & MII_ANA_TAF) | MII_ANA_CSMA);
2797                     ana &= (lp->fdx ? ~0 : ~MII_ANA_FDAM);
2798                     mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2799                     lp->media = ANS;
2800                 } else if (lp->autosense == AUTO) {
2801                     lp->media = SPD_DET;
2802                 } else if (is_spd_100(dev) && is_100_up(dev)) {
2803                     lp->media = _100Mb;
2804                 } else {
2805                     lp->media = NC;
2806                 }
2807             }
2808             lp->local_state = 0;
2809             next_tick = dc21140m_autoconf(dev);
2810         }
2811         break;
2812
2813     case ANS:
2814         switch (lp->local_state) {
2815         case 0:
2816             if (lp->timeout < 0) {
2817                 mii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
2818             }
2819             cr = test_mii_reg(dev, MII_CR, MII_CR_RAN, false, 500);
2820             if (cr < 0) {
2821                 next_tick = cr & ~TIMER_CB;
2822             } else {
2823                 if (cr) {
2824                     lp->local_state = 0;
2825                     lp->media = SPD_DET;
2826                 } else {
2827                     lp->local_state++;
2828                 }
2829                 next_tick = dc21140m_autoconf(dev);
2830             }
2831             break;
2832
2833         case 1:
2834             if ((sr=test_mii_reg(dev, MII_SR, MII_SR_ASSC, true, 2000)) < 0) {
2835                 next_tick = sr & ~TIMER_CB;
2836             } else {
2837                 lp->media = SPD_DET;
2838                 lp->local_state = 0;
2839                 if (sr) {                         /* Success! */
2840                     lp->tmp = MII_SR_ASSC;
2841                     anlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
2842                     ana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2843                     if (!(anlpa & MII_ANLPA_RF) &&
2844                          (cap = anlpa & MII_ANLPA_TAF & ana)) {
2845                         if (cap & MII_ANA_100M) {
2846                             lp->fdx = (ana & anlpa & MII_ANA_FDAM & MII_ANA_100M) != 0;
2847                             lp->media = _100Mb;
2848                         } else if (cap & MII_ANA_10M) {
2849                             lp->fdx = (ana & anlpa & MII_ANA_FDAM & MII_ANA_10M) != 0;
2850
2851                             lp->media = _10Mb;
2852                         }
2853                     }
2854                 }                       /* Auto Negotiation failed to finish */
2855                 next_tick = dc21140m_autoconf(dev);
2856             }                           /* Auto Negotiation failed to start */
2857             break;
2858         }
2859         break;
2860
2861     case SPD_DET:                              /* Choose 10Mb/s or 100Mb/s */
2862         if (lp->timeout < 0) {
2863             lp->tmp = (lp->phy[lp->active].id ? MII_SR_LKS :
2864                                                   (~gep_rd(dev) & GEP_LNP));
2865             SET_100Mb_PDET;
2866         }
2867         if ((slnk = test_for_100Mb(dev, 6500)) < 0) {
2868             next_tick = slnk & ~TIMER_CB;
2869         } else {
2870             if (is_spd_100(dev) && is_100_up(dev)) {
2871                 lp->media = _100Mb;
2872             } else if ((!is_spd_100(dev) && (is_10_up(dev) & lp->tmp))) {
2873                 lp->media = _10Mb;
2874             } else {
2875                 lp->media = NC;
2876             }
2877             next_tick = dc21140m_autoconf(dev);
2878         }
2879         break;
2880
2881     case _100Mb:                               /* Set 100Mb/s */
2882         next_tick = 3000;
2883         if (!lp->tx_enable) {
2884             SET_100Mb;
2885             de4x5_init_connection(dev);
2886         } else {
2887             if (!lp->linkOK && (lp->autosense == AUTO)) {
2888                 if (!is_100_up(dev) || (!lp->useSROM && !is_spd_100(dev))) {
2889                     lp->media = INIT;
2890                     lp->tcount++;
2891                     next_tick = DE4X5_AUTOSENSE_MS;
2892                 }
2893             }
2894         }
2895         break;
2896
2897     case BNC:
2898     case AUI:
2899     case _10Mb:                                /* Set 10Mb/s */
2900         next_tick = 3000;
2901         if (!lp->tx_enable) {
2902             SET_10Mb;
2903             de4x5_init_connection(dev);
2904         } else {
2905             if (!lp->linkOK && (lp->autosense == AUTO)) {
2906                 if (!is_10_up(dev) || (!lp->useSROM && is_spd_100(dev))) {
2907                     lp->media = INIT;
2908                     lp->tcount++;
2909                     next_tick = DE4X5_AUTOSENSE_MS;
2910                 }
2911             }
2912         }
2913         break;
2914
2915     case NC:
2916         if (lp->media != lp->c_media) {
2917             de4x5_dbg_media(dev);
2918             lp->c_media = lp->media;
2919         }
2920         lp->media = INIT;
2921         lp->tx_enable = false;
2922         break;
2923     }
2924
2925     return next_tick;
2926 }
2927
2928 /*
2929 ** This routine may be merged into dc21140m_autoconf() sometime as I'm
2930 ** changing how I figure out the media - but trying to keep it backwards
2931 ** compatible with the de500-xa and de500-aa.
2932 ** Whether it's BNC, AUI, SYM or MII is sorted out in the infoblock
2933 ** functions and set during de4x5_mac_port() and/or de4x5_reset_phy().
2934 ** This routine just has to figure out whether 10Mb/s or 100Mb/s is
2935 ** active.
2936 ** When autonegotiation is working, the ANS part searches the SROM for
2937 ** the highest common speed (TP) link that both can run and if that can
2938 ** be full duplex. That infoblock is executed and then the link speed set.
2939 **
2940 ** Only _10Mb and _100Mb are tested here.
2941 */
2942 static int
2943 dc2114x_autoconf(struct net_device *dev)
2944 {
2945     struct de4x5_private *lp = netdev_priv(dev);
2946     u_long iobase = dev->base_addr;
2947     s32 cr, anlpa, ana, cap, irqs, irq_mask, imr, omr, slnk, sr, sts;
2948     int next_tick = DE4X5_AUTOSENSE_MS;
2949
2950     switch (lp->media) {
2951     case INIT:
2952         if (lp->timeout < 0) {
2953             DISABLE_IRQs;
2954             lp->tx_enable = false;
2955             lp->linkOK = 0;
2956             lp->timeout = -1;
2957             de4x5_save_skbs(dev);            /* Save non transmitted skb's */
2958             if (lp->params.autosense & ~AUTO) {
2959                 srom_map_media(dev);         /* Fixed media requested      */
2960                 if (lp->media != lp->params.autosense) {
2961                     lp->tcount++;
2962                     lp->media = INIT;
2963                     return next_tick;
2964                 }
2965                 lp->media = INIT;
2966             }
2967         }
2968         if ((next_tick = de4x5_reset_phy(dev)) < 0) {
2969             next_tick &= ~TIMER_CB;
2970         } else {
2971             if (lp->autosense == _100Mb) {
2972                 lp->media = _100Mb;
2973             } else if (lp->autosense == _10Mb) {
2974                 lp->media = _10Mb;
2975             } else if (lp->autosense == TP) {
2976                 lp->media = TP;
2977             } else if (lp->autosense == BNC) {
2978                 lp->media = BNC;
2979             } else if (lp->autosense == AUI) {
2980                 lp->media = AUI;
2981             } else {
2982                 lp->media = SPD_DET;
2983                 if ((lp->infoblock_media == ANS) &&
2984                                     ((sr=is_anc_capable(dev)) & MII_SR_ANC)) {
2985                     ana = (((sr >> 6) & MII_ANA_TAF) | MII_ANA_CSMA);
2986                     ana &= (lp->fdx ? ~0 : ~MII_ANA_FDAM);
2987                     mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2988                     lp->media = ANS;
2989                 }
2990             }
2991             lp->local_state = 0;
2992             next_tick = dc2114x_autoconf(dev);
2993         }
2994         break;
2995
2996     case ANS:
2997         switch (lp->local_state) {
2998         case 0:
2999             if (lp->timeout < 0) {
3000                 mii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
3001             }
3002             cr = test_mii_reg(dev, MII_CR, MII_CR_RAN, false, 500);
3003             if (cr < 0) {
3004                 next_tick = cr & ~TIMER_CB;
3005             } else {
3006                 if (cr) {
3007                     lp->local_state = 0;
3008                     lp->media = SPD_DET;
3009                 } else {
3010                     lp->local_state++;
3011                 }
3012                 next_tick = dc2114x_autoconf(dev);
3013             }
3014             break;
3015
3016         case 1:
3017             sr = test_mii_reg(dev, MII_SR, MII_SR_ASSC, true, 2000);
3018             if (sr < 0) {
3019                 next_tick = sr & ~TIMER_CB;
3020             } else {
3021                 lp->media = SPD_DET;
3022                 lp->local_state = 0;
3023                 if (sr) {                         /* Success! */
3024                     lp->tmp = MII_SR_ASSC;
3025                     anlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
3026                     ana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
3027                     if (!(anlpa & MII_ANLPA_RF) &&
3028                          (cap = anlpa & MII_ANLPA_TAF & ana)) {
3029                         if (cap & MII_ANA_100M) {
3030                             lp->fdx = (ana & anlpa & MII_ANA_FDAM & MII_ANA_100M) != 0;
3031                             lp->media = _100Mb;
3032                         } else if (cap & MII_ANA_10M) {
3033                             lp->fdx = (ana & anlpa & MII_ANA_FDAM & MII_ANA_10M) != 0;
3034                             lp->media = _10Mb;
3035                         }
3036                     }
3037                 }                       /* Auto Negotiation failed to finish */
3038                 next_tick = dc2114x_autoconf(dev);
3039             }                           /* Auto Negotiation failed to start  */
3040             break;
3041         }
3042         break;
3043
3044     case AUI:
3045         if (!lp->tx_enable) {
3046             if (lp->timeout < 0) {
3047                 omr = inl(DE4X5_OMR);   /* Set up half duplex for AUI        */
3048                 outl(omr & ~OMR_FDX, DE4X5_OMR);
3049             }
3050             irqs = 0;
3051             irq_mask = 0;
3052             sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
3053             if (sts < 0) {
3054                 next_tick = sts & ~TIMER_CB;
3055             } else {
3056                 if (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
3057                     lp->media = BNC;
3058                     next_tick = dc2114x_autoconf(dev);
3059                 } else {
3060                     lp->local_state = 1;
3061                     de4x5_init_connection(dev);
3062                 }
3063             }
3064         } else if (!lp->linkOK && (lp->autosense == AUTO)) {
3065             lp->media = AUI_SUSPECT;
3066             next_tick = 3000;
3067         }
3068         break;
3069
3070     case AUI_SUSPECT:
3071         next_tick = de4x5_suspect_state(dev, 1000, AUI, ping_media, dc2114x_autoconf);
3072         break;
3073
3074     case BNC:
3075         switch (lp->local_state) {
3076         case 0:
3077             if (lp->timeout < 0) {
3078                 omr = inl(DE4X5_OMR);          /* Set up half duplex for BNC */
3079                 outl(omr & ~OMR_FDX, DE4X5_OMR);
3080             }
3081             irqs = 0;
3082             irq_mask = 0;
3083             sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
3084             if (sts < 0) {
3085                 next_tick = sts & ~TIMER_CB;
3086             } else {
3087                 lp->local_state++;             /* Ensure media connected */
3088                 next_tick = dc2114x_autoconf(dev);
3089             }
3090             break;
3091
3092         case 1:
3093             if (!lp->tx_enable) {
3094                 if ((sts = ping_media(dev, 3000)) < 0) {
3095                     next_tick = sts & ~TIMER_CB;
3096                 } else {
3097                     if (sts) {
3098                         lp->local_state = 0;
3099                         lp->tcount++;
3100                         lp->media = INIT;
3101                     } else {
3102                         de4x5_init_connection(dev);
3103                     }
3104                 }
3105             } else if (!lp->linkOK && (lp->autosense == AUTO)) {
3106                 lp->media = BNC_SUSPECT;
3107                 next_tick = 3000;
3108             }
3109             break;
3110         }
3111         break;
3112
3113     case BNC_SUSPECT:
3114         next_tick = de4x5_suspect_state(dev, 1000, BNC, ping_media, dc2114x_autoconf);
3115         break;
3116
3117     case SPD_DET:                              /* Choose 10Mb/s or 100Mb/s */
3118           if (srom_map_media(dev) < 0) {
3119               lp->tcount++;
3120               lp->media = INIT;
3121               return next_tick;
3122           }
3123           if (lp->media == _100Mb) {
3124               if ((slnk = test_for_100Mb(dev, 6500)) < 0) {
3125                   lp->media = SPD_DET;
3126                   return  (slnk & ~TIMER_CB);
3127               }
3128           } else {
3129               if (wait_for_link(dev) < 0) {
3130                   lp->media = SPD_DET;
3131                   return PDET_LINK_WAIT;
3132               }
3133           }
3134           if (lp->media == ANS) {           /* Do MII parallel detection */
3135               if (is_spd_100(dev)) {
3136                   lp->media = _100Mb;
3137               } else {
3138                   lp->media = _10Mb;
3139               }
3140               next_tick = dc2114x_autoconf(dev);
3141           } else if (((lp->media == _100Mb) && is_100_up(dev)) ||
3142                      (((lp->media == _10Mb) || (lp->media == TP) ||
3143                        (lp->media == BNC)   || (lp->media == AUI)) &&
3144                       is_10_up(dev))) {
3145               next_tick = dc2114x_autoconf(dev);
3146           } else {
3147               lp->tcount++;
3148               lp->media = INIT;
3149           }
3150           break;
3151
3152     case _10Mb:
3153         next_tick = 3000;
3154         if (!lp->tx_enable) {
3155             SET_10Mb;
3156             de4x5_init_connection(dev);
3157         } else {
3158             if (!lp->linkOK && (lp->autosense == AUTO)) {
3159                 if (!is_10_up(dev) || (!lp->useSROM && is_spd_100(dev))) {
3160                     lp->media = INIT;
3161                     lp->tcount++;
3162                     next_tick = DE4X5_AUTOSENSE_MS;
3163                 }
3164             }
3165         }
3166         break;
3167
3168     case _100Mb:
3169         next_tick = 3000;
3170         if (!lp->tx_enable) {
3171             SET_100Mb;
3172             de4x5_init_connection(dev);
3173         } else {
3174             if (!lp->linkOK && (lp->autosense == AUTO)) {
3175                 if (!is_100_up(dev) || (!lp->useSROM && !is_spd_100(dev))) {
3176                     lp->media = INIT;
3177                     lp->tcount++;
3178                     next_tick = DE4X5_AUTOSENSE_MS;
3179                 }
3180             }
3181         }
3182         break;
3183
3184     default:
3185         lp->tcount++;
3186 printk("Huh?: media:%02x\n", lp->media);
3187         lp->media = INIT;
3188         break;
3189     }
3190
3191     return next_tick;
3192 }
3193
3194 static int
3195 srom_autoconf(struct net_device *dev)
3196 {
3197     struct de4x5_private *lp = netdev_priv(dev);
3198
3199     return lp->infoleaf_fn(dev);
3200 }
3201
3202 /*
3203 ** This mapping keeps the original media codes and FDX flag unchanged.
3204 ** While it isn't strictly necessary, it helps me for the moment...
3205 ** The early return avoids a media state / SROM media space clash.
3206 */
3207 static int
3208 srom_map_media(struct net_device *dev)
3209 {
3210     struct de4x5_private *lp = netdev_priv(dev);
3211
3212     lp->fdx = false;
3213     if (lp->infoblock_media == lp->media)
3214       return 0;
3215
3216     switch(lp->infoblock_media) {
3217       case SROM_10BASETF:
3218         if (!lp->params.fdx) return -1;
3219         lp->fdx = true;
3220       case SROM_10BASET:
3221         if (lp->params.fdx && !lp->fdx) return -1;
3222         if ((lp->chipset == DC21140) || ((lp->chipset & ~0x00ff) == DC2114x)) {
3223             lp->media = _10Mb;
3224         } else {
3225             lp->media = TP;
3226         }
3227         break;
3228
3229       case SROM_10BASE2:
3230         lp->media = BNC;
3231         break;
3232
3233       case SROM_10BASE5:
3234         lp->media = AUI;
3235         break;
3236
3237       case SROM_100BASETF:
3238         if (!lp->params.fdx) return -1;
3239         lp->fdx = true;
3240       case SROM_100BASET:
3241         if (lp->params.fdx && !lp->fdx) return -1;
3242         lp->media = _100Mb;
3243         break;
3244
3245       case SROM_100BASET4:
3246         lp->media = _100Mb;
3247         break;
3248
3249       case SROM_100BASEFF:
3250         if (!lp->params.fdx) return -1;
3251         lp->fdx = true;
3252       case SROM_100BASEF:
3253         if (lp->params.fdx && !lp->fdx) return -1;
3254         lp->media = _100Mb;
3255         break;
3256
3257       case ANS:
3258         lp->media = ANS;
3259         lp->fdx = lp->params.fdx;
3260         break;
3261
3262       default:
3263         printk("%s: Bad media code [%d] detected in SROM!\n", dev->name,
3264                                                           lp->infoblock_media);
3265         return -1;
3266         break;
3267     }
3268
3269     return 0;
3270 }
3271
3272 static void
3273 de4x5_init_connection(struct net_device *dev)
3274 {
3275     struct de4x5_private *lp = netdev_priv(dev);
3276     u_long iobase = dev->base_addr;
3277     u_long flags = 0;
3278
3279     if (lp->media != lp->c_media) {
3280         de4x5_dbg_media(dev);
3281         lp->c_media = lp->media;          /* Stop scrolling media messages */
3282     }
3283
3284     spin_lock_irqsave(&lp->lock, flags);
3285     de4x5_rst_desc_ring(dev);
3286     de4x5_setup_intr(dev);
3287     lp->tx_enable = true;
3288     spin_unlock_irqrestore(&lp->lock, flags);
3289     outl(POLL_DEMAND, DE4X5_TPD);
3290
3291     netif_wake_queue(dev);
3292
3293     return;
3294 }
3295
3296 /*
3297 ** General PHY reset function. Some MII devices don't reset correctly
3298 ** since their MII address pins can float at voltages that are dependent
3299 ** on the signal pin use. Do a double reset to ensure a reset.
3300 */
3301 static int
3302 de4x5_reset_phy(struct net_device *dev)
3303 {
3304     struct de4x5_private *lp = netdev_priv(dev);
3305     u_long iobase = dev->base_addr;
3306     int next_tick = 0;
3307
3308     if ((lp->useSROM) || (lp->phy[lp->active].id)) {
3309         if (lp->timeout < 0) {
3310             if (lp->useSROM) {
3311                 if (lp->phy[lp->active].rst) {
3312                     srom_exec(dev, lp->phy[lp->active].rst);
3313                     srom_exec(dev, lp->phy[lp->active].rst);
3314                 } else if (lp->rst) {          /* Type 5 infoblock reset */
3315                     srom_exec(dev, lp->rst);
3316                     srom_exec(dev, lp->rst);
3317                 }
3318             } else {
3319                 PHY_HARD_RESET;
3320             }
3321             if (lp->useMII) {
3322                 mii_wr(MII_CR_RST, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
3323             }
3324         }
3325         if (lp->useMII) {
3326             next_tick = test_mii_reg(dev, MII_CR, MII_CR_RST, false, 500);
3327         }
3328     } else if (lp->chipset == DC21140) {
3329         PHY_HARD_RESET;
3330     }
3331
3332     return next_tick;
3333 }
3334
3335 static int
3336 test_media(struct net_device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec)
3337 {
3338     struct de4x5_private *lp = netdev_priv(dev);
3339     u_long iobase = dev->base_addr;
3340     s32 sts, csr12;
3341
3342     if (lp->timeout < 0) {
3343         lp->timeout = msec/100;
3344         if (!lp->useSROM) {      /* Already done if by SROM, else dc2104[01] */
3345             reset_init_sia(dev, csr13, csr14, csr15);
3346         }
3347
3348         /* set up the interrupt mask */
3349         outl(irq_mask, DE4X5_IMR);
3350
3351         /* clear all pending interrupts */
3352         sts = inl(DE4X5_STS);
3353         outl(sts, DE4X5_STS);
3354
3355         /* clear csr12 NRA and SRA bits */
3356         if ((lp->chipset == DC21041) || lp->useSROM) {
3357             csr12 = inl(DE4X5_SISR);
3358             outl(csr12, DE4X5_SISR);
3359         }
3360     }
3361
3362     sts = inl(DE4X5_STS) & ~TIMER_CB;
3363
3364     if (!(sts & irqs) && --lp->timeout) {
3365         sts = 100 | TIMER_CB;
3366     } else {
3367         lp->timeout = -1;
3368     }
3369
3370     return sts;
3371 }
3372
3373 static int
3374 test_tp(struct net_device *dev, s32 msec)
3375 {
3376     struct de4x5_private *lp = netdev_priv(dev);
3377     u_long iobase = dev->base_addr;
3378     int sisr;
3379
3380     if (lp->timeout < 0) {
3381         lp->timeout = msec/100;
3382     }
3383
3384     sisr = (inl(DE4X5_SISR) & ~TIMER_CB) & (SISR_LKF | SISR_NCR);
3385
3386     if (sisr && --lp->timeout) {
3387         sisr = 100 | TIMER_CB;
3388     } else {
3389         lp->timeout = -1;
3390     }
3391
3392     return sisr;
3393 }
3394
3395 /*
3396 ** Samples the 100Mb Link State Signal. The sample interval is important
3397 ** because too fast a rate can give erroneous results and confuse the
3398 ** speed sense algorithm.
3399 */
3400 #define SAMPLE_INTERVAL 500  /* ms */
3401 #define SAMPLE_DELAY    2000 /* ms */
3402 static int
3403 test_for_100Mb(struct net_device *dev, int msec)
3404 {
3405     struct de4x5_private *lp = netdev_priv(dev);
3406     int gep = 0, ret = ((lp->chipset & ~0x00ff)==DC2114x? -1 :GEP_SLNK);
3407
3408     if (lp->timeout < 0) {
3409         if ((msec/SAMPLE_INTERVAL) <= 0) return 0;
3410         if (msec > SAMPLE_DELAY) {
3411             lp->timeout = (msec - SAMPLE_DELAY)/SAMPLE_INTERVAL;
3412             gep = SAMPLE_DELAY | TIMER_CB;
3413             return gep;
3414         } else {
3415             lp->timeout = msec/SAMPLE_INTERVAL;
3416         }
3417     }
3418
3419     if (lp->phy[lp->active].id || lp->useSROM) {
3420         gep = is_100_up(dev) | is_spd_100(dev);
3421     } else {
3422         gep = (~gep_rd(dev) & (GEP_SLNK | GEP_LNP));
3423     }
3424     if (!(gep & ret) && --lp->timeout) {
3425         gep = SAMPLE_INTERVAL | TIMER_CB;
3426     } else {
3427         lp->timeout = -1;
3428     }
3429
3430     return gep;
3431 }
3432
3433 static int
3434 wait_for_link(struct net_device *dev)
3435 {
3436     struct de4x5_private *lp = netdev_priv(dev);
3437
3438     if (lp->timeout < 0) {
3439         lp->timeout = 1;
3440     }
3441
3442     if (lp->timeout--) {
3443         return TIMER_CB;
3444     } else {
3445         lp->timeout = -1;
3446     }
3447
3448     return 0;
3449 }
3450
3451 /*
3452 **
3453 **
3454 */
3455 static int
3456 test_mii_reg(struct net_device *dev, int reg, int mask, bool pol, long msec)
3457 {
3458     struct de4x5_private *lp = netdev_priv(dev);
3459     int test;
3460     u_long iobase = dev->base_addr;
3461
3462     if (lp->timeout < 0) {
3463         lp->timeout = msec/100;
3464     }
3465
3466     reg = mii_rd((u_char)reg, lp->phy[lp->active].addr, DE4X5_MII) & mask;
3467     test = (reg ^ (pol ? ~0 : 0)) & mask;
3468
3469     if (test && --lp->timeout) {
3470         reg = 100 | TIMER_CB;
3471     } else {
3472         lp->timeout = -1;
3473     }
3474
3475     return reg;
3476 }
3477
3478 static int
3479 is_spd_100(struct net_device *dev)
3480 {
3481     struct de4x5_private *lp = netdev_priv(dev);
3482     u_long iobase = dev->base_addr;
3483     int spd;
3484
3485     if (lp->useMII) {
3486         spd = mii_rd(lp->phy[lp->active].spd.reg, lp->phy[lp->active].addr, DE4X5_MII);
3487         spd = ~(spd ^ lp->phy[lp->active].spd.value);
3488         spd &= lp->phy[lp->active].spd.mask;
3489     } else if (!lp->useSROM) {                      /* de500-xa */
3490         spd = ((~gep_rd(dev)) & GEP_SLNK);
3491     } else {
3492         if ((lp->ibn == 2) || !lp->asBitValid)
3493             return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
3494
3495         spd = (lp->asBitValid & (lp->asPolarity ^ (gep_rd(dev) & lp->asBit))) |
3496                   (lp->linkOK & ~lp->asBitValid);
3497     }
3498
3499     return spd;
3500 }
3501
3502 static int
3503 is_100_up(struct net_device *dev)
3504 {
3505     struct de4x5_private *lp = netdev_priv(dev);
3506     u_long iobase = dev->base_addr;
3507
3508     if (lp->useMII) {
3509         /* Double read for sticky bits & temporary drops */
3510         mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
3511         return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
3512     } else if (!lp->useSROM) {                       /* de500-xa */
3513         return ((~gep_rd(dev)) & GEP_SLNK);
3514     } else {
3515         if ((lp->ibn == 2) || !lp->asBitValid)
3516             return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
3517
3518         return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
3519                 (lp->linkOK & ~lp->asBitValid));
3520     }
3521 }
3522
3523 static int
3524 is_10_up(struct net_device *dev)
3525 {
3526     struct de4x5_private *lp = netdev_priv(dev);
3527     u_long iobase = dev->base_addr;
3528
3529     if (lp->useMII) {
3530         /* Double read for sticky bits & temporary drops */
3531         mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
3532         return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
3533     } else if (!lp->useSROM) {                       /* de500-xa */
3534         return ((~gep_rd(dev)) & GEP_LNP);
3535     } else {
3536         if ((lp->ibn == 2) || !lp->asBitValid)
3537             return (((lp->chipset & ~0x00ff) == DC2114x) ?
3538                     (~inl(DE4X5_SISR)&SISR_LS10):
3539                     0);
3540
3541         return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
3542                 (lp->linkOK & ~lp->asBitValid));
3543     }
3544 }
3545
3546 static int
3547 is_anc_capable(struct net_device *dev)
3548 {
3549     struct de4x5_private *lp = netdev_priv(dev);
3550     u_long iobase = dev->base_addr;
3551
3552     if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
3553         return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII));
3554     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
3555         return (inl(DE4X5_SISR) & SISR_LPN) >> 12;
3556     } else {
3557         return 0;
3558     }
3559 }
3560
3561 /*
3562 ** Send a packet onto the media and watch for send errors that indicate the
3563 ** media is bad or unconnected.
3564 */
3565 static int
3566 ping_media(struct net_device *dev, int msec)
3567 {
3568     struct de4x5_private *lp = netdev_priv(dev);
3569     u_long iobase = dev->base_addr;
3570     int sisr;
3571
3572     if (lp->timeout < 0) {
3573         lp->timeout = msec/100;
3574
3575         lp->tmp = lp->tx_new;                /* Remember the ring position */
3576         load_packet(dev, lp->frame, TD_LS | TD_FS | sizeof(lp->frame), (struct sk_buff *)1);
3577         lp->tx_new = (++lp->tx_new) % lp->txRingSize;
3578         outl(POLL_DEMAND, DE4X5_TPD);
3579     }
3580
3581     sisr = inl(DE4X5_SISR);
3582
3583     if ((!(sisr & SISR_NCR)) &&
3584         ((s32)le32_to_cpu(lp->tx_ring[lp->tmp].status) < 0) &&
3585          (--lp->timeout)) {
3586         sisr = 100 | TIMER_CB;
3587     } else {
3588         if ((!(sisr & SISR_NCR)) &&
3589             !(le32_to_cpu(lp->tx_ring[lp->tmp].status) & (T_OWN | TD_ES)) &&
3590             lp->timeout) {
3591             sisr = 0;
3592         } else {
3593             sisr = 1;
3594         }
3595         lp->timeout = -1;
3596     }
3597
3598     return sisr;
3599 }
3600
3601 /*
3602 ** This function does 2 things: on Intels it kmalloc's another buffer to
3603 ** replace the one about to be passed up. On Alpha's it kmallocs a buffer
3604 ** into which the packet is copied.
3605 */
3606 static struct sk_buff *
3607 de4x5_alloc_rx_buff(struct net_device *dev, int index, int len)
3608 {
3609     struct de4x5_private *lp = netdev_priv(dev);
3610     struct sk_buff *p;
3611
3612 #if !defined(__alpha__) && !defined(__powerpc__) && !defined(CONFIG_SPARC) && !defined(DE4X5_DO_MEMCPY)
3613     struct sk_buff *ret;
3614     u_long i=0, tmp;
3615
3616     p = dev_alloc_skb(IEEE802_3_SZ + DE4X5_ALIGN + 2);
3617     if (!p) return NULL;
3618
3619     tmp = virt_to_bus(p->data);
3620     i = ((tmp + DE4X5_ALIGN) & ~DE4X5_ALIGN) - tmp;
3621     skb_reserve(p, i);
3622     lp->rx_ring[index].buf = cpu_to_le32(tmp + i);
3623
3624     ret = lp->rx_skb[index];
3625     lp->rx_skb[index] = p;
3626
3627     if ((u_long) ret > 1) {
3628         skb_put(ret, len);
3629     }
3630
3631     return ret;
3632
3633 #else
3634     if (lp->state != OPEN) return (struct sk_buff *)1; /* Fake out the open */
3635
3636     p = dev_alloc_skb(len + 2);
3637     if (!p) return NULL;
3638
3639     skb_reserve(p, 2);                                 /* Align */
3640     if (index < lp->rx_old) {                          /* Wrapped buffer */
3641         short tlen = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
3642         memcpy(skb_put(p,tlen),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,tlen);
3643         memcpy(skb_put(p,len-tlen),lp->rx_bufs,len-tlen);
3644     } else {                                           /* Linear buffer */
3645         memcpy(skb_put(p,len),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,len);
3646     }
3647
3648     return p;
3649 #endif
3650 }
3651
3652 static void
3653 de4x5_free_rx_buffs(struct net_device *dev)
3654 {
3655     struct de4x5_private *lp = netdev_priv(dev);
3656     int i;
3657
3658     for (i=0; i<lp->rxRingSize; i++) {
3659         if ((u_long) lp->rx_skb[i] > 1) {
3660             dev_kfree_skb(lp->rx_skb[i]);
3661         }
3662         lp->rx_ring[i].status = 0;
3663         lp->rx_skb[i] = (struct sk_buff *)1;    /* Dummy entry */
3664     }
3665
3666     return;
3667 }
3668
3669 static void
3670 de4x5_free_tx_buffs(struct net_device *dev)
3671 {
3672     struct de4x5_private *lp = netdev_priv(dev);
3673     int i;
3674
3675     for (i=0; i<lp->txRingSize; i++) {
3676         if (lp->tx_skb[i])
3677             de4x5_free_tx_buff(lp, i);
3678         lp->tx_ring[i].status = 0;
3679     }
3680
3681     /* Unload the locally queued packets */
3682     while (lp->cache.skb) {
3683         dev_kfree_skb(de4x5_get_cache(dev));
3684     }
3685
3686     return;
3687 }
3688
3689 /*
3690 ** When a user pulls a connection, the DECchip can end up in a
3691 ** 'running - waiting for end of transmission' state. This means that we
3692 ** have to perform a chip soft reset to ensure that we can synchronize
3693 ** the hardware and software and make any media probes using a loopback
3694 ** packet meaningful.
3695 */
3696 static void
3697 de4x5_save_skbs(struct net_device *dev)
3698 {
3699     struct de4x5_private *lp = netdev_priv(dev);
3700     u_long iobase = dev->base_addr;
3701     s32 omr;
3702
3703     if (!lp->cache.save_cnt) {
3704         STOP_DE4X5;
3705         de4x5_tx(dev);                          /* Flush any sent skb's */
3706         de4x5_free_tx_buffs(dev);
3707         de4x5_cache_state(dev, DE4X5_SAVE_STATE);
3708         de4x5_sw_reset(dev);
3709         de4x5_cache_state(dev, DE4X5_RESTORE_STATE);
3710         lp->cache.save_cnt++;
3711         START_DE4X5;
3712     }
3713
3714     return;
3715 }
3716
3717 static void
3718 de4x5_rst_desc_ring(struct net_device *dev)
3719 {
3720     struct de4x5_private *lp = netdev_priv(dev);
3721     u_long iobase = dev->base_addr;
3722     int i;
3723     s32 omr;
3724
3725     if (lp->cache.save_cnt) {
3726         STOP_DE4X5;
3727         outl(lp->dma_rings, DE4X5_RRBA);
3728         outl(lp->dma_rings + NUM_RX_DESC * sizeof(struct de4x5_desc),
3729              DE4X5_TRBA);
3730
3731         lp->rx_new = lp->rx_old = 0;
3732         lp->tx_new = lp->tx_old = 0;
3733
3734         for (i = 0; i < lp->rxRingSize; i++) {
3735             lp->rx_ring[i].status = cpu_to_le32(R_OWN);
3736         }
3737
3738         for (i = 0; i < lp->txRingSize; i++) {
3739             lp->tx_ring[i].status = cpu_to_le32(0);
3740         }
3741
3742         barrier();
3743         lp->cache.save_cnt--;
3744         START_DE4X5;
3745     }
3746
3747     return;
3748 }
3749
3750 static void
3751 de4x5_cache_state(struct net_device *dev, int flag)
3752 {
3753     struct de4x5_private *lp = netdev_priv(dev);
3754     u_long iobase = dev->base_addr;
3755
3756     switch(flag) {
3757       case DE4X5_SAVE_STATE:
3758         lp->cache.csr0 = inl(DE4X5_BMR);
3759         lp->cache.csr6 = (inl(DE4X5_OMR) & ~(OMR_ST | OMR_SR));
3760         lp->cache.csr7 = inl(DE4X5_IMR);
3761         break;
3762
3763       case DE4X5_RESTORE_STATE:
3764         outl(lp->cache.csr0, DE4X5_BMR);
3765         outl(lp->cache.csr6, DE4X5_OMR);
3766         outl(lp->cache.csr7, DE4X5_IMR);
3767         if (lp->chipset == DC21140) {
3768             gep_wr(lp->cache.gepc, dev);
3769             gep_wr(lp->cache.gep, dev);
3770         } else {
3771             reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14,
3772                                                               lp->cache.csr15);
3773         }
3774         break;
3775     }
3776
3777     return;
3778 }
3779
3780 static void
3781 de4x5_put_cache(struct net_device *dev, struct sk_buff *skb)
3782 {
3783     struct de4x5_private *lp = netdev_priv(dev);
3784     struct sk_buff *p;
3785
3786     if (lp->cache.skb) {
3787         for (p=lp->cache.skb; p->next; p=p->next);
3788         p->next = skb;
3789     } else {
3790         lp->cache.skb = skb;
3791     }
3792     skb->next = NULL;
3793
3794     return;
3795 }
3796
3797 static void
3798 de4x5_putb_cache(struct net_device *dev, struct sk_buff *skb)
3799 {
3800     struct de4x5_private *lp = netdev_priv(dev);
3801     struct sk_buff *p = lp->cache.skb;
3802
3803     lp->cache.skb = skb;
3804     skb->next = p;
3805
3806     return;
3807 }
3808
3809 static struct sk_buff *
3810 de4x5_get_cache(struct net_device *dev)
3811 {
3812     struct de4x5_private *lp = netdev_priv(dev);
3813     struct sk_buff *p = lp->cache.skb;
3814
3815     if (p) {
3816         lp->cache.skb = p->next;
3817         p->next = NULL;
3818     }
3819
3820     return p;
3821 }
3822
3823 /*
3824 ** Check the Auto Negotiation State. Return OK when a link pass interrupt
3825 ** is received and the auto-negotiation status is NWAY OK.
3826 */
3827 static int
3828 test_ans(struct net_device *dev, s32 irqs, s32 irq_mask, s32 msec)
3829 {
3830     struct de4x5_private *lp = netdev_priv(dev);
3831     u_long iobase = dev->base_addr;
3832     s32 sts, ans;
3833
3834     if (lp->timeout < 0) {
3835         lp->timeout = msec/100;
3836         outl(irq_mask, DE4X5_IMR);
3837
3838         /* clear all pending interrupts */
3839         sts = inl(DE4X5_STS);
3840         outl(sts, DE4X5_STS);
3841     }
3842
3843     ans = inl(DE4X5_SISR) & SISR_ANS;
3844     sts = inl(DE4X5_STS) & ~TIMER_CB;
3845
3846     if (!(sts & irqs) && (ans ^ ANS_NWOK) && --lp->timeout) {
3847         sts = 100 | TIMER_CB;
3848     } else {
3849         lp->timeout = -1;
3850     }
3851
3852     return sts;
3853 }
3854
3855 static void
3856 de4x5_setup_intr(struct net_device *dev)
3857 {
3858     struct de4x5_private *lp = netdev_priv(dev);
3859     u_long iobase = dev->base_addr;
3860     s32 imr, sts;
3861
3862     if (inl(DE4X5_OMR) & OMR_SR) {   /* Only unmask if TX/RX is enabled */
3863         imr = 0;
3864         UNMASK_IRQs;
3865         sts = inl(DE4X5_STS);        /* Reset any pending (stale) interrupts */
3866         outl(sts, DE4X5_STS);
3867         ENABLE_IRQs;
3868     }
3869
3870     return;
3871 }
3872
3873 /*
3874 **
3875 */
3876 static void
3877 reset_init_sia(struct net_device *dev, s32 csr13, s32 csr14, s32 csr15)
3878 {
3879     struct de4x5_private *lp = netdev_priv(dev);
3880     u_long iobase = dev->base_addr;
3881
3882     RESET_SIA;
3883     if (lp->useSROM) {
3884         if (lp->ibn == 3) {
3885             srom_exec(dev, lp->phy[lp->active].rst);
3886             srom_exec(dev, lp->phy[lp->active].gep);
3887             outl(1, DE4X5_SICR);
3888             return;
3889         } else {
3890             csr15 = lp->cache.csr15;
3891             csr14 = lp->cache.csr14;
3892             csr13 = lp->cache.csr13;
3893             outl(csr15 | lp->cache.gepc, DE4X5_SIGR);
3894             outl(csr15 | lp->cache.gep, DE4X5_SIGR);
3895         }
3896     } else {
3897         outl(csr15, DE4X5_SIGR);
3898     }
3899     outl(csr14, DE4X5_STRR);
3900     outl(csr13, DE4X5_SICR);
3901
3902     mdelay(10);
3903
3904     return;
3905 }
3906
3907 /*
3908 ** Create a loopback ethernet packet
3909 */
3910 static void
3911 create_packet(struct net_device *dev, char *frame, int len)
3912 {
3913     int i;
3914     char *buf = frame;
3915
3916     for (i=0; i<ETH_ALEN; i++) {             /* Use this source address */
3917         *buf++ = dev->dev_addr[i];
3918     }
3919     for (i=0; i<ETH_ALEN; i++) {             /* Use this destination address */
3920         *buf++ = dev->dev_addr[i];
3921     }
3922
3923     *buf++ = 0;                              /* Packet length (2 bytes) */
3924     *buf++ = 1;
3925
3926     return;
3927 }
3928
3929 /*
3930 ** Look for a particular board name in the EISA configuration space
3931 */
3932 static int
3933 EISA_signature(char *name, struct device *device)
3934 {
3935     int i, status = 0, siglen = ARRAY_SIZE(de4x5_signatures);
3936     struct eisa_device *edev;
3937
3938     *name = '\0';
3939     edev = to_eisa_device (device);
3940     i = edev->id.driver_data;
3941
3942     if (i >= 0 && i < siglen) {
3943             strcpy (name, de4x5_signatures[i]);
3944             status = 1;
3945     }
3946
3947     return status;                         /* return the device name string */
3948 }
3949
3950 /*
3951 ** Look for a particular board name in the PCI configuration space
3952 */
3953 static int
3954 PCI_signature(char *name, struct de4x5_private *lp)
3955 {
3956     int i, status = 0, siglen = ARRAY_SIZE(de4x5_signatures);
3957
3958     if (lp->chipset == DC21040) {
3959         strcpy(name, "DE434/5");
3960         return status;
3961     } else {                           /* Search for a DEC name in the SROM */
3962         int i = *((char *)&lp->srom + 19) * 3;
3963         strncpy(name, (char *)&lp->srom + 26 + i, 8);
3964     }
3965     name[8] = '\0';
3966     for (i=0; i<siglen; i++) {
3967         if (strstr(name,de4x5_signatures[i])!=NULL) break;
3968     }
3969     if (i == siglen) {
3970         if (dec_only) {
3971             *name = '\0';
3972         } else {                        /* Use chip name to avoid confusion */
3973             strcpy(name, (((lp->chipset == DC21040) ? "DC21040" :
3974                            ((lp->chipset == DC21041) ? "DC21041" :
3975                             ((lp->chipset == DC21140) ? "DC21140" :
3976                              ((lp->chipset == DC21142) ? "DC21142" :
3977                               ((lp->chipset == DC21143) ? "DC21143" : "UNKNOWN"
3978                              )))))));
3979         }
3980         if (lp->chipset != DC21041) {
3981             lp->useSROM = true;             /* card is not recognisably DEC */
3982         }
3983     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
3984         lp->useSROM = true;
3985     }
3986
3987     return status;
3988 }
3989
3990 /*
3991 ** Set up the Ethernet PROM counter to the start of the Ethernet address on
3992 ** the DC21040, else  read the SROM for the other chips.
3993 ** The SROM may not be present in a multi-MAC card, so first read the
3994 ** MAC address and check for a bad address. If there is a bad one then exit
3995 ** immediately with the prior srom contents intact (the h/w address will
3996 ** be fixed up later).
3997 */
3998 static void
3999 DevicePresent(struct net_device *dev, u_long aprom_addr)
4000 {
4001     int i, j=0;
4002     struct de4x5_private *lp = netdev_priv(dev);
4003
4004     if (lp->chipset == DC21040) {
4005         if (lp->bus == EISA) {
4006             enet_addr_rst(aprom_addr); /* Reset Ethernet Address ROM Pointer */
4007         } else {
4008             outl(0, aprom_addr);       /* Reset Ethernet Address ROM Pointer */
4009         }
4010     } else {                           /* Read new srom */
4011         u_short tmp;
4012         __le16 *p = (__le16 *)((char *)&lp->srom + SROM_HWADD);
4013         for (i=0; i<(ETH_ALEN>>1); i++) {
4014             tmp = srom_rd(aprom_addr, (SROM_HWADD>>1) + i);
4015             j += tmp;   /* for check for 0:0:0:0:0:0 or ff:ff:ff:ff:ff:ff */
4016             *p = cpu_to_le16(tmp);
4017         }
4018         if (j == 0 || j == 3 * 0xffff) {
4019                 /* could get 0 only from all-0 and 3 * 0xffff only from all-1 */
4020                 return;
4021         }
4022
4023         p = (__le16 *)&lp->srom;
4024         for (i=0; i<(sizeof(struct de4x5_srom)>>1); i++) {
4025             tmp = srom_rd(aprom_addr, i);
4026             *p++ = cpu_to_le16(tmp);
4027         }
4028         de4x5_dbg_srom((struct de4x5_srom *)&lp->srom);
4029     }
4030
4031     return;
4032 }
4033
4034 /*
4035 ** Since the write on the Enet PROM register doesn't seem to reset the PROM
4036 ** pointer correctly (at least on my DE425 EISA card), this routine should do
4037 ** it...from depca.c.
4038 */
4039 static void
4040 enet_addr_rst(u_long aprom_addr)
4041 {
4042     union {
4043         struct {
4044             u32 a;
4045             u32 b;
4046         } llsig;
4047         char Sig[sizeof(u32) << 1];
4048     } dev;
4049     short sigLength=0;
4050     s8 data;
4051     int i, j;
4052
4053     dev.llsig.a = ETH_PROM_SIG;
4054     dev.llsig.b = ETH_PROM_SIG;
4055     sigLength = sizeof(u32) << 1;
4056
4057     for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
4058         data = inb(aprom_addr);
4059         if (dev.Sig[j] == data) {    /* track signature */
4060             j++;
4061         } else {                     /* lost signature; begin search again */
4062             if (data == dev.Sig[0]) {  /* rare case.... */
4063                 j=1;
4064             } else {
4065                 j=0;
4066             }
4067         }
4068     }
4069
4070     return;
4071 }
4072
4073 /*
4074 ** For the bad status case and no SROM, then add one to the previous
4075 ** address. However, need to add one backwards in case we have 0xff
4076 ** as one or more of the bytes. Only the last 3 bytes should be checked
4077 ** as the first three are invariant - assigned to an organisation.
4078 */
4079 static int
4080 get_hw_addr(struct net_device *dev)
4081 {
4082     u_long iobase = dev->base_addr;
4083     int broken, i, k, tmp, status = 0;
4084     u_short j,chksum;
4085     struct de4x5_private *lp = netdev_priv(dev);
4086
4087     broken = de4x5_bad_srom(lp);
4088
4089     for (i=0,k=0,j=0;j<3;j++) {
4090         k <<= 1;
4091         if (k > 0xffff) k-=0xffff;
4092
4093         if (lp->bus == PCI) {
4094             if (lp->chipset == DC21040) {
4095                 while ((tmp = inl(DE4X5_APROM)) < 0);
4096                 k += (u_char) tmp;
4097                 dev->dev_addr[i++] = (u_char) tmp;
4098                 while ((tmp = inl(DE4X5_APROM)) < 0);
4099                 k += (u_short) (tmp << 8);
4100                 dev->dev_addr[i++] = (u_char) tmp;
4101             } else if (!broken) {
4102                 dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
4103                 dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
4104             } else if ((broken == SMC) || (broken == ACCTON)) {
4105                 dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
4106                 dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
4107             }
4108         } else {
4109             k += (u_char) (tmp = inb(EISA_APROM));
4110             dev->dev_addr[i++] = (u_char) tmp;
4111             k += (u_short) ((tmp = inb(EISA_APROM)) << 8);
4112             dev->dev_addr[i++] = (u_char) tmp;
4113         }
4114
4115         if (k > 0xffff) k-=0xffff;
4116     }
4117     if (k == 0xffff) k=0;
4118
4119     if (lp->bus == PCI) {
4120         if (lp->chipset == DC21040) {
4121             while ((tmp = inl(DE4X5_APROM)) < 0);
4122             chksum = (u_char) tmp;
4123             while ((tmp = inl(DE4X5_APROM)) < 0);
4124             chksum |= (u_short) (tmp << 8);
4125             if ((k != chksum) && (dec_only)) status = -1;
4126         }
4127     } else {
4128         chksum = (u_char) inb(EISA_APROM);
4129         chksum |= (u_short) (inb(EISA_APROM) << 8);
4130         if ((k != chksum) && (dec_only)) status = -1;
4131     }
4132
4133     /* If possible, try to fix a broken card - SMC only so far */
4134     srom_repair(dev, broken);
4135
4136 #ifdef CONFIG_PPC_PMAC
4137     /*
4138     ** If the address starts with 00 a0, we have to bit-reverse
4139     ** each byte of the address.
4140     */
4141     if ( machine_is(powermac) &&
4142          (dev->dev_addr[0] == 0) &&
4143          (dev->dev_addr[1] == 0xa0) )
4144     {
4145             for (i = 0; i < ETH_ALEN; ++i)
4146             {
4147                     int x = dev->dev_addr[i];
4148                     x = ((x & 0xf) << 4) + ((x & 0xf0) >> 4);
4149                     x = ((x & 0x33) << 2) + ((x & 0xcc) >> 2);
4150                     dev->dev_addr[i] = ((x & 0x55) << 1) + ((x & 0xaa) >> 1);
4151             }
4152     }
4153 #endif /* CONFIG_PPC_PMAC */
4154
4155     /* Test for a bad enet address */
4156     status = test_bad_enet(dev, status);
4157
4158     return status;
4159 }
4160
4161 /*
4162 ** Test for enet addresses in the first 32 bytes. The built-in strncmp
4163 ** didn't seem to work here...?
4164 */
4165 static int
4166 de4x5_bad_srom(struct de4x5_private *lp)
4167 {
4168     int i, status = 0;
4169
4170     for (i = 0; i < ARRAY_SIZE(enet_det); i++) {
4171         if (!de4x5_strncmp((char *)&lp->srom, (char *)&enet_det[i], 3) &&
4172             !de4x5_strncmp((char *)&lp->srom+0x10, (char *)&enet_det[i], 3)) {
4173             if (i == 0) {
4174                 status = SMC;
4175             } else if (i == 1) {
4176                 status = ACCTON;
4177             }
4178             break;
4179         }
4180     }
4181
4182     return status;
4183 }
4184
4185 static int
4186 de4x5_strncmp(char *a, char *b, int n)
4187 {
4188     int ret=0;
4189
4190     for (;n && !ret; n--) {
4191         ret = *a++ - *b++;
4192     }
4193
4194     return ret;
4195 }
4196
4197 static void
4198 srom_repair(struct net_device *dev, int card)
4199 {
4200     struct de4x5_private *lp = netdev_priv(dev);
4201
4202     switch(card) {
4203       case SMC:
4204         memset((char *)&lp->srom, 0, sizeof(struct de4x5_srom));
4205         memcpy(lp->srom.ieee_addr, (char *)dev->dev_addr, ETH_ALEN);
4206         memcpy(lp->srom.info, (char *)&srom_repair_info[SMC-1], 100);
4207         lp->useSROM = true;
4208         break;
4209     }
4210
4211     return;
4212 }
4213
4214 /*
4215 ** Assume that the irq's do not follow the PCI spec - this is seems
4216 ** to be true so far (2 for 2).
4217 */
4218 static int
4219 test_bad_enet(struct net_device *dev, int status)
4220 {
4221     struct de4x5_private *lp = netdev_priv(dev);
4222     int i, tmp;
4223
4224     for (tmp=0,i=0; i<ETH_ALEN; i++) tmp += (u_char)dev->dev_addr[i];
4225     if ((tmp == 0) || (tmp == 0x5fa)) {
4226         if ((lp->chipset == last.chipset) &&
4227             (lp->bus_num == last.bus) && (lp->bus_num > 0)) {
4228             for (i=0; i<ETH_ALEN; i++) dev->dev_addr[i] = last.addr[i];
4229             for (i=ETH_ALEN-1; i>2; --i) {
4230                 dev->dev_addr[i] += 1;
4231                 if (dev->dev_addr[i] != 0) break;
4232             }
4233             for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
4234             if (!an_exception(lp)) {
4235                 dev->irq = last.irq;
4236             }
4237
4238             status = 0;
4239         }
4240     } else if (!status) {
4241         last.chipset = lp->chipset;
4242         last.bus = lp->bus_num;
4243         last.irq = dev->irq;
4244         for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
4245     }
4246
4247     return status;
4248 }
4249
4250 /*
4251 ** List of board exceptions with correctly wired IRQs
4252 */
4253 static int
4254 an_exception(struct de4x5_private *lp)
4255 {
4256     if ((*(u_short *)lp->srom.sub_vendor_id == 0x00c0) &&
4257         (*(u_short *)lp->srom.sub_system_id == 0x95e0)) {
4258         return -1;
4259     }
4260
4261     return 0;
4262 }
4263
4264 /*
4265 ** SROM Read
4266 */
4267 static short
4268 srom_rd(u_long addr, u_char offset)
4269 {
4270     sendto_srom(SROM_RD | SROM_SR, addr);
4271
4272     srom_latch(SROM_RD | SROM_SR | DT_CS, addr);
4273     srom_command(SROM_RD | SROM_SR | DT_IN | DT_CS, addr);
4274     srom_address(SROM_RD | SROM_SR | DT_CS, addr, offset);
4275
4276     return srom_data(SROM_RD | SROM_SR | DT_CS, addr);
4277 }
4278
4279 static void
4280 srom_latch(u_int command, u_long addr)
4281 {
4282     sendto_srom(command, addr);
4283     sendto_srom(command | DT_CLK, addr);
4284     sendto_srom(command, addr);
4285
4286     return;
4287 }
4288
4289 static void
4290 srom_command(u_int command, u_long addr)
4291 {
4292     srom_latch(command, addr);
4293     srom_latch(command, addr);
4294     srom_latch((command & 0x0000ff00) | DT_CS, addr);
4295
4296     return;
4297 }
4298
4299 static void
4300 srom_address(u_int command, u_long addr, u_char offset)
4301 {
4302     int i, a;
4303
4304     a = offset << 2;
4305     for (i=0; i<6; i++, a <<= 1) {
4306         srom_latch(command | ((a & 0x80) ? DT_IN : 0), addr);
4307     }
4308     udelay(1);
4309
4310     i = (getfrom_srom(addr) >> 3) & 0x01;
4311
4312     return;
4313 }
4314
4315 static short
4316 srom_data(u_int command, u_long addr)
4317 {
4318     int i;
4319     short word = 0;
4320     s32 tmp;
4321
4322     for (i=0; i<16; i++) {
4323         sendto_srom(command  | DT_CLK, addr);
4324         tmp = getfrom_srom(addr);
4325         sendto_srom(command, addr);
4326
4327         word = (word << 1) | ((tmp >> 3) & 0x01);
4328     }
4329
4330     sendto_srom(command & 0x0000ff00, addr);
4331
4332     return word;
4333 }
4334
4335 /*
4336 static void
4337 srom_busy(u_int command, u_long addr)
4338 {
4339    sendto_srom((command & 0x0000ff00) | DT_CS, addr);
4340
4341    while (!((getfrom_srom(addr) >> 3) & 0x01)) {
4342        mdelay(1);
4343    }
4344
4345    sendto_srom(command & 0x0000ff00, addr);
4346
4347    return;
4348 }
4349 */
4350
4351 static void
4352 sendto_srom(u_int command, u_long addr)
4353 {
4354     outl(command, addr);
4355     udelay(1);
4356
4357     return;
4358 }
4359
4360 static int
4361 getfrom_srom(u_long addr)
4362 {
4363     s32 tmp;
4364
4365     tmp = inl(addr);
4366     udelay(1);
4367
4368     return tmp;
4369 }
4370
4371 static int
4372 srom_infoleaf_info(struct net_device *dev)
4373 {
4374     struct de4x5_private *lp = netdev_priv(dev);
4375     int i, count;
4376     u_char *p;
4377
4378     /* Find the infoleaf decoder function that matches this chipset */
4379     for (i=0; i<INFOLEAF_SIZE; i++) {
4380         if (lp->chipset == infoleaf_array[i].chipset) break;
4381     }
4382     if (i == INFOLEAF_SIZE) {
4383         lp->useSROM = false;
4384         printk("%s: Cannot find correct chipset for SROM decoding!\n",
4385                                                                   dev->name);
4386         return -ENXIO;
4387     }
4388
4389     lp->infoleaf_fn = infoleaf_array[i].fn;
4390
4391     /* Find the information offset that this function should use */
4392     count = *((u_char *)&lp->srom + 19);
4393     p  = (u_char *)&lp->srom + 26;
4394
4395     if (count > 1) {
4396         for (i=count; i; --i, p+=3) {
4397             if (lp->device == *p) break;
4398         }
4399         if (i == 0) {
4400             lp->useSROM = false;
4401             printk("%s: Cannot find correct PCI device [%d] for SROM decoding!\n",
4402                                                        dev->name, lp->device);
4403             return -ENXIO;
4404         }
4405     }
4406
4407         lp->infoleaf_offset = get_unaligned_le16(p + 1);
4408
4409     return 0;
4410 }
4411
4412 /*
4413 ** This routine loads any type 1 or 3 MII info into the mii device
4414 ** struct and executes any type 5 code to reset PHY devices for this
4415 ** controller.
4416 ** The info for the MII devices will be valid since the index used
4417 ** will follow the discovery process from MII address 1-31 then 0.
4418 */
4419 static void
4420 srom_init(struct net_device *dev)
4421 {
4422     struct de4x5_private *lp = netdev_priv(dev);
4423     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4424     u_char count;
4425
4426     p+=2;
4427     if (lp->chipset == DC21140) {
4428         lp->cache.gepc = (*p++ | GEP_CTRL);
4429         gep_wr(lp->cache.gepc, dev);
4430     }
4431
4432     /* Block count */
4433     count = *p++;
4434
4435     /* Jump the infoblocks to find types */
4436     for (;count; --count) {
4437         if (*p < 128) {
4438             p += COMPACT_LEN;
4439         } else if (*(p+1) == 5) {
4440             type5_infoblock(dev, 1, p);
4441             p += ((*p & BLOCK_LEN) + 1);
4442         } else if (*(p+1) == 4) {
4443             p += ((*p & BLOCK_LEN) + 1);
4444         } else if (*(p+1) == 3) {
4445             type3_infoblock(dev, 1, p);
4446             p += ((*p & BLOCK_LEN) + 1);
4447         } else if (*(p+1) == 2) {
4448             p += ((*p & BLOCK_LEN) + 1);
4449         } else if (*(p+1) == 1) {
4450             type1_infoblock(dev, 1, p);
4451             p += ((*p & BLOCK_LEN) + 1);
4452         } else {
4453             p += ((*p & BLOCK_LEN) + 1);
4454         }
4455     }
4456
4457     return;
4458 }
4459
4460 /*
4461 ** A generic routine that writes GEP control, data and reset information
4462 ** to the GEP register (21140) or csr15 GEP portion (2114[23]).
4463 */
4464 static void
4465 srom_exec(struct net_device *dev, u_char *p)
4466 {
4467     struct de4x5_private *lp = netdev_priv(dev);
4468     u_long iobase = dev->base_addr;
4469     u_char count = (p ? *p++ : 0);
4470     u_short *w = (u_short *)p;
4471
4472     if (((lp->ibn != 1) && (lp->ibn != 3) && (lp->ibn != 5)) || !count) return;
4473
4474     if (lp->chipset != DC21140) RESET_SIA;
4475
4476     while (count--) {
4477         gep_wr(((lp->chipset==DC21140) && (lp->ibn!=5) ?
4478                                                    *p++ : get_unaligned_le16(w++)), dev);
4479         mdelay(2);                          /* 2ms per action */
4480     }
4481
4482     if (lp->chipset != DC21140) {
4483         outl(lp->cache.csr14, DE4X5_STRR);
4484         outl(lp->cache.csr13, DE4X5_SICR);
4485     }
4486
4487     return;
4488 }
4489
4490 /*
4491 ** Basically this function is a NOP since it will never be called,
4492 ** unless I implement the DC21041 SROM functions. There's no need
4493 ** since the existing code will be satisfactory for all boards.
4494 */
4495 static int
4496 dc21041_infoleaf(struct net_device *dev)
4497 {
4498     return DE4X5_AUTOSENSE_MS;
4499 }
4500
4501 static int
4502 dc21140_infoleaf(struct net_device *dev)
4503 {
4504     struct de4x5_private *lp = netdev_priv(dev);
4505     u_char count = 0;
4506     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4507     int next_tick = DE4X5_AUTOSENSE_MS;
4508
4509     /* Read the connection type */
4510     p+=2;
4511
4512     /* GEP control */
4513     lp->cache.gepc = (*p++ | GEP_CTRL);
4514
4515     /* Block count */
4516     count = *p++;
4517
4518     /* Recursively figure out the info blocks */
4519     if (*p < 128) {
4520         next_tick = dc_infoblock[COMPACT](dev, count, p);
4521     } else {
4522         next_tick = dc_infoblock[*(p+1)](dev, count, p);
4523     }
4524
4525     if (lp->tcount == count) {
4526         lp->media = NC;
4527         if (lp->media != lp->c_media) {
4528             de4x5_dbg_media(dev);
4529             lp->c_media = lp->media;
4530         }
4531         lp->media = INIT;
4532         lp->tcount = 0;
4533         lp->tx_enable = false;
4534     }
4535
4536     return next_tick & ~TIMER_CB;
4537 }
4538
4539 static int
4540 dc21142_infoleaf(struct net_device *dev)
4541 {
4542     struct de4x5_private *lp = netdev_priv(dev);
4543     u_char count = 0;
4544     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4545     int next_tick = DE4X5_AUTOSENSE_MS;
4546
4547     /* Read the connection type */
4548     p+=2;
4549
4550     /* Block count */
4551     count = *p++;
4552
4553     /* Recursively figure out the info blocks */
4554     if (*p < 128) {
4555         next_tick = dc_infoblock[COMPACT](dev, count, p);
4556     } else {
4557         next_tick = dc_infoblock[*(p+1)](dev, count, p);
4558     }
4559
4560     if (lp->tcount == count) {
4561         lp->media = NC;
4562         if (lp->media != lp->c_media) {
4563             de4x5_dbg_media(dev);
4564             lp->c_media = lp->media;
4565         }
4566         lp->media = INIT;
4567         lp->tcount = 0;
4568         lp->tx_enable = false;
4569     }
4570
4571     return next_tick & ~TIMER_CB;
4572 }
4573
4574 static int
4575 dc21143_infoleaf(struct net_device *dev)
4576 {
4577     struct de4x5_private *lp = netdev_priv(dev);
4578     u_char count = 0;
4579     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4580     int next_tick = DE4X5_AUTOSENSE_MS;
4581
4582     /* Read the connection type */
4583     p+=2;
4584
4585     /* Block count */
4586     count = *p++;
4587
4588     /* Recursively figure out the info blocks */
4589     if (*p < 128) {
4590         next_tick = dc_infoblock[COMPACT](dev, count, p);
4591     } else {
4592         next_tick = dc_infoblock[*(p+1)](dev, count, p);
4593     }
4594     if (lp->tcount == count) {
4595         lp->media = NC;
4596         if (lp->media != lp->c_media) {
4597             de4x5_dbg_media(dev);
4598             lp->c_media = lp->media;
4599         }
4600         lp->media = INIT;
4601         lp->tcount = 0;
4602         lp->tx_enable = false;
4603     }
4604
4605     return next_tick & ~TIMER_CB;
4606 }
4607
4608 /*
4609 ** The compact infoblock is only designed for DC21140[A] chips, so
4610 ** we'll reuse the dc21140m_autoconf function. Non MII media only.
4611 */
4612 static int
4613 compact_infoblock(struct net_device *dev, u_char count, u_char *p)
4614 {
4615     struct de4x5_private *lp = netdev_priv(dev);
4616     u_char flags, csr6;
4617
4618     /* Recursively figure out the info blocks */
4619     if (--count > lp->tcount) {
4620         if (*(p+COMPACT_LEN) < 128) {
4621             return dc_infoblock[COMPACT](dev, count, p+COMPACT_LEN);
4622         } else {
4623             return dc_infoblock[*(p+COMPACT_LEN+1)](dev, count, p+COMPACT_LEN);
4624         }
4625     }
4626
4627     if ((lp->media == INIT) && (lp->timeout < 0)) {
4628         lp->ibn = COMPACT;
4629         lp->active = 0;
4630         gep_wr(lp->cache.gepc, dev);
4631         lp->infoblock_media = (*p++) & COMPACT_MC;
4632         lp->cache.gep = *p++;
4633         csr6 = *p++;
4634         flags = *p++;
4635
4636         lp->asBitValid = (flags & 0x80) ? 0 : -1;
4637         lp->defMedium = (flags & 0x40) ? -1 : 0;
4638         lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4639         lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4640         lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4641         lp->useMII = false;
4642
4643         de4x5_switch_mac_port(dev);
4644     }
4645
4646     return dc21140m_autoconf(dev);
4647 }
4648
4649 /*
4650 ** This block describes non MII media for the DC21140[A] only.
4651 */
4652 static int
4653 type0_infoblock(struct net_device *dev, u_char count, u_char *p)
4654 {
4655     struct de4x5_private *lp = netdev_priv(dev);
4656     u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
4657
4658     /* Recursively figure out the info blocks */
4659     if (--count > lp->tcount) {
4660         if (*(p+len) < 128) {
4661             return dc_infoblock[COMPACT](dev, count, p+len);
4662         } else {
4663             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4664         }
4665     }
4666
4667     if ((lp->media == INIT) && (lp->timeout < 0)) {
4668         lp->ibn = 0;
4669         lp->active = 0;
4670         gep_wr(lp->cache.gepc, dev);
4671         p+=2;
4672         lp->infoblock_media = (*p++) & BLOCK0_MC;
4673         lp->cache.gep = *p++;
4674         csr6 = *p++;
4675         flags = *p++;
4676
4677         lp->asBitValid = (flags & 0x80) ? 0 : -1;
4678         lp->defMedium = (flags & 0x40) ? -1 : 0;
4679         lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4680         lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4681         lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4682         lp->useMII = false;
4683
4684         de4x5_switch_mac_port(dev);
4685     }
4686
4687     return dc21140m_autoconf(dev);
4688 }
4689
4690 /* These functions are under construction! */
4691
4692 static int
4693 type1_infoblock(struct net_device *dev, u_char count, u_char *p)
4694 {
4695     struct de4x5_private *lp = netdev_priv(dev);
4696     u_char len = (*p & BLOCK_LEN)+1;
4697
4698     /* Recursively figure out the info blocks */
4699     if (--count > lp->tcount) {
4700         if (*(p+len) < 128) {
4701             return dc_infoblock[COMPACT](dev, count, p+len);
4702         } else {
4703             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4704         }
4705     }
4706
4707     p += 2;
4708     if (lp->state == INITIALISED) {
4709         lp->ibn = 1;
4710         lp->active = *p++;
4711         lp->phy[lp->active].gep = (*p ? p : NULL); p += (*p + 1);
4712         lp->phy[lp->active].rst = (*p ? p : NULL); p += (*p + 1);
4713         lp->phy[lp->active].mc  = get_unaligned_le16(p); p += 2;
4714         lp->phy[lp->active].ana = get_unaligned_le16(p); p += 2;
4715         lp->phy[lp->active].fdx = get_unaligned_le16(p); p += 2;
4716         lp->phy[lp->active].ttm = get_unaligned_le16(p);
4717         return 0;
4718     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
4719         lp->ibn = 1;
4720         lp->active = *p;
4721         lp->infoblock_csr6 = OMR_MII_100;
4722         lp->useMII = true;
4723         lp->infoblock_media = ANS;
4724
4725         de4x5_switch_mac_port(dev);
4726     }
4727
4728     return dc21140m_autoconf(dev);
4729 }
4730
4731 static int
4732 type2_infoblock(struct net_device *dev, u_char count, u_char *p)
4733 {
4734     struct de4x5_private *lp = netdev_priv(dev);
4735     u_char len = (*p & BLOCK_LEN)+1;
4736
4737     /* Recursively figure out the info blocks */
4738     if (--count > lp->tcount) {
4739         if (*(p+len) < 128) {
4740             return dc_infoblock[COMPACT](dev, count, p+len);
4741         } else {
4742             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4743         }
4744     }
4745
4746     if ((lp->media == INIT) && (lp->timeout < 0)) {
4747         lp->ibn = 2;
4748         lp->active = 0;
4749         p += 2;
4750         lp->infoblock_media = (*p) & MEDIA_CODE;
4751
4752         if ((*p++) & EXT_FIELD) {
4753             lp->cache.csr13 = get_unaligned_le16(p); p += 2;
4754             lp->cache.csr14 = get_unaligned_le16(p); p += 2;
4755             lp->cache.csr15 = get_unaligned_le16(p); p += 2;
4756         } else {
4757             lp->cache.csr13 = CSR13;
4758             lp->cache.csr14 = CSR14;
4759             lp->cache.csr15 = CSR15;
4760         }
4761         lp->cache.gepc = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
4762         lp->cache.gep  = ((s32)(get_unaligned_le16(p)) << 16);
4763         lp->infoblock_csr6 = OMR_SIA;
4764         lp->useMII = false;
4765
4766         de4x5_switch_mac_port(dev);
4767     }
4768
4769     return dc2114x_autoconf(dev);
4770 }
4771
4772 static int
4773 type3_infoblock(struct net_device *dev, u_char count, u_char *p)
4774 {
4775     struct de4x5_private *lp = netdev_priv(dev);
4776     u_char len = (*p & BLOCK_LEN)+1;
4777
4778     /* Recursively figure out the info blocks */
4779     if (--count > lp->tcount) {
4780         if (*(p+len) < 128) {
4781             return dc_infoblock[COMPACT](dev, count, p+len);
4782         } else {
4783             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4784         }
4785     }
4786
4787     p += 2;
4788     if (lp->state == INITIALISED) {
4789         lp->ibn = 3;
4790         lp->active = *p++;
4791         if (MOTO_SROM_BUG) lp->active = 0;
4792         lp->phy[lp->active].gep = (*p ? p : NULL); p += (2 * (*p) + 1);
4793         lp->phy[lp->active].rst = (*p ? p : NULL); p += (2 * (*p) + 1);
4794         lp->phy[lp->active].mc  = get_unaligned_le16(p); p += 2;
4795         lp->phy[lp->active].ana = get_unaligned_le16(p); p += 2;
4796         lp->phy[lp->active].fdx = get_unaligned_le16(p); p += 2;
4797         lp->phy[lp->active].ttm = get_unaligned_le16(p); p += 2;
4798         lp->phy[lp->active].mci = *p;
4799         return 0;
4800     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
4801         lp->ibn = 3;
4802         lp->active = *p;
4803         if (MOTO_SROM_BUG) lp->active = 0;
4804         lp->infoblock_csr6 = OMR_MII_100;
4805         lp->useMII = true;
4806         lp->infoblock_media = ANS;
4807
4808         de4x5_switch_mac_port(dev);
4809     }
4810
4811     return dc2114x_autoconf(dev);
4812 }
4813
4814 static int
4815 type4_infoblock(struct net_device *dev, u_char count, u_char *p)
4816 {
4817     struct de4x5_private *lp = netdev_priv(dev);
4818     u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
4819
4820     /* Recursively figure out the info blocks */
4821     if (--count > lp->tcount) {
4822         if (*(p+len) < 128) {
4823             return dc_infoblock[COMPACT](dev, count, p+len);
4824         } else {
4825             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4826         }
4827     }
4828
4829     if ((lp->media == INIT) && (lp->timeout < 0)) {
4830         lp->ibn = 4;
4831         lp->active = 0;
4832         p+=2;
4833         lp->infoblock_media = (*p++) & MEDIA_CODE;
4834         lp->cache.csr13 = CSR13;              /* Hard coded defaults */
4835         lp->cache.csr14 = CSR14;
4836         lp->cache.csr15 = CSR15;
4837         lp->cache.gepc = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
4838         lp->cache.gep  = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
4839         csr6 = *p++;
4840         flags = *p++;
4841
4842         lp->asBitValid = (flags & 0x80) ? 0 : -1;
4843         lp->defMedium = (flags & 0x40) ? -1 : 0;
4844         lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4845         lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4846         lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4847         lp->useMII = false;
4848
4849         de4x5_switch_mac_port(dev);
4850     }
4851
4852     return dc2114x_autoconf(dev);
4853 }
4854
4855 /*
4856 ** This block type provides information for resetting external devices
4857 ** (chips) through the General Purpose Register.
4858 */
4859 static int
4860 type5_infoblock(struct net_device *dev, u_char count, u_char *p)
4861 {
4862     struct de4x5_private *lp = netdev_priv(dev);
4863     u_char len = (*p & BLOCK_LEN)+1;
4864
4865     /* Recursively figure out the info blocks */
4866     if (--count > lp->tcount) {
4867         if (*(p+len) < 128) {
4868             return dc_infoblock[COMPACT](dev, count, p+len);
4869         } else {
4870             return dc_infoblock[*(p+len+1)](dev, count, p+len);
4871         }
4872     }
4873
4874     /* Must be initializing to run this code */
4875     if ((lp->state == INITIALISED) || (lp->media == INIT)) {
4876         p+=2;
4877         lp->rst = p;
4878         srom_exec(dev, lp->rst);
4879     }
4880
4881     return DE4X5_AUTOSENSE_MS;
4882 }
4883
4884 /*
4885 ** MII Read/Write
4886 */
4887
4888 static int
4889 mii_rd(u_char phyreg, u_char phyaddr, u_long ioaddr)
4890 {
4891     mii_wdata(MII_PREAMBLE,  2, ioaddr);   /* Start of 34 bit preamble...    */
4892     mii_wdata(MII_PREAMBLE, 32, ioaddr);   /* ...continued                   */
4893     mii_wdata(MII_STRD, 4, ioaddr);        /* SFD and Read operation         */
4894     mii_address(phyaddr, ioaddr);          /* PHY address to be accessed     */
4895     mii_address(phyreg, ioaddr);           /* PHY Register to read           */
4896     mii_ta(MII_STRD, ioaddr);              /* Turn around time - 2 MDC       */
4897
4898     return mii_rdata(ioaddr);              /* Read data                      */
4899 }
4900
4901 static void
4902 mii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr)
4903 {
4904     mii_wdata(MII_PREAMBLE,  2, ioaddr);   /* Start of 34 bit preamble...    */
4905     mii_wdata(MII_PREAMBLE, 32, ioaddr);   /* ...continued                   */
4906     mii_wdata(MII_STWR, 4, ioaddr);        /* SFD and Write operation        */
4907     mii_address(phyaddr, ioaddr);          /* PHY address to be accessed     */
4908     mii_address(phyreg, ioaddr);           /* PHY Register to write          */
4909     mii_ta(MII_STWR, ioaddr);              /* Turn around time - 2 MDC       */
4910     data = mii_swap(data, 16);             /* Swap data bit ordering         */
4911     mii_wdata(data, 16, ioaddr);           /* Write data                     */
4912
4913     return;
4914 }
4915
4916 static int
4917 mii_rdata(u_long ioaddr)
4918 {
4919     int i;
4920     s32 tmp = 0;
4921
4922     for (i=0; i<16; i++) {
4923         tmp <<= 1;
4924         tmp |= getfrom_mii(MII_MRD | MII_RD, ioaddr);
4925     }
4926
4927     return tmp;
4928 }
4929
4930 static void
4931 mii_wdata(int data, int len, u_long ioaddr)
4932 {
4933     int i;
4934
4935     for (i=0; i<len; i++) {
4936         sendto_mii(MII_MWR | MII_WR, data, ioaddr);
4937         data >>= 1;
4938     }
4939
4940     return;
4941 }
4942
4943 static void
4944 mii_address(u_char addr, u_long ioaddr)
4945 {
4946     int i;
4947
4948     addr = mii_swap(addr, 5);
4949     for (i=0; i<5; i++) {
4950         sendto_mii(MII_MWR | MII_WR, addr, ioaddr);
4951         addr >>= 1;
4952     }
4953
4954     return;
4955 }
4956
4957 static void
4958 mii_ta(u_long rw, u_long ioaddr)
4959 {
4960     if (rw == MII_STWR) {
4961         sendto_mii(MII_MWR | MII_WR, 1, ioaddr);
4962         sendto_mii(MII_MWR | MII_WR, 0, ioaddr);
4963     } else {
4964         getfrom_mii(MII_MRD | MII_RD, ioaddr);        /* Tri-state MDIO */
4965     }
4966
4967     return;
4968 }
4969
4970 static int
4971 mii_swap(int data, int len)
4972 {
4973     int i, tmp = 0;
4974
4975     for (i=0; i<len; i++) {
4976         tmp <<= 1;
4977         tmp |= (data & 1);
4978         data >>= 1;
4979     }
4980
4981     return tmp;
4982 }
4983
4984 static void
4985 sendto_mii(u32 command, int data, u_long ioaddr)
4986 {
4987     u32 j;
4988
4989     j = (data & 1) << 17;
4990     outl(command | j, ioaddr);
4991     udelay(1);
4992     outl(command | MII_MDC | j, ioaddr);
4993     udelay(1);
4994
4995     return;
4996 }
4997
4998 static int
4999 getfrom_mii(u32 command, u_long ioaddr)
5000 {
5001     outl(command, ioaddr);
5002     udelay(1);
5003     outl(command | MII_MDC, ioaddr);
5004     udelay(1);
5005
5006     return ((inl(ioaddr) >> 19) & 1);
5007 }
5008
5009 /*
5010 ** Here's 3 ways to calculate the OUI from the ID registers.
5011 */
5012 static int
5013 mii_get_oui(u_char phyaddr, u_long ioaddr)
5014 {
5015 /*
5016     union {
5017         u_short reg;
5018         u_char breg[2];
5019     } a;
5020     int i, r2, r3, ret=0;*/
5021     int r2, r3;
5022
5023     /* Read r2 and r3 */
5024     r2 = mii_rd(MII_ID0, phyaddr, ioaddr);
5025     r3 = mii_rd(MII_ID1, phyaddr, ioaddr);
5026                                                 /* SEEQ and Cypress way * /
5027     / * Shuffle r2 and r3 * /
5028     a.reg=0;
5029     r3 = ((r3>>10)|(r2<<6))&0x0ff;
5030     r2 = ((r2>>2)&0x3fff);
5031
5032     / * Bit reverse r3 * /
5033     for (i=0;i<8;i++) {
5034         ret<<=1;
5035         ret |= (r3&1);
5036         r3>>=1;
5037     }
5038
5039     / * Bit reverse r2 * /
5040     for (i=0;i<16;i++) {
5041         a.reg<<=1;
5042         a.reg |= (r2&1);
5043         r2>>=1;
5044     }
5045
5046     / * Swap r2 bytes * /
5047     i=a.breg[0];
5048     a.breg[0]=a.breg[1];
5049     a.breg[1]=i;
5050
5051     return ((a.reg<<8)|ret); */                 /* SEEQ and Cypress way */
5052 /*    return ((r2<<6)|(u_int)(r3>>10)); */      /* NATIONAL and BROADCOM way */
5053     return r2;                                  /* (I did it) My way */
5054 }
5055
5056 /*
5057 ** The SROM spec forces us to search addresses [1-31 0]. Bummer.
5058 */
5059 static int
5060 mii_get_phy(struct net_device *dev)
5061 {
5062     struct de4x5_private *lp = netdev_priv(dev);
5063     u_long iobase = dev->base_addr;
5064     int i, j, k, n, limit=ARRAY_SIZE(phy_info);
5065     int id;
5066
5067     lp->active = 0;
5068     lp->useMII = true;
5069
5070     /* Search the MII address space for possible PHY devices */
5071     for (n=0, lp->mii_cnt=0, i=1; !((i==1) && (n==1)); i=(i+1)%DE4X5_MAX_MII) {
5072         lp->phy[lp->active].addr = i;
5073         if (i==0) n++;                             /* Count cycles */
5074         while (de4x5_reset_phy(dev)<0) udelay(100);/* Wait for reset */
5075         id = mii_get_oui(i, DE4X5_MII);
5076         if ((id == 0) || (id == 65535)) continue;  /* Valid ID? */
5077         for (j=0; j<limit; j++) {                  /* Search PHY table */
5078             if (id != phy_info[j].id) continue;    /* ID match? */
5079             for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
5080             if (k < DE4X5_MAX_PHY) {
5081                 memcpy((char *)&lp->phy[k],
5082                        (char *)&phy_info[j], sizeof(struct phy_table));
5083                 lp->phy[k].addr = i;
5084                 lp->mii_cnt++;
5085                 lp->active++;
5086             } else {
5087                 goto purgatory;                    /* Stop the search */
5088             }
5089             break;
5090         }
5091         if ((j == limit) && (i < DE4X5_MAX_MII)) {
5092             for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
5093             lp->phy[k].addr = i;
5094             lp->phy[k].id = id;
5095             lp->phy[k].spd.reg = GENERIC_REG;      /* ANLPA register         */
5096             lp->phy[k].spd.mask = GENERIC_MASK;    /* 100Mb/s technologies   */
5097             lp->phy[k].spd.value = GENERIC_VALUE;  /* TX & T4, H/F Duplex    */
5098             lp->mii_cnt++;
5099             lp->active++;
5100             printk("%s: Using generic MII device control. If the board doesn't operate, \nplease mail the following dump to the author:\n", dev->name);
5101             j = de4x5_debug;
5102             de4x5_debug |= DEBUG_MII;
5103             de4x5_dbg_mii(dev, k);
5104             de4x5_debug = j;
5105             printk("\n");
5106         }
5107     }
5108   purgatory:
5109     lp->active = 0;
5110     if (lp->phy[0].id) {                           /* Reset the PHY devices */
5111         for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++) { /*For each PHY*/
5112             mii_wr(MII_CR_RST, MII_CR, lp->phy[k].addr, DE4X5_MII);
5113             while (mii_rd(MII_CR, lp->phy[k].addr, DE4X5_MII) & MII_CR_RST);
5114
5115             de4x5_dbg_mii(dev, k);
5116         }
5117     }
5118     if (!lp->mii_cnt) lp->useMII = false;
5119
5120     return lp->mii_cnt;
5121 }
5122
5123 static char *
5124 build_setup_frame(struct net_device *dev, int mode)
5125 {
5126     struct de4x5_private *lp = netdev_priv(dev);
5127     int i;
5128     char *pa = lp->setup_frame;
5129
5130     /* Initialise the setup frame */
5131     if (mode == ALL) {
5132         memset(lp->setup_frame, 0, SETUP_FRAME_LEN);
5133     }
5134
5135     if (lp->setup_f == HASH_PERF) {
5136         for (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
5137             *(pa + i) = dev->dev_addr[i];                 /* Host address */
5138             if (i & 0x01) pa += 2;
5139         }
5140         *(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80;
5141     } else {
5142         for (i=0; i<ETH_ALEN; i++) { /* Host address */
5143             *(pa + (i&1)) = dev->dev_addr[i];
5144             if (i & 0x01) pa += 4;
5145         }
5146         for (i=0; i<ETH_ALEN; i++) { /* Broadcast address */
5147             *(pa + (i&1)) = (char) 0xff;
5148             if (i & 0x01) pa += 4;
5149         }
5150     }
5151
5152     return pa;                     /* Points to the next entry */
5153 }
5154
5155 static void
5156 disable_ast(struct net_device *dev)
5157 {
5158         struct de4x5_private *lp = netdev_priv(dev);
5159         del_timer_sync(&lp->timer);
5160 }
5161
5162 static long
5163 de4x5_switch_mac_port(struct net_device *dev)
5164 {
5165     struct de4x5_private *lp = netdev_priv(dev);
5166     u_long iobase = dev->base_addr;
5167     s32 omr;
5168
5169     STOP_DE4X5;
5170
5171     /* Assert the OMR_PS bit in CSR6 */
5172     omr = (inl(DE4X5_OMR) & ~(OMR_PS | OMR_HBD | OMR_TTM | OMR_PCS | OMR_SCR |
5173                                                                      OMR_FDX));
5174     omr |= lp->infoblock_csr6;
5175     if (omr & OMR_PS) omr |= OMR_HBD;
5176     outl(omr, DE4X5_OMR);
5177
5178     /* Soft Reset */
5179     RESET_DE4X5;
5180
5181     /* Restore the GEP - especially for COMPACT and Type 0 Infoblocks */
5182     if (lp->chipset == DC21140) {
5183         gep_wr(lp->cache.gepc, dev);
5184         gep_wr(lp->cache.gep, dev);
5185     } else if ((lp->chipset & ~0x0ff) == DC2114x) {
5186         reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14, lp->cache.csr15);
5187     }
5188
5189     /* Restore CSR6 */
5190     outl(omr, DE4X5_OMR);
5191
5192     /* Reset CSR8 */
5193     inl(DE4X5_MFC);
5194
5195     return omr;
5196 }
5197
5198 static void
5199 gep_wr(s32 data, struct net_device *dev)
5200 {
5201     struct de4x5_private *lp = netdev_priv(dev);
5202     u_long iobase = dev->base_addr;
5203
5204     if (lp->chipset == DC21140) {
5205         outl(data, DE4X5_GEP);
5206     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
5207         outl((data<<16) | lp->cache.csr15, DE4X5_SIGR);
5208     }
5209
5210     return;
5211 }
5212
5213 static int
5214 gep_rd(struct net_device *dev)
5215 {
5216     struct de4x5_private *lp = netdev_priv(dev);
5217     u_long iobase = dev->base_addr;
5218
5219     if (lp->chipset == DC21140) {
5220         return inl(DE4X5_GEP);
5221     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
5222         return (inl(DE4X5_SIGR) & 0x000fffff);
5223     }
5224
5225     return 0;
5226 }
5227
5228 static void
5229 yawn(struct net_device *dev, int state)
5230 {
5231     struct de4x5_private *lp = netdev_priv(dev);
5232     u_long iobase = dev->base_addr;
5233
5234     if ((lp->chipset == DC21040) || (lp->chipset == DC21140)) return;
5235
5236     if(lp->bus == EISA) {
5237         switch(state) {
5238           case WAKEUP:
5239             outb(WAKEUP, PCI_CFPM);
5240             mdelay(10);
5241             break;
5242
5243           case SNOOZE:
5244             outb(SNOOZE, PCI_CFPM);
5245             break;
5246
5247           case SLEEP:
5248             outl(0, DE4X5_SICR);
5249             outb(SLEEP, PCI_CFPM);
5250             break;
5251         }
5252     } else {
5253         struct pci_dev *pdev = to_pci_dev (lp->gendev);
5254         switch(state) {
5255           case WAKEUP:
5256             pci_write_config_byte(pdev, PCI_CFDA_PSM, WAKEUP);
5257             mdelay(10);
5258             break;
5259
5260           case SNOOZE:
5261             pci_write_config_byte(pdev, PCI_CFDA_PSM, SNOOZE);
5262             break;
5263
5264           case SLEEP:
5265             outl(0, DE4X5_SICR);
5266             pci_write_config_byte(pdev, PCI_CFDA_PSM, SLEEP);
5267             break;
5268         }
5269     }
5270
5271     return;
5272 }
5273
5274 static void
5275 de4x5_parse_params(struct net_device *dev)
5276 {
5277     struct de4x5_private *lp = netdev_priv(dev);
5278     char *p, *q, t;
5279
5280     lp->params.fdx = 0;
5281     lp->params.autosense = AUTO;
5282
5283     if (args == NULL) return;
5284
5285     if ((p = strstr(args, dev->name))) {
5286         if (!(q = strstr(p+strlen(dev->name), "eth"))) q = p + strlen(p);
5287         t = *q;
5288         *q = '\0';
5289
5290         if (strstr(p, "fdx") || strstr(p, "FDX")) lp->params.fdx = 1;
5291
5292         if (strstr(p, "autosense") || strstr(p, "AUTOSENSE")) {
5293             if (strstr(p, "TP")) {
5294                 lp->params.autosense = TP;
5295             } else if (strstr(p, "TP_NW")) {
5296                 lp->params.autosense = TP_NW;
5297             } else if (strstr(p, "BNC")) {
5298                 lp->params.autosense = BNC;
5299             } else if (strstr(p, "AUI")) {
5300                 lp->params.autosense = AUI;
5301             } else if (strstr(p, "BNC_AUI")) {
5302                 lp->params.autosense = BNC;
5303             } else if (strstr(p, "10Mb")) {
5304                 lp->params.autosense = _10Mb;
5305             } else if (strstr(p, "100Mb")) {
5306                 lp->params.autosense = _100Mb;
5307             } else if (strstr(p, "AUTO")) {
5308                 lp->params.autosense = AUTO;
5309             }
5310         }
5311         *q = t;
5312     }
5313
5314     return;
5315 }
5316
5317 static void
5318 de4x5_dbg_open(struct net_device *dev)
5319 {
5320     struct de4x5_private *lp = netdev_priv(dev);
5321     int i;
5322
5323     if (de4x5_debug & DEBUG_OPEN) {
5324         printk("%s: de4x5 opening with irq %d\n",dev->name,dev->irq);
5325         printk("\tphysical address: ");
5326         for (i=0;i<6;i++) {
5327             printk("%2.2x:",(short)dev->dev_addr[i]);
5328         }
5329         printk("\n");
5330         printk("Descriptor head addresses:\n");
5331         printk("\t0x%8.8lx  0x%8.8lx\n",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
5332         printk("Descriptor addresses:\nRX: ");
5333         for (i=0;i<lp->rxRingSize-1;i++){
5334             if (i < 3) {
5335                 printk("0x%8.8lx  ",(u_long)&lp->rx_ring[i].status);
5336             }
5337         }
5338         printk("...0x%8.8lx\n",(u_long)&lp->rx_ring[i].status);
5339         printk("TX: ");
5340         for (i=0;i<lp->txRingSize-1;i++){
5341             if (i < 3) {
5342                 printk("0x%8.8lx  ", (u_long)&lp->tx_ring[i].status);
5343             }
5344         }
5345         printk("...0x%8.8lx\n", (u_long)&lp->tx_ring[i].status);
5346         printk("Descriptor buffers:\nRX: ");
5347         for (i=0;i<lp->rxRingSize-1;i++){
5348             if (i < 3) {
5349                 printk("0x%8.8x  ",le32_to_cpu(lp->rx_ring[i].buf));
5350             }
5351         }
5352         printk("...0x%8.8x\n",le32_to_cpu(lp->rx_ring[i].buf));
5353         printk("TX: ");
5354         for (i=0;i<lp->txRingSize-1;i++){
5355             if (i < 3) {
5356                 printk("0x%8.8x  ", le32_to_cpu(lp->tx_ring[i].buf));
5357             }
5358         }
5359         printk("...0x%8.8x\n", le32_to_cpu(lp->tx_ring[i].buf));
5360         printk("Ring size: \nRX: %d\nTX: %d\n",
5361                (short)lp->rxRingSize,
5362                (short)lp->txRingSize);
5363     }
5364
5365     return;
5366 }
5367
5368 static void
5369 de4x5_dbg_mii(struct net_device *dev, int k)
5370 {
5371     struct de4x5_private *lp = netdev_priv(dev);
5372     u_long iobase = dev->base_addr;
5373
5374     if (de4x5_debug & DEBUG_MII) {
5375         printk("\nMII device address: %d\n", lp->phy[k].addr);
5376         printk("MII CR:  %x\n",mii_rd(MII_CR,lp->phy[k].addr,DE4X5_MII));
5377         printk("MII SR:  %x\n",mii_rd(MII_SR,lp->phy[k].addr,DE4X5_MII));
5378         printk("MII ID0: %x\n",mii_rd(MII_ID0,lp->phy[k].addr,DE4X5_MII));
5379         printk("MII ID1: %x\n",mii_rd(MII_ID1,lp->phy[k].addr,DE4X5_MII));
5380         if (lp->phy[k].id != BROADCOM_T4) {
5381             printk("MII ANA: %x\n",mii_rd(0x04,lp->phy[k].addr,DE4X5_MII));
5382             printk("MII ANC: %x\n",mii_rd(0x05,lp->phy[k].addr,DE4X5_MII));
5383         }
5384         printk("MII 16:  %x\n",mii_rd(0x10,lp->phy[k].addr,DE4X5_MII));
5385         if (lp->phy[k].id != BROADCOM_T4) {
5386             printk("MII 17:  %x\n",mii_rd(0x11,lp->phy[k].addr,DE4X5_MII));
5387             printk("MII 18:  %x\n",mii_rd(0x12,lp->phy[k].addr,DE4X5_MII));
5388         } else {
5389             printk("MII 20:  %x\n",mii_rd(0x14,lp->phy[k].addr,DE4X5_MII));
5390         }
5391     }
5392
5393     return;
5394 }
5395
5396 static void
5397 de4x5_dbg_media(struct net_device *dev)
5398 {
5399     struct de4x5_private *lp = netdev_priv(dev);
5400
5401     if (lp->media != lp->c_media) {
5402         if (de4x5_debug & DEBUG_MEDIA) {
5403             printk("%s: media is %s%s\n", dev->name,
5404                    (lp->media == NC  ? "unconnected, link down or incompatible connection" :
5405                     (lp->media == TP  ? "TP" :
5406                      (lp->media == ANS ? "TP/Nway" :
5407                       (lp->media == BNC ? "BNC" :
5408                        (lp->media == AUI ? "AUI" :
5409                         (lp->media == BNC_AUI ? "BNC/AUI" :
5410                          (lp->media == EXT_SIA ? "EXT SIA" :
5411                           (lp->media == _100Mb  ? "100Mb/s" :
5412                            (lp->media == _10Mb   ? "10Mb/s" :
5413                             "???"
5414                             ))))))))), (lp->fdx?" full duplex.":"."));
5415         }
5416         lp->c_media = lp->media;
5417     }
5418
5419     return;
5420 }
5421
5422 static void
5423 de4x5_dbg_srom(struct de4x5_srom *p)
5424 {
5425     int i;
5426     DECLARE_MAC_BUF(mac);
5427
5428     if (de4x5_debug & DEBUG_SROM) {
5429         printk("Sub-system Vendor ID: %04x\n", *((u_short *)p->sub_vendor_id));
5430         printk("Sub-system ID:        %04x\n", *((u_short *)p->sub_system_id));
5431         printk("ID Block CRC:         %02x\n", (u_char)(p->id_block_crc));
5432         printk("SROM version:         %02x\n", (u_char)(p->version));
5433         printk("# controllers:        %02x\n", (u_char)(p->num_controllers));
5434
5435         printk("Hardware Address:     %s\n", print_mac(mac, p->ieee_addr));
5436         printk("CRC checksum:         %04x\n", (u_short)(p->chksum));
5437         for (i=0; i<64; i++) {
5438             printk("%3d %04x\n", i<<1, (u_short)*((u_short *)p+i));
5439         }
5440     }
5441
5442     return;
5443 }
5444
5445 static void
5446 de4x5_dbg_rx(struct sk_buff *skb, int len)
5447 {
5448     int i, j;
5449     DECLARE_MAC_BUF(mac);
5450     DECLARE_MAC_BUF(mac2);
5451
5452     if (de4x5_debug & DEBUG_RX) {
5453         printk("R: %s <- %s len/SAP:%02x%02x [%d]\n",
5454                print_mac(mac, skb->data), print_mac(mac2, &skb->data[6]),
5455                (u_char)skb->data[12],
5456                (u_char)skb->data[13],
5457                len);
5458         for (j=0; len>0;j+=16, len-=16) {
5459           printk("    %03x: ",j);
5460           for (i=0; i<16 && i<len; i++) {
5461             printk("%02x ",(u_char)skb->data[i+j]);
5462           }
5463           printk("\n");
5464         }
5465     }
5466
5467     return;
5468 }
5469
5470 /*
5471 ** Perform IOCTL call functions here. Some are privileged operations and the
5472 ** effective uid is checked in those cases. In the normal course of events
5473 ** this function is only used for my testing.
5474 */
5475 static int
5476 de4x5_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5477 {
5478     struct de4x5_private *lp = netdev_priv(dev);
5479     struct de4x5_ioctl *ioc = (struct de4x5_ioctl *) &rq->ifr_ifru;
5480     u_long iobase = dev->base_addr;
5481     int i, j, status = 0;
5482     s32 omr;
5483     union {
5484         u8  addr[144];
5485         u16 sval[72];
5486         u32 lval[36];
5487     } tmp;
5488     u_long flags = 0;
5489
5490     switch(ioc->cmd) {
5491     case DE4X5_GET_HWADDR:           /* Get the hardware address */
5492         ioc->len = ETH_ALEN;
5493         for (i=0; i<ETH_ALEN; i++) {
5494             tmp.addr[i] = dev->dev_addr[i];
5495         }
5496         if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5497         break;
5498
5499     case DE4X5_SET_HWADDR:           /* Set the hardware address */
5500         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5501         if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN)) return -EFAULT;
5502         if (netif_queue_stopped(dev))
5503                 return -EBUSY;
5504         netif_stop_queue(dev);
5505         for (i=0; i<ETH_ALEN; i++) {
5506             dev->dev_addr[i] = tmp.addr[i];
5507         }
5508         build_setup_frame(dev, PHYS_ADDR_ONLY);
5509         /* Set up the descriptor and give ownership to the card */
5510         load_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET |
5511                                                        SETUP_FRAME_LEN, (struct sk_buff *)1);
5512         lp->tx_new = (++lp->tx_new) % lp->txRingSize;
5513         outl(POLL_DEMAND, DE4X5_TPD);                /* Start the TX */
5514         netif_wake_queue(dev);                      /* Unlock the TX ring */
5515         break;
5516
5517     case DE4X5_SET_PROM:             /* Set Promiscuous Mode */
5518         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5519         omr = inl(DE4X5_OMR);
5520         omr |= OMR_PR;
5521         outl(omr, DE4X5_OMR);
5522         dev->flags |= IFF_PROMISC;
5523         break;
5524
5525     case DE4X5_CLR_PROM:             /* Clear Promiscuous Mode */
5526         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5527         omr = inl(DE4X5_OMR);
5528         omr &= ~OMR_PR;
5529         outl(omr, DE4X5_OMR);
5530         dev->flags &= ~IFF_PROMISC;
5531         break;
5532
5533     case DE4X5_SAY_BOO:              /* Say "Boo!" to the kernel log file */
5534         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5535         printk("%s: Boo!\n", dev->name);
5536         break;
5537
5538     case DE4X5_MCA_EN:               /* Enable pass all multicast addressing */
5539         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5540         omr = inl(DE4X5_OMR);
5541         omr |= OMR_PM;
5542         outl(omr, DE4X5_OMR);
5543         break;
5544
5545     case DE4X5_GET_STATS:            /* Get the driver statistics */
5546     {
5547         struct pkt_stats statbuf;
5548         ioc->len = sizeof(statbuf);
5549         spin_lock_irqsave(&lp->lock, flags);
5550         memcpy(&statbuf, &lp->pktStats, ioc->len);
5551         spin_unlock_irqrestore(&lp->lock, flags);
5552         if (copy_to_user(ioc->data, &statbuf, ioc->len))
5553                 return -EFAULT;
5554         break;
5555     }
5556     case DE4X5_CLR_STATS:            /* Zero out the driver statistics */
5557         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5558         spin_lock_irqsave(&lp->lock, flags);
5559         memset(&lp->pktStats, 0, sizeof(lp->pktStats));
5560         spin_unlock_irqrestore(&lp->lock, flags);
5561         break;
5562
5563     case DE4X5_GET_OMR:              /* Get the OMR Register contents */
5564         tmp.addr[0] = inl(DE4X5_OMR);
5565         if (copy_to_user(ioc->data, tmp.addr, 1)) return -EFAULT;
5566         break;
5567
5568     case DE4X5_SET_OMR:              /* Set the OMR Register contents */
5569         if (!capable(CAP_NET_ADMIN)) return -EPERM;
5570         if (copy_from_user(tmp.addr, ioc->data, 1)) return -EFAULT;
5571         outl(tmp.addr[0], DE4X5_OMR);
5572         break;
5573
5574     case DE4X5_GET_REG:              /* Get the DE4X5 Registers */
5575         j = 0;
5576         tmp.lval[0] = inl(DE4X5_STS); j+=4;
5577         tmp.lval[1] = inl(DE4X5_BMR); j+=4;
5578         tmp.lval[2] = inl(DE4X5_IMR); j+=4;
5579         tmp.lval[3] = inl(DE4X5_OMR); j+=4;
5580         tmp.lval[4] = inl(DE4X5_SISR); j+=4;
5581         tmp.lval[5] = inl(DE4X5_SICR); j+=4;
5582         tmp.lval[6] = inl(DE4X5_STRR); j+=4;
5583         tmp.lval[7] = inl(DE4X5_SIGR); j+=4;
5584         ioc->len = j;
5585         if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5586         break;
5587
5588 #define DE4X5_DUMP              0x0f /* Dump the DE4X5 Status */
5589 /*
5590       case DE4X5_DUMP:
5591         j = 0;
5592         tmp.addr[j++] = dev->irq;
5593         for (i=0; i<ETH_ALEN; i++) {
5594             tmp.addr[j++] = dev->dev_addr[i];
5595         }
5596         tmp.addr[j++] = lp->rxRingSize;
5597         tmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
5598         tmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
5599
5600         for (i=0;i<lp->rxRingSize-1;i++){
5601             if (i < 3) {
5602                 tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
5603             }
5604         }
5605         tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
5606         for (i=0;i<lp->txRingSize-1;i++){
5607             if (i < 3) {
5608                 tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
5609             }
5610         }
5611         tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
5612
5613         for (i=0;i<lp->rxRingSize-1;i++){
5614             if (i < 3) {
5615                 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
5616             }
5617         }
5618         tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
5619         for (i=0;i<lp->txRingSize-1;i++){
5620             if (i < 3) {
5621                 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
5622             }
5623         }
5624         tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
5625
5626         for (i=0;i<lp->rxRingSize;i++){
5627             tmp.lval[j>>2] = le32_to_cpu(lp->rx_ring[i].status); j+=4;
5628         }
5629         for (i=0;i<lp->txRingSize;i++){
5630             tmp.lval[j>>2] = le32_to_cpu(lp->tx_ring[i].status); j+=4;
5631         }
5632
5633         tmp.lval[j>>2] = inl(DE4X5_BMR);  j+=4;
5634         tmp.lval[j>>2] = inl(DE4X5_TPD);  j+=4;
5635         tmp.lval[j>>2] = inl(DE4X5_RPD);  j+=4;
5636         tmp.lval[j>>2] = inl(DE4X5_RRBA); j+=4;
5637         tmp.lval[j>>2] = inl(DE4X5_TRBA); j+=4;
5638         tmp.lval[j>>2] = inl(DE4X5_STS);  j+=4;
5639         tmp.lval[j>>2] = inl(DE4X5_OMR);  j+=4;
5640         tmp.lval[j>>2] = inl(DE4X5_IMR);  j+=4;
5641         tmp.lval[j>>2] = lp->chipset; j+=4;
5642         if (lp->chipset == DC21140) {
5643             tmp.lval[j>>2] = gep_rd(dev);  j+=4;
5644         } else {
5645             tmp.lval[j>>2] = inl(DE4X5_SISR); j+=4;
5646             tmp.lval[j>>2] = inl(DE4X5_SICR); j+=4;
5647             tmp.lval[j>>2] = inl(DE4X5_STRR); j+=4;
5648             tmp.lval[j>>2] = inl(DE4X5_SIGR); j+=4;
5649         }
5650         tmp.lval[j>>2] = lp->phy[lp->active].id; j+=4;
5651         if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
5652             tmp.lval[j>>2] = lp->active; j+=4;
5653             tmp.lval[j>>2]=mii_rd(MII_CR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5654             tmp.lval[j>>2]=mii_rd(MII_SR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5655             tmp.lval[j>>2]=mii_rd(MII_ID0,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5656             tmp.lval[j>>2]=mii_rd(MII_ID1,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5657             if (lp->phy[lp->active].id != BROADCOM_T4) {
5658                 tmp.lval[j>>2]=mii_rd(MII_ANA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5659                 tmp.lval[j>>2]=mii_rd(MII_ANLPA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5660             }
5661             tmp.lval[j>>2]=mii_rd(0x10,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5662             if (lp->phy[lp->active].id != BROADCOM_T4) {
5663                 tmp.lval[j>>2]=mii_rd(0x11,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5664                 tmp.lval[j>>2]=mii_rd(0x12,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5665             } else {
5666                 tmp.lval[j>>2]=mii_rd(0x14,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5667             }
5668         }
5669
5670         tmp.addr[j++] = lp->txRingSize;
5671         tmp.addr[j++] = netif_queue_stopped(dev);
5672
5673         ioc->len = j;
5674         if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5675         break;
5676
5677 */
5678     default:
5679         return -EOPNOTSUPP;
5680     }
5681
5682     return status;
5683 }
5684
5685 static int __init de4x5_module_init (void)
5686 {
5687         int err = 0;
5688
5689 #ifdef CONFIG_PCI
5690         err = pci_register_driver(&de4x5_pci_driver);
5691 #endif
5692 #ifdef CONFIG_EISA
5693         err |= eisa_driver_register (&de4x5_eisa_driver);
5694 #endif
5695
5696         return err;
5697 }
5698
5699 static void __exit de4x5_module_exit (void)
5700 {
5701 #ifdef CONFIG_PCI
5702         pci_unregister_driver (&de4x5_pci_driver);
5703 #endif
5704 #ifdef CONFIG_EISA
5705         eisa_driver_unregister (&de4x5_eisa_driver);
5706 #endif
5707 }
5708
5709 module_init (de4x5_module_init);
5710 module_exit (de4x5_module_exit);