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