2 * Copyright (C) 2003 - 2009 NetXen, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
23 * Contact Information:
27 * Cupertino, CA 95014-0701
31 #include "netxen_nic.h"
32 #include "netxen_nic_hw.h"
33 #include "netxen_nic_phan_reg.h"
35 #include <linux/firmware.h>
38 #define MASK(n) ((1ULL<<(n))-1)
39 #define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | ((addr >> 25) & 0x3ff))
40 #define OCM_WIN(addr) (((addr & 0x1ff0000) >> 1) | ((addr >> 25) & 0x3ff))
41 #define MS_WIN(addr) (addr & 0x0ffc0000)
43 #define GET_MEM_OFFS_2M(addr) (addr & MASK(18))
45 #define CRB_BLK(off) ((off >> 20) & 0x3f)
46 #define CRB_SUBBLK(off) ((off >> 16) & 0xf)
47 #define CRB_WINDOW_2M (0x130060)
48 #define CRB_HI(off) ((crb_hub_agt[CRB_BLK(off)] << 20) | ((off) & 0xf0000))
49 #define CRB_INDIRECT_2M (0x1e0000UL)
51 #define CRB_WIN_LOCK_TIMEOUT 100000000
52 static crb_128M_2M_block_map_t crb_128M_2M_map
[64] = {
53 {{{0, 0, 0, 0} } }, /* 0: PCI */
54 {{{1, 0x0100000, 0x0102000, 0x120000}, /* 1: PCIE */
55 {1, 0x0110000, 0x0120000, 0x130000},
56 {1, 0x0120000, 0x0122000, 0x124000},
57 {1, 0x0130000, 0x0132000, 0x126000},
58 {1, 0x0140000, 0x0142000, 0x128000},
59 {1, 0x0150000, 0x0152000, 0x12a000},
60 {1, 0x0160000, 0x0170000, 0x110000},
61 {1, 0x0170000, 0x0172000, 0x12e000},
62 {0, 0x0000000, 0x0000000, 0x000000},
63 {0, 0x0000000, 0x0000000, 0x000000},
64 {0, 0x0000000, 0x0000000, 0x000000},
65 {0, 0x0000000, 0x0000000, 0x000000},
66 {0, 0x0000000, 0x0000000, 0x000000},
67 {0, 0x0000000, 0x0000000, 0x000000},
68 {1, 0x01e0000, 0x01e0800, 0x122000},
69 {0, 0x0000000, 0x0000000, 0x000000} } },
70 {{{1, 0x0200000, 0x0210000, 0x180000} } },/* 2: MN */
71 {{{0, 0, 0, 0} } }, /* 3: */
72 {{{1, 0x0400000, 0x0401000, 0x169000} } },/* 4: P2NR1 */
73 {{{1, 0x0500000, 0x0510000, 0x140000} } },/* 5: SRE */
74 {{{1, 0x0600000, 0x0610000, 0x1c0000} } },/* 6: NIU */
75 {{{1, 0x0700000, 0x0704000, 0x1b8000} } },/* 7: QM */
76 {{{1, 0x0800000, 0x0802000, 0x170000}, /* 8: SQM0 */
77 {0, 0x0000000, 0x0000000, 0x000000},
78 {0, 0x0000000, 0x0000000, 0x000000},
79 {0, 0x0000000, 0x0000000, 0x000000},
80 {0, 0x0000000, 0x0000000, 0x000000},
81 {0, 0x0000000, 0x0000000, 0x000000},
82 {0, 0x0000000, 0x0000000, 0x000000},
83 {0, 0x0000000, 0x0000000, 0x000000},
84 {0, 0x0000000, 0x0000000, 0x000000},
85 {0, 0x0000000, 0x0000000, 0x000000},
86 {0, 0x0000000, 0x0000000, 0x000000},
87 {0, 0x0000000, 0x0000000, 0x000000},
88 {0, 0x0000000, 0x0000000, 0x000000},
89 {0, 0x0000000, 0x0000000, 0x000000},
90 {0, 0x0000000, 0x0000000, 0x000000},
91 {1, 0x08f0000, 0x08f2000, 0x172000} } },
92 {{{1, 0x0900000, 0x0902000, 0x174000}, /* 9: SQM1*/
93 {0, 0x0000000, 0x0000000, 0x000000},
94 {0, 0x0000000, 0x0000000, 0x000000},
95 {0, 0x0000000, 0x0000000, 0x000000},
96 {0, 0x0000000, 0x0000000, 0x000000},
97 {0, 0x0000000, 0x0000000, 0x000000},
98 {0, 0x0000000, 0x0000000, 0x000000},
99 {0, 0x0000000, 0x0000000, 0x000000},
100 {0, 0x0000000, 0x0000000, 0x000000},
101 {0, 0x0000000, 0x0000000, 0x000000},
102 {0, 0x0000000, 0x0000000, 0x000000},
103 {0, 0x0000000, 0x0000000, 0x000000},
104 {0, 0x0000000, 0x0000000, 0x000000},
105 {0, 0x0000000, 0x0000000, 0x000000},
106 {0, 0x0000000, 0x0000000, 0x000000},
107 {1, 0x09f0000, 0x09f2000, 0x176000} } },
108 {{{0, 0x0a00000, 0x0a02000, 0x178000}, /* 10: SQM2*/
109 {0, 0x0000000, 0x0000000, 0x000000},
110 {0, 0x0000000, 0x0000000, 0x000000},
111 {0, 0x0000000, 0x0000000, 0x000000},
112 {0, 0x0000000, 0x0000000, 0x000000},
113 {0, 0x0000000, 0x0000000, 0x000000},
114 {0, 0x0000000, 0x0000000, 0x000000},
115 {0, 0x0000000, 0x0000000, 0x000000},
116 {0, 0x0000000, 0x0000000, 0x000000},
117 {0, 0x0000000, 0x0000000, 0x000000},
118 {0, 0x0000000, 0x0000000, 0x000000},
119 {0, 0x0000000, 0x0000000, 0x000000},
120 {0, 0x0000000, 0x0000000, 0x000000},
121 {0, 0x0000000, 0x0000000, 0x000000},
122 {0, 0x0000000, 0x0000000, 0x000000},
123 {1, 0x0af0000, 0x0af2000, 0x17a000} } },
124 {{{0, 0x0b00000, 0x0b02000, 0x17c000}, /* 11: SQM3*/
125 {0, 0x0000000, 0x0000000, 0x000000},
126 {0, 0x0000000, 0x0000000, 0x000000},
127 {0, 0x0000000, 0x0000000, 0x000000},
128 {0, 0x0000000, 0x0000000, 0x000000},
129 {0, 0x0000000, 0x0000000, 0x000000},
130 {0, 0x0000000, 0x0000000, 0x000000},
131 {0, 0x0000000, 0x0000000, 0x000000},
132 {0, 0x0000000, 0x0000000, 0x000000},
133 {0, 0x0000000, 0x0000000, 0x000000},
134 {0, 0x0000000, 0x0000000, 0x000000},
135 {0, 0x0000000, 0x0000000, 0x000000},
136 {0, 0x0000000, 0x0000000, 0x000000},
137 {0, 0x0000000, 0x0000000, 0x000000},
138 {0, 0x0000000, 0x0000000, 0x000000},
139 {1, 0x0bf0000, 0x0bf2000, 0x17e000} } },
140 {{{1, 0x0c00000, 0x0c04000, 0x1d4000} } },/* 12: I2Q */
141 {{{1, 0x0d00000, 0x0d04000, 0x1a4000} } },/* 13: TMR */
142 {{{1, 0x0e00000, 0x0e04000, 0x1a0000} } },/* 14: ROMUSB */
143 {{{1, 0x0f00000, 0x0f01000, 0x164000} } },/* 15: PEG4 */
144 {{{0, 0x1000000, 0x1004000, 0x1a8000} } },/* 16: XDMA */
145 {{{1, 0x1100000, 0x1101000, 0x160000} } },/* 17: PEG0 */
146 {{{1, 0x1200000, 0x1201000, 0x161000} } },/* 18: PEG1 */
147 {{{1, 0x1300000, 0x1301000, 0x162000} } },/* 19: PEG2 */
148 {{{1, 0x1400000, 0x1401000, 0x163000} } },/* 20: PEG3 */
149 {{{1, 0x1500000, 0x1501000, 0x165000} } },/* 21: P2ND */
150 {{{1, 0x1600000, 0x1601000, 0x166000} } },/* 22: P2NI */
151 {{{0, 0, 0, 0} } }, /* 23: */
152 {{{0, 0, 0, 0} } }, /* 24: */
153 {{{0, 0, 0, 0} } }, /* 25: */
154 {{{0, 0, 0, 0} } }, /* 26: */
155 {{{0, 0, 0, 0} } }, /* 27: */
156 {{{0, 0, 0, 0} } }, /* 28: */
157 {{{1, 0x1d00000, 0x1d10000, 0x190000} } },/* 29: MS */
158 {{{1, 0x1e00000, 0x1e01000, 0x16a000} } },/* 30: P2NR2 */
159 {{{1, 0x1f00000, 0x1f10000, 0x150000} } },/* 31: EPG */
160 {{{0} } }, /* 32: PCI */
161 {{{1, 0x2100000, 0x2102000, 0x120000}, /* 33: PCIE */
162 {1, 0x2110000, 0x2120000, 0x130000},
163 {1, 0x2120000, 0x2122000, 0x124000},
164 {1, 0x2130000, 0x2132000, 0x126000},
165 {1, 0x2140000, 0x2142000, 0x128000},
166 {1, 0x2150000, 0x2152000, 0x12a000},
167 {1, 0x2160000, 0x2170000, 0x110000},
168 {1, 0x2170000, 0x2172000, 0x12e000},
169 {0, 0x0000000, 0x0000000, 0x000000},
170 {0, 0x0000000, 0x0000000, 0x000000},
171 {0, 0x0000000, 0x0000000, 0x000000},
172 {0, 0x0000000, 0x0000000, 0x000000},
173 {0, 0x0000000, 0x0000000, 0x000000},
174 {0, 0x0000000, 0x0000000, 0x000000},
175 {0, 0x0000000, 0x0000000, 0x000000},
176 {0, 0x0000000, 0x0000000, 0x000000} } },
177 {{{1, 0x2200000, 0x2204000, 0x1b0000} } },/* 34: CAM */
183 {{{1, 0x2800000, 0x2804000, 0x1a4000} } },/* 40: TMR */
184 {{{1, 0x2900000, 0x2901000, 0x16b000} } },/* 41: P2NR3 */
185 {{{1, 0x2a00000, 0x2a00400, 0x1ac400} } },/* 42: RPMX1 */
186 {{{1, 0x2b00000, 0x2b00400, 0x1ac800} } },/* 43: RPMX2 */
187 {{{1, 0x2c00000, 0x2c00400, 0x1acc00} } },/* 44: RPMX3 */
188 {{{1, 0x2d00000, 0x2d00400, 0x1ad000} } },/* 45: RPMX4 */
189 {{{1, 0x2e00000, 0x2e00400, 0x1ad400} } },/* 46: RPMX5 */
190 {{{1, 0x2f00000, 0x2f00400, 0x1ad800} } },/* 47: RPMX6 */
191 {{{1, 0x3000000, 0x3000400, 0x1adc00} } },/* 48: RPMX7 */
192 {{{0, 0x3100000, 0x3104000, 0x1a8000} } },/* 49: XDMA */
193 {{{1, 0x3200000, 0x3204000, 0x1d4000} } },/* 50: I2Q */
194 {{{1, 0x3300000, 0x3304000, 0x1a0000} } },/* 51: ROMUSB */
196 {{{1, 0x3500000, 0x3500400, 0x1ac000} } },/* 53: RPMX0 */
197 {{{1, 0x3600000, 0x3600400, 0x1ae000} } },/* 54: RPMX8 */
198 {{{1, 0x3700000, 0x3700400, 0x1ae400} } },/* 55: RPMX9 */
199 {{{1, 0x3800000, 0x3804000, 0x1d0000} } },/* 56: OCM0 */
200 {{{1, 0x3900000, 0x3904000, 0x1b4000} } },/* 57: CRYPTO */
201 {{{1, 0x3a00000, 0x3a04000, 0x1d8000} } },/* 58: SMB */
202 {{{0} } }, /* 59: I2C0 */
203 {{{0} } }, /* 60: I2C1 */
204 {{{1, 0x3d00000, 0x3d04000, 0x1d8000} } },/* 61: LPC */
205 {{{1, 0x3e00000, 0x3e01000, 0x167000} } },/* 62: P2NC */
206 {{{1, 0x3f00000, 0x3f01000, 0x168000} } } /* 63: P2NR0 */
210 * top 12 bits of crb internal address (hub, agent)
212 static unsigned crb_hub_agt
[64] =
215 NETXEN_HW_CRB_HUB_AGT_ADR_PS
,
216 NETXEN_HW_CRB_HUB_AGT_ADR_MN
,
217 NETXEN_HW_CRB_HUB_AGT_ADR_MS
,
219 NETXEN_HW_CRB_HUB_AGT_ADR_SRE
,
220 NETXEN_HW_CRB_HUB_AGT_ADR_NIU
,
221 NETXEN_HW_CRB_HUB_AGT_ADR_QMN
,
222 NETXEN_HW_CRB_HUB_AGT_ADR_SQN0
,
223 NETXEN_HW_CRB_HUB_AGT_ADR_SQN1
,
224 NETXEN_HW_CRB_HUB_AGT_ADR_SQN2
,
225 NETXEN_HW_CRB_HUB_AGT_ADR_SQN3
,
226 NETXEN_HW_CRB_HUB_AGT_ADR_I2Q
,
227 NETXEN_HW_CRB_HUB_AGT_ADR_TIMR
,
228 NETXEN_HW_CRB_HUB_AGT_ADR_ROMUSB
,
229 NETXEN_HW_CRB_HUB_AGT_ADR_PGN4
,
230 NETXEN_HW_CRB_HUB_AGT_ADR_XDMA
,
231 NETXEN_HW_CRB_HUB_AGT_ADR_PGN0
,
232 NETXEN_HW_CRB_HUB_AGT_ADR_PGN1
,
233 NETXEN_HW_CRB_HUB_AGT_ADR_PGN2
,
234 NETXEN_HW_CRB_HUB_AGT_ADR_PGN3
,
235 NETXEN_HW_CRB_HUB_AGT_ADR_PGND
,
236 NETXEN_HW_CRB_HUB_AGT_ADR_PGNI
,
237 NETXEN_HW_CRB_HUB_AGT_ADR_PGS0
,
238 NETXEN_HW_CRB_HUB_AGT_ADR_PGS1
,
239 NETXEN_HW_CRB_HUB_AGT_ADR_PGS2
,
240 NETXEN_HW_CRB_HUB_AGT_ADR_PGS3
,
242 NETXEN_HW_CRB_HUB_AGT_ADR_PGSI
,
243 NETXEN_HW_CRB_HUB_AGT_ADR_SN
,
245 NETXEN_HW_CRB_HUB_AGT_ADR_EG
,
247 NETXEN_HW_CRB_HUB_AGT_ADR_PS
,
248 NETXEN_HW_CRB_HUB_AGT_ADR_CAM
,
254 NETXEN_HW_CRB_HUB_AGT_ADR_TIMR
,
256 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX1
,
257 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX2
,
258 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX3
,
259 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX4
,
260 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX5
,
261 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX6
,
262 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX7
,
263 NETXEN_HW_CRB_HUB_AGT_ADR_XDMA
,
264 NETXEN_HW_CRB_HUB_AGT_ADR_I2Q
,
265 NETXEN_HW_CRB_HUB_AGT_ADR_ROMUSB
,
267 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX0
,
268 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX8
,
269 NETXEN_HW_CRB_HUB_AGT_ADR_RPMX9
,
270 NETXEN_HW_CRB_HUB_AGT_ADR_OCM0
,
272 NETXEN_HW_CRB_HUB_AGT_ADR_SMB
,
273 NETXEN_HW_CRB_HUB_AGT_ADR_I2C0
,
274 NETXEN_HW_CRB_HUB_AGT_ADR_I2C1
,
276 NETXEN_HW_CRB_HUB_AGT_ADR_PGNC
,
280 /* PCI Windowing for DDR regions. */
282 #define ADDR_IN_RANGE(addr, low, high) \
283 (((addr) <= (high)) && ((addr) >= (low)))
285 #define NETXEN_WINDOW_ONE 0x2000000 /*CRB Window: bit 25 of CRB address */
287 #define NETXEN_NIC_ZERO_PAUSE_ADDR 0ULL
288 #define NETXEN_NIC_UNIT_PAUSE_ADDR 0x200ULL
289 #define NETXEN_NIC_EPG_PAUSE_ADDR1 0x2200010000c28001ULL
290 #define NETXEN_NIC_EPG_PAUSE_ADDR2 0x0100088866554433ULL
292 #define NETXEN_NIC_WINDOW_MARGIN 0x100000
294 int netxen_nic_set_mac(struct net_device
*netdev
, void *p
)
296 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
297 struct sockaddr
*addr
= p
;
299 if (netif_running(netdev
))
302 if (!is_valid_ether_addr(addr
->sa_data
))
303 return -EADDRNOTAVAIL
;
305 memcpy(netdev
->dev_addr
, addr
->sa_data
, netdev
->addr_len
);
307 /* For P3, MAC addr is not set in NIU */
308 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
309 if (adapter
->macaddr_set
)
310 adapter
->macaddr_set(adapter
, addr
->sa_data
);
315 #define NETXEN_UNICAST_ADDR(port, index) \
316 (NETXEN_UNICAST_ADDR_BASE+(port*32)+(index*8))
317 #define NETXEN_MCAST_ADDR(port, index) \
318 (NETXEN_MULTICAST_ADDR_BASE+(port*0x80)+(index*8))
319 #define MAC_HI(addr) \
320 ((addr[2] << 16) | (addr[1] << 8) | (addr[0]))
321 #define MAC_LO(addr) \
322 ((addr[5] << 16) | (addr[4] << 8) | (addr[3]))
325 netxen_nic_enable_mcast_filter(struct netxen_adapter
*adapter
)
328 u16 port
= adapter
->physical_port
;
329 u8
*addr
= adapter
->netdev
->dev_addr
;
331 if (adapter
->mc_enabled
)
334 adapter
->hw_read_wx(adapter
, NETXEN_MAC_ADDR_CNTL_REG
, &val
, 4);
335 val
|= (1UL << (28+port
));
336 adapter
->hw_write_wx(adapter
, NETXEN_MAC_ADDR_CNTL_REG
, &val
, 4);
338 /* add broadcast addr to filter */
340 netxen_crb_writelit_adapter(adapter
, NETXEN_UNICAST_ADDR(port
, 0), val
);
341 netxen_crb_writelit_adapter(adapter
,
342 NETXEN_UNICAST_ADDR(port
, 0)+4, val
);
344 /* add station addr to filter */
346 netxen_crb_writelit_adapter(adapter
, NETXEN_UNICAST_ADDR(port
, 1), val
);
348 netxen_crb_writelit_adapter(adapter
,
349 NETXEN_UNICAST_ADDR(port
, 1)+4, val
);
351 adapter
->mc_enabled
= 1;
356 netxen_nic_disable_mcast_filter(struct netxen_adapter
*adapter
)
359 u16 port
= adapter
->physical_port
;
360 u8
*addr
= adapter
->netdev
->dev_addr
;
362 if (!adapter
->mc_enabled
)
365 adapter
->hw_read_wx(adapter
, NETXEN_MAC_ADDR_CNTL_REG
, &val
, 4);
366 val
&= ~(1UL << (28+port
));
367 adapter
->hw_write_wx(adapter
, NETXEN_MAC_ADDR_CNTL_REG
, &val
, 4);
370 netxen_crb_writelit_adapter(adapter
, NETXEN_UNICAST_ADDR(port
, 0), val
);
372 netxen_crb_writelit_adapter(adapter
,
373 NETXEN_UNICAST_ADDR(port
, 0)+4, val
);
375 netxen_crb_writelit_adapter(adapter
, NETXEN_UNICAST_ADDR(port
, 1), 0);
376 netxen_crb_writelit_adapter(adapter
, NETXEN_UNICAST_ADDR(port
, 1)+4, 0);
378 adapter
->mc_enabled
= 0;
383 netxen_nic_set_mcast_addr(struct netxen_adapter
*adapter
,
387 u16 port
= adapter
->physical_port
;
392 netxen_crb_writelit_adapter(adapter
,
393 NETXEN_MCAST_ADDR(port
, index
), hi
);
394 netxen_crb_writelit_adapter(adapter
,
395 NETXEN_MCAST_ADDR(port
, index
)+4, lo
);
400 void netxen_p2_nic_set_multi(struct net_device
*netdev
)
402 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
403 struct dev_mc_list
*mc_ptr
;
407 memset(null_addr
, 0, 6);
409 if (netdev
->flags
& IFF_PROMISC
) {
411 adapter
->set_promisc(adapter
,
412 NETXEN_NIU_PROMISC_MODE
);
414 /* Full promiscuous mode */
415 netxen_nic_disable_mcast_filter(adapter
);
420 if (netdev
->mc_count
== 0) {
421 adapter
->set_promisc(adapter
,
422 NETXEN_NIU_NON_PROMISC_MODE
);
423 netxen_nic_disable_mcast_filter(adapter
);
427 adapter
->set_promisc(adapter
, NETXEN_NIU_ALLMULTI_MODE
);
428 if (netdev
->flags
& IFF_ALLMULTI
||
429 netdev
->mc_count
> adapter
->max_mc_count
) {
430 netxen_nic_disable_mcast_filter(adapter
);
434 netxen_nic_enable_mcast_filter(adapter
);
436 for (mc_ptr
= netdev
->mc_list
; mc_ptr
; mc_ptr
= mc_ptr
->next
, index
++)
437 netxen_nic_set_mcast_addr(adapter
, index
, mc_ptr
->dmi_addr
);
439 if (index
!= netdev
->mc_count
)
440 printk(KERN_WARNING
"%s: %s multicast address count mismatch\n",
441 netxen_nic_driver_name
, netdev
->name
);
443 /* Clear out remaining addresses */
444 for (; index
< adapter
->max_mc_count
; index
++)
445 netxen_nic_set_mcast_addr(adapter
, index
, null_addr
);
448 static int nx_p3_nic_add_mac(struct netxen_adapter
*adapter
,
449 u8
*addr
, nx_mac_list_t
**add_list
, nx_mac_list_t
**del_list
)
451 nx_mac_list_t
*cur
, *prev
;
453 /* if in del_list, move it to adapter->mac_list */
454 for (cur
= *del_list
, prev
= NULL
; cur
;) {
455 if (memcmp(addr
, cur
->mac_addr
, ETH_ALEN
) == 0) {
457 *del_list
= cur
->next
;
459 prev
->next
= cur
->next
;
460 cur
->next
= adapter
->mac_list
;
461 adapter
->mac_list
= cur
;
468 /* make sure to add each mac address only once */
469 for (cur
= adapter
->mac_list
; cur
; cur
= cur
->next
) {
470 if (memcmp(addr
, cur
->mac_addr
, ETH_ALEN
) == 0)
473 /* not in del_list, create new entry and add to add_list */
474 cur
= kmalloc(sizeof(*cur
), in_atomic()? GFP_ATOMIC
: GFP_KERNEL
);
476 printk(KERN_ERR
"%s: cannot allocate memory. MAC filtering may"
477 "not work properly from now.\n", __func__
);
481 memcpy(cur
->mac_addr
, addr
, ETH_ALEN
);
482 cur
->next
= *add_list
;
488 netxen_send_cmd_descs(struct netxen_adapter
*adapter
,
489 struct cmd_desc_type0
*cmd_desc_arr
, int nr_elements
)
491 uint32_t i
, producer
;
492 struct netxen_cmd_buffer
*pbuf
;
493 struct cmd_desc_type0
*cmd_desc
;
495 if (nr_elements
> MAX_PENDING_DESC_BLOCK_SIZE
|| nr_elements
== 0) {
496 printk(KERN_WARNING
"%s: Too many command descriptors in a "
497 "request\n", __func__
);
503 netif_tx_lock_bh(adapter
->netdev
);
505 producer
= adapter
->cmd_producer
;
507 cmd_desc
= &cmd_desc_arr
[i
];
509 pbuf
= &adapter
->cmd_buf_arr
[producer
];
511 pbuf
->frag_count
= 0;
513 /* adapter->ahw.cmd_desc_head[producer] = *cmd_desc; */
514 memcpy(&adapter
->ahw
.cmd_desc_head
[producer
],
515 &cmd_desc_arr
[i
], sizeof(struct cmd_desc_type0
));
517 producer
= get_next_index(producer
,
521 } while (i
!= nr_elements
);
523 adapter
->cmd_producer
= producer
;
525 /* write producer index to start the xmit */
527 netxen_nic_update_cmd_producer(adapter
, adapter
->cmd_producer
);
529 netif_tx_unlock_bh(adapter
->netdev
);
534 static int nx_p3_sre_macaddr_change(struct net_device
*dev
,
535 u8
*addr
, unsigned op
)
537 struct netxen_adapter
*adapter
= netdev_priv(dev
);
539 nx_mac_req_t
*mac_req
;
543 memset(&req
, 0, sizeof(nx_nic_req_t
));
544 req
.qhdr
= cpu_to_le64(NX_NIC_REQUEST
<< 23);
546 word
= NX_MAC_EVENT
| ((u64
)adapter
->portnum
<< 16);
547 req
.req_hdr
= cpu_to_le64(word
);
549 mac_req
= (nx_mac_req_t
*)&req
.words
[0];
551 memcpy(mac_req
->mac_addr
, addr
, 6);
553 rv
= netxen_send_cmd_descs(adapter
, (struct cmd_desc_type0
*)&req
, 1);
555 printk(KERN_ERR
"ERROR. Could not send mac update\n");
562 void netxen_p3_nic_set_multi(struct net_device
*netdev
)
564 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
565 nx_mac_list_t
*cur
, *next
, *del_list
, *add_list
= NULL
;
566 struct dev_mc_list
*mc_ptr
;
567 u8 bcast_addr
[ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
568 u32 mode
= VPORT_MISS_MODE_DROP
;
570 del_list
= adapter
->mac_list
;
571 adapter
->mac_list
= NULL
;
573 nx_p3_nic_add_mac(adapter
, netdev
->dev_addr
, &add_list
, &del_list
);
574 nx_p3_nic_add_mac(adapter
, bcast_addr
, &add_list
, &del_list
);
576 if (netdev
->flags
& IFF_PROMISC
) {
577 mode
= VPORT_MISS_MODE_ACCEPT_ALL
;
581 if ((netdev
->flags
& IFF_ALLMULTI
) ||
582 (netdev
->mc_count
> adapter
->max_mc_count
)) {
583 mode
= VPORT_MISS_MODE_ACCEPT_MULTI
;
587 if (netdev
->mc_count
> 0) {
588 for (mc_ptr
= netdev
->mc_list
; mc_ptr
;
589 mc_ptr
= mc_ptr
->next
) {
590 nx_p3_nic_add_mac(adapter
, mc_ptr
->dmi_addr
,
591 &add_list
, &del_list
);
596 adapter
->set_promisc(adapter
, mode
);
597 for (cur
= del_list
; cur
;) {
598 nx_p3_sre_macaddr_change(netdev
, cur
->mac_addr
, NETXEN_MAC_DEL
);
603 for (cur
= add_list
; cur
;) {
604 nx_p3_sre_macaddr_change(netdev
, cur
->mac_addr
, NETXEN_MAC_ADD
);
606 cur
->next
= adapter
->mac_list
;
607 adapter
->mac_list
= cur
;
612 int netxen_p3_nic_set_promisc(struct netxen_adapter
*adapter
, u32 mode
)
617 memset(&req
, 0, sizeof(nx_nic_req_t
));
619 req
.qhdr
= cpu_to_le64(NX_HOST_REQUEST
<< 23);
621 word
= NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE
|
622 ((u64
)adapter
->portnum
<< 16);
623 req
.req_hdr
= cpu_to_le64(word
);
625 req
.words
[0] = cpu_to_le64(mode
);
627 return netxen_send_cmd_descs(adapter
,
628 (struct cmd_desc_type0
*)&req
, 1);
631 void netxen_p3_free_mac_list(struct netxen_adapter
*adapter
)
633 nx_mac_list_t
*cur
, *next
;
635 cur
= adapter
->mac_list
;
644 #define NETXEN_CONFIG_INTR_COALESCE 3
647 * Send the interrupt coalescing parameter set by ethtool to the card.
649 int netxen_config_intr_coalesce(struct netxen_adapter
*adapter
)
655 memset(&req
, 0, sizeof(nx_nic_req_t
));
657 req
.qhdr
= cpu_to_le64(NX_NIC_REQUEST
<< 23);
659 word
= NETXEN_CONFIG_INTR_COALESCE
| ((u64
)adapter
->portnum
<< 16);
660 req
.req_hdr
= cpu_to_le64(word
);
662 memcpy(&req
.words
[0], &adapter
->coal
, sizeof(adapter
->coal
));
664 rv
= netxen_send_cmd_descs(adapter
, (struct cmd_desc_type0
*)&req
, 1);
666 printk(KERN_ERR
"ERROR. Could not send "
667 "interrupt coalescing parameters\n");
673 #define RSS_HASHTYPE_IP_TCP 0x3
675 int netxen_config_rss(struct netxen_adapter
*adapter
, int enable
)
681 u64 key
[] = { 0xbeac01fa6a42b73bULL
, 0x8030f20c77cb2da3ULL
,
682 0xae7b30b4d0ca2bcbULL
, 0x43a38fb04167253dULL
,
683 0x255b0ec26d5a56daULL
};
686 memset(&req
, 0, sizeof(nx_nic_req_t
));
687 req
.qhdr
= cpu_to_le64(NX_HOST_REQUEST
<< 23);
689 word
= NX_NIC_H2C_OPCODE_CONFIG_RSS
| ((u64
)adapter
->portnum
<< 16);
690 req
.req_hdr
= cpu_to_le64(word
);
694 * bits 3-0: hash_method
695 * 5-4: hash_type_ipv4
696 * 7-6: hash_type_ipv6
698 * 9: use indirection table
700 * 63-48: indirection table mask
702 word
= ((u64
)(RSS_HASHTYPE_IP_TCP
& 0x3) << 4) |
703 ((u64
)(RSS_HASHTYPE_IP_TCP
& 0x3) << 6) |
704 ((u64
)(enable
& 0x1) << 8) |
706 req
.words
[0] = cpu_to_le64(word
);
707 for (i
= 0; i
< 5; i
++)
708 req
.words
[i
+1] = cpu_to_le64(key
[i
]);
711 rv
= netxen_send_cmd_descs(adapter
, (struct cmd_desc_type0
*)&req
, 1);
713 printk(KERN_ERR
"%s: could not configure RSS\n",
714 adapter
->netdev
->name
);
721 * netxen_nic_change_mtu - Change the Maximum Transfer Unit
722 * @returns 0 on success, negative on failure
725 #define MTU_FUDGE_FACTOR 100
727 int netxen_nic_change_mtu(struct net_device
*netdev
, int mtu
)
729 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
733 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
734 max_mtu
= P3_MAX_MTU
;
736 max_mtu
= P2_MAX_MTU
;
739 printk(KERN_ERR
"%s: mtu > %d bytes unsupported\n",
740 netdev
->name
, max_mtu
);
744 if (adapter
->set_mtu
)
745 rc
= adapter
->set_mtu(adapter
, mtu
);
753 int netxen_is_flash_supported(struct netxen_adapter
*adapter
)
755 const int locs
[] = { 0, 0x4, 0x100, 0x4000, 0x4128 };
756 int addr
, val01
, val02
, i
, j
;
758 /* if the flash size less than 4Mb, make huge war cry and die */
759 for (j
= 1; j
< 4; j
++) {
760 addr
= j
* NETXEN_NIC_WINDOW_MARGIN
;
761 for (i
= 0; i
< ARRAY_SIZE(locs
); i
++) {
762 if (netxen_rom_fast_read(adapter
, locs
[i
], &val01
) == 0
763 && netxen_rom_fast_read(adapter
, (addr
+ locs
[i
]),
775 static int netxen_get_flash_block(struct netxen_adapter
*adapter
, int base
,
776 int size
, __le32
* buf
)
783 for (i
= 0; i
< size
/ sizeof(u32
); i
++) {
784 if (netxen_rom_fast_read(adapter
, addr
, &v
) == -1)
786 *ptr32
= cpu_to_le32(v
);
790 if ((char *)buf
+ size
> (char *)ptr32
) {
792 if (netxen_rom_fast_read(adapter
, addr
, &v
) == -1)
794 local
= cpu_to_le32(v
);
795 memcpy(ptr32
, &local
, (char *)buf
+ size
- (char *)ptr32
);
801 int netxen_get_flash_mac_addr(struct netxen_adapter
*adapter
, __le64
*mac
)
803 __le32
*pmac
= (__le32
*) mac
;
806 offset
= NETXEN_USER_START
+
807 offsetof(struct netxen_new_user_info
, mac_addr
) +
808 adapter
->portnum
* sizeof(u64
);
810 if (netxen_get_flash_block(adapter
, offset
, sizeof(u64
), pmac
) == -1)
813 if (*mac
== cpu_to_le64(~0ULL)) {
815 offset
= NETXEN_USER_START_OLD
+
816 offsetof(struct netxen_user_old_info
, mac_addr
) +
817 adapter
->portnum
* sizeof(u64
);
819 if (netxen_get_flash_block(adapter
,
820 offset
, sizeof(u64
), pmac
) == -1)
823 if (*mac
== cpu_to_le64(~0ULL))
829 int netxen_p3_get_mac_addr(struct netxen_adapter
*adapter
, __le64
*mac
)
831 uint32_t crbaddr
, mac_hi
, mac_lo
;
832 int pci_func
= adapter
->ahw
.pci_func
;
834 crbaddr
= CRB_MAC_BLOCK_START
+
835 (4 * ((pci_func
/2) * 3)) + (4 * (pci_func
& 1));
837 adapter
->hw_read_wx(adapter
, crbaddr
, &mac_lo
, 4);
838 adapter
->hw_read_wx(adapter
, crbaddr
+4, &mac_hi
, 4);
841 *mac
= le64_to_cpu((mac_lo
>> 16) | ((u64
)mac_hi
<< 16));
843 *mac
= le64_to_cpu((u64
)mac_lo
| ((u64
)mac_hi
<< 32));
848 #define CRB_WIN_LOCK_TIMEOUT 100000000
850 static int crb_win_lock(struct netxen_adapter
*adapter
)
852 int done
= 0, timeout
= 0;
855 /* acquire semaphore3 from PCI HW block */
856 adapter
->hw_read_wx(adapter
,
857 NETXEN_PCIE_REG(PCIE_SEM7_LOCK
), &done
, 4);
860 if (timeout
>= CRB_WIN_LOCK_TIMEOUT
)
865 netxen_crb_writelit_adapter(adapter
,
866 NETXEN_CRB_WIN_LOCK_ID
, adapter
->portnum
);
870 static void crb_win_unlock(struct netxen_adapter
*adapter
)
874 adapter
->hw_read_wx(adapter
,
875 NETXEN_PCIE_REG(PCIE_SEM7_UNLOCK
), &val
, 4);
879 * Changes the CRB window to the specified window.
882 netxen_nic_pci_change_crbwindow_128M(struct netxen_adapter
*adapter
, u32 wndw
)
884 void __iomem
*offset
;
887 uint8_t func
= adapter
->ahw
.pci_func
;
889 if (adapter
->curr_window
== wndw
)
892 * Move the CRB window.
893 * We need to write to the "direct access" region of PCI
894 * to avoid a race condition where the window register has
895 * not been successfully written across CRB before the target
896 * register address is received by PCI. The direct region bypasses
899 offset
= PCI_OFFSET_SECOND_RANGE(adapter
,
900 NETXEN_PCIX_PH_REG(PCIE_CRB_WINDOW_REG(func
)));
903 wndw
= NETXEN_WINDOW_ONE
;
905 writel(wndw
, offset
);
907 /* MUST make sure window is set before we forge on... */
908 while ((tmp
= readl(offset
)) != wndw
) {
909 printk(KERN_WARNING
"%s: %s WARNING: CRB window value not "
910 "registered properly: 0x%08x.\n",
911 netxen_nic_driver_name
, __func__
, tmp
);
918 if (wndw
== NETXEN_WINDOW_ONE
)
919 adapter
->curr_window
= 1;
921 adapter
->curr_window
= 0;
925 * Return -1 if off is not valid,
926 * 1 if window access is needed. 'off' is set to offset from
927 * CRB space in 128M pci map
928 * 0 if no window access is needed. 'off' is set to 2M addr
929 * In: 'off' is offset from base in 128M pci map
932 netxen_nic_pci_get_crb_addr_2M(struct netxen_adapter
*adapter
,
935 unsigned long end
= *off
+ len
;
936 crb_128M_2M_sub_block_map_t
*m
;
939 if (*off
>= NETXEN_CRB_MAX
)
942 if (*off
>= NETXEN_PCI_CAMQM
&& (end
<= NETXEN_PCI_CAMQM_2M_END
)) {
943 *off
= (*off
- NETXEN_PCI_CAMQM
) + NETXEN_PCI_CAMQM_2M_BASE
+
944 (ulong
)adapter
->ahw
.pci_base0
;
948 if (*off
< NETXEN_PCI_CRBSPACE
)
951 *off
-= NETXEN_PCI_CRBSPACE
;
957 m
= &crb_128M_2M_map
[CRB_BLK(*off
)].sub_block
[CRB_SUBBLK(*off
)];
959 if (m
->valid
&& (m
->start_128M
<= *off
) && (m
->end_128M
>= end
)) {
960 *off
= *off
+ m
->start_2M
- m
->start_128M
+
961 (ulong
)adapter
->ahw
.pci_base0
;
966 * Not in direct map, use crb window
972 * In: 'off' is offset from CRB space in 128M pci map
973 * Out: 'off' is 2M pci map addr
974 * side effect: lock crb window
977 netxen_nic_pci_set_crbwindow_2M(struct netxen_adapter
*adapter
, ulong
*off
)
981 adapter
->crb_win
= CRB_HI(*off
);
982 writel(adapter
->crb_win
, (adapter
->ahw
.pci_base0
+ CRB_WINDOW_2M
));
984 * Read back value to make sure write has gone through before trying
987 win_read
= readl(adapter
->ahw
.pci_base0
+ CRB_WINDOW_2M
);
988 if (win_read
!= adapter
->crb_win
) {
989 printk(KERN_ERR
"%s: Written crbwin (0x%x) != "
990 "Read crbwin (0x%x), off=0x%lx\n",
991 __func__
, adapter
->crb_win
, win_read
, *off
);
993 *off
= (*off
& MASK(16)) + CRB_INDIRECT_2M
+
994 (ulong
)adapter
->ahw
.pci_base0
;
998 netxen_do_load_firmware(struct netxen_adapter
*adapter
, const char *fwname
,
999 const struct firmware
*fw
)
1002 u32 i
, flashaddr
, size
;
1003 struct pci_dev
*pdev
= adapter
->pdev
;
1006 dev_info(&pdev
->dev
, "loading firmware from file %s\n", fwname
);
1008 dev_info(&pdev
->dev
, "loading firmware from flash\n");
1010 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
1011 adapter
->pci_write_normalize(adapter
,
1012 NETXEN_ROMUSB_GLB_CAS_RST
, 1);
1017 size
= (NETXEN_IMAGE_START
- NETXEN_BOOTLD_START
) / 8;
1019 ptr64
= (u64
*)&fw
->data
[NETXEN_BOOTLD_START
];
1020 flashaddr
= NETXEN_BOOTLD_START
;
1022 for (i
= 0; i
< size
; i
++) {
1023 data
= cpu_to_le64(ptr64
[i
]);
1024 adapter
->pci_mem_write(adapter
, flashaddr
, &data
, 8);
1028 size
= *(u32
*)&fw
->data
[NX_FW_SIZE_OFFSET
];
1029 size
= (__force u32
)cpu_to_le32(size
) / 8;
1031 ptr64
= (u64
*)&fw
->data
[NETXEN_IMAGE_START
];
1032 flashaddr
= NETXEN_IMAGE_START
;
1034 for (i
= 0; i
< size
; i
++) {
1035 data
= cpu_to_le64(ptr64
[i
]);
1037 if (adapter
->pci_mem_write(adapter
,
1038 flashaddr
, &data
, 8))
1046 size
= (NETXEN_IMAGE_START
- NETXEN_BOOTLD_START
) / 4;
1047 flashaddr
= NETXEN_BOOTLD_START
;
1049 for (i
= 0; i
< size
; i
++) {
1050 if (netxen_rom_fast_read(adapter
,
1051 flashaddr
, (int *)&data
) != 0)
1054 if (adapter
->pci_mem_write(adapter
,
1055 flashaddr
, &data
, 4))
1063 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1064 adapter
->pci_write_normalize(adapter
,
1065 NETXEN_ROMUSB_GLB_SW_RESET
, 0x80001d);
1067 adapter
->pci_write_normalize(adapter
,
1068 NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL
, 0x3fff);
1069 adapter
->pci_write_normalize(adapter
,
1070 NETXEN_ROMUSB_GLB_CAS_RST
, 0);
1077 netxen_validate_firmware(struct netxen_adapter
*adapter
, const char *fwname
,
1078 const struct firmware
*fw
)
1081 u32 major
, minor
, build
, ver
, min_ver
, bios
;
1082 struct pci_dev
*pdev
= adapter
->pdev
;
1084 if (fw
->size
< NX_FW_MIN_SIZE
)
1087 val
= cpu_to_le32(*(u32
*)&fw
->data
[NX_FW_MAGIC_OFFSET
]);
1088 if ((__force u32
)val
!= NETXEN_BDINFO_MAGIC
)
1091 val
= cpu_to_le32(*(u32
*)&fw
->data
[NX_FW_VERSION_OFFSET
]);
1092 major
= (__force u32
)val
& 0xff;
1093 minor
= ((__force u32
)val
>> 8) & 0xff;
1094 build
= (__force u32
)val
>> 16;
1096 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1097 min_ver
= NETXEN_VERSION_CODE(4, 0, 216);
1099 min_ver
= NETXEN_VERSION_CODE(3, 4, 216);
1101 ver
= NETXEN_VERSION_CODE(major
, minor
, build
);
1103 if ((major
> _NETXEN_NIC_LINUX_MAJOR
) || (ver
< min_ver
)) {
1105 "%s: firmware version %d.%d.%d unsupported\n",
1106 fwname
, major
, minor
, build
);
1110 val
= cpu_to_le32(*(u32
*)&fw
->data
[NX_BIOS_VERSION_OFFSET
]);
1111 netxen_rom_fast_read(adapter
, NX_BIOS_VERSION_OFFSET
, (int *)&bios
);
1112 if ((__force u32
)val
!= bios
) {
1113 dev_err(&pdev
->dev
, "%s: firmware bios is incompatible\n",
1118 /* check if flashed firmware is newer */
1119 if (netxen_rom_fast_read(adapter
,
1120 NX_FW_VERSION_OFFSET
, (int *)&val
))
1122 major
= (__force u32
)val
& 0xff;
1123 minor
= ((__force u32
)val
>> 8) & 0xff;
1124 build
= (__force u32
)val
>> 16;
1125 if (NETXEN_VERSION_CODE(major
, minor
, build
) > ver
)
1128 netxen_nic_reg_write(adapter
, NETXEN_CAM_RAM(0x1fc),
1129 NETXEN_BDINFO_MAGIC
);
1133 int netxen_load_firmware(struct netxen_adapter
*adapter
)
1135 u32 capability
, flashed_ver
;
1136 const struct firmware
*fw
;
1137 char *fw_name
= NULL
;
1138 struct pci_dev
*pdev
= adapter
->pdev
;
1141 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
1142 fw_name
= NX_P2_MN_ROMIMAGE
;
1146 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
1147 fw_name
= NX_P3_CT_ROMIMAGE
;
1154 netxen_rom_fast_read(adapter
,
1155 NX_FW_VERSION_OFFSET
, (int *)&flashed_ver
);
1156 if (flashed_ver
>= NETXEN_VERSION_CODE(4, 0, 220)) {
1157 adapter
->hw_read_wx(adapter
,
1158 NX_PEG_TUNE_CAPABILITY
, &capability
, 4);
1159 if (capability
& NX_PEG_TUNE_MN_PRESENT
) {
1160 fw_name
= NX_P3_MN_ROMIMAGE
;
1166 rc
= request_firmware(&fw
, fw_name
, &pdev
->dev
);
1168 if (fw_name
== NX_P3_CT_ROMIMAGE
) {
1177 rc
= netxen_validate_firmware(adapter
, fw_name
, fw
);
1179 release_firmware(fw
);
1181 if (fw_name
== NX_P3_CT_ROMIMAGE
) {
1190 rc
= netxen_do_load_firmware(adapter
, fw_name
, fw
);
1193 release_firmware(fw
);
1198 netxen_nic_hw_write_wx_128M(struct netxen_adapter
*adapter
,
1199 ulong off
, void *data
, int len
)
1205 if (ADDR_IN_WINDOW1(off
)) {
1206 addr
= NETXEN_CRB_NORMALIZE(adapter
, off
);
1207 } else { /* Window 0 */
1208 addr
= pci_base_offset(adapter
, off
);
1209 netxen_nic_pci_change_crbwindow_128M(adapter
, 0);
1213 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1217 writel(*(u32
*) data
, addr
);
1219 if (!ADDR_IN_WINDOW1(off
))
1220 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1226 netxen_nic_hw_read_wx_128M(struct netxen_adapter
*adapter
,
1227 ulong off
, void *data
, int len
)
1233 if (ADDR_IN_WINDOW1(off
)) { /* Window 1 */
1234 addr
= NETXEN_CRB_NORMALIZE(adapter
, off
);
1235 } else { /* Window 0 */
1236 addr
= pci_base_offset(adapter
, off
);
1237 netxen_nic_pci_change_crbwindow_128M(adapter
, 0);
1241 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1245 *(u32
*)data
= readl(addr
);
1247 if (!ADDR_IN_WINDOW1(off
))
1248 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1254 netxen_nic_hw_write_wx_2M(struct netxen_adapter
*adapter
,
1255 ulong off
, void *data
, int len
)
1257 unsigned long flags
= 0;
1262 rv
= netxen_nic_pci_get_crb_addr_2M(adapter
, &off
, len
);
1265 printk(KERN_ERR
"%s: invalid offset: 0x%016lx\n",
1272 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1273 crb_win_lock(adapter
);
1274 netxen_nic_pci_set_crbwindow_2M(adapter
, &off
);
1275 writel(*(uint32_t *)data
, (void __iomem
*)off
);
1276 crb_win_unlock(adapter
);
1277 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1279 writel(*(uint32_t *)data
, (void __iomem
*)off
);
1286 netxen_nic_hw_read_wx_2M(struct netxen_adapter
*adapter
,
1287 ulong off
, void *data
, int len
)
1289 unsigned long flags
= 0;
1294 rv
= netxen_nic_pci_get_crb_addr_2M(adapter
, &off
, len
);
1297 printk(KERN_ERR
"%s: invalid offset: 0x%016lx\n",
1304 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1305 crb_win_lock(adapter
);
1306 netxen_nic_pci_set_crbwindow_2M(adapter
, &off
);
1307 *(uint32_t *)data
= readl((void __iomem
*)off
);
1308 crb_win_unlock(adapter
);
1309 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1311 *(uint32_t *)data
= readl((void __iomem
*)off
);
1316 void netxen_nic_reg_write(struct netxen_adapter
*adapter
, u64 off
, u32 val
)
1318 adapter
->hw_write_wx(adapter
, off
, &val
, 4);
1321 int netxen_nic_reg_read(struct netxen_adapter
*adapter
, u64 off
)
1324 adapter
->hw_read_wx(adapter
, off
, &val
, 4);
1328 /* Change the window to 0, write and change back to window 1. */
1329 void netxen_nic_write_w0(struct netxen_adapter
*adapter
, u32 index
, u32 value
)
1331 adapter
->hw_write_wx(adapter
, index
, &value
, 4);
1334 /* Change the window to 0, read and change back to window 1. */
1335 void netxen_nic_read_w0(struct netxen_adapter
*adapter
, u32 index
, u32
*value
)
1337 adapter
->hw_read_wx(adapter
, index
, value
, 4);
1340 void netxen_nic_write_w1(struct netxen_adapter
*adapter
, u32 index
, u32 value
)
1342 adapter
->hw_write_wx(adapter
, index
, &value
, 4);
1345 void netxen_nic_read_w1(struct netxen_adapter
*adapter
, u32 index
, u32
*value
)
1347 adapter
->hw_read_wx(adapter
, index
, value
, 4);
1351 * check memory access boundary.
1352 * used by test agent. support ddr access only for now
1354 static unsigned long
1355 netxen_nic_pci_mem_bound_check(struct netxen_adapter
*adapter
,
1356 unsigned long long addr
, int size
)
1358 if (!ADDR_IN_RANGE(addr
,
1359 NETXEN_ADDR_DDR_NET
, NETXEN_ADDR_DDR_NET_MAX
) ||
1360 !ADDR_IN_RANGE(addr
+size
-1,
1361 NETXEN_ADDR_DDR_NET
, NETXEN_ADDR_DDR_NET_MAX
) ||
1362 ((size
!= 1) && (size
!= 2) && (size
!= 4) && (size
!= 8))) {
1369 static int netxen_pci_set_window_warning_count
;
1372 netxen_nic_pci_set_window_128M(struct netxen_adapter
*adapter
,
1373 unsigned long long addr
)
1375 void __iomem
*offset
;
1377 unsigned long long qdr_max
;
1378 uint8_t func
= adapter
->ahw
.pci_func
;
1380 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
1381 qdr_max
= NETXEN_ADDR_QDR_NET_MAX_P2
;
1383 qdr_max
= NETXEN_ADDR_QDR_NET_MAX_P3
;
1386 if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_DDR_NET
, NETXEN_ADDR_DDR_NET_MAX
)) {
1387 /* DDR network side */
1388 addr
-= NETXEN_ADDR_DDR_NET
;
1389 window
= (addr
>> 25) & 0x3ff;
1390 if (adapter
->ahw
.ddr_mn_window
!= window
) {
1391 adapter
->ahw
.ddr_mn_window
= window
;
1392 offset
= PCI_OFFSET_SECOND_RANGE(adapter
,
1393 NETXEN_PCIX_PH_REG(PCIE_MN_WINDOW_REG(func
)));
1394 writel(window
, offset
);
1395 /* MUST make sure window is set before we forge on... */
1398 addr
-= (window
* NETXEN_WINDOW_ONE
);
1399 addr
+= NETXEN_PCI_DDR_NET
;
1400 } else if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_OCM0
, NETXEN_ADDR_OCM0_MAX
)) {
1401 addr
-= NETXEN_ADDR_OCM0
;
1402 addr
+= NETXEN_PCI_OCM0
;
1403 } else if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_OCM1
, NETXEN_ADDR_OCM1_MAX
)) {
1404 addr
-= NETXEN_ADDR_OCM1
;
1405 addr
+= NETXEN_PCI_OCM1
;
1406 } else if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_QDR_NET
, qdr_max
)) {
1407 /* QDR network side */
1408 addr
-= NETXEN_ADDR_QDR_NET
;
1409 window
= (addr
>> 22) & 0x3f;
1410 if (adapter
->ahw
.qdr_sn_window
!= window
) {
1411 adapter
->ahw
.qdr_sn_window
= window
;
1412 offset
= PCI_OFFSET_SECOND_RANGE(adapter
,
1413 NETXEN_PCIX_PH_REG(PCIE_SN_WINDOW_REG(func
)));
1414 writel((window
<< 22), offset
);
1415 /* MUST make sure window is set before we forge on... */
1418 addr
-= (window
* 0x400000);
1419 addr
+= NETXEN_PCI_QDR_NET
;
1422 * peg gdb frequently accesses memory that doesn't exist,
1423 * this limits the chit chat so debugging isn't slowed down.
1425 if ((netxen_pci_set_window_warning_count
++ < 8)
1426 || (netxen_pci_set_window_warning_count
% 64 == 0))
1427 printk("%s: Warning:netxen_nic_pci_set_window()"
1428 " Unknown address range!\n",
1429 netxen_nic_driver_name
);
1436 * Note : only 32-bit writes!
1438 int netxen_nic_pci_write_immediate_128M(struct netxen_adapter
*adapter
,
1441 writel(data
, (void __iomem
*)(PCI_OFFSET_SECOND_RANGE(adapter
, off
)));
1445 u32
netxen_nic_pci_read_immediate_128M(struct netxen_adapter
*adapter
, u64 off
)
1447 return readl((void __iomem
*)(pci_base_offset(adapter
, off
)));
1450 void netxen_nic_pci_write_normalize_128M(struct netxen_adapter
*adapter
,
1453 writel(data
, NETXEN_CRB_NORMALIZE(adapter
, off
));
1456 u32
netxen_nic_pci_read_normalize_128M(struct netxen_adapter
*adapter
, u64 off
)
1458 return readl(NETXEN_CRB_NORMALIZE(adapter
, off
));
1462 netxen_nic_pci_set_window_2M(struct netxen_adapter
*adapter
,
1463 unsigned long long addr
)
1468 if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_DDR_NET
, NETXEN_ADDR_DDR_NET_MAX
)) {
1469 /* DDR network side */
1470 window
= MN_WIN(addr
);
1471 adapter
->ahw
.ddr_mn_window
= window
;
1472 adapter
->hw_write_wx(adapter
,
1473 adapter
->ahw
.mn_win_crb
| NETXEN_PCI_CRBSPACE
,
1475 adapter
->hw_read_wx(adapter
,
1476 adapter
->ahw
.mn_win_crb
| NETXEN_PCI_CRBSPACE
,
1478 if ((win_read
<< 17) != window
) {
1479 printk(KERN_INFO
"Written MNwin (0x%x) != "
1480 "Read MNwin (0x%x)\n", window
, win_read
);
1482 addr
= GET_MEM_OFFS_2M(addr
) + NETXEN_PCI_DDR_NET
;
1483 } else if (ADDR_IN_RANGE(addr
,
1484 NETXEN_ADDR_OCM0
, NETXEN_ADDR_OCM0_MAX
)) {
1485 if ((addr
& 0x00ff800) == 0xff800) {
1486 printk("%s: QM access not handled.\n", __func__
);
1490 window
= OCM_WIN(addr
);
1491 adapter
->ahw
.ddr_mn_window
= window
;
1492 adapter
->hw_write_wx(adapter
,
1493 adapter
->ahw
.mn_win_crb
| NETXEN_PCI_CRBSPACE
,
1495 adapter
->hw_read_wx(adapter
,
1496 adapter
->ahw
.mn_win_crb
| NETXEN_PCI_CRBSPACE
,
1498 if ((win_read
>> 7) != window
) {
1499 printk(KERN_INFO
"%s: Written OCMwin (0x%x) != "
1500 "Read OCMwin (0x%x)\n",
1501 __func__
, window
, win_read
);
1503 addr
= GET_MEM_OFFS_2M(addr
) + NETXEN_PCI_OCM0_2M
;
1505 } else if (ADDR_IN_RANGE(addr
,
1506 NETXEN_ADDR_QDR_NET
, NETXEN_ADDR_QDR_NET_MAX_P3
)) {
1507 /* QDR network side */
1508 window
= MS_WIN(addr
);
1509 adapter
->ahw
.qdr_sn_window
= window
;
1510 adapter
->hw_write_wx(adapter
,
1511 adapter
->ahw
.ms_win_crb
| NETXEN_PCI_CRBSPACE
,
1513 adapter
->hw_read_wx(adapter
,
1514 adapter
->ahw
.ms_win_crb
| NETXEN_PCI_CRBSPACE
,
1516 if (win_read
!= window
) {
1517 printk(KERN_INFO
"%s: Written MSwin (0x%x) != "
1518 "Read MSwin (0x%x)\n",
1519 __func__
, window
, win_read
);
1521 addr
= GET_MEM_OFFS_2M(addr
) + NETXEN_PCI_QDR_NET
;
1525 * peg gdb frequently accesses memory that doesn't exist,
1526 * this limits the chit chat so debugging isn't slowed down.
1528 if ((netxen_pci_set_window_warning_count
++ < 8)
1529 || (netxen_pci_set_window_warning_count
%64 == 0)) {
1530 printk("%s: Warning:%s Unknown address range!\n",
1531 __func__
, netxen_nic_driver_name
);
1538 static int netxen_nic_pci_is_same_window(struct netxen_adapter
*adapter
,
1539 unsigned long long addr
)
1542 unsigned long long qdr_max
;
1544 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
1545 qdr_max
= NETXEN_ADDR_QDR_NET_MAX_P2
;
1547 qdr_max
= NETXEN_ADDR_QDR_NET_MAX_P3
;
1549 if (ADDR_IN_RANGE(addr
,
1550 NETXEN_ADDR_DDR_NET
, NETXEN_ADDR_DDR_NET_MAX
)) {
1551 /* DDR network side */
1552 BUG(); /* MN access can not come here */
1553 } else if (ADDR_IN_RANGE(addr
,
1554 NETXEN_ADDR_OCM0
, NETXEN_ADDR_OCM0_MAX
)) {
1556 } else if (ADDR_IN_RANGE(addr
,
1557 NETXEN_ADDR_OCM1
, NETXEN_ADDR_OCM1_MAX
)) {
1559 } else if (ADDR_IN_RANGE(addr
, NETXEN_ADDR_QDR_NET
, qdr_max
)) {
1560 /* QDR network side */
1561 window
= ((addr
- NETXEN_ADDR_QDR_NET
) >> 22) & 0x3f;
1562 if (adapter
->ahw
.qdr_sn_window
== window
)
1569 static int netxen_nic_pci_mem_read_direct(struct netxen_adapter
*adapter
,
1570 u64 off
, void *data
, int size
)
1572 unsigned long flags
;
1573 void __iomem
*addr
, *mem_ptr
= NULL
;
1576 unsigned long mem_base
;
1577 unsigned long mem_page
;
1579 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1582 * If attempting to access unknown address or straddle hw windows,
1585 start
= adapter
->pci_set_window(adapter
, off
);
1586 if ((start
== -1UL) ||
1587 (netxen_nic_pci_is_same_window(adapter
, off
+size
-1) == 0)) {
1588 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1589 printk(KERN_ERR
"%s out of bound pci memory access. "
1590 "offset is 0x%llx\n", netxen_nic_driver_name
,
1591 (unsigned long long)off
);
1595 addr
= pci_base_offset(adapter
, start
);
1597 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1598 mem_base
= pci_resource_start(adapter
->pdev
, 0);
1599 mem_page
= start
& PAGE_MASK
;
1600 /* Map two pages whenever user tries to access addresses in two
1603 if (mem_page
!= ((start
+ size
- 1) & PAGE_MASK
))
1604 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
* 2);
1606 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
);
1607 if (mem_ptr
== NULL
) {
1608 *(uint8_t *)data
= 0;
1612 addr
+= start
& (PAGE_SIZE
- 1);
1613 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1618 *(uint8_t *)data
= readb(addr
);
1621 *(uint16_t *)data
= readw(addr
);
1624 *(uint32_t *)data
= readl(addr
);
1627 *(uint64_t *)data
= readq(addr
);
1633 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1641 netxen_nic_pci_mem_write_direct(struct netxen_adapter
*adapter
, u64 off
,
1642 void *data
, int size
)
1644 unsigned long flags
;
1645 void __iomem
*addr
, *mem_ptr
= NULL
;
1648 unsigned long mem_base
;
1649 unsigned long mem_page
;
1651 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1654 * If attempting to access unknown address or straddle hw windows,
1657 start
= adapter
->pci_set_window(adapter
, off
);
1658 if ((start
== -1UL) ||
1659 (netxen_nic_pci_is_same_window(adapter
, off
+size
-1) == 0)) {
1660 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1661 printk(KERN_ERR
"%s out of bound pci memory access. "
1662 "offset is 0x%llx\n", netxen_nic_driver_name
,
1663 (unsigned long long)off
);
1667 addr
= pci_base_offset(adapter
, start
);
1669 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1670 mem_base
= pci_resource_start(adapter
->pdev
, 0);
1671 mem_page
= start
& PAGE_MASK
;
1672 /* Map two pages whenever user tries to access addresses in two
1673 * consecutive pages.
1675 if (mem_page
!= ((start
+ size
- 1) & PAGE_MASK
))
1676 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
*2);
1678 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
);
1679 if (mem_ptr
== NULL
)
1682 addr
+= start
& (PAGE_SIZE
- 1);
1683 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1688 writeb(*(uint8_t *)data
, addr
);
1691 writew(*(uint16_t *)data
, addr
);
1694 writel(*(uint32_t *)data
, addr
);
1697 writeq(*(uint64_t *)data
, addr
);
1703 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1709 #define MAX_CTL_CHECK 1000
1712 netxen_nic_pci_mem_write_128M(struct netxen_adapter
*adapter
,
1713 u64 off
, void *data
, int size
)
1715 unsigned long flags
;
1716 int i
, j
, ret
= 0, loop
, sz
[2], off0
;
1718 uint64_t off8
, tmpw
, word
[2] = {0, 0};
1719 void __iomem
*mem_crb
;
1722 * If not MN, go check for MS or invalid.
1724 if (netxen_nic_pci_mem_bound_check(adapter
, off
, size
) == 0)
1725 return netxen_nic_pci_mem_write_direct(adapter
,
1728 off8
= off
& 0xfffffff8;
1730 sz
[0] = (size
< (8 - off0
)) ? size
: (8 - off0
);
1731 sz
[1] = size
- sz
[0];
1732 loop
= ((off0
+ size
- 1) >> 3) + 1;
1733 mem_crb
= pci_base_offset(adapter
, NETXEN_CRB_DDR_NET
);
1735 if ((size
!= 8) || (off0
!= 0)) {
1736 for (i
= 0; i
< loop
; i
++) {
1737 if (adapter
->pci_mem_read(adapter
,
1738 off8
+ (i
<< 3), &word
[i
], 8))
1745 tmpw
= *((uint8_t *)data
);
1748 tmpw
= *((uint16_t *)data
);
1751 tmpw
= *((uint32_t *)data
);
1755 tmpw
= *((uint64_t *)data
);
1758 word
[0] &= ~((~(~0ULL << (sz
[0] * 8))) << (off0
* 8));
1759 word
[0] |= tmpw
<< (off0
* 8);
1762 word
[1] &= ~(~0ULL << (sz
[1] * 8));
1763 word
[1] |= tmpw
>> (sz
[0] * 8);
1766 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1767 netxen_nic_pci_change_crbwindow_128M(adapter
, 0);
1769 for (i
= 0; i
< loop
; i
++) {
1770 writel((uint32_t)(off8
+ (i
<< 3)),
1771 (mem_crb
+MIU_TEST_AGT_ADDR_LO
));
1773 (mem_crb
+MIU_TEST_AGT_ADDR_HI
));
1774 writel(word
[i
] & 0xffffffff,
1775 (mem_crb
+MIU_TEST_AGT_WRDATA_LO
));
1776 writel((word
[i
] >> 32) & 0xffffffff,
1777 (mem_crb
+MIU_TEST_AGT_WRDATA_HI
));
1778 writel(MIU_TA_CTL_ENABLE
|MIU_TA_CTL_WRITE
,
1779 (mem_crb
+MIU_TEST_AGT_CTRL
));
1780 writel(MIU_TA_CTL_START
|MIU_TA_CTL_ENABLE
|MIU_TA_CTL_WRITE
,
1781 (mem_crb
+MIU_TEST_AGT_CTRL
));
1783 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
1785 (mem_crb
+MIU_TEST_AGT_CTRL
));
1786 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
1790 if (j
>= MAX_CTL_CHECK
) {
1791 if (printk_ratelimit())
1792 dev_err(&adapter
->pdev
->dev
,
1793 "failed to write through agent\n");
1799 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1800 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1805 netxen_nic_pci_mem_read_128M(struct netxen_adapter
*adapter
,
1806 u64 off
, void *data
, int size
)
1808 unsigned long flags
;
1809 int i
, j
= 0, k
, start
, end
, loop
, sz
[2], off0
[2];
1811 uint64_t off8
, val
, word
[2] = {0, 0};
1812 void __iomem
*mem_crb
;
1816 * If not MN, go check for MS or invalid.
1818 if (netxen_nic_pci_mem_bound_check(adapter
, off
, size
) == 0)
1819 return netxen_nic_pci_mem_read_direct(adapter
, off
, data
, size
);
1821 off8
= off
& 0xfffffff8;
1822 off0
[0] = off
& 0x7;
1824 sz
[0] = (size
< (8 - off0
[0])) ? size
: (8 - off0
[0]);
1825 sz
[1] = size
- sz
[0];
1826 loop
= ((off0
[0] + size
- 1) >> 3) + 1;
1827 mem_crb
= pci_base_offset(adapter
, NETXEN_CRB_DDR_NET
);
1829 write_lock_irqsave(&adapter
->adapter_lock
, flags
);
1830 netxen_nic_pci_change_crbwindow_128M(adapter
, 0);
1832 for (i
= 0; i
< loop
; i
++) {
1833 writel((uint32_t)(off8
+ (i
<< 3)),
1834 (mem_crb
+MIU_TEST_AGT_ADDR_LO
));
1836 (mem_crb
+MIU_TEST_AGT_ADDR_HI
));
1837 writel(MIU_TA_CTL_ENABLE
,
1838 (mem_crb
+MIU_TEST_AGT_CTRL
));
1839 writel(MIU_TA_CTL_START
|MIU_TA_CTL_ENABLE
,
1840 (mem_crb
+MIU_TEST_AGT_CTRL
));
1842 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
1844 (mem_crb
+MIU_TEST_AGT_CTRL
));
1845 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
1849 if (j
>= MAX_CTL_CHECK
) {
1850 if (printk_ratelimit())
1851 dev_err(&adapter
->pdev
->dev
,
1852 "failed to read through agent\n");
1856 start
= off0
[i
] >> 2;
1857 end
= (off0
[i
] + sz
[i
] - 1) >> 2;
1858 for (k
= start
; k
<= end
; k
++) {
1859 word
[i
] |= ((uint64_t) readl(
1861 MIU_TEST_AGT_RDDATA(k
))) << (32*k
));
1865 netxen_nic_pci_change_crbwindow_128M(adapter
, 1);
1866 write_unlock_irqrestore(&adapter
->adapter_lock
, flags
);
1868 if (j
>= MAX_CTL_CHECK
)
1874 val
= ((word
[0] >> (off0
[0] * 8)) & (~(~0ULL << (sz
[0] * 8)))) |
1875 ((word
[1] & (~(~0ULL << (sz
[1] * 8)))) << (sz
[0] * 8));
1880 *(uint8_t *)data
= val
;
1883 *(uint16_t *)data
= val
;
1886 *(uint32_t *)data
= val
;
1889 *(uint64_t *)data
= val
;
1896 netxen_nic_pci_mem_write_2M(struct netxen_adapter
*adapter
,
1897 u64 off
, void *data
, int size
)
1899 int i
, j
, ret
= 0, loop
, sz
[2], off0
;
1901 uint64_t off8
, mem_crb
, tmpw
, word
[2] = {0, 0};
1904 * If not MN, go check for MS or invalid.
1906 if (off
>= NETXEN_ADDR_QDR_NET
&& off
<= NETXEN_ADDR_QDR_NET_MAX_P3
)
1907 mem_crb
= NETXEN_CRB_QDR_NET
;
1909 mem_crb
= NETXEN_CRB_DDR_NET
;
1910 if (netxen_nic_pci_mem_bound_check(adapter
, off
, size
) == 0)
1911 return netxen_nic_pci_mem_write_direct(adapter
,
1915 off8
= off
& 0xfffffff8;
1917 sz
[0] = (size
< (8 - off0
)) ? size
: (8 - off0
);
1918 sz
[1] = size
- sz
[0];
1919 loop
= ((off0
+ size
- 1) >> 3) + 1;
1921 if ((size
!= 8) || (off0
!= 0)) {
1922 for (i
= 0; i
< loop
; i
++) {
1923 if (adapter
->pci_mem_read(adapter
, off8
+ (i
<< 3),
1931 tmpw
= *((uint8_t *)data
);
1934 tmpw
= *((uint16_t *)data
);
1937 tmpw
= *((uint32_t *)data
);
1941 tmpw
= *((uint64_t *)data
);
1945 word
[0] &= ~((~(~0ULL << (sz
[0] * 8))) << (off0
* 8));
1946 word
[0] |= tmpw
<< (off0
* 8);
1949 word
[1] &= ~(~0ULL << (sz
[1] * 8));
1950 word
[1] |= tmpw
>> (sz
[0] * 8);
1954 * don't lock here - write_wx gets the lock if each time
1955 * write_lock_irqsave(&adapter->adapter_lock, flags);
1956 * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
1959 for (i
= 0; i
< loop
; i
++) {
1960 temp
= off8
+ (i
<< 3);
1961 adapter
->hw_write_wx(adapter
,
1962 mem_crb
+MIU_TEST_AGT_ADDR_LO
, &temp
, 4);
1964 adapter
->hw_write_wx(adapter
,
1965 mem_crb
+MIU_TEST_AGT_ADDR_HI
, &temp
, 4);
1966 temp
= word
[i
] & 0xffffffff;
1967 adapter
->hw_write_wx(adapter
,
1968 mem_crb
+MIU_TEST_AGT_WRDATA_LO
, &temp
, 4);
1969 temp
= (word
[i
] >> 32) & 0xffffffff;
1970 adapter
->hw_write_wx(adapter
,
1971 mem_crb
+MIU_TEST_AGT_WRDATA_HI
, &temp
, 4);
1972 temp
= MIU_TA_CTL_ENABLE
| MIU_TA_CTL_WRITE
;
1973 adapter
->hw_write_wx(adapter
,
1974 mem_crb
+MIU_TEST_AGT_CTRL
, &temp
, 4);
1975 temp
= MIU_TA_CTL_START
| MIU_TA_CTL_ENABLE
| MIU_TA_CTL_WRITE
;
1976 adapter
->hw_write_wx(adapter
,
1977 mem_crb
+MIU_TEST_AGT_CTRL
, &temp
, 4);
1979 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
1980 adapter
->hw_read_wx(adapter
,
1981 mem_crb
+ MIU_TEST_AGT_CTRL
, &temp
, 4);
1982 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
1986 if (j
>= MAX_CTL_CHECK
) {
1987 if (printk_ratelimit())
1988 dev_err(&adapter
->pdev
->dev
,
1989 "failed to write through agent\n");
1996 * netxen_nic_pci_change_crbwindow_128M(adapter, 1);
1997 * write_unlock_irqrestore(&adapter->adapter_lock, flags);
2003 netxen_nic_pci_mem_read_2M(struct netxen_adapter
*adapter
,
2004 u64 off
, void *data
, int size
)
2006 int i
, j
= 0, k
, start
, end
, loop
, sz
[2], off0
[2];
2008 uint64_t off8
, val
, mem_crb
, word
[2] = {0, 0};
2011 * If not MN, go check for MS or invalid.
2014 if (off
>= NETXEN_ADDR_QDR_NET
&& off
<= NETXEN_ADDR_QDR_NET_MAX_P3
)
2015 mem_crb
= NETXEN_CRB_QDR_NET
;
2017 mem_crb
= NETXEN_CRB_DDR_NET
;
2018 if (netxen_nic_pci_mem_bound_check(adapter
, off
, size
) == 0)
2019 return netxen_nic_pci_mem_read_direct(adapter
,
2023 off8
= off
& 0xfffffff8;
2024 off0
[0] = off
& 0x7;
2026 sz
[0] = (size
< (8 - off0
[0])) ? size
: (8 - off0
[0]);
2027 sz
[1] = size
- sz
[0];
2028 loop
= ((off0
[0] + size
- 1) >> 3) + 1;
2031 * don't lock here - write_wx gets the lock if each time
2032 * write_lock_irqsave(&adapter->adapter_lock, flags);
2033 * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
2036 for (i
= 0; i
< loop
; i
++) {
2037 temp
= off8
+ (i
<< 3);
2038 adapter
->hw_write_wx(adapter
,
2039 mem_crb
+ MIU_TEST_AGT_ADDR_LO
, &temp
, 4);
2041 adapter
->hw_write_wx(adapter
,
2042 mem_crb
+ MIU_TEST_AGT_ADDR_HI
, &temp
, 4);
2043 temp
= MIU_TA_CTL_ENABLE
;
2044 adapter
->hw_write_wx(adapter
,
2045 mem_crb
+ MIU_TEST_AGT_CTRL
, &temp
, 4);
2046 temp
= MIU_TA_CTL_START
| MIU_TA_CTL_ENABLE
;
2047 adapter
->hw_write_wx(adapter
,
2048 mem_crb
+ MIU_TEST_AGT_CTRL
, &temp
, 4);
2050 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
2051 adapter
->hw_read_wx(adapter
,
2052 mem_crb
+ MIU_TEST_AGT_CTRL
, &temp
, 4);
2053 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
2057 if (j
>= MAX_CTL_CHECK
) {
2058 if (printk_ratelimit())
2059 dev_err(&adapter
->pdev
->dev
,
2060 "failed to read through agent\n");
2064 start
= off0
[i
] >> 2;
2065 end
= (off0
[i
] + sz
[i
] - 1) >> 2;
2066 for (k
= start
; k
<= end
; k
++) {
2067 adapter
->hw_read_wx(adapter
,
2068 mem_crb
+ MIU_TEST_AGT_RDDATA(k
), &temp
, 4);
2069 word
[i
] |= ((uint64_t)temp
<< (32 * k
));
2074 * netxen_nic_pci_change_crbwindow_128M(adapter, 1);
2075 * write_unlock_irqrestore(&adapter->adapter_lock, flags);
2078 if (j
>= MAX_CTL_CHECK
)
2084 val
= ((word
[0] >> (off0
[0] * 8)) & (~(~0ULL << (sz
[0] * 8)))) |
2085 ((word
[1] & (~(~0ULL << (sz
[1] * 8)))) << (sz
[0] * 8));
2090 *(uint8_t *)data
= val
;
2093 *(uint16_t *)data
= val
;
2096 *(uint32_t *)data
= val
;
2099 *(uint64_t *)data
= val
;
2106 * Note : only 32-bit writes!
2108 int netxen_nic_pci_write_immediate_2M(struct netxen_adapter
*adapter
,
2111 adapter
->hw_write_wx(adapter
, off
, &data
, 4);
2116 u32
netxen_nic_pci_read_immediate_2M(struct netxen_adapter
*adapter
, u64 off
)
2119 adapter
->hw_read_wx(adapter
, off
, &temp
, 4);
2123 void netxen_nic_pci_write_normalize_2M(struct netxen_adapter
*adapter
,
2126 adapter
->hw_write_wx(adapter
, off
, &data
, 4);
2129 u32
netxen_nic_pci_read_normalize_2M(struct netxen_adapter
*adapter
, u64 off
)
2132 adapter
->hw_read_wx(adapter
, off
, &temp
, 4);
2136 int netxen_nic_get_board_info(struct netxen_adapter
*adapter
)
2138 int offset
, board_type
, magic
, header_version
;
2139 struct pci_dev
*pdev
= adapter
->pdev
;
2141 offset
= NETXEN_BRDCFG_START
+
2142 offsetof(struct netxen_board_info
, magic
);
2143 if (netxen_rom_fast_read(adapter
, offset
, &magic
))
2146 offset
= NETXEN_BRDCFG_START
+
2147 offsetof(struct netxen_board_info
, header_version
);
2148 if (netxen_rom_fast_read(adapter
, offset
, &header_version
))
2151 if (magic
!= NETXEN_BDINFO_MAGIC
||
2152 header_version
!= NETXEN_BDINFO_VERSION
) {
2154 "invalid board config, magic=%08x, version=%08x\n",
2155 magic
, header_version
);
2159 offset
= NETXEN_BRDCFG_START
+
2160 offsetof(struct netxen_board_info
, board_type
);
2161 if (netxen_rom_fast_read(adapter
, offset
, &board_type
))
2164 adapter
->ahw
.board_type
= board_type
;
2166 if (board_type
== NETXEN_BRDTYPE_P3_4_GB_MM
) {
2167 u32 gpio
= netxen_nic_reg_read(adapter
,
2168 NETXEN_ROMUSB_GLB_PAD_GPIO_I
);
2169 if ((gpio
& 0x8000) == 0)
2170 board_type
= NETXEN_BRDTYPE_P3_10G_TP
;
2173 switch ((netxen_brdtype_t
)board_type
) {
2174 case NETXEN_BRDTYPE_P2_SB35_4G
:
2175 adapter
->ahw
.port_type
= NETXEN_NIC_GBE
;
2177 case NETXEN_BRDTYPE_P2_SB31_10G
:
2178 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ
:
2179 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ
:
2180 case NETXEN_BRDTYPE_P2_SB31_10G_CX4
:
2181 case NETXEN_BRDTYPE_P3_HMEZ
:
2182 case NETXEN_BRDTYPE_P3_XG_LOM
:
2183 case NETXEN_BRDTYPE_P3_10G_CX4
:
2184 case NETXEN_BRDTYPE_P3_10G_CX4_LP
:
2185 case NETXEN_BRDTYPE_P3_IMEZ
:
2186 case NETXEN_BRDTYPE_P3_10G_SFP_PLUS
:
2187 case NETXEN_BRDTYPE_P3_10G_SFP_CT
:
2188 case NETXEN_BRDTYPE_P3_10G_SFP_QT
:
2189 case NETXEN_BRDTYPE_P3_10G_XFP
:
2190 case NETXEN_BRDTYPE_P3_10000_BASE_T
:
2191 adapter
->ahw
.port_type
= NETXEN_NIC_XGBE
;
2193 case NETXEN_BRDTYPE_P1_BD
:
2194 case NETXEN_BRDTYPE_P1_SB
:
2195 case NETXEN_BRDTYPE_P1_SMAX
:
2196 case NETXEN_BRDTYPE_P1_SOCK
:
2197 case NETXEN_BRDTYPE_P3_REF_QG
:
2198 case NETXEN_BRDTYPE_P3_4_GB
:
2199 case NETXEN_BRDTYPE_P3_4_GB_MM
:
2200 adapter
->ahw
.port_type
= NETXEN_NIC_GBE
;
2202 case NETXEN_BRDTYPE_P3_10G_TP
:
2203 adapter
->ahw
.port_type
= (adapter
->portnum
< 2) ?
2204 NETXEN_NIC_XGBE
: NETXEN_NIC_GBE
;
2207 dev_err(&pdev
->dev
, "unknown board type %x\n", board_type
);
2208 adapter
->ahw
.port_type
= NETXEN_NIC_XGBE
;
2215 /* NIU access sections */
2217 int netxen_nic_set_mtu_gb(struct netxen_adapter
*adapter
, int new_mtu
)
2219 new_mtu
+= MTU_FUDGE_FACTOR
;
2220 netxen_nic_write_w0(adapter
,
2221 NETXEN_NIU_GB_MAX_FRAME_SIZE(adapter
->physical_port
),
2226 int netxen_nic_set_mtu_xgb(struct netxen_adapter
*adapter
, int new_mtu
)
2228 new_mtu
+= MTU_FUDGE_FACTOR
;
2229 if (adapter
->physical_port
== 0)
2230 netxen_nic_write_w0(adapter
, NETXEN_NIU_XGE_MAX_FRAME_SIZE
,
2233 netxen_nic_write_w0(adapter
, NETXEN_NIU_XG1_MAX_FRAME_SIZE
,
2239 netxen_crb_writelit_adapter(struct netxen_adapter
*adapter
,
2240 unsigned long off
, int data
)
2242 adapter
->hw_write_wx(adapter
, off
, &data
, 4);
2245 void netxen_nic_set_link_parameters(struct netxen_adapter
*adapter
)
2251 if (!netif_carrier_ok(adapter
->netdev
)) {
2252 adapter
->link_speed
= 0;
2253 adapter
->link_duplex
= -1;
2254 adapter
->link_autoneg
= AUTONEG_ENABLE
;
2258 if (adapter
->ahw
.port_type
== NETXEN_NIC_GBE
) {
2259 adapter
->hw_read_wx(adapter
,
2260 NETXEN_PORT_MODE_ADDR
, &port_mode
, 4);
2261 if (port_mode
== NETXEN_PORT_MODE_802_3_AP
) {
2262 adapter
->link_speed
= SPEED_1000
;
2263 adapter
->link_duplex
= DUPLEX_FULL
;
2264 adapter
->link_autoneg
= AUTONEG_DISABLE
;
2268 if (adapter
->phy_read
2269 && adapter
->phy_read(adapter
,
2270 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS
,
2272 if (netxen_get_phy_link(status
)) {
2273 switch (netxen_get_phy_speed(status
)) {
2275 adapter
->link_speed
= SPEED_10
;
2278 adapter
->link_speed
= SPEED_100
;
2281 adapter
->link_speed
= SPEED_1000
;
2284 adapter
->link_speed
= 0;
2287 switch (netxen_get_phy_duplex(status
)) {
2289 adapter
->link_duplex
= DUPLEX_HALF
;
2292 adapter
->link_duplex
= DUPLEX_FULL
;
2295 adapter
->link_duplex
= -1;
2298 if (adapter
->phy_read
2299 && adapter
->phy_read(adapter
,
2300 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG
,
2302 adapter
->link_autoneg
= autoneg
;
2307 adapter
->link_speed
= 0;
2308 adapter
->link_duplex
= -1;
2313 void netxen_nic_get_firmware_info(struct netxen_adapter
*adapter
)
2315 u32 fw_major
, fw_minor
, fw_build
;
2316 char brd_name
[NETXEN_MAX_SHORT_NAME
];
2317 char serial_num
[32];
2320 struct pci_dev
*pdev
= adapter
->pdev
;
2322 adapter
->driver_mismatch
= 0;
2324 ptr32
= (int *)&serial_num
;
2325 addr
= NETXEN_USER_START
+
2326 offsetof(struct netxen_new_user_info
, serial_num
);
2327 for (i
= 0; i
< 8; i
++) {
2328 if (netxen_rom_fast_read(adapter
, addr
, &val
) == -1) {
2329 dev_err(&pdev
->dev
, "error reading board info\n");
2330 adapter
->driver_mismatch
= 1;
2333 ptr32
[i
] = cpu_to_le32(val
);
2334 addr
+= sizeof(u32
);
2337 adapter
->hw_read_wx(adapter
, NETXEN_FW_VERSION_MAJOR
, &fw_major
, 4);
2338 adapter
->hw_read_wx(adapter
, NETXEN_FW_VERSION_MINOR
, &fw_minor
, 4);
2339 adapter
->hw_read_wx(adapter
, NETXEN_FW_VERSION_SUB
, &fw_build
, 4);
2341 adapter
->fw_major
= fw_major
;
2342 adapter
->fw_version
= NETXEN_VERSION_CODE(fw_major
, fw_minor
, fw_build
);
2344 if (adapter
->portnum
== 0) {
2345 get_brd_name_by_type(adapter
->ahw
.board_type
, brd_name
);
2347 printk(KERN_INFO
"NetXen %s Board S/N %s Chip rev 0x%x\n",
2348 brd_name
, serial_num
, adapter
->ahw
.revision_id
);
2351 if (adapter
->fw_version
< NETXEN_VERSION_CODE(3, 4, 216)) {
2352 adapter
->driver_mismatch
= 1;
2353 dev_warn(&pdev
->dev
, "firmware version %d.%d.%d unsupported\n",
2354 fw_major
, fw_minor
, fw_build
);
2358 dev_info(&pdev
->dev
, "firmware version %d.%d.%d\n",
2359 fw_major
, fw_minor
, fw_build
);
2361 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
2362 adapter
->hw_read_wx(adapter
,
2363 NETXEN_MIU_MN_CONTROL
, &i
, 4);
2364 adapter
->ahw
.cut_through
= (i
& 0x4) ? 1 : 0;
2365 dev_info(&pdev
->dev
, "firmware running in %s mode\n",
2366 adapter
->ahw
.cut_through
? "cut-through" : "legacy");
2371 netxen_nic_wol_supported(struct netxen_adapter
*adapter
)
2375 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
2378 wol_cfg
= netxen_nic_reg_read(adapter
, NETXEN_WOL_CONFIG_NV
);
2379 if (wol_cfg
& (1UL << adapter
->portnum
)) {
2380 wol_cfg
= netxen_nic_reg_read(adapter
, NETXEN_WOL_CONFIG
);
2381 if (wol_cfg
& (1 << adapter
->portnum
))