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