?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
firewire: core: check for 1394a compliant IRM, fix inaccessibility of Sony camcorder
[firewire-audio.git] / drivers / net / bnx2x_link.c
blobff70be898765d79b5ca45e83332fb4bd810de948
1 /* Copyright 2008-2009 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 #define ETH_OVREHEAD (ETH_HLEN + 8)/* 8 for CRC + VLAN*/
32 #define ETH_MIN_PACKET_SIZE 60
33 #define ETH_MAX_PACKET_SIZE 1500
34 #define ETH_MAX_JUMBO_PACKET_SIZE 9600
35 #define MDIO_ACCESS_TIMEOUT 1000
36 #define BMAC_CONTROL_RX_ENABLE 2
37
38 /***********************************************************/
39 /* Shortcut definitions */
40 /***********************************************************/
41
42 #define NIG_LATCH_BC_ENABLE_MI_INT 0
43
44 #define NIG_STATUS_EMAC0_MI_INT \
45 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_EMAC0_MISC_MI_INT
46 #define NIG_STATUS_XGXS0_LINK10G \
47 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK10G
48 #define NIG_STATUS_XGXS0_LINK_STATUS \
49 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS
50 #define NIG_STATUS_XGXS0_LINK_STATUS_SIZE \
51 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS_SIZE
52 #define NIG_STATUS_SERDES0_LINK_STATUS \
53 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_SERDES0_LINK_STATUS
54 #define NIG_MASK_MI_INT \
55 NIG_MASK_INTERRUPT_PORT0_REG_MASK_EMAC0_MISC_MI_INT
56 #define NIG_MASK_XGXS0_LINK10G \
57 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK10G
58 #define NIG_MASK_XGXS0_LINK_STATUS \
59 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK_STATUS
60 #define NIG_MASK_SERDES0_LINK_STATUS \
61 NIG_MASK_INTERRUPT_PORT0_REG_MASK_SERDES0_LINK_STATUS
62
63 #define MDIO_AN_CL73_OR_37_COMPLETE \
64 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE | \
65 MDIO_GP_STATUS_TOP_AN_STATUS1_CL37_AUTONEG_COMPLETE)
66
67 #define XGXS_RESET_BITS \
68 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_RSTB_HW | \
69 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_IDDQ | \
70 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN | \
71 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN_SD | \
72 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_TXD_FIFO_RSTB)
73
74 #define SERDES_RESET_BITS \
75 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_RSTB_HW | \
76 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_IDDQ | \
77 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN | \
78 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN_SD)
79
80 #define AUTONEG_CL37 SHARED_HW_CFG_AN_ENABLE_CL37
81 #define AUTONEG_CL73 SHARED_HW_CFG_AN_ENABLE_CL73
82 #define AUTONEG_BAM SHARED_HW_CFG_AN_ENABLE_BAM
83 #define AUTONEG_PARALLEL \
84 SHARED_HW_CFG_AN_ENABLE_PARALLEL_DETECTION
85 #define AUTONEG_SGMII_FIBER_AUTODET \
86 SHARED_HW_CFG_AN_EN_SGMII_FIBER_AUTO_DETECT
87 #define AUTONEG_REMOTE_PHY SHARED_HW_CFG_AN_ENABLE_REMOTE_PHY
88
89 #define GP_STATUS_PAUSE_RSOLUTION_TXSIDE \
90 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_TXSIDE
91 #define GP_STATUS_PAUSE_RSOLUTION_RXSIDE \
92 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_RXSIDE
93 #define GP_STATUS_SPEED_MASK \
94 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_MASK
95 #define GP_STATUS_10M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10M
96 #define GP_STATUS_100M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_100M
97 #define GP_STATUS_1G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G
98 #define GP_STATUS_2_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_2_5G
99 #define GP_STATUS_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_5G
100 #define GP_STATUS_6G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_6G
101 #define GP_STATUS_10G_HIG \
102 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_HIG
103 #define GP_STATUS_10G_CX4 \
104 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_CX4
105 #define GP_STATUS_12G_HIG \
106 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12G_HIG
107 #define GP_STATUS_12_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12_5G
108 #define GP_STATUS_13G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_13G
109 #define GP_STATUS_15G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_15G
110 #define GP_STATUS_16G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_16G
111 #define GP_STATUS_1G_KX MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G_KX
112 #define GP_STATUS_10G_KX4 \
113 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_KX4
114
115 #define LINK_10THD LINK_STATUS_SPEED_AND_DUPLEX_10THD
116 #define LINK_10TFD LINK_STATUS_SPEED_AND_DUPLEX_10TFD
117 #define LINK_100TXHD LINK_STATUS_SPEED_AND_DUPLEX_100TXHD
118 #define LINK_100T4 LINK_STATUS_SPEED_AND_DUPLEX_100T4
119 #define LINK_100TXFD LINK_STATUS_SPEED_AND_DUPLEX_100TXFD
120 #define LINK_1000THD LINK_STATUS_SPEED_AND_DUPLEX_1000THD
121 #define LINK_1000TFD LINK_STATUS_SPEED_AND_DUPLEX_1000TFD
122 #define LINK_1000XFD LINK_STATUS_SPEED_AND_DUPLEX_1000XFD
123 #define LINK_2500THD LINK_STATUS_SPEED_AND_DUPLEX_2500THD
124 #define LINK_2500TFD LINK_STATUS_SPEED_AND_DUPLEX_2500TFD
125 #define LINK_2500XFD LINK_STATUS_SPEED_AND_DUPLEX_2500XFD
126 #define LINK_10GTFD LINK_STATUS_SPEED_AND_DUPLEX_10GTFD
127 #define LINK_10GXFD LINK_STATUS_SPEED_AND_DUPLEX_10GXFD
128 #define LINK_12GTFD LINK_STATUS_SPEED_AND_DUPLEX_12GTFD
129 #define LINK_12GXFD LINK_STATUS_SPEED_AND_DUPLEX_12GXFD
130 #define LINK_12_5GTFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GTFD
131 #define LINK_12_5GXFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GXFD
132 #define LINK_13GTFD LINK_STATUS_SPEED_AND_DUPLEX_13GTFD
133 #define LINK_13GXFD LINK_STATUS_SPEED_AND_DUPLEX_13GXFD
134 #define LINK_15GTFD LINK_STATUS_SPEED_AND_DUPLEX_15GTFD
135 #define LINK_15GXFD LINK_STATUS_SPEED_AND_DUPLEX_15GXFD
136 #define LINK_16GTFD LINK_STATUS_SPEED_AND_DUPLEX_16GTFD
137 #define LINK_16GXFD LINK_STATUS_SPEED_AND_DUPLEX_16GXFD
138
139 #define PHY_XGXS_FLAG 0x1
140 #define PHY_SGMII_FLAG 0x2
141 #define PHY_SERDES_FLAG 0x4
142
143 /* */
144 #define SFP_EEPROM_CON_TYPE_ADDR 0x2
145 #define SFP_EEPROM_CON_TYPE_VAL_LC 0x7
146 #define SFP_EEPROM_CON_TYPE_VAL_COPPER 0x21
147
148
149 #define SFP_EEPROM_COMP_CODE_ADDR 0x3
150 #define SFP_EEPROM_COMP_CODE_SR_MASK (1<<4)
151 #define SFP_EEPROM_COMP_CODE_LR_MASK (1<<5)
152 #define SFP_EEPROM_COMP_CODE_LRM_MASK (1<<6)
153
154 #define SFP_EEPROM_FC_TX_TECH_ADDR 0x8
155 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE 0x4
156 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE 0x8
157
158 #define SFP_EEPROM_OPTIONS_ADDR 0x40
159 #define SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK 0x1
160 #define SFP_EEPROM_OPTIONS_SIZE 2
161
162 #define EDC_MODE_LINEAR 0x0022
163 #define EDC_MODE_LIMITING 0x0044
164 #define EDC_MODE_PASSIVE_DAC 0x0055
165
166
167
168 /**********************************************************/
169 /* INTERFACE */
170 /**********************************************************/
171 #define CL45_WR_OVER_CL22(_bp, _port, _phy_addr, _bank, _addr, _val) \
172 bnx2x_cl45_write(_bp, _port, 0, _phy_addr, \
173 DEFAULT_PHY_DEV_ADDR, \
174 (_bank + (_addr & 0xf)), \
175 _val)
176
177 #define CL45_RD_OVER_CL22(_bp, _port, _phy_addr, _bank, _addr, _val) \
178 bnx2x_cl45_read(_bp, _port, 0, _phy_addr, \
179 DEFAULT_PHY_DEV_ADDR, \
180 (_bank + (_addr & 0xf)), \
181 _val)
182
183 static void bnx2x_set_serdes_access(struct link_params *params)
184 {
185 struct bnx2x *bp = params->bp;
186 u32 emac_base = (params->port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
187
188 /* Set Clause 22 */
189 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + params->port*0x10, 1);
190 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245f8000);
191 udelay(500);
192 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245d000f);
193 udelay(500);
194 /* Set Clause 45 */
195 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + params->port*0x10, 0);
196 }
197 static void bnx2x_set_phy_mdio(struct link_params *params, u8 phy_flags)
198 {
199 struct bnx2x *bp = params->bp;
200
201 if (phy_flags & PHY_XGXS_FLAG) {
202 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_ST +
203 params->port*0x18, 0);
204 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + params->port*0x18,
205 DEFAULT_PHY_DEV_ADDR);
206 } else {
207 bnx2x_set_serdes_access(params);
208
209 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_DEVAD +
210 params->port*0x10,
211 DEFAULT_PHY_DEV_ADDR);
212 }
213 }
214
215 static u32 bnx2x_bits_en(struct bnx2x *bp, u32 reg, u32 bits)
216 {
217 u32 val = REG_RD(bp, reg);
218
219 val |= bits;
220 REG_WR(bp, reg, val);
221 return val;
222 }
223
224 static u32 bnx2x_bits_dis(struct bnx2x *bp, u32 reg, u32 bits)
225 {
226 u32 val = REG_RD(bp, reg);
227
228 val &= ~bits;
229 REG_WR(bp, reg, val);
230 return val;
231 }
232
233 static void bnx2x_emac_init(struct link_params *params,
234 struct link_vars *vars)
235 {
236 /* reset and unreset the emac core */
237 struct bnx2x *bp = params->bp;
238 u8 port = params->port;
239 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
240 u32 val;
241 u16 timeout;
242
243 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
244 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
245 udelay(5);
246 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
247 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
248
249 /* init emac - use read-modify-write */
250 /* self clear reset */
251 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
252 EMAC_WR(bp, EMAC_REG_EMAC_MODE, (val | EMAC_MODE_RESET));
253
254 timeout = 200;
255 do {
256 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
257 DP(NETIF_MSG_LINK, "EMAC reset reg is %u\n", val);
258 if (!timeout) {
259 DP(NETIF_MSG_LINK, "EMAC timeout!\n");
260 return;
261 }
262 timeout--;
263 } while (val & EMAC_MODE_RESET);
264
265 /* Set mac address */
266 val = ((params->mac_addr[0] << 8) |
267 params->mac_addr[1]);
268 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH, val);
269
270 val = ((params->mac_addr[2] << 24) |
271 (params->mac_addr[3] << 16) |
272 (params->mac_addr[4] << 8) |
273 params->mac_addr[5]);
274 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + 4, val);
275 }
276
277 static u8 bnx2x_emac_enable(struct link_params *params,
278 struct link_vars *vars, u8 lb)
279 {
280 struct bnx2x *bp = params->bp;
281 u8 port = params->port;
282 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
283 u32 val;
284
285 DP(NETIF_MSG_LINK, "enabling EMAC\n");
286
287 /* enable emac and not bmac */
288 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 1);
289
290 /* for paladium */
291 if (CHIP_REV_IS_EMUL(bp)) {
292 /* Use lane 1 (of lanes 0-3) */
293 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
294 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
295 port*4, 1);
296 }
297 /* for fpga */
298 else
299
300 if (CHIP_REV_IS_FPGA(bp)) {
301 /* Use lane 1 (of lanes 0-3) */
302 DP(NETIF_MSG_LINK, "bnx2x_emac_enable: Setting FPGA\n");
303
304 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
305 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4,
306 0);
307 } else
308 /* ASIC */
309 if (vars->phy_flags & PHY_XGXS_FLAG) {
310 u32 ser_lane = ((params->lane_config &
311 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
312 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
313
314 DP(NETIF_MSG_LINK, "XGXS\n");
315 /* select the master lanes (out of 0-3) */
316 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 +
317 port*4, ser_lane);
318 /* select XGXS */
319 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
320 port*4, 1);
321
322 } else { /* SerDes */
323 DP(NETIF_MSG_LINK, "SerDes\n");
324 /* select SerDes */
325 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
326 port*4, 0);
327 }
328
329 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
330 EMAC_RX_MODE_RESET);
331 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
332 EMAC_TX_MODE_RESET);
333
334 if (CHIP_REV_IS_SLOW(bp)) {
335 /* config GMII mode */
336 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
337 EMAC_WR(bp, EMAC_REG_EMAC_MODE,
338 (val | EMAC_MODE_PORT_GMII));
339 } else { /* ASIC */
340 /* pause enable/disable */
341 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
342 EMAC_RX_MODE_FLOW_EN);
343 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
344 bnx2x_bits_en(bp, emac_base +
345 EMAC_REG_EMAC_RX_MODE,
346 EMAC_RX_MODE_FLOW_EN);
347
348 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
349 (EMAC_TX_MODE_EXT_PAUSE_EN |
350 EMAC_TX_MODE_FLOW_EN));
351 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
352 bnx2x_bits_en(bp, emac_base +
353 EMAC_REG_EMAC_TX_MODE,
354 (EMAC_TX_MODE_EXT_PAUSE_EN |
355 EMAC_TX_MODE_FLOW_EN));
356 }
357
358 /* KEEP_VLAN_TAG, promiscuous */
359 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_RX_MODE);
360 val |= EMAC_RX_MODE_KEEP_VLAN_TAG | EMAC_RX_MODE_PROMISCUOUS;
361 EMAC_WR(bp, EMAC_REG_EMAC_RX_MODE, val);
362
363 /* Set Loopback */
364 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
365 if (lb)
366 val |= 0x810;
367 else
368 val &= ~0x810;
369 EMAC_WR(bp, EMAC_REG_EMAC_MODE, val);
370
371 /* enable emac */
372 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 1);
373
374 /* enable emac for jumbo packets */
375 EMAC_WR(bp, EMAC_REG_EMAC_RX_MTU_SIZE,
376 (EMAC_RX_MTU_SIZE_JUMBO_ENA |
377 (ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD)));
378
379 /* strip CRC */
380 REG_WR(bp, NIG_REG_NIG_INGRESS_EMAC0_NO_CRC + port*4, 0x1);
381
382 /* disable the NIG in/out to the bmac */
383 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x0);
384 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, 0x0);
385 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x0);
386
387 /* enable the NIG in/out to the emac */
388 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x1);
389 val = 0;
390 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
391 val = 1;
392
393 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, val);
394 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x1);
395
396 if (CHIP_REV_IS_EMUL(bp)) {
397 /* take the BigMac out of reset */
398 REG_WR(bp,
399 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
400 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
401
402 /* enable access for bmac registers */
403 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
404 } else
405 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x0);
406
407 vars->mac_type = MAC_TYPE_EMAC;
408 return 0;
409 }
410
411
412
413 static u8 bnx2x_bmac_enable(struct link_params *params, struct link_vars *vars,
414 u8 is_lb)
415 {
416 struct bnx2x *bp = params->bp;
417 u8 port = params->port;
418 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
419 NIG_REG_INGRESS_BMAC0_MEM;
420 u32 wb_data[2];
421 u32 val;
422
423 DP(NETIF_MSG_LINK, "Enabling BigMAC\n");
424 /* reset and unreset the BigMac */
425 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
426 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
427 msleep(1);
428
429 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
430 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
431
432 /* enable access for bmac registers */
433 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
434
435 /* XGXS control */
436 wb_data[0] = 0x3c;
437 wb_data[1] = 0;
438 REG_WR_DMAE(bp, bmac_addr +
439 BIGMAC_REGISTER_BMAC_XGXS_CONTROL,
440 wb_data, 2);
441
442 /* tx MAC SA */
443 wb_data[0] = ((params->mac_addr[2] << 24) |
444 (params->mac_addr[3] << 16) |
445 (params->mac_addr[4] << 8) |
446 params->mac_addr[5]);
447 wb_data[1] = ((params->mac_addr[0] << 8) |
448 params->mac_addr[1]);
449 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_SOURCE_ADDR,
450 wb_data, 2);
451
452 /* tx control */
453 val = 0xc0;
454 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
455 val |= 0x800000;
456 wb_data[0] = val;
457 wb_data[1] = 0;
458 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_CONTROL,
459 wb_data, 2);
460
461 /* mac control */
462 val = 0x3;
463 if (is_lb) {
464 val |= 0x4;
465 DP(NETIF_MSG_LINK, "enable bmac loopback\n");
466 }
467 wb_data[0] = val;
468 wb_data[1] = 0;
469 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
470 wb_data, 2);
471
472 /* set rx mtu */
473 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
474 wb_data[1] = 0;
475 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_MAX_SIZE,
476 wb_data, 2);
477
478 /* rx control set to don't strip crc */
479 val = 0x14;
480 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
481 val |= 0x20;
482 wb_data[0] = val;
483 wb_data[1] = 0;
484 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_CONTROL,
485 wb_data, 2);
486
487 /* set tx mtu */
488 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
489 wb_data[1] = 0;
490 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_MAX_SIZE,
491 wb_data, 2);
492
493 /* set cnt max size */
494 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
495 wb_data[1] = 0;
496 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_CNT_MAX_SIZE,
497 wb_data, 2);
498
499 /* configure safc */
500 wb_data[0] = 0x1000200;
501 wb_data[1] = 0;
502 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LLFC_MSG_FLDS,
503 wb_data, 2);
504 /* fix for emulation */
505 if (CHIP_REV_IS_EMUL(bp)) {
506 wb_data[0] = 0xf000;
507 wb_data[1] = 0;
508 REG_WR_DMAE(bp,
509 bmac_addr + BIGMAC_REGISTER_TX_PAUSE_THRESHOLD,
510 wb_data, 2);
511 }
512
513 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0x1);
514 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 0x0);
515 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 0x0);
516 val = 0;
517 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
518 val = 1;
519 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, val);
520 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x0);
521 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x0);
522 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, 0x0);
523 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x1);
524 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x1);
525
526 vars->mac_type = MAC_TYPE_BMAC;
527 return 0;
528 }
529
530 static void bnx2x_phy_deassert(struct link_params *params, u8 phy_flags)
531 {
532 struct bnx2x *bp = params->bp;
533 u32 val;
534
535 if (phy_flags & PHY_XGXS_FLAG) {
536 DP(NETIF_MSG_LINK, "bnx2x_phy_deassert:XGXS\n");
537 val = XGXS_RESET_BITS;
538
539 } else { /* SerDes */
540 DP(NETIF_MSG_LINK, "bnx2x_phy_deassert:SerDes\n");
541 val = SERDES_RESET_BITS;
542 }
543
544 val = val << (params->port*16);
545
546 /* reset and unreset the SerDes/XGXS */
547 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
548 val);
549 udelay(500);
550 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET,
551 val);
552 bnx2x_set_phy_mdio(params, phy_flags);
553 }
554
555 void bnx2x_link_status_update(struct link_params *params,
556 struct link_vars *vars)
557 {
558 struct bnx2x *bp = params->bp;
559 u8 link_10g;
560 u8 port = params->port;
561
562 if (params->switch_cfg == SWITCH_CFG_1G)
563 vars->phy_flags = PHY_SERDES_FLAG;
564 else
565 vars->phy_flags = PHY_XGXS_FLAG;
566 vars->link_status = REG_RD(bp, params->shmem_base +
567 offsetof(struct shmem_region,
568 port_mb[port].link_status));
569
570 vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
571
572 if (vars->link_up) {
573 DP(NETIF_MSG_LINK, "phy link up\n");
574
575 vars->phy_link_up = 1;
576 vars->duplex = DUPLEX_FULL;
577 switch (vars->link_status &
578 LINK_STATUS_SPEED_AND_DUPLEX_MASK) {
579 case LINK_10THD:
580 vars->duplex = DUPLEX_HALF;
581 /* fall thru */
582 case LINK_10TFD:
583 vars->line_speed = SPEED_10;
584 break;
585
586 case LINK_100TXHD:
587 vars->duplex = DUPLEX_HALF;
588 /* fall thru */
589 case LINK_100T4:
590 case LINK_100TXFD:
591 vars->line_speed = SPEED_100;
592 break;
593
594 case LINK_1000THD:
595 vars->duplex = DUPLEX_HALF;
596 /* fall thru */
597 case LINK_1000TFD:
598 vars->line_speed = SPEED_1000;
599 break;
600
601 case LINK_2500THD:
602 vars->duplex = DUPLEX_HALF;
603 /* fall thru */
604 case LINK_2500TFD:
605 vars->line_speed = SPEED_2500;
606 break;
607
608 case LINK_10GTFD:
609 vars->line_speed = SPEED_10000;
610 break;
611
612 case LINK_12GTFD:
613 vars->line_speed = SPEED_12000;
614 break;
615
616 case LINK_12_5GTFD:
617 vars->line_speed = SPEED_12500;
618 break;
619
620 case LINK_13GTFD:
621 vars->line_speed = SPEED_13000;
622 break;
623
624 case LINK_15GTFD:
625 vars->line_speed = SPEED_15000;
626 break;
627
628 case LINK_16GTFD:
629 vars->line_speed = SPEED_16000;
630 break;
631
632 default:
633 break;
634 }
635
636 if (vars->link_status & LINK_STATUS_TX_FLOW_CONTROL_ENABLED)
637 vars->flow_ctrl |= BNX2X_FLOW_CTRL_TX;
638 else
639 vars->flow_ctrl &= ~BNX2X_FLOW_CTRL_TX;
640
641 if (vars->link_status & LINK_STATUS_RX_FLOW_CONTROL_ENABLED)
642 vars->flow_ctrl |= BNX2X_FLOW_CTRL_RX;
643 else
644 vars->flow_ctrl &= ~BNX2X_FLOW_CTRL_RX;
645
646 if (vars->phy_flags & PHY_XGXS_FLAG) {
647 if (vars->line_speed &&
648 ((vars->line_speed == SPEED_10) ||
649 (vars->line_speed == SPEED_100))) {
650 vars->phy_flags |= PHY_SGMII_FLAG;
651 } else {
652 vars->phy_flags &= ~PHY_SGMII_FLAG;
653 }
654 }
655
656 /* anything 10 and over uses the bmac */
657 link_10g = ((vars->line_speed == SPEED_10000) ||
658 (vars->line_speed == SPEED_12000) ||
659 (vars->line_speed == SPEED_12500) ||
660 (vars->line_speed == SPEED_13000) ||
661 (vars->line_speed == SPEED_15000) ||
662 (vars->line_speed == SPEED_16000));
663 if (link_10g)
664 vars->mac_type = MAC_TYPE_BMAC;
665 else
666 vars->mac_type = MAC_TYPE_EMAC;
667
668 } else { /* link down */
669 DP(NETIF_MSG_LINK, "phy link down\n");
670
671 vars->phy_link_up = 0;
672
673 vars->line_speed = 0;
674 vars->duplex = DUPLEX_FULL;
675 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
676
677 /* indicate no mac active */
678 vars->mac_type = MAC_TYPE_NONE;
679 }
680
681 DP(NETIF_MSG_LINK, "link_status 0x%x phy_link_up %x\n",
682 vars->link_status, vars->phy_link_up);
683 DP(NETIF_MSG_LINK, "line_speed %x duplex %x flow_ctrl 0x%x\n",
684 vars->line_speed, vars->duplex, vars->flow_ctrl);
685 }
686
687 static void bnx2x_update_mng(struct link_params *params, u32 link_status)
688 {
689 struct bnx2x *bp = params->bp;
690
691 REG_WR(bp, params->shmem_base +
692 offsetof(struct shmem_region,
693 port_mb[params->port].link_status),
694 link_status);
695 }
696
697 static void bnx2x_bmac_rx_disable(struct bnx2x *bp, u8 port)
698 {
699 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
700 NIG_REG_INGRESS_BMAC0_MEM;
701 u32 wb_data[2];
702 u32 nig_bmac_enable = REG_RD(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4);
703
704 /* Only if the bmac is out of reset */
705 if (REG_RD(bp, MISC_REG_RESET_REG_2) &
706 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port) &&
707 nig_bmac_enable) {
708
709 /* Clear Rx Enable bit in BMAC_CONTROL register */
710 REG_RD_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
711 wb_data, 2);
712 wb_data[0] &= ~BMAC_CONTROL_RX_ENABLE;
713 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
714 wb_data, 2);
715
716 msleep(1);
717 }
718 }
719
720 static u8 bnx2x_pbf_update(struct link_params *params, u32 flow_ctrl,
721 u32 line_speed)
722 {
723 struct bnx2x *bp = params->bp;
724 u8 port = params->port;
725 u32 init_crd, crd;
726 u32 count = 1000;
727
728 /* disable port */
729 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x1);
730
731 /* wait for init credit */
732 init_crd = REG_RD(bp, PBF_REG_P0_INIT_CRD + port*4);
733 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
734 DP(NETIF_MSG_LINK, "init_crd 0x%x crd 0x%x\n", init_crd, crd);
735
736 while ((init_crd != crd) && count) {
737 msleep(5);
738
739 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
740 count--;
741 }
742 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
743 if (init_crd != crd) {
744 DP(NETIF_MSG_LINK, "BUG! init_crd 0x%x != crd 0x%x\n",
745 init_crd, crd);
746 return -EINVAL;
747 }
748
749 if (flow_ctrl & BNX2X_FLOW_CTRL_RX ||
750 line_speed == SPEED_10 ||
751 line_speed == SPEED_100 ||
752 line_speed == SPEED_1000 ||
753 line_speed == SPEED_2500) {
754 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 1);
755 /* update threshold */
756 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, 0);
757 /* update init credit */
758 init_crd = 778; /* (800-18-4) */
759
760 } else {
761 u32 thresh = (ETH_MAX_JUMBO_PACKET_SIZE +
762 ETH_OVREHEAD)/16;
763 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
764 /* update threshold */
765 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, thresh);
766 /* update init credit */
767 switch (line_speed) {
768 case SPEED_10000:
769 init_crd = thresh + 553 - 22;
770 break;
771
772 case SPEED_12000:
773 init_crd = thresh + 664 - 22;
774 break;
775
776 case SPEED_13000:
777 init_crd = thresh + 742 - 22;
778 break;
779
780 case SPEED_16000:
781 init_crd = thresh + 778 - 22;
782 break;
783 default:
784 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
785 line_speed);
786 return -EINVAL;
787 }
788 }
789 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, init_crd);
790 DP(NETIF_MSG_LINK, "PBF updated to speed %d credit %d\n",
791 line_speed, init_crd);
792
793 /* probe the credit changes */
794 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x1);
795 msleep(5);
796 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x0);
797
798 /* enable port */
799 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x0);
800 return 0;
801 }
802
803 static u32 bnx2x_get_emac_base(struct bnx2x *bp, u32 ext_phy_type, u8 port)
804 {
805 u32 emac_base;
806
807 switch (ext_phy_type) {
808 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
809 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
810 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
811 /* All MDC/MDIO is directed through single EMAC */
812 if (REG_RD(bp, NIG_REG_PORT_SWAP))
813 emac_base = GRCBASE_EMAC0;
814 else
815 emac_base = GRCBASE_EMAC1;
816 break;
817 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
818 emac_base = (port) ? GRCBASE_EMAC0 : GRCBASE_EMAC1;
819 break;
820 default:
821 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
822 break;
823 }
824 return emac_base;
825
826 }
827
828 u8 bnx2x_cl45_write(struct bnx2x *bp, u8 port, u32 ext_phy_type,
829 u8 phy_addr, u8 devad, u16 reg, u16 val)
830 {
831 u32 tmp, saved_mode;
832 u8 i, rc = 0;
833 u32 mdio_ctrl = bnx2x_get_emac_base(bp, ext_phy_type, port);
834
835 /* set clause 45 mode, slow down the MDIO clock to 2.5MHz
836 * (a value of 49==0x31) and make sure that the AUTO poll is off
837 */
838
839 saved_mode = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
840 tmp = saved_mode & ~(EMAC_MDIO_MODE_AUTO_POLL |
841 EMAC_MDIO_MODE_CLOCK_CNT);
842 tmp |= (EMAC_MDIO_MODE_CLAUSE_45 |
843 (49 << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
844 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, tmp);
845 REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
846 udelay(40);
847
848 /* address */
849
850 tmp = ((phy_addr << 21) | (devad << 16) | reg |
851 EMAC_MDIO_COMM_COMMAND_ADDRESS |
852 EMAC_MDIO_COMM_START_BUSY);
853 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
854
855 for (i = 0; i < 50; i++) {
856 udelay(10);
857
858 tmp = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
859 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
860 udelay(5);
861 break;
862 }
863 }
864 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
865 DP(NETIF_MSG_LINK, "write phy register failed\n");
866 rc = -EFAULT;
867 } else {
868 /* data */
869 tmp = ((phy_addr << 21) | (devad << 16) | val |
870 EMAC_MDIO_COMM_COMMAND_WRITE_45 |
871 EMAC_MDIO_COMM_START_BUSY);
872 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
873
874 for (i = 0; i < 50; i++) {
875 udelay(10);
876
877 tmp = REG_RD(bp, mdio_ctrl +
878 EMAC_REG_EMAC_MDIO_COMM);
879 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
880 udelay(5);
881 break;
882 }
883 }
884 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
885 DP(NETIF_MSG_LINK, "write phy register failed\n");
886 rc = -EFAULT;
887 }
888 }
889
890 /* Restore the saved mode */
891 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
892
893 return rc;
894 }
895
896 u8 bnx2x_cl45_read(struct bnx2x *bp, u8 port, u32 ext_phy_type,
897 u8 phy_addr, u8 devad, u16 reg, u16 *ret_val)
898 {
899 u32 val, saved_mode;
900 u16 i;
901 u8 rc = 0;
902
903 u32 mdio_ctrl = bnx2x_get_emac_base(bp, ext_phy_type, port);
904 /* set clause 45 mode, slow down the MDIO clock to 2.5MHz
905 * (a value of 49==0x31) and make sure that the AUTO poll is off
906 */
907
908 saved_mode = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
909 val = saved_mode & ((EMAC_MDIO_MODE_AUTO_POLL |
910 EMAC_MDIO_MODE_CLOCK_CNT));
911 val |= (EMAC_MDIO_MODE_CLAUSE_45 |
912 (49L << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
913 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, val);
914 REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
915 udelay(40);
916
917 /* address */
918 val = ((phy_addr << 21) | (devad << 16) | reg |
919 EMAC_MDIO_COMM_COMMAND_ADDRESS |
920 EMAC_MDIO_COMM_START_BUSY);
921 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
922
923 for (i = 0; i < 50; i++) {
924 udelay(10);
925
926 val = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
927 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
928 udelay(5);
929 break;
930 }
931 }
932 if (val & EMAC_MDIO_COMM_START_BUSY) {
933 DP(NETIF_MSG_LINK, "read phy register failed\n");
934
935 *ret_val = 0;
936 rc = -EFAULT;
937
938 } else {
939 /* data */
940 val = ((phy_addr << 21) | (devad << 16) |
941 EMAC_MDIO_COMM_COMMAND_READ_45 |
942 EMAC_MDIO_COMM_START_BUSY);
943 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
944
945 for (i = 0; i < 50; i++) {
946 udelay(10);
947
948 val = REG_RD(bp, mdio_ctrl +
949 EMAC_REG_EMAC_MDIO_COMM);
950 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
951 *ret_val = (u16)(val & EMAC_MDIO_COMM_DATA);
952 break;
953 }
954 }
955 if (val & EMAC_MDIO_COMM_START_BUSY) {
956 DP(NETIF_MSG_LINK, "read phy register failed\n");
957
958 *ret_val = 0;
959 rc = -EFAULT;
960 }
961 }
962
963 /* Restore the saved mode */
964 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
965
966 return rc;
967 }
968
969 static void bnx2x_set_aer_mmd(struct link_params *params,
970 struct link_vars *vars)
971 {
972 struct bnx2x *bp = params->bp;
973 u32 ser_lane;
974 u16 offset;
975
976 ser_lane = ((params->lane_config &
977 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
978 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
979
980 offset = (vars->phy_flags & PHY_XGXS_FLAG) ?
981 (params->phy_addr + ser_lane) : 0;
982
983 CL45_WR_OVER_CL22(bp, params->port,
984 params->phy_addr,
985 MDIO_REG_BANK_AER_BLOCK,
986 MDIO_AER_BLOCK_AER_REG, 0x3800 + offset);
987 }
988
989 static void bnx2x_set_master_ln(struct link_params *params)
990 {
991 struct bnx2x *bp = params->bp;
992 u16 new_master_ln, ser_lane;
993 ser_lane = ((params->lane_config &
994 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
995 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
996
997 /* set the master_ln for AN */
998 CL45_RD_OVER_CL22(bp, params->port,
999 params->phy_addr,
1000 MDIO_REG_BANK_XGXS_BLOCK2,
1001 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1002 &new_master_ln);
1003
1004 CL45_WR_OVER_CL22(bp, params->port,
1005 params->phy_addr,
1006 MDIO_REG_BANK_XGXS_BLOCK2 ,
1007 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1008 (new_master_ln | ser_lane));
1009 }
1010
1011 static u8 bnx2x_reset_unicore(struct link_params *params)
1012 {
1013 struct bnx2x *bp = params->bp;
1014 u16 mii_control;
1015 u16 i;
1016
1017 CL45_RD_OVER_CL22(bp, params->port,
1018 params->phy_addr,
1019 MDIO_REG_BANK_COMBO_IEEE0,
1020 MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
1021
1022 /* reset the unicore */
1023 CL45_WR_OVER_CL22(bp, params->port,
1024 params->phy_addr,
1025 MDIO_REG_BANK_COMBO_IEEE0,
1026 MDIO_COMBO_IEEE0_MII_CONTROL,
1027 (mii_control |
1028 MDIO_COMBO_IEEO_MII_CONTROL_RESET));
1029 if (params->switch_cfg == SWITCH_CFG_1G)
1030 bnx2x_set_serdes_access(params);
1031
1032 /* wait for the reset to self clear */
1033 for (i = 0; i < MDIO_ACCESS_TIMEOUT; i++) {
1034 udelay(5);
1035
1036 /* the reset erased the previous bank value */
1037 CL45_RD_OVER_CL22(bp, params->port,
1038 params->phy_addr,
1039 MDIO_REG_BANK_COMBO_IEEE0,
1040 MDIO_COMBO_IEEE0_MII_CONTROL,
1041 &mii_control);
1042
1043 if (!(mii_control & MDIO_COMBO_IEEO_MII_CONTROL_RESET)) {
1044 udelay(5);
1045 return 0;
1046 }
1047 }
1048
1049 DP(NETIF_MSG_LINK, "BUG! XGXS is still in reset!\n");
1050 return -EINVAL;
1051
1052 }
1053
1054 static void bnx2x_set_swap_lanes(struct link_params *params)
1055 {
1056 struct bnx2x *bp = params->bp;
1057 /* Each two bits represents a lane number:
1058 No swap is 0123 => 0x1b no need to enable the swap */
1059 u16 ser_lane, rx_lane_swap, tx_lane_swap;
1060
1061 ser_lane = ((params->lane_config &
1062 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
1063 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
1064 rx_lane_swap = ((params->lane_config &
1065 PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK) >>
1066 PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT);
1067 tx_lane_swap = ((params->lane_config &
1068 PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK) >>
1069 PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT);
1070
1071 if (rx_lane_swap != 0x1b) {
1072 CL45_WR_OVER_CL22(bp, params->port,
1073 params->phy_addr,
1074 MDIO_REG_BANK_XGXS_BLOCK2,
1075 MDIO_XGXS_BLOCK2_RX_LN_SWAP,
1076 (rx_lane_swap |
1077 MDIO_XGXS_BLOCK2_RX_LN_SWAP_ENABLE |
1078 MDIO_XGXS_BLOCK2_RX_LN_SWAP_FORCE_ENABLE));
1079 } else {
1080 CL45_WR_OVER_CL22(bp, params->port,
1081 params->phy_addr,
1082 MDIO_REG_BANK_XGXS_BLOCK2,
1083 MDIO_XGXS_BLOCK2_RX_LN_SWAP, 0);
1084 }
1085
1086 if (tx_lane_swap != 0x1b) {
1087 CL45_WR_OVER_CL22(bp, params->port,
1088 params->phy_addr,
1089 MDIO_REG_BANK_XGXS_BLOCK2,
1090 MDIO_XGXS_BLOCK2_TX_LN_SWAP,
1091 (tx_lane_swap |
1092 MDIO_XGXS_BLOCK2_TX_LN_SWAP_ENABLE));
1093 } else {
1094 CL45_WR_OVER_CL22(bp, params->port,
1095 params->phy_addr,
1096 MDIO_REG_BANK_XGXS_BLOCK2,
1097 MDIO_XGXS_BLOCK2_TX_LN_SWAP, 0);
1098 }
1099 }
1100
1101 static void bnx2x_set_parallel_detection(struct link_params *params,
1102 u8 phy_flags)
1103 {
1104 struct bnx2x *bp = params->bp;
1105 u16 control2;
1106
1107 CL45_RD_OVER_CL22(bp, params->port,
1108 params->phy_addr,
1109 MDIO_REG_BANK_SERDES_DIGITAL,
1110 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1111 &control2);
1112 if (params->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
1113 control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
1114 else
1115 control2 &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
1116 DP(NETIF_MSG_LINK, "params->speed_cap_mask = 0x%x, control2 = 0x%x\n",
1117 params->speed_cap_mask, control2);
1118 CL45_WR_OVER_CL22(bp, params->port,
1119 params->phy_addr,
1120 MDIO_REG_BANK_SERDES_DIGITAL,
1121 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1122 control2);
1123
1124 if ((phy_flags & PHY_XGXS_FLAG) &&
1125 (params->speed_cap_mask &
1126 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
1127 DP(NETIF_MSG_LINK, "XGXS\n");
1128
1129 CL45_WR_OVER_CL22(bp, params->port,
1130 params->phy_addr,
1131 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1132 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK,
1133 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK_CNT);
1134
1135 CL45_RD_OVER_CL22(bp, params->port,
1136 params->phy_addr,
1137 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1138 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1139 &control2);
1140
1141
1142 control2 |=
1143 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL_PARDET10G_EN;
1144
1145 CL45_WR_OVER_CL22(bp, params->port,
1146 params->phy_addr,
1147 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1148 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1149 control2);
1150
1151 /* Disable parallel detection of HiG */
1152 CL45_WR_OVER_CL22(bp, params->port,
1153 params->phy_addr,
1154 MDIO_REG_BANK_XGXS_BLOCK2,
1155 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G,
1156 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_CX4_XGXS |
1157 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_HIGIG_XGXS);
1158 }
1159 }
1160
1161 static void bnx2x_set_autoneg(struct link_params *params,
1162 struct link_vars *vars,
1163 u8 enable_cl73)
1164 {
1165 struct bnx2x *bp = params->bp;
1166 u16 reg_val;
1167
1168 /* CL37 Autoneg */
1169
1170 CL45_RD_OVER_CL22(bp, params->port,
1171 params->phy_addr,
1172 MDIO_REG_BANK_COMBO_IEEE0,
1173 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
1174
1175 /* CL37 Autoneg Enabled */
1176 if (vars->line_speed == SPEED_AUTO_NEG)
1177 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_AN_EN;
1178 else /* CL37 Autoneg Disabled */
1179 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1180 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN);
1181
1182 CL45_WR_OVER_CL22(bp, params->port,
1183 params->phy_addr,
1184 MDIO_REG_BANK_COMBO_IEEE0,
1185 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
1186
1187 /* Enable/Disable Autodetection */
1188
1189 CL45_RD_OVER_CL22(bp, params->port,
1190 params->phy_addr,
1191 MDIO_REG_BANK_SERDES_DIGITAL,
1192 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, &reg_val);
1193 reg_val &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_SIGNAL_DETECT_EN |
1194 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT);
1195 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE;
1196 if (vars->line_speed == SPEED_AUTO_NEG)
1197 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1198 else
1199 reg_val &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1200
1201 CL45_WR_OVER_CL22(bp, params->port,
1202 params->phy_addr,
1203 MDIO_REG_BANK_SERDES_DIGITAL,
1204 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, reg_val);
1205
1206 /* Enable TetonII and BAM autoneg */
1207 CL45_RD_OVER_CL22(bp, params->port,
1208 params->phy_addr,
1209 MDIO_REG_BANK_BAM_NEXT_PAGE,
1210 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1211 &reg_val);
1212 if (vars->line_speed == SPEED_AUTO_NEG) {
1213 /* Enable BAM aneg Mode and TetonII aneg Mode */
1214 reg_val |= (MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1215 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1216 } else {
1217 /* TetonII and BAM Autoneg Disabled */
1218 reg_val &= ~(MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1219 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1220 }
1221 CL45_WR_OVER_CL22(bp, params->port,
1222 params->phy_addr,
1223 MDIO_REG_BANK_BAM_NEXT_PAGE,
1224 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1225 reg_val);
1226
1227 if (enable_cl73) {
1228 /* Enable Cl73 FSM status bits */
1229 CL45_WR_OVER_CL22(bp, params->port,
1230 params->phy_addr,
1231 MDIO_REG_BANK_CL73_USERB0,
1232 MDIO_CL73_USERB0_CL73_UCTRL,
1233 0xe);
1234
1235 /* Enable BAM Station Manager*/
1236 CL45_WR_OVER_CL22(bp, params->port,
1237 params->phy_addr,
1238 MDIO_REG_BANK_CL73_USERB0,
1239 MDIO_CL73_USERB0_CL73_BAM_CTRL1,
1240 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_EN |
1241 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_STATION_MNGR_EN |
1242 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_NP_AFTER_BP_EN);
1243
1244 /* Advertise CL73 link speeds */
1245 CL45_RD_OVER_CL22(bp, params->port,
1246 params->phy_addr,
1247 MDIO_REG_BANK_CL73_IEEEB1,
1248 MDIO_CL73_IEEEB1_AN_ADV2,
1249 &reg_val);
1250 if (params->speed_cap_mask &
1251 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
1252 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_10G_KX4;
1253 if (params->speed_cap_mask &
1254 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
1255 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_1000M_KX;
1256
1257 CL45_WR_OVER_CL22(bp, params->port,
1258 params->phy_addr,
1259 MDIO_REG_BANK_CL73_IEEEB1,
1260 MDIO_CL73_IEEEB1_AN_ADV2,
1261 reg_val);
1262
1263 /* CL73 Autoneg Enabled */
1264 reg_val = MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN;
1265
1266 } else /* CL73 Autoneg Disabled */
1267 reg_val = 0;
1268
1269 CL45_WR_OVER_CL22(bp, params->port,
1270 params->phy_addr,
1271 MDIO_REG_BANK_CL73_IEEEB0,
1272 MDIO_CL73_IEEEB0_CL73_AN_CONTROL, reg_val);
1273 }
1274
1275 /* program SerDes, forced speed */
1276 static void bnx2x_program_serdes(struct link_params *params,
1277 struct link_vars *vars)
1278 {
1279 struct bnx2x *bp = params->bp;
1280 u16 reg_val;
1281
1282 /* program duplex, disable autoneg and sgmii*/
1283 CL45_RD_OVER_CL22(bp, params->port,
1284 params->phy_addr,
1285 MDIO_REG_BANK_COMBO_IEEE0,
1286 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
1287 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX |
1288 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1289 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK);
1290 if (params->req_duplex == DUPLEX_FULL)
1291 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
1292 CL45_WR_OVER_CL22(bp, params->port,
1293 params->phy_addr,
1294 MDIO_REG_BANK_COMBO_IEEE0,
1295 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
1296
1297 /* program speed
1298 - needed only if the speed is greater than 1G (2.5G or 10G) */
1299 CL45_RD_OVER_CL22(bp, params->port,
1300 params->phy_addr,
1301 MDIO_REG_BANK_SERDES_DIGITAL,
1302 MDIO_SERDES_DIGITAL_MISC1, &reg_val);
1303 /* clearing the speed value before setting the right speed */
1304 DP(NETIF_MSG_LINK, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x\n", reg_val);
1305
1306 reg_val &= ~(MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK |
1307 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
1308
1309 if (!((vars->line_speed == SPEED_1000) ||
1310 (vars->line_speed == SPEED_100) ||
1311 (vars->line_speed == SPEED_10))) {
1312
1313 reg_val |= (MDIO_SERDES_DIGITAL_MISC1_REFCLK_SEL_156_25M |
1314 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
1315 if (vars->line_speed == SPEED_10000)
1316 reg_val |=
1317 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_10G_CX4;
1318 if (vars->line_speed == SPEED_13000)
1319 reg_val |=
1320 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_13G;
1321 }
1322
1323 CL45_WR_OVER_CL22(bp, params->port,
1324 params->phy_addr,
1325 MDIO_REG_BANK_SERDES_DIGITAL,
1326 MDIO_SERDES_DIGITAL_MISC1, reg_val);
1327
1328 }
1329
1330 static void bnx2x_set_brcm_cl37_advertisment(struct link_params *params)
1331 {
1332 struct bnx2x *bp = params->bp;
1333 u16 val = 0;
1334
1335 /* configure the 48 bits for BAM AN */
1336
1337 /* set extended capabilities */
1338 if (params->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G)
1339 val |= MDIO_OVER_1G_UP1_2_5G;
1340 if (params->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
1341 val |= MDIO_OVER_1G_UP1_10G;
1342 CL45_WR_OVER_CL22(bp, params->port,
1343 params->phy_addr,
1344 MDIO_REG_BANK_OVER_1G,
1345 MDIO_OVER_1G_UP1, val);
1346
1347 CL45_WR_OVER_CL22(bp, params->port,
1348 params->phy_addr,
1349 MDIO_REG_BANK_OVER_1G,
1350 MDIO_OVER_1G_UP3, 0x400);
1351 }
1352
1353 static void bnx2x_calc_ieee_aneg_adv(struct link_params *params, u16 *ieee_fc)
1354 {
1355 struct bnx2x *bp = params->bp;
1356 *ieee_fc = MDIO_COMBO_IEEE0_AUTO_NEG_ADV_FULL_DUPLEX;
1357 /* resolve pause mode and advertisement
1358 * Please refer to Table 28B-3 of the 802.3ab-1999 spec */
1359
1360 switch (params->req_flow_ctrl) {
1361 case BNX2X_FLOW_CTRL_AUTO:
1362 if (params->req_fc_auto_adv == BNX2X_FLOW_CTRL_BOTH) {
1363 *ieee_fc |=
1364 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
1365 } else {
1366 *ieee_fc |=
1367 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
1368 }
1369 break;
1370 case BNX2X_FLOW_CTRL_TX:
1371 *ieee_fc |=
1372 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
1373 break;
1374
1375 case BNX2X_FLOW_CTRL_RX:
1376 case BNX2X_FLOW_CTRL_BOTH:
1377 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
1378 break;
1379
1380 case BNX2X_FLOW_CTRL_NONE:
1381 default:
1382 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
1383 break;
1384 }
1385 DP(NETIF_MSG_LINK, "ieee_fc = 0x%x\n", *ieee_fc);
1386 }
1387
1388 static void bnx2x_set_ieee_aneg_advertisment(struct link_params *params,
1389 u16 ieee_fc)
1390 {
1391 struct bnx2x *bp = params->bp;
1392 u16 val;
1393 /* for AN, we are always publishing full duplex */
1394
1395 CL45_WR_OVER_CL22(bp, params->port,
1396 params->phy_addr,
1397 MDIO_REG_BANK_COMBO_IEEE0,
1398 MDIO_COMBO_IEEE0_AUTO_NEG_ADV, ieee_fc);
1399 CL45_RD_OVER_CL22(bp, params->port,
1400 params->phy_addr,
1401 MDIO_REG_BANK_CL73_IEEEB1,
1402 MDIO_CL73_IEEEB1_AN_ADV1, &val);
1403 val &= ~MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_BOTH;
1404 val |= ((ieee_fc<<3) & MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK);
1405 CL45_WR_OVER_CL22(bp, params->port,
1406 params->phy_addr,
1407 MDIO_REG_BANK_CL73_IEEEB1,
1408 MDIO_CL73_IEEEB1_AN_ADV1, val);
1409 }
1410
1411 static void bnx2x_restart_autoneg(struct link_params *params, u8 enable_cl73)
1412 {
1413 struct bnx2x *bp = params->bp;
1414 u16 mii_control;
1415
1416 DP(NETIF_MSG_LINK, "bnx2x_restart_autoneg\n");
1417 /* Enable and restart BAM/CL37 aneg */
1418
1419 if (enable_cl73) {
1420 CL45_RD_OVER_CL22(bp, params->port,
1421 params->phy_addr,
1422 MDIO_REG_BANK_CL73_IEEEB0,
1423 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1424 &mii_control);
1425
1426 CL45_WR_OVER_CL22(bp, params->port,
1427 params->phy_addr,
1428 MDIO_REG_BANK_CL73_IEEEB0,
1429 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1430 (mii_control |
1431 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN |
1432 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_RESTART_AN));
1433 } else {
1434
1435 CL45_RD_OVER_CL22(bp, params->port,
1436 params->phy_addr,
1437 MDIO_REG_BANK_COMBO_IEEE0,
1438 MDIO_COMBO_IEEE0_MII_CONTROL,
1439 &mii_control);
1440 DP(NETIF_MSG_LINK,
1441 "bnx2x_restart_autoneg mii_control before = 0x%x\n",
1442 mii_control);
1443 CL45_WR_OVER_CL22(bp, params->port,
1444 params->phy_addr,
1445 MDIO_REG_BANK_COMBO_IEEE0,
1446 MDIO_COMBO_IEEE0_MII_CONTROL,
1447 (mii_control |
1448 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1449 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN));
1450 }
1451 }
1452
1453 static void bnx2x_initialize_sgmii_process(struct link_params *params,
1454 struct link_vars *vars)
1455 {
1456 struct bnx2x *bp = params->bp;
1457 u16 control1;
1458
1459 /* in SGMII mode, the unicore is always slave */
1460
1461 CL45_RD_OVER_CL22(bp, params->port,
1462 params->phy_addr,
1463 MDIO_REG_BANK_SERDES_DIGITAL,
1464 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
1465 &control1);
1466 control1 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT;
1467 /* set sgmii mode (and not fiber) */
1468 control1 &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE |
1469 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET |
1470 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_MSTR_MODE);
1471 CL45_WR_OVER_CL22(bp, params->port,
1472 params->phy_addr,
1473 MDIO_REG_BANK_SERDES_DIGITAL,
1474 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
1475 control1);
1476
1477 /* if forced speed */
1478 if (!(vars->line_speed == SPEED_AUTO_NEG)) {
1479 /* set speed, disable autoneg */
1480 u16 mii_control;
1481
1482 CL45_RD_OVER_CL22(bp, params->port,
1483 params->phy_addr,
1484 MDIO_REG_BANK_COMBO_IEEE0,
1485 MDIO_COMBO_IEEE0_MII_CONTROL,
1486 &mii_control);
1487 mii_control &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1488 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK|
1489 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX);
1490
1491 switch (vars->line_speed) {
1492 case SPEED_100:
1493 mii_control |=
1494 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_100;
1495 break;
1496 case SPEED_1000:
1497 mii_control |=
1498 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_1000;
1499 break;
1500 case SPEED_10:
1501 /* there is nothing to set for 10M */
1502 break;
1503 default:
1504 /* invalid speed for SGMII */
1505 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
1506 vars->line_speed);
1507 break;
1508 }
1509
1510 /* setting the full duplex */
1511 if (params->req_duplex == DUPLEX_FULL)
1512 mii_control |=
1513 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
1514 CL45_WR_OVER_CL22(bp, params->port,
1515 params->phy_addr,
1516 MDIO_REG_BANK_COMBO_IEEE0,
1517 MDIO_COMBO_IEEE0_MII_CONTROL,
1518 mii_control);
1519
1520 } else { /* AN mode */
1521 /* enable and restart AN */
1522 bnx2x_restart_autoneg(params, 0);
1523 }
1524 }
1525
1526
1527 /*
1528 * link management
1529 */
1530
1531 static void bnx2x_pause_resolve(struct link_vars *vars, u32 pause_result)
1532 { /* LD LP */
1533 switch (pause_result) { /* ASYM P ASYM P */
1534 case 0xb: /* 1 0 1 1 */
1535 vars->flow_ctrl = BNX2X_FLOW_CTRL_TX;
1536 break;
1537
1538 case 0xe: /* 1 1 1 0 */
1539 vars->flow_ctrl = BNX2X_FLOW_CTRL_RX;
1540 break;
1541
1542 case 0x5: /* 0 1 0 1 */
1543 case 0x7: /* 0 1 1 1 */
1544 case 0xd: /* 1 1 0 1 */
1545 case 0xf: /* 1 1 1 1 */
1546 vars->flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
1547 break;
1548
1549 default:
1550 break;
1551 }
1552 }
1553
1554 static u8 bnx2x_ext_phy_resolve_fc(struct link_params *params,
1555 struct link_vars *vars)
1556 {
1557 struct bnx2x *bp = params->bp;
1558 u8 ext_phy_addr;
1559 u16 ld_pause; /* local */
1560 u16 lp_pause; /* link partner */
1561 u16 an_complete; /* AN complete */
1562 u16 pause_result;
1563 u8 ret = 0;
1564 u32 ext_phy_type;
1565 u8 port = params->port;
1566 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
1567 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
1568 /* read twice */
1569
1570 bnx2x_cl45_read(bp, port,
1571 ext_phy_type,
1572 ext_phy_addr,
1573 MDIO_AN_DEVAD,
1574 MDIO_AN_REG_STATUS, &an_complete);
1575 bnx2x_cl45_read(bp, port,
1576 ext_phy_type,
1577 ext_phy_addr,
1578 MDIO_AN_DEVAD,
1579 MDIO_AN_REG_STATUS, &an_complete);
1580
1581 if (an_complete & MDIO_AN_REG_STATUS_AN_COMPLETE) {
1582 ret = 1;
1583 bnx2x_cl45_read(bp, port,
1584 ext_phy_type,
1585 ext_phy_addr,
1586 MDIO_AN_DEVAD,
1587 MDIO_AN_REG_ADV_PAUSE, &ld_pause);
1588 bnx2x_cl45_read(bp, port,
1589 ext_phy_type,
1590 ext_phy_addr,
1591 MDIO_AN_DEVAD,
1592 MDIO_AN_REG_LP_AUTO_NEG, &lp_pause);
1593 pause_result = (ld_pause &
1594 MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
1595 pause_result |= (lp_pause &
1596 MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
1597 DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x\n",
1598 pause_result);
1599 bnx2x_pause_resolve(vars, pause_result);
1600 if (vars->flow_ctrl == BNX2X_FLOW_CTRL_NONE &&
1601 ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
1602 bnx2x_cl45_read(bp, port,
1603 ext_phy_type,
1604 ext_phy_addr,
1605 MDIO_AN_DEVAD,
1606 MDIO_AN_REG_CL37_FC_LD, &ld_pause);
1607
1608 bnx2x_cl45_read(bp, port,
1609 ext_phy_type,
1610 ext_phy_addr,
1611 MDIO_AN_DEVAD,
1612 MDIO_AN_REG_CL37_FC_LP, &lp_pause);
1613 pause_result = (ld_pause &
1614 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 5;
1615 pause_result |= (lp_pause &
1616 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
1617
1618 bnx2x_pause_resolve(vars, pause_result);
1619 DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x\n",
1620 pause_result);
1621 }
1622 }
1623 return ret;
1624 }
1625
1626 static u8 bnx2x_direct_parallel_detect_used(struct link_params *params)
1627 {
1628 struct bnx2x *bp = params->bp;
1629 u16 pd_10g, status2_1000x;
1630 CL45_RD_OVER_CL22(bp, params->port,
1631 params->phy_addr,
1632 MDIO_REG_BANK_SERDES_DIGITAL,
1633 MDIO_SERDES_DIGITAL_A_1000X_STATUS2,
1634 &status2_1000x);
1635 CL45_RD_OVER_CL22(bp, params->port,
1636 params->phy_addr,
1637 MDIO_REG_BANK_SERDES_DIGITAL,
1638 MDIO_SERDES_DIGITAL_A_1000X_STATUS2,
1639 &status2_1000x);
1640 if (status2_1000x & MDIO_SERDES_DIGITAL_A_1000X_STATUS2_AN_DISABLED) {
1641 DP(NETIF_MSG_LINK, "1G parallel detect link on port %d\n",
1642 params->port);
1643 return 1;
1644 }
1645
1646 CL45_RD_OVER_CL22(bp, params->port,
1647 params->phy_addr,
1648 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1649 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS,
1650 &pd_10g);
1651
1652 if (pd_10g & MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS_PD_LINK) {
1653 DP(NETIF_MSG_LINK, "10G parallel detect link on port %d\n",
1654 params->port);
1655 return 1;
1656 }
1657 return 0;
1658 }
1659
1660 static void bnx2x_flow_ctrl_resolve(struct link_params *params,
1661 struct link_vars *vars,
1662 u32 gp_status)
1663 {
1664 struct bnx2x *bp = params->bp;
1665 u16 ld_pause; /* local driver */
1666 u16 lp_pause; /* link partner */
1667 u16 pause_result;
1668
1669 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
1670
1671 /* resolve from gp_status in case of AN complete and not sgmii */
1672 if ((params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
1673 (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) &&
1674 (!(vars->phy_flags & PHY_SGMII_FLAG)) &&
1675 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1676 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)) {
1677 if (bnx2x_direct_parallel_detect_used(params)) {
1678 vars->flow_ctrl = params->req_fc_auto_adv;
1679 return;
1680 }
1681 if ((gp_status &
1682 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE |
1683 MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_MR_LP_NP_AN_ABLE)) ==
1684 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE |
1685 MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_MR_LP_NP_AN_ABLE)) {
1686
1687 CL45_RD_OVER_CL22(bp, params->port,
1688 params->phy_addr,
1689 MDIO_REG_BANK_CL73_IEEEB1,
1690 MDIO_CL73_IEEEB1_AN_ADV1,
1691 &ld_pause);
1692 CL45_RD_OVER_CL22(bp, params->port,
1693 params->phy_addr,
1694 MDIO_REG_BANK_CL73_IEEEB1,
1695 MDIO_CL73_IEEEB1_AN_LP_ADV1,
1696 &lp_pause);
1697 pause_result = (ld_pause &
1698 MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK)
1699 >> 8;
1700 pause_result |= (lp_pause &
1701 MDIO_CL73_IEEEB1_AN_LP_ADV1_PAUSE_MASK)
1702 >> 10;
1703 DP(NETIF_MSG_LINK, "pause_result CL73 0x%x\n",
1704 pause_result);
1705 } else {
1706
1707 CL45_RD_OVER_CL22(bp, params->port,
1708 params->phy_addr,
1709 MDIO_REG_BANK_COMBO_IEEE0,
1710 MDIO_COMBO_IEEE0_AUTO_NEG_ADV,
1711 &ld_pause);
1712 CL45_RD_OVER_CL22(bp, params->port,
1713 params->phy_addr,
1714 MDIO_REG_BANK_COMBO_IEEE0,
1715 MDIO_COMBO_IEEE0_AUTO_NEG_LINK_PARTNER_ABILITY1,
1716 &lp_pause);
1717 pause_result = (ld_pause &
1718 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>5;
1719 pause_result |= (lp_pause &
1720 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>7;
1721 DP(NETIF_MSG_LINK, "pause_result CL37 0x%x\n",
1722 pause_result);
1723 }
1724 bnx2x_pause_resolve(vars, pause_result);
1725 } else if ((params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
1726 (bnx2x_ext_phy_resolve_fc(params, vars))) {
1727 return;
1728 } else {
1729 if (params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO)
1730 vars->flow_ctrl = params->req_fc_auto_adv;
1731 else
1732 vars->flow_ctrl = params->req_flow_ctrl;
1733 }
1734 DP(NETIF_MSG_LINK, "flow_ctrl 0x%x\n", vars->flow_ctrl);
1735 }
1736
1737 static void bnx2x_check_fallback_to_cl37(struct link_params *params)
1738 {
1739 struct bnx2x *bp = params->bp;
1740 u16 rx_status, ustat_val, cl37_fsm_recieved;
1741 DP(NETIF_MSG_LINK, "bnx2x_check_fallback_to_cl37\n");
1742 /* Step 1: Make sure signal is detected */
1743 CL45_RD_OVER_CL22(bp, params->port,
1744 params->phy_addr,
1745 MDIO_REG_BANK_RX0,
1746 MDIO_RX0_RX_STATUS,
1747 &rx_status);
1748 if ((rx_status & MDIO_RX0_RX_STATUS_SIGDET) !=
1749 (MDIO_RX0_RX_STATUS_SIGDET)) {
1750 DP(NETIF_MSG_LINK, "Signal is not detected. Restoring CL73."
1751 "rx_status(0x80b0) = 0x%x\n", rx_status);
1752 CL45_WR_OVER_CL22(bp, params->port,
1753 params->phy_addr,
1754 MDIO_REG_BANK_CL73_IEEEB0,
1755 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1756 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN);
1757 return;
1758 }
1759 /* Step 2: Check CL73 state machine */
1760 CL45_RD_OVER_CL22(bp, params->port,
1761 params->phy_addr,
1762 MDIO_REG_BANK_CL73_USERB0,
1763 MDIO_CL73_USERB0_CL73_USTAT1,
1764 &ustat_val);
1765 if ((ustat_val &
1766 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
1767 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) !=
1768 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
1769 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) {
1770 DP(NETIF_MSG_LINK, "CL73 state-machine is not stable. "
1771 "ustat_val(0x8371) = 0x%x\n", ustat_val);
1772 return;
1773 }
1774 /* Step 3: Check CL37 Message Pages received to indicate LP
1775 supports only CL37 */
1776 CL45_RD_OVER_CL22(bp, params->port,
1777 params->phy_addr,
1778 MDIO_REG_BANK_REMOTE_PHY,
1779 MDIO_REMOTE_PHY_MISC_RX_STATUS,
1780 &cl37_fsm_recieved);
1781 if ((cl37_fsm_recieved &
1782 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
1783 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) !=
1784 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
1785 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) {
1786 DP(NETIF_MSG_LINK, "No CL37 FSM were received. "
1787 "misc_rx_status(0x8330) = 0x%x\n",
1788 cl37_fsm_recieved);
1789 return;
1790 }
1791 /* The combined cl37/cl73 fsm state information indicating that we are
1792 connected to a device which does not support cl73, but does support
1793 cl37 BAM. In this case we disable cl73 and restart cl37 auto-neg */
1794 /* Disable CL73 */
1795 CL45_WR_OVER_CL22(bp, params->port,
1796 params->phy_addr,
1797 MDIO_REG_BANK_CL73_IEEEB0,
1798 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1799 0);
1800 /* Restart CL37 autoneg */
1801 bnx2x_restart_autoneg(params, 0);
1802 DP(NETIF_MSG_LINK, "Disabling CL73, and restarting CL37 autoneg\n");
1803 }
1804 static u8 bnx2x_link_settings_status(struct link_params *params,
1805 struct link_vars *vars,
1806 u32 gp_status,
1807 u8 ext_phy_link_up)
1808 {
1809 struct bnx2x *bp = params->bp;
1810 u16 new_line_speed;
1811 u8 rc = 0;
1812 vars->link_status = 0;
1813
1814 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) {
1815 DP(NETIF_MSG_LINK, "phy link up gp_status=0x%x\n",
1816 gp_status);
1817
1818 vars->phy_link_up = 1;
1819 vars->link_status |= LINK_STATUS_LINK_UP;
1820
1821 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_DUPLEX_STATUS)
1822 vars->duplex = DUPLEX_FULL;
1823 else
1824 vars->duplex = DUPLEX_HALF;
1825
1826 bnx2x_flow_ctrl_resolve(params, vars, gp_status);
1827
1828 switch (gp_status & GP_STATUS_SPEED_MASK) {
1829 case GP_STATUS_10M:
1830 new_line_speed = SPEED_10;
1831 if (vars->duplex == DUPLEX_FULL)
1832 vars->link_status |= LINK_10TFD;
1833 else
1834 vars->link_status |= LINK_10THD;
1835 break;
1836
1837 case GP_STATUS_100M:
1838 new_line_speed = SPEED_100;
1839 if (vars->duplex == DUPLEX_FULL)
1840 vars->link_status |= LINK_100TXFD;
1841 else
1842 vars->link_status |= LINK_100TXHD;
1843 break;
1844
1845 case GP_STATUS_1G:
1846 case GP_STATUS_1G_KX:
1847 new_line_speed = SPEED_1000;
1848 if (vars->duplex == DUPLEX_FULL)
1849 vars->link_status |= LINK_1000TFD;
1850 else
1851 vars->link_status |= LINK_1000THD;
1852 break;
1853
1854 case GP_STATUS_2_5G:
1855 new_line_speed = SPEED_2500;
1856 if (vars->duplex == DUPLEX_FULL)
1857 vars->link_status |= LINK_2500TFD;
1858 else
1859 vars->link_status |= LINK_2500THD;
1860 break;
1861
1862 case GP_STATUS_5G:
1863 case GP_STATUS_6G:
1864 DP(NETIF_MSG_LINK,
1865 "link speed unsupported gp_status 0x%x\n",
1866 gp_status);
1867 return -EINVAL;
1868
1869 case GP_STATUS_10G_KX4:
1870 case GP_STATUS_10G_HIG:
1871 case GP_STATUS_10G_CX4:
1872 new_line_speed = SPEED_10000;
1873 vars->link_status |= LINK_10GTFD;
1874 break;
1875
1876 case GP_STATUS_12G_HIG:
1877 new_line_speed = SPEED_12000;
1878 vars->link_status |= LINK_12GTFD;
1879 break;
1880
1881 case GP_STATUS_12_5G:
1882 new_line_speed = SPEED_12500;
1883 vars->link_status |= LINK_12_5GTFD;
1884 break;
1885
1886 case GP_STATUS_13G:
1887 new_line_speed = SPEED_13000;
1888 vars->link_status |= LINK_13GTFD;
1889 break;
1890
1891 case GP_STATUS_15G:
1892 new_line_speed = SPEED_15000;
1893 vars->link_status |= LINK_15GTFD;
1894 break;
1895
1896 case GP_STATUS_16G:
1897 new_line_speed = SPEED_16000;
1898 vars->link_status |= LINK_16GTFD;
1899 break;
1900
1901 default:
1902 DP(NETIF_MSG_LINK,
1903 "link speed unsupported gp_status 0x%x\n",
1904 gp_status);
1905 return -EINVAL;
1906 }
1907
1908 /* Upon link speed change set the NIG into drain mode.
1909 Comes to deals with possible FIFO glitch due to clk change
1910 when speed is decreased without link down indicator */
1911 if (new_line_speed != vars->line_speed) {
1912 if (XGXS_EXT_PHY_TYPE(params->ext_phy_config) !=
1913 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT &&
1914 ext_phy_link_up) {
1915 DP(NETIF_MSG_LINK, "Internal link speed %d is"
1916 " different than the external"
1917 " link speed %d\n", new_line_speed,
1918 vars->line_speed);
1919 vars->phy_link_up = 0;
1920 return 0;
1921 }
1922 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
1923 + params->port*4, 0);
1924 msleep(1);
1925 }
1926 vars->line_speed = new_line_speed;
1927 vars->link_status |= LINK_STATUS_SERDES_LINK;
1928
1929 if ((params->req_line_speed == SPEED_AUTO_NEG) &&
1930 ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1931 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) ||
1932 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1933 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
1934 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1935 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706) ||
1936 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1937 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726))) {
1938 vars->autoneg = AUTO_NEG_ENABLED;
1939
1940 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) {
1941 vars->autoneg |= AUTO_NEG_COMPLETE;
1942 vars->link_status |=
1943 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
1944 }
1945
1946 vars->autoneg |= AUTO_NEG_PARALLEL_DETECTION_USED;
1947 vars->link_status |=
1948 LINK_STATUS_PARALLEL_DETECTION_USED;
1949
1950 }
1951 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
1952 vars->link_status |=
1953 LINK_STATUS_TX_FLOW_CONTROL_ENABLED;
1954
1955 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
1956 vars->link_status |=
1957 LINK_STATUS_RX_FLOW_CONTROL_ENABLED;
1958
1959 } else { /* link_down */
1960 DP(NETIF_MSG_LINK, "phy link down\n");
1961
1962 vars->phy_link_up = 0;
1963
1964 vars->duplex = DUPLEX_FULL;
1965 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
1966 vars->autoneg = AUTO_NEG_DISABLED;
1967 vars->mac_type = MAC_TYPE_NONE;
1968
1969 if ((params->req_line_speed == SPEED_AUTO_NEG) &&
1970 ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1971 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT))) {
1972 /* Check signal is detected */
1973 bnx2x_check_fallback_to_cl37(params);
1974 }
1975 }
1976
1977 DP(NETIF_MSG_LINK, "gp_status 0x%x phy_link_up %x line_speed %x\n",
1978 gp_status, vars->phy_link_up, vars->line_speed);
1979 DP(NETIF_MSG_LINK, "duplex %x flow_ctrl 0x%x"
1980 " autoneg 0x%x\n",
1981 vars->duplex,
1982 vars->flow_ctrl, vars->autoneg);
1983 DP(NETIF_MSG_LINK, "link_status 0x%x\n", vars->link_status);
1984
1985 return rc;
1986 }
1987
1988 static void bnx2x_set_gmii_tx_driver(struct link_params *params)
1989 {
1990 struct bnx2x *bp = params->bp;
1991 u16 lp_up2;
1992 u16 tx_driver;
1993 u16 bank;
1994
1995 /* read precomp */
1996 CL45_RD_OVER_CL22(bp, params->port,
1997 params->phy_addr,
1998 MDIO_REG_BANK_OVER_1G,
1999 MDIO_OVER_1G_LP_UP2, &lp_up2);
2000
2001 /* bits [10:7] at lp_up2, positioned at [15:12] */
2002 lp_up2 = (((lp_up2 & MDIO_OVER_1G_LP_UP2_PREEMPHASIS_MASK) >>
2003 MDIO_OVER_1G_LP_UP2_PREEMPHASIS_SHIFT) <<
2004 MDIO_TX0_TX_DRIVER_PREEMPHASIS_SHIFT);
2005
2006 if (lp_up2 == 0)
2007 return;
2008
2009 for (bank = MDIO_REG_BANK_TX0; bank <= MDIO_REG_BANK_TX3;
2010 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0)) {
2011 CL45_RD_OVER_CL22(bp, params->port,
2012 params->phy_addr,
2013 bank,
2014 MDIO_TX0_TX_DRIVER, &tx_driver);
2015
2016 /* replace tx_driver bits [15:12] */
2017 if (lp_up2 !=
2018 (tx_driver & MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK)) {
2019 tx_driver &= ~MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK;
2020 tx_driver |= lp_up2;
2021 CL45_WR_OVER_CL22(bp, params->port,
2022 params->phy_addr,
2023 bank,
2024 MDIO_TX0_TX_DRIVER, tx_driver);
2025 }
2026 }
2027 }
2028
2029 static u8 bnx2x_emac_program(struct link_params *params,
2030 u32 line_speed, u32 duplex)
2031 {
2032 struct bnx2x *bp = params->bp;
2033 u8 port = params->port;
2034 u16 mode = 0;
2035
2036 DP(NETIF_MSG_LINK, "setting link speed & duplex\n");
2037 bnx2x_bits_dis(bp, GRCBASE_EMAC0 + port*0x400 +
2038 EMAC_REG_EMAC_MODE,
2039 (EMAC_MODE_25G_MODE |
2040 EMAC_MODE_PORT_MII_10M |
2041 EMAC_MODE_HALF_DUPLEX));
2042 switch (line_speed) {
2043 case SPEED_10:
2044 mode |= EMAC_MODE_PORT_MII_10M;
2045 break;
2046
2047 case SPEED_100:
2048 mode |= EMAC_MODE_PORT_MII;
2049 break;
2050
2051 case SPEED_1000:
2052 mode |= EMAC_MODE_PORT_GMII;
2053 break;
2054
2055 case SPEED_2500:
2056 mode |= (EMAC_MODE_25G_MODE | EMAC_MODE_PORT_GMII);
2057 break;
2058
2059 default:
2060 /* 10G not valid for EMAC */
2061 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n", line_speed);
2062 return -EINVAL;
2063 }
2064
2065 if (duplex == DUPLEX_HALF)
2066 mode |= EMAC_MODE_HALF_DUPLEX;
2067 bnx2x_bits_en(bp,
2068 GRCBASE_EMAC0 + port*0x400 + EMAC_REG_EMAC_MODE,
2069 mode);
2070
2071 bnx2x_set_led(params, LED_MODE_OPER, line_speed);
2072 return 0;
2073 }
2074
2075 /*****************************************************************************/
2076 /* External Phy section */
2077 /*****************************************************************************/
2078 void bnx2x_ext_phy_hw_reset(struct bnx2x *bp, u8 port)
2079 {
2080 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2081 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
2082 msleep(1);
2083 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2084 MISC_REGISTERS_GPIO_OUTPUT_HIGH, port);
2085 }
2086
2087 static void bnx2x_ext_phy_reset(struct link_params *params,
2088 struct link_vars *vars)
2089 {
2090 struct bnx2x *bp = params->bp;
2091 u32 ext_phy_type;
2092 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2093
2094 DP(NETIF_MSG_LINK, "Port %x: bnx2x_ext_phy_reset\n", params->port);
2095 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2096 /* The PHY reset is controled by GPIO 1
2097 * Give it 1ms of reset pulse
2098 */
2099 if (vars->phy_flags & PHY_XGXS_FLAG) {
2100
2101 switch (ext_phy_type) {
2102 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
2103 DP(NETIF_MSG_LINK, "XGXS Direct\n");
2104 break;
2105
2106 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
2107 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
2108 DP(NETIF_MSG_LINK, "XGXS 8705/8706\n");
2109
2110 /* Restore normal power mode*/
2111 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2112 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2113 params->port);
2114
2115 /* HW reset */
2116 bnx2x_ext_phy_hw_reset(bp, params->port);
2117
2118 bnx2x_cl45_write(bp, params->port,
2119 ext_phy_type,
2120 ext_phy_addr,
2121 MDIO_PMA_DEVAD,
2122 MDIO_PMA_REG_CTRL, 0xa040);
2123 break;
2124
2125 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
2126 break;
2127
2128 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
2129
2130 /* Restore normal power mode*/
2131 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2132 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2133 params->port);
2134
2135 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2136 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2137 params->port);
2138
2139 bnx2x_cl45_write(bp, params->port,
2140 ext_phy_type,
2141 ext_phy_addr,
2142 MDIO_PMA_DEVAD,
2143 MDIO_PMA_REG_CTRL,
2144 1<<15);
2145 break;
2146
2147 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
2148 DP(NETIF_MSG_LINK, "XGXS 8072\n");
2149
2150 /* Unset Low Power Mode and SW reset */
2151 /* Restore normal power mode*/
2152 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2153 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2154 params->port);
2155
2156 bnx2x_cl45_write(bp, params->port,
2157 ext_phy_type,
2158 ext_phy_addr,
2159 MDIO_PMA_DEVAD,
2160 MDIO_PMA_REG_CTRL,
2161 1<<15);
2162 break;
2163
2164 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
2165 DP(NETIF_MSG_LINK, "XGXS 8073\n");
2166
2167 /* Restore normal power mode*/
2168 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2169 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2170 params->port);
2171
2172 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2173 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2174 params->port);
2175 break;
2176
2177 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
2178 DP(NETIF_MSG_LINK, "XGXS SFX7101\n");
2179
2180 /* Restore normal power mode*/
2181 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2182 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2183 params->port);
2184
2185 /* HW reset */
2186 bnx2x_ext_phy_hw_reset(bp, params->port);
2187 break;
2188
2189 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
2190 /* Restore normal power mode*/
2191 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2192 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2193 params->port);
2194
2195 /* HW reset */
2196 bnx2x_ext_phy_hw_reset(bp, params->port);
2197
2198 bnx2x_cl45_write(bp, params->port,
2199 ext_phy_type,
2200 ext_phy_addr,
2201 MDIO_PMA_DEVAD,
2202 MDIO_PMA_REG_CTRL,
2203 1<<15);
2204 break;
2205 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
2206 break;
2207 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
2208 DP(NETIF_MSG_LINK, "XGXS PHY Failure detected\n");
2209 break;
2210
2211 default:
2212 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
2213 params->ext_phy_config);
2214 break;
2215 }
2216
2217 } else { /* SerDes */
2218 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
2219 switch (ext_phy_type) {
2220 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
2221 DP(NETIF_MSG_LINK, "SerDes Direct\n");
2222 break;
2223
2224 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
2225 DP(NETIF_MSG_LINK, "SerDes 5482\n");
2226 bnx2x_ext_phy_hw_reset(bp, params->port);
2227 break;
2228
2229 default:
2230 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
2231 params->ext_phy_config);
2232 break;
2233 }
2234 }
2235 }
2236
2237 static void bnx2x_save_spirom_version(struct bnx2x *bp, u8 port,
2238 u32 shmem_base, u32 spirom_ver)
2239 {
2240 DP(NETIF_MSG_LINK, "FW version 0x%x:0x%x for port %d\n",
2241 (u16)(spirom_ver>>16), (u16)spirom_ver, port);
2242 REG_WR(bp, shmem_base +
2243 offsetof(struct shmem_region,
2244 port_mb[port].ext_phy_fw_version),
2245 spirom_ver);
2246 }
2247
2248 static void bnx2x_save_bcm_spirom_ver(struct bnx2x *bp, u8 port,
2249 u32 ext_phy_type, u8 ext_phy_addr,
2250 u32 shmem_base)
2251 {
2252 u16 fw_ver1, fw_ver2;
2253
2254 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr, MDIO_PMA_DEVAD,
2255 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
2256 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr, MDIO_PMA_DEVAD,
2257 MDIO_PMA_REG_ROM_VER2, &fw_ver2);
2258 bnx2x_save_spirom_version(bp, port, shmem_base,
2259 (u32)(fw_ver1<<16 | fw_ver2));
2260 }
2261
2262
2263 static void bnx2x_save_8481_spirom_version(struct bnx2x *bp, u8 port,
2264 u8 ext_phy_addr, u32 shmem_base)
2265 {
2266 u16 val, fw_ver1, fw_ver2, cnt;
2267 /* For the 32 bits registers in 8481, access via MDIO2ARM interface.*/
2268 /* (1) set register 0xc200_0014(SPI_BRIDGE_CTRL_2) to 0x03000000 */
2269 bnx2x_cl45_write(bp, port,
2270 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2271 ext_phy_addr, MDIO_PMA_DEVAD,
2272 0xA819, 0x0014);
2273 bnx2x_cl45_write(bp, port,
2274 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2275 ext_phy_addr,
2276 MDIO_PMA_DEVAD,
2277 0xA81A,
2278 0xc200);
2279 bnx2x_cl45_write(bp, port,
2280 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2281 ext_phy_addr,
2282 MDIO_PMA_DEVAD,
2283 0xA81B,
2284 0x0000);
2285 bnx2x_cl45_write(bp, port,
2286 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2287 ext_phy_addr,
2288 MDIO_PMA_DEVAD,
2289 0xA81C,
2290 0x0300);
2291 bnx2x_cl45_write(bp, port,
2292 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2293 ext_phy_addr,
2294 MDIO_PMA_DEVAD,
2295 0xA817,
2296 0x0009);
2297
2298 for (cnt = 0; cnt < 100; cnt++) {
2299 bnx2x_cl45_read(bp, port,
2300 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2301 ext_phy_addr,
2302 MDIO_PMA_DEVAD,
2303 0xA818,
2304 &val);
2305 if (val & 1)
2306 break;
2307 udelay(5);
2308 }
2309 if (cnt == 100) {
2310 DP(NETIF_MSG_LINK, "Unable to read 8481 phy fw version(1)\n");
2311 bnx2x_save_spirom_version(bp, port,
2312 shmem_base, 0);
2313 return;
2314 }
2315
2316
2317 /* 2) read register 0xc200_0000 (SPI_FW_STATUS) */
2318 bnx2x_cl45_write(bp, port,
2319 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2320 ext_phy_addr, MDIO_PMA_DEVAD,
2321 0xA819, 0x0000);
2322 bnx2x_cl45_write(bp, port,
2323 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2324 ext_phy_addr, MDIO_PMA_DEVAD,
2325 0xA81A, 0xc200);
2326 bnx2x_cl45_write(bp, port,
2327 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2328 ext_phy_addr, MDIO_PMA_DEVAD,
2329 0xA817, 0x000A);
2330 for (cnt = 0; cnt < 100; cnt++) {
2331 bnx2x_cl45_read(bp, port,
2332 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2333 ext_phy_addr,
2334 MDIO_PMA_DEVAD,
2335 0xA818,
2336 &val);
2337 if (val & 1)
2338 break;
2339 udelay(5);
2340 }
2341 if (cnt == 100) {
2342 DP(NETIF_MSG_LINK, "Unable to read 8481 phy fw version(2)\n");
2343 bnx2x_save_spirom_version(bp, port,
2344 shmem_base, 0);
2345 return;
2346 }
2347
2348 /* lower 16 bits of the register SPI_FW_STATUS */
2349 bnx2x_cl45_read(bp, port,
2350 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2351 ext_phy_addr,
2352 MDIO_PMA_DEVAD,
2353 0xA81B,
2354 &fw_ver1);
2355 /* upper 16 bits of register SPI_FW_STATUS */
2356 bnx2x_cl45_read(bp, port,
2357 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2358 ext_phy_addr,
2359 MDIO_PMA_DEVAD,
2360 0xA81C,
2361 &fw_ver2);
2362
2363 bnx2x_save_spirom_version(bp, port,
2364 shmem_base, (fw_ver2<<16) | fw_ver1);
2365 }
2366
2367 static void bnx2x_bcm8072_external_rom_boot(struct link_params *params)
2368 {
2369 struct bnx2x *bp = params->bp;
2370 u8 port = params->port;
2371 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2372 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2373
2374 /* Need to wait 200ms after reset */
2375 msleep(200);
2376 /* Boot port from external ROM
2377 * Set ser_boot_ctl bit in the MISC_CTRL1 register
2378 */
2379 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2380 MDIO_PMA_DEVAD,
2381 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2382
2383 /* Reset internal microprocessor */
2384 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2385 MDIO_PMA_DEVAD,
2386 MDIO_PMA_REG_GEN_CTRL,
2387 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2388 /* set micro reset = 0 */
2389 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2390 MDIO_PMA_DEVAD,
2391 MDIO_PMA_REG_GEN_CTRL,
2392 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2393 /* Reset internal microprocessor */
2394 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2395 MDIO_PMA_DEVAD,
2396 MDIO_PMA_REG_GEN_CTRL,
2397 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2398 /* wait for 100ms for code download via SPI port */
2399 msleep(100);
2400
2401 /* Clear ser_boot_ctl bit */
2402 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2403 MDIO_PMA_DEVAD,
2404 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2405 /* Wait 100ms */
2406 msleep(100);
2407
2408 bnx2x_save_bcm_spirom_ver(bp, port,
2409 ext_phy_type,
2410 ext_phy_addr,
2411 params->shmem_base);
2412 }
2413
2414 static u8 bnx2x_8073_is_snr_needed(struct link_params *params)
2415 {
2416 /* This is only required for 8073A1, version 102 only */
2417
2418 struct bnx2x *bp = params->bp;
2419 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2420 u16 val;
2421
2422 /* Read 8073 HW revision*/
2423 bnx2x_cl45_read(bp, params->port,
2424 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2425 ext_phy_addr,
2426 MDIO_PMA_DEVAD,
2427 MDIO_PMA_REG_8073_CHIP_REV, &val);
2428
2429 if (val != 1) {
2430 /* No need to workaround in 8073 A1 */
2431 return 0;
2432 }
2433
2434 bnx2x_cl45_read(bp, params->port,
2435 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2436 ext_phy_addr,
2437 MDIO_PMA_DEVAD,
2438 MDIO_PMA_REG_ROM_VER2, &val);
2439
2440 /* SNR should be applied only for version 0x102 */
2441 if (val != 0x102)
2442 return 0;
2443
2444 return 1;
2445 }
2446
2447 static u8 bnx2x_bcm8073_xaui_wa(struct link_params *params)
2448 {
2449 struct bnx2x *bp = params->bp;
2450 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2451 u16 val, cnt, cnt1 ;
2452
2453 bnx2x_cl45_read(bp, params->port,
2454 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2455 ext_phy_addr,
2456 MDIO_PMA_DEVAD,
2457 MDIO_PMA_REG_8073_CHIP_REV, &val);
2458
2459 if (val > 0) {
2460 /* No need to workaround in 8073 A1 */
2461 return 0;
2462 }
2463 /* XAUI workaround in 8073 A0: */
2464
2465 /* After loading the boot ROM and restarting Autoneg,
2466 poll Dev1, Reg $C820: */
2467
2468 for (cnt = 0; cnt < 1000; cnt++) {
2469 bnx2x_cl45_read(bp, params->port,
2470 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2471 ext_phy_addr,
2472 MDIO_PMA_DEVAD,
2473 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
2474 &val);
2475 /* If bit [14] = 0 or bit [13] = 0, continue on with
2476 system initialization (XAUI work-around not required,
2477 as these bits indicate 2.5G or 1G link up). */
2478 if (!(val & (1<<14)) || !(val & (1<<13))) {
2479 DP(NETIF_MSG_LINK, "XAUI work-around not required\n");
2480 return 0;
2481 } else if (!(val & (1<<15))) {
2482 DP(NETIF_MSG_LINK, "clc bit 15 went off\n");
2483 /* If bit 15 is 0, then poll Dev1, Reg $C841 until
2484 it's MSB (bit 15) goes to 1 (indicating that the
2485 XAUI workaround has completed),
2486 then continue on with system initialization.*/
2487 for (cnt1 = 0; cnt1 < 1000; cnt1++) {
2488 bnx2x_cl45_read(bp, params->port,
2489 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2490 ext_phy_addr,
2491 MDIO_PMA_DEVAD,
2492 MDIO_PMA_REG_8073_XAUI_WA, &val);
2493 if (val & (1<<15)) {
2494 DP(NETIF_MSG_LINK,
2495 "XAUI workaround has completed\n");
2496 return 0;
2497 }
2498 msleep(3);
2499 }
2500 break;
2501 }
2502 msleep(3);
2503 }
2504 DP(NETIF_MSG_LINK, "Warning: XAUI work-around timeout !!!\n");
2505 return -EINVAL;
2506 }
2507
2508 static void bnx2x_bcm8073_bcm8727_external_rom_boot(struct bnx2x *bp, u8 port,
2509 u8 ext_phy_addr,
2510 u32 ext_phy_type,
2511 u32 shmem_base)
2512 {
2513 /* Boot port from external ROM */
2514 /* EDC grst */
2515 bnx2x_cl45_write(bp, port,
2516 ext_phy_type,
2517 ext_phy_addr,
2518 MDIO_PMA_DEVAD,
2519 MDIO_PMA_REG_GEN_CTRL,
2520 0x0001);
2521
2522 /* ucode reboot and rst */
2523 bnx2x_cl45_write(bp, port,
2524 ext_phy_type,
2525 ext_phy_addr,
2526 MDIO_PMA_DEVAD,
2527 MDIO_PMA_REG_GEN_CTRL,
2528 0x008c);
2529
2530 bnx2x_cl45_write(bp, port,
2531 ext_phy_type,
2532 ext_phy_addr,
2533 MDIO_PMA_DEVAD,
2534 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2535
2536 /* Reset internal microprocessor */
2537 bnx2x_cl45_write(bp, port,
2538 ext_phy_type,
2539 ext_phy_addr,
2540 MDIO_PMA_DEVAD,
2541 MDIO_PMA_REG_GEN_CTRL,
2542 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2543
2544 /* Release srst bit */
2545 bnx2x_cl45_write(bp, port,
2546 ext_phy_type,
2547 ext_phy_addr,
2548 MDIO_PMA_DEVAD,
2549 MDIO_PMA_REG_GEN_CTRL,
2550 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2551
2552 /* wait for 100ms for code download via SPI port */
2553 msleep(100);
2554
2555 /* Clear ser_boot_ctl bit */
2556 bnx2x_cl45_write(bp, port,
2557 ext_phy_type,
2558 ext_phy_addr,
2559 MDIO_PMA_DEVAD,
2560 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2561
2562 bnx2x_save_bcm_spirom_ver(bp, port,
2563 ext_phy_type,
2564 ext_phy_addr,
2565 shmem_base);
2566 }
2567
2568 static void bnx2x_bcm8073_external_rom_boot(struct bnx2x *bp, u8 port,
2569 u8 ext_phy_addr,
2570 u32 shmem_base)
2571 {
2572 bnx2x_bcm8073_bcm8727_external_rom_boot(bp, port, ext_phy_addr,
2573 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2574 shmem_base);
2575 }
2576
2577 static void bnx2x_bcm8727_external_rom_boot(struct bnx2x *bp, u8 port,
2578 u8 ext_phy_addr,
2579 u32 shmem_base)
2580 {
2581 bnx2x_bcm8073_bcm8727_external_rom_boot(bp, port, ext_phy_addr,
2582 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
2583 shmem_base);
2584
2585 }
2586
2587 static void bnx2x_bcm8726_external_rom_boot(struct link_params *params)
2588 {
2589 struct bnx2x *bp = params->bp;
2590 u8 port = params->port;
2591 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2592 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2593
2594 /* Need to wait 100ms after reset */
2595 msleep(100);
2596
2597 /* Micro controller re-boot */
2598 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2599 MDIO_PMA_DEVAD,
2600 MDIO_PMA_REG_GEN_CTRL,
2601 0x018B);
2602
2603 /* Set soft reset */
2604 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2605 MDIO_PMA_DEVAD,
2606 MDIO_PMA_REG_GEN_CTRL,
2607 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2608
2609 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2610 MDIO_PMA_DEVAD,
2611 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2612
2613 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2614 MDIO_PMA_DEVAD,
2615 MDIO_PMA_REG_GEN_CTRL,
2616 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2617
2618 /* wait for 150ms for microcode load */
2619 msleep(150);
2620
2621 /* Disable serial boot control, tristates pins SS_N, SCK, MOSI, MISO */
2622 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2623 MDIO_PMA_DEVAD,
2624 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2625
2626 msleep(200);
2627 bnx2x_save_bcm_spirom_ver(bp, port,
2628 ext_phy_type,
2629 ext_phy_addr,
2630 params->shmem_base);
2631 }
2632
2633 static void bnx2x_sfp_set_transmitter(struct bnx2x *bp, u8 port,
2634 u32 ext_phy_type, u8 ext_phy_addr,
2635 u8 tx_en)
2636 {
2637 u16 val;
2638
2639 DP(NETIF_MSG_LINK, "Setting transmitter tx_en=%x for port %x\n",
2640 tx_en, port);
2641 /* Disable/Enable transmitter ( TX laser of the SFP+ module.)*/
2642 bnx2x_cl45_read(bp, port,
2643 ext_phy_type,
2644 ext_phy_addr,
2645 MDIO_PMA_DEVAD,
2646 MDIO_PMA_REG_PHY_IDENTIFIER,
2647 &val);
2648
2649 if (tx_en)
2650 val &= ~(1<<15);
2651 else
2652 val |= (1<<15);
2653
2654 bnx2x_cl45_write(bp, port,
2655 ext_phy_type,
2656 ext_phy_addr,
2657 MDIO_PMA_DEVAD,
2658 MDIO_PMA_REG_PHY_IDENTIFIER,
2659 val);
2660 }
2661
2662 static u8 bnx2x_8726_read_sfp_module_eeprom(struct link_params *params,
2663 u16 addr, u8 byte_cnt, u8 *o_buf)
2664 {
2665 struct bnx2x *bp = params->bp;
2666 u16 val = 0;
2667 u16 i;
2668 u8 port = params->port;
2669 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2670 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2671
2672 if (byte_cnt > 16) {
2673 DP(NETIF_MSG_LINK, "Reading from eeprom is"
2674 " is limited to 0xf\n");
2675 return -EINVAL;
2676 }
2677 /* Set the read command byte count */
2678 bnx2x_cl45_write(bp, port,
2679 ext_phy_type,
2680 ext_phy_addr,
2681 MDIO_PMA_DEVAD,
2682 MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
2683 (byte_cnt | 0xa000));
2684
2685 /* Set the read command address */
2686 bnx2x_cl45_write(bp, port,
2687 ext_phy_type,
2688 ext_phy_addr,
2689 MDIO_PMA_DEVAD,
2690 MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
2691 addr);
2692
2693 /* Activate read command */
2694 bnx2x_cl45_write(bp, port,
2695 ext_phy_type,
2696 ext_phy_addr,
2697 MDIO_PMA_DEVAD,
2698 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
2699 0x2c0f);
2700
2701 /* Wait up to 500us for command complete status */
2702 for (i = 0; i < 100; i++) {
2703 bnx2x_cl45_read(bp, port,
2704 ext_phy_type,
2705 ext_phy_addr,
2706 MDIO_PMA_DEVAD,
2707 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2708 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2709 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
2710 break;
2711 udelay(5);
2712 }
2713
2714 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
2715 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
2716 DP(NETIF_MSG_LINK,
2717 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
2718 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
2719 return -EINVAL;
2720 }
2721
2722 /* Read the buffer */
2723 for (i = 0; i < byte_cnt; i++) {
2724 bnx2x_cl45_read(bp, port,
2725 ext_phy_type,
2726 ext_phy_addr,
2727 MDIO_PMA_DEVAD,
2728 MDIO_PMA_REG_8726_TWO_WIRE_DATA_BUF + i, &val);
2729 o_buf[i] = (u8)(val & MDIO_PMA_REG_8726_TWO_WIRE_DATA_MASK);
2730 }
2731
2732 for (i = 0; i < 100; i++) {
2733 bnx2x_cl45_read(bp, port,
2734 ext_phy_type,
2735 ext_phy_addr,
2736 MDIO_PMA_DEVAD,
2737 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2738 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2739 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
2740 return 0;;
2741 msleep(1);
2742 }
2743 return -EINVAL;
2744 }
2745
2746 static u8 bnx2x_8727_read_sfp_module_eeprom(struct link_params *params,
2747 u16 addr, u8 byte_cnt, u8 *o_buf)
2748 {
2749 struct bnx2x *bp = params->bp;
2750 u16 val, i;
2751 u8 port = params->port;
2752 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2753 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2754
2755 if (byte_cnt > 16) {
2756 DP(NETIF_MSG_LINK, "Reading from eeprom is"
2757 " is limited to 0xf\n");
2758 return -EINVAL;
2759 }
2760
2761 /* Need to read from 1.8000 to clear it */
2762 bnx2x_cl45_read(bp, port,
2763 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
2764 ext_phy_addr,
2765 MDIO_PMA_DEVAD,
2766 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
2767 &val);
2768
2769 /* Set the read command byte count */
2770 bnx2x_cl45_write(bp, port,
2771 ext_phy_type,
2772 ext_phy_addr,
2773 MDIO_PMA_DEVAD,
2774 MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
2775 ((byte_cnt < 2) ? 2 : byte_cnt));
2776
2777 /* Set the read command address */
2778 bnx2x_cl45_write(bp, port,
2779 ext_phy_type,
2780 ext_phy_addr,
2781 MDIO_PMA_DEVAD,
2782 MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
2783 addr);
2784 /* Set the destination address */
2785 bnx2x_cl45_write(bp, port,
2786 ext_phy_type,
2787 ext_phy_addr,
2788 MDIO_PMA_DEVAD,
2789 0x8004,
2790 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF);
2791
2792 /* Activate read command */
2793 bnx2x_cl45_write(bp, port,
2794 ext_phy_type,
2795 ext_phy_addr,
2796 MDIO_PMA_DEVAD,
2797 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
2798 0x8002);
2799 /* Wait appropriate time for two-wire command to finish before
2800 polling the status register */
2801 msleep(1);
2802
2803 /* Wait up to 500us for command complete status */
2804 for (i = 0; i < 100; i++) {
2805 bnx2x_cl45_read(bp, port,
2806 ext_phy_type,
2807 ext_phy_addr,
2808 MDIO_PMA_DEVAD,
2809 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2810 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2811 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
2812 break;
2813 udelay(5);
2814 }
2815
2816 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
2817 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
2818 DP(NETIF_MSG_LINK,
2819 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
2820 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
2821 return -EINVAL;
2822 }
2823
2824 /* Read the buffer */
2825 for (i = 0; i < byte_cnt; i++) {
2826 bnx2x_cl45_read(bp, port,
2827 ext_phy_type,
2828 ext_phy_addr,
2829 MDIO_PMA_DEVAD,
2830 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF + i, &val);
2831 o_buf[i] = (u8)(val & MDIO_PMA_REG_8727_TWO_WIRE_DATA_MASK);
2832 }
2833
2834 for (i = 0; i < 100; i++) {
2835 bnx2x_cl45_read(bp, port,
2836 ext_phy_type,
2837 ext_phy_addr,
2838 MDIO_PMA_DEVAD,
2839 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2840 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2841 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
2842 return 0;;
2843 msleep(1);
2844 }
2845
2846 return -EINVAL;
2847 }
2848
2849 u8 bnx2x_read_sfp_module_eeprom(struct link_params *params, u16 addr,
2850 u8 byte_cnt, u8 *o_buf)
2851 {
2852 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2853
2854 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
2855 return bnx2x_8726_read_sfp_module_eeprom(params, addr,
2856 byte_cnt, o_buf);
2857 else if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
2858 return bnx2x_8727_read_sfp_module_eeprom(params, addr,
2859 byte_cnt, o_buf);
2860 return -EINVAL;
2861 }
2862
2863 static u8 bnx2x_get_edc_mode(struct link_params *params,
2864 u16 *edc_mode)
2865 {
2866 struct bnx2x *bp = params->bp;
2867 u8 val, check_limiting_mode = 0;
2868 *edc_mode = EDC_MODE_LIMITING;
2869
2870 /* First check for copper cable */
2871 if (bnx2x_read_sfp_module_eeprom(params,
2872 SFP_EEPROM_CON_TYPE_ADDR,
2873 1,
2874 &val) != 0) {
2875 DP(NETIF_MSG_LINK, "Failed to read from SFP+ module EEPROM\n");
2876 return -EINVAL;
2877 }
2878
2879 switch (val) {
2880 case SFP_EEPROM_CON_TYPE_VAL_COPPER:
2881 {
2882 u8 copper_module_type;
2883
2884 /* Check if its active cable( includes SFP+ module)
2885 of passive cable*/
2886 if (bnx2x_read_sfp_module_eeprom(params,
2887 SFP_EEPROM_FC_TX_TECH_ADDR,
2888 1,
2889 &copper_module_type) !=
2890 0) {
2891 DP(NETIF_MSG_LINK,
2892 "Failed to read copper-cable-type"
2893 " from SFP+ EEPROM\n");
2894 return -EINVAL;
2895 }
2896
2897 if (copper_module_type &
2898 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE) {
2899 DP(NETIF_MSG_LINK, "Active Copper cable detected\n");
2900 check_limiting_mode = 1;
2901 } else if (copper_module_type &
2902 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE) {
2903 DP(NETIF_MSG_LINK, "Passive Copper"
2904 " cable detected\n");
2905 *edc_mode =
2906 EDC_MODE_PASSIVE_DAC;
2907 } else {
2908 DP(NETIF_MSG_LINK, "Unknown copper-cable-"
2909 "type 0x%x !!!\n", copper_module_type);
2910 return -EINVAL;
2911 }
2912 break;
2913 }
2914 case SFP_EEPROM_CON_TYPE_VAL_LC:
2915 DP(NETIF_MSG_LINK, "Optic module detected\n");
2916 check_limiting_mode = 1;
2917 break;
2918 default:
2919 DP(NETIF_MSG_LINK, "Unable to determine module type 0x%x !!!\n",
2920 val);
2921 return -EINVAL;
2922 }
2923
2924 if (check_limiting_mode) {
2925 u8 options[SFP_EEPROM_OPTIONS_SIZE];
2926 if (bnx2x_read_sfp_module_eeprom(params,
2927 SFP_EEPROM_OPTIONS_ADDR,
2928 SFP_EEPROM_OPTIONS_SIZE,
2929 options) != 0) {
2930 DP(NETIF_MSG_LINK, "Failed to read Option"
2931 " field from module EEPROM\n");
2932 return -EINVAL;
2933 }
2934 if ((options[0] & SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK))
2935 *edc_mode = EDC_MODE_LINEAR;
2936 else
2937 *edc_mode = EDC_MODE_LIMITING;
2938 }
2939 DP(NETIF_MSG_LINK, "EDC mode is set to 0x%x\n", *edc_mode);
2940 return 0;
2941 }
2942
2943 /* This function read the relevant field from the module ( SFP+ ),
2944 and verify it is compliant with this board */
2945 static u8 bnx2x_verify_sfp_module(struct link_params *params)
2946 {
2947 struct bnx2x *bp = params->bp;
2948 u32 val;
2949 u32 fw_resp;
2950 char vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE+1];
2951 char vendor_pn[SFP_EEPROM_PART_NO_SIZE+1];
2952
2953 val = REG_RD(bp, params->shmem_base +
2954 offsetof(struct shmem_region, dev_info.
2955 port_feature_config[params->port].config));
2956 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
2957 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT) {
2958 DP(NETIF_MSG_LINK, "NOT enforcing module verification\n");
2959 return 0;
2960 }
2961
2962 /* Ask the FW to validate the module */
2963 if (!(params->feature_config_flags &
2964 FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY)) {
2965 DP(NETIF_MSG_LINK, "FW does not support OPT MDL "
2966 "verification\n");
2967 return -EINVAL;
2968 }
2969
2970 fw_resp = bnx2x_fw_command(bp, DRV_MSG_CODE_VRFY_OPT_MDL);
2971 if (fw_resp == FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS) {
2972 DP(NETIF_MSG_LINK, "Approved module\n");
2973 return 0;
2974 }
2975
2976 /* format the warning message */
2977 if (bnx2x_read_sfp_module_eeprom(params,
2978 SFP_EEPROM_VENDOR_NAME_ADDR,
2979 SFP_EEPROM_VENDOR_NAME_SIZE,
2980 (u8 *)vendor_name))
2981 vendor_name[0] = '\0';
2982 else
2983 vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE] = '\0';
2984 if (bnx2x_read_sfp_module_eeprom(params,
2985 SFP_EEPROM_PART_NO_ADDR,
2986 SFP_EEPROM_PART_NO_SIZE,
2987 (u8 *)vendor_pn))
2988 vendor_pn[0] = '\0';
2989 else
2990 vendor_pn[SFP_EEPROM_PART_NO_SIZE] = '\0';
2991
2992 netdev_info(bp->dev, "Warning: Unqualified SFP+ module detected, Port %d from %s part number %s\n",
2993 params->port, vendor_name, vendor_pn);
2994 return -EINVAL;
2995 }
2996
2997 static u8 bnx2x_bcm8726_set_limiting_mode(struct link_params *params,
2998 u16 edc_mode)
2999 {
3000 struct bnx2x *bp = params->bp;
3001 u8 port = params->port;
3002 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3003 u16 cur_limiting_mode;
3004
3005 bnx2x_cl45_read(bp, port,
3006 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3007 ext_phy_addr,
3008 MDIO_PMA_DEVAD,
3009 MDIO_PMA_REG_ROM_VER2,
3010 &cur_limiting_mode);
3011 DP(NETIF_MSG_LINK, "Current Limiting mode is 0x%x\n",
3012 cur_limiting_mode);
3013
3014 if (edc_mode == EDC_MODE_LIMITING) {
3015 DP(NETIF_MSG_LINK,
3016 "Setting LIMITING MODE\n");
3017 bnx2x_cl45_write(bp, port,
3018 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3019 ext_phy_addr,
3020 MDIO_PMA_DEVAD,
3021 MDIO_PMA_REG_ROM_VER2,
3022 EDC_MODE_LIMITING);
3023 } else { /* LRM mode ( default )*/
3024
3025 DP(NETIF_MSG_LINK, "Setting LRM MODE\n");
3026
3027 /* Changing to LRM mode takes quite few seconds.
3028 So do it only if current mode is limiting
3029 ( default is LRM )*/
3030 if (cur_limiting_mode != EDC_MODE_LIMITING)
3031 return 0;
3032
3033 bnx2x_cl45_write(bp, port,
3034 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3035 ext_phy_addr,
3036 MDIO_PMA_DEVAD,
3037 MDIO_PMA_REG_LRM_MODE,
3038 0);
3039 bnx2x_cl45_write(bp, port,
3040 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3041 ext_phy_addr,
3042 MDIO_PMA_DEVAD,
3043 MDIO_PMA_REG_ROM_VER2,
3044 0x128);
3045 bnx2x_cl45_write(bp, port,
3046 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3047 ext_phy_addr,
3048 MDIO_PMA_DEVAD,
3049 MDIO_PMA_REG_MISC_CTRL0,
3050 0x4008);
3051 bnx2x_cl45_write(bp, port,
3052 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
3053 ext_phy_addr,
3054 MDIO_PMA_DEVAD,
3055 MDIO_PMA_REG_LRM_MODE,
3056 0xaaaa);
3057 }
3058 return 0;
3059 }
3060
3061 static u8 bnx2x_bcm8727_set_limiting_mode(struct link_params *params,
3062 u16 edc_mode)
3063 {
3064 struct bnx2x *bp = params->bp;
3065 u8 port = params->port;
3066 u16 phy_identifier;
3067 u16 rom_ver2_val;
3068 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3069
3070 bnx2x_cl45_read(bp, port,
3071 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3072 ext_phy_addr,
3073 MDIO_PMA_DEVAD,
3074 MDIO_PMA_REG_PHY_IDENTIFIER,
3075 &phy_identifier);
3076
3077 bnx2x_cl45_write(bp, port,
3078 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3079 ext_phy_addr,
3080 MDIO_PMA_DEVAD,
3081 MDIO_PMA_REG_PHY_IDENTIFIER,
3082 (phy_identifier & ~(1<<9)));
3083
3084 bnx2x_cl45_read(bp, port,
3085 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3086 ext_phy_addr,
3087 MDIO_PMA_DEVAD,
3088 MDIO_PMA_REG_ROM_VER2,
3089 &rom_ver2_val);
3090 /* Keep the MSB 8-bits, and set the LSB 8-bits with the edc_mode */
3091 bnx2x_cl45_write(bp, port,
3092 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3093 ext_phy_addr,
3094 MDIO_PMA_DEVAD,
3095 MDIO_PMA_REG_ROM_VER2,
3096 (rom_ver2_val & 0xff00) | (edc_mode & 0x00ff));
3097
3098 bnx2x_cl45_write(bp, port,
3099 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3100 ext_phy_addr,
3101 MDIO_PMA_DEVAD,
3102 MDIO_PMA_REG_PHY_IDENTIFIER,
3103 (phy_identifier | (1<<9)));
3104
3105 return 0;
3106 }
3107
3108
3109 static u8 bnx2x_wait_for_sfp_module_initialized(struct link_params *params)
3110 {
3111 u8 val;
3112 struct bnx2x *bp = params->bp;
3113 u16 timeout;
3114 /* Initialization time after hot-plug may take up to 300ms for some
3115 phys type ( e.g. JDSU ) */
3116 for (timeout = 0; timeout < 60; timeout++) {
3117 if (bnx2x_read_sfp_module_eeprom(params, 1, 1, &val)
3118 == 0) {
3119 DP(NETIF_MSG_LINK, "SFP+ module initialization "
3120 "took %d ms\n", timeout * 5);
3121 return 0;
3122 }
3123 msleep(5);
3124 }
3125 return -EINVAL;
3126 }
3127
3128 static void bnx2x_8727_power_module(struct bnx2x *bp,
3129 struct link_params *params,
3130 u8 ext_phy_addr, u8 is_power_up) {
3131 /* Make sure GPIOs are not using for LED mode */
3132 u16 val;
3133 u8 port = params->port;
3134 /*
3135 * In the GPIO register, bit 4 is use to detemine if the GPIOs are
3136 * operating as INPUT or as OUTPUT. Bit 1 is for input, and 0 for
3137 * output
3138 * Bits 0-1 determine the gpios value for OUTPUT in case bit 4 val is 0
3139 * Bits 8-9 determine the gpios value for INPUT in case bit 4 val is 1
3140 * where the 1st bit is the over-current(only input), and 2nd bit is
3141 * for power( only output )
3142 */
3143
3144 /*
3145 * In case of NOC feature is disabled and power is up, set GPIO control
3146 * as input to enable listening of over-current indication
3147 */
3148
3149 if (!(params->feature_config_flags &
3150 FEATURE_CONFIG_BCM8727_NOC) && is_power_up)
3151 val = (1<<4);
3152 else
3153 /*
3154 * Set GPIO control to OUTPUT, and set the power bit
3155 * to according to the is_power_up
3156 */
3157 val = ((!(is_power_up)) << 1);
3158
3159 bnx2x_cl45_write(bp, port,
3160 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3161 ext_phy_addr,
3162 MDIO_PMA_DEVAD,
3163 MDIO_PMA_REG_8727_GPIO_CTRL,
3164 val);
3165 }
3166
3167 static u8 bnx2x_sfp_module_detection(struct link_params *params)
3168 {
3169 struct bnx2x *bp = params->bp;
3170 u16 edc_mode;
3171 u8 rc = 0;
3172 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3173 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3174 u32 val = REG_RD(bp, params->shmem_base +
3175 offsetof(struct shmem_region, dev_info.
3176 port_feature_config[params->port].config));
3177
3178 DP(NETIF_MSG_LINK, "SFP+ module plugged in/out detected on port %d\n",
3179 params->port);
3180
3181 if (bnx2x_get_edc_mode(params, &edc_mode) != 0) {
3182 DP(NETIF_MSG_LINK, "Failed to get valid module type\n");
3183 return -EINVAL;
3184 } else if (bnx2x_verify_sfp_module(params) !=
3185 0) {
3186 /* check SFP+ module compatibility */
3187 DP(NETIF_MSG_LINK, "Module verification failed!!\n");
3188 rc = -EINVAL;
3189 /* Turn on fault module-detected led */
3190 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3191 MISC_REGISTERS_GPIO_HIGH,
3192 params->port);
3193 if ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727) &&
3194 ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
3195 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN)) {
3196 /* Shutdown SFP+ module */
3197 DP(NETIF_MSG_LINK, "Shutdown SFP+ module!!\n");
3198 bnx2x_8727_power_module(bp, params,
3199 ext_phy_addr, 0);
3200 return rc;
3201 }
3202 } else {
3203 /* Turn off fault module-detected led */
3204 DP(NETIF_MSG_LINK, "Turn off fault module-detected led\n");
3205 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3206 MISC_REGISTERS_GPIO_LOW,
3207 params->port);
3208 }
3209
3210 /* power up the SFP module */
3211 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
3212 bnx2x_8727_power_module(bp, params, ext_phy_addr, 1);
3213
3214 /* Check and set limiting mode / LRM mode on 8726.
3215 On 8727 it is done automatically */
3216 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
3217 bnx2x_bcm8726_set_limiting_mode(params, edc_mode);
3218 else
3219 bnx2x_bcm8727_set_limiting_mode(params, edc_mode);
3220 /*
3221 * Enable transmit for this module if the module is approved, or
3222 * if unapproved modules should also enable the Tx laser
3223 */
3224 if (rc == 0 ||
3225 (val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) !=
3226 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
3227 bnx2x_sfp_set_transmitter(bp, params->port,
3228 ext_phy_type, ext_phy_addr, 1);
3229 else
3230 bnx2x_sfp_set_transmitter(bp, params->port,
3231 ext_phy_type, ext_phy_addr, 0);
3232
3233 return rc;
3234 }
3235
3236 void bnx2x_handle_module_detect_int(struct link_params *params)
3237 {
3238 struct bnx2x *bp = params->bp;
3239 u32 gpio_val;
3240 u8 port = params->port;
3241
3242 /* Set valid module led off */
3243 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3244 MISC_REGISTERS_GPIO_HIGH,
3245 params->port);
3246
3247 /* Get current gpio val refelecting module plugged in / out*/
3248 gpio_val = bnx2x_get_gpio(bp, MISC_REGISTERS_GPIO_3, port);
3249
3250 /* Call the handling function in case module is detected */
3251 if (gpio_val == 0) {
3252
3253 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
3254 MISC_REGISTERS_GPIO_INT_OUTPUT_CLR,
3255 port);
3256
3257 if (bnx2x_wait_for_sfp_module_initialized(params) ==
3258 0)
3259 bnx2x_sfp_module_detection(params);
3260 else
3261 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
3262 } else {
3263 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3264
3265 u32 ext_phy_type =
3266 XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3267 u32 val = REG_RD(bp, params->shmem_base +
3268 offsetof(struct shmem_region, dev_info.
3269 port_feature_config[params->port].
3270 config));
3271
3272 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
3273 MISC_REGISTERS_GPIO_INT_OUTPUT_SET,
3274 port);
3275 /* Module was plugged out. */
3276 /* Disable transmit for this module */
3277 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
3278 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
3279 bnx2x_sfp_set_transmitter(bp, params->port,
3280 ext_phy_type, ext_phy_addr, 0);
3281 }
3282 }
3283
3284 static void bnx2x_bcm807x_force_10G(struct link_params *params)
3285 {
3286 struct bnx2x *bp = params->bp;
3287 u8 port = params->port;
3288 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3289 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3290
3291 /* Force KR or KX */
3292 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3293 MDIO_PMA_DEVAD,
3294 MDIO_PMA_REG_CTRL,
3295 0x2040);
3296 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3297 MDIO_PMA_DEVAD,
3298 MDIO_PMA_REG_10G_CTRL2,
3299 0x000b);
3300 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3301 MDIO_PMA_DEVAD,
3302 MDIO_PMA_REG_BCM_CTRL,
3303 0x0000);
3304 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3305 MDIO_AN_DEVAD,
3306 MDIO_AN_REG_CTRL,
3307 0x0000);
3308 }
3309
3310 static void bnx2x_bcm8073_set_xaui_low_power_mode(struct link_params *params)
3311 {
3312 struct bnx2x *bp = params->bp;
3313 u8 port = params->port;
3314 u16 val;
3315 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3316 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3317
3318 bnx2x_cl45_read(bp, params->port,
3319 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
3320 ext_phy_addr,
3321 MDIO_PMA_DEVAD,
3322 MDIO_PMA_REG_8073_CHIP_REV, &val);
3323
3324 if (val == 0) {
3325 /* Mustn't set low power mode in 8073 A0 */
3326 return;
3327 }
3328
3329 /* Disable PLL sequencer (use read-modify-write to clear bit 13) */
3330 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr,
3331 MDIO_XS_DEVAD,
3332 MDIO_XS_PLL_SEQUENCER, &val);
3333 val &= ~(1<<13);
3334 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3335 MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val);
3336
3337 /* PLL controls */
3338 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3339 MDIO_XS_DEVAD, 0x805E, 0x1077);
3340 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3341 MDIO_XS_DEVAD, 0x805D, 0x0000);
3342 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3343 MDIO_XS_DEVAD, 0x805C, 0x030B);
3344 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3345 MDIO_XS_DEVAD, 0x805B, 0x1240);
3346 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3347 MDIO_XS_DEVAD, 0x805A, 0x2490);
3348
3349 /* Tx Controls */
3350 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3351 MDIO_XS_DEVAD, 0x80A7, 0x0C74);
3352 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3353 MDIO_XS_DEVAD, 0x80A6, 0x9041);
3354 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3355 MDIO_XS_DEVAD, 0x80A5, 0x4640);
3356
3357 /* Rx Controls */
3358 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3359 MDIO_XS_DEVAD, 0x80FE, 0x01C4);
3360 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3361 MDIO_XS_DEVAD, 0x80FD, 0x9249);
3362 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3363 MDIO_XS_DEVAD, 0x80FC, 0x2015);
3364
3365 /* Enable PLL sequencer (use read-modify-write to set bit 13) */
3366 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr,
3367 MDIO_XS_DEVAD,
3368 MDIO_XS_PLL_SEQUENCER, &val);
3369 val |= (1<<13);
3370 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3371 MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val);
3372 }
3373
3374 static void bnx2x_8073_set_pause_cl37(struct link_params *params,
3375 struct link_vars *vars)
3376 {
3377 struct bnx2x *bp = params->bp;
3378 u16 cl37_val;
3379 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3380 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3381
3382 bnx2x_cl45_read(bp, params->port,
3383 ext_phy_type,
3384 ext_phy_addr,
3385 MDIO_AN_DEVAD,
3386 MDIO_AN_REG_CL37_FC_LD, &cl37_val);
3387
3388 cl37_val &= ~MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
3389 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
3390
3391 if ((vars->ieee_fc &
3392 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) ==
3393 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) {
3394 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC;
3395 }
3396 if ((vars->ieee_fc &
3397 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
3398 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
3399 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
3400 }
3401 if ((vars->ieee_fc &
3402 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
3403 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
3404 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
3405 }
3406 DP(NETIF_MSG_LINK,
3407 "Ext phy AN advertize cl37 0x%x\n", cl37_val);
3408
3409 bnx2x_cl45_write(bp, params->port,
3410 ext_phy_type,
3411 ext_phy_addr,
3412 MDIO_AN_DEVAD,
3413 MDIO_AN_REG_CL37_FC_LD, cl37_val);
3414 msleep(500);
3415 }
3416
3417 static void bnx2x_ext_phy_set_pause(struct link_params *params,
3418 struct link_vars *vars)
3419 {
3420 struct bnx2x *bp = params->bp;
3421 u16 val;
3422 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3423 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3424
3425 /* read modify write pause advertizing */
3426 bnx2x_cl45_read(bp, params->port,
3427 ext_phy_type,
3428 ext_phy_addr,
3429 MDIO_AN_DEVAD,
3430 MDIO_AN_REG_ADV_PAUSE, &val);
3431
3432 val &= ~MDIO_AN_REG_ADV_PAUSE_BOTH;
3433
3434 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
3435
3436 if ((vars->ieee_fc &
3437 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
3438 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
3439 val |= MDIO_AN_REG_ADV_PAUSE_ASYMMETRIC;
3440 }
3441 if ((vars->ieee_fc &
3442 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
3443 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
3444 val |=
3445 MDIO_AN_REG_ADV_PAUSE_PAUSE;
3446 }
3447 DP(NETIF_MSG_LINK,
3448 "Ext phy AN advertize 0x%x\n", val);
3449 bnx2x_cl45_write(bp, params->port,
3450 ext_phy_type,
3451 ext_phy_addr,
3452 MDIO_AN_DEVAD,
3453 MDIO_AN_REG_ADV_PAUSE, val);
3454 }
3455 static void bnx2x_set_preemphasis(struct link_params *params)
3456 {
3457 u16 bank, i = 0;
3458 struct bnx2x *bp = params->bp;
3459
3460 for (bank = MDIO_REG_BANK_RX0, i = 0; bank <= MDIO_REG_BANK_RX3;
3461 bank += (MDIO_REG_BANK_RX1-MDIO_REG_BANK_RX0), i++) {
3462 CL45_WR_OVER_CL22(bp, params->port,
3463 params->phy_addr,
3464 bank,
3465 MDIO_RX0_RX_EQ_BOOST,
3466 params->xgxs_config_rx[i]);
3467 }
3468
3469 for (bank = MDIO_REG_BANK_TX0, i = 0; bank <= MDIO_REG_BANK_TX3;
3470 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0), i++) {
3471 CL45_WR_OVER_CL22(bp, params->port,
3472 params->phy_addr,
3473 bank,
3474 MDIO_TX0_TX_DRIVER,
3475 params->xgxs_config_tx[i]);
3476 }
3477 }
3478
3479
3480 static void bnx2x_8481_set_led4(struct link_params *params,
3481 u32 ext_phy_type, u8 ext_phy_addr)
3482 {
3483 struct bnx2x *bp = params->bp;
3484
3485 /* PHYC_CTL_LED_CTL */
3486 bnx2x_cl45_write(bp, params->port,
3487 ext_phy_type,
3488 ext_phy_addr,
3489 MDIO_PMA_DEVAD,
3490 MDIO_PMA_REG_8481_LINK_SIGNAL, 0xa482);
3491
3492 /* Unmask LED4 for 10G link */
3493 bnx2x_cl45_write(bp, params->port,
3494 ext_phy_type,
3495 ext_phy_addr,
3496 MDIO_PMA_DEVAD,
3497 MDIO_PMA_REG_8481_SIGNAL_MASK, (1<<6));
3498 /* 'Interrupt Mask' */
3499 bnx2x_cl45_write(bp, params->port,
3500 ext_phy_type,
3501 ext_phy_addr,
3502 MDIO_AN_DEVAD,
3503 0xFFFB, 0xFFFD);
3504 }
3505 static void bnx2x_8481_set_legacy_led_mode(struct link_params *params,
3506 u32 ext_phy_type, u8 ext_phy_addr)
3507 {
3508 struct bnx2x *bp = params->bp;
3509
3510 /* LED1 (10G Link): Disable LED1 when 10/100/1000 link */
3511 /* LED2 (1G/100/10 Link): Enable LED2 when 10/100/1000 link) */
3512 bnx2x_cl45_write(bp, params->port,
3513 ext_phy_type,
3514 ext_phy_addr,
3515 MDIO_AN_DEVAD,
3516 MDIO_AN_REG_8481_LEGACY_SHADOW,
3517 (1<<15) | (0xd << 10) | (0xc<<4) | 0xe);
3518 }
3519
3520 static void bnx2x_8481_set_10G_led_mode(struct link_params *params,
3521 u32 ext_phy_type, u8 ext_phy_addr)
3522 {
3523 struct bnx2x *bp = params->bp;
3524 u16 val1;
3525
3526 /* LED1 (10G Link) */
3527 /* Enable continuse based on source 7(10G-link) */
3528 bnx2x_cl45_read(bp, params->port,
3529 ext_phy_type,
3530 ext_phy_addr,
3531 MDIO_PMA_DEVAD,
3532 MDIO_PMA_REG_8481_LINK_SIGNAL,
3533 &val1);
3534 /* Set bit 2 to 0, and bits [1:0] to 10 */
3535 val1 &= ~((1<<0) | (1<<2) | (1<<7)); /* Clear bits 0,2,7*/
3536 val1 |= ((1<<1) | (1<<6)); /* Set bit 1, 6 */
3537
3538 bnx2x_cl45_write(bp, params->port,
3539 ext_phy_type,
3540 ext_phy_addr,
3541 MDIO_PMA_DEVAD,
3542 MDIO_PMA_REG_8481_LINK_SIGNAL,
3543 val1);
3544
3545 /* Unmask LED1 for 10G link */
3546 bnx2x_cl45_read(bp, params->port,
3547 ext_phy_type,
3548 ext_phy_addr,
3549 MDIO_PMA_DEVAD,
3550 MDIO_PMA_REG_8481_LED1_MASK,
3551 &val1);
3552 /* Set bit 2 to 0, and bits [1:0] to 10 */
3553 val1 |= (1<<7);
3554 bnx2x_cl45_write(bp, params->port,
3555 ext_phy_type,
3556 ext_phy_addr,
3557 MDIO_PMA_DEVAD,
3558 MDIO_PMA_REG_8481_LED1_MASK,
3559 val1);
3560
3561 /* LED2 (1G/100/10G Link) */
3562 /* Mask LED2 for 10G link */
3563 bnx2x_cl45_write(bp, params->port,
3564 ext_phy_type,
3565 ext_phy_addr,
3566 MDIO_PMA_DEVAD,
3567 MDIO_PMA_REG_8481_LED2_MASK,
3568 0);
3569
3570 /* Unmask LED3 for 10G link */
3571 bnx2x_cl45_write(bp, params->port,
3572 ext_phy_type,
3573 ext_phy_addr,
3574 MDIO_PMA_DEVAD,
3575 MDIO_PMA_REG_8481_LED3_MASK,
3576 0x6);
3577 bnx2x_cl45_write(bp, params->port,
3578 ext_phy_type,
3579 ext_phy_addr,
3580 MDIO_PMA_DEVAD,
3581 MDIO_PMA_REG_8481_LED3_BLINK,
3582 0);
3583 }
3584
3585
3586 static void bnx2x_init_internal_phy(struct link_params *params,
3587 struct link_vars *vars,
3588 u8 enable_cl73)
3589 {
3590 struct bnx2x *bp = params->bp;
3591
3592 if (!(vars->phy_flags & PHY_SGMII_FLAG)) {
3593 if ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
3594 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
3595 (params->feature_config_flags &
3596 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED))
3597 bnx2x_set_preemphasis(params);
3598
3599 /* forced speed requested? */
3600 if (vars->line_speed != SPEED_AUTO_NEG ||
3601 ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
3602 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
3603 params->loopback_mode == LOOPBACK_EXT)) {
3604 DP(NETIF_MSG_LINK, "not SGMII, no AN\n");
3605
3606 /* disable autoneg */
3607 bnx2x_set_autoneg(params, vars, 0);
3608
3609 /* program speed and duplex */
3610 bnx2x_program_serdes(params, vars);
3611
3612 } else { /* AN_mode */
3613 DP(NETIF_MSG_LINK, "not SGMII, AN\n");
3614
3615 /* AN enabled */
3616 bnx2x_set_brcm_cl37_advertisment(params);
3617
3618 /* program duplex & pause advertisement (for aneg) */
3619 bnx2x_set_ieee_aneg_advertisment(params,
3620 vars->ieee_fc);
3621
3622 /* enable autoneg */
3623 bnx2x_set_autoneg(params, vars, enable_cl73);
3624
3625 /* enable and restart AN */
3626 bnx2x_restart_autoneg(params, enable_cl73);
3627 }
3628
3629 } else { /* SGMII mode */
3630 DP(NETIF_MSG_LINK, "SGMII\n");
3631
3632 bnx2x_initialize_sgmii_process(params, vars);
3633 }
3634 }
3635
3636 static u8 bnx2x_ext_phy_init(struct link_params *params, struct link_vars *vars)
3637 {
3638 struct bnx2x *bp = params->bp;
3639 u32 ext_phy_type;
3640 u8 ext_phy_addr;
3641 u16 cnt;
3642 u16 ctrl = 0;
3643 u16 val = 0;
3644 u8 rc = 0;
3645
3646 if (vars->phy_flags & PHY_XGXS_FLAG) {
3647 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3648
3649 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3650 /* Make sure that the soft reset is off (expect for the 8072:
3651 * due to the lock, it will be done inside the specific
3652 * handling)
3653 */
3654 if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
3655 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
3656 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN) &&
3657 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) &&
3658 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073)) {
3659 /* Wait for soft reset to get cleared upto 1 sec */
3660 for (cnt = 0; cnt < 1000; cnt++) {
3661 bnx2x_cl45_read(bp, params->port,
3662 ext_phy_type,
3663 ext_phy_addr,
3664 MDIO_PMA_DEVAD,
3665 MDIO_PMA_REG_CTRL, &ctrl);
3666 if (!(ctrl & (1<<15)))
3667 break;
3668 msleep(1);
3669 }
3670 DP(NETIF_MSG_LINK, "control reg 0x%x (after %d ms)\n",
3671 ctrl, cnt);
3672 }
3673
3674 switch (ext_phy_type) {
3675 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
3676 break;
3677
3678 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
3679 DP(NETIF_MSG_LINK, "XGXS 8705\n");
3680
3681 bnx2x_cl45_write(bp, params->port,
3682 ext_phy_type,
3683 ext_phy_addr,
3684 MDIO_PMA_DEVAD,
3685 MDIO_PMA_REG_MISC_CTRL,
3686 0x8288);
3687 bnx2x_cl45_write(bp, params->port,
3688 ext_phy_type,
3689 ext_phy_addr,
3690 MDIO_PMA_DEVAD,
3691 MDIO_PMA_REG_PHY_IDENTIFIER,
3692 0x7fbf);
3693 bnx2x_cl45_write(bp, params->port,
3694 ext_phy_type,
3695 ext_phy_addr,
3696 MDIO_PMA_DEVAD,
3697 MDIO_PMA_REG_CMU_PLL_BYPASS,
3698 0x0100);
3699 bnx2x_cl45_write(bp, params->port,
3700 ext_phy_type,
3701 ext_phy_addr,
3702 MDIO_WIS_DEVAD,
3703 MDIO_WIS_REG_LASI_CNTL, 0x1);
3704
3705 /* BCM8705 doesn't have microcode, hence the 0 */
3706 bnx2x_save_spirom_version(bp, params->port,
3707 params->shmem_base, 0);
3708 break;
3709
3710 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
3711 /* Wait until fw is loaded */
3712 for (cnt = 0; cnt < 100; cnt++) {
3713 bnx2x_cl45_read(bp, params->port, ext_phy_type,
3714 ext_phy_addr, MDIO_PMA_DEVAD,
3715 MDIO_PMA_REG_ROM_VER1, &val);
3716 if (val)
3717 break;
3718 msleep(10);
3719 }
3720 DP(NETIF_MSG_LINK, "XGXS 8706 is initialized "
3721 "after %d ms\n", cnt);
3722 if ((params->feature_config_flags &
3723 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
3724 u8 i;
3725 u16 reg;
3726 for (i = 0; i < 4; i++) {
3727 reg = MDIO_XS_8706_REG_BANK_RX0 +
3728 i*(MDIO_XS_8706_REG_BANK_RX1 -
3729 MDIO_XS_8706_REG_BANK_RX0);
3730 bnx2x_cl45_read(bp, params->port,
3731 ext_phy_type,
3732 ext_phy_addr,
3733 MDIO_XS_DEVAD,
3734 reg, &val);
3735 /* Clear first 3 bits of the control */
3736 val &= ~0x7;
3737 /* Set control bits according to
3738 configuation */
3739 val |= (params->xgxs_config_rx[i] &
3740 0x7);
3741 DP(NETIF_MSG_LINK, "Setting RX"
3742 "Equalizer to BCM8706 reg 0x%x"
3743 " <-- val 0x%x\n", reg, val);
3744 bnx2x_cl45_write(bp, params->port,
3745 ext_phy_type,
3746 ext_phy_addr,
3747 MDIO_XS_DEVAD,
3748 reg, val);
3749 }
3750 }
3751 /* Force speed */
3752 if (params->req_line_speed == SPEED_10000) {
3753 DP(NETIF_MSG_LINK, "XGXS 8706 force 10Gbps\n");
3754
3755 bnx2x_cl45_write(bp, params->port,
3756 ext_phy_type,
3757 ext_phy_addr,
3758 MDIO_PMA_DEVAD,
3759 MDIO_PMA_REG_DIGITAL_CTRL,
3760 0x400);
3761 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3762 ext_phy_addr, MDIO_PMA_DEVAD,
3763 MDIO_PMA_REG_LASI_CTRL, 1);
3764 } else {
3765 /* Force 1Gbps using autoneg with 1G
3766 advertisment */
3767
3768 /* Allow CL37 through CL73 */
3769 DP(NETIF_MSG_LINK, "XGXS 8706 AutoNeg\n");
3770 bnx2x_cl45_write(bp, params->port,
3771 ext_phy_type,
3772 ext_phy_addr,
3773 MDIO_AN_DEVAD,
3774 MDIO_AN_REG_CL37_CL73,
3775 0x040c);
3776
3777 /* Enable Full-Duplex advertisment on CL37 */
3778 bnx2x_cl45_write(bp, params->port,
3779 ext_phy_type,
3780 ext_phy_addr,
3781 MDIO_AN_DEVAD,
3782 MDIO_AN_REG_CL37_FC_LP,
3783 0x0020);
3784 /* Enable CL37 AN */
3785 bnx2x_cl45_write(bp, params->port,
3786 ext_phy_type,
3787 ext_phy_addr,
3788 MDIO_AN_DEVAD,
3789 MDIO_AN_REG_CL37_AN,
3790 0x1000);
3791 /* 1G support */
3792 bnx2x_cl45_write(bp, params->port,
3793 ext_phy_type,
3794 ext_phy_addr,
3795 MDIO_AN_DEVAD,
3796 MDIO_AN_REG_ADV, (1<<5));
3797
3798 /* Enable clause 73 AN */
3799 bnx2x_cl45_write(bp, params->port,
3800 ext_phy_type,
3801 ext_phy_addr,
3802 MDIO_AN_DEVAD,
3803 MDIO_AN_REG_CTRL,
3804 0x1200);
3805 bnx2x_cl45_write(bp, params->port,
3806 ext_phy_type,
3807 ext_phy_addr,
3808 MDIO_PMA_DEVAD,
3809 MDIO_PMA_REG_RX_ALARM_CTRL,
3810 0x0400);
3811 bnx2x_cl45_write(bp, params->port,
3812 ext_phy_type,
3813 ext_phy_addr,
3814 MDIO_PMA_DEVAD,
3815 MDIO_PMA_REG_LASI_CTRL, 0x0004);
3816
3817 }
3818 bnx2x_save_bcm_spirom_ver(bp, params->port,
3819 ext_phy_type,
3820 ext_phy_addr,
3821 params->shmem_base);
3822 break;
3823 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
3824 DP(NETIF_MSG_LINK, "Initializing BCM8726\n");
3825 bnx2x_bcm8726_external_rom_boot(params);
3826
3827 /* Need to call module detected on initialization since
3828 the module detection triggered by actual module
3829 insertion might occur before driver is loaded, and when
3830 driver is loaded, it reset all registers, including the
3831 transmitter */
3832 bnx2x_sfp_module_detection(params);
3833
3834 /* Set Flow control */
3835 bnx2x_ext_phy_set_pause(params, vars);
3836 if (params->req_line_speed == SPEED_1000) {
3837 DP(NETIF_MSG_LINK, "Setting 1G force\n");
3838 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3839 ext_phy_addr, MDIO_PMA_DEVAD,
3840 MDIO_PMA_REG_CTRL, 0x40);
3841 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3842 ext_phy_addr, MDIO_PMA_DEVAD,
3843 MDIO_PMA_REG_10G_CTRL2, 0xD);
3844 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3845 ext_phy_addr, MDIO_PMA_DEVAD,
3846 MDIO_PMA_REG_LASI_CTRL, 0x5);
3847 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3848 ext_phy_addr, MDIO_PMA_DEVAD,
3849 MDIO_PMA_REG_RX_ALARM_CTRL,
3850 0x400);
3851 } else if ((params->req_line_speed ==
3852 SPEED_AUTO_NEG) &&
3853 ((params->speed_cap_mask &
3854 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
3855 DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
3856 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3857 ext_phy_addr, MDIO_AN_DEVAD,
3858 MDIO_AN_REG_ADV, 0x20);
3859 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3860 ext_phy_addr, MDIO_AN_DEVAD,
3861 MDIO_AN_REG_CL37_CL73, 0x040c);
3862 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3863 ext_phy_addr, MDIO_AN_DEVAD,
3864 MDIO_AN_REG_CL37_FC_LD, 0x0020);
3865 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3866 ext_phy_addr, MDIO_AN_DEVAD,
3867 MDIO_AN_REG_CL37_AN, 0x1000);
3868 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3869 ext_phy_addr, MDIO_AN_DEVAD,
3870 MDIO_AN_REG_CTRL, 0x1200);
3871
3872 /* Enable RX-ALARM control to receive
3873 interrupt for 1G speed change */
3874 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3875 ext_phy_addr, MDIO_PMA_DEVAD,
3876 MDIO_PMA_REG_LASI_CTRL, 0x4);
3877 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3878 ext_phy_addr, MDIO_PMA_DEVAD,
3879 MDIO_PMA_REG_RX_ALARM_CTRL,
3880 0x400);
3881
3882 } else { /* Default 10G. Set only LASI control */
3883 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3884 ext_phy_addr, MDIO_PMA_DEVAD,
3885 MDIO_PMA_REG_LASI_CTRL, 1);
3886 }
3887
3888 /* Set TX PreEmphasis if needed */
3889 if ((params->feature_config_flags &
3890 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
3891 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x,"
3892 "TX_CTRL2 0x%x\n",
3893 params->xgxs_config_tx[0],
3894 params->xgxs_config_tx[1]);
3895 bnx2x_cl45_write(bp, params->port,
3896 ext_phy_type,
3897 ext_phy_addr,
3898 MDIO_PMA_DEVAD,
3899 MDIO_PMA_REG_8726_TX_CTRL1,
3900 params->xgxs_config_tx[0]);
3901
3902 bnx2x_cl45_write(bp, params->port,
3903 ext_phy_type,
3904 ext_phy_addr,
3905 MDIO_PMA_DEVAD,
3906 MDIO_PMA_REG_8726_TX_CTRL2,
3907 params->xgxs_config_tx[1]);
3908 }
3909 break;
3910 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
3911 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
3912 {
3913 u16 tmp1;
3914 u16 rx_alarm_ctrl_val;
3915 u16 lasi_ctrl_val;
3916 if (ext_phy_type ==
3917 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) {
3918 rx_alarm_ctrl_val = 0x400;
3919 lasi_ctrl_val = 0x0004;
3920 } else {
3921 rx_alarm_ctrl_val = (1<<2);
3922 lasi_ctrl_val = 0x0004;
3923 }
3924
3925 /* enable LASI */
3926 bnx2x_cl45_write(bp, params->port,
3927 ext_phy_type,
3928 ext_phy_addr,
3929 MDIO_PMA_DEVAD,
3930 MDIO_PMA_REG_RX_ALARM_CTRL,
3931 rx_alarm_ctrl_val);
3932
3933 bnx2x_cl45_write(bp, params->port,
3934 ext_phy_type,
3935 ext_phy_addr,
3936 MDIO_PMA_DEVAD,
3937 MDIO_PMA_REG_LASI_CTRL,
3938 lasi_ctrl_val);
3939
3940 bnx2x_8073_set_pause_cl37(params, vars);
3941
3942 if (ext_phy_type ==
3943 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072)
3944 bnx2x_bcm8072_external_rom_boot(params);
3945 else
3946 /* In case of 8073 with long xaui lines,
3947 don't set the 8073 xaui low power*/
3948 bnx2x_bcm8073_set_xaui_low_power_mode(params);
3949
3950 bnx2x_cl45_read(bp, params->port,
3951 ext_phy_type,
3952 ext_phy_addr,
3953 MDIO_PMA_DEVAD,
3954 MDIO_PMA_REG_M8051_MSGOUT_REG,
3955 &tmp1);
3956
3957 bnx2x_cl45_read(bp, params->port,
3958 ext_phy_type,
3959 ext_phy_addr,
3960 MDIO_PMA_DEVAD,
3961 MDIO_PMA_REG_RX_ALARM, &tmp1);
3962
3963 DP(NETIF_MSG_LINK, "Before rom RX_ALARM(port1):"
3964 "0x%x\n", tmp1);
3965
3966 /* If this is forced speed, set to KR or KX
3967 * (all other are not supported)
3968 */
3969 if (params->loopback_mode == LOOPBACK_EXT) {
3970 bnx2x_bcm807x_force_10G(params);
3971 DP(NETIF_MSG_LINK,
3972 "Forced speed 10G on 807X\n");
3973 break;
3974 } else {
3975 bnx2x_cl45_write(bp, params->port,
3976 ext_phy_type, ext_phy_addr,
3977 MDIO_PMA_DEVAD,
3978 MDIO_PMA_REG_BCM_CTRL,
3979 0x0002);
3980 }
3981 if (params->req_line_speed != SPEED_AUTO_NEG) {
3982 if (params->req_line_speed == SPEED_10000) {
3983 val = (1<<7);
3984 } else if (params->req_line_speed ==
3985 SPEED_2500) {
3986 val = (1<<5);
3987 /* Note that 2.5G works only
3988 when used with 1G advertisment */
3989 } else
3990 val = (1<<5);
3991 } else {
3992
3993 val = 0;
3994 if (params->speed_cap_mask &
3995 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
3996 val |= (1<<7);
3997
3998 /* Note that 2.5G works only when
3999 used with 1G advertisment */
4000 if (params->speed_cap_mask &
4001 (PORT_HW_CFG_SPEED_CAPABILITY_D0_1G |
4002 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
4003 val |= (1<<5);
4004 DP(NETIF_MSG_LINK,
4005 "807x autoneg val = 0x%x\n", val);
4006 }
4007
4008 bnx2x_cl45_write(bp, params->port,
4009 ext_phy_type,
4010 ext_phy_addr,
4011 MDIO_AN_DEVAD,
4012 MDIO_AN_REG_ADV, val);
4013 if (ext_phy_type ==
4014 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
4015 bnx2x_cl45_read(bp, params->port,
4016 ext_phy_type,
4017 ext_phy_addr,
4018 MDIO_AN_DEVAD,
4019 MDIO_AN_REG_8073_2_5G, &tmp1);
4020
4021 if (((params->speed_cap_mask &
4022 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G) &&
4023 (params->req_line_speed ==
4024 SPEED_AUTO_NEG)) ||
4025 (params->req_line_speed ==
4026 SPEED_2500)) {
4027 u16 phy_ver;
4028 /* Allow 2.5G for A1 and above */
4029 bnx2x_cl45_read(bp, params->port,
4030 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
4031 ext_phy_addr,
4032 MDIO_PMA_DEVAD,
4033 MDIO_PMA_REG_8073_CHIP_REV, &phy_ver);
4034 DP(NETIF_MSG_LINK, "Add 2.5G\n");
4035 if (phy_ver > 0)
4036 tmp1 |= 1;
4037 else
4038 tmp1 &= 0xfffe;
4039 } else {
4040 DP(NETIF_MSG_LINK, "Disable 2.5G\n");
4041 tmp1 &= 0xfffe;
4042 }
4043
4044 bnx2x_cl45_write(bp, params->port,
4045 ext_phy_type,
4046 ext_phy_addr,
4047 MDIO_AN_DEVAD,
4048 MDIO_AN_REG_8073_2_5G, tmp1);
4049 }
4050
4051 /* Add support for CL37 (passive mode) II */
4052
4053 bnx2x_cl45_read(bp, params->port,
4054 ext_phy_type,
4055 ext_phy_addr,
4056 MDIO_AN_DEVAD,
4057 MDIO_AN_REG_CL37_FC_LD,
4058 &tmp1);
4059
4060 bnx2x_cl45_write(bp, params->port,
4061 ext_phy_type,
4062 ext_phy_addr,
4063 MDIO_AN_DEVAD,
4064 MDIO_AN_REG_CL37_FC_LD, (tmp1 |
4065 ((params->req_duplex == DUPLEX_FULL) ?
4066 0x20 : 0x40)));
4067
4068 /* Add support for CL37 (passive mode) III */
4069 bnx2x_cl45_write(bp, params->port,
4070 ext_phy_type,
4071 ext_phy_addr,
4072 MDIO_AN_DEVAD,
4073 MDIO_AN_REG_CL37_AN, 0x1000);
4074
4075 if (ext_phy_type ==
4076 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
4077 /* The SNR will improve about 2db by changing
4078 BW and FEE main tap. Rest commands are executed
4079 after link is up*/
4080 /*Change FFE main cursor to 5 in EDC register*/
4081 if (bnx2x_8073_is_snr_needed(params))
4082 bnx2x_cl45_write(bp, params->port,
4083 ext_phy_type,
4084 ext_phy_addr,
4085 MDIO_PMA_DEVAD,
4086 MDIO_PMA_REG_EDC_FFE_MAIN,
4087 0xFB0C);
4088
4089 /* Enable FEC (Forware Error Correction)
4090 Request in the AN */
4091 bnx2x_cl45_read(bp, params->port,
4092 ext_phy_type,
4093 ext_phy_addr,
4094 MDIO_AN_DEVAD,
4095 MDIO_AN_REG_ADV2, &tmp1);
4096
4097 tmp1 |= (1<<15);
4098
4099 bnx2x_cl45_write(bp, params->port,
4100 ext_phy_type,
4101 ext_phy_addr,
4102 MDIO_AN_DEVAD,
4103 MDIO_AN_REG_ADV2, tmp1);
4104
4105 }
4106
4107 bnx2x_ext_phy_set_pause(params, vars);
4108
4109 /* Restart autoneg */
4110 msleep(500);
4111 bnx2x_cl45_write(bp, params->port,
4112 ext_phy_type,
4113 ext_phy_addr,
4114 MDIO_AN_DEVAD,
4115 MDIO_AN_REG_CTRL, 0x1200);
4116 DP(NETIF_MSG_LINK, "807x Autoneg Restart: "
4117 "Advertise 1G=%x, 10G=%x\n",
4118 ((val & (1<<5)) > 0),
4119 ((val & (1<<7)) > 0));
4120 break;
4121 }
4122
4123 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
4124 {
4125 u16 tmp1;
4126 u16 rx_alarm_ctrl_val;
4127 u16 lasi_ctrl_val;
4128
4129 /* Enable PMD link, MOD_ABS_FLT, and 1G link alarm */
4130
4131 u16 mod_abs;
4132 rx_alarm_ctrl_val = (1<<2) | (1<<5) ;
4133 lasi_ctrl_val = 0x0004;
4134
4135 DP(NETIF_MSG_LINK, "Initializing BCM8727\n");
4136 /* enable LASI */
4137 bnx2x_cl45_write(bp, params->port,
4138 ext_phy_type,
4139 ext_phy_addr,
4140 MDIO_PMA_DEVAD,
4141 MDIO_PMA_REG_RX_ALARM_CTRL,
4142 rx_alarm_ctrl_val);
4143
4144 bnx2x_cl45_write(bp, params->port,
4145 ext_phy_type,
4146 ext_phy_addr,
4147 MDIO_PMA_DEVAD,
4148 MDIO_PMA_REG_LASI_CTRL,
4149 lasi_ctrl_val);
4150
4151 /* Initially configure MOD_ABS to interrupt when
4152 module is presence( bit 8) */
4153 bnx2x_cl45_read(bp, params->port,
4154 ext_phy_type,
4155 ext_phy_addr,
4156 MDIO_PMA_DEVAD,
4157 MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
4158 /* Set EDC off by setting OPTXLOS signal input to low
4159 (bit 9).
4160 When the EDC is off it locks onto a reference clock and
4161 avoids becoming 'lost'.*/
4162 mod_abs &= ~((1<<8) | (1<<9));
4163 bnx2x_cl45_write(bp, params->port,
4164 ext_phy_type,
4165 ext_phy_addr,
4166 MDIO_PMA_DEVAD,
4167 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4168
4169 /* Make MOD_ABS give interrupt on change */
4170 bnx2x_cl45_read(bp, params->port,
4171 ext_phy_type,
4172 ext_phy_addr,
4173 MDIO_PMA_DEVAD,
4174 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4175 &val);
4176 val |= (1<<12);
4177 bnx2x_cl45_write(bp, params->port,
4178 ext_phy_type,
4179 ext_phy_addr,
4180 MDIO_PMA_DEVAD,
4181 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4182 val);
4183
4184 /* Set 8727 GPIOs to input to allow reading from the
4185 8727 GPIO0 status which reflect SFP+ module
4186 over-current */
4187
4188 bnx2x_cl45_read(bp, params->port,
4189 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4190 ext_phy_addr,
4191 MDIO_PMA_DEVAD,
4192 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4193 &val);
4194 val &= 0xff8f; /* Reset bits 4-6 */
4195 bnx2x_cl45_write(bp, params->port,
4196 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4197 ext_phy_addr,
4198 MDIO_PMA_DEVAD,
4199 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4200 val);
4201
4202 bnx2x_8727_power_module(bp, params, ext_phy_addr, 1);
4203 bnx2x_bcm8073_set_xaui_low_power_mode(params);
4204
4205 bnx2x_cl45_read(bp, params->port,
4206 ext_phy_type,
4207 ext_phy_addr,
4208 MDIO_PMA_DEVAD,
4209 MDIO_PMA_REG_M8051_MSGOUT_REG,
4210 &tmp1);
4211
4212 bnx2x_cl45_read(bp, params->port,
4213 ext_phy_type,
4214 ext_phy_addr,
4215 MDIO_PMA_DEVAD,
4216 MDIO_PMA_REG_RX_ALARM, &tmp1);
4217
4218 /* Set option 1G speed */
4219 if (params->req_line_speed == SPEED_1000) {
4220
4221 DP(NETIF_MSG_LINK, "Setting 1G force\n");
4222 bnx2x_cl45_write(bp, params->port,
4223 ext_phy_type,
4224 ext_phy_addr,
4225 MDIO_PMA_DEVAD,
4226 MDIO_PMA_REG_CTRL, 0x40);
4227 bnx2x_cl45_write(bp, params->port,
4228 ext_phy_type,
4229 ext_phy_addr,
4230 MDIO_PMA_DEVAD,
4231 MDIO_PMA_REG_10G_CTRL2, 0xD);
4232 bnx2x_cl45_read(bp, params->port,
4233 ext_phy_type,
4234 ext_phy_addr,
4235 MDIO_PMA_DEVAD,
4236 MDIO_PMA_REG_10G_CTRL2, &tmp1);
4237 DP(NETIF_MSG_LINK, "1.7 = 0x%x\n", tmp1);
4238
4239 } else if ((params->req_line_speed ==
4240 SPEED_AUTO_NEG) &&
4241 ((params->speed_cap_mask &
4242 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
4243
4244 DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
4245 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4246 ext_phy_addr, MDIO_AN_DEVAD,
4247 MDIO_PMA_REG_8727_MISC_CTRL, 0);
4248 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4249 ext_phy_addr, MDIO_AN_DEVAD,
4250 MDIO_AN_REG_CL37_AN, 0x1300);
4251 } else {
4252 /* Since the 8727 has only single reset pin,
4253 need to set the 10G registers although it is
4254 default */
4255 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4256 ext_phy_addr, MDIO_AN_DEVAD,
4257 MDIO_AN_REG_CTRL, 0x0020);
4258 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4259 ext_phy_addr, MDIO_AN_DEVAD,
4260 0x7, 0x0100);
4261 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4262 ext_phy_addr, MDIO_PMA_DEVAD,
4263 MDIO_PMA_REG_CTRL, 0x2040);
4264 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4265 ext_phy_addr, MDIO_PMA_DEVAD,
4266 MDIO_PMA_REG_10G_CTRL2, 0x0008);
4267 }
4268
4269 /* Set 2-wire transfer rate to 400Khz since 100Khz
4270 is not operational */
4271 bnx2x_cl45_write(bp, params->port,
4272 ext_phy_type,
4273 ext_phy_addr,
4274 MDIO_PMA_DEVAD,
4275 MDIO_PMA_REG_8727_TWO_WIRE_SLAVE_ADDR,
4276 0xa101);
4277
4278 /* Set TX PreEmphasis if needed */
4279 if ((params->feature_config_flags &
4280 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
4281 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x,"
4282 "TX_CTRL2 0x%x\n",
4283 params->xgxs_config_tx[0],
4284 params->xgxs_config_tx[1]);
4285 bnx2x_cl45_write(bp, params->port,
4286 ext_phy_type,
4287 ext_phy_addr,
4288 MDIO_PMA_DEVAD,
4289 MDIO_PMA_REG_8727_TX_CTRL1,
4290 params->xgxs_config_tx[0]);
4291
4292 bnx2x_cl45_write(bp, params->port,
4293 ext_phy_type,
4294 ext_phy_addr,
4295 MDIO_PMA_DEVAD,
4296 MDIO_PMA_REG_8727_TX_CTRL2,
4297 params->xgxs_config_tx[1]);
4298 }
4299
4300 break;
4301 }
4302
4303 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
4304 {
4305 u16 fw_ver1, fw_ver2;
4306 DP(NETIF_MSG_LINK,
4307 "Setting the SFX7101 LASI indication\n");
4308
4309 bnx2x_cl45_write(bp, params->port,
4310 ext_phy_type,
4311 ext_phy_addr,
4312 MDIO_PMA_DEVAD,
4313 MDIO_PMA_REG_LASI_CTRL, 0x1);
4314 DP(NETIF_MSG_LINK,
4315 "Setting the SFX7101 LED to blink on traffic\n");
4316 bnx2x_cl45_write(bp, params->port,
4317 ext_phy_type,
4318 ext_phy_addr,
4319 MDIO_PMA_DEVAD,
4320 MDIO_PMA_REG_7107_LED_CNTL, (1<<3));
4321
4322 bnx2x_ext_phy_set_pause(params, vars);
4323 /* Restart autoneg */
4324 bnx2x_cl45_read(bp, params->port,
4325 ext_phy_type,
4326 ext_phy_addr,
4327 MDIO_AN_DEVAD,
4328 MDIO_AN_REG_CTRL, &val);
4329 val |= 0x200;
4330 bnx2x_cl45_write(bp, params->port,
4331 ext_phy_type,
4332 ext_phy_addr,
4333 MDIO_AN_DEVAD,
4334 MDIO_AN_REG_CTRL, val);
4335
4336 /* Save spirom version */
4337 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4338 ext_phy_addr, MDIO_PMA_DEVAD,
4339 MDIO_PMA_REG_7101_VER1, &fw_ver1);
4340
4341 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4342 ext_phy_addr, MDIO_PMA_DEVAD,
4343 MDIO_PMA_REG_7101_VER2, &fw_ver2);
4344
4345 bnx2x_save_spirom_version(params->bp, params->port,
4346 params->shmem_base,
4347 (u32)(fw_ver1<<16 | fw_ver2));
4348 break;
4349 }
4350 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
4351 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
4352 /* This phy uses the NIG latch mechanism since link
4353 indication arrives through its LED4 and not via
4354 its LASI signal, so we get steady signal
4355 instead of clear on read */
4356 bnx2x_bits_en(bp, NIG_REG_LATCH_BC_0 + params->port*4,
4357 1 << NIG_LATCH_BC_ENABLE_MI_INT);
4358
4359 bnx2x_cl45_write(bp, params->port,
4360 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
4361 ext_phy_addr,
4362 MDIO_PMA_DEVAD,
4363 MDIO_PMA_REG_CTRL, 0x0000);
4364
4365 bnx2x_8481_set_led4(params, ext_phy_type, ext_phy_addr);
4366 if (params->req_line_speed == SPEED_AUTO_NEG) {
4367
4368 u16 autoneg_val, an_1000_val, an_10_100_val;
4369 /* set 1000 speed advertisement */
4370 bnx2x_cl45_read(bp, params->port,
4371 ext_phy_type,
4372 ext_phy_addr,
4373 MDIO_AN_DEVAD,
4374 MDIO_AN_REG_8481_1000T_CTRL,
4375 &an_1000_val);
4376
4377 if (params->speed_cap_mask &
4378 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G) {
4379 an_1000_val |= (1<<8);
4380 if (params->req_duplex == DUPLEX_FULL)
4381 an_1000_val |= (1<<9);
4382 DP(NETIF_MSG_LINK, "Advertising 1G\n");
4383 } else
4384 an_1000_val &= ~((1<<8) | (1<<9));
4385
4386 bnx2x_cl45_write(bp, params->port,
4387 ext_phy_type,
4388 ext_phy_addr,
4389 MDIO_AN_DEVAD,
4390 MDIO_AN_REG_8481_1000T_CTRL,
4391 an_1000_val);
4392
4393 /* set 100 speed advertisement */
4394 bnx2x_cl45_read(bp, params->port,
4395 ext_phy_type,
4396 ext_phy_addr,
4397 MDIO_AN_DEVAD,
4398 MDIO_AN_REG_8481_LEGACY_AN_ADV,
4399 &an_10_100_val);
4400
4401 if (params->speed_cap_mask &
4402 (PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL |
4403 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF)) {
4404 an_10_100_val |= (1<<7);
4405 if (params->req_duplex == DUPLEX_FULL)
4406 an_10_100_val |= (1<<8);
4407 DP(NETIF_MSG_LINK,
4408 "Advertising 100M\n");
4409 } else
4410 an_10_100_val &= ~((1<<7) | (1<<8));
4411
4412 /* set 10 speed advertisement */
4413 if (params->speed_cap_mask &
4414 (PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL |
4415 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF)) {
4416 an_10_100_val |= (1<<5);
4417 if (params->req_duplex == DUPLEX_FULL)
4418 an_10_100_val |= (1<<6);
4419 DP(NETIF_MSG_LINK, "Advertising 10M\n");
4420 }
4421 else
4422 an_10_100_val &= ~((1<<5) | (1<<6));
4423
4424 bnx2x_cl45_write(bp, params->port,
4425 ext_phy_type,
4426 ext_phy_addr,
4427 MDIO_AN_DEVAD,
4428 MDIO_AN_REG_8481_LEGACY_AN_ADV,
4429 an_10_100_val);
4430
4431 bnx2x_cl45_read(bp, params->port,
4432 ext_phy_type,
4433 ext_phy_addr,
4434 MDIO_AN_DEVAD,
4435 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4436 &autoneg_val);
4437
4438 /* Disable forced speed */
4439 autoneg_val &= ~(1<<6|1<<13);
4440
4441 /* Enable autoneg and restart autoneg
4442 for legacy speeds */
4443 autoneg_val |= (1<<9|1<<12);
4444
4445 if (params->req_duplex == DUPLEX_FULL)
4446 autoneg_val |= (1<<8);
4447 else
4448 autoneg_val &= ~(1<<8);
4449
4450 bnx2x_cl45_write(bp, params->port,
4451 ext_phy_type,
4452 ext_phy_addr,
4453 MDIO_AN_DEVAD,
4454 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4455 autoneg_val);
4456
4457 if (params->speed_cap_mask &
4458 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
4459 DP(NETIF_MSG_LINK, "Advertising 10G\n");
4460 /* Restart autoneg for 10G*/
4461
4462 bnx2x_cl45_write(bp, params->port,
4463 ext_phy_type,
4464 ext_phy_addr,
4465 MDIO_AN_DEVAD,
4466 MDIO_AN_REG_CTRL, 0x3200);
4467 }
4468 } else {
4469 /* Force speed */
4470 u16 autoneg_ctrl, pma_ctrl;
4471 bnx2x_cl45_read(bp, params->port,
4472 ext_phy_type,
4473 ext_phy_addr,
4474 MDIO_AN_DEVAD,
4475 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4476 &autoneg_ctrl);
4477
4478 /* Disable autoneg */
4479 autoneg_ctrl &= ~(1<<12);
4480
4481 /* Set 1000 force */
4482 switch (params->req_line_speed) {
4483 case SPEED_10000:
4484 DP(NETIF_MSG_LINK,
4485 "Unable to set 10G force !\n");
4486 break;
4487 case SPEED_1000:
4488 bnx2x_cl45_read(bp, params->port,
4489 ext_phy_type,
4490 ext_phy_addr,
4491 MDIO_PMA_DEVAD,
4492 MDIO_PMA_REG_CTRL,
4493 &pma_ctrl);
4494 autoneg_ctrl &= ~(1<<13);
4495 autoneg_ctrl |= (1<<6);
4496 pma_ctrl &= ~(1<<13);
4497 pma_ctrl |= (1<<6);
4498 DP(NETIF_MSG_LINK,
4499 "Setting 1000M force\n");
4500 bnx2x_cl45_write(bp, params->port,
4501 ext_phy_type,
4502 ext_phy_addr,
4503 MDIO_PMA_DEVAD,
4504 MDIO_PMA_REG_CTRL,
4505 pma_ctrl);
4506 break;
4507 case SPEED_100:
4508 autoneg_ctrl |= (1<<13);
4509 autoneg_ctrl &= ~(1<<6);
4510 DP(NETIF_MSG_LINK,
4511 "Setting 100M force\n");
4512 break;
4513 case SPEED_10:
4514 autoneg_ctrl &= ~(1<<13);
4515 autoneg_ctrl &= ~(1<<6);
4516 DP(NETIF_MSG_LINK,
4517 "Setting 10M force\n");
4518 break;
4519 }
4520
4521 /* Duplex mode */
4522 if (params->req_duplex == DUPLEX_FULL) {
4523 autoneg_ctrl |= (1<<8);
4524 DP(NETIF_MSG_LINK,
4525 "Setting full duplex\n");
4526 } else
4527 autoneg_ctrl &= ~(1<<8);
4528
4529 /* Update autoneg ctrl and pma ctrl */
4530 bnx2x_cl45_write(bp, params->port,
4531 ext_phy_type,
4532 ext_phy_addr,
4533 MDIO_AN_DEVAD,
4534 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4535 autoneg_ctrl);
4536 }
4537
4538 /* Save spirom version */
4539 bnx2x_save_8481_spirom_version(bp, params->port,
4540 ext_phy_addr,
4541 params->shmem_base);
4542 break;
4543 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
4544 DP(NETIF_MSG_LINK,
4545 "XGXS PHY Failure detected 0x%x\n",
4546 params->ext_phy_config);
4547 rc = -EINVAL;
4548 break;
4549 default:
4550 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
4551 params->ext_phy_config);
4552 rc = -EINVAL;
4553 break;
4554 }
4555
4556 } else { /* SerDes */
4557
4558 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
4559 switch (ext_phy_type) {
4560 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
4561 DP(NETIF_MSG_LINK, "SerDes Direct\n");
4562 break;
4563
4564 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
4565 DP(NETIF_MSG_LINK, "SerDes 5482\n");
4566 break;
4567
4568 default:
4569 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
4570 params->ext_phy_config);
4571 break;
4572 }
4573 }
4574 return rc;
4575 }
4576
4577 static void bnx2x_8727_handle_mod_abs(struct link_params *params)
4578 {
4579 struct bnx2x *bp = params->bp;
4580 u16 mod_abs, rx_alarm_status;
4581 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
4582 u32 val = REG_RD(bp, params->shmem_base +
4583 offsetof(struct shmem_region, dev_info.
4584 port_feature_config[params->port].
4585 config));
4586 bnx2x_cl45_read(bp, params->port,
4587 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4588 ext_phy_addr,
4589 MDIO_PMA_DEVAD,
4590 MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
4591 if (mod_abs & (1<<8)) {
4592
4593 /* Module is absent */
4594 DP(NETIF_MSG_LINK, "MOD_ABS indication "
4595 "show module is absent\n");
4596
4597 /* 1. Set mod_abs to detect next module
4598 presence event
4599 2. Set EDC off by setting OPTXLOS signal input to low
4600 (bit 9).
4601 When the EDC is off it locks onto a reference clock and
4602 avoids becoming 'lost'.*/
4603 mod_abs &= ~((1<<8)|(1<<9));
4604 bnx2x_cl45_write(bp, params->port,
4605 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4606 ext_phy_addr,
4607 MDIO_PMA_DEVAD,
4608 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4609
4610 /* Clear RX alarm since it stays up as long as
4611 the mod_abs wasn't changed */
4612 bnx2x_cl45_read(bp, params->port,
4613 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4614 ext_phy_addr,
4615 MDIO_PMA_DEVAD,
4616 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4617
4618 } else {
4619 /* Module is present */
4620 DP(NETIF_MSG_LINK, "MOD_ABS indication "
4621 "show module is present\n");
4622 /* First thing, disable transmitter,
4623 and if the module is ok, the
4624 module_detection will enable it*/
4625
4626 /* 1. Set mod_abs to detect next module
4627 absent event ( bit 8)
4628 2. Restore the default polarity of the OPRXLOS signal and
4629 this signal will then correctly indicate the presence or
4630 absence of the Rx signal. (bit 9) */
4631 mod_abs |= ((1<<8)|(1<<9));
4632 bnx2x_cl45_write(bp, params->port,
4633 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4634 ext_phy_addr,
4635 MDIO_PMA_DEVAD,
4636 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4637
4638 /* Clear RX alarm since it stays up as long as
4639 the mod_abs wasn't changed. This is need to be done
4640 before calling the module detection, otherwise it will clear
4641 the link update alarm */
4642 bnx2x_cl45_read(bp, params->port,
4643 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4644 ext_phy_addr,
4645 MDIO_PMA_DEVAD,
4646 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4647
4648
4649 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
4650 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
4651 bnx2x_sfp_set_transmitter(bp, params->port,
4652 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4653 ext_phy_addr, 0);
4654
4655 if (bnx2x_wait_for_sfp_module_initialized(params)
4656 == 0)
4657 bnx2x_sfp_module_detection(params);
4658 else
4659 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
4660 }
4661
4662 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n",
4663 rx_alarm_status);
4664 /* No need to check link status in case of
4665 module plugged in/out */
4666 }
4667
4668
4669 static u8 bnx2x_ext_phy_is_link_up(struct link_params *params,
4670 struct link_vars *vars,
4671 u8 is_mi_int)
4672 {
4673 struct bnx2x *bp = params->bp;
4674 u32 ext_phy_type;
4675 u8 ext_phy_addr;
4676 u16 val1 = 0, val2;
4677 u16 rx_sd, pcs_status;
4678 u8 ext_phy_link_up = 0;
4679 u8 port = params->port;
4680
4681 if (vars->phy_flags & PHY_XGXS_FLAG) {
4682 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
4683 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
4684 switch (ext_phy_type) {
4685 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
4686 DP(NETIF_MSG_LINK, "XGXS Direct\n");
4687 ext_phy_link_up = 1;
4688 break;
4689
4690 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
4691 DP(NETIF_MSG_LINK, "XGXS 8705\n");
4692 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4693 ext_phy_addr,
4694 MDIO_WIS_DEVAD,
4695 MDIO_WIS_REG_LASI_STATUS, &val1);
4696 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4697
4698 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4699 ext_phy_addr,
4700 MDIO_WIS_DEVAD,
4701 MDIO_WIS_REG_LASI_STATUS, &val1);
4702 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4703
4704 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4705 ext_phy_addr,
4706 MDIO_PMA_DEVAD,
4707 MDIO_PMA_REG_RX_SD, &rx_sd);
4708
4709 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4710 ext_phy_addr,
4711 1,
4712 0xc809, &val1);
4713 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4714 ext_phy_addr,
4715 1,
4716 0xc809, &val1);
4717
4718 DP(NETIF_MSG_LINK, "8705 1.c809 val=0x%x\n", val1);
4719 ext_phy_link_up = ((rx_sd & 0x1) && (val1 & (1<<9)) &&
4720 ((val1 & (1<<8)) == 0));
4721 if (ext_phy_link_up)
4722 vars->line_speed = SPEED_10000;
4723 break;
4724
4725 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
4726 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
4727 DP(NETIF_MSG_LINK, "XGXS 8706/8726\n");
4728 /* Clear RX Alarm*/
4729 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4730 ext_phy_addr,
4731 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM,
4732 &val2);
4733 /* clear LASI indication*/
4734 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4735 ext_phy_addr,
4736 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS,
4737 &val1);
4738 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4739 ext_phy_addr,
4740 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS,
4741 &val2);
4742 DP(NETIF_MSG_LINK, "8706/8726 LASI status 0x%x-->"
4743 "0x%x\n", val1, val2);
4744
4745 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4746 ext_phy_addr,
4747 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD,
4748 &rx_sd);
4749 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4750 ext_phy_addr,
4751 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS,
4752 &pcs_status);
4753 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4754 ext_phy_addr,
4755 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS,
4756 &val2);
4757 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4758 ext_phy_addr,
4759 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS,
4760 &val2);
4761
4762 DP(NETIF_MSG_LINK, "8706/8726 rx_sd 0x%x"
4763 " pcs_status 0x%x 1Gbps link_status 0x%x\n",
4764 rx_sd, pcs_status, val2);
4765 /* link is up if both bit 0 of pmd_rx_sd and
4766 * bit 0 of pcs_status are set, or if the autoneg bit
4767 1 is set
4768 */
4769 ext_phy_link_up = ((rx_sd & pcs_status & 0x1) ||
4770 (val2 & (1<<1)));
4771 if (ext_phy_link_up) {
4772 if (ext_phy_type ==
4773 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) {
4774 /* If transmitter is disabled,
4775 ignore false link up indication */
4776 bnx2x_cl45_read(bp, params->port,
4777 ext_phy_type,
4778 ext_phy_addr,
4779 MDIO_PMA_DEVAD,
4780 MDIO_PMA_REG_PHY_IDENTIFIER,
4781 &val1);
4782 if (val1 & (1<<15)) {
4783 DP(NETIF_MSG_LINK, "Tx is "
4784 "disabled\n");
4785 ext_phy_link_up = 0;
4786 break;
4787 }
4788 }
4789 if (val2 & (1<<1))
4790 vars->line_speed = SPEED_1000;
4791 else
4792 vars->line_speed = SPEED_10000;
4793 }
4794 break;
4795
4796 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
4797 {
4798 u16 link_status = 0;
4799 u16 rx_alarm_status;
4800 /* Check the LASI */
4801 bnx2x_cl45_read(bp, params->port,
4802 ext_phy_type,
4803 ext_phy_addr,
4804 MDIO_PMA_DEVAD,
4805 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4806
4807 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n",
4808 rx_alarm_status);
4809
4810 bnx2x_cl45_read(bp, params->port,
4811 ext_phy_type,
4812 ext_phy_addr,
4813 MDIO_PMA_DEVAD,
4814 MDIO_PMA_REG_LASI_STATUS, &val1);
4815
4816 DP(NETIF_MSG_LINK,
4817 "8727 LASI status 0x%x\n",
4818 val1);
4819
4820 /* Clear MSG-OUT */
4821 bnx2x_cl45_read(bp, params->port,
4822 ext_phy_type,
4823 ext_phy_addr,
4824 MDIO_PMA_DEVAD,
4825 MDIO_PMA_REG_M8051_MSGOUT_REG,
4826 &val1);
4827
4828 /*
4829 * If a module is present and there is need to check
4830 * for over current
4831 */
4832 if (!(params->feature_config_flags &
4833 FEATURE_CONFIG_BCM8727_NOC) &&
4834 !(rx_alarm_status & (1<<5))) {
4835 /* Check over-current using 8727 GPIO0 input*/
4836 bnx2x_cl45_read(bp, params->port,
4837 ext_phy_type,
4838 ext_phy_addr,
4839 MDIO_PMA_DEVAD,
4840 MDIO_PMA_REG_8727_GPIO_CTRL,
4841 &val1);
4842
4843 if ((val1 & (1<<8)) == 0) {
4844 DP(NETIF_MSG_LINK, "8727 Power fault"
4845 " has been detected on "
4846 "port %d\n",
4847 params->port);
4848 netdev_err(bp->dev, "Error: Power fault on Port %d has been detected and the power to that SFP+ module has been removed to prevent failure of the card. Please remove the SFP+ module and restart the system to clear this error.\n",
4849 params->port);
4850 /*
4851 * Disable all RX_ALARMs except for
4852 * mod_abs
4853 */
4854 bnx2x_cl45_write(bp, params->port,
4855 ext_phy_type,
4856 ext_phy_addr,
4857 MDIO_PMA_DEVAD,
4858 MDIO_PMA_REG_RX_ALARM_CTRL,
4859 (1<<5));
4860
4861 bnx2x_cl45_read(bp, params->port,
4862 ext_phy_type,
4863 ext_phy_addr,
4864 MDIO_PMA_DEVAD,
4865 MDIO_PMA_REG_PHY_IDENTIFIER,
4866 &val1);
4867 /* Wait for module_absent_event */
4868 val1 |= (1<<8);
4869 bnx2x_cl45_write(bp, params->port,
4870 ext_phy_type,
4871 ext_phy_addr,
4872 MDIO_PMA_DEVAD,
4873 MDIO_PMA_REG_PHY_IDENTIFIER,
4874 val1);
4875 /* Clear RX alarm */
4876 bnx2x_cl45_read(bp, params->port,
4877 ext_phy_type,
4878 ext_phy_addr,
4879 MDIO_PMA_DEVAD,
4880 MDIO_PMA_REG_RX_ALARM,
4881 &rx_alarm_status);
4882 break;
4883 }
4884 } /* Over current check */
4885
4886 /* When module absent bit is set, check module */
4887 if (rx_alarm_status & (1<<5)) {
4888 bnx2x_8727_handle_mod_abs(params);
4889 /* Enable all mod_abs and link detection bits */
4890 bnx2x_cl45_write(bp, params->port,
4891 ext_phy_type,
4892 ext_phy_addr,
4893 MDIO_PMA_DEVAD,
4894 MDIO_PMA_REG_RX_ALARM_CTRL,
4895 ((1<<5) | (1<<2)));
4896 }
4897
4898 /* If transmitter is disabled,
4899 ignore false link up indication */
4900 bnx2x_cl45_read(bp, params->port,
4901 ext_phy_type,
4902 ext_phy_addr,
4903 MDIO_PMA_DEVAD,
4904 MDIO_PMA_REG_PHY_IDENTIFIER,
4905 &val1);
4906 if (val1 & (1<<15)) {
4907 DP(NETIF_MSG_LINK, "Tx is disabled\n");
4908 ext_phy_link_up = 0;
4909 break;
4910 }
4911
4912 bnx2x_cl45_read(bp, params->port,
4913 ext_phy_type,
4914 ext_phy_addr,
4915 MDIO_PMA_DEVAD,
4916 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
4917 &link_status);
4918
4919 /* Bits 0..2 --> speed detected,
4920 bits 13..15--> link is down */
4921 if ((link_status & (1<<2)) &&
4922 (!(link_status & (1<<15)))) {
4923 ext_phy_link_up = 1;
4924 vars->line_speed = SPEED_10000;
4925 } else if ((link_status & (1<<0)) &&
4926 (!(link_status & (1<<13)))) {
4927 ext_phy_link_up = 1;
4928 vars->line_speed = SPEED_1000;
4929 DP(NETIF_MSG_LINK,
4930 "port %x: External link"
4931 " up in 1G\n", params->port);
4932 } else {
4933 ext_phy_link_up = 0;
4934 DP(NETIF_MSG_LINK,
4935 "port %x: External link"
4936 " is down\n", params->port);
4937 }
4938 break;
4939 }
4940
4941 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
4942 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
4943 {
4944 u16 link_status = 0;
4945 u16 an1000_status = 0;
4946
4947 if (ext_phy_type ==
4948 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) {
4949 bnx2x_cl45_read(bp, params->port,
4950 ext_phy_type,
4951 ext_phy_addr,
4952 MDIO_PCS_DEVAD,
4953 MDIO_PCS_REG_LASI_STATUS, &val1);
4954 bnx2x_cl45_read(bp, params->port,
4955 ext_phy_type,
4956 ext_phy_addr,
4957 MDIO_PCS_DEVAD,
4958 MDIO_PCS_REG_LASI_STATUS, &val2);
4959 DP(NETIF_MSG_LINK,
4960 "870x LASI status 0x%x->0x%x\n",
4961 val1, val2);
4962 } else {
4963 /* In 8073, port1 is directed through emac0 and
4964 * port0 is directed through emac1
4965 */
4966 bnx2x_cl45_read(bp, params->port,
4967 ext_phy_type,
4968 ext_phy_addr,
4969 MDIO_PMA_DEVAD,
4970 MDIO_PMA_REG_LASI_STATUS, &val1);
4971
4972 DP(NETIF_MSG_LINK,
4973 "8703 LASI status 0x%x\n",
4974 val1);
4975 }
4976
4977 /* clear the interrupt LASI status register */
4978 bnx2x_cl45_read(bp, params->port,
4979 ext_phy_type,
4980 ext_phy_addr,
4981 MDIO_PCS_DEVAD,
4982 MDIO_PCS_REG_STATUS, &val2);
4983 bnx2x_cl45_read(bp, params->port,
4984 ext_phy_type,
4985 ext_phy_addr,
4986 MDIO_PCS_DEVAD,
4987 MDIO_PCS_REG_STATUS, &val1);
4988 DP(NETIF_MSG_LINK, "807x PCS status 0x%x->0x%x\n",
4989 val2, val1);
4990 /* Clear MSG-OUT */
4991 bnx2x_cl45_read(bp, params->port,
4992 ext_phy_type,
4993 ext_phy_addr,
4994 MDIO_PMA_DEVAD,
4995 MDIO_PMA_REG_M8051_MSGOUT_REG,
4996 &val1);
4997
4998 /* Check the LASI */
4999 bnx2x_cl45_read(bp, params->port,
5000 ext_phy_type,
5001 ext_phy_addr,
5002 MDIO_PMA_DEVAD,
5003 MDIO_PMA_REG_RX_ALARM, &val2);
5004
5005 DP(NETIF_MSG_LINK, "KR 0x9003 0x%x\n", val2);
5006
5007 /* Check the link status */
5008 bnx2x_cl45_read(bp, params->port,
5009 ext_phy_type,
5010 ext_phy_addr,
5011 MDIO_PCS_DEVAD,
5012 MDIO_PCS_REG_STATUS, &val2);
5013 DP(NETIF_MSG_LINK, "KR PCS status 0x%x\n", val2);
5014
5015 bnx2x_cl45_read(bp, params->port,
5016 ext_phy_type,
5017 ext_phy_addr,
5018 MDIO_PMA_DEVAD,
5019 MDIO_PMA_REG_STATUS, &val2);
5020 bnx2x_cl45_read(bp, params->port,
5021 ext_phy_type,
5022 ext_phy_addr,
5023 MDIO_PMA_DEVAD,
5024 MDIO_PMA_REG_STATUS, &val1);
5025 ext_phy_link_up = ((val1 & 4) == 4);
5026 DP(NETIF_MSG_LINK, "PMA_REG_STATUS=0x%x\n", val1);
5027 if (ext_phy_type ==
5028 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
5029
5030 if (ext_phy_link_up &&
5031 ((params->req_line_speed !=
5032 SPEED_10000))) {
5033 if (bnx2x_bcm8073_xaui_wa(params)
5034 != 0) {
5035 ext_phy_link_up = 0;
5036 break;
5037 }
5038 }
5039 bnx2x_cl45_read(bp, params->port,
5040 ext_phy_type,
5041 ext_phy_addr,
5042 MDIO_AN_DEVAD,
5043 MDIO_AN_REG_LINK_STATUS,
5044 &an1000_status);
5045 bnx2x_cl45_read(bp, params->port,
5046 ext_phy_type,
5047 ext_phy_addr,
5048 MDIO_AN_DEVAD,
5049 MDIO_AN_REG_LINK_STATUS,
5050 &an1000_status);
5051
5052 /* Check the link status on 1.1.2 */
5053 bnx2x_cl45_read(bp, params->port,
5054 ext_phy_type,
5055 ext_phy_addr,
5056 MDIO_PMA_DEVAD,
5057 MDIO_PMA_REG_STATUS, &val2);
5058 bnx2x_cl45_read(bp, params->port,
5059 ext_phy_type,
5060 ext_phy_addr,
5061 MDIO_PMA_DEVAD,
5062 MDIO_PMA_REG_STATUS, &val1);
5063 DP(NETIF_MSG_LINK, "KR PMA status 0x%x->0x%x,"
5064 "an_link_status=0x%x\n",
5065 val2, val1, an1000_status);
5066
5067 ext_phy_link_up = (((val1 & 4) == 4) ||
5068 (an1000_status & (1<<1)));
5069 if (ext_phy_link_up &&
5070 bnx2x_8073_is_snr_needed(params)) {
5071 /* The SNR will improve about 2dbby
5072 changing the BW and FEE main tap.*/
5073
5074 /* The 1st write to change FFE main
5075 tap is set before restart AN */
5076 /* Change PLL Bandwidth in EDC
5077 register */
5078 bnx2x_cl45_write(bp, port, ext_phy_type,
5079 ext_phy_addr,
5080 MDIO_PMA_DEVAD,
5081 MDIO_PMA_REG_PLL_BANDWIDTH,
5082 0x26BC);
5083
5084 /* Change CDR Bandwidth in EDC
5085 register */
5086 bnx2x_cl45_write(bp, port, ext_phy_type,
5087 ext_phy_addr,
5088 MDIO_PMA_DEVAD,
5089 MDIO_PMA_REG_CDR_BANDWIDTH,
5090 0x0333);
5091 }
5092 bnx2x_cl45_read(bp, params->port,
5093 ext_phy_type,
5094 ext_phy_addr,
5095 MDIO_PMA_DEVAD,
5096 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
5097 &link_status);
5098
5099 /* Bits 0..2 --> speed detected,
5100 bits 13..15--> link is down */
5101 if ((link_status & (1<<2)) &&
5102 (!(link_status & (1<<15)))) {
5103 ext_phy_link_up = 1;
5104 vars->line_speed = SPEED_10000;
5105 DP(NETIF_MSG_LINK,
5106 "port %x: External link"
5107 " up in 10G\n", params->port);
5108 } else if ((link_status & (1<<1)) &&
5109 (!(link_status & (1<<14)))) {
5110 ext_phy_link_up = 1;
5111 vars->line_speed = SPEED_2500;
5112 DP(NETIF_MSG_LINK,
5113 "port %x: External link"
5114 " up in 2.5G\n", params->port);
5115 } else if ((link_status & (1<<0)) &&
5116 (!(link_status & (1<<13)))) {
5117 ext_phy_link_up = 1;
5118 vars->line_speed = SPEED_1000;
5119 DP(NETIF_MSG_LINK,
5120 "port %x: External link"
5121 " up in 1G\n", params->port);
5122 } else {
5123 ext_phy_link_up = 0;
5124 DP(NETIF_MSG_LINK,
5125 "port %x: External link"
5126 " is down\n", params->port);
5127 }
5128 } else {
5129 /* See if 1G link is up for the 8072 */
5130 bnx2x_cl45_read(bp, params->port,
5131 ext_phy_type,
5132 ext_phy_addr,
5133 MDIO_AN_DEVAD,
5134 MDIO_AN_REG_LINK_STATUS,
5135 &an1000_status);
5136 bnx2x_cl45_read(bp, params->port,
5137 ext_phy_type,
5138 ext_phy_addr,
5139 MDIO_AN_DEVAD,
5140 MDIO_AN_REG_LINK_STATUS,
5141 &an1000_status);
5142 if (an1000_status & (1<<1)) {
5143 ext_phy_link_up = 1;
5144 vars->line_speed = SPEED_1000;
5145 DP(NETIF_MSG_LINK,
5146 "port %x: External link"
5147 " up in 1G\n", params->port);
5148 } else if (ext_phy_link_up) {
5149 ext_phy_link_up = 1;
5150 vars->line_speed = SPEED_10000;
5151 DP(NETIF_MSG_LINK,
5152 "port %x: External link"
5153 " up in 10G\n", params->port);
5154 }
5155 }
5156
5157
5158 break;
5159 }
5160 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5161 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5162 ext_phy_addr,
5163 MDIO_PMA_DEVAD,
5164 MDIO_PMA_REG_LASI_STATUS, &val2);
5165 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5166 ext_phy_addr,
5167 MDIO_PMA_DEVAD,
5168 MDIO_PMA_REG_LASI_STATUS, &val1);
5169 DP(NETIF_MSG_LINK,
5170 "10G-base-T LASI status 0x%x->0x%x\n",
5171 val2, val1);
5172 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5173 ext_phy_addr,
5174 MDIO_PMA_DEVAD,
5175 MDIO_PMA_REG_STATUS, &val2);
5176 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5177 ext_phy_addr,
5178 MDIO_PMA_DEVAD,
5179 MDIO_PMA_REG_STATUS, &val1);
5180 DP(NETIF_MSG_LINK,
5181 "10G-base-T PMA status 0x%x->0x%x\n",
5182 val2, val1);
5183 ext_phy_link_up = ((val1 & 4) == 4);
5184 /* if link is up
5185 * print the AN outcome of the SFX7101 PHY
5186 */
5187 if (ext_phy_link_up) {
5188 bnx2x_cl45_read(bp, params->port,
5189 ext_phy_type,
5190 ext_phy_addr,
5191 MDIO_AN_DEVAD,
5192 MDIO_AN_REG_MASTER_STATUS,
5193 &val2);
5194 vars->line_speed = SPEED_10000;
5195 DP(NETIF_MSG_LINK,
5196 "SFX7101 AN status 0x%x->Master=%x\n",
5197 val2,
5198 (val2 & (1<<14)));
5199 }
5200 break;
5201 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
5202 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
5203 /* Check 10G-BaseT link status */
5204 /* Check PMD signal ok */
5205 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5206 ext_phy_addr,
5207 MDIO_AN_DEVAD,
5208 0xFFFA,
5209 &val1);
5210 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5211 ext_phy_addr,
5212 MDIO_PMA_DEVAD,
5213 MDIO_PMA_REG_8481_PMD_SIGNAL,
5214 &val2);
5215 DP(NETIF_MSG_LINK, "PMD_SIGNAL 1.a811 = 0x%x\n", val2);
5216
5217 /* Check link 10G */
5218 if (val2 & (1<<11)) {
5219 vars->line_speed = SPEED_10000;
5220 ext_phy_link_up = 1;
5221 bnx2x_8481_set_10G_led_mode(params,
5222 ext_phy_type,
5223 ext_phy_addr);
5224 } else { /* Check Legacy speed link */
5225 u16 legacy_status, legacy_speed;
5226
5227 /* Enable expansion register 0x42
5228 (Operation mode status) */
5229 bnx2x_cl45_write(bp, params->port,
5230 ext_phy_type,
5231 ext_phy_addr,
5232 MDIO_AN_DEVAD,
5233 MDIO_AN_REG_8481_EXPANSION_REG_ACCESS,
5234 0xf42);
5235
5236 /* Get legacy speed operation status */
5237 bnx2x_cl45_read(bp, params->port,
5238 ext_phy_type,
5239 ext_phy_addr,
5240 MDIO_AN_DEVAD,
5241 MDIO_AN_REG_8481_EXPANSION_REG_RD_RW,
5242 &legacy_status);
5243
5244 DP(NETIF_MSG_LINK, "Legacy speed status"
5245 " = 0x%x\n", legacy_status);
5246 ext_phy_link_up = ((legacy_status & (1<<11))
5247 == (1<<11));
5248 if (ext_phy_link_up) {
5249 legacy_speed = (legacy_status & (3<<9));
5250 if (legacy_speed == (0<<9))
5251 vars->line_speed = SPEED_10;
5252 else if (legacy_speed == (1<<9))
5253 vars->line_speed =
5254 SPEED_100;
5255 else if (legacy_speed == (2<<9))
5256 vars->line_speed =
5257 SPEED_1000;
5258 else /* Should not happen */
5259 vars->line_speed = 0;
5260
5261 if (legacy_status & (1<<8))
5262 vars->duplex = DUPLEX_FULL;
5263 else
5264 vars->duplex = DUPLEX_HALF;
5265
5266 DP(NETIF_MSG_LINK, "Link is up "
5267 "in %dMbps, is_duplex_full"
5268 "= %d\n",
5269 vars->line_speed,
5270 (vars->duplex == DUPLEX_FULL));
5271 bnx2x_8481_set_legacy_led_mode(params,
5272 ext_phy_type,
5273 ext_phy_addr);
5274 }
5275 }
5276 break;
5277 default:
5278 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
5279 params->ext_phy_config);
5280 ext_phy_link_up = 0;
5281 break;
5282 }
5283 /* Set SGMII mode for external phy */
5284 if (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) {
5285 if (vars->line_speed < SPEED_1000)
5286 vars->phy_flags |= PHY_SGMII_FLAG;
5287 else
5288 vars->phy_flags &= ~PHY_SGMII_FLAG;
5289 }
5290
5291 } else { /* SerDes */
5292 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5293 switch (ext_phy_type) {
5294 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
5295 DP(NETIF_MSG_LINK, "SerDes Direct\n");
5296 ext_phy_link_up = 1;
5297 break;
5298
5299 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
5300 DP(NETIF_MSG_LINK, "SerDes 5482\n");
5301 ext_phy_link_up = 1;
5302 break;
5303
5304 default:
5305 DP(NETIF_MSG_LINK,
5306 "BAD SerDes ext_phy_config 0x%x\n",
5307 params->ext_phy_config);
5308 ext_phy_link_up = 0;
5309 break;
5310 }
5311 }
5312
5313 return ext_phy_link_up;
5314 }
5315
5316 static void bnx2x_link_int_enable(struct link_params *params)
5317 {
5318 u8 port = params->port;
5319 u32 ext_phy_type;
5320 u32 mask;
5321 struct bnx2x *bp = params->bp;
5322
5323 /* setting the status to report on link up
5324 for either XGXS or SerDes */
5325
5326 if (params->switch_cfg == SWITCH_CFG_10G) {
5327 mask = (NIG_MASK_XGXS0_LINK10G |
5328 NIG_MASK_XGXS0_LINK_STATUS);
5329 DP(NETIF_MSG_LINK, "enabled XGXS interrupt\n");
5330 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5331 if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
5332 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
5333 (ext_phy_type !=
5334 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN)) {
5335 mask |= NIG_MASK_MI_INT;
5336 DP(NETIF_MSG_LINK, "enabled external phy int\n");
5337 }
5338
5339 } else { /* SerDes */
5340 mask = NIG_MASK_SERDES0_LINK_STATUS;
5341 DP(NETIF_MSG_LINK, "enabled SerDes interrupt\n");
5342 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5343 if ((ext_phy_type !=
5344 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT) &&
5345 (ext_phy_type !=
5346 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN)) {
5347 mask |= NIG_MASK_MI_INT;
5348 DP(NETIF_MSG_LINK, "enabled external phy int\n");
5349 }
5350 }
5351 bnx2x_bits_en(bp,
5352 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
5353 mask);
5354
5355 DP(NETIF_MSG_LINK, "port %x, is_xgxs %x, int_status 0x%x\n", port,
5356 (params->switch_cfg == SWITCH_CFG_10G),
5357 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
5358 DP(NETIF_MSG_LINK, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x\n",
5359 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
5360 REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port*0x18),
5361 REG_RD(bp, NIG_REG_SERDES0_STATUS_LINK_STATUS+port*0x3c));
5362 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
5363 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
5364 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
5365 }
5366
5367 static void bnx2x_8481_rearm_latch_signal(struct bnx2x *bp, u8 port,
5368 u8 is_mi_int)
5369 {
5370 u32 latch_status = 0, is_mi_int_status;
5371 /* Disable the MI INT ( external phy int )
5372 * by writing 1 to the status register. Link down indication
5373 * is high-active-signal, so in this case we need to write the
5374 * status to clear the XOR
5375 */
5376 /* Read Latched signals */
5377 latch_status = REG_RD(bp,
5378 NIG_REG_LATCH_STATUS_0 + port*8);
5379 is_mi_int_status = REG_RD(bp,
5380 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4);
5381 DP(NETIF_MSG_LINK, "original_signal = 0x%x, nig_status = 0x%x,"
5382 "latch_status = 0x%x\n",
5383 is_mi_int, is_mi_int_status, latch_status);
5384 /* Handle only those with latched-signal=up.*/
5385 if (latch_status & 1) {
5386 /* For all latched-signal=up,Write original_signal to status */
5387 if (is_mi_int)
5388 bnx2x_bits_en(bp,
5389 NIG_REG_STATUS_INTERRUPT_PORT0
5390 + port*4,
5391 NIG_STATUS_EMAC0_MI_INT);
5392 else
5393 bnx2x_bits_dis(bp,
5394 NIG_REG_STATUS_INTERRUPT_PORT0
5395 + port*4,
5396 NIG_STATUS_EMAC0_MI_INT);
5397 /* For all latched-signal=up : Re-Arm Latch signals */
5398 REG_WR(bp, NIG_REG_LATCH_STATUS_0 + port*8,
5399 (latch_status & 0xfffe) | (latch_status & 1));
5400 }
5401 }
5402 /*
5403 * link management
5404 */
5405 static void bnx2x_link_int_ack(struct link_params *params,
5406 struct link_vars *vars, u8 is_10g,
5407 u8 is_mi_int)
5408 {
5409 struct bnx2x *bp = params->bp;
5410 u8 port = params->port;
5411
5412 /* first reset all status
5413 * we assume only one line will be change at a time */
5414 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5415 (NIG_STATUS_XGXS0_LINK10G |
5416 NIG_STATUS_XGXS0_LINK_STATUS |
5417 NIG_STATUS_SERDES0_LINK_STATUS));
5418 if ((XGXS_EXT_PHY_TYPE(params->ext_phy_config)
5419 == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481) ||
5420 (XGXS_EXT_PHY_TYPE(params->ext_phy_config)
5421 == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823)) {
5422 bnx2x_8481_rearm_latch_signal(bp, port, is_mi_int);
5423 }
5424 if (vars->phy_link_up) {
5425 if (is_10g) {
5426 /* Disable the 10G link interrupt
5427 * by writing 1 to the status register
5428 */
5429 DP(NETIF_MSG_LINK, "10G XGXS phy link up\n");
5430 bnx2x_bits_en(bp,
5431 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5432 NIG_STATUS_XGXS0_LINK10G);
5433
5434 } else if (params->switch_cfg == SWITCH_CFG_10G) {
5435 /* Disable the link interrupt
5436 * by writing 1 to the relevant lane
5437 * in the status register
5438 */
5439 u32 ser_lane = ((params->lane_config &
5440 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
5441 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
5442
5443 DP(NETIF_MSG_LINK, "%d speed XGXS phy link up\n",
5444 vars->line_speed);
5445 bnx2x_bits_en(bp,
5446 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5447 ((1 << ser_lane) <<
5448 NIG_STATUS_XGXS0_LINK_STATUS_SIZE));
5449
5450 } else { /* SerDes */
5451 DP(NETIF_MSG_LINK, "SerDes phy link up\n");
5452 /* Disable the link interrupt
5453 * by writing 1 to the status register
5454 */
5455 bnx2x_bits_en(bp,
5456 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5457 NIG_STATUS_SERDES0_LINK_STATUS);
5458 }
5459
5460 } else { /* link_down */
5461 }
5462 }
5463
5464 static u8 bnx2x_format_ver(u32 num, u8 *str, u16 len)
5465 {
5466 u8 *str_ptr = str;
5467 u32 mask = 0xf0000000;
5468 u8 shift = 8*4;
5469 u8 digit;
5470 if (len < 10) {
5471 /* Need more than 10chars for this format */
5472 *str_ptr = '\0';
5473 return -EINVAL;
5474 }
5475 while (shift > 0) {
5476
5477 shift -= 4;
5478 digit = ((num & mask) >> shift);
5479 if (digit < 0xa)
5480 *str_ptr = digit + '0';
5481 else
5482 *str_ptr = digit - 0xa + 'a';
5483 str_ptr++;
5484 mask = mask >> 4;
5485 if (shift == 4*4) {
5486 *str_ptr = ':';
5487 str_ptr++;
5488 }
5489 }
5490 *str_ptr = '\0';
5491 return 0;
5492 }
5493
5494 u8 bnx2x_get_ext_phy_fw_version(struct link_params *params, u8 driver_loaded,
5495 u8 *version, u16 len)
5496 {
5497 struct bnx2x *bp;
5498 u32 ext_phy_type = 0;
5499 u32 spirom_ver = 0;
5500 u8 status;
5501
5502 if (version == NULL || params == NULL)
5503 return -EINVAL;
5504 bp = params->bp;
5505
5506 spirom_ver = REG_RD(bp, params->shmem_base +
5507 offsetof(struct shmem_region,
5508 port_mb[params->port].ext_phy_fw_version));
5509
5510 status = 0;
5511 /* reset the returned value to zero */
5512 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5513 switch (ext_phy_type) {
5514 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5515
5516 if (len < 5)
5517 return -EINVAL;
5518
5519 version[0] = (spirom_ver & 0xFF);
5520 version[1] = (spirom_ver & 0xFF00) >> 8;
5521 version[2] = (spirom_ver & 0xFF0000) >> 16;
5522 version[3] = (spirom_ver & 0xFF000000) >> 24;
5523 version[4] = '\0';
5524
5525 break;
5526 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
5527 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
5528 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
5529 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
5530 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
5531 status = bnx2x_format_ver(spirom_ver, version, len);
5532 break;
5533 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
5534 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
5535 spirom_ver = ((spirom_ver & 0xF80) >> 7) << 16 |
5536 (spirom_ver & 0x7F);
5537 status = bnx2x_format_ver(spirom_ver, version, len);
5538 break;
5539 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
5540 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
5541 version[0] = '\0';
5542 break;
5543
5544 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
5545 DP(NETIF_MSG_LINK, "bnx2x_get_ext_phy_fw_version:"
5546 " type is FAILURE!\n");
5547 status = -EINVAL;
5548 break;
5549
5550 default:
5551 break;
5552 }
5553 return status;
5554 }
5555
5556 static void bnx2x_set_xgxs_loopback(struct link_params *params,
5557 struct link_vars *vars,
5558 u8 is_10g)
5559 {
5560 u8 port = params->port;
5561 struct bnx2x *bp = params->bp;
5562
5563 if (is_10g) {
5564 u32 md_devad;
5565
5566 DP(NETIF_MSG_LINK, "XGXS 10G loopback enable\n");
5567
5568 /* change the uni_phy_addr in the nig */
5569 md_devad = REG_RD(bp, (NIG_REG_XGXS0_CTRL_MD_DEVAD +
5570 port*0x18));
5571
5572 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, 0x5);
5573
5574 bnx2x_cl45_write(bp, port, 0,
5575 params->phy_addr,
5576 5,
5577 (MDIO_REG_BANK_AER_BLOCK +
5578 (MDIO_AER_BLOCK_AER_REG & 0xf)),
5579 0x2800);
5580
5581 bnx2x_cl45_write(bp, port, 0,
5582 params->phy_addr,
5583 5,
5584 (MDIO_REG_BANK_CL73_IEEEB0 +
5585 (MDIO_CL73_IEEEB0_CL73_AN_CONTROL & 0xf)),
5586 0x6041);
5587 msleep(200);
5588 /* set aer mmd back */
5589 bnx2x_set_aer_mmd(params, vars);
5590
5591 /* and md_devad */
5592 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18,
5593 md_devad);
5594
5595 } else {
5596 u16 mii_control;
5597
5598 DP(NETIF_MSG_LINK, "XGXS 1G loopback enable\n");
5599
5600 CL45_RD_OVER_CL22(bp, port,
5601 params->phy_addr,
5602 MDIO_REG_BANK_COMBO_IEEE0,
5603 MDIO_COMBO_IEEE0_MII_CONTROL,
5604 &mii_control);
5605
5606 CL45_WR_OVER_CL22(bp, port,
5607 params->phy_addr,
5608 MDIO_REG_BANK_COMBO_IEEE0,
5609 MDIO_COMBO_IEEE0_MII_CONTROL,
5610 (mii_control |
5611 MDIO_COMBO_IEEO_MII_CONTROL_LOOPBACK));
5612 }
5613 }
5614
5615
5616 static void bnx2x_ext_phy_loopback(struct link_params *params)
5617 {
5618 struct bnx2x *bp = params->bp;
5619 u8 ext_phy_addr;
5620 u32 ext_phy_type;
5621
5622 if (params->switch_cfg == SWITCH_CFG_10G) {
5623 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5624 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
5625 /* CL37 Autoneg Enabled */
5626 switch (ext_phy_type) {
5627 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
5628 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN:
5629 DP(NETIF_MSG_LINK,
5630 "ext_phy_loopback: We should not get here\n");
5631 break;
5632 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
5633 DP(NETIF_MSG_LINK, "ext_phy_loopback: 8705\n");
5634 break;
5635 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
5636 DP(NETIF_MSG_LINK, "ext_phy_loopback: 8706\n");
5637 break;
5638 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
5639 DP(NETIF_MSG_LINK, "PMA/PMD ext_phy_loopback: 8726\n");
5640 bnx2x_cl45_write(bp, params->port, ext_phy_type,
5641 ext_phy_addr,
5642 MDIO_PMA_DEVAD,
5643 MDIO_PMA_REG_CTRL,
5644 0x0001);
5645 break;
5646 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5647 /* SFX7101_XGXS_TEST1 */
5648 bnx2x_cl45_write(bp, params->port, ext_phy_type,
5649 ext_phy_addr,
5650 MDIO_XS_DEVAD,
5651 MDIO_XS_SFX7101_XGXS_TEST1,
5652 0x100);
5653 DP(NETIF_MSG_LINK,
5654 "ext_phy_loopback: set ext phy loopback\n");
5655 break;
5656 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
5657
5658 break;
5659 } /* switch external PHY type */
5660 } else {
5661 /* serdes */
5662 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5663 ext_phy_addr = (params->ext_phy_config &
5664 PORT_HW_CFG_SERDES_EXT_PHY_ADDR_MASK)
5665 >> PORT_HW_CFG_SERDES_EXT_PHY_ADDR_SHIFT;
5666 }
5667 }
5668
5669
5670 /*
5671 *------------------------------------------------------------------------
5672 * bnx2x_override_led_value -
5673 *
5674 * Override the led value of the requsted led
5675 *
5676 *------------------------------------------------------------------------
5677 */
5678 u8 bnx2x_override_led_value(struct bnx2x *bp, u8 port,
5679 u32 led_idx, u32 value)
5680 {
5681 u32 reg_val;
5682
5683 /* If port 0 then use EMAC0, else use EMAC1*/
5684 u32 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
5685
5686 DP(NETIF_MSG_LINK,
5687 "bnx2x_override_led_value() port %x led_idx %d value %d\n",
5688 port, led_idx, value);
5689
5690 switch (led_idx) {
5691 case 0: /* 10MB led */
5692 /* Read the current value of the LED register in
5693 the EMAC block */
5694 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5695 /* Set the OVERRIDE bit to 1 */
5696 reg_val |= EMAC_LED_OVERRIDE;
5697 /* If value is 1, set the 10M_OVERRIDE bit,
5698 otherwise reset it.*/
5699 reg_val = (value == 1) ? (reg_val | EMAC_LED_10MB_OVERRIDE) :
5700 (reg_val & ~EMAC_LED_10MB_OVERRIDE);
5701 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5702 break;
5703 case 1: /*100MB led */
5704 /*Read the current value of the LED register in
5705 the EMAC block */
5706 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5707 /* Set the OVERRIDE bit to 1 */
5708 reg_val |= EMAC_LED_OVERRIDE;
5709 /* If value is 1, set the 100M_OVERRIDE bit,
5710 otherwise reset it.*/
5711 reg_val = (value == 1) ? (reg_val | EMAC_LED_100MB_OVERRIDE) :
5712 (reg_val & ~EMAC_LED_100MB_OVERRIDE);
5713 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5714 break;
5715 case 2: /* 1000MB led */
5716 /* Read the current value of the LED register in the
5717 EMAC block */
5718 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5719 /* Set the OVERRIDE bit to 1 */
5720 reg_val |= EMAC_LED_OVERRIDE;
5721 /* If value is 1, set the 1000M_OVERRIDE bit, otherwise
5722 reset it. */
5723 reg_val = (value == 1) ? (reg_val | EMAC_LED_1000MB_OVERRIDE) :
5724 (reg_val & ~EMAC_LED_1000MB_OVERRIDE);
5725 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5726 break;
5727 case 3: /* 2500MB led */
5728 /* Read the current value of the LED register in the
5729 EMAC block*/
5730 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5731 /* Set the OVERRIDE bit to 1 */
5732 reg_val |= EMAC_LED_OVERRIDE;
5733 /* If value is 1, set the 2500M_OVERRIDE bit, otherwise
5734 reset it.*/
5735 reg_val = (value == 1) ? (reg_val | EMAC_LED_2500MB_OVERRIDE) :
5736 (reg_val & ~EMAC_LED_2500MB_OVERRIDE);
5737 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5738 break;
5739 case 4: /*10G led */
5740 if (port == 0) {
5741 REG_WR(bp, NIG_REG_LED_10G_P0,
5742 value);
5743 } else {
5744 REG_WR(bp, NIG_REG_LED_10G_P1,
5745 value);
5746 }
5747 break;
5748 case 5: /* TRAFFIC led */
5749 /* Find if the traffic control is via BMAC or EMAC */
5750 if (port == 0)
5751 reg_val = REG_RD(bp, NIG_REG_NIG_EMAC0_EN);
5752 else
5753 reg_val = REG_RD(bp, NIG_REG_NIG_EMAC1_EN);
5754
5755 /* Override the traffic led in the EMAC:*/
5756 if (reg_val == 1) {
5757 /* Read the current value of the LED register in
5758 the EMAC block */
5759 reg_val = REG_RD(bp, emac_base +
5760 EMAC_REG_EMAC_LED);
5761 /* Set the TRAFFIC_OVERRIDE bit to 1 */
5762 reg_val |= EMAC_LED_OVERRIDE;
5763 /* If value is 1, set the TRAFFIC bit, otherwise
5764 reset it.*/
5765 reg_val = (value == 1) ? (reg_val | EMAC_LED_TRAFFIC) :
5766 (reg_val & ~EMAC_LED_TRAFFIC);
5767 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5768 } else { /* Override the traffic led in the BMAC: */
5769 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0
5770 + port*4, 1);
5771 REG_WR(bp, NIG_REG_LED_CONTROL_TRAFFIC_P0 + port*4,
5772 value);
5773 }
5774 break;
5775 default:
5776 DP(NETIF_MSG_LINK,
5777 "bnx2x_override_led_value() unknown led index %d "
5778 "(should be 0-5)\n", led_idx);
5779 return -EINVAL;
5780 }
5781
5782 return 0;
5783 }
5784
5785
5786 u8 bnx2x_set_led(struct link_params *params, u8 mode, u32 speed)
5787 {
5788 u8 port = params->port;
5789 u16 hw_led_mode = params->hw_led_mode;
5790 u8 rc = 0;
5791 u32 tmp;
5792 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
5793 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5794 struct bnx2x *bp = params->bp;
5795 DP(NETIF_MSG_LINK, "bnx2x_set_led: port %x, mode %d\n", port, mode);
5796 DP(NETIF_MSG_LINK, "speed 0x%x, hw_led_mode 0x%x\n",
5797 speed, hw_led_mode);
5798 switch (mode) {
5799 case LED_MODE_OFF:
5800 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 0);
5801 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4,
5802 SHARED_HW_CFG_LED_MAC1);
5803
5804 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
5805 EMAC_WR(bp, EMAC_REG_EMAC_LED, (tmp | EMAC_LED_OVERRIDE));
5806 break;
5807
5808 case LED_MODE_OPER:
5809 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) {
5810 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, 0);
5811 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
5812 } else {
5813 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4,
5814 hw_led_mode);
5815 }
5816
5817 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 +
5818 port*4, 0);
5819 /* Set blinking rate to ~15.9Hz */
5820 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_P0 + port*4,
5821 LED_BLINK_RATE_VAL);
5822 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_ENA_P0 +
5823 port*4, 1);
5824 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
5825 EMAC_WR(bp, EMAC_REG_EMAC_LED,
5826 (tmp & (~EMAC_LED_OVERRIDE)));
5827
5828 if (CHIP_IS_E1(bp) &&
5829 ((speed == SPEED_2500) ||
5830 (speed == SPEED_1000) ||
5831 (speed == SPEED_100) ||
5832 (speed == SPEED_10))) {
5833 /* On Everest 1 Ax chip versions for speeds less than
5834 10G LED scheme is different */
5835 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0
5836 + port*4, 1);
5837 REG_WR(bp, NIG_REG_LED_CONTROL_TRAFFIC_P0 +
5838 port*4, 0);
5839 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_TRAFFIC_P0 +
5840 port*4, 1);
5841 }
5842 break;
5843
5844 default:
5845 rc = -EINVAL;
5846 DP(NETIF_MSG_LINK, "bnx2x_set_led: Invalid led mode %d\n",
5847 mode);
5848 break;
5849 }
5850 return rc;
5851
5852 }
5853
5854 u8 bnx2x_test_link(struct link_params *params, struct link_vars *vars)
5855 {
5856 struct bnx2x *bp = params->bp;
5857 u16 gp_status = 0;
5858
5859 CL45_RD_OVER_CL22(bp, params->port,
5860 params->phy_addr,
5861 MDIO_REG_BANK_GP_STATUS,
5862 MDIO_GP_STATUS_TOP_AN_STATUS1,
5863 &gp_status);
5864 /* link is up only if both local phy and external phy are up */
5865 if ((gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) &&
5866 bnx2x_ext_phy_is_link_up(params, vars, 1))
5867 return 0;
5868
5869 return -ESRCH;
5870 }
5871
5872 static u8 bnx2x_link_initialize(struct link_params *params,
5873 struct link_vars *vars)
5874 {
5875 struct bnx2x *bp = params->bp;
5876 u8 port = params->port;
5877 u8 rc = 0;
5878 u8 non_ext_phy;
5879 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5880
5881 /* Activate the external PHY */
5882 bnx2x_ext_phy_reset(params, vars);
5883
5884 bnx2x_set_aer_mmd(params, vars);
5885
5886 if (vars->phy_flags & PHY_XGXS_FLAG)
5887 bnx2x_set_master_ln(params);
5888
5889 rc = bnx2x_reset_unicore(params);
5890 /* reset the SerDes and wait for reset bit return low */
5891 if (rc != 0)
5892 return rc;
5893
5894 bnx2x_set_aer_mmd(params, vars);
5895
5896 /* setting the masterLn_def again after the reset */
5897 if (vars->phy_flags & PHY_XGXS_FLAG) {
5898 bnx2x_set_master_ln(params);
5899 bnx2x_set_swap_lanes(params);
5900 }
5901
5902 if (vars->phy_flags & PHY_XGXS_FLAG) {
5903 if ((params->req_line_speed &&
5904 ((params->req_line_speed == SPEED_100) ||
5905 (params->req_line_speed == SPEED_10))) ||
5906 (!params->req_line_speed &&
5907 (params->speed_cap_mask >=
5908 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) &&
5909 (params->speed_cap_mask <
5910 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
5911 )) {
5912 vars->phy_flags |= PHY_SGMII_FLAG;
5913 } else {
5914 vars->phy_flags &= ~PHY_SGMII_FLAG;
5915 }
5916 }
5917 /* In case of external phy existance, the line speed would be the
5918 line speed linked up by the external phy. In case it is direct only,
5919 then the line_speed during initialization will be equal to the
5920 req_line_speed*/
5921 vars->line_speed = params->req_line_speed;
5922
5923 bnx2x_calc_ieee_aneg_adv(params, &vars->ieee_fc);
5924
5925 /* init ext phy and enable link state int */
5926 non_ext_phy = ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) ||
5927 (params->loopback_mode == LOOPBACK_XGXS_10));
5928
5929 if (non_ext_phy ||
5930 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
5931 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706) ||
5932 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) ||
5933 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
5934 if (params->req_line_speed == SPEED_AUTO_NEG)
5935 bnx2x_set_parallel_detection(params, vars->phy_flags);
5936 bnx2x_init_internal_phy(params, vars, non_ext_phy);
5937 }
5938
5939 if (!non_ext_phy)
5940 rc |= bnx2x_ext_phy_init(params, vars);
5941
5942 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5943 (NIG_STATUS_XGXS0_LINK10G |
5944 NIG_STATUS_XGXS0_LINK_STATUS |
5945 NIG_STATUS_SERDES0_LINK_STATUS));
5946
5947 return rc;
5948
5949 }
5950
5951
5952 u8 bnx2x_phy_init(struct link_params *params, struct link_vars *vars)
5953 {
5954 struct bnx2x *bp = params->bp;
5955 u32 val;
5956
5957 DP(NETIF_MSG_LINK, "Phy Initialization started\n");
5958 DP(NETIF_MSG_LINK, "req_speed %d, req_flowctrl %d\n",
5959 params->req_line_speed, params->req_flow_ctrl);
5960 vars->link_status = 0;
5961 vars->phy_link_up = 0;
5962 vars->link_up = 0;
5963 vars->line_speed = 0;
5964 vars->duplex = DUPLEX_FULL;
5965 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
5966 vars->mac_type = MAC_TYPE_NONE;
5967
5968 if (params->switch_cfg == SWITCH_CFG_1G)
5969 vars->phy_flags = PHY_SERDES_FLAG;
5970 else
5971 vars->phy_flags = PHY_XGXS_FLAG;
5972
5973 /* disable attentions */
5974 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + params->port*4,
5975 (NIG_MASK_XGXS0_LINK_STATUS |
5976 NIG_MASK_XGXS0_LINK10G |
5977 NIG_MASK_SERDES0_LINK_STATUS |
5978 NIG_MASK_MI_INT));
5979
5980 bnx2x_emac_init(params, vars);
5981
5982 if (CHIP_REV_IS_FPGA(bp)) {
5983
5984 vars->link_up = 1;
5985 vars->line_speed = SPEED_10000;
5986 vars->duplex = DUPLEX_FULL;
5987 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
5988 vars->link_status = (LINK_STATUS_LINK_UP | LINK_10GTFD);
5989 /* enable on E1.5 FPGA */
5990 if (CHIP_IS_E1H(bp)) {
5991 vars->flow_ctrl |=
5992 (BNX2X_FLOW_CTRL_TX |
5993 BNX2X_FLOW_CTRL_RX);
5994 vars->link_status |=
5995 (LINK_STATUS_TX_FLOW_CONTROL_ENABLED |
5996 LINK_STATUS_RX_FLOW_CONTROL_ENABLED);
5997 }
5998
5999 bnx2x_emac_enable(params, vars, 0);
6000 bnx2x_pbf_update(params, vars->flow_ctrl, vars->line_speed);
6001 /* disable drain */
6002 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
6003
6004 /* update shared memory */
6005 bnx2x_update_mng(params, vars->link_status);
6006
6007 return 0;
6008
6009 } else
6010 if (CHIP_REV_IS_EMUL(bp)) {
6011
6012 vars->link_up = 1;
6013 vars->line_speed = SPEED_10000;
6014 vars->duplex = DUPLEX_FULL;
6015 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
6016 vars->link_status = (LINK_STATUS_LINK_UP | LINK_10GTFD);
6017
6018 bnx2x_bmac_enable(params, vars, 0);
6019
6020 bnx2x_pbf_update(params, vars->flow_ctrl, vars->line_speed);
6021 /* Disable drain */
6022 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
6023 + params->port*4, 0);
6024
6025 /* update shared memory */
6026 bnx2x_update_mng(params, vars->link_status);
6027
6028 return 0;
6029
6030 } else
6031 if (params->loopback_mode == LOOPBACK_BMAC) {
6032
6033 vars->link_up = 1;
6034 vars->line_speed = SPEED_10000;
6035 vars->duplex = DUPLEX_FULL;
6036 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
6037 vars->mac_type = MAC_TYPE_BMAC;
6038
6039 vars->phy_flags = PHY_XGXS_FLAG;
6040
6041 bnx2x_phy_deassert(params, vars->phy_flags);
6042 /* set bmac loopback */
6043 bnx2x_bmac_enable(params, vars, 1);
6044
6045 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
6046 params->port*4, 0);
6047
6048 } else if (params->loopback_mode == LOOPBACK_EMAC) {
6049
6050 vars->link_up = 1;
6051 vars->line_speed = SPEED_1000;
6052 vars->duplex = DUPLEX_FULL;
6053 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
6054 vars->mac_type = MAC_TYPE_EMAC;
6055
6056 vars->phy_flags = PHY_XGXS_FLAG;
6057
6058 bnx2x_phy_deassert(params, vars->phy_flags);
6059 /* set bmac loopback */
6060 bnx2x_emac_enable(params, vars, 1);
6061 bnx2x_emac_program(params, vars->line_speed,
6062 vars->duplex);
6063 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
6064 params->port*4, 0);
6065
6066 } else if ((params->loopback_mode == LOOPBACK_XGXS_10) ||
6067 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
6068
6069 vars->link_up = 1;
6070 vars->line_speed = SPEED_10000;
6071 vars->duplex = DUPLEX_FULL;
6072 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
6073
6074 vars->phy_flags = PHY_XGXS_FLAG;
6075
6076 val = REG_RD(bp,
6077 NIG_REG_XGXS0_CTRL_PHY_ADDR+
6078 params->port*0x18);
6079 params->phy_addr = (u8)val;
6080
6081 bnx2x_phy_deassert(params, vars->phy_flags);
6082 bnx2x_link_initialize(params, vars);
6083
6084 vars->mac_type = MAC_TYPE_BMAC;
6085
6086 bnx2x_bmac_enable(params, vars, 0);
6087
6088 if (params->loopback_mode == LOOPBACK_XGXS_10) {
6089 /* set 10G XGXS loopback */
6090 bnx2x_set_xgxs_loopback(params, vars, 1);
6091 } else {
6092 /* set external phy loopback */
6093 bnx2x_ext_phy_loopback(params);
6094 }
6095 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
6096 params->port*4, 0);
6097
6098 bnx2x_set_led(params, LED_MODE_OPER, vars->line_speed);
6099 } else
6100 /* No loopback */
6101 {
6102 bnx2x_phy_deassert(params, vars->phy_flags);
6103 switch (params->switch_cfg) {
6104 case SWITCH_CFG_1G:
6105 vars->phy_flags |= PHY_SERDES_FLAG;
6106 if ((params->ext_phy_config &
6107 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_MASK) ==
6108 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482) {
6109 vars->phy_flags |= PHY_SGMII_FLAG;
6110 }
6111
6112 val = REG_RD(bp,
6113 NIG_REG_SERDES0_CTRL_PHY_ADDR+
6114 params->port*0x10);
6115
6116 params->phy_addr = (u8)val;
6117
6118 break;
6119 case SWITCH_CFG_10G:
6120 vars->phy_flags |= PHY_XGXS_FLAG;
6121 val = REG_RD(bp,
6122 NIG_REG_XGXS0_CTRL_PHY_ADDR+
6123 params->port*0x18);
6124 params->phy_addr = (u8)val;
6125
6126 break;
6127 default:
6128 DP(NETIF_MSG_LINK, "Invalid switch_cfg\n");
6129 return -EINVAL;
6130 }
6131 DP(NETIF_MSG_LINK, "Phy address = 0x%x\n", params->phy_addr);
6132
6133 bnx2x_link_initialize(params, vars);
6134 msleep(30);
6135 bnx2x_link_int_enable(params);
6136 }
6137 return 0;
6138 }
6139
6140 static void bnx2x_8726_reset_phy(struct bnx2x *bp, u8 port, u8 ext_phy_addr)
6141 {
6142 DP(NETIF_MSG_LINK, "bnx2x_8726_reset_phy port %d\n", port);
6143
6144 /* Set serial boot control for external load */
6145 bnx2x_cl45_write(bp, port,
6146 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726, ext_phy_addr,
6147 MDIO_PMA_DEVAD,
6148 MDIO_PMA_REG_GEN_CTRL, 0x0001);
6149 }
6150
6151 u8 bnx2x_link_reset(struct link_params *params, struct link_vars *vars,
6152 u8 reset_ext_phy)
6153 {
6154 struct bnx2x *bp = params->bp;
6155 u32 ext_phy_config = params->ext_phy_config;
6156 u8 port = params->port;
6157 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
6158 u32 val = REG_RD(bp, params->shmem_base +
6159 offsetof(struct shmem_region, dev_info.
6160 port_feature_config[params->port].
6161 config));
6162 DP(NETIF_MSG_LINK, "Resetting the link of port %d\n", port);
6163 /* disable attentions */
6164 vars->link_status = 0;
6165 bnx2x_update_mng(params, vars->link_status);
6166 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6167 (NIG_MASK_XGXS0_LINK_STATUS |
6168 NIG_MASK_XGXS0_LINK10G |
6169 NIG_MASK_SERDES0_LINK_STATUS |
6170 NIG_MASK_MI_INT));
6171
6172 /* activate nig drain */
6173 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
6174
6175 /* disable nig egress interface */
6176 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
6177 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
6178
6179 /* Stop BigMac rx */
6180 bnx2x_bmac_rx_disable(bp, port);
6181
6182 /* disable emac */
6183 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6184
6185 msleep(10);
6186 /* The PHY reset is controled by GPIO 1
6187 * Hold it as vars low
6188 */
6189 /* clear link led */
6190 bnx2x_set_led(params, LED_MODE_OFF, 0);
6191 if (reset_ext_phy) {
6192 switch (ext_phy_type) {
6193 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
6194 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
6195 break;
6196
6197 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
6198 {
6199
6200 /* Disable Transmitter */
6201 u8 ext_phy_addr =
6202 XGXS_EXT_PHY_ADDR(params->ext_phy_config);
6203 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
6204 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
6205 bnx2x_sfp_set_transmitter(bp, port,
6206 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6207 ext_phy_addr, 0);
6208 break;
6209 }
6210 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
6211 DP(NETIF_MSG_LINK, "Setting 8073 port %d into "
6212 "low power mode\n",
6213 port);
6214 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6215 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6216 port);
6217 break;
6218 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
6219 {
6220 u8 ext_phy_addr =
6221 XGXS_EXT_PHY_ADDR(params->ext_phy_config);
6222 /* Set soft reset */
6223 bnx2x_8726_reset_phy(bp, params->port, ext_phy_addr);
6224 break;
6225 }
6226 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
6227 {
6228 u8 ext_phy_addr =
6229 XGXS_EXT_PHY_ADDR(params->ext_phy_config);
6230 bnx2x_cl45_write(bp, port,
6231 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
6232 ext_phy_addr,
6233 MDIO_AN_DEVAD,
6234 MDIO_AN_REG_CTRL, 0x0000);
6235 bnx2x_cl45_write(bp, port,
6236 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
6237 ext_phy_addr,
6238 MDIO_PMA_DEVAD,
6239 MDIO_PMA_REG_CTRL, 1);
6240 break;
6241 }
6242 default:
6243 /* HW reset */
6244 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
6245 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6246 port);
6247 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6248 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6249 port);
6250 DP(NETIF_MSG_LINK, "reset external PHY\n");
6251 }
6252 }
6253 /* reset the SerDes/XGXS */
6254 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
6255 (0x1ff << (port*16)));
6256
6257 /* reset BigMac */
6258 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
6259 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
6260
6261 /* disable nig ingress interface */
6262 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0);
6263 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0);
6264 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
6265 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
6266 vars->link_up = 0;
6267 return 0;
6268 }
6269
6270 static u8 bnx2x_update_link_down(struct link_params *params,
6271 struct link_vars *vars)
6272 {
6273 struct bnx2x *bp = params->bp;
6274 u8 port = params->port;
6275
6276 DP(NETIF_MSG_LINK, "Port %x: Link is down\n", port);
6277 bnx2x_set_led(params, LED_MODE_OFF, 0);
6278
6279 /* indicate no mac active */
6280 vars->mac_type = MAC_TYPE_NONE;
6281
6282 /* update shared memory */
6283 vars->link_status = 0;
6284 vars->line_speed = 0;
6285 bnx2x_update_mng(params, vars->link_status);
6286
6287 /* activate nig drain */
6288 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
6289
6290 /* disable emac */
6291 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6292
6293 msleep(10);
6294
6295 /* reset BigMac */
6296 bnx2x_bmac_rx_disable(bp, params->port);
6297 REG_WR(bp, GRCBASE_MISC +
6298 MISC_REGISTERS_RESET_REG_2_CLEAR,
6299 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
6300 return 0;
6301 }
6302
6303 static u8 bnx2x_update_link_up(struct link_params *params,
6304 struct link_vars *vars,
6305 u8 link_10g, u32 gp_status)
6306 {
6307 struct bnx2x *bp = params->bp;
6308 u8 port = params->port;
6309 u8 rc = 0;
6310
6311 vars->link_status |= LINK_STATUS_LINK_UP;
6312 if (link_10g) {
6313 bnx2x_bmac_enable(params, vars, 0);
6314 bnx2x_set_led(params, LED_MODE_OPER, SPEED_10000);
6315 } else {
6316 rc = bnx2x_emac_program(params, vars->line_speed,
6317 vars->duplex);
6318
6319 bnx2x_emac_enable(params, vars, 0);
6320
6321 /* AN complete? */
6322 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) {
6323 if (!(vars->phy_flags &
6324 PHY_SGMII_FLAG))
6325 bnx2x_set_gmii_tx_driver(params);
6326 }
6327 }
6328
6329 /* PBF - link up */
6330 rc |= bnx2x_pbf_update(params, vars->flow_ctrl,
6331 vars->line_speed);
6332
6333 /* disable drain */
6334 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 0);
6335
6336 /* update shared memory */
6337 bnx2x_update_mng(params, vars->link_status);
6338 msleep(20);
6339 return rc;
6340 }
6341 /* This function should called upon link interrupt */
6342 /* In case vars->link_up, driver needs to
6343 1. Update the pbf
6344 2. Disable drain
6345 3. Update the shared memory
6346 4. Indicate link up
6347 5. Set LEDs
6348 Otherwise,
6349 1. Update shared memory
6350 2. Reset BigMac
6351 3. Report link down
6352 4. Unset LEDs
6353 */
6354 u8 bnx2x_link_update(struct link_params *params, struct link_vars *vars)
6355 {
6356 struct bnx2x *bp = params->bp;
6357 u8 port = params->port;
6358 u16 gp_status;
6359 u8 link_10g;
6360 u8 ext_phy_link_up, rc = 0;
6361 u32 ext_phy_type;
6362 u8 is_mi_int = 0;
6363
6364 DP(NETIF_MSG_LINK, "port %x, XGXS?%x, int_status 0x%x\n",
6365 port, (vars->phy_flags & PHY_XGXS_FLAG),
6366 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
6367
6368 is_mi_int = (u8)(REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT +
6369 port*0x18) > 0);
6370 DP(NETIF_MSG_LINK, "int_mask 0x%x MI_INT %x, SERDES_LINK %x\n",
6371 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
6372 is_mi_int,
6373 REG_RD(bp,
6374 NIG_REG_SERDES0_STATUS_LINK_STATUS + port*0x3c));
6375
6376 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
6377 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
6378 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
6379
6380 /* disable emac */
6381 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6382
6383 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
6384
6385 /* Check external link change only for non-direct */
6386 ext_phy_link_up = bnx2x_ext_phy_is_link_up(params, vars, is_mi_int);
6387
6388 /* Read gp_status */
6389 CL45_RD_OVER_CL22(bp, port, params->phy_addr,
6390 MDIO_REG_BANK_GP_STATUS,
6391 MDIO_GP_STATUS_TOP_AN_STATUS1,
6392 &gp_status);
6393
6394 rc = bnx2x_link_settings_status(params, vars, gp_status,
6395 ext_phy_link_up);
6396 if (rc != 0)
6397 return rc;
6398
6399 /* anything 10 and over uses the bmac */
6400 link_10g = ((vars->line_speed == SPEED_10000) ||
6401 (vars->line_speed == SPEED_12000) ||
6402 (vars->line_speed == SPEED_12500) ||
6403 (vars->line_speed == SPEED_13000) ||
6404 (vars->line_speed == SPEED_15000) ||
6405 (vars->line_speed == SPEED_16000));
6406
6407 bnx2x_link_int_ack(params, vars, link_10g, is_mi_int);
6408
6409 /* In case external phy link is up, and internal link is down
6410 ( not initialized yet probably after link initialization, it needs
6411 to be initialized.
6412 Note that after link down-up as result of cable plug,
6413 the xgxs link would probably become up again without the need to
6414 initialize it*/
6415
6416 if ((ext_phy_type != PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT) &&
6417 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) &&
6418 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706) &&
6419 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) &&
6420 (ext_phy_link_up && !vars->phy_link_up))
6421 bnx2x_init_internal_phy(params, vars, 0);
6422
6423 /* link is up only if both local phy and external phy are up */
6424 vars->link_up = (ext_phy_link_up && vars->phy_link_up);
6425
6426 if (vars->link_up)
6427 rc = bnx2x_update_link_up(params, vars, link_10g, gp_status);
6428 else
6429 rc = bnx2x_update_link_down(params, vars);
6430
6431 return rc;
6432 }
6433
6434 static u8 bnx2x_8073_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6435 {
6436 u8 ext_phy_addr[PORT_MAX];
6437 u16 val;
6438 s8 port;
6439
6440 /* PART1 - Reset both phys */
6441 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
6442 /* Extract the ext phy address for the port */
6443 u32 ext_phy_config = REG_RD(bp, shmem_base +
6444 offsetof(struct shmem_region,
6445 dev_info.port_hw_config[port].external_phy_config));
6446
6447 /* disable attentions */
6448 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6449 (NIG_MASK_XGXS0_LINK_STATUS |
6450 NIG_MASK_XGXS0_LINK10G |
6451 NIG_MASK_SERDES0_LINK_STATUS |
6452 NIG_MASK_MI_INT));
6453
6454 ext_phy_addr[port] = XGXS_EXT_PHY_ADDR(ext_phy_config);
6455
6456 /* Need to take the phy out of low power mode in order
6457 to write to access its registers */
6458 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6459 MISC_REGISTERS_GPIO_OUTPUT_HIGH, port);
6460
6461 /* Reset the phy */
6462 bnx2x_cl45_write(bp, port,
6463 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6464 ext_phy_addr[port],
6465 MDIO_PMA_DEVAD,
6466 MDIO_PMA_REG_CTRL,
6467 1<<15);
6468 }
6469
6470 /* Add delay of 150ms after reset */
6471 msleep(150);
6472
6473 /* PART2 - Download firmware to both phys */
6474 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
6475 u16 fw_ver1;
6476
6477 bnx2x_bcm8073_external_rom_boot(bp, port,
6478 ext_phy_addr[port], shmem_base);
6479
6480 bnx2x_cl45_read(bp, port, PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6481 ext_phy_addr[port],
6482 MDIO_PMA_DEVAD,
6483 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
6484 if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
6485 DP(NETIF_MSG_LINK,
6486 "bnx2x_8073_common_init_phy port %x:"
6487 "Download failed. fw version = 0x%x\n",
6488 port, fw_ver1);
6489 return -EINVAL;
6490 }
6491
6492 /* Only set bit 10 = 1 (Tx power down) */
6493 bnx2x_cl45_read(bp, port,
6494 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6495 ext_phy_addr[port],
6496 MDIO_PMA_DEVAD,
6497 MDIO_PMA_REG_TX_POWER_DOWN, &val);
6498
6499 /* Phase1 of TX_POWER_DOWN reset */
6500 bnx2x_cl45_write(bp, port,
6501 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6502 ext_phy_addr[port],
6503 MDIO_PMA_DEVAD,
6504 MDIO_PMA_REG_TX_POWER_DOWN,
6505 (val | 1<<10));
6506 }
6507
6508 /* Toggle Transmitter: Power down and then up with 600ms
6509 delay between */
6510 msleep(600);
6511
6512 /* PART3 - complete TX_POWER_DOWN process, and set GPIO2 back to low */
6513 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
6514 /* Phase2 of POWER_DOWN_RESET */
6515 /* Release bit 10 (Release Tx power down) */
6516 bnx2x_cl45_read(bp, port,
6517 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6518 ext_phy_addr[port],
6519 MDIO_PMA_DEVAD,
6520 MDIO_PMA_REG_TX_POWER_DOWN, &val);
6521
6522 bnx2x_cl45_write(bp, port,
6523 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6524 ext_phy_addr[port],
6525 MDIO_PMA_DEVAD,
6526 MDIO_PMA_REG_TX_POWER_DOWN, (val & (~(1<<10))));
6527 msleep(15);
6528
6529 /* Read modify write the SPI-ROM version select register */
6530 bnx2x_cl45_read(bp, port,
6531 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6532 ext_phy_addr[port],
6533 MDIO_PMA_DEVAD,
6534 MDIO_PMA_REG_EDC_FFE_MAIN, &val);
6535 bnx2x_cl45_write(bp, port,
6536 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6537 ext_phy_addr[port],
6538 MDIO_PMA_DEVAD,
6539 MDIO_PMA_REG_EDC_FFE_MAIN, (val | (1<<12)));
6540
6541 /* set GPIO2 back to LOW */
6542 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6543 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
6544 }
6545 return 0;
6546
6547 }
6548
6549 static u8 bnx2x_8727_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6550 {
6551 u8 ext_phy_addr[PORT_MAX];
6552 s8 port, first_port, i;
6553 u32 swap_val, swap_override;
6554 DP(NETIF_MSG_LINK, "Executing BCM8727 common init\n");
6555 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
6556 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
6557
6558 bnx2x_ext_phy_hw_reset(bp, 1 ^ (swap_val && swap_override));
6559 msleep(5);
6560
6561 if (swap_val && swap_override)
6562 first_port = PORT_0;
6563 else
6564 first_port = PORT_1;
6565
6566 /* PART1 - Reset both phys */
6567 for (i = 0, port = first_port; i < PORT_MAX; i++, port = !port) {
6568 /* Extract the ext phy address for the port */
6569 u32 ext_phy_config = REG_RD(bp, shmem_base +
6570 offsetof(struct shmem_region,
6571 dev_info.port_hw_config[port].external_phy_config));
6572
6573 /* disable attentions */
6574 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6575 (NIG_MASK_XGXS0_LINK_STATUS |
6576 NIG_MASK_XGXS0_LINK10G |
6577 NIG_MASK_SERDES0_LINK_STATUS |
6578 NIG_MASK_MI_INT));
6579
6580 ext_phy_addr[port] = XGXS_EXT_PHY_ADDR(ext_phy_config);
6581
6582 /* Reset the phy */
6583 bnx2x_cl45_write(bp, port,
6584 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6585 ext_phy_addr[port],
6586 MDIO_PMA_DEVAD,
6587 MDIO_PMA_REG_CTRL,
6588 1<<15);
6589 }
6590
6591 /* Add delay of 150ms after reset */
6592 msleep(150);
6593
6594 /* PART2 - Download firmware to both phys */
6595 for (i = 0, port = first_port; i < PORT_MAX; i++, port = !port) {
6596 u16 fw_ver1;
6597
6598 bnx2x_bcm8727_external_rom_boot(bp, port,
6599 ext_phy_addr[port], shmem_base);
6600
6601 bnx2x_cl45_read(bp, port, PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6602 ext_phy_addr[port],
6603 MDIO_PMA_DEVAD,
6604 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
6605 if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
6606 DP(NETIF_MSG_LINK,
6607 "bnx2x_8727_common_init_phy port %x:"
6608 "Download failed. fw version = 0x%x\n",
6609 port, fw_ver1);
6610 return -EINVAL;
6611 }
6612 }
6613
6614 return 0;
6615 }
6616
6617
6618 static u8 bnx2x_8726_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6619 {
6620 u8 ext_phy_addr;
6621 u32 val;
6622 s8 port;
6623
6624 /* Use port1 because of the static port-swap */
6625 /* Enable the module detection interrupt */
6626 val = REG_RD(bp, MISC_REG_GPIO_EVENT_EN);
6627 val |= ((1<<MISC_REGISTERS_GPIO_3)|
6628 (1<<(MISC_REGISTERS_GPIO_3 + MISC_REGISTERS_GPIO_PORT_SHIFT)));
6629 REG_WR(bp, MISC_REG_GPIO_EVENT_EN, val);
6630
6631 bnx2x_ext_phy_hw_reset(bp, 1);
6632 msleep(5);
6633 for (port = 0; port < PORT_MAX; port++) {
6634 /* Extract the ext phy address for the port */
6635 u32 ext_phy_config = REG_RD(bp, shmem_base +
6636 offsetof(struct shmem_region,
6637 dev_info.port_hw_config[port].external_phy_config));
6638
6639 ext_phy_addr = XGXS_EXT_PHY_ADDR(ext_phy_config);
6640 DP(NETIF_MSG_LINK, "8726_common_init : ext_phy_addr = 0x%x\n",
6641 ext_phy_addr);
6642
6643 bnx2x_8726_reset_phy(bp, port, ext_phy_addr);
6644
6645 /* Set fault module detected LED on */
6646 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
6647 MISC_REGISTERS_GPIO_HIGH,
6648 port);
6649 }
6650
6651 return 0;
6652 }
6653
6654
6655 static u8 bnx2x_84823_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6656 {
6657 /* HW reset */
6658 bnx2x_ext_phy_hw_reset(bp, 1);
6659 return 0;
6660 }
6661 u8 bnx2x_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6662 {
6663 u8 rc = 0;
6664 u32 ext_phy_type;
6665
6666 DP(NETIF_MSG_LINK, "Begin common phy init\n");
6667
6668 /* Read the ext_phy_type for arbitrary port(0) */
6669 ext_phy_type = XGXS_EXT_PHY_TYPE(
6670 REG_RD(bp, shmem_base +
6671 offsetof(struct shmem_region,
6672 dev_info.port_hw_config[0].external_phy_config)));
6673
6674 switch (ext_phy_type) {
6675 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
6676 {
6677 rc = bnx2x_8073_common_init_phy(bp, shmem_base);
6678 break;
6679 }
6680
6681 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
6682 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC:
6683 rc = bnx2x_8727_common_init_phy(bp, shmem_base);
6684 break;
6685
6686 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
6687 /* GPIO1 affects both ports, so there's need to pull
6688 it for single port alone */
6689 rc = bnx2x_8726_common_init_phy(bp, shmem_base);
6690 break;
6691 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84823:
6692 rc = bnx2x_84823_common_init_phy(bp, shmem_base);
6693 break;
6694 default:
6695 DP(NETIF_MSG_LINK,
6696 "bnx2x_common_init_phy: ext_phy 0x%x not required\n",
6697 ext_phy_type);
6698 break;
6699 }
6700
6701 return rc;
6702 }
6703
6704 void bnx2x_sfx7101_sp_sw_reset(struct bnx2x *bp, u8 port, u8 phy_addr)
6705 {
6706 u16 val, cnt;
6707
6708 bnx2x_cl45_read(bp, port,
6709 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6710 phy_addr,
6711 MDIO_PMA_DEVAD,
6712 MDIO_PMA_REG_7101_RESET, &val);
6713
6714 for (cnt = 0; cnt < 10; cnt++) {
6715 msleep(50);
6716 /* Writes a self-clearing reset */
6717 bnx2x_cl45_write(bp, port,
6718 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6719 phy_addr,
6720 MDIO_PMA_DEVAD,
6721 MDIO_PMA_REG_7101_RESET,
6722 (val | (1<<15)));
6723 /* Wait for clear */
6724 bnx2x_cl45_read(bp, port,
6725 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6726 phy_addr,
6727 MDIO_PMA_DEVAD,
6728 MDIO_PMA_REG_7101_RESET, &val);
6729
6730 if ((val & (1<<15)) == 0)
6731 break;
6732 }
6733 }
AMDTP streaming driver for the Linux FireWire stack (Juju)