blob: e32d3370862e75bdbeff078b3e1a18e57ee14979 [file] [log] [blame]
Eilon Greensteind05c26c2009-01-17 23:26:13 -08001/* Copyright 2008-2009 Broadcom Corporation
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002 *
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#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/pci.h>
20#include <linux/netdevice.h>
21#include <linux/delay.h>
22#include <linux/ethtool.h>
23#include <linux/mutex.h>
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070024
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070025#include "bnx2x.h"
26
27/********************************************************/
Eilon Greenstein3196a882008-08-13 15:58:49 -070028#define ETH_HLEN 14
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070029#define ETH_OVREHEAD (ETH_HLEN + 8)/* 8 for CRC + VLAN*/
30#define ETH_MIN_PACKET_SIZE 60
31#define ETH_MAX_PACKET_SIZE 1500
32#define ETH_MAX_JUMBO_PACKET_SIZE 9600
33#define MDIO_ACCESS_TIMEOUT 1000
34#define BMAC_CONTROL_RX_ENABLE 2
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070035
36/***********************************************************/
Eilon Greenstein3196a882008-08-13 15:58:49 -070037/* Shortcut definitions */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070038/***********************************************************/
39
Eilon Greenstein2f904462009-08-12 08:22:16 +000040#define NIG_LATCH_BC_ENABLE_MI_INT 0
41
42#define NIG_STATUS_EMAC0_MI_INT \
43 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_EMAC0_MISC_MI_INT
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070044#define NIG_STATUS_XGXS0_LINK10G \
45 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK10G
46#define NIG_STATUS_XGXS0_LINK_STATUS \
47 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS
48#define NIG_STATUS_XGXS0_LINK_STATUS_SIZE \
49 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_XGXS0_LINK_STATUS_SIZE
50#define NIG_STATUS_SERDES0_LINK_STATUS \
51 NIG_STATUS_INTERRUPT_PORT0_REG_STATUS_SERDES0_LINK_STATUS
52#define NIG_MASK_MI_INT \
53 NIG_MASK_INTERRUPT_PORT0_REG_MASK_EMAC0_MISC_MI_INT
54#define NIG_MASK_XGXS0_LINK10G \
55 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK10G
56#define NIG_MASK_XGXS0_LINK_STATUS \
57 NIG_MASK_INTERRUPT_PORT0_REG_MASK_XGXS0_LINK_STATUS
58#define NIG_MASK_SERDES0_LINK_STATUS \
59 NIG_MASK_INTERRUPT_PORT0_REG_MASK_SERDES0_LINK_STATUS
60
61#define MDIO_AN_CL73_OR_37_COMPLETE \
62 (MDIO_GP_STATUS_TOP_AN_STATUS1_CL73_AUTONEG_COMPLETE | \
63 MDIO_GP_STATUS_TOP_AN_STATUS1_CL37_AUTONEG_COMPLETE)
64
65#define XGXS_RESET_BITS \
66 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_RSTB_HW | \
67 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_IDDQ | \
68 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN | \
69 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_PWRDWN_SD | \
70 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_XGXS0_TXD_FIFO_RSTB)
71
72#define SERDES_RESET_BITS \
73 (MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_RSTB_HW | \
74 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_IDDQ | \
75 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN | \
76 MISC_REGISTERS_RESET_REG_3_MISC_NIG_MUX_SERDES0_PWRDWN_SD)
77
78#define AUTONEG_CL37 SHARED_HW_CFG_AN_ENABLE_CL37
79#define AUTONEG_CL73 SHARED_HW_CFG_AN_ENABLE_CL73
Eilon Greenstein3196a882008-08-13 15:58:49 -070080#define AUTONEG_BAM SHARED_HW_CFG_AN_ENABLE_BAM
81#define AUTONEG_PARALLEL \
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070082 SHARED_HW_CFG_AN_ENABLE_PARALLEL_DETECTION
Eilon Greenstein3196a882008-08-13 15:58:49 -070083#define AUTONEG_SGMII_FIBER_AUTODET \
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070084 SHARED_HW_CFG_AN_EN_SGMII_FIBER_AUTO_DETECT
Eilon Greenstein3196a882008-08-13 15:58:49 -070085#define AUTONEG_REMOTE_PHY SHARED_HW_CFG_AN_ENABLE_REMOTE_PHY
Yaniv Rosnerea4e0402008-06-23 20:27:26 -070086
87#define GP_STATUS_PAUSE_RSOLUTION_TXSIDE \
88 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_TXSIDE
89#define GP_STATUS_PAUSE_RSOLUTION_RXSIDE \
90 MDIO_GP_STATUS_TOP_AN_STATUS1_PAUSE_RSOLUTION_RXSIDE
91#define GP_STATUS_SPEED_MASK \
92 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_MASK
93#define GP_STATUS_10M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10M
94#define GP_STATUS_100M MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_100M
95#define GP_STATUS_1G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G
96#define GP_STATUS_2_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_2_5G
97#define GP_STATUS_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_5G
98#define GP_STATUS_6G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_6G
99#define GP_STATUS_10G_HIG \
100 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_HIG
101#define GP_STATUS_10G_CX4 \
102 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_CX4
103#define GP_STATUS_12G_HIG \
104 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12G_HIG
105#define GP_STATUS_12_5G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_12_5G
106#define GP_STATUS_13G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_13G
107#define GP_STATUS_15G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_15G
108#define GP_STATUS_16G MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_16G
109#define GP_STATUS_1G_KX MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_1G_KX
110#define GP_STATUS_10G_KX4 \
111 MDIO_GP_STATUS_TOP_AN_STATUS1_ACTUAL_SPEED_10G_KX4
112
113#define LINK_10THD LINK_STATUS_SPEED_AND_DUPLEX_10THD
114#define LINK_10TFD LINK_STATUS_SPEED_AND_DUPLEX_10TFD
115#define LINK_100TXHD LINK_STATUS_SPEED_AND_DUPLEX_100TXHD
116#define LINK_100T4 LINK_STATUS_SPEED_AND_DUPLEX_100T4
117#define LINK_100TXFD LINK_STATUS_SPEED_AND_DUPLEX_100TXFD
118#define LINK_1000THD LINK_STATUS_SPEED_AND_DUPLEX_1000THD
119#define LINK_1000TFD LINK_STATUS_SPEED_AND_DUPLEX_1000TFD
120#define LINK_1000XFD LINK_STATUS_SPEED_AND_DUPLEX_1000XFD
121#define LINK_2500THD LINK_STATUS_SPEED_AND_DUPLEX_2500THD
122#define LINK_2500TFD LINK_STATUS_SPEED_AND_DUPLEX_2500TFD
123#define LINK_2500XFD LINK_STATUS_SPEED_AND_DUPLEX_2500XFD
124#define LINK_10GTFD LINK_STATUS_SPEED_AND_DUPLEX_10GTFD
125#define LINK_10GXFD LINK_STATUS_SPEED_AND_DUPLEX_10GXFD
126#define LINK_12GTFD LINK_STATUS_SPEED_AND_DUPLEX_12GTFD
127#define LINK_12GXFD LINK_STATUS_SPEED_AND_DUPLEX_12GXFD
128#define LINK_12_5GTFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GTFD
129#define LINK_12_5GXFD LINK_STATUS_SPEED_AND_DUPLEX_12_5GXFD
130#define LINK_13GTFD LINK_STATUS_SPEED_AND_DUPLEX_13GTFD
131#define LINK_13GXFD LINK_STATUS_SPEED_AND_DUPLEX_13GXFD
132#define LINK_15GTFD LINK_STATUS_SPEED_AND_DUPLEX_15GTFD
133#define LINK_15GXFD LINK_STATUS_SPEED_AND_DUPLEX_15GXFD
134#define LINK_16GTFD LINK_STATUS_SPEED_AND_DUPLEX_16GTFD
135#define LINK_16GXFD LINK_STATUS_SPEED_AND_DUPLEX_16GXFD
136
137#define PHY_XGXS_FLAG 0x1
138#define PHY_SGMII_FLAG 0x2
139#define PHY_SERDES_FLAG 0x4
140
Eilon Greenstein589abe32009-02-12 08:36:55 +0000141/* */
142#define SFP_EEPROM_CON_TYPE_ADDR 0x2
143 #define SFP_EEPROM_CON_TYPE_VAL_LC 0x7
144 #define SFP_EEPROM_CON_TYPE_VAL_COPPER 0x21
145
Eilon Greenstein4d295db2009-07-21 05:47:47 +0000146
147#define SFP_EEPROM_COMP_CODE_ADDR 0x3
148 #define SFP_EEPROM_COMP_CODE_SR_MASK (1<<4)
149 #define SFP_EEPROM_COMP_CODE_LR_MASK (1<<5)
150 #define SFP_EEPROM_COMP_CODE_LRM_MASK (1<<6)
151
Eilon Greenstein589abe32009-02-12 08:36:55 +0000152#define SFP_EEPROM_FC_TX_TECH_ADDR 0x8
153 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE 0x4
154 #define SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE 0x8
Eilon Greenstein4d295db2009-07-21 05:47:47 +0000155
Eilon Greenstein589abe32009-02-12 08:36:55 +0000156#define SFP_EEPROM_OPTIONS_ADDR 0x40
157 #define SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK 0x1
158#define SFP_EEPROM_OPTIONS_SIZE 2
159
Eilon Greenstein4d295db2009-07-21 05:47:47 +0000160#define EDC_MODE_LINEAR 0x0022
161#define EDC_MODE_LIMITING 0x0044
162#define EDC_MODE_PASSIVE_DAC 0x0055
Eilon Greenstein589abe32009-02-12 08:36:55 +0000163
Eilon Greenstein4d295db2009-07-21 05:47:47 +0000164
165
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700166/**********************************************************/
167/* INTERFACE */
168/**********************************************************/
169#define CL45_WR_OVER_CL22(_bp, _port, _phy_addr, _bank, _addr, _val) \
170 bnx2x_cl45_write(_bp, _port, 0, _phy_addr, \
171 DEFAULT_PHY_DEV_ADDR, \
172 (_bank + (_addr & 0xf)), \
173 _val)
174
175#define CL45_RD_OVER_CL22(_bp, _port, _phy_addr, _bank, _addr, _val) \
176 bnx2x_cl45_read(_bp, _port, 0, _phy_addr, \
177 DEFAULT_PHY_DEV_ADDR, \
178 (_bank + (_addr & 0xf)), \
179 _val)
180
Eilon Greensteinc1b73992009-02-12 08:37:07 +0000181static void bnx2x_set_serdes_access(struct link_params *params)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700182{
183 struct bnx2x *bp = params->bp;
Eilon Greensteinc1b73992009-02-12 08:37:07 +0000184 u32 emac_base = (params->port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +0000185
Eilon Greensteinc1b73992009-02-12 08:37:07 +0000186 /* Set Clause 22 */
187 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + params->port*0x10, 1);
188 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245f8000);
189 udelay(500);
190 REG_WR(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM, 0x245d000f);
191 udelay(500);
192 /* Set Clause 45 */
193 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_ST + params->port*0x10, 0);
194}
195static void bnx2x_set_phy_mdio(struct link_params *params, u8 phy_flags)
196{
197 struct bnx2x *bp = params->bp;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +0000198
Eilon Greensteinc1b73992009-02-12 08:37:07 +0000199 if (phy_flags & PHY_XGXS_FLAG) {
200 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_ST +
201 params->port*0x18, 0);
202 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + params->port*0x18,
203 DEFAULT_PHY_DEV_ADDR);
204 } else {
205 bnx2x_set_serdes_access(params);
206
207 REG_WR(bp, NIG_REG_SERDES0_CTRL_MD_DEVAD +
208 params->port*0x10,
209 DEFAULT_PHY_DEV_ADDR);
210 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700211}
212
213static u32 bnx2x_bits_en(struct bnx2x *bp, u32 reg, u32 bits)
214{
215 u32 val = REG_RD(bp, reg);
216
217 val |= bits;
218 REG_WR(bp, reg, val);
219 return val;
220}
221
222static u32 bnx2x_bits_dis(struct bnx2x *bp, u32 reg, u32 bits)
223{
224 u32 val = REG_RD(bp, reg);
225
226 val &= ~bits;
227 REG_WR(bp, reg, val);
228 return val;
229}
230
231static void bnx2x_emac_init(struct link_params *params,
232 struct link_vars *vars)
233{
234 /* reset and unreset the emac core */
235 struct bnx2x *bp = params->bp;
236 u8 port = params->port;
237 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
238 u32 val;
239 u16 timeout;
240
241 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
242 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
243 udelay(5);
244 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
245 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
246
247 /* init emac - use read-modify-write */
248 /* self clear reset */
249 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
Eilon Greenstein3196a882008-08-13 15:58:49 -0700250 EMAC_WR(bp, EMAC_REG_EMAC_MODE, (val | EMAC_MODE_RESET));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700251
252 timeout = 200;
Eilon Greenstein3196a882008-08-13 15:58:49 -0700253 do {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700254 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
255 DP(NETIF_MSG_LINK, "EMAC reset reg is %u\n", val);
256 if (!timeout) {
257 DP(NETIF_MSG_LINK, "EMAC timeout!\n");
258 return;
259 }
260 timeout--;
Eilon Greenstein3196a882008-08-13 15:58:49 -0700261 } while (val & EMAC_MODE_RESET);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700262
263 /* Set mac address */
264 val = ((params->mac_addr[0] << 8) |
265 params->mac_addr[1]);
Eilon Greenstein3196a882008-08-13 15:58:49 -0700266 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH, val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700267
268 val = ((params->mac_addr[2] << 24) |
269 (params->mac_addr[3] << 16) |
270 (params->mac_addr[4] << 8) |
271 params->mac_addr[5]);
Eilon Greenstein3196a882008-08-13 15:58:49 -0700272 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + 4, val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700273}
274
275static u8 bnx2x_emac_enable(struct link_params *params,
276 struct link_vars *vars, u8 lb)
277{
278 struct bnx2x *bp = params->bp;
279 u8 port = params->port;
280 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
281 u32 val;
282
283 DP(NETIF_MSG_LINK, "enabling EMAC\n");
284
285 /* enable emac and not bmac */
286 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 1);
287
288 /* for paladium */
289 if (CHIP_REV_IS_EMUL(bp)) {
290 /* Use lane 1 (of lanes 0-3) */
291 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
292 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
293 port*4, 1);
294 }
295 /* for fpga */
296 else
297
298 if (CHIP_REV_IS_FPGA(bp)) {
299 /* Use lane 1 (of lanes 0-3) */
300 DP(NETIF_MSG_LINK, "bnx2x_emac_enable: Setting FPGA\n");
301
302 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
303 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4,
304 0);
305 } else
306 /* ASIC */
307 if (vars->phy_flags & PHY_XGXS_FLAG) {
308 u32 ser_lane = ((params->lane_config &
309 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
310 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
311
312 DP(NETIF_MSG_LINK, "XGXS\n");
313 /* select the master lanes (out of 0-3) */
314 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 +
315 port*4, ser_lane);
316 /* select XGXS */
317 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
318 port*4, 1);
319
320 } else { /* SerDes */
321 DP(NETIF_MSG_LINK, "SerDes\n");
322 /* select SerDes */
323 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL +
324 port*4, 0);
325 }
326
Eilon Greenstein811a2f22009-02-12 08:37:04 +0000327 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
328 EMAC_RX_MODE_RESET);
329 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
330 EMAC_TX_MODE_RESET);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700331
332 if (CHIP_REV_IS_SLOW(bp)) {
333 /* config GMII mode */
334 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
Eilon Greenstein3196a882008-08-13 15:58:49 -0700335 EMAC_WR(bp, EMAC_REG_EMAC_MODE,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700336 (val | EMAC_MODE_PORT_GMII));
337 } else { /* ASIC */
338 /* pause enable/disable */
339 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
340 EMAC_RX_MODE_FLOW_EN);
David S. Millerc0700f92008-12-16 23:53:20 -0800341 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700342 bnx2x_bits_en(bp, emac_base +
343 EMAC_REG_EMAC_RX_MODE,
344 EMAC_RX_MODE_FLOW_EN);
345
346 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700347 (EMAC_TX_MODE_EXT_PAUSE_EN |
348 EMAC_TX_MODE_FLOW_EN));
David S. Millerc0700f92008-12-16 23:53:20 -0800349 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700350 bnx2x_bits_en(bp, emac_base +
351 EMAC_REG_EMAC_TX_MODE,
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700352 (EMAC_TX_MODE_EXT_PAUSE_EN |
353 EMAC_TX_MODE_FLOW_EN));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700354 }
355
356 /* KEEP_VLAN_TAG, promiscuous */
357 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_RX_MODE);
358 val |= EMAC_RX_MODE_KEEP_VLAN_TAG | EMAC_RX_MODE_PROMISCUOUS;
Eilon Greenstein3196a882008-08-13 15:58:49 -0700359 EMAC_WR(bp, EMAC_REG_EMAC_RX_MODE, val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700360
361 /* Set Loopback */
362 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
363 if (lb)
364 val |= 0x810;
365 else
366 val &= ~0x810;
Eilon Greenstein3196a882008-08-13 15:58:49 -0700367 EMAC_WR(bp, EMAC_REG_EMAC_MODE, val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700368
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +0000369 /* enable emac */
370 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 1);
371
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700372 /* enable emac for jumbo packets */
Eilon Greenstein3196a882008-08-13 15:58:49 -0700373 EMAC_WR(bp, EMAC_REG_EMAC_RX_MTU_SIZE,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700374 (EMAC_RX_MTU_SIZE_JUMBO_ENA |
375 (ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD)));
376
377 /* strip CRC */
378 REG_WR(bp, NIG_REG_NIG_INGRESS_EMAC0_NO_CRC + port*4, 0x1);
379
380 /* disable the NIG in/out to the bmac */
381 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x0);
382 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, 0x0);
383 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x0);
384
385 /* enable the NIG in/out to the emac */
386 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x1);
387 val = 0;
David S. Millerc0700f92008-12-16 23:53:20 -0800388 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700389 val = 1;
390
391 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, val);
392 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x1);
393
394 if (CHIP_REV_IS_EMUL(bp)) {
395 /* take the BigMac out of reset */
396 REG_WR(bp,
397 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
398 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
399
400 /* enable access for bmac registers */
401 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
Eilon Greenstein6f654972009-08-12 08:23:51 +0000402 } else
403 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700404
405 vars->mac_type = MAC_TYPE_EMAC;
406 return 0;
407}
408
409
410
411static u8 bnx2x_bmac_enable(struct link_params *params, struct link_vars *vars,
412 u8 is_lb)
413{
414 struct bnx2x *bp = params->bp;
415 u8 port = params->port;
416 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
417 NIG_REG_INGRESS_BMAC0_MEM;
418 u32 wb_data[2];
419 u32 val;
420
421 DP(NETIF_MSG_LINK, "Enabling BigMAC\n");
422 /* reset and unreset the BigMac */
423 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
424 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
425 msleep(1);
426
427 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
428 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
429
430 /* enable access for bmac registers */
431 REG_WR(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
432
433 /* XGXS control */
434 wb_data[0] = 0x3c;
435 wb_data[1] = 0;
436 REG_WR_DMAE(bp, bmac_addr +
437 BIGMAC_REGISTER_BMAC_XGXS_CONTROL,
438 wb_data, 2);
439
440 /* tx MAC SA */
441 wb_data[0] = ((params->mac_addr[2] << 24) |
442 (params->mac_addr[3] << 16) |
443 (params->mac_addr[4] << 8) |
444 params->mac_addr[5]);
445 wb_data[1] = ((params->mac_addr[0] << 8) |
446 params->mac_addr[1]);
447 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_SOURCE_ADDR,
448 wb_data, 2);
449
450 /* tx control */
451 val = 0xc0;
David S. Millerc0700f92008-12-16 23:53:20 -0800452 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700453 val |= 0x800000;
454 wb_data[0] = val;
455 wb_data[1] = 0;
456 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_CONTROL,
457 wb_data, 2);
458
459 /* mac control */
460 val = 0x3;
461 if (is_lb) {
462 val |= 0x4;
463 DP(NETIF_MSG_LINK, "enable bmac loopback\n");
464 }
465 wb_data[0] = val;
466 wb_data[1] = 0;
467 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
468 wb_data, 2);
469
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700470 /* set rx mtu */
471 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
472 wb_data[1] = 0;
473 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_MAX_SIZE,
474 wb_data, 2);
475
476 /* rx control set to don't strip crc */
477 val = 0x14;
David S. Millerc0700f92008-12-16 23:53:20 -0800478 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700479 val |= 0x20;
480 wb_data[0] = val;
481 wb_data[1] = 0;
482 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_CONTROL,
483 wb_data, 2);
484
485 /* set tx mtu */
486 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
487 wb_data[1] = 0;
488 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_MAX_SIZE,
489 wb_data, 2);
490
491 /* set cnt max size */
492 wb_data[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
493 wb_data[1] = 0;
494 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_CNT_MAX_SIZE,
495 wb_data, 2);
496
497 /* configure safc */
498 wb_data[0] = 0x1000200;
499 wb_data[1] = 0;
500 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LLFC_MSG_FLDS,
501 wb_data, 2);
502 /* fix for emulation */
503 if (CHIP_REV_IS_EMUL(bp)) {
504 wb_data[0] = 0xf000;
505 wb_data[1] = 0;
506 REG_WR_DMAE(bp,
507 bmac_addr + BIGMAC_REGISTER_TX_PAUSE_THRESHOLD,
508 wb_data, 2);
509 }
510
511 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0x1);
512 REG_WR(bp, NIG_REG_XGXS_LANE_SEL_P0 + port*4, 0x0);
513 REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 0x0);
514 val = 0;
David S. Millerc0700f92008-12-16 23:53:20 -0800515 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700516 val = 1;
517 REG_WR(bp, NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, val);
518 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x0);
519 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0x0);
520 REG_WR(bp, NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, 0x0);
521 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0x1);
522 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0x1);
523
524 vars->mac_type = MAC_TYPE_BMAC;
525 return 0;
526}
527
528static void bnx2x_phy_deassert(struct link_params *params, u8 phy_flags)
529{
530 struct bnx2x *bp = params->bp;
531 u32 val;
532
533 if (phy_flags & PHY_XGXS_FLAG) {
534 DP(NETIF_MSG_LINK, "bnx2x_phy_deassert:XGXS\n");
535 val = XGXS_RESET_BITS;
536
537 } else { /* SerDes */
538 DP(NETIF_MSG_LINK, "bnx2x_phy_deassert:SerDes\n");
539 val = SERDES_RESET_BITS;
540 }
541
542 val = val << (params->port*16);
543
544 /* reset and unreset the SerDes/XGXS */
545 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
546 val);
547 udelay(500);
548 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET,
549 val);
Eilon Greensteinc1b73992009-02-12 08:37:07 +0000550 bnx2x_set_phy_mdio(params, phy_flags);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700551}
552
553void bnx2x_link_status_update(struct link_params *params,
554 struct link_vars *vars)
555{
556 struct bnx2x *bp = params->bp;
557 u8 link_10g;
558 u8 port = params->port;
559
560 if (params->switch_cfg == SWITCH_CFG_1G)
561 vars->phy_flags = PHY_SERDES_FLAG;
562 else
563 vars->phy_flags = PHY_XGXS_FLAG;
564 vars->link_status = REG_RD(bp, params->shmem_base +
565 offsetof(struct shmem_region,
566 port_mb[port].link_status));
567
568 vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
569
570 if (vars->link_up) {
571 DP(NETIF_MSG_LINK, "phy link up\n");
572
573 vars->phy_link_up = 1;
574 vars->duplex = DUPLEX_FULL;
575 switch (vars->link_status &
576 LINK_STATUS_SPEED_AND_DUPLEX_MASK) {
577 case LINK_10THD:
578 vars->duplex = DUPLEX_HALF;
579 /* fall thru */
580 case LINK_10TFD:
581 vars->line_speed = SPEED_10;
582 break;
583
584 case LINK_100TXHD:
585 vars->duplex = DUPLEX_HALF;
586 /* fall thru */
587 case LINK_100T4:
588 case LINK_100TXFD:
589 vars->line_speed = SPEED_100;
590 break;
591
592 case LINK_1000THD:
593 vars->duplex = DUPLEX_HALF;
594 /* fall thru */
595 case LINK_1000TFD:
596 vars->line_speed = SPEED_1000;
597 break;
598
599 case LINK_2500THD:
600 vars->duplex = DUPLEX_HALF;
601 /* fall thru */
602 case LINK_2500TFD:
603 vars->line_speed = SPEED_2500;
604 break;
605
606 case LINK_10GTFD:
607 vars->line_speed = SPEED_10000;
608 break;
609
610 case LINK_12GTFD:
611 vars->line_speed = SPEED_12000;
612 break;
613
614 case LINK_12_5GTFD:
615 vars->line_speed = SPEED_12500;
616 break;
617
618 case LINK_13GTFD:
619 vars->line_speed = SPEED_13000;
620 break;
621
622 case LINK_15GTFD:
623 vars->line_speed = SPEED_15000;
624 break;
625
626 case LINK_16GTFD:
627 vars->line_speed = SPEED_16000;
628 break;
629
630 default:
631 break;
632 }
633
634 if (vars->link_status & LINK_STATUS_TX_FLOW_CONTROL_ENABLED)
David S. Millerc0700f92008-12-16 23:53:20 -0800635 vars->flow_ctrl |= BNX2X_FLOW_CTRL_TX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700636 else
David S. Millerc0700f92008-12-16 23:53:20 -0800637 vars->flow_ctrl &= ~BNX2X_FLOW_CTRL_TX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700638
639 if (vars->link_status & LINK_STATUS_RX_FLOW_CONTROL_ENABLED)
David S. Millerc0700f92008-12-16 23:53:20 -0800640 vars->flow_ctrl |= BNX2X_FLOW_CTRL_RX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700641 else
David S. Millerc0700f92008-12-16 23:53:20 -0800642 vars->flow_ctrl &= ~BNX2X_FLOW_CTRL_RX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700643
644 if (vars->phy_flags & PHY_XGXS_FLAG) {
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700645 if (vars->line_speed &&
646 ((vars->line_speed == SPEED_10) ||
647 (vars->line_speed == SPEED_100))) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700648 vars->phy_flags |= PHY_SGMII_FLAG;
649 } else {
650 vars->phy_flags &= ~PHY_SGMII_FLAG;
651 }
652 }
653
654 /* anything 10 and over uses the bmac */
655 link_10g = ((vars->line_speed == SPEED_10000) ||
656 (vars->line_speed == SPEED_12000) ||
657 (vars->line_speed == SPEED_12500) ||
658 (vars->line_speed == SPEED_13000) ||
659 (vars->line_speed == SPEED_15000) ||
660 (vars->line_speed == SPEED_16000));
661 if (link_10g)
662 vars->mac_type = MAC_TYPE_BMAC;
663 else
664 vars->mac_type = MAC_TYPE_EMAC;
665
666 } else { /* link down */
667 DP(NETIF_MSG_LINK, "phy link down\n");
668
669 vars->phy_link_up = 0;
670
671 vars->line_speed = 0;
672 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -0800673 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700674
675 /* indicate no mac active */
676 vars->mac_type = MAC_TYPE_NONE;
677 }
678
679 DP(NETIF_MSG_LINK, "link_status 0x%x phy_link_up %x\n",
680 vars->link_status, vars->phy_link_up);
681 DP(NETIF_MSG_LINK, "line_speed %x duplex %x flow_ctrl 0x%x\n",
682 vars->line_speed, vars->duplex, vars->flow_ctrl);
683}
684
685static void bnx2x_update_mng(struct link_params *params, u32 link_status)
686{
687 struct bnx2x *bp = params->bp;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +0000688
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700689 REG_WR(bp, params->shmem_base +
690 offsetof(struct shmem_region,
691 port_mb[params->port].link_status),
692 link_status);
693}
694
695static void bnx2x_bmac_rx_disable(struct bnx2x *bp, u8 port)
696{
697 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
698 NIG_REG_INGRESS_BMAC0_MEM;
699 u32 wb_data[2];
Eilon Greenstein3196a882008-08-13 15:58:49 -0700700 u32 nig_bmac_enable = REG_RD(bp, NIG_REG_BMAC0_REGS_OUT_EN + port*4);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700701
702 /* Only if the bmac is out of reset */
703 if (REG_RD(bp, MISC_REG_RESET_REG_2) &
704 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port) &&
705 nig_bmac_enable) {
706
707 /* Clear Rx Enable bit in BMAC_CONTROL register */
708 REG_RD_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
709 wb_data, 2);
710 wb_data[0] &= ~BMAC_CONTROL_RX_ENABLE;
711 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
712 wb_data, 2);
713
714 msleep(1);
715 }
716}
717
718static u8 bnx2x_pbf_update(struct link_params *params, u32 flow_ctrl,
719 u32 line_speed)
720{
721 struct bnx2x *bp = params->bp;
722 u8 port = params->port;
723 u32 init_crd, crd;
724 u32 count = 1000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700725
726 /* disable port */
727 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x1);
728
729 /* wait for init credit */
730 init_crd = REG_RD(bp, PBF_REG_P0_INIT_CRD + port*4);
731 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
732 DP(NETIF_MSG_LINK, "init_crd 0x%x crd 0x%x\n", init_crd, crd);
733
734 while ((init_crd != crd) && count) {
735 msleep(5);
736
737 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
738 count--;
739 }
740 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
741 if (init_crd != crd) {
742 DP(NETIF_MSG_LINK, "BUG! init_crd 0x%x != crd 0x%x\n",
743 init_crd, crd);
744 return -EINVAL;
745 }
746
David S. Millerc0700f92008-12-16 23:53:20 -0800747 if (flow_ctrl & BNX2X_FLOW_CTRL_RX ||
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700748 line_speed == SPEED_10 ||
749 line_speed == SPEED_100 ||
750 line_speed == SPEED_1000 ||
751 line_speed == SPEED_2500) {
752 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 1);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700753 /* update threshold */
754 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, 0);
755 /* update init credit */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700756 init_crd = 778; /* (800-18-4) */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700757
758 } else {
759 u32 thresh = (ETH_MAX_JUMBO_PACKET_SIZE +
760 ETH_OVREHEAD)/16;
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -0700761 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700762 /* update threshold */
763 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, thresh);
764 /* update init credit */
765 switch (line_speed) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700766 case SPEED_10000:
767 init_crd = thresh + 553 - 22;
768 break;
769
770 case SPEED_12000:
771 init_crd = thresh + 664 - 22;
772 break;
773
774 case SPEED_13000:
775 init_crd = thresh + 742 - 22;
776 break;
777
778 case SPEED_16000:
779 init_crd = thresh + 778 - 22;
780 break;
781 default:
782 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
783 line_speed);
784 return -EINVAL;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700785 }
786 }
787 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, init_crd);
788 DP(NETIF_MSG_LINK, "PBF updated to speed %d credit %d\n",
789 line_speed, init_crd);
790
791 /* probe the credit changes */
792 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x1);
793 msleep(5);
794 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x0);
795
796 /* enable port */
797 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x0);
798 return 0;
799}
800
Eilon Greenstein589abe32009-02-12 08:36:55 +0000801static u32 bnx2x_get_emac_base(struct bnx2x *bp, u32 ext_phy_type, u8 port)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700802{
803 u32 emac_base;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +0000804
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700805 switch (ext_phy_type) {
806 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
Eilon Greenstein589abe32009-02-12 08:36:55 +0000807 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
Eilon Greenstein4d295db2009-07-21 05:47:47 +0000808 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
Eilon Greenstein589abe32009-02-12 08:36:55 +0000809 /* All MDC/MDIO is directed through single EMAC */
810 if (REG_RD(bp, NIG_REG_PORT_SWAP))
811 emac_base = GRCBASE_EMAC0;
812 else
813 emac_base = GRCBASE_EMAC1;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700814 break;
815 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
Eilon Greenstein6378c022008-08-13 15:59:25 -0700816 emac_base = (port) ? GRCBASE_EMAC0 : GRCBASE_EMAC1;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700817 break;
818 default:
Eilon Greenstein6378c022008-08-13 15:59:25 -0700819 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700820 break;
821 }
822 return emac_base;
823
824}
825
826u8 bnx2x_cl45_write(struct bnx2x *bp, u8 port, u32 ext_phy_type,
827 u8 phy_addr, u8 devad, u16 reg, u16 val)
828{
829 u32 tmp, saved_mode;
830 u8 i, rc = 0;
Eilon Greenstein589abe32009-02-12 08:36:55 +0000831 u32 mdio_ctrl = bnx2x_get_emac_base(bp, ext_phy_type, port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700832
833 /* set clause 45 mode, slow down the MDIO clock to 2.5MHz
834 * (a value of 49==0x31) and make sure that the AUTO poll is off
835 */
Eilon Greenstein589abe32009-02-12 08:36:55 +0000836
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700837 saved_mode = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
838 tmp = saved_mode & ~(EMAC_MDIO_MODE_AUTO_POLL |
839 EMAC_MDIO_MODE_CLOCK_CNT);
840 tmp |= (EMAC_MDIO_MODE_CLAUSE_45 |
841 (49 << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
842 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, tmp);
843 REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
844 udelay(40);
845
846 /* address */
847
848 tmp = ((phy_addr << 21) | (devad << 16) | reg |
849 EMAC_MDIO_COMM_COMMAND_ADDRESS |
850 EMAC_MDIO_COMM_START_BUSY);
851 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
852
853 for (i = 0; i < 50; i++) {
854 udelay(10);
855
856 tmp = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
857 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
858 udelay(5);
859 break;
860 }
861 }
862 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
863 DP(NETIF_MSG_LINK, "write phy register failed\n");
864 rc = -EFAULT;
865 } else {
866 /* data */
867 tmp = ((phy_addr << 21) | (devad << 16) | val |
868 EMAC_MDIO_COMM_COMMAND_WRITE_45 |
869 EMAC_MDIO_COMM_START_BUSY);
870 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, tmp);
871
872 for (i = 0; i < 50; i++) {
873 udelay(10);
874
875 tmp = REG_RD(bp, mdio_ctrl +
876 EMAC_REG_EMAC_MDIO_COMM);
877 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
878 udelay(5);
879 break;
880 }
881 }
882 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
883 DP(NETIF_MSG_LINK, "write phy register failed\n");
884 rc = -EFAULT;
885 }
886 }
887
888 /* Restore the saved mode */
889 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
890
891 return rc;
892}
893
894u8 bnx2x_cl45_read(struct bnx2x *bp, u8 port, u32 ext_phy_type,
895 u8 phy_addr, u8 devad, u16 reg, u16 *ret_val)
896{
897 u32 val, saved_mode;
898 u16 i;
899 u8 rc = 0;
900
Eilon Greenstein589abe32009-02-12 08:36:55 +0000901 u32 mdio_ctrl = bnx2x_get_emac_base(bp, ext_phy_type, port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700902 /* set clause 45 mode, slow down the MDIO clock to 2.5MHz
903 * (a value of 49==0x31) and make sure that the AUTO poll is off
904 */
Eilon Greenstein589abe32009-02-12 08:36:55 +0000905
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700906 saved_mode = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
907 val = saved_mode & ((EMAC_MDIO_MODE_AUTO_POLL |
908 EMAC_MDIO_MODE_CLOCK_CNT));
909 val |= (EMAC_MDIO_MODE_CLAUSE_45 |
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +0000910 (49L << EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -0700911 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, val);
912 REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE);
913 udelay(40);
914
915 /* address */
916 val = ((phy_addr << 21) | (devad << 16) | reg |
917 EMAC_MDIO_COMM_COMMAND_ADDRESS |
918 EMAC_MDIO_COMM_START_BUSY);
919 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
920
921 for (i = 0; i < 50; i++) {
922 udelay(10);
923
924 val = REG_RD(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM);
925 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
926 udelay(5);
927 break;
928 }
929 }
930 if (val & EMAC_MDIO_COMM_START_BUSY) {
931 DP(NETIF_MSG_LINK, "read phy register failed\n");
932
933 *ret_val = 0;
934 rc = -EFAULT;
935
936 } else {
937 /* data */
938 val = ((phy_addr << 21) | (devad << 16) |
939 EMAC_MDIO_COMM_COMMAND_READ_45 |
940 EMAC_MDIO_COMM_START_BUSY);
941 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_COMM, val);
942
943 for (i = 0; i < 50; i++) {
944 udelay(10);
945
946 val = REG_RD(bp, mdio_ctrl +
947 EMAC_REG_EMAC_MDIO_COMM);
948 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
949 *ret_val = (u16)(val & EMAC_MDIO_COMM_DATA);
950 break;
951 }
952 }
953 if (val & EMAC_MDIO_COMM_START_BUSY) {
954 DP(NETIF_MSG_LINK, "read phy register failed\n");
955
956 *ret_val = 0;
957 rc = -EFAULT;
958 }
959 }
960
961 /* Restore the saved mode */
962 REG_WR(bp, mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, saved_mode);
963
964 return rc;
965}
966
967static void bnx2x_set_aer_mmd(struct link_params *params,
968 struct link_vars *vars)
969{
970 struct bnx2x *bp = params->bp;
971 u32 ser_lane;
972 u16 offset;
973
974 ser_lane = ((params->lane_config &
975 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
976 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
977
978 offset = (vars->phy_flags & PHY_XGXS_FLAG) ?
979 (params->phy_addr + ser_lane) : 0;
980
981 CL45_WR_OVER_CL22(bp, params->port,
982 params->phy_addr,
983 MDIO_REG_BANK_AER_BLOCK,
984 MDIO_AER_BLOCK_AER_REG, 0x3800 + offset);
985}
986
987static void bnx2x_set_master_ln(struct link_params *params)
988{
989 struct bnx2x *bp = params->bp;
990 u16 new_master_ln, ser_lane;
991 ser_lane = ((params->lane_config &
992 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
993 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
994
995 /* set the master_ln for AN */
996 CL45_RD_OVER_CL22(bp, params->port,
997 params->phy_addr,
998 MDIO_REG_BANK_XGXS_BLOCK2,
999 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1000 &new_master_ln);
1001
1002 CL45_WR_OVER_CL22(bp, params->port,
1003 params->phy_addr,
1004 MDIO_REG_BANK_XGXS_BLOCK2 ,
1005 MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
1006 (new_master_ln | ser_lane));
1007}
1008
1009static u8 bnx2x_reset_unicore(struct link_params *params)
1010{
1011 struct bnx2x *bp = params->bp;
1012 u16 mii_control;
1013 u16 i;
1014
1015 CL45_RD_OVER_CL22(bp, params->port,
1016 params->phy_addr,
1017 MDIO_REG_BANK_COMBO_IEEE0,
1018 MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
1019
1020 /* reset the unicore */
1021 CL45_WR_OVER_CL22(bp, params->port,
1022 params->phy_addr,
1023 MDIO_REG_BANK_COMBO_IEEE0,
1024 MDIO_COMBO_IEEE0_MII_CONTROL,
1025 (mii_control |
1026 MDIO_COMBO_IEEO_MII_CONTROL_RESET));
Eilon Greenstein6f654972009-08-12 08:23:51 +00001027 if (params->switch_cfg == SWITCH_CFG_1G)
1028 bnx2x_set_serdes_access(params);
Eilon Greensteinc1b73992009-02-12 08:37:07 +00001029
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001030 /* wait for the reset to self clear */
1031 for (i = 0; i < MDIO_ACCESS_TIMEOUT; i++) {
1032 udelay(5);
1033
1034 /* the reset erased the previous bank value */
1035 CL45_RD_OVER_CL22(bp, params->port,
1036 params->phy_addr,
1037 MDIO_REG_BANK_COMBO_IEEE0,
1038 MDIO_COMBO_IEEE0_MII_CONTROL,
1039 &mii_control);
1040
1041 if (!(mii_control & MDIO_COMBO_IEEO_MII_CONTROL_RESET)) {
1042 udelay(5);
1043 return 0;
1044 }
1045 }
1046
1047 DP(NETIF_MSG_LINK, "BUG! XGXS is still in reset!\n");
1048 return -EINVAL;
1049
1050}
1051
1052static void bnx2x_set_swap_lanes(struct link_params *params)
1053{
1054 struct bnx2x *bp = params->bp;
1055 /* Each two bits represents a lane number:
1056 No swap is 0123 => 0x1b no need to enable the swap */
1057 u16 ser_lane, rx_lane_swap, tx_lane_swap;
1058
1059 ser_lane = ((params->lane_config &
1060 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
1061 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
1062 rx_lane_swap = ((params->lane_config &
1063 PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK) >>
1064 PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT);
1065 tx_lane_swap = ((params->lane_config &
1066 PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK) >>
1067 PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT);
1068
1069 if (rx_lane_swap != 0x1b) {
1070 CL45_WR_OVER_CL22(bp, params->port,
1071 params->phy_addr,
1072 MDIO_REG_BANK_XGXS_BLOCK2,
1073 MDIO_XGXS_BLOCK2_RX_LN_SWAP,
1074 (rx_lane_swap |
1075 MDIO_XGXS_BLOCK2_RX_LN_SWAP_ENABLE |
1076 MDIO_XGXS_BLOCK2_RX_LN_SWAP_FORCE_ENABLE));
1077 } else {
1078 CL45_WR_OVER_CL22(bp, params->port,
1079 params->phy_addr,
1080 MDIO_REG_BANK_XGXS_BLOCK2,
1081 MDIO_XGXS_BLOCK2_RX_LN_SWAP, 0);
1082 }
1083
1084 if (tx_lane_swap != 0x1b) {
1085 CL45_WR_OVER_CL22(bp, params->port,
1086 params->phy_addr,
1087 MDIO_REG_BANK_XGXS_BLOCK2,
1088 MDIO_XGXS_BLOCK2_TX_LN_SWAP,
1089 (tx_lane_swap |
1090 MDIO_XGXS_BLOCK2_TX_LN_SWAP_ENABLE));
1091 } else {
1092 CL45_WR_OVER_CL22(bp, params->port,
1093 params->phy_addr,
1094 MDIO_REG_BANK_XGXS_BLOCK2,
1095 MDIO_XGXS_BLOCK2_TX_LN_SWAP, 0);
1096 }
1097}
1098
1099static void bnx2x_set_parallel_detection(struct link_params *params,
Eilon Greenstein3196a882008-08-13 15:58:49 -07001100 u8 phy_flags)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001101{
1102 struct bnx2x *bp = params->bp;
1103 u16 control2;
1104
1105 CL45_RD_OVER_CL22(bp, params->port,
1106 params->phy_addr,
1107 MDIO_REG_BANK_SERDES_DIGITAL,
1108 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1109 &control2);
1110
1111
1112 control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
1113
1114
1115 CL45_WR_OVER_CL22(bp, params->port,
1116 params->phy_addr,
1117 MDIO_REG_BANK_SERDES_DIGITAL,
1118 MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
1119 control2);
1120
1121 if (phy_flags & PHY_XGXS_FLAG) {
1122 DP(NETIF_MSG_LINK, "XGXS\n");
1123
1124 CL45_WR_OVER_CL22(bp, params->port,
1125 params->phy_addr,
1126 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1127 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK,
1128 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK_CNT);
1129
1130 CL45_RD_OVER_CL22(bp, params->port,
1131 params->phy_addr,
1132 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1133 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1134 &control2);
1135
1136
1137 control2 |=
1138 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL_PARDET10G_EN;
1139
1140 CL45_WR_OVER_CL22(bp, params->port,
1141 params->phy_addr,
1142 MDIO_REG_BANK_10G_PARALLEL_DETECT,
1143 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
1144 control2);
1145
1146 /* Disable parallel detection of HiG */
1147 CL45_WR_OVER_CL22(bp, params->port,
1148 params->phy_addr,
1149 MDIO_REG_BANK_XGXS_BLOCK2,
1150 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G,
1151 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_CX4_XGXS |
1152 MDIO_XGXS_BLOCK2_UNICORE_MODE_10G_HIGIG_XGXS);
1153 }
1154}
1155
1156static void bnx2x_set_autoneg(struct link_params *params,
Eilon Greenstein239d6862009-08-12 08:23:04 +00001157 struct link_vars *vars,
1158 u8 enable_cl73)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001159{
1160 struct bnx2x *bp = params->bp;
1161 u16 reg_val;
1162
1163 /* CL37 Autoneg */
1164
1165 CL45_RD_OVER_CL22(bp, params->port,
1166 params->phy_addr,
1167 MDIO_REG_BANK_COMBO_IEEE0,
1168 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
1169
1170 /* CL37 Autoneg Enabled */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001171 if (vars->line_speed == SPEED_AUTO_NEG)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001172 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_AN_EN;
1173 else /* CL37 Autoneg Disabled */
1174 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1175 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN);
1176
1177 CL45_WR_OVER_CL22(bp, params->port,
1178 params->phy_addr,
1179 MDIO_REG_BANK_COMBO_IEEE0,
1180 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
1181
1182 /* Enable/Disable Autodetection */
1183
1184 CL45_RD_OVER_CL22(bp, params->port,
1185 params->phy_addr,
1186 MDIO_REG_BANK_SERDES_DIGITAL,
1187 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, &reg_val);
Eilon Greenstein239d6862009-08-12 08:23:04 +00001188 reg_val &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_SIGNAL_DETECT_EN |
1189 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT);
1190 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE;
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001191 if (vars->line_speed == SPEED_AUTO_NEG)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001192 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1193 else
1194 reg_val &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
1195
1196 CL45_WR_OVER_CL22(bp, params->port,
1197 params->phy_addr,
1198 MDIO_REG_BANK_SERDES_DIGITAL,
1199 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, reg_val);
1200
1201 /* Enable TetonII and BAM autoneg */
1202 CL45_RD_OVER_CL22(bp, params->port,
1203 params->phy_addr,
1204 MDIO_REG_BANK_BAM_NEXT_PAGE,
1205 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1206 &reg_val);
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001207 if (vars->line_speed == SPEED_AUTO_NEG) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001208 /* Enable BAM aneg Mode and TetonII aneg Mode */
1209 reg_val |= (MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1210 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1211 } else {
1212 /* TetonII and BAM Autoneg Disabled */
1213 reg_val &= ~(MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
1214 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
1215 }
1216 CL45_WR_OVER_CL22(bp, params->port,
1217 params->phy_addr,
1218 MDIO_REG_BANK_BAM_NEXT_PAGE,
1219 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
1220 reg_val);
1221
Eilon Greenstein239d6862009-08-12 08:23:04 +00001222 if (enable_cl73) {
1223 /* Enable Cl73 FSM status bits */
1224 CL45_WR_OVER_CL22(bp, params->port,
1225 params->phy_addr,
1226 MDIO_REG_BANK_CL73_USERB0,
1227 MDIO_CL73_USERB0_CL73_UCTRL,
1228 MDIO_CL73_USERB0_CL73_UCTRL_USTAT1_MUXSEL);
1229
1230 /* Enable BAM Station Manager*/
1231 CL45_WR_OVER_CL22(bp, params->port,
1232 params->phy_addr,
1233 MDIO_REG_BANK_CL73_USERB0,
1234 MDIO_CL73_USERB0_CL73_BAM_CTRL1,
1235 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_EN |
1236 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_STATION_MNGR_EN |
1237 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_NP_AFTER_BP_EN);
1238
1239 /* Merge CL73 and CL37 aneg resolution */
1240 CL45_RD_OVER_CL22(bp, params->port,
1241 params->phy_addr,
1242 MDIO_REG_BANK_CL73_USERB0,
1243 MDIO_CL73_USERB0_CL73_BAM_CTRL3,
1244 &reg_val);
1245
1246 if (params->speed_cap_mask &
1247 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
1248 /* Set the CL73 AN speed */
1249 CL45_RD_OVER_CL22(bp, params->port,
1250 params->phy_addr,
1251 MDIO_REG_BANK_CL73_IEEEB1,
1252 MDIO_CL73_IEEEB1_AN_ADV2,
1253 &reg_val);
1254
1255 CL45_WR_OVER_CL22(bp, params->port,
1256 params->phy_addr,
1257 MDIO_REG_BANK_CL73_IEEEB1,
1258 MDIO_CL73_IEEEB1_AN_ADV2,
1259 reg_val | MDIO_CL73_IEEEB1_AN_ADV2_ADVR_10G_KX4);
1260
1261 }
1262 /* CL73 Autoneg Enabled */
1263 reg_val = MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN;
1264
1265 } else /* CL73 Autoneg Disabled */
1266 reg_val = 0;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001267
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001268 CL45_WR_OVER_CL22(bp, params->port,
1269 params->phy_addr,
1270 MDIO_REG_BANK_CL73_IEEEB0,
1271 MDIO_CL73_IEEEB0_CL73_AN_CONTROL, reg_val);
1272}
1273
1274/* program SerDes, forced speed */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001275static void bnx2x_program_serdes(struct link_params *params,
1276 struct link_vars *vars)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001277{
1278 struct bnx2x *bp = params->bp;
1279 u16 reg_val;
1280
Eilon Greenstein57937202009-08-12 08:23:53 +00001281 /* program duplex, disable autoneg and sgmii*/
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001282 CL45_RD_OVER_CL22(bp, params->port,
1283 params->phy_addr,
1284 MDIO_REG_BANK_COMBO_IEEE0,
1285 MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
1286 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX |
Eilon Greenstein57937202009-08-12 08:23:53 +00001287 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1288 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001289 if (params->req_duplex == DUPLEX_FULL)
1290 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
1291 CL45_WR_OVER_CL22(bp, params->port,
1292 params->phy_addr,
1293 MDIO_REG_BANK_COMBO_IEEE0,
1294 MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
1295
1296 /* program speed
1297 - needed only if the speed is greater than 1G (2.5G or 10G) */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001298 CL45_RD_OVER_CL22(bp, params->port,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001299 params->phy_addr,
1300 MDIO_REG_BANK_SERDES_DIGITAL,
1301 MDIO_SERDES_DIGITAL_MISC1, &reg_val);
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001302 /* clearing the speed value before setting the right speed */
1303 DP(NETIF_MSG_LINK, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x\n", reg_val);
1304
1305 reg_val &= ~(MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK |
1306 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
1307
1308 if (!((vars->line_speed == SPEED_1000) ||
1309 (vars->line_speed == SPEED_100) ||
1310 (vars->line_speed == SPEED_10))) {
1311
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001312 reg_val |= (MDIO_SERDES_DIGITAL_MISC1_REFCLK_SEL_156_25M |
1313 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001314 if (vars->line_speed == SPEED_10000)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001315 reg_val |=
1316 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_10G_CX4;
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001317 if (vars->line_speed == SPEED_13000)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001318 reg_val |=
1319 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_13G;
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001320 }
1321
1322 CL45_WR_OVER_CL22(bp, params->port,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001323 params->phy_addr,
1324 MDIO_REG_BANK_SERDES_DIGITAL,
1325 MDIO_SERDES_DIGITAL_MISC1, reg_val);
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001326
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001327}
1328
1329static void bnx2x_set_brcm_cl37_advertisment(struct link_params *params)
1330{
1331 struct bnx2x *bp = params->bp;
1332 u16 val = 0;
1333
1334 /* configure the 48 bits for BAM AN */
1335
1336 /* set extended capabilities */
1337 if (params->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G)
1338 val |= MDIO_OVER_1G_UP1_2_5G;
1339 if (params->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
1340 val |= MDIO_OVER_1G_UP1_10G;
1341 CL45_WR_OVER_CL22(bp, params->port,
1342 params->phy_addr,
1343 MDIO_REG_BANK_OVER_1G,
1344 MDIO_OVER_1G_UP1, val);
1345
1346 CL45_WR_OVER_CL22(bp, params->port,
1347 params->phy_addr,
1348 MDIO_REG_BANK_OVER_1G,
Eilon Greenstein239d6862009-08-12 08:23:04 +00001349 MDIO_OVER_1G_UP3, 0x400);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001350}
1351
Eilon Greenstein1ef70b92009-08-12 08:23:59 +00001352static void bnx2x_calc_ieee_aneg_adv(struct link_params *params, u16 *ieee_fc)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001353{
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001354 *ieee_fc = MDIO_COMBO_IEEE0_AUTO_NEG_ADV_FULL_DUPLEX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001355 /* resolve pause mode and advertisement
1356 * Please refer to Table 28B-3 of the 802.3ab-1999 spec */
1357
1358 switch (params->req_flow_ctrl) {
David S. Millerc0700f92008-12-16 23:53:20 -08001359 case BNX2X_FLOW_CTRL_AUTO:
1360 if (params->req_fc_auto_adv == BNX2X_FLOW_CTRL_BOTH) {
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001361 *ieee_fc |=
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001362 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
1363 } else {
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001364 *ieee_fc |=
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001365 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
1366 }
1367 break;
David S. Millerc0700f92008-12-16 23:53:20 -08001368 case BNX2X_FLOW_CTRL_TX:
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001369 *ieee_fc |=
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001370 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
1371 break;
1372
David S. Millerc0700f92008-12-16 23:53:20 -08001373 case BNX2X_FLOW_CTRL_RX:
1374 case BNX2X_FLOW_CTRL_BOTH:
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001375 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001376 break;
1377
David S. Millerc0700f92008-12-16 23:53:20 -08001378 case BNX2X_FLOW_CTRL_NONE:
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001379 default:
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001380 *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001381 break;
1382 }
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001383}
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001384
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001385static void bnx2x_set_ieee_aneg_advertisment(struct link_params *params,
Eilon Greenstein1ef70b92009-08-12 08:23:59 +00001386 u16 ieee_fc)
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001387{
1388 struct bnx2x *bp = params->bp;
1389 /* for AN, we are always publishing full duplex */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001390
1391 CL45_WR_OVER_CL22(bp, params->port,
1392 params->phy_addr,
1393 MDIO_REG_BANK_COMBO_IEEE0,
Eilon Greenstein1ef70b92009-08-12 08:23:59 +00001394 MDIO_COMBO_IEEE0_AUTO_NEG_ADV, ieee_fc);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001395}
1396
Eilon Greenstein239d6862009-08-12 08:23:04 +00001397static void bnx2x_restart_autoneg(struct link_params *params, u8 enable_cl73)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001398{
1399 struct bnx2x *bp = params->bp;
Eilon Greenstein3a36f2e2009-02-12 08:37:09 +00001400 u16 mii_control;
Eilon Greenstein239d6862009-08-12 08:23:04 +00001401
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001402 DP(NETIF_MSG_LINK, "bnx2x_restart_autoneg\n");
Eilon Greenstein3a36f2e2009-02-12 08:37:09 +00001403 /* Enable and restart BAM/CL37 aneg */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001404
Eilon Greenstein239d6862009-08-12 08:23:04 +00001405 if (enable_cl73) {
1406 CL45_RD_OVER_CL22(bp, params->port,
1407 params->phy_addr,
1408 MDIO_REG_BANK_CL73_IEEEB0,
1409 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1410 &mii_control);
1411
1412 CL45_WR_OVER_CL22(bp, params->port,
1413 params->phy_addr,
1414 MDIO_REG_BANK_CL73_IEEEB0,
1415 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1416 (mii_control |
1417 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN |
1418 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_RESTART_AN));
1419 } else {
1420
1421 CL45_RD_OVER_CL22(bp, params->port,
1422 params->phy_addr,
1423 MDIO_REG_BANK_COMBO_IEEE0,
1424 MDIO_COMBO_IEEE0_MII_CONTROL,
1425 &mii_control);
1426 DP(NETIF_MSG_LINK,
1427 "bnx2x_restart_autoneg mii_control before = 0x%x\n",
1428 mii_control);
1429 CL45_WR_OVER_CL22(bp, params->port,
1430 params->phy_addr,
1431 MDIO_REG_BANK_COMBO_IEEE0,
1432 MDIO_COMBO_IEEE0_MII_CONTROL,
1433 (mii_control |
1434 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1435 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN));
1436 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001437}
1438
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001439static void bnx2x_initialize_sgmii_process(struct link_params *params,
1440 struct link_vars *vars)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001441{
1442 struct bnx2x *bp = params->bp;
1443 u16 control1;
1444
1445 /* in SGMII mode, the unicore is always slave */
1446
1447 CL45_RD_OVER_CL22(bp, params->port,
1448 params->phy_addr,
1449 MDIO_REG_BANK_SERDES_DIGITAL,
1450 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
1451 &control1);
1452 control1 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT;
1453 /* set sgmii mode (and not fiber) */
1454 control1 &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE |
1455 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET |
1456 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_MSTR_MODE);
1457 CL45_WR_OVER_CL22(bp, params->port,
1458 params->phy_addr,
1459 MDIO_REG_BANK_SERDES_DIGITAL,
1460 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
1461 control1);
1462
1463 /* if forced speed */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001464 if (!(vars->line_speed == SPEED_AUTO_NEG)) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001465 /* set speed, disable autoneg */
1466 u16 mii_control;
1467
1468 CL45_RD_OVER_CL22(bp, params->port,
1469 params->phy_addr,
1470 MDIO_REG_BANK_COMBO_IEEE0,
1471 MDIO_COMBO_IEEE0_MII_CONTROL,
1472 &mii_control);
1473 mii_control &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
1474 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK|
1475 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX);
1476
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001477 switch (vars->line_speed) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001478 case SPEED_100:
1479 mii_control |=
1480 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_100;
1481 break;
1482 case SPEED_1000:
1483 mii_control |=
1484 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_1000;
1485 break;
1486 case SPEED_10:
1487 /* there is nothing to set for 10M */
1488 break;
1489 default:
1490 /* invalid speed for SGMII */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001491 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n",
1492 vars->line_speed);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001493 break;
1494 }
1495
1496 /* setting the full duplex */
1497 if (params->req_duplex == DUPLEX_FULL)
1498 mii_control |=
1499 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
1500 CL45_WR_OVER_CL22(bp, params->port,
1501 params->phy_addr,
1502 MDIO_REG_BANK_COMBO_IEEE0,
1503 MDIO_COMBO_IEEE0_MII_CONTROL,
1504 mii_control);
1505
1506 } else { /* AN mode */
1507 /* enable and restart AN */
Eilon Greenstein239d6862009-08-12 08:23:04 +00001508 bnx2x_restart_autoneg(params, 0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001509 }
1510}
1511
1512
1513/*
1514 * link management
1515 */
1516
1517static void bnx2x_pause_resolve(struct link_vars *vars, u32 pause_result)
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001518{ /* LD LP */
1519 switch (pause_result) { /* ASYM P ASYM P */
1520 case 0xb: /* 1 0 1 1 */
David S. Millerc0700f92008-12-16 23:53:20 -08001521 vars->flow_ctrl = BNX2X_FLOW_CTRL_TX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001522 break;
1523
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001524 case 0xe: /* 1 1 1 0 */
David S. Millerc0700f92008-12-16 23:53:20 -08001525 vars->flow_ctrl = BNX2X_FLOW_CTRL_RX;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001526 break;
1527
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001528 case 0x5: /* 0 1 0 1 */
1529 case 0x7: /* 0 1 1 1 */
1530 case 0xd: /* 1 1 0 1 */
1531 case 0xf: /* 1 1 1 1 */
David S. Millerc0700f92008-12-16 23:53:20 -08001532 vars->flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001533 break;
1534
1535 default:
1536 break;
1537 }
1538}
1539
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00001540static u8 bnx2x_ext_phy_resolve_fc(struct link_params *params,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001541 struct link_vars *vars)
1542{
1543 struct bnx2x *bp = params->bp;
1544 u8 ext_phy_addr;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00001545 u16 ld_pause; /* local */
1546 u16 lp_pause; /* link partner */
1547 u16 an_complete; /* AN complete */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001548 u16 pause_result;
1549 u8 ret = 0;
1550 u32 ext_phy_type;
1551 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00001552 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001553 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
1554 /* read twice */
1555
1556 bnx2x_cl45_read(bp, port,
1557 ext_phy_type,
1558 ext_phy_addr,
1559 MDIO_AN_DEVAD,
1560 MDIO_AN_REG_STATUS, &an_complete);
1561 bnx2x_cl45_read(bp, port,
1562 ext_phy_type,
1563 ext_phy_addr,
1564 MDIO_AN_DEVAD,
1565 MDIO_AN_REG_STATUS, &an_complete);
1566
1567 if (an_complete & MDIO_AN_REG_STATUS_AN_COMPLETE) {
1568 ret = 1;
1569 bnx2x_cl45_read(bp, port,
1570 ext_phy_type,
1571 ext_phy_addr,
1572 MDIO_AN_DEVAD,
1573 MDIO_AN_REG_ADV_PAUSE, &ld_pause);
1574 bnx2x_cl45_read(bp, port,
1575 ext_phy_type,
1576 ext_phy_addr,
1577 MDIO_AN_DEVAD,
1578 MDIO_AN_REG_LP_AUTO_NEG, &lp_pause);
1579 pause_result = (ld_pause &
1580 MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
1581 pause_result |= (lp_pause &
1582 MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
1583 DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x \n",
1584 pause_result);
1585 bnx2x_pause_resolve(vars, pause_result);
David S. Millerc0700f92008-12-16 23:53:20 -08001586 if (vars->flow_ctrl == BNX2X_FLOW_CTRL_NONE &&
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001587 ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
1588 bnx2x_cl45_read(bp, port,
1589 ext_phy_type,
1590 ext_phy_addr,
1591 MDIO_AN_DEVAD,
1592 MDIO_AN_REG_CL37_FC_LD, &ld_pause);
1593
1594 bnx2x_cl45_read(bp, port,
1595 ext_phy_type,
1596 ext_phy_addr,
1597 MDIO_AN_DEVAD,
1598 MDIO_AN_REG_CL37_FC_LP, &lp_pause);
1599 pause_result = (ld_pause &
1600 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 5;
1601 pause_result |= (lp_pause &
1602 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
1603
1604 bnx2x_pause_resolve(vars, pause_result);
1605 DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x \n",
1606 pause_result);
1607 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001608 }
1609 return ret;
1610}
1611
1612
1613static void bnx2x_flow_ctrl_resolve(struct link_params *params,
1614 struct link_vars *vars,
1615 u32 gp_status)
1616{
1617 struct bnx2x *bp = params->bp;
Eilon Greenstein3196a882008-08-13 15:58:49 -07001618 u16 ld_pause; /* local driver */
1619 u16 lp_pause; /* link partner */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001620 u16 pause_result;
1621
David S. Millerc0700f92008-12-16 23:53:20 -08001622 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001623
1624 /* resolve from gp_status in case of AN complete and not sgmii */
David S. Millerc0700f92008-12-16 23:53:20 -08001625 if ((params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001626 (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) &&
1627 (!(vars->phy_flags & PHY_SGMII_FLAG)) &&
1628 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1629 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)) {
1630 CL45_RD_OVER_CL22(bp, params->port,
1631 params->phy_addr,
1632 MDIO_REG_BANK_COMBO_IEEE0,
1633 MDIO_COMBO_IEEE0_AUTO_NEG_ADV,
1634 &ld_pause);
1635 CL45_RD_OVER_CL22(bp, params->port,
1636 params->phy_addr,
1637 MDIO_REG_BANK_COMBO_IEEE0,
1638 MDIO_COMBO_IEEE0_AUTO_NEG_LINK_PARTNER_ABILITY1,
1639 &lp_pause);
1640 pause_result = (ld_pause &
1641 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>5;
1642 pause_result |= (lp_pause &
1643 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>7;
1644 DP(NETIF_MSG_LINK, "pause_result 0x%x\n", pause_result);
1645 bnx2x_pause_resolve(vars, pause_result);
David S. Millerc0700f92008-12-16 23:53:20 -08001646 } else if ((params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00001647 (bnx2x_ext_phy_resolve_fc(params, vars))) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001648 return;
1649 } else {
David S. Millerc0700f92008-12-16 23:53:20 -08001650 if (params->req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO)
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001651 vars->flow_ctrl = params->req_fc_auto_adv;
1652 else
1653 vars->flow_ctrl = params->req_flow_ctrl;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001654 }
1655 DP(NETIF_MSG_LINK, "flow_ctrl 0x%x\n", vars->flow_ctrl);
1656}
1657
Eilon Greenstein239d6862009-08-12 08:23:04 +00001658static void bnx2x_check_fallback_to_cl37(struct link_params *params)
1659{
1660 struct bnx2x *bp = params->bp;
1661 u16 rx_status, ustat_val, cl37_fsm_recieved;
1662 DP(NETIF_MSG_LINK, "bnx2x_check_fallback_to_cl37\n");
1663 /* Step 1: Make sure signal is detected */
1664 CL45_RD_OVER_CL22(bp, params->port,
1665 params->phy_addr,
1666 MDIO_REG_BANK_RX0,
1667 MDIO_RX0_RX_STATUS,
1668 &rx_status);
1669 if ((rx_status & MDIO_RX0_RX_STATUS_SIGDET) !=
1670 (MDIO_RX0_RX_STATUS_SIGDET)) {
1671 DP(NETIF_MSG_LINK, "Signal is not detected. Restoring CL73."
1672 "rx_status(0x80b0) = 0x%x\n", rx_status);
1673 CL45_WR_OVER_CL22(bp, params->port,
1674 params->phy_addr,
1675 MDIO_REG_BANK_CL73_IEEEB0,
1676 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1677 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN);
1678 return;
1679 }
1680 /* Step 2: Check CL73 state machine */
1681 CL45_RD_OVER_CL22(bp, params->port,
1682 params->phy_addr,
1683 MDIO_REG_BANK_CL73_USERB0,
1684 MDIO_CL73_USERB0_CL73_USTAT1,
1685 &ustat_val);
1686 if ((ustat_val &
1687 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
1688 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) !=
1689 (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
1690 MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) {
1691 DP(NETIF_MSG_LINK, "CL73 state-machine is not stable. "
1692 "ustat_val(0x8371) = 0x%x\n", ustat_val);
1693 return;
1694 }
1695 /* Step 3: Check CL37 Message Pages received to indicate LP
1696 supports only CL37 */
1697 CL45_RD_OVER_CL22(bp, params->port,
1698 params->phy_addr,
1699 MDIO_REG_BANK_REMOTE_PHY,
1700 MDIO_REMOTE_PHY_MISC_RX_STATUS,
1701 &cl37_fsm_recieved);
1702 if ((cl37_fsm_recieved &
1703 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
1704 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) !=
1705 (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
1706 MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) {
1707 DP(NETIF_MSG_LINK, "No CL37 FSM were received. "
1708 "misc_rx_status(0x8330) = 0x%x\n",
1709 cl37_fsm_recieved);
1710 return;
1711 }
1712 /* The combined cl37/cl73 fsm state information indicating that we are
1713 connected to a device which does not support cl73, but does support
1714 cl37 BAM. In this case we disable cl73 and restart cl37 auto-neg */
1715 /* Disable CL73 */
1716 CL45_WR_OVER_CL22(bp, params->port,
1717 params->phy_addr,
1718 MDIO_REG_BANK_CL73_IEEEB0,
1719 MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
1720 0);
1721 /* Restart CL37 autoneg */
1722 bnx2x_restart_autoneg(params, 0);
1723 DP(NETIF_MSG_LINK, "Disabling CL73, and restarting CL37 autoneg\n");
1724}
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001725static u8 bnx2x_link_settings_status(struct link_params *params,
Eilon Greenstein2f904462009-08-12 08:22:16 +00001726 struct link_vars *vars,
1727 u32 gp_status,
1728 u8 ext_phy_link_up)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001729{
1730 struct bnx2x *bp = params->bp;
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001731 u16 new_line_speed;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001732 u8 rc = 0;
1733 vars->link_status = 0;
1734
1735 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) {
1736 DP(NETIF_MSG_LINK, "phy link up gp_status=0x%x\n",
1737 gp_status);
1738
1739 vars->phy_link_up = 1;
1740 vars->link_status |= LINK_STATUS_LINK_UP;
1741
1742 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_DUPLEX_STATUS)
1743 vars->duplex = DUPLEX_FULL;
1744 else
1745 vars->duplex = DUPLEX_HALF;
1746
1747 bnx2x_flow_ctrl_resolve(params, vars, gp_status);
1748
1749 switch (gp_status & GP_STATUS_SPEED_MASK) {
1750 case GP_STATUS_10M:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001751 new_line_speed = SPEED_10;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001752 if (vars->duplex == DUPLEX_FULL)
1753 vars->link_status |= LINK_10TFD;
1754 else
1755 vars->link_status |= LINK_10THD;
1756 break;
1757
1758 case GP_STATUS_100M:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001759 new_line_speed = SPEED_100;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001760 if (vars->duplex == DUPLEX_FULL)
1761 vars->link_status |= LINK_100TXFD;
1762 else
1763 vars->link_status |= LINK_100TXHD;
1764 break;
1765
1766 case GP_STATUS_1G:
1767 case GP_STATUS_1G_KX:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001768 new_line_speed = SPEED_1000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001769 if (vars->duplex == DUPLEX_FULL)
1770 vars->link_status |= LINK_1000TFD;
1771 else
1772 vars->link_status |= LINK_1000THD;
1773 break;
1774
1775 case GP_STATUS_2_5G:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001776 new_line_speed = SPEED_2500;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001777 if (vars->duplex == DUPLEX_FULL)
1778 vars->link_status |= LINK_2500TFD;
1779 else
1780 vars->link_status |= LINK_2500THD;
1781 break;
1782
1783 case GP_STATUS_5G:
1784 case GP_STATUS_6G:
1785 DP(NETIF_MSG_LINK,
1786 "link speed unsupported gp_status 0x%x\n",
1787 gp_status);
1788 return -EINVAL;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00001789
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001790 case GP_STATUS_10G_KX4:
1791 case GP_STATUS_10G_HIG:
1792 case GP_STATUS_10G_CX4:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001793 new_line_speed = SPEED_10000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001794 vars->link_status |= LINK_10GTFD;
1795 break;
1796
1797 case GP_STATUS_12G_HIG:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001798 new_line_speed = SPEED_12000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001799 vars->link_status |= LINK_12GTFD;
1800 break;
1801
1802 case GP_STATUS_12_5G:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001803 new_line_speed = SPEED_12500;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001804 vars->link_status |= LINK_12_5GTFD;
1805 break;
1806
1807 case GP_STATUS_13G:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001808 new_line_speed = SPEED_13000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001809 vars->link_status |= LINK_13GTFD;
1810 break;
1811
1812 case GP_STATUS_15G:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001813 new_line_speed = SPEED_15000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001814 vars->link_status |= LINK_15GTFD;
1815 break;
1816
1817 case GP_STATUS_16G:
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001818 new_line_speed = SPEED_16000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001819 vars->link_status |= LINK_16GTFD;
1820 break;
1821
1822 default:
1823 DP(NETIF_MSG_LINK,
1824 "link speed unsupported gp_status 0x%x\n",
1825 gp_status);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00001826 return -EINVAL;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001827 }
1828
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001829 /* Upon link speed change set the NIG into drain mode.
1830 Comes to deals with possible FIFO glitch due to clk change
1831 when speed is decreased without link down indicator */
1832 if (new_line_speed != vars->line_speed) {
Eilon Greenstein2f904462009-08-12 08:22:16 +00001833 if (XGXS_EXT_PHY_TYPE(params->ext_phy_config) !=
1834 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT &&
1835 ext_phy_link_up) {
1836 DP(NETIF_MSG_LINK, "Internal link speed %d is"
1837 " different than the external"
1838 " link speed %d\n", new_line_speed,
1839 vars->line_speed);
1840 vars->phy_link_up = 0;
1841 return 0;
1842 }
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00001843 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
1844 + params->port*4, 0);
1845 msleep(1);
1846 }
1847 vars->line_speed = new_line_speed;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001848 vars->link_status |= LINK_STATUS_SERDES_LINK;
1849
Yaniv Rosner57963ed2008-08-13 15:55:28 -07001850 if ((params->req_line_speed == SPEED_AUTO_NEG) &&
1851 ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1852 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) ||
1853 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
Eilon Greenstein589abe32009-02-12 08:36:55 +00001854 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
1855 (XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
Eilon Greenstein2f904462009-08-12 08:22:16 +00001856 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726))) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001857 vars->autoneg = AUTO_NEG_ENABLED;
1858
1859 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) {
1860 vars->autoneg |= AUTO_NEG_COMPLETE;
1861 vars->link_status |=
1862 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
1863 }
1864
1865 vars->autoneg |= AUTO_NEG_PARALLEL_DETECTION_USED;
1866 vars->link_status |=
1867 LINK_STATUS_PARALLEL_DETECTION_USED;
1868
1869 }
David S. Millerc0700f92008-12-16 23:53:20 -08001870 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001871 vars->link_status |=
1872 LINK_STATUS_TX_FLOW_CONTROL_ENABLED;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001873
David S. Millerc0700f92008-12-16 23:53:20 -08001874 if (vars->flow_ctrl & BNX2X_FLOW_CTRL_RX)
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07001875 vars->link_status |=
1876 LINK_STATUS_RX_FLOW_CONTROL_ENABLED;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001877
1878 } else { /* link_down */
1879 DP(NETIF_MSG_LINK, "phy link down\n");
1880
1881 vars->phy_link_up = 0;
Yaniv Rosner57963ed2008-08-13 15:55:28 -07001882
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001883 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08001884 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001885 vars->autoneg = AUTO_NEG_DISABLED;
1886 vars->mac_type = MAC_TYPE_NONE;
Eilon Greenstein239d6862009-08-12 08:23:04 +00001887
1888 if ((params->req_line_speed == SPEED_AUTO_NEG) &&
1889 ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
1890 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT))) {
1891 /* Check signal is detected */
1892 bnx2x_check_fallback_to_cl37(params);
1893 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001894 }
1895
1896 DP(NETIF_MSG_LINK, "gp_status 0x%x phy_link_up %x line_speed %x \n",
1897 gp_status, vars->phy_link_up, vars->line_speed);
1898 DP(NETIF_MSG_LINK, "duplex %x flow_ctrl 0x%x"
1899 " autoneg 0x%x\n",
1900 vars->duplex,
1901 vars->flow_ctrl, vars->autoneg);
1902 DP(NETIF_MSG_LINK, "link_status 0x%x\n", vars->link_status);
1903
1904 return rc;
1905}
1906
Eilon Greensteined8680a2009-02-12 08:37:12 +00001907static void bnx2x_set_gmii_tx_driver(struct link_params *params)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001908{
1909 struct bnx2x *bp = params->bp;
1910 u16 lp_up2;
1911 u16 tx_driver;
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00001912 u16 bank;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001913
1914 /* read precomp */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001915 CL45_RD_OVER_CL22(bp, params->port,
1916 params->phy_addr,
1917 MDIO_REG_BANK_OVER_1G,
1918 MDIO_OVER_1G_LP_UP2, &lp_up2);
1919
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001920 /* bits [10:7] at lp_up2, positioned at [15:12] */
1921 lp_up2 = (((lp_up2 & MDIO_OVER_1G_LP_UP2_PREEMPHASIS_MASK) >>
1922 MDIO_OVER_1G_LP_UP2_PREEMPHASIS_SHIFT) <<
1923 MDIO_TX0_TX_DRIVER_PREEMPHASIS_SHIFT);
1924
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00001925 if (lp_up2 == 0)
1926 return;
1927
1928 for (bank = MDIO_REG_BANK_TX0; bank <= MDIO_REG_BANK_TX3;
1929 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0)) {
1930 CL45_RD_OVER_CL22(bp, params->port,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001931 params->phy_addr,
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00001932 bank,
1933 MDIO_TX0_TX_DRIVER, &tx_driver);
1934
1935 /* replace tx_driver bits [15:12] */
1936 if (lp_up2 !=
1937 (tx_driver & MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK)) {
1938 tx_driver &= ~MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK;
1939 tx_driver |= lp_up2;
1940 CL45_WR_OVER_CL22(bp, params->port,
1941 params->phy_addr,
1942 bank,
1943 MDIO_TX0_TX_DRIVER, tx_driver);
1944 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001945 }
1946}
1947
1948static u8 bnx2x_emac_program(struct link_params *params,
1949 u32 line_speed, u32 duplex)
1950{
1951 struct bnx2x *bp = params->bp;
1952 u8 port = params->port;
1953 u16 mode = 0;
1954
1955 DP(NETIF_MSG_LINK, "setting link speed & duplex\n");
1956 bnx2x_bits_dis(bp, GRCBASE_EMAC0 + port*0x400 +
1957 EMAC_REG_EMAC_MODE,
1958 (EMAC_MODE_25G_MODE |
1959 EMAC_MODE_PORT_MII_10M |
1960 EMAC_MODE_HALF_DUPLEX));
1961 switch (line_speed) {
1962 case SPEED_10:
1963 mode |= EMAC_MODE_PORT_MII_10M;
1964 break;
1965
1966 case SPEED_100:
1967 mode |= EMAC_MODE_PORT_MII;
1968 break;
1969
1970 case SPEED_1000:
1971 mode |= EMAC_MODE_PORT_GMII;
1972 break;
1973
1974 case SPEED_2500:
1975 mode |= (EMAC_MODE_25G_MODE | EMAC_MODE_PORT_GMII);
1976 break;
1977
1978 default:
1979 /* 10G not valid for EMAC */
1980 DP(NETIF_MSG_LINK, "Invalid line_speed 0x%x\n", line_speed);
1981 return -EINVAL;
1982 }
1983
1984 if (duplex == DUPLEX_HALF)
1985 mode |= EMAC_MODE_HALF_DUPLEX;
1986 bnx2x_bits_en(bp,
1987 GRCBASE_EMAC0 + port*0x400 + EMAC_REG_EMAC_MODE,
1988 mode);
1989
1990 bnx2x_set_led(bp, params->port, LED_MODE_OPER,
1991 line_speed, params->hw_led_mode, params->chip_id);
1992 return 0;
1993}
1994
1995/*****************************************************************************/
Eilon Greenstein17de50b2008-08-13 15:56:59 -07001996/* External Phy section */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001997/*****************************************************************************/
Eilon Greensteinf57a6022009-08-12 08:23:11 +00001998void bnx2x_ext_phy_hw_reset(struct bnx2x *bp, u8 port)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07001999{
2000 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002001 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002002 msleep(1);
2003 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002004 MISC_REGISTERS_GPIO_OUTPUT_HIGH, port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002005}
2006
2007static void bnx2x_ext_phy_reset(struct link_params *params,
2008 struct link_vars *vars)
2009{
2010 struct bnx2x *bp = params->bp;
2011 u32 ext_phy_type;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002012 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
2013
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002014 DP(NETIF_MSG_LINK, "Port %x: bnx2x_ext_phy_reset\n", params->port);
2015 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2016 /* The PHY reset is controled by GPIO 1
2017 * Give it 1ms of reset pulse
2018 */
2019 if (vars->phy_flags & PHY_XGXS_FLAG) {
2020
2021 switch (ext_phy_type) {
2022 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
2023 DP(NETIF_MSG_LINK, "XGXS Direct\n");
2024 break;
2025
2026 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
2027 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
2028 DP(NETIF_MSG_LINK, "XGXS 8705/8706\n");
2029
2030 /* Restore normal power mode*/
2031 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002032 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2033 params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002034
2035 /* HW reset */
Eilon Greensteinf57a6022009-08-12 08:23:11 +00002036 bnx2x_ext_phy_hw_reset(bp, params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002037
2038 bnx2x_cl45_write(bp, params->port,
2039 ext_phy_type,
2040 ext_phy_addr,
2041 MDIO_PMA_DEVAD,
2042 MDIO_PMA_REG_CTRL, 0xa040);
2043 break;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002044
2045 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
2046 break;
2047
Eilon Greenstein589abe32009-02-12 08:36:55 +00002048 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
2049
2050 /* Restore normal power mode*/
2051 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2052 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2053 params->port);
2054
2055 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2056 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2057 params->port);
2058
2059 bnx2x_cl45_write(bp, params->port,
2060 ext_phy_type,
2061 ext_phy_addr,
2062 MDIO_PMA_DEVAD,
2063 MDIO_PMA_REG_CTRL,
2064 1<<15);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002065 break;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002066
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002067 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002068 DP(NETIF_MSG_LINK, "XGXS 8072\n");
2069
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002070 /* Unset Low Power Mode and SW reset */
2071 /* Restore normal power mode*/
2072 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002073 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2074 params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002075
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002076 bnx2x_cl45_write(bp, params->port,
2077 ext_phy_type,
2078 ext_phy_addr,
2079 MDIO_PMA_DEVAD,
2080 MDIO_PMA_REG_CTRL,
2081 1<<15);
2082 break;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002083
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002084 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002085 DP(NETIF_MSG_LINK, "XGXS 8073\n");
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002086
2087 /* Restore normal power mode*/
2088 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002089 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2090 params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002091
2092 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002093 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2094 params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002095 break;
2096
2097 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
2098 DP(NETIF_MSG_LINK, "XGXS SFX7101\n");
2099
2100 /* Restore normal power mode*/
2101 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07002102 MISC_REGISTERS_GPIO_OUTPUT_HIGH,
2103 params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002104
2105 /* HW reset */
Eilon Greensteinf57a6022009-08-12 08:23:11 +00002106 bnx2x_ext_phy_hw_reset(bp, params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002107 break;
2108
Eilon Greenstein28577182009-02-12 08:37:00 +00002109 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
Eilon Greenstein28577182009-02-12 08:37:00 +00002110 /* 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 */
Eilon Greensteinf57a6022009-08-12 08:23:11 +00002116 bnx2x_ext_phy_hw_reset(bp, params->port);
Eilon Greenstein28577182009-02-12 08:37:00 +00002117
2118 bnx2x_cl45_write(bp, params->port,
2119 ext_phy_type,
2120 ext_phy_addr,
2121 MDIO_PMA_DEVAD,
2122 MDIO_PMA_REG_CTRL,
2123 1<<15);
2124 break;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002125 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
2126 DP(NETIF_MSG_LINK, "XGXS PHY Failure detected\n");
2127 break;
2128
2129 default:
2130 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
2131 params->ext_phy_config);
2132 break;
2133 }
2134
2135 } else { /* SerDes */
2136 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
2137 switch (ext_phy_type) {
2138 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
2139 DP(NETIF_MSG_LINK, "SerDes Direct\n");
2140 break;
2141
2142 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
2143 DP(NETIF_MSG_LINK, "SerDes 5482\n");
Eilon Greensteinf57a6022009-08-12 08:23:11 +00002144 bnx2x_ext_phy_hw_reset(bp, params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002145 break;
2146
2147 default:
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002148 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002149 params->ext_phy_config);
2150 break;
2151 }
2152 }
2153}
2154
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002155static void bnx2x_save_spirom_version(struct bnx2x *bp, u8 port,
2156 u32 shmem_base, u32 spirom_ver)
2157{
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002158 DP(NETIF_MSG_LINK, "FW version 0x%x:0x%x for port %d\n",
2159 (u16)(spirom_ver>>16), (u16)spirom_ver, port);
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002160 REG_WR(bp, shmem_base +
2161 offsetof(struct shmem_region,
2162 port_mb[port].ext_phy_fw_version),
2163 spirom_ver);
2164}
2165
2166static void bnx2x_save_bcm_spirom_ver(struct bnx2x *bp, u8 port,
2167 u32 ext_phy_type, u8 ext_phy_addr,
2168 u32 shmem_base)
2169{
2170 u16 fw_ver1, fw_ver2;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002171
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002172 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr, MDIO_PMA_DEVAD,
2173 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
2174 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr, MDIO_PMA_DEVAD,
2175 MDIO_PMA_REG_ROM_VER2, &fw_ver2);
2176 bnx2x_save_spirom_version(bp, port, shmem_base,
2177 (u32)(fw_ver1<<16 | fw_ver2));
2178}
2179
Eilon Greensteinb1607af2009-08-12 08:22:54 +00002180
2181static void bnx2x_save_8481_spirom_version(struct bnx2x *bp, u8 port,
2182 u8 ext_phy_addr, u32 shmem_base)
2183{
2184 u16 val, fw_ver1, fw_ver2, cnt;
2185 /* For the 32 bits registers in 8481, access via MDIO2ARM interface.*/
2186 /* (1) set register 0xc200_0014(SPI_BRIDGE_CTRL_2) to 0x03000000 */
2187 bnx2x_cl45_write(bp, port,
2188 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2189 ext_phy_addr, MDIO_PMA_DEVAD,
2190 0xA819, 0x0014);
2191 bnx2x_cl45_write(bp, port,
2192 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2193 ext_phy_addr,
2194 MDIO_PMA_DEVAD,
2195 0xA81A,
2196 0xc200);
2197 bnx2x_cl45_write(bp, port,
2198 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2199 ext_phy_addr,
2200 MDIO_PMA_DEVAD,
2201 0xA81B,
2202 0x0000);
2203 bnx2x_cl45_write(bp, port,
2204 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2205 ext_phy_addr,
2206 MDIO_PMA_DEVAD,
2207 0xA81C,
2208 0x0300);
2209 bnx2x_cl45_write(bp, port,
2210 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2211 ext_phy_addr,
2212 MDIO_PMA_DEVAD,
2213 0xA817,
2214 0x0009);
2215
2216 for (cnt = 0; cnt < 100; cnt++) {
2217 bnx2x_cl45_read(bp, port,
2218 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2219 ext_phy_addr,
2220 MDIO_PMA_DEVAD,
2221 0xA818,
2222 &val);
2223 if (val & 1)
2224 break;
2225 udelay(5);
2226 }
2227 if (cnt == 100) {
2228 DP(NETIF_MSG_LINK, "Unable to read 8481 phy fw version(1)\n");
2229 bnx2x_save_spirom_version(bp, port,
2230 shmem_base, 0);
2231 return;
2232 }
2233
2234
2235 /* 2) read register 0xc200_0000 (SPI_FW_STATUS) */
2236 bnx2x_cl45_write(bp, port,
2237 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2238 ext_phy_addr, MDIO_PMA_DEVAD,
2239 0xA819, 0x0000);
2240 bnx2x_cl45_write(bp, port,
2241 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2242 ext_phy_addr, MDIO_PMA_DEVAD,
2243 0xA81A, 0xc200);
2244 bnx2x_cl45_write(bp, port,
2245 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2246 ext_phy_addr, MDIO_PMA_DEVAD,
2247 0xA817, 0x000A);
2248 for (cnt = 0; cnt < 100; cnt++) {
2249 bnx2x_cl45_read(bp, port,
2250 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2251 ext_phy_addr,
2252 MDIO_PMA_DEVAD,
2253 0xA818,
2254 &val);
2255 if (val & 1)
2256 break;
2257 udelay(5);
2258 }
2259 if (cnt == 100) {
2260 DP(NETIF_MSG_LINK, "Unable to read 8481 phy fw version(2)\n");
2261 bnx2x_save_spirom_version(bp, port,
2262 shmem_base, 0);
2263 return;
2264 }
2265
2266 /* lower 16 bits of the register SPI_FW_STATUS */
2267 bnx2x_cl45_read(bp, port,
2268 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2269 ext_phy_addr,
2270 MDIO_PMA_DEVAD,
2271 0xA81B,
2272 &fw_ver1);
2273 /* upper 16 bits of register SPI_FW_STATUS */
2274 bnx2x_cl45_read(bp, port,
2275 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481,
2276 ext_phy_addr,
2277 MDIO_PMA_DEVAD,
2278 0xA81C,
2279 &fw_ver2);
2280
2281 bnx2x_save_spirom_version(bp, port,
2282 shmem_base, (fw_ver2<<16) | fw_ver1);
2283}
2284
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002285static void bnx2x_bcm8072_external_rom_boot(struct link_params *params)
2286{
2287 struct bnx2x *bp = params->bp;
2288 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002289 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002290 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002291
2292 /* Need to wait 200ms after reset */
2293 msleep(200);
2294 /* Boot port from external ROM
2295 * Set ser_boot_ctl bit in the MISC_CTRL1 register
2296 */
2297 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2298 MDIO_PMA_DEVAD,
2299 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2300
2301 /* Reset internal microprocessor */
2302 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2303 MDIO_PMA_DEVAD,
2304 MDIO_PMA_REG_GEN_CTRL,
2305 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2306 /* set micro reset = 0 */
2307 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2308 MDIO_PMA_DEVAD,
2309 MDIO_PMA_REG_GEN_CTRL,
2310 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2311 /* Reset internal microprocessor */
2312 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2313 MDIO_PMA_DEVAD,
2314 MDIO_PMA_REG_GEN_CTRL,
2315 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2316 /* wait for 100ms for code download via SPI port */
2317 msleep(100);
2318
2319 /* Clear ser_boot_ctl bit */
2320 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2321 MDIO_PMA_DEVAD,
2322 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2323 /* Wait 100ms */
2324 msleep(100);
2325
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002326 bnx2x_save_bcm_spirom_ver(bp, port,
2327 ext_phy_type,
2328 ext_phy_addr,
2329 params->shmem_base);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002330}
2331
2332static u8 bnx2x_8073_is_snr_needed(struct link_params *params)
2333{
2334 /* This is only required for 8073A1, version 102 only */
2335
2336 struct bnx2x *bp = params->bp;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002337 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002338 u16 val;
2339
2340 /* Read 8073 HW revision*/
2341 bnx2x_cl45_read(bp, params->port,
2342 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2343 ext_phy_addr,
2344 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00002345 MDIO_PMA_REG_8073_CHIP_REV, &val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002346
2347 if (val != 1) {
2348 /* No need to workaround in 8073 A1 */
2349 return 0;
2350 }
2351
2352 bnx2x_cl45_read(bp, params->port,
2353 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2354 ext_phy_addr,
2355 MDIO_PMA_DEVAD,
2356 MDIO_PMA_REG_ROM_VER2, &val);
2357
2358 /* SNR should be applied only for version 0x102 */
2359 if (val != 0x102)
2360 return 0;
2361
2362 return 1;
2363}
2364
2365static u8 bnx2x_bcm8073_xaui_wa(struct link_params *params)
2366{
2367 struct bnx2x *bp = params->bp;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002368 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002369 u16 val, cnt, cnt1 ;
2370
2371 bnx2x_cl45_read(bp, params->port,
2372 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2373 ext_phy_addr,
2374 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00002375 MDIO_PMA_REG_8073_CHIP_REV, &val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002376
2377 if (val > 0) {
2378 /* No need to workaround in 8073 A1 */
2379 return 0;
2380 }
2381 /* XAUI workaround in 8073 A0: */
2382
2383 /* After loading the boot ROM and restarting Autoneg,
2384 poll Dev1, Reg $C820: */
2385
2386 for (cnt = 0; cnt < 1000; cnt++) {
2387 bnx2x_cl45_read(bp, params->port,
2388 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2389 ext_phy_addr,
2390 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00002391 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
2392 &val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002393 /* If bit [14] = 0 or bit [13] = 0, continue on with
2394 system initialization (XAUI work-around not required,
2395 as these bits indicate 2.5G or 1G link up). */
2396 if (!(val & (1<<14)) || !(val & (1<<13))) {
2397 DP(NETIF_MSG_LINK, "XAUI work-around not required\n");
2398 return 0;
2399 } else if (!(val & (1<<15))) {
2400 DP(NETIF_MSG_LINK, "clc bit 15 went off\n");
2401 /* If bit 15 is 0, then poll Dev1, Reg $C841 until
2402 it's MSB (bit 15) goes to 1 (indicating that the
2403 XAUI workaround has completed),
2404 then continue on with system initialization.*/
2405 for (cnt1 = 0; cnt1 < 1000; cnt1++) {
2406 bnx2x_cl45_read(bp, params->port,
2407 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2408 ext_phy_addr,
2409 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00002410 MDIO_PMA_REG_8073_XAUI_WA, &val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002411 if (val & (1<<15)) {
2412 DP(NETIF_MSG_LINK,
2413 "XAUI workaround has completed\n");
2414 return 0;
2415 }
2416 msleep(3);
2417 }
2418 break;
2419 }
2420 msleep(3);
2421 }
2422 DP(NETIF_MSG_LINK, "Warning: XAUI work-around timeout !!!\n");
2423 return -EINVAL;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002424}
2425
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002426static void bnx2x_bcm8073_bcm8727_external_rom_boot(struct bnx2x *bp, u8 port,
2427 u8 ext_phy_addr,
2428 u32 ext_phy_type,
2429 u32 shmem_base)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002430{
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002431 /* Boot port from external ROM */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002432 /* EDC grst */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002433 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002434 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002435 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002436 MDIO_PMA_DEVAD,
2437 MDIO_PMA_REG_GEN_CTRL,
2438 0x0001);
2439
2440 /* ucode reboot and rst */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002441 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002442 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002443 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002444 MDIO_PMA_DEVAD,
2445 MDIO_PMA_REG_GEN_CTRL,
2446 0x008c);
2447
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002448 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002449 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002450 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002451 MDIO_PMA_DEVAD,
2452 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2453
2454 /* Reset internal microprocessor */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002455 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002456 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002457 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002458 MDIO_PMA_DEVAD,
2459 MDIO_PMA_REG_GEN_CTRL,
2460 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2461
2462 /* Release srst bit */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002463 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002464 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002465 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002466 MDIO_PMA_DEVAD,
2467 MDIO_PMA_REG_GEN_CTRL,
2468 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2469
2470 /* wait for 100ms for code download via SPI port */
2471 msleep(100);
2472
2473 /* Clear ser_boot_ctl bit */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002474 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002475 ext_phy_type,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07002476 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002477 MDIO_PMA_DEVAD,
2478 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2479
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002480 bnx2x_save_bcm_spirom_ver(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002481 ext_phy_type,
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002482 ext_phy_addr,
2483 shmem_base);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07002484}
2485
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002486static void bnx2x_bcm8073_external_rom_boot(struct bnx2x *bp, u8 port,
2487 u8 ext_phy_addr,
2488 u32 shmem_base)
2489{
2490 bnx2x_bcm8073_bcm8727_external_rom_boot(bp, port, ext_phy_addr,
2491 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
2492 shmem_base);
2493}
2494
2495static void bnx2x_bcm8727_external_rom_boot(struct bnx2x *bp, u8 port,
2496 u8 ext_phy_addr,
2497 u32 shmem_base)
2498{
2499 bnx2x_bcm8073_bcm8727_external_rom_boot(bp, port, ext_phy_addr,
2500 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
2501 shmem_base);
2502
2503}
2504
Eilon Greenstein589abe32009-02-12 08:36:55 +00002505static void bnx2x_bcm8726_external_rom_boot(struct link_params *params)
2506{
2507 struct bnx2x *bp = params->bp;
2508 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002509 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002510 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2511
2512 /* Need to wait 100ms after reset */
2513 msleep(100);
2514
2515 /* Set serial boot control for external load */
2516 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2517 MDIO_PMA_DEVAD,
2518 MDIO_PMA_REG_MISC_CTRL1, 0x0001);
2519
2520 /* Micro controller re-boot */
2521 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2522 MDIO_PMA_DEVAD,
2523 MDIO_PMA_REG_GEN_CTRL,
2524 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2525
2526 /* Set soft reset */
2527 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2528 MDIO_PMA_DEVAD,
2529 MDIO_PMA_REG_GEN_CTRL,
2530 MDIO_PMA_REG_GEN_CTRL_ROM_MICRO_RESET);
2531
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002532 /* Set PLL register value to be same like in P13 ver */
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002533 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2534 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002535 MDIO_PMA_REG_PLL_CTRL,
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002536 0x73A0);
2537
Eilon Greenstein589abe32009-02-12 08:36:55 +00002538 /* Clear soft reset.
2539 Will automatically reset micro-controller re-boot */
2540 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2541 MDIO_PMA_DEVAD,
2542 MDIO_PMA_REG_GEN_CTRL,
2543 MDIO_PMA_REG_GEN_CTRL_ROM_RESET_INTERNAL_MP);
2544
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002545 /* wait for 150ms for microcode load */
2546 msleep(150);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002547
2548 /* Disable serial boot control, tristates pins SS_N, SCK, MOSI, MISO */
2549 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
2550 MDIO_PMA_DEVAD,
2551 MDIO_PMA_REG_MISC_CTRL1, 0x0000);
2552
2553 msleep(200);
Eilon Greensteina35da8d2009-02-12 08:37:02 +00002554 bnx2x_save_bcm_spirom_ver(bp, port,
2555 ext_phy_type,
2556 ext_phy_addr,
2557 params->shmem_base);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002558}
2559
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002560static void bnx2x_sfp_set_transmitter(struct bnx2x *bp, u8 port,
2561 u32 ext_phy_type, u8 ext_phy_addr,
2562 u8 tx_en)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002563{
2564 u16 val;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002565
Eilon Greenstein589abe32009-02-12 08:36:55 +00002566 DP(NETIF_MSG_LINK, "Setting transmitter tx_en=%x for port %x\n",
2567 tx_en, port);
2568 /* Disable/Enable transmitter ( TX laser of the SFP+ module.)*/
2569 bnx2x_cl45_read(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002570 ext_phy_type,
Eilon Greenstein589abe32009-02-12 08:36:55 +00002571 ext_phy_addr,
2572 MDIO_PMA_DEVAD,
2573 MDIO_PMA_REG_PHY_IDENTIFIER,
2574 &val);
2575
2576 if (tx_en)
2577 val &= ~(1<<15);
2578 else
2579 val |= (1<<15);
2580
2581 bnx2x_cl45_write(bp, port,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002582 ext_phy_type,
Eilon Greenstein589abe32009-02-12 08:36:55 +00002583 ext_phy_addr,
2584 MDIO_PMA_DEVAD,
2585 MDIO_PMA_REG_PHY_IDENTIFIER,
2586 val);
2587}
2588
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002589static u8 bnx2x_8726_read_sfp_module_eeprom(struct link_params *params,
2590 u16 addr, u8 byte_cnt, u8 *o_buf)
2591{
Eilon Greenstein589abe32009-02-12 08:36:55 +00002592 struct bnx2x *bp = params->bp;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002593 u16 val = 0;
2594 u16 i;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002595 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002596 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002597 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002598
Eilon Greenstein589abe32009-02-12 08:36:55 +00002599 if (byte_cnt > 16) {
2600 DP(NETIF_MSG_LINK, "Reading from eeprom is"
2601 " is limited to 0xf\n");
2602 return -EINVAL;
2603 }
2604 /* Set the read command byte count */
2605 bnx2x_cl45_write(bp, port,
2606 ext_phy_type,
2607 ext_phy_addr,
2608 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002609 MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
Eilon Greenstein589abe32009-02-12 08:36:55 +00002610 (byte_cnt | 0xa000));
2611
2612 /* Set the read command address */
2613 bnx2x_cl45_write(bp, port,
2614 ext_phy_type,
2615 ext_phy_addr,
2616 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002617 MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
Eilon Greenstein589abe32009-02-12 08:36:55 +00002618 addr);
2619
2620 /* Activate read command */
2621 bnx2x_cl45_write(bp, port,
2622 ext_phy_type,
2623 ext_phy_addr,
2624 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002625 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
Eilon Greenstein589abe32009-02-12 08:36:55 +00002626 0x2c0f);
2627
2628 /* Wait up to 500us for command complete status */
2629 for (i = 0; i < 100; i++) {
2630 bnx2x_cl45_read(bp, port,
2631 ext_phy_type,
2632 ext_phy_addr,
2633 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002634 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2635 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2636 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002637 break;
2638 udelay(5);
2639 }
2640
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002641 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
2642 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
Eilon Greenstein589abe32009-02-12 08:36:55 +00002643 DP(NETIF_MSG_LINK,
2644 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002645 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
Eilon Greenstein589abe32009-02-12 08:36:55 +00002646 return -EINVAL;
2647 }
2648
2649 /* Read the buffer */
2650 for (i = 0; i < byte_cnt; i++) {
2651 bnx2x_cl45_read(bp, port,
2652 ext_phy_type,
2653 ext_phy_addr,
2654 MDIO_PMA_DEVAD,
2655 MDIO_PMA_REG_8726_TWO_WIRE_DATA_BUF + i, &val);
2656 o_buf[i] = (u8)(val & MDIO_PMA_REG_8726_TWO_WIRE_DATA_MASK);
2657 }
2658
2659 for (i = 0; i < 100; i++) {
2660 bnx2x_cl45_read(bp, port,
2661 ext_phy_type,
2662 ext_phy_addr,
2663 MDIO_PMA_DEVAD,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002664 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2665 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2666 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002667 return 0;;
2668 msleep(1);
2669 }
2670 return -EINVAL;
2671}
2672
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002673static u8 bnx2x_8727_read_sfp_module_eeprom(struct link_params *params,
2674 u16 addr, u8 byte_cnt, u8 *o_buf)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002675{
2676 struct bnx2x *bp = params->bp;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002677 u16 val, i;
2678 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002679 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002680 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2681
2682 if (byte_cnt > 16) {
2683 DP(NETIF_MSG_LINK, "Reading from eeprom is"
2684 " is limited to 0xf\n");
2685 return -EINVAL;
2686 }
2687
2688 /* Need to read from 1.8000 to clear it */
2689 bnx2x_cl45_read(bp, port,
2690 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
2691 ext_phy_addr,
2692 MDIO_PMA_DEVAD,
2693 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
2694 &val);
2695
2696 /* Set the read command byte count */
2697 bnx2x_cl45_write(bp, port,
2698 ext_phy_type,
2699 ext_phy_addr,
2700 MDIO_PMA_DEVAD,
2701 MDIO_PMA_REG_SFP_TWO_WIRE_BYTE_CNT,
2702 ((byte_cnt < 2) ? 2 : byte_cnt));
2703
2704 /* Set the read command address */
2705 bnx2x_cl45_write(bp, port,
2706 ext_phy_type,
2707 ext_phy_addr,
2708 MDIO_PMA_DEVAD,
2709 MDIO_PMA_REG_SFP_TWO_WIRE_MEM_ADDR,
2710 addr);
2711 /* Set the destination address */
2712 bnx2x_cl45_write(bp, port,
2713 ext_phy_type,
2714 ext_phy_addr,
2715 MDIO_PMA_DEVAD,
2716 0x8004,
2717 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF);
2718
2719 /* Activate read command */
2720 bnx2x_cl45_write(bp, port,
2721 ext_phy_type,
2722 ext_phy_addr,
2723 MDIO_PMA_DEVAD,
2724 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL,
2725 0x8002);
2726 /* Wait appropriate time for two-wire command to finish before
2727 polling the status register */
2728 msleep(1);
2729
2730 /* Wait up to 500us for command complete status */
2731 for (i = 0; i < 100; i++) {
2732 bnx2x_cl45_read(bp, port,
2733 ext_phy_type,
2734 ext_phy_addr,
2735 MDIO_PMA_DEVAD,
2736 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2737 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2738 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE)
2739 break;
2740 udelay(5);
2741 }
2742
2743 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
2744 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
2745 DP(NETIF_MSG_LINK,
2746 "Got bad status 0x%x when reading from SFP+ EEPROM\n",
2747 (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
2748 return -EINVAL;
2749 }
2750
2751 /* Read the buffer */
2752 for (i = 0; i < byte_cnt; i++) {
2753 bnx2x_cl45_read(bp, port,
2754 ext_phy_type,
2755 ext_phy_addr,
2756 MDIO_PMA_DEVAD,
2757 MDIO_PMA_REG_8727_TWO_WIRE_DATA_BUF + i, &val);
2758 o_buf[i] = (u8)(val & MDIO_PMA_REG_8727_TWO_WIRE_DATA_MASK);
2759 }
2760
2761 for (i = 0; i < 100; i++) {
2762 bnx2x_cl45_read(bp, port,
2763 ext_phy_type,
2764 ext_phy_addr,
2765 MDIO_PMA_DEVAD,
2766 MDIO_PMA_REG_SFP_TWO_WIRE_CTRL, &val);
2767 if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) ==
2768 MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_IDLE)
2769 return 0;;
2770 msleep(1);
2771 }
2772
2773 return -EINVAL;
2774}
2775
2776u8 bnx2x_read_sfp_module_eeprom(struct link_params *params, u16 addr,
2777 u8 byte_cnt, u8 *o_buf)
2778{
2779 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
2780
2781 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
2782 return bnx2x_8726_read_sfp_module_eeprom(params, addr,
2783 byte_cnt, o_buf);
2784 else if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
2785 return bnx2x_8727_read_sfp_module_eeprom(params, addr,
2786 byte_cnt, o_buf);
2787 return -EINVAL;
2788}
2789
2790static u8 bnx2x_get_edc_mode(struct link_params *params,
2791 u16 *edc_mode)
2792{
2793 struct bnx2x *bp = params->bp;
2794 u8 val, check_limiting_mode = 0;
2795 *edc_mode = EDC_MODE_LIMITING;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002796
2797 /* First check for copper cable */
2798 if (bnx2x_read_sfp_module_eeprom(params,
2799 SFP_EEPROM_CON_TYPE_ADDR,
2800 1,
2801 &val) != 0) {
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002802 DP(NETIF_MSG_LINK, "Failed to read from SFP+ module EEPROM\n");
Eilon Greenstein589abe32009-02-12 08:36:55 +00002803 return -EINVAL;
2804 }
2805
2806 switch (val) {
2807 case SFP_EEPROM_CON_TYPE_VAL_COPPER:
2808 {
2809 u8 copper_module_type;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00002810
Eilon Greenstein589abe32009-02-12 08:36:55 +00002811 /* Check if its active cable( includes SFP+ module)
2812 of passive cable*/
2813 if (bnx2x_read_sfp_module_eeprom(params,
2814 SFP_EEPROM_FC_TX_TECH_ADDR,
2815 1,
2816 &copper_module_type) !=
2817 0) {
2818 DP(NETIF_MSG_LINK,
2819 "Failed to read copper-cable-type"
2820 " from SFP+ EEPROM\n");
2821 return -EINVAL;
2822 }
2823
2824 if (copper_module_type &
2825 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE) {
2826 DP(NETIF_MSG_LINK, "Active Copper cable detected\n");
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002827 check_limiting_mode = 1;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002828 } else if (copper_module_type &
2829 SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE) {
2830 DP(NETIF_MSG_LINK, "Passive Copper"
2831 " cable detected\n");
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002832 *edc_mode =
2833 EDC_MODE_PASSIVE_DAC;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002834 } else {
2835 DP(NETIF_MSG_LINK, "Unknown copper-cable-"
2836 "type 0x%x !!!\n", copper_module_type);
2837 return -EINVAL;
2838 }
2839 break;
2840 }
2841 case SFP_EEPROM_CON_TYPE_VAL_LC:
2842 DP(NETIF_MSG_LINK, "Optic module detected\n");
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002843 check_limiting_mode = 1;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002844 break;
Eilon Greenstein589abe32009-02-12 08:36:55 +00002845 default:
2846 DP(NETIF_MSG_LINK, "Unable to determine module type 0x%x !!!\n",
2847 val);
2848 return -EINVAL;
2849 }
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002850
2851 if (check_limiting_mode) {
2852 u8 options[SFP_EEPROM_OPTIONS_SIZE];
2853 if (bnx2x_read_sfp_module_eeprom(params,
2854 SFP_EEPROM_OPTIONS_ADDR,
2855 SFP_EEPROM_OPTIONS_SIZE,
2856 options) != 0) {
2857 DP(NETIF_MSG_LINK, "Failed to read Option"
2858 " field from module EEPROM\n");
2859 return -EINVAL;
2860 }
2861 if ((options[0] & SFP_EEPROM_OPTIONS_LINEAR_RX_OUT_MASK))
2862 *edc_mode = EDC_MODE_LINEAR;
2863 else
2864 *edc_mode = EDC_MODE_LIMITING;
2865 }
2866 DP(NETIF_MSG_LINK, "EDC mode is set to 0x%x\n", *edc_mode);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002867 return 0;
2868}
2869
Eilon Greenstein589abe32009-02-12 08:36:55 +00002870/* This function read the relevant field from the module ( SFP+ ),
2871 and verify it is compliant with this board */
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002872static u8 bnx2x_verify_sfp_module(struct link_params *params)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002873{
2874 struct bnx2x *bp = params->bp;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002875 u32 val;
2876 u32 fw_resp;
2877 char vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE+1];
2878 char vendor_pn[SFP_EEPROM_PART_NO_SIZE+1];
Eilon Greenstein589abe32009-02-12 08:36:55 +00002879
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002880 val = REG_RD(bp, params->shmem_base +
2881 offsetof(struct shmem_region, dev_info.
2882 port_feature_config[params->port].config));
2883 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
2884 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT) {
Eilon Greenstein589abe32009-02-12 08:36:55 +00002885 DP(NETIF_MSG_LINK, "NOT enforcing module verification\n");
2886 return 0;
2887 }
2888
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002889 /* Ask the FW to validate the module */
2890 if (!(params->feature_config_flags &
2891 FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY)) {
2892 DP(NETIF_MSG_LINK, "FW does not support OPT MDL "
2893 "verification\n");
2894 return -EINVAL;
2895 }
2896
2897 fw_resp = bnx2x_fw_command(bp, DRV_MSG_CODE_VRFY_OPT_MDL);
2898 if (fw_resp == FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS) {
2899 DP(NETIF_MSG_LINK, "Approved module\n");
Eilon Greenstein589abe32009-02-12 08:36:55 +00002900 return 0;
2901 }
2902
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002903 /* format the warning message */
Eilon Greenstein589abe32009-02-12 08:36:55 +00002904 if (bnx2x_read_sfp_module_eeprom(params,
2905 SFP_EEPROM_VENDOR_NAME_ADDR,
2906 SFP_EEPROM_VENDOR_NAME_SIZE,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002907 (u8 *)vendor_name))
2908 vendor_name[0] = '\0';
2909 else
2910 vendor_name[SFP_EEPROM_VENDOR_NAME_SIZE] = '\0';
2911 if (bnx2x_read_sfp_module_eeprom(params,
2912 SFP_EEPROM_PART_NO_ADDR,
2913 SFP_EEPROM_PART_NO_SIZE,
2914 (u8 *)vendor_pn))
2915 vendor_pn[0] = '\0';
2916 else
2917 vendor_pn[SFP_EEPROM_PART_NO_SIZE] = '\0';
Eilon Greenstein589abe32009-02-12 08:36:55 +00002918
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002919 printk(KERN_INFO PFX "Warning: "
2920 "Unqualified SFP+ module "
2921 "detected on %s, Port %d from %s part number %s\n"
2922 , bp->dev->name, params->port,
2923 vendor_name, vendor_pn);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002924 return -EINVAL;
2925}
2926
Eilon Greenstein589abe32009-02-12 08:36:55 +00002927static u8 bnx2x_bcm8726_set_limiting_mode(struct link_params *params,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002928 u16 edc_mode)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002929{
2930 struct bnx2x *bp = params->bp;
2931 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002932 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002933 u16 cur_limiting_mode;
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002934
2935 bnx2x_cl45_read(bp, port,
2936 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2937 ext_phy_addr,
2938 MDIO_PMA_DEVAD,
2939 MDIO_PMA_REG_ROM_VER2,
2940 &cur_limiting_mode);
2941 DP(NETIF_MSG_LINK, "Current Limiting mode is 0x%x\n",
2942 cur_limiting_mode);
2943
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002944 if (edc_mode == EDC_MODE_LIMITING) {
Eilon Greenstein589abe32009-02-12 08:36:55 +00002945 DP(NETIF_MSG_LINK,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002946 "Setting LIMITING MODE\n");
Eilon Greenstein589abe32009-02-12 08:36:55 +00002947 bnx2x_cl45_write(bp, port,
2948 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2949 ext_phy_addr,
2950 MDIO_PMA_DEVAD,
2951 MDIO_PMA_REG_ROM_VER2,
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002952 EDC_MODE_LIMITING);
Eilon Greenstein589abe32009-02-12 08:36:55 +00002953 } else { /* LRM mode ( default )*/
Eilon Greensteincc1cb002009-03-02 08:00:03 +00002954
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002955 DP(NETIF_MSG_LINK, "Setting LRM MODE\n");
Eilon Greenstein589abe32009-02-12 08:36:55 +00002956
Eilon Greenstein589abe32009-02-12 08:36:55 +00002957 /* Changing to LRM mode takes quite few seconds.
2958 So do it only if current mode is limiting
2959 ( default is LRM )*/
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002960 if (cur_limiting_mode != EDC_MODE_LIMITING)
Eilon Greenstein589abe32009-02-12 08:36:55 +00002961 return 0;
2962
2963 bnx2x_cl45_write(bp, port,
2964 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2965 ext_phy_addr,
2966 MDIO_PMA_DEVAD,
2967 MDIO_PMA_REG_LRM_MODE,
2968 0);
2969 bnx2x_cl45_write(bp, port,
2970 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2971 ext_phy_addr,
2972 MDIO_PMA_DEVAD,
2973 MDIO_PMA_REG_ROM_VER2,
2974 0x128);
2975 bnx2x_cl45_write(bp, port,
2976 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2977 ext_phy_addr,
2978 MDIO_PMA_DEVAD,
2979 MDIO_PMA_REG_MISC_CTRL0,
2980 0x4008);
2981 bnx2x_cl45_write(bp, port,
2982 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726,
2983 ext_phy_addr,
2984 MDIO_PMA_DEVAD,
2985 MDIO_PMA_REG_LRM_MODE,
2986 0xaaaa);
2987 }
2988 return 0;
2989}
2990
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002991static u8 bnx2x_bcm8727_set_limiting_mode(struct link_params *params,
2992 u16 edc_mode)
2993{
2994 struct bnx2x *bp = params->bp;
2995 u8 port = params->port;
2996 u16 phy_identifier;
2997 u16 rom_ver2_val;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00002998 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00002999
3000 bnx2x_cl45_read(bp, port,
3001 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3002 ext_phy_addr,
3003 MDIO_PMA_DEVAD,
3004 MDIO_PMA_REG_PHY_IDENTIFIER,
3005 &phy_identifier);
3006
3007 bnx2x_cl45_write(bp, port,
3008 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3009 ext_phy_addr,
3010 MDIO_PMA_DEVAD,
3011 MDIO_PMA_REG_PHY_IDENTIFIER,
3012 (phy_identifier & ~(1<<9)));
3013
3014 bnx2x_cl45_read(bp, port,
3015 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3016 ext_phy_addr,
3017 MDIO_PMA_DEVAD,
3018 MDIO_PMA_REG_ROM_VER2,
3019 &rom_ver2_val);
3020 /* Keep the MSB 8-bits, and set the LSB 8-bits with the edc_mode */
3021 bnx2x_cl45_write(bp, port,
3022 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3023 ext_phy_addr,
3024 MDIO_PMA_DEVAD,
3025 MDIO_PMA_REG_ROM_VER2,
3026 (rom_ver2_val & 0xff00) | (edc_mode & 0x00ff));
3027
3028 bnx2x_cl45_write(bp, port,
3029 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3030 ext_phy_addr,
3031 MDIO_PMA_DEVAD,
3032 MDIO_PMA_REG_PHY_IDENTIFIER,
3033 (phy_identifier | (1<<9)));
3034
3035 return 0;
3036}
3037
3038
Eilon Greenstein589abe32009-02-12 08:36:55 +00003039static u8 bnx2x_wait_for_sfp_module_initialized(struct link_params *params)
3040{
3041 u8 val;
3042 struct bnx2x *bp = params->bp;
3043 u16 timeout;
3044 /* Initialization time after hot-plug may take up to 300ms for some
3045 phys type ( e.g. JDSU ) */
3046 for (timeout = 0; timeout < 60; timeout++) {
3047 if (bnx2x_read_sfp_module_eeprom(params, 1, 1, &val)
3048 == 0) {
3049 DP(NETIF_MSG_LINK, "SFP+ module initialization "
3050 "took %d ms\n", timeout * 5);
3051 return 0;
3052 }
3053 msleep(5);
3054 }
3055 return -EINVAL;
3056}
3057
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003058static void bnx2x_8727_power_module(struct bnx2x *bp,
3059 struct link_params *params,
3060 u8 ext_phy_addr, u8 is_power_up) {
3061 /* Make sure GPIOs are not using for LED mode */
3062 u16 val;
3063 u8 port = params->port;
3064 /*
3065 * In the GPIO register, bit 4 is use to detemine if the GPIOs are
3066 * operating as INPUT or as OUTPUT. Bit 1 is for input, and 0 for
3067 * output
3068 * Bits 0-1 determine the gpios value for OUTPUT in case bit 4 val is 0
3069 * Bits 8-9 determine the gpios value for INPUT in case bit 4 val is 1
3070 * where the 1st bit is the over-current(only input), and 2nd bit is
3071 * for power( only output )
3072 */
3073
3074 /*
3075 * In case of NOC feature is disabled and power is up, set GPIO control
3076 * as input to enable listening of over-current indication
3077 */
3078
3079 if (!(params->feature_config_flags &
3080 FEATURE_CONFIG_BCM8727_NOC) && is_power_up)
3081 val = (1<<4);
3082 else
3083 /*
3084 * Set GPIO control to OUTPUT, and set the power bit
3085 * to according to the is_power_up
3086 */
3087 val = ((!(is_power_up)) << 1);
3088
3089 bnx2x_cl45_write(bp, port,
3090 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
3091 ext_phy_addr,
3092 MDIO_PMA_DEVAD,
3093 MDIO_PMA_REG_8727_GPIO_CTRL,
3094 val);
3095}
3096
Eilon Greenstein589abe32009-02-12 08:36:55 +00003097static u8 bnx2x_sfp_module_detection(struct link_params *params)
3098{
3099 struct bnx2x *bp = params->bp;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003100 u16 edc_mode;
3101 u8 rc = 0;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003102 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003103 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003104 u32 val = REG_RD(bp, params->shmem_base +
3105 offsetof(struct shmem_region, dev_info.
3106 port_feature_config[params->port].config));
Eilon Greenstein589abe32009-02-12 08:36:55 +00003107
3108 DP(NETIF_MSG_LINK, "SFP+ module plugged in/out detected on port %d\n",
3109 params->port);
3110
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003111 if (bnx2x_get_edc_mode(params, &edc_mode) != 0) {
Eilon Greenstein589abe32009-02-12 08:36:55 +00003112 DP(NETIF_MSG_LINK, "Failed to get valid module type\n");
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003113 return -EINVAL;
3114 } else if (bnx2x_verify_sfp_module(params) !=
Eilon Greenstein589abe32009-02-12 08:36:55 +00003115 0) {
3116 /* check SFP+ module compatibility */
3117 DP(NETIF_MSG_LINK, "Module verification failed!!\n");
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003118 rc = -EINVAL;
Eilon Greenstein589abe32009-02-12 08:36:55 +00003119 /* Turn on fault module-detected led */
3120 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3121 MISC_REGISTERS_GPIO_HIGH,
3122 params->port);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003123 if ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727) &&
3124 ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
3125 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN)) {
3126 /* Shutdown SFP+ module */
3127 DP(NETIF_MSG_LINK, "Shutdown SFP+ module!!\n");
3128 bnx2x_8727_power_module(bp, params,
3129 ext_phy_addr, 0);
3130 return rc;
3131 }
3132 } else {
3133 /* Turn off fault module-detected led */
3134 DP(NETIF_MSG_LINK, "Turn off fault module-detected led\n");
3135 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3136 MISC_REGISTERS_GPIO_LOW,
3137 params->port);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003138 }
3139
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003140 /* power up the SFP module */
3141 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727)
3142 bnx2x_8727_power_module(bp, params, ext_phy_addr, 1);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003143
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003144 /* Check and set limiting mode / LRM mode on 8726.
3145 On 8727 it is done automatically */
3146 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726)
3147 bnx2x_bcm8726_set_limiting_mode(params, edc_mode);
3148 else
3149 bnx2x_bcm8727_set_limiting_mode(params, edc_mode);
3150 /*
3151 * Enable transmit for this module if the module is approved, or
3152 * if unapproved modules should also enable the Tx laser
3153 */
3154 if (rc == 0 ||
3155 (val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) !=
3156 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
3157 bnx2x_sfp_set_transmitter(bp, params->port,
3158 ext_phy_type, ext_phy_addr, 1);
3159 else
3160 bnx2x_sfp_set_transmitter(bp, params->port,
3161 ext_phy_type, ext_phy_addr, 0);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003162
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003163 return rc;
Eilon Greenstein589abe32009-02-12 08:36:55 +00003164}
3165
3166void bnx2x_handle_module_detect_int(struct link_params *params)
3167{
3168 struct bnx2x *bp = params->bp;
3169 u32 gpio_val;
3170 u8 port = params->port;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003171
Eilon Greenstein589abe32009-02-12 08:36:55 +00003172 /* Set valid module led off */
3173 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
3174 MISC_REGISTERS_GPIO_HIGH,
3175 params->port);
3176
3177 /* Get current gpio val refelecting module plugged in / out*/
3178 gpio_val = bnx2x_get_gpio(bp, MISC_REGISTERS_GPIO_3, port);
3179
3180 /* Call the handling function in case module is detected */
3181 if (gpio_val == 0) {
3182
3183 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
3184 MISC_REGISTERS_GPIO_INT_OUTPUT_CLR,
3185 port);
3186
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003187 if (bnx2x_wait_for_sfp_module_initialized(params) ==
3188 0)
Eilon Greenstein589abe32009-02-12 08:36:55 +00003189 bnx2x_sfp_module_detection(params);
3190 else
3191 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
3192 } else {
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003193 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
3194
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003195 u32 ext_phy_type =
3196 XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3197 u32 val = REG_RD(bp, params->shmem_base +
3198 offsetof(struct shmem_region, dev_info.
3199 port_feature_config[params->port].
3200 config));
3201
Eilon Greenstein589abe32009-02-12 08:36:55 +00003202 bnx2x_set_gpio_int(bp, MISC_REGISTERS_GPIO_3,
3203 MISC_REGISTERS_GPIO_INT_OUTPUT_SET,
3204 port);
3205 /* Module was plugged out. */
3206 /* Disable transmit for this module */
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003207 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
3208 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
3209 bnx2x_sfp_set_transmitter(bp, params->port,
3210 ext_phy_type, ext_phy_addr, 0);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003211 }
3212}
3213
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003214static void bnx2x_bcm807x_force_10G(struct link_params *params)
3215{
3216 struct bnx2x *bp = params->bp;
3217 u8 port = params->port;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003218 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003219 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3220
3221 /* Force KR or KX */
3222 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3223 MDIO_PMA_DEVAD,
3224 MDIO_PMA_REG_CTRL,
3225 0x2040);
3226 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3227 MDIO_PMA_DEVAD,
3228 MDIO_PMA_REG_10G_CTRL2,
3229 0x000b);
3230 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3231 MDIO_PMA_DEVAD,
3232 MDIO_PMA_REG_BCM_CTRL,
3233 0x0000);
3234 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3235 MDIO_AN_DEVAD,
3236 MDIO_AN_REG_CTRL,
3237 0x0000);
3238}
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003239
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003240static void bnx2x_bcm8073_set_xaui_low_power_mode(struct link_params *params)
3241{
3242 struct bnx2x *bp = params->bp;
3243 u8 port = params->port;
3244 u16 val;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003245 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003246 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3247
3248 bnx2x_cl45_read(bp, params->port,
3249 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
3250 ext_phy_addr,
3251 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00003252 MDIO_PMA_REG_8073_CHIP_REV, &val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003253
3254 if (val == 0) {
3255 /* Mustn't set low power mode in 8073 A0 */
3256 return;
3257 }
3258
3259 /* Disable PLL sequencer (use read-modify-write to clear bit 13) */
3260 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr,
3261 MDIO_XS_DEVAD,
3262 MDIO_XS_PLL_SEQUENCER, &val);
3263 val &= ~(1<<13);
3264 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3265 MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val);
3266
3267 /* PLL controls */
3268 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3269 MDIO_XS_DEVAD, 0x805E, 0x1077);
3270 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3271 MDIO_XS_DEVAD, 0x805D, 0x0000);
3272 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3273 MDIO_XS_DEVAD, 0x805C, 0x030B);
3274 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3275 MDIO_XS_DEVAD, 0x805B, 0x1240);
3276 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3277 MDIO_XS_DEVAD, 0x805A, 0x2490);
3278
3279 /* Tx Controls */
3280 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3281 MDIO_XS_DEVAD, 0x80A7, 0x0C74);
3282 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3283 MDIO_XS_DEVAD, 0x80A6, 0x9041);
3284 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3285 MDIO_XS_DEVAD, 0x80A5, 0x4640);
3286
3287 /* Rx Controls */
3288 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3289 MDIO_XS_DEVAD, 0x80FE, 0x01C4);
3290 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3291 MDIO_XS_DEVAD, 0x80FD, 0x9249);
3292 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3293 MDIO_XS_DEVAD, 0x80FC, 0x2015);
3294
3295 /* Enable PLL sequencer (use read-modify-write to set bit 13) */
3296 bnx2x_cl45_read(bp, port, ext_phy_type, ext_phy_addr,
3297 MDIO_XS_DEVAD,
3298 MDIO_XS_PLL_SEQUENCER, &val);
3299 val |= (1<<13);
3300 bnx2x_cl45_write(bp, port, ext_phy_type, ext_phy_addr,
3301 MDIO_XS_DEVAD, MDIO_XS_PLL_SEQUENCER, val);
3302}
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003303
3304static void bnx2x_8073_set_pause_cl37(struct link_params *params,
3305 struct link_vars *vars)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003306{
3307 struct bnx2x *bp = params->bp;
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003308 u16 cl37_val;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003309 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003310 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3311
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003312 bnx2x_cl45_read(bp, params->port,
3313 ext_phy_type,
3314 ext_phy_addr,
3315 MDIO_AN_DEVAD,
3316 MDIO_AN_REG_CL37_FC_LD, &cl37_val);
3317
3318 cl37_val &= ~MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
3319 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
3320
3321 if ((vars->ieee_fc &
3322 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) ==
3323 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC) {
3324 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC;
3325 }
3326 if ((vars->ieee_fc &
3327 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
3328 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
3329 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
3330 }
3331 if ((vars->ieee_fc &
3332 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
3333 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
3334 cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
3335 }
3336 DP(NETIF_MSG_LINK,
3337 "Ext phy AN advertize cl37 0x%x\n", cl37_val);
3338
3339 bnx2x_cl45_write(bp, params->port,
3340 ext_phy_type,
3341 ext_phy_addr,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003342 MDIO_AN_DEVAD,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003343 MDIO_AN_REG_CL37_FC_LD, cl37_val);
3344 msleep(500);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003345}
3346
3347static void bnx2x_ext_phy_set_pause(struct link_params *params,
3348 struct link_vars *vars)
3349{
3350 struct bnx2x *bp = params->bp;
3351 u16 val;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003352 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003353 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3354
3355 /* read modify write pause advertizing */
3356 bnx2x_cl45_read(bp, params->port,
3357 ext_phy_type,
3358 ext_phy_addr,
3359 MDIO_AN_DEVAD,
3360 MDIO_AN_REG_ADV_PAUSE, &val);
3361
3362 val &= ~MDIO_AN_REG_ADV_PAUSE_BOTH;
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003363
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003364 /* Please refer to Table 28B-3 of 802.3ab-1999 spec. */
3365
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003366 if ((vars->ieee_fc &
3367 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) ==
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003368 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC) {
3369 val |= MDIO_AN_REG_ADV_PAUSE_ASYMMETRIC;
3370 }
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003371 if ((vars->ieee_fc &
3372 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) ==
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003373 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
3374 val |=
3375 MDIO_AN_REG_ADV_PAUSE_PAUSE;
3376 }
3377 DP(NETIF_MSG_LINK,
3378 "Ext phy AN advertize 0x%x\n", val);
3379 bnx2x_cl45_write(bp, params->port,
3380 ext_phy_type,
3381 ext_phy_addr,
3382 MDIO_AN_DEVAD,
3383 MDIO_AN_REG_ADV_PAUSE, val);
3384}
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00003385static void bnx2x_set_preemphasis(struct link_params *params)
3386{
3387 u16 bank, i = 0;
3388 struct bnx2x *bp = params->bp;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003389
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00003390 for (bank = MDIO_REG_BANK_RX0, i = 0; bank <= MDIO_REG_BANK_RX3;
3391 bank += (MDIO_REG_BANK_RX1-MDIO_REG_BANK_RX0), i++) {
3392 CL45_WR_OVER_CL22(bp, params->port,
3393 params->phy_addr,
3394 bank,
3395 MDIO_RX0_RX_EQ_BOOST,
3396 params->xgxs_config_rx[i]);
3397 }
3398
3399 for (bank = MDIO_REG_BANK_TX0, i = 0; bank <= MDIO_REG_BANK_TX3;
3400 bank += (MDIO_REG_BANK_TX1 - MDIO_REG_BANK_TX0), i++) {
3401 CL45_WR_OVER_CL22(bp, params->port,
3402 params->phy_addr,
3403 bank,
3404 MDIO_TX0_TX_DRIVER,
3405 params->xgxs_config_tx[i]);
3406 }
3407}
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003408
Eilon Greenstein2f904462009-08-12 08:22:16 +00003409
3410static void bnx2x_8481_set_led4(struct link_params *params,
3411 u32 ext_phy_type, u8 ext_phy_addr)
3412{
3413 struct bnx2x *bp = params->bp;
3414
3415 /* PHYC_CTL_LED_CTL */
3416 bnx2x_cl45_write(bp, params->port,
3417 ext_phy_type,
3418 ext_phy_addr,
3419 MDIO_PMA_DEVAD,
3420 MDIO_PMA_REG_8481_LINK_SIGNAL, 0xa482);
3421
3422 /* Unmask LED4 for 10G link */
3423 bnx2x_cl45_write(bp, params->port,
3424 ext_phy_type,
3425 ext_phy_addr,
3426 MDIO_PMA_DEVAD,
3427 MDIO_PMA_REG_8481_SIGNAL_MASK, (1<<6));
3428 /* 'Interrupt Mask' */
3429 bnx2x_cl45_write(bp, params->port,
3430 ext_phy_type,
3431 ext_phy_addr,
3432 MDIO_AN_DEVAD,
3433 0xFFFB, 0xFFFD);
3434}
3435static void bnx2x_8481_set_legacy_led_mode(struct link_params *params,
3436 u32 ext_phy_type, u8 ext_phy_addr)
3437{
3438 struct bnx2x *bp = params->bp;
3439
3440 /* LED1 (10G Link): Disable LED1 when 10/100/1000 link */
3441 /* LED2 (1G/100/10 Link): Enable LED2 when 10/100/1000 link) */
3442 bnx2x_cl45_write(bp, params->port,
3443 ext_phy_type,
3444 ext_phy_addr,
3445 MDIO_AN_DEVAD,
3446 MDIO_AN_REG_8481_LEGACY_SHADOW,
3447 (1<<15) | (0xd << 10) | (0xc<<4) | 0xe);
3448}
3449
3450static void bnx2x_8481_set_10G_led_mode(struct link_params *params,
3451 u32 ext_phy_type, u8 ext_phy_addr)
3452{
3453 struct bnx2x *bp = params->bp;
3454 u16 val1;
3455
3456 /* LED1 (10G Link) */
3457 /* Enable continuse based on source 7(10G-link) */
3458 bnx2x_cl45_read(bp, params->port,
3459 ext_phy_type,
3460 ext_phy_addr,
3461 MDIO_PMA_DEVAD,
3462 MDIO_PMA_REG_8481_LINK_SIGNAL,
3463 &val1);
3464 /* Set bit 2 to 0, and bits [1:0] to 10 */
3465 val1 &= ~((1<<0) | (1<<2)); /* Clear bits 0,2*/
3466 val1 |= (1<<1); /* Set bit 1 */
3467
3468 bnx2x_cl45_write(bp, params->port,
3469 ext_phy_type,
3470 ext_phy_addr,
3471 MDIO_PMA_DEVAD,
3472 MDIO_PMA_REG_8481_LINK_SIGNAL,
3473 val1);
3474
3475 /* Unmask LED1 for 10G link */
3476 bnx2x_cl45_read(bp, params->port,
3477 ext_phy_type,
3478 ext_phy_addr,
3479 MDIO_PMA_DEVAD,
3480 MDIO_PMA_REG_8481_LED1_MASK,
3481 &val1);
3482 /* Set bit 2 to 0, and bits [1:0] to 10 */
3483 val1 |= (1<<7);
3484 bnx2x_cl45_write(bp, params->port,
3485 ext_phy_type,
3486 ext_phy_addr,
3487 MDIO_PMA_DEVAD,
3488 MDIO_PMA_REG_8481_LED1_MASK,
3489 val1);
3490
3491 /* LED2 (1G/100/10G Link) */
3492 /* Mask LED2 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_LED2_MASK,
3498 0);
3499
3500 /* LED3 (10G/1G/100/10G Activity) */
3501 bnx2x_cl45_read(bp, params->port,
3502 ext_phy_type,
3503 ext_phy_addr,
3504 MDIO_PMA_DEVAD,
3505 MDIO_PMA_REG_8481_LINK_SIGNAL,
3506 &val1);
3507 /* Enable blink based on source 4(Activity) */
3508 val1 &= ~((1<<7) | (1<<8)); /* Clear bits 7,8 */
3509 val1 |= (1<<6); /* Set only bit 6 */
3510 bnx2x_cl45_write(bp, params->port,
3511 ext_phy_type,
3512 ext_phy_addr,
3513 MDIO_PMA_DEVAD,
3514 MDIO_PMA_REG_8481_LINK_SIGNAL,
3515 val1);
3516
3517 bnx2x_cl45_read(bp, params->port,
3518 ext_phy_type,
3519 ext_phy_addr,
3520 MDIO_PMA_DEVAD,
3521 MDIO_PMA_REG_8481_LED3_MASK,
3522 &val1);
3523 val1 |= (1<<4); /* Unmask LED3 for 10G link */
3524 bnx2x_cl45_write(bp, params->port,
3525 ext_phy_type,
3526 ext_phy_addr,
3527 MDIO_PMA_DEVAD,
3528 MDIO_PMA_REG_8481_LED3_MASK,
3529 val1);
3530}
3531
3532
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003533static void bnx2x_init_internal_phy(struct link_params *params,
Eilon Greenstein239d6862009-08-12 08:23:04 +00003534 struct link_vars *vars,
3535 u8 enable_cl73)
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003536{
3537 struct bnx2x *bp = params->bp;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003538
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003539 if (!(vars->phy_flags & PHY_SGMII_FLAG)) {
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00003540 if ((XGXS_EXT_PHY_TYPE(params->ext_phy_config) ==
3541 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
3542 (params->feature_config_flags &
3543 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED))
3544 bnx2x_set_preemphasis(params);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003545
3546 /* forced speed requested? */
3547 if (vars->line_speed != SPEED_AUTO_NEG) {
3548 DP(NETIF_MSG_LINK, "not SGMII, no AN\n");
3549
3550 /* disable autoneg */
Eilon Greenstein239d6862009-08-12 08:23:04 +00003551 bnx2x_set_autoneg(params, vars, 0);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003552
3553 /* program speed and duplex */
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003554 bnx2x_program_serdes(params, vars);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003555
3556 } else { /* AN_mode */
3557 DP(NETIF_MSG_LINK, "not SGMII, AN\n");
3558
3559 /* AN enabled */
3560 bnx2x_set_brcm_cl37_advertisment(params);
3561
3562 /* program duplex & pause advertisement (for aneg) */
3563 bnx2x_set_ieee_aneg_advertisment(params,
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003564 vars->ieee_fc);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003565
3566 /* enable autoneg */
Eilon Greenstein239d6862009-08-12 08:23:04 +00003567 bnx2x_set_autoneg(params, vars, enable_cl73);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003568
3569 /* enable and restart AN */
Eilon Greenstein239d6862009-08-12 08:23:04 +00003570 bnx2x_restart_autoneg(params, enable_cl73);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003571 }
3572
3573 } else { /* SGMII mode */
3574 DP(NETIF_MSG_LINK, "SGMII\n");
3575
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003576 bnx2x_initialize_sgmii_process(params, vars);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07003577 }
3578}
3579
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003580static u8 bnx2x_ext_phy_init(struct link_params *params, struct link_vars *vars)
3581{
3582 struct bnx2x *bp = params->bp;
3583 u32 ext_phy_type;
3584 u8 ext_phy_addr;
3585 u16 cnt;
3586 u16 ctrl = 0;
3587 u16 val = 0;
3588 u8 rc = 0;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003589
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003590 if (vars->phy_flags & PHY_XGXS_FLAG) {
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00003591 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003592
3593 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
3594 /* Make sure that the soft reset is off (expect for the 8072:
3595 * due to the lock, it will be done inside the specific
3596 * handling)
3597 */
3598 if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
3599 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
3600 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN) &&
3601 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) &&
3602 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073)) {
3603 /* Wait for soft reset to get cleared upto 1 sec */
3604 for (cnt = 0; cnt < 1000; cnt++) {
3605 bnx2x_cl45_read(bp, params->port,
3606 ext_phy_type,
3607 ext_phy_addr,
3608 MDIO_PMA_DEVAD,
3609 MDIO_PMA_REG_CTRL, &ctrl);
3610 if (!(ctrl & (1<<15)))
3611 break;
3612 msleep(1);
3613 }
3614 DP(NETIF_MSG_LINK, "control reg 0x%x (after %d ms)\n",
3615 ctrl, cnt);
3616 }
3617
3618 switch (ext_phy_type) {
3619 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003620 break;
3621
3622 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
3623 DP(NETIF_MSG_LINK, "XGXS 8705\n");
3624
3625 bnx2x_cl45_write(bp, params->port,
3626 ext_phy_type,
3627 ext_phy_addr,
3628 MDIO_PMA_DEVAD,
3629 MDIO_PMA_REG_MISC_CTRL,
3630 0x8288);
3631 bnx2x_cl45_write(bp, params->port,
3632 ext_phy_type,
3633 ext_phy_addr,
3634 MDIO_PMA_DEVAD,
3635 MDIO_PMA_REG_PHY_IDENTIFIER,
3636 0x7fbf);
3637 bnx2x_cl45_write(bp, params->port,
3638 ext_phy_type,
3639 ext_phy_addr,
3640 MDIO_PMA_DEVAD,
3641 MDIO_PMA_REG_CMU_PLL_BYPASS,
3642 0x0100);
3643 bnx2x_cl45_write(bp, params->port,
3644 ext_phy_type,
3645 ext_phy_addr,
3646 MDIO_WIS_DEVAD,
3647 MDIO_WIS_REG_LASI_CNTL, 0x1);
Eilon Greensteina35da8d2009-02-12 08:37:02 +00003648
Eilon Greenstein3b313b62009-03-02 08:00:10 +00003649 /* BCM8705 doesn't have microcode, hence the 0 */
3650 bnx2x_save_spirom_version(bp, params->port,
3651 params->shmem_base, 0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003652 break;
3653
3654 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
Eilon Greensteina35da8d2009-02-12 08:37:02 +00003655 /* Wait until fw is loaded */
3656 for (cnt = 0; cnt < 100; cnt++) {
3657 bnx2x_cl45_read(bp, params->port, ext_phy_type,
3658 ext_phy_addr, MDIO_PMA_DEVAD,
3659 MDIO_PMA_REG_ROM_VER1, &val);
3660 if (val)
3661 break;
3662 msleep(10);
3663 }
3664 DP(NETIF_MSG_LINK, "XGXS 8706 is initialized "
3665 "after %d ms\n", cnt);
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00003666 if ((params->feature_config_flags &
3667 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
3668 u8 i;
3669 u16 reg;
3670 for (i = 0; i < 4; i++) {
3671 reg = MDIO_XS_8706_REG_BANK_RX0 +
3672 i*(MDIO_XS_8706_REG_BANK_RX1 -
3673 MDIO_XS_8706_REG_BANK_RX0);
3674 bnx2x_cl45_read(bp, params->port,
3675 ext_phy_type,
3676 ext_phy_addr,
3677 MDIO_XS_DEVAD,
3678 reg, &val);
3679 /* Clear first 3 bits of the control */
3680 val &= ~0x7;
3681 /* Set control bits according to
3682 configuation */
3683 val |= (params->xgxs_config_rx[i] &
3684 0x7);
3685 DP(NETIF_MSG_LINK, "Setting RX"
3686 "Equalizer to BCM8706 reg 0x%x"
3687 " <-- val 0x%x\n", reg, val);
3688 bnx2x_cl45_write(bp, params->port,
3689 ext_phy_type,
3690 ext_phy_addr,
3691 MDIO_XS_DEVAD,
3692 reg, val);
3693 }
3694 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003695 /* Force speed */
3696 /* First enable LASI */
3697 bnx2x_cl45_write(bp, params->port,
3698 ext_phy_type,
3699 ext_phy_addr,
3700 MDIO_PMA_DEVAD,
3701 MDIO_PMA_REG_RX_ALARM_CTRL,
3702 0x0400);
3703 bnx2x_cl45_write(bp, params->port,
3704 ext_phy_type,
3705 ext_phy_addr,
3706 MDIO_PMA_DEVAD,
3707 MDIO_PMA_REG_LASI_CTRL, 0x0004);
3708
3709 if (params->req_line_speed == SPEED_10000) {
3710 DP(NETIF_MSG_LINK, "XGXS 8706 force 10Gbps\n");
3711
3712 bnx2x_cl45_write(bp, params->port,
3713 ext_phy_type,
3714 ext_phy_addr,
3715 MDIO_PMA_DEVAD,
3716 MDIO_PMA_REG_DIGITAL_CTRL,
3717 0x400);
3718 } else {
3719 /* Force 1Gbps using autoneg with 1G
3720 advertisment */
3721
3722 /* Allow CL37 through CL73 */
3723 DP(NETIF_MSG_LINK, "XGXS 8706 AutoNeg\n");
3724 bnx2x_cl45_write(bp, params->port,
3725 ext_phy_type,
3726 ext_phy_addr,
3727 MDIO_AN_DEVAD,
3728 MDIO_AN_REG_CL37_CL73,
3729 0x040c);
3730
3731 /* Enable Full-Duplex advertisment on CL37 */
3732 bnx2x_cl45_write(bp, params->port,
3733 ext_phy_type,
3734 ext_phy_addr,
3735 MDIO_AN_DEVAD,
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07003736 MDIO_AN_REG_CL37_FC_LP,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003737 0x0020);
3738 /* Enable CL37 AN */
3739 bnx2x_cl45_write(bp, params->port,
3740 ext_phy_type,
3741 ext_phy_addr,
3742 MDIO_AN_DEVAD,
3743 MDIO_AN_REG_CL37_AN,
3744 0x1000);
3745 /* 1G support */
3746 bnx2x_cl45_write(bp, params->port,
3747 ext_phy_type,
3748 ext_phy_addr,
3749 MDIO_AN_DEVAD,
3750 MDIO_AN_REG_ADV, (1<<5));
3751
3752 /* Enable clause 73 AN */
3753 bnx2x_cl45_write(bp, params->port,
3754 ext_phy_type,
3755 ext_phy_addr,
3756 MDIO_AN_DEVAD,
3757 MDIO_AN_REG_CTRL,
3758 0x1200);
3759
3760 }
Eilon Greensteina35da8d2009-02-12 08:37:02 +00003761 bnx2x_save_bcm_spirom_ver(bp, params->port,
3762 ext_phy_type,
3763 ext_phy_addr,
3764 params->shmem_base);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003765 break;
Eilon Greenstein589abe32009-02-12 08:36:55 +00003766 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
3767 DP(NETIF_MSG_LINK, "Initializing BCM8726\n");
3768 bnx2x_bcm8726_external_rom_boot(params);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003769
Eilon Greenstein589abe32009-02-12 08:36:55 +00003770 /* Need to call module detected on initialization since
3771 the module detection triggered by actual module
3772 insertion might occur before driver is loaded, and when
3773 driver is loaded, it reset all registers, including the
3774 transmitter */
3775 bnx2x_sfp_module_detection(params);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00003776
3777 /* Set Flow control */
3778 bnx2x_ext_phy_set_pause(params, vars);
Eilon Greenstein589abe32009-02-12 08:36:55 +00003779 if (params->req_line_speed == SPEED_1000) {
3780 DP(NETIF_MSG_LINK, "Setting 1G force\n");
3781 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3782 ext_phy_addr, MDIO_PMA_DEVAD,
3783 MDIO_PMA_REG_CTRL, 0x40);
3784 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3785 ext_phy_addr, MDIO_PMA_DEVAD,
3786 MDIO_PMA_REG_10G_CTRL2, 0xD);
3787 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3788 ext_phy_addr, MDIO_PMA_DEVAD,
3789 MDIO_PMA_REG_LASI_CTRL, 0x5);
3790 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3791 ext_phy_addr, MDIO_PMA_DEVAD,
3792 MDIO_PMA_REG_RX_ALARM_CTRL,
3793 0x400);
3794 } else if ((params->req_line_speed ==
3795 SPEED_AUTO_NEG) &&
3796 ((params->speed_cap_mask &
3797 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
3798 DP(NETIF_MSG_LINK, "Setting 1G clause37 \n");
3799 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3800 ext_phy_addr, MDIO_AN_DEVAD,
3801 MDIO_AN_REG_ADV, 0x20);
3802 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3803 ext_phy_addr, MDIO_AN_DEVAD,
3804 MDIO_AN_REG_CL37_CL73, 0x040c);
3805 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3806 ext_phy_addr, MDIO_AN_DEVAD,
3807 MDIO_AN_REG_CL37_FC_LD, 0x0020);
3808 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3809 ext_phy_addr, MDIO_AN_DEVAD,
3810 MDIO_AN_REG_CL37_AN, 0x1000);
3811 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3812 ext_phy_addr, MDIO_AN_DEVAD,
3813 MDIO_AN_REG_CTRL, 0x1200);
3814
3815 /* Enable RX-ALARM control to receive
3816 interrupt for 1G speed change */
3817 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3818 ext_phy_addr, MDIO_PMA_DEVAD,
3819 MDIO_PMA_REG_LASI_CTRL, 0x4);
3820 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3821 ext_phy_addr, MDIO_PMA_DEVAD,
3822 MDIO_PMA_REG_RX_ALARM_CTRL,
3823 0x400);
3824
3825 } else { /* Default 10G. Set only LASI control */
3826 bnx2x_cl45_write(bp, params->port, ext_phy_type,
3827 ext_phy_addr, MDIO_PMA_DEVAD,
3828 MDIO_PMA_REG_LASI_CTRL, 1);
3829 }
Eilon Greensteinc2c8b032009-02-12 08:37:14 +00003830
3831 /* Set TX PreEmphasis if needed */
3832 if ((params->feature_config_flags &
3833 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
3834 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x,"
3835 "TX_CTRL2 0x%x\n",
3836 params->xgxs_config_tx[0],
3837 params->xgxs_config_tx[1]);
3838 bnx2x_cl45_write(bp, params->port,
3839 ext_phy_type,
3840 ext_phy_addr,
3841 MDIO_PMA_DEVAD,
3842 MDIO_PMA_REG_8726_TX_CTRL1,
3843 params->xgxs_config_tx[0]);
3844
3845 bnx2x_cl45_write(bp, params->port,
3846 ext_phy_type,
3847 ext_phy_addr,
3848 MDIO_PMA_DEVAD,
3849 MDIO_PMA_REG_8726_TX_CTRL2,
3850 params->xgxs_config_tx[1]);
3851 }
Eilon Greenstein589abe32009-02-12 08:36:55 +00003852 break;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003853 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
3854 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
3855 {
3856 u16 tmp1;
3857 u16 rx_alarm_ctrl_val;
3858 u16 lasi_ctrl_val;
3859 if (ext_phy_type ==
3860 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) {
3861 rx_alarm_ctrl_val = 0x400;
3862 lasi_ctrl_val = 0x0004;
3863 } else {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003864 rx_alarm_ctrl_val = (1<<2);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003865 lasi_ctrl_val = 0x0004;
3866 }
3867
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003868 /* enable LASI */
3869 bnx2x_cl45_write(bp, params->port,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003870 ext_phy_type,
3871 ext_phy_addr,
3872 MDIO_PMA_DEVAD,
3873 MDIO_PMA_REG_RX_ALARM_CTRL,
3874 rx_alarm_ctrl_val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003875
3876 bnx2x_cl45_write(bp, params->port,
3877 ext_phy_type,
3878 ext_phy_addr,
3879 MDIO_PMA_DEVAD,
3880 MDIO_PMA_REG_LASI_CTRL,
3881 lasi_ctrl_val);
3882
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003883 bnx2x_8073_set_pause_cl37(params, vars);
3884
3885 if (ext_phy_type ==
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003886 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072)
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003887 bnx2x_bcm8072_external_rom_boot(params);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00003888 else
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003889 /* In case of 8073 with long xaui lines,
3890 don't set the 8073 xaui low power*/
3891 bnx2x_bcm8073_set_xaui_low_power_mode(params);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003892
3893 bnx2x_cl45_read(bp, params->port,
3894 ext_phy_type,
3895 ext_phy_addr,
3896 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00003897 MDIO_PMA_REG_M8051_MSGOUT_REG,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003898 &tmp1);
3899
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003900 bnx2x_cl45_read(bp, params->port,
3901 ext_phy_type,
3902 ext_phy_addr,
3903 MDIO_PMA_DEVAD,
3904 MDIO_PMA_REG_RX_ALARM, &tmp1);
3905
3906 DP(NETIF_MSG_LINK, "Before rom RX_ALARM(port1):"
3907 "0x%x\n", tmp1);
3908
3909 /* If this is forced speed, set to KR or KX
3910 * (all other are not supported)
3911 */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003912 if (params->loopback_mode == LOOPBACK_EXT) {
3913 bnx2x_bcm807x_force_10G(params);
3914 DP(NETIF_MSG_LINK,
3915 "Forced speed 10G on 807X\n");
3916 break;
3917 } else {
3918 bnx2x_cl45_write(bp, params->port,
3919 ext_phy_type, ext_phy_addr,
3920 MDIO_PMA_DEVAD,
3921 MDIO_PMA_REG_BCM_CTRL,
3922 0x0002);
3923 }
3924 if (params->req_line_speed != SPEED_AUTO_NEG) {
3925 if (params->req_line_speed == SPEED_10000) {
3926 val = (1<<7);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003927 } else if (params->req_line_speed ==
3928 SPEED_2500) {
3929 val = (1<<5);
3930 /* Note that 2.5G works only
3931 when used with 1G advertisment */
3932 } else
3933 val = (1<<5);
3934 } else {
3935
3936 val = 0;
3937 if (params->speed_cap_mask &
3938 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
3939 val |= (1<<7);
3940
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003941 /* Note that 2.5G works only when
3942 used with 1G advertisment */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003943 if (params->speed_cap_mask &
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003944 (PORT_HW_CFG_SPEED_CAPABILITY_D0_1G |
3945 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003946 val |= (1<<5);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003947 DP(NETIF_MSG_LINK,
3948 "807x autoneg val = 0x%x\n", val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003949 }
3950
3951 bnx2x_cl45_write(bp, params->port,
3952 ext_phy_type,
3953 ext_phy_addr,
3954 MDIO_AN_DEVAD,
3955 MDIO_AN_REG_ADV, val);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003956 if (ext_phy_type ==
3957 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003958 bnx2x_cl45_read(bp, params->port,
3959 ext_phy_type,
3960 ext_phy_addr,
3961 MDIO_AN_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00003962 MDIO_AN_REG_8073_2_5G, &tmp1);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003963
3964 if (((params->speed_cap_mask &
3965 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G) &&
3966 (params->req_line_speed ==
3967 SPEED_AUTO_NEG)) ||
3968 (params->req_line_speed ==
3969 SPEED_2500)) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003970 u16 phy_ver;
3971 /* Allow 2.5G for A1 and above */
3972 bnx2x_cl45_read(bp, params->port,
3973 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
3974 ext_phy_addr,
3975 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00003976 MDIO_PMA_REG_8073_CHIP_REV, &phy_ver);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003977 DP(NETIF_MSG_LINK, "Add 2.5G\n");
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003978 if (phy_ver > 0)
3979 tmp1 |= 1;
3980 else
3981 tmp1 &= 0xfffe;
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003982 } else {
3983 DP(NETIF_MSG_LINK, "Disable 2.5G\n");
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07003984 tmp1 &= 0xfffe;
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003985 }
3986
3987 bnx2x_cl45_write(bp, params->port,
3988 ext_phy_type,
3989 ext_phy_addr,
3990 MDIO_AN_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00003991 MDIO_AN_REG_8073_2_5G, tmp1);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07003992 }
3993
3994 /* Add support for CL37 (passive mode) II */
3995
3996 bnx2x_cl45_read(bp, params->port,
3997 ext_phy_type,
3998 ext_phy_addr,
3999 MDIO_AN_DEVAD,
4000 MDIO_AN_REG_CL37_FC_LD,
4001 &tmp1);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004002
4003 bnx2x_cl45_write(bp, params->port,
4004 ext_phy_type,
4005 ext_phy_addr,
4006 MDIO_AN_DEVAD,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004007 MDIO_AN_REG_CL37_FC_LD, (tmp1 |
4008 ((params->req_duplex == DUPLEX_FULL) ?
4009 0x20 : 0x40)));
4010
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004011 /* Add support for CL37 (passive mode) III */
4012 bnx2x_cl45_write(bp, params->port,
4013 ext_phy_type,
4014 ext_phy_addr,
4015 MDIO_AN_DEVAD,
4016 MDIO_AN_REG_CL37_AN, 0x1000);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004017
4018 if (ext_phy_type ==
4019 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004020 /* The SNR will improve about 2db by changing
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004021 BW and FEE main tap. Rest commands are executed
4022 after link is up*/
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004023 /*Change FFE main cursor to 5 in EDC register*/
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004024 if (bnx2x_8073_is_snr_needed(params))
4025 bnx2x_cl45_write(bp, params->port,
4026 ext_phy_type,
4027 ext_phy_addr,
4028 MDIO_PMA_DEVAD,
4029 MDIO_PMA_REG_EDC_FFE_MAIN,
4030 0xFB0C);
4031
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004032 /* Enable FEC (Forware Error Correction)
4033 Request in the AN */
4034 bnx2x_cl45_read(bp, params->port,
4035 ext_phy_type,
4036 ext_phy_addr,
4037 MDIO_AN_DEVAD,
4038 MDIO_AN_REG_ADV2, &tmp1);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004039
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004040 tmp1 |= (1<<15);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004041
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004042 bnx2x_cl45_write(bp, params->port,
4043 ext_phy_type,
4044 ext_phy_addr,
4045 MDIO_AN_DEVAD,
4046 MDIO_AN_REG_ADV2, tmp1);
4047
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004048 }
4049
4050 bnx2x_ext_phy_set_pause(params, vars);
4051
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004052 /* Restart autoneg */
4053 msleep(500);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004054 bnx2x_cl45_write(bp, params->port,
4055 ext_phy_type,
4056 ext_phy_addr,
4057 MDIO_AN_DEVAD,
4058 MDIO_AN_REG_CTRL, 0x1200);
4059 DP(NETIF_MSG_LINK, "807x Autoneg Restart: "
4060 "Advertise 1G=%x, 10G=%x\n",
4061 ((val & (1<<5)) > 0),
4062 ((val & (1<<7)) > 0));
4063 break;
4064 }
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004065
4066 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
4067 {
4068 u16 tmp1;
4069 u16 rx_alarm_ctrl_val;
4070 u16 lasi_ctrl_val;
4071
4072 /* Enable PMD link, MOD_ABS_FLT, and 1G link alarm */
4073
4074 u16 mod_abs;
4075 rx_alarm_ctrl_val = (1<<2) | (1<<5) ;
4076 lasi_ctrl_val = 0x0004;
4077
4078 DP(NETIF_MSG_LINK, "Initializing BCM8727\n");
4079 /* enable LASI */
4080 bnx2x_cl45_write(bp, params->port,
4081 ext_phy_type,
4082 ext_phy_addr,
4083 MDIO_PMA_DEVAD,
4084 MDIO_PMA_REG_RX_ALARM_CTRL,
4085 rx_alarm_ctrl_val);
4086
4087 bnx2x_cl45_write(bp, params->port,
4088 ext_phy_type,
4089 ext_phy_addr,
4090 MDIO_PMA_DEVAD,
4091 MDIO_PMA_REG_LASI_CTRL,
4092 lasi_ctrl_val);
4093
4094 /* Initially configure MOD_ABS to interrupt when
4095 module is presence( bit 8) */
4096 bnx2x_cl45_read(bp, params->port,
4097 ext_phy_type,
4098 ext_phy_addr,
4099 MDIO_PMA_DEVAD,
4100 MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
4101 /* Set EDC off by setting OPTXLOS signal input to low
4102 (bit 9).
4103 When the EDC is off it locks onto a reference clock and
4104 avoids becoming 'lost'.*/
4105 mod_abs &= ~((1<<8) | (1<<9));
4106 bnx2x_cl45_write(bp, params->port,
4107 ext_phy_type,
4108 ext_phy_addr,
4109 MDIO_PMA_DEVAD,
4110 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4111
4112 /* Make MOD_ABS give interrupt on change */
4113 bnx2x_cl45_read(bp, params->port,
4114 ext_phy_type,
4115 ext_phy_addr,
4116 MDIO_PMA_DEVAD,
4117 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4118 &val);
4119 val |= (1<<12);
4120 bnx2x_cl45_write(bp, params->port,
4121 ext_phy_type,
4122 ext_phy_addr,
4123 MDIO_PMA_DEVAD,
4124 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4125 val);
4126
4127 /* Set 8727 GPIOs to input to allow reading from the
4128 8727 GPIO0 status which reflect SFP+ module
4129 over-current */
4130
4131 bnx2x_cl45_read(bp, params->port,
4132 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4133 ext_phy_addr,
4134 MDIO_PMA_DEVAD,
4135 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4136 &val);
4137 val &= 0xff8f; /* Reset bits 4-6 */
4138 bnx2x_cl45_write(bp, params->port,
4139 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4140 ext_phy_addr,
4141 MDIO_PMA_DEVAD,
4142 MDIO_PMA_REG_8727_PCS_OPT_CTRL,
4143 val);
4144
4145 bnx2x_8727_power_module(bp, params, ext_phy_addr, 1);
4146 bnx2x_bcm8073_set_xaui_low_power_mode(params);
4147
4148 bnx2x_cl45_read(bp, params->port,
4149 ext_phy_type,
4150 ext_phy_addr,
4151 MDIO_PMA_DEVAD,
4152 MDIO_PMA_REG_M8051_MSGOUT_REG,
4153 &tmp1);
4154
4155 bnx2x_cl45_read(bp, params->port,
4156 ext_phy_type,
4157 ext_phy_addr,
4158 MDIO_PMA_DEVAD,
4159 MDIO_PMA_REG_RX_ALARM, &tmp1);
4160
4161 /* Set option 1G speed */
4162 if (params->req_line_speed == SPEED_1000) {
4163
4164 DP(NETIF_MSG_LINK, "Setting 1G force\n");
4165 bnx2x_cl45_write(bp, params->port,
4166 ext_phy_type,
4167 ext_phy_addr,
4168 MDIO_PMA_DEVAD,
4169 MDIO_PMA_REG_CTRL, 0x40);
4170 bnx2x_cl45_write(bp, params->port,
4171 ext_phy_type,
4172 ext_phy_addr,
4173 MDIO_PMA_DEVAD,
4174 MDIO_PMA_REG_10G_CTRL2, 0xD);
4175 bnx2x_cl45_read(bp, params->port,
4176 ext_phy_type,
4177 ext_phy_addr,
4178 MDIO_PMA_DEVAD,
4179 MDIO_PMA_REG_10G_CTRL2, &tmp1);
4180 DP(NETIF_MSG_LINK, "1.7 = 0x%x \n", tmp1);
4181
4182 } else if ((params->req_line_speed ==
4183 SPEED_AUTO_NEG) &&
4184 ((params->speed_cap_mask &
4185 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
4186
4187 DP(NETIF_MSG_LINK, "Setting 1G clause37 \n");
4188 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4189 ext_phy_addr, MDIO_AN_DEVAD,
4190 MDIO_PMA_REG_8727_MISC_CTRL, 0);
4191 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4192 ext_phy_addr, MDIO_AN_DEVAD,
4193 MDIO_AN_REG_CL37_AN, 0x1300);
4194 } else {
4195 /* Since the 8727 has only single reset pin,
4196 need to set the 10G registers although it is
4197 default */
4198 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4199 ext_phy_addr, MDIO_AN_DEVAD,
4200 MDIO_AN_REG_CTRL, 0x0020);
4201 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4202 ext_phy_addr, MDIO_AN_DEVAD,
4203 0x7, 0x0100);
4204 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4205 ext_phy_addr, MDIO_PMA_DEVAD,
4206 MDIO_PMA_REG_CTRL, 0x2040);
4207 bnx2x_cl45_write(bp, params->port, ext_phy_type,
4208 ext_phy_addr, MDIO_PMA_DEVAD,
4209 MDIO_PMA_REG_10G_CTRL2, 0x0008);
4210 }
4211
4212 /* Set 2-wire transfer rate to 400Khz since 100Khz
4213 is not operational */
4214 bnx2x_cl45_write(bp, params->port,
4215 ext_phy_type,
4216 ext_phy_addr,
4217 MDIO_PMA_DEVAD,
4218 MDIO_PMA_REG_8727_TWO_WIRE_SLAVE_ADDR,
4219 0xa101);
4220
4221 /* Set TX PreEmphasis if needed */
4222 if ((params->feature_config_flags &
4223 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
4224 DP(NETIF_MSG_LINK, "Setting TX_CTRL1 0x%x,"
4225 "TX_CTRL2 0x%x\n",
4226 params->xgxs_config_tx[0],
4227 params->xgxs_config_tx[1]);
4228 bnx2x_cl45_write(bp, params->port,
4229 ext_phy_type,
4230 ext_phy_addr,
4231 MDIO_PMA_DEVAD,
4232 MDIO_PMA_REG_8727_TX_CTRL1,
4233 params->xgxs_config_tx[0]);
4234
4235 bnx2x_cl45_write(bp, params->port,
4236 ext_phy_type,
4237 ext_phy_addr,
4238 MDIO_PMA_DEVAD,
4239 MDIO_PMA_REG_8727_TX_CTRL2,
4240 params->xgxs_config_tx[1]);
4241 }
4242
4243 break;
4244 }
4245
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004246 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
Eilon Greensteina35da8d2009-02-12 08:37:02 +00004247 {
4248 u16 fw_ver1, fw_ver2;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004249 DP(NETIF_MSG_LINK,
4250 "Setting the SFX7101 LASI indication\n");
4251
4252 bnx2x_cl45_write(bp, params->port,
4253 ext_phy_type,
4254 ext_phy_addr,
4255 MDIO_PMA_DEVAD,
4256 MDIO_PMA_REG_LASI_CTRL, 0x1);
4257 DP(NETIF_MSG_LINK,
4258 "Setting the SFX7101 LED to blink on traffic\n");
4259 bnx2x_cl45_write(bp, params->port,
4260 ext_phy_type,
4261 ext_phy_addr,
4262 MDIO_PMA_DEVAD,
4263 MDIO_PMA_REG_7107_LED_CNTL, (1<<3));
4264
4265 bnx2x_ext_phy_set_pause(params, vars);
4266 /* Restart autoneg */
4267 bnx2x_cl45_read(bp, params->port,
4268 ext_phy_type,
4269 ext_phy_addr,
4270 MDIO_AN_DEVAD,
4271 MDIO_AN_REG_CTRL, &val);
4272 val |= 0x200;
4273 bnx2x_cl45_write(bp, params->port,
4274 ext_phy_type,
4275 ext_phy_addr,
4276 MDIO_AN_DEVAD,
4277 MDIO_AN_REG_CTRL, val);
Eilon Greenstein28577182009-02-12 08:37:00 +00004278
Eilon Greensteina35da8d2009-02-12 08:37:02 +00004279 /* Save spirom version */
4280 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4281 ext_phy_addr, MDIO_PMA_DEVAD,
4282 MDIO_PMA_REG_7101_VER1, &fw_ver1);
4283
4284 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4285 ext_phy_addr, MDIO_PMA_DEVAD,
4286 MDIO_PMA_REG_7101_VER2, &fw_ver2);
4287
4288 bnx2x_save_spirom_version(params->bp, params->port,
4289 params->shmem_base,
4290 (u32)(fw_ver1<<16 | fw_ver2));
Eilon Greenstein28577182009-02-12 08:37:00 +00004291 break;
Eilon Greensteina35da8d2009-02-12 08:37:02 +00004292 }
Eilon Greenstein28577182009-02-12 08:37:00 +00004293 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
Eilon Greenstein2f904462009-08-12 08:22:16 +00004294 /* This phy uses the NIG latch mechanism since link
4295 indication arrives through its LED4 and not via
4296 its LASI signal, so we get steady signal
4297 instead of clear on read */
4298 bnx2x_bits_en(bp, NIG_REG_LATCH_BC_0 + params->port*4,
4299 1 << NIG_LATCH_BC_ENABLE_MI_INT);
Eilon Greenstein28577182009-02-12 08:37:00 +00004300
Eilon Greenstein2f904462009-08-12 08:22:16 +00004301 bnx2x_8481_set_led4(params, ext_phy_type, ext_phy_addr);
4302 if (params->req_line_speed == SPEED_AUTO_NEG) {
Eilon Greenstein28577182009-02-12 08:37:00 +00004303
Eilon Greenstein2f904462009-08-12 08:22:16 +00004304 u16 autoneg_val, an_1000_val, an_10_100_val;
4305 /* set 1000 speed advertisement */
4306 bnx2x_cl45_read(bp, params->port,
4307 ext_phy_type,
4308 ext_phy_addr,
4309 MDIO_AN_DEVAD,
4310 MDIO_AN_REG_8481_1000T_CTRL,
4311 &an_1000_val);
4312
4313 if (params->speed_cap_mask &
4314 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G) {
4315 an_1000_val |= (1<<8);
4316 if (params->req_duplex == DUPLEX_FULL)
4317 an_1000_val |= (1<<9);
4318 DP(NETIF_MSG_LINK, "Advertising 1G\n");
4319 } else
4320 an_1000_val &= ~((1<<8) | (1<<9));
4321
4322 bnx2x_cl45_write(bp, params->port,
4323 ext_phy_type,
4324 ext_phy_addr,
4325 MDIO_AN_DEVAD,
4326 MDIO_AN_REG_8481_1000T_CTRL,
4327 an_1000_val);
4328
4329 /* set 100 speed advertisement */
4330 bnx2x_cl45_read(bp, params->port,
4331 ext_phy_type,
4332 ext_phy_addr,
4333 MDIO_AN_DEVAD,
4334 MDIO_AN_REG_8481_LEGACY_AN_ADV,
4335 &an_10_100_val);
4336
4337 if (params->speed_cap_mask &
4338 (PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL |
4339 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF)) {
4340 an_10_100_val |= (1<<7);
4341 if (params->req_duplex == DUPLEX_FULL)
4342 an_10_100_val |= (1<<8);
4343 DP(NETIF_MSG_LINK,
4344 "Advertising 100M\n");
4345 } else
4346 an_10_100_val &= ~((1<<7) | (1<<8));
4347
4348 /* set 10 speed advertisement */
4349 if (params->speed_cap_mask &
4350 (PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL |
4351 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF)) {
4352 an_10_100_val |= (1<<5);
4353 if (params->req_duplex == DUPLEX_FULL)
4354 an_10_100_val |= (1<<6);
4355 DP(NETIF_MSG_LINK, "Advertising 10M\n");
4356 }
4357 else
4358 an_10_100_val &= ~((1<<5) | (1<<6));
4359
4360 bnx2x_cl45_write(bp, params->port,
4361 ext_phy_type,
4362 ext_phy_addr,
4363 MDIO_AN_DEVAD,
4364 MDIO_AN_REG_8481_LEGACY_AN_ADV,
4365 an_10_100_val);
4366
4367 bnx2x_cl45_read(bp, params->port,
4368 ext_phy_type,
4369 ext_phy_addr,
4370 MDIO_AN_DEVAD,
4371 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4372 &autoneg_val);
4373
4374 /* Disable forced speed */
4375 autoneg_val &= ~(1<<6|1<<13);
4376
4377 /* Enable autoneg and restart autoneg
4378 for legacy speeds */
4379 autoneg_val |= (1<<9|1<<12);
4380
4381 if (params->req_duplex == DUPLEX_FULL)
4382 autoneg_val |= (1<<8);
4383 else
4384 autoneg_val &= ~(1<<8);
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_LEGACY_MII_CTRL,
4391 autoneg_val);
4392
4393 if (params->speed_cap_mask &
4394 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
4395 DP(NETIF_MSG_LINK, "Advertising 10G\n");
4396 /* Restart autoneg for 10G*/
Eilon Greenstein28577182009-02-12 08:37:00 +00004397 bnx2x_cl45_read(bp, params->port,
4398 ext_phy_type,
4399 ext_phy_addr,
4400 MDIO_AN_DEVAD,
4401 MDIO_AN_REG_CTRL, &val);
4402 val |= 0x200;
4403 bnx2x_cl45_write(bp, params->port,
4404 ext_phy_type,
4405 ext_phy_addr,
4406 MDIO_AN_DEVAD,
4407 MDIO_AN_REG_CTRL, val);
Eilon Greenstein2f904462009-08-12 08:22:16 +00004408 }
4409 } else {
4410 /* Force speed */
4411 u16 autoneg_ctrl, pma_ctrl;
4412 bnx2x_cl45_read(bp, params->port,
4413 ext_phy_type,
4414 ext_phy_addr,
4415 MDIO_AN_DEVAD,
4416 MDIO_AN_REG_8481_LEGACY_MII_CTRL,
4417 &autoneg_ctrl);
4418
4419 /* Disable autoneg */
4420 autoneg_ctrl &= ~(1<<12);
4421
4422 /* Set 1000 force */
4423 switch (params->req_line_speed) {
4424 case SPEED_10000:
4425 DP(NETIF_MSG_LINK,
4426 "Unable to set 10G force !\n");
4427 break;
4428 case SPEED_1000:
4429 bnx2x_cl45_read(bp, params->port,
4430 ext_phy_type,
4431 ext_phy_addr,
4432 MDIO_PMA_DEVAD,
4433 MDIO_PMA_REG_CTRL,
4434 &pma_ctrl);
4435 autoneg_ctrl &= ~(1<<13);
4436 autoneg_ctrl |= (1<<6);
4437 pma_ctrl &= ~(1<<13);
4438 pma_ctrl |= (1<<6);
4439 DP(NETIF_MSG_LINK,
4440 "Setting 1000M force\n");
4441 bnx2x_cl45_write(bp, params->port,
4442 ext_phy_type,
4443 ext_phy_addr,
4444 MDIO_PMA_DEVAD,
4445 MDIO_PMA_REG_CTRL,
4446 pma_ctrl);
4447 break;
4448 case SPEED_100:
4449 autoneg_ctrl |= (1<<13);
4450 autoneg_ctrl &= ~(1<<6);
4451 DP(NETIF_MSG_LINK,
4452 "Setting 100M force\n");
4453 break;
4454 case SPEED_10:
4455 autoneg_ctrl &= ~(1<<13);
4456 autoneg_ctrl &= ~(1<<6);
4457 DP(NETIF_MSG_LINK,
4458 "Setting 10M force\n");
4459 break;
4460 }
4461
4462 /* Duplex mode */
4463 if (params->req_duplex == DUPLEX_FULL) {
4464 autoneg_ctrl |= (1<<8);
4465 DP(NETIF_MSG_LINK,
4466 "Setting full duplex\n");
4467 } else
4468 autoneg_ctrl &= ~(1<<8);
4469
4470 /* Update autoneg ctrl and pma ctrl */
4471 bnx2x_cl45_write(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 }
Eilon Greenstein28577182009-02-12 08:37:00 +00004478
Eilon Greensteinb1607af2009-08-12 08:22:54 +00004479 /* Save spirom version */
4480 bnx2x_save_8481_spirom_version(bp, params->port,
4481 ext_phy_addr,
4482 params->shmem_base);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004483 break;
4484 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
4485 DP(NETIF_MSG_LINK,
4486 "XGXS PHY Failure detected 0x%x\n",
4487 params->ext_phy_config);
4488 rc = -EINVAL;
4489 break;
4490 default:
4491 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
4492 params->ext_phy_config);
4493 rc = -EINVAL;
4494 break;
4495 }
4496
4497 } else { /* SerDes */
Yaniv Rosner57963ed2008-08-13 15:55:28 -07004498
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004499 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
4500 switch (ext_phy_type) {
4501 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
4502 DP(NETIF_MSG_LINK, "SerDes Direct\n");
4503 break;
4504
4505 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
4506 DP(NETIF_MSG_LINK, "SerDes 5482\n");
4507 break;
4508
4509 default:
4510 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
4511 params->ext_phy_config);
4512 break;
4513 }
4514 }
4515 return rc;
4516}
4517
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004518static void bnx2x_8727_handle_mod_abs(struct link_params *params)
4519{
4520 struct bnx2x *bp = params->bp;
4521 u16 mod_abs, rx_alarm_status;
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00004522 u8 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004523 u32 val = REG_RD(bp, params->shmem_base +
4524 offsetof(struct shmem_region, dev_info.
4525 port_feature_config[params->port].
4526 config));
4527 bnx2x_cl45_read(bp, params->port,
4528 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4529 ext_phy_addr,
4530 MDIO_PMA_DEVAD,
4531 MDIO_PMA_REG_PHY_IDENTIFIER, &mod_abs);
4532 if (mod_abs & (1<<8)) {
4533
4534 /* Module is absent */
4535 DP(NETIF_MSG_LINK, "MOD_ABS indication "
4536 "show module is absent\n");
4537
4538 /* 1. Set mod_abs to detect next module
4539 presence event
4540 2. Set EDC off by setting OPTXLOS signal input to low
4541 (bit 9).
4542 When the EDC is off it locks onto a reference clock and
4543 avoids becoming 'lost'.*/
4544 mod_abs &= ~((1<<8)|(1<<9));
4545 bnx2x_cl45_write(bp, params->port,
4546 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4547 ext_phy_addr,
4548 MDIO_PMA_DEVAD,
4549 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4550
4551 /* Clear RX alarm since it stays up as long as
4552 the mod_abs wasn't changed */
4553 bnx2x_cl45_read(bp, params->port,
4554 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4555 ext_phy_addr,
4556 MDIO_PMA_DEVAD,
4557 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4558
4559 } else {
4560 /* Module is present */
4561 DP(NETIF_MSG_LINK, "MOD_ABS indication "
4562 "show module is present\n");
4563 /* First thing, disable transmitter,
4564 and if the module is ok, the
4565 module_detection will enable it*/
4566
4567 /* 1. Set mod_abs to detect next module
4568 absent event ( bit 8)
4569 2. Restore the default polarity of the OPRXLOS signal and
4570 this signal will then correctly indicate the presence or
4571 absence of the Rx signal. (bit 9) */
4572 mod_abs |= ((1<<8)|(1<<9));
4573 bnx2x_cl45_write(bp, params->port,
4574 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4575 ext_phy_addr,
4576 MDIO_PMA_DEVAD,
4577 MDIO_PMA_REG_PHY_IDENTIFIER, mod_abs);
4578
4579 /* Clear RX alarm since it stays up as long as
4580 the mod_abs wasn't changed. This is need to be done
4581 before calling the module detection, otherwise it will clear
4582 the link update alarm */
4583 bnx2x_cl45_read(bp, params->port,
4584 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4585 ext_phy_addr,
4586 MDIO_PMA_DEVAD,
4587 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4588
4589
4590 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
4591 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
4592 bnx2x_sfp_set_transmitter(bp, params->port,
4593 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
4594 ext_phy_addr, 0);
4595
4596 if (bnx2x_wait_for_sfp_module_initialized(params)
4597 == 0)
4598 bnx2x_sfp_module_detection(params);
4599 else
4600 DP(NETIF_MSG_LINK, "SFP+ module is not initialized\n");
4601 }
4602
4603 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n",
4604 rx_alarm_status);
4605 /* No need to check link status in case of
4606 module plugged in/out */
4607}
4608
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004609
4610static u8 bnx2x_ext_phy_is_link_up(struct link_params *params,
Eilon Greenstein2f904462009-08-12 08:22:16 +00004611 struct link_vars *vars,
4612 u8 is_mi_int)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004613{
4614 struct bnx2x *bp = params->bp;
4615 u32 ext_phy_type;
4616 u8 ext_phy_addr;
4617 u16 val1 = 0, val2;
4618 u16 rx_sd, pcs_status;
4619 u8 ext_phy_link_up = 0;
4620 u8 port = params->port;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00004621
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004622 if (vars->phy_flags & PHY_XGXS_FLAG) {
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00004623 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004624 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
4625 switch (ext_phy_type) {
4626 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
4627 DP(NETIF_MSG_LINK, "XGXS Direct\n");
4628 ext_phy_link_up = 1;
4629 break;
4630
4631 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
4632 DP(NETIF_MSG_LINK, "XGXS 8705\n");
4633 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4634 ext_phy_addr,
4635 MDIO_WIS_DEVAD,
4636 MDIO_WIS_REG_LASI_STATUS, &val1);
4637 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4638
4639 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4640 ext_phy_addr,
4641 MDIO_WIS_DEVAD,
4642 MDIO_WIS_REG_LASI_STATUS, &val1);
4643 DP(NETIF_MSG_LINK, "8705 LASI status 0x%x\n", val1);
4644
4645 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4646 ext_phy_addr,
4647 MDIO_PMA_DEVAD,
4648 MDIO_PMA_REG_RX_SD, &rx_sd);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004649
4650 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4651 ext_phy_addr,
4652 1,
4653 0xc809, &val1);
4654 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4655 ext_phy_addr,
4656 1,
4657 0xc809, &val1);
4658
4659 DP(NETIF_MSG_LINK, "8705 1.c809 val=0x%x\n", val1);
4660 ext_phy_link_up = ((rx_sd & 0x1) && (val1 & (1<<9))
4661 && ((val1 & (1<<8)) == 0));
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07004662 if (ext_phy_link_up)
4663 vars->line_speed = SPEED_10000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004664 break;
4665
4666 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
Eilon Greenstein589abe32009-02-12 08:36:55 +00004667 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
4668 DP(NETIF_MSG_LINK, "XGXS 8706/8726\n");
4669 /* Clear RX Alarm*/
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004670 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4671 ext_phy_addr,
Eilon Greenstein589abe32009-02-12 08:36:55 +00004672 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_ALARM,
4673 &val2);
4674 /* clear LASI indication*/
4675 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4676 ext_phy_addr,
4677 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS,
4678 &val1);
4679 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4680 ext_phy_addr,
4681 MDIO_PMA_DEVAD, MDIO_PMA_REG_LASI_STATUS,
4682 &val2);
4683 DP(NETIF_MSG_LINK, "8706/8726 LASI status 0x%x-->"
4684 "0x%x\n", val1, val2);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004685
4686 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4687 ext_phy_addr,
Eilon Greenstein589abe32009-02-12 08:36:55 +00004688 MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD,
4689 &rx_sd);
4690 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4691 ext_phy_addr,
4692 MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS,
4693 &pcs_status);
4694 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4695 ext_phy_addr,
4696 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS,
4697 &val2);
4698 bnx2x_cl45_read(bp, params->port, ext_phy_type,
4699 ext_phy_addr,
4700 MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS,
4701 &val2);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004702
Eilon Greenstein589abe32009-02-12 08:36:55 +00004703 DP(NETIF_MSG_LINK, "8706/8726 rx_sd 0x%x"
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004704 " pcs_status 0x%x 1Gbps link_status 0x%x\n",
4705 rx_sd, pcs_status, val2);
4706 /* link is up if both bit 0 of pmd_rx_sd and
4707 * bit 0 of pcs_status are set, or if the autoneg bit
4708 1 is set
4709 */
4710 ext_phy_link_up = ((rx_sd & pcs_status & 0x1) ||
4711 (val2 & (1<<1)));
Yaniv Rosner57963ed2008-08-13 15:55:28 -07004712 if (ext_phy_link_up) {
Eilon Greenstein589abe32009-02-12 08:36:55 +00004713 if (ext_phy_type ==
4714 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) {
4715 /* If transmitter is disabled,
4716 ignore false link up indication */
4717 bnx2x_cl45_read(bp, params->port,
4718 ext_phy_type,
4719 ext_phy_addr,
4720 MDIO_PMA_DEVAD,
4721 MDIO_PMA_REG_PHY_IDENTIFIER,
4722 &val1);
4723 if (val1 & (1<<15)) {
4724 DP(NETIF_MSG_LINK, "Tx is "
4725 "disabled\n");
4726 ext_phy_link_up = 0;
4727 break;
4728 }
4729 }
Yaniv Rosner57963ed2008-08-13 15:55:28 -07004730 if (val2 & (1<<1))
4731 vars->line_speed = SPEED_1000;
4732 else
4733 vars->line_speed = SPEED_10000;
4734 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004735 break;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004736
4737 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
4738 {
4739 u16 link_status = 0;
4740 u16 rx_alarm_status;
4741 /* Check the LASI */
4742 bnx2x_cl45_read(bp, params->port,
4743 ext_phy_type,
4744 ext_phy_addr,
4745 MDIO_PMA_DEVAD,
4746 MDIO_PMA_REG_RX_ALARM, &rx_alarm_status);
4747
4748 DP(NETIF_MSG_LINK, "8727 RX_ALARM_STATUS 0x%x\n",
4749 rx_alarm_status);
4750
4751 bnx2x_cl45_read(bp, params->port,
4752 ext_phy_type,
4753 ext_phy_addr,
4754 MDIO_PMA_DEVAD,
4755 MDIO_PMA_REG_LASI_STATUS, &val1);
4756
4757 DP(NETIF_MSG_LINK,
4758 "8727 LASI status 0x%x\n",
4759 val1);
4760
4761 /* Clear MSG-OUT */
4762 bnx2x_cl45_read(bp, params->port,
4763 ext_phy_type,
4764 ext_phy_addr,
4765 MDIO_PMA_DEVAD,
4766 MDIO_PMA_REG_M8051_MSGOUT_REG,
4767 &val1);
4768
4769 /*
4770 * If a module is present and there is need to check
4771 * for over current
4772 */
4773 if (!(params->feature_config_flags &
4774 FEATURE_CONFIG_BCM8727_NOC) &&
4775 !(rx_alarm_status & (1<<5))) {
4776 /* Check over-current using 8727 GPIO0 input*/
4777 bnx2x_cl45_read(bp, params->port,
4778 ext_phy_type,
4779 ext_phy_addr,
4780 MDIO_PMA_DEVAD,
4781 MDIO_PMA_REG_8727_GPIO_CTRL,
4782 &val1);
4783
4784 if ((val1 & (1<<8)) == 0) {
4785 DP(NETIF_MSG_LINK, "8727 Power fault"
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00004786 " has been detected on "
4787 "port %d\n",
4788 params->port);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00004789 printk(KERN_ERR PFX "Error: Power"
4790 " fault on %s Port %d has"
4791 " been detected and the"
4792 " power to that SFP+ module"
4793 " has been removed to prevent"
4794 " failure of the card. Please"
4795 " remove the SFP+ module and"
4796 " restart the system to clear"
4797 " this error.\n"
4798 , bp->dev->name, params->port);
4799 /*
4800 * Disable all RX_ALARMs except for
4801 * mod_abs
4802 */
4803 bnx2x_cl45_write(bp, params->port,
4804 ext_phy_type,
4805 ext_phy_addr,
4806 MDIO_PMA_DEVAD,
4807 MDIO_PMA_REG_RX_ALARM_CTRL,
4808 (1<<5));
4809
4810 bnx2x_cl45_read(bp, params->port,
4811 ext_phy_type,
4812 ext_phy_addr,
4813 MDIO_PMA_DEVAD,
4814 MDIO_PMA_REG_PHY_IDENTIFIER,
4815 &val1);
4816 /* Wait for module_absent_event */
4817 val1 |= (1<<8);
4818 bnx2x_cl45_write(bp, params->port,
4819 ext_phy_type,
4820 ext_phy_addr,
4821 MDIO_PMA_DEVAD,
4822 MDIO_PMA_REG_PHY_IDENTIFIER,
4823 val1);
4824 /* Clear RX alarm */
4825 bnx2x_cl45_read(bp, params->port,
4826 ext_phy_type,
4827 ext_phy_addr,
4828 MDIO_PMA_DEVAD,
4829 MDIO_PMA_REG_RX_ALARM,
4830 &rx_alarm_status);
4831 break;
4832 }
4833 } /* Over current check */
4834
4835 /* When module absent bit is set, check module */
4836 if (rx_alarm_status & (1<<5)) {
4837 bnx2x_8727_handle_mod_abs(params);
4838 /* Enable all mod_abs and link detection bits */
4839 bnx2x_cl45_write(bp, params->port,
4840 ext_phy_type,
4841 ext_phy_addr,
4842 MDIO_PMA_DEVAD,
4843 MDIO_PMA_REG_RX_ALARM_CTRL,
4844 ((1<<5) | (1<<2)));
4845 }
4846
4847 /* If transmitter is disabled,
4848 ignore false link up indication */
4849 bnx2x_cl45_read(bp, params->port,
4850 ext_phy_type,
4851 ext_phy_addr,
4852 MDIO_PMA_DEVAD,
4853 MDIO_PMA_REG_PHY_IDENTIFIER,
4854 &val1);
4855 if (val1 & (1<<15)) {
4856 DP(NETIF_MSG_LINK, "Tx is disabled\n");
4857 ext_phy_link_up = 0;
4858 break;
4859 }
4860
4861 bnx2x_cl45_read(bp, params->port,
4862 ext_phy_type,
4863 ext_phy_addr,
4864 MDIO_PMA_DEVAD,
4865 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
4866 &link_status);
4867
4868 /* Bits 0..2 --> speed detected,
4869 bits 13..15--> link is down */
4870 if ((link_status & (1<<2)) &&
4871 (!(link_status & (1<<15)))) {
4872 ext_phy_link_up = 1;
4873 vars->line_speed = SPEED_10000;
4874 } else if ((link_status & (1<<0)) &&
4875 (!(link_status & (1<<13)))) {
4876 ext_phy_link_up = 1;
4877 vars->line_speed = SPEED_1000;
4878 DP(NETIF_MSG_LINK,
4879 "port %x: External link"
4880 " up in 1G\n", params->port);
4881 } else {
4882 ext_phy_link_up = 0;
4883 DP(NETIF_MSG_LINK,
4884 "port %x: External link"
4885 " is down\n", params->port);
4886 }
4887 break;
4888 }
4889
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004890 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
4891 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
4892 {
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004893 u16 link_status = 0;
4894 u16 an1000_status = 0;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00004895
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004896 if (ext_phy_type ==
4897 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) {
4898 bnx2x_cl45_read(bp, params->port,
4899 ext_phy_type,
4900 ext_phy_addr,
4901 MDIO_PCS_DEVAD,
4902 MDIO_PCS_REG_LASI_STATUS, &val1);
4903 bnx2x_cl45_read(bp, params->port,
4904 ext_phy_type,
4905 ext_phy_addr,
4906 MDIO_PCS_DEVAD,
4907 MDIO_PCS_REG_LASI_STATUS, &val2);
4908 DP(NETIF_MSG_LINK,
4909 "870x LASI status 0x%x->0x%x\n",
4910 val1, val2);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004911 } else {
4912 /* In 8073, port1 is directed through emac0 and
4913 * port0 is directed through emac1
4914 */
4915 bnx2x_cl45_read(bp, params->port,
4916 ext_phy_type,
4917 ext_phy_addr,
4918 MDIO_PMA_DEVAD,
4919 MDIO_PMA_REG_LASI_STATUS, &val1);
4920
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004921 DP(NETIF_MSG_LINK,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004922 "8703 LASI status 0x%x\n",
4923 val1);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004924 }
4925
4926 /* clear the interrupt LASI status register */
4927 bnx2x_cl45_read(bp, params->port,
4928 ext_phy_type,
4929 ext_phy_addr,
4930 MDIO_PCS_DEVAD,
4931 MDIO_PCS_REG_STATUS, &val2);
4932 bnx2x_cl45_read(bp, params->port,
4933 ext_phy_type,
4934 ext_phy_addr,
4935 MDIO_PCS_DEVAD,
4936 MDIO_PCS_REG_STATUS, &val1);
4937 DP(NETIF_MSG_LINK, "807x PCS status 0x%x->0x%x\n",
4938 val2, val1);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004939 /* Clear MSG-OUT */
4940 bnx2x_cl45_read(bp, params->port,
4941 ext_phy_type,
4942 ext_phy_addr,
4943 MDIO_PMA_DEVAD,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00004944 MDIO_PMA_REG_M8051_MSGOUT_REG,
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004945 &val1);
4946
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004947 /* Check the LASI */
4948 bnx2x_cl45_read(bp, params->port,
4949 ext_phy_type,
4950 ext_phy_addr,
4951 MDIO_PMA_DEVAD,
4952 MDIO_PMA_REG_RX_ALARM, &val2);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004953
4954 DP(NETIF_MSG_LINK, "KR 0x9003 0x%x\n", val2);
4955
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004956 /* Check the link status */
4957 bnx2x_cl45_read(bp, params->port,
4958 ext_phy_type,
4959 ext_phy_addr,
4960 MDIO_PCS_DEVAD,
4961 MDIO_PCS_REG_STATUS, &val2);
4962 DP(NETIF_MSG_LINK, "KR PCS status 0x%x\n", val2);
4963
4964 bnx2x_cl45_read(bp, params->port,
4965 ext_phy_type,
4966 ext_phy_addr,
4967 MDIO_PMA_DEVAD,
4968 MDIO_PMA_REG_STATUS, &val2);
4969 bnx2x_cl45_read(bp, params->port,
4970 ext_phy_type,
4971 ext_phy_addr,
4972 MDIO_PMA_DEVAD,
4973 MDIO_PMA_REG_STATUS, &val1);
4974 ext_phy_link_up = ((val1 & 4) == 4);
4975 DP(NETIF_MSG_LINK, "PMA_REG_STATUS=0x%x\n", val1);
4976 if (ext_phy_type ==
4977 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073) {
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004978
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004979 if (ext_phy_link_up &&
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004980 ((params->req_line_speed !=
4981 SPEED_10000))) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004982 if (bnx2x_bcm8073_xaui_wa(params)
4983 != 0) {
4984 ext_phy_link_up = 0;
4985 break;
4986 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07004987 }
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004988 bnx2x_cl45_read(bp, params->port,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00004989 ext_phy_type,
4990 ext_phy_addr,
4991 MDIO_AN_DEVAD,
4992 MDIO_AN_REG_LINK_STATUS,
4993 &an1000_status);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07004994 bnx2x_cl45_read(bp, params->port,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00004995 ext_phy_type,
4996 ext_phy_addr,
4997 MDIO_AN_DEVAD,
4998 MDIO_AN_REG_LINK_STATUS,
4999 &an1000_status);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005000
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005001 /* Check the link status on 1.1.2 */
5002 bnx2x_cl45_read(bp, params->port,
5003 ext_phy_type,
5004 ext_phy_addr,
5005 MDIO_PMA_DEVAD,
5006 MDIO_PMA_REG_STATUS, &val2);
5007 bnx2x_cl45_read(bp, params->port,
5008 ext_phy_type,
5009 ext_phy_addr,
5010 MDIO_PMA_DEVAD,
5011 MDIO_PMA_REG_STATUS, &val1);
5012 DP(NETIF_MSG_LINK, "KR PMA status 0x%x->0x%x,"
5013 "an_link_status=0x%x\n",
5014 val2, val1, an1000_status);
5015
Eilon Greenstein356e2382009-02-12 08:38:32 +00005016 ext_phy_link_up = (((val1 & 4) == 4) ||
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005017 (an1000_status & (1<<1)));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005018 if (ext_phy_link_up &&
5019 bnx2x_8073_is_snr_needed(params)) {
5020 /* The SNR will improve about 2dbby
5021 changing the BW and FEE main tap.*/
5022
5023 /* The 1st write to change FFE main
5024 tap is set before restart AN */
5025 /* Change PLL Bandwidth in EDC
5026 register */
5027 bnx2x_cl45_write(bp, port, ext_phy_type,
5028 ext_phy_addr,
5029 MDIO_PMA_DEVAD,
5030 MDIO_PMA_REG_PLL_BANDWIDTH,
5031 0x26BC);
5032
5033 /* Change CDR Bandwidth in EDC
5034 register */
5035 bnx2x_cl45_write(bp, port, ext_phy_type,
5036 ext_phy_addr,
5037 MDIO_PMA_DEVAD,
5038 MDIO_PMA_REG_CDR_BANDWIDTH,
5039 0x0333);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005040 }
5041 bnx2x_cl45_read(bp, params->port,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00005042 ext_phy_type,
5043 ext_phy_addr,
5044 MDIO_PMA_DEVAD,
5045 MDIO_PMA_REG_8073_SPEED_LINK_STATUS,
5046 &link_status);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005047
5048 /* Bits 0..2 --> speed detected,
5049 bits 13..15--> link is down */
5050 if ((link_status & (1<<2)) &&
5051 (!(link_status & (1<<15)))) {
5052 ext_phy_link_up = 1;
5053 vars->line_speed = SPEED_10000;
5054 DP(NETIF_MSG_LINK,
5055 "port %x: External link"
5056 " up in 10G\n", params->port);
5057 } else if ((link_status & (1<<1)) &&
5058 (!(link_status & (1<<14)))) {
5059 ext_phy_link_up = 1;
5060 vars->line_speed = SPEED_2500;
5061 DP(NETIF_MSG_LINK,
5062 "port %x: External link"
5063 " up in 2.5G\n", params->port);
5064 } else if ((link_status & (1<<0)) &&
5065 (!(link_status & (1<<13)))) {
5066 ext_phy_link_up = 1;
5067 vars->line_speed = SPEED_1000;
5068 DP(NETIF_MSG_LINK,
5069 "port %x: External link"
5070 " up in 1G\n", params->port);
5071 } else {
5072 ext_phy_link_up = 0;
5073 DP(NETIF_MSG_LINK,
5074 "port %x: External link"
5075 " is down\n", params->port);
5076 }
5077 } else {
5078 /* See if 1G link is up for the 8072 */
5079 bnx2x_cl45_read(bp, params->port,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00005080 ext_phy_type,
5081 ext_phy_addr,
5082 MDIO_AN_DEVAD,
5083 MDIO_AN_REG_LINK_STATUS,
5084 &an1000_status);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005085 bnx2x_cl45_read(bp, params->port,
Eilon Greenstein052a38e2009-02-12 08:37:16 +00005086 ext_phy_type,
5087 ext_phy_addr,
5088 MDIO_AN_DEVAD,
5089 MDIO_AN_REG_LINK_STATUS,
5090 &an1000_status);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005091 if (an1000_status & (1<<1)) {
5092 ext_phy_link_up = 1;
5093 vars->line_speed = SPEED_1000;
5094 DP(NETIF_MSG_LINK,
5095 "port %x: External link"
5096 " up in 1G\n", params->port);
5097 } else if (ext_phy_link_up) {
5098 ext_phy_link_up = 1;
5099 vars->line_speed = SPEED_10000;
5100 DP(NETIF_MSG_LINK,
5101 "port %x: External link"
5102 " up in 10G\n", params->port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005103 }
5104 }
Yaniv Rosner6bbca912008-08-13 15:57:28 -07005105
5106
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005107 break;
5108 }
5109 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5110 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5111 ext_phy_addr,
5112 MDIO_PMA_DEVAD,
5113 MDIO_PMA_REG_LASI_STATUS, &val2);
5114 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5115 ext_phy_addr,
5116 MDIO_PMA_DEVAD,
5117 MDIO_PMA_REG_LASI_STATUS, &val1);
5118 DP(NETIF_MSG_LINK,
5119 "10G-base-T LASI status 0x%x->0x%x\n",
5120 val2, val1);
5121 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5122 ext_phy_addr,
5123 MDIO_PMA_DEVAD,
5124 MDIO_PMA_REG_STATUS, &val2);
5125 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5126 ext_phy_addr,
5127 MDIO_PMA_DEVAD,
5128 MDIO_PMA_REG_STATUS, &val1);
5129 DP(NETIF_MSG_LINK,
5130 "10G-base-T PMA status 0x%x->0x%x\n",
5131 val2, val1);
5132 ext_phy_link_up = ((val1 & 4) == 4);
5133 /* if link is up
5134 * print the AN outcome of the SFX7101 PHY
5135 */
5136 if (ext_phy_link_up) {
5137 bnx2x_cl45_read(bp, params->port,
5138 ext_phy_type,
5139 ext_phy_addr,
5140 MDIO_AN_DEVAD,
5141 MDIO_AN_REG_MASTER_STATUS,
5142 &val2);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005143 vars->line_speed = SPEED_10000;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005144 DP(NETIF_MSG_LINK,
5145 "SFX7101 AN status 0x%x->Master=%x\n",
5146 val2,
5147 (val2 & (1<<14)));
5148 }
5149 break;
Eilon Greenstein28577182009-02-12 08:37:00 +00005150 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
Eilon Greenstein2f904462009-08-12 08:22:16 +00005151 /* Check 10G-BaseT link status */
5152 /* Check PMD signal ok */
5153 bnx2x_cl45_read(bp, params->port, ext_phy_type,
5154 ext_phy_addr,
5155 MDIO_AN_DEVAD,
5156 0xFFFA,
5157 &val1);
5158 bnx2x_cl45_read(bp, params->port, ext_phy_type,
Eilon Greenstein28577182009-02-12 08:37:00 +00005159 ext_phy_addr,
5160 MDIO_PMA_DEVAD,
Eilon Greenstein2f904462009-08-12 08:22:16 +00005161 MDIO_PMA_REG_8481_PMD_SIGNAL,
5162 &val2);
5163 DP(NETIF_MSG_LINK, "PMD_SIGNAL 1.a811 = 0x%x\n", val2);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005164
Eilon Greenstein2f904462009-08-12 08:22:16 +00005165 /* Check link 10G */
5166 if (val2 & (1<<11)) {
Eilon Greenstein28577182009-02-12 08:37:00 +00005167 vars->line_speed = SPEED_10000;
5168 ext_phy_link_up = 1;
Eilon Greenstein2f904462009-08-12 08:22:16 +00005169 bnx2x_8481_set_10G_led_mode(params,
5170 ext_phy_type,
5171 ext_phy_addr);
5172 } else { /* Check Legacy speed link */
5173 u16 legacy_status, legacy_speed;
Eilon Greenstein28577182009-02-12 08:37:00 +00005174
Eilon Greenstein2f904462009-08-12 08:22:16 +00005175 /* Enable expansion register 0x42
5176 (Operation mode status) */
5177 bnx2x_cl45_write(bp, params->port,
5178 ext_phy_type,
5179 ext_phy_addr,
5180 MDIO_AN_DEVAD,
5181 MDIO_AN_REG_8481_EXPANSION_REG_ACCESS,
5182 0xf42);
Eilon Greenstein28577182009-02-12 08:37:00 +00005183
Eilon Greenstein2f904462009-08-12 08:22:16 +00005184 /* Get legacy speed operation status */
5185 bnx2x_cl45_read(bp, params->port,
5186 ext_phy_type,
5187 ext_phy_addr,
5188 MDIO_AN_DEVAD,
5189 MDIO_AN_REG_8481_EXPANSION_REG_RD_RW,
5190 &legacy_status);
5191
5192 DP(NETIF_MSG_LINK, "Legacy speed status"
5193 " = 0x%x\n", legacy_status);
5194 ext_phy_link_up = ((legacy_status & (1<<11))
5195 == (1<<11));
5196 if (ext_phy_link_up) {
5197 legacy_speed = (legacy_status & (3<<9));
5198 if (legacy_speed == (0<<9))
5199 vars->line_speed = SPEED_10;
5200 else if (legacy_speed == (1<<9))
5201 vars->line_speed =
5202 SPEED_100;
5203 else if (legacy_speed == (2<<9))
5204 vars->line_speed =
5205 SPEED_1000;
5206 else /* Should not happen */
5207 vars->line_speed = 0;
5208
5209 if (legacy_status & (1<<8))
5210 vars->duplex = DUPLEX_FULL;
5211 else
5212 vars->duplex = DUPLEX_HALF;
5213
5214 DP(NETIF_MSG_LINK, "Link is up "
5215 "in %dMbps, is_duplex_full"
5216 "= %d\n",
5217 vars->line_speed,
5218 (vars->duplex == DUPLEX_FULL));
5219 bnx2x_8481_set_legacy_led_mode(params,
5220 ext_phy_type,
5221 ext_phy_addr);
Eilon Greenstein28577182009-02-12 08:37:00 +00005222 }
5223 }
Eilon Greenstein28577182009-02-12 08:37:00 +00005224 break;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005225 default:
5226 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
5227 params->ext_phy_config);
5228 ext_phy_link_up = 0;
5229 break;
5230 }
Eilon Greenstein57937202009-08-12 08:23:53 +00005231 /* Set SGMII mode for external phy */
5232 if (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) {
5233 if (vars->line_speed < SPEED_1000)
5234 vars->phy_flags |= PHY_SGMII_FLAG;
5235 else
5236 vars->phy_flags &= ~PHY_SGMII_FLAG;
5237 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005238
5239 } else { /* SerDes */
5240 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5241 switch (ext_phy_type) {
5242 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
5243 DP(NETIF_MSG_LINK, "SerDes Direct\n");
5244 ext_phy_link_up = 1;
5245 break;
5246
5247 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
5248 DP(NETIF_MSG_LINK, "SerDes 5482\n");
5249 ext_phy_link_up = 1;
5250 break;
5251
5252 default:
5253 DP(NETIF_MSG_LINK,
5254 "BAD SerDes ext_phy_config 0x%x\n",
5255 params->ext_phy_config);
5256 ext_phy_link_up = 0;
5257 break;
5258 }
5259 }
5260
5261 return ext_phy_link_up;
5262}
5263
5264static void bnx2x_link_int_enable(struct link_params *params)
5265{
5266 u8 port = params->port;
5267 u32 ext_phy_type;
5268 u32 mask;
5269 struct bnx2x *bp = params->bp;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005270
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005271 /* setting the status to report on link up
5272 for either XGXS or SerDes */
5273
5274 if (params->switch_cfg == SWITCH_CFG_10G) {
5275 mask = (NIG_MASK_XGXS0_LINK10G |
5276 NIG_MASK_XGXS0_LINK_STATUS);
5277 DP(NETIF_MSG_LINK, "enabled XGXS interrupt\n");
5278 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
5279 if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
5280 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
5281 (ext_phy_type !=
5282 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN)) {
5283 mask |= NIG_MASK_MI_INT;
5284 DP(NETIF_MSG_LINK, "enabled external phy int\n");
5285 }
5286
5287 } else { /* SerDes */
5288 mask = NIG_MASK_SERDES0_LINK_STATUS;
5289 DP(NETIF_MSG_LINK, "enabled SerDes interrupt\n");
5290 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5291 if ((ext_phy_type !=
5292 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT) &&
5293 (ext_phy_type !=
5294 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN)) {
5295 mask |= NIG_MASK_MI_INT;
5296 DP(NETIF_MSG_LINK, "enabled external phy int\n");
5297 }
5298 }
5299 bnx2x_bits_en(bp,
5300 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
5301 mask);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005302
5303 DP(NETIF_MSG_LINK, "port %x, is_xgxs %x, int_status 0x%x\n", port,
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005304 (params->switch_cfg == SWITCH_CFG_10G),
5305 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005306 DP(NETIF_MSG_LINK, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x\n",
5307 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
5308 REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port*0x18),
5309 REG_RD(bp, NIG_REG_SERDES0_STATUS_LINK_STATUS+port*0x3c));
5310 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
5311 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
5312 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
5313}
5314
Eilon Greenstein2f904462009-08-12 08:22:16 +00005315static void bnx2x_8481_rearm_latch_signal(struct bnx2x *bp, u8 port,
5316 u8 is_mi_int)
5317{
5318 u32 latch_status = 0, is_mi_int_status;
5319 /* Disable the MI INT ( external phy int )
5320 * by writing 1 to the status register. Link down indication
5321 * is high-active-signal, so in this case we need to write the
5322 * status to clear the XOR
5323 */
5324 /* Read Latched signals */
5325 latch_status = REG_RD(bp,
5326 NIG_REG_LATCH_STATUS_0 + port*8);
5327 is_mi_int_status = REG_RD(bp,
5328 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4);
5329 DP(NETIF_MSG_LINK, "original_signal = 0x%x, nig_status = 0x%x,"
5330 "latch_status = 0x%x\n",
5331 is_mi_int, is_mi_int_status, latch_status);
5332 /* Handle only those with latched-signal=up.*/
5333 if (latch_status & 1) {
5334 /* For all latched-signal=up,Write original_signal to status */
5335 if (is_mi_int)
5336 bnx2x_bits_en(bp,
5337 NIG_REG_STATUS_INTERRUPT_PORT0
5338 + port*4,
5339 NIG_STATUS_EMAC0_MI_INT);
5340 else
5341 bnx2x_bits_dis(bp,
5342 NIG_REG_STATUS_INTERRUPT_PORT0
5343 + port*4,
5344 NIG_STATUS_EMAC0_MI_INT);
5345 /* For all latched-signal=up : Re-Arm Latch signals */
5346 REG_WR(bp, NIG_REG_LATCH_STATUS_0 + port*8,
5347 (latch_status & 0xfffe) | (latch_status & 1));
5348 }
5349}
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005350/*
5351 * link management
5352 */
5353static void bnx2x_link_int_ack(struct link_params *params,
Eilon Greenstein2f904462009-08-12 08:22:16 +00005354 struct link_vars *vars, u8 is_10g,
5355 u8 is_mi_int)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005356{
5357 struct bnx2x *bp = params->bp;
5358 u8 port = params->port;
5359
5360 /* first reset all status
5361 * we assume only one line will be change at a time */
5362 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5363 (NIG_STATUS_XGXS0_LINK10G |
5364 NIG_STATUS_XGXS0_LINK_STATUS |
5365 NIG_STATUS_SERDES0_LINK_STATUS));
Eilon Greenstein2f904462009-08-12 08:22:16 +00005366 if (XGXS_EXT_PHY_TYPE(params->ext_phy_config)
5367 == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481) {
5368 bnx2x_8481_rearm_latch_signal(bp, port, is_mi_int);
5369 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005370 if (vars->phy_link_up) {
5371 if (is_10g) {
5372 /* Disable the 10G link interrupt
5373 * by writing 1 to the status register
5374 */
5375 DP(NETIF_MSG_LINK, "10G XGXS phy link up\n");
5376 bnx2x_bits_en(bp,
5377 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5378 NIG_STATUS_XGXS0_LINK10G);
5379
5380 } else if (params->switch_cfg == SWITCH_CFG_10G) {
5381 /* Disable the link interrupt
5382 * by writing 1 to the relevant lane
5383 * in the status register
5384 */
5385 u32 ser_lane = ((params->lane_config &
5386 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
5387 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
5388
Eilon Greenstein2f904462009-08-12 08:22:16 +00005389 DP(NETIF_MSG_LINK, "%d speed XGXS phy link up\n",
5390 vars->line_speed);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005391 bnx2x_bits_en(bp,
5392 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5393 ((1 << ser_lane) <<
5394 NIG_STATUS_XGXS0_LINK_STATUS_SIZE));
5395
5396 } else { /* SerDes */
5397 DP(NETIF_MSG_LINK, "SerDes phy link up\n");
5398 /* Disable the link interrupt
5399 * by writing 1 to the status register
5400 */
5401 bnx2x_bits_en(bp,
5402 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
5403 NIG_STATUS_SERDES0_LINK_STATUS);
5404 }
5405
5406 } else { /* link_down */
5407 }
5408}
5409
5410static u8 bnx2x_format_ver(u32 num, u8 *str, u16 len)
5411{
5412 u8 *str_ptr = str;
5413 u32 mask = 0xf0000000;
5414 u8 shift = 8*4;
5415 u8 digit;
5416 if (len < 10) {
Frederik Schwarzer025dfda2008-10-16 19:02:37 +02005417 /* Need more than 10chars for this format */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005418 *str_ptr = '\0';
5419 return -EINVAL;
5420 }
5421 while (shift > 0) {
5422
5423 shift -= 4;
5424 digit = ((num & mask) >> shift);
5425 if (digit < 0xa)
5426 *str_ptr = digit + '0';
5427 else
5428 *str_ptr = digit - 0xa + 'a';
5429 str_ptr++;
5430 mask = mask >> 4;
5431 if (shift == 4*4) {
5432 *str_ptr = ':';
5433 str_ptr++;
5434 }
5435 }
5436 *str_ptr = '\0';
5437 return 0;
5438}
5439
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005440u8 bnx2x_get_ext_phy_fw_version(struct link_params *params, u8 driver_loaded,
5441 u8 *version, u16 len)
5442{
Julia Lawall0376d5b2009-07-19 05:26:35 +00005443 struct bnx2x *bp;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005444 u32 ext_phy_type = 0;
Eilon Greensteina35da8d2009-02-12 08:37:02 +00005445 u32 spirom_ver = 0;
Eilon Greenstein97b41da2009-08-12 08:22:59 +00005446 u8 status;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005447
5448 if (version == NULL || params == NULL)
5449 return -EINVAL;
Julia Lawall0376d5b2009-07-19 05:26:35 +00005450 bp = params->bp;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005451
Eilon Greensteina35da8d2009-02-12 08:37:02 +00005452 spirom_ver = REG_RD(bp, params->shmem_base +
5453 offsetof(struct shmem_region,
5454 port_mb[params->port].ext_phy_fw_version));
5455
Eilon Greenstein97b41da2009-08-12 08:22:59 +00005456 status = 0;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005457 /* reset the returned value to zero */
5458 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005459 switch (ext_phy_type) {
5460 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5461
5462 if (len < 5)
5463 return -EINVAL;
5464
Eilon Greensteina35da8d2009-02-12 08:37:02 +00005465 version[0] = (spirom_ver & 0xFF);
5466 version[1] = (spirom_ver & 0xFF00) >> 8;
5467 version[2] = (spirom_ver & 0xFF0000) >> 16;
5468 version[3] = (spirom_ver & 0xFF000000) >> 24;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005469 version[4] = '\0';
5470
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005471 break;
5472 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
5473 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
Eilon Greenstein4d295db2009-07-21 05:47:47 +00005474 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005475 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
Eilon Greenstein589abe32009-02-12 08:36:55 +00005476 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
Eilon Greensteinb1607af2009-08-12 08:22:54 +00005477 status = bnx2x_format_ver(spirom_ver, version, len);
5478 break;
Eilon Greenstein9223dea2009-03-02 08:00:15 +00005479 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
Eilon Greensteinb1607af2009-08-12 08:22:54 +00005480 spirom_ver = ((spirom_ver & 0xF80) >> 7) << 16 |
5481 (spirom_ver & 0x7F);
Eilon Greensteina35da8d2009-02-12 08:37:02 +00005482 status = bnx2x_format_ver(spirom_ver, version, len);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005483 break;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005484 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
Eilon Greenstein97b41da2009-08-12 08:22:59 +00005485 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
5486 version[0] = '\0';
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005487 break;
5488
5489 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
5490 DP(NETIF_MSG_LINK, "bnx2x_get_ext_phy_fw_version:"
5491 " type is FAILURE!\n");
5492 status = -EINVAL;
5493 break;
5494
5495 default:
5496 break;
5497 }
5498 return status;
5499}
5500
5501static void bnx2x_set_xgxs_loopback(struct link_params *params,
5502 struct link_vars *vars,
5503 u8 is_10g)
5504{
5505 u8 port = params->port;
5506 struct bnx2x *bp = params->bp;
5507
5508 if (is_10g) {
Eilon Greenstein6378c022008-08-13 15:59:25 -07005509 u32 md_devad;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005510
5511 DP(NETIF_MSG_LINK, "XGXS 10G loopback enable\n");
5512
5513 /* change the uni_phy_addr in the nig */
5514 md_devad = REG_RD(bp, (NIG_REG_XGXS0_CTRL_MD_DEVAD +
5515 port*0x18));
5516
5517 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, 0x5);
5518
5519 bnx2x_cl45_write(bp, port, 0,
5520 params->phy_addr,
5521 5,
5522 (MDIO_REG_BANK_AER_BLOCK +
5523 (MDIO_AER_BLOCK_AER_REG & 0xf)),
5524 0x2800);
5525
5526 bnx2x_cl45_write(bp, port, 0,
5527 params->phy_addr,
5528 5,
5529 (MDIO_REG_BANK_CL73_IEEEB0 +
5530 (MDIO_CL73_IEEEB0_CL73_AN_CONTROL & 0xf)),
5531 0x6041);
Eilon Greenstein38582762009-01-14 06:44:16 +00005532 msleep(200);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005533 /* set aer mmd back */
5534 bnx2x_set_aer_mmd(params, vars);
5535
5536 /* and md_devad */
5537 REG_WR(bp, NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18,
5538 md_devad);
5539
5540 } else {
5541 u16 mii_control;
5542
5543 DP(NETIF_MSG_LINK, "XGXS 1G loopback enable\n");
5544
5545 CL45_RD_OVER_CL22(bp, port,
5546 params->phy_addr,
5547 MDIO_REG_BANK_COMBO_IEEE0,
5548 MDIO_COMBO_IEEE0_MII_CONTROL,
5549 &mii_control);
5550
5551 CL45_WR_OVER_CL22(bp, port,
5552 params->phy_addr,
5553 MDIO_REG_BANK_COMBO_IEEE0,
5554 MDIO_COMBO_IEEE0_MII_CONTROL,
5555 (mii_control |
5556 MDIO_COMBO_IEEO_MII_CONTROL_LOOPBACK));
5557 }
5558}
5559
5560
5561static void bnx2x_ext_phy_loopback(struct link_params *params)
5562{
5563 struct bnx2x *bp = params->bp;
5564 u8 ext_phy_addr;
5565 u32 ext_phy_type;
5566
5567 if (params->switch_cfg == SWITCH_CFG_10G) {
5568 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00005569 ext_phy_addr = XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005570 /* CL37 Autoneg Enabled */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005571 switch (ext_phy_type) {
5572 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
5573 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN:
5574 DP(NETIF_MSG_LINK,
5575 "ext_phy_loopback: We should not get here\n");
5576 break;
5577 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
5578 DP(NETIF_MSG_LINK, "ext_phy_loopback: 8705\n");
5579 break;
5580 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
5581 DP(NETIF_MSG_LINK, "ext_phy_loopback: 8706\n");
5582 break;
Eilon Greenstein589abe32009-02-12 08:36:55 +00005583 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
5584 DP(NETIF_MSG_LINK, "PMA/PMD ext_phy_loopback: 8726\n");
5585 bnx2x_cl45_write(bp, params->port, ext_phy_type,
5586 ext_phy_addr,
5587 MDIO_PMA_DEVAD,
5588 MDIO_PMA_REG_CTRL,
5589 0x0001);
5590 break;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005591 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5592 /* SFX7101_XGXS_TEST1 */
5593 bnx2x_cl45_write(bp, params->port, ext_phy_type,
5594 ext_phy_addr,
5595 MDIO_XS_DEVAD,
5596 MDIO_XS_SFX7101_XGXS_TEST1,
5597 0x100);
5598 DP(NETIF_MSG_LINK,
5599 "ext_phy_loopback: set ext phy loopback\n");
5600 break;
5601 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
5602
5603 break;
5604 } /* switch external PHY type */
5605 } else {
5606 /* serdes */
5607 ext_phy_type = SERDES_EXT_PHY_TYPE(params->ext_phy_config);
5608 ext_phy_addr = (params->ext_phy_config &
5609 PORT_HW_CFG_SERDES_EXT_PHY_ADDR_MASK)
5610 >> PORT_HW_CFG_SERDES_EXT_PHY_ADDR_SHIFT;
5611 }
5612}
5613
5614
5615/*
5616 *------------------------------------------------------------------------
5617 * bnx2x_override_led_value -
5618 *
5619 * Override the led value of the requsted led
5620 *
5621 *------------------------------------------------------------------------
5622 */
5623u8 bnx2x_override_led_value(struct bnx2x *bp, u8 port,
5624 u32 led_idx, u32 value)
5625{
5626 u32 reg_val;
5627
5628 /* If port 0 then use EMAC0, else use EMAC1*/
5629 u32 emac_base = (port) ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
5630
5631 DP(NETIF_MSG_LINK,
5632 "bnx2x_override_led_value() port %x led_idx %d value %d\n",
5633 port, led_idx, value);
5634
5635 switch (led_idx) {
5636 case 0: /* 10MB led */
5637 /* Read the current value of the LED register in
5638 the EMAC block */
5639 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5640 /* Set the OVERRIDE bit to 1 */
5641 reg_val |= EMAC_LED_OVERRIDE;
5642 /* If value is 1, set the 10M_OVERRIDE bit,
5643 otherwise reset it.*/
5644 reg_val = (value == 1) ? (reg_val | EMAC_LED_10MB_OVERRIDE) :
5645 (reg_val & ~EMAC_LED_10MB_OVERRIDE);
5646 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5647 break;
5648 case 1: /*100MB led */
5649 /*Read the current value of the LED register in
5650 the EMAC block */
5651 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5652 /* Set the OVERRIDE bit to 1 */
5653 reg_val |= EMAC_LED_OVERRIDE;
5654 /* If value is 1, set the 100M_OVERRIDE bit,
5655 otherwise reset it.*/
5656 reg_val = (value == 1) ? (reg_val | EMAC_LED_100MB_OVERRIDE) :
5657 (reg_val & ~EMAC_LED_100MB_OVERRIDE);
5658 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5659 break;
5660 case 2: /* 1000MB led */
5661 /* Read the current value of the LED register in the
5662 EMAC block */
5663 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5664 /* Set the OVERRIDE bit to 1 */
5665 reg_val |= EMAC_LED_OVERRIDE;
5666 /* If value is 1, set the 1000M_OVERRIDE bit, otherwise
5667 reset it. */
5668 reg_val = (value == 1) ? (reg_val | EMAC_LED_1000MB_OVERRIDE) :
5669 (reg_val & ~EMAC_LED_1000MB_OVERRIDE);
5670 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5671 break;
5672 case 3: /* 2500MB led */
5673 /* Read the current value of the LED register in the
5674 EMAC block*/
5675 reg_val = REG_RD(bp, emac_base + EMAC_REG_EMAC_LED);
5676 /* Set the OVERRIDE bit to 1 */
5677 reg_val |= EMAC_LED_OVERRIDE;
5678 /* If value is 1, set the 2500M_OVERRIDE bit, otherwise
5679 reset it.*/
5680 reg_val = (value == 1) ? (reg_val | EMAC_LED_2500MB_OVERRIDE) :
5681 (reg_val & ~EMAC_LED_2500MB_OVERRIDE);
5682 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5683 break;
5684 case 4: /*10G led */
5685 if (port == 0) {
5686 REG_WR(bp, NIG_REG_LED_10G_P0,
5687 value);
5688 } else {
5689 REG_WR(bp, NIG_REG_LED_10G_P1,
5690 value);
5691 }
5692 break;
5693 case 5: /* TRAFFIC led */
5694 /* Find if the traffic control is via BMAC or EMAC */
5695 if (port == 0)
5696 reg_val = REG_RD(bp, NIG_REG_NIG_EMAC0_EN);
5697 else
5698 reg_val = REG_RD(bp, NIG_REG_NIG_EMAC1_EN);
5699
5700 /* Override the traffic led in the EMAC:*/
5701 if (reg_val == 1) {
5702 /* Read the current value of the LED register in
5703 the EMAC block */
5704 reg_val = REG_RD(bp, emac_base +
5705 EMAC_REG_EMAC_LED);
5706 /* Set the TRAFFIC_OVERRIDE bit to 1 */
5707 reg_val |= EMAC_LED_OVERRIDE;
5708 /* If value is 1, set the TRAFFIC bit, otherwise
5709 reset it.*/
5710 reg_val = (value == 1) ? (reg_val | EMAC_LED_TRAFFIC) :
5711 (reg_val & ~EMAC_LED_TRAFFIC);
5712 REG_WR(bp, emac_base + EMAC_REG_EMAC_LED, reg_val);
5713 } else { /* Override the traffic led in the BMAC: */
5714 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0
5715 + port*4, 1);
5716 REG_WR(bp, NIG_REG_LED_CONTROL_TRAFFIC_P0 + port*4,
5717 value);
5718 }
5719 break;
5720 default:
5721 DP(NETIF_MSG_LINK,
5722 "bnx2x_override_led_value() unknown led index %d "
5723 "(should be 0-5)\n", led_idx);
5724 return -EINVAL;
5725 }
5726
5727 return 0;
5728}
5729
5730
5731u8 bnx2x_set_led(struct bnx2x *bp, u8 port, u8 mode, u32 speed,
5732 u16 hw_led_mode, u32 chip_id)
5733{
5734 u8 rc = 0;
Eilon Greenstein345b5d52008-08-13 15:58:12 -07005735 u32 tmp;
5736 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005737
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005738 DP(NETIF_MSG_LINK, "bnx2x_set_led: port %x, mode %d\n", port, mode);
5739 DP(NETIF_MSG_LINK, "speed 0x%x, hw_led_mode 0x%x\n",
5740 speed, hw_led_mode);
5741 switch (mode) {
5742 case LED_MODE_OFF:
5743 REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 0);
5744 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4,
5745 SHARED_HW_CFG_LED_MAC1);
Eilon Greenstein345b5d52008-08-13 15:58:12 -07005746
5747 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
Eilon Greenstein3196a882008-08-13 15:58:49 -07005748 EMAC_WR(bp, EMAC_REG_EMAC_LED, (tmp | EMAC_LED_OVERRIDE));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005749 break;
5750
5751 case LED_MODE_OPER:
5752 REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, hw_led_mode);
5753 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 +
5754 port*4, 0);
5755 /* Set blinking rate to ~15.9Hz */
5756 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_P0 + port*4,
5757 LED_BLINK_RATE_VAL);
5758 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_RATE_ENA_P0 +
5759 port*4, 1);
Eilon Greenstein345b5d52008-08-13 15:58:12 -07005760 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
Eilon Greenstein3196a882008-08-13 15:58:49 -07005761 EMAC_WR(bp, EMAC_REG_EMAC_LED,
Eilon Greenstein345b5d52008-08-13 15:58:12 -07005762 (tmp & (~EMAC_LED_OVERRIDE)));
5763
Eilon Greenstein34f80b02008-06-23 20:33:01 -07005764 if (!CHIP_IS_E1H(bp) &&
5765 ((speed == SPEED_2500) ||
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005766 (speed == SPEED_1000) ||
5767 (speed == SPEED_100) ||
5768 (speed == SPEED_10))) {
5769 /* On Everest 1 Ax chip versions for speeds less than
5770 10G LED scheme is different */
5771 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0
5772 + port*4, 1);
5773 REG_WR(bp, NIG_REG_LED_CONTROL_TRAFFIC_P0 +
5774 port*4, 0);
5775 REG_WR(bp, NIG_REG_LED_CONTROL_BLINK_TRAFFIC_P0 +
5776 port*4, 1);
5777 }
5778 break;
5779
5780 default:
5781 rc = -EINVAL;
5782 DP(NETIF_MSG_LINK, "bnx2x_set_led: Invalid led mode %d\n",
5783 mode);
5784 break;
5785 }
5786 return rc;
5787
5788}
5789
5790u8 bnx2x_test_link(struct link_params *params, struct link_vars *vars)
5791{
5792 struct bnx2x *bp = params->bp;
5793 u16 gp_status = 0;
5794
5795 CL45_RD_OVER_CL22(bp, params->port,
5796 params->phy_addr,
5797 MDIO_REG_BANK_GP_STATUS,
5798 MDIO_GP_STATUS_TOP_AN_STATUS1,
5799 &gp_status);
5800 /* link is up only if both local phy and external phy are up */
5801 if ((gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) &&
Eilon Greenstein2f904462009-08-12 08:22:16 +00005802 bnx2x_ext_phy_is_link_up(params, vars, 1))
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005803 return 0;
5804
5805 return -ESRCH;
5806}
5807
5808static u8 bnx2x_link_initialize(struct link_params *params,
5809 struct link_vars *vars)
5810{
5811 struct bnx2x *bp = params->bp;
5812 u8 port = params->port;
5813 u8 rc = 0;
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005814 u8 non_ext_phy;
5815 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005816
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005817 /* Activate the external PHY */
5818 bnx2x_ext_phy_reset(params, vars);
5819
5820 bnx2x_set_aer_mmd(params, vars);
5821
5822 if (vars->phy_flags & PHY_XGXS_FLAG)
5823 bnx2x_set_master_ln(params);
5824
5825 rc = bnx2x_reset_unicore(params);
5826 /* reset the SerDes and wait for reset bit return low */
5827 if (rc != 0)
5828 return rc;
5829
5830 bnx2x_set_aer_mmd(params, vars);
5831
5832 /* setting the masterLn_def again after the reset */
5833 if (vars->phy_flags & PHY_XGXS_FLAG) {
5834 bnx2x_set_master_ln(params);
5835 bnx2x_set_swap_lanes(params);
5836 }
5837
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005838 if (vars->phy_flags & PHY_XGXS_FLAG) {
Eilon Greenstein44722d12009-01-14 06:44:21 +00005839 if ((params->req_line_speed &&
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005840 ((params->req_line_speed == SPEED_100) ||
Eilon Greenstein44722d12009-01-14 06:44:21 +00005841 (params->req_line_speed == SPEED_10))) ||
5842 (!params->req_line_speed &&
5843 (params->speed_cap_mask >=
5844 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) &&
5845 (params->speed_cap_mask <
5846 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
5847 )) {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005848 vars->phy_flags |= PHY_SGMII_FLAG;
5849 } else {
5850 vars->phy_flags &= ~PHY_SGMII_FLAG;
5851 }
5852 }
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005853 /* In case of external phy existance, the line speed would be the
5854 line speed linked up by the external phy. In case it is direct only,
5855 then the line_speed during initialization will be equal to the
5856 req_line_speed*/
5857 vars->line_speed = params->req_line_speed;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005858
Yaniv Rosner8c99e7b2008-08-13 15:56:17 -07005859 bnx2x_calc_ieee_aneg_adv(params, &vars->ieee_fc);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005860
5861 /* init ext phy and enable link state int */
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005862 non_ext_phy = ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) ||
Eilon Greenstein8660d8c2009-03-02 08:01:02 +00005863 (params->loopback_mode == LOOPBACK_XGXS_10));
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005864
5865 if (non_ext_phy ||
Eilon Greenstein589abe32009-02-12 08:36:55 +00005866 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
Eilon Greenstein28577182009-02-12 08:37:00 +00005867 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) ||
Eilon Greenstein8660d8c2009-03-02 08:01:02 +00005868 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005869 if (params->req_line_speed == SPEED_AUTO_NEG)
5870 bnx2x_set_parallel_detection(params, vars->phy_flags);
Eilon Greenstein239d6862009-08-12 08:23:04 +00005871 bnx2x_init_internal_phy(params, vars, non_ext_phy);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005872 }
5873
5874 if (!non_ext_phy)
5875 rc |= bnx2x_ext_phy_init(params, vars);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005876
5877 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005878 (NIG_STATUS_XGXS0_LINK10G |
5879 NIG_STATUS_XGXS0_LINK_STATUS |
5880 NIG_STATUS_SERDES0_LINK_STATUS));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005881
5882 return rc;
5883
5884}
5885
5886
5887u8 bnx2x_phy_init(struct link_params *params, struct link_vars *vars)
5888{
5889 struct bnx2x *bp = params->bp;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005890 u32 val;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005891
5892 DP(NETIF_MSG_LINK, "Phy Initialization started\n");
5893 DP(NETIF_MSG_LINK, "req_speed %d, req_flowctrl %d\n",
5894 params->req_line_speed, params->req_flow_ctrl);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005895 vars->link_status = 0;
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005896 vars->phy_link_up = 0;
5897 vars->link_up = 0;
5898 vars->line_speed = 0;
5899 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08005900 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosner57963ed2008-08-13 15:55:28 -07005901 vars->mac_type = MAC_TYPE_NONE;
5902
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005903 if (params->switch_cfg == SWITCH_CFG_1G)
5904 vars->phy_flags = PHY_SERDES_FLAG;
5905 else
5906 vars->phy_flags = PHY_XGXS_FLAG;
5907
5908 /* disable attentions */
5909 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + params->port*4,
5910 (NIG_MASK_XGXS0_LINK_STATUS |
5911 NIG_MASK_XGXS0_LINK10G |
5912 NIG_MASK_SERDES0_LINK_STATUS |
5913 NIG_MASK_MI_INT));
5914
5915 bnx2x_emac_init(params, vars);
5916
5917 if (CHIP_REV_IS_FPGA(bp)) {
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005918
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005919 vars->link_up = 1;
5920 vars->line_speed = SPEED_10000;
5921 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08005922 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005923 vars->link_status = (LINK_STATUS_LINK_UP | LINK_10GTFD);
Eilon Greenstein34f80b02008-06-23 20:33:01 -07005924 /* enable on E1.5 FPGA */
5925 if (CHIP_IS_E1H(bp)) {
5926 vars->flow_ctrl |=
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005927 (BNX2X_FLOW_CTRL_TX |
5928 BNX2X_FLOW_CTRL_RX);
Eilon Greenstein34f80b02008-06-23 20:33:01 -07005929 vars->link_status |=
5930 (LINK_STATUS_TX_FLOW_CONTROL_ENABLED |
5931 LINK_STATUS_RX_FLOW_CONTROL_ENABLED);
5932 }
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005933
5934 bnx2x_emac_enable(params, vars, 0);
5935 bnx2x_pbf_update(params, vars->flow_ctrl, vars->line_speed);
5936 /* disable drain */
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005937 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005938
5939 /* update shared memory */
5940 bnx2x_update_mng(params, vars->link_status);
5941
5942 return 0;
5943
5944 } else
5945 if (CHIP_REV_IS_EMUL(bp)) {
5946
5947 vars->link_up = 1;
5948 vars->line_speed = SPEED_10000;
5949 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08005950 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005951 vars->link_status = (LINK_STATUS_LINK_UP | LINK_10GTFD);
5952
5953 bnx2x_bmac_enable(params, vars, 0);
5954
5955 bnx2x_pbf_update(params, vars->flow_ctrl, vars->line_speed);
5956 /* Disable drain */
5957 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
5958 + params->port*4, 0);
5959
5960 /* update shared memory */
5961 bnx2x_update_mng(params, vars->link_status);
5962
5963 return 0;
5964
5965 } else
5966 if (params->loopback_mode == LOOPBACK_BMAC) {
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005967
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005968 vars->link_up = 1;
5969 vars->line_speed = SPEED_10000;
5970 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08005971 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005972 vars->mac_type = MAC_TYPE_BMAC;
5973
5974 vars->phy_flags = PHY_XGXS_FLAG;
5975
5976 bnx2x_phy_deassert(params, vars->phy_flags);
5977 /* set bmac loopback */
5978 bnx2x_bmac_enable(params, vars, 1);
5979
5980 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
5981 params->port*4, 0);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005982
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005983 } else if (params->loopback_mode == LOOPBACK_EMAC) {
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00005984
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005985 vars->link_up = 1;
5986 vars->line_speed = SPEED_1000;
5987 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08005988 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07005989 vars->mac_type = MAC_TYPE_EMAC;
5990
5991 vars->phy_flags = PHY_XGXS_FLAG;
5992
5993 bnx2x_phy_deassert(params, vars->phy_flags);
5994 /* set bmac loopback */
5995 bnx2x_emac_enable(params, vars, 1);
5996 bnx2x_emac_program(params, vars->line_speed,
5997 vars->duplex);
5998 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
5999 params->port*4, 0);
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006000
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006001 } else if ((params->loopback_mode == LOOPBACK_XGXS_10) ||
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006002 (params->loopback_mode == LOOPBACK_EXT_PHY)) {
6003
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006004 vars->link_up = 1;
6005 vars->line_speed = SPEED_10000;
6006 vars->duplex = DUPLEX_FULL;
David S. Millerc0700f92008-12-16 23:53:20 -08006007 vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006008
6009 vars->phy_flags = PHY_XGXS_FLAG;
6010
6011 val = REG_RD(bp,
6012 NIG_REG_XGXS0_CTRL_PHY_ADDR+
6013 params->port*0x18);
6014 params->phy_addr = (u8)val;
6015
6016 bnx2x_phy_deassert(params, vars->phy_flags);
6017 bnx2x_link_initialize(params, vars);
6018
6019 vars->mac_type = MAC_TYPE_BMAC;
6020
6021 bnx2x_bmac_enable(params, vars, 0);
6022
6023 if (params->loopback_mode == LOOPBACK_XGXS_10) {
6024 /* set 10G XGXS loopback */
6025 bnx2x_set_xgxs_loopback(params, vars, 1);
6026 } else {
6027 /* set external phy loopback */
6028 bnx2x_ext_phy_loopback(params);
6029 }
6030 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE +
6031 params->port*4, 0);
Eilon Greensteinba71d312009-07-21 05:47:49 +00006032
6033 bnx2x_set_led(bp, params->port, LED_MODE_OPER,
6034 vars->line_speed, params->hw_led_mode,
6035 params->chip_id);
6036
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006037 } else
6038 /* No loopback */
6039 {
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006040 bnx2x_phy_deassert(params, vars->phy_flags);
6041 switch (params->switch_cfg) {
6042 case SWITCH_CFG_1G:
6043 vars->phy_flags |= PHY_SERDES_FLAG;
6044 if ((params->ext_phy_config &
6045 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_MASK) ==
6046 PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482) {
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006047 vars->phy_flags |= PHY_SGMII_FLAG;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006048 }
6049
6050 val = REG_RD(bp,
6051 NIG_REG_SERDES0_CTRL_PHY_ADDR+
6052 params->port*0x10);
6053
6054 params->phy_addr = (u8)val;
6055
6056 break;
6057 case SWITCH_CFG_10G:
6058 vars->phy_flags |= PHY_XGXS_FLAG;
6059 val = REG_RD(bp,
6060 NIG_REG_XGXS0_CTRL_PHY_ADDR+
6061 params->port*0x18);
6062 params->phy_addr = (u8)val;
6063
6064 break;
6065 default:
6066 DP(NETIF_MSG_LINK, "Invalid switch_cfg\n");
6067 return -EINVAL;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006068 }
Eilon Greensteinf5372252009-02-12 08:38:30 +00006069 DP(NETIF_MSG_LINK, "Phy address = 0x%x\n", params->phy_addr);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006070
6071 bnx2x_link_initialize(params, vars);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006072 msleep(30);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006073 bnx2x_link_int_enable(params);
6074 }
6075 return 0;
6076}
6077
Eilon Greenstein589abe32009-02-12 08:36:55 +00006078static void bnx2x_8726_reset_phy(struct bnx2x *bp, u8 port, u8 ext_phy_addr)
6079{
6080 DP(NETIF_MSG_LINK, "bnx2x_8726_reset_phy port %d\n", port);
6081
6082 /* Set serial boot control for external load */
6083 bnx2x_cl45_write(bp, port,
6084 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726, ext_phy_addr,
6085 MDIO_PMA_DEVAD,
6086 MDIO_PMA_REG_GEN_CTRL, 0x0001);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006087}
6088
6089u8 bnx2x_link_reset(struct link_params *params, struct link_vars *vars,
6090 u8 reset_ext_phy)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006091{
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006092 struct bnx2x *bp = params->bp;
6093 u32 ext_phy_config = params->ext_phy_config;
6094 u16 hw_led_mode = params->hw_led_mode;
6095 u32 chip_id = params->chip_id;
6096 u8 port = params->port;
6097 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006098 u32 val = REG_RD(bp, params->shmem_base +
6099 offsetof(struct shmem_region, dev_info.
6100 port_feature_config[params->port].
6101 config));
6102
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006103 /* disable attentions */
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006104 vars->link_status = 0;
6105 bnx2x_update_mng(params, vars->link_status);
6106 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6107 (NIG_MASK_XGXS0_LINK_STATUS |
6108 NIG_MASK_XGXS0_LINK10G |
6109 NIG_MASK_SERDES0_LINK_STATUS |
6110 NIG_MASK_MI_INT));
6111
6112 /* activate nig drain */
6113 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
6114
6115 /* disable nig egress interface */
6116 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
6117 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
6118
6119 /* Stop BigMac rx */
6120 bnx2x_bmac_rx_disable(bp, port);
6121
6122 /* disable emac */
6123 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6124
6125 msleep(10);
6126 /* The PHY reset is controled by GPIO 1
6127 * Hold it as vars low
6128 */
6129 /* clear link led */
6130 bnx2x_set_led(bp, port, LED_MODE_OFF, 0, hw_led_mode, chip_id);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006131 if (reset_ext_phy) {
6132 switch (ext_phy_type) {
6133 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
6134 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
6135 break;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006136
6137 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
6138 {
6139
6140 /* Disable Transmitter */
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00006141 u8 ext_phy_addr =
6142 XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006143 if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
6144 PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
6145 bnx2x_sfp_set_transmitter(bp, port,
6146 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6147 ext_phy_addr, 0);
6148 break;
6149 }
Eilon Greenstein589abe32009-02-12 08:36:55 +00006150 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
6151 DP(NETIF_MSG_LINK, "Setting 8073 port %d into "
6152 "low power mode\n",
6153 port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006154 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
Eilon Greenstein17de50b2008-08-13 15:56:59 -07006155 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6156 port);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006157 break;
6158 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
6159 {
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00006160 u8 ext_phy_addr =
6161 XGXS_EXT_PHY_ADDR(params->ext_phy_config);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006162 /* Set soft reset */
6163 bnx2x_8726_reset_phy(bp, params->port, ext_phy_addr);
6164 break;
6165 }
6166 default:
6167 /* HW reset */
6168 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
6169 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6170 port);
6171 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6172 MISC_REGISTERS_GPIO_OUTPUT_LOW,
6173 port);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006174 DP(NETIF_MSG_LINK, "reset external PHY\n");
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006175 }
6176 }
6177 /* reset the SerDes/XGXS */
6178 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
6179 (0x1ff << (port*16)));
6180
6181 /* reset BigMac */
6182 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
6183 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
6184
6185 /* disable nig ingress interface */
6186 REG_WR(bp, NIG_REG_BMAC0_IN_EN + port*4, 0);
6187 REG_WR(bp, NIG_REG_EMAC0_IN_EN + port*4, 0);
6188 REG_WR(bp, NIG_REG_BMAC0_OUT_EN + port*4, 0);
6189 REG_WR(bp, NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
6190 vars->link_up = 0;
6191 return 0;
6192}
6193
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006194static u8 bnx2x_update_link_down(struct link_params *params,
6195 struct link_vars *vars)
6196{
6197 struct bnx2x *bp = params->bp;
6198 u8 port = params->port;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006199
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006200 DP(NETIF_MSG_LINK, "Port %x: Link is down\n", port);
6201 bnx2x_set_led(bp, port, LED_MODE_OFF,
6202 0, params->hw_led_mode,
6203 params->chip_id);
6204
6205 /* indicate no mac active */
6206 vars->mac_type = MAC_TYPE_NONE;
6207
6208 /* update shared memory */
6209 vars->link_status = 0;
6210 vars->line_speed = 0;
6211 bnx2x_update_mng(params, vars->link_status);
6212
6213 /* activate nig drain */
6214 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
6215
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00006216 /* disable emac */
6217 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6218
6219 msleep(10);
6220
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006221 /* reset BigMac */
6222 bnx2x_bmac_rx_disable(bp, params->port);
6223 REG_WR(bp, GRCBASE_MISC +
6224 MISC_REGISTERS_RESET_REG_2_CLEAR,
6225 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
6226 return 0;
6227}
6228
6229static u8 bnx2x_update_link_up(struct link_params *params,
6230 struct link_vars *vars,
6231 u8 link_10g, u32 gp_status)
6232{
6233 struct bnx2x *bp = params->bp;
6234 u8 port = params->port;
6235 u8 rc = 0;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006236
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006237 vars->link_status |= LINK_STATUS_LINK_UP;
6238 if (link_10g) {
6239 bnx2x_bmac_enable(params, vars, 0);
6240 bnx2x_set_led(bp, port, LED_MODE_OPER,
6241 SPEED_10000, params->hw_led_mode,
6242 params->chip_id);
6243
6244 } else {
6245 bnx2x_emac_enable(params, vars, 0);
6246 rc = bnx2x_emac_program(params, vars->line_speed,
6247 vars->duplex);
6248
6249 /* AN complete? */
6250 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) {
6251 if (!(vars->phy_flags &
6252 PHY_SGMII_FLAG))
Eilon Greensteined8680a2009-02-12 08:37:12 +00006253 bnx2x_set_gmii_tx_driver(params);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006254 }
6255 }
6256
6257 /* PBF - link up */
6258 rc |= bnx2x_pbf_update(params, vars->flow_ctrl,
6259 vars->line_speed);
6260
6261 /* disable drain */
6262 REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 0);
6263
6264 /* update shared memory */
6265 bnx2x_update_mng(params, vars->link_status);
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00006266 msleep(20);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006267 return rc;
6268}
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006269/* This function should called upon link interrupt */
6270/* In case vars->link_up, driver needs to
6271 1. Update the pbf
6272 2. Disable drain
6273 3. Update the shared memory
6274 4. Indicate link up
6275 5. Set LEDs
6276 Otherwise,
6277 1. Update shared memory
6278 2. Reset BigMac
6279 3. Report link down
6280 4. Unset LEDs
6281*/
6282u8 bnx2x_link_update(struct link_params *params, struct link_vars *vars)
6283{
6284 struct bnx2x *bp = params->bp;
6285 u8 port = params->port;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006286 u16 gp_status;
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006287 u8 link_10g;
6288 u8 ext_phy_link_up, rc = 0;
6289 u32 ext_phy_type;
Eilon Greenstein2f904462009-08-12 08:22:16 +00006290 u8 is_mi_int = 0;
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006291
6292 DP(NETIF_MSG_LINK, "port %x, XGXS?%x, int_status 0x%x\n",
Eilon Greenstein2f904462009-08-12 08:22:16 +00006293 port, (vars->phy_flags & PHY_XGXS_FLAG),
6294 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006295
Eilon Greenstein2f904462009-08-12 08:22:16 +00006296 is_mi_int = (u8)(REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT +
6297 port*0x18) > 0);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006298 DP(NETIF_MSG_LINK, "int_mask 0x%x MI_INT %x, SERDES_LINK %x\n",
Eilon Greenstein2f904462009-08-12 08:22:16 +00006299 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4),
6300 is_mi_int,
6301 REG_RD(bp,
6302 NIG_REG_SERDES0_STATUS_LINK_STATUS + port*0x3c));
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006303
6304 DP(NETIF_MSG_LINK, " 10G %x, XGXS_LINK %x\n",
6305 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
6306 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
6307
Eilon Greenstein6c55c3cd2009-01-14 06:44:13 +00006308 /* disable emac */
6309 REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
6310
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006311 ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006312
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006313 /* Check external link change only for non-direct */
Eilon Greenstein2f904462009-08-12 08:22:16 +00006314 ext_phy_link_up = bnx2x_ext_phy_is_link_up(params, vars, is_mi_int);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006315
6316 /* Read gp_status */
6317 CL45_RD_OVER_CL22(bp, port, params->phy_addr,
6318 MDIO_REG_BANK_GP_STATUS,
6319 MDIO_GP_STATUS_TOP_AN_STATUS1,
6320 &gp_status);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006321
Eilon Greenstein2f904462009-08-12 08:22:16 +00006322 rc = bnx2x_link_settings_status(params, vars, gp_status,
6323 ext_phy_link_up);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006324 if (rc != 0)
6325 return rc;
6326
6327 /* anything 10 and over uses the bmac */
6328 link_10g = ((vars->line_speed == SPEED_10000) ||
6329 (vars->line_speed == SPEED_12000) ||
6330 (vars->line_speed == SPEED_12500) ||
6331 (vars->line_speed == SPEED_13000) ||
6332 (vars->line_speed == SPEED_15000) ||
6333 (vars->line_speed == SPEED_16000));
6334
Eilon Greenstein2f904462009-08-12 08:22:16 +00006335 bnx2x_link_int_ack(params, vars, link_10g, is_mi_int);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006336
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006337 /* In case external phy link is up, and internal link is down
6338 ( not initialized yet probably after link initialization, it needs
6339 to be initialized.
6340 Note that after link down-up as result of cable plug,
6341 the xgxs link would probably become up again without the need to
6342 initialize it*/
6343
6344 if ((ext_phy_type != PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT) &&
6345 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) &&
Eilon Greenstein589abe32009-02-12 08:36:55 +00006346 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726) &&
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006347 (ext_phy_link_up && !vars->phy_link_up))
Eilon Greenstein239d6862009-08-12 08:23:04 +00006348 bnx2x_init_internal_phy(params, vars, 0);
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006349
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006350 /* link is up only if both local phy and external phy are up */
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006351 vars->link_up = (ext_phy_link_up && vars->phy_link_up);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006352
Yaniv Rosner57963ed2008-08-13 15:55:28 -07006353 if (vars->link_up)
6354 rc = bnx2x_update_link_up(params, vars, link_10g, gp_status);
6355 else
6356 rc = bnx2x_update_link_down(params, vars);
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006357
6358 return rc;
6359}
6360
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006361static u8 bnx2x_8073_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6362{
6363 u8 ext_phy_addr[PORT_MAX];
6364 u16 val;
6365 s8 port;
6366
6367 /* PART1 - Reset both phys */
6368 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
6369 /* Extract the ext phy address for the port */
6370 u32 ext_phy_config = REG_RD(bp, shmem_base +
6371 offsetof(struct shmem_region,
6372 dev_info.port_hw_config[port].external_phy_config));
6373
6374 /* disable attentions */
6375 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6376 (NIG_MASK_XGXS0_LINK_STATUS |
6377 NIG_MASK_XGXS0_LINK10G |
6378 NIG_MASK_SERDES0_LINK_STATUS |
6379 NIG_MASK_MI_INT));
6380
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00006381 ext_phy_addr[port] = XGXS_EXT_PHY_ADDR(ext_phy_config);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006382
6383 /* Need to take the phy out of low power mode in order
6384 to write to access its registers */
6385 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6386 MISC_REGISTERS_GPIO_OUTPUT_HIGH, port);
6387
6388 /* Reset the phy */
6389 bnx2x_cl45_write(bp, port,
6390 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6391 ext_phy_addr[port],
6392 MDIO_PMA_DEVAD,
6393 MDIO_PMA_REG_CTRL,
6394 1<<15);
6395 }
6396
6397 /* Add delay of 150ms after reset */
6398 msleep(150);
6399
6400 /* PART2 - Download firmware to both phys */
6401 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
6402 u16 fw_ver1;
6403
6404 bnx2x_bcm8073_external_rom_boot(bp, port,
Eilon Greensteina35da8d2009-02-12 08:37:02 +00006405 ext_phy_addr[port], shmem_base);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006406
6407 bnx2x_cl45_read(bp, port, PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6408 ext_phy_addr[port],
6409 MDIO_PMA_DEVAD,
6410 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
Eilon Greenstein16b311c2009-01-14 06:44:24 +00006411 if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006412 DP(NETIF_MSG_LINK,
Eilon Greenstein16b311c2009-01-14 06:44:24 +00006413 "bnx2x_8073_common_init_phy port %x:"
6414 "Download failed. fw version = 0x%x\n",
6415 port, fw_ver1);
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006416 return -EINVAL;
6417 }
6418
6419 /* Only set bit 10 = 1 (Tx power down) */
6420 bnx2x_cl45_read(bp, port,
6421 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6422 ext_phy_addr[port],
6423 MDIO_PMA_DEVAD,
6424 MDIO_PMA_REG_TX_POWER_DOWN, &val);
6425
6426 /* Phase1 of TX_POWER_DOWN reset */
6427 bnx2x_cl45_write(bp, port,
6428 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6429 ext_phy_addr[port],
6430 MDIO_PMA_DEVAD,
6431 MDIO_PMA_REG_TX_POWER_DOWN,
6432 (val | 1<<10));
6433 }
6434
6435 /* Toggle Transmitter: Power down and then up with 600ms
6436 delay between */
6437 msleep(600);
6438
6439 /* PART3 - complete TX_POWER_DOWN process, and set GPIO2 back to low */
6440 for (port = PORT_MAX - 1; port >= PORT_0; port--) {
Eilon Greensteinf5372252009-02-12 08:38:30 +00006441 /* Phase2 of POWER_DOWN_RESET */
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006442 /* Release bit 10 (Release Tx power down) */
6443 bnx2x_cl45_read(bp, port,
6444 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6445 ext_phy_addr[port],
6446 MDIO_PMA_DEVAD,
6447 MDIO_PMA_REG_TX_POWER_DOWN, &val);
6448
6449 bnx2x_cl45_write(bp, port,
6450 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6451 ext_phy_addr[port],
6452 MDIO_PMA_DEVAD,
6453 MDIO_PMA_REG_TX_POWER_DOWN, (val & (~(1<<10))));
6454 msleep(15);
6455
6456 /* Read modify write the SPI-ROM version select register */
6457 bnx2x_cl45_read(bp, port,
6458 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073,
6459 ext_phy_addr[port],
6460 MDIO_PMA_DEVAD,
6461 MDIO_PMA_REG_EDC_FFE_MAIN, &val);
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_EDC_FFE_MAIN, (val | (1<<12)));
6467
6468 /* set GPIO2 back to LOW */
6469 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
6470 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
6471 }
6472 return 0;
6473
6474}
6475
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006476static u8 bnx2x_8727_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6477{
6478 u8 ext_phy_addr[PORT_MAX];
Eilon Greensteinbc7f0a02009-08-12 08:23:01 +00006479 s8 port, first_port, i;
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006480 u32 swap_val, swap_override;
6481 DP(NETIF_MSG_LINK, "Executing BCM8727 common init\n");
6482 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
6483 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
6484
Eilon Greensteinf57a6022009-08-12 08:23:11 +00006485 bnx2x_ext_phy_hw_reset(bp, 1 ^ (swap_val && swap_override));
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006486 msleep(5);
6487
Eilon Greensteinbc7f0a02009-08-12 08:23:01 +00006488 if (swap_val && swap_override)
6489 first_port = PORT_0;
6490 else
6491 first_port = PORT_1;
6492
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006493 /* PART1 - Reset both phys */
Eilon Greensteinbc7f0a02009-08-12 08:23:01 +00006494 for (i = 0, port = first_port; i < PORT_MAX; i++, port = !port) {
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006495 /* Extract the ext phy address for the port */
6496 u32 ext_phy_config = REG_RD(bp, shmem_base +
6497 offsetof(struct shmem_region,
6498 dev_info.port_hw_config[port].external_phy_config));
6499
6500 /* disable attentions */
6501 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
6502 (NIG_MASK_XGXS0_LINK_STATUS |
6503 NIG_MASK_XGXS0_LINK10G |
6504 NIG_MASK_SERDES0_LINK_STATUS |
6505 NIG_MASK_MI_INT));
6506
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00006507 ext_phy_addr[port] = XGXS_EXT_PHY_ADDR(ext_phy_config);
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006508
6509 /* Reset the phy */
6510 bnx2x_cl45_write(bp, port,
6511 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6512 ext_phy_addr[port],
6513 MDIO_PMA_DEVAD,
6514 MDIO_PMA_REG_CTRL,
6515 1<<15);
6516 }
6517
6518 /* Add delay of 150ms after reset */
6519 msleep(150);
6520
6521 /* PART2 - Download firmware to both phys */
Eilon Greensteinbc7f0a02009-08-12 08:23:01 +00006522 for (i = 0, port = first_port; i < PORT_MAX; i++, port = !port) {
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006523 u16 fw_ver1;
6524
6525 bnx2x_bcm8727_external_rom_boot(bp, port,
6526 ext_phy_addr[port], shmem_base);
6527
6528 bnx2x_cl45_read(bp, port, PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
6529 ext_phy_addr[port],
6530 MDIO_PMA_DEVAD,
6531 MDIO_PMA_REG_ROM_VER1, &fw_ver1);
6532 if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
6533 DP(NETIF_MSG_LINK,
Eilon Greensteinbc7f0a02009-08-12 08:23:01 +00006534 "bnx2x_8727_common_init_phy port %x:"
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006535 "Download failed. fw version = 0x%x\n",
6536 port, fw_ver1);
6537 return -EINVAL;
6538 }
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006539 }
6540
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006541 return 0;
6542}
6543
Eilon Greenstein589abe32009-02-12 08:36:55 +00006544
6545static u8 bnx2x_8726_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6546{
6547 u8 ext_phy_addr;
6548 u32 val;
6549 s8 port;
Eilon Greensteinab6ad5a2009-08-12 08:24:29 +00006550
Eilon Greenstein589abe32009-02-12 08:36:55 +00006551 /* Use port1 because of the static port-swap */
6552 /* Enable the module detection interrupt */
6553 val = REG_RD(bp, MISC_REG_GPIO_EVENT_EN);
6554 val |= ((1<<MISC_REGISTERS_GPIO_3)|
6555 (1<<(MISC_REGISTERS_GPIO_3 + MISC_REGISTERS_GPIO_PORT_SHIFT)));
6556 REG_WR(bp, MISC_REG_GPIO_EVENT_EN, val);
6557
Eilon Greensteinf57a6022009-08-12 08:23:11 +00006558 bnx2x_ext_phy_hw_reset(bp, 1);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006559 msleep(5);
6560 for (port = 0; port < PORT_MAX; port++) {
6561 /* Extract the ext phy address for the port */
6562 u32 ext_phy_config = REG_RD(bp, shmem_base +
6563 offsetof(struct shmem_region,
6564 dev_info.port_hw_config[port].external_phy_config));
6565
Eilon Greenstein659bc5c2009-08-12 08:24:02 +00006566 ext_phy_addr = XGXS_EXT_PHY_ADDR(ext_phy_config);
Eilon Greenstein589abe32009-02-12 08:36:55 +00006567 DP(NETIF_MSG_LINK, "8726_common_init : ext_phy_addr = 0x%x\n",
6568 ext_phy_addr);
6569
6570 bnx2x_8726_reset_phy(bp, port, ext_phy_addr);
6571
6572 /* Set fault module detected LED on */
6573 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_0,
6574 MISC_REGISTERS_GPIO_HIGH,
6575 port);
6576 }
6577
6578 return 0;
6579}
6580
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006581u8 bnx2x_common_init_phy(struct bnx2x *bp, u32 shmem_base)
6582{
6583 u8 rc = 0;
6584 u32 ext_phy_type;
6585
Eilon Greensteinf5372252009-02-12 08:38:30 +00006586 DP(NETIF_MSG_LINK, "Begin common phy init\n");
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006587
6588 /* Read the ext_phy_type for arbitrary port(0) */
6589 ext_phy_type = XGXS_EXT_PHY_TYPE(
6590 REG_RD(bp, shmem_base +
6591 offsetof(struct shmem_region,
6592 dev_info.port_hw_config[0].external_phy_config)));
6593
6594 switch (ext_phy_type) {
6595 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
6596 {
6597 rc = bnx2x_8073_common_init_phy(bp, shmem_base);
6598 break;
6599 }
Eilon Greenstein4d295db2009-07-21 05:47:47 +00006600
6601 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
6602 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727_NOC:
6603 rc = bnx2x_8727_common_init_phy(bp, shmem_base);
6604 break;
6605
Eilon Greenstein589abe32009-02-12 08:36:55 +00006606 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
6607 /* GPIO1 affects both ports, so there's need to pull
6608 it for single port alone */
6609 rc = bnx2x_8726_common_init_phy(bp, shmem_base);
6610
6611 break;
Yaniv Rosner6bbca912008-08-13 15:57:28 -07006612 default:
6613 DP(NETIF_MSG_LINK,
6614 "bnx2x_common_init_phy: ext_phy 0x%x not required\n",
6615 ext_phy_type);
6616 break;
6617 }
6618
6619 return rc;
6620}
6621
Eilon Greensteinf57a6022009-08-12 08:23:11 +00006622void bnx2x_sfx7101_sp_sw_reset(struct bnx2x *bp, u8 port, u8 phy_addr)
Yaniv Rosnerea4e0402008-06-23 20:27:26 -07006623{
6624 u16 val, cnt;
6625
6626 bnx2x_cl45_read(bp, port,
6627 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6628 phy_addr,
6629 MDIO_PMA_DEVAD,
6630 MDIO_PMA_REG_7101_RESET, &val);
6631
6632 for (cnt = 0; cnt < 10; cnt++) {
6633 msleep(50);
6634 /* Writes a self-clearing reset */
6635 bnx2x_cl45_write(bp, port,
6636 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6637 phy_addr,
6638 MDIO_PMA_DEVAD,
6639 MDIO_PMA_REG_7101_RESET,
6640 (val | (1<<15)));
6641 /* Wait for clear */
6642 bnx2x_cl45_read(bp, port,
6643 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101,
6644 phy_addr,
6645 MDIO_PMA_DEVAD,
6646 MDIO_PMA_REG_7101_RESET, &val);
6647
6648 if ((val & (1<<15)) == 0)
6649 break;
6650 }
6651}