3 * 10/100/1000 Base-T Ethernet Driver for the ET1301 and ET131x series MACs
5 * Copyright © 2005 Agere Systems Inc.
9 *------------------------------------------------------------------------------
11 * et1310_mac.c - All code and routines pertaining to the MAC
13 *------------------------------------------------------------------------------
17 * This software is provided subject to the following terms and conditions,
18 * which you should read carefully before using the software. Using this
19 * software indicates your acceptance of these terms and conditions. If you do
20 * not agree with these terms and conditions, do not use the software.
22 * Copyright © 2005 Agere Systems Inc.
23 * All rights reserved.
25 * Redistribution and use in source or binary forms, with or without
26 * modifications, are permitted provided that the following conditions are met:
28 * . Redistributions of source code must retain the above copyright notice, this
29 * list of conditions and the following Disclaimer as comments in the code as
30 * well as in the documentation and/or other materials provided with the
33 * . Redistributions in binary form must reproduce the above copyright notice,
34 * this list of conditions and the following Disclaimer in the documentation
35 * and/or other materials provided with the distribution.
37 * . Neither the name of Agere Systems Inc. nor the names of the contributors
38 * may be used to endorse or promote products derived from this software
39 * without specific prior written permission.
43 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
44 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
45 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
46 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
47 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
48 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
49 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
50 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
51 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
53 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
58 #include "et131x_version.h"
59 #include "et131x_defs.h"
61 #include <linux/init.h>
62 #include <linux/module.h>
63 #include <linux/types.h>
64 #include <linux/kernel.h>
66 #include <linux/sched.h>
67 #include <linux/ptrace.h>
68 #include <linux/slab.h>
69 #include <linux/ctype.h>
70 #include <linux/string.h>
71 #include <linux/timer.h>
72 #include <linux/interrupt.h>
74 #include <linux/delay.h>
76 #include <linux/bitops.h>
77 #include <linux/pci.h>
78 #include <asm/system.h>
80 #include <linux/netdevice.h>
81 #include <linux/etherdevice.h>
82 #include <linux/skbuff.h>
83 #include <linux/if_arp.h>
84 #include <linux/ioport.h>
85 #include <linux/crc32.h>
87 #include "et1310_phy.h"
88 #include "et1310_pm.h"
89 #include "et1310_jagcore.h"
90 #include "et1310_mac.h"
92 #include "et131x_adapter.h"
93 #include "et131x_initpci.h"
96 * ConfigMacRegs1 - Initialize the first part of MAC regs
97 * @pAdpater: pointer to our adapter structure
99 void ConfigMACRegs1(struct et131x_adapter
*etdev
)
101 struct _MAC_t __iomem
*pMac
= &etdev
->regs
->mac
;
102 MAC_STATION_ADDR1_t station1
;
103 MAC_STATION_ADDR2_t station2
;
106 MII_MGMT_CFG_t mii_mgmt_cfg
;
108 /* First we need to reset everything. Write to MAC configuration
109 * register 1 to perform reset.
111 writel(0xC00F0000, &pMac
->cfg1
.value
);
113 /* Next lets configure the MAC Inter-packet gap register */
114 ipg
.bits
.non_B2B_ipg_1
= 0x38; /* 58d */
115 ipg
.bits
.non_B2B_ipg_2
= 0x58; /* 88d */
116 ipg
.bits
.min_ifg_enforce
= 0x50; /* 80d */
117 ipg
.bits
.B2B_ipg
= 0x60; /* 96d */
118 writel(ipg
.value
, &pMac
->ipg
.value
);
120 /* Next lets configure the MAC Half Duplex register */
121 hfdp
.bits
.alt_beb_trunc
= 0xA;
122 hfdp
.bits
.alt_beb_enable
= 0x0;
123 hfdp
.bits
.bp_no_backoff
= 0x0;
124 hfdp
.bits
.no_backoff
= 0x0;
125 hfdp
.bits
.excess_defer
= 0x1;
126 hfdp
.bits
.rexmit_max
= 0xF;
127 hfdp
.bits
.coll_window
= 0x37; /* 55d */
128 writel(hfdp
.value
, &pMac
->hfdp
.value
);
130 /* Next lets configure the MAC Interface Control register */
131 writel(0, &pMac
->if_ctrl
.value
);
133 /* Let's move on to setting up the mii management configuration */
134 mii_mgmt_cfg
.bits
.reset_mii_mgmt
= 0;
135 mii_mgmt_cfg
.bits
.scan_auto_incremt
= 0;
136 mii_mgmt_cfg
.bits
.preamble_suppress
= 0;
137 mii_mgmt_cfg
.bits
.mgmt_clk_reset
= 0x7;
138 writel(mii_mgmt_cfg
.value
, &pMac
->mii_mgmt_cfg
.value
);
140 /* Next lets configure the MAC Station Address register. These
141 * values are read from the EEPROM during initialization and stored
142 * in the adapter structure. We write what is stored in the adapter
143 * structure to the MAC Station Address registers high and low. This
144 * station address is used for generating and checking pause control
147 station2
.bits
.Octet1
= etdev
->CurrentAddress
[0];
148 station2
.bits
.Octet2
= etdev
->CurrentAddress
[1];
149 station1
.bits
.Octet3
= etdev
->CurrentAddress
[2];
150 station1
.bits
.Octet4
= etdev
->CurrentAddress
[3];
151 station1
.bits
.Octet5
= etdev
->CurrentAddress
[4];
152 station1
.bits
.Octet6
= etdev
->CurrentAddress
[5];
153 writel(station1
.value
, &pMac
->station_addr_1
.value
);
154 writel(station2
.value
, &pMac
->station_addr_2
.value
);
156 /* Max ethernet packet in bytes that will passed by the mac without
157 * being truncated. Allow the MAC to pass 4 more than our max packet
158 * size. This is 4 for the Ethernet CRC.
160 * Packets larger than (RegistryJumboPacket) that do not contain a
161 * VLAN ID will be dropped by the Rx function.
163 writel(etdev
->RegistryJumboPacket
+ 4, &pMac
->max_fm_len
.value
);
165 /* clear out MAC config reset */
166 writel(0, &pMac
->cfg1
.value
);
170 * ConfigMacRegs2 - Initialize the second part of MAC regs
171 * @pAdpater: pointer to our adapter structure
173 void ConfigMACRegs2(struct et131x_adapter
*etdev
)
176 struct _MAC_t __iomem
*pMac
= &etdev
->regs
->mac
;
179 MAC_IF_CTRL_t ifctrl
;
182 ctl
.value
= readl(&etdev
->regs
->txmac
.ctl
.value
);
183 cfg1
.value
= readl(&pMac
->cfg1
.value
);
184 cfg2
.value
= readl(&pMac
->cfg2
.value
);
185 ifctrl
.value
= readl(&pMac
->if_ctrl
.value
);
187 if (etdev
->linkspeed
== TRUEPHY_SPEED_1000MBPS
) {
188 cfg2
.bits
.if_mode
= 0x2;
189 ifctrl
.bits
.phy_mode
= 0x0;
191 cfg2
.bits
.if_mode
= 0x1;
192 ifctrl
.bits
.phy_mode
= 0x1;
195 /* We need to enable Rx/Tx */
196 cfg1
.bits
.rx_enable
= 0x1;
197 cfg1
.bits
.tx_enable
= 0x1;
199 /* Set up flow control */
200 cfg1
.bits
.tx_flow
= 0x1;
202 if ((etdev
->FlowControl
== RxOnly
) ||
203 (etdev
->FlowControl
== Both
)) {
204 cfg1
.bits
.rx_flow
= 0x1;
206 cfg1
.bits
.rx_flow
= 0x0;
209 /* Initialize loop back to off */
210 cfg1
.bits
.loop_back
= 0;
212 writel(cfg1
.value
, &pMac
->cfg1
.value
);
214 /* Now we need to initialize the MAC Configuration 2 register */
215 cfg2
.bits
.preamble_len
= 0x7;
216 cfg2
.bits
.huge_frame
= 0x0;
217 /* LENGTH FIELD CHECKING bit4: Set this bit to cause the MAC to check
218 * the frame's length field to ensure it matches the actual data
219 * field length. Clear this bit if no length field checking is
220 * desired. Its default is 0.
222 cfg2
.bits
.len_check
= 0x1;
224 cfg2
.bits
.pad_crc
= 0x1;
225 cfg2
.bits
.crc_enable
= 0x1;
227 /* 1 - full duplex, 0 - half-duplex */
228 cfg2
.bits
.full_duplex
= etdev
->duplex_mode
;
229 ifctrl
.bits
.ghd_mode
= !etdev
->duplex_mode
;
231 writel(ifctrl
.value
, &pMac
->if_ctrl
.value
);
232 writel(cfg2
.value
, &pMac
->cfg2
.value
);
237 cfg1
.value
= readl(&pMac
->cfg1
.value
);
238 } while ((!cfg1
.bits
.syncd_rx_en
|| !cfg1
.bits
.syncd_tx_en
) &&
242 dev_warn(&etdev
->pdev
->dev
,
243 "Syncd bits did not respond correctly cfg1 word 0x%08x\n",
248 ctl
.bits
.txmac_en
= 0x1;
249 ctl
.bits
.fc_disable
= 0x1;
250 writel(ctl
.value
, &etdev
->regs
->txmac
.ctl
.value
);
252 /* Ready to start the RXDMA/TXDMA engine */
253 if (etdev
->Flags
& fMP_ADAPTER_LOWER_POWER
) {
254 et131x_rx_dma_enable(etdev
);
255 et131x_tx_dma_enable(etdev
);
259 void ConfigRxMacRegs(struct et131x_adapter
*etdev
)
261 struct _RXMAC_t __iomem
*pRxMac
= &etdev
->regs
->rxmac
;
262 RXMAC_WOL_SA_LO_t sa_lo
;
263 RXMAC_WOL_SA_HI_t sa_hi
;
264 RXMAC_PF_CTRL_t pf_ctrl
= { 0 };
266 /* Disable the MAC while it is being configured (also disable WOL) */
267 writel(0x8, &pRxMac
->ctrl
.value
);
269 /* Initialize WOL to disabled. */
270 writel(0, &pRxMac
->crc0
.value
);
271 writel(0, &pRxMac
->crc12
.value
);
272 writel(0, &pRxMac
->crc34
.value
);
274 /* We need to set the WOL mask0 - mask4 next. We initialize it to
275 * its default Values of 0x00000000 because there are not WOL masks
278 writel(0, &pRxMac
->mask0_word0
);
279 writel(0, &pRxMac
->mask0_word1
);
280 writel(0, &pRxMac
->mask0_word2
);
281 writel(0, &pRxMac
->mask0_word3
);
283 writel(0, &pRxMac
->mask1_word0
);
284 writel(0, &pRxMac
->mask1_word1
);
285 writel(0, &pRxMac
->mask1_word2
);
286 writel(0, &pRxMac
->mask1_word3
);
288 writel(0, &pRxMac
->mask2_word0
);
289 writel(0, &pRxMac
->mask2_word1
);
290 writel(0, &pRxMac
->mask2_word2
);
291 writel(0, &pRxMac
->mask2_word3
);
293 writel(0, &pRxMac
->mask3_word0
);
294 writel(0, &pRxMac
->mask3_word1
);
295 writel(0, &pRxMac
->mask3_word2
);
296 writel(0, &pRxMac
->mask3_word3
);
298 writel(0, &pRxMac
->mask4_word0
);
299 writel(0, &pRxMac
->mask4_word1
);
300 writel(0, &pRxMac
->mask4_word2
);
301 writel(0, &pRxMac
->mask4_word3
);
303 /* Lets setup the WOL Source Address */
304 sa_lo
.bits
.sa3
= etdev
->CurrentAddress
[2];
305 sa_lo
.bits
.sa4
= etdev
->CurrentAddress
[3];
306 sa_lo
.bits
.sa5
= etdev
->CurrentAddress
[4];
307 sa_lo
.bits
.sa6
= etdev
->CurrentAddress
[5];
308 writel(sa_lo
.value
, &pRxMac
->sa_lo
.value
);
310 sa_hi
.bits
.sa1
= etdev
->CurrentAddress
[0];
311 sa_hi
.bits
.sa2
= etdev
->CurrentAddress
[1];
312 writel(sa_hi
.value
, &pRxMac
->sa_hi
.value
);
314 /* Disable all Packet Filtering */
315 writel(0, &pRxMac
->pf_ctrl
.value
);
317 /* Let's initialize the Unicast Packet filtering address */
318 if (etdev
->PacketFilter
& ET131X_PACKET_TYPE_DIRECTED
) {
319 SetupDeviceForUnicast(etdev
);
320 pf_ctrl
.bits
.filter_uni_en
= 1;
322 writel(0, &pRxMac
->uni_pf_addr1
.value
);
323 writel(0, &pRxMac
->uni_pf_addr2
.value
);
324 writel(0, &pRxMac
->uni_pf_addr3
.value
);
327 /* Let's initialize the Multicast hash */
328 if (etdev
->PacketFilter
& ET131X_PACKET_TYPE_ALL_MULTICAST
) {
329 pf_ctrl
.bits
.filter_multi_en
= 0;
331 pf_ctrl
.bits
.filter_multi_en
= 1;
332 SetupDeviceForMulticast(etdev
);
335 /* Runt packet filtering. Didn't work in version A silicon. */
336 pf_ctrl
.bits
.min_pkt_size
= NIC_MIN_PACKET_SIZE
+ 4;
337 pf_ctrl
.bits
.filter_frag_en
= 1;
339 if (etdev
->RegistryJumboPacket
> 8192) {
340 RXMAC_MCIF_CTRL_MAX_SEG_t mcif_ctrl_max_seg
;
342 /* In order to transmit jumbo packets greater than 8k, the
343 * FIFO between RxMAC and RxDMA needs to be reduced in size
344 * to (16k - Jumbo packet size). In order to implement this,
345 * we must use "cut through" mode in the RxMAC, which chops
346 * packets down into segments which are (max_size * 16). In
347 * this case we selected 256 bytes, since this is the size of
348 * the PCI-Express TLP's that the 1310 uses.
350 mcif_ctrl_max_seg
.bits
.seg_en
= 0x1;
351 mcif_ctrl_max_seg
.bits
.fc_en
= 0x0;
352 mcif_ctrl_max_seg
.bits
.max_size
= 0x10;
354 writel(mcif_ctrl_max_seg
.value
,
355 &pRxMac
->mcif_ctrl_max_seg
.value
);
357 writel(0, &pRxMac
->mcif_ctrl_max_seg
.value
);
360 /* Initialize the MCIF water marks */
361 writel(0, &pRxMac
->mcif_water_mark
.value
);
363 /* Initialize the MIF control */
364 writel(0, &pRxMac
->mif_ctrl
.value
);
366 /* Initialize the Space Available Register */
367 writel(0, &pRxMac
->space_avail
.value
);
369 /* Initialize the the mif_ctrl register
370 * bit 3: Receive code error. One or more nibbles were signaled as
371 * errors during the reception of the packet. Clear this
372 * bit in Gigabit, set it in 100Mbit. This was derived
373 * experimentally at UNH.
374 * bit 4: Receive CRC error. The packet's CRC did not match the
375 * internally generated CRC.
376 * bit 5: Receive length check error. Indicates that frame length
377 * field value in the packet does not match the actual data
378 * byte length and is not a type field.
379 * bit 16: Receive frame truncated.
380 * bit 17: Drop packet enable
382 if (etdev
->linkspeed
== TRUEPHY_SPEED_100MBPS
)
383 writel(0x30038, &pRxMac
->mif_ctrl
.value
);
385 writel(0x30030, &pRxMac
->mif_ctrl
.value
);
387 /* Finally we initialize RxMac to be enabled & WOL disabled. Packet
388 * filter is always enabled since it is where the runt packets are
389 * supposed to be dropped. For version A silicon, runt packet
390 * dropping doesn't work, so it is disabled in the pf_ctrl register,
391 * but we still leave the packet filter on.
393 writel(pf_ctrl
.value
, &pRxMac
->pf_ctrl
.value
);
394 writel(0x9, &pRxMac
->ctrl
.value
);
397 void ConfigTxMacRegs(struct et131x_adapter
*etdev
)
399 struct _TXMAC_t __iomem
*pTxMac
= &etdev
->regs
->txmac
;
400 TXMAC_CF_PARAM_t Local
;
402 /* We need to update the Control Frame Parameters
403 * cfpt - control frame pause timer set to 64 (0x40)
404 * cfep - control frame extended pause timer set to 0x0
406 if (etdev
->FlowControl
== None
) {
407 writel(0, &pTxMac
->cf_param
.value
);
409 Local
.bits
.cfpt
= 0x40;
410 Local
.bits
.cfep
= 0x0;
411 writel(Local
.value
, &pTxMac
->cf_param
.value
);
415 void ConfigMacStatRegs(struct et131x_adapter
*etdev
)
417 struct _MAC_STAT_t __iomem
*pDevMacStat
=
418 &etdev
->regs
->macStat
;
420 /* Next we need to initialize all the MAC_STAT registers to zero on
423 writel(0, &pDevMacStat
->RFcs
);
424 writel(0, &pDevMacStat
->RAln
);
425 writel(0, &pDevMacStat
->RFlr
);
426 writel(0, &pDevMacStat
->RDrp
);
427 writel(0, &pDevMacStat
->RCde
);
428 writel(0, &pDevMacStat
->ROvr
);
429 writel(0, &pDevMacStat
->RFrg
);
431 writel(0, &pDevMacStat
->TScl
);
432 writel(0, &pDevMacStat
->TDfr
);
433 writel(0, &pDevMacStat
->TMcl
);
434 writel(0, &pDevMacStat
->TLcl
);
435 writel(0, &pDevMacStat
->TNcl
);
436 writel(0, &pDevMacStat
->TOvr
);
437 writel(0, &pDevMacStat
->TUnd
);
439 /* Unmask any counters that we want to track the overflow of.
440 * Initially this will be all counters. It may become clear later
441 * that we do not need to track all counters.
444 MAC_STAT_REG_1_t Carry1M
= { 0xffffffff };
446 Carry1M
.bits
.rdrp
= 0;
447 Carry1M
.bits
.rjbr
= 1;
448 Carry1M
.bits
.rfrg
= 0;
449 Carry1M
.bits
.rovr
= 0;
450 Carry1M
.bits
.rund
= 1;
451 Carry1M
.bits
.rcse
= 1;
452 Carry1M
.bits
.rcde
= 0;
453 Carry1M
.bits
.rflr
= 0;
454 Carry1M
.bits
.raln
= 0;
455 Carry1M
.bits
.rxuo
= 1;
456 Carry1M
.bits
.rxpf
= 1;
457 Carry1M
.bits
.rxcf
= 1;
458 Carry1M
.bits
.rbca
= 1;
459 Carry1M
.bits
.rmca
= 1;
460 Carry1M
.bits
.rfcs
= 0;
461 Carry1M
.bits
.rpkt
= 1;
462 Carry1M
.bits
.rbyt
= 1;
463 Carry1M
.bits
.trmgv
= 1;
464 Carry1M
.bits
.trmax
= 1;
465 Carry1M
.bits
.tr1k
= 1;
466 Carry1M
.bits
.tr511
= 1;
467 Carry1M
.bits
.tr255
= 1;
468 Carry1M
.bits
.tr127
= 1;
469 Carry1M
.bits
.tr64
= 1;
471 writel(Carry1M
.value
, &pDevMacStat
->Carry1M
.value
);
475 MAC_STAT_REG_2_t Carry2M
= { 0xffffffff };
477 Carry2M
.bits
.tdrp
= 1;
478 Carry2M
.bits
.tpfh
= 1;
479 Carry2M
.bits
.tncl
= 0;
480 Carry2M
.bits
.txcl
= 1;
481 Carry2M
.bits
.tlcl
= 0;
482 Carry2M
.bits
.tmcl
= 0;
483 Carry2M
.bits
.tscl
= 0;
484 Carry2M
.bits
.tedf
= 1;
485 Carry2M
.bits
.tdfr
= 0;
486 Carry2M
.bits
.txpf
= 1;
487 Carry2M
.bits
.tbca
= 1;
488 Carry2M
.bits
.tmca
= 1;
489 Carry2M
.bits
.tpkt
= 1;
490 Carry2M
.bits
.tbyt
= 1;
491 Carry2M
.bits
.tfrg
= 1;
492 Carry2M
.bits
.tund
= 0;
493 Carry2M
.bits
.tovr
= 0;
494 Carry2M
.bits
.txcf
= 1;
495 Carry2M
.bits
.tfcs
= 1;
496 Carry2M
.bits
.tjbr
= 1;
498 writel(Carry2M
.value
, &pDevMacStat
->Carry2M
.value
);
502 void ConfigFlowControl(struct et131x_adapter
*etdev
)
504 if (etdev
->duplex_mode
== 0) {
505 etdev
->FlowControl
= None
;
507 char RemotePause
, RemoteAsyncPause
;
509 ET1310_PhyAccessMiBit(etdev
,
510 TRUEPHY_BIT_READ
, 5, 10, &RemotePause
);
511 ET1310_PhyAccessMiBit(etdev
,
512 TRUEPHY_BIT_READ
, 5, 11,
515 if ((RemotePause
== TRUEPHY_BIT_SET
) &&
516 (RemoteAsyncPause
== TRUEPHY_BIT_SET
)) {
517 etdev
->FlowControl
= etdev
->RegistryFlowControl
;
518 } else if ((RemotePause
== TRUEPHY_BIT_SET
) &&
519 (RemoteAsyncPause
== TRUEPHY_BIT_CLEAR
)) {
520 if (etdev
->RegistryFlowControl
== Both
)
521 etdev
->FlowControl
= Both
;
523 etdev
->FlowControl
= None
;
524 } else if ((RemotePause
== TRUEPHY_BIT_CLEAR
) &&
525 (RemoteAsyncPause
== TRUEPHY_BIT_CLEAR
)) {
526 etdev
->FlowControl
= None
;
527 } else {/* if (RemotePause == TRUEPHY_CLEAR_BIT &&
528 RemoteAsyncPause == TRUEPHY_SET_BIT) */
529 if (etdev
->RegistryFlowControl
== Both
)
530 etdev
->FlowControl
= RxOnly
;
532 etdev
->FlowControl
= None
;
538 * UpdateMacStatHostCounters - Update the local copy of the statistics
539 * @etdev: pointer to the adapter structure
541 void UpdateMacStatHostCounters(struct et131x_adapter
*etdev
)
543 struct _ce_stats_t
*stats
= &etdev
->Stats
;
544 struct _MAC_STAT_t __iomem
*pDevMacStat
=
545 &etdev
->regs
->macStat
;
547 stats
->collisions
+= readl(&pDevMacStat
->TNcl
);
548 stats
->first_collision
+= readl(&pDevMacStat
->TScl
);
549 stats
->tx_deferred
+= readl(&pDevMacStat
->TDfr
);
550 stats
->excessive_collisions
+= readl(&pDevMacStat
->TMcl
);
551 stats
->late_collisions
+= readl(&pDevMacStat
->TLcl
);
552 stats
->tx_uflo
+= readl(&pDevMacStat
->TUnd
);
553 stats
->max_pkt_error
+= readl(&pDevMacStat
->TOvr
);
555 stats
->alignment_err
+= readl(&pDevMacStat
->RAln
);
556 stats
->crc_err
+= readl(&pDevMacStat
->RCde
);
557 stats
->norcvbuf
+= readl(&pDevMacStat
->RDrp
);
558 stats
->rx_ov_flow
+= readl(&pDevMacStat
->ROvr
);
559 stats
->code_violations
+= readl(&pDevMacStat
->RFcs
);
560 stats
->length_err
+= readl(&pDevMacStat
->RFlr
);
562 stats
->other_errors
+= readl(&pDevMacStat
->RFrg
);
566 * HandleMacStatInterrupt
567 * @etdev: pointer to the adapter structure
569 * One of the MACSTAT counters has wrapped. Update the local copy of
570 * the statistics held in the adapter structure, checking the "wrap"
571 * bit for each counter.
573 void HandleMacStatInterrupt(struct et131x_adapter
*etdev
)
575 MAC_STAT_REG_1_t Carry1
;
576 MAC_STAT_REG_2_t Carry2
;
578 /* Read the interrupt bits from the register(s). These are Clear On
581 Carry1
.value
= readl(&etdev
->regs
->macStat
.Carry1
.value
);
582 Carry2
.value
= readl(&etdev
->regs
->macStat
.Carry2
.value
);
584 writel(Carry1
.value
, &etdev
->regs
->macStat
.Carry1
.value
);
585 writel(Carry2
.value
, &etdev
->regs
->macStat
.Carry2
.value
);
587 /* We need to do update the host copy of all the MAC_STAT counters.
588 * For each counter, check it's overflow bit. If the overflow bit is
589 * set, then increment the host version of the count by one complete
590 * revolution of the counter. This routine is called when the counter
591 * block indicates that one of the counters has wrapped.
593 if (Carry1
.bits
.rfcs
)
594 etdev
->Stats
.code_violations
+= COUNTER_WRAP_16_BIT
;
595 if (Carry1
.bits
.raln
)
596 etdev
->Stats
.alignment_err
+= COUNTER_WRAP_12_BIT
;
597 if (Carry1
.bits
.rflr
)
598 etdev
->Stats
.length_err
+= COUNTER_WRAP_16_BIT
;
599 if (Carry1
.bits
.rfrg
)
600 etdev
->Stats
.other_errors
+= COUNTER_WRAP_16_BIT
;
601 if (Carry1
.bits
.rcde
)
602 etdev
->Stats
.crc_err
+= COUNTER_WRAP_16_BIT
;
603 if (Carry1
.bits
.rovr
)
604 etdev
->Stats
.rx_ov_flow
+= COUNTER_WRAP_16_BIT
;
605 if (Carry1
.bits
.rdrp
)
606 etdev
->Stats
.norcvbuf
+= COUNTER_WRAP_16_BIT
;
607 if (Carry2
.bits
.tovr
)
608 etdev
->Stats
.max_pkt_error
+= COUNTER_WRAP_12_BIT
;
609 if (Carry2
.bits
.tund
)
610 etdev
->Stats
.tx_uflo
+= COUNTER_WRAP_12_BIT
;
611 if (Carry2
.bits
.tscl
)
612 etdev
->Stats
.first_collision
+= COUNTER_WRAP_12_BIT
;
613 if (Carry2
.bits
.tdfr
)
614 etdev
->Stats
.tx_deferred
+= COUNTER_WRAP_12_BIT
;
615 if (Carry2
.bits
.tmcl
)
616 etdev
->Stats
.excessive_collisions
+= COUNTER_WRAP_12_BIT
;
617 if (Carry2
.bits
.tlcl
)
618 etdev
->Stats
.late_collisions
+= COUNTER_WRAP_12_BIT
;
619 if (Carry2
.bits
.tncl
)
620 etdev
->Stats
.collisions
+= COUNTER_WRAP_12_BIT
;
623 void SetupDeviceForMulticast(struct et131x_adapter
*etdev
)
625 struct _RXMAC_t __iomem
*rxmac
= &etdev
->regs
->rxmac
;
634 /* If ET131X_PACKET_TYPE_MULTICAST is specified, then we provision
635 * the multi-cast LIST. If it is NOT specified, (and "ALL" is not
636 * specified) then we should pass NO multi-cast addresses to the
639 if (etdev
->PacketFilter
& ET131X_PACKET_TYPE_MULTICAST
) {
640 /* Loop through our multicast array and set up the device */
641 for (nIndex
= 0; nIndex
< etdev
->MCAddressCount
; nIndex
++) {
642 result
= ether_crc(6, etdev
->MCList
[nIndex
]);
644 result
= (result
& 0x3F800000) >> 23;
647 hash1
|= (1 << result
);
648 } else if ((31 < result
) && (result
< 64)) {
650 hash2
|= (1 << result
);
651 } else if ((63 < result
) && (result
< 96)) {
653 hash3
|= (1 << result
);
656 hash4
|= (1 << result
);
661 /* Write out the new hash to the device */
662 pm_csr
= readl(&etdev
->regs
->global
.pm_csr
);
663 if ((pm_csr
& ET_PM_PHY_SW_COMA
) == 0) {
664 writel(hash1
, &rxmac
->multi_hash1
);
665 writel(hash2
, &rxmac
->multi_hash2
);
666 writel(hash3
, &rxmac
->multi_hash3
);
667 writel(hash4
, &rxmac
->multi_hash4
);
671 void SetupDeviceForUnicast(struct et131x_adapter
*etdev
)
673 struct _RXMAC_t __iomem
*rxmac
= &etdev
->regs
->rxmac
;
674 RXMAC_UNI_PF_ADDR1_t uni_pf1
;
675 RXMAC_UNI_PF_ADDR2_t uni_pf2
;
676 RXMAC_UNI_PF_ADDR3_t uni_pf3
;
679 /* Set up unicast packet filter reg 3 to be the first two octets of
680 * the MAC address for both address
682 * Set up unicast packet filter reg 2 to be the octets 2 - 5 of the
683 * MAC address for second address
685 * Set up unicast packet filter reg 3 to be the octets 2 - 5 of the
686 * MAC address for first address
688 uni_pf3
.bits
.addr1_1
= etdev
->CurrentAddress
[0];
689 uni_pf3
.bits
.addr1_2
= etdev
->CurrentAddress
[1];
690 uni_pf3
.bits
.addr2_1
= etdev
->CurrentAddress
[0];
691 uni_pf3
.bits
.addr2_2
= etdev
->CurrentAddress
[1];
693 uni_pf2
.bits
.addr2_3
= etdev
->CurrentAddress
[2];
694 uni_pf2
.bits
.addr2_4
= etdev
->CurrentAddress
[3];
695 uni_pf2
.bits
.addr2_5
= etdev
->CurrentAddress
[4];
696 uni_pf2
.bits
.addr2_6
= etdev
->CurrentAddress
[5];
698 uni_pf1
.bits
.addr1_3
= etdev
->CurrentAddress
[2];
699 uni_pf1
.bits
.addr1_4
= etdev
->CurrentAddress
[3];
700 uni_pf1
.bits
.addr1_5
= etdev
->CurrentAddress
[4];
701 uni_pf1
.bits
.addr1_6
= etdev
->CurrentAddress
[5];
703 pm_csr
= readl(&etdev
->regs
->global
.pm_csr
);
704 if ((pm_csr
& ET_PM_PHY_SW_COMA
) == 0) {
705 writel(uni_pf1
.value
, &rxmac
->uni_pf_addr1
.value
);
706 writel(uni_pf2
.value
, &rxmac
->uni_pf_addr2
.value
);
707 writel(uni_pf3
.value
, &rxmac
->uni_pf_addr3
.value
);