netxen: onchip memory access change
[linux-2.6.git] / drivers / net / netxen / netxen_nic_hw.c
1 /*
2  * Copyright (C) 2003 - 2009 NetXen, Inc.
3  * Copyright (C) 2009 - QLogic Corporation.
4  * All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
19  * MA  02111-1307, USA.
20  *
21  * The full GNU General Public License is included in this distribution
22  * in the file called LICENSE.
23  *
24  */
25
26 #include "netxen_nic.h"
27 #include "netxen_nic_hw.h"
28
29 #include <net/ip.h>
30
31 #define MASK(n) ((1ULL<<(n))-1)
32 #define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | ((addr >> 25) & 0x3ff))
33 #define OCM_WIN(addr) (((addr & 0x1ff0000) >> 1) | ((addr >> 25) & 0x3ff))
34 #define OCM_WIN_P3P(addr) (addr & 0xffc0000)
35 #define MS_WIN(addr) (addr & 0x0ffc0000)
36
37 #define GET_MEM_OFFS_2M(addr) (addr & MASK(18))
38
39 #define CRB_BLK(off)    ((off >> 20) & 0x3f)
40 #define CRB_SUBBLK(off) ((off >> 16) & 0xf)
41 #define CRB_WINDOW_2M   (0x130060)
42 #define CRB_HI(off)     ((crb_hub_agt[CRB_BLK(off)] << 20) | ((off) & 0xf0000))
43 #define CRB_INDIRECT_2M (0x1e0000UL)
44
45 static void netxen_nic_io_write_128M(struct netxen_adapter *adapter,
46                 void __iomem *addr, u32 data);
47 static u32 netxen_nic_io_read_128M(struct netxen_adapter *adapter,
48                 void __iomem *addr);
49
50 #ifndef readq
51 static inline u64 readq(void __iomem *addr)
52 {
53         return readl(addr) | (((u64) readl(addr + 4)) << 32LL);
54 }
55 #endif
56
57 #ifndef writeq
58 static inline void writeq(u64 val, void __iomem *addr)
59 {
60         writel(((u32) (val)), (addr));
61         writel(((u32) (val >> 32)), (addr + 4));
62 }
63 #endif
64
65 #define ADDR_IN_RANGE(addr, low, high)  \
66         (((addr) < (high)) && ((addr) >= (low)))
67
68 #define PCI_OFFSET_FIRST_RANGE(adapter, off)    \
69         ((adapter)->ahw.pci_base0 + (off))
70 #define PCI_OFFSET_SECOND_RANGE(adapter, off)   \
71         ((adapter)->ahw.pci_base1 + (off) - SECOND_PAGE_GROUP_START)
72 #define PCI_OFFSET_THIRD_RANGE(adapter, off)    \
73         ((adapter)->ahw.pci_base2 + (off) - THIRD_PAGE_GROUP_START)
74
75 static void __iomem *pci_base_offset(struct netxen_adapter *adapter,
76                                             unsigned long off)
77 {
78         if (ADDR_IN_RANGE(off, FIRST_PAGE_GROUP_START, FIRST_PAGE_GROUP_END))
79                 return PCI_OFFSET_FIRST_RANGE(adapter, off);
80
81         if (ADDR_IN_RANGE(off, SECOND_PAGE_GROUP_START, SECOND_PAGE_GROUP_END))
82                 return PCI_OFFSET_SECOND_RANGE(adapter, off);
83
84         if (ADDR_IN_RANGE(off, THIRD_PAGE_GROUP_START, THIRD_PAGE_GROUP_END))
85                 return PCI_OFFSET_THIRD_RANGE(adapter, off);
86
87         return NULL;
88 }
89
90 static crb_128M_2M_block_map_t
91 crb_128M_2M_map[64] __cacheline_aligned_in_smp = {
92     {{{0, 0,         0,         0} } },         /* 0: PCI */
93     {{{1, 0x0100000, 0x0102000, 0x120000},      /* 1: PCIE */
94           {1, 0x0110000, 0x0120000, 0x130000},
95           {1, 0x0120000, 0x0122000, 0x124000},
96           {1, 0x0130000, 0x0132000, 0x126000},
97           {1, 0x0140000, 0x0142000, 0x128000},
98           {1, 0x0150000, 0x0152000, 0x12a000},
99           {1, 0x0160000, 0x0170000, 0x110000},
100           {1, 0x0170000, 0x0172000, 0x12e000},
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, 0x01e0000, 0x01e0800, 0x122000},
108           {0, 0x0000000, 0x0000000, 0x000000} } },
109         {{{1, 0x0200000, 0x0210000, 0x180000} } },/* 2: MN */
110     {{{0, 0,         0,         0} } },     /* 3: */
111     {{{1, 0x0400000, 0x0401000, 0x169000} } },/* 4: P2NR1 */
112     {{{1, 0x0500000, 0x0510000, 0x140000} } },/* 5: SRE   */
113     {{{1, 0x0600000, 0x0610000, 0x1c0000} } },/* 6: NIU   */
114     {{{1, 0x0700000, 0x0704000, 0x1b8000} } },/* 7: QM    */
115     {{{1, 0x0800000, 0x0802000, 0x170000},  /* 8: SQM0  */
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       {0, 0x0000000, 0x0000000, 0x000000},
124       {0, 0x0000000, 0x0000000, 0x000000},
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       {1, 0x08f0000, 0x08f2000, 0x172000} } },
131     {{{1, 0x0900000, 0x0902000, 0x174000},      /* 9: SQM1*/
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       {0, 0x0000000, 0x0000000, 0x000000},
140       {0, 0x0000000, 0x0000000, 0x000000},
141       {0, 0x0000000, 0x0000000, 0x000000},
142       {0, 0x0000000, 0x0000000, 0x000000},
143       {0, 0x0000000, 0x0000000, 0x000000},
144       {0, 0x0000000, 0x0000000, 0x000000},
145       {0, 0x0000000, 0x0000000, 0x000000},
146       {1, 0x09f0000, 0x09f2000, 0x176000} } },
147     {{{0, 0x0a00000, 0x0a02000, 0x178000},      /* 10: SQM2*/
148       {0, 0x0000000, 0x0000000, 0x000000},
149       {0, 0x0000000, 0x0000000, 0x000000},
150       {0, 0x0000000, 0x0000000, 0x000000},
151       {0, 0x0000000, 0x0000000, 0x000000},
152       {0, 0x0000000, 0x0000000, 0x000000},
153       {0, 0x0000000, 0x0000000, 0x000000},
154       {0, 0x0000000, 0x0000000, 0x000000},
155       {0, 0x0000000, 0x0000000, 0x000000},
156       {0, 0x0000000, 0x0000000, 0x000000},
157       {0, 0x0000000, 0x0000000, 0x000000},
158       {0, 0x0000000, 0x0000000, 0x000000},
159       {0, 0x0000000, 0x0000000, 0x000000},
160       {0, 0x0000000, 0x0000000, 0x000000},
161       {0, 0x0000000, 0x0000000, 0x000000},
162       {1, 0x0af0000, 0x0af2000, 0x17a000} } },
163     {{{0, 0x0b00000, 0x0b02000, 0x17c000},      /* 11: SQM3*/
164       {0, 0x0000000, 0x0000000, 0x000000},
165       {0, 0x0000000, 0x0000000, 0x000000},
166       {0, 0x0000000, 0x0000000, 0x000000},
167       {0, 0x0000000, 0x0000000, 0x000000},
168       {0, 0x0000000, 0x0000000, 0x000000},
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       {0, 0x0000000, 0x0000000, 0x000000},
178       {1, 0x0bf0000, 0x0bf2000, 0x17e000} } },
179         {{{1, 0x0c00000, 0x0c04000, 0x1d4000} } },/* 12: I2Q */
180         {{{1, 0x0d00000, 0x0d04000, 0x1a4000} } },/* 13: TMR */
181         {{{1, 0x0e00000, 0x0e04000, 0x1a0000} } },/* 14: ROMUSB */
182         {{{1, 0x0f00000, 0x0f01000, 0x164000} } },/* 15: PEG4 */
183         {{{0, 0x1000000, 0x1004000, 0x1a8000} } },/* 16: XDMA */
184         {{{1, 0x1100000, 0x1101000, 0x160000} } },/* 17: PEG0 */
185         {{{1, 0x1200000, 0x1201000, 0x161000} } },/* 18: PEG1 */
186         {{{1, 0x1300000, 0x1301000, 0x162000} } },/* 19: PEG2 */
187         {{{1, 0x1400000, 0x1401000, 0x163000} } },/* 20: PEG3 */
188         {{{1, 0x1500000, 0x1501000, 0x165000} } },/* 21: P2ND */
189         {{{1, 0x1600000, 0x1601000, 0x166000} } },/* 22: P2NI */
190         {{{0, 0,         0,         0} } },     /* 23: */
191         {{{0, 0,         0,         0} } },     /* 24: */
192         {{{0, 0,         0,         0} } },     /* 25: */
193         {{{0, 0,         0,         0} } },     /* 26: */
194         {{{0, 0,         0,         0} } },     /* 27: */
195         {{{0, 0,         0,         0} } },     /* 28: */
196         {{{1, 0x1d00000, 0x1d10000, 0x190000} } },/* 29: MS */
197     {{{1, 0x1e00000, 0x1e01000, 0x16a000} } },/* 30: P2NR2 */
198     {{{1, 0x1f00000, 0x1f10000, 0x150000} } },/* 31: EPG */
199         {{{0} } },                              /* 32: PCI */
200         {{{1, 0x2100000, 0x2102000, 0x120000},  /* 33: PCIE */
201           {1, 0x2110000, 0x2120000, 0x130000},
202           {1, 0x2120000, 0x2122000, 0x124000},
203           {1, 0x2130000, 0x2132000, 0x126000},
204           {1, 0x2140000, 0x2142000, 0x128000},
205           {1, 0x2150000, 0x2152000, 0x12a000},
206           {1, 0x2160000, 0x2170000, 0x110000},
207           {1, 0x2170000, 0x2172000, 0x12e000},
208           {0, 0x0000000, 0x0000000, 0x000000},
209           {0, 0x0000000, 0x0000000, 0x000000},
210           {0, 0x0000000, 0x0000000, 0x000000},
211           {0, 0x0000000, 0x0000000, 0x000000},
212           {0, 0x0000000, 0x0000000, 0x000000},
213           {0, 0x0000000, 0x0000000, 0x000000},
214           {0, 0x0000000, 0x0000000, 0x000000},
215           {0, 0x0000000, 0x0000000, 0x000000} } },
216         {{{1, 0x2200000, 0x2204000, 0x1b0000} } },/* 34: CAM */
217         {{{0} } },                              /* 35: */
218         {{{0} } },                              /* 36: */
219         {{{0} } },                              /* 37: */
220         {{{0} } },                              /* 38: */
221         {{{0} } },                              /* 39: */
222         {{{1, 0x2800000, 0x2804000, 0x1a4000} } },/* 40: TMR */
223         {{{1, 0x2900000, 0x2901000, 0x16b000} } },/* 41: P2NR3 */
224         {{{1, 0x2a00000, 0x2a00400, 0x1ac400} } },/* 42: RPMX1 */
225         {{{1, 0x2b00000, 0x2b00400, 0x1ac800} } },/* 43: RPMX2 */
226         {{{1, 0x2c00000, 0x2c00400, 0x1acc00} } },/* 44: RPMX3 */
227         {{{1, 0x2d00000, 0x2d00400, 0x1ad000} } },/* 45: RPMX4 */
228         {{{1, 0x2e00000, 0x2e00400, 0x1ad400} } },/* 46: RPMX5 */
229         {{{1, 0x2f00000, 0x2f00400, 0x1ad800} } },/* 47: RPMX6 */
230         {{{1, 0x3000000, 0x3000400, 0x1adc00} } },/* 48: RPMX7 */
231         {{{0, 0x3100000, 0x3104000, 0x1a8000} } },/* 49: XDMA */
232         {{{1, 0x3200000, 0x3204000, 0x1d4000} } },/* 50: I2Q */
233         {{{1, 0x3300000, 0x3304000, 0x1a0000} } },/* 51: ROMUSB */
234         {{{0} } },                              /* 52: */
235         {{{1, 0x3500000, 0x3500400, 0x1ac000} } },/* 53: RPMX0 */
236         {{{1, 0x3600000, 0x3600400, 0x1ae000} } },/* 54: RPMX8 */
237         {{{1, 0x3700000, 0x3700400, 0x1ae400} } },/* 55: RPMX9 */
238         {{{1, 0x3800000, 0x3804000, 0x1d0000} } },/* 56: OCM0 */
239         {{{1, 0x3900000, 0x3904000, 0x1b4000} } },/* 57: CRYPTO */
240         {{{1, 0x3a00000, 0x3a04000, 0x1d8000} } },/* 58: SMB */
241         {{{0} } },                              /* 59: I2C0 */
242         {{{0} } },                              /* 60: I2C1 */
243         {{{1, 0x3d00000, 0x3d04000, 0x1d8000} } },/* 61: LPC */
244         {{{1, 0x3e00000, 0x3e01000, 0x167000} } },/* 62: P2NC */
245         {{{1, 0x3f00000, 0x3f01000, 0x168000} } }       /* 63: P2NR0 */
246 };
247
248 /*
249  * top 12 bits of crb internal address (hub, agent)
250  */
251 static unsigned crb_hub_agt[64] =
252 {
253         0,
254         NETXEN_HW_CRB_HUB_AGT_ADR_PS,
255         NETXEN_HW_CRB_HUB_AGT_ADR_MN,
256         NETXEN_HW_CRB_HUB_AGT_ADR_MS,
257         0,
258         NETXEN_HW_CRB_HUB_AGT_ADR_SRE,
259         NETXEN_HW_CRB_HUB_AGT_ADR_NIU,
260         NETXEN_HW_CRB_HUB_AGT_ADR_QMN,
261         NETXEN_HW_CRB_HUB_AGT_ADR_SQN0,
262         NETXEN_HW_CRB_HUB_AGT_ADR_SQN1,
263         NETXEN_HW_CRB_HUB_AGT_ADR_SQN2,
264         NETXEN_HW_CRB_HUB_AGT_ADR_SQN3,
265         NETXEN_HW_CRB_HUB_AGT_ADR_I2Q,
266         NETXEN_HW_CRB_HUB_AGT_ADR_TIMR,
267         NETXEN_HW_CRB_HUB_AGT_ADR_ROMUSB,
268         NETXEN_HW_CRB_HUB_AGT_ADR_PGN4,
269         NETXEN_HW_CRB_HUB_AGT_ADR_XDMA,
270         NETXEN_HW_CRB_HUB_AGT_ADR_PGN0,
271         NETXEN_HW_CRB_HUB_AGT_ADR_PGN1,
272         NETXEN_HW_CRB_HUB_AGT_ADR_PGN2,
273         NETXEN_HW_CRB_HUB_AGT_ADR_PGN3,
274         NETXEN_HW_CRB_HUB_AGT_ADR_PGND,
275         NETXEN_HW_CRB_HUB_AGT_ADR_PGNI,
276         NETXEN_HW_CRB_HUB_AGT_ADR_PGS0,
277         NETXEN_HW_CRB_HUB_AGT_ADR_PGS1,
278         NETXEN_HW_CRB_HUB_AGT_ADR_PGS2,
279         NETXEN_HW_CRB_HUB_AGT_ADR_PGS3,
280         0,
281         NETXEN_HW_CRB_HUB_AGT_ADR_PGSI,
282         NETXEN_HW_CRB_HUB_AGT_ADR_SN,
283         0,
284         NETXEN_HW_CRB_HUB_AGT_ADR_EG,
285         0,
286         NETXEN_HW_CRB_HUB_AGT_ADR_PS,
287         NETXEN_HW_CRB_HUB_AGT_ADR_CAM,
288         0,
289         0,
290         0,
291         0,
292         0,
293         NETXEN_HW_CRB_HUB_AGT_ADR_TIMR,
294         0,
295         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX1,
296         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX2,
297         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX3,
298         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX4,
299         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX5,
300         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX6,
301         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX7,
302         NETXEN_HW_CRB_HUB_AGT_ADR_XDMA,
303         NETXEN_HW_CRB_HUB_AGT_ADR_I2Q,
304         NETXEN_HW_CRB_HUB_AGT_ADR_ROMUSB,
305         0,
306         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX0,
307         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX8,
308         NETXEN_HW_CRB_HUB_AGT_ADR_RPMX9,
309         NETXEN_HW_CRB_HUB_AGT_ADR_OCM0,
310         0,
311         NETXEN_HW_CRB_HUB_AGT_ADR_SMB,
312         NETXEN_HW_CRB_HUB_AGT_ADR_I2C0,
313         NETXEN_HW_CRB_HUB_AGT_ADR_I2C1,
314         0,
315         NETXEN_HW_CRB_HUB_AGT_ADR_PGNC,
316         0,
317 };
318
319 /*  PCI Windowing for DDR regions.  */
320
321 #define NETXEN_WINDOW_ONE       0x2000000 /*CRB Window: bit 25 of CRB address */
322
323 #define NETXEN_PCIE_SEM_TIMEOUT 10000
324
325 int
326 netxen_pcie_sem_lock(struct netxen_adapter *adapter, int sem, u32 id_reg)
327 {
328         int done = 0, timeout = 0;
329
330         while (!done) {
331                 done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM_LOCK(sem)));
332                 if (done == 1)
333                         break;
334                 if (++timeout >= NETXEN_PCIE_SEM_TIMEOUT)
335                         return -1;
336                 msleep(1);
337         }
338
339         if (id_reg)
340                 NXWR32(adapter, id_reg, adapter->portnum);
341
342         return 0;
343 }
344
345 void
346 netxen_pcie_sem_unlock(struct netxen_adapter *adapter, int sem)
347 {
348         int val;
349         val = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM_UNLOCK(sem)));
350 }
351
352 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
353 {
354         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
355                 NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1+(0x10000*port), 0x1447);
356                 NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_0+(0x10000*port), 0x5);
357         }
358
359         return 0;
360 }
361
362 /* Disable an XG interface */
363 int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
364 {
365         __u32 mac_cfg;
366         u32 port = adapter->physical_port;
367
368         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
369                 return 0;
370
371         if (port > NETXEN_NIU_MAX_XG_PORTS)
372                 return -EINVAL;
373
374         mac_cfg = 0;
375         if (NXWR32(adapter,
376                         NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), mac_cfg))
377                 return -EIO;
378         return 0;
379 }
380
381 #define NETXEN_UNICAST_ADDR(port, index) \
382         (NETXEN_UNICAST_ADDR_BASE+(port*32)+(index*8))
383 #define NETXEN_MCAST_ADDR(port, index) \
384         (NETXEN_MULTICAST_ADDR_BASE+(port*0x80)+(index*8))
385 #define MAC_HI(addr) \
386         ((addr[2] << 16) | (addr[1] << 8) | (addr[0]))
387 #define MAC_LO(addr) \
388         ((addr[5] << 16) | (addr[4] << 8) | (addr[3]))
389
390 int netxen_p2_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
391 {
392         __u32 reg;
393         u32 port = adapter->physical_port;
394
395         if (port > NETXEN_NIU_MAX_XG_PORTS)
396                 return -EINVAL;
397
398         reg = NXRD32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port));
399         if (mode == NETXEN_NIU_PROMISC_MODE)
400                 reg = (reg | 0x2000UL);
401         else
402                 reg = (reg & ~0x2000UL);
403
404         if (mode == NETXEN_NIU_ALLMULTI_MODE)
405                 reg = (reg | 0x1000UL);
406         else
407                 reg = (reg & ~0x1000UL);
408
409         NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
410
411         return 0;
412 }
413
414 int netxen_p2_nic_set_mac_addr(struct netxen_adapter *adapter, u8 *addr)
415 {
416         u32 mac_hi, mac_lo;
417         u32 reg_hi, reg_lo;
418
419         u8 phy = adapter->physical_port;
420
421         if (phy >= NETXEN_NIU_MAX_XG_PORTS)
422                 return -EINVAL;
423
424         mac_lo = ((u32)addr[0] << 16) | ((u32)addr[1] << 24);
425         mac_hi = addr[2] | ((u32)addr[3] << 8) |
426                 ((u32)addr[4] << 16) | ((u32)addr[5] << 24);
427
428         reg_lo = NETXEN_NIU_XGE_STATION_ADDR_0_1 + (0x10000 * phy);
429         reg_hi = NETXEN_NIU_XGE_STATION_ADDR_0_HI + (0x10000 * phy);
430
431         /* write twice to flush */
432         if (NXWR32(adapter, reg_lo, mac_lo) || NXWR32(adapter, reg_hi, mac_hi))
433                 return -EIO;
434         if (NXWR32(adapter, reg_lo, mac_lo) || NXWR32(adapter, reg_hi, mac_hi))
435                 return -EIO;
436
437         return 0;
438 }
439
440 static int
441 netxen_nic_enable_mcast_filter(struct netxen_adapter *adapter)
442 {
443         u32     val = 0;
444         u16 port = adapter->physical_port;
445         u8 *addr = adapter->netdev->dev_addr;
446
447         if (adapter->mc_enabled)
448                 return 0;
449
450         val = NXRD32(adapter, NETXEN_MAC_ADDR_CNTL_REG);
451         val |= (1UL << (28+port));
452         NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
453
454         /* add broadcast addr to filter */
455         val = 0xffffff;
456         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
457         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0)+4, val);
458
459         /* add station addr to filter */
460         val = MAC_HI(addr);
461         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1), val);
462         val = MAC_LO(addr);
463         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1)+4, val);
464
465         adapter->mc_enabled = 1;
466         return 0;
467 }
468
469 static int
470 netxen_nic_disable_mcast_filter(struct netxen_adapter *adapter)
471 {
472         u32     val = 0;
473         u16 port = adapter->physical_port;
474         u8 *addr = adapter->netdev->dev_addr;
475
476         if (!adapter->mc_enabled)
477                 return 0;
478
479         val = NXRD32(adapter, NETXEN_MAC_ADDR_CNTL_REG);
480         val &= ~(1UL << (28+port));
481         NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
482
483         val = MAC_HI(addr);
484         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
485         val = MAC_LO(addr);
486         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0)+4, val);
487
488         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1), 0);
489         NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1)+4, 0);
490
491         adapter->mc_enabled = 0;
492         return 0;
493 }
494
495 static int
496 netxen_nic_set_mcast_addr(struct netxen_adapter *adapter,
497                 int index, u8 *addr)
498 {
499         u32 hi = 0, lo = 0;
500         u16 port = adapter->physical_port;
501
502         lo = MAC_LO(addr);
503         hi = MAC_HI(addr);
504
505         NXWR32(adapter, NETXEN_MCAST_ADDR(port, index), hi);
506         NXWR32(adapter, NETXEN_MCAST_ADDR(port, index)+4, lo);
507
508         return 0;
509 }
510
511 void netxen_p2_nic_set_multi(struct net_device *netdev)
512 {
513         struct netxen_adapter *adapter = netdev_priv(netdev);
514         struct dev_mc_list *mc_ptr;
515         u8 null_addr[6];
516         int index = 0;
517
518         memset(null_addr, 0, 6);
519
520         if (netdev->flags & IFF_PROMISC) {
521
522                 adapter->set_promisc(adapter,
523                                 NETXEN_NIU_PROMISC_MODE);
524
525                 /* Full promiscuous mode */
526                 netxen_nic_disable_mcast_filter(adapter);
527
528                 return;
529         }
530
531         if (netdev->mc_count == 0) {
532                 adapter->set_promisc(adapter,
533                                 NETXEN_NIU_NON_PROMISC_MODE);
534                 netxen_nic_disable_mcast_filter(adapter);
535                 return;
536         }
537
538         adapter->set_promisc(adapter, NETXEN_NIU_ALLMULTI_MODE);
539         if (netdev->flags & IFF_ALLMULTI ||
540                         netdev->mc_count > adapter->max_mc_count) {
541                 netxen_nic_disable_mcast_filter(adapter);
542                 return;
543         }
544
545         netxen_nic_enable_mcast_filter(adapter);
546
547         for (mc_ptr = netdev->mc_list; mc_ptr; mc_ptr = mc_ptr->next, index++)
548                 netxen_nic_set_mcast_addr(adapter, index, mc_ptr->dmi_addr);
549
550         if (index != netdev->mc_count)
551                 printk(KERN_WARNING "%s: %s multicast address count mismatch\n",
552                         netxen_nic_driver_name, netdev->name);
553
554         /* Clear out remaining addresses */
555         for (; index < adapter->max_mc_count; index++)
556                 netxen_nic_set_mcast_addr(adapter, index, null_addr);
557 }
558
559 static int
560 netxen_send_cmd_descs(struct netxen_adapter *adapter,
561                 struct cmd_desc_type0 *cmd_desc_arr, int nr_desc)
562 {
563         u32 i, producer, consumer;
564         struct netxen_cmd_buffer *pbuf;
565         struct cmd_desc_type0 *cmd_desc;
566         struct nx_host_tx_ring *tx_ring;
567
568         i = 0;
569
570         if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
571                 return -EIO;
572
573         tx_ring = adapter->tx_ring;
574         __netif_tx_lock_bh(tx_ring->txq);
575
576         producer = tx_ring->producer;
577         consumer = tx_ring->sw_consumer;
578
579         if (nr_desc >= netxen_tx_avail(tx_ring)) {
580                 netif_tx_stop_queue(tx_ring->txq);
581                 __netif_tx_unlock_bh(tx_ring->txq);
582                 return -EBUSY;
583         }
584
585         do {
586                 cmd_desc = &cmd_desc_arr[i];
587
588                 pbuf = &tx_ring->cmd_buf_arr[producer];
589                 pbuf->skb = NULL;
590                 pbuf->frag_count = 0;
591
592                 memcpy(&tx_ring->desc_head[producer],
593                         &cmd_desc_arr[i], sizeof(struct cmd_desc_type0));
594
595                 producer = get_next_index(producer, tx_ring->num_desc);
596                 i++;
597
598         } while (i != nr_desc);
599
600         tx_ring->producer = producer;
601
602         netxen_nic_update_cmd_producer(adapter, tx_ring);
603
604         __netif_tx_unlock_bh(tx_ring->txq);
605
606         return 0;
607 }
608
609 static int
610 nx_p3_sre_macaddr_change(struct netxen_adapter *adapter, u8 *addr, unsigned op)
611 {
612         nx_nic_req_t req;
613         nx_mac_req_t *mac_req;
614         u64 word;
615
616         memset(&req, 0, sizeof(nx_nic_req_t));
617         req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
618
619         word = NX_MAC_EVENT | ((u64)adapter->portnum << 16);
620         req.req_hdr = cpu_to_le64(word);
621
622         mac_req = (nx_mac_req_t *)&req.words[0];
623         mac_req->op = op;
624         memcpy(mac_req->mac_addr, addr, 6);
625
626         return netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
627 }
628
629 static int nx_p3_nic_add_mac(struct netxen_adapter *adapter,
630                 u8 *addr, struct list_head *del_list)
631 {
632         struct list_head *head;
633         nx_mac_list_t *cur;
634
635         /* look up if already exists */
636         list_for_each(head, del_list) {
637                 cur = list_entry(head, nx_mac_list_t, list);
638
639                 if (memcmp(addr, cur->mac_addr, ETH_ALEN) == 0) {
640                         list_move_tail(head, &adapter->mac_list);
641                         return 0;
642                 }
643         }
644
645         cur = kzalloc(sizeof(nx_mac_list_t), GFP_ATOMIC);
646         if (cur == NULL) {
647                 printk(KERN_ERR "%s: failed to add mac address filter\n",
648                                 adapter->netdev->name);
649                 return -ENOMEM;
650         }
651         memcpy(cur->mac_addr, addr, ETH_ALEN);
652         list_add_tail(&cur->list, &adapter->mac_list);
653         return nx_p3_sre_macaddr_change(adapter,
654                                 cur->mac_addr, NETXEN_MAC_ADD);
655 }
656
657 void netxen_p3_nic_set_multi(struct net_device *netdev)
658 {
659         struct netxen_adapter *adapter = netdev_priv(netdev);
660         struct dev_mc_list *mc_ptr;
661         u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
662         u32 mode = VPORT_MISS_MODE_DROP;
663         LIST_HEAD(del_list);
664         struct list_head *head;
665         nx_mac_list_t *cur;
666
667         list_splice_tail_init(&adapter->mac_list, &del_list);
668
669         nx_p3_nic_add_mac(adapter, netdev->dev_addr, &del_list);
670         nx_p3_nic_add_mac(adapter, bcast_addr, &del_list);
671
672         if (netdev->flags & IFF_PROMISC) {
673                 mode = VPORT_MISS_MODE_ACCEPT_ALL;
674                 goto send_fw_cmd;
675         }
676
677         if ((netdev->flags & IFF_ALLMULTI) ||
678                         (netdev->mc_count > adapter->max_mc_count)) {
679                 mode = VPORT_MISS_MODE_ACCEPT_MULTI;
680                 goto send_fw_cmd;
681         }
682
683         if (netdev->mc_count > 0) {
684                 for (mc_ptr = netdev->mc_list; mc_ptr;
685                      mc_ptr = mc_ptr->next) {
686                         nx_p3_nic_add_mac(adapter, mc_ptr->dmi_addr, &del_list);
687                 }
688         }
689
690 send_fw_cmd:
691         adapter->set_promisc(adapter, mode);
692         head = &del_list;
693         while (!list_empty(head)) {
694                 cur = list_entry(head->next, nx_mac_list_t, list);
695
696                 nx_p3_sre_macaddr_change(adapter,
697                                 cur->mac_addr, NETXEN_MAC_DEL);
698                 list_del(&cur->list);
699                 kfree(cur);
700         }
701 }
702
703 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
704 {
705         nx_nic_req_t req;
706         u64 word;
707
708         memset(&req, 0, sizeof(nx_nic_req_t));
709
710         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
711
712         word = NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE |
713                         ((u64)adapter->portnum << 16);
714         req.req_hdr = cpu_to_le64(word);
715
716         req.words[0] = cpu_to_le64(mode);
717
718         return netxen_send_cmd_descs(adapter,
719                                 (struct cmd_desc_type0 *)&req, 1);
720 }
721
722 void netxen_p3_free_mac_list(struct netxen_adapter *adapter)
723 {
724         nx_mac_list_t *cur;
725         struct list_head *head = &adapter->mac_list;
726
727         while (!list_empty(head)) {
728                 cur = list_entry(head->next, nx_mac_list_t, list);
729                 nx_p3_sre_macaddr_change(adapter,
730                                 cur->mac_addr, NETXEN_MAC_DEL);
731                 list_del(&cur->list);
732                 kfree(cur);
733         }
734 }
735
736 int netxen_p3_nic_set_mac_addr(struct netxen_adapter *adapter, u8 *addr)
737 {
738         /* assuming caller has already copied new addr to netdev */
739         netxen_p3_nic_set_multi(adapter->netdev);
740         return 0;
741 }
742
743 #define NETXEN_CONFIG_INTR_COALESCE     3
744
745 /*
746  * Send the interrupt coalescing parameter set by ethtool to the card.
747  */
748 int netxen_config_intr_coalesce(struct netxen_adapter *adapter)
749 {
750         nx_nic_req_t req;
751         u64 word;
752         int rv;
753
754         memset(&req, 0, sizeof(nx_nic_req_t));
755
756         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
757
758         word = NETXEN_CONFIG_INTR_COALESCE | ((u64)adapter->portnum << 16);
759         req.req_hdr = cpu_to_le64(word);
760
761         memcpy(&req.words[0], &adapter->coal, sizeof(adapter->coal));
762
763         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
764         if (rv != 0) {
765                 printk(KERN_ERR "ERROR. Could not send "
766                         "interrupt coalescing parameters\n");
767         }
768
769         return rv;
770 }
771
772 int netxen_config_hw_lro(struct netxen_adapter *adapter, int enable)
773 {
774         nx_nic_req_t req;
775         u64 word;
776         int rv = 0;
777
778         if ((adapter->flags & NETXEN_NIC_LRO_ENABLED) == enable)
779                 return 0;
780
781         memset(&req, 0, sizeof(nx_nic_req_t));
782
783         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
784
785         word = NX_NIC_H2C_OPCODE_CONFIG_HW_LRO | ((u64)adapter->portnum << 16);
786         req.req_hdr = cpu_to_le64(word);
787
788         req.words[0] = cpu_to_le64(enable);
789
790         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
791         if (rv != 0) {
792                 printk(KERN_ERR "ERROR. Could not send "
793                         "configure hw lro request\n");
794         }
795
796         adapter->flags ^= NETXEN_NIC_LRO_ENABLED;
797
798         return rv;
799 }
800
801 int netxen_config_bridged_mode(struct netxen_adapter *adapter, int enable)
802 {
803         nx_nic_req_t req;
804         u64 word;
805         int rv = 0;
806
807         if (!!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED) == enable)
808                 return rv;
809
810         memset(&req, 0, sizeof(nx_nic_req_t));
811
812         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
813
814         word = NX_NIC_H2C_OPCODE_CONFIG_BRIDGING |
815                 ((u64)adapter->portnum << 16);
816         req.req_hdr = cpu_to_le64(word);
817
818         req.words[0] = cpu_to_le64(enable);
819
820         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
821         if (rv != 0) {
822                 printk(KERN_ERR "ERROR. Could not send "
823                                 "configure bridge mode request\n");
824         }
825
826         adapter->flags ^= NETXEN_NIC_BRIDGE_ENABLED;
827
828         return rv;
829 }
830
831
832 #define RSS_HASHTYPE_IP_TCP     0x3
833
834 int netxen_config_rss(struct netxen_adapter *adapter, int enable)
835 {
836         nx_nic_req_t req;
837         u64 word;
838         int i, rv;
839
840         u64 key[] = { 0xbeac01fa6a42b73bULL, 0x8030f20c77cb2da3ULL,
841                         0xae7b30b4d0ca2bcbULL, 0x43a38fb04167253dULL,
842                         0x255b0ec26d5a56daULL };
843
844
845         memset(&req, 0, sizeof(nx_nic_req_t));
846         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
847
848         word = NX_NIC_H2C_OPCODE_CONFIG_RSS | ((u64)adapter->portnum << 16);
849         req.req_hdr = cpu_to_le64(word);
850
851         /*
852          * RSS request:
853          * bits 3-0: hash_method
854          *      5-4: hash_type_ipv4
855          *      7-6: hash_type_ipv6
856          *        8: enable
857          *        9: use indirection table
858          *    47-10: reserved
859          *    63-48: indirection table mask
860          */
861         word =  ((u64)(RSS_HASHTYPE_IP_TCP & 0x3) << 4) |
862                 ((u64)(RSS_HASHTYPE_IP_TCP & 0x3) << 6) |
863                 ((u64)(enable & 0x1) << 8) |
864                 ((0x7ULL) << 48);
865         req.words[0] = cpu_to_le64(word);
866         for (i = 0; i < 5; i++)
867                 req.words[i+1] = cpu_to_le64(key[i]);
868
869
870         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
871         if (rv != 0) {
872                 printk(KERN_ERR "%s: could not configure RSS\n",
873                                 adapter->netdev->name);
874         }
875
876         return rv;
877 }
878
879 int netxen_config_ipaddr(struct netxen_adapter *adapter, u32 ip, int cmd)
880 {
881         nx_nic_req_t req;
882         u64 word;
883         int rv;
884
885         memset(&req, 0, sizeof(nx_nic_req_t));
886         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
887
888         word = NX_NIC_H2C_OPCODE_CONFIG_IPADDR | ((u64)adapter->portnum << 16);
889         req.req_hdr = cpu_to_le64(word);
890
891         req.words[0] = cpu_to_le64(cmd);
892         req.words[1] = cpu_to_le64(ip);
893
894         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
895         if (rv != 0) {
896                 printk(KERN_ERR "%s: could not notify %s IP 0x%x reuqest\n",
897                                 adapter->netdev->name,
898                                 (cmd == NX_IP_UP) ? "Add" : "Remove", ip);
899         }
900         return rv;
901 }
902
903 int netxen_linkevent_request(struct netxen_adapter *adapter, int enable)
904 {
905         nx_nic_req_t req;
906         u64 word;
907         int rv;
908
909         memset(&req, 0, sizeof(nx_nic_req_t));
910         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
911
912         word = NX_NIC_H2C_OPCODE_GET_LINKEVENT | ((u64)adapter->portnum << 16);
913         req.req_hdr = cpu_to_le64(word);
914         req.words[0] = cpu_to_le64(enable | (enable << 8));
915
916         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
917         if (rv != 0) {
918                 printk(KERN_ERR "%s: could not configure link notification\n",
919                                 adapter->netdev->name);
920         }
921
922         return rv;
923 }
924
925 int netxen_send_lro_cleanup(struct netxen_adapter *adapter)
926 {
927         nx_nic_req_t req;
928         u64 word;
929         int rv;
930
931         memset(&req, 0, sizeof(nx_nic_req_t));
932         req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
933
934         word = NX_NIC_H2C_OPCODE_LRO_REQUEST |
935                 ((u64)adapter->portnum << 16) |
936                 ((u64)NX_NIC_LRO_REQUEST_CLEANUP << 56) ;
937
938         req.req_hdr = cpu_to_le64(word);
939
940         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
941         if (rv != 0) {
942                 printk(KERN_ERR "%s: could not cleanup lro flows\n",
943                                 adapter->netdev->name);
944         }
945         return rv;
946 }
947
948 /*
949  * netxen_nic_change_mtu - Change the Maximum Transfer Unit
950  * @returns 0 on success, negative on failure
951  */
952
953 #define MTU_FUDGE_FACTOR        100
954
955 int netxen_nic_change_mtu(struct net_device *netdev, int mtu)
956 {
957         struct netxen_adapter *adapter = netdev_priv(netdev);
958         int max_mtu;
959         int rc = 0;
960
961         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
962                 max_mtu = P3_MAX_MTU;
963         else
964                 max_mtu = P2_MAX_MTU;
965
966         if (mtu > max_mtu) {
967                 printk(KERN_ERR "%s: mtu > %d bytes unsupported\n",
968                                 netdev->name, max_mtu);
969                 return -EINVAL;
970         }
971
972         if (adapter->set_mtu)
973                 rc = adapter->set_mtu(adapter, mtu);
974
975         if (!rc)
976                 netdev->mtu = mtu;
977
978         return rc;
979 }
980
981 static int netxen_get_flash_block(struct netxen_adapter *adapter, int base,
982                                   int size, __le32 * buf)
983 {
984         int i, v, addr;
985         __le32 *ptr32;
986
987         addr = base;
988         ptr32 = buf;
989         for (i = 0; i < size / sizeof(u32); i++) {
990                 if (netxen_rom_fast_read(adapter, addr, &v) == -1)
991                         return -1;
992                 *ptr32 = cpu_to_le32(v);
993                 ptr32++;
994                 addr += sizeof(u32);
995         }
996         if ((char *)buf + size > (char *)ptr32) {
997                 __le32 local;
998                 if (netxen_rom_fast_read(adapter, addr, &v) == -1)
999                         return -1;
1000                 local = cpu_to_le32(v);
1001                 memcpy(ptr32, &local, (char *)buf + size - (char *)ptr32);
1002         }
1003
1004         return 0;
1005 }
1006
1007 int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
1008 {
1009         __le32 *pmac = (__le32 *) mac;
1010         u32 offset;
1011
1012         offset = NX_FW_MAC_ADDR_OFFSET + (adapter->portnum * sizeof(u64));
1013
1014         if (netxen_get_flash_block(adapter, offset, sizeof(u64), pmac) == -1)
1015                 return -1;
1016
1017         if (*mac == cpu_to_le64(~0ULL)) {
1018
1019                 offset = NX_OLD_MAC_ADDR_OFFSET +
1020                         (adapter->portnum * sizeof(u64));
1021
1022                 if (netxen_get_flash_block(adapter,
1023                                         offset, sizeof(u64), pmac) == -1)
1024                         return -1;
1025
1026                 if (*mac == cpu_to_le64(~0ULL))
1027                         return -1;
1028         }
1029         return 0;
1030 }
1031
1032 int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
1033 {
1034         uint32_t crbaddr, mac_hi, mac_lo;
1035         int pci_func = adapter->ahw.pci_func;
1036
1037         crbaddr = CRB_MAC_BLOCK_START +
1038                 (4 * ((pci_func/2) * 3)) + (4 * (pci_func & 1));
1039
1040         mac_lo = NXRD32(adapter, crbaddr);
1041         mac_hi = NXRD32(adapter, crbaddr+4);
1042
1043         if (pci_func & 1)
1044                 *mac = le64_to_cpu((mac_lo >> 16) | ((u64)mac_hi << 16));
1045         else
1046                 *mac = le64_to_cpu((u64)mac_lo | ((u64)mac_hi << 32));
1047
1048         return 0;
1049 }
1050
1051 /*
1052  * Changes the CRB window to the specified window.
1053  */
1054 static void
1055 netxen_nic_pci_set_crbwindow_128M(struct netxen_adapter *adapter,
1056                 u32 window)
1057 {
1058         void __iomem *offset;
1059         int count = 10;
1060         u8 func = adapter->ahw.pci_func;
1061
1062         if (adapter->ahw.crb_win == window)
1063                 return;
1064
1065         offset = PCI_OFFSET_SECOND_RANGE(adapter,
1066                         NETXEN_PCIX_PH_REG(PCIE_CRB_WINDOW_REG(func)));
1067
1068         writel(window, offset);
1069         do {
1070                 if (window == readl(offset))
1071                         break;
1072
1073                 if (printk_ratelimit())
1074                         dev_warn(&adapter->pdev->dev,
1075                                         "failed to set CRB window to %d\n",
1076                                         (window == NETXEN_WINDOW_ONE));
1077                 udelay(1);
1078
1079         } while (--count > 0);
1080
1081         if (count > 0)
1082                 adapter->ahw.crb_win = window;
1083 }
1084
1085 /*
1086  * Return -1 if off is not valid,
1087  *       1 if window access is needed. 'off' is set to offset from
1088  *         CRB space in 128M pci map
1089  *       0 if no window access is needed. 'off' is set to 2M addr
1090  * In: 'off' is offset from base in 128M pci map
1091  */
1092 static int
1093 netxen_nic_pci_get_crb_addr_2M(struct netxen_adapter *adapter, ulong *off)
1094 {
1095         crb_128M_2M_sub_block_map_t *m;
1096
1097
1098         if (*off >= NETXEN_CRB_MAX)
1099                 return -1;
1100
1101         if (*off >= NETXEN_PCI_CAMQM && (*off < NETXEN_PCI_CAMQM_2M_END)) {
1102                 *off = (*off - NETXEN_PCI_CAMQM) + NETXEN_PCI_CAMQM_2M_BASE +
1103                         (ulong)adapter->ahw.pci_base0;
1104                 return 0;
1105         }
1106
1107         if (*off < NETXEN_PCI_CRBSPACE)
1108                 return -1;
1109
1110         *off -= NETXEN_PCI_CRBSPACE;
1111
1112         /*
1113          * Try direct map
1114          */
1115         m = &crb_128M_2M_map[CRB_BLK(*off)].sub_block[CRB_SUBBLK(*off)];
1116
1117         if (m->valid && (m->start_128M <= *off) && (m->end_128M > *off)) {
1118                 *off = *off + m->start_2M - m->start_128M +
1119                         (ulong)adapter->ahw.pci_base0;
1120                 return 0;
1121         }
1122
1123         /*
1124          * Not in direct map, use crb window
1125          */
1126         return 1;
1127 }
1128
1129 /*
1130  * In: 'off' is offset from CRB space in 128M pci map
1131  * Out: 'off' is 2M pci map addr
1132  * side effect: lock crb window
1133  */
1134 static void
1135 netxen_nic_pci_set_crbwindow_2M(struct netxen_adapter *adapter, ulong *off)
1136 {
1137         u32 window;
1138         void __iomem *addr = adapter->ahw.pci_base0 + CRB_WINDOW_2M;
1139
1140         window = CRB_HI(*off);
1141
1142         if (adapter->ahw.crb_win == window)
1143                 goto done;
1144
1145         writel(window, addr);
1146         if (readl(addr) != window) {
1147                 if (printk_ratelimit())
1148                         dev_warn(&adapter->pdev->dev,
1149                                 "failed to set CRB window to %d off 0x%lx\n",
1150                                 window, *off);
1151         }
1152         adapter->ahw.crb_win = window;
1153
1154 done:
1155         *off = (*off & MASK(16)) + CRB_INDIRECT_2M +
1156                 (ulong)adapter->ahw.pci_base0;
1157 }
1158
1159 static int
1160 netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter, ulong off, u32 data)
1161 {
1162         unsigned long flags;
1163         void __iomem *addr;
1164
1165         if (ADDR_IN_WINDOW1(off))
1166                 addr = NETXEN_CRB_NORMALIZE(adapter, off);
1167         else
1168                 addr = pci_base_offset(adapter, off);
1169
1170         BUG_ON(!addr);
1171
1172         if (ADDR_IN_WINDOW1(off)) {     /* Window 1 */
1173                 netxen_nic_io_write_128M(adapter, addr, data);
1174         } else {                /* Window 0 */
1175                 write_lock_irqsave(&adapter->ahw.crb_lock, flags);
1176                 addr = pci_base_offset(adapter, off);
1177                 netxen_nic_pci_set_crbwindow_128M(adapter, 0);
1178                 writel(data, addr);
1179                 netxen_nic_pci_set_crbwindow_128M(adapter,
1180                                 NETXEN_WINDOW_ONE);
1181                 write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
1182         }
1183
1184         return 0;
1185 }
1186
1187 static u32
1188 netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off)
1189 {
1190         unsigned long flags;
1191         void __iomem *addr;
1192         u32 data;
1193
1194         if (ADDR_IN_WINDOW1(off))
1195                 addr = NETXEN_CRB_NORMALIZE(adapter, off);
1196         else
1197                 addr = pci_base_offset(adapter, off);
1198
1199         BUG_ON(!addr);
1200
1201         if (ADDR_IN_WINDOW1(off)) {     /* Window 1 */
1202                 data = netxen_nic_io_read_128M(adapter, addr);
1203         } else {                /* Window 0 */
1204                 write_lock_irqsave(&adapter->ahw.crb_lock, flags);
1205                 netxen_nic_pci_set_crbwindow_128M(adapter, 0);
1206                 data = readl(addr);
1207                 netxen_nic_pci_set_crbwindow_128M(adapter,
1208                                 NETXEN_WINDOW_ONE);
1209                 write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
1210         }
1211
1212         return data;
1213 }
1214
1215 static int
1216 netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter, ulong off, u32 data)
1217 {
1218         unsigned long flags;
1219         int rv;
1220
1221         rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off);
1222
1223         if (rv == -1) {
1224                 printk(KERN_ERR "%s: invalid offset: 0x%016lx\n",
1225                                 __func__, off);
1226                 dump_stack();
1227                 return -1;
1228         }
1229
1230         if (rv == 1) {
1231                 write_lock_irqsave(&adapter->ahw.crb_lock, flags);
1232                 crb_win_lock(adapter);
1233                 netxen_nic_pci_set_crbwindow_2M(adapter, &off);
1234                 writel(data, (void __iomem *)off);
1235                 crb_win_unlock(adapter);
1236                 write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
1237         } else
1238                 writel(data, (void __iomem *)off);
1239
1240
1241         return 0;
1242 }
1243
1244 static u32
1245 netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off)
1246 {
1247         unsigned long flags;
1248         int rv;
1249         u32 data;
1250
1251         rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off);
1252
1253         if (rv == -1) {
1254                 printk(KERN_ERR "%s: invalid offset: 0x%016lx\n",
1255                                 __func__, off);
1256                 dump_stack();
1257                 return -1;
1258         }
1259
1260         if (rv == 1) {
1261                 write_lock_irqsave(&adapter->ahw.crb_lock, flags);
1262                 crb_win_lock(adapter);
1263                 netxen_nic_pci_set_crbwindow_2M(adapter, &off);
1264                 data = readl((void __iomem *)off);
1265                 crb_win_unlock(adapter);
1266                 write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
1267         } else
1268                 data = readl((void __iomem *)off);
1269
1270         return data;
1271 }
1272
1273 /* window 1 registers only */
1274 static void netxen_nic_io_write_128M(struct netxen_adapter *adapter,
1275                 void __iomem *addr, u32 data)
1276 {
1277         read_lock(&adapter->ahw.crb_lock);
1278         writel(data, addr);
1279         read_unlock(&adapter->ahw.crb_lock);
1280 }
1281
1282 static u32 netxen_nic_io_read_128M(struct netxen_adapter *adapter,
1283                 void __iomem *addr)
1284 {
1285         u32 val;
1286
1287         read_lock(&adapter->ahw.crb_lock);
1288         val = readl(addr);
1289         read_unlock(&adapter->ahw.crb_lock);
1290
1291         return val;
1292 }
1293
1294 static void netxen_nic_io_write_2M(struct netxen_adapter *adapter,
1295                 void __iomem *addr, u32 data)
1296 {
1297         writel(data, addr);
1298 }
1299
1300 static u32 netxen_nic_io_read_2M(struct netxen_adapter *adapter,
1301                 void __iomem *addr)
1302 {
1303         return readl(addr);
1304 }
1305
1306 void __iomem *
1307 netxen_get_ioaddr(struct netxen_adapter *adapter, u32 offset)
1308 {
1309         ulong off = offset;
1310
1311         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1312                 if (offset < NETXEN_CRB_PCIX_HOST2 &&
1313                                 offset > NETXEN_CRB_PCIX_HOST)
1314                         return PCI_OFFSET_SECOND_RANGE(adapter, offset);
1315                 return NETXEN_CRB_NORMALIZE(adapter, offset);
1316         }
1317
1318         BUG_ON(netxen_nic_pci_get_crb_addr_2M(adapter, &off));
1319         return (void __iomem *)off;
1320 }
1321
1322 static int
1323 netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter,
1324                 u64 addr, u32 *start)
1325 {
1326         if (ADDR_IN_RANGE(addr, NETXEN_ADDR_OCM0, NETXEN_ADDR_OCM0_MAX)) {
1327                 *start = (addr - NETXEN_ADDR_OCM0  + NETXEN_PCI_OCM0);
1328                 return 0;
1329         } else if (ADDR_IN_RANGE(addr,
1330                                 NETXEN_ADDR_OCM1, NETXEN_ADDR_OCM1_MAX)) {
1331                 *start = (addr - NETXEN_ADDR_OCM1 + NETXEN_PCI_OCM1);
1332                 return 0;
1333         }
1334
1335         return -EIO;
1336 }
1337
1338 static int
1339 netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
1340                 u64 addr, u32 *start)
1341 {
1342         u32 window;
1343         struct pci_dev *pdev = adapter->pdev;
1344
1345         if ((addr & 0x00ff800) == 0xff800) {
1346                 if (printk_ratelimit())
1347                         dev_warn(&pdev->dev, "QM access not handled\n");
1348                 return -EIO;
1349         }
1350
1351         if (NX_IS_REVISION_P3P(adapter->ahw.revision_id))
1352                 window = OCM_WIN_P3P(addr);
1353         else
1354                 window = OCM_WIN(addr);
1355
1356         writel(window, adapter->ahw.ocm_win_crb);
1357         /* read back to flush */
1358         readl(adapter->ahw.ocm_win_crb);
1359
1360         adapter->ahw.ocm_win = window;
1361         *start = NETXEN_PCI_OCM0_2M + GET_MEM_OFFS_2M(addr);
1362         return 0;
1363 }
1364
1365 static int
1366 netxen_nic_pci_mem_access_direct(struct netxen_adapter *adapter, u64 off,
1367                 u64 *data, int op)
1368 {
1369         void __iomem *addr, *mem_ptr = NULL;
1370         resource_size_t mem_base;
1371         int ret = -EIO;
1372         u32 start;
1373
1374         spin_lock(&adapter->ahw.mem_lock);
1375
1376         ret = adapter->pci_set_window(adapter, off, &start);
1377         if (ret != 0)
1378                 goto unlock;
1379
1380         addr = pci_base_offset(adapter, start);
1381         if (addr)
1382                 goto noremap;
1383
1384         mem_base = pci_resource_start(adapter->pdev, 0) + (start & PAGE_MASK);
1385
1386         mem_ptr = ioremap(mem_base, PAGE_SIZE);
1387         if (mem_ptr == NULL) {
1388                 ret = -EIO;
1389                 goto unlock;
1390         }
1391
1392         addr = mem_ptr + (start & (PAGE_SIZE - 1));
1393
1394 noremap:
1395         if (op == 0)    /* read */
1396                 *data = readq(addr);
1397         else            /* write */
1398                 writeq(*data, addr);
1399
1400 unlock:
1401         spin_unlock(&adapter->ahw.mem_lock);
1402
1403         if (mem_ptr)
1404                 iounmap(mem_ptr);
1405         return ret;
1406 }
1407
1408 #define MAX_CTL_CHECK   1000
1409
1410 static int
1411 netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter,
1412                 u64 off, u64 data)
1413 {
1414         int j, ret;
1415         u32 temp, off_lo, off_hi, addr_hi, data_hi, data_lo;
1416         void __iomem *mem_crb;
1417
1418         /* Only 64-bit aligned access */
1419         if (off & 7)
1420                 return -EIO;
1421
1422         /* P2 has different SIU and MIU test agent base addr */
1423         if (ADDR_IN_RANGE(off, NETXEN_ADDR_QDR_NET,
1424                                 NETXEN_ADDR_QDR_NET_MAX_P2)) {
1425                 mem_crb = pci_base_offset(adapter,
1426                                 NETXEN_CRB_QDR_NET+SIU_TEST_AGT_BASE);
1427                 addr_hi = SIU_TEST_AGT_ADDR_HI;
1428                 data_lo = SIU_TEST_AGT_WRDATA_LO;
1429                 data_hi = SIU_TEST_AGT_WRDATA_HI;
1430                 off_lo = off & SIU_TEST_AGT_ADDR_MASK;
1431                 off_hi = SIU_TEST_AGT_UPPER_ADDR(off);
1432                 goto correct;
1433         }
1434
1435         if (ADDR_IN_RANGE(off, NETXEN_ADDR_DDR_NET, NETXEN_ADDR_DDR_NET_MAX)) {
1436                 mem_crb = pci_base_offset(adapter,
1437                                 NETXEN_CRB_DDR_NET+MIU_TEST_AGT_BASE);
1438                 addr_hi = MIU_TEST_AGT_ADDR_HI;
1439                 data_lo = MIU_TEST_AGT_WRDATA_LO;
1440                 data_hi = MIU_TEST_AGT_WRDATA_HI;
1441                 off_lo = off & MIU_TEST_AGT_ADDR_MASK;
1442                 off_hi = 0;
1443                 goto correct;
1444         }
1445
1446         if (ADDR_IN_RANGE(off, NETXEN_ADDR_OCM0, NETXEN_ADDR_OCM0_MAX) ||
1447                 ADDR_IN_RANGE(off, NETXEN_ADDR_OCM1, NETXEN_ADDR_OCM1_MAX)) {
1448                 if (adapter->ahw.pci_len0 != 0) {
1449                         return netxen_nic_pci_mem_access_direct(adapter,
1450                                         off, &data, 1);
1451                 }
1452         }
1453
1454         return -EIO;
1455
1456 correct:
1457         spin_lock(&adapter->ahw.mem_lock);
1458         netxen_nic_pci_set_crbwindow_128M(adapter, 0);
1459
1460         writel(off_lo, (mem_crb + MIU_TEST_AGT_ADDR_LO));
1461         writel(off_hi, (mem_crb + addr_hi));
1462         writel(data & 0xffffffff, (mem_crb + data_lo));
1463         writel((data >> 32) & 0xffffffff, (mem_crb + data_hi));
1464         writel((TA_CTL_ENABLE | TA_CTL_WRITE), (mem_crb + TEST_AGT_CTRL));
1465         writel((TA_CTL_START | TA_CTL_ENABLE | TA_CTL_WRITE),
1466                         (mem_crb + TEST_AGT_CTRL));
1467
1468         for (j = 0; j < MAX_CTL_CHECK; j++) {
1469                 temp = readl((mem_crb + TEST_AGT_CTRL));
1470                 if ((temp & TA_CTL_BUSY) == 0)
1471                         break;
1472         }
1473
1474         if (j >= MAX_CTL_CHECK) {
1475                 if (printk_ratelimit())
1476                         dev_err(&adapter->pdev->dev,
1477                                         "failed to write through agent\n");
1478                 ret = -EIO;
1479         } else
1480                 ret = 0;
1481
1482         netxen_nic_pci_set_crbwindow_128M(adapter, NETXEN_WINDOW_ONE);
1483         spin_unlock(&adapter->ahw.mem_lock);
1484         return ret;
1485 }
1486
1487 static int
1488 netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter,
1489                 u64 off, u64 *data)
1490 {
1491         int j, ret;
1492         u32 temp, off_lo, off_hi, addr_hi, data_hi, data_lo;
1493         u64 val;
1494         void __iomem *mem_crb;
1495
1496         /* Only 64-bit aligned access */
1497         if (off & 7)
1498                 return -EIO;
1499
1500         /* P2 has different SIU and MIU test agent base addr */
1501         if (ADDR_IN_RANGE(off, NETXEN_ADDR_QDR_NET,
1502                                 NETXEN_ADDR_QDR_NET_MAX_P2)) {
1503                 mem_crb = pci_base_offset(adapter,
1504                                 NETXEN_CRB_QDR_NET+SIU_TEST_AGT_BASE);
1505                 addr_hi = SIU_TEST_AGT_ADDR_HI;
1506                 data_lo = SIU_TEST_AGT_RDDATA_LO;
1507                 data_hi = SIU_TEST_AGT_RDDATA_HI;
1508                 off_lo = off & SIU_TEST_AGT_ADDR_MASK;
1509                 off_hi = SIU_TEST_AGT_UPPER_ADDR(off);
1510                 goto correct;
1511         }
1512
1513         if (ADDR_IN_RANGE(off, NETXEN_ADDR_DDR_NET, NETXEN_ADDR_DDR_NET_MAX)) {
1514                 mem_crb = pci_base_offset(adapter,
1515                                 NETXEN_CRB_DDR_NET+MIU_TEST_AGT_BASE);
1516                 addr_hi = MIU_TEST_AGT_ADDR_HI;
1517                 data_lo = MIU_TEST_AGT_RDDATA_LO;
1518                 data_hi = MIU_TEST_AGT_RDDATA_HI;
1519                 off_lo = off & MIU_TEST_AGT_ADDR_MASK;
1520                 off_hi = 0;
1521                 goto correct;
1522         }
1523
1524         if (ADDR_IN_RANGE(off, NETXEN_ADDR_OCM0, NETXEN_ADDR_OCM0_MAX) ||
1525                 ADDR_IN_RANGE(off, NETXEN_ADDR_OCM1, NETXEN_ADDR_OCM1_MAX)) {
1526                 if (adapter->ahw.pci_len0 != 0) {
1527                         return netxen_nic_pci_mem_access_direct(adapter,
1528                                         off, data, 0);
1529                 }
1530         }
1531
1532         return -EIO;
1533
1534 correct:
1535         spin_lock(&adapter->ahw.mem_lock);
1536         netxen_nic_pci_set_crbwindow_128M(adapter, 0);
1537
1538         writel(off_lo, (mem_crb + MIU_TEST_AGT_ADDR_LO));
1539         writel(off_hi, (mem_crb + addr_hi));
1540         writel(TA_CTL_ENABLE, (mem_crb + TEST_AGT_CTRL));
1541         writel((TA_CTL_START|TA_CTL_ENABLE), (mem_crb + TEST_AGT_CTRL));
1542
1543         for (j = 0; j < MAX_CTL_CHECK; j++) {
1544                 temp = readl(mem_crb + TEST_AGT_CTRL);
1545                 if ((temp & TA_CTL_BUSY) == 0)
1546                         break;
1547         }
1548
1549         if (j >= MAX_CTL_CHECK) {
1550                 if (printk_ratelimit())
1551                         dev_err(&adapter->pdev->dev,
1552                                         "failed to read through agent\n");
1553                 ret = -EIO;
1554         } else {
1555
1556                 temp = readl(mem_crb + data_hi);
1557                 val = ((u64)temp << 32);
1558                 val |= readl(mem_crb + data_lo);
1559                 *data = val;
1560                 ret = 0;
1561         }
1562
1563         netxen_nic_pci_set_crbwindow_128M(adapter, NETXEN_WINDOW_ONE);
1564         spin_unlock(&adapter->ahw.mem_lock);
1565
1566         return ret;
1567 }
1568
1569 static int
1570 netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
1571                 u64 off, u64 data)
1572 {
1573         int i, j, ret;
1574         u32 temp, off8;
1575         u64 stride;
1576         void __iomem *mem_crb;
1577
1578         /* Only 64-bit aligned access */
1579         if (off & 7)
1580                 return -EIO;
1581
1582         /* P3 onward, test agent base for MIU and SIU is same */
1583         if (ADDR_IN_RANGE(off, NETXEN_ADDR_QDR_NET,
1584                                 NETXEN_ADDR_QDR_NET_MAX_P3)) {
1585                 mem_crb = netxen_get_ioaddr(adapter,
1586                                 NETXEN_CRB_QDR_NET+MIU_TEST_AGT_BASE);
1587                 goto correct;
1588         }
1589
1590         if (ADDR_IN_RANGE(off, NETXEN_ADDR_DDR_NET, NETXEN_ADDR_DDR_NET_MAX)) {
1591                 mem_crb = netxen_get_ioaddr(adapter,
1592                                 NETXEN_CRB_DDR_NET+MIU_TEST_AGT_BASE);
1593                 goto correct;
1594         }
1595
1596         if (ADDR_IN_RANGE(off, NETXEN_ADDR_OCM0, NETXEN_ADDR_OCM0_MAX))
1597                 return netxen_nic_pci_mem_access_direct(adapter, off, &data, 1);
1598
1599         return -EIO;
1600
1601 correct:
1602         stride = NX_IS_REVISION_P3P(adapter->ahw.revision_id) ? 16 : 8;
1603
1604         off8 = off & ~(stride-1);
1605
1606         spin_lock(&adapter->ahw.mem_lock);
1607
1608         writel(off8, (mem_crb + MIU_TEST_AGT_ADDR_LO));
1609         writel(0, (mem_crb + MIU_TEST_AGT_ADDR_HI));
1610
1611         i = 0;
1612         if (stride == 16) {
1613                 writel(TA_CTL_ENABLE, (mem_crb + TEST_AGT_CTRL));
1614                 writel((TA_CTL_START | TA_CTL_ENABLE),
1615                                 (mem_crb + TEST_AGT_CTRL));
1616
1617                 for (j = 0; j < MAX_CTL_CHECK; j++) {
1618                         temp = readl(mem_crb + TEST_AGT_CTRL);
1619                         if ((temp & TA_CTL_BUSY) == 0)
1620                                 break;
1621                 }
1622
1623                 if (j >= MAX_CTL_CHECK) {
1624                         ret = -EIO;
1625                         goto done;
1626                 }
1627
1628                 i = (off & 0xf) ? 0 : 2;
1629                 writel(readl(mem_crb + MIU_TEST_AGT_RDDATA(i)),
1630                                 mem_crb + MIU_TEST_AGT_WRDATA(i));
1631                 writel(readl(mem_crb + MIU_TEST_AGT_RDDATA(i+1)),
1632                                 mem_crb + MIU_TEST_AGT_WRDATA(i+1));
1633                 i = (off & 0xf) ? 2 : 0;
1634         }
1635
1636         writel(data & 0xffffffff,
1637                         mem_crb + MIU_TEST_AGT_WRDATA(i));
1638         writel((data >> 32) & 0xffffffff,
1639                         mem_crb + MIU_TEST_AGT_WRDATA(i+1));
1640
1641         writel((TA_CTL_ENABLE | TA_CTL_WRITE), (mem_crb + TEST_AGT_CTRL));
1642         writel((TA_CTL_START | TA_CTL_ENABLE | TA_CTL_WRITE),
1643                         (mem_crb + TEST_AGT_CTRL));
1644
1645         for (j = 0; j < MAX_CTL_CHECK; j++) {
1646                 temp = readl(mem_crb + TEST_AGT_CTRL);
1647                 if ((temp & TA_CTL_BUSY) == 0)
1648                         break;
1649         }
1650
1651         if (j >= MAX_CTL_CHECK) {
1652                 if (printk_ratelimit())
1653                         dev_err(&adapter->pdev->dev,
1654                                         "failed to write through agent\n");
1655                 ret = -EIO;
1656         } else
1657                 ret = 0;
1658
1659 done:
1660         spin_unlock(&adapter->ahw.mem_lock);
1661
1662         return ret;
1663 }
1664
1665 static int
1666 netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
1667                 u64 off, u64 *data)
1668 {
1669         int j, ret;
1670         u32 temp, off8;
1671         u64 val, stride;
1672         void __iomem *mem_crb;
1673
1674         /* Only 64-bit aligned access */
1675         if (off & 7)
1676                 return -EIO;
1677
1678         /* P3 onward, test agent base for MIU and SIU is same */
1679         if (ADDR_IN_RANGE(off, NETXEN_ADDR_QDR_NET,
1680                                 NETXEN_ADDR_QDR_NET_MAX_P3)) {
1681                 mem_crb = netxen_get_ioaddr(adapter,
1682                                 NETXEN_CRB_QDR_NET+MIU_TEST_AGT_BASE);
1683                 goto correct;
1684         }
1685
1686         if (ADDR_IN_RANGE(off, NETXEN_ADDR_DDR_NET, NETXEN_ADDR_DDR_NET_MAX)) {
1687                 mem_crb = netxen_get_ioaddr(adapter,
1688                                 NETXEN_CRB_DDR_NET+MIU_TEST_AGT_BASE);
1689                 goto correct;
1690         }
1691
1692         if (ADDR_IN_RANGE(off, NETXEN_ADDR_OCM0, NETXEN_ADDR_OCM0_MAX)) {
1693                 return netxen_nic_pci_mem_access_direct(adapter,
1694                                 off, data, 0);
1695         }
1696
1697         return -EIO;
1698
1699 correct:
1700         stride = NX_IS_REVISION_P3P(adapter->ahw.revision_id) ? 16 : 8;
1701
1702         off8 = off & ~(stride-1);
1703
1704         spin_lock(&adapter->ahw.mem_lock);
1705
1706         writel(off8, (mem_crb + MIU_TEST_AGT_ADDR_LO));
1707         writel(0, (mem_crb + MIU_TEST_AGT_ADDR_HI));
1708         writel(TA_CTL_ENABLE, (mem_crb + TEST_AGT_CTRL));
1709         writel((TA_CTL_START | TA_CTL_ENABLE), (mem_crb + TEST_AGT_CTRL));
1710
1711         for (j = 0; j < MAX_CTL_CHECK; j++) {
1712                 temp = readl(mem_crb + TEST_AGT_CTRL);
1713                 if ((temp & TA_CTL_BUSY) == 0)
1714                         break;
1715         }
1716
1717         if (j >= MAX_CTL_CHECK) {
1718                 if (printk_ratelimit())
1719                         dev_err(&adapter->pdev->dev,
1720                                         "failed to read through agent\n");
1721                 ret = -EIO;
1722         } else {
1723                 off8 = MIU_TEST_AGT_RDDATA_LO;
1724                 if ((stride == 16) && (off & 0xf))
1725                         off8 = MIU_TEST_AGT_RDDATA_UPPER_LO;
1726
1727                 temp = readl(mem_crb + off8 + 4);
1728                 val = (u64)temp << 32;
1729                 val |= readl(mem_crb + off8);
1730                 *data = val;
1731                 ret = 0;
1732         }
1733
1734         spin_unlock(&adapter->ahw.mem_lock);
1735
1736         return ret;
1737 }
1738
1739 void
1740 netxen_setup_hwops(struct netxen_adapter *adapter)
1741 {
1742         adapter->init_port = netxen_niu_xg_init_port;
1743         adapter->stop_port = netxen_niu_disable_xg_port;
1744
1745         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1746                 adapter->crb_read = netxen_nic_hw_read_wx_128M,
1747                 adapter->crb_write = netxen_nic_hw_write_wx_128M,
1748                 adapter->pci_set_window = netxen_nic_pci_set_window_128M,
1749                 adapter->pci_mem_read = netxen_nic_pci_mem_read_128M,
1750                 adapter->pci_mem_write = netxen_nic_pci_mem_write_128M,
1751                 adapter->io_read = netxen_nic_io_read_128M,
1752                 adapter->io_write = netxen_nic_io_write_128M,
1753
1754                 adapter->macaddr_set = netxen_p2_nic_set_mac_addr;
1755                 adapter->set_multi = netxen_p2_nic_set_multi;
1756                 adapter->set_mtu = netxen_nic_set_mtu_xgb;
1757                 adapter->set_promisc = netxen_p2_nic_set_promisc;
1758
1759         } else {
1760                 adapter->crb_read = netxen_nic_hw_read_wx_2M,
1761                 adapter->crb_write = netxen_nic_hw_write_wx_2M,
1762                 adapter->pci_set_window = netxen_nic_pci_set_window_2M,
1763                 adapter->pci_mem_read = netxen_nic_pci_mem_read_2M,
1764                 adapter->pci_mem_write = netxen_nic_pci_mem_write_2M,
1765                 adapter->io_read = netxen_nic_io_read_2M,
1766                 adapter->io_write = netxen_nic_io_write_2M,
1767
1768                 adapter->set_mtu = nx_fw_cmd_set_mtu;
1769                 adapter->set_promisc = netxen_p3_nic_set_promisc;
1770                 adapter->macaddr_set = netxen_p3_nic_set_mac_addr;
1771                 adapter->set_multi = netxen_p3_nic_set_multi;
1772
1773                 adapter->phy_read = nx_fw_cmd_query_phy;
1774                 adapter->phy_write = nx_fw_cmd_set_phy;
1775         }
1776 }
1777
1778 int netxen_nic_get_board_info(struct netxen_adapter *adapter)
1779 {
1780         int offset, board_type, magic, header_version;
1781         struct pci_dev *pdev = adapter->pdev;
1782
1783         offset = NX_FW_MAGIC_OFFSET;
1784         if (netxen_rom_fast_read(adapter, offset, &magic))
1785                 return -EIO;
1786
1787         offset = NX_HDR_VERSION_OFFSET;
1788         if (netxen_rom_fast_read(adapter, offset, &header_version))
1789                 return -EIO;
1790
1791         if (magic != NETXEN_BDINFO_MAGIC ||
1792                         header_version != NETXEN_BDINFO_VERSION) {
1793                 dev_err(&pdev->dev,
1794                         "invalid board config, magic=%08x, version=%08x\n",
1795                         magic, header_version);
1796                 return -EIO;
1797         }
1798
1799         offset = NX_BRDTYPE_OFFSET;
1800         if (netxen_rom_fast_read(adapter, offset, &board_type))
1801                 return -EIO;
1802
1803         adapter->ahw.board_type = board_type;
1804
1805         if (board_type == NETXEN_BRDTYPE_P3_4_GB_MM) {
1806                 u32 gpio = NXRD32(adapter, NETXEN_ROMUSB_GLB_PAD_GPIO_I);
1807                 if ((gpio & 0x8000) == 0)
1808                         board_type = NETXEN_BRDTYPE_P3_10G_TP;
1809         }
1810
1811         switch (board_type) {
1812         case NETXEN_BRDTYPE_P2_SB35_4G:
1813                 adapter->ahw.port_type = NETXEN_NIC_GBE;
1814                 break;
1815         case NETXEN_BRDTYPE_P2_SB31_10G:
1816         case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
1817         case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
1818         case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
1819         case NETXEN_BRDTYPE_P3_HMEZ:
1820         case NETXEN_BRDTYPE_P3_XG_LOM:
1821         case NETXEN_BRDTYPE_P3_10G_CX4:
1822         case NETXEN_BRDTYPE_P3_10G_CX4_LP:
1823         case NETXEN_BRDTYPE_P3_IMEZ:
1824         case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
1825         case NETXEN_BRDTYPE_P3_10G_SFP_CT:
1826         case NETXEN_BRDTYPE_P3_10G_SFP_QT:
1827         case NETXEN_BRDTYPE_P3_10G_XFP:
1828         case NETXEN_BRDTYPE_P3_10000_BASE_T:
1829                 adapter->ahw.port_type = NETXEN_NIC_XGBE;
1830                 break;
1831         case NETXEN_BRDTYPE_P1_BD:
1832         case NETXEN_BRDTYPE_P1_SB:
1833         case NETXEN_BRDTYPE_P1_SMAX:
1834         case NETXEN_BRDTYPE_P1_SOCK:
1835         case NETXEN_BRDTYPE_P3_REF_QG:
1836         case NETXEN_BRDTYPE_P3_4_GB:
1837         case NETXEN_BRDTYPE_P3_4_GB_MM:
1838                 adapter->ahw.port_type = NETXEN_NIC_GBE;
1839                 break;
1840         case NETXEN_BRDTYPE_P3_10G_TP:
1841                 adapter->ahw.port_type = (adapter->portnum < 2) ?
1842                         NETXEN_NIC_XGBE : NETXEN_NIC_GBE;
1843                 break;
1844         default:
1845                 dev_err(&pdev->dev, "unknown board type %x\n", board_type);
1846                 adapter->ahw.port_type = NETXEN_NIC_XGBE;
1847                 break;
1848         }
1849
1850         return 0;
1851 }
1852
1853 /* NIU access sections */
1854
1855 int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu)
1856 {
1857         new_mtu += MTU_FUDGE_FACTOR;
1858         NXWR32(adapter, NETXEN_NIU_GB_MAX_FRAME_SIZE(adapter->physical_port),
1859                 new_mtu);
1860         return 0;
1861 }
1862
1863 int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu)
1864 {
1865         new_mtu += MTU_FUDGE_FACTOR;
1866         if (adapter->physical_port == 0)
1867                 NXWR32(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, new_mtu);
1868         else
1869                 NXWR32(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE, new_mtu);
1870         return 0;
1871 }
1872
1873 void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
1874 {
1875         __u32 status;
1876         __u32 autoneg;
1877         __u32 port_mode;
1878
1879         if (!netif_carrier_ok(adapter->netdev)) {
1880                 adapter->link_speed   = 0;
1881                 adapter->link_duplex  = -1;
1882                 adapter->link_autoneg = AUTONEG_ENABLE;
1883                 return;
1884         }
1885
1886         if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
1887                 port_mode = NXRD32(adapter, NETXEN_PORT_MODE_ADDR);
1888                 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
1889                         adapter->link_speed   = SPEED_1000;
1890                         adapter->link_duplex  = DUPLEX_FULL;
1891                         adapter->link_autoneg = AUTONEG_DISABLE;
1892                         return;
1893                 }
1894
1895                 if (adapter->phy_read
1896                     && adapter->phy_read(adapter,
1897                              NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
1898                              &status) == 0) {
1899                         if (netxen_get_phy_link(status)) {
1900                                 switch (netxen_get_phy_speed(status)) {
1901                                 case 0:
1902                                         adapter->link_speed = SPEED_10;
1903                                         break;
1904                                 case 1:
1905                                         adapter->link_speed = SPEED_100;
1906                                         break;
1907                                 case 2:
1908                                         adapter->link_speed = SPEED_1000;
1909                                         break;
1910                                 default:
1911                                         adapter->link_speed = 0;
1912                                         break;
1913                                 }
1914                                 switch (netxen_get_phy_duplex(status)) {
1915                                 case 0:
1916                                         adapter->link_duplex = DUPLEX_HALF;
1917                                         break;
1918                                 case 1:
1919                                         adapter->link_duplex = DUPLEX_FULL;
1920                                         break;
1921                                 default:
1922                                         adapter->link_duplex = -1;
1923                                         break;
1924                                 }
1925                                 if (adapter->phy_read
1926                                     && adapter->phy_read(adapter,
1927                                              NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
1928                                              &autoneg) != 0)
1929                                         adapter->link_autoneg = autoneg;
1930                         } else
1931                                 goto link_down;
1932                 } else {
1933                       link_down:
1934                         adapter->link_speed = 0;
1935                         adapter->link_duplex = -1;
1936                 }
1937         }
1938 }
1939
1940 int
1941 netxen_nic_wol_supported(struct netxen_adapter *adapter)
1942 {
1943         u32 wol_cfg;
1944
1945         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1946                 return 0;
1947
1948         wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG_NV);
1949         if (wol_cfg & (1UL << adapter->portnum)) {
1950                 wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG);
1951                 if (wol_cfg & (1 << adapter->portnum))
1952                         return 1;
1953         }
1954
1955         return 0;
1956 }