?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
IPVS: fix netns if reading ip_vs_* procfs entries
[linux-2.6/linux-mips.git] / drivers / net / bnx2x / bnx2x_link.c
blob974ef2be36a5b6e804da1325dfdf94cd0da88f0e
1 /* Copyright 2008-2011 Broadcom Corporation
2 *
3 * Unless you and Broadcom execute a separate written software license
4 * agreement governing use of this software, this software is licensed to you
5 * under the terms of the GNU General Public License version 2, available
6 * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
7 *
8 * Notwithstanding the above, under no circumstances may you combine this
9 * software in any way with any other Broadcom software provided under a
10 * license other than the GPL, without Broadcom's express prior written
11 * consent.
12 *
13 * Written by Yaniv Rosner
14 *
15 */
16
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/pci.h>
22 #include <linux/netdevice.h>
23 #include <linux/delay.h>
24 #include <linux/ethtool.h>
25 #include <linux/mutex.h>
26
27 #include "bnx2x.h"
28
29 /********************************************************/
30 #define ETH_HLEN 14
31 /* L2 header size + 2*VLANs (8 bytes) + LLC SNAP (8 bytes) */
32 #define ETH_OVREHEAD (ETH_HLEN + 8 + 8)
33 #define ETH_MIN_PACKET_SIZE 60
34 #define ETH_MAX_PACKET_SIZE 1500
35 #define ETH_MAX_JUMBO_PACKET_SIZE 9600
36 #define MDIO_ACCESS_TIMEOUT 1000
37 #define BMAC_CONTROL_RX_ENABLE 2
38
39 /***********************************************************/
40 /* Shortcut definitions */
41 /***********************************************************/
42
43 #define NIG_LATCH_BC_ENABLE_MI_INT 0
44
45 #define NIG_STATUS_EMAC0_MI_INT \
46 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_EMAC0_MISC_MI_INT
47 #define NIG_STATUS_XGXS0_LINK10G \
48 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK10G
49 #define NIG_STATUS_XGXS0_LINK_STATUS \
50 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS
51 #define NIG_STATUS_XGXS0_LINK_STATUS_SIZE \
52 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS_SIZE
53 #define NIG_STATUS_SERDES0_LINK_STATUS \
54 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_SERDES0_LINK_STATUS
55 #define NIG_MASK_MI_INT \
56 NIG_MASK_INTERRUPT_PORT0_REG_MASK_EMAC0_MISC_MI_INT
57 #define NIG_MASK_XGXS0_LINK10G \
58 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK10G
59 #define NIG_MASK_XGXS0_LINK_STATUS \
60 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK_STATUS
61 #define NIG_MASK_SERDES0_LINK_STATUS \
62 NIG_MASK_INTERRUPT_PORT0_REG_MASK_SERDES0_LINK_STATUS
63
64 #define MDIO_AN_CL73_OR_37_COMPLETE \
65 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE | \
66 MDIO_GP_STATUS_TOP_AN_STATUS1_CL37_AUTONEG_COMPLETE)
67
68 #define XGXS_RESET_BITS \
69 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_RSTB_HW | \
70 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_IDDQ | \
71 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN | \
72 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN_SD | \
73 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_TXD_FIFO_RSTB)
74
75 #define SERDES_RESET_BITS \
76 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_RSTB_HW | \
77 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_IDDQ | \
78 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN | \
79 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN_SD)
80
81 #define AUTONEG_CL37 SHARED_HW_CFG_AN_ENABLE_CL37
82 #define AUTONEG_CL73 SHARED_HW_CFG_AN_ENABLE_CL73
83 #define AUTONEG_BAM SHARED_HW_CFG_AN_ENABLE_BAM
84 #define AUTONEG_PARALLEL \
85 SHARED_HW_CFG_AN_ENABLE_PARALLEL_DETECTION
86 #define AUTONEG_SGMII_FIBER_AUTODET \
87 SHARED_HW_CFG_AN_EN_SGMII_FIBER_AUTO_DETECT
88 #define AUTONEG_REMOTE_PHY SHARED_HW_CFG_AN_ENABLE_REMOTE_PHY
89
90 #define GP_STATUS_PAUSE_RSOLUTION_TXSIDE \
91 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_TXSIDE
92 #define GP_STATUS_PAUSE_RSOLUTION_RXSIDE \
93 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_RXSIDE
94 #define GP_STATUS_SPEED_MASK \
95 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_MASK
96 #define GP_STATUS_10M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10M
97 #define GP_STATUS_100M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_100M
98 #define GP_STATUS_1G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G
99 #define GP_STATUS_2_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_2_5G
100 #define GP_STATUS_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_5G
101 #define GP_STATUS_6G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_6G
102 #define GP_STATUS_10G_HIG \
103 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_HIG
104 #define GP_STATUS_10G_CX4 \
105 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_CX4
106 #define GP_STATUS_12G_HIG \
107 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12G_HIG
108 #define GP_STATUS_12_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12_5G
109 #define GP_STATUS_13G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_13G
110 #define GP_STATUS_15G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_15G
111 #define GP_STATUS_16G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_16G
112 #define GP_STATUS_1G_KX MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G_KX
113 #define GP_STATUS_10G_KX4 \
114 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_KX4
115
116 #define LINK_10THD LINK_STATUS_SPEED_AND_DUPLEX_10THD
117 #define LINK_10TFD LINK_STATUS_SPEED_AND_DUPLEX_10TFD
118 #define LINK_100TXHD LINK_STATUS_SPEED_AND_DUPLEX_100TXHD
119 #define LINK_100T4 LINK_STATUS_SPEED_AND_DUPLEX_100T4
120 #define LINK_100TXFD LINK_STATUS_SPEED_AND_DUPLEX_100TXFD
121 #define LINK_1000THD LINK_STATUS_SPEED_AND_DUPLEX_1000THD
122 #define LINK_1000TFD LINK_STATUS_SPEED_AND_DUPLEX_1000TFD
123 #define LINK_1000XFD LINK_STATUS_SPEED_AND_DUPLEX_1000XFD
124 #define LINK_2500THD LINK_STATUS_SPEED_AND_DUPLEX_2500THD
125 #define LINK_2500TFD LINK_STATUS_SPEED_AND_DUPLEX_2500TFD
126 #define LINK_2500XFD LINK_STATUS_SPEED_AND_DUPLEX_2500XFD
127 #define LINK_10GTFD LINK_STATUS_SPEED_AND_DUPLEX_10GTFD
128 #define LINK_10GXFD LINK_STATUS_SPEED_AND_DUPLEX_10GXFD
129 #define LINK_12GTFD LINK_STATUS_SPEED_AND_DUPLEX_12GTFD
130 #define LINK_12GXFD LINK_STATUS_SPEED_AND_DUPLEX_12GXFD
131 #define LINK_12_5GTFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GTFD
132 #define LINK_12_5GXFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GXFD
133 #define LINK_13GTFD LINK_STATUS_SPEED_AND_DUPLEX_13GTFD
134 #define LINK_13GXFD LINK_STATUS_SPEED_AND_DUPLEX_13GXFD
135 #define LINK_15GTFD LINK_STATUS_SPEED_AND_DUPLEX_15GTFD
136 #define LINK_15GXFD LINK_STATUS_SPEED_AND_DUPLEX_15GXFD
137 #define LINK_16GTFD LINK_STATUS_SPEED_AND_DUPLEX_16GTFD
138 #define LINK_16GXFD LINK_STATUS_SPEED_AND_DUPLEX_16GXFD
139
140 #define PHY_XGXS_FLAG 0x1
141 #define PHY_SGMII_FLAG 0x2
142 #define PHY_SERDES_FLAG 0x4
143
144 /* */
145 #define SFP_EEPROM_CON_TYPE_ADDR 0x2
146 #define SFP_EEPROM_CON_TYPE_VAL_LC 0x7
147 #define SFP_EEPROM_CON_TYPE_VAL_COPPER 0x21
148
149
150 #define SFP_EEPROM_COMP_CODE_ADDR 0x3
151 #define SFP_EEPROM_COMP_CODE_SR_MASK (1<<4)
152 #define SFP_EEPROM_COMP_CODE_LR_MASK (1<<5)
153 #define SFP_EEPROM_COMP_CODE_LRM_MASK (1<<6)
154
155 #define SFP_EEPROM_FC_TX_TECH_ADDR 0x8
156 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE 0x4
157 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE 0x8
158
159 #define SFP_EEPROM_OPTIONS_ADDR 0x40
160 #define SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK 0x1
161 #define SFP_EEPROM_OPTIONS_SIZE 2
162
163 #define EDC_MODE_LINEAR 0x0022
164 #define EDC_MODE_LIMITING 0x0044
165 #define EDC_MODE_PASSIVE_DAC 0x0055
166
167
168 #define ETS_BW_LIMIT_CREDIT_UPPER_BOUND (0x5000)
169 #define ETS_BW_LIMIT_CREDIT_WEIGHT (0x5000)
170 /**********************************************************/
171 /* INTERFACE */
172 /**********************************************************/
173
174 #define CL22_WR_OVER_CL45(_bp, _phy, _bank, _addr, _val) \
175 bnx2x_cl45_write(_bp, _phy, \
176 (_phy)->def_md_devad, \
177 (_bank + (_addr & 0xf)), \
178 _val)
179
180 #define CL22_RD_OVER_CL45(_bp, _phy, _bank, _addr, _val) \
181 bnx2x_cl45_read(_bp, _phy, \
182 (_phy)->def_md_devad, \
183 (_bank + (_addr & 0xf)), \
184 _val)
185
186 static u32 bnx2x_bits_en(struct bnx2x *bp, u32 reg, u32 bits)
187 {
188 u32 val = REG_RD(bp, reg);
189
190 val |= bits;
191 REG_WR(bp, reg, val);
192 return val;
193 }
194
195 static u32 bnx2x_bits_dis(struct bnx2x *bp, u32 reg, u32 bits)
196 {
197 u32 val = REG_RD(bp, reg);
198
199 val &= ~bits;
200 REG_WR(bp, reg, val);
201 return val;
202 }
203
204 /******************************************************************/
205 /* ETS section */
206 /******************************************************************/
207 void bnx2x_ets_disabled(struct link_params *params)
208 {
209 /* ETS disabled configuration*/
210 struct bnx2x *bp = params->bp;
211
212 DP(NETIF_MSG_LINK, "ETS disabled configuration\n");
213
214 /*
215 * mapping between entry priority to client number (0,1,2 -debug and
216 * management clients, 3 - COS0 client, 4 - COS client)(HIGHEST)
217 * 3bits client num.
218 * PRI4 | PRI3 | PRI2 | PRI1 | PRI0
219 * cos1-100 cos0-011 dbg1-010 dbg0-001 MCP-000
220 */
221
222 REG_WR(bp, NIG_REG_P0_TX_ARB_PRIORITY_CLIENT, 0x4688);
223 /*
224 * Bitmap of 5bits length. Each bit specifies whether the entry behaves
225 * as strict. Bits 0,1,2 - debug and management entries, 3 -
226 * COS0 entry, 4 - COS1 entry.
227 * COS1 | COS0 | DEBUG1 | DEBUG0 | MGMT
228 * bit4 bit3 bit2 bit1 bit0
229 * MCP and debug are strict
230 */
231
232 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_IS_STRICT, 0x7);
233 /* defines which entries (clients) are subjected to WFQ arbitration */
234 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_IS_SUBJECT2WFQ, 0);
235 /*
236 * For strict priority entries defines the number of consecutive
237 * slots for the highest priority.
238 */
239 REG_WR(bp, NIG_REG_P0_TX_ARB_NUM_STRICT_ARB_SLOTS, 0x100);
240 /*
241 * mapping between the CREDIT_WEIGHT registers and actual client
242 * numbers
243 */
244 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_CREDIT_MAP, 0);
245 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_WEIGHT_0, 0);
246 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_WEIGHT_1, 0);
247
248 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_UPPER_BOUND_0, 0);
249 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_UPPER_BOUND_1, 0);
250 REG_WR(bp, PBF_REG_HIGH_PRIORITY_COS_NUM, 0);
251 /* ETS mode disable */
252 REG_WR(bp, PBF_REG_ETS_ENABLED, 0);
253 /*
254 * If ETS mode is enabled (there is no strict priority) defines a WFQ
255 * weight for COS0/COS1.
256 */
257 REG_WR(bp, PBF_REG_COS0_WEIGHT, 0x2710);
258 REG_WR(bp, PBF_REG_COS1_WEIGHT, 0x2710);
259 /* Upper bound that COS0_WEIGHT can reach in the WFQ arbiter */
260 REG_WR(bp, PBF_REG_COS0_UPPER_BOUND, 0x989680);
261 REG_WR(bp, PBF_REG_COS1_UPPER_BOUND, 0x989680);
262 /* Defines the number of consecutive slots for the strict priority */
263 REG_WR(bp, PBF_REG_NUM_STRICT_ARB_SLOTS, 0);
264 }
265
266 static void bnx2x_ets_bw_limit_common(const struct link_params *params)
267 {
268 /* ETS disabled configuration */
269 struct bnx2x *bp = params->bp;
270 DP(NETIF_MSG_LINK, "ETS enabled BW limit configuration\n");
271 /*
272 * defines which entries (clients) are subjected to WFQ arbitration
273 * COS0 0x8
274 * COS1 0x10
275 */
276 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_IS_SUBJECT2WFQ, 0x18);
277 /*
278 * mapping between the ARB_CREDIT_WEIGHT registers and actual
279 * client numbers (WEIGHT_0 does not actually have to represent
280 * client 0)
281 * PRI4 | PRI3 | PRI2 | PRI1 | PRI0
282 * cos1-001 cos0-000 dbg1-100 dbg0-011 MCP-010
283 */
284 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_CREDIT_MAP, 0x111A);
285
286 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_UPPER_BOUND_0,
287 ETS_BW_LIMIT_CREDIT_UPPER_BOUND);
288 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_UPPER_BOUND_1,
289 ETS_BW_LIMIT_CREDIT_UPPER_BOUND);
290
291 /* ETS mode enabled*/
292 REG_WR(bp, PBF_REG_ETS_ENABLED, 1);
293
294 /* Defines the number of consecutive slots for the strict priority */
295 REG_WR(bp, PBF_REG_NUM_STRICT_ARB_SLOTS, 0);
296 /*
297 * Bitmap of 5bits length. Each bit specifies whether the entry behaves
298 * as strict. Bits 0,1,2 - debug and management entries, 3 - COS0
299 * entry, 4 - COS1 entry.
300 * COS1 | COS0 | DEBUG21 | DEBUG0 | MGMT
301 * bit4 bit3 bit2 bit1 bit0
302 * MCP and debug are strict
303 */
304 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_IS_STRICT, 0x7);
305
306 /* Upper bound that COS0_WEIGHT can reach in the WFQ arbiter.*/
307 REG_WR(bp, PBF_REG_COS0_UPPER_BOUND,
308 ETS_BW_LIMIT_CREDIT_UPPER_BOUND);
309 REG_WR(bp, PBF_REG_COS1_UPPER_BOUND,
310 ETS_BW_LIMIT_CREDIT_UPPER_BOUND);
311 }
312
313 void bnx2x_ets_bw_limit(const struct link_params *params, const u32 cos0_bw,
314 const u32 cos1_bw)
315 {
316 /* ETS disabled configuration*/
317 struct bnx2x *bp = params->bp;
318 const u32 total_bw = cos0_bw + cos1_bw;
319 u32 cos0_credit_weight = 0;
320 u32 cos1_credit_weight = 0;
321
322 DP(NETIF_MSG_LINK, "ETS enabled BW limit configuration\n");
323
324 if ((0 == total_bw) ||
325 (0 == cos0_bw) ||
326 (0 == cos1_bw)) {
327 DP(NETIF_MSG_LINK, "Total BW can't be zero\n");
328 return;
329 }
330
331 cos0_credit_weight = (cos0_bw * ETS_BW_LIMIT_CREDIT_WEIGHT)/
332 total_bw;
333 cos1_credit_weight = (cos1_bw * ETS_BW_LIMIT_CREDIT_WEIGHT)/
334 total_bw;
335
336 bnx2x_ets_bw_limit_common(params);
337
338 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_WEIGHT_0, cos0_credit_weight);
339 REG_WR(bp, NIG_REG_P0_TX_ARB_CREDIT_WEIGHT_1, cos1_credit_weight);
340
341 REG_WR(bp, PBF_REG_COS0_WEIGHT, cos0_credit_weight);
342 REG_WR(bp, PBF_REG_COS1_WEIGHT, cos1_credit_weight);
343 }
344
345 u8 bnx2x_ets_strict(const struct link_params *params, const u8 strict_cos)
346 {
347 /* ETS disabled configuration*/
348 struct bnx2x *bp = params->bp;
349 u32 val = 0;
350
351 DP(NETIF_MSG_LINK, "ETS enabled strict configuration\n");
352 /*
353 * Bitmap of 5bits length. Each bit specifies whether the entry behaves
354 * as strict. Bits 0,1,2 - debug and management entries,
355 * 3 - COS0 entry, 4 - COS1 entry.
356 * COS1 | COS0 | DEBUG21 | DEBUG0 | MGMT
357 * bit4 bit3 bit2 bit1 bit0
358 * MCP and debug are strict
359 */
360 REG_WR(bp, NIG_REG_P0_TX_ARB_CLIENT_IS_STRICT, 0x1F);
361 /*
362 * For strict priority entries defines the number of consecutive slots
363 * for the highest priority.
364 */
365 REG_WR(bp, NIG_REG_P0_TX_ARB_NUM_STRICT_ARB_SLOTS, 0x100);
366 /* ETS mode disable */
367 REG_WR(bp, PBF_REG_ETS_ENABLED, 0);
368 /* Defines the number of consecutive slots for the strict priority */
369 REG_WR(bp, PBF_REG_NUM_STRICT_ARB_SLOTS, 0x100);
370
371 /* Defines the number of consecutive slots for the strict priority */
372 REG_WR(bp, PBF_REG_HIGH_PRIORITY_COS_NUM, strict_cos);
373
374 /*
375 * mapping between entry priority to client number (0,1,2 -debug and
376 * management clients, 3 - COS0 client, 4 - COS client)(HIGHEST)
377 * 3bits client num.
378 * PRI4 | PRI3 | PRI2 | PRI1 | PRI0
379 * dbg0-010 dbg1-001 cos1-100 cos0-011 MCP-000
380 * dbg0-010 dbg1-001 cos0-011 cos1-100 MCP-000
381 */
382 val = (0 == strict_cos) ? 0x2318 : 0x22E0;
383 REG_WR(bp, NIG_REG_P0_TX_ARB_PRIORITY_CLIENT, val);
384
385 return 0;
386 }
387 /******************************************************************/
388 /* ETS section */
389 /******************************************************************/
390
391 static void bnx2x_bmac2_get_pfc_stat(struct link_params *params,
392 u32 pfc_frames_sent[2],
393 u32 pfc_frames_received[2])
394 {
395 /* Read pfc statistic */
396 struct bnx2x *bp = params->bp;
397 u32 bmac_addr = params->port ? NIG_REG_INGRESS_BMAC1_MEM :
398 NIG_REG_INGRESS_BMAC0_MEM;
399
400 DP(NETIF_MSG_LINK, "pfc statistic read from BMAC\n");
401
402 REG_RD_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_TX_STAT_GTPP,
403 pfc_frames_sent, 2);
404
405 REG_RD_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_RX_STAT_GRPP,
406 pfc_frames_received, 2);
407
408 }
409 static void bnx2x_emac_get_pfc_stat(struct link_params *params,
410 u32 pfc_frames_sent[2],
411 u32 pfc_frames_received[2])
412 {
413 /* Read pfc statistic */
414 struct bnx2x *bp = params->bp;
415 u32 emac_base = params->port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
416 u32 val_xon = 0;
417 u32 val_xoff = 0;
418
419 DP(NETIF_MSG_LINK, "pfc statistic read from EMAC\n");
420
421 /* PFC received frames */
422 val_xoff = REG_RD(bp, emac_base +
423 EMAC_REG_RX_PFC_STATS_XOFF_RCVD);
424 val_xoff &= EMAC_REG_RX_PFC_STATS_XOFF_RCVD_COUNT;
425 val_xon = REG_RD(bp, emac_base + EMAC_REG_RX_PFC_STATS_XON_RCVD);
426 val_xon &= EMAC_REG_RX_PFC_STATS_XON_RCVD_COUNT;
427
428 pfc_frames_received[0] = val_xon + val_xoff;
429
430 /* PFC received sent */
431 val_xoff = REG_RD(bp, emac_base +
432 EMAC_REG_RX_PFC_STATS_XOFF_SENT);
433 val_xoff &= EMAC_REG_RX_PFC_STATS_XOFF_SENT_COUNT;
434 val_xon = REG_RD(bp, emac_base + EMAC_REG_RX_PFC_STATS_XON_SENT);
435 val_xon &= EMAC_REG_RX_PFC_STATS_XON_SENT_COUNT;
436
437 pfc_frames_sent[0] = val_xon + val_xoff;
438 }
439
440 void bnx2x_pfc_statistic(struct link_params *params, struct link_vars *vars,
441 u32 pfc_frames_sent[2],
442 u32 pfc_frames_received[2])
443 {
444 /* Read pfc statistic */
445 struct bnx2x *bp = params->bp;
446 u32 val = 0;
447 DP(NETIF_MSG_LINK, "pfc statistic\n");
448
449 if (!vars->link_up)
450 return;
451
452 val = REG_RD(bp, MISC_REG_RESET_REG_2);
453 if ((val & (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port))
454 == 0) {
455 DP(NETIF_MSG_LINK, "About to read stats from EMAC\n");
456 bnx2x_emac_get_pfc_stat(params, pfc_frames_sent,
457 pfc_frames_received);
458 } else {
459 DP(NETIF_MSG_LINK, "About to read stats from BMAC\n");
460 bnx2x_bmac2_get_pfc_stat(params, pfc_frames_sent,
461 pfc_frames_received);
462 }
463 }
464 /******************************************************************/
465 /* MAC/PBF section */
466 /******************************************************************/
467 static void bnx2x_emac_init(struct link_params *params,
468 struct link_vars *vars)
469 {
470 /* reset and unreset the emac core */
471 struct bnx2x *bp = params->bp;
472 u8 port = params->port;
473 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
474 u32 val;
475 u16 timeout;
476
477 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
478 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
479 udelay(5);
480 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
481 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
482
483 /* init emac - use read-modify-write */
484 /* self clear reset */
485 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
486 EMAC_WR(bp, EMAC_REG_EMAC_MODE, (val | EMAC_MODE_RESET));
487
488 timeout = 200;
489 do {
490 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
491 DP(NETIF_MSG_LINK, "EMAC reset reg is %u\n", val);
492 if (!timeout) {
493 DP(NETIF_MSG_LINK, "EMAC timeout!\n");
494 return;
495 }
496 timeout--;
497 } while (val & EMAC_MODE_RESET);
498
499 /* Set mac address */
500 val = ((params->mac_addr[0] << 8) |
501 params->mac_addr[1]);
502 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH, val);
503
504 val = ((params->mac_addr[2] << 24) |
505 (params->mac_addr[3] << 16) |
506 (params->mac_addr[4] << 8) |
507 params->mac_addr[5]);
508 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + 4, val);
509 }
510
511 static u8 bnx2x_emac_enable(struct link_params *params,
512 struct link_vars *vars, u8 lb)
513 {
514 struct bnx2x *bp = params->bp;
515 u8 port = params->port;
516 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
517 u32 val;
518
519 DP(NETIF_MSG_LINK, "enabling EMAC\n");
520
521 /* enable emac and not bmac */
522 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 1);
523
524 /* ASIC */
525 if (vars->phy_flags & PHY_XGXS_FLAG) {
526 u32 ser_lane = ((params->lane_config &
527 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
528 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
529
530 DP(NETIF_MSG_LINK, "XGXS\n");
531 /* select the master lanes (out of 0-3) */
532 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, ser_lane);
533 /* select XGXS */
534 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
535
536 } else { /* SerDes */
537 DP(NETIF_MSG_LINK, "SerDes\n");
538 /* select SerDes */
539 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0);
540 }
541
542 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
543 EMAC_RX_MODE_RESET);
544 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
545 EMAC_TX_MODE_RESET);
546
547 if (CHIP_REV_IS_SLOW(bp)) {
548 /* config GMII mode */
549 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
550 EMAC_WR(bp, EMAC_REG_EMAC_MODE, (val | EMAC_MODE_PORT_GMII));
551 } else { /* ASIC */
552 /* pause enable/disable */
553 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
554 EMAC_RX_MODE_FLOW_EN);
555
556 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
557 (EMAC_TX_MODE_EXT_PAUSE_EN |
558 EMAC_TX_MODE_FLOW_EN));
559 if (!(params->feature_config_flags &
560 FEATURE_CONFIG_PFC_ENABLED)) {
561 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
562 bnx2x_bits_en(bp, emac_base +
563 EMAC_REG_EMAC_RX_MODE,
564 EMAC_RX_MODE_FLOW_EN);
565
566 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
567 bnx2x_bits_en(bp, emac_base +
568 EMAC_REG_EMAC_TX_MODE,
569 (EMAC_TX_MODE_EXT_PAUSE_EN |
570 EMAC_TX_MODE_FLOW_EN));
571 } else
572 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
573 EMAC_TX_MODE_FLOW_EN);
574 }
575
576 /* KEEP_VLAN_TAG, promiscuous */
577 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_RX_MODE);
578 val |= EMAC_RX_MODE_KEEP_VLAN_TAG | EMAC_RX_MODE_PROMISCUOUS;
579
580 /*
581 * Setting this bit causes MAC control frames (except for pause
582 * frames) to be passed on for processing. This setting has no
583 * affect on the operation of the pause frames. This bit effects
584 * all packets regardless of RX Parser packet sorting logic.
585 * Turn the PFC off to make sure we are in Xon state before
586 * enabling it.
587 */
588 EMAC_WR(bp, EMAC_REG_RX_PFC_MODE, 0);
589 if (params->feature_config_flags & FEATURE_CONFIG_PFC_ENABLED) {
590 DP(NETIF_MSG_LINK, "PFC is enabled\n");
591 /* Enable PFC again */
592 EMAC_WR(bp, EMAC_REG_RX_PFC_MODE,
593 EMAC_REG_RX_PFC_MODE_RX_EN |
594 EMAC_REG_RX_PFC_MODE_TX_EN |
595 EMAC_REG_RX_PFC_MODE_PRIORITIES);
596
597 EMAC_WR(bp, EMAC_REG_RX_PFC_PARAM,
598 ((0x0101 <<
599 EMAC_REG_RX_PFC_PARAM_OPCODE_BITSHIFT) |
600 (0x00ff <<
601 EMAC_REG_RX_PFC_PARAM_PRIORITY_EN_BITSHIFT)));
602 val |= EMAC_RX_MODE_KEEP_MAC_CONTROL;
603 }
604 EMAC_WR(bp, EMAC_REG_EMAC_RX_MODE, val);
605
606 /* Set Loopback */
607 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
608 if (lb)
609 val |= 0x810;
610 else
611 val &= ~0x810;
612 EMAC_WR(bp, EMAC_REG_EMAC_MODE, val);
613
614 /* enable emac */
615 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 1);
616
617 /* enable emac for jumbo packets */
618 EMAC_WR(bp, EMAC_REG_EMAC_RX_MTU_SIZE,
619 (EMAC_RX_MTU_SIZE_JUMBO_ENA |
620 (ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD)));
621
622 /* strip CRC */
623 REG_WR(bp, NIG_REG_NIG_INGRESS_EMAC0_NO_CRC + port*4, 0x1);
624
625 /* disable the NIG in/out to the bmac */
626 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x0);
627 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, 0x0);
628 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x0);
629
630 /* enable the NIG in/out to the emac */
631 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x1);
632 val = 0;
633 if ((params->feature_config_flags &
634 FEATURE_CONFIG_PFC_ENABLED) ||
635 (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
636 val = 1;
637
638 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, val);
639 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x1);
640
641 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x0);
642
643 vars->mac_type = MAC_TYPE_EMAC;
644 return 0;
645 }
646
647 static void bnx2x_update_pfc_bmac1(struct link_params *params,
648 struct link_vars *vars)
649 {
650 u32 wb_data[2];
651 struct bnx2x *bp = params->bp;
652 u32 bmac_addr = params->port ? NIG_REG_INGRESS_BMAC1_MEM :
653 NIG_REG_INGRESS_BMAC0_MEM;
654
655 u32 val = 0x14;
656 if ((!(params->feature_config_flags &
657 FEATURE_CONFIG_PFC_ENABLED)) &&
658 (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX))
659 /* Enable BigMAC to react on received Pause packets */
660 val |= (1<<5);
661 wb_data[0] = val;
662 wb_data[1] = 0;
663 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_CONTROL, wb_data, 2);
664
665 /* tx control */
666 val = 0xc0;
667 if (!(params->feature_config_flags &
668 FEATURE_CONFIG_PFC_ENABLED) &&
669 (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
670 val |= 0x800000;
671 wb_data[0] = val;
672 wb_data[1] = 0;
673 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_CONTROL, wb_data, 2);
674 }
675
676 static void bnx2x_update_pfc_bmac2(struct link_params *params,
677 struct link_vars *vars,
678 u8 is_lb)
679 {
680 /*
681 * Set rx control: Strip CRC and enable BigMAC to relay
682 * control packets to the system as well
683 */
684 u32 wb_data[2];
685 struct bnx2x *bp = params->bp;
686 u32 bmac_addr = params->port ? NIG_REG_INGRESS_BMAC1_MEM :
687 NIG_REG_INGRESS_BMAC0_MEM;
688 u32 val = 0x14;
689
690 if ((!(params->feature_config_flags &
691 FEATURE_CONFIG_PFC_ENABLED)) &&
692 (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX))
693 /* Enable BigMAC to react on received Pause packets */
694 val |= (1<<5);
695 wb_data[0] = val;
696 wb_data[1] = 0;
697 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_RX_CONTROL, wb_data, 2);
698 udelay(30);
699
700 /* Tx control */
701 val = 0xc0;
702 if (!(params->feature_config_flags &
703 FEATURE_CONFIG_PFC_ENABLED) &&
704 (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
705 val |= 0x800000;
706 wb_data[0] = val;
707 wb_data[1] = 0;
708 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_TX_CONTROL, wb_data, 2);
709
710 if (params->feature_config_flags & FEATURE_CONFIG_PFC_ENABLED) {
711 DP(NETIF_MSG_LINK, "PFC is enabled\n");
712 /* Enable PFC RX & TX & STATS and set 8 COS */
713 wb_data[0] = 0x0;
714 wb_data[0] |= (1<<0); /* RX */
715 wb_data[0] |= (1<<1); /* TX */
716 wb_data[0] |= (1<<2); /* Force initial Xon */
717 wb_data[0] |= (1<<3); /* 8 cos */
718 wb_data[0] |= (1<<5); /* STATS */
719 wb_data[1] = 0;
720 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_PFC_CONTROL,
721 wb_data, 2);
722 /* Clear the force Xon */
723 wb_data[0] &= ~(1<<2);
724 } else {
725 DP(NETIF_MSG_LINK, "PFC is disabled\n");
726 /* disable PFC RX & TX & STATS and set 8 COS */
727 wb_data[0] = 0x8;
728 wb_data[1] = 0;
729 }
730
731 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_PFC_CONTROL, wb_data, 2);
732
733 /*
734 * Set Time (based unit is 512 bit time) between automatic
735 * re-sending of PP packets amd enable automatic re-send of
736 * Per-Priroity Packet as long as pp_gen is asserted and
737 * pp_disable is low.
738 */
739 val = 0x8000;
740 if (params->feature_config_flags & FEATURE_CONFIG_PFC_ENABLED)
741 val |= (1<<16); /* enable automatic re-send */
742
743 wb_data[0] = val;
744 wb_data[1] = 0;
745 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_TX_PAUSE_CONTROL,
746 wb_data, 2);
747
748 /* mac control */
749 val = 0x3; /* Enable RX and TX */
750 if (is_lb) {
751 val |= 0x4; /* Local loopback */
752 DP(NETIF_MSG_LINK, "enable bmac loopback\n");
753 }
754 /* When PFC enabled, Pass pause frames towards the NIG. */
755 if (params->feature_config_flags & FEATURE_CONFIG_PFC_ENABLED)
756 val |= ((1<<6)|(1<<5));
757
758 wb_data[0] = val;
759 wb_data[1] = 0;
760 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_BMAC_CONTROL, wb_data, 2);
761 }
762
763 static void bnx2x_update_pfc_brb(struct link_params *params,
764 struct link_vars *vars,
765 struct bnx2x_nig_brb_pfc_port_params *pfc_params)
766 {
767 struct bnx2x *bp = params->bp;
768 int set_pfc = params->feature_config_flags &
769 FEATURE_CONFIG_PFC_ENABLED;
770
771 /* default - pause configuration */
772 u32 pause_xoff_th = PFC_BRB_MAC_PAUSE_XOFF_THRESHOLD_PAUSEABLE;
773 u32 pause_xon_th = PFC_BRB_MAC_PAUSE_XON_THRESHOLD_PAUSEABLE;
774 u32 full_xoff_th = PFC_BRB_MAC_FULL_XOFF_THRESHOLD_PAUSEABLE;
775 u32 full_xon_th = PFC_BRB_MAC_FULL_XON_THRESHOLD_PAUSEABLE;
776
777 if (set_pfc && pfc_params)
778 /* First COS */
779 if (!pfc_params->cos0_pauseable) {
780 pause_xoff_th =
781 PFC_BRB_MAC_PAUSE_XOFF_THRESHOLD_NON_PAUSEABLE;
782 pause_xon_th =
783 PFC_BRB_MAC_PAUSE_XON_THRESHOLD_NON_PAUSEABLE;
784 full_xoff_th =
785 PFC_BRB_MAC_FULL_XOFF_THRESHOLD_NON_PAUSEABLE;
786 full_xon_th =
787 PFC_BRB_MAC_FULL_XON_THRESHOLD_NON_PAUSEABLE;
788 }
789 /*
790 * The number of free blocks below which the pause signal to class 0
791 * of MAC #n is asserted. n=0,1
792 */
793 REG_WR(bp, BRB1_REG_PAUSE_0_XOFF_THRESHOLD_0 , pause_xoff_th);
794 /*
795 * The number of free blocks above which the pause signal to class 0
796 * of MAC #n is de-asserted. n=0,1
797 */
798 REG_WR(bp, BRB1_REG_PAUSE_0_XON_THRESHOLD_0 , pause_xon_th);
799 /*
800 * The number of free blocks below which the full signal to class 0
801 * of MAC #n is asserted. n=0,1
802 */
803 REG_WR(bp, BRB1_REG_FULL_0_XOFF_THRESHOLD_0 , full_xoff_th);
804 /*
805 * The number of free blocks above which the full signal to class 0
806 * of MAC #n is de-asserted. n=0,1
807 */
808 REG_WR(bp, BRB1_REG_FULL_0_XON_THRESHOLD_0 , full_xon_th);
809
810 if (set_pfc && pfc_params) {
811 /* Second COS */
812 if (pfc_params->cos1_pauseable) {
813 pause_xoff_th =
814 PFC_BRB_MAC_PAUSE_XOFF_THRESHOLD_PAUSEABLE;
815 pause_xon_th =
816 PFC_BRB_MAC_PAUSE_XON_THRESHOLD_PAUSEABLE;
817 full_xoff_th =
818 PFC_BRB_MAC_FULL_XOFF_THRESHOLD_PAUSEABLE;
819 full_xon_th =
820 PFC_BRB_MAC_FULL_XON_THRESHOLD_PAUSEABLE;
821 } else {
822 pause_xoff_th =
823 PFC_BRB_MAC_PAUSE_XOFF_THRESHOLD_NON_PAUSEABLE;
824 pause_xon_th =
825 PFC_BRB_MAC_PAUSE_XON_THRESHOLD_NON_PAUSEABLE;
826 full_xoff_th =
827 PFC_BRB_MAC_FULL_XOFF_THRESHOLD_NON_PAUSEABLE;
828 full_xon_th =
829 PFC_BRB_MAC_FULL_XON_THRESHOLD_NON_PAUSEABLE;
830 }
831 /*
832 * The number of free blocks below which the pause signal to
833 * class 1 of MAC #n is asserted. n=0,1
834 */
835 REG_WR(bp, BRB1_REG_PAUSE_1_XOFF_THRESHOLD_0, pause_xoff_th);
836 /*
837 * The number of free blocks above which the pause signal to
838 * class 1 of MAC #n is de-asserted. n=0,1
839 */
840 REG_WR(bp, BRB1_REG_PAUSE_1_XON_THRESHOLD_0, pause_xon_th);
841 /*
842 * The number of free blocks below which the full signal to
843 * class 1 of MAC #n is asserted. n=0,1
844 */
845 REG_WR(bp, BRB1_REG_FULL_1_XOFF_THRESHOLD_0, full_xoff_th);
846 /*
847 * The number of free blocks above which the full signal to
848 * class 1 of MAC #n is de-asserted. n=0,1
849 */
850 REG_WR(bp, BRB1_REG_FULL_1_XON_THRESHOLD_0, full_xon_th);
851 }
852 }
853
854 static void bnx2x_update_pfc_nig(struct link_params *params,
855 struct link_vars *vars,
856 struct bnx2x_nig_brb_pfc_port_params *nig_params)
857 {
858 u32 xcm_mask = 0, ppp_enable = 0, pause_enable = 0, llfc_out_en = 0;
859 u32 llfc_enable = 0, xcm0_out_en = 0, p0_hwpfc_enable = 0;
860 u32 pkt_priority_to_cos = 0;
861 u32 val;
862 struct bnx2x *bp = params->bp;
863 int port = params->port;
864 int set_pfc = params->feature_config_flags &
865 FEATURE_CONFIG_PFC_ENABLED;
866 DP(NETIF_MSG_LINK, "updating pfc nig parameters\n");
867
868 /*
869 * When NIG_LLH0_XCM_MASK_REG_LLHX_XCM_MASK_BCN bit is set
870 * MAC control frames (that are not pause packets)
871 * will be forwarded to the XCM.
872 */
873 xcm_mask = REG_RD(bp,
874 port ? NIG_REG_LLH1_XCM_MASK :
875 NIG_REG_LLH0_XCM_MASK);
876 /*
877 * nig params will override non PFC params, since it's possible to
878 * do transition from PFC to SAFC
879 */
880 if (set_pfc) {
881 pause_enable = 0;
882 llfc_out_en = 0;
883 llfc_enable = 0;
884 ppp_enable = 1;
885 xcm_mask &= ~(port ? NIG_LLH1_XCM_MASK_REG_LLH1_XCM_MASK_BCN :
886 NIG_LLH0_XCM_MASK_REG_LLH0_XCM_MASK_BCN);
887 xcm0_out_en = 0;
888 p0_hwpfc_enable = 1;
889 } else {
890 if (nig_params) {
891 llfc_out_en = nig_params->llfc_out_en;
892 llfc_enable = nig_params->llfc_enable;
893 pause_enable = nig_params->pause_enable;
894 } else /*defaul non PFC mode - PAUSE */
895 pause_enable = 1;
896
897 xcm_mask |= (port ? NIG_LLH1_XCM_MASK_REG_LLH1_XCM_MASK_BCN :
898 NIG_LLH0_XCM_MASK_REG_LLH0_XCM_MASK_BCN);
899 xcm0_out_en = 1;
900 }
901
902 REG_WR(bp, port ? NIG_REG_LLFC_OUT_EN_1 :
903 NIG_REG_LLFC_OUT_EN_0, llfc_out_en);
904 REG_WR(bp, port ? NIG_REG_LLFC_ENABLE_1 :
905 NIG_REG_LLFC_ENABLE_0, llfc_enable);
906 REG_WR(bp, port ? NIG_REG_PAUSE_ENABLE_1 :
907 NIG_REG_PAUSE_ENABLE_0, pause_enable);
908
909 REG_WR(bp, port ? NIG_REG_PPP_ENABLE_1 :
910 NIG_REG_PPP_ENABLE_0, ppp_enable);
911
912 REG_WR(bp, port ? NIG_REG_LLH1_XCM_MASK :
913 NIG_REG_LLH0_XCM_MASK, xcm_mask);
914
915 REG_WR(bp, NIG_REG_LLFC_EGRESS_SRC_ENABLE_0, 0x7);
916
917 /* output enable for RX_XCM # IF */
918 REG_WR(bp, NIG_REG_XCM0_OUT_EN, xcm0_out_en);
919
920 /* HW PFC TX enable */
921 REG_WR(bp, NIG_REG_P0_HWPFC_ENABLE, p0_hwpfc_enable);
922
923 /* 0x2 = BMAC, 0x1= EMAC */
924 switch (vars->mac_type) {
925 case MAC_TYPE_EMAC:
926 val = 1;
927 break;
928 case MAC_TYPE_BMAC:
929 val = 0;
930 break;
931 default:
932 val = 0;
933 break;
934 }
935 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT, val);
936
937 if (nig_params) {
938 pkt_priority_to_cos = nig_params->pkt_priority_to_cos;
939
940 REG_WR(bp, port ? NIG_REG_P1_RX_COS0_PRIORITY_MASK :
941 NIG_REG_P0_RX_COS0_PRIORITY_MASK,
942 nig_params->rx_cos0_priority_mask);
943
944 REG_WR(bp, port ? NIG_REG_P1_RX_COS1_PRIORITY_MASK :
945 NIG_REG_P0_RX_COS1_PRIORITY_MASK,
946 nig_params->rx_cos1_priority_mask);
947
948 REG_WR(bp, port ? NIG_REG_LLFC_HIGH_PRIORITY_CLASSES_1 :
949 NIG_REG_LLFC_HIGH_PRIORITY_CLASSES_0,
950 nig_params->llfc_high_priority_classes);
951
952 REG_WR(bp, port ? NIG_REG_LLFC_LOW_PRIORITY_CLASSES_1 :
953 NIG_REG_LLFC_LOW_PRIORITY_CLASSES_0,
954 nig_params->llfc_low_priority_classes);
955 }
956 REG_WR(bp, port ? NIG_REG_P1_PKT_PRIORITY_TO_COS :
957 NIG_REG_P0_PKT_PRIORITY_TO_COS,
958 pkt_priority_to_cos);
959 }
960
961
962 void bnx2x_update_pfc(struct link_params *params,
963 struct link_vars *vars,
964 struct bnx2x_nig_brb_pfc_port_params *pfc_params)
965 {
966 /*
967 * The PFC and pause are orthogonal to one another, meaning when
968 * PFC is enabled, the pause are disabled, and when PFC is
969 * disabled, pause are set according to the pause result.
970 */
971 u32 val;
972 struct bnx2x *bp = params->bp;
973
974 /* update NIG params */
975 bnx2x_update_pfc_nig(params, vars, pfc_params);
976
977 /* update BRB params */
978 bnx2x_update_pfc_brb(params, vars, pfc_params);
979
980 if (!vars->link_up)
981 return;
982
983 val = REG_RD(bp, MISC_REG_RESET_REG_2);
984 if ((val & (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port))
985 == 0) {
986 DP(NETIF_MSG_LINK, "About to update PFC in EMAC\n");
987 bnx2x_emac_enable(params, vars, 0);
988 return;
989 }
990
991 DP(NETIF_MSG_LINK, "About to update PFC in BMAC\n");
992 if (CHIP_IS_E2(bp))
993 bnx2x_update_pfc_bmac2(params, vars, 0);
994 else
995 bnx2x_update_pfc_bmac1(params, vars);
996
997 val = 0;
998 if ((params->feature_config_flags &
999 FEATURE_CONFIG_PFC_ENABLED) ||
1000 (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
1001 val = 1;
1002 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + params->port*4, val);
1003 }
1004
1005 static u8 bnx2x_bmac1_enable(struct link_params *params,
1006 struct link_vars *vars,
1007 u8 is_lb)
1008 {
1009 struct bnx2x *bp = params->bp;
1010 u8 port = params->port;
1011 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
1012 NIG_REG_INGRESS_BMAC0_MEM;
1013 u32 wb_data[2];
1014 u32 val;
1015
1016 DP(NETIF_MSG_LINK, "Enabling BigMAC1\n");
1017
1018 /* XGXS control */
1019 wb_data[0] = 0x3c;
1020 wb_data[1] = 0;
1021 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_XGXS_CONTROL,
1022 wb_data, 2);
1023
1024 /* tx MAC SA */
1025 wb_data[0] = ((params->mac_addr[2] << 24) |
1026 (params->mac_addr[3] << 16) |
1027 (params->mac_addr[4] << 8) |
1028 params->mac_addr[5]);
1029 wb_data[1] = ((params->mac_addr[0] << 8) |
1030 params->mac_addr[1]);
1031 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_SOURCE_ADDR, wb_data, 2);
1032
1033 /* mac control */
1034 val = 0x3;
1035 if (is_lb) {
1036 val |= 0x4;
1037 DP(NETIF_MSG_LINK, "enable bmac loopback\n");
1038 }
1039 wb_data[0] = val;
1040 wb_data[1] = 0;
1041 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL, wb_data, 2);
1042
1043 /* set rx mtu */
1044 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1045 wb_data[1] = 0;
1046 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_MAX_SIZE, wb_data, 2);
1047
1048 bnx2x_update_pfc_bmac1(params, vars);
1049
1050 /* set tx mtu */
1051 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1052 wb_data[1] = 0;
1053 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_MAX_SIZE, wb_data, 2);
1054
1055 /* set cnt max size */
1056 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1057 wb_data[1] = 0;
1058 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_CNT_MAX_SIZE, wb_data, 2);
1059
1060 /* configure safc */
1061 wb_data[0] = 0x1000200;
1062 wb_data[1] = 0;
1063 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LLFC_MSG_FLDS,
1064 wb_data, 2);
1065
1066 return 0;
1067 }
1068
1069 static u8 bnx2x_bmac2_enable(struct link_params *params,
1070 struct link_vars *vars,
1071 u8 is_lb)
1072 {
1073 struct bnx2x *bp = params->bp;
1074 u8 port = params->port;
1075 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
1076 NIG_REG_INGRESS_BMAC0_MEM;
1077 u32 wb_data[2];
1078
1079 DP(NETIF_MSG_LINK, "Enabling BigMAC2\n");
1080
1081 wb_data[0] = 0;
1082 wb_data[1] = 0;
1083 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_BMAC_CONTROL, wb_data, 2);
1084 udelay(30);
1085
1086 /* XGXS control: Reset phy HW, MDIO registers, PHY PLL and BMAC */
1087 wb_data[0] = 0x3c;
1088 wb_data[1] = 0;
1089 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_BMAC_XGXS_CONTROL,
1090 wb_data, 2);
1091
1092 udelay(30);
1093
1094 /* tx MAC SA */
1095 wb_data[0] = ((params->mac_addr[2] << 24) |
1096 (params->mac_addr[3] << 16) |
1097 (params->mac_addr[4] << 8) |
1098 params->mac_addr[5]);
1099 wb_data[1] = ((params->mac_addr[0] << 8) |
1100 params->mac_addr[1]);
1101 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_TX_SOURCE_ADDR,
1102 wb_data, 2);
1103
1104 udelay(30);
1105
1106 /* Configure SAFC */
1107 wb_data[0] = 0x1000200;
1108 wb_data[1] = 0;
1109 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_RX_LLFC_MSG_FLDS,
1110 wb_data, 2);
1111 udelay(30);
1112
1113 /* set rx mtu */
1114 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1115 wb_data[1] = 0;
1116 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_RX_MAX_SIZE, wb_data, 2);
1117 udelay(30);
1118
1119 /* set tx mtu */
1120 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1121 wb_data[1] = 0;
1122 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_TX_MAX_SIZE, wb_data, 2);
1123 udelay(30);
1124 /* set cnt max size */
1125 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD - 2;
1126 wb_data[1] = 0;
1127 REG_WR_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_CNT_MAX_SIZE, wb_data, 2);
1128 udelay(30);
1129 bnx2x_update_pfc_bmac2(params, vars, is_lb);
1130
1131 return 0;
1132 }
1133
1134 static u8 bnx2x_bmac_enable(struct link_params *params,
1135 struct link_vars *vars,
1136 u8 is_lb)
1137 {
1138 u8 rc, port = params->port;
1139 struct bnx2x *bp = params->bp;
1140 u32 val;
1141 /* reset and unreset the BigMac */
1142 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
1143 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
1144 msleep(1);
1145
1146 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
1147 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
1148
1149 /* enable access for bmac registers */
1150 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
1151
1152 /* Enable BMAC according to BMAC type*/
1153 if (CHIP_IS_E2(bp))
1154 rc = bnx2x_bmac2_enable(params, vars, is_lb);
1155 else
1156 rc = bnx2x_bmac1_enable(params, vars, is_lb);
1157 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0x1);
1158 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 0x0);
1159 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 0x0);
1160 val = 0;
1161 if ((params->feature_config_flags &
1162 FEATURE_CONFIG_PFC_ENABLED) ||
1163 (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
1164 val = 1;
1165 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, val);
1166 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x0);
1167 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x0);
1168 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, 0x0);
1169 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x1);
1170 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x1);
1171
1172 vars->mac_type = MAC_TYPE_BMAC;
1173 return rc;
1174 }
1175
1176
1177 static void bnx2x_update_mng(struct link_params *params, u32 link_status)
1178 {
1179 struct bnx2x *bp = params->bp;
1180
1181 REG_WR(bp, params->shmem_base +
1182 offsetof(struct shmem_region,
1183 port_mb[params->port].link_status), link_status);
1184 }
1185
1186 static void bnx2x_bmac_rx_disable(struct bnx2x *bp, u8 port)
1187 {
1188 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
1189 NIG_REG_INGRESS_BMAC0_MEM;
1190 u32 wb_data[2];
1191 u32 nig_bmac_enable = REG_RD(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4);
1192
1193 /* Only if the bmac is out of reset */
1194 if (REG_RD(bp, MISC_REG_RESET_REG_2) &
1195 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port) &&
1196 nig_bmac_enable) {
1197
1198 if (CHIP_IS_E2(bp)) {
1199 /* Clear Rx Enable bit in BMAC_CONTROL register */
1200 REG_RD_DMAE(bp, bmac_addr +
1201 BIGMAC2_REGISTER_BMAC_CONTROL,
1202 wb_data, 2);
1203 wb_data[0] &= ~BMAC_CONTROL_RX_ENABLE;
1204 REG_WR_DMAE(bp, bmac_addr +
1205 BIGMAC2_REGISTER_BMAC_CONTROL,
1206 wb_data, 2);
1207 } else {
1208 /* Clear Rx Enable bit in BMAC_CONTROL register */
1209 REG_RD_DMAE(bp, bmac_addr +
1210 BIGMAC_REGISTER_BMAC_CONTROL,
1211 wb_data, 2);
1212 wb_data[0] &= ~BMAC_CONTROL_RX_ENABLE;
1213 REG_WR_DMAE(bp, bmac_addr +
1214 BIGMAC_REGISTER_BMAC_CONTROL,
1215 wb_data, 2);
1216 }
1217 msleep(1);
1218 }
1219 }
1220
1221 static u8 bnx2x_pbf_update(struct link_params *params, u32 flow_ctrl,
1222 u32 line_speed)
1223 {
1224 struct bnx2x *bp = params->bp;
1225 u8 port = params->port;
1226 u32 init_crd, crd;
1227 u32 count = 1000;
1228
1229 /* disable port */
1230 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x1);
1231
1232 /* wait for init credit */
1233 init_crd = REG_RD(bp, PBF_REG_P0_INIT_CRD + port*4);
1234 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
1235 DP(NETIF_MSG_LINK, "init_crd 0x%x crd 0x%x\n", init_crd, crd);
1236
1237 while ((init_crd != crd) && count) {
1238 msleep(5);
1239
1240 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
1241 count--;
1242 }
1243 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
1244 if (init_crd != crd) {
1245 DP(NETIF_MSG_LINK, "BUG! init_crd 0x%x != crd 0x%x\n",
1246 init_crd, crd);
1247 return -EINVAL;
1248 }
1249
1250 if (flow_ctrl & BNX2X_FLOW_CTRL_RX ||
1251 line_speed == SPEED_10 ||
1252 line_speed == SPEED_100 ||
1253 line_speed == SPEED_1000 ||
1254 line_speed == SPEED_2500) {
1255 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 1);
1256 /* update threshold */
1257 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, 0);
1258 /* update init credit */
1259 init_crd = 778; /* (800-18-4) */
1260
1261 } else {
1262 u32 thresh = (ETH_MAX_JUMBO_PACKET_SIZE +
1263 ETH_OVREHEAD)/16;
1264 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
1265 /* update threshold */
1266 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, thresh);
1267 /* update init credit */
1268 switch (line_speed) {
1269 case SPEED_10000:
1270 init_crd = thresh + 553 - 22;
1271 break;
1272
1273 case SPEED_12000:
1274 init_crd = thresh + 664 - 22;
1275 break;
1276
1277 case SPEED_13000:
1278 init_crd = thresh + 742 - 22;
1279 break;
1280
1281 case SPEED_16000:
1282 init_crd = thresh + 778 - 22;
1283 break;
1284 default:
1285 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
1286 line_speed);
1287 return -EINVAL;
1288 }
1289 }
1290 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, init_crd);
1291 DP(NETIF_MSG_LINK, "PBF updated to speed %d credit %d\n",
1292 line_speed, init_crd);
1293
1294 /* probe the credit changes */
1295 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x1);
1296 msleep(5);
1297 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x0);
1298
1299 /* enable port */
1300 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x0);
1301 return 0;
1302 }
1303
1304 /*
1305 * get_emac_base
1306 *
1307 * @param cb
1308 * @param mdc_mdio_access
1309 * @param port
1310 *
1311 * @return u32
1312 *
1313 * This function selects the MDC/MDIO access (through emac0 or
1314 * emac1) depend on the mdc_mdio_access, port, port swapped. Each
1315 * phy has a default access mode, which could also be overridden
1316 * by nvram configuration. This parameter, whether this is the
1317 * default phy configuration, or the nvram overrun
1318 * configuration, is passed here as mdc_mdio_access and selects
1319 * the emac_base for the CL45 read/writes operations
1320 */
1321 static u32 bnx2x_get_emac_base(struct bnx2x *bp,
1322 u32 mdc_mdio_access, u8 port)
1323 {
1324 u32 emac_base = 0;
1325 switch (mdc_mdio_access) {
1326 case SHARED_HW_CFG_MDC_MDIO_ACCESS1_PHY_TYPE:
1327 break;
1328 case SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC0:
1329 if (REG_RD(bp, NIG_REG_PORT_SWAP))
1330 emac_base = GRCBASE_EMAC1;
1331 else
1332 emac_base = GRCBASE_EMAC0;
1333 break;
1334 case SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1:
1335 if (REG_RD(bp, NIG_REG_PORT_SWAP))
1336 emac_base = GRCBASE_EMAC0;
1337 else
1338 emac_base = GRCBASE_EMAC1;
1339 break;
1340 case SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH:
1341 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1342 break;
1343 case SHARED_HW_CFG_MDC_MDIO_ACCESS1_SWAPPED:
1344 emac_base = (port) ? GRCBASE_EMAC0 : GRCBASE_EMAC1;
1345 break;
1346 default:
1347 break;
1348 }
1349 return emac_base;
1350
1351 }
1352
1353 /******************************************************************/
1354 /* CL45 access functions */
1355 /******************************************************************/
1356 static u8 bnx2x_cl45_write(struct bnx2x *bp, struct bnx2x_phy *phy,
1357 u8 devad, u16 reg, u16 val)
1358 {
1359 u32 tmp, saved_mode;
1360 u8 i, rc = 0;
1361 /*
1362 * Set clause 45 mode, slow down the MDIO clock to 2.5MHz
1363 * (a value of 49==0x31) and make sure that the AUTO poll is off
1364 */
1365
1366 saved_mode = REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
1367 tmp = saved_mode & ~(EMAC_MDIO_MODE_AUTO_POLL |
1368 EMAC_MDIO_MODE_CLOCK_CNT);
1369 tmp |= (EMAC_MDIO_MODE_CLAUSE_45 |
1370 (49 << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
1371 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, tmp);
1372 REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
1373 udelay(40);
1374
1375 /* address */
1376
1377 tmp = ((phy->addr << 21) | (devad << 16) | reg |
1378 EMAC_MDIO_COMM_COMMAND_ADDRESS |
1379 EMAC_MDIO_COMM_START_BUSY);
1380 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
1381
1382 for (i = 0; i < 50; i++) {
1383 udelay(10);
1384
1385 tmp = REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
1386 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
1387 udelay(5);
1388 break;
1389 }
1390 }
1391 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
1392 DP(NETIF_MSG_LINK, "write phy register failed\n");
1393 netdev_err(bp->dev, "MDC/MDIO access timeout\n");
1394 rc = -EFAULT;
1395 } else {
1396 /* data */
1397 tmp = ((phy->addr << 21) | (devad << 16) | val |
1398 EMAC_MDIO_COMM_COMMAND_WRITE_45 |
1399 EMAC_MDIO_COMM_START_BUSY);
1400 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
1401
1402 for (i = 0; i < 50; i++) {
1403 udelay(10);
1404
1405 tmp = REG_RD(bp, phy->mdio_ctrl +
1406 EMAC_REG_EMAC_MDIO_COMM);
1407 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
1408 udelay(5);
1409 break;
1410 }
1411 }
1412 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
1413 DP(NETIF_MSG_LINK, "write phy register failed\n");
1414 netdev_err(bp->dev, "MDC/MDIO access timeout\n");
1415 rc = -EFAULT;
1416 }
1417 }
1418
1419 /* Restore the saved mode */
1420 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
1421
1422 return rc;
1423 }
1424
1425 static u8 bnx2x_cl45_read(struct bnx2x *bp, struct bnx2x_phy *phy,
1426 u8 devad, u16 reg, u16 *ret_val)
1427 {
1428 u32 val, saved_mode;
1429 u16 i;
1430 u8 rc = 0;
1431 /*
1432 * Set clause 45 mode, slow down the MDIO clock to 2.5MHz
1433 * (a value of 49==0x31) and make sure that the AUTO poll is off
1434 */
1435
1436 saved_mode = REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
1437 val = saved_mode & ~((EMAC_MDIO_MODE_AUTO_POLL |
1438 EMAC_MDIO_MODE_CLOCK_CNT));
1439 val |= (EMAC_MDIO_MODE_CLAUSE_45 |
1440 (49L << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
1441 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, val);
1442 REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
1443 udelay(40);
1444
1445 /* address */
1446 val = ((phy->addr << 21) | (devad << 16) | reg |
1447 EMAC_MDIO_COMM_COMMAND_ADDRESS |
1448 EMAC_MDIO_COMM_START_BUSY);
1449 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
1450
1451 for (i = 0; i < 50; i++) {
1452 udelay(10);
1453
1454 val = REG_RD(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
1455 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
1456 udelay(5);
1457 break;
1458 }
1459 }
1460 if (val & EMAC_MDIO_COMM_START_BUSY) {
1461 DP(NETIF_MSG_LINK, "read phy register failed\n");
1462 netdev_err(bp->dev, "MDC/MDIO access timeout\n");
1463 *ret_val = 0;
1464 rc = -EFAULT;
1465
1466 } else {
1467 /* data */
1468 val = ((phy->addr << 21) | (devad << 16) |
1469 EMAC_MDIO_COMM_COMMAND_READ_45 |
1470 EMAC_MDIO_COMM_START_BUSY);
1471 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
1472
1473 for (i = 0; i < 50; i++) {
1474 udelay(10);
1475
1476 val = REG_RD(bp, phy->mdio_ctrl +
1477 EMAC_REG_EMAC_MDIO_COMM);
1478 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
1479 *ret_val = (u16)(val & EMAC_MDIO_COMM_DATA);
1480 break;
1481 }
1482 }
1483 if (val & EMAC_MDIO_COMM_START_BUSY) {
1484 DP(NETIF_MSG_LINK, "read phy register failed\n");
1485 netdev_err(bp->dev, "MDC/MDIO access timeout\n");
1486 *ret_val = 0;
1487 rc = -EFAULT;
1488 }
1489 }
1490
1491 /* Restore the saved mode */
1492 REG_WR(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
1493
1494 return rc;
1495 }
1496
1497 u8 bnx2x_phy_read(struct link_params *params, u8 phy_addr,
1498 u8 devad, u16 reg, u16 *ret_val)
1499 {
1500 u8 phy_index;
1501 /*
1502 * Probe for the phy according to the given phy_addr, and execute
1503 * the read request on it
1504 */
1505 for (phy_index = 0; phy_index < params->num_phys; phy_index++) {
1506 if (params->phy[phy_index].addr == phy_addr) {
1507 return bnx2x_cl45_read(params->bp,
1508 &params->phy[phy_index], devad,
1509 reg, ret_val);
1510 }
1511 }
1512 return -EINVAL;
1513 }
1514
1515 u8 bnx2x_phy_write(struct link_params *params, u8 phy_addr,
1516 u8 devad, u16 reg, u16 val)
1517 {
1518 u8 phy_index;
1519 /*
1520 * Probe for the phy according to the given phy_addr, and execute
1521 * the write request on it
1522 */
1523 for (phy_index = 0; phy_index < params->num_phys; phy_index++) {
1524 if (params->phy[phy_index].addr == phy_addr) {
1525 return bnx2x_cl45_write(params->bp,
1526 &params->phy[phy_index], devad,
1527 reg, val);
1528 }
1529 }
1530 return -EINVAL;
1531 }
1532
1533 static void bnx2x_set_aer_mmd_xgxs(struct link_params *params,
1534 struct bnx2x_phy *phy)
1535 {
1536 u32 ser_lane;
1537 u16 offset, aer_val;
1538 struct bnx2x *bp = params->bp;
1539 ser_lane = ((params->lane_config &
1540 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
1541 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
1542
1543 offset = phy->addr + ser_lane;
1544 if (CHIP_IS_E2(bp))
1545 aer_val = 0x3800 + offset - 1;
1546 else
1547 aer_val = 0x3800 + offset;
1548 CL22_WR_OVER_CL45(bp, phy, MDIO_REG_BANK_AER_BLOCK,
1549 MDIO_AER_BLOCK_AER_REG, aer_val);
1550 }
1551 static void bnx2x_set_aer_mmd_serdes(struct bnx2x *bp,
1552 struct bnx2x_phy *phy)
1553 {
1554 CL22_WR_OVER_CL45(bp, phy,
1555 MDIO_REG_BANK_AER_BLOCK,
1556 MDIO_AER_BLOCK_AER_REG, 0x3800);
1557 }
1558
1559 /******************************************************************/
1560 /* Internal phy section */
1561 /******************************************************************/
1562
1563 static void bnx2x_set_serdes_access(struct bnx2x *bp, u8 port)
1564 {
1565 u32 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1566
1567 /* Set Clause 22 */
1568 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + port*0x10, 1);
1569 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245f8000);
1570 udelay(500);
1571 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245d000f);
1572 udelay(500);
1573 /* Set Clause 45 */
1574 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + port*0x10, 0);
1575 }
1576
1577 static void bnx2x_serdes_deassert(struct bnx2x *bp, u8 port)
1578 {
1579 u32 val;
1580
1581 DP(NETIF_MSG_LINK, "bnx2x_serdes_deassert\n");
1582
1583 val = SERDES_RESET_BITS << (port*16);
1584
1585 /* reset and unreset the SerDes/XGXS */
1586 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR, val);
1587 udelay(500);
1588 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET, val);
1589
1590 bnx2x_set_serdes_access(bp, port);
1591
1592 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_DEVAD + port*0x10,
1593 DEFAULT_PHY_DEV_ADDR);
1594 }
1595
1596 static void bnx2x_xgxs_deassert(struct link_params *params)
1597 {
1598 struct bnx2x *bp = params->bp;
1599 u8 port;
1600 u32 val;
1601 DP(NETIF_MSG_LINK, "bnx2x_xgxs_deassert\n");
1602 port = params->port;
1603
1604 val = XGXS_RESET_BITS << (port*16);
1605
1606 /* reset and unreset the SerDes/XGXS */
1607 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR, val);
1608 udelay(500);
1609 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET, val);
1610
1611 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_ST + port*0x18, 0);
1612 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18,
1613 params->phy[INT_PHY].def_md_devad);
1614 }
1615
1616
1617 void bnx2x_link_status_update(struct link_params *params,
1618 struct link_vars *vars)
1619 {
1620 struct bnx2x *bp = params->bp;
1621 u8 link_10g;
1622 u8 port = params->port;
1623
1624 vars->link_status = REG_RD(bp, params->shmem_base +
1625 offsetof(struct shmem_region,
1626 port_mb[port].link_status));
1627
1628 vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
1629
1630 if (vars->link_up) {
1631 DP(NETIF_MSG_LINK, "phy link up\n");
1632
1633 vars->phy_link_up = 1;
1634 vars->duplex = DUPLEX_FULL;
1635 switch (vars->link_status &
1636 LINK_STATUS_SPEED_AND_DUPLEX_MASK) {
1637 case LINK_10THD:
1638 vars->duplex = DUPLEX_HALF;
1639 /* fall thru */
1640 case LINK_10TFD:
1641 vars->line_speed = SPEED_10;
1642 break;
1643
1644 case LINK_100TXHD:
1645 vars->duplex = DUPLEX_HALF;
1646 /* fall thru */
1647 case LINK_100T4:
1648 case LINK_100TXFD:
1649 vars->line_speed = SPEED_100;
1650 break;
1651
1652 case LINK_1000THD:
1653 vars->duplex = DUPLEX_HALF;
1654 /* fall thru */
1655 case LINK_1000TFD:
1656 vars->line_speed = SPEED_1000;
1657 break;
1658
1659 case LINK_2500THD:
1660 vars->duplex = DUPLEX_HALF;
1661 /* fall thru */
1662 case LINK_2500TFD:
1663 vars->line_speed = SPEED_2500;
1664 break;
1665
1666 case LINK_10GTFD:
1667 vars->line_speed = SPEED_10000;
1668 break;
1669
1670 case LINK_12GTFD:
1671 vars->line_speed = SPEED_12000;
1672 break;
1673
1674 case LINK_12_5GTFD:
1675 vars->line_speed = SPEED_12500;
1676 break;
1677
1678 case LINK_13GTFD:
1679 vars->line_speed = SPEED_13000;
1680 break;
1681
1682 case LINK_15GTFD:
1683 vars->line_speed = SPEED_15000;
1684 break;
1685
1686 case LINK_16GTFD:
1687 vars->line_speed = SPEED_16000;
1688 break;
1689
1690 default:
1691 break;
1692 }
1693 vars->flow_ctrl = 0;
1694 if (vars->link_status & LINK_STATUS_TX_FLOW_CONTROL_ENABLED)
1695 vars->flow_ctrl |= BNX2X_FLOW_CTRL_TX;
1696
1697 if (vars->link_status & LINK_STATUS_RX_FLOW_CONTROL_ENABLED)
1698 vars->flow_ctrl |= BNX2X_FLOW_CTRL_RX;
1699
1700 if (!vars->flow_ctrl)
1701 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
1702
1703 if (vars->line_speed &&
1704 ((vars->line_speed == SPEED_10) ||
1705 (vars->line_speed == SPEED_100))) {
1706 vars->phy_flags |= PHY_SGMII_FLAG;
1707 } else {
1708 vars->phy_flags &= ~PHY_SGMII_FLAG;
1709 }
1710
1711 /* anything 10 and over uses the bmac */
1712 link_10g = ((vars->line_speed == SPEED_10000) ||
1713 (vars->line_speed == SPEED_12000) ||
1714 (vars->line_speed == SPEED_12500) ||
1715 (vars->line_speed == SPEED_13000) ||
1716 (vars->line_speed == SPEED_15000) ||
1717 (vars->line_speed == SPEED_16000));
1718 if (link_10g)
1719 vars->mac_type = MAC_TYPE_BMAC;
1720 else
1721 vars->mac_type = MAC_TYPE_EMAC;
1722
1723 } else { /* link down */
1724 DP(NETIF_MSG_LINK, "phy link down\n");
1725
1726 vars->phy_link_up = 0;
1727
1728 vars->line_speed = 0;
1729 vars->duplex = DUPLEX_FULL;
1730 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
1731
1732 /* indicate no mac active */
1733 vars->mac_type = MAC_TYPE_NONE;
1734 }
1735
1736 DP(NETIF_MSG_LINK, "link_status 0x%x phy_link_up %x\n",
1737 vars->link_status, vars->phy_link_up);
1738 DP(NETIF_MSG_LINK, "line_speed %x duplex %x flow_ctrl 0x%x\n",
1739 vars->line_speed, vars->duplex, vars->flow_ctrl);
1740 }
1741
1742
1743 static void bnx2x_set_master_ln(struct link_params *params,
1744 struct bnx2x_phy *phy)
1745 {
1746 struct bnx2x *bp = params->bp;
1747 u16 new_master_ln, ser_lane;
1748 ser_lane = ((params->lane_config &
1749 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
1750 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
1751
1752 /* set the master_ln for AN */
1753 CL22_RD_OVER_CL45(bp, phy,
1754 MDIO_REG_BANK_XGXS_BLOCK2,
1755 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1756 &new_master_ln);
1757
1758 CL22_WR_OVER_CL45(bp, phy,
1759 MDIO_REG_BANK_XGXS_BLOCK2 ,
1760 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1761 (new_master_ln | ser_lane));
1762 }
1763
1764 static u8 bnx2x_reset_unicore(struct link_params *params,
1765 struct bnx2x_phy *phy,
1766 u8 set_serdes)
1767 {
1768 struct bnx2x *bp = params->bp;
1769 u16 mii_control;
1770 u16 i;
1771 CL22_RD_OVER_CL45(bp, phy,
1772 MDIO_REG_BANK_COMBO_IEEE0,
1773 MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
1774
1775 /* reset the unicore */
1776 CL22_WR_OVER_CL45(bp, phy,
1777 MDIO_REG_BANK_COMBO_IEEE0,
1778 MDIO_COMBO_IEEE0_MII_CONTROL,
1779 (mii_control |
1780 MDIO_COMBO_IEEO_MII_CONTROL_RESET));
1781 if (set_serdes)
1782 bnx2x_set_serdes_access(bp, params->port);
1783
1784 /* wait for the reset to self clear */
1785 for (i = 0; i < MDIO_ACCESS_TIMEOUT; i++) {
1786 udelay(5);
1787
1788 /* the reset erased the previous bank value */
1789 CL22_RD_OVER_CL45(bp, phy,
1790 MDIO_REG_BANK_COMBO_IEEE0,
1791 MDIO_COMBO_IEEE0_MII_CONTROL,
1792 &mii_control);
1793
1794 if (!(mii_control & MDIO_COMBO_IEEO_MII_CONTROL_RESET)) {
1795 udelay(5);
1796 return 0;
1797 }
1798 }
1799
1800 netdev_err(bp->dev, "Warning: PHY was not initialized,"
1801 " Port %d\n",
1802 params->port);
1803 DP(NETIF_MSG_LINK, "BUG! XGXS is still in reset!\n");
1804 return -EINVAL;
1805
1806 }
1807
1808 static void bnx2x_set_swap_lanes(struct link_params *params,
1809 struct bnx2x_phy *phy)
1810 {
1811 struct bnx2x *bp = params->bp;
1812 /*
1813 * Each two bits represents a lane number:
1814 * No swap is 0123 => 0x1b no need to enable the swap
1815 */
1816 u16 ser_lane, rx_lane_swap, tx_lane_swap;
1817
1818 ser_lane = ((params->lane_config &
1819 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
1820 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
1821 rx_lane_swap = ((params->lane_config &
1822 PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK) >>
1823 PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT);
1824 tx_lane_swap = ((params->lane_config &
1825 PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK) >>
1826 PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT);
1827
1828 if (rx_lane_swap != 0x1b) {
1829 CL22_WR_OVER_CL45(bp, phy,
1830 MDIO_REG_BANK_XGXS_BLOCK2,
1831 MDIO_XGXS_BLOCK2_RX_LN_SWAP,
1832 (rx_lane_swap |
1833 MDIO_XGXS_BLOCK2_RX_LN_SWAP_ENABLE |
1834 MDIO_XGXS_BLOCK2_RX_LN_SWAP_FORCE_ENABLE));
1835 } else {
1836 CL22_WR_OVER_CL45(bp, phy,
1837 MDIO_REG_BANK_XGXS_BLOCK2,
1838 MDIO_XGXS_BLOCK2_RX_LN_SWAP, 0);
1839 }
1840
1841 if (tx_lane_swap != 0x1b) {
1842 CL22_WR_OVER_CL45(bp, phy,
1843 MDIO_REG_BANK_XGXS_BLOCK2,
1844 MDIO_XGXS_BLOCK2_TX_LN_SWAP,
1845 (tx_lane_swap |
1846 MDIO_XGXS_BLOCK2_TX_LN_SWAP_ENABLE));
1847 } else {
1848 CL22_WR_OVER_CL45(bp, phy,
1849 MDIO_REG_BANK_XGXS_BLOCK2,
1850 MDIO_XGXS_BLOCK2_TX_LN_SWAP, 0);
1851 }
1852 }
1853
1854 static void bnx2x_set_parallel_detection(struct bnx2x_phy *phy,
1855 struct link_params *params)
1856 {
1857 struct bnx2x *bp = params->bp;
1858 u16 control2;
1859 CL22_RD_OVER_CL45(bp, phy,
1860 MDIO_REG_BANK_SERDES_DIGITAL,
1861 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1862 &control2);
1863 if (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
1864 control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
1865 else
1866 control2 &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
1867 DP(NETIF_MSG_LINK, "phy->speed_cap_mask = 0x%x, control2 = 0x%x\n",
1868 phy->speed_cap_mask, control2);
1869 CL22_WR_OVER_CL45(bp, phy,
1870 MDIO_REG_BANK_SERDES_DIGITAL,
1871 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1872 control2);
1873
1874 if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
1875 (phy->speed_cap_mask &
1876 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
1877 DP(NETIF_MSG_LINK, "XGXS\n");
1878
1879 CL22_WR_OVER_CL45(bp, phy,
1880 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1881 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK,
1882 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK_CNT);
1883
1884 CL22_RD_OVER_CL45(bp, phy,
1885 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1886 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1887 &control2);
1888
1889
1890 control2 |=
1891 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL_PARDET10G_EN;
1892
1893 CL22_WR_OVER_CL45(bp, phy,
1894 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1895 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1896 control2);
1897
1898 /* Disable parallel detection of HiG */
1899 CL22_WR_OVER_CL45(bp, phy,
1900 MDIO_REG_BANK_XGXS_BLOCK2,
1901 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G,
1902 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_CX4_XGXS |
1903 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_HIGIG_XGXS);
1904 }
1905 }
1906
1907 static void bnx2x_set_autoneg(struct bnx2x_phy *phy,
1908 struct link_params *params,
1909 struct link_vars *vars,
1910 u8 enable_cl73)
1911 {
1912 struct bnx2x *bp = params->bp;
1913 u16 reg_val;
1914
1915 /* CL37 Autoneg */
1916 CL22_RD_OVER_CL45(bp, phy,
1917 MDIO_REG_BANK_COMBO_IEEE0,
1918 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
1919
1920 /* CL37 Autoneg Enabled */
1921 if (vars->line_speed == SPEED_AUTO_NEG)
1922 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_AN_EN;
1923 else /* CL37 Autoneg Disabled */
1924 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1925 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN);
1926
1927 CL22_WR_OVER_CL45(bp, phy,
1928 MDIO_REG_BANK_COMBO_IEEE0,
1929 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
1930
1931 /* Enable/Disable Autodetection */
1932
1933 CL22_RD_OVER_CL45(bp, phy,
1934 MDIO_REG_BANK_SERDES_DIGITAL,
1935 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, &reg_val);
1936 reg_val &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_SIGNAL_DETECT_EN |
1937 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT);
1938 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE;
1939 if (vars->line_speed == SPEED_AUTO_NEG)
1940 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1941 else
1942 reg_val &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1943
1944 CL22_WR_OVER_CL45(bp, phy,
1945 MDIO_REG_BANK_SERDES_DIGITAL,
1946 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, reg_val);
1947
1948 /* Enable TetonII and BAM autoneg */
1949 CL22_RD_OVER_CL45(bp, phy,
1950 MDIO_REG_BANK_BAM_NEXT_PAGE,
1951 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1952 &reg_val);
1953 if (vars->line_speed == SPEED_AUTO_NEG) {
1954 /* Enable BAM aneg Mode and TetonII aneg Mode */
1955 reg_val |= (MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1956 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1957 } else {
1958 /* TetonII and BAM Autoneg Disabled */
1959 reg_val &= ~(MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1960 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1961 }
1962 CL22_WR_OVER_CL45(bp, phy,
1963 MDIO_REG_BANK_BAM_NEXT_PAGE,
1964 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1965 reg_val);
1966
1967 if (enable_cl73) {
1968 /* Enable Cl73 FSM status bits */
1969 CL22_WR_OVER_CL45(bp, phy,
1970 MDIO_REG_BANK_CL73_USERB0,
1971 MDIO_CL73_USERB0_CL73_UCTRL,
1972 0xe);
1973
1974 /* Enable BAM Station Manager*/
1975 CL22_WR_OVER_CL45(bp, phy,
1976 MDIO_REG_BANK_CL73_USERB0,
1977 MDIO_CL73_USERB0_CL73_BAM_CTRL1,
1978 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_EN |
1979 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_STATION_MNGR_EN |
1980 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_NP_AFTER_BP_EN);
1981
1982 /* Advertise CL73 link speeds */
1983 CL22_RD_OVER_CL45(bp, phy,
1984 MDIO_REG_BANK_CL73_IEEEB1,
1985 MDIO_CL73_IEEEB1_AN_ADV2,
1986 &reg_val);
1987 if (phy->speed_cap_mask &
1988 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
1989 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_10G_KX4;
1990 if (phy->speed_cap_mask &
1991 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
1992 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_1000M_KX;
1993
1994 CL22_WR_OVER_CL45(bp, phy,
1995 MDIO_REG_BANK_CL73_IEEEB1,
1996 MDIO_CL73_IEEEB1_AN_ADV2,
1997 reg_val);
1998
1999 /* CL73 Autoneg Enabled */
2000 reg_val = MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN;
2001
2002 } else /* CL73 Autoneg Disabled */
2003 reg_val = 0;
2004
2005 CL22_WR_OVER_CL45(bp, phy,
2006 MDIO_REG_BANK_CL73_IEEEB0,
2007 MDIO_CL73_IEEEB0_CL73_AN_CONTROL, reg_val);
2008 }
2009
2010 /* program SerDes, forced speed */
2011 static void bnx2x_program_serdes(struct bnx2x_phy *phy,
2012 struct link_params *params,
2013 struct link_vars *vars)
2014 {
2015 struct bnx2x *bp = params->bp;
2016 u16 reg_val;
2017
2018 /* program duplex, disable autoneg and sgmii*/
2019 CL22_RD_OVER_CL45(bp, phy,
2020 MDIO_REG_BANK_COMBO_IEEE0,
2021 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
2022 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX |
2023 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2024 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK);
2025 if (phy->req_duplex == DUPLEX_FULL)
2026 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
2027 CL22_WR_OVER_CL45(bp, phy,
2028 MDIO_REG_BANK_COMBO_IEEE0,
2029 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
2030
2031 /*
2032 * program speed
2033 * - needed only if the speed is greater than 1G (2.5G or 10G)
2034 */
2035 CL22_RD_OVER_CL45(bp, phy,
2036 MDIO_REG_BANK_SERDES_DIGITAL,
2037 MDIO_SERDES_DIGITAL_MISC1, &reg_val);
2038 /* clearing the speed value before setting the right speed */
2039 DP(NETIF_MSG_LINK, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x\n", reg_val);
2040
2041 reg_val &= ~(MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK |
2042 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
2043
2044 if (!((vars->line_speed == SPEED_1000) ||
2045 (vars->line_speed == SPEED_100) ||
2046 (vars->line_speed == SPEED_10))) {
2047
2048 reg_val |= (MDIO_SERDES_DIGITAL_MISC1_REFCLK_SEL_156_25M |
2049 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
2050 if (vars->line_speed == SPEED_10000)
2051 reg_val |=
2052 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_10G_CX4;
2053 if (vars->line_speed == SPEED_13000)
2054 reg_val |=
2055 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_13G;
2056 }
2057
2058 CL22_WR_OVER_CL45(bp, phy,
2059 MDIO_REG_BANK_SERDES_DIGITAL,
2060 MDIO_SERDES_DIGITAL_MISC1, reg_val);
2061
2062 }
2063
2064 static void bnx2x_set_brcm_cl37_advertisment(struct bnx2x_phy *phy,
2065 struct link_params *params)
2066 {
2067 struct bnx2x *bp = params->bp;
2068 u16 val = 0;
2069
2070 /* configure the 48 bits for BAM AN */
2071
2072 /* set extended capabilities */
2073 if (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G)
2074 val |= MDIO_OVER_1G_UP1_2_5G;
2075 if (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
2076 val |= MDIO_OVER_1G_UP1_10G;
2077 CL22_WR_OVER_CL45(bp, phy,
2078 MDIO_REG_BANK_OVER_1G,
2079 MDIO_OVER_1G_UP1, val);
2080
2081 CL22_WR_OVER_CL45(bp, phy,
2082 MDIO_REG_BANK_OVER_1G,
2083 MDIO_OVER_1G_UP3, 0x400);
2084 }
2085
2086 static void bnx2x_calc_ieee_aneg_adv(struct bnx2x_phy *phy,
2087 struct link_params *params, u16 *ieee_fc)
2088 {
2089 struct bnx2x *bp = params->bp;
2090 *ieee_fc = MDIO_COMBO_IEEE0_AUTO_NEG_ADV_FULL_DUPLEX;
2091 /*
2092 * Resolve pause mode and advertisement.
2093 * Please refer to Table 28B-3 of the 802.3ab-1999 spec
2094 */
2095
2096 switch (phy->req_flow_ctrl) {
2097 case BNX2X_FLOW_CTRL_AUTO:
2098 if (params->req_fc_auto_adv == BNX2X_FLOW_CTRL_BOTH)
2099 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
2100 else
2101 *ieee_fc |=
2102 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
2103 break;
2104 case BNX2X_FLOW_CTRL_TX:
2105 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
2106 break;
2107
2108 case BNX2X_FLOW_CTRL_RX:
2109 case BNX2X_FLOW_CTRL_BOTH:
2110 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
2111 break;
2112
2113 case BNX2X_FLOW_CTRL_NONE:
2114 default:
2115 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
2116 break;
2117 }
2118 DP(NETIF_MSG_LINK, "ieee_fc = 0x%x\n", *ieee_fc);
2119 }
2120
2121 static void bnx2x_set_ieee_aneg_advertisment(struct bnx2x_phy *phy,
2122 struct link_params *params,
2123 u16 ieee_fc)
2124 {
2125 struct bnx2x *bp = params->bp;
2126 u16 val;
2127 /* for AN, we are always publishing full duplex */
2128
2129 CL22_WR_OVER_CL45(bp, phy,
2130 MDIO_REG_BANK_COMBO_IEEE0,
2131 MDIO_COMBO_IEEE0_AUTO_NEG_ADV, ieee_fc);
2132 CL22_RD_OVER_CL45(bp, phy,
2133 MDIO_REG_BANK_CL73_IEEEB1,
2134 MDIO_CL73_IEEEB1_AN_ADV1, &val);
2135 val &= ~MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_BOTH;
2136 val |= ((ieee_fc<<3) & MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK);
2137 CL22_WR_OVER_CL45(bp, phy,
2138 MDIO_REG_BANK_CL73_IEEEB1,
2139 MDIO_CL73_IEEEB1_AN_ADV1, val);
2140 }
2141
2142 static void bnx2x_restart_autoneg(struct bnx2x_phy *phy,
2143 struct link_params *params,
2144 u8 enable_cl73)
2145 {
2146 struct bnx2x *bp = params->bp;
2147 u16 mii_control;
2148
2149 DP(NETIF_MSG_LINK, "bnx2x_restart_autoneg\n");
2150 /* Enable and restart BAM/CL37 aneg */
2151
2152 if (enable_cl73) {
2153 CL22_RD_OVER_CL45(bp, phy,
2154 MDIO_REG_BANK_CL73_IEEEB0,
2155 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2156 &mii_control);
2157
2158 CL22_WR_OVER_CL45(bp, phy,
2159 MDIO_REG_BANK_CL73_IEEEB0,
2160 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2161 (mii_control |
2162 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN |
2163 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_RESTART_AN));
2164 } else {
2165
2166 CL22_RD_OVER_CL45(bp, phy,
2167 MDIO_REG_BANK_COMBO_IEEE0,
2168 MDIO_COMBO_IEEE0_MII_CONTROL,
2169 &mii_control);
2170 DP(NETIF_MSG_LINK,
2171 "bnx2x_restart_autoneg mii_control before = 0x%x\n",
2172 mii_control);
2173 CL22_WR_OVER_CL45(bp, phy,
2174 MDIO_REG_BANK_COMBO_IEEE0,
2175 MDIO_COMBO_IEEE0_MII_CONTROL,
2176 (mii_control |
2177 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2178 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN));
2179 }
2180 }
2181
2182 static void bnx2x_initialize_sgmii_process(struct bnx2x_phy *phy,
2183 struct link_params *params,
2184 struct link_vars *vars)
2185 {
2186 struct bnx2x *bp = params->bp;
2187 u16 control1;
2188
2189 /* in SGMII mode, the unicore is always slave */
2190
2191 CL22_RD_OVER_CL45(bp, phy,
2192 MDIO_REG_BANK_SERDES_DIGITAL,
2193 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
2194 &control1);
2195 control1 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT;
2196 /* set sgmii mode (and not fiber) */
2197 control1 &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE |
2198 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET |
2199 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_MSTR_MODE);
2200 CL22_WR_OVER_CL45(bp, phy,
2201 MDIO_REG_BANK_SERDES_DIGITAL,
2202 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
2203 control1);
2204
2205 /* if forced speed */
2206 if (!(vars->line_speed == SPEED_AUTO_NEG)) {
2207 /* set speed, disable autoneg */
2208 u16 mii_control;
2209
2210 CL22_RD_OVER_CL45(bp, phy,
2211 MDIO_REG_BANK_COMBO_IEEE0,
2212 MDIO_COMBO_IEEE0_MII_CONTROL,
2213 &mii_control);
2214 mii_control &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2215 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK|
2216 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX);
2217
2218 switch (vars->line_speed) {
2219 case SPEED_100:
2220 mii_control |=
2221 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_100;
2222 break;
2223 case SPEED_1000:
2224 mii_control |=
2225 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_1000;
2226 break;
2227 case SPEED_10:
2228 /* there is nothing to set for 10M */
2229 break;
2230 default:
2231 /* invalid speed for SGMII */
2232 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
2233 vars->line_speed);
2234 break;
2235 }
2236
2237 /* setting the full duplex */
2238 if (phy->req_duplex == DUPLEX_FULL)
2239 mii_control |=
2240 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
2241 CL22_WR_OVER_CL45(bp, phy,
2242 MDIO_REG_BANK_COMBO_IEEE0,
2243 MDIO_COMBO_IEEE0_MII_CONTROL,
2244 mii_control);
2245
2246 } else { /* AN mode */
2247 /* enable and restart AN */
2248 bnx2x_restart_autoneg(phy, params, 0);
2249 }
2250 }
2251
2252
2253 /*
2254 * link management
2255 */
2256
2257 static void bnx2x_pause_resolve(struct link_vars *vars, u32 pause_result)
2258 { /* LD LP */
2259 switch (pause_result) { /* ASYM P ASYM P */
2260 case 0xb: /* 1 0 1 1 */
2261 vars->flow_ctrl = BNX2X_FLOW_CTRL_TX;
2262 break;
2263
2264 case 0xe: /* 1 1 1 0 */
2265 vars->flow_ctrl = BNX2X_FLOW_CTRL_RX;
2266 break;
2267
2268 case 0x5: /* 0 1 0 1 */
2269 case 0x7: /* 0 1 1 1 */
2270 case 0xd: /* 1 1 0 1 */
2271 case 0xf: /* 1 1 1 1 */
2272 vars->flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
2273 break;
2274
2275 default:
2276 break;
2277 }
2278 if (pause_result & (1<<0))
2279 vars->link_status |= LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE;
2280 if (pause_result & (1<<1))
2281 vars->link_status |= LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE;
2282 }
2283
2284 static u8 bnx2x_direct_parallel_detect_used(struct bnx2x_phy *phy,
2285 struct link_params *params)
2286 {
2287 struct bnx2x *bp = params->bp;
2288 u16 pd_10g, status2_1000x;
2289 if (phy->req_line_speed != SPEED_AUTO_NEG)
2290 return 0;
2291 CL22_RD_OVER_CL45(bp, phy,
2292 MDIO_REG_BANK_SERDES_DIGITAL,
2293 MDIO_SERDES_DIGITAL_A_1000X_STATUS2,
2294 &status2_1000x);
2295 CL22_RD_OVER_CL45(bp, phy,
2296 MDIO_REG_BANK_SERDES_DIGITAL,
2297 MDIO_SERDES_DIGITAL_A_1000X_STATUS2,
2298 &status2_1000x);
2299 if (status2_1000x & MDIO_SERDES_DIGITAL_A_1000X_STATUS2_AN_DISABLED) {
2300 DP(NETIF_MSG_LINK, "1G parallel detect link on port %d\n",
2301 params->port);
2302 return 1;
2303 }
2304
2305 CL22_RD_OVER_CL45(bp, phy,
2306 MDIO_REG_BANK_10G_PARALLEL_DETECT,
2307 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS,
2308 &pd_10g);
2309
2310 if (pd_10g & MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS_PD_LINK) {
2311 DP(NETIF_MSG_LINK, "10G parallel detect link on port %d\n",
2312 params->port);
2313 return 1;
2314 }
2315 return 0;
2316 }
2317
2318 static void bnx2x_flow_ctrl_resolve(struct bnx2x_phy *phy,
2319 struct link_params *params,
2320 struct link_vars *vars,
2321 u32 gp_status)
2322 {
2323 struct bnx2x *bp = params->bp;
2324 u16 ld_pause; /* local driver */
2325 u16 lp_pause; /* link partner */
2326 u16 pause_result;
2327
2328 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
2329
2330 /* resolve from gp_status in case of AN complete and not sgmii */
2331 if (phy->req_flow_ctrl != BNX2X_FLOW_CTRL_AUTO)
2332 vars->flow_ctrl = phy->req_flow_ctrl;
2333 else if (phy->req_line_speed != SPEED_AUTO_NEG)
2334 vars->flow_ctrl = params->req_fc_auto_adv;
2335 else if ((gp_status & MDIO_AN_CL73_OR_37_COMPLETE) &&
2336 (!(vars->phy_flags & PHY_SGMII_FLAG))) {
2337 if (bnx2x_direct_parallel_detect_used(phy, params)) {
2338 vars->flow_ctrl = params->req_fc_auto_adv;
2339 return;
2340 }
2341 if ((gp_status &
2342 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE |
2343 MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_MR_LP_NP_AN_ABLE)) ==
2344 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE |
2345 MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_MR_LP_NP_AN_ABLE)) {
2346
2347 CL22_RD_OVER_CL45(bp, phy,
2348 MDIO_REG_BANK_CL73_IEEEB1,
2349 MDIO_CL73_IEEEB1_AN_ADV1,
2350 &ld_pause);
2351 CL22_RD_OVER_CL45(bp, phy,
2352 MDIO_REG_BANK_CL73_IEEEB1,
2353 MDIO_CL73_IEEEB1_AN_LP_ADV1,
2354 &lp_pause);
2355 pause_result = (ld_pause &
2356 MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK)
2357 >> 8;
2358 pause_result |= (lp_pause &
2359 MDIO_CL73_IEEEB1_AN_LP_ADV1_PAUSE_MASK)
2360 >> 10;
2361 DP(NETIF_MSG_LINK, "pause_result CL73 0x%x\n",
2362 pause_result);
2363 } else {
2364 CL22_RD_OVER_CL45(bp, phy,
2365 MDIO_REG_BANK_COMBO_IEEE0,
2366 MDIO_COMBO_IEEE0_AUTO_NEG_ADV,
2367 &ld_pause);
2368 CL22_RD_OVER_CL45(bp, phy,
2369 MDIO_REG_BANK_COMBO_IEEE0,
2370 MDIO_COMBO_IEEE0_AUTO_NEG_LINK_PARTNER_ABILITY1,
2371 &lp_pause);
2372 pause_result = (ld_pause &
2373 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>5;
2374 pause_result |= (lp_pause &
2375 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>7;
2376 DP(NETIF_MSG_LINK, "pause_result CL37 0x%x\n",
2377 pause_result);
2378 }
2379 bnx2x_pause_resolve(vars, pause_result);
2380 }
2381 DP(NETIF_MSG_LINK, "flow_ctrl 0x%x\n", vars->flow_ctrl);
2382 }
2383
2384 static void bnx2x_check_fallback_to_cl37(struct bnx2x_phy *phy,
2385 struct link_params *params)
2386 {
2387 struct bnx2x *bp = params->bp;
2388 u16 rx_status, ustat_val, cl37_fsm_recieved;
2389 DP(NETIF_MSG_LINK, "bnx2x_check_fallback_to_cl37\n");
2390 /* Step 1: Make sure signal is detected */
2391 CL22_RD_OVER_CL45(bp, phy,
2392 MDIO_REG_BANK_RX0,
2393 MDIO_RX0_RX_STATUS,
2394 &rx_status);
2395 if ((rx_status & MDIO_RX0_RX_STATUS_SIGDET) !=
2396 (MDIO_RX0_RX_STATUS_SIGDET)) {
2397 DP(NETIF_MSG_LINK, "Signal is not detected. Restoring CL73."
2398 "rx_status(0x80b0) = 0x%x\n", rx_status);
2399 CL22_WR_OVER_CL45(bp, phy,
2400 MDIO_REG_BANK_CL73_IEEEB0,
2401 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2402 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN);
2403 return;
2404 }
2405 /* Step 2: Check CL73 state machine */
2406 CL22_RD_OVER_CL45(bp, phy,
2407 MDIO_REG_BANK_CL73_USERB0,
2408 MDIO_CL73_USERB0_CL73_USTAT1,
2409 &ustat_val);
2410 if ((ustat_val &
2411 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
2412 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) !=
2413 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
2414 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) {
2415 DP(NETIF_MSG_LINK, "CL73 state-machine is not stable. "
2416 "ustat_val(0x8371) = 0x%x\n", ustat_val);
2417 return;
2418 }
2419 /*
2420 * Step 3: Check CL37 Message Pages received to indicate LP
2421 * supports only CL37
2422 */
2423 CL22_RD_OVER_CL45(bp, phy,
2424 MDIO_REG_BANK_REMOTE_PHY,
2425 MDIO_REMOTE_PHY_MISC_RX_STATUS,
2426 &cl37_fsm_recieved);
2427 if ((cl37_fsm_recieved &
2428 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
2429 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) !=
2430 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
2431 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) {
2432 DP(NETIF_MSG_LINK, "No CL37 FSM were received. "
2433 "misc_rx_status(0x8330) = 0x%x\n",
2434 cl37_fsm_recieved);
2435 return;
2436 }
2437 /*
2438 * The combined cl37/cl73 fsm state information indicating that
2439 * we are connected to a device which does not support cl73, but
2440 * does support cl37 BAM. In this case we disable cl73 and
2441 * restart cl37 auto-neg
2442 */
2443
2444 /* Disable CL73 */
2445 CL22_WR_OVER_CL45(bp, phy,
2446 MDIO_REG_BANK_CL73_IEEEB0,
2447 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2448 0);
2449 /* Restart CL37 autoneg */
2450 bnx2x_restart_autoneg(phy, params, 0);
2451 DP(NETIF_MSG_LINK, "Disabling CL73, and restarting CL37 autoneg\n");
2452 }
2453
2454 static void bnx2x_xgxs_an_resolve(struct bnx2x_phy *phy,
2455 struct link_params *params,
2456 struct link_vars *vars,
2457 u32 gp_status)
2458 {
2459 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE)
2460 vars->link_status |=
2461 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
2462
2463 if (bnx2x_direct_parallel_detect_used(phy, params))
2464 vars->link_status |=
2465 LINK_STATUS_PARALLEL_DETECTION_USED;
2466 }
2467
2468 static u8 bnx2x_link_settings_status(struct bnx2x_phy *phy,
2469 struct link_params *params,
2470 struct link_vars *vars)
2471 {
2472 struct bnx2x *bp = params->bp;
2473 u16 new_line_speed, gp_status;
2474 u8 rc = 0;
2475
2476 /* Read gp_status */
2477 CL22_RD_OVER_CL45(bp, phy,
2478 MDIO_REG_BANK_GP_STATUS,
2479 MDIO_GP_STATUS_TOP_AN_STATUS1,
2480 &gp_status);
2481
2482 if (phy->req_line_speed == SPEED_AUTO_NEG)
2483 vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
2484 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) {
2485 DP(NETIF_MSG_LINK, "phy link up gp_status=0x%x\n",
2486 gp_status);
2487
2488 vars->phy_link_up = 1;
2489 vars->link_status |= LINK_STATUS_LINK_UP;
2490
2491 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_DUPLEX_STATUS)
2492 vars->duplex = DUPLEX_FULL;
2493 else
2494 vars->duplex = DUPLEX_HALF;
2495
2496 if (SINGLE_MEDIA_DIRECT(params)) {
2497 bnx2x_flow_ctrl_resolve(phy, params, vars, gp_status);
2498 if (phy->req_line_speed == SPEED_AUTO_NEG)
2499 bnx2x_xgxs_an_resolve(phy, params, vars,
2500 gp_status);
2501 }
2502
2503 switch (gp_status & GP_STATUS_SPEED_MASK) {
2504 case GP_STATUS_10M:
2505 new_line_speed = SPEED_10;
2506 if (vars->duplex == DUPLEX_FULL)
2507 vars->link_status |= LINK_10TFD;
2508 else
2509 vars->link_status |= LINK_10THD;
2510 break;
2511
2512 case GP_STATUS_100M:
2513 new_line_speed = SPEED_100;
2514 if (vars->duplex == DUPLEX_FULL)
2515 vars->link_status |= LINK_100TXFD;
2516 else
2517 vars->link_status |= LINK_100TXHD;
2518 break;
2519
2520 case GP_STATUS_1G:
2521 case GP_STATUS_1G_KX:
2522 new_line_speed = SPEED_1000;
2523 if (vars->duplex == DUPLEX_FULL)
2524 vars->link_status |= LINK_1000TFD;
2525 else
2526 vars->link_status |= LINK_1000THD;
2527 break;
2528
2529 case GP_STATUS_2_5G:
2530 new_line_speed = SPEED_2500;
2531 if (vars->duplex == DUPLEX_FULL)
2532 vars->link_status |= LINK_2500TFD;
2533 else
2534 vars->link_status |= LINK_2500THD;
2535 break;
2536
2537 case GP_STATUS_5G:
2538 case GP_STATUS_6G:
2539 DP(NETIF_MSG_LINK,
2540 "link speed unsupported gp_status 0x%x\n",
2541 gp_status);
2542 return -EINVAL;
2543
2544 case GP_STATUS_10G_KX4:
2545 case GP_STATUS_10G_HIG:
2546 case GP_STATUS_10G_CX4:
2547 new_line_speed = SPEED_10000;
2548 vars->link_status |= LINK_10GTFD;
2549 break;
2550
2551 case GP_STATUS_12G_HIG:
2552 new_line_speed = SPEED_12000;
2553 vars->link_status |= LINK_12GTFD;
2554 break;
2555
2556 case GP_STATUS_12_5G:
2557 new_line_speed = SPEED_12500;
2558 vars->link_status |= LINK_12_5GTFD;
2559 break;
2560
2561 case GP_STATUS_13G:
2562 new_line_speed = SPEED_13000;
2563 vars->link_status |= LINK_13GTFD;
2564 break;
2565
2566 case GP_STATUS_15G:
2567 new_line_speed = SPEED_15000;
2568 vars->link_status |= LINK_15GTFD;
2569 break;
2570
2571 case GP_STATUS_16G:
2572 new_line_speed = SPEED_16000;
2573 vars->link_status |= LINK_16GTFD;
2574 break;
2575
2576 default:
2577 DP(NETIF_MSG_LINK,
2578 "link speed unsupported gp_status 0x%x\n",
2579 gp_status);
2580 return -EINVAL;
2581 }
2582
2583 vars->line_speed = new_line_speed;
2584
2585 } else { /* link_down */
2586 DP(NETIF_MSG_LINK, "phy link down\n");
2587
2588 vars->phy_link_up = 0;
2589
2590 vars->duplex = DUPLEX_FULL;
2591 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
2592 vars->mac_type = MAC_TYPE_NONE;
2593
2594 if ((phy->req_line_speed == SPEED_AUTO_NEG) &&
2595 SINGLE_MEDIA_DIRECT(params)) {
2596 /* Check signal is detected */
2597 bnx2x_check_fallback_to_cl37(phy, params);
2598 }
2599 }
2600
2601 DP(NETIF_MSG_LINK, "gp_status 0x%x phy_link_up %x line_speed %x\n",
2602 gp_status, vars->phy_link_up, vars->line_speed);
2603 DP(NETIF_MSG_LINK, "duplex %x flow_ctrl 0x%x link_status 0x%x\n",
2604 vars->duplex, vars->flow_ctrl, vars->link_status);
2605 return rc;
2606 }
2607
2608 static void bnx2x_set_gmii_tx_driver(struct link_params *params)
2609 {
2610 struct bnx2x *bp = params->bp;
2611 struct bnx2x_phy *phy = &params->phy[INT_PHY];
2612 u16 lp_up2;
2613 u16 tx_driver;
2614 u16 bank;
2615
2616 /* read precomp */
2617 CL22_RD_OVER_CL45(bp, phy,
2618 MDIO_REG_BANK_OVER_1G,
2619 MDIO_OVER_1G_LP_UP2, &lp_up2);
2620
2621 /* bits [10:7] at lp_up2, positioned at [15:12] */
2622 lp_up2 = (((lp_up2 & MDIO_OVER_1G_LP_UP2_PREEMPHASIS_MASK) >>
2623 MDIO_OVER_1G_LP_UP2_PREEMPHASIS_SHIFT) <<
2624 MDIO_TX0_TX_DRIVER_PREEMPHASIS_SHIFT);
2625
2626 if (lp_up2 == 0)
2627 return;
2628
2629 for (bank = MDIO_REG_BANK_TX0; bank <= MDIO_REG_BANK_TX3;
2630 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0)) {
2631 CL22_RD_OVER_CL45(bp, phy,
2632 bank,
2633 MDIO_TX0_TX_DRIVER, &tx_driver);
2634
2635 /* replace tx_driver bits [15:12] */
2636 if (lp_up2 !=
2637 (tx_driver & MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK)) {
2638 tx_driver &= ~MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK;
2639 tx_driver |= lp_up2;
2640 CL22_WR_OVER_CL45(bp, phy,
2641 bank,
2642 MDIO_TX0_TX_DRIVER, tx_driver);
2643 }
2644 }
2645 }
2646
2647 static u8 bnx2x_emac_program(struct link_params *params,
2648 struct link_vars *vars)
2649 {
2650 struct bnx2x *bp = params->bp;
2651 u8 port = params->port;
2652 u16 mode = 0;
2653
2654 DP(NETIF_MSG_LINK, "setting link speed & duplex\n");
2655 bnx2x_bits_dis(bp, GRCBASE_EMAC0 + port*0x400 +
2656 EMAC_REG_EMAC_MODE,
2657 (EMAC_MODE_25G_MODE |
2658 EMAC_MODE_PORT_MII_10M |
2659 EMAC_MODE_HALF_DUPLEX));
2660 switch (vars->line_speed) {
2661 case SPEED_10:
2662 mode |= EMAC_MODE_PORT_MII_10M;
2663 break;
2664
2665 case SPEED_100:
2666 mode |= EMAC_MODE_PORT_MII;
2667 break;
2668
2669 case SPEED_1000:
2670 mode |= EMAC_MODE_PORT_GMII;
2671 break;
2672
2673 case SPEED_2500:
2674 mode |= (EMAC_MODE_25G_MODE | EMAC_MODE_PORT_GMII);
2675 break;
2676
2677 default:
2678 /* 10G not valid for EMAC */
2679 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
2680 vars->line_speed);
2681 return -EINVAL;
2682 }
2683
2684 if (vars->duplex == DUPLEX_HALF)
2685 mode |= EMAC_MODE_HALF_DUPLEX;
2686 bnx2x_bits_en(bp,
2687 GRCBASE_EMAC0 + port*0x400 + EMAC_REG_EMAC_MODE,
2688 mode);
2689
2690 bnx2x_set_led(params, vars, LED_MODE_OPER, vars->line_speed);
2691 return 0;
2692 }
2693
2694 static void bnx2x_set_preemphasis(struct bnx2x_phy *phy,
2695 struct link_params *params)
2696 {
2697
2698 u16 bank, i = 0;
2699 struct bnx2x *bp = params->bp;
2700
2701 for (bank = MDIO_REG_BANK_RX0, i = 0; bank <= MDIO_REG_BANK_RX3;
2702 bank += (MDIO_REG_BANK_RX1-MDIO_REG_BANK_RX0), i++) {
2703 CL22_WR_OVER_CL45(bp, phy,
2704 bank,
2705 MDIO_RX0_RX_EQ_BOOST,
2706 phy->rx_preemphasis[i]);
2707 }
2708
2709 for (bank = MDIO_REG_BANK_TX0, i = 0; bank <= MDIO_REG_BANK_TX3;
2710 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0), i++) {
2711 CL22_WR_OVER_CL45(bp, phy,
2712 bank,
2713 MDIO_TX0_TX_DRIVER,
2714 phy->tx_preemphasis[i]);
2715 }
2716 }
2717
2718 static void bnx2x_init_internal_phy(struct bnx2x_phy *phy,
2719 struct link_params *params,
2720 struct link_vars *vars)
2721 {
2722 struct bnx2x *bp = params->bp;
2723 u8 enable_cl73 = (SINGLE_MEDIA_DIRECT(params) ||
2724 (params->loopback_mode == LOOPBACK_XGXS));
2725 if (!(vars->phy_flags & PHY_SGMII_FLAG)) {
2726 if (SINGLE_MEDIA_DIRECT(params) &&
2727 (params->feature_config_flags &
2728 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED))
2729 bnx2x_set_preemphasis(phy, params);
2730
2731 /* forced speed requested? */
2732 if (vars->line_speed != SPEED_AUTO_NEG ||
2733 (SINGLE_MEDIA_DIRECT(params) &&
2734 params->loopback_mode == LOOPBACK_EXT)) {
2735 DP(NETIF_MSG_LINK, "not SGMII, no AN\n");
2736
2737 /* disable autoneg */
2738 bnx2x_set_autoneg(phy, params, vars, 0);
2739
2740 /* program speed and duplex */
2741 bnx2x_program_serdes(phy, params, vars);
2742
2743 } else { /* AN_mode */
2744 DP(NETIF_MSG_LINK, "not SGMII, AN\n");
2745
2746 /* AN enabled */
2747 bnx2x_set_brcm_cl37_advertisment(phy, params);
2748
2749 /* program duplex & pause advertisement (for aneg) */
2750 bnx2x_set_ieee_aneg_advertisment(phy, params,
2751 vars->ieee_fc);
2752
2753 /* enable autoneg */
2754 bnx2x_set_autoneg(phy, params, vars, enable_cl73);
2755
2756 /* enable and restart AN */
2757 bnx2x_restart_autoneg(phy, params, enable_cl73);
2758 }
2759
2760 } else { /* SGMII mode */
2761 DP(NETIF_MSG_LINK, "SGMII\n");
2762
2763 bnx2x_initialize_sgmii_process(phy, params, vars);
2764 }
2765 }
2766
2767 static u8 bnx2x_init_serdes(struct bnx2x_phy *phy,
2768 struct link_params *params,
2769 struct link_vars *vars)
2770 {
2771 u8 rc;
2772 vars->phy_flags |= PHY_SGMII_FLAG;
2773 bnx2x_calc_ieee_aneg_adv(phy, params, &vars->ieee_fc);
2774 bnx2x_set_aer_mmd_serdes(params->bp, phy);
2775 rc = bnx2x_reset_unicore(params, phy, 1);
2776 /* reset the SerDes and wait for reset bit return low */
2777 if (rc != 0)
2778 return rc;
2779 bnx2x_set_aer_mmd_serdes(params->bp, phy);
2780
2781 return rc;
2782 }
2783
2784 static u8 bnx2x_init_xgxs(struct bnx2x_phy *phy,
2785 struct link_params *params,
2786 struct link_vars *vars)
2787 {
2788 u8 rc;
2789 vars->phy_flags = PHY_XGXS_FLAG;
2790 if ((phy->req_line_speed &&
2791 ((phy->req_line_speed == SPEED_100) ||
2792 (phy->req_line_speed == SPEED_10))) ||
2793 (!phy->req_line_speed &&
2794 (phy->speed_cap_mask >=
2795 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) &&
2796 (phy->speed_cap_mask <
2797 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
2798 ))
2799 vars->phy_flags |= PHY_SGMII_FLAG;
2800 else
2801 vars->phy_flags &= ~PHY_SGMII_FLAG;
2802
2803 bnx2x_calc_ieee_aneg_adv(phy, params, &vars->ieee_fc);
2804 bnx2x_set_aer_mmd_xgxs(params, phy);
2805 bnx2x_set_master_ln(params, phy);
2806
2807 rc = bnx2x_reset_unicore(params, phy, 0);
2808 /* reset the SerDes and wait for reset bit return low */
2809 if (rc != 0)
2810 return rc;
2811
2812 bnx2x_set_aer_mmd_xgxs(params, phy);
2813
2814 /* setting the masterLn_def again after the reset */
2815 bnx2x_set_master_ln(params, phy);
2816 bnx2x_set_swap_lanes(params, phy);
2817
2818 return rc;
2819 }
2820
2821 static u16 bnx2x_wait_reset_complete(struct bnx2x *bp,
2822 struct bnx2x_phy *phy,
2823 struct link_params *params)
2824 {
2825 u16 cnt, ctrl;
2826 /* Wait for soft reset to get cleared up to 1 sec */
2827 for (cnt = 0; cnt < 1000; cnt++) {
2828 bnx2x_cl45_read(bp, phy,
2829 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, &ctrl);
2830 if (!(ctrl & (1<<15)))
2831 break;
2832 msleep(1);
2833 }
2834
2835 if (cnt == 1000)
2836 netdev_err(bp->dev, "Warning: PHY was not initialized,"
2837 " Port %d\n",
2838 params->port);
2839 DP(NETIF_MSG_LINK, "control reg 0x%x (after %d ms)\n", ctrl, cnt);
2840 return cnt;
2841 }
2842
2843 static void bnx2x_link_int_enable(struct link_params *params)
2844 {
2845 u8 port = params->port;
2846 u32 mask;
2847 struct bnx2x *bp = params->bp;
2848
2849 /* Setting the status to report on link up for either XGXS or SerDes */
2850 if (params->switch_cfg == SWITCH_CFG_10G) {
2851 mask = (NIG_MASK_XGXS0_LINK10G |
2852 NIG_MASK_XGXS0_LINK_STATUS);
2853 DP(NETIF_MSG_LINK, "enabled XGXS interrupt\n");
2854 if (!(SINGLE_MEDIA_DIRECT(params)) &&
2855 params->phy[INT_PHY].type !=
2856 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) {
2857 mask |= NIG_MASK_MI_INT;
2858 DP(NETIF_MSG_LINK, "enabled external phy int\n");
2859 }
2860
2861 } else { /* SerDes */
2862 mask = NIG_MASK_SERDES0_LINK_STATUS;
2863 DP(NETIF_MSG_LINK, "enabled SerDes interrupt\n");
2864 if (!(SINGLE_MEDIA_DIRECT(params)) &&
2865 params->phy[INT_PHY].type !=
2866 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN) {
2867 mask |= NIG_MASK_MI_INT;
2868 DP(NETIF_MSG_LINK, "enabled external phy int\n");
2869 }
2870 }
2871 bnx2x_bits_en(bp,
2872 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2873 mask);
2874
2875 DP(NETIF_MSG_LINK, "port %x, is_xgxs %x, int_status 0x%x\n", port,
2876 (params->switch_cfg == SWITCH_CFG_10G),
2877 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
2878 DP(NETIF_MSG_LINK, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x\n",
2879 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
2880 REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port*0x18),
2881 REG_RD(bp, NIG_REG_SERDES0_STATUS_LINK_STATUS+port*0x3c));
2882 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
2883 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
2884 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
2885 }
2886
2887 static void bnx2x_rearm_latch_signal(struct bnx2x *bp, u8 port,
2888 u8 exp_mi_int)
2889 {
2890 u32 latch_status = 0;
2891
2892 /*
2893 * Disable the MI INT ( external phy int ) by writing 1 to the
2894 * status register. Link down indication is high-active-signal,
2895 * so in this case we need to write the status to clear the XOR
2896 */
2897 /* Read Latched signals */
2898 latch_status = REG_RD(bp,
2899 NIG_REG_LATCH_STATUS_0 + port*8);
2900 DP(NETIF_MSG_LINK, "latch_status = 0x%x\n", latch_status);
2901 /* Handle only those with latched-signal=up.*/
2902 if (exp_mi_int)
2903 bnx2x_bits_en(bp,
2904 NIG_REG_STATUS_INTERRUPT_PORT0
2905 + port*4,
2906 NIG_STATUS_EMAC0_MI_INT);
2907 else
2908 bnx2x_bits_dis(bp,
2909 NIG_REG_STATUS_INTERRUPT_PORT0
2910 + port*4,
2911 NIG_STATUS_EMAC0_MI_INT);
2912
2913 if (latch_status & 1) {
2914
2915 /* For all latched-signal=up : Re-Arm Latch signals */
2916 REG_WR(bp, NIG_REG_LATCH_STATUS_0 + port*8,
2917 (latch_status & 0xfffe) | (latch_status & 1));
2918 }
2919 /* For all latched-signal=up,Write original_signal to status */
2920 }
2921
2922 static void bnx2x_link_int_ack(struct link_params *params,
2923 struct link_vars *vars, u8 is_10g)
2924 {
2925 struct bnx2x *bp = params->bp;
2926 u8 port = params->port;
2927
2928 /*
2929 * First reset all status we assume only one line will be
2930 * change at a time
2931 */
2932 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
2933 (NIG_STATUS_XGXS0_LINK10G |
2934 NIG_STATUS_XGXS0_LINK_STATUS |
2935 NIG_STATUS_SERDES0_LINK_STATUS));
2936 if (vars->phy_link_up) {
2937 if (is_10g) {
2938 /*
2939 * Disable the 10G link interrupt by writing 1 to the
2940 * status register
2941 */
2942 DP(NETIF_MSG_LINK, "10G XGXS phy link up\n");
2943 bnx2x_bits_en(bp,
2944 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
2945 NIG_STATUS_XGXS0_LINK10G);
2946
2947 } else if (params->switch_cfg == SWITCH_CFG_10G) {
2948 /*
2949 * Disable the link interrupt by writing 1 to the
2950 * relevant lane in the status register
2951 */
2952 u32 ser_lane = ((params->lane_config &
2953 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
2954 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
2955
2956 DP(NETIF_MSG_LINK, "%d speed XGXS phy link up\n",
2957 vars->line_speed);
2958 bnx2x_bits_en(bp,
2959 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
2960 ((1 << ser_lane) <<
2961 NIG_STATUS_XGXS0_LINK_STATUS_SIZE));
2962
2963 } else { /* SerDes */
2964 DP(NETIF_MSG_LINK, "SerDes phy link up\n");
2965 /*
2966 * Disable the link interrupt by writing 1 to the status
2967 * register
2968 */
2969 bnx2x_bits_en(bp,
2970 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
2971 NIG_STATUS_SERDES0_LINK_STATUS);
2972 }
2973
2974 }
2975 }
2976
2977 static u8 bnx2x_format_ver(u32 num, u8 *str, u16 *len)
2978 {
2979 u8 *str_ptr = str;
2980 u32 mask = 0xf0000000;
2981 u8 shift = 8*4;
2982 u8 digit;
2983 u8 remove_leading_zeros = 1;
2984 if (*len < 10) {
2985 /* Need more than 10chars for this format */
2986 *str_ptr = '\0';
2987 (*len)--;
2988 return -EINVAL;
2989 }
2990 while (shift > 0) {
2991
2992 shift -= 4;
2993 digit = ((num & mask) >> shift);
2994 if (digit == 0 && remove_leading_zeros) {
2995 mask = mask >> 4;
2996 continue;
2997 } else if (digit < 0xa)
2998 *str_ptr = digit + '0';
2999 else
3000 *str_ptr = digit - 0xa + 'a';
3001 remove_leading_zeros = 0;
3002 str_ptr++;
3003 (*len)--;
3004 mask = mask >> 4;
3005 if (shift == 4*4) {
3006 *str_ptr = '.';
3007 str_ptr++;
3008 (*len)--;
3009 remove_leading_zeros = 1;
3010 }
3011 }
3012 return 0;
3013 }
3014
3015
3016 static u8 bnx2x_null_format_ver(u32 spirom_ver, u8 *str, u16 *len)
3017 {
3018 str[0] = '\0';
3019 (*len)--;
3020 return 0;
3021 }
3022
3023 u8 bnx2x_get_ext_phy_fw_version(struct link_params *params, u8 driver_loaded,
3024 u8 *version, u16 len)
3025 {
3026 struct bnx2x *bp;
3027 u32 spirom_ver = 0;
3028 u8 status = 0;
3029 u8 *ver_p = version;
3030 u16 remain_len = len;
3031 if (version == NULL || params == NULL)
3032 return -EINVAL;
3033 bp = params->bp;
3034
3035 /* Extract first external phy*/
3036 version[0] = '\0';
3037 spirom_ver = REG_RD(bp, params->phy[EXT_PHY1].ver_addr);
3038
3039 if (params->phy[EXT_PHY1].format_fw_ver) {
3040 status |= params->phy[EXT_PHY1].format_fw_ver(spirom_ver,
3041 ver_p,
3042 &remain_len);
3043 ver_p += (len - remain_len);
3044 }
3045 if ((params->num_phys == MAX_PHYS) &&
3046 (params->phy[EXT_PHY2].ver_addr != 0)) {
3047 spirom_ver = REG_RD(bp, params->phy[EXT_PHY2].ver_addr);
3048 if (params->phy[EXT_PHY2].format_fw_ver) {
3049 *ver_p = '/';
3050 ver_p++;
3051 remain_len--;
3052 status |= params->phy[EXT_PHY2].format_fw_ver(
3053 spirom_ver,
3054 ver_p,
3055 &remain_len);
3056 ver_p = version + (len - remain_len);
3057 }
3058 }
3059 *ver_p = '\0';
3060 return status;
3061 }
3062
3063 static void bnx2x_set_xgxs_loopback(struct bnx2x_phy *phy,
3064 struct link_params *params)
3065 {
3066 u8 port = params->port;
3067 struct bnx2x *bp = params->bp;
3068
3069 if (phy->req_line_speed != SPEED_1000) {
3070 u32 md_devad;
3071
3072 DP(NETIF_MSG_LINK, "XGXS 10G loopback enable\n");
3073
3074 /* change the uni_phy_addr in the nig */
3075 md_devad = REG_RD(bp, (NIG_REG_XGXS0_CTRL_MD_DEVAD +
3076 port*0x18));
3077
3078 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, 0x5);
3079
3080 bnx2x_cl45_write(bp, phy,
3081 5,
3082 (MDIO_REG_BANK_AER_BLOCK +
3083 (MDIO_AER_BLOCK_AER_REG & 0xf)),
3084 0x2800);
3085
3086 bnx2x_cl45_write(bp, phy,
3087 5,
3088 (MDIO_REG_BANK_CL73_IEEEB0 +
3089 (MDIO_CL73_IEEEB0_CL73_AN_CONTROL & 0xf)),
3090 0x6041);
3091 msleep(200);
3092 /* set aer mmd back */
3093 bnx2x_set_aer_mmd_xgxs(params, phy);
3094
3095 /* and md_devad */
3096 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, md_devad);
3097 } else {
3098 u16 mii_ctrl;
3099 DP(NETIF_MSG_LINK, "XGXS 1G loopback enable\n");
3100 bnx2x_cl45_read(bp, phy, 5,
3101 (MDIO_REG_BANK_COMBO_IEEE0 +
3102 (MDIO_COMBO_IEEE0_MII_CONTROL & 0xf)),
3103 &mii_ctrl);
3104 bnx2x_cl45_write(bp, phy, 5,
3105 (MDIO_REG_BANK_COMBO_IEEE0 +
3106 (MDIO_COMBO_IEEE0_MII_CONTROL & 0xf)),
3107 mii_ctrl |
3108 MDIO_COMBO_IEEO_MII_CONTROL_LOOPBACK);
3109 }
3110 }
3111
3112 u8 bnx2x_set_led(struct link_params *params,
3113 struct link_vars *vars, u8 mode, u32 speed)
3114 {
3115 u8 port = params->port;
3116 u16 hw_led_mode = params->hw_led_mode;
3117 u8 rc = 0, phy_idx;
3118 u32 tmp;
3119 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
3120 struct bnx2x *bp = params->bp;
3121 DP(NETIF_MSG_LINK, "bnx2x_set_led: port %x, mode %d\n", port, mode);
3122 DP(NETIF_MSG_LINK, "speed 0x%x, hw_led_mode 0x%x\n",
3123 speed, hw_led_mode);
3124 /* In case */
3125 for (phy_idx = EXT_PHY1; phy_idx < MAX_PHYS; phy_idx++) {
3126 if (params->phy[phy_idx].set_link_led) {
3127 params->phy[phy_idx].set_link_led(
3128 &params->phy[phy_idx], params, mode);
3129 }
3130 }
3131
3132 switch (mode) {
3133 case LED_MODE_FRONT_PANEL_OFF:
3134 case LED_MODE_OFF:
3135 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 0);
3136 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4,
3137 SHARED_HW_CFG_LED_MAC1);
3138
3139 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
3140 EMAC_WR(bp, EMAC_REG_EMAC_LED, (tmp | EMAC_LED_OVERRIDE));
3141 break;
3142
3143 case LED_MODE_OPER:
3144 /*
3145 * For all other phys, OPER mode is same as ON, so in case
3146 * link is down, do nothing
3147 */
3148 if (!vars->link_up)
3149 break;
3150 case LED_MODE_ON:
3151 if (params->phy[EXT_PHY1].type ==
3152 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727 &&
3153 CHIP_IS_E2(bp) && params->num_phys == 2) {
3154 /*
3155 * This is a work-around for E2+8727 Configurations
3156 */
3157 if (mode == LED_MODE_ON ||
3158 speed == SPEED_10000){
3159 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, 0);
3160 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
3161
3162 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
3163 EMAC_WR(bp, EMAC_REG_EMAC_LED,
3164 (tmp | EMAC_LED_OVERRIDE));
3165 return rc;
3166 }
3167 } else if (SINGLE_MEDIA_DIRECT(params)) {
3168 /*
3169 * This is a work-around for HW issue found when link
3170 * is up in CL73
3171 */
3172 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, 0);
3173 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
3174 } else {
3175 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, hw_led_mode);
3176 }
3177
3178 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 + port*4, 0);
3179 /* Set blinking rate to ~15.9Hz */
3180 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_P0 + port*4,
3181 LED_BLINK_RATE_VAL);
3182 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_ENA_P0 +
3183 port*4, 1);
3184 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
3185 EMAC_WR(bp, EMAC_REG_EMAC_LED, (tmp & (~EMAC_LED_OVERRIDE)));
3186
3187 if (CHIP_IS_E1(bp) &&
3188 ((speed == SPEED_2500) ||
3189 (speed == SPEED_1000) ||
3190 (speed == SPEED_100) ||
3191 (speed == SPEED_10))) {
3192 /*
3193 * On Everest 1 Ax chip versions for speeds less than
3194 * 10G LED scheme is different
3195 */
3196 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0
3197 + port*4, 1);
3198 REG_WR(bp, NIG_REG_LED_CONTROL_TRAFFIC_P0 +
3199 port*4, 0);
3200 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_TRAFFIC_P0 +
3201 port*4, 1);
3202 }
3203 break;
3204
3205 default:
3206 rc = -EINVAL;
3207 DP(NETIF_MSG_LINK, "bnx2x_set_led: Invalid led mode %d\n",
3208 mode);
3209 break;
3210 }
3211 return rc;
3212
3213 }
3214
3215 /*
3216 * This function comes to reflect the actual link state read DIRECTLY from the
3217 * HW
3218 */
3219 u8 bnx2x_test_link(struct link_params *params, struct link_vars *vars,
3220 u8 is_serdes)
3221 {
3222 struct bnx2x *bp = params->bp;
3223 u16 gp_status = 0, phy_index = 0;
3224 u8 ext_phy_link_up = 0, serdes_phy_type;
3225 struct link_vars temp_vars;
3226
3227 CL22_RD_OVER_CL45(bp, &params->phy[INT_PHY],
3228 MDIO_REG_BANK_GP_STATUS,
3229 MDIO_GP_STATUS_TOP_AN_STATUS1,
3230 &gp_status);
3231 /* link is up only if both local phy and external phy are up */
3232 if (!(gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS))
3233 return -ESRCH;
3234
3235 switch (params->num_phys) {
3236 case 1:
3237 /* No external PHY */
3238 return 0;
3239 case 2:
3240 ext_phy_link_up = params->phy[EXT_PHY1].read_status(
3241 &params->phy[EXT_PHY1],
3242 params, &temp_vars);
3243 break;
3244 case 3: /* Dual Media */
3245 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
3246 phy_index++) {
3247 serdes_phy_type = ((params->phy[phy_index].media_type ==
3248 ETH_PHY_SFP_FIBER) ||
3249 (params->phy[phy_index].media_type ==
3250 ETH_PHY_XFP_FIBER));
3251
3252 if (is_serdes != serdes_phy_type)
3253 continue;
3254 if (params->phy[phy_index].read_status) {
3255 ext_phy_link_up |=
3256 params->phy[phy_index].read_status(
3257 &params->phy[phy_index],
3258 params, &temp_vars);
3259 }
3260 }
3261 break;
3262 }
3263 if (ext_phy_link_up)
3264 return 0;
3265 return -ESRCH;
3266 }
3267
3268 static u8 bnx2x_link_initialize(struct link_params *params,
3269 struct link_vars *vars)
3270 {
3271 u8 rc = 0;
3272 u8 phy_index, non_ext_phy;
3273 struct bnx2x *bp = params->bp;
3274 /*
3275 * In case of external phy existence, the line speed would be the
3276 * line speed linked up by the external phy. In case it is direct
3277 * only, then the line_speed during initialization will be
3278 * equal to the req_line_speed
3279 */
3280 vars->line_speed = params->phy[INT_PHY].req_line_speed;
3281
3282 /*
3283 * Initialize the internal phy in case this is a direct board
3284 * (no external phys), or this board has external phy which requires
3285 * to first.
3286 */
3287
3288 if (params->phy[INT_PHY].config_init)
3289 params->phy[INT_PHY].config_init(
3290 &params->phy[INT_PHY],
3291 params, vars);
3292
3293 /* init ext phy and enable link state int */
3294 non_ext_phy = (SINGLE_MEDIA_DIRECT(params) ||
3295 (params->loopback_mode == LOOPBACK_XGXS));
3296
3297 if (non_ext_phy ||
3298 (params->phy[EXT_PHY1].flags & FLAGS_INIT_XGXS_FIRST) ||
3299 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
3300 struct bnx2x_phy *phy = &params->phy[INT_PHY];
3301 if (vars->line_speed == SPEED_AUTO_NEG)
3302 bnx2x_set_parallel_detection(phy, params);
3303 bnx2x_init_internal_phy(phy, params, vars);
3304 }
3305
3306 /* Init external phy*/
3307 if (!non_ext_phy)
3308 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
3309 phy_index++) {
3310 /*
3311 * No need to initialize second phy in case of first
3312 * phy only selection. In case of second phy, we do
3313 * need to initialize the first phy, since they are
3314 * connected.
3315 */
3316 if (phy_index == EXT_PHY2 &&
3317 (bnx2x_phy_selection(params) ==
3318 PORT_HW_CFG_PHY_SELECTION_FIRST_PHY)) {
3319 DP(NETIF_MSG_LINK, "Ignoring second phy\n");
3320 continue;
3321 }
3322 params->phy[phy_index].config_init(
3323 &params->phy[phy_index],
3324 params, vars);
3325 }
3326
3327 /* Reset the interrupt indication after phy was initialized */
3328 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 +
3329 params->port*4,
3330 (NIG_STATUS_XGXS0_LINK10G |
3331 NIG_STATUS_XGXS0_LINK_STATUS |
3332 NIG_STATUS_SERDES0_LINK_STATUS |
3333 NIG_MASK_MI_INT));
3334 return rc;
3335 }
3336
3337 static void bnx2x_int_link_reset(struct bnx2x_phy *phy,
3338 struct link_params *params)
3339 {
3340 /* reset the SerDes/XGXS */
3341 REG_WR(params->bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
3342 (0x1ff << (params->port*16)));
3343 }
3344
3345 static void bnx2x_common_ext_link_reset(struct bnx2x_phy *phy,
3346 struct link_params *params)
3347 {
3348 struct bnx2x *bp = params->bp;
3349 u8 gpio_port;
3350 /* HW reset */
3351 if (CHIP_IS_E2(bp))
3352 gpio_port = BP_PATH(bp);
3353 else
3354 gpio_port = params->port;
3355 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
3356 MISC_REGISTERS_GPIO_OUTPUT_LOW,
3357 gpio_port);
3358 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
3359 MISC_REGISTERS_GPIO_OUTPUT_LOW,
3360 gpio_port);
3361 DP(NETIF_MSG_LINK, "reset external PHY\n");
3362 }
3363
3364 static u8 bnx2x_update_link_down(struct link_params *params,
3365 struct link_vars *vars)
3366 {
3367 struct bnx2x *bp = params->bp;
3368 u8 port = params->port;
3369
3370 DP(NETIF_MSG_LINK, "Port %x: Link is down\n", port);
3371 bnx2x_set_led(params, vars, LED_MODE_OFF, 0);
3372
3373 /* indicate no mac active */
3374 vars->mac_type = MAC_TYPE_NONE;
3375
3376 /* update shared memory */
3377 vars->link_status = 0;
3378 vars->line_speed = 0;
3379 bnx2x_update_mng(params, vars->link_status);
3380
3381 /* activate nig drain */
3382 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
3383
3384 /* disable emac */
3385 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
3386
3387 msleep(10);
3388
3389 /* reset BigMac */
3390 bnx2x_bmac_rx_disable(bp, params->port);
3391 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
3392 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
3393 return 0;
3394 }
3395
3396 static u8 bnx2x_update_link_up(struct link_params *params,
3397 struct link_vars *vars,
3398 u8 link_10g)
3399 {
3400 struct bnx2x *bp = params->bp;
3401 u8 port = params->port;
3402 u8 rc = 0;
3403
3404 vars->link_status |= LINK_STATUS_LINK_UP;
3405
3406 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
3407 vars->link_status |=
3408 LINK_STATUS_TX_FLOW_CONTROL_ENABLED;
3409
3410 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
3411 vars->link_status |=
3412 LINK_STATUS_RX_FLOW_CONTROL_ENABLED;
3413
3414 if (link_10g) {
3415 bnx2x_bmac_enable(params, vars, 0);
3416 bnx2x_set_led(params, vars,
3417 LED_MODE_OPER, SPEED_10000);
3418 } else {
3419 rc = bnx2x_emac_program(params, vars);
3420
3421 bnx2x_emac_enable(params, vars, 0);
3422
3423 /* AN complete? */
3424 if ((vars->link_status & LINK_STATUS_AUTO_NEGOTIATE_COMPLETE)
3425 && (!(vars->phy_flags & PHY_SGMII_FLAG)) &&
3426 SINGLE_MEDIA_DIRECT(params))
3427 bnx2x_set_gmii_tx_driver(params);
3428 }
3429
3430 /* PBF - link up */
3431 if (!(CHIP_IS_E2(bp)))
3432 rc |= bnx2x_pbf_update(params, vars->flow_ctrl,
3433 vars->line_speed);
3434
3435 /* disable drain */
3436 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 0);
3437
3438 /* update shared memory */
3439 bnx2x_update_mng(params, vars->link_status);
3440 msleep(20);
3441 return rc;
3442 }
3443 /*
3444 * The bnx2x_link_update function should be called upon link
3445 * interrupt.
3446 * Link is considered up as follows:
3447 * - DIRECT_SINGLE_MEDIA - Only XGXS link (internal link) needs
3448 * to be up
3449 * - SINGLE_MEDIA - The link between the 577xx and the external
3450 * phy (XGXS) need to up as well as the external link of the
3451 * phy (PHY_EXT1)
3452 * - DUAL_MEDIA - The link between the 577xx and the first
3453 * external phy needs to be up, and at least one of the 2
3454 * external phy link must be up.
3455 */
3456 u8 bnx2x_link_update(struct link_params *params, struct link_vars *vars)
3457 {
3458 struct bnx2x *bp = params->bp;
3459 struct link_vars phy_vars[MAX_PHYS];
3460 u8 port = params->port;
3461 u8 link_10g, phy_index;
3462 u8 ext_phy_link_up = 0, cur_link_up, rc = 0;
3463 u8 is_mi_int = 0;
3464 u16 ext_phy_line_speed = 0, prev_line_speed = vars->line_speed;
3465 u8 active_external_phy = INT_PHY;
3466 vars->link_status = 0;
3467 for (phy_index = INT_PHY; phy_index < params->num_phys;
3468 phy_index++) {
3469 phy_vars[phy_index].flow_ctrl = 0;
3470 phy_vars[phy_index].link_status = 0;
3471 phy_vars[phy_index].line_speed = 0;
3472 phy_vars[phy_index].duplex = DUPLEX_FULL;
3473 phy_vars[phy_index].phy_link_up = 0;
3474 phy_vars[phy_index].link_up = 0;
3475 }
3476
3477 DP(NETIF_MSG_LINK, "port %x, XGXS?%x, int_status 0x%x\n",
3478 port, (vars->phy_flags & PHY_XGXS_FLAG),
3479 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
3480
3481 is_mi_int = (u8)(REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT +
3482 port*0x18) > 0);
3483 DP(NETIF_MSG_LINK, "int_mask 0x%x MI_INT %x, SERDES_LINK %x\n",
3484 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
3485 is_mi_int,
3486 REG_RD(bp, NIG_REG_SERDES0_STATUS_LINK_STATUS + port*0x3c));
3487
3488 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
3489 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
3490 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
3491
3492 /* disable emac */
3493 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
3494
3495 /*
3496 * Step 1:
3497 * Check external link change only for external phys, and apply
3498 * priority selection between them in case the link on both phys
3499 * is up. Note that the instead of the common vars, a temporary
3500 * vars argument is used since each phy may have different link/
3501 * speed/duplex result
3502 */
3503 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
3504 phy_index++) {
3505 struct bnx2x_phy *phy = &params->phy[phy_index];
3506 if (!phy->read_status)
3507 continue;
3508 /* Read link status and params of this ext phy */
3509 cur_link_up = phy->read_status(phy, params,
3510 &phy_vars[phy_index]);
3511 if (cur_link_up) {
3512 DP(NETIF_MSG_LINK, "phy in index %d link is up\n",
3513 phy_index);
3514 } else {
3515 DP(NETIF_MSG_LINK, "phy in index %d link is down\n",
3516 phy_index);
3517 continue;
3518 }
3519
3520 if (!ext_phy_link_up) {
3521 ext_phy_link_up = 1;
3522 active_external_phy = phy_index;
3523 } else {
3524 switch (bnx2x_phy_selection(params)) {
3525 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
3526 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
3527 /*
3528 * In this option, the first PHY makes sure to pass the
3529 * traffic through itself only.
3530 * Its not clear how to reset the link on the second phy
3531 */
3532 active_external_phy = EXT_PHY1;
3533 break;
3534 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
3535 /*
3536 * In this option, the first PHY makes sure to pass the
3537 * traffic through the second PHY.
3538 */
3539 active_external_phy = EXT_PHY2;
3540 break;
3541 default:
3542 /*
3543 * Link indication on both PHYs with the following cases
3544 * is invalid:
3545 * - FIRST_PHY means that second phy wasn't initialized,
3546 * hence its link is expected to be down
3547 * - SECOND_PHY means that first phy should not be able
3548 * to link up by itself (using configuration)
3549 * - DEFAULT should be overriden during initialiazation
3550 */
3551 DP(NETIF_MSG_LINK, "Invalid link indication"
3552 "mpc=0x%x. DISABLING LINK !!!\n",
3553 params->multi_phy_config);
3554 ext_phy_link_up = 0;
3555 break;
3556 }
3557 }
3558 }
3559 prev_line_speed = vars->line_speed;
3560 /*
3561 * Step 2:
3562 * Read the status of the internal phy. In case of
3563 * DIRECT_SINGLE_MEDIA board, this link is the external link,
3564 * otherwise this is the link between the 577xx and the first
3565 * external phy
3566 */
3567 if (params->phy[INT_PHY].read_status)
3568 params->phy[INT_PHY].read_status(
3569 &params->phy[INT_PHY],
3570 params, vars);
3571 /*
3572 * The INT_PHY flow control reside in the vars. This include the
3573 * case where the speed or flow control are not set to AUTO.
3574 * Otherwise, the active external phy flow control result is set
3575 * to the vars. The ext_phy_line_speed is needed to check if the
3576 * speed is different between the internal phy and external phy.
3577 * This case may be result of intermediate link speed change.
3578 */
3579 if (active_external_phy > INT_PHY) {
3580 vars->flow_ctrl = phy_vars[active_external_phy].flow_ctrl;
3581 /*
3582 * Link speed is taken from the XGXS. AN and FC result from
3583 * the external phy.
3584 */
3585 vars->link_status |= phy_vars[active_external_phy].link_status;
3586
3587 /*
3588 * if active_external_phy is first PHY and link is up - disable
3589 * disable TX on second external PHY
3590 */
3591 if (active_external_phy == EXT_PHY1) {
3592 if (params->phy[EXT_PHY2].phy_specific_func) {
3593 DP(NETIF_MSG_LINK, "Disabling TX on"
3594 " EXT_PHY2\n");
3595 params->phy[EXT_PHY2].phy_specific_func(
3596 &params->phy[EXT_PHY2],
3597 params, DISABLE_TX);
3598 }
3599 }
3600
3601 ext_phy_line_speed = phy_vars[active_external_phy].line_speed;
3602 vars->duplex = phy_vars[active_external_phy].duplex;
3603 if (params->phy[active_external_phy].supported &
3604 SUPPORTED_FIBRE)
3605 vars->link_status |= LINK_STATUS_SERDES_LINK;
3606 DP(NETIF_MSG_LINK, "Active external phy selected: %x\n",
3607 active_external_phy);
3608 }
3609
3610 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
3611 phy_index++) {
3612 if (params->phy[phy_index].flags &
3613 FLAGS_REARM_LATCH_SIGNAL) {
3614 bnx2x_rearm_latch_signal(bp, port,
3615 phy_index ==
3616 active_external_phy);
3617 break;
3618 }
3619 }
3620 DP(NETIF_MSG_LINK, "vars->flow_ctrl = 0x%x, vars->link_status = 0x%x,"
3621 " ext_phy_line_speed = %d\n", vars->flow_ctrl,
3622 vars->link_status, ext_phy_line_speed);
3623 /*
3624 * Upon link speed change set the NIG into drain mode. Comes to
3625 * deals with possible FIFO glitch due to clk change when speed
3626 * is decreased without link down indicator
3627 */
3628
3629 if (vars->phy_link_up) {
3630 if (!(SINGLE_MEDIA_DIRECT(params)) && ext_phy_link_up &&
3631 (ext_phy_line_speed != vars->line_speed)) {
3632 DP(NETIF_MSG_LINK, "Internal link speed %d is"
3633 " different than the external"
3634 " link speed %d\n", vars->line_speed,
3635 ext_phy_line_speed);
3636 vars->phy_link_up = 0;
3637 } else if (prev_line_speed != vars->line_speed) {
3638 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4,
3639 0);
3640 msleep(1);
3641 }
3642 }
3643
3644 /* anything 10 and over uses the bmac */
3645 link_10g = ((vars->line_speed == SPEED_10000) ||
3646 (vars->line_speed == SPEED_12000) ||
3647 (vars->line_speed == SPEED_12500) ||
3648 (vars->line_speed == SPEED_13000) ||
3649 (vars->line_speed == SPEED_15000) ||
3650 (vars->line_speed == SPEED_16000));
3651
3652 bnx2x_link_int_ack(params, vars, link_10g);
3653
3654 /*
3655 * In case external phy link is up, and internal link is down
3656 * (not initialized yet probably after link initialization, it
3657 * needs to be initialized.
3658 * Note that after link down-up as result of cable plug, the xgxs
3659 * link would probably become up again without the need
3660 * initialize it
3661 */
3662 if (!(SINGLE_MEDIA_DIRECT(params))) {
3663 DP(NETIF_MSG_LINK, "ext_phy_link_up = %d, int_link_up = %d,"
3664 " init_preceding = %d\n", ext_phy_link_up,
3665 vars->phy_link_up,
3666 params->phy[EXT_PHY1].flags &
3667 FLAGS_INIT_XGXS_FIRST);
3668 if (!(params->phy[EXT_PHY1].flags &
3669 FLAGS_INIT_XGXS_FIRST)
3670 && ext_phy_link_up && !vars->phy_link_up) {
3671 vars->line_speed = ext_phy_line_speed;
3672 if (vars->line_speed < SPEED_1000)
3673 vars->phy_flags |= PHY_SGMII_FLAG;
3674 else
3675 vars->phy_flags &= ~PHY_SGMII_FLAG;
3676 bnx2x_init_internal_phy(&params->phy[INT_PHY],
3677 params,
3678 vars);
3679 }
3680 }
3681 /*
3682 * Link is up only if both local phy and external phy (in case of
3683 * non-direct board) are up
3684 */
3685 vars->link_up = (vars->phy_link_up &&
3686 (ext_phy_link_up ||
3687 SINGLE_MEDIA_DIRECT(params)));
3688
3689 if (vars->link_up)
3690 rc = bnx2x_update_link_up(params, vars, link_10g);
3691 else
3692 rc = bnx2x_update_link_down(params, vars);
3693
3694 return rc;
3695 }
3696
3697
3698 /*****************************************************************************/
3699 /* External Phy section */
3700 /*****************************************************************************/
3701 void bnx2x_ext_phy_hw_reset(struct bnx2x *bp, u8 port)
3702 {
3703 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
3704 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
3705 msleep(1);
3706 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
3707 MISC_REGISTERS_GPIO_OUTPUT_HIGH, port);
3708 }
3709
3710 static void bnx2x_save_spirom_version(struct bnx2x *bp, u8 port,
3711 u32 spirom_ver, u32 ver_addr)
3712 {
3713 DP(NETIF_MSG_LINK, "FW version 0x%x:0x%x for port %d\n",
3714 (u16)(spirom_ver>>16), (u16)spirom_ver, port);
3715
3716 if (ver_addr)
3717 REG_WR(bp, ver_addr, spirom_ver);
3718 }
3719
3720 static void bnx2x_save_bcm_spirom_ver(struct bnx2x *bp,
3721 struct bnx2x_phy *phy,
3722 u8 port)
3723 {
3724 u16 fw_ver1, fw_ver2;
3725
3726 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD,
3727 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
3728 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD,
3729 MDIO_PMA_REG_ROM_VER2, &fw_ver2);
3730 bnx2x_save_spirom_version(bp, port, (u32)(fw_ver1<<16 | fw_ver2),
3731 phy->ver_addr);
3732 }
3733
3734 static void bnx2x_ext_phy_set_pause(struct link_params *params,
3735 struct bnx2x_phy *phy,
3736 struct link_vars *vars)
3737 {
3738 u16 val;
3739 struct bnx2x *bp = params->bp;
3740 /* read modify write pause advertizing */
3741 bnx2x_cl45_read(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV_PAUSE, &val);
3742
3743 val &= ~MDIO_AN_REG_ADV_PAUSE_BOTH;
3744
3745 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
3746 bnx2x_calc_ieee_aneg_adv(phy, params, &vars->ieee_fc);
3747 if ((vars->ieee_fc &
3748 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
3749 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
3750 val |= MDIO_AN_REG_ADV_PAUSE_ASYMMETRIC;
3751 }
3752 if ((vars->ieee_fc &
3753 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
3754 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
3755 val |= MDIO_AN_REG_ADV_PAUSE_PAUSE;
3756 }
3757 DP(NETIF_MSG_LINK, "Ext phy AN advertize 0x%x\n", val);
3758 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV_PAUSE, val);
3759 }
3760
3761 static u8 bnx2x_ext_phy_resolve_fc(struct bnx2x_phy *phy,
3762 struct link_params *params,
3763 struct link_vars *vars)
3764 {
3765 struct bnx2x *bp = params->bp;
3766 u16 ld_pause; /* local */
3767 u16 lp_pause; /* link partner */
3768 u16 pause_result;
3769 u8 ret = 0;
3770 /* read twice */
3771
3772 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
3773
3774 if (phy->req_flow_ctrl != BNX2X_FLOW_CTRL_AUTO)
3775 vars->flow_ctrl = phy->req_flow_ctrl;
3776 else if (phy->req_line_speed != SPEED_AUTO_NEG)
3777 vars->flow_ctrl = params->req_fc_auto_adv;
3778 else if (vars->link_status & LINK_STATUS_AUTO_NEGOTIATE_COMPLETE) {
3779 ret = 1;
3780 bnx2x_cl45_read(bp, phy,
3781 MDIO_AN_DEVAD,
3782 MDIO_AN_REG_ADV_PAUSE, &ld_pause);
3783 bnx2x_cl45_read(bp, phy,
3784 MDIO_AN_DEVAD,
3785 MDIO_AN_REG_LP_AUTO_NEG, &lp_pause);
3786 pause_result = (ld_pause &
3787 MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
3788 pause_result |= (lp_pause &
3789 MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
3790 DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x\n",
3791 pause_result);
3792 bnx2x_pause_resolve(vars, pause_result);
3793 }
3794 return ret;
3795 }
3796
3797 static void bnx2x_ext_phy_10G_an_resolve(struct bnx2x *bp,
3798 struct bnx2x_phy *phy,
3799 struct link_vars *vars)
3800 {
3801 u16 val;
3802 bnx2x_cl45_read(bp, phy,
3803 MDIO_AN_DEVAD,
3804 MDIO_AN_REG_STATUS, &val);
3805 bnx2x_cl45_read(bp, phy,
3806 MDIO_AN_DEVAD,
3807 MDIO_AN_REG_STATUS, &val);
3808 if (val & (1<<5))
3809 vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
3810 if ((val & (1<<0)) == 0)
3811 vars->link_status |= LINK_STATUS_PARALLEL_DETECTION_USED;
3812 }
3813
3814 /******************************************************************/
3815 /* common BCM8073/BCM8727 PHY SECTION */
3816 /******************************************************************/
3817 static void bnx2x_8073_resolve_fc(struct bnx2x_phy *phy,
3818 struct link_params *params,
3819 struct link_vars *vars)
3820 {
3821 struct bnx2x *bp = params->bp;
3822 if (phy->req_line_speed == SPEED_10 ||
3823 phy->req_line_speed == SPEED_100) {
3824 vars->flow_ctrl = phy->req_flow_ctrl;
3825 return;
3826 }
3827
3828 if (bnx2x_ext_phy_resolve_fc(phy, params, vars) &&
3829 (vars->flow_ctrl == BNX2X_FLOW_CTRL_NONE)) {
3830 u16 pause_result;
3831 u16 ld_pause; /* local */
3832 u16 lp_pause; /* link partner */
3833 bnx2x_cl45_read(bp, phy,
3834 MDIO_AN_DEVAD,
3835 MDIO_AN_REG_CL37_FC_LD, &ld_pause);
3836
3837 bnx2x_cl45_read(bp, phy,
3838 MDIO_AN_DEVAD,
3839 MDIO_AN_REG_CL37_FC_LP, &lp_pause);
3840 pause_result = (ld_pause &
3841 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 5;
3842 pause_result |= (lp_pause &
3843 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
3844
3845 bnx2x_pause_resolve(vars, pause_result);
3846 DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x\n",
3847 pause_result);
3848 }
3849 }
3850 static u8 bnx2x_8073_8727_external_rom_boot(struct bnx2x *bp,
3851 struct bnx2x_phy *phy,
3852 u8 port)
3853 {
3854 u32 count = 0;
3855 u16 fw_ver1, fw_msgout;
3856 u8 rc = 0;
3857
3858 /* Boot port from external ROM */
3859 /* EDC grst */
3860 bnx2x_cl45_write(bp, phy,
3861 MDIO_PMA_DEVAD,
3862 MDIO_PMA_REG_GEN_CTRL,
3863 0x0001);
3864
3865 /* ucode reboot and rst */
3866 bnx2x_cl45_write(bp, phy,
3867 MDIO_PMA_DEVAD,
3868 MDIO_PMA_REG_GEN_CTRL,
3869 0x008c);
3870
3871 bnx2x_cl45_write(bp, phy,
3872 MDIO_PMA_DEVAD,
3873 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
3874
3875 /* Reset internal microprocessor */
3876 bnx2x_cl45_write(bp, phy,
3877 MDIO_PMA_DEVAD,
3878 MDIO_PMA_REG_GEN_CTRL,
3879 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
3880
3881 /* Release srst bit */
3882 bnx2x_cl45_write(bp, phy,
3883 MDIO_PMA_DEVAD,
3884 MDIO_PMA_REG_GEN_CTRL,
3885 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
3886
3887 /* Delay 100ms per the PHY specifications */
3888 msleep(100);
3889
3890 /* 8073 sometimes taking longer to download */
3891 do {
3892 count++;
3893 if (count > 300) {
3894 DP(NETIF_MSG_LINK,
3895 "bnx2x_8073_8727_external_rom_boot port %x:"
3896 "Download failed. fw version = 0x%x\n",
3897 port, fw_ver1);
3898 rc = -EINVAL;
3899 break;
3900 }
3901
3902 bnx2x_cl45_read(bp, phy,
3903 MDIO_PMA_DEVAD,
3904 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
3905 bnx2x_cl45_read(bp, phy,
3906 MDIO_PMA_DEVAD,
3907 MDIO_PMA_REG_M8051_MSGOUT_REG, &fw_msgout);
3908
3909 msleep(1);
3910 } while (fw_ver1 == 0 || fw_ver1 == 0x4321 ||
3911 ((fw_msgout & 0xff) != 0x03 && (phy->type ==
3912 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073)));
3913
3914 /* Clear ser_boot_ctl bit */
3915 bnx2x_cl45_write(bp, phy,
3916 MDIO_PMA_DEVAD,
3917 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
3918 bnx2x_save_bcm_spirom_ver(bp, phy, port);
3919
3920 DP(NETIF_MSG_LINK,
3921 "bnx2x_8073_8727_external_rom_boot port %x:"
3922 "Download complete. fw version = 0x%x\n",
3923 port, fw_ver1);
3924
3925 return rc;
3926 }
3927
3928 /******************************************************************/
3929 /* BCM8073 PHY SECTION */
3930 /******************************************************************/
3931 static u8 bnx2x_8073_is_snr_needed(struct bnx2x *bp, struct bnx2x_phy *phy)
3932 {
3933 /* This is only required for 8073A1, version 102 only */
3934 u16 val;
3935
3936 /* Read 8073 HW revision*/
3937 bnx2x_cl45_read(bp, phy,
3938 MDIO_PMA_DEVAD,
3939 MDIO_PMA_REG_8073_CHIP_REV, &val);
3940
3941 if (val != 1) {
3942 /* No need to workaround in 8073 A1 */
3943 return 0;
3944 }
3945
3946 bnx2x_cl45_read(bp, phy,
3947 MDIO_PMA_DEVAD,
3948 MDIO_PMA_REG_ROM_VER2, &val);
3949
3950 /* SNR should be applied only for version 0x102 */
3951 if (val != 0x102)
3952 return 0;
3953
3954 return 1;
3955 }
3956
3957 static u8 bnx2x_8073_xaui_wa(struct bnx2x *bp, struct bnx2x_phy *phy)
3958 {
3959 u16 val, cnt, cnt1 ;
3960
3961 bnx2x_cl45_read(bp, phy,
3962 MDIO_PMA_DEVAD,
3963 MDIO_PMA_REG_8073_CHIP_REV, &val);
3964
3965 if (val > 0) {
3966 /* No need to workaround in 8073 A1 */
3967 return 0;
3968 }
3969 /* XAUI workaround in 8073 A0: */
3970
3971 /*
3972 * After loading the boot ROM and restarting Autoneg, poll
3973 * Dev1, Reg $C820:
3974 */
3975
3976 for (cnt = 0; cnt < 1000; cnt++) {
3977 bnx2x_cl45_read(bp, phy,
3978 MDIO_PMA_DEVAD,
3979 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
3980 &val);
3981 /*
3982 * If bit [14] = 0 or bit [13] = 0, continue on with
3983 * system initialization (XAUI work-around not required, as
3984 * these bits indicate 2.5G or 1G link up).
3985 */
3986 if (!(val & (1<<14)) || !(val & (1<<13))) {
3987 DP(NETIF_MSG_LINK, "XAUI work-around not required\n");
3988 return 0;
3989 } else if (!(val & (1<<15))) {
3990 DP(NETIF_MSG_LINK, "bit 15 went off\n");
3991 /*
3992 * If bit 15 is 0, then poll Dev1, Reg $C841 until it's
3993 * MSB (bit15) goes to 1 (indicating that the XAUI
3994 * workaround has completed), then continue on with
3995 * system initialization.
3996 */
3997 for (cnt1 = 0; cnt1 < 1000; cnt1++) {
3998 bnx2x_cl45_read(bp, phy,
3999 MDIO_PMA_DEVAD,
4000 MDIO_PMA_REG_8073_XAUI_WA, &val);
4001 if (val & (1<<15)) {
4002 DP(NETIF_MSG_LINK,
4003 "XAUI workaround has completed\n");
4004 return 0;
4005 }
4006 msleep(3);
4007 }
4008 break;
4009 }
4010 msleep(3);
4011 }
4012 DP(NETIF_MSG_LINK, "Warning: XAUI work-around timeout !!!\n");
4013 return -EINVAL;
4014 }
4015
4016 static void bnx2x_807x_force_10G(struct bnx2x *bp, struct bnx2x_phy *phy)
4017 {
4018 /* Force KR or KX */
4019 bnx2x_cl45_write(bp, phy,
4020 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x2040);
4021 bnx2x_cl45_write(bp, phy,
4022 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, 0x000b);
4023 bnx2x_cl45_write(bp, phy,
4024 MDIO_PMA_DEVAD, MDIO_PMA_REG_BCM_CTRL, 0x0000);
4025 bnx2x_cl45_write(bp, phy,
4026 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
4027 }
4028
4029 static void bnx2x_8073_set_pause_cl37(struct link_params *params,
4030 struct bnx2x_phy *phy,
4031 struct link_vars *vars)
4032 {
4033 u16 cl37_val;
4034 struct bnx2x *bp = params->bp;
4035 bnx2x_cl45_read(bp, phy,
4036 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, &cl37_val);
4037
4038 cl37_val &= ~MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
4039 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
4040 bnx2x_calc_ieee_aneg_adv(phy, params, &vars->ieee_fc);
4041 if ((vars->ieee_fc &
4042 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) ==
4043 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) {
4044 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC;
4045 }
4046 if ((vars->ieee_fc &
4047 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
4048 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
4049 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
4050 }
4051 if ((vars->ieee_fc &
4052 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
4053 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
4054 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
4055 }
4056 DP(NETIF_MSG_LINK,
4057 "Ext phy AN advertize cl37 0x%x\n", cl37_val);
4058
4059 bnx2x_cl45_write(bp, phy,
4060 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, cl37_val);
4061 msleep(500);
4062 }
4063
4064 static u8 bnx2x_8073_config_init(struct bnx2x_phy *phy,
4065 struct link_params *params,
4066 struct link_vars *vars)
4067 {
4068 struct bnx2x *bp = params->bp;
4069 u16 val = 0, tmp1;
4070 u8 gpio_port;
4071 DP(NETIF_MSG_LINK, "Init 8073\n");
4072
4073 if (CHIP_IS_E2(bp))
4074 gpio_port = BP_PATH(bp);
4075 else
4076 gpio_port = params->port;
4077 /* Restore normal power mode*/
4078 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
4079 MISC_REGISTERS_GPIO_OUTPUT_HIGH, gpio_port);
4080
4081 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
4082 MISC_REGISTERS_GPIO_OUTPUT_HIGH, gpio_port);
4083
4084 /* enable LASI */
4085 bnx2x_cl45_write(bp, phy,
4086 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL, (1<<2));
4087 bnx2x_cl45_write(bp, phy,
4088 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0x0004);
4089
4090 bnx2x_8073_set_pause_cl37(params, phy, vars);
4091
4092 bnx2x_cl45_read(bp, phy,
4093 MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &tmp1);
4094
4095 bnx2x_cl45_read(bp, phy,
4096 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM, &tmp1);
4097
4098 DP(NETIF_MSG_LINK, "Before rom RX_ALARM(port1): 0x%x\n", tmp1);
4099
4100 /* Swap polarity if required - Must be done only in non-1G mode */
4101 if (params->lane_config & PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED) {
4102 /* Configure the 8073 to swap _P and _N of the KR lines */
4103 DP(NETIF_MSG_LINK, "Swapping polarity for the 8073\n");
4104 /* 10G Rx/Tx and 1G Tx signal polarity swap */
4105 bnx2x_cl45_read(bp, phy,
4106 MDIO_PMA_DEVAD,
4107 MDIO_PMA_REG_8073_OPT_DIGITAL_CTRL, &val);
4108 bnx2x_cl45_write(bp, phy,
4109 MDIO_PMA_DEVAD,
4110 MDIO_PMA_REG_8073_OPT_DIGITAL_CTRL,
4111 (val | (3<<9)));
4112 }
4113
4114
4115 /* Enable CL37 BAM */
4116 if (REG_RD(bp, params->shmem_base +
4117 offsetof(struct shmem_region, dev_info.
4118 port_hw_config[params->port].default_cfg)) &
4119 PORT_HW_CFG_ENABLE_BAM_ON_KR_ENABLED) {
4120
4121 bnx2x_cl45_read(bp, phy,
4122 MDIO_AN_DEVAD,
4123 MDIO_AN_REG_8073_BAM, &val);
4124 bnx2x_cl45_write(bp, phy,
4125 MDIO_AN_DEVAD,
4126 MDIO_AN_REG_8073_BAM, val | 1);
4127 DP(NETIF_MSG_LINK, "Enable CL37 BAM on KR\n");
4128 }
4129 if (params->loopback_mode == LOOPBACK_EXT) {
4130 bnx2x_807x_force_10G(bp, phy);
4131 DP(NETIF_MSG_LINK, "Forced speed 10G on 807X\n");
4132 return 0;
4133 } else {
4134 bnx2x_cl45_write(bp, phy,
4135 MDIO_PMA_DEVAD, MDIO_PMA_REG_BCM_CTRL, 0x0002);
4136 }
4137 if (phy->req_line_speed != SPEED_AUTO_NEG) {
4138 if (phy->req_line_speed == SPEED_10000) {
4139 val = (1<<7);
4140 } else if (phy->req_line_speed == SPEED_2500) {
4141 val = (1<<5);
4142 /*
4143 * Note that 2.5G works only when used with 1G
4144 * advertisement
4145 */
4146 } else
4147 val = (1<<5);
4148 } else {
4149 val = 0;
4150 if (phy->speed_cap_mask &
4151 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
4152 val |= (1<<7);
4153
4154 /* Note that 2.5G works only when used with 1G advertisement */
4155 if (phy->speed_cap_mask &
4156 (PORT_HW_CFG_SPEED_CAPABILITY_D0_1G |
4157 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
4158 val |= (1<<5);
4159 DP(NETIF_MSG_LINK, "807x autoneg val = 0x%x\n", val);
4160 }
4161
4162 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV, val);
4163 bnx2x_cl45_read(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_8073_2_5G, &tmp1);
4164
4165 if (((phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G) &&
4166 (phy->req_line_speed == SPEED_AUTO_NEG)) ||
4167 (phy->req_line_speed == SPEED_2500)) {
4168 u16 phy_ver;
4169 /* Allow 2.5G for A1 and above */
4170 bnx2x_cl45_read(bp, phy,
4171 MDIO_PMA_DEVAD, MDIO_PMA_REG_8073_CHIP_REV,
4172 &phy_ver);
4173 DP(NETIF_MSG_LINK, "Add 2.5G\n");
4174 if (phy_ver > 0)
4175 tmp1 |= 1;
4176 else
4177 tmp1 &= 0xfffe;
4178 } else {
4179 DP(NETIF_MSG_LINK, "Disable 2.5G\n");
4180 tmp1 &= 0xfffe;
4181 }
4182
4183 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_8073_2_5G, tmp1);
4184 /* Add support for CL37 (passive mode) II */
4185
4186 bnx2x_cl45_read(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, &tmp1);
4187 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD,
4188 (tmp1 | ((phy->req_duplex == DUPLEX_FULL) ?
4189 0x20 : 0x40)));
4190
4191 /* Add support for CL37 (passive mode) III */
4192 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CL37_AN, 0x1000);
4193
4194 /*
4195 * The SNR will improve about 2db by changing BW and FEE main
4196 * tap. Rest commands are executed after link is up
4197 * Change FFE main cursor to 5 in EDC register
4198 */
4199 if (bnx2x_8073_is_snr_needed(bp, phy))
4200 bnx2x_cl45_write(bp, phy,
4201 MDIO_PMA_DEVAD, MDIO_PMA_REG_EDC_FFE_MAIN,
4202 0xFB0C);
4203
4204 /* Enable FEC (Forware Error Correction) Request in the AN */
4205 bnx2x_cl45_read(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV2, &tmp1);
4206 tmp1 |= (1<<15);
4207 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV2, tmp1);
4208
4209 bnx2x_ext_phy_set_pause(params, phy, vars);
4210
4211 /* Restart autoneg */
4212 msleep(500);
4213 bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x1200);
4214 DP(NETIF_MSG_LINK, "807x Autoneg Restart: Advertise 1G=%x, 10G=%x\n",
4215 ((val & (1<<5)) > 0), ((val & (1<<7)) > 0));
4216 return 0;
4217 }
4218
4219 static u8 bnx2x_8073_read_status(struct bnx2x_phy *phy,
4220 struct link_params *params,
4221 struct link_vars *vars)
4222 {
4223 struct bnx2x *bp = params->bp;
4224 u8 link_up = 0;
4225 u16 val1, val2;
4226 u16 link_status = 0;
4227 u16 an1000_status = 0;
4228
4229 bnx2x_cl45_read(bp, phy,
4230 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val1);
4231
4232 DP(NETIF_MSG_LINK, "8703 LASI status 0x%x\n", val1);
4233
4234 /* clear the interrupt LASI status register */
4235 bnx2x_cl45_read(bp, phy,
4236 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
4237 bnx2x_cl45_read(bp, phy,
4238 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val1);
4239 DP(NETIF_MSG_LINK, "807x PCS status 0x%x->0x%x\n", val2, val1);
4240 /* Clear MSG-OUT */
4241 bnx2x_cl45_read(bp, phy,
4242 MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &val1);
4243
4244 /* Check the LASI */
4245 bnx2x_cl45_read(bp, phy,
4246 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM, &val2);
4247
4248 DP(NETIF_MSG_LINK, "KR 0x9003 0x%x\n", val2);
4249
4250 /* Check the link status */
4251 bnx2x_cl45_read(bp, phy,
4252 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
4253 DP(NETIF_MSG_LINK, "KR PCS status 0x%x\n", val2);
4254
4255 bnx2x_cl45_read(bp, phy,
4256 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
4257 bnx2x_cl45_read(bp, phy,
4258 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
4259 link_up = ((val1 & 4) == 4);
4260 DP(NETIF_MSG_LINK, "PMA_REG_STATUS=0x%x\n", val1);
4261
4262 if (link_up &&
4263 ((phy->req_line_speed != SPEED_10000))) {
4264 if (bnx2x_8073_xaui_wa(bp, phy) != 0)
4265 return 0;
4266 }
4267 bnx2x_cl45_read(bp, phy,
4268 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &an1000_status);
4269 bnx2x_cl45_read(bp, phy,
4270 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &an1000_status);
4271
4272 /* Check the link status on 1.1.2 */
4273 bnx2x_cl45_read(bp, phy,
4274 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
4275 bnx2x_cl45_read(bp, phy,
4276 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
4277 DP(NETIF_MSG_LINK, "KR PMA status 0x%x->0x%x,"
4278 "an_link_status=0x%x\n", val2, val1, an1000_status);
4279
4280 link_up = (((val1 & 4) == 4) || (an1000_status & (1<<1)));
4281 if (link_up && bnx2x_8073_is_snr_needed(bp, phy)) {
4282 /*
4283 * The SNR will improve about 2dbby changing the BW and FEE main
4284 * tap. The 1st write to change FFE main tap is set before
4285 * restart AN. Change PLL Bandwidth in EDC register
4286 */
4287 bnx2x_cl45_write(bp, phy,
4288 MDIO_PMA_DEVAD, MDIO_PMA_REG_PLL_BANDWIDTH,
4289 0x26BC);
4290
4291 /* Change CDR Bandwidth in EDC register */
4292 bnx2x_cl45_write(bp, phy,
4293 MDIO_PMA_DEVAD, MDIO_PMA_REG_CDR_BANDWIDTH,
4294 0x0333);
4295 }
4296 bnx2x_cl45_read(bp, phy,
4297 MDIO_PMA_DEVAD, MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
4298 &link_status);
4299
4300 /* Bits 0..2 --> speed detected, bits 13..15--> link is down */
4301 if ((link_status & (1<<2)) && (!(link_status & (1<<15)))) {
4302 link_up = 1;
4303 vars->line_speed = SPEED_10000;
4304 DP(NETIF_MSG_LINK, "port %x: External link up in 10G\n",
4305 params->port);
4306 } else if ((link_status & (1<<1)) && (!(link_status & (1<<14)))) {
4307 link_up = 1;
4308 vars->line_speed = SPEED_2500;
4309 DP(NETIF_MSG_LINK, "port %x: External link up in 2.5G\n",
4310 params->port);
4311 } else if ((link_status & (1<<0)) && (!(link_status & (1<<13)))) {
4312 link_up = 1;
4313 vars->line_speed = SPEED_1000;
4314 DP(NETIF_MSG_LINK, "port %x: External link up in 1G\n",
4315 params->port);
4316 } else {
4317 link_up = 0;
4318 DP(NETIF_MSG_LINK, "port %x: External link is down\n",
4319 params->port);
4320 }
4321
4322 if (link_up) {
4323 /* Swap polarity if required */
4324 if (params->lane_config &
4325 PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED) {
4326 /* Configure the 8073 to swap P and N of the KR lines */
4327 bnx2x_cl45_read(bp, phy,
4328 MDIO_XS_DEVAD,
4329 MDIO_XS_REG_8073_RX_CTRL_PCIE, &val1);
4330 /*
4331 * Set bit 3 to invert Rx in 1G mode and clear this bit
4332 * when it`s in 10G mode.
4333 */
4334 if (vars->line_speed == SPEED_1000) {
4335 DP(NETIF_MSG_LINK, "Swapping 1G polarity for"
4336 "the 8073\n");
4337 val1 |= (1<<3);
4338 } else
4339 val1 &= ~(1<<3);
4340
4341 bnx2x_cl45_write(bp, phy,
4342 MDIO_XS_DEVAD,
4343 MDIO_XS_REG_8073_RX_CTRL_PCIE,
4344 val1);
4345 }
4346 bnx2x_ext_phy_10G_an_resolve(bp, phy, vars);
4347 bnx2x_8073_resolve_fc(phy, params, vars);
4348 vars->duplex = DUPLEX_FULL;
4349 }
4350 return link_up;
4351 }
4352
4353 static void bnx2x_8073_link_reset(struct bnx2x_phy *phy,
4354 struct link_params *params)
4355 {
4356 struct bnx2x *bp = params->bp;
4357 u8 gpio_port;
4358 if (CHIP_IS_E2(bp))
4359 gpio_port = BP_PATH(bp);
4360 else
4361 gpio_port = params->port;
4362 DP(NETIF_MSG_LINK, "Setting 8073 port %d into low power mode\n",
4363 gpio_port);
4364 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
4365 MISC_REGISTERS_GPIO_OUTPUT_LOW,
4366 gpio_port);
4367 }
4368
4369 /******************************************************************/
4370 /* BCM8705 PHY SECTION */
4371 /******************************************************************/
4372 static u8 bnx2x_8705_config_init(struct bnx2x_phy *phy,
4373 struct link_params *params,
4374 struct link_vars *vars)
4375 {
4376 struct bnx2x *bp = params->bp;
4377 DP(NETIF_MSG_LINK, "init 8705\n");
4378 /* Restore normal power mode*/
4379 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
4380 MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
4381 /* HW reset */
4382 bnx2x_ext_phy_hw_reset(bp, params->port);
4383 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0xa040);
4384 bnx2x_wait_reset_complete(bp, phy, params);
4385
4386 bnx2x_cl45_write(bp, phy,
4387 MDIO_PMA_DEVAD, MDIO_PMA_REG_MISC_CTRL, 0x8288);
4388 bnx2x_cl45_write(bp, phy,
4389 MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER, 0x7fbf);
4390 bnx2x_cl45_write(bp, phy,
4391 MDIO_PMA_DEVAD, MDIO_PMA_REG_CMU_PLL_BYPASS, 0x0100);
4392 bnx2x_cl45_write(bp, phy,
4393 MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_CNTL, 0x1);
4394 /* BCM8705 doesn't have microcode, hence the 0 */
4395 bnx2x_save_spirom_version(bp, params->port, params->shmem_base, 0);
4396 return 0;
4397 }
4398
4399 static u8 bnx2x_8705_read_status(struct bnx2x_phy *phy,
4400 struct link_params *params,
4401 struct link_vars *vars)
4402 {
4403 u8 link_up = 0;
4404 u16 val1, rx_sd;
4405 struct bnx2x *bp = params->bp;
4406 DP(NETIF_MSG_LINK, "read status 8705\n");
4407 bnx2x_cl45_read(bp, phy,
4408 MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
4409 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4410
4411 bnx2x_cl45_read(bp, phy,
4412 MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
4413 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4414
4415 bnx2x_cl45_read(bp, phy,
4416 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
4417
4418 bnx2x_cl45_read(bp, phy,
4419 MDIO_PMA_DEVAD, 0xc809, &val1);
4420 bnx2x_cl45_read(bp, phy,
4421 MDIO_PMA_DEVAD, 0xc809, &val1);
4422
4423 DP(NETIF_MSG_LINK, "8705 1.c809 val=0x%x\n", val1);
4424 link_up = ((rx_sd & 0x1) && (val1 & (1<<9)) && ((val1 & (1<<8)) == 0));
4425 if (link_up) {
4426 vars->line_speed = SPEED_10000;
4427 bnx2x_ext_phy_resolve_fc(phy, params, vars);
4428 }
4429 return link_up;
4430 }
4431
4432 /******************************************************************/
4433 /* SFP+ module Section */
4434 /******************************************************************/
4435 static u8 bnx2x_get_gpio_port(struct link_params *params)
4436 {
4437 u8 gpio_port;
4438 u32 swap_val, swap_override;
4439 struct bnx2x *bp = params->bp;
4440 if (CHIP_IS_E2(bp))
4441 gpio_port = BP_PATH(bp);
4442 else
4443 gpio_port = params->port;
4444 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
4445 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
4446 return gpio_port ^ (swap_val && swap_override);
4447 }
4448 static void bnx2x_sfp_set_transmitter(struct link_params *params,
4449 struct bnx2x_phy *phy,
4450 u8 tx_en)
4451 {
4452 u16 val;
4453 u8 port = params->port;
4454 struct bnx2x *bp = params->bp;
4455 u32 tx_en_mode;
4456
4457 /* Disable/Enable transmitter ( TX laser of the SFP+ module.)*/
4458 tx_en_mode = REG_RD(bp, params->shmem_base +
4459 offsetof(struct shmem_region,
4460 dev_info.port_hw_config[port].sfp_ctrl)) &
4461 PORT_HW_CFG_TX_LASER_MASK;
4462 DP(NETIF_MSG_LINK, "Setting transmitter tx_en=%x for port %x "
4463 "mode = %x\n", tx_en, port, tx_en_mode);
4464 switch (tx_en_mode) {
4465 case PORT_HW_CFG_TX_LASER_MDIO:
4466
4467 bnx2x_cl45_read(bp, phy,
4468 MDIO_PMA_DEVAD,
4469 MDIO_PMA_REG_PHY_IDENTIFIER,
4470 &val);
4471
4472 if (tx_en)
4473 val &= ~(1<<15);
4474 else
4475 val |= (1<<15);
4476
4477 bnx2x_cl45_write(bp, phy,
4478 MDIO_PMA_DEVAD,
4479 MDIO_PMA_REG_PHY_IDENTIFIER,
4480 val);
4481 break;
4482 case PORT_HW_CFG_TX_LASER_GPIO0:
4483 case PORT_HW_CFG_TX_LASER_GPIO1:
4484 case PORT_HW_CFG_TX_LASER_GPIO2:
4485 case PORT_HW_CFG_TX_LASER_GPIO3:
4486 {
4487 u16 gpio_pin;
4488 u8 gpio_port, gpio_mode;
4489 if (tx_en)
4490 gpio_mode = MISC_REGISTERS_GPIO_OUTPUT_HIGH;
4491 else
4492 gpio_mode = MISC_REGISTERS_GPIO_OUTPUT_LOW;
4493
4494 gpio_pin = tx_en_mode - PORT_HW_CFG_TX_LASER_GPIO0;
4495 gpio_port = bnx2x_get_gpio_port(params);
4496 bnx2x_set_gpio(bp, gpio_pin, gpio_mode, gpio_port);
4497 break;
4498 }
4499 default:
4500 DP(NETIF_MSG_LINK, "Invalid TX_LASER_MDIO 0x%x\n", tx_en_mode);
4501 break;
4502 }
4503 }
4504
4505 static u8 bnx2x_8726_read_sfp_module_eeprom(struct bnx2x_phy *phy,
4506 struct link_params *params,
4507 u16 addr, u8 byte_cnt, u8 *o_buf)
4508 {
4509 struct bnx2x *bp = params->bp;
4510 u16 val = 0;
4511 u16 i;
4512 if (byte_cnt > 16) {
4513 DP(NETIF_MSG_LINK, "Reading from eeprom is"
4514 " is limited to 0xf\n");
4515 return -EINVAL;
4516 }
4517 /* Set the read command byte count */
4518 bnx2x_cl45_write(bp, phy,
4519 MDIO_PMA_DEVAD, MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
4520 (byte_cnt | 0xa000));
4521
4522 /* Set the read command address */
4523 bnx2x_cl45_write(bp, phy,
4524 MDIO_PMA_DEVAD, MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
4525 addr);
4526
4527 /* Activate read command */
4528 bnx2x_cl45_write(bp, phy,
4529 MDIO_PMA_DEVAD, MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
4530 0x2c0f);
4531
4532 /* Wait up to 500us for command complete status */
4533 for (i = 0; i < 100; i++) {
4534 bnx2x_cl45_read(bp, phy,
4535 MDIO_PMA_DEVAD,
4536 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
4537 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
4538 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
4539 break;
4540 udelay(5);
4541 }
4542
4543 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
4544 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
4545 DP(NETIF_MSG_LINK,
4546 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
4547 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
4548 return -EINVAL;
4549 }
4550
4551 /* Read the buffer */
4552 for (i = 0; i < byte_cnt; i++) {
4553 bnx2x_cl45_read(bp, phy,
4554 MDIO_PMA_DEVAD,
4555 MDIO_PMA_REG_8726_TWO_WIRE_DATA_BUF + i, &val);
4556 o_buf[i] = (u8)(val & MDIO_PMA_REG_8726_TWO_WIRE_DATA_MASK);
4557 }
4558
4559 for (i = 0; i < 100; i++) {
4560 bnx2x_cl45_read(bp, phy,
4561 MDIO_PMA_DEVAD,
4562 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
4563 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
4564 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
4565 return 0;
4566 msleep(1);
4567 }
4568 return -EINVAL;
4569 }
4570
4571 static u8 bnx2x_8727_read_sfp_module_eeprom(struct bnx2x_phy *phy,
4572 struct link_params *params,
4573 u16 addr, u8 byte_cnt, u8 *o_buf)
4574 {
4575 struct bnx2x *bp = params->bp;
4576 u16 val, i;
4577
4578 if (byte_cnt > 16) {
4579 DP(NETIF_MSG_LINK, "Reading from eeprom is"
4580 " is limited to 0xf\n");
4581 return -EINVAL;
4582 }
4583
4584 /* Need to read from 1.8000 to clear it */
4585 bnx2x_cl45_read(bp, phy,
4586 MDIO_PMA_DEVAD,
4587 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
4588 &val);
4589
4590 /* Set the read command byte count */
4591 bnx2x_cl45_write(bp, phy,
4592 MDIO_PMA_DEVAD,
4593 MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
4594 ((byte_cnt < 2) ? 2 : byte_cnt));
4595
4596 /* Set the read command address */
4597 bnx2x_cl45_write(bp, phy,
4598 MDIO_PMA_DEVAD,
4599 MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
4600 addr);
4601 /* Set the destination address */
4602 bnx2x_cl45_write(bp, phy,
4603 MDIO_PMA_DEVAD,
4604 0x8004,
4605 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF);
4606
4607 /* Activate read command */
4608 bnx2x_cl45_write(bp, phy,
4609 MDIO_PMA_DEVAD,
4610 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
4611 0x8002);
4612 /*
4613 * Wait appropriate time for two-wire command to finish before
4614 * polling the status register
4615 */
4616 msleep(1);
4617
4618 /* Wait up to 500us for command complete status */
4619 for (i = 0; i < 100; i++) {
4620 bnx2x_cl45_read(bp, phy,
4621 MDIO_PMA_DEVAD,
4622 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
4623 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
4624 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
4625 break;
4626 udelay(5);
4627 }
4628
4629 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
4630 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
4631 DP(NETIF_MSG_LINK,
4632 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
4633 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
4634 return -EFAULT;
4635 }
4636
4637 /* Read the buffer */
4638 for (i = 0; i < byte_cnt; i++) {
4639 bnx2x_cl45_read(bp, phy,
4640 MDIO_PMA_DEVAD,
4641 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF + i, &val);
4642 o_buf[i] = (u8)(val & MDIO_PMA_REG_8727_TWO_WIRE_DATA_MASK);
4643 }
4644
4645 for (i = 0; i < 100; i++) {
4646 bnx2x_cl45_read(bp, phy,
4647 MDIO_PMA_DEVAD,
4648 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
4649 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
4650 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
4651 return 0;
4652 msleep(1);
4653 }
4654
4655 return -EINVAL;
4656 }
4657
4658 u8 bnx2x_read_sfp_module_eeprom(struct bnx2x_phy *phy,
4659 struct link_params *params, u16 addr,
4660 u8 byte_cnt, u8 *o_buf)
4661 {
4662 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
4663 return bnx2x_8726_read_sfp_module_eeprom(phy, params, addr,
4664 byte_cnt, o_buf);
4665 else if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
4666 return bnx2x_8727_read_sfp_module_eeprom(phy, params, addr,
4667 byte_cnt, o_buf);
4668 return -EINVAL;
4669 }
4670
4671 static u8 bnx2x_get_edc_mode(struct bnx2x_phy *phy,
4672 struct link_params *params,
4673 u16 *edc_mode)
4674 {
4675 struct bnx2x *bp = params->bp;
4676 u8 val, check_limiting_mode = 0;
4677 *edc_mode = EDC_MODE_LIMITING;
4678
4679 /* First check for copper cable */
4680 if (bnx2x_read_sfp_module_eeprom(phy,
4681 params,
4682 SFP_EEPROM_CON_TYPE_ADDR,
4683 1,
4684 &val) != 0) {
4685 DP(NETIF_MSG_LINK, "Failed to read from SFP+ module EEPROM\n");
4686 return -EINVAL;
4687 }
4688
4689 switch (val) {
4690 case SFP_EEPROM_CON_TYPE_VAL_COPPER:
4691 {
4692 u8 copper_module_type;
4693
4694 /*
4695 * Check if its active cable (includes SFP+ module)
4696 * of passive cable
4697 */
4698 if (bnx2x_read_sfp_module_eeprom(phy,
4699 params,
4700 SFP_EEPROM_FC_TX_TECH_ADDR,
4701 1,
4702 &copper_module_type) !=
4703 0) {
4704 DP(NETIF_MSG_LINK,
4705 "Failed to read copper-cable-type"
4706 " from SFP+ EEPROM\n");
4707 return -EINVAL;
4708 }
4709
4710 if (copper_module_type &
4711 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE) {
4712 DP(NETIF_MSG_LINK, "Active Copper cable detected\n");
4713 check_limiting_mode = 1;
4714 } else if (copper_module_type &
4715 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE) {
4716 DP(NETIF_MSG_LINK, "Passive Copper"
4717 " cable detected\n");
4718 *edc_mode =
4719 EDC_MODE_PASSIVE_DAC;
4720 } else {
4721 DP(NETIF_MSG_LINK, "Unknown copper-cable-"
4722 "type 0x%x !!!\n", copper_module_type);
4723 return -EINVAL;
4724 }
4725 break;
4726 }
4727 case SFP_EEPROM_CON_TYPE_VAL_LC:
4728 DP(NETIF_MSG_LINK, "Optic module detected\n");
4729 check_limiting_mode = 1;
4730 break;
4731 default:
4732 DP(NETIF_MSG_LINK, "Unable to determine module type 0x%x !!!\n",
4733 val);
4734 return -EINVAL;
4735 }
4736
4737 if (check_limiting_mode) {
4738 u8 options[SFP_EEPROM_OPTIONS_SIZE];
4739 if (bnx2x_read_sfp_module_eeprom(phy,
4740 params,
4741 SFP_EEPROM_OPTIONS_ADDR,
4742 SFP_EEPROM_OPTIONS_SIZE,
4743 options) != 0) {
4744 DP(NETIF_MSG_LINK, "Failed to read Option"
4745 " field from module EEPROM\n");
4746 return -EINVAL;
4747 }
4748 if ((options[0] & SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK))
4749 *edc_mode = EDC_MODE_LINEAR;
4750 else
4751 *edc_mode = EDC_MODE_LIMITING;
4752 }
4753 DP(NETIF_MSG_LINK, "EDC mode is set to 0x%x\n", *edc_mode);
4754 return 0;
4755 }
4756 /*
4757 * This function read the relevant field from the module (SFP+), and verify it
4758 * is compliant with this board
4759 */
4760 static u8 bnx2x_verify_sfp_module(struct bnx2x_phy *phy,
4761 struct link_params *params)
4762 {
4763 struct bnx2x *bp = params->bp;
4764 u32 val, cmd;
4765 u32 fw_resp, fw_cmd_param;
4766 char vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE+1];
4767 char vendor_pn[SFP_EEPROM_PART_NO_SIZE+1];
4768 phy->flags &= ~FLAGS_SFP_NOT_APPROVED;
4769 val = REG_RD(bp, params->shmem_base +
4770 offsetof(struct shmem_region, dev_info.
4771 port_feature_config[params->port].config));
4772 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
4773 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT) {
4774 DP(NETIF_MSG_LINK, "NOT enforcing module verification\n");
4775 return 0;
4776 }
4777
4778 if (params->feature_config_flags &
4779 FEATURE_CONFIG_BC_SUPPORTS_DUAL_PHY_OPT_MDL_VRFY) {
4780 /* Use specific phy request */
4781 cmd = DRV_MSG_CODE_VRFY_SPECIFIC_PHY_OPT_MDL;
4782 } else if (params->feature_config_flags &
4783 FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY) {
4784 /* Use first phy request only in case of non-dual media*/
4785 if (DUAL_MEDIA(params)) {
4786 DP(NETIF_MSG_LINK, "FW does not support OPT MDL "
4787 "verification\n");
4788 return -EINVAL;
4789 }
4790 cmd = DRV_MSG_CODE_VRFY_FIRST_PHY_OPT_MDL;
4791 } else {
4792 /* No support in OPT MDL detection */
4793 DP(NETIF_MSG_LINK, "FW does not support OPT MDL "
4794 "verification\n");
4795 return -EINVAL;
4796 }
4797
4798 fw_cmd_param = FW_PARAM_SET(phy->addr, phy->type, phy->mdio_ctrl);
4799 fw_resp = bnx2x_fw_command(bp, cmd, fw_cmd_param);
4800 if (fw_resp == FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS) {
4801 DP(NETIF_MSG_LINK, "Approved module\n");
4802 return 0;
4803 }
4804
4805 /* format the warning message */
4806 if (bnx2x_read_sfp_module_eeprom(phy,
4807 params,
4808 SFP_EEPROM_VENDOR_NAME_ADDR,
4809 SFP_EEPROM_VENDOR_NAME_SIZE,
4810 (u8 *)vendor_name))
4811 vendor_name[0] = '\0';
4812 else
4813 vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE] = '\0';
4814 if (bnx2x_read_sfp_module_eeprom(phy,
4815 params,
4816 SFP_EEPROM_PART_NO_ADDR,
4817 SFP_EEPROM_PART_NO_SIZE,
4818 (u8 *)vendor_pn))
4819 vendor_pn[0] = '\0';
4820 else
4821 vendor_pn[SFP_EEPROM_PART_NO_SIZE] = '\0';
4822
4823 netdev_err(bp->dev, "Warning: Unqualified SFP+ module detected,"
4824 " Port %d from %s part number %s\n",
4825 params->port, vendor_name, vendor_pn);
4826 phy->flags |= FLAGS_SFP_NOT_APPROVED;
4827 return -EINVAL;
4828 }
4829
4830 static u8 bnx2x_wait_for_sfp_module_initialized(struct bnx2x_phy *phy,
4831 struct link_params *params)
4832
4833 {
4834 u8 val;
4835 struct bnx2x *bp = params->bp;
4836 u16 timeout;
4837 /*
4838 * Initialization time after hot-plug may take up to 300ms for
4839 * some phys type ( e.g. JDSU )
4840 */
4841
4842 for (timeout = 0; timeout < 60; timeout++) {
4843 if (bnx2x_read_sfp_module_eeprom(phy, params, 1, 1, &val)
4844 == 0) {
4845 DP(NETIF_MSG_LINK, "SFP+ module initialization "
4846 "took %d ms\n", timeout * 5);
4847 return 0;
4848 }
4849 msleep(5);
4850 }
4851 return -EINVAL;
4852 }
4853
4854 static void bnx2x_8727_power_module(struct bnx2x *bp,
4855 struct bnx2x_phy *phy,
4856 u8 is_power_up) {
4857 /* Make sure GPIOs are not using for LED mode */
4858 u16 val;
4859 /*
4860 * In the GPIO register, bit 4 is use to determine if the GPIOs are
4861 * operating as INPUT or as OUTPUT. Bit 1 is for input, and 0 for
4862 * output
4863 * Bits 0-1 determine the gpios value for OUTPUT in case bit 4 val is 0
4864 * Bits 8-9 determine the gpios value for INPUT in case bit 4 val is 1
4865 * where the 1st bit is the over-current(only input), and 2nd bit is
4866 * for power( only output )
4867 *
4868 * In case of NOC feature is disabled and power is up, set GPIO control
4869 * as input to enable listening of over-current indication
4870 */
4871 if (phy->flags & FLAGS_NOC)
4872 return;
4873 if (!(phy->flags &
4874 FLAGS_NOC) && is_power_up)
4875 val = (1<<4);
4876 else
4877 /*
4878 * Set GPIO control to OUTPUT, and set the power bit
4879 * to according to the is_power_up
4880 */
4881 val = ((!(is_power_up)) << 1);
4882
4883 bnx2x_cl45_write(bp, phy,
4884 MDIO_PMA_DEVAD,
4885 MDIO_PMA_REG_8727_GPIO_CTRL,
4886 val);
4887 }
4888
4889 static u8 bnx2x_8726_set_limiting_mode(struct bnx2x *bp,
4890 struct bnx2x_phy *phy,
4891 u16 edc_mode)
4892 {
4893 u16 cur_limiting_mode;
4894
4895 bnx2x_cl45_read(bp, phy,
4896 MDIO_PMA_DEVAD,
4897 MDIO_PMA_REG_ROM_VER2,
4898 &cur_limiting_mode);
4899 DP(NETIF_MSG_LINK, "Current Limiting mode is 0x%x\n",
4900 cur_limiting_mode);
4901
4902 if (edc_mode == EDC_MODE_LIMITING) {
4903 DP(NETIF_MSG_LINK, "Setting LIMITING MODE\n");
4904 bnx2x_cl45_write(bp, phy,
4905 MDIO_PMA_DEVAD,
4906 MDIO_PMA_REG_ROM_VER2,
4907 EDC_MODE_LIMITING);
4908 } else { /* LRM mode ( default )*/
4909
4910 DP(NETIF_MSG_LINK, "Setting LRM MODE\n");
4911
4912 /*
4913 * Changing to LRM mode takes quite few seconds. So do it only
4914 * if current mode is limiting (default is LRM)
4915 */
4916 if (cur_limiting_mode != EDC_MODE_LIMITING)
4917 return 0;
4918
4919 bnx2x_cl45_write(bp, phy,
4920 MDIO_PMA_DEVAD,
4921 MDIO_PMA_REG_LRM_MODE,
4922 0);
4923 bnx2x_cl45_write(bp, phy,
4924 MDIO_PMA_DEVAD,
4925 MDIO_PMA_REG_ROM_VER2,
4926 0x128);
4927 bnx2x_cl45_write(bp, phy,
4928 MDIO_PMA_DEVAD,
4929 MDIO_PMA_REG_MISC_CTRL0,
4930 0x4008);
4931 bnx2x_cl45_write(bp, phy,
4932 MDIO_PMA_DEVAD,
4933 MDIO_PMA_REG_LRM_MODE,
4934 0xaaaa);
4935 }
4936 return 0;
4937 }
4938
4939 static u8 bnx2x_8727_set_limiting_mode(struct bnx2x *bp,
4940 struct bnx2x_phy *phy,
4941 u16 edc_mode)
4942 {
4943 u16 phy_identifier;
4944 u16 rom_ver2_val;
4945 bnx2x_cl45_read(bp, phy,
4946 MDIO_PMA_DEVAD,
4947 MDIO_PMA_REG_PHY_IDENTIFIER,
4948 &phy_identifier);
4949
4950 bnx2x_cl45_write(bp, phy,
4951 MDIO_PMA_DEVAD,
4952 MDIO_PMA_REG_PHY_IDENTIFIER,
4953 (phy_identifier & ~(1<<9)));
4954
4955 bnx2x_cl45_read(bp, phy,
4956 MDIO_PMA_DEVAD,
4957 MDIO_PMA_REG_ROM_VER2,
4958 &rom_ver2_val);
4959 /* Keep the MSB 8-bits, and set the LSB 8-bits with the edc_mode */
4960 bnx2x_cl45_write(bp, phy,
4961 MDIO_PMA_DEVAD,
4962 MDIO_PMA_REG_ROM_VER2,
4963 (rom_ver2_val & 0xff00) | (edc_mode & 0x00ff));
4964
4965 bnx2x_cl45_write(bp, phy,
4966 MDIO_PMA_DEVAD,
4967 MDIO_PMA_REG_PHY_IDENTIFIER,
4968 (phy_identifier | (1<<9)));
4969
4970 return 0;
4971 }
4972
4973 static void bnx2x_8727_specific_func(struct bnx2x_phy *phy,
4974 struct link_params *params,
4975 u32 action)
4976 {
4977 struct bnx2x *bp = params->bp;
4978
4979 switch (action) {
4980 case DISABLE_TX:
4981 bnx2x_sfp_set_transmitter(params, phy, 0);
4982 break;
4983 case ENABLE_TX:
4984 if (!(phy->flags & FLAGS_SFP_NOT_APPROVED))
4985 bnx2x_sfp_set_transmitter(params, phy, 1);
4986 break;
4987 default:
4988 DP(NETIF_MSG_LINK, "Function 0x%x not supported by 8727\n",
4989 action);
4990 return;
4991 }
4992 }
4993
4994 static void bnx2x_set_sfp_module_fault_led(struct link_params *params,
4995 u8 gpio_mode)
4996 {
4997 struct bnx2x *bp = params->bp;
4998
4999 u32 fault_led_gpio = REG_RD(bp, params->shmem_base +
5000 offsetof(struct shmem_region,
5001 dev_info.port_hw_config[params->port].sfp_ctrl)) &
5002 PORT_HW_CFG_FAULT_MODULE_LED_MASK;
5003 switch (fault_led_gpio) {
5004 case PORT_HW_CFG_FAULT_MODULE_LED_DISABLED:
5005 return;
5006 case PORT_HW_CFG_FAULT_MODULE_LED_GPIO0:
5007 case PORT_HW_CFG_FAULT_MODULE_LED_GPIO1:
5008 case PORT_HW_CFG_FAULT_MODULE_LED_GPIO2:
5009 case PORT_HW_CFG_FAULT_MODULE_LED_GPIO3:
5010 {
5011 u8 gpio_port = bnx2x_get_gpio_port(params);
5012 u16 gpio_pin = fault_led_gpio -
5013 PORT_HW_CFG_FAULT_MODULE_LED_GPIO0;
5014 DP(NETIF_MSG_LINK, "Set fault module-detected led "
5015 "pin %x port %x mode %x\n",
5016 gpio_pin, gpio_port, gpio_mode);
5017 bnx2x_set_gpio(bp, gpio_pin, gpio_mode, gpio_port);
5018 }
5019 break;
5020 default:
5021 DP(NETIF_MSG_LINK, "Error: Invalid fault led mode 0x%x\n",
5022 fault_led_gpio);
5023 }
5024 }
5025
5026 static u8 bnx2x_sfp_module_detection(struct bnx2x_phy *phy,
5027 struct link_params *params)
5028 {
5029 struct bnx2x *bp = params->bp;
5030 u16 edc_mode;
5031 u8 rc = 0;
5032
5033 u32 val = REG_RD(bp, params->shmem_base +
5034 offsetof(struct shmem_region, dev_info.
5035 port_feature_config[params->port].config));
5036
5037 DP(NETIF_MSG_LINK, "SFP+ module plugged in/out detected on port %d\n",
5038 params->port);
5039
5040 if (bnx2x_get_edc_mode(phy, params, &edc_mode) != 0) {
5041 DP(NETIF_MSG_LINK, "Failed to get valid module type\n");
5042 return -EINVAL;
5043 } else if (bnx2x_verify_sfp_module(phy, params) != 0) {
5044 /* check SFP+ module compatibility */
5045 DP(NETIF_MSG_LINK, "Module verification failed!!\n");
5046 rc = -EINVAL;
5047 /* Turn on fault module-detected led */
5048 bnx2x_set_sfp_module_fault_led(params,
5049 MISC_REGISTERS_GPIO_HIGH);
5050
5051 if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727) &&
5052 ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
5053 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN)) {
5054 /* Shutdown SFP+ module */
5055 DP(NETIF_MSG_LINK, "Shutdown SFP+ module!!\n");
5056 bnx2x_8727_power_module(bp, phy, 0);
5057 return rc;
5058 }
5059 } else {
5060 /* Turn off fault module-detected led */
5061 bnx2x_set_sfp_module_fault_led(params, MISC_REGISTERS_GPIO_LOW);
5062 }
5063
5064 /* power up the SFP module */
5065 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
5066 bnx2x_8727_power_module(bp, phy, 1);
5067
5068 /*
5069 * Check and set limiting mode / LRM mode on 8726. On 8727 it
5070 * is done automatically
5071 */
5072 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
5073 bnx2x_8726_set_limiting_mode(bp, phy, edc_mode);
5074 else
5075 bnx2x_8727_set_limiting_mode(bp, phy, edc_mode);
5076 /*
5077 * Enable transmit for this module if the module is approved, or
5078 * if unapproved modules should also enable the Tx laser
5079 */
5080 if (rc == 0 ||
5081 (val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) !=
5082 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
5083 bnx2x_sfp_set_transmitter(params, phy, 1);
5084 else
5085 bnx2x_sfp_set_transmitter(params, phy, 0);
5086
5087 return rc;
5088 }
5089
5090 void bnx2x_handle_module_detect_int(struct link_params *params)
5091 {
5092 struct bnx2x *bp = params->bp;
5093 struct bnx2x_phy *phy = &params->phy[EXT_PHY1];
5094 u32 gpio_val;
5095 u8 port = params->port;
5096
5097 /* Set valid module led off */
5098 bnx2x_set_sfp_module_fault_led(params, MISC_REGISTERS_GPIO_HIGH);
5099
5100 /* Get current gpio val reflecting module plugged in / out*/
5101 gpio_val = bnx2x_get_gpio(bp, MISC_REGISTERS_GPIO_3, port);
5102
5103 /* Call the handling function in case module is detected */
5104 if (gpio_val == 0) {
5105
5106 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
5107 MISC_REGISTERS_GPIO_INT_OUTPUT_CLR,
5108 port);
5109
5110 if (bnx2x_wait_for_sfp_module_initialized(phy, params) == 0)
5111 bnx2x_sfp_module_detection(phy, params);
5112 else
5113 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
5114 } else {
5115 u32 val = REG_RD(bp, params->shmem_base +
5116 offsetof(struct shmem_region, dev_info.
5117 port_feature_config[params->port].
5118 config));
5119
5120 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
5121 MISC_REGISTERS_GPIO_INT_OUTPUT_SET,
5122 port);
5123 /*
5124 * Module was plugged out.
5125 * Disable transmit for this module
5126 */
5127 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
5128 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
5129 bnx2x_sfp_set_transmitter(params, phy, 0);
5130 }
5131 }
5132
5133 /******************************************************************/
5134 /* common BCM8706/BCM8726 PHY SECTION */
5135 /******************************************************************/
5136 static u8 bnx2x_8706_8726_read_status(struct bnx2x_phy *phy,
5137 struct link_params *params,
5138 struct link_vars *vars)
5139 {
5140 u8 link_up = 0;
5141 u16 val1, val2, rx_sd, pcs_status;
5142 struct bnx2x *bp = params->bp;
5143 DP(NETIF_MSG_LINK, "XGXS 8706/8726\n");
5144 /* Clear RX Alarm*/
5145 bnx2x_cl45_read(bp, phy,
5146 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM, &val2);
5147 /* clear LASI indication*/
5148 bnx2x_cl45_read(bp, phy,
5149 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val1);
5150 bnx2x_cl45_read(bp, phy,
5151 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val2);
5152 DP(NETIF_MSG_LINK, "8706/8726 LASI status 0x%x--> 0x%x\n", val1, val2);
5153
5154 bnx2x_cl45_read(bp, phy,
5155 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
5156 bnx2x_cl45_read(bp, phy,
5157 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &pcs_status);
5158 bnx2x_cl45_read(bp, phy,
5159 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
5160 bnx2x_cl45_read(bp, phy,
5161 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
5162
5163 DP(NETIF_MSG_LINK, "8706/8726 rx_sd 0x%x pcs_status 0x%x 1Gbps"
5164 " link_status 0x%x\n", rx_sd, pcs_status, val2);
5165 /*
5166 * link is up if both bit 0 of pmd_rx_sd and bit 0 of pcs_status
5167 * are set, or if the autoneg bit 1 is set
5168 */
5169 link_up = ((rx_sd & pcs_status & 0x1) || (val2 & (1<<1)));
5170 if (link_up) {
5171 if (val2 & (1<<1))
5172 vars->line_speed = SPEED_1000;
5173 else
5174 vars->line_speed = SPEED_10000;
5175 bnx2x_ext_phy_resolve_fc(phy, params, vars);
5176 vars->duplex = DUPLEX_FULL;
5177 }
5178 return link_up;
5179 }
5180
5181 /******************************************************************/
5182 /* BCM8706 PHY SECTION */
5183 /******************************************************************/
5184 static u8 bnx2x_8706_config_init(struct bnx2x_phy *phy,
5185 struct link_params *params,
5186 struct link_vars *vars)
5187 {
5188 u32 tx_en_mode;
5189 u16 cnt, val, tmp1;
5190 struct bnx2x *bp = params->bp;
5191 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
5192 MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
5193 /* HW reset */
5194 bnx2x_ext_phy_hw_reset(bp, params->port);
5195 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0xa040);
5196 bnx2x_wait_reset_complete(bp, phy, params);
5197
5198 /* Wait until fw is loaded */
5199 for (cnt = 0; cnt < 100; cnt++) {
5200 bnx2x_cl45_read(bp, phy,
5201 MDIO_PMA_DEVAD, MDIO_PMA_REG_ROM_VER1, &val);
5202 if (val)
5203 break;
5204 msleep(10);
5205 }
5206 DP(NETIF_MSG_LINK, "XGXS 8706 is initialized after %d ms\n", cnt);
5207 if ((params->feature_config_flags &
5208 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
5209 u8 i;
5210 u16 reg;
5211 for (i = 0; i < 4; i++) {
5212 reg = MDIO_XS_8706_REG_BANK_RX0 +
5213 i*(MDIO_XS_8706_REG_BANK_RX1 -
5214 MDIO_XS_8706_REG_BANK_RX0);
5215 bnx2x_cl45_read(bp, phy, MDIO_XS_DEVAD, reg, &val);
5216 /* Clear first 3 bits of the control */
5217 val &= ~0x7;
5218 /* Set control bits according to configuration */
5219 val |= (phy->rx_preemphasis[i] & 0x7);
5220 DP(NETIF_MSG_LINK, "Setting RX Equalizer to BCM8706"
5221 " reg 0x%x <-- val 0x%x\n", reg, val);
5222 bnx2x_cl45_write(bp, phy, MDIO_XS_DEVAD, reg, val);
5223 }
5224 }
5225 /* Force speed */
5226 if (phy->req_line_speed == SPEED_10000) {
5227 DP(NETIF_MSG_LINK, "XGXS 8706 force 10Gbps\n");
5228
5229 bnx2x_cl45_write(bp, phy,
5230 MDIO_PMA_DEVAD,
5231 MDIO_PMA_REG_DIGITAL_CTRL, 0x400);
5232 bnx2x_cl45_write(bp, phy,
5233 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 1);
5234 } else {
5235 /* Force 1Gbps using autoneg with 1G advertisement */
5236
5237 /* Allow CL37 through CL73 */
5238 DP(NETIF_MSG_LINK, "XGXS 8706 AutoNeg\n");
5239 bnx2x_cl45_write(bp, phy,
5240 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_CL73, 0x040c);
5241
5242 /* Enable Full-Duplex advertisement on CL37 */
5243 bnx2x_cl45_write(bp, phy,
5244 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LP, 0x0020);
5245 /* Enable CL37 AN */
5246 bnx2x_cl45_write(bp, phy,
5247 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_AN, 0x1000);
5248 /* 1G support */
5249 bnx2x_cl45_write(bp, phy,
5250 MDIO_AN_DEVAD, MDIO_AN_REG_ADV, (1<<5));
5251
5252 /* Enable clause 73 AN */
5253 bnx2x_cl45_write(bp, phy,
5254 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x1200);
5255 bnx2x_cl45_write(bp, phy,
5256 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL,
5257 0x0400);
5258 bnx2x_cl45_write(bp, phy,
5259 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL,
5260 0x0004);
5261 }
5262 bnx2x_save_bcm_spirom_ver(bp, phy, params->port);
5263
5264 /*
5265 * If TX Laser is controlled by GPIO_0, do not let PHY go into low
5266 * power mode, if TX Laser is disabled
5267 */
5268
5269 tx_en_mode = REG_RD(bp, params->shmem_base +
5270 offsetof(struct shmem_region,
5271 dev_info.port_hw_config[params->port].sfp_ctrl))
5272 & PORT_HW_CFG_TX_LASER_MASK;
5273
5274 if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
5275 DP(NETIF_MSG_LINK, "Enabling TXONOFF_PWRDN_DIS\n");
5276 bnx2x_cl45_read(bp, phy,
5277 MDIO_PMA_DEVAD, MDIO_PMA_REG_DIGITAL_CTRL, &tmp1);
5278 tmp1 |= 0x1;
5279 bnx2x_cl45_write(bp, phy,
5280 MDIO_PMA_DEVAD, MDIO_PMA_REG_DIGITAL_CTRL, tmp1);
5281 }
5282
5283 return 0;
5284 }
5285
5286 static u8 bnx2x_8706_read_status(struct bnx2x_phy *phy,
5287 struct link_params *params,
5288 struct link_vars *vars)
5289 {
5290 return bnx2x_8706_8726_read_status(phy, params, vars);
5291 }
5292
5293 /******************************************************************/
5294 /* BCM8726 PHY SECTION */
5295 /******************************************************************/
5296 static void bnx2x_8726_config_loopback(struct bnx2x_phy *phy,
5297 struct link_params *params)
5298 {
5299 struct bnx2x *bp = params->bp;
5300 DP(NETIF_MSG_LINK, "PMA/PMD ext_phy_loopback: 8726\n");
5301 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x0001);
5302 }
5303
5304 static void bnx2x_8726_external_rom_boot(struct bnx2x_phy *phy,
5305 struct link_params *params)
5306 {
5307 struct bnx2x *bp = params->bp;
5308 /* Need to wait 100ms after reset */
5309 msleep(100);
5310
5311 /* Micro controller re-boot */
5312 bnx2x_cl45_write(bp, phy,
5313 MDIO_PMA_DEVAD, MDIO_PMA_REG_GEN_CTRL, 0x018B);
5314
5315 /* Set soft reset */
5316 bnx2x_cl45_write(bp, phy,
5317 MDIO_PMA_DEVAD,
5318 MDIO_PMA_REG_GEN_CTRL,
5319 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
5320
5321 bnx2x_cl45_write(bp, phy,
5322 MDIO_PMA_DEVAD,
5323 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
5324
5325 bnx2x_cl45_write(bp, phy,
5326 MDIO_PMA_DEVAD,
5327 MDIO_PMA_REG_GEN_CTRL,
5328 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
5329
5330 /* wait for 150ms for microcode load */
5331 msleep(150);
5332
5333 /* Disable serial boot control, tristates pins SS_N, SCK, MOSI, MISO */
5334 bnx2x_cl45_write(bp, phy,
5335 MDIO_PMA_DEVAD,
5336 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
5337
5338 msleep(200);
5339 bnx2x_save_bcm_spirom_ver(bp, phy, params->port);
5340 }
5341
5342 static u8 bnx2x_8726_read_status(struct bnx2x_phy *phy,
5343 struct link_params *params,
5344 struct link_vars *vars)
5345 {
5346 struct bnx2x *bp = params->bp;
5347 u16 val1;
5348 u8 link_up = bnx2x_8706_8726_read_status(phy, params, vars);
5349 if (link_up) {
5350 bnx2x_cl45_read(bp, phy,
5351 MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER,
5352 &val1);
5353 if (val1 & (1<<15)) {
5354 DP(NETIF_MSG_LINK, "Tx is disabled\n");
5355 link_up = 0;
5356 vars->line_speed = 0;
5357 }
5358 }
5359 return link_up;
5360 }
5361
5362
5363 static u8 bnx2x_8726_config_init(struct bnx2x_phy *phy,
5364 struct link_params *params,
5365 struct link_vars *vars)
5366 {
5367 struct bnx2x *bp = params->bp;
5368 u32 val;
5369 u32 swap_val, swap_override, aeu_gpio_mask, offset;
5370 DP(NETIF_MSG_LINK, "Initializing BCM8726\n");
5371
5372 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1<<15);
5373 bnx2x_wait_reset_complete(bp, phy, params);
5374
5375 bnx2x_8726_external_rom_boot(phy, params);
5376
5377 /*
5378 * Need to call module detected on initialization since the module
5379 * detection triggered by actual module insertion might occur before
5380 * driver is loaded, and when driver is loaded, it reset all
5381 * registers, including the transmitter
5382 */
5383 bnx2x_sfp_module_detection(phy, params);
5384
5385 if (phy->req_line_speed == SPEED_1000) {
5386 DP(NETIF_MSG_LINK, "Setting 1G force\n");
5387 bnx2x_cl45_write(bp, phy,
5388 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
5389 bnx2x_cl45_write(bp, phy,
5390 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, 0xD);
5391 bnx2x_cl45_write(bp, phy,
5392 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0x5);
5393 bnx2x_cl45_write(bp, phy,
5394 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL,
5395 0x400);
5396 } else if ((phy->req_line_speed == SPEED_AUTO_NEG) &&
5397 (phy->speed_cap_mask &
5398 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G) &&
5399 ((phy->speed_cap_mask &
5400 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
5401 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
5402 DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
5403 /* Set Flow control */
5404 bnx2x_ext_phy_set_pause(params, phy, vars);
5405 bnx2x_cl45_write(bp, phy,
5406 MDIO_AN_DEVAD, MDIO_AN_REG_ADV, 0x20);
5407 bnx2x_cl45_write(bp, phy,
5408 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_CL73, 0x040c);
5409 bnx2x_cl45_write(bp, phy,
5410 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, 0x0020);
5411 bnx2x_cl45_write(bp, phy,
5412 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_AN, 0x1000);
5413 bnx2x_cl45_write(bp, phy,
5414 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x1200);
5415 /*
5416 * Enable RX-ALARM control to receive interrupt for 1G speed
5417 * change
5418 */
5419 bnx2x_cl45_write(bp, phy,
5420 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0x4);
5421 bnx2x_cl45_write(bp, phy,
5422 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL,
5423 0x400);
5424
5425 } else { /* Default 10G. Set only LASI control */
5426 bnx2x_cl45_write(bp, phy,
5427 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 1);
5428 }
5429
5430 /* Set TX PreEmphasis if needed */
5431 if ((params->feature_config_flags &
5432 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
5433 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x,"
5434 "TX_CTRL2 0x%x\n",
5435 phy->tx_preemphasis[0],
5436 phy->tx_preemphasis[1]);
5437 bnx2x_cl45_write(bp, phy,
5438 MDIO_PMA_DEVAD,
5439 MDIO_PMA_REG_8726_TX_CTRL1,
5440 phy->tx_preemphasis[0]);
5441
5442 bnx2x_cl45_write(bp, phy,
5443 MDIO_PMA_DEVAD,
5444 MDIO_PMA_REG_8726_TX_CTRL2,
5445 phy->tx_preemphasis[1]);
5446 }
5447
5448 /* Set GPIO3 to trigger SFP+ module insertion/removal */
5449 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_3,
5450 MISC_REGISTERS_GPIO_INPUT_HI_Z, params->port);
5451
5452 /* The GPIO should be swapped if the swap register is set and active */
5453 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
5454 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
5455
5456 /* Select function upon port-swap configuration */
5457 if (params->port == 0) {
5458 offset = MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0;
5459 aeu_gpio_mask = (swap_val && swap_override) ?
5460 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1 :
5461 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0;
5462 } else {
5463 offset = MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0;
5464 aeu_gpio_mask = (swap_val && swap_override) ?
5465 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 :
5466 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1;
5467 }
5468 val = REG_RD(bp, offset);
5469 /* add GPIO3 to group */
5470 val |= aeu_gpio_mask;
5471 REG_WR(bp, offset, val);
5472 return 0;
5473
5474 }
5475
5476 static void bnx2x_8726_link_reset(struct bnx2x_phy *phy,
5477 struct link_params *params)
5478 {
5479 struct bnx2x *bp = params->bp;
5480 DP(NETIF_MSG_LINK, "bnx2x_8726_link_reset port %d\n", params->port);
5481 /* Set serial boot control for external load */
5482 bnx2x_cl45_write(bp, phy,
5483 MDIO_PMA_DEVAD,
5484 MDIO_PMA_REG_GEN_CTRL, 0x0001);
5485 }
5486
5487 /******************************************************************/
5488 /* BCM8727 PHY SECTION */
5489 /******************************************************************/
5490
5491 static void bnx2x_8727_set_link_led(struct bnx2x_phy *phy,
5492 struct link_params *params, u8 mode)
5493 {
5494 struct bnx2x *bp = params->bp;
5495 u16 led_mode_bitmask = 0;
5496 u16 gpio_pins_bitmask = 0;
5497 u16 val;
5498 /* Only NOC flavor requires to set the LED specifically */
5499 if (!(phy->flags & FLAGS_NOC))
5500 return;
5501 switch (mode) {
5502 case LED_MODE_FRONT_PANEL_OFF:
5503 case LED_MODE_OFF:
5504 led_mode_bitmask = 0;
5505 gpio_pins_bitmask = 0x03;
5506 break;
5507 case LED_MODE_ON:
5508 led_mode_bitmask = 0;
5509 gpio_pins_bitmask = 0x02;
5510 break;
5511 case LED_MODE_OPER:
5512 led_mode_bitmask = 0x60;
5513 gpio_pins_bitmask = 0x11;
5514 break;
5515 }
5516 bnx2x_cl45_read(bp, phy,
5517 MDIO_PMA_DEVAD,
5518 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
5519 &val);
5520 val &= 0xff8f;
5521 val |= led_mode_bitmask;
5522 bnx2x_cl45_write(bp, phy,
5523 MDIO_PMA_DEVAD,
5524 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
5525 val);
5526 bnx2x_cl45_read(bp, phy,
5527 MDIO_PMA_DEVAD,
5528 MDIO_PMA_REG_8727_GPIO_CTRL,
5529 &val);
5530 val &= 0xffe0;
5531 val |= gpio_pins_bitmask;
5532 bnx2x_cl45_write(bp, phy,
5533 MDIO_PMA_DEVAD,
5534 MDIO_PMA_REG_8727_GPIO_CTRL,
5535 val);
5536 }
5537 static void bnx2x_8727_hw_reset(struct bnx2x_phy *phy,
5538 struct link_params *params) {
5539 u32 swap_val, swap_override;
5540 u8 port;
5541 /*
5542 * The PHY reset is controlled by GPIO 1. Fake the port number
5543 * to cancel the swap done in set_gpio()
5544 */
5545 struct bnx2x *bp = params->bp;
5546 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
5547 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
5548 port = (swap_val && swap_override) ^ 1;
5549 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
5550 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
5551 }
5552
5553 static u8 bnx2x_8727_config_init(struct bnx2x_phy *phy,
5554 struct link_params *params,
5555 struct link_vars *vars)
5556 {
5557 u32 tx_en_mode;
5558 u16 tmp1, val, mod_abs, tmp2;
5559 u16 rx_alarm_ctrl_val;
5560 u16 lasi_ctrl_val;
5561 struct bnx2x *bp = params->bp;
5562 /* Enable PMD link, MOD_ABS_FLT, and 1G link alarm */
5563
5564 bnx2x_wait_reset_complete(bp, phy, params);
5565 rx_alarm_ctrl_val = (1<<2) | (1<<5) ;
5566 lasi_ctrl_val = 0x0004;
5567
5568 DP(NETIF_MSG_LINK, "Initializing BCM8727\n");
5569 /* enable LASI */
5570 bnx2x_cl45_write(bp, phy,
5571 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL,
5572 rx_alarm_ctrl_val);
5573
5574 bnx2x_cl45_write(bp, phy,
5575 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, lasi_ctrl_val);
5576
5577 /*
5578 * Initially configure MOD_ABS to interrupt when module is
5579 * presence( bit 8)
5580 */
5581 bnx2x_cl45_read(bp, phy,
5582 MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
5583 /*
5584 * Set EDC off by setting OPTXLOS signal input to low (bit 9).
5585 * When the EDC is off it locks onto a reference clock and avoids
5586 * becoming 'lost'
5587 */
5588 mod_abs &= ~(1<<8);
5589 if (!(phy->flags & FLAGS_NOC))
5590 mod_abs &= ~(1<<9);
5591 bnx2x_cl45_write(bp, phy,
5592 MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
5593
5594
5595 /* Make MOD_ABS give interrupt on change */
5596 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_PCS_OPT_CTRL,
5597 &val);
5598 val |= (1<<12);
5599 if (phy->flags & FLAGS_NOC)
5600 val |= (3<<5);
5601
5602 /*
5603 * Set 8727 GPIOs to input to allow reading from the 8727 GPIO0
5604 * status which reflect SFP+ module over-current
5605 */
5606 if (!(phy->flags & FLAGS_NOC))
5607 val &= 0xff8f; /* Reset bits 4-6 */
5608 bnx2x_cl45_write(bp, phy,
5609 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_PCS_OPT_CTRL, val);
5610
5611 bnx2x_8727_power_module(bp, phy, 1);
5612
5613 bnx2x_cl45_read(bp, phy,
5614 MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &tmp1);
5615
5616 bnx2x_cl45_read(bp, phy,
5617 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM, &tmp1);
5618
5619 /* Set option 1G speed */
5620 if (phy->req_line_speed == SPEED_1000) {
5621 DP(NETIF_MSG_LINK, "Setting 1G force\n");
5622 bnx2x_cl45_write(bp, phy,
5623 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
5624 bnx2x_cl45_write(bp, phy,
5625 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, 0xD);
5626 bnx2x_cl45_read(bp, phy,
5627 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, &tmp1);
5628 DP(NETIF_MSG_LINK, "1.7 = 0x%x\n", tmp1);
5629 /*
5630 * Power down the XAUI until link is up in case of dual-media
5631 * and 1G
5632 */
5633 if (DUAL_MEDIA(params)) {
5634 bnx2x_cl45_read(bp, phy,
5635 MDIO_PMA_DEVAD,
5636 MDIO_PMA_REG_8727_PCS_GP, &val);
5637 val |= (3<<10);
5638 bnx2x_cl45_write(bp, phy,
5639 MDIO_PMA_DEVAD,
5640 MDIO_PMA_REG_8727_PCS_GP, val);
5641 }
5642 } else if ((phy->req_line_speed == SPEED_AUTO_NEG) &&
5643 ((phy->speed_cap_mask &
5644 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) &&
5645 ((phy->speed_cap_mask &
5646 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
5647 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
5648
5649 DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
5650 bnx2x_cl45_write(bp, phy,
5651 MDIO_AN_DEVAD, MDIO_AN_REG_8727_MISC_CTRL, 0);
5652 bnx2x_cl45_write(bp, phy,
5653 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_AN, 0x1300);
5654 } else {
5655 /*
5656 * Since the 8727 has only single reset pin, need to set the 10G
5657 * registers although it is default
5658 */
5659 bnx2x_cl45_write(bp, phy,
5660 MDIO_AN_DEVAD, MDIO_AN_REG_8727_MISC_CTRL,
5661 0x0020);
5662 bnx2x_cl45_write(bp, phy,
5663 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_AN, 0x0100);
5664 bnx2x_cl45_write(bp, phy,
5665 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x2040);
5666 bnx2x_cl45_write(bp, phy,
5667 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2,
5668 0x0008);
5669 }
5670
5671 /*
5672 * Set 2-wire transfer rate of SFP+ module EEPROM
5673 * to 100Khz since some DACs(direct attached cables) do
5674 * not work at 400Khz.
5675 */
5676 bnx2x_cl45_write(bp, phy,
5677 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_TWO_WIRE_SLAVE_ADDR,
5678 0xa001);
5679
5680 /* Set TX PreEmphasis if needed */
5681 if ((params->feature_config_flags &
5682 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
5683 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x\n",
5684 phy->tx_preemphasis[0],
5685 phy->tx_preemphasis[1]);
5686 bnx2x_cl45_write(bp, phy,
5687 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_TX_CTRL1,
5688 phy->tx_preemphasis[0]);
5689
5690 bnx2x_cl45_write(bp, phy,
5691 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_TX_CTRL2,
5692 phy->tx_preemphasis[1]);
5693 }
5694
5695 /*
5696 * If TX Laser is controlled by GPIO_0, do not let PHY go into low
5697 * power mode, if TX Laser is disabled
5698 */
5699 tx_en_mode = REG_RD(bp, params->shmem_base +
5700 offsetof(struct shmem_region,
5701 dev_info.port_hw_config[params->port].sfp_ctrl))
5702 & PORT_HW_CFG_TX_LASER_MASK;
5703
5704 if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
5705
5706 DP(NETIF_MSG_LINK, "Enabling TXONOFF_PWRDN_DIS\n");
5707 bnx2x_cl45_read(bp, phy,
5708 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_OPT_CFG_REG, &tmp2);
5709 tmp2 |= 0x1000;
5710 tmp2 &= 0xFFEF;
5711 bnx2x_cl45_write(bp, phy,
5712 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_OPT_CFG_REG, tmp2);
5713 }
5714
5715 return 0;
5716 }
5717
5718 static void bnx2x_8727_handle_mod_abs(struct bnx2x_phy *phy,
5719 struct link_params *params)
5720 {
5721 struct bnx2x *bp = params->bp;
5722 u16 mod_abs, rx_alarm_status;
5723 u32 val = REG_RD(bp, params->shmem_base +
5724 offsetof(struct shmem_region, dev_info.
5725 port_feature_config[params->port].
5726 config));
5727 bnx2x_cl45_read(bp, phy,
5728 MDIO_PMA_DEVAD,
5729 MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
5730 if (mod_abs & (1<<8)) {
5731
5732 /* Module is absent */
5733 DP(NETIF_MSG_LINK, "MOD_ABS indication "
5734 "show module is absent\n");
5735
5736 /*
5737 * 1. Set mod_abs to detect next module
5738 * presence event
5739 * 2. Set EDC off by setting OPTXLOS signal input to low
5740 * (bit 9).
5741 * When the EDC is off it locks onto a reference clock and
5742 * avoids becoming 'lost'.
5743 */
5744 mod_abs &= ~(1<<8);
5745 if (!(phy->flags & FLAGS_NOC))
5746 mod_abs &= ~(1<<9);
5747 bnx2x_cl45_write(bp, phy,
5748 MDIO_PMA_DEVAD,
5749 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
5750
5751 /*
5752 * Clear RX alarm since it stays up as long as
5753 * the mod_abs wasn't changed
5754 */
5755 bnx2x_cl45_read(bp, phy,
5756 MDIO_PMA_DEVAD,
5757 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
5758
5759 } else {
5760 /* Module is present */
5761 DP(NETIF_MSG_LINK, "MOD_ABS indication "
5762 "show module is present\n");
5763 /*
5764 * First disable transmitter, and if the module is ok, the
5765 * module_detection will enable it
5766 * 1. Set mod_abs to detect next module absent event ( bit 8)
5767 * 2. Restore the default polarity of the OPRXLOS signal and
5768 * this signal will then correctly indicate the presence or
5769 * absence of the Rx signal. (bit 9)
5770 */
5771 mod_abs |= (1<<8);
5772 if (!(phy->flags & FLAGS_NOC))
5773 mod_abs |= (1<<9);
5774 bnx2x_cl45_write(bp, phy,
5775 MDIO_PMA_DEVAD,
5776 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
5777
5778 /*
5779 * Clear RX alarm since it stays up as long as the mod_abs
5780 * wasn't changed. This is need to be done before calling the
5781 * module detection, otherwise it will clear* the link update
5782 * alarm
5783 */
5784 bnx2x_cl45_read(bp, phy,
5785 MDIO_PMA_DEVAD,
5786 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
5787
5788
5789 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
5790 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
5791 bnx2x_sfp_set_transmitter(params, phy, 0);
5792
5793 if (bnx2x_wait_for_sfp_module_initialized(phy, params) == 0)
5794 bnx2x_sfp_module_detection(phy, params);
5795 else
5796 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
5797 }
5798
5799 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n",
5800 rx_alarm_status);
5801 /* No need to check link status in case of module plugged in/out */
5802 }
5803
5804 static u8 bnx2x_8727_read_status(struct bnx2x_phy *phy,
5805 struct link_params *params,
5806 struct link_vars *vars)
5807
5808 {
5809 struct bnx2x *bp = params->bp;
5810 u8 link_up = 0;
5811 u16 link_status = 0;
5812 u16 rx_alarm_status, lasi_ctrl, val1;
5813
5814 /* If PHY is not initialized, do not check link status */
5815 bnx2x_cl45_read(bp, phy,
5816 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL,
5817 &lasi_ctrl);
5818 if (!lasi_ctrl)
5819 return 0;
5820
5821 /* Check the LASI */
5822 bnx2x_cl45_read(bp, phy,
5823 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM,
5824 &rx_alarm_status);
5825 vars->line_speed = 0;
5826 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n", rx_alarm_status);
5827
5828 bnx2x_cl45_read(bp, phy,
5829 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val1);
5830
5831 DP(NETIF_MSG_LINK, "8727 LASI status 0x%x\n", val1);
5832
5833 /* Clear MSG-OUT */
5834 bnx2x_cl45_read(bp, phy,
5835 MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &val1);
5836
5837 /*
5838 * If a module is present and there is need to check
5839 * for over current
5840 */
5841 if (!(phy->flags & FLAGS_NOC) && !(rx_alarm_status & (1<<5))) {
5842 /* Check over-current using 8727 GPIO0 input*/
5843 bnx2x_cl45_read(bp, phy,
5844 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_GPIO_CTRL,
5845 &val1);
5846
5847 if ((val1 & (1<<8)) == 0) {
5848 DP(NETIF_MSG_LINK, "8727 Power fault has been detected"
5849 " on port %d\n", params->port);
5850 netdev_err(bp->dev, "Error: Power fault on Port %d has"
5851 " been detected and the power to "
5852 "that SFP+ module has been removed"
5853 " to prevent failure of the card."
5854 " Please remove the SFP+ module and"
5855 " restart the system to clear this"
5856 " error.\n",
5857 params->port);
5858 /* Disable all RX_ALARMs except for mod_abs */
5859 bnx2x_cl45_write(bp, phy,
5860 MDIO_PMA_DEVAD,
5861 MDIO_PMA_REG_RX_ALARM_CTRL, (1<<5));
5862
5863 bnx2x_cl45_read(bp, phy,
5864 MDIO_PMA_DEVAD,
5865 MDIO_PMA_REG_PHY_IDENTIFIER, &val1);
5866 /* Wait for module_absent_event */
5867 val1 |= (1<<8);
5868 bnx2x_cl45_write(bp, phy,
5869 MDIO_PMA_DEVAD,
5870 MDIO_PMA_REG_PHY_IDENTIFIER, val1);
5871 /* Clear RX alarm */
5872 bnx2x_cl45_read(bp, phy,
5873 MDIO_PMA_DEVAD,
5874 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
5875 return 0;
5876 }
5877 } /* Over current check */
5878
5879 /* When module absent bit is set, check module */
5880 if (rx_alarm_status & (1<<5)) {
5881 bnx2x_8727_handle_mod_abs(phy, params);
5882 /* Enable all mod_abs and link detection bits */
5883 bnx2x_cl45_write(bp, phy,
5884 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM_CTRL,
5885 ((1<<5) | (1<<2)));
5886 }
5887 DP(NETIF_MSG_LINK, "Enabling 8727 TX laser if SFP is approved\n");
5888 bnx2x_8727_specific_func(phy, params, ENABLE_TX);
5889 /* If transmitter is disabled, ignore false link up indication */
5890 bnx2x_cl45_read(bp, phy,
5891 MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER, &val1);
5892 if (val1 & (1<<15)) {
5893 DP(NETIF_MSG_LINK, "Tx is disabled\n");
5894 return 0;
5895 }
5896
5897 bnx2x_cl45_read(bp, phy,
5898 MDIO_PMA_DEVAD,
5899 MDIO_PMA_REG_8073_SPEED_LINK_STATUS, &link_status);
5900
5901 /*
5902 * Bits 0..2 --> speed detected,
5903 * Bits 13..15--> link is down
5904 */
5905 if ((link_status & (1<<2)) && (!(link_status & (1<<15)))) {
5906 link_up = 1;
5907 vars->line_speed = SPEED_10000;
5908 DP(NETIF_MSG_LINK, "port %x: External link up in 10G\n",
5909 params->port);
5910 } else if ((link_status & (1<<0)) && (!(link_status & (1<<13)))) {
5911 link_up = 1;
5912 vars->line_speed = SPEED_1000;
5913 DP(NETIF_MSG_LINK, "port %x: External link up in 1G\n",
5914 params->port);
5915 } else {
5916 link_up = 0;
5917 DP(NETIF_MSG_LINK, "port %x: External link is down\n",
5918 params->port);
5919 }
5920 if (link_up) {
5921 bnx2x_ext_phy_resolve_fc(phy, params, vars);
5922 vars->duplex = DUPLEX_FULL;
5923 DP(NETIF_MSG_LINK, "duplex = 0x%x\n", vars->duplex);
5924 }
5925
5926 if ((DUAL_MEDIA(params)) &&
5927 (phy->req_line_speed == SPEED_1000)) {
5928 bnx2x_cl45_read(bp, phy,
5929 MDIO_PMA_DEVAD,
5930 MDIO_PMA_REG_8727_PCS_GP, &val1);
5931 /*
5932 * In case of dual-media board and 1G, power up the XAUI side,
5933 * otherwise power it down. For 10G it is done automatically
5934 */
5935 if (link_up)
5936 val1 &= ~(3<<10);
5937 else
5938 val1 |= (3<<10);
5939 bnx2x_cl45_write(bp, phy,
5940 MDIO_PMA_DEVAD,
5941 MDIO_PMA_REG_8727_PCS_GP, val1);
5942 }
5943 return link_up;
5944 }
5945
5946 static void bnx2x_8727_link_reset(struct bnx2x_phy *phy,
5947 struct link_params *params)
5948 {
5949 struct bnx2x *bp = params->bp;
5950 /* Disable Transmitter */
5951 bnx2x_sfp_set_transmitter(params, phy, 0);
5952 /* Clear LASI */
5953 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0);
5954
5955 }
5956
5957 /******************************************************************/
5958 /* BCM8481/BCM84823/BCM84833 PHY SECTION */
5959 /******************************************************************/
5960 static void bnx2x_save_848xx_spirom_version(struct bnx2x_phy *phy,
5961 struct link_params *params)
5962 {
5963 u16 val, fw_ver1, fw_ver2, cnt, adj;
5964 struct bnx2x *bp = params->bp;
5965
5966 adj = 0;
5967 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833)
5968 adj = -1;
5969
5970 /* For the 32 bits registers in 848xx, access via MDIO2ARM interface.*/
5971 /* (1) set register 0xc200_0014(SPI_BRIDGE_CTRL_2) to 0x03000000 */
5972 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA819 + adj, 0x0014);
5973 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA81A + adj, 0xc200);
5974 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA81B + adj, 0x0000);
5975 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA81C + adj, 0x0300);
5976 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA817 + adj, 0x0009);
5977
5978 for (cnt = 0; cnt < 100; cnt++) {
5979 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD, 0xA818 + adj, &val);
5980 if (val & 1)
5981 break;
5982 udelay(5);
5983 }
5984 if (cnt == 100) {
5985 DP(NETIF_MSG_LINK, "Unable to read 848xx phy fw version(1)\n");
5986 bnx2x_save_spirom_version(bp, params->port, 0,
5987 phy->ver_addr);
5988 return;
5989 }
5990
5991
5992 /* 2) read register 0xc200_0000 (SPI_FW_STATUS) */
5993 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA819 + adj, 0x0000);
5994 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA81A + adj, 0xc200);
5995 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, 0xA817 + adj, 0x000A);
5996 for (cnt = 0; cnt < 100; cnt++) {
5997 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD, 0xA818 + adj, &val);
5998 if (val & 1)
5999 break;
6000 udelay(5);
6001 }
6002 if (cnt == 100) {
6003 DP(NETIF_MSG_LINK, "Unable to read 848xx phy fw version(2)\n");
6004 bnx2x_save_spirom_version(bp, params->port, 0,
6005 phy->ver_addr);
6006 return;
6007 }
6008
6009 /* lower 16 bits of the register SPI_FW_STATUS */
6010 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD, 0xA81B + adj, &fw_ver1);
6011 /* upper 16 bits of register SPI_FW_STATUS */
6012 bnx2x_cl45_read(bp, phy, MDIO_PMA_DEVAD, 0xA81C + adj, &fw_ver2);
6013
6014 bnx2x_save_spirom_version(bp, params->port, (fw_ver2<<16) | fw_ver1,
6015 phy->ver_addr);
6016 }
6017
6018 static void bnx2x_848xx_set_led(struct bnx2x *bp,
6019 struct bnx2x_phy *phy)
6020 {
6021 u16 val, adj;
6022
6023 adj = 0;
6024 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833)
6025 adj = -1;
6026
6027 /* PHYC_CTL_LED_CTL */
6028 bnx2x_cl45_read(bp, phy,
6029 MDIO_PMA_DEVAD,
6030 MDIO_PMA_REG_8481_LINK_SIGNAL + adj, &val);
6031 val &= 0xFE00;
6032 val |= 0x0092;
6033
6034 bnx2x_cl45_write(bp, phy,
6035 MDIO_PMA_DEVAD,
6036 MDIO_PMA_REG_8481_LINK_SIGNAL + adj, val);
6037
6038 bnx2x_cl45_write(bp, phy,
6039 MDIO_PMA_DEVAD,
6040 MDIO_PMA_REG_8481_LED1_MASK + adj,
6041 0x80);
6042
6043 bnx2x_cl45_write(bp, phy,
6044 MDIO_PMA_DEVAD,
6045 MDIO_PMA_REG_8481_LED2_MASK + adj,
6046 0x18);
6047
6048 /* Select activity source by Tx and Rx, as suggested by PHY AE */
6049 bnx2x_cl45_write(bp, phy,
6050 MDIO_PMA_DEVAD,
6051 MDIO_PMA_REG_8481_LED3_MASK + adj,
6052 0x0006);
6053
6054 /* Select the closest activity blink rate to that in 10/100/1000 */
6055 bnx2x_cl45_write(bp, phy,
6056 MDIO_PMA_DEVAD,
6057 MDIO_PMA_REG_8481_LED3_BLINK + adj,
6058 0);
6059
6060 bnx2x_cl45_read(bp, phy,
6061 MDIO_PMA_DEVAD,
6062 MDIO_PMA_REG_84823_CTL_LED_CTL_1 + adj, &val);
6063 val |= MDIO_PMA_REG_84823_LED3_STRETCH_EN; /* stretch_en for LED3*/
6064
6065 bnx2x_cl45_write(bp, phy,
6066 MDIO_PMA_DEVAD,
6067 MDIO_PMA_REG_84823_CTL_LED_CTL_1 + adj, val);
6068
6069 /* 'Interrupt Mask' */
6070 bnx2x_cl45_write(bp, phy,
6071 MDIO_AN_DEVAD,
6072 0xFFFB, 0xFFFD);
6073 }
6074
6075 static u8 bnx2x_848xx_cmn_config_init(struct bnx2x_phy *phy,
6076 struct link_params *params,
6077 struct link_vars *vars)
6078 {
6079 struct bnx2x *bp = params->bp;
6080 u16 autoneg_val, an_1000_val, an_10_100_val;
6081 /*
6082 * This phy uses the NIG latch mechanism since link indication
6083 * arrives through its LED4 and not via its LASI signal, so we
6084 * get steady signal instead of clear on read
6085 */
6086 bnx2x_bits_en(bp, NIG_REG_LATCH_BC_0 + params->port*4,
6087 1 << NIG_LATCH_BC_ENABLE_MI_INT);
6088
6089 bnx2x_cl45_write(bp, phy,
6090 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x0000);
6091
6092 bnx2x_848xx_set_led(bp, phy);
6093
6094 /* set 1000 speed advertisement */
6095 bnx2x_cl45_read(bp, phy,
6096 MDIO_AN_DEVAD, MDIO_AN_REG_8481_1000T_CTRL,
6097 &an_1000_val);
6098
6099 bnx2x_ext_phy_set_pause(params, phy, vars);
6100 bnx2x_cl45_read(bp, phy,
6101 MDIO_AN_DEVAD,
6102 MDIO_AN_REG_8481_LEGACY_AN_ADV,
6103 &an_10_100_val);
6104 bnx2x_cl45_read(bp, phy,
6105 MDIO_AN_DEVAD, MDIO_AN_REG_8481_LEGACY_MII_CTRL,
6106 &autoneg_val);
6107 /* Disable forced speed */
6108 autoneg_val &= ~((1<<6) | (1<<8) | (1<<9) | (1<<12) | (1<<13));
6109 an_10_100_val &= ~((1<<5) | (1<<6) | (1<<7) | (1<<8));
6110
6111 if (((phy->req_line_speed == SPEED_AUTO_NEG) &&
6112 (phy->speed_cap_mask &
6113 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) ||
6114 (phy->req_line_speed == SPEED_1000)) {
6115 an_1000_val |= (1<<8);
6116 autoneg_val |= (1<<9 | 1<<12);
6117 if (phy->req_duplex == DUPLEX_FULL)
6118 an_1000_val |= (1<<9);
6119 DP(NETIF_MSG_LINK, "Advertising 1G\n");
6120 } else
6121 an_1000_val &= ~((1<<8) | (1<<9));
6122
6123 bnx2x_cl45_write(bp, phy,
6124 MDIO_AN_DEVAD, MDIO_AN_REG_8481_1000T_CTRL,
6125 an_1000_val);
6126
6127 /* set 10 speed advertisement */
6128 if (((phy->req_line_speed == SPEED_AUTO_NEG) &&
6129 (phy->speed_cap_mask &
6130 (PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL |
6131 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF)))) {
6132 an_10_100_val |= (1<<7);
6133 /* Enable autoneg and restart autoneg for legacy speeds */
6134 autoneg_val |= (1<<9 | 1<<12);
6135
6136 if (phy->req_duplex == DUPLEX_FULL)
6137 an_10_100_val |= (1<<8);
6138 DP(NETIF_MSG_LINK, "Advertising 100M\n");
6139 }
6140 /* set 10 speed advertisement */
6141 if (((phy->req_line_speed == SPEED_AUTO_NEG) &&
6142 (phy->speed_cap_mask &
6143 (PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL |
6144 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF)))) {
6145 an_10_100_val |= (1<<5);
6146 autoneg_val |= (1<<9 | 1<<12);
6147 if (phy->req_duplex == DUPLEX_FULL)
6148 an_10_100_val |= (1<<6);
6149 DP(NETIF_MSG_LINK, "Advertising 10M\n");
6150 }
6151
6152 /* Only 10/100 are allowed to work in FORCE mode */
6153 if (phy->req_line_speed == SPEED_100) {
6154 autoneg_val |= (1<<13);
6155 /* Enabled AUTO-MDIX when autoneg is disabled */
6156 bnx2x_cl45_write(bp, phy,
6157 MDIO_AN_DEVAD, MDIO_AN_REG_8481_AUX_CTRL,
6158 (1<<15 | 1<<9 | 7<<0));
6159 DP(NETIF_MSG_LINK, "Setting 100M force\n");
6160 }
6161 if (phy->req_line_speed == SPEED_10) {
6162 /* Enabled AUTO-MDIX when autoneg is disabled */
6163 bnx2x_cl45_write(bp, phy,
6164 MDIO_AN_DEVAD, MDIO_AN_REG_8481_AUX_CTRL,
6165 (1<<15 | 1<<9 | 7<<0));
6166 DP(NETIF_MSG_LINK, "Setting 10M force\n");
6167 }
6168
6169 bnx2x_cl45_write(bp, phy,
6170 MDIO_AN_DEVAD, MDIO_AN_REG_8481_LEGACY_AN_ADV,
6171 an_10_100_val);
6172
6173 if (phy->req_duplex == DUPLEX_FULL)
6174 autoneg_val |= (1<<8);
6175
6176 bnx2x_cl45_write(bp, phy,
6177 MDIO_AN_DEVAD,
6178 MDIO_AN_REG_8481_LEGACY_MII_CTRL, autoneg_val);
6179
6180 if (((phy->req_line_speed == SPEED_AUTO_NEG) &&
6181 (phy->speed_cap_mask &
6182 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
6183 (phy->req_line_speed == SPEED_10000)) {
6184 DP(NETIF_MSG_LINK, "Advertising 10G\n");
6185 /* Restart autoneg for 10G*/
6186
6187 bnx2x_cl45_write(bp, phy,
6188 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL,
6189 0x3200);
6190 } else if (phy->req_line_speed != SPEED_10 &&
6191 phy->req_line_speed != SPEED_100) {
6192 bnx2x_cl45_write(bp, phy,
6193 MDIO_AN_DEVAD,
6194 MDIO_AN_REG_8481_10GBASE_T_AN_CTRL,
6195 1);
6196 }
6197 /* Save spirom version */
6198 bnx2x_save_848xx_spirom_version(phy, params);
6199
6200 return 0;
6201 }
6202
6203 static u8 bnx2x_8481_config_init(struct bnx2x_phy *phy,
6204 struct link_params *params,
6205 struct link_vars *vars)
6206 {
6207 struct bnx2x *bp = params->bp;
6208 /* Restore normal power mode*/
6209 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6210 MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
6211
6212 /* HW reset */
6213 bnx2x_ext_phy_hw_reset(bp, params->port);
6214 bnx2x_wait_reset_complete(bp, phy, params);
6215
6216 bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1<<15);
6217 return bnx2x_848xx_cmn_config_init(phy, params, vars);
6218 }
6219
6220 static u8 bnx2x_848x3_config_init(struct bnx2x_phy *phy,
6221 struct link_params *params,
6222 struct link_vars *vars)
6223 {
6224 struct bnx2x *bp = params->bp;
6225 u8 port, initialize = 1;
6226 u16 val, adj;
6227 u16 temp;
6228 u32 actual_phy_selection, cms_enable;
6229 u8 rc = 0;
6230
6231 /* This is just for MDIO_CTL_REG_84823_MEDIA register. */
6232 adj = 0;
6233 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833)
6234 adj = 3;
6235
6236 msleep(1);
6237 if (CHIP_IS_E2(bp))
6238 port = BP_PATH(bp);
6239 else
6240 port = params->port;
6241 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_3,
6242 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
6243 port);
6244 bnx2x_wait_reset_complete(bp, phy, params);
6245 /* Wait for GPHY to come out of reset */
6246 msleep(50);
6247 /*
6248 * BCM84823 requires that XGXS links up first @ 10G for normal behavior
6249 */
6250 temp = vars->line_speed;
6251 vars->line_speed = SPEED_10000;
6252 bnx2x_set_autoneg(&params->phy[INT_PHY], params, vars, 0);
6253 bnx2x_program_serdes(&params->phy[INT_PHY], params, vars);
6254 vars->line_speed = temp;
6255
6256 /* Set dual-media configuration according to configuration */
6257
6258 bnx2x_cl45_read(bp, phy, MDIO_CTL_DEVAD,
6259 MDIO_CTL_REG_84823_MEDIA + adj, &val);
6260 val &= ~(MDIO_CTL_REG_84823_MEDIA_MAC_MASK |
6261 MDIO_CTL_REG_84823_MEDIA_LINE_MASK |
6262 MDIO_CTL_REG_84823_MEDIA_COPPER_CORE_DOWN |
6263 MDIO_CTL_REG_84823_MEDIA_PRIORITY_MASK |
6264 MDIO_CTL_REG_84823_MEDIA_FIBER_1G);
6265 val |= MDIO_CTL_REG_84823_CTRL_MAC_XFI |
6266 MDIO_CTL_REG_84823_MEDIA_LINE_XAUI_L;
6267
6268 actual_phy_selection = bnx2x_phy_selection(params);
6269
6270 switch (actual_phy_selection) {
6271 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
6272 /* Do nothing. Essentially this is like the priority copper */
6273 break;
6274 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
6275 val |= MDIO_CTL_REG_84823_MEDIA_PRIORITY_COPPER;
6276 break;
6277 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
6278 val |= MDIO_CTL_REG_84823_MEDIA_PRIORITY_FIBER;
6279 break;
6280 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
6281 /* Do nothing here. The first PHY won't be initialized at all */
6282 break;
6283 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
6284 val |= MDIO_CTL_REG_84823_MEDIA_COPPER_CORE_DOWN;
6285 initialize = 0;
6286 break;
6287 }
6288 if (params->phy[EXT_PHY2].req_line_speed == SPEED_1000)
6289 val |= MDIO_CTL_REG_84823_MEDIA_FIBER_1G;
6290
6291 bnx2x_cl45_write(bp, phy, MDIO_CTL_DEVAD,
6292 MDIO_CTL_REG_84823_MEDIA + adj, val);
6293 DP(NETIF_MSG_LINK, "Multi_phy config = 0x%x, Media control = 0x%x\n",
6294 params->multi_phy_config, val);
6295
6296 if (initialize)
6297 rc = bnx2x_848xx_cmn_config_init(phy, params, vars);
6298 else
6299 bnx2x_save_848xx_spirom_version(phy, params);
6300 cms_enable = REG_RD(bp, params->shmem_base +
6301 offsetof(struct shmem_region,
6302 dev_info.port_hw_config[params->port].default_cfg)) &
6303 PORT_HW_CFG_ENABLE_CMS_MASK;
6304
6305 bnx2x_cl45_read(bp, phy, MDIO_CTL_DEVAD,
6306 MDIO_CTL_REG_84823_USER_CTRL_REG, &val);
6307 if (cms_enable)
6308 val |= MDIO_CTL_REG_84823_USER_CTRL_CMS;
6309 else
6310 val &= ~MDIO_CTL_REG_84823_USER_CTRL_CMS;
6311 bnx2x_cl45_write(bp, phy, MDIO_CTL_DEVAD,
6312 MDIO_CTL_REG_84823_USER_CTRL_REG, val);
6313
6314
6315 return rc;
6316 }
6317
6318 static u8 bnx2x_848xx_read_status(struct bnx2x_phy *phy,
6319 struct link_params *params,
6320 struct link_vars *vars)
6321 {
6322 struct bnx2x *bp = params->bp;
6323 u16 val, val1, val2, adj;
6324 u8 link_up = 0;
6325
6326 /* Reg offset adjustment for 84833 */
6327 adj = 0;
6328 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833)
6329 adj = -1;
6330
6331 /* Check 10G-BaseT link status */
6332 /* Check PMD signal ok */
6333 bnx2x_cl45_read(bp, phy,
6334 MDIO_AN_DEVAD, 0xFFFA, &val1);
6335 bnx2x_cl45_read(bp, phy,
6336 MDIO_PMA_DEVAD, MDIO_PMA_REG_8481_PMD_SIGNAL + adj,
6337 &val2);
6338 DP(NETIF_MSG_LINK, "BCM848xx: PMD_SIGNAL 1.a811 = 0x%x\n", val2);
6339
6340 /* Check link 10G */
6341 if (val2 & (1<<11)) {
6342 vars->line_speed = SPEED_10000;
6343 vars->duplex = DUPLEX_FULL;
6344 link_up = 1;
6345 bnx2x_ext_phy_10G_an_resolve(bp, phy, vars);
6346 } else { /* Check Legacy speed link */
6347 u16 legacy_status, legacy_speed;
6348
6349 /* Enable expansion register 0x42 (Operation mode status) */
6350 bnx2x_cl45_write(bp, phy,
6351 MDIO_AN_DEVAD,
6352 MDIO_AN_REG_8481_EXPANSION_REG_ACCESS, 0xf42);
6353
6354 /* Get legacy speed operation status */
6355 bnx2x_cl45_read(bp, phy,
6356 MDIO_AN_DEVAD,
6357 MDIO_AN_REG_8481_EXPANSION_REG_RD_RW,
6358 &legacy_status);
6359
6360 DP(NETIF_MSG_LINK, "Legacy speed status"
6361 " = 0x%x\n", legacy_status);
6362 link_up = ((legacy_status & (1<<11)) == (1<<11));
6363 if (link_up) {
6364 legacy_speed = (legacy_status & (3<<9));
6365 if (legacy_speed == (0<<9))
6366 vars->line_speed = SPEED_10;
6367 else if (legacy_speed == (1<<9))
6368 vars->line_speed = SPEED_100;
6369 else if (legacy_speed == (2<<9))
6370 vars->line_speed = SPEED_1000;
6371 else /* Should not happen */
6372 vars->line_speed = 0;
6373
6374 if (legacy_status & (1<<8))
6375 vars->duplex = DUPLEX_FULL;
6376 else
6377 vars->duplex = DUPLEX_HALF;
6378
6379 DP(NETIF_MSG_LINK, "Link is up in %dMbps,"
6380 " is_duplex_full= %d\n", vars->line_speed,
6381 (vars->duplex == DUPLEX_FULL));
6382 /* Check legacy speed AN resolution */
6383 bnx2x_cl45_read(bp, phy,
6384 MDIO_AN_DEVAD,
6385 MDIO_AN_REG_8481_LEGACY_MII_STATUS,
6386 &val);
6387 if (val & (1<<5))
6388 vars->link_status |=
6389 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
6390 bnx2x_cl45_read(bp, phy,
6391 MDIO_AN_DEVAD,
6392 MDIO_AN_REG_8481_LEGACY_AN_EXPANSION,
6393 &val);
6394 if ((val & (1<<0)) == 0)
6395 vars->link_status |=
6396 LINK_STATUS_PARALLEL_DETECTION_USED;
6397 }
6398 }
6399 if (link_up) {
6400 DP(NETIF_MSG_LINK, "BCM84823: link speed is %d\n",
6401 vars->line_speed);
6402 bnx2x_ext_phy_resolve_fc(phy, params, vars);
6403 }
6404
6405 return link_up;
6406 }
6407
6408 static u8 bnx2x_848xx_format_ver(u32 raw_ver, u8 *str, u16 *len)
6409 {
6410 u8 status = 0;
6411 u32 spirom_ver;
6412 spirom_ver = ((raw_ver & 0xF80) >> 7) << 16 | (raw_ver & 0x7F);
6413 status = bnx2x_format_ver(spirom_ver, str, len);
6414 return status;
6415 }
6416
6417 static void bnx2x_8481_hw_reset(struct bnx2x_phy *phy,
6418 struct link_params *params)
6419 {
6420 bnx2x_set_gpio(params->bp, MISC_REGISTERS_GPIO_1,
6421 MISC_REGISTERS_GPIO_OUTPUT_LOW, 0);
6422 bnx2x_set_gpio(params->bp, MISC_REGISTERS_GPIO_1,
6423 MISC_REGISTERS_GPIO_OUTPUT_LOW, 1);
6424 }
6425
6426 static void bnx2x_8481_link_reset(struct bnx2x_phy *phy,
6427 struct link_params *params)
6428 {
6429 bnx2x_cl45_write(params->bp, phy,
6430 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
6431 bnx2x_cl45_write(params->bp, phy,
6432 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1);
6433 }
6434
6435 static void bnx2x_848x3_link_reset(struct bnx2x_phy *phy,
6436 struct link_params *params)
6437 {
6438 struct bnx2x *bp = params->bp;
6439 u8 port;
6440 if (CHIP_IS_E2(bp))
6441 port = BP_PATH(bp);
6442 else
6443 port = params->port;
6444 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_3,
6445 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6446 port);
6447 }
6448
6449 static void bnx2x_848xx_set_link_led(struct bnx2x_phy *phy,
6450 struct link_params *params, u8 mode)
6451 {
6452 struct bnx2x *bp = params->bp;
6453 u16 val;
6454
6455 switch (mode) {
6456 case LED_MODE_OFF:
6457
6458 DP(NETIF_MSG_LINK, "Port 0x%x: LED MODE OFF\n", params->port);
6459
6460 if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
6461 SHARED_HW_CFG_LED_EXTPHY1) {
6462
6463 /* Set LED masks */
6464 bnx2x_cl45_write(bp, phy,
6465 MDIO_PMA_DEVAD,
6466 MDIO_PMA_REG_8481_LED1_MASK,
6467 0x0);
6468
6469 bnx2x_cl45_write(bp, phy,
6470 MDIO_PMA_DEVAD,
6471 MDIO_PMA_REG_8481_LED2_MASK,
6472 0x0);
6473
6474 bnx2x_cl45_write(bp, phy,
6475 MDIO_PMA_DEVAD,
6476 MDIO_PMA_REG_8481_LED3_MASK,
6477 0x0);
6478
6479 bnx2x_cl45_write(bp, phy,
6480 MDIO_PMA_DEVAD,
6481 MDIO_PMA_REG_8481_LED5_MASK,
6482 0x0);
6483
6484 } else {
6485 bnx2x_cl45_write(bp, phy,
6486 MDIO_PMA_DEVAD,
6487 MDIO_PMA_REG_8481_LED1_MASK,
6488 0x0);
6489 }
6490 break;
6491 case LED_MODE_FRONT_PANEL_OFF:
6492
6493 DP(NETIF_MSG_LINK, "Port 0x%x: LED MODE FRONT PANEL OFF\n",
6494 params->port);
6495
6496 if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
6497 SHARED_HW_CFG_LED_EXTPHY1) {
6498
6499 /* Set LED masks */
6500 bnx2x_cl45_write(bp, phy,
6501 MDIO_PMA_DEVAD,
6502 MDIO_PMA_REG_8481_LED1_MASK,
6503 0x0);
6504
6505 bnx2x_cl45_write(bp, phy,
6506 MDIO_PMA_DEVAD,
6507 MDIO_PMA_REG_8481_LED2_MASK,
6508 0x0);
6509
6510 bnx2x_cl45_write(bp, phy,
6511 MDIO_PMA_DEVAD,
6512 MDIO_PMA_REG_8481_LED3_MASK,
6513 0x0);
6514
6515 bnx2x_cl45_write(bp, phy,
6516 MDIO_PMA_DEVAD,
6517 MDIO_PMA_REG_8481_LED5_MASK,
6518 0x20);
6519
6520 } else {
6521 bnx2x_cl45_write(bp, phy,
6522 MDIO_PMA_DEVAD,
6523 MDIO_PMA_REG_8481_LED1_MASK,
6524 0x0);
6525 }
6526 break;
6527 case LED_MODE_ON:
6528
6529 DP(NETIF_MSG_LINK, "Port 0x%x: LED MODE ON\n", params->port);
6530
6531 if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
6532 SHARED_HW_CFG_LED_EXTPHY1) {
6533 /* Set control reg */
6534 bnx2x_cl45_read(bp, phy,
6535 MDIO_PMA_DEVAD,
6536 MDIO_PMA_REG_8481_LINK_SIGNAL,
6537 &val);
6538 val &= 0x8000;
6539 val |= 0x2492;
6540
6541 bnx2x_cl45_write(bp, phy,
6542 MDIO_PMA_DEVAD,
6543 MDIO_PMA_REG_8481_LINK_SIGNAL,
6544 val);
6545
6546 /* Set LED masks */
6547 bnx2x_cl45_write(bp, phy,
6548 MDIO_PMA_DEVAD,
6549 MDIO_PMA_REG_8481_LED1_MASK,
6550 0x0);
6551
6552 bnx2x_cl45_write(bp, phy,
6553 MDIO_PMA_DEVAD,
6554 MDIO_PMA_REG_8481_LED2_MASK,
6555 0x20);
6556
6557 bnx2x_cl45_write(bp, phy,
6558 MDIO_PMA_DEVAD,
6559 MDIO_PMA_REG_8481_LED3_MASK,
6560 0x20);
6561
6562 bnx2x_cl45_write(bp, phy,
6563 MDIO_PMA_DEVAD,
6564 MDIO_PMA_REG_8481_LED5_MASK,
6565 0x0);
6566 } else {
6567 bnx2x_cl45_write(bp, phy,
6568 MDIO_PMA_DEVAD,
6569 MDIO_PMA_REG_8481_LED1_MASK,
6570 0x20);
6571 }
6572 break;
6573
6574 case LED_MODE_OPER:
6575
6576 DP(NETIF_MSG_LINK, "Port 0x%x: LED MODE OPER\n", params->port);
6577
6578 if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
6579 SHARED_HW_CFG_LED_EXTPHY1) {
6580
6581 /* Set control reg */
6582 bnx2x_cl45_read(bp, phy,
6583 MDIO_PMA_DEVAD,
6584 MDIO_PMA_REG_8481_LINK_SIGNAL,
6585 &val);
6586
6587 if (!((val &
6588 MDIO_PMA_REG_8481_LINK_SIGNAL_LED4_ENABLE_MASK)
6589 >> MDIO_PMA_REG_8481_LINK_SIGNAL_LED4_ENABLE_SHIFT)) {
6590 DP(NETIF_MSG_LINK, "Setting LINK_SIGNAL\n");
6591 bnx2x_cl45_write(bp, phy,
6592 MDIO_PMA_DEVAD,
6593 MDIO_PMA_REG_8481_LINK_SIGNAL,
6594 0xa492);
6595 }
6596
6597 /* Set LED masks */
6598 bnx2x_cl45_write(bp, phy,
6599 MDIO_PMA_DEVAD,
6600 MDIO_PMA_REG_8481_LED1_MASK,
6601 0x10);
6602
6603 bnx2x_cl45_write(bp, phy,
6604 MDIO_PMA_DEVAD,
6605 MDIO_PMA_REG_8481_LED2_MASK,
6606 0x80);
6607
6608 bnx2x_cl45_write(bp, phy,
6609 MDIO_PMA_DEVAD,
6610 MDIO_PMA_REG_8481_LED3_MASK,
6611 0x98);
6612
6613 bnx2x_cl45_write(bp, phy,
6614 MDIO_PMA_DEVAD,
6615 MDIO_PMA_REG_8481_LED5_MASK,
6616 0x40);
6617
6618 } else {
6619 bnx2x_cl45_write(bp, phy,
6620 MDIO_PMA_DEVAD,
6621 MDIO_PMA_REG_8481_LED1_MASK,
6622 0x80);
6623
6624 /* Tell LED3 to blink on source */
6625 bnx2x_cl45_read(bp, phy,
6626 MDIO_PMA_DEVAD,
6627 MDIO_PMA_REG_8481_LINK_SIGNAL,
6628 &val);
6629 val &= ~(7<<6);
6630 val |= (1<<6); /* A83B[8:6]= 1 */
6631 bnx2x_cl45_write(bp, phy,
6632 MDIO_PMA_DEVAD,
6633 MDIO_PMA_REG_8481_LINK_SIGNAL,
6634 val);
6635 }
6636 break;
6637 }
6638 }
6639 /******************************************************************/
6640 /* SFX7101 PHY SECTION */
6641 /******************************************************************/
6642 static void bnx2x_7101_config_loopback(struct bnx2x_phy *phy,
6643 struct link_params *params)
6644 {
6645 struct bnx2x *bp = params->bp;
6646 /* SFX7101_XGXS_TEST1 */
6647 bnx2x_cl45_write(bp, phy,
6648 MDIO_XS_DEVAD, MDIO_XS_SFX7101_XGXS_TEST1, 0x100);
6649 }
6650
6651 static u8 bnx2x_7101_config_init(struct bnx2x_phy *phy,
6652 struct link_params *params,
6653 struct link_vars *vars)
6654 {
6655 u16 fw_ver1, fw_ver2, val;
6656 struct bnx2x *bp = params->bp;
6657 DP(NETIF_MSG_LINK, "Setting the SFX7101 LASI indication\n");
6658
6659 /* Restore normal power mode*/
6660 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6661 MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
6662 /* HW reset */
6663 bnx2x_ext_phy_hw_reset(bp, params->port);
6664 bnx2x_wait_reset_complete(bp, phy, params);
6665
6666 bnx2x_cl45_write(bp, phy,
6667 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_CTRL, 0x1);
6668 DP(NETIF_MSG_LINK, "Setting the SFX7101 LED to blink on traffic\n");
6669 bnx2x_cl45_write(bp, phy,
6670 MDIO_PMA_DEVAD, MDIO_PMA_REG_7107_LED_CNTL, (1<<3));
6671
6672 bnx2x_ext_phy_set_pause(params, phy, vars);
6673 /* Restart autoneg */
6674 bnx2x_cl45_read(bp, phy,
6675 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, &val);
6676 val |= 0x200;
6677 bnx2x_cl45_write(bp, phy,
6678 MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, val);
6679
6680 /* Save spirom version */
6681 bnx2x_cl45_read(bp, phy,
6682 MDIO_PMA_DEVAD, MDIO_PMA_REG_7101_VER1, &fw_ver1);
6683
6684 bnx2x_cl45_read(bp, phy,
6685 MDIO_PMA_DEVAD, MDIO_PMA_REG_7101_VER2, &fw_ver2);
6686 bnx2x_save_spirom_version(bp, params->port,
6687 (u32)(fw_ver1<<16 | fw_ver2), phy->ver_addr);
6688 return 0;
6689 }
6690
6691 static u8 bnx2x_7101_read_status(struct bnx2x_phy *phy,
6692 struct link_params *params,
6693 struct link_vars *vars)
6694 {
6695 struct bnx2x *bp = params->bp;
6696 u8 link_up;
6697 u16 val1, val2;
6698 bnx2x_cl45_read(bp, phy,
6699 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val2);
6700 bnx2x_cl45_read(bp, phy,
6701 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS, &val1);
6702 DP(NETIF_MSG_LINK, "10G-base-T LASI status 0x%x->0x%x\n",
6703 val2, val1);
6704 bnx2x_cl45_read(bp, phy,
6705 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
6706 bnx2x_cl45_read(bp, phy,
6707 MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
6708 DP(NETIF_MSG_LINK, "10G-base-T PMA status 0x%x->0x%x\n",
6709 val2, val1);
6710 link_up = ((val1 & 4) == 4);
6711 /* if link is up print the AN outcome of the SFX7101 PHY */
6712 if (link_up) {
6713 bnx2x_cl45_read(bp, phy,
6714 MDIO_AN_DEVAD, MDIO_AN_REG_MASTER_STATUS,
6715 &val2);
6716 vars->line_speed = SPEED_10000;
6717 vars->duplex = DUPLEX_FULL;
6718 DP(NETIF_MSG_LINK, "SFX7101 AN status 0x%x->Master=%x\n",
6719 val2, (val2 & (1<<14)));
6720 bnx2x_ext_phy_10G_an_resolve(bp, phy, vars);
6721 bnx2x_ext_phy_resolve_fc(phy, params, vars);
6722 }
6723 return link_up;
6724 }
6725
6726
6727 static u8 bnx2x_7101_format_ver(u32 spirom_ver, u8 *str, u16 *len)
6728 {
6729 if (*len < 5)
6730 return -EINVAL;
6731 str[0] = (spirom_ver & 0xFF);
6732 str[1] = (spirom_ver & 0xFF00) >> 8;
6733 str[2] = (spirom_ver & 0xFF0000) >> 16;
6734 str[3] = (spirom_ver & 0xFF000000) >> 24;
6735 str[4] = '\0';
6736 *len -= 5;
6737 return 0;
6738 }
6739
6740 void bnx2x_sfx7101_sp_sw_reset(struct bnx2x *bp, struct bnx2x_phy *phy)
6741 {
6742 u16 val, cnt;
6743
6744 bnx2x_cl45_read(bp, phy,
6745 MDIO_PMA_DEVAD,
6746 MDIO_PMA_REG_7101_RESET, &val);
6747
6748 for (cnt = 0; cnt < 10; cnt++) {
6749 msleep(50);
6750 /* Writes a self-clearing reset */
6751 bnx2x_cl45_write(bp, phy,
6752 MDIO_PMA_DEVAD,
6753 MDIO_PMA_REG_7101_RESET,
6754 (val | (1<<15)));
6755 /* Wait for clear */
6756 bnx2x_cl45_read(bp, phy,
6757 MDIO_PMA_DEVAD,
6758 MDIO_PMA_REG_7101_RESET, &val);
6759
6760 if ((val & (1<<15)) == 0)
6761 break;
6762 }
6763 }
6764
6765 static void bnx2x_7101_hw_reset(struct bnx2x_phy *phy,
6766 struct link_params *params) {
6767 /* Low power mode is controlled by GPIO 2 */
6768 bnx2x_set_gpio(params->bp, MISC_REGISTERS_GPIO_2,
6769 MISC_REGISTERS_GPIO_OUTPUT_LOW, params->port);
6770 /* The PHY reset is controlled by GPIO 1 */
6771 bnx2x_set_gpio(params->bp, MISC_REGISTERS_GPIO_1,
6772 MISC_REGISTERS_GPIO_OUTPUT_LOW, params->port);
6773 }
6774
6775 static void bnx2x_7101_set_link_led(struct bnx2x_phy *phy,
6776 struct link_params *params, u8 mode)
6777 {
6778 u16 val = 0;
6779 struct bnx2x *bp = params->bp;
6780 switch (mode) {
6781 case LED_MODE_FRONT_PANEL_OFF:
6782 case LED_MODE_OFF:
6783 val = 2;
6784 break;
6785 case LED_MODE_ON:
6786 val = 1;
6787 break;
6788 case LED_MODE_OPER:
6789 val = 0;
6790 break;
6791 }
6792 bnx2x_cl45_write(bp, phy,
6793 MDIO_PMA_DEVAD,
6794 MDIO_PMA_REG_7107_LINK_LED_CNTL,
6795 val);
6796 }
6797
6798 /******************************************************************/
6799 /* STATIC PHY DECLARATION */
6800 /******************************************************************/
6801
6802 static struct bnx2x_phy phy_null = {
6803 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN,
6804 .addr = 0,
6805 .flags = FLAGS_INIT_XGXS_FIRST,
6806 .def_md_devad = 0,
6807 .reserved = 0,
6808 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6809 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6810 .mdio_ctrl = 0,
6811 .supported = 0,
6812 .media_type = ETH_PHY_NOT_PRESENT,
6813 .ver_addr = 0,
6814 .req_flow_ctrl = 0,
6815 .req_line_speed = 0,
6816 .speed_cap_mask = 0,
6817 .req_duplex = 0,
6818 .rsrv = 0,
6819 .config_init = (config_init_t)NULL,
6820 .read_status = (read_status_t)NULL,
6821 .link_reset = (link_reset_t)NULL,
6822 .config_loopback = (config_loopback_t)NULL,
6823 .format_fw_ver = (format_fw_ver_t)NULL,
6824 .hw_reset = (hw_reset_t)NULL,
6825 .set_link_led = (set_link_led_t)NULL,
6826 .phy_specific_func = (phy_specific_func_t)NULL
6827 };
6828
6829 static struct bnx2x_phy phy_serdes = {
6830 .type = PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT,
6831 .addr = 0xff,
6832 .flags = 0,
6833 .def_md_devad = 0,
6834 .reserved = 0,
6835 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6836 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6837 .mdio_ctrl = 0,
6838 .supported = (SUPPORTED_10baseT_Half |
6839 SUPPORTED_10baseT_Full |
6840 SUPPORTED_100baseT_Half |
6841 SUPPORTED_100baseT_Full |
6842 SUPPORTED_1000baseT_Full |
6843 SUPPORTED_2500baseX_Full |
6844 SUPPORTED_TP |
6845 SUPPORTED_Autoneg |
6846 SUPPORTED_Pause |
6847 SUPPORTED_Asym_Pause),
6848 .media_type = ETH_PHY_UNSPECIFIED,
6849 .ver_addr = 0,
6850 .req_flow_ctrl = 0,
6851 .req_line_speed = 0,
6852 .speed_cap_mask = 0,
6853 .req_duplex = 0,
6854 .rsrv = 0,
6855 .config_init = (config_init_t)bnx2x_init_serdes,
6856 .read_status = (read_status_t)bnx2x_link_settings_status,
6857 .link_reset = (link_reset_t)bnx2x_int_link_reset,
6858 .config_loopback = (config_loopback_t)NULL,
6859 .format_fw_ver = (format_fw_ver_t)NULL,
6860 .hw_reset = (hw_reset_t)NULL,
6861 .set_link_led = (set_link_led_t)NULL,
6862 .phy_specific_func = (phy_specific_func_t)NULL
6863 };
6864
6865 static struct bnx2x_phy phy_xgxs = {
6866 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT,
6867 .addr = 0xff,
6868 .flags = 0,
6869 .def_md_devad = 0,
6870 .reserved = 0,
6871 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6872 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6873 .mdio_ctrl = 0,
6874 .supported = (SUPPORTED_10baseT_Half |
6875 SUPPORTED_10baseT_Full |
6876 SUPPORTED_100baseT_Half |
6877 SUPPORTED_100baseT_Full |
6878 SUPPORTED_1000baseT_Full |
6879 SUPPORTED_2500baseX_Full |
6880 SUPPORTED_10000baseT_Full |
6881 SUPPORTED_FIBRE |
6882 SUPPORTED_Autoneg |
6883 SUPPORTED_Pause |
6884 SUPPORTED_Asym_Pause),
6885 .media_type = ETH_PHY_UNSPECIFIED,
6886 .ver_addr = 0,
6887 .req_flow_ctrl = 0,
6888 .req_line_speed = 0,
6889 .speed_cap_mask = 0,
6890 .req_duplex = 0,
6891 .rsrv = 0,
6892 .config_init = (config_init_t)bnx2x_init_xgxs,
6893 .read_status = (read_status_t)bnx2x_link_settings_status,
6894 .link_reset = (link_reset_t)bnx2x_int_link_reset,
6895 .config_loopback = (config_loopback_t)bnx2x_set_xgxs_loopback,
6896 .format_fw_ver = (format_fw_ver_t)NULL,
6897 .hw_reset = (hw_reset_t)NULL,
6898 .set_link_led = (set_link_led_t)NULL,
6899 .phy_specific_func = (phy_specific_func_t)NULL
6900 };
6901
6902 static struct bnx2x_phy phy_7101 = {
6903 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6904 .addr = 0xff,
6905 .flags = FLAGS_FAN_FAILURE_DET_REQ,
6906 .def_md_devad = 0,
6907 .reserved = 0,
6908 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6909 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6910 .mdio_ctrl = 0,
6911 .supported = (SUPPORTED_10000baseT_Full |
6912 SUPPORTED_TP |
6913 SUPPORTED_Autoneg |
6914 SUPPORTED_Pause |
6915 SUPPORTED_Asym_Pause),
6916 .media_type = ETH_PHY_BASE_T,
6917 .ver_addr = 0,
6918 .req_flow_ctrl = 0,
6919 .req_line_speed = 0,
6920 .speed_cap_mask = 0,
6921 .req_duplex = 0,
6922 .rsrv = 0,
6923 .config_init = (config_init_t)bnx2x_7101_config_init,
6924 .read_status = (read_status_t)bnx2x_7101_read_status,
6925 .link_reset = (link_reset_t)bnx2x_common_ext_link_reset,
6926 .config_loopback = (config_loopback_t)bnx2x_7101_config_loopback,
6927 .format_fw_ver = (format_fw_ver_t)bnx2x_7101_format_ver,
6928 .hw_reset = (hw_reset_t)bnx2x_7101_hw_reset,
6929 .set_link_led = (set_link_led_t)bnx2x_7101_set_link_led,
6930 .phy_specific_func = (phy_specific_func_t)NULL
6931 };
6932 static struct bnx2x_phy phy_8073 = {
6933 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6934 .addr = 0xff,
6935 .flags = FLAGS_HW_LOCK_REQUIRED,
6936 .def_md_devad = 0,
6937 .reserved = 0,
6938 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6939 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6940 .mdio_ctrl = 0,
6941 .supported = (SUPPORTED_10000baseT_Full |
6942 SUPPORTED_2500baseX_Full |
6943 SUPPORTED_1000baseT_Full |
6944 SUPPORTED_FIBRE |
6945 SUPPORTED_Autoneg |
6946 SUPPORTED_Pause |
6947 SUPPORTED_Asym_Pause),
6948 .media_type = ETH_PHY_UNSPECIFIED,
6949 .ver_addr = 0,
6950 .req_flow_ctrl = 0,
6951 .req_line_speed = 0,
6952 .speed_cap_mask = 0,
6953 .req_duplex = 0,
6954 .rsrv = 0,
6955 .config_init = (config_init_t)bnx2x_8073_config_init,
6956 .read_status = (read_status_t)bnx2x_8073_read_status,
6957 .link_reset = (link_reset_t)bnx2x_8073_link_reset,
6958 .config_loopback = (config_loopback_t)NULL,
6959 .format_fw_ver = (format_fw_ver_t)bnx2x_format_ver,
6960 .hw_reset = (hw_reset_t)NULL,
6961 .set_link_led = (set_link_led_t)NULL,
6962 .phy_specific_func = (phy_specific_func_t)NULL
6963 };
6964 static struct bnx2x_phy phy_8705 = {
6965 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705,
6966 .addr = 0xff,
6967 .flags = FLAGS_INIT_XGXS_FIRST,
6968 .def_md_devad = 0,
6969 .reserved = 0,
6970 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6971 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
6972 .mdio_ctrl = 0,
6973 .supported = (SUPPORTED_10000baseT_Full |
6974 SUPPORTED_FIBRE |
6975 SUPPORTED_Pause |
6976 SUPPORTED_Asym_Pause),
6977 .media_type = ETH_PHY_XFP_FIBER,
6978 .ver_addr = 0,
6979 .req_flow_ctrl = 0,
6980 .req_line_speed = 0,
6981 .speed_cap_mask = 0,
6982 .req_duplex = 0,
6983 .rsrv = 0,
6984 .config_init = (config_init_t)bnx2x_8705_config_init,
6985 .read_status = (read_status_t)bnx2x_8705_read_status,
6986 .link_reset = (link_reset_t)bnx2x_common_ext_link_reset,
6987 .config_loopback = (config_loopback_t)NULL,
6988 .format_fw_ver = (format_fw_ver_t)bnx2x_null_format_ver,
6989 .hw_reset = (hw_reset_t)NULL,
6990 .set_link_led = (set_link_led_t)NULL,
6991 .phy_specific_func = (phy_specific_func_t)NULL
6992 };
6993 static struct bnx2x_phy phy_8706 = {
6994 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706,
6995 .addr = 0xff,
6996 .flags = FLAGS_INIT_XGXS_FIRST,
6997 .def_md_devad = 0,
6998 .reserved = 0,
6999 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7000 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7001 .mdio_ctrl = 0,
7002 .supported = (SUPPORTED_10000baseT_Full |
7003 SUPPORTED_1000baseT_Full |
7004 SUPPORTED_FIBRE |
7005 SUPPORTED_Pause |
7006 SUPPORTED_Asym_Pause),
7007 .media_type = ETH_PHY_SFP_FIBER,
7008 .ver_addr = 0,
7009 .req_flow_ctrl = 0,
7010 .req_line_speed = 0,
7011 .speed_cap_mask = 0,
7012 .req_duplex = 0,
7013 .rsrv = 0,
7014 .config_init = (config_init_t)bnx2x_8706_config_init,
7015 .read_status = (read_status_t)bnx2x_8706_read_status,
7016 .link_reset = (link_reset_t)bnx2x_common_ext_link_reset,
7017 .config_loopback = (config_loopback_t)NULL,
7018 .format_fw_ver = (format_fw_ver_t)bnx2x_format_ver,
7019 .hw_reset = (hw_reset_t)NULL,
7020 .set_link_led = (set_link_led_t)NULL,
7021 .phy_specific_func = (phy_specific_func_t)NULL
7022 };
7023
7024 static struct bnx2x_phy phy_8726 = {
7025 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
7026 .addr = 0xff,
7027 .flags = (FLAGS_HW_LOCK_REQUIRED |
7028 FLAGS_INIT_XGXS_FIRST),
7029 .def_md_devad = 0,
7030 .reserved = 0,
7031 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7032 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7033 .mdio_ctrl = 0,
7034 .supported = (SUPPORTED_10000baseT_Full |
7035 SUPPORTED_1000baseT_Full |
7036 SUPPORTED_Autoneg |
7037 SUPPORTED_FIBRE |
7038 SUPPORTED_Pause |
7039 SUPPORTED_Asym_Pause),
7040 .media_type = ETH_PHY_SFP_FIBER,
7041 .ver_addr = 0,
7042 .req_flow_ctrl = 0,
7043 .req_line_speed = 0,
7044 .speed_cap_mask = 0,
7045 .req_duplex = 0,
7046 .rsrv = 0,
7047 .config_init = (config_init_t)bnx2x_8726_config_init,
7048 .read_status = (read_status_t)bnx2x_8726_read_status,
7049 .link_reset = (link_reset_t)bnx2x_8726_link_reset,
7050 .config_loopback = (config_loopback_t)bnx2x_8726_config_loopback,
7051 .format_fw_ver = (format_fw_ver_t)bnx2x_format_ver,
7052 .hw_reset = (hw_reset_t)NULL,
7053 .set_link_led = (set_link_led_t)NULL,
7054 .phy_specific_func = (phy_specific_func_t)NULL
7055 };
7056
7057 static struct bnx2x_phy phy_8727 = {
7058 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
7059 .addr = 0xff,
7060 .flags = FLAGS_FAN_FAILURE_DET_REQ,
7061 .def_md_devad = 0,
7062 .reserved = 0,
7063 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7064 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7065 .mdio_ctrl = 0,
7066 .supported = (SUPPORTED_10000baseT_Full |
7067 SUPPORTED_1000baseT_Full |
7068 SUPPORTED_FIBRE |
7069 SUPPORTED_Pause |
7070 SUPPORTED_Asym_Pause),
7071 .media_type = ETH_PHY_SFP_FIBER,
7072 .ver_addr = 0,
7073 .req_flow_ctrl = 0,
7074 .req_line_speed = 0,
7075 .speed_cap_mask = 0,
7076 .req_duplex = 0,
7077 .rsrv = 0,
7078 .config_init = (config_init_t)bnx2x_8727_config_init,
7079 .read_status = (read_status_t)bnx2x_8727_read_status,
7080 .link_reset = (link_reset_t)bnx2x_8727_link_reset,
7081 .config_loopback = (config_loopback_t)NULL,
7082 .format_fw_ver = (format_fw_ver_t)bnx2x_format_ver,
7083 .hw_reset = (hw_reset_t)bnx2x_8727_hw_reset,
7084 .set_link_led = (set_link_led_t)bnx2x_8727_set_link_led,
7085 .phy_specific_func = (phy_specific_func_t)bnx2x_8727_specific_func
7086 };
7087 static struct bnx2x_phy phy_8481 = {
7088 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
7089 .addr = 0xff,
7090 .flags = FLAGS_FAN_FAILURE_DET_REQ |
7091 FLAGS_REARM_LATCH_SIGNAL,
7092 .def_md_devad = 0,
7093 .reserved = 0,
7094 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7095 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7096 .mdio_ctrl = 0,
7097 .supported = (SUPPORTED_10baseT_Half |
7098 SUPPORTED_10baseT_Full |
7099 SUPPORTED_100baseT_Half |
7100 SUPPORTED_100baseT_Full |
7101 SUPPORTED_1000baseT_Full |
7102 SUPPORTED_10000baseT_Full |
7103 SUPPORTED_TP |
7104 SUPPORTED_Autoneg |
7105 SUPPORTED_Pause |
7106 SUPPORTED_Asym_Pause),
7107 .media_type = ETH_PHY_BASE_T,
7108 .ver_addr = 0,
7109 .req_flow_ctrl = 0,
7110 .req_line_speed = 0,
7111 .speed_cap_mask = 0,
7112 .req_duplex = 0,
7113 .rsrv = 0,
7114 .config_init = (config_init_t)bnx2x_8481_config_init,
7115 .read_status = (read_status_t)bnx2x_848xx_read_status,
7116 .link_reset = (link_reset_t)bnx2x_8481_link_reset,
7117 .config_loopback = (config_loopback_t)NULL,
7118 .format_fw_ver = (format_fw_ver_t)bnx2x_848xx_format_ver,
7119 .hw_reset = (hw_reset_t)bnx2x_8481_hw_reset,
7120 .set_link_led = (set_link_led_t)bnx2x_848xx_set_link_led,
7121 .phy_specific_func = (phy_specific_func_t)NULL
7122 };
7123
7124 static struct bnx2x_phy phy_84823 = {
7125 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823,
7126 .addr = 0xff,
7127 .flags = FLAGS_FAN_FAILURE_DET_REQ |
7128 FLAGS_REARM_LATCH_SIGNAL,
7129 .def_md_devad = 0,
7130 .reserved = 0,
7131 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7132 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7133 .mdio_ctrl = 0,
7134 .supported = (SUPPORTED_10baseT_Half |
7135 SUPPORTED_10baseT_Full |
7136 SUPPORTED_100baseT_Half |
7137 SUPPORTED_100baseT_Full |
7138 SUPPORTED_1000baseT_Full |
7139 SUPPORTED_10000baseT_Full |
7140 SUPPORTED_TP |
7141 SUPPORTED_Autoneg |
7142 SUPPORTED_Pause |
7143 SUPPORTED_Asym_Pause),
7144 .media_type = ETH_PHY_BASE_T,
7145 .ver_addr = 0,
7146 .req_flow_ctrl = 0,
7147 .req_line_speed = 0,
7148 .speed_cap_mask = 0,
7149 .req_duplex = 0,
7150 .rsrv = 0,
7151 .config_init = (config_init_t)bnx2x_848x3_config_init,
7152 .read_status = (read_status_t)bnx2x_848xx_read_status,
7153 .link_reset = (link_reset_t)bnx2x_848x3_link_reset,
7154 .config_loopback = (config_loopback_t)NULL,
7155 .format_fw_ver = (format_fw_ver_t)bnx2x_848xx_format_ver,
7156 .hw_reset = (hw_reset_t)NULL,
7157 .set_link_led = (set_link_led_t)bnx2x_848xx_set_link_led,
7158 .phy_specific_func = (phy_specific_func_t)NULL
7159 };
7160
7161 static struct bnx2x_phy phy_84833 = {
7162 .type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833,
7163 .addr = 0xff,
7164 .flags = FLAGS_FAN_FAILURE_DET_REQ |
7165 FLAGS_REARM_LATCH_SIGNAL,
7166 .def_md_devad = 0,
7167 .reserved = 0,
7168 .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7169 .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
7170 .mdio_ctrl = 0,
7171 .supported = (SUPPORTED_10baseT_Half |
7172 SUPPORTED_10baseT_Full |
7173 SUPPORTED_100baseT_Half |
7174 SUPPORTED_100baseT_Full |
7175 SUPPORTED_1000baseT_Full |
7176 SUPPORTED_10000baseT_Full |
7177 SUPPORTED_TP |
7178 SUPPORTED_Autoneg |
7179 SUPPORTED_Pause |
7180 SUPPORTED_Asym_Pause),
7181 .media_type = ETH_PHY_BASE_T,
7182 .ver_addr = 0,
7183 .req_flow_ctrl = 0,
7184 .req_line_speed = 0,
7185 .speed_cap_mask = 0,
7186 .req_duplex = 0,
7187 .rsrv = 0,
7188 .config_init = (config_init_t)bnx2x_848x3_config_init,
7189 .read_status = (read_status_t)bnx2x_848xx_read_status,
7190 .link_reset = (link_reset_t)bnx2x_848x3_link_reset,
7191 .config_loopback = (config_loopback_t)NULL,
7192 .format_fw_ver = (format_fw_ver_t)bnx2x_848xx_format_ver,
7193 .hw_reset = (hw_reset_t)NULL,
7194 .set_link_led = (set_link_led_t)bnx2x_848xx_set_link_led,
7195 .phy_specific_func = (phy_specific_func_t)NULL
7196 };
7197
7198 /*****************************************************************/
7199 /* */
7200 /* Populate the phy according. Main function: bnx2x_populate_phy */
7201 /* */
7202 /*****************************************************************/
7203
7204 static void bnx2x_populate_preemphasis(struct bnx2x *bp, u32 shmem_base,
7205 struct bnx2x_phy *phy, u8 port,
7206 u8 phy_index)
7207 {
7208 /* Get the 4 lanes xgxs config rx and tx */
7209 u32 rx = 0, tx = 0, i;
7210 for (i = 0; i < 2; i++) {
7211 /*
7212 * INT_PHY and EXT_PHY1 share the same value location in the
7213 * shmem. When num_phys is greater than 1, than this value
7214 * applies only to EXT_PHY1
7215 */
7216 if (phy_index == INT_PHY || phy_index == EXT_PHY1) {
7217 rx = REG_RD(bp, shmem_base +
7218 offsetof(struct shmem_region,
7219 dev_info.port_hw_config[port].xgxs_config_rx[i<<1]));
7220
7221 tx = REG_RD(bp, shmem_base +
7222 offsetof(struct shmem_region,
7223 dev_info.port_hw_config[port].xgxs_config_tx[i<<1]));
7224 } else {
7225 rx = REG_RD(bp, shmem_base +
7226 offsetof(struct shmem_region,
7227 dev_info.port_hw_config[port].xgxs_config2_rx[i<<1]));
7228
7229 tx = REG_RD(bp, shmem_base +
7230 offsetof(struct shmem_region,
7231 dev_info.port_hw_config[port].xgxs_config2_rx[i<<1]));
7232 }
7233
7234 phy->rx_preemphasis[i << 1] = ((rx>>16) & 0xffff);
7235 phy->rx_preemphasis[(i << 1) + 1] = (rx & 0xffff);
7236
7237 phy->tx_preemphasis[i << 1] = ((tx>>16) & 0xffff);
7238 phy->tx_preemphasis[(i << 1) + 1] = (tx & 0xffff);
7239 }
7240 }
7241
7242 static u32 bnx2x_get_ext_phy_config(struct bnx2x *bp, u32 shmem_base,
7243 u8 phy_index, u8 port)
7244 {
7245 u32 ext_phy_config = 0;
7246 switch (phy_index) {
7247 case EXT_PHY1:
7248 ext_phy_config = REG_RD(bp, shmem_base +
7249 offsetof(struct shmem_region,
7250 dev_info.port_hw_config[port].external_phy_config));
7251 break;
7252 case EXT_PHY2:
7253 ext_phy_config = REG_RD(bp, shmem_base +
7254 offsetof(struct shmem_region,
7255 dev_info.port_hw_config[port].external_phy_config2));
7256 break;
7257 default:
7258 DP(NETIF_MSG_LINK, "Invalid phy_index %d\n", phy_index);
7259 return -EINVAL;
7260 }
7261
7262 return ext_phy_config;
7263 }
7264 static u8 bnx2x_populate_int_phy(struct bnx2x *bp, u32 shmem_base, u8 port,
7265 struct bnx2x_phy *phy)
7266 {
7267 u32 phy_addr;
7268 u32 chip_id;
7269 u32 switch_cfg = (REG_RD(bp, shmem_base +
7270 offsetof(struct shmem_region,
7271 dev_info.port_feature_config[port].link_config)) &
7272 PORT_FEATURE_CONNECTED_SWITCH_MASK);
7273 chip_id = REG_RD(bp, MISC_REG_CHIP_NUM) << 16;
7274 switch (switch_cfg) {
7275 case SWITCH_CFG_1G:
7276 phy_addr = REG_RD(bp,
7277 NIG_REG_SERDES0_CTRL_PHY_ADDR +
7278 port * 0x10);
7279 *phy = phy_serdes;
7280 break;
7281 case SWITCH_CFG_10G:
7282 phy_addr = REG_RD(bp,
7283 NIG_REG_XGXS0_CTRL_PHY_ADDR +
7284 port * 0x18);
7285 *phy = phy_xgxs;
7286 break;
7287 default:
7288 DP(NETIF_MSG_LINK, "Invalid switch_cfg\n");
7289 return -EINVAL;
7290 }
7291 phy->addr = (u8)phy_addr;
7292 phy->mdio_ctrl = bnx2x_get_emac_base(bp,
7293 SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH,
7294 port);
7295 if (CHIP_IS_E2(bp))
7296 phy->def_md_devad = E2_DEFAULT_PHY_DEV_ADDR;
7297 else
7298 phy->def_md_devad = DEFAULT_PHY_DEV_ADDR;
7299
7300 DP(NETIF_MSG_LINK, "Internal phy port=%d, addr=0x%x, mdio_ctl=0x%x\n",
7301 port, phy->addr, phy->mdio_ctrl);
7302
7303 bnx2x_populate_preemphasis(bp, shmem_base, phy, port, INT_PHY);
7304 return 0;
7305 }
7306
7307 static u8 bnx2x_populate_ext_phy(struct bnx2x *bp,
7308 u8 phy_index,
7309 u32 shmem_base,
7310 u32 shmem2_base,
7311 u8 port,
7312 struct bnx2x_phy *phy)
7313 {
7314 u32 ext_phy_config, phy_type, config2;
7315 u32 mdc_mdio_access = SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH;
7316 ext_phy_config = bnx2x_get_ext_phy_config(bp, shmem_base,
7317 phy_index, port);
7318 phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
7319 /* Select the phy type */
7320 switch (phy_type) {
7321 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
7322 mdc_mdio_access = SHARED_HW_CFG_MDC_MDIO_ACCESS1_SWAPPED;
7323 *phy = phy_8073;
7324 break;
7325 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
7326 *phy = phy_8705;
7327 break;
7328 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
7329 *phy = phy_8706;
7330 break;
7331 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
7332 mdc_mdio_access = SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1;
7333 *phy = phy_8726;
7334 break;
7335 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC:
7336 /* BCM8727_NOC => BCM8727 no over current */
7337 mdc_mdio_access = SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1;
7338 *phy = phy_8727;
7339 phy->flags |= FLAGS_NOC;
7340 break;
7341 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
7342 mdc_mdio_access = SHARED_HW_CFG_MDC_MDIO_ACCESS1_EMAC1;
7343 *phy = phy_8727;
7344 break;
7345 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
7346 *phy = phy_8481;
7347 break;
7348 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
7349 *phy = phy_84823;
7350 break;
7351 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833:
7352 *phy = phy_84833;
7353 break;
7354 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
7355 *phy = phy_7101;
7356 break;
7357 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
7358 *phy = phy_null;
7359 return -EINVAL;
7360 default:
7361 *phy = phy_null;
7362 return 0;
7363 }
7364
7365 phy->addr = XGXS_EXT_PHY_ADDR(ext_phy_config);
7366 bnx2x_populate_preemphasis(bp, shmem_base, phy, port, phy_index);
7367
7368 /*
7369 * The shmem address of the phy version is located on different
7370 * structures. In case this structure is too old, do not set
7371 * the address
7372 */
7373 config2 = REG_RD(bp, shmem_base + offsetof(struct shmem_region,
7374 dev_info.shared_hw_config.config2));
7375 if (phy_index == EXT_PHY1) {
7376 phy->ver_addr = shmem_base + offsetof(struct shmem_region,
7377 port_mb[port].ext_phy_fw_version);
7378
7379 /* Check specific mdc mdio settings */
7380 if (config2 & SHARED_HW_CFG_MDC_MDIO_ACCESS1_MASK)
7381 mdc_mdio_access = config2 &
7382 SHARED_HW_CFG_MDC_MDIO_ACCESS1_MASK;
7383 } else {
7384 u32 size = REG_RD(bp, shmem2_base);
7385
7386 if (size >
7387 offsetof(struct shmem2_region, ext_phy_fw_version2)) {
7388 phy->ver_addr = shmem2_base +
7389 offsetof(struct shmem2_region,
7390 ext_phy_fw_version2[port]);
7391 }
7392 /* Check specific mdc mdio settings */
7393 if (config2 & SHARED_HW_CFG_MDC_MDIO_ACCESS2_MASK)
7394 mdc_mdio_access = (config2 &
7395 SHARED_HW_CFG_MDC_MDIO_ACCESS2_MASK) >>
7396 (SHARED_HW_CFG_MDC_MDIO_ACCESS2_SHIFT -
7397 SHARED_HW_CFG_MDC_MDIO_ACCESS1_SHIFT);
7398 }
7399 phy->mdio_ctrl = bnx2x_get_emac_base(bp, mdc_mdio_access, port);
7400
7401 /*
7402 * In case mdc/mdio_access of the external phy is different than the
7403 * mdc/mdio access of the XGXS, a HW lock must be taken in each access
7404 * to prevent one port interfere with another port's CL45 operations.
7405 */
7406 if (mdc_mdio_access != SHARED_HW_CFG_MDC_MDIO_ACCESS1_BOTH)
7407 phy->flags |= FLAGS_HW_LOCK_REQUIRED;
7408 DP(NETIF_MSG_LINK, "phy_type 0x%x port %d found in index %d\n",
7409 phy_type, port, phy_index);
7410 DP(NETIF_MSG_LINK, " addr=0x%x, mdio_ctl=0x%x\n",
7411 phy->addr, phy->mdio_ctrl);
7412 return 0;
7413 }
7414
7415 static u8 bnx2x_populate_phy(struct bnx2x *bp, u8 phy_index, u32 shmem_base,
7416 u32 shmem2_base, u8 port, struct bnx2x_phy *phy)
7417 {
7418 u8 status = 0;
7419 phy->type = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN;
7420 if (phy_index == INT_PHY)
7421 return bnx2x_populate_int_phy(bp, shmem_base, port, phy);
7422 status = bnx2x_populate_ext_phy(bp, phy_index, shmem_base, shmem2_base,
7423 port, phy);
7424 return status;
7425 }
7426
7427 static void bnx2x_phy_def_cfg(struct link_params *params,
7428 struct bnx2x_phy *phy,
7429 u8 phy_index)
7430 {
7431 struct bnx2x *bp = params->bp;
7432 u32 link_config;
7433 /* Populate the default phy configuration for MF mode */
7434 if (phy_index == EXT_PHY2) {
7435 link_config = REG_RD(bp, params->shmem_base +
7436 offsetof(struct shmem_region, dev_info.
7437 port_feature_config[params->port].link_config2));
7438 phy->speed_cap_mask = REG_RD(bp, params->shmem_base +
7439 offsetof(struct shmem_region,
7440 dev_info.
7441 port_hw_config[params->port].speed_capability_mask2));
7442 } else {
7443 link_config = REG_RD(bp, params->shmem_base +
7444 offsetof(struct shmem_region, dev_info.
7445 port_feature_config[params->port].link_config));
7446 phy->speed_cap_mask = REG_RD(bp, params->shmem_base +
7447 offsetof(struct shmem_region,
7448 dev_info.
7449 port_hw_config[params->port].speed_capability_mask));
7450 }
7451 DP(NETIF_MSG_LINK, "Default config phy idx %x cfg 0x%x speed_cap_mask"
7452 " 0x%x\n", phy_index, link_config, phy->speed_cap_mask);
7453
7454 phy->req_duplex = DUPLEX_FULL;
7455 switch (link_config & PORT_FEATURE_LINK_SPEED_MASK) {
7456 case PORT_FEATURE_LINK_SPEED_10M_HALF:
7457 phy->req_duplex = DUPLEX_HALF;
7458 case PORT_FEATURE_LINK_SPEED_10M_FULL:
7459 phy->req_line_speed = SPEED_10;
7460 break;
7461 case PORT_FEATURE_LINK_SPEED_100M_HALF:
7462 phy->req_duplex = DUPLEX_HALF;
7463 case PORT_FEATURE_LINK_SPEED_100M_FULL:
7464 phy->req_line_speed = SPEED_100;
7465 break;
7466 case PORT_FEATURE_LINK_SPEED_1G:
7467 phy->req_line_speed = SPEED_1000;
7468 break;
7469 case PORT_FEATURE_LINK_SPEED_2_5G:
7470 phy->req_line_speed = SPEED_2500;
7471 break;
7472 case PORT_FEATURE_LINK_SPEED_10G_CX4:
7473 phy->req_line_speed = SPEED_10000;
7474 break;
7475 default:
7476 phy->req_line_speed = SPEED_AUTO_NEG;
7477 break;
7478 }
7479
7480 switch (link_config & PORT_FEATURE_FLOW_CONTROL_MASK) {
7481 case PORT_FEATURE_FLOW_CONTROL_AUTO:
7482 phy->req_flow_ctrl = BNX2X_FLOW_CTRL_AUTO;
7483 break;
7484 case PORT_FEATURE_FLOW_CONTROL_TX:
7485 phy->req_flow_ctrl = BNX2X_FLOW_CTRL_TX;
7486 break;
7487 case PORT_FEATURE_FLOW_CONTROL_RX:
7488 phy->req_flow_ctrl = BNX2X_FLOW_CTRL_RX;
7489 break;
7490 case PORT_FEATURE_FLOW_CONTROL_BOTH:
7491 phy->req_flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
7492 break;
7493 default:
7494 phy->req_flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7495 break;
7496 }
7497 }
7498
7499 u32 bnx2x_phy_selection(struct link_params *params)
7500 {
7501 u32 phy_config_swapped, prio_cfg;
7502 u32 return_cfg = PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT;
7503
7504 phy_config_swapped = params->multi_phy_config &
7505 PORT_HW_CFG_PHY_SWAPPED_ENABLED;
7506
7507 prio_cfg = params->multi_phy_config &
7508 PORT_HW_CFG_PHY_SELECTION_MASK;
7509
7510 if (phy_config_swapped) {
7511 switch (prio_cfg) {
7512 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
7513 return_cfg = PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY;
7514 break;
7515 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
7516 return_cfg = PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY;
7517 break;
7518 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
7519 return_cfg = PORT_HW_CFG_PHY_SELECTION_FIRST_PHY;
7520 break;
7521 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
7522 return_cfg = PORT_HW_CFG_PHY_SELECTION_SECOND_PHY;
7523 break;
7524 }
7525 } else
7526 return_cfg = prio_cfg;
7527
7528 return return_cfg;
7529 }
7530
7531
7532 u8 bnx2x_phy_probe(struct link_params *params)
7533 {
7534 u8 phy_index, actual_phy_idx, link_cfg_idx;
7535 u32 phy_config_swapped;
7536 struct bnx2x *bp = params->bp;
7537 struct bnx2x_phy *phy;
7538 params->num_phys = 0;
7539 DP(NETIF_MSG_LINK, "Begin phy probe\n");
7540 phy_config_swapped = params->multi_phy_config &
7541 PORT_HW_CFG_PHY_SWAPPED_ENABLED;
7542
7543 for (phy_index = INT_PHY; phy_index < MAX_PHYS;
7544 phy_index++) {
7545 link_cfg_idx = LINK_CONFIG_IDX(phy_index);
7546 actual_phy_idx = phy_index;
7547 if (phy_config_swapped) {
7548 if (phy_index == EXT_PHY1)
7549 actual_phy_idx = EXT_PHY2;
7550 else if (phy_index == EXT_PHY2)
7551 actual_phy_idx = EXT_PHY1;
7552 }
7553 DP(NETIF_MSG_LINK, "phy_config_swapped %x, phy_index %x,"
7554 " actual_phy_idx %x\n", phy_config_swapped,
7555 phy_index, actual_phy_idx);
7556 phy = &params->phy[actual_phy_idx];
7557 if (bnx2x_populate_phy(bp, phy_index, params->shmem_base,
7558 params->shmem2_base, params->port,
7559 phy) != 0) {
7560 params->num_phys = 0;
7561 DP(NETIF_MSG_LINK, "phy probe failed in phy index %d\n",
7562 phy_index);
7563 for (phy_index = INT_PHY;
7564 phy_index < MAX_PHYS;
7565 phy_index++)
7566 *phy = phy_null;
7567 return -EINVAL;
7568 }
7569 if (phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN)
7570 break;
7571
7572 bnx2x_phy_def_cfg(params, phy, phy_index);
7573 params->num_phys++;
7574 }
7575
7576 DP(NETIF_MSG_LINK, "End phy probe. #phys found %x\n", params->num_phys);
7577 return 0;
7578 }
7579
7580 static void set_phy_vars(struct link_params *params)
7581 {
7582 struct bnx2x *bp = params->bp;
7583 u8 actual_phy_idx, phy_index, link_cfg_idx;
7584 u8 phy_config_swapped = params->multi_phy_config &
7585 PORT_HW_CFG_PHY_SWAPPED_ENABLED;
7586 for (phy_index = INT_PHY; phy_index < params->num_phys;
7587 phy_index++) {
7588 link_cfg_idx = LINK_CONFIG_IDX(phy_index);
7589 actual_phy_idx = phy_index;
7590 if (phy_config_swapped) {
7591 if (phy_index == EXT_PHY1)
7592 actual_phy_idx = EXT_PHY2;
7593 else if (phy_index == EXT_PHY2)
7594 actual_phy_idx = EXT_PHY1;
7595 }
7596 params->phy[actual_phy_idx].req_flow_ctrl =
7597 params->req_flow_ctrl[link_cfg_idx];
7598
7599 params->phy[actual_phy_idx].req_line_speed =
7600 params->req_line_speed[link_cfg_idx];
7601
7602 params->phy[actual_phy_idx].speed_cap_mask =
7603 params->speed_cap_mask[link_cfg_idx];
7604
7605 params->phy[actual_phy_idx].req_duplex =
7606 params->req_duplex[link_cfg_idx];
7607
7608 DP(NETIF_MSG_LINK, "req_flow_ctrl %x, req_line_speed %x,"
7609 " speed_cap_mask %x\n",
7610 params->phy[actual_phy_idx].req_flow_ctrl,
7611 params->phy[actual_phy_idx].req_line_speed,
7612 params->phy[actual_phy_idx].speed_cap_mask);
7613 }
7614 }
7615
7616 u8 bnx2x_phy_init(struct link_params *params, struct link_vars *vars)
7617 {
7618 struct bnx2x *bp = params->bp;
7619 DP(NETIF_MSG_LINK, "Phy Initialization started\n");
7620 DP(NETIF_MSG_LINK, "(1) req_speed %d, req_flowctrl %d\n",
7621 params->req_line_speed[0], params->req_flow_ctrl[0]);
7622 DP(NETIF_MSG_LINK, "(2) req_speed %d, req_flowctrl %d\n",
7623 params->req_line_speed[1], params->req_flow_ctrl[1]);
7624 vars->link_status = 0;
7625 vars->phy_link_up = 0;
7626 vars->link_up = 0;
7627 vars->line_speed = 0;
7628 vars->duplex = DUPLEX_FULL;
7629 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7630 vars->mac_type = MAC_TYPE_NONE;
7631 vars->phy_flags = 0;
7632
7633 /* disable attentions */
7634 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + params->port*4,
7635 (NIG_MASK_XGXS0_LINK_STATUS |
7636 NIG_MASK_XGXS0_LINK10G |
7637 NIG_MASK_SERDES0_LINK_STATUS |
7638 NIG_MASK_MI_INT));
7639
7640 bnx2x_emac_init(params, vars);
7641
7642 if (params->num_phys == 0) {
7643 DP(NETIF_MSG_LINK, "No phy found for initialization !!\n");
7644 return -EINVAL;
7645 }
7646 set_phy_vars(params);
7647
7648 DP(NETIF_MSG_LINK, "Num of phys on board: %d\n", params->num_phys);
7649 if (params->loopback_mode == LOOPBACK_BMAC) {
7650
7651 vars->link_up = 1;
7652 vars->line_speed = SPEED_10000;
7653 vars->duplex = DUPLEX_FULL;
7654 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7655 vars->mac_type = MAC_TYPE_BMAC;
7656
7657 vars->phy_flags = PHY_XGXS_FLAG;
7658
7659 bnx2x_xgxs_deassert(params);
7660
7661 /* set bmac loopback */
7662 bnx2x_bmac_enable(params, vars, 1);
7663
7664 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
7665
7666 } else if (params->loopback_mode == LOOPBACK_EMAC) {
7667
7668 vars->link_up = 1;
7669 vars->line_speed = SPEED_1000;
7670 vars->duplex = DUPLEX_FULL;
7671 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7672 vars->mac_type = MAC_TYPE_EMAC;
7673
7674 vars->phy_flags = PHY_XGXS_FLAG;
7675
7676 bnx2x_xgxs_deassert(params);
7677 /* set bmac loopback */
7678 bnx2x_emac_enable(params, vars, 1);
7679 bnx2x_emac_program(params, vars);
7680 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
7681
7682 } else if ((params->loopback_mode == LOOPBACK_XGXS) ||
7683 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
7684
7685 vars->link_up = 1;
7686 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7687 vars->duplex = DUPLEX_FULL;
7688 if (params->req_line_speed[0] == SPEED_1000) {
7689 vars->line_speed = SPEED_1000;
7690 vars->mac_type = MAC_TYPE_EMAC;
7691 } else {
7692 vars->line_speed = SPEED_10000;
7693 vars->mac_type = MAC_TYPE_BMAC;
7694 }
7695
7696 bnx2x_xgxs_deassert(params);
7697 bnx2x_link_initialize(params, vars);
7698
7699 if (params->req_line_speed[0] == SPEED_1000) {
7700 bnx2x_emac_program(params, vars);
7701 bnx2x_emac_enable(params, vars, 0);
7702 } else
7703 bnx2x_bmac_enable(params, vars, 0);
7704 if (params->loopback_mode == LOOPBACK_XGXS) {
7705 /* set 10G XGXS loopback */
7706 params->phy[INT_PHY].config_loopback(
7707 &params->phy[INT_PHY],
7708 params);
7709
7710 } else {
7711 /* set external phy loopback */
7712 u8 phy_index;
7713 for (phy_index = EXT_PHY1;
7714 phy_index < params->num_phys; phy_index++) {
7715 if (params->phy[phy_index].config_loopback)
7716 params->phy[phy_index].config_loopback(
7717 &params->phy[phy_index],
7718 params);
7719 }
7720 }
7721 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
7722
7723 bnx2x_set_led(params, vars,
7724 LED_MODE_OPER, vars->line_speed);
7725 } else
7726 /* No loopback */
7727 {
7728 if (params->switch_cfg == SWITCH_CFG_10G)
7729 bnx2x_xgxs_deassert(params);
7730 else
7731 bnx2x_serdes_deassert(bp, params->port);
7732
7733 bnx2x_link_initialize(params, vars);
7734 msleep(30);
7735 bnx2x_link_int_enable(params);
7736 }
7737 return 0;
7738 }
7739 u8 bnx2x_link_reset(struct link_params *params, struct link_vars *vars,
7740 u8 reset_ext_phy)
7741 {
7742 struct bnx2x *bp = params->bp;
7743 u8 phy_index, port = params->port, clear_latch_ind = 0;
7744 DP(NETIF_MSG_LINK, "Resetting the link of port %d\n", port);
7745 /* disable attentions */
7746 vars->link_status = 0;
7747 bnx2x_update_mng(params, vars->link_status);
7748 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
7749 (NIG_MASK_XGXS0_LINK_STATUS |
7750 NIG_MASK_XGXS0_LINK10G |
7751 NIG_MASK_SERDES0_LINK_STATUS |
7752 NIG_MASK_MI_INT));
7753
7754 /* activate nig drain */
7755 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
7756
7757 /* disable nig egress interface */
7758 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
7759 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
7760
7761 /* Stop BigMac rx */
7762 bnx2x_bmac_rx_disable(bp, port);
7763
7764 /* disable emac */
7765 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
7766
7767 msleep(10);
7768 /* The PHY reset is controlled by GPIO 1
7769 * Hold it as vars low
7770 */
7771 /* clear link led */
7772 bnx2x_set_led(params, vars, LED_MODE_OFF, 0);
7773
7774 if (reset_ext_phy) {
7775 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
7776 phy_index++) {
7777 if (params->phy[phy_index].link_reset)
7778 params->phy[phy_index].link_reset(
7779 &params->phy[phy_index],
7780 params);
7781 if (params->phy[phy_index].flags &
7782 FLAGS_REARM_LATCH_SIGNAL)
7783 clear_latch_ind = 1;
7784 }
7785 }
7786
7787 if (clear_latch_ind) {
7788 /* Clear latching indication */
7789 bnx2x_rearm_latch_signal(bp, port, 0);
7790 bnx2x_bits_dis(bp, NIG_REG_LATCH_BC_0 + port*4,
7791 1 << NIG_LATCH_BC_ENABLE_MI_INT);
7792 }
7793 if (params->phy[INT_PHY].link_reset)
7794 params->phy[INT_PHY].link_reset(
7795 &params->phy[INT_PHY], params);
7796 /* reset BigMac */
7797 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7798 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
7799
7800 /* disable nig ingress interface */
7801 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0);
7802 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0);
7803 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
7804 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
7805 vars->link_up = 0;
7806 return 0;
7807 }
7808
7809 /****************************************************************************/
7810 /* Common function */
7811 /****************************************************************************/
7812 static u8 bnx2x_8073_common_init_phy(struct bnx2x *bp,
7813 u32 shmem_base_path[],
7814 u32 shmem2_base_path[], u8 phy_index,
7815 u32 chip_id)
7816 {
7817 struct bnx2x_phy phy[PORT_MAX];
7818 struct bnx2x_phy *phy_blk[PORT_MAX];
7819 u16 val;
7820 s8 port = 0;
7821 s8 port_of_path = 0;
7822 u32 swap_val, swap_override;
7823 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
7824 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
7825 port ^= (swap_val && swap_override);
7826 bnx2x_ext_phy_hw_reset(bp, port);
7827 /* PART1 - Reset both phys */
7828 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
7829 u32 shmem_base, shmem2_base;
7830 /* In E2, same phy is using for port0 of the two paths */
7831 if (CHIP_IS_E2(bp)) {
7832 shmem_base = shmem_base_path[port];
7833 shmem2_base = shmem2_base_path[port];
7834 port_of_path = 0;
7835 } else {
7836 shmem_base = shmem_base_path[0];
7837 shmem2_base = shmem2_base_path[0];
7838 port_of_path = port;
7839 }
7840
7841 /* Extract the ext phy address for the port */
7842 if (bnx2x_populate_phy(bp, phy_index, shmem_base, shmem2_base,
7843 port_of_path, &phy[port]) !=
7844 0) {
7845 DP(NETIF_MSG_LINK, "populate_phy failed\n");
7846 return -EINVAL;
7847 }
7848 /* disable attentions */
7849 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 +
7850 port_of_path*4,
7851 (NIG_MASK_XGXS0_LINK_STATUS |
7852 NIG_MASK_XGXS0_LINK10G |
7853 NIG_MASK_SERDES0_LINK_STATUS |
7854 NIG_MASK_MI_INT));
7855
7856 /* Need to take the phy out of low power mode in order
7857 to write to access its registers */
7858 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
7859 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
7860 port);
7861
7862 /* Reset the phy */
7863 bnx2x_cl45_write(bp, &phy[port],
7864 MDIO_PMA_DEVAD,
7865 MDIO_PMA_REG_CTRL,
7866 1<<15);
7867 }
7868
7869 /* Add delay of 150ms after reset */
7870 msleep(150);
7871
7872 if (phy[PORT_0].addr & 0x1) {
7873 phy_blk[PORT_0] = &(phy[PORT_1]);
7874 phy_blk[PORT_1] = &(phy[PORT_0]);
7875 } else {
7876 phy_blk[PORT_0] = &(phy[PORT_0]);
7877 phy_blk[PORT_1] = &(phy[PORT_1]);
7878 }
7879
7880 /* PART2 - Download firmware to both phys */
7881 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
7882 if (CHIP_IS_E2(bp))
7883 port_of_path = 0;
7884 else
7885 port_of_path = port;
7886
7887 DP(NETIF_MSG_LINK, "Loading spirom for phy address 0x%x\n",
7888 phy_blk[port]->addr);
7889 if (bnx2x_8073_8727_external_rom_boot(bp, phy_blk[port],
7890 port_of_path))
7891 return -EINVAL;
7892
7893 /* Only set bit 10 = 1 (Tx power down) */
7894 bnx2x_cl45_read(bp, phy_blk[port],
7895 MDIO_PMA_DEVAD,
7896 MDIO_PMA_REG_TX_POWER_DOWN, &val);
7897
7898 /* Phase1 of TX_POWER_DOWN reset */
7899 bnx2x_cl45_write(bp, phy_blk[port],
7900 MDIO_PMA_DEVAD,
7901 MDIO_PMA_REG_TX_POWER_DOWN,
7902 (val | 1<<10));
7903 }
7904
7905 /*
7906 * Toggle Transmitter: Power down and then up with 600ms delay
7907 * between
7908 */
7909 msleep(600);
7910
7911 /* PART3 - complete TX_POWER_DOWN process, and set GPIO2 back to low */
7912 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
7913 /* Phase2 of POWER_DOWN_RESET */
7914 /* Release bit 10 (Release Tx power down) */
7915 bnx2x_cl45_read(bp, phy_blk[port],
7916 MDIO_PMA_DEVAD,
7917 MDIO_PMA_REG_TX_POWER_DOWN, &val);
7918
7919 bnx2x_cl45_write(bp, phy_blk[port],
7920 MDIO_PMA_DEVAD,
7921 MDIO_PMA_REG_TX_POWER_DOWN, (val & (~(1<<10))));
7922 msleep(15);
7923
7924 /* Read modify write the SPI-ROM version select register */
7925 bnx2x_cl45_read(bp, phy_blk[port],
7926 MDIO_PMA_DEVAD,
7927 MDIO_PMA_REG_EDC_FFE_MAIN, &val);
7928 bnx2x_cl45_write(bp, phy_blk[port],
7929 MDIO_PMA_DEVAD,
7930 MDIO_PMA_REG_EDC_FFE_MAIN, (val | (1<<12)));
7931
7932 /* set GPIO2 back to LOW */
7933 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
7934 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
7935 }
7936 return 0;
7937 }
7938 static u8 bnx2x_8726_common_init_phy(struct bnx2x *bp,
7939 u32 shmem_base_path[],
7940 u32 shmem2_base_path[], u8 phy_index,
7941 u32 chip_id)
7942 {
7943 u32 val;
7944 s8 port;
7945 struct bnx2x_phy phy;
7946 /* Use port1 because of the static port-swap */
7947 /* Enable the module detection interrupt */
7948 val = REG_RD(bp, MISC_REG_GPIO_EVENT_EN);
7949 val |= ((1<<MISC_REGISTERS_GPIO_3)|
7950 (1<<(MISC_REGISTERS_GPIO_3 + MISC_REGISTERS_GPIO_PORT_SHIFT)));
7951 REG_WR(bp, MISC_REG_GPIO_EVENT_EN, val);
7952
7953 bnx2x_ext_phy_hw_reset(bp, 0);
7954 msleep(5);
7955 for (port = 0; port < PORT_MAX; port++) {
7956 u32 shmem_base, shmem2_base;
7957
7958 /* In E2, same phy is using for port0 of the two paths */
7959 if (CHIP_IS_E2(bp)) {
7960 shmem_base = shmem_base_path[port];
7961 shmem2_base = shmem2_base_path[port];
7962 } else {
7963 shmem_base = shmem_base_path[0];
7964 shmem2_base = shmem2_base_path[0];
7965 }
7966 /* Extract the ext phy address for the port */
7967 if (bnx2x_populate_phy(bp, phy_index, shmem_base, shmem2_base,
7968 port, &phy) !=
7969 0) {
7970 DP(NETIF_MSG_LINK, "populate phy failed\n");
7971 return -EINVAL;
7972 }
7973
7974 /* Reset phy*/
7975 bnx2x_cl45_write(bp, &phy,
7976 MDIO_PMA_DEVAD, MDIO_PMA_REG_GEN_CTRL, 0x0001);
7977
7978
7979 /* Set fault module detected LED on */
7980 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
7981 MISC_REGISTERS_GPIO_HIGH,
7982 port);
7983 }
7984
7985 return 0;
7986 }
7987 static void bnx2x_get_ext_phy_reset_gpio(struct bnx2x *bp, u32 shmem_base,
7988 u8 *io_gpio, u8 *io_port)
7989 {
7990
7991 u32 phy_gpio_reset = REG_RD(bp, shmem_base +
7992 offsetof(struct shmem_region,
7993 dev_info.port_hw_config[PORT_0].default_cfg));
7994 switch (phy_gpio_reset) {
7995 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P0:
7996 *io_gpio = 0;
7997 *io_port = 0;
7998 break;
7999 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P0:
8000 *io_gpio = 1;
8001 *io_port = 0;
8002 break;
8003 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P0:
8004 *io_gpio = 2;
8005 *io_port = 0;
8006 break;
8007 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P0:
8008 *io_gpio = 3;
8009 *io_port = 0;
8010 break;
8011 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO0_P1:
8012 *io_gpio = 0;
8013 *io_port = 1;
8014 break;
8015 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO1_P1:
8016 *io_gpio = 1;
8017 *io_port = 1;
8018 break;
8019 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO2_P1:
8020 *io_gpio = 2;
8021 *io_port = 1;
8022 break;
8023 case PORT_HW_CFG_EXT_PHY_GPIO_RST_GPIO3_P1:
8024 *io_gpio = 3;
8025 *io_port = 1;
8026 break;
8027 default:
8028 /* Don't override the io_gpio and io_port */
8029 break;
8030 }
8031 }
8032 static u8 bnx2x_8727_common_init_phy(struct bnx2x *bp,
8033 u32 shmem_base_path[],
8034 u32 shmem2_base_path[], u8 phy_index,
8035 u32 chip_id)
8036 {
8037 s8 port, reset_gpio;
8038 u32 swap_val, swap_override;
8039 struct bnx2x_phy phy[PORT_MAX];
8040 struct bnx2x_phy *phy_blk[PORT_MAX];
8041 s8 port_of_path;
8042 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
8043 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
8044
8045 reset_gpio = MISC_REGISTERS_GPIO_1;
8046 port = 1;
8047
8048 /*
8049 * Retrieve the reset gpio/port which control the reset.
8050 * Default is GPIO1, PORT1
8051 */
8052 bnx2x_get_ext_phy_reset_gpio(bp, shmem_base_path[0],
8053 (u8 *)&reset_gpio, (u8 *)&port);
8054
8055 /* Calculate the port based on port swap */
8056 port ^= (swap_val && swap_override);
8057
8058 /* Initiate PHY reset*/
8059 bnx2x_set_gpio(bp, reset_gpio, MISC_REGISTERS_GPIO_OUTPUT_LOW,
8060 port);
8061 msleep(1);
8062 bnx2x_set_gpio(bp, reset_gpio, MISC_REGISTERS_GPIO_OUTPUT_HIGH,
8063 port);
8064
8065 msleep(5);
8066
8067 /* PART1 - Reset both phys */
8068 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
8069 u32 shmem_base, shmem2_base;
8070
8071 /* In E2, same phy is using for port0 of the two paths */
8072 if (CHIP_IS_E2(bp)) {
8073 shmem_base = shmem_base_path[port];
8074 shmem2_base = shmem2_base_path[port];
8075 port_of_path = 0;
8076 } else {
8077 shmem_base = shmem_base_path[0];
8078 shmem2_base = shmem2_base_path[0];
8079 port_of_path = port;
8080 }
8081
8082 /* Extract the ext phy address for the port */
8083 if (bnx2x_populate_phy(bp, phy_index, shmem_base, shmem2_base,
8084 port_of_path, &phy[port]) !=
8085 0) {
8086 DP(NETIF_MSG_LINK, "populate phy failed\n");
8087 return -EINVAL;
8088 }
8089 /* disable attentions */
8090 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 +
8091 port_of_path*4,
8092 (NIG_MASK_XGXS0_LINK_STATUS |
8093 NIG_MASK_XGXS0_LINK10G |
8094 NIG_MASK_SERDES0_LINK_STATUS |
8095 NIG_MASK_MI_INT));
8096
8097
8098 /* Reset the phy */
8099 bnx2x_cl45_write(bp, &phy[port],
8100 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1<<15);
8101 }
8102
8103 /* Add delay of 150ms after reset */
8104 msleep(150);
8105 if (phy[PORT_0].addr & 0x1) {
8106 phy_blk[PORT_0] = &(phy[PORT_1]);
8107 phy_blk[PORT_1] = &(phy[PORT_0]);
8108 } else {
8109 phy_blk[PORT_0] = &(phy[PORT_0]);
8110 phy_blk[PORT_1] = &(phy[PORT_1]);
8111 }
8112 /* PART2 - Download firmware to both phys */
8113 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
8114 if (CHIP_IS_E2(bp))
8115 port_of_path = 0;
8116 else
8117 port_of_path = port;
8118 DP(NETIF_MSG_LINK, "Loading spirom for phy address 0x%x\n",
8119 phy_blk[port]->addr);
8120 if (bnx2x_8073_8727_external_rom_boot(bp, phy_blk[port],
8121 port_of_path))
8122 return -EINVAL;
8123
8124 }
8125 return 0;
8126 }
8127
8128 static u8 bnx2x_ext_phy_common_init(struct bnx2x *bp, u32 shmem_base_path[],
8129 u32 shmem2_base_path[], u8 phy_index,
8130 u32 ext_phy_type, u32 chip_id)
8131 {
8132 u8 rc = 0;
8133
8134 switch (ext_phy_type) {
8135 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
8136 rc = bnx2x_8073_common_init_phy(bp, shmem_base_path,
8137 shmem2_base_path,
8138 phy_index, chip_id);
8139 break;
8140
8141 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
8142 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC:
8143 rc = bnx2x_8727_common_init_phy(bp, shmem_base_path,
8144 shmem2_base_path,
8145 phy_index, chip_id);
8146 break;
8147
8148 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
8149 /*
8150 * GPIO1 affects both ports, so there's need to pull
8151 * it for single port alone
8152 */
8153 rc = bnx2x_8726_common_init_phy(bp, shmem_base_path,
8154 shmem2_base_path,
8155 phy_index, chip_id);
8156 break;
8157 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
8158 rc = -EINVAL;
8159 break;
8160 default:
8161 DP(NETIF_MSG_LINK,
8162 "ext_phy 0x%x common init not required\n",
8163 ext_phy_type);
8164 break;
8165 }
8166
8167 if (rc != 0)
8168 netdev_err(bp->dev, "Warning: PHY was not initialized,"
8169 " Port %d\n",
8170 0);
8171 return rc;
8172 }
8173
8174 u8 bnx2x_common_init_phy(struct bnx2x *bp, u32 shmem_base_path[],
8175 u32 shmem2_base_path[], u32 chip_id)
8176 {
8177 u8 rc = 0;
8178 u32 phy_ver;
8179 u8 phy_index;
8180 u32 ext_phy_type, ext_phy_config;
8181 DP(NETIF_MSG_LINK, "Begin common phy init\n");
8182
8183 /* Check if common init was already done */
8184 phy_ver = REG_RD(bp, shmem_base_path[0] +
8185 offsetof(struct shmem_region,
8186 port_mb[PORT_0].ext_phy_fw_version));
8187 if (phy_ver) {
8188 DP(NETIF_MSG_LINK, "Not doing common init; phy ver is 0x%x\n",
8189 phy_ver);
8190 return 0;
8191 }
8192
8193 /* Read the ext_phy_type for arbitrary port(0) */
8194 for (phy_index = EXT_PHY1; phy_index < MAX_PHYS;
8195 phy_index++) {
8196 ext_phy_config = bnx2x_get_ext_phy_config(bp,
8197 shmem_base_path[0],
8198 phy_index, 0);
8199 ext_phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
8200 rc |= bnx2x_ext_phy_common_init(bp, shmem_base_path,
8201 shmem2_base_path,
8202 phy_index, ext_phy_type,
8203 chip_id);
8204 }
8205 return rc;
8206 }
8207
8208 u8 bnx2x_hw_lock_required(struct bnx2x *bp, u32 shmem_base, u32 shmem2_base)
8209 {
8210 u8 phy_index;
8211 struct bnx2x_phy phy;
8212 for (phy_index = INT_PHY; phy_index < MAX_PHYS;
8213 phy_index++) {
8214 if (bnx2x_populate_phy(bp, phy_index, shmem_base, shmem2_base,
8215 0, &phy) != 0) {
8216 DP(NETIF_MSG_LINK, "populate phy failed\n");
8217 return 0;
8218 }
8219
8220 if (phy.flags & FLAGS_HW_LOCK_REQUIRED)
8221 return 1;
8222 }
8223 return 0;
8224 }
8225
8226 u8 bnx2x_fan_failure_det_req(struct bnx2x *bp,
8227 u32 shmem_base,
8228 u32 shmem2_base,
8229 u8 port)
8230 {
8231 u8 phy_index, fan_failure_det_req = 0;
8232 struct bnx2x_phy phy;
8233 for (phy_index = EXT_PHY1; phy_index < MAX_PHYS;
8234 phy_index++) {
8235 if (bnx2x_populate_phy(bp, phy_index, shmem_base, shmem2_base,
8236 port, &phy)
8237 != 0) {
8238 DP(NETIF_MSG_LINK, "populate phy failed\n");
8239 return 0;
8240 }
8241 fan_failure_det_req |= (phy.flags &
8242 FLAGS_FAN_FAILURE_DET_REQ);
8243 }
8244 return fan_failure_det_req;
8245 }
8246
8247 void bnx2x_hw_reset_phy(struct link_params *params)
8248 {
8249 u8 phy_index;
8250 for (phy_index = EXT_PHY1; phy_index < MAX_PHYS;
8251 phy_index++) {
8252 if (params->phy[phy_index].hw_reset) {
8253 params->phy[phy_index].hw_reset(
8254 &params->phy[phy_index],
8255 params);
8256 params->phy[phy_index] = phy_null;
8257 }
8258 }
8259 }
Mirror of the linux-mips.org kernel tree