?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / net / tulip / de4x5.c
blob05e8947f9047d4ea8eec364682ecae3e238fbb49
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
471 #include <asm/bitops.h>
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 lp->lock = SPIN_LOCK_UNLOCKED;
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 lp->lock = SPIN_LOCK_UNLOCKED;
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 #endif
2128
2129 #ifdef CONFIG_PCI
2130
2131 /*
2132 ** This function searches the current bus (which is >0) for a DECchip with an
2133 ** SROM, so that in multiport cards that have one SROM shared between multiple
2134 ** DECchips, we can find the base SROM irrespective of the BIOS scan direction.
2135 ** For single port cards this is a time waster...
2136 */
2137 static void __devinit
2138 srom_search(struct net_device *dev, struct pci_dev *pdev)
2139 {
2140 u_char pb;
2141 u_short vendor, status;
2142 u_int irq = 0, device;
2143 u_long iobase = 0; /* Clear upper 32 bits in Alphas */
2144 int i, j, cfrv;
2145 struct de4x5_private *lp = netdev_priv(dev);
2146 struct list_head *walk = &pdev->bus_list;
2147
2148 for (walk = walk->next; walk != &pdev->bus_list; walk = walk->next) {
2149 struct pci_dev *this_dev = pci_dev_b(walk);
2150
2151 /* Skip the pci_bus list entry */
2152 if (list_entry(walk, struct pci_bus, devices) == pdev->bus) continue;
2153
2154 vendor = this_dev->vendor;
2155 device = this_dev->device << 8;
2156 if (!(is_DC21040 || is_DC21041 || is_DC21140 || is_DC2114x)) continue;
2157
2158 /* Get the chip configuration revision register */
2159 pb = this_dev->bus->number;
2160 pci_read_config_dword(this_dev, PCI_REVISION_ID, &cfrv);
2161
2162 /* Set the device number information */
2163 lp->device = PCI_SLOT(this_dev->devfn);
2164 lp->bus_num = pb;
2165
2166 /* Set the chipset information */
2167 if (is_DC2114x) {
2168 device = ((cfrv & CFRV_RN) < DC2114x_BRK ? DC21142 : DC21143);
2169 }
2170 lp->chipset = device;
2171
2172 /* Get the board I/O address (64 bits on sparc64) */
2173 iobase = pci_resource_start(this_dev, 0);
2174
2175 /* Fetch the IRQ to be used */
2176 irq = this_dev->irq;
2177 if ((irq == 0) || (irq == 0xff) || ((int)irq == -1)) continue;
2178
2179 /* Check if I/O accesses are enabled */
2180 pci_read_config_word(this_dev, PCI_COMMAND, &status);
2181 if (!(status & PCI_COMMAND_IO)) continue;
2182
2183 /* Search for a valid SROM attached to this DECchip */
2184 DevicePresent(dev, DE4X5_APROM);
2185 for (j=0, i=0; i<ETH_ALEN; i++) {
2186 j += (u_char) *((u_char *)&lp->srom + SROM_HWADD + i);
2187 }
2188 if ((j != 0) && (j != 0x5fa)) {
2189 last.chipset = device;
2190 last.bus = pb;
2191 last.irq = irq;
2192 for (i=0; i<ETH_ALEN; i++) {
2193 last.addr[i] = (u_char)*((u_char *)&lp->srom + SROM_HWADD + i);
2194 }
2195 return;
2196 }
2197 }
2198
2199 return;
2200 }
2201
2202 /*
2203 ** PCI bus I/O device probe
2204 ** NB: PCI I/O accesses and Bus Mastering are enabled by the PCI BIOS, not
2205 ** the driver. Some PCI BIOS's, pre V2.1, need the slot + features to be
2206 ** enabled by the user first in the set up utility. Hence we just check for
2207 ** enabled features and silently ignore the card if they're not.
2208 **
2209 ** STOP PRESS: Some BIOS's __require__ the driver to enable the bus mastering
2210 ** bit. Here, check for I/O accesses and then set BM. If you put the card in
2211 ** a non BM slot, you're on your own (and complain to the PC vendor that your
2212 ** PC doesn't conform to the PCI standard)!
2213 **
2214 ** This function is only compatible with the *latest* 2.1.x kernels. For 2.0.x
2215 ** kernels use the V0.535[n] drivers.
2216 */
2217
2218 static int __devinit de4x5_pci_probe (struct pci_dev *pdev,
2219 const struct pci_device_id *ent)
2220 {
2221 u_char pb, pbus = 0, dev_num, dnum = 0, timer;
2222 u_short vendor, status;
2223 u_int irq = 0, device;
2224 u_long iobase = 0; /* Clear upper 32 bits in Alphas */
2225 int error;
2226 struct net_device *dev;
2227 struct de4x5_private *lp;
2228
2229 dev_num = PCI_SLOT(pdev->devfn);
2230 pb = pdev->bus->number;
2231
2232 if (io) { /* probe a single PCI device */
2233 pbus = (u_short)(io >> 8);
2234 dnum = (u_short)(io & 0xff);
2235 if ((pbus != pb) || (dnum != dev_num))
2236 return -ENODEV;
2237 }
2238
2239 vendor = pdev->vendor;
2240 device = pdev->device << 8;
2241 if (!(is_DC21040 || is_DC21041 || is_DC21140 || is_DC2114x))
2242 return -ENODEV;
2243
2244 /* Ok, the device seems to be for us. */
2245 if (pci_enable_device (pdev))
2246 return -ENODEV;
2247
2248 if (!(dev = alloc_etherdev (sizeof (struct de4x5_private)))) {
2249 error = -ENOMEM;
2250 goto disable_dev;
2251 }
2252
2253 lp = netdev_priv(dev);
2254 lp->bus = PCI;
2255 lp->bus_num = 0;
2256
2257 /* Search for an SROM on this bus */
2258 if (lp->bus_num != pb) {
2259 lp->bus_num = pb;
2260 srom_search(dev, pdev);
2261 }
2262
2263 /* Get the chip configuration revision register */
2264 pci_read_config_dword(pdev, PCI_REVISION_ID, &lp->cfrv);
2265
2266 /* Set the device number information */
2267 lp->device = dev_num;
2268 lp->bus_num = pb;
2269
2270 /* Set the chipset information */
2271 if (is_DC2114x) {
2272 device = ((lp->cfrv & CFRV_RN) < DC2114x_BRK ? DC21142 : DC21143);
2273 }
2274 lp->chipset = device;
2275
2276 /* Get the board I/O address (64 bits on sparc64) */
2277 iobase = pci_resource_start(pdev, 0);
2278
2279 /* Fetch the IRQ to be used */
2280 irq = pdev->irq;
2281 if ((irq == 0) || (irq == 0xff) || ((int)irq == -1)) {
2282 error = -ENODEV;
2283 goto free_dev;
2284 }
2285
2286 /* Check if I/O accesses and Bus Mastering are enabled */
2287 pci_read_config_word(pdev, PCI_COMMAND, &status);
2288 #ifdef __powerpc__
2289 if (!(status & PCI_COMMAND_IO)) {
2290 status |= PCI_COMMAND_IO;
2291 pci_write_config_word(pdev, PCI_COMMAND, status);
2292 pci_read_config_word(pdev, PCI_COMMAND, &status);
2293 }
2294 #endif /* __powerpc__ */
2295 if (!(status & PCI_COMMAND_IO)) {
2296 error = -ENODEV;
2297 goto free_dev;
2298 }
2299
2300 if (!(status & PCI_COMMAND_MASTER)) {
2301 status |= PCI_COMMAND_MASTER;
2302 pci_write_config_word(pdev, PCI_COMMAND, status);
2303 pci_read_config_word(pdev, PCI_COMMAND, &status);
2304 }
2305 if (!(status & PCI_COMMAND_MASTER)) {
2306 error = -ENODEV;
2307 goto free_dev;
2308 }
2309
2310 /* Check the latency timer for values >= 0x60 */
2311 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &timer);
2312 if (timer < 0x60) {
2313 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x60);
2314 }
2315
2316 DevicePresent(dev, DE4X5_APROM);
2317
2318 if (!request_region (iobase, DE4X5_PCI_TOTAL_SIZE, "de4x5")) {
2319 error = -EBUSY;
2320 goto free_dev;
2321 }
2322
2323 dev->irq = irq;
2324
2325 if ((error = de4x5_hw_init(dev, iobase, &pdev->dev))) {
2326 goto release;
2327 }
2328
2329 return 0;
2330
2331 release:
2332 release_region (iobase, DE4X5_PCI_TOTAL_SIZE);
2333 free_dev:
2334 free_netdev (dev);
2335 disable_dev:
2336 pci_disable_device (pdev);
2337 return error;
2338 }
2339
2340 static void __devexit de4x5_pci_remove (struct pci_dev *pdev)
2341 {
2342 struct net_device *dev;
2343 u_long iobase;
2344
2345 dev = pdev->dev.driver_data;
2346 iobase = dev->base_addr;
2347
2348 unregister_netdev (dev);
2349 free_netdev (dev);
2350 release_region (iobase, DE4X5_PCI_TOTAL_SIZE);
2351 pci_disable_device (pdev);
2352 }
2353
2354 static struct pci_device_id de4x5_pci_tbl[] = {
2355 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
2356 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2357 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
2358 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
2359 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_FAST,
2360 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
2361 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21142,
2362 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
2363 { },
2364 };
2365
2366 static struct pci_driver de4x5_pci_driver = {
2367 .name = "de4x5",
2368 .id_table = de4x5_pci_tbl,
2369 .probe = de4x5_pci_probe,
2370 .remove = __devexit_p (de4x5_pci_remove),
2371 };
2372
2373 #endif
2374
2375 /*
2376 ** Auto configure the media here rather than setting the port at compile
2377 ** time. This routine is called by de4x5_init() and when a loss of media is
2378 ** detected (excessive collisions, loss of carrier, no carrier or link fail
2379 ** [TP] or no recent receive activity) to check whether the user has been
2380 ** sneaky and changed the port on us.
2381 */
2382 static int
2383 autoconf_media(struct net_device *dev)
2384 {
2385 struct de4x5_private *lp = netdev_priv(dev);
2386 u_long iobase = dev->base_addr;
2387 int next_tick = DE4X5_AUTOSENSE_MS;
2388
2389 lp->linkOK = 0;
2390 lp->c_media = AUTO; /* Bogus last media */
2391 disable_ast(dev);
2392 inl(DE4X5_MFC); /* Zero the lost frames counter */
2393 lp->media = INIT;
2394 lp->tcount = 0;
2395
2396 if (lp->useSROM) {
2397 next_tick = srom_autoconf(dev);
2398 } else if (lp->chipset == DC21040) {
2399 next_tick = dc21040_autoconf(dev);
2400 } else if (lp->chipset == DC21041) {
2401 next_tick = dc21041_autoconf(dev);
2402 } else if (lp->chipset == DC21140) {
2403 next_tick = dc21140m_autoconf(dev);
2404 }
2405
2406 enable_ast(dev, next_tick);
2407
2408 return (lp->media);
2409 }
2410
2411 /*
2412 ** Autoconfigure the media when using the DC21040. AUI cannot be distinguished
2413 ** from BNC as the port has a jumper to set thick or thin wire. When set for
2414 ** BNC, the BNC port will indicate activity if it's not terminated correctly.
2415 ** The only way to test for that is to place a loopback packet onto the
2416 ** network and watch for errors. Since we're messing with the interrupt mask
2417 ** register, disable the board interrupts and do not allow any more packets to
2418 ** be queued to the hardware. Re-enable everything only when the media is
2419 ** found.
2420 ** I may have to "age out" locally queued packets so that the higher layer
2421 ** timeouts don't effectively duplicate packets on the network.
2422 */
2423 static int
2424 dc21040_autoconf(struct net_device *dev)
2425 {
2426 struct de4x5_private *lp = netdev_priv(dev);
2427 u_long iobase = dev->base_addr;
2428 int next_tick = DE4X5_AUTOSENSE_MS;
2429 s32 imr;
2430
2431 switch (lp->media) {
2432 case INIT:
2433 DISABLE_IRQs;
2434 lp->tx_enable = NO;
2435 lp->timeout = -1;
2436 de4x5_save_skbs(dev);
2437 if ((lp->autosense == AUTO) || (lp->autosense == TP)) {
2438 lp->media = TP;
2439 } else if ((lp->autosense == BNC) || (lp->autosense == AUI) || (lp->autosense == BNC_AUI)) {
2440 lp->media = BNC_AUI;
2441 } else if (lp->autosense == EXT_SIA) {
2442 lp->media = EXT_SIA;
2443 } else {
2444 lp->media = NC;
2445 }
2446 lp->local_state = 0;
2447 next_tick = dc21040_autoconf(dev);
2448 break;
2449
2450 case TP:
2451 next_tick = dc21040_state(dev, 0x8f01, 0xffff, 0x0000, 3000, BNC_AUI,
2452 TP_SUSPECT, test_tp);
2453 break;
2454
2455 case TP_SUSPECT:
2456 next_tick = de4x5_suspect_state(dev, 1000, TP, test_tp, dc21040_autoconf);
2457 break;
2458
2459 case BNC:
2460 case AUI:
2461 case BNC_AUI:
2462 next_tick = dc21040_state(dev, 0x8f09, 0x0705, 0x0006, 3000, EXT_SIA,
2463 BNC_AUI_SUSPECT, ping_media);
2464 break;
2465
2466 case BNC_AUI_SUSPECT:
2467 next_tick = de4x5_suspect_state(dev, 1000, BNC_AUI, ping_media, dc21040_autoconf);
2468 break;
2469
2470 case EXT_SIA:
2471 next_tick = dc21040_state(dev, 0x3041, 0x0000, 0x0006, 3000,
2472 NC, EXT_SIA_SUSPECT, ping_media);
2473 break;
2474
2475 case EXT_SIA_SUSPECT:
2476 next_tick = de4x5_suspect_state(dev, 1000, EXT_SIA, ping_media, dc21040_autoconf);
2477 break;
2478
2479 case NC:
2480 /* default to TP for all */
2481 reset_init_sia(dev, 0x8f01, 0xffff, 0x0000);
2482 if (lp->media != lp->c_media) {
2483 de4x5_dbg_media(dev);
2484 lp->c_media = lp->media;
2485 }
2486 lp->media = INIT;
2487 lp->tx_enable = NO;
2488 break;
2489 }
2490
2491 return next_tick;
2492 }
2493
2494 static int
2495 dc21040_state(struct net_device *dev, int csr13, int csr14, int csr15, int timeout,
2496 int next_state, int suspect_state,
2497 int (*fn)(struct net_device *, int))
2498 {
2499 struct de4x5_private *lp = netdev_priv(dev);
2500 int next_tick = DE4X5_AUTOSENSE_MS;
2501 int linkBad;
2502
2503 switch (lp->local_state) {
2504 case 0:
2505 reset_init_sia(dev, csr13, csr14, csr15);
2506 lp->local_state++;
2507 next_tick = 500;
2508 break;
2509
2510 case 1:
2511 if (!lp->tx_enable) {
2512 linkBad = fn(dev, timeout);
2513 if (linkBad < 0) {
2514 next_tick = linkBad & ~TIMER_CB;
2515 } else {
2516 if (linkBad && (lp->autosense == AUTO)) {
2517 lp->local_state = 0;
2518 lp->media = next_state;
2519 } else {
2520 de4x5_init_connection(dev);
2521 }
2522 }
2523 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2524 lp->media = suspect_state;
2525 next_tick = 3000;
2526 }
2527 break;
2528 }
2529
2530 return next_tick;
2531 }
2532
2533 static int
2534 de4x5_suspect_state(struct net_device *dev, int timeout, int prev_state,
2535 int (*fn)(struct net_device *, int),
2536 int (*asfn)(struct net_device *))
2537 {
2538 struct de4x5_private *lp = netdev_priv(dev);
2539 int next_tick = DE4X5_AUTOSENSE_MS;
2540 int linkBad;
2541
2542 switch (lp->local_state) {
2543 case 1:
2544 if (lp->linkOK) {
2545 lp->media = prev_state;
2546 } else {
2547 lp->local_state++;
2548 next_tick = asfn(dev);
2549 }
2550 break;
2551
2552 case 2:
2553 linkBad = fn(dev, timeout);
2554 if (linkBad < 0) {
2555 next_tick = linkBad & ~TIMER_CB;
2556 } else if (!linkBad) {
2557 lp->local_state--;
2558 lp->media = prev_state;
2559 } else {
2560 lp->media = INIT;
2561 lp->tcount++;
2562 }
2563 }
2564
2565 return next_tick;
2566 }
2567
2568 /*
2569 ** Autoconfigure the media when using the DC21041. AUI needs to be tested
2570 ** before BNC, because the BNC port will indicate activity if it's not
2571 ** terminated correctly. The only way to test for that is to place a loopback
2572 ** packet onto the network and watch for errors. Since we're messing with
2573 ** the interrupt mask register, disable the board interrupts and do not allow
2574 ** any more packets to be queued to the hardware. Re-enable everything only
2575 ** when the media is found.
2576 */
2577 static int
2578 dc21041_autoconf(struct net_device *dev)
2579 {
2580 struct de4x5_private *lp = netdev_priv(dev);
2581 u_long iobase = dev->base_addr;
2582 s32 sts, irqs, irq_mask, imr, omr;
2583 int next_tick = DE4X5_AUTOSENSE_MS;
2584
2585 switch (lp->media) {
2586 case INIT:
2587 DISABLE_IRQs;
2588 lp->tx_enable = NO;
2589 lp->timeout = -1;
2590 de4x5_save_skbs(dev); /* Save non transmitted skb's */
2591 if ((lp->autosense == AUTO) || (lp->autosense == TP_NW)) {
2592 lp->media = TP; /* On chip auto negotiation is broken */
2593 } else if (lp->autosense == TP) {
2594 lp->media = TP;
2595 } else if (lp->autosense == BNC) {
2596 lp->media = BNC;
2597 } else if (lp->autosense == AUI) {
2598 lp->media = AUI;
2599 } else {
2600 lp->media = NC;
2601 }
2602 lp->local_state = 0;
2603 next_tick = dc21041_autoconf(dev);
2604 break;
2605
2606 case TP_NW:
2607 if (lp->timeout < 0) {
2608 omr = inl(DE4X5_OMR);/* Set up full duplex for the autonegotiate */
2609 outl(omr | OMR_FDX, DE4X5_OMR);
2610 }
2611 irqs = STS_LNF | STS_LNP;
2612 irq_mask = IMR_LFM | IMR_LPM;
2613 sts = test_media(dev, irqs, irq_mask, 0xef01, 0xffff, 0x0008, 2400);
2614 if (sts < 0) {
2615 next_tick = sts & ~TIMER_CB;
2616 } else {
2617 if (sts & STS_LNP) {
2618 lp->media = ANS;
2619 } else {
2620 lp->media = AUI;
2621 }
2622 next_tick = dc21041_autoconf(dev);
2623 }
2624 break;
2625
2626 case ANS:
2627 if (!lp->tx_enable) {
2628 irqs = STS_LNP;
2629 irq_mask = IMR_LPM;
2630 sts = test_ans(dev, irqs, irq_mask, 3000);
2631 if (sts < 0) {
2632 next_tick = sts & ~TIMER_CB;
2633 } else {
2634 if (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
2635 lp->media = TP;
2636 next_tick = dc21041_autoconf(dev);
2637 } else {
2638 lp->local_state = 1;
2639 de4x5_init_connection(dev);
2640 }
2641 }
2642 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2643 lp->media = ANS_SUSPECT;
2644 next_tick = 3000;
2645 }
2646 break;
2647
2648 case ANS_SUSPECT:
2649 next_tick = de4x5_suspect_state(dev, 1000, ANS, test_tp, dc21041_autoconf);
2650 break;
2651
2652 case TP:
2653 if (!lp->tx_enable) {
2654 if (lp->timeout < 0) {
2655 omr = inl(DE4X5_OMR); /* Set up half duplex for TP */
2656 outl(omr & ~OMR_FDX, DE4X5_OMR);
2657 }
2658 irqs = STS_LNF | STS_LNP;
2659 irq_mask = IMR_LFM | IMR_LPM;
2660 sts = test_media(dev,irqs, irq_mask, 0xef01, 0xff3f, 0x0008, 2400);
2661 if (sts < 0) {
2662 next_tick = sts & ~TIMER_CB;
2663 } else {
2664 if (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
2665 if (inl(DE4X5_SISR) & SISR_NRA) {
2666 lp->media = AUI; /* Non selected port activity */
2667 } else {
2668 lp->media = BNC;
2669 }
2670 next_tick = dc21041_autoconf(dev);
2671 } else {
2672 lp->local_state = 1;
2673 de4x5_init_connection(dev);
2674 }
2675 }
2676 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2677 lp->media = TP_SUSPECT;
2678 next_tick = 3000;
2679 }
2680 break;
2681
2682 case TP_SUSPECT:
2683 next_tick = de4x5_suspect_state(dev, 1000, TP, test_tp, dc21041_autoconf);
2684 break;
2685
2686 case AUI:
2687 if (!lp->tx_enable) {
2688 if (lp->timeout < 0) {
2689 omr = inl(DE4X5_OMR); /* Set up half duplex for AUI */
2690 outl(omr & ~OMR_FDX, DE4X5_OMR);
2691 }
2692 irqs = 0;
2693 irq_mask = 0;
2694 sts = test_media(dev,irqs, irq_mask, 0xef09, 0xf73d, 0x000e, 1000);
2695 if (sts < 0) {
2696 next_tick = sts & ~TIMER_CB;
2697 } else {
2698 if (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
2699 lp->media = BNC;
2700 next_tick = dc21041_autoconf(dev);
2701 } else {
2702 lp->local_state = 1;
2703 de4x5_init_connection(dev);
2704 }
2705 }
2706 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2707 lp->media = AUI_SUSPECT;
2708 next_tick = 3000;
2709 }
2710 break;
2711
2712 case AUI_SUSPECT:
2713 next_tick = de4x5_suspect_state(dev, 1000, AUI, ping_media, dc21041_autoconf);
2714 break;
2715
2716 case BNC:
2717 switch (lp->local_state) {
2718 case 0:
2719 if (lp->timeout < 0) {
2720 omr = inl(DE4X5_OMR); /* Set up half duplex for BNC */
2721 outl(omr & ~OMR_FDX, DE4X5_OMR);
2722 }
2723 irqs = 0;
2724 irq_mask = 0;
2725 sts = test_media(dev,irqs, irq_mask, 0xef09, 0xf73d, 0x0006, 1000);
2726 if (sts < 0) {
2727 next_tick = sts & ~TIMER_CB;
2728 } else {
2729 lp->local_state++; /* Ensure media connected */
2730 next_tick = dc21041_autoconf(dev);
2731 }
2732 break;
2733
2734 case 1:
2735 if (!lp->tx_enable) {
2736 if ((sts = ping_media(dev, 3000)) < 0) {
2737 next_tick = sts & ~TIMER_CB;
2738 } else {
2739 if (sts) {
2740 lp->local_state = 0;
2741 lp->media = NC;
2742 } else {
2743 de4x5_init_connection(dev);
2744 }
2745 }
2746 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
2747 lp->media = BNC_SUSPECT;
2748 next_tick = 3000;
2749 }
2750 break;
2751 }
2752 break;
2753
2754 case BNC_SUSPECT:
2755 next_tick = de4x5_suspect_state(dev, 1000, BNC, ping_media, dc21041_autoconf);
2756 break;
2757
2758 case NC:
2759 omr = inl(DE4X5_OMR); /* Set up full duplex for the autonegotiate */
2760 outl(omr | OMR_FDX, DE4X5_OMR);
2761 reset_init_sia(dev, 0xef01, 0xffff, 0x0008);/* Initialise the SIA */
2762 if (lp->media != lp->c_media) {
2763 de4x5_dbg_media(dev);
2764 lp->c_media = lp->media;
2765 }
2766 lp->media = INIT;
2767 lp->tx_enable = NO;
2768 break;
2769 }
2770
2771 return next_tick;
2772 }
2773
2774 /*
2775 ** Some autonegotiation chips are broken in that they do not return the
2776 ** acknowledge bit (anlpa & MII_ANLPA_ACK) in the link partner advertisement
2777 ** register, except at the first power up negotiation.
2778 */
2779 static int
2780 dc21140m_autoconf(struct net_device *dev)
2781 {
2782 struct de4x5_private *lp = netdev_priv(dev);
2783 int ana, anlpa, cap, cr, slnk, sr;
2784 int next_tick = DE4X5_AUTOSENSE_MS;
2785 u_long imr, omr, iobase = dev->base_addr;
2786
2787 switch(lp->media) {
2788 case INIT:
2789 if (lp->timeout < 0) {
2790 DISABLE_IRQs;
2791 lp->tx_enable = FALSE;
2792 lp->linkOK = 0;
2793 de4x5_save_skbs(dev); /* Save non transmitted skb's */
2794 }
2795 if ((next_tick = de4x5_reset_phy(dev)) < 0) {
2796 next_tick &= ~TIMER_CB;
2797 } else {
2798 if (lp->useSROM) {
2799 if (srom_map_media(dev) < 0) {
2800 lp->tcount++;
2801 return next_tick;
2802 }
2803 srom_exec(dev, lp->phy[lp->active].gep);
2804 if (lp->infoblock_media == ANS) {
2805 ana = lp->phy[lp->active].ana | MII_ANA_CSMA;
2806 mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2807 }
2808 } else {
2809 lp->tmp = MII_SR_ASSC; /* Fake out the MII speed set */
2810 SET_10Mb;
2811 if (lp->autosense == _100Mb) {
2812 lp->media = _100Mb;
2813 } else if (lp->autosense == _10Mb) {
2814 lp->media = _10Mb;
2815 } else if ((lp->autosense == AUTO) &&
2816 ((sr=is_anc_capable(dev)) & MII_SR_ANC)) {
2817 ana = (((sr >> 6) & MII_ANA_TAF) | MII_ANA_CSMA);
2818 ana &= (lp->fdx ? ~0 : ~MII_ANA_FDAM);
2819 mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2820 lp->media = ANS;
2821 } else if (lp->autosense == AUTO) {
2822 lp->media = SPD_DET;
2823 } else if (is_spd_100(dev) && is_100_up(dev)) {
2824 lp->media = _100Mb;
2825 } else {
2826 lp->media = NC;
2827 }
2828 }
2829 lp->local_state = 0;
2830 next_tick = dc21140m_autoconf(dev);
2831 }
2832 break;
2833
2834 case ANS:
2835 switch (lp->local_state) {
2836 case 0:
2837 if (lp->timeout < 0) {
2838 mii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
2839 }
2840 cr = test_mii_reg(dev, MII_CR, MII_CR_RAN, FALSE, 500);
2841 if (cr < 0) {
2842 next_tick = cr & ~TIMER_CB;
2843 } else {
2844 if (cr) {
2845 lp->local_state = 0;
2846 lp->media = SPD_DET;
2847 } else {
2848 lp->local_state++;
2849 }
2850 next_tick = dc21140m_autoconf(dev);
2851 }
2852 break;
2853
2854 case 1:
2855 if ((sr=test_mii_reg(dev, MII_SR, MII_SR_ASSC, TRUE, 2000)) < 0) {
2856 next_tick = sr & ~TIMER_CB;
2857 } else {
2858 lp->media = SPD_DET;
2859 lp->local_state = 0;
2860 if (sr) { /* Success! */
2861 lp->tmp = MII_SR_ASSC;
2862 anlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
2863 ana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
2864 if (!(anlpa & MII_ANLPA_RF) &&
2865 (cap = anlpa & MII_ANLPA_TAF & ana)) {
2866 if (cap & MII_ANA_100M) {
2867 lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_100M) ? TRUE : FALSE);
2868 lp->media = _100Mb;
2869 } else if (cap & MII_ANA_10M) {
2870 lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_10M) ? TRUE : FALSE);
2871
2872 lp->media = _10Mb;
2873 }
2874 }
2875 } /* Auto Negotiation failed to finish */
2876 next_tick = dc21140m_autoconf(dev);
2877 } /* Auto Negotiation failed to start */
2878 break;
2879 }
2880 break;
2881
2882 case SPD_DET: /* Choose 10Mb/s or 100Mb/s */
2883 if (lp->timeout < 0) {
2884 lp->tmp = (lp->phy[lp->active].id ? MII_SR_LKS :
2885 (~gep_rd(dev) & GEP_LNP));
2886 SET_100Mb_PDET;
2887 }
2888 if ((slnk = test_for_100Mb(dev, 6500)) < 0) {
2889 next_tick = slnk & ~TIMER_CB;
2890 } else {
2891 if (is_spd_100(dev) && is_100_up(dev)) {
2892 lp->media = _100Mb;
2893 } else if ((!is_spd_100(dev) && (is_10_up(dev) & lp->tmp))) {
2894 lp->media = _10Mb;
2895 } else {
2896 lp->media = NC;
2897 }
2898 next_tick = dc21140m_autoconf(dev);
2899 }
2900 break;
2901
2902 case _100Mb: /* Set 100Mb/s */
2903 next_tick = 3000;
2904 if (!lp->tx_enable) {
2905 SET_100Mb;
2906 de4x5_init_connection(dev);
2907 } else {
2908 if (!lp->linkOK && (lp->autosense == AUTO)) {
2909 if (!is_100_up(dev) || (!lp->useSROM && !is_spd_100(dev))) {
2910 lp->media = INIT;
2911 lp->tcount++;
2912 next_tick = DE4X5_AUTOSENSE_MS;
2913 }
2914 }
2915 }
2916 break;
2917
2918 case BNC:
2919 case AUI:
2920 case _10Mb: /* Set 10Mb/s */
2921 next_tick = 3000;
2922 if (!lp->tx_enable) {
2923 SET_10Mb;
2924 de4x5_init_connection(dev);
2925 } else {
2926 if (!lp->linkOK && (lp->autosense == AUTO)) {
2927 if (!is_10_up(dev) || (!lp->useSROM && is_spd_100(dev))) {
2928 lp->media = INIT;
2929 lp->tcount++;
2930 next_tick = DE4X5_AUTOSENSE_MS;
2931 }
2932 }
2933 }
2934 break;
2935
2936 case NC:
2937 if (lp->media != lp->c_media) {
2938 de4x5_dbg_media(dev);
2939 lp->c_media = lp->media;
2940 }
2941 lp->media = INIT;
2942 lp->tx_enable = FALSE;
2943 break;
2944 }
2945
2946 return next_tick;
2947 }
2948
2949 /*
2950 ** This routine may be merged into dc21140m_autoconf() sometime as I'm
2951 ** changing how I figure out the media - but trying to keep it backwards
2952 ** compatible with the de500-xa and de500-aa.
2953 ** Whether it's BNC, AUI, SYM or MII is sorted out in the infoblock
2954 ** functions and set during de4x5_mac_port() and/or de4x5_reset_phy().
2955 ** This routine just has to figure out whether 10Mb/s or 100Mb/s is
2956 ** active.
2957 ** When autonegotiation is working, the ANS part searches the SROM for
2958 ** the highest common speed (TP) link that both can run and if that can
2959 ** be full duplex. That infoblock is executed and then the link speed set.
2960 **
2961 ** Only _10Mb and _100Mb are tested here.
2962 */
2963 static int
2964 dc2114x_autoconf(struct net_device *dev)
2965 {
2966 struct de4x5_private *lp = netdev_priv(dev);
2967 u_long iobase = dev->base_addr;
2968 s32 cr, anlpa, ana, cap, irqs, irq_mask, imr, omr, slnk, sr, sts;
2969 int next_tick = DE4X5_AUTOSENSE_MS;
2970
2971 switch (lp->media) {
2972 case INIT:
2973 if (lp->timeout < 0) {
2974 DISABLE_IRQs;
2975 lp->tx_enable = FALSE;
2976 lp->linkOK = 0;
2977 lp->timeout = -1;
2978 de4x5_save_skbs(dev); /* Save non transmitted skb's */
2979 if (lp->params.autosense & ~AUTO) {
2980 srom_map_media(dev); /* Fixed media requested */
2981 if (lp->media != lp->params.autosense) {
2982 lp->tcount++;
2983 lp->media = INIT;
2984 return next_tick;
2985 }
2986 lp->media = INIT;
2987 }
2988 }
2989 if ((next_tick = de4x5_reset_phy(dev)) < 0) {
2990 next_tick &= ~TIMER_CB;
2991 } else {
2992 if (lp->autosense == _100Mb) {
2993 lp->media = _100Mb;
2994 } else if (lp->autosense == _10Mb) {
2995 lp->media = _10Mb;
2996 } else if (lp->autosense == TP) {
2997 lp->media = TP;
2998 } else if (lp->autosense == BNC) {
2999 lp->media = BNC;
3000 } else if (lp->autosense == AUI) {
3001 lp->media = AUI;
3002 } else {
3003 lp->media = SPD_DET;
3004 if ((lp->infoblock_media == ANS) &&
3005 ((sr=is_anc_capable(dev)) & MII_SR_ANC)) {
3006 ana = (((sr >> 6) & MII_ANA_TAF) | MII_ANA_CSMA);
3007 ana &= (lp->fdx ? ~0 : ~MII_ANA_FDAM);
3008 mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
3009 lp->media = ANS;
3010 }
3011 }
3012 lp->local_state = 0;
3013 next_tick = dc2114x_autoconf(dev);
3014 }
3015 break;
3016
3017 case ANS:
3018 switch (lp->local_state) {
3019 case 0:
3020 if (lp->timeout < 0) {
3021 mii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
3022 }
3023 cr = test_mii_reg(dev, MII_CR, MII_CR_RAN, FALSE, 500);
3024 if (cr < 0) {
3025 next_tick = cr & ~TIMER_CB;
3026 } else {
3027 if (cr) {
3028 lp->local_state = 0;
3029 lp->media = SPD_DET;
3030 } else {
3031 lp->local_state++;
3032 }
3033 next_tick = dc2114x_autoconf(dev);
3034 }
3035 break;
3036
3037 case 1:
3038 if ((sr=test_mii_reg(dev, MII_SR, MII_SR_ASSC, TRUE, 2000)) < 0) {
3039 next_tick = sr & ~TIMER_CB;
3040 } else {
3041 lp->media = SPD_DET;
3042 lp->local_state = 0;
3043 if (sr) { /* Success! */
3044 lp->tmp = MII_SR_ASSC;
3045 anlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
3046 ana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
3047 if (!(anlpa & MII_ANLPA_RF) &&
3048 (cap = anlpa & MII_ANLPA_TAF & ana)) {
3049 if (cap & MII_ANA_100M) {
3050 lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_100M) ? TRUE : FALSE);
3051 lp->media = _100Mb;
3052 } else if (cap & MII_ANA_10M) {
3053 lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_10M) ? TRUE : FALSE);
3054 lp->media = _10Mb;
3055 }
3056 }
3057 } /* Auto Negotiation failed to finish */
3058 next_tick = dc2114x_autoconf(dev);
3059 } /* Auto Negotiation failed to start */
3060 break;
3061 }
3062 break;
3063
3064 case AUI:
3065 if (!lp->tx_enable) {
3066 if (lp->timeout < 0) {
3067 omr = inl(DE4X5_OMR); /* Set up half duplex for AUI */
3068 outl(omr & ~OMR_FDX, DE4X5_OMR);
3069 }
3070 irqs = 0;
3071 irq_mask = 0;
3072 sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
3073 if (sts < 0) {
3074 next_tick = sts & ~TIMER_CB;
3075 } else {
3076 if (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
3077 lp->media = BNC;
3078 next_tick = dc2114x_autoconf(dev);
3079 } else {
3080 lp->local_state = 1;
3081 de4x5_init_connection(dev);
3082 }
3083 }
3084 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
3085 lp->media = AUI_SUSPECT;
3086 next_tick = 3000;
3087 }
3088 break;
3089
3090 case AUI_SUSPECT:
3091 next_tick = de4x5_suspect_state(dev, 1000, AUI, ping_media, dc2114x_autoconf);
3092 break;
3093
3094 case BNC:
3095 switch (lp->local_state) {
3096 case 0:
3097 if (lp->timeout < 0) {
3098 omr = inl(DE4X5_OMR); /* Set up half duplex for BNC */
3099 outl(omr & ~OMR_FDX, DE4X5_OMR);
3100 }
3101 irqs = 0;
3102 irq_mask = 0;
3103 sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
3104 if (sts < 0) {
3105 next_tick = sts & ~TIMER_CB;
3106 } else {
3107 lp->local_state++; /* Ensure media connected */
3108 next_tick = dc2114x_autoconf(dev);
3109 }
3110 break;
3111
3112 case 1:
3113 if (!lp->tx_enable) {
3114 if ((sts = ping_media(dev, 3000)) < 0) {
3115 next_tick = sts & ~TIMER_CB;
3116 } else {
3117 if (sts) {
3118 lp->local_state = 0;
3119 lp->tcount++;
3120 lp->media = INIT;
3121 } else {
3122 de4x5_init_connection(dev);
3123 }
3124 }
3125 } else if (!lp->linkOK && (lp->autosense == AUTO)) {
3126 lp->media = BNC_SUSPECT;
3127 next_tick = 3000;
3128 }
3129 break;
3130 }
3131 break;
3132
3133 case BNC_SUSPECT:
3134 next_tick = de4x5_suspect_state(dev, 1000, BNC, ping_media, dc2114x_autoconf);
3135 break;
3136
3137 case SPD_DET: /* Choose 10Mb/s or 100Mb/s */
3138 if (srom_map_media(dev) < 0) {
3139 lp->tcount++;
3140 lp->media = INIT;
3141 return next_tick;
3142 }
3143 if (lp->media == _100Mb) {
3144 if ((slnk = test_for_100Mb(dev, 6500)) < 0) {
3145 lp->media = SPD_DET;
3146 return (slnk & ~TIMER_CB);
3147 }
3148 } else {
3149 if (wait_for_link(dev) < 0) {
3150 lp->media = SPD_DET;
3151 return PDET_LINK_WAIT;
3152 }
3153 }
3154 if (lp->media == ANS) { /* Do MII parallel detection */
3155 if (is_spd_100(dev)) {
3156 lp->media = _100Mb;
3157 } else {
3158 lp->media = _10Mb;
3159 }
3160 next_tick = dc2114x_autoconf(dev);
3161 } else if (((lp->media == _100Mb) && is_100_up(dev)) ||
3162 (((lp->media == _10Mb) || (lp->media == TP) ||
3163 (lp->media == BNC) || (lp->media == AUI)) &&
3164 is_10_up(dev))) {
3165 next_tick = dc2114x_autoconf(dev);
3166 } else {
3167 lp->tcount++;
3168 lp->media = INIT;
3169 }
3170 break;
3171
3172 case _10Mb:
3173 next_tick = 3000;
3174 if (!lp->tx_enable) {
3175 SET_10Mb;
3176 de4x5_init_connection(dev);
3177 } else {
3178 if (!lp->linkOK && (lp->autosense == AUTO)) {
3179 if (!is_10_up(dev) || (!lp->useSROM && is_spd_100(dev))) {
3180 lp->media = INIT;
3181 lp->tcount++;
3182 next_tick = DE4X5_AUTOSENSE_MS;
3183 }
3184 }
3185 }
3186 break;
3187
3188 case _100Mb:
3189 next_tick = 3000;
3190 if (!lp->tx_enable) {
3191 SET_100Mb;
3192 de4x5_init_connection(dev);
3193 } else {
3194 if (!lp->linkOK && (lp->autosense == AUTO)) {
3195 if (!is_100_up(dev) || (!lp->useSROM && !is_spd_100(dev))) {
3196 lp->media = INIT;
3197 lp->tcount++;
3198 next_tick = DE4X5_AUTOSENSE_MS;
3199 }
3200 }
3201 }
3202 break;
3203
3204 default:
3205 lp->tcount++;
3206 printk("Huh?: media:%02x\n", lp->media);
3207 lp->media = INIT;
3208 break;
3209 }
3210
3211 return next_tick;
3212 }
3213
3214 static int
3215 srom_autoconf(struct net_device *dev)
3216 {
3217 struct de4x5_private *lp = netdev_priv(dev);
3218
3219 return lp->infoleaf_fn(dev);
3220 }
3221
3222 /*
3223 ** This mapping keeps the original media codes and FDX flag unchanged.
3224 ** While it isn't strictly necessary, it helps me for the moment...
3225 ** The early return avoids a media state / SROM media space clash.
3226 */
3227 static int
3228 srom_map_media(struct net_device *dev)
3229 {
3230 struct de4x5_private *lp = netdev_priv(dev);
3231
3232 lp->fdx = 0;
3233 if (lp->infoblock_media == lp->media)
3234 return 0;
3235
3236 switch(lp->infoblock_media) {
3237 case SROM_10BASETF:
3238 if (!lp->params.fdx) return -1;
3239 lp->fdx = TRUE;
3240 case SROM_10BASET:
3241 if (lp->params.fdx && !lp->fdx) return -1;
3242 if ((lp->chipset == DC21140) || ((lp->chipset & ~0x00ff) == DC2114x)) {
3243 lp->media = _10Mb;
3244 } else {
3245 lp->media = TP;
3246 }
3247 break;
3248
3249 case SROM_10BASE2:
3250 lp->media = BNC;
3251 break;
3252
3253 case SROM_10BASE5:
3254 lp->media = AUI;
3255 break;
3256
3257 case SROM_100BASETF:
3258 if (!lp->params.fdx) return -1;
3259 lp->fdx = TRUE;
3260 case SROM_100BASET:
3261 if (lp->params.fdx && !lp->fdx) return -1;
3262 lp->media = _100Mb;
3263 break;
3264
3265 case SROM_100BASET4:
3266 lp->media = _100Mb;
3267 break;
3268
3269 case SROM_100BASEFF:
3270 if (!lp->params.fdx) return -1;
3271 lp->fdx = TRUE;
3272 case SROM_100BASEF:
3273 if (lp->params.fdx && !lp->fdx) return -1;
3274 lp->media = _100Mb;
3275 break;
3276
3277 case ANS:
3278 lp->media = ANS;
3279 lp->fdx = lp->params.fdx;
3280 break;
3281
3282 default:
3283 printk("%s: Bad media code [%d] detected in SROM!\n", dev->name,
3284 lp->infoblock_media);
3285 return -1;
3286 break;
3287 }
3288
3289 return 0;
3290 }
3291
3292 static void
3293 de4x5_init_connection(struct net_device *dev)
3294 {
3295 struct de4x5_private *lp = netdev_priv(dev);
3296 u_long iobase = dev->base_addr;
3297 u_long flags = 0;
3298
3299 if (lp->media != lp->c_media) {
3300 de4x5_dbg_media(dev);
3301 lp->c_media = lp->media; /* Stop scrolling media messages */
3302 }
3303
3304 spin_lock_irqsave(&lp->lock, flags);
3305 de4x5_rst_desc_ring(dev);
3306 de4x5_setup_intr(dev);
3307 lp->tx_enable = YES;
3308 spin_unlock_irqrestore(&lp->lock, flags);
3309 outl(POLL_DEMAND, DE4X5_TPD);
3310
3311 netif_wake_queue(dev);
3312
3313 return;
3314 }
3315
3316 /*
3317 ** General PHY reset function. Some MII devices don't reset correctly
3318 ** since their MII address pins can float at voltages that are dependent
3319 ** on the signal pin use. Do a double reset to ensure a reset.
3320 */
3321 static int
3322 de4x5_reset_phy(struct net_device *dev)
3323 {
3324 struct de4x5_private *lp = netdev_priv(dev);
3325 u_long iobase = dev->base_addr;
3326 int next_tick = 0;
3327
3328 if ((lp->useSROM) || (lp->phy[lp->active].id)) {
3329 if (lp->timeout < 0) {
3330 if (lp->useSROM) {
3331 if (lp->phy[lp->active].rst) {
3332 srom_exec(dev, lp->phy[lp->active].rst);
3333 srom_exec(dev, lp->phy[lp->active].rst);
3334 } else if (lp->rst) { /* Type 5 infoblock reset */
3335 srom_exec(dev, lp->rst);
3336 srom_exec(dev, lp->rst);
3337 }
3338 } else {
3339 PHY_HARD_RESET;
3340 }
3341 if (lp->useMII) {
3342 mii_wr(MII_CR_RST, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
3343 }
3344 }
3345 if (lp->useMII) {
3346 next_tick = test_mii_reg(dev, MII_CR, MII_CR_RST, FALSE, 500);
3347 }
3348 } else if (lp->chipset == DC21140) {
3349 PHY_HARD_RESET;
3350 }
3351
3352 return next_tick;
3353 }
3354
3355 static int
3356 test_media(struct net_device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec)
3357 {
3358 struct de4x5_private *lp = netdev_priv(dev);
3359 u_long iobase = dev->base_addr;
3360 s32 sts, csr12;
3361
3362 if (lp->timeout < 0) {
3363 lp->timeout = msec/100;
3364 if (!lp->useSROM) { /* Already done if by SROM, else dc2104[01] */
3365 reset_init_sia(dev, csr13, csr14, csr15);
3366 }
3367
3368 /* set up the interrupt mask */
3369 outl(irq_mask, DE4X5_IMR);
3370
3371 /* clear all pending interrupts */
3372 sts = inl(DE4X5_STS);
3373 outl(sts, DE4X5_STS);
3374
3375 /* clear csr12 NRA and SRA bits */
3376 if ((lp->chipset == DC21041) || lp->useSROM) {
3377 csr12 = inl(DE4X5_SISR);
3378 outl(csr12, DE4X5_SISR);
3379 }
3380 }
3381
3382 sts = inl(DE4X5_STS) & ~TIMER_CB;
3383
3384 if (!(sts & irqs) && --lp->timeout) {
3385 sts = 100 | TIMER_CB;
3386 } else {
3387 lp->timeout = -1;
3388 }
3389
3390 return sts;
3391 }
3392
3393 static int
3394 test_tp(struct net_device *dev, s32 msec)
3395 {
3396 struct de4x5_private *lp = netdev_priv(dev);
3397 u_long iobase = dev->base_addr;
3398 int sisr;
3399
3400 if (lp->timeout < 0) {
3401 lp->timeout = msec/100;
3402 }
3403
3404 sisr = (inl(DE4X5_SISR) & ~TIMER_CB) & (SISR_LKF | SISR_NCR);
3405
3406 if (sisr && --lp->timeout) {
3407 sisr = 100 | TIMER_CB;
3408 } else {
3409 lp->timeout = -1;
3410 }
3411
3412 return sisr;
3413 }
3414
3415 /*
3416 ** Samples the 100Mb Link State Signal. The sample interval is important
3417 ** because too fast a rate can give erroneous results and confuse the
3418 ** speed sense algorithm.
3419 */
3420 #define SAMPLE_INTERVAL 500 /* ms */
3421 #define SAMPLE_DELAY 2000 /* ms */
3422 static int
3423 test_for_100Mb(struct net_device *dev, int msec)
3424 {
3425 struct de4x5_private *lp = netdev_priv(dev);
3426 int gep = 0, ret = ((lp->chipset & ~0x00ff)==DC2114x? -1 :GEP_SLNK);
3427
3428 if (lp->timeout < 0) {
3429 if ((msec/SAMPLE_INTERVAL) <= 0) return 0;
3430 if (msec > SAMPLE_DELAY) {
3431 lp->timeout = (msec - SAMPLE_DELAY)/SAMPLE_INTERVAL;
3432 gep = SAMPLE_DELAY | TIMER_CB;
3433 return gep;
3434 } else {
3435 lp->timeout = msec/SAMPLE_INTERVAL;
3436 }
3437 }
3438
3439 if (lp->phy[lp->active].id || lp->useSROM) {
3440 gep = is_100_up(dev) | is_spd_100(dev);
3441 } else {
3442 gep = (~gep_rd(dev) & (GEP_SLNK | GEP_LNP));
3443 }
3444 if (!(gep & ret) && --lp->timeout) {
3445 gep = SAMPLE_INTERVAL | TIMER_CB;
3446 } else {
3447 lp->timeout = -1;
3448 }
3449
3450 return gep;
3451 }
3452
3453 static int
3454 wait_for_link(struct net_device *dev)
3455 {
3456 struct de4x5_private *lp = netdev_priv(dev);
3457
3458 if (lp->timeout < 0) {
3459 lp->timeout = 1;
3460 }
3461
3462 if (lp->timeout--) {
3463 return TIMER_CB;
3464 } else {
3465 lp->timeout = -1;
3466 }
3467
3468 return 0;
3469 }
3470
3471 /*
3472 **
3473 **
3474 */
3475 static int
3476 test_mii_reg(struct net_device *dev, int reg, int mask, int pol, long msec)
3477 {
3478 struct de4x5_private *lp = netdev_priv(dev);
3479 int test;
3480 u_long iobase = dev->base_addr;
3481
3482 if (lp->timeout < 0) {
3483 lp->timeout = msec/100;
3484 }
3485
3486 if (pol) pol = ~0;
3487 reg = mii_rd((u_char)reg, lp->phy[lp->active].addr, DE4X5_MII) & mask;
3488 test = (reg ^ pol) & mask;
3489
3490 if (test && --lp->timeout) {
3491 reg = 100 | TIMER_CB;
3492 } else {
3493 lp->timeout = -1;
3494 }
3495
3496 return reg;
3497 }
3498
3499 static int
3500 is_spd_100(struct net_device *dev)
3501 {
3502 struct de4x5_private *lp = netdev_priv(dev);
3503 u_long iobase = dev->base_addr;
3504 int spd;
3505
3506 if (lp->useMII) {
3507 spd = mii_rd(lp->phy[lp->active].spd.reg, lp->phy[lp->active].addr, DE4X5_MII);
3508 spd = ~(spd ^ lp->phy[lp->active].spd.value);
3509 spd &= lp->phy[lp->active].spd.mask;
3510 } else if (!lp->useSROM) { /* de500-xa */
3511 spd = ((~gep_rd(dev)) & GEP_SLNK);
3512 } else {
3513 if ((lp->ibn == 2) || !lp->asBitValid)
3514 return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
3515
3516 spd = (lp->asBitValid & (lp->asPolarity ^ (gep_rd(dev) & lp->asBit))) |
3517 (lp->linkOK & ~lp->asBitValid);
3518 }
3519
3520 return spd;
3521 }
3522
3523 static int
3524 is_100_up(struct net_device *dev)
3525 {
3526 struct de4x5_private *lp = netdev_priv(dev);
3527 u_long iobase = dev->base_addr;
3528
3529 if (lp->useMII) {
3530 /* Double read for sticky bits & temporary drops */
3531 mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
3532 return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
3533 } else if (!lp->useSROM) { /* de500-xa */
3534 return ((~gep_rd(dev)) & GEP_SLNK);
3535 } else {
3536 if ((lp->ibn == 2) || !lp->asBitValid)
3537 return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
3538
3539 return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
3540 (lp->linkOK & ~lp->asBitValid));
3541 }
3542 }
3543
3544 static int
3545 is_10_up(struct net_device *dev)
3546 {
3547 struct de4x5_private *lp = netdev_priv(dev);
3548 u_long iobase = dev->base_addr;
3549
3550 if (lp->useMII) {
3551 /* Double read for sticky bits & temporary drops */
3552 mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
3553 return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
3554 } else if (!lp->useSROM) { /* de500-xa */
3555 return ((~gep_rd(dev)) & GEP_LNP);
3556 } else {
3557 if ((lp->ibn == 2) || !lp->asBitValid)
3558 return (((lp->chipset & ~0x00ff) == DC2114x) ?
3559 (~inl(DE4X5_SISR)&SISR_LS10):
3560 0);
3561
3562 return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
3563 (lp->linkOK & ~lp->asBitValid));
3564 }
3565 }
3566
3567 static int
3568 is_anc_capable(struct net_device *dev)
3569 {
3570 struct de4x5_private *lp = netdev_priv(dev);
3571 u_long iobase = dev->base_addr;
3572
3573 if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
3574 return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII));
3575 } else if ((lp->chipset & ~0x00ff) == DC2114x) {
3576 return (inl(DE4X5_SISR) & SISR_LPN) >> 12;
3577 } else {
3578 return 0;
3579 }
3580 }
3581
3582 /*
3583 ** Send a packet onto the media and watch for send errors that indicate the
3584 ** media is bad or unconnected.
3585 */
3586 static int
3587 ping_media(struct net_device *dev, int msec)
3588 {
3589 struct de4x5_private *lp = netdev_priv(dev);
3590 u_long iobase = dev->base_addr;
3591 int sisr;
3592
3593 if (lp->timeout < 0) {
3594 lp->timeout = msec/100;
3595
3596 lp->tmp = lp->tx_new; /* Remember the ring position */
3597 load_packet(dev, lp->frame, TD_LS | TD_FS | sizeof(lp->frame), (struct sk_buff *)1);
3598 lp->tx_new = (++lp->tx_new) % lp->txRingSize;
3599 outl(POLL_DEMAND, DE4X5_TPD);
3600 }
3601
3602 sisr = inl(DE4X5_SISR);
3603
3604 if ((!(sisr & SISR_NCR)) &&
3605 ((s32)le32_to_cpu(lp->tx_ring[lp->tmp].status) < 0) &&
3606 (--lp->timeout)) {
3607 sisr = 100 | TIMER_CB;
3608 } else {
3609 if ((!(sisr & SISR_NCR)) &&
3610 !(le32_to_cpu(lp->tx_ring[lp->tmp].status) & (T_OWN | TD_ES)) &&
3611 lp->timeout) {
3612 sisr = 0;
3613 } else {
3614 sisr = 1;
3615 }
3616 lp->timeout = -1;
3617 }
3618
3619 return sisr;
3620 }
3621
3622 /*
3623 ** This function does 2 things: on Intels it kmalloc's another buffer to
3624 ** replace the one about to be passed up. On Alpha's it kmallocs a buffer
3625 ** into which the packet is copied.
3626 */
3627 static struct sk_buff *
3628 de4x5_alloc_rx_buff(struct net_device *dev, int index, int len)
3629 {
3630 struct de4x5_private *lp = netdev_priv(dev);
3631 struct sk_buff *p;
3632
3633 #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__sparc_v9__) && !defined(DE4X5_DO_MEMCPY)
3634 struct sk_buff *ret;
3635 u_long i=0, tmp;
3636
3637 p = dev_alloc_skb(IEEE802_3_SZ + DE4X5_ALIGN + 2);
3638 if (!p) return NULL;
3639
3640 p->dev = dev;
3641 tmp = virt_to_bus(p->data);
3642 i = ((tmp + DE4X5_ALIGN) & ~DE4X5_ALIGN) - tmp;
3643 skb_reserve(p, i);
3644 lp->rx_ring[index].buf = cpu_to_le32(tmp + i);
3645
3646 ret = lp->rx_skb[index];
3647 lp->rx_skb[index] = p;
3648
3649 if ((u_long) ret > 1) {
3650 skb_put(ret, len);
3651 }
3652
3653 return ret;
3654
3655 #else
3656 if (lp->state != OPEN) return (struct sk_buff *)1; /* Fake out the open */
3657
3658 p = dev_alloc_skb(len + 2);
3659 if (!p) return NULL;
3660
3661 p->dev = dev;
3662 skb_reserve(p, 2); /* Align */
3663 if (index < lp->rx_old) { /* Wrapped buffer */
3664 short tlen = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
3665 memcpy(skb_put(p,tlen),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,tlen);
3666 memcpy(skb_put(p,len-tlen),lp->rx_bufs,len-tlen);
3667 } else { /* Linear buffer */
3668 memcpy(skb_put(p,len),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,len);
3669 }
3670
3671 return p;
3672 #endif
3673 }
3674
3675 static void
3676 de4x5_free_rx_buffs(struct net_device *dev)
3677 {
3678 struct de4x5_private *lp = netdev_priv(dev);
3679 int i;
3680
3681 for (i=0; i<lp->rxRingSize; i++) {
3682 if ((u_long) lp->rx_skb[i] > 1) {
3683 dev_kfree_skb(lp->rx_skb[i]);
3684 }
3685 lp->rx_ring[i].status = 0;
3686 lp->rx_skb[i] = (struct sk_buff *)1; /* Dummy entry */
3687 }
3688
3689 return;
3690 }
3691
3692 static void
3693 de4x5_free_tx_buffs(struct net_device *dev)
3694 {
3695 struct de4x5_private *lp = netdev_priv(dev);
3696 int i;
3697
3698 for (i=0; i<lp->txRingSize; i++) {
3699 if (lp->tx_skb[i])
3700 de4x5_free_tx_buff(lp, i);
3701 lp->tx_ring[i].status = 0;
3702 }
3703
3704 /* Unload the locally queued packets */
3705 while (lp->cache.skb) {
3706 dev_kfree_skb(de4x5_get_cache(dev));
3707 }
3708
3709 return;
3710 }
3711
3712 /*
3713 ** When a user pulls a connection, the DECchip can end up in a
3714 ** 'running - waiting for end of transmission' state. This means that we
3715 ** have to perform a chip soft reset to ensure that we can synchronize
3716 ** the hardware and software and make any media probes using a loopback
3717 ** packet meaningful.
3718 */
3719 static void
3720 de4x5_save_skbs(struct net_device *dev)
3721 {
3722 struct de4x5_private *lp = netdev_priv(dev);
3723 u_long iobase = dev->base_addr;
3724 s32 omr;
3725
3726 if (!lp->cache.save_cnt) {
3727 STOP_DE4X5;
3728 de4x5_tx(dev); /* Flush any sent skb's */
3729 de4x5_free_tx_buffs(dev);
3730 de4x5_cache_state(dev, DE4X5_SAVE_STATE);
3731 de4x5_sw_reset(dev);
3732 de4x5_cache_state(dev, DE4X5_RESTORE_STATE);
3733 lp->cache.save_cnt++;
3734 START_DE4X5;
3735 }
3736
3737 return;
3738 }
3739
3740 static void
3741 de4x5_rst_desc_ring(struct net_device *dev)
3742 {
3743 struct de4x5_private *lp = netdev_priv(dev);
3744 u_long iobase = dev->base_addr;
3745 int i;
3746 s32 omr;
3747
3748 if (lp->cache.save_cnt) {
3749 STOP_DE4X5;
3750 outl(lp->dma_rings, DE4X5_RRBA);
3751 outl(lp->dma_rings + NUM_RX_DESC * sizeof(struct de4x5_desc),
3752 DE4X5_TRBA);
3753
3754 lp->rx_new = lp->rx_old = 0;
3755 lp->tx_new = lp->tx_old = 0;
3756
3757 for (i = 0; i < lp->rxRingSize; i++) {
3758 lp->rx_ring[i].status = cpu_to_le32(R_OWN);
3759 }
3760
3761 for (i = 0; i < lp->txRingSize; i++) {
3762 lp->tx_ring[i].status = cpu_to_le32(0);
3763 }
3764
3765 barrier();
3766 lp->cache.save_cnt--;
3767 START_DE4X5;
3768 }
3769
3770 return;
3771 }
3772
3773 static void
3774 de4x5_cache_state(struct net_device *dev, int flag)
3775 {
3776 struct de4x5_private *lp = netdev_priv(dev);
3777 u_long iobase = dev->base_addr;
3778
3779 switch(flag) {
3780 case DE4X5_SAVE_STATE:
3781 lp->cache.csr0 = inl(DE4X5_BMR);
3782 lp->cache.csr6 = (inl(DE4X5_OMR) & ~(OMR_ST | OMR_SR));
3783 lp->cache.csr7 = inl(DE4X5_IMR);
3784 break;
3785
3786 case DE4X5_RESTORE_STATE:
3787 outl(lp->cache.csr0, DE4X5_BMR);
3788 outl(lp->cache.csr6, DE4X5_OMR);
3789 outl(lp->cache.csr7, DE4X5_IMR);
3790 if (lp->chipset == DC21140) {
3791 gep_wr(lp->cache.gepc, dev);
3792 gep_wr(lp->cache.gep, dev);
3793 } else {
3794 reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14,
3795 lp->cache.csr15);
3796 }
3797 break;
3798 }
3799
3800 return;
3801 }
3802
3803 static void
3804 de4x5_put_cache(struct net_device *dev, struct sk_buff *skb)
3805 {
3806 struct de4x5_private *lp = netdev_priv(dev);
3807 struct sk_buff *p;
3808
3809 if (lp->cache.skb) {
3810 for (p=lp->cache.skb; p->next; p=p->next);
3811 p->next = skb;
3812 } else {
3813 lp->cache.skb = skb;
3814 }
3815 skb->next = NULL;
3816
3817 return;
3818 }
3819
3820 static void
3821 de4x5_putb_cache(struct net_device *dev, struct sk_buff *skb)
3822 {
3823 struct de4x5_private *lp = netdev_priv(dev);
3824 struct sk_buff *p = lp->cache.skb;
3825
3826 lp->cache.skb = skb;
3827 skb->next = p;
3828
3829 return;
3830 }
3831
3832 static struct sk_buff *
3833 de4x5_get_cache(struct net_device *dev)
3834 {
3835 struct de4x5_private *lp = netdev_priv(dev);
3836 struct sk_buff *p = lp->cache.skb;
3837
3838 if (p) {
3839 lp->cache.skb = p->next;
3840 p->next = NULL;
3841 }
3842
3843 return p;
3844 }
3845
3846 /*
3847 ** Check the Auto Negotiation State. Return OK when a link pass interrupt
3848 ** is received and the auto-negotiation status is NWAY OK.
3849 */
3850 static int
3851 test_ans(struct net_device *dev, s32 irqs, s32 irq_mask, s32 msec)
3852 {
3853 struct de4x5_private *lp = netdev_priv(dev);
3854 u_long iobase = dev->base_addr;
3855 s32 sts, ans;
3856
3857 if (lp->timeout < 0) {
3858 lp->timeout = msec/100;
3859 outl(irq_mask, DE4X5_IMR);
3860
3861 /* clear all pending interrupts */
3862 sts = inl(DE4X5_STS);
3863 outl(sts, DE4X5_STS);
3864 }
3865
3866 ans = inl(DE4X5_SISR) & SISR_ANS;
3867 sts = inl(DE4X5_STS) & ~TIMER_CB;
3868
3869 if (!(sts & irqs) && (ans ^ ANS_NWOK) && --lp->timeout) {
3870 sts = 100 | TIMER_CB;
3871 } else {
3872 lp->timeout = -1;
3873 }
3874
3875 return sts;
3876 }
3877
3878 static void
3879 de4x5_setup_intr(struct net_device *dev)
3880 {
3881 struct de4x5_private *lp = netdev_priv(dev);
3882 u_long iobase = dev->base_addr;
3883 s32 imr, sts;
3884
3885 if (inl(DE4X5_OMR) & OMR_SR) { /* Only unmask if TX/RX is enabled */
3886 imr = 0;
3887 UNMASK_IRQs;
3888 sts = inl(DE4X5_STS); /* Reset any pending (stale) interrupts */
3889 outl(sts, DE4X5_STS);
3890 ENABLE_IRQs;
3891 }
3892
3893 return;
3894 }
3895
3896 /*
3897 **
3898 */
3899 static void
3900 reset_init_sia(struct net_device *dev, s32 csr13, s32 csr14, s32 csr15)
3901 {
3902 struct de4x5_private *lp = netdev_priv(dev);
3903 u_long iobase = dev->base_addr;
3904
3905 RESET_SIA;
3906 if (lp->useSROM) {
3907 if (lp->ibn == 3) {
3908 srom_exec(dev, lp->phy[lp->active].rst);
3909 srom_exec(dev, lp->phy[lp->active].gep);
3910 outl(1, DE4X5_SICR);
3911 return;
3912 } else {
3913 csr15 = lp->cache.csr15;
3914 csr14 = lp->cache.csr14;
3915 csr13 = lp->cache.csr13;
3916 outl(csr15 | lp->cache.gepc, DE4X5_SIGR);
3917 outl(csr15 | lp->cache.gep, DE4X5_SIGR);
3918 }
3919 } else {
3920 outl(csr15, DE4X5_SIGR);
3921 }
3922 outl(csr14, DE4X5_STRR);
3923 outl(csr13, DE4X5_SICR);
3924
3925 mdelay(10);
3926
3927 return;
3928 }
3929
3930 /*
3931 ** Create a loopback ethernet packet
3932 */
3933 static void
3934 create_packet(struct net_device *dev, char *frame, int len)
3935 {
3936 int i;
3937 char *buf = frame;
3938
3939 for (i=0; i<ETH_ALEN; i++) { /* Use this source address */
3940 *buf++ = dev->dev_addr[i];
3941 }
3942 for (i=0; i<ETH_ALEN; i++) { /* Use this destination address */
3943 *buf++ = dev->dev_addr[i];
3944 }
3945
3946 *buf++ = 0; /* Packet length (2 bytes) */
3947 *buf++ = 1;
3948
3949 return;
3950 }
3951
3952 /*
3953 ** Look for a particular board name in the EISA configuration space
3954 */
3955 static int
3956 EISA_signature(char *name, struct device *device)
3957 {
3958 int i, status = 0, siglen = sizeof(de4x5_signatures)/sizeof(c_char *);
3959 struct eisa_device *edev;
3960
3961 *name = '\0';
3962 edev = to_eisa_device (device);
3963 i = edev->id.driver_data;
3964
3965 if (i >= 0 && i < siglen) {
3966 strcpy (name, de4x5_signatures[i]);
3967 status = 1;
3968 }
3969
3970 return status; /* return the device name string */
3971 }
3972
3973 /*
3974 ** Look for a particular board name in the PCI configuration space
3975 */
3976 static int
3977 PCI_signature(char *name, struct de4x5_private *lp)
3978 {
3979 int i, status = 0, siglen = sizeof(de4x5_signatures)/sizeof(c_char *);
3980
3981 if (lp->chipset == DC21040) {
3982 strcpy(name, "DE434/5");
3983 return status;
3984 } else { /* Search for a DEC name in the SROM */
3985 int i = *((char *)&lp->srom + 19) * 3;
3986 strncpy(name, (char *)&lp->srom + 26 + i, 8);
3987 }
3988 name[8] = '\0';
3989 for (i=0; i<siglen; i++) {
3990 if (strstr(name,de4x5_signatures[i])!=NULL) break;
3991 }
3992 if (i == siglen) {
3993 if (dec_only) {
3994 *name = '\0';
3995 } else { /* Use chip name to avoid confusion */
3996 strcpy(name, (((lp->chipset == DC21040) ? "DC21040" :
3997 ((lp->chipset == DC21041) ? "DC21041" :
3998 ((lp->chipset == DC21140) ? "DC21140" :
3999 ((lp->chipset == DC21142) ? "DC21142" :
4000 ((lp->chipset == DC21143) ? "DC21143" : "UNKNOWN"
4001 )))))));
4002 }
4003 if (lp->chipset != DC21041) {
4004 lp->useSROM = TRUE; /* card is not recognisably DEC */
4005 }
4006 } else if ((lp->chipset & ~0x00ff) == DC2114x) {
4007 lp->useSROM = TRUE;
4008 }
4009
4010 return status;
4011 }
4012
4013 /*
4014 ** Set up the Ethernet PROM counter to the start of the Ethernet address on
4015 ** the DC21040, else read the SROM for the other chips.
4016 ** The SROM may not be present in a multi-MAC card, so first read the
4017 ** MAC address and check for a bad address. If there is a bad one then exit
4018 ** immediately with the prior srom contents intact (the h/w address will
4019 ** be fixed up later).
4020 */
4021 static void
4022 DevicePresent(struct net_device *dev, u_long aprom_addr)
4023 {
4024 int i, j=0;
4025 struct de4x5_private *lp = netdev_priv(dev);
4026
4027 if (lp->chipset == DC21040) {
4028 if (lp->bus == EISA) {
4029 enet_addr_rst(aprom_addr); /* Reset Ethernet Address ROM Pointer */
4030 } else {
4031 outl(0, aprom_addr); /* Reset Ethernet Address ROM Pointer */
4032 }
4033 } else { /* Read new srom */
4034 u_short tmp, *p = (short *)((char *)&lp->srom + SROM_HWADD);
4035 for (i=0; i<(ETH_ALEN>>1); i++) {
4036 tmp = srom_rd(aprom_addr, (SROM_HWADD>>1) + i);
4037 *p = le16_to_cpu(tmp);
4038 j += *p++;
4039 }
4040 if ((j == 0) || (j == 0x2fffd)) {
4041 return;
4042 }
4043
4044 p=(short *)&lp->srom;
4045 for (i=0; i<(sizeof(struct de4x5_srom)>>1); i++) {
4046 tmp = srom_rd(aprom_addr, i);
4047 *p++ = le16_to_cpu(tmp);
4048 }
4049 de4x5_dbg_srom((struct de4x5_srom *)&lp->srom);
4050 }
4051
4052 return;
4053 }
4054
4055 /*
4056 ** Since the write on the Enet PROM register doesn't seem to reset the PROM
4057 ** pointer correctly (at least on my DE425 EISA card), this routine should do
4058 ** it...from depca.c.
4059 */
4060 static void
4061 enet_addr_rst(u_long aprom_addr)
4062 {
4063 union {
4064 struct {
4065 u32 a;
4066 u32 b;
4067 } llsig;
4068 char Sig[sizeof(u32) << 1];
4069 } dev;
4070 short sigLength=0;
4071 s8 data;
4072 int i, j;
4073
4074 dev.llsig.a = ETH_PROM_SIG;
4075 dev.llsig.b = ETH_PROM_SIG;
4076 sigLength = sizeof(u32) << 1;
4077
4078 for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
4079 data = inb(aprom_addr);
4080 if (dev.Sig[j] == data) { /* track signature */
4081 j++;
4082 } else { /* lost signature; begin search again */
4083 if (data == dev.Sig[0]) { /* rare case.... */
4084 j=1;
4085 } else {
4086 j=0;
4087 }
4088 }
4089 }
4090
4091 return;
4092 }
4093
4094 /*
4095 ** For the bad status case and no SROM, then add one to the previous
4096 ** address. However, need to add one backwards in case we have 0xff
4097 ** as one or more of the bytes. Only the last 3 bytes should be checked
4098 ** as the first three are invariant - assigned to an organisation.
4099 */
4100 static int
4101 get_hw_addr(struct net_device *dev)
4102 {
4103 u_long iobase = dev->base_addr;
4104 int broken, i, k, tmp, status = 0;
4105 u_short j,chksum;
4106 struct de4x5_private *lp = netdev_priv(dev);
4107
4108 broken = de4x5_bad_srom(lp);
4109
4110 for (i=0,k=0,j=0;j<3;j++) {
4111 k <<= 1;
4112 if (k > 0xffff) k-=0xffff;
4113
4114 if (lp->bus == PCI) {
4115 if (lp->chipset == DC21040) {
4116 while ((tmp = inl(DE4X5_APROM)) < 0);
4117 k += (u_char) tmp;
4118 dev->dev_addr[i++] = (u_char) tmp;
4119 while ((tmp = inl(DE4X5_APROM)) < 0);
4120 k += (u_short) (tmp << 8);
4121 dev->dev_addr[i++] = (u_char) tmp;
4122 } else if (!broken) {
4123 dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
4124 dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
4125 } else if ((broken == SMC) || (broken == ACCTON)) {
4126 dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
4127 dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
4128 }
4129 } else {
4130 k += (u_char) (tmp = inb(EISA_APROM));
4131 dev->dev_addr[i++] = (u_char) tmp;
4132 k += (u_short) ((tmp = inb(EISA_APROM)) << 8);
4133 dev->dev_addr[i++] = (u_char) tmp;
4134 }
4135
4136 if (k > 0xffff) k-=0xffff;
4137 }
4138 if (k == 0xffff) k=0;
4139
4140 if (lp->bus == PCI) {
4141 if (lp->chipset == DC21040) {
4142 while ((tmp = inl(DE4X5_APROM)) < 0);
4143 chksum = (u_char) tmp;
4144 while ((tmp = inl(DE4X5_APROM)) < 0);
4145 chksum |= (u_short) (tmp << 8);
4146 if ((k != chksum) && (dec_only)) status = -1;
4147 }
4148 } else {
4149 chksum = (u_char) inb(EISA_APROM);
4150 chksum |= (u_short) (inb(EISA_APROM) << 8);
4151 if ((k != chksum) && (dec_only)) status = -1;
4152 }
4153
4154 /* If possible, try to fix a broken card - SMC only so far */
4155 srom_repair(dev, broken);
4156
4157 #ifdef CONFIG_PPC_MULTIPLATFORM
4158 /*
4159 ** If the address starts with 00 a0, we have to bit-reverse
4160 ** each byte of the address.
4161 */
4162 if ( (_machine & _MACH_Pmac) &&
4163 (dev->dev_addr[0] == 0) &&
4164 (dev->dev_addr[1] == 0xa0) )
4165 {
4166 for (i = 0; i < ETH_ALEN; ++i)
4167 {
4168 int x = dev->dev_addr[i];
4169 x = ((x & 0xf) << 4) + ((x & 0xf0) >> 4);
4170 x = ((x & 0x33) << 2) + ((x & 0xcc) >> 2);
4171 dev->dev_addr[i] = ((x & 0x55) << 1) + ((x & 0xaa) >> 1);
4172 }
4173 }
4174 #endif /* CONFIG_PPC_MULTIPLATFORM */
4175
4176 /* Test for a bad enet address */
4177 status = test_bad_enet(dev, status);
4178
4179 return status;
4180 }
4181
4182 /*
4183 ** Test for enet addresses in the first 32 bytes. The built-in strncmp
4184 ** didn't seem to work here...?
4185 */
4186 static int
4187 de4x5_bad_srom(struct de4x5_private *lp)
4188 {
4189 int i, status = 0;
4190
4191 for (i=0; i<sizeof(enet_det)/ETH_ALEN; i++) {
4192 if (!de4x5_strncmp((char *)&lp->srom, (char *)&enet_det[i], 3) &&
4193 !de4x5_strncmp((char *)&lp->srom+0x10, (char *)&enet_det[i], 3)) {
4194 if (i == 0) {
4195 status = SMC;
4196 } else if (i == 1) {
4197 status = ACCTON;
4198 }
4199 break;
4200 }
4201 }
4202
4203 return status;
4204 }
4205
4206 static int
4207 de4x5_strncmp(char *a, char *b, int n)
4208 {
4209 int ret=0;
4210
4211 for (;n && !ret;n--) {
4212 ret = *a++ - *b++;
4213 }
4214
4215 return ret;
4216 }
4217
4218 static void
4219 srom_repair(struct net_device *dev, int card)
4220 {
4221 struct de4x5_private *lp = netdev_priv(dev);
4222
4223 switch(card) {
4224 case SMC:
4225 memset((char *)&lp->srom, 0, sizeof(struct de4x5_srom));
4226 memcpy(lp->srom.ieee_addr, (char *)dev->dev_addr, ETH_ALEN);
4227 memcpy(lp->srom.info, (char *)&srom_repair_info[SMC-1], 100);
4228 lp->useSROM = TRUE;
4229 break;
4230 }
4231
4232 return;
4233 }
4234
4235 /*
4236 ** Assume that the irq's do not follow the PCI spec - this is seems
4237 ** to be true so far (2 for 2).
4238 */
4239 static int
4240 test_bad_enet(struct net_device *dev, int status)
4241 {
4242 struct de4x5_private *lp = netdev_priv(dev);
4243 int i, tmp;
4244
4245 for (tmp=0,i=0; i<ETH_ALEN; i++) tmp += (u_char)dev->dev_addr[i];
4246 if ((tmp == 0) || (tmp == 0x5fa)) {
4247 if ((lp->chipset == last.chipset) &&
4248 (lp->bus_num == last.bus) && (lp->bus_num > 0)) {
4249 for (i=0; i<ETH_ALEN; i++) dev->dev_addr[i] = last.addr[i];
4250 for (i=ETH_ALEN-1; i>2; --i) {
4251 dev->dev_addr[i] += 1;
4252 if (dev->dev_addr[i] != 0) break;
4253 }
4254 for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
4255 if (!an_exception(lp)) {
4256 dev->irq = last.irq;
4257 }
4258
4259 status = 0;
4260 }
4261 } else if (!status) {
4262 last.chipset = lp->chipset;
4263 last.bus = lp->bus_num;
4264 last.irq = dev->irq;
4265 for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
4266 }
4267
4268 return status;
4269 }
4270
4271 /*
4272 ** List of board exceptions with correctly wired IRQs
4273 */
4274 static int
4275 an_exception(struct de4x5_private *lp)
4276 {
4277 if ((*(u_short *)lp->srom.sub_vendor_id == 0x00c0) &&
4278 (*(u_short *)lp->srom.sub_system_id == 0x95e0)) {
4279 return -1;
4280 }
4281
4282 return 0;
4283 }
4284
4285 /*
4286 ** SROM Read
4287 */
4288 static short
4289 srom_rd(u_long addr, u_char offset)
4290 {
4291 sendto_srom(SROM_RD | SROM_SR, addr);
4292
4293 srom_latch(SROM_RD | SROM_SR | DT_CS, addr);
4294 srom_command(SROM_RD | SROM_SR | DT_IN | DT_CS, addr);
4295 srom_address(SROM_RD | SROM_SR | DT_CS, addr, offset);
4296
4297 return srom_data(SROM_RD | SROM_SR | DT_CS, addr);
4298 }
4299
4300 static void
4301 srom_latch(u_int command, u_long addr)
4302 {
4303 sendto_srom(command, addr);
4304 sendto_srom(command | DT_CLK, addr);
4305 sendto_srom(command, addr);
4306
4307 return;
4308 }
4309
4310 static void
4311 srom_command(u_int command, u_long addr)
4312 {
4313 srom_latch(command, addr);
4314 srom_latch(command, addr);
4315 srom_latch((command & 0x0000ff00) | DT_CS, addr);
4316
4317 return;
4318 }
4319
4320 static void
4321 srom_address(u_int command, u_long addr, u_char offset)
4322 {
4323 int i, a;
4324
4325 a = offset << 2;
4326 for (i=0; i<6; i++, a <<= 1) {
4327 srom_latch(command | ((a & 0x80) ? DT_IN : 0), addr);
4328 }
4329 udelay(1);
4330
4331 i = (getfrom_srom(addr) >> 3) & 0x01;
4332
4333 return;
4334 }
4335
4336 static short
4337 srom_data(u_int command, u_long addr)
4338 {
4339 int i;
4340 short word = 0;
4341 s32 tmp;
4342
4343 for (i=0; i<16; i++) {
4344 sendto_srom(command | DT_CLK, addr);
4345 tmp = getfrom_srom(addr);
4346 sendto_srom(command, addr);
4347
4348 word = (word << 1) | ((tmp >> 3) & 0x01);
4349 }
4350
4351 sendto_srom(command & 0x0000ff00, addr);
4352
4353 return word;
4354 }
4355
4356 /*
4357 static void
4358 srom_busy(u_int command, u_long addr)
4359 {
4360 sendto_srom((command & 0x0000ff00) | DT_CS, addr);
4361
4362 while (!((getfrom_srom(addr) >> 3) & 0x01)) {
4363 mdelay(1);
4364 }
4365
4366 sendto_srom(command & 0x0000ff00, addr);
4367
4368 return;
4369 }
4370 */
4371
4372 static void
4373 sendto_srom(u_int command, u_long addr)
4374 {
4375 outl(command, addr);
4376 udelay(1);
4377
4378 return;
4379 }
4380
4381 static int
4382 getfrom_srom(u_long addr)
4383 {
4384 s32 tmp;
4385
4386 tmp = inl(addr);
4387 udelay(1);
4388
4389 return tmp;
4390 }
4391
4392 static int
4393 srom_infoleaf_info(struct net_device *dev)
4394 {
4395 struct de4x5_private *lp = netdev_priv(dev);
4396 int i, count;
4397 u_char *p;
4398
4399 /* Find the infoleaf decoder function that matches this chipset */
4400 for (i=0; i<INFOLEAF_SIZE; i++) {
4401 if (lp->chipset == infoleaf_array[i].chipset) break;
4402 }
4403 if (i == INFOLEAF_SIZE) {
4404 lp->useSROM = FALSE;
4405 printk("%s: Cannot find correct chipset for SROM decoding!\n",
4406 dev->name);
4407 return -ENXIO;
4408 }
4409
4410 lp->infoleaf_fn = infoleaf_array[i].fn;
4411
4412 /* Find the information offset that this function should use */
4413 count = *((u_char *)&lp->srom + 19);
4414 p = (u_char *)&lp->srom + 26;
4415
4416 if (count > 1) {
4417 for (i=count; i; --i, p+=3) {
4418 if (lp->device == *p) break;
4419 }
4420 if (i == 0) {
4421 lp->useSROM = FALSE;
4422 printk("%s: Cannot find correct PCI device [%d] for SROM decoding!\n",
4423 dev->name, lp->device);
4424 return -ENXIO;
4425 }
4426 }
4427
4428 lp->infoleaf_offset = TWIDDLE(p+1);
4429
4430 return 0;
4431 }
4432
4433 /*
4434 ** This routine loads any type 1 or 3 MII info into the mii device
4435 ** struct and executes any type 5 code to reset PHY devices for this
4436 ** controller.
4437 ** The info for the MII devices will be valid since the index used
4438 ** will follow the discovery process from MII address 1-31 then 0.
4439 */
4440 static void
4441 srom_init(struct net_device *dev)
4442 {
4443 struct de4x5_private *lp = netdev_priv(dev);
4444 u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4445 u_char count;
4446
4447 p+=2;
4448 if (lp->chipset == DC21140) {
4449 lp->cache.gepc = (*p++ | GEP_CTRL);
4450 gep_wr(lp->cache.gepc, dev);
4451 }
4452
4453 /* Block count */
4454 count = *p++;
4455
4456 /* Jump the infoblocks to find types */
4457 for (;count; --count) {
4458 if (*p < 128) {
4459 p += COMPACT_LEN;
4460 } else if (*(p+1) == 5) {
4461 type5_infoblock(dev, 1, p);
4462 p += ((*p & BLOCK_LEN) + 1);
4463 } else if (*(p+1) == 4) {
4464 p += ((*p & BLOCK_LEN) + 1);
4465 } else if (*(p+1) == 3) {
4466 type3_infoblock(dev, 1, p);
4467 p += ((*p & BLOCK_LEN) + 1);
4468 } else if (*(p+1) == 2) {
4469 p += ((*p & BLOCK_LEN) + 1);
4470 } else if (*(p+1) == 1) {
4471 type1_infoblock(dev, 1, p);
4472 p += ((*p & BLOCK_LEN) + 1);
4473 } else {
4474 p += ((*p & BLOCK_LEN) + 1);
4475 }
4476 }
4477
4478 return;
4479 }
4480
4481 /*
4482 ** A generic routine that writes GEP control, data and reset information
4483 ** to the GEP register (21140) or csr15 GEP portion (2114[23]).
4484 */
4485 static void
4486 srom_exec(struct net_device *dev, u_char *p)
4487 {
4488 struct de4x5_private *lp = netdev_priv(dev);
4489 u_long iobase = dev->base_addr;
4490 u_char count = (p ? *p++ : 0);
4491 u_short *w = (u_short *)p;
4492
4493 if (((lp->ibn != 1) && (lp->ibn != 3) && (lp->ibn != 5)) || !count) return;
4494
4495 if (lp->chipset != DC21140) RESET_SIA;
4496
4497 while (count--) {
4498 gep_wr(((lp->chipset==DC21140) && (lp->ibn!=5) ?
4499 *p++ : TWIDDLE(w++)), dev);
4500 mdelay(2); /* 2ms per action */
4501 }
4502
4503 if (lp->chipset != DC21140) {
4504 outl(lp->cache.csr14, DE4X5_STRR);
4505 outl(lp->cache.csr13, DE4X5_SICR);
4506 }
4507
4508 return;
4509 }
4510
4511 /*
4512 ** Basically this function is a NOP since it will never be called,
4513 ** unless I implement the DC21041 SROM functions. There's no need
4514 ** since the existing code will be satisfactory for all boards.
4515 */
4516 static int
4517 dc21041_infoleaf(struct net_device *dev)
4518 {
4519 return DE4X5_AUTOSENSE_MS;
4520 }
4521
4522 static int
4523 dc21140_infoleaf(struct net_device *dev)
4524 {
4525 struct de4x5_private *lp = netdev_priv(dev);
4526 u_char count = 0;
4527 u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4528 int next_tick = DE4X5_AUTOSENSE_MS;
4529
4530 /* Read the connection type */
4531 p+=2;
4532
4533 /* GEP control */
4534 lp->cache.gepc = (*p++ | GEP_CTRL);
4535
4536 /* Block count */
4537 count = *p++;
4538
4539 /* Recursively figure out the info blocks */
4540 if (*p < 128) {
4541 next_tick = dc_infoblock[COMPACT](dev, count, p);
4542 } else {
4543 next_tick = dc_infoblock[*(p+1)](dev, count, p);
4544 }
4545
4546 if (lp->tcount == count) {
4547 lp->media = NC;
4548 if (lp->media != lp->c_media) {
4549 de4x5_dbg_media(dev);
4550 lp->c_media = lp->media;
4551 }
4552 lp->media = INIT;
4553 lp->tcount = 0;
4554 lp->tx_enable = FALSE;
4555 }
4556
4557 return next_tick & ~TIMER_CB;
4558 }
4559
4560 static int
4561 dc21142_infoleaf(struct net_device *dev)
4562 {
4563 struct de4x5_private *lp = netdev_priv(dev);
4564 u_char count = 0;
4565 u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4566 int next_tick = DE4X5_AUTOSENSE_MS;
4567
4568 /* Read the connection type */
4569 p+=2;
4570
4571 /* Block count */
4572 count = *p++;
4573
4574 /* Recursively figure out the info blocks */
4575 if (*p < 128) {
4576 next_tick = dc_infoblock[COMPACT](dev, count, p);
4577 } else {
4578 next_tick = dc_infoblock[*(p+1)](dev, count, p);
4579 }
4580
4581 if (lp->tcount == count) {
4582 lp->media = NC;
4583 if (lp->media != lp->c_media) {
4584 de4x5_dbg_media(dev);
4585 lp->c_media = lp->media;
4586 }
4587 lp->media = INIT;
4588 lp->tcount = 0;
4589 lp->tx_enable = FALSE;
4590 }
4591
4592 return next_tick & ~TIMER_CB;
4593 }
4594
4595 static int
4596 dc21143_infoleaf(struct net_device *dev)
4597 {
4598 struct de4x5_private *lp = netdev_priv(dev);
4599 u_char count = 0;
4600 u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
4601 int next_tick = DE4X5_AUTOSENSE_MS;
4602
4603 /* Read the connection type */
4604 p+=2;
4605
4606 /* Block count */
4607 count = *p++;
4608
4609 /* Recursively figure out the info blocks */
4610 if (*p < 128) {
4611 next_tick = dc_infoblock[COMPACT](dev, count, p);
4612 } else {
4613 next_tick = dc_infoblock[*(p+1)](dev, count, p);
4614 }
4615 if (lp->tcount == count) {
4616 lp->media = NC;
4617 if (lp->media != lp->c_media) {
4618 de4x5_dbg_media(dev);
4619 lp->c_media = lp->media;
4620 }
4621 lp->media = INIT;
4622 lp->tcount = 0;
4623 lp->tx_enable = FALSE;
4624 }
4625
4626 return next_tick & ~TIMER_CB;
4627 }
4628
4629 /*
4630 ** The compact infoblock is only designed for DC21140[A] chips, so
4631 ** we'll reuse the dc21140m_autoconf function. Non MII media only.
4632 */
4633 static int
4634 compact_infoblock(struct net_device *dev, u_char count, u_char *p)
4635 {
4636 struct de4x5_private *lp = netdev_priv(dev);
4637 u_char flags, csr6;
4638
4639 /* Recursively figure out the info blocks */
4640 if (--count > lp->tcount) {
4641 if (*(p+COMPACT_LEN) < 128) {
4642 return dc_infoblock[COMPACT](dev, count, p+COMPACT_LEN);
4643 } else {
4644 return dc_infoblock[*(p+COMPACT_LEN+1)](dev, count, p+COMPACT_LEN);
4645 }
4646 }
4647
4648 if ((lp->media == INIT) && (lp->timeout < 0)) {
4649 lp->ibn = COMPACT;
4650 lp->active = 0;
4651 gep_wr(lp->cache.gepc, dev);
4652 lp->infoblock_media = (*p++) & COMPACT_MC;
4653 lp->cache.gep = *p++;
4654 csr6 = *p++;
4655 flags = *p++;
4656
4657 lp->asBitValid = (flags & 0x80) ? 0 : -1;
4658 lp->defMedium = (flags & 0x40) ? -1 : 0;
4659 lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4660 lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4661 lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4662 lp->useMII = FALSE;
4663
4664 de4x5_switch_mac_port(dev);
4665 }
4666
4667 return dc21140m_autoconf(dev);
4668 }
4669
4670 /*
4671 ** This block describes non MII media for the DC21140[A] only.
4672 */
4673 static int
4674 type0_infoblock(struct net_device *dev, u_char count, u_char *p)
4675 {
4676 struct de4x5_private *lp = netdev_priv(dev);
4677 u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
4678
4679 /* Recursively figure out the info blocks */
4680 if (--count > lp->tcount) {
4681 if (*(p+len) < 128) {
4682 return dc_infoblock[COMPACT](dev, count, p+len);
4683 } else {
4684 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4685 }
4686 }
4687
4688 if ((lp->media == INIT) && (lp->timeout < 0)) {
4689 lp->ibn = 0;
4690 lp->active = 0;
4691 gep_wr(lp->cache.gepc, dev);
4692 p+=2;
4693 lp->infoblock_media = (*p++) & BLOCK0_MC;
4694 lp->cache.gep = *p++;
4695 csr6 = *p++;
4696 flags = *p++;
4697
4698 lp->asBitValid = (flags & 0x80) ? 0 : -1;
4699 lp->defMedium = (flags & 0x40) ? -1 : 0;
4700 lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4701 lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4702 lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4703 lp->useMII = FALSE;
4704
4705 de4x5_switch_mac_port(dev);
4706 }
4707
4708 return dc21140m_autoconf(dev);
4709 }
4710
4711 /* These functions are under construction! */
4712
4713 static int
4714 type1_infoblock(struct net_device *dev, u_char count, u_char *p)
4715 {
4716 struct de4x5_private *lp = netdev_priv(dev);
4717 u_char len = (*p & BLOCK_LEN)+1;
4718
4719 /* Recursively figure out the info blocks */
4720 if (--count > lp->tcount) {
4721 if (*(p+len) < 128) {
4722 return dc_infoblock[COMPACT](dev, count, p+len);
4723 } else {
4724 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4725 }
4726 }
4727
4728 p += 2;
4729 if (lp->state == INITIALISED) {
4730 lp->ibn = 1;
4731 lp->active = *p++;
4732 lp->phy[lp->active].gep = (*p ? p : NULL); p += (*p + 1);
4733 lp->phy[lp->active].rst = (*p ? p : NULL); p += (*p + 1);
4734 lp->phy[lp->active].mc = TWIDDLE(p); p += 2;
4735 lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
4736 lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
4737 lp->phy[lp->active].ttm = TWIDDLE(p);
4738 return 0;
4739 } else if ((lp->media == INIT) && (lp->timeout < 0)) {
4740 lp->ibn = 1;
4741 lp->active = *p;
4742 lp->infoblock_csr6 = OMR_MII_100;
4743 lp->useMII = TRUE;
4744 lp->infoblock_media = ANS;
4745
4746 de4x5_switch_mac_port(dev);
4747 }
4748
4749 return dc21140m_autoconf(dev);
4750 }
4751
4752 static int
4753 type2_infoblock(struct net_device *dev, u_char count, u_char *p)
4754 {
4755 struct de4x5_private *lp = netdev_priv(dev);
4756 u_char len = (*p & BLOCK_LEN)+1;
4757
4758 /* Recursively figure out the info blocks */
4759 if (--count > lp->tcount) {
4760 if (*(p+len) < 128) {
4761 return dc_infoblock[COMPACT](dev, count, p+len);
4762 } else {
4763 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4764 }
4765 }
4766
4767 if ((lp->media == INIT) && (lp->timeout < 0)) {
4768 lp->ibn = 2;
4769 lp->active = 0;
4770 p += 2;
4771 lp->infoblock_media = (*p) & MEDIA_CODE;
4772
4773 if ((*p++) & EXT_FIELD) {
4774 lp->cache.csr13 = TWIDDLE(p); p += 2;
4775 lp->cache.csr14 = TWIDDLE(p); p += 2;
4776 lp->cache.csr15 = TWIDDLE(p); p += 2;
4777 } else {
4778 lp->cache.csr13 = CSR13;
4779 lp->cache.csr14 = CSR14;
4780 lp->cache.csr15 = CSR15;
4781 }
4782 lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
4783 lp->cache.gep = ((s32)(TWIDDLE(p)) << 16);
4784 lp->infoblock_csr6 = OMR_SIA;
4785 lp->useMII = FALSE;
4786
4787 de4x5_switch_mac_port(dev);
4788 }
4789
4790 return dc2114x_autoconf(dev);
4791 }
4792
4793 static int
4794 type3_infoblock(struct net_device *dev, u_char count, u_char *p)
4795 {
4796 struct de4x5_private *lp = netdev_priv(dev);
4797 u_char len = (*p & BLOCK_LEN)+1;
4798
4799 /* Recursively figure out the info blocks */
4800 if (--count > lp->tcount) {
4801 if (*(p+len) < 128) {
4802 return dc_infoblock[COMPACT](dev, count, p+len);
4803 } else {
4804 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4805 }
4806 }
4807
4808 p += 2;
4809 if (lp->state == INITIALISED) {
4810 lp->ibn = 3;
4811 lp->active = *p++;
4812 if (MOTO_SROM_BUG) lp->active = 0;
4813 lp->phy[lp->active].gep = (*p ? p : NULL); p += (2 * (*p) + 1);
4814 lp->phy[lp->active].rst = (*p ? p : NULL); p += (2 * (*p) + 1);
4815 lp->phy[lp->active].mc = TWIDDLE(p); p += 2;
4816 lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
4817 lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
4818 lp->phy[lp->active].ttm = TWIDDLE(p); p += 2;
4819 lp->phy[lp->active].mci = *p;
4820 return 0;
4821 } else if ((lp->media == INIT) && (lp->timeout < 0)) {
4822 lp->ibn = 3;
4823 lp->active = *p;
4824 if (MOTO_SROM_BUG) lp->active = 0;
4825 lp->infoblock_csr6 = OMR_MII_100;
4826 lp->useMII = TRUE;
4827 lp->infoblock_media = ANS;
4828
4829 de4x5_switch_mac_port(dev);
4830 }
4831
4832 return dc2114x_autoconf(dev);
4833 }
4834
4835 static int
4836 type4_infoblock(struct net_device *dev, u_char count, u_char *p)
4837 {
4838 struct de4x5_private *lp = netdev_priv(dev);
4839 u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
4840
4841 /* Recursively figure out the info blocks */
4842 if (--count > lp->tcount) {
4843 if (*(p+len) < 128) {
4844 return dc_infoblock[COMPACT](dev, count, p+len);
4845 } else {
4846 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4847 }
4848 }
4849
4850 if ((lp->media == INIT) && (lp->timeout < 0)) {
4851 lp->ibn = 4;
4852 lp->active = 0;
4853 p+=2;
4854 lp->infoblock_media = (*p++) & MEDIA_CODE;
4855 lp->cache.csr13 = CSR13; /* Hard coded defaults */
4856 lp->cache.csr14 = CSR14;
4857 lp->cache.csr15 = CSR15;
4858 lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
4859 lp->cache.gep = ((s32)(TWIDDLE(p)) << 16); p += 2;
4860 csr6 = *p++;
4861 flags = *p++;
4862
4863 lp->asBitValid = (flags & 0x80) ? 0 : -1;
4864 lp->defMedium = (flags & 0x40) ? -1 : 0;
4865 lp->asBit = 1 << ((csr6 >> 1) & 0x07);
4866 lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
4867 lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
4868 lp->useMII = FALSE;
4869
4870 de4x5_switch_mac_port(dev);
4871 }
4872
4873 return dc2114x_autoconf(dev);
4874 }
4875
4876 /*
4877 ** This block type provides information for resetting external devices
4878 ** (chips) through the General Purpose Register.
4879 */
4880 static int
4881 type5_infoblock(struct net_device *dev, u_char count, u_char *p)
4882 {
4883 struct de4x5_private *lp = netdev_priv(dev);
4884 u_char len = (*p & BLOCK_LEN)+1;
4885
4886 /* Recursively figure out the info blocks */
4887 if (--count > lp->tcount) {
4888 if (*(p+len) < 128) {
4889 return dc_infoblock[COMPACT](dev, count, p+len);
4890 } else {
4891 return dc_infoblock[*(p+len+1)](dev, count, p+len);
4892 }
4893 }
4894
4895 /* Must be initializing to run this code */
4896 if ((lp->state == INITIALISED) || (lp->media == INIT)) {
4897 p+=2;
4898 lp->rst = p;
4899 srom_exec(dev, lp->rst);
4900 }
4901
4902 return DE4X5_AUTOSENSE_MS;
4903 }
4904
4905 /*
4906 ** MII Read/Write
4907 */
4908
4909 static int
4910 mii_rd(u_char phyreg, u_char phyaddr, u_long ioaddr)
4911 {
4912 mii_wdata(MII_PREAMBLE, 2, ioaddr); /* Start of 34 bit preamble... */
4913 mii_wdata(MII_PREAMBLE, 32, ioaddr); /* ...continued */
4914 mii_wdata(MII_STRD, 4, ioaddr); /* SFD and Read operation */
4915 mii_address(phyaddr, ioaddr); /* PHY address to be accessed */
4916 mii_address(phyreg, ioaddr); /* PHY Register to read */
4917 mii_ta(MII_STRD, ioaddr); /* Turn around time - 2 MDC */
4918
4919 return mii_rdata(ioaddr); /* Read data */
4920 }
4921
4922 static void
4923 mii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr)
4924 {
4925 mii_wdata(MII_PREAMBLE, 2, ioaddr); /* Start of 34 bit preamble... */
4926 mii_wdata(MII_PREAMBLE, 32, ioaddr); /* ...continued */
4927 mii_wdata(MII_STWR, 4, ioaddr); /* SFD and Write operation */
4928 mii_address(phyaddr, ioaddr); /* PHY address to be accessed */
4929 mii_address(phyreg, ioaddr); /* PHY Register to write */
4930 mii_ta(MII_STWR, ioaddr); /* Turn around time - 2 MDC */
4931 data = mii_swap(data, 16); /* Swap data bit ordering */
4932 mii_wdata(data, 16, ioaddr); /* Write data */
4933
4934 return;
4935 }
4936
4937 static int
4938 mii_rdata(u_long ioaddr)
4939 {
4940 int i;
4941 s32 tmp = 0;
4942
4943 for (i=0; i<16; i++) {
4944 tmp <<= 1;
4945 tmp |= getfrom_mii(MII_MRD | MII_RD, ioaddr);
4946 }
4947
4948 return tmp;
4949 }
4950
4951 static void
4952 mii_wdata(int data, int len, u_long ioaddr)
4953 {
4954 int i;
4955
4956 for (i=0; i<len; i++) {
4957 sendto_mii(MII_MWR | MII_WR, data, ioaddr);
4958 data >>= 1;
4959 }
4960
4961 return;
4962 }
4963
4964 static void
4965 mii_address(u_char addr, u_long ioaddr)
4966 {
4967 int i;
4968
4969 addr = mii_swap(addr, 5);
4970 for (i=0; i<5; i++) {
4971 sendto_mii(MII_MWR | MII_WR, addr, ioaddr);
4972 addr >>= 1;
4973 }
4974
4975 return;
4976 }
4977
4978 static void
4979 mii_ta(u_long rw, u_long ioaddr)
4980 {
4981 if (rw == MII_STWR) {
4982 sendto_mii(MII_MWR | MII_WR, 1, ioaddr);
4983 sendto_mii(MII_MWR | MII_WR, 0, ioaddr);
4984 } else {
4985 getfrom_mii(MII_MRD | MII_RD, ioaddr); /* Tri-state MDIO */
4986 }
4987
4988 return;
4989 }
4990
4991 static int
4992 mii_swap(int data, int len)
4993 {
4994 int i, tmp = 0;
4995
4996 for (i=0; i<len; i++) {
4997 tmp <<= 1;
4998 tmp |= (data & 1);
4999 data >>= 1;
5000 }
5001
5002 return tmp;
5003 }
5004
5005 static void
5006 sendto_mii(u32 command, int data, u_long ioaddr)
5007 {
5008 u32 j;
5009
5010 j = (data & 1) << 17;
5011 outl(command | j, ioaddr);
5012 udelay(1);
5013 outl(command | MII_MDC | j, ioaddr);
5014 udelay(1);
5015
5016 return;
5017 }
5018
5019 static int
5020 getfrom_mii(u32 command, u_long ioaddr)
5021 {
5022 outl(command, ioaddr);
5023 udelay(1);
5024 outl(command | MII_MDC, ioaddr);
5025 udelay(1);
5026
5027 return ((inl(ioaddr) >> 19) & 1);
5028 }
5029
5030 /*
5031 ** Here's 3 ways to calculate the OUI from the ID registers.
5032 */
5033 static int
5034 mii_get_oui(u_char phyaddr, u_long ioaddr)
5035 {
5036 /*
5037 union {
5038 u_short reg;
5039 u_char breg[2];
5040 } a;
5041 int i, r2, r3, ret=0;*/
5042 int r2, r3;
5043
5044 /* Read r2 and r3 */
5045 r2 = mii_rd(MII_ID0, phyaddr, ioaddr);
5046 r3 = mii_rd(MII_ID1, phyaddr, ioaddr);
5047 /* SEEQ and Cypress way * /
5048 / * Shuffle r2 and r3 * /
5049 a.reg=0;
5050 r3 = ((r3>>10)|(r2<<6))&0x0ff;
5051 r2 = ((r2>>2)&0x3fff);
5052
5053 / * Bit reverse r3 * /
5054 for (i=0;i<8;i++) {
5055 ret<<=1;
5056 ret |= (r3&1);
5057 r3>>=1;
5058 }
5059
5060 / * Bit reverse r2 * /
5061 for (i=0;i<16;i++) {
5062 a.reg<<=1;
5063 a.reg |= (r2&1);
5064 r2>>=1;
5065 }
5066
5067 / * Swap r2 bytes * /
5068 i=a.breg[0];
5069 a.breg[0]=a.breg[1];
5070 a.breg[1]=i;
5071
5072 return ((a.reg<<8)|ret); */ /* SEEQ and Cypress way */
5073 /* return ((r2<<6)|(u_int)(r3>>10)); */ /* NATIONAL and BROADCOM way */
5074 return r2; /* (I did it) My way */
5075 }
5076
5077 /*
5078 ** The SROM spec forces us to search addresses [1-31 0]. Bummer.
5079 */
5080 static int
5081 mii_get_phy(struct net_device *dev)
5082 {
5083 struct de4x5_private *lp = netdev_priv(dev);
5084 u_long iobase = dev->base_addr;
5085 int i, j, k, n, limit=sizeof(phy_info)/sizeof(struct phy_table);
5086 int id;
5087
5088 lp->active = 0;
5089 lp->useMII = TRUE;
5090
5091 /* Search the MII address space for possible PHY devices */
5092 for (n=0, lp->mii_cnt=0, i=1; !((i==1) && (n==1)); i=(++i)%DE4X5_MAX_MII) {
5093 lp->phy[lp->active].addr = i;
5094 if (i==0) n++; /* Count cycles */
5095 while (de4x5_reset_phy(dev)<0) udelay(100);/* Wait for reset */
5096 id = mii_get_oui(i, DE4X5_MII);
5097 if ((id == 0) || (id == 65535)) continue; /* Valid ID? */
5098 for (j=0; j<limit; j++) { /* Search PHY table */
5099 if (id != phy_info[j].id) continue; /* ID match? */
5100 for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
5101 if (k < DE4X5_MAX_PHY) {
5102 memcpy((char *)&lp->phy[k],
5103 (char *)&phy_info[j], sizeof(struct phy_table));
5104 lp->phy[k].addr = i;
5105 lp->mii_cnt++;
5106 lp->active++;
5107 } else {
5108 goto purgatory; /* Stop the search */
5109 }
5110 break;
5111 }
5112 if ((j == limit) && (i < DE4X5_MAX_MII)) {
5113 for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
5114 lp->phy[k].addr = i;
5115 lp->phy[k].id = id;
5116 lp->phy[k].spd.reg = GENERIC_REG; /* ANLPA register */
5117 lp->phy[k].spd.mask = GENERIC_MASK; /* 100Mb/s technologies */
5118 lp->phy[k].spd.value = GENERIC_VALUE; /* TX & T4, H/F Duplex */
5119 lp->mii_cnt++;
5120 lp->active++;
5121 printk("%s: Using generic MII device control. If the board doesn't operate, \nplease mail the following dump to the author:\n", dev->name);
5122 j = de4x5_debug;
5123 de4x5_debug |= DEBUG_MII;
5124 de4x5_dbg_mii(dev, k);
5125 de4x5_debug = j;
5126 printk("\n");
5127 }
5128 }
5129 purgatory:
5130 lp->active = 0;
5131 if (lp->phy[0].id) { /* Reset the PHY devices */
5132 for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++) { /*For each PHY*/
5133 mii_wr(MII_CR_RST, MII_CR, lp->phy[k].addr, DE4X5_MII);
5134 while (mii_rd(MII_CR, lp->phy[k].addr, DE4X5_MII) & MII_CR_RST);
5135
5136 de4x5_dbg_mii(dev, k);
5137 }
5138 }
5139 if (!lp->mii_cnt) lp->useMII = FALSE;
5140
5141 return lp->mii_cnt;
5142 }
5143
5144 static char *
5145 build_setup_frame(struct net_device *dev, int mode)
5146 {
5147 struct de4x5_private *lp = netdev_priv(dev);
5148 int i;
5149 char *pa = lp->setup_frame;
5150
5151 /* Initialise the setup frame */
5152 if (mode == ALL) {
5153 memset(lp->setup_frame, 0, SETUP_FRAME_LEN);
5154 }
5155
5156 if (lp->setup_f == HASH_PERF) {
5157 for (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
5158 *(pa + i) = dev->dev_addr[i]; /* Host address */
5159 if (i & 0x01) pa += 2;
5160 }
5161 *(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80;
5162 } else {
5163 for (i=0; i<ETH_ALEN; i++) { /* Host address */
5164 *(pa + (i&1)) = dev->dev_addr[i];
5165 if (i & 0x01) pa += 4;
5166 }
5167 for (i=0; i<ETH_ALEN; i++) { /* Broadcast address */
5168 *(pa + (i&1)) = (char) 0xff;
5169 if (i & 0x01) pa += 4;
5170 }
5171 }
5172
5173 return pa; /* Points to the next entry */
5174 }
5175
5176 static void
5177 enable_ast(struct net_device *dev, u32 time_out)
5178 {
5179 timeout(dev, (void *)&de4x5_ast, (u_long)dev, time_out);
5180
5181 return;
5182 }
5183
5184 static void
5185 disable_ast(struct net_device *dev)
5186 {
5187 struct de4x5_private *lp = netdev_priv(dev);
5188
5189 del_timer(&lp->timer);
5190
5191 return;
5192 }
5193
5194 static long
5195 de4x5_switch_mac_port(struct net_device *dev)
5196 {
5197 struct de4x5_private *lp = netdev_priv(dev);
5198 u_long iobase = dev->base_addr;
5199 s32 omr;
5200
5201 STOP_DE4X5;
5202
5203 /* Assert the OMR_PS bit in CSR6 */
5204 omr = (inl(DE4X5_OMR) & ~(OMR_PS | OMR_HBD | OMR_TTM | OMR_PCS | OMR_SCR |
5205 OMR_FDX));
5206 omr |= lp->infoblock_csr6;
5207 if (omr & OMR_PS) omr |= OMR_HBD;
5208 outl(omr, DE4X5_OMR);
5209
5210 /* Soft Reset */
5211 RESET_DE4X5;
5212
5213 /* Restore the GEP - especially for COMPACT and Type 0 Infoblocks */
5214 if (lp->chipset == DC21140) {
5215 gep_wr(lp->cache.gepc, dev);
5216 gep_wr(lp->cache.gep, dev);
5217 } else if ((lp->chipset & ~0x0ff) == DC2114x) {
5218 reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14, lp->cache.csr15);
5219 }
5220
5221 /* Restore CSR6 */
5222 outl(omr, DE4X5_OMR);
5223
5224 /* Reset CSR8 */
5225 inl(DE4X5_MFC);
5226
5227 return omr;
5228 }
5229
5230 static void
5231 gep_wr(s32 data, struct net_device *dev)
5232 {
5233 struct de4x5_private *lp = netdev_priv(dev);
5234 u_long iobase = dev->base_addr;
5235
5236 if (lp->chipset == DC21140) {
5237 outl(data, DE4X5_GEP);
5238 } else if ((lp->chipset & ~0x00ff) == DC2114x) {
5239 outl((data<<16) | lp->cache.csr15, DE4X5_SIGR);
5240 }
5241
5242 return;
5243 }
5244
5245 static int
5246 gep_rd(struct net_device *dev)
5247 {
5248 struct de4x5_private *lp = netdev_priv(dev);
5249 u_long iobase = dev->base_addr;
5250
5251 if (lp->chipset == DC21140) {
5252 return inl(DE4X5_GEP);
5253 } else if ((lp->chipset & ~0x00ff) == DC2114x) {
5254 return (inl(DE4X5_SIGR) & 0x000fffff);
5255 }
5256
5257 return 0;
5258 }
5259
5260 static void
5261 timeout(struct net_device *dev, void (*fn)(u_long data), u_long data, u_long msec)
5262 {
5263 struct de4x5_private *lp = netdev_priv(dev);
5264 int dt;
5265
5266 /* First, cancel any pending timer events */
5267 del_timer(&lp->timer);
5268
5269 /* Convert msec to ticks */
5270 dt = (msec * HZ) / 1000;
5271 if (dt==0) dt=1;
5272
5273 /* Set up timer */
5274 init_timer(&lp->timer);
5275 lp->timer.expires = jiffies + dt;
5276 lp->timer.function = fn;
5277 lp->timer.data = data;
5278 add_timer(&lp->timer);
5279
5280 return;
5281 }
5282
5283 static void
5284 yawn(struct net_device *dev, int state)
5285 {
5286 struct de4x5_private *lp = netdev_priv(dev);
5287 u_long iobase = dev->base_addr;
5288
5289 if ((lp->chipset == DC21040) || (lp->chipset == DC21140)) return;
5290
5291 if(lp->bus == EISA) {
5292 switch(state) {
5293 case WAKEUP:
5294 outb(WAKEUP, PCI_CFPM);
5295 mdelay(10);
5296 break;
5297
5298 case SNOOZE:
5299 outb(SNOOZE, PCI_CFPM);
5300 break;
5301
5302 case SLEEP:
5303 outl(0, DE4X5_SICR);
5304 outb(SLEEP, PCI_CFPM);
5305 break;
5306 }
5307 } else {
5308 struct pci_dev *pdev = to_pci_dev (lp->gendev);
5309 switch(state) {
5310 case WAKEUP:
5311 pci_write_config_byte(pdev, PCI_CFDA_PSM, WAKEUP);
5312 mdelay(10);
5313 break;
5314
5315 case SNOOZE:
5316 pci_write_config_byte(pdev, PCI_CFDA_PSM, SNOOZE);
5317 break;
5318
5319 case SLEEP:
5320 outl(0, DE4X5_SICR);
5321 pci_write_config_byte(pdev, PCI_CFDA_PSM, SLEEP);
5322 break;
5323 }
5324 }
5325
5326 return;
5327 }
5328
5329 static void
5330 de4x5_parse_params(struct net_device *dev)
5331 {
5332 struct de4x5_private *lp = netdev_priv(dev);
5333 char *p, *q, t;
5334
5335 lp->params.fdx = 0;
5336 lp->params.autosense = AUTO;
5337
5338 if (args == NULL) return;
5339
5340 if ((p = strstr(args, dev->name))) {
5341 if (!(q = strstr(p+strlen(dev->name), "eth"))) q = p + strlen(p);
5342 t = *q;
5343 *q = '\0';
5344
5345 if (strstr(p, "fdx") || strstr(p, "FDX")) lp->params.fdx = 1;
5346
5347 if (strstr(p, "autosense") || strstr(p, "AUTOSENSE")) {
5348 if (strstr(p, "TP")) {
5349 lp->params.autosense = TP;
5350 } else if (strstr(p, "TP_NW")) {
5351 lp->params.autosense = TP_NW;
5352 } else if (strstr(p, "BNC")) {
5353 lp->params.autosense = BNC;
5354 } else if (strstr(p, "AUI")) {
5355 lp->params.autosense = AUI;
5356 } else if (strstr(p, "BNC_AUI")) {
5357 lp->params.autosense = BNC;
5358 } else if (strstr(p, "10Mb")) {
5359 lp->params.autosense = _10Mb;
5360 } else if (strstr(p, "100Mb")) {
5361 lp->params.autosense = _100Mb;
5362 } else if (strstr(p, "AUTO")) {
5363 lp->params.autosense = AUTO;
5364 }
5365 }
5366 *q = t;
5367 }
5368
5369 return;
5370 }
5371
5372 static void
5373 de4x5_dbg_open(struct net_device *dev)
5374 {
5375 struct de4x5_private *lp = netdev_priv(dev);
5376 int i;
5377
5378 if (de4x5_debug & DEBUG_OPEN) {
5379 printk("%s: de4x5 opening with irq %d\n",dev->name,dev->irq);
5380 printk("\tphysical address: ");
5381 for (i=0;i<6;i++) {
5382 printk("%2.2x:",(short)dev->dev_addr[i]);
5383 }
5384 printk("\n");
5385 printk("Descriptor head addresses:\n");
5386 printk("\t0x%8.8lx 0x%8.8lx\n",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
5387 printk("Descriptor addresses:\nRX: ");
5388 for (i=0;i<lp->rxRingSize-1;i++){
5389 if (i < 3) {
5390 printk("0x%8.8lx ",(u_long)&lp->rx_ring[i].status);
5391 }
5392 }
5393 printk("...0x%8.8lx\n",(u_long)&lp->rx_ring[i].status);
5394 printk("TX: ");
5395 for (i=0;i<lp->txRingSize-1;i++){
5396 if (i < 3) {
5397 printk("0x%8.8lx ", (u_long)&lp->tx_ring[i].status);
5398 }
5399 }
5400 printk("...0x%8.8lx\n", (u_long)&lp->tx_ring[i].status);
5401 printk("Descriptor buffers:\nRX: ");
5402 for (i=0;i<lp->rxRingSize-1;i++){
5403 if (i < 3) {
5404 printk("0x%8.8x ",le32_to_cpu(lp->rx_ring[i].buf));
5405 }
5406 }
5407 printk("...0x%8.8x\n",le32_to_cpu(lp->rx_ring[i].buf));
5408 printk("TX: ");
5409 for (i=0;i<lp->txRingSize-1;i++){
5410 if (i < 3) {
5411 printk("0x%8.8x ", le32_to_cpu(lp->tx_ring[i].buf));
5412 }
5413 }
5414 printk("...0x%8.8x\n", le32_to_cpu(lp->tx_ring[i].buf));
5415 printk("Ring size: \nRX: %d\nTX: %d\n",
5416 (short)lp->rxRingSize,
5417 (short)lp->txRingSize);
5418 }
5419
5420 return;
5421 }
5422
5423 static void
5424 de4x5_dbg_mii(struct net_device *dev, int k)
5425 {
5426 struct de4x5_private *lp = netdev_priv(dev);
5427 u_long iobase = dev->base_addr;
5428
5429 if (de4x5_debug & DEBUG_MII) {
5430 printk("\nMII device address: %d\n", lp->phy[k].addr);
5431 printk("MII CR: %x\n",mii_rd(MII_CR,lp->phy[k].addr,DE4X5_MII));
5432 printk("MII SR: %x\n",mii_rd(MII_SR,lp->phy[k].addr,DE4X5_MII));
5433 printk("MII ID0: %x\n",mii_rd(MII_ID0,lp->phy[k].addr,DE4X5_MII));
5434 printk("MII ID1: %x\n",mii_rd(MII_ID1,lp->phy[k].addr,DE4X5_MII));
5435 if (lp->phy[k].id != BROADCOM_T4) {
5436 printk("MII ANA: %x\n",mii_rd(0x04,lp->phy[k].addr,DE4X5_MII));
5437 printk("MII ANC: %x\n",mii_rd(0x05,lp->phy[k].addr,DE4X5_MII));
5438 }
5439 printk("MII 16: %x\n",mii_rd(0x10,lp->phy[k].addr,DE4X5_MII));
5440 if (lp->phy[k].id != BROADCOM_T4) {
5441 printk("MII 17: %x\n",mii_rd(0x11,lp->phy[k].addr,DE4X5_MII));
5442 printk("MII 18: %x\n",mii_rd(0x12,lp->phy[k].addr,DE4X5_MII));
5443 } else {
5444 printk("MII 20: %x\n",mii_rd(0x14,lp->phy[k].addr,DE4X5_MII));
5445 }
5446 }
5447
5448 return;
5449 }
5450
5451 static void
5452 de4x5_dbg_media(struct net_device *dev)
5453 {
5454 struct de4x5_private *lp = netdev_priv(dev);
5455
5456 if (lp->media != lp->c_media) {
5457 if (de4x5_debug & DEBUG_MEDIA) {
5458 printk("%s: media is %s%s\n", dev->name,
5459 (lp->media == NC ? "unconnected, link down or incompatible connection" :
5460 (lp->media == TP ? "TP" :
5461 (lp->media == ANS ? "TP/Nway" :
5462 (lp->media == BNC ? "BNC" :
5463 (lp->media == AUI ? "AUI" :
5464 (lp->media == BNC_AUI ? "BNC/AUI" :
5465 (lp->media == EXT_SIA ? "EXT SIA" :
5466 (lp->media == _100Mb ? "100Mb/s" :
5467 (lp->media == _10Mb ? "10Mb/s" :
5468 "???"
5469 ))))))))), (lp->fdx?" full duplex.":"."));
5470 }
5471 lp->c_media = lp->media;
5472 }
5473
5474 return;
5475 }
5476
5477 static void
5478 de4x5_dbg_srom(struct de4x5_srom *p)
5479 {
5480 int i;
5481
5482 if (de4x5_debug & DEBUG_SROM) {
5483 printk("Sub-system Vendor ID: %04x\n", *((u_short *)p->sub_vendor_id));
5484 printk("Sub-system ID: %04x\n", *((u_short *)p->sub_system_id));
5485 printk("ID Block CRC: %02x\n", (u_char)(p->id_block_crc));
5486 printk("SROM version: %02x\n", (u_char)(p->version));
5487 printk("# controllers: %02x\n", (u_char)(p->num_controllers));
5488
5489 printk("Hardware Address: ");
5490 for (i=0;i<ETH_ALEN-1;i++) {
5491 printk("%02x:", (u_char)*(p->ieee_addr+i));
5492 }
5493 printk("%02x\n", (u_char)*(p->ieee_addr+i));
5494 printk("CRC checksum: %04x\n", (u_short)(p->chksum));
5495 for (i=0; i<64; i++) {
5496 printk("%3d %04x\n", i<<1, (u_short)*((u_short *)p+i));
5497 }
5498 }
5499
5500 return;
5501 }
5502
5503 static void
5504 de4x5_dbg_rx(struct sk_buff *skb, int len)
5505 {
5506 int i, j;
5507
5508 if (de4x5_debug & DEBUG_RX) {
5509 printk("R: %02x:%02x:%02x:%02x:%02x:%02x <- %02x:%02x:%02x:%02x:%02x:%02x len/SAP:%02x%02x [%d]\n",
5510 (u_char)skb->data[0],
5511 (u_char)skb->data[1],
5512 (u_char)skb->data[2],
5513 (u_char)skb->data[3],
5514 (u_char)skb->data[4],
5515 (u_char)skb->data[5],
5516 (u_char)skb->data[6],
5517 (u_char)skb->data[7],
5518 (u_char)skb->data[8],
5519 (u_char)skb->data[9],
5520 (u_char)skb->data[10],
5521 (u_char)skb->data[11],
5522 (u_char)skb->data[12],
5523 (u_char)skb->data[13],
5524 len);
5525 for (j=0; len>0;j+=16, len-=16) {
5526 printk(" %03x: ",j);
5527 for (i=0; i<16 && i<len; i++) {
5528 printk("%02x ",(u_char)skb->data[i+j]);
5529 }
5530 printk("\n");
5531 }
5532 }
5533
5534 return;
5535 }
5536
5537 /*
5538 ** Perform IOCTL call functions here. Some are privileged operations and the
5539 ** effective uid is checked in those cases. In the normal course of events
5540 ** this function is only used for my testing.
5541 */
5542 static int
5543 de4x5_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5544 {
5545 struct de4x5_private *lp = netdev_priv(dev);
5546 struct de4x5_ioctl *ioc = (struct de4x5_ioctl *) &rq->ifr_ifru;
5547 u_long iobase = dev->base_addr;
5548 int i, j, status = 0;
5549 s32 omr;
5550 union {
5551 u8 addr[144];
5552 u16 sval[72];
5553 u32 lval[36];
5554 } tmp;
5555 u_long flags = 0;
5556
5557 switch(ioc->cmd) {
5558 case DE4X5_GET_HWADDR: /* Get the hardware address */
5559 ioc->len = ETH_ALEN;
5560 for (i=0; i<ETH_ALEN; i++) {
5561 tmp.addr[i] = dev->dev_addr[i];
5562 }
5563 if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5564 break;
5565
5566 case DE4X5_SET_HWADDR: /* Set the hardware address */
5567 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5568 if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN)) return -EFAULT;
5569 if (netif_queue_stopped(dev))
5570 return -EBUSY;
5571 netif_stop_queue(dev);
5572 for (i=0; i<ETH_ALEN; i++) {
5573 dev->dev_addr[i] = tmp.addr[i];
5574 }
5575 build_setup_frame(dev, PHYS_ADDR_ONLY);
5576 /* Set up the descriptor and give ownership to the card */
5577 load_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET |
5578 SETUP_FRAME_LEN, (struct sk_buff *)1);
5579 lp->tx_new = (++lp->tx_new) % lp->txRingSize;
5580 outl(POLL_DEMAND, DE4X5_TPD); /* Start the TX */
5581 netif_wake_queue(dev); /* Unlock the TX ring */
5582 break;
5583
5584 case DE4X5_SET_PROM: /* Set Promiscuous Mode */
5585 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5586 omr = inl(DE4X5_OMR);
5587 omr |= OMR_PR;
5588 outl(omr, DE4X5_OMR);
5589 dev->flags |= IFF_PROMISC;
5590 break;
5591
5592 case DE4X5_CLR_PROM: /* Clear Promiscuous Mode */
5593 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5594 omr = inl(DE4X5_OMR);
5595 omr &= ~OMR_PR;
5596 outl(omr, DE4X5_OMR);
5597 dev->flags &= ~IFF_PROMISC;
5598 break;
5599
5600 case DE4X5_SAY_BOO: /* Say "Boo!" to the kernel log file */
5601 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5602 printk("%s: Boo!\n", dev->name);
5603 break;
5604
5605 case DE4X5_MCA_EN: /* Enable pass all multicast addressing */
5606 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5607 omr = inl(DE4X5_OMR);
5608 omr |= OMR_PM;
5609 outl(omr, DE4X5_OMR);
5610 break;
5611
5612 case DE4X5_GET_STATS: /* Get the driver statistics */
5613 {
5614 struct pkt_stats statbuf;
5615 ioc->len = sizeof(statbuf);
5616 spin_lock_irqsave(&lp->lock, flags);
5617 memcpy(&statbuf, &lp->pktStats, ioc->len);
5618 spin_unlock_irqrestore(&lp->lock, flags);
5619 if (copy_to_user(ioc->data, &statbuf, ioc->len))
5620 return -EFAULT;
5621 break;
5622 }
5623 case DE4X5_CLR_STATS: /* Zero out the driver statistics */
5624 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5625 spin_lock_irqsave(&lp->lock, flags);
5626 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
5627 spin_unlock_irqrestore(&lp->lock, flags);
5628 break;
5629
5630 case DE4X5_GET_OMR: /* Get the OMR Register contents */
5631 tmp.addr[0] = inl(DE4X5_OMR);
5632 if (copy_to_user(ioc->data, tmp.addr, 1)) return -EFAULT;
5633 break;
5634
5635 case DE4X5_SET_OMR: /* Set the OMR Register contents */
5636 if (!capable(CAP_NET_ADMIN)) return -EPERM;
5637 if (copy_from_user(tmp.addr, ioc->data, 1)) return -EFAULT;
5638 outl(tmp.addr[0], DE4X5_OMR);
5639 break;
5640
5641 case DE4X5_GET_REG: /* Get the DE4X5 Registers */
5642 j = 0;
5643 tmp.lval[0] = inl(DE4X5_STS); j+=4;
5644 tmp.lval[1] = inl(DE4X5_BMR); j+=4;
5645 tmp.lval[2] = inl(DE4X5_IMR); j+=4;
5646 tmp.lval[3] = inl(DE4X5_OMR); j+=4;
5647 tmp.lval[4] = inl(DE4X5_SISR); j+=4;
5648 tmp.lval[5] = inl(DE4X5_SICR); j+=4;
5649 tmp.lval[6] = inl(DE4X5_STRR); j+=4;
5650 tmp.lval[7] = inl(DE4X5_SIGR); j+=4;
5651 ioc->len = j;
5652 if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5653 break;
5654
5655 #define DE4X5_DUMP 0x0f /* Dump the DE4X5 Status */
5656 /*
5657 case DE4X5_DUMP:
5658 j = 0;
5659 tmp.addr[j++] = dev->irq;
5660 for (i=0; i<ETH_ALEN; i++) {
5661 tmp.addr[j++] = dev->dev_addr[i];
5662 }
5663 tmp.addr[j++] = lp->rxRingSize;
5664 tmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
5665 tmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
5666
5667 for (i=0;i<lp->rxRingSize-1;i++){
5668 if (i < 3) {
5669 tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
5670 }
5671 }
5672 tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
5673 for (i=0;i<lp->txRingSize-1;i++){
5674 if (i < 3) {
5675 tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
5676 }
5677 }
5678 tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
5679
5680 for (i=0;i<lp->rxRingSize-1;i++){
5681 if (i < 3) {
5682 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
5683 }
5684 }
5685 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
5686 for (i=0;i<lp->txRingSize-1;i++){
5687 if (i < 3) {
5688 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
5689 }
5690 }
5691 tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
5692
5693 for (i=0;i<lp->rxRingSize;i++){
5694 tmp.lval[j>>2] = le32_to_cpu(lp->rx_ring[i].status); j+=4;
5695 }
5696 for (i=0;i<lp->txRingSize;i++){
5697 tmp.lval[j>>2] = le32_to_cpu(lp->tx_ring[i].status); j+=4;
5698 }
5699
5700 tmp.lval[j>>2] = inl(DE4X5_BMR); j+=4;
5701 tmp.lval[j>>2] = inl(DE4X5_TPD); j+=4;
5702 tmp.lval[j>>2] = inl(DE4X5_RPD); j+=4;
5703 tmp.lval[j>>2] = inl(DE4X5_RRBA); j+=4;
5704 tmp.lval[j>>2] = inl(DE4X5_TRBA); j+=4;
5705 tmp.lval[j>>2] = inl(DE4X5_STS); j+=4;
5706 tmp.lval[j>>2] = inl(DE4X5_OMR); j+=4;
5707 tmp.lval[j>>2] = inl(DE4X5_IMR); j+=4;
5708 tmp.lval[j>>2] = lp->chipset; j+=4;
5709 if (lp->chipset == DC21140) {
5710 tmp.lval[j>>2] = gep_rd(dev); j+=4;
5711 } else {
5712 tmp.lval[j>>2] = inl(DE4X5_SISR); j+=4;
5713 tmp.lval[j>>2] = inl(DE4X5_SICR); j+=4;
5714 tmp.lval[j>>2] = inl(DE4X5_STRR); j+=4;
5715 tmp.lval[j>>2] = inl(DE4X5_SIGR); j+=4;
5716 }
5717 tmp.lval[j>>2] = lp->phy[lp->active].id; j+=4;
5718 if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
5719 tmp.lval[j>>2] = lp->active; j+=4;
5720 tmp.lval[j>>2]=mii_rd(MII_CR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5721 tmp.lval[j>>2]=mii_rd(MII_SR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5722 tmp.lval[j>>2]=mii_rd(MII_ID0,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5723 tmp.lval[j>>2]=mii_rd(MII_ID1,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5724 if (lp->phy[lp->active].id != BROADCOM_T4) {
5725 tmp.lval[j>>2]=mii_rd(MII_ANA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5726 tmp.lval[j>>2]=mii_rd(MII_ANLPA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5727 }
5728 tmp.lval[j>>2]=mii_rd(0x10,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5729 if (lp->phy[lp->active].id != BROADCOM_T4) {
5730 tmp.lval[j>>2]=mii_rd(0x11,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5731 tmp.lval[j>>2]=mii_rd(0x12,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5732 } else {
5733 tmp.lval[j>>2]=mii_rd(0x14,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
5734 }
5735 }
5736
5737 tmp.addr[j++] = lp->txRingSize;
5738 tmp.addr[j++] = netif_queue_stopped(dev);
5739
5740 ioc->len = j;
5741 if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
5742 break;
5743
5744 */
5745 default:
5746 return -EOPNOTSUPP;
5747 }
5748
5749 return status;
5750 }
5751
5752 static int __init de4x5_module_init (void)
5753 {
5754 int err = 0;
5755
5756 #ifdef CONFIG_PCI
5757 err = pci_module_init (&de4x5_pci_driver);
5758 #endif
5759 #ifdef CONFIG_EISA
5760 err |= eisa_driver_register (&de4x5_eisa_driver);
5761 #endif
5762
5763 return err;
5764 }
5765
5766 static void __exit de4x5_module_exit (void)
5767 {
5768 #ifdef CONFIG_PCI
5769 pci_unregister_driver (&de4x5_pci_driver);
5770 #endif
5771 #ifdef CONFIG_EISA
5772 eisa_driver_unregister (&de4x5_eisa_driver);
5773 #endif
5774 }
5775
5776 module_init (de4x5_module_init);
5777 module_exit (de4x5_module_exit);
MOXA 2.6.9 from sdlinux-moxaart.tgz