cxgb3 - detect NIC only adapters
[linux-3.10.git] / drivers / net / cxgb3 / mc5.c
1 /*
2  * Copyright (c) 2003-2007 Chelsio, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32 #include "common.h"
33 #include "regs.h"
34
35 enum {
36         IDT75P52100 = 4,
37         IDT75N43102 = 5
38 };
39
40 /* DBGI command mode */
41 enum {
42         DBGI_MODE_MBUS = 0,
43         DBGI_MODE_IDT52100 = 5
44 };
45
46 /* IDT 75P52100 commands */
47 #define IDT_CMD_READ   0
48 #define IDT_CMD_WRITE  1
49 #define IDT_CMD_SEARCH 2
50 #define IDT_CMD_LEARN  3
51
52 /* IDT LAR register address and value for 144-bit mode (low 32 bits) */
53 #define IDT_LAR_ADR0    0x180006
54 #define IDT_LAR_MODE144 0xffff0000
55
56 /* IDT SCR and SSR addresses (low 32 bits) */
57 #define IDT_SCR_ADR0  0x180000
58 #define IDT_SSR0_ADR0 0x180002
59 #define IDT_SSR1_ADR0 0x180004
60
61 /* IDT GMR base address (low 32 bits) */
62 #define IDT_GMR_BASE_ADR0 0x180020
63
64 /* IDT data and mask array base addresses (low 32 bits) */
65 #define IDT_DATARY_BASE_ADR0 0
66 #define IDT_MSKARY_BASE_ADR0 0x80000
67
68 /* IDT 75N43102 commands */
69 #define IDT4_CMD_SEARCH144 3
70 #define IDT4_CMD_WRITE     4
71 #define IDT4_CMD_READ      5
72
73 /* IDT 75N43102 SCR address (low 32 bits) */
74 #define IDT4_SCR_ADR0  0x3
75
76 /* IDT 75N43102 GMR base addresses (low 32 bits) */
77 #define IDT4_GMR_BASE0 0x10
78 #define IDT4_GMR_BASE1 0x20
79 #define IDT4_GMR_BASE2 0x30
80
81 /* IDT 75N43102 data and mask array base addresses (low 32 bits) */
82 #define IDT4_DATARY_BASE_ADR0 0x1000000
83 #define IDT4_MSKARY_BASE_ADR0 0x2000000
84
85 #define MAX_WRITE_ATTEMPTS 5
86
87 #define MAX_ROUTES 2048
88
89 /*
90  * Issue a command to the TCAM and wait for its completion.  The address and
91  * any data required by the command must have been setup by the caller.
92  */
93 static int mc5_cmd_write(struct adapter *adapter, u32 cmd)
94 {
95         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_CMD, cmd);
96         return t3_wait_op_done(adapter, A_MC5_DB_DBGI_RSP_STATUS,
97                                F_DBGIRSPVALID, 1, MAX_WRITE_ATTEMPTS, 1);
98 }
99
100 static inline void dbgi_wr_addr3(struct adapter *adapter, u32 v1, u32 v2,
101                                  u32 v3)
102 {
103         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR0, v1);
104         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR1, v2);
105         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR2, v3);
106 }
107
108 static inline void dbgi_wr_data3(struct adapter *adapter, u32 v1, u32 v2,
109                                  u32 v3)
110 {
111         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA0, v1);
112         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA1, v2);
113         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA2, v3);
114 }
115
116 static inline void dbgi_rd_rsp3(struct adapter *adapter, u32 *v1, u32 *v2,
117                                 u32 *v3)
118 {
119         *v1 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA0);
120         *v2 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA1);
121         *v3 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA2);
122 }
123
124 /*
125  * Write data to the TCAM register at address (0, 0, addr_lo) using the TCAM
126  * command cmd.  The data to be written must have been set up by the caller.
127  * Returns -1 on failure, 0 on success.
128  */
129 static int mc5_write(struct adapter *adapter, u32 addr_lo, u32 cmd)
130 {
131         t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR0, addr_lo);
132         if (mc5_cmd_write(adapter, cmd) == 0)
133                 return 0;
134         CH_ERR(adapter, "MC5 timeout writing to TCAM address 0x%x\n",
135                addr_lo);
136         return -1;
137 }
138
139 static int init_mask_data_array(struct mc5 *mc5, u32 mask_array_base,
140                                 u32 data_array_base, u32 write_cmd,
141                                 int addr_shift)
142 {
143         unsigned int i;
144         struct adapter *adap = mc5->adapter;
145
146         /*
147          * We need the size of the TCAM data and mask arrays in terms of
148          * 72-bit entries.
149          */
150         unsigned int size72 = mc5->tcam_size;
151         unsigned int server_base = t3_read_reg(adap, A_MC5_DB_SERVER_INDEX);
152
153         if (mc5->mode == MC5_MODE_144_BIT) {
154                 size72 *= 2;    /* 1 144-bit entry is 2 72-bit entries */
155                 server_base *= 2;
156         }
157
158         /* Clear the data array */
159         dbgi_wr_data3(adap, 0, 0, 0);
160         for (i = 0; i < size72; i++)
161                 if (mc5_write(adap, data_array_base + (i << addr_shift),
162                               write_cmd))
163                         return -1;
164
165         /* Initialize the mask array. */
166         dbgi_wr_data3(adap, 0xffffffff, 0xffffffff, 0xff);
167         for (i = 0; i < size72; i++) {
168                 if (i == server_base)   /* entering server or routing region */
169                         t3_write_reg(adap, A_MC5_DB_DBGI_REQ_DATA0,
170                                      mc5->mode == MC5_MODE_144_BIT ?
171                                      0xfffffff9 : 0xfffffffd);
172                 if (mc5_write(adap, mask_array_base + (i << addr_shift),
173                               write_cmd))
174                         return -1;
175         }
176         return 0;
177 }
178
179 static int init_idt52100(struct mc5 *mc5)
180 {
181         int i;
182         struct adapter *adap = mc5->adapter;
183
184         t3_write_reg(adap, A_MC5_DB_RSP_LATENCY,
185                      V_RDLAT(0x15) | V_LRNLAT(0x15) | V_SRCHLAT(0x15));
186         t3_write_reg(adap, A_MC5_DB_PART_ID_INDEX, 2);
187
188         /*
189          * Use GMRs 14-15 for ELOOKUP, GMRs 12-13 for SYN lookups, and
190          * GMRs 8-9 for ACK- and AOPEN searches.
191          */
192         t3_write_reg(adap, A_MC5_DB_POPEN_DATA_WR_CMD, IDT_CMD_WRITE);
193         t3_write_reg(adap, A_MC5_DB_POPEN_MASK_WR_CMD, IDT_CMD_WRITE);
194         t3_write_reg(adap, A_MC5_DB_AOPEN_SRCH_CMD, IDT_CMD_SEARCH);
195         t3_write_reg(adap, A_MC5_DB_AOPEN_LRN_CMD, IDT_CMD_LEARN);
196         t3_write_reg(adap, A_MC5_DB_SYN_SRCH_CMD, IDT_CMD_SEARCH | 0x6000);
197         t3_write_reg(adap, A_MC5_DB_SYN_LRN_CMD, IDT_CMD_LEARN);
198         t3_write_reg(adap, A_MC5_DB_ACK_SRCH_CMD, IDT_CMD_SEARCH);
199         t3_write_reg(adap, A_MC5_DB_ACK_LRN_CMD, IDT_CMD_LEARN);
200         t3_write_reg(adap, A_MC5_DB_ILOOKUP_CMD, IDT_CMD_SEARCH);
201         t3_write_reg(adap, A_MC5_DB_ELOOKUP_CMD, IDT_CMD_SEARCH | 0x7000);
202         t3_write_reg(adap, A_MC5_DB_DATA_WRITE_CMD, IDT_CMD_WRITE);
203         t3_write_reg(adap, A_MC5_DB_DATA_READ_CMD, IDT_CMD_READ);
204
205         /* Set DBGI command mode for IDT TCAM. */
206         t3_write_reg(adap, A_MC5_DB_DBGI_CONFIG, DBGI_MODE_IDT52100);
207
208         /* Set up LAR */
209         dbgi_wr_data3(adap, IDT_LAR_MODE144, 0, 0);
210         if (mc5_write(adap, IDT_LAR_ADR0, IDT_CMD_WRITE))
211                 goto err;
212
213         /* Set up SSRs */
214         dbgi_wr_data3(adap, 0xffffffff, 0xffffffff, 0);
215         if (mc5_write(adap, IDT_SSR0_ADR0, IDT_CMD_WRITE) ||
216             mc5_write(adap, IDT_SSR1_ADR0, IDT_CMD_WRITE))
217                 goto err;
218
219         /* Set up GMRs */
220         for (i = 0; i < 32; ++i) {
221                 if (i >= 12 && i < 15)
222                         dbgi_wr_data3(adap, 0xfffffff9, 0xffffffff, 0xff);
223                 else if (i == 15)
224                         dbgi_wr_data3(adap, 0xfffffff9, 0xffff8007, 0xff);
225                 else
226                         dbgi_wr_data3(adap, 0xffffffff, 0xffffffff, 0xff);
227
228                 if (mc5_write(adap, IDT_GMR_BASE_ADR0 + i, IDT_CMD_WRITE))
229                         goto err;
230         }
231
232         /* Set up SCR */
233         dbgi_wr_data3(adap, 1, 0, 0);
234         if (mc5_write(adap, IDT_SCR_ADR0, IDT_CMD_WRITE))
235                 goto err;
236
237         return init_mask_data_array(mc5, IDT_MSKARY_BASE_ADR0,
238                                     IDT_DATARY_BASE_ADR0, IDT_CMD_WRITE, 0);
239 err:
240         return -EIO;
241 }
242
243 static int init_idt43102(struct mc5 *mc5)
244 {
245         int i;
246         struct adapter *adap = mc5->adapter;
247
248         t3_write_reg(adap, A_MC5_DB_RSP_LATENCY,
249                      adap->params.rev == 0 ? V_RDLAT(0xd) | V_SRCHLAT(0x11) :
250                      V_RDLAT(0xd) | V_SRCHLAT(0x12));
251
252         /*
253          * Use GMRs 24-25 for ELOOKUP, GMRs 20-21 for SYN lookups, and no mask
254          * for ACK- and AOPEN searches.
255          */
256         t3_write_reg(adap, A_MC5_DB_POPEN_DATA_WR_CMD, IDT4_CMD_WRITE);
257         t3_write_reg(adap, A_MC5_DB_POPEN_MASK_WR_CMD, IDT4_CMD_WRITE);
258         t3_write_reg(adap, A_MC5_DB_AOPEN_SRCH_CMD,
259                      IDT4_CMD_SEARCH144 | 0x3800);
260         t3_write_reg(adap, A_MC5_DB_SYN_SRCH_CMD, IDT4_CMD_SEARCH144);
261         t3_write_reg(adap, A_MC5_DB_ACK_SRCH_CMD, IDT4_CMD_SEARCH144 | 0x3800);
262         t3_write_reg(adap, A_MC5_DB_ILOOKUP_CMD, IDT4_CMD_SEARCH144 | 0x3800);
263         t3_write_reg(adap, A_MC5_DB_ELOOKUP_CMD, IDT4_CMD_SEARCH144 | 0x800);
264         t3_write_reg(adap, A_MC5_DB_DATA_WRITE_CMD, IDT4_CMD_WRITE);
265         t3_write_reg(adap, A_MC5_DB_DATA_READ_CMD, IDT4_CMD_READ);
266
267         t3_write_reg(adap, A_MC5_DB_PART_ID_INDEX, 3);
268
269         /* Set DBGI command mode for IDT TCAM. */
270         t3_write_reg(adap, A_MC5_DB_DBGI_CONFIG, DBGI_MODE_IDT52100);
271
272         /* Set up GMRs */
273         dbgi_wr_data3(adap, 0xffffffff, 0xffffffff, 0xff);
274         for (i = 0; i < 7; ++i)
275                 if (mc5_write(adap, IDT4_GMR_BASE0 + i, IDT4_CMD_WRITE))
276                         goto err;
277
278         for (i = 0; i < 4; ++i)
279                 if (mc5_write(adap, IDT4_GMR_BASE2 + i, IDT4_CMD_WRITE))
280                         goto err;
281
282         dbgi_wr_data3(adap, 0xfffffff9, 0xffffffff, 0xff);
283         if (mc5_write(adap, IDT4_GMR_BASE1, IDT4_CMD_WRITE) ||
284             mc5_write(adap, IDT4_GMR_BASE1 + 1, IDT4_CMD_WRITE) ||
285             mc5_write(adap, IDT4_GMR_BASE1 + 4, IDT4_CMD_WRITE))
286                 goto err;
287
288         dbgi_wr_data3(adap, 0xfffffff9, 0xffff8007, 0xff);
289         if (mc5_write(adap, IDT4_GMR_BASE1 + 5, IDT4_CMD_WRITE))
290                 goto err;
291
292         /* Set up SCR */
293         dbgi_wr_data3(adap, 0xf0000000, 0, 0);
294         if (mc5_write(adap, IDT4_SCR_ADR0, IDT4_CMD_WRITE))
295                 goto err;
296
297         return init_mask_data_array(mc5, IDT4_MSKARY_BASE_ADR0,
298                                     IDT4_DATARY_BASE_ADR0, IDT4_CMD_WRITE, 1);
299 err:
300         return -EIO;
301 }
302
303 /* Put MC5 in DBGI mode. */
304 static inline void mc5_dbgi_mode_enable(const struct mc5 *mc5)
305 {
306         t3_write_reg(mc5->adapter, A_MC5_DB_CONFIG,
307                      V_TMMODE(mc5->mode == MC5_MODE_72_BIT) | F_DBGIEN);
308 }
309
310 /* Put MC5 in M-Bus mode. */
311 static void mc5_dbgi_mode_disable(const struct mc5 *mc5)
312 {
313         t3_write_reg(mc5->adapter, A_MC5_DB_CONFIG,
314                      V_TMMODE(mc5->mode == MC5_MODE_72_BIT) |
315                      V_COMPEN(mc5->mode == MC5_MODE_72_BIT) |
316                      V_PRTYEN(mc5->parity_enabled) | F_MBUSEN);
317 }
318
319 /*
320  * Initialization that requires the OS and protocol layers to already
321  * be intialized goes here.
322  */
323 int t3_mc5_init(struct mc5 *mc5, unsigned int nservers, unsigned int nfilters,
324                 unsigned int nroutes)
325 {
326         u32 cfg;
327         int err;
328         unsigned int tcam_size = mc5->tcam_size;
329         struct adapter *adap = mc5->adapter;
330
331         if (!tcam_size)
332                 return 0;
333
334         if (nroutes > MAX_ROUTES || nroutes + nservers + nfilters > tcam_size)
335                 return -EINVAL;
336
337         /* Reset the TCAM */
338         cfg = t3_read_reg(adap, A_MC5_DB_CONFIG) & ~F_TMMODE;
339         cfg |= V_TMMODE(mc5->mode == MC5_MODE_72_BIT) | F_TMRST;
340         t3_write_reg(adap, A_MC5_DB_CONFIG, cfg);
341         if (t3_wait_op_done(adap, A_MC5_DB_CONFIG, F_TMRDY, 1, 500, 0)) {
342                 CH_ERR(adap, "TCAM reset timed out\n");
343                 return -1;
344         }
345
346         t3_write_reg(adap, A_MC5_DB_ROUTING_TABLE_INDEX, tcam_size - nroutes);
347         t3_write_reg(adap, A_MC5_DB_FILTER_TABLE,
348                      tcam_size - nroutes - nfilters);
349         t3_write_reg(adap, A_MC5_DB_SERVER_INDEX,
350                      tcam_size - nroutes - nfilters - nservers);
351
352         mc5->parity_enabled = 1;
353
354         /* All the TCAM addresses we access have only the low 32 bits non 0 */
355         t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR1, 0);
356         t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR2, 0);
357
358         mc5_dbgi_mode_enable(mc5);
359
360         switch (mc5->part_type) {
361         case IDT75P52100:
362                 err = init_idt52100(mc5);
363                 break;
364         case IDT75N43102:
365                 err = init_idt43102(mc5);
366                 break;
367         default:
368                 CH_ERR(adap, "Unsupported TCAM type %d\n", mc5->part_type);
369                 err = -EINVAL;
370                 break;
371         }
372
373         mc5_dbgi_mode_disable(mc5);
374         return err;
375 }
376
377 /*
378  *      read_mc5_range - dump a part of the memory managed by MC5
379  *      @mc5: the MC5 handle
380  *      @start: the start address for the dump
381  *      @n: number of 72-bit words to read
382  *      @buf: result buffer
383  *
384  *      Read n 72-bit words from MC5 memory from the given start location.
385  */
386 int t3_read_mc5_range(const struct mc5 *mc5, unsigned int start,
387                       unsigned int n, u32 *buf)
388 {
389         u32 read_cmd;
390         int err = 0;
391         struct adapter *adap = mc5->adapter;
392
393         if (mc5->part_type == IDT75P52100)
394                 read_cmd = IDT_CMD_READ;
395         else if (mc5->part_type == IDT75N43102)
396                 read_cmd = IDT4_CMD_READ;
397         else
398                 return -EINVAL;
399
400         mc5_dbgi_mode_enable(mc5);
401
402         while (n--) {
403                 t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR0, start++);
404                 if (mc5_cmd_write(adap, read_cmd)) {
405                         err = -EIO;
406                         break;
407                 }
408                 dbgi_rd_rsp3(adap, buf + 2, buf + 1, buf);
409                 buf += 3;
410         }
411
412         mc5_dbgi_mode_disable(mc5);
413         return 0;
414 }
415
416 #define MC5_INT_FATAL (F_PARITYERR | F_REQQPARERR | F_DISPQPARERR)
417
418 /*
419  * MC5 interrupt handler
420  */
421 void t3_mc5_intr_handler(struct mc5 *mc5)
422 {
423         struct adapter *adap = mc5->adapter;
424         u32 cause = t3_read_reg(adap, A_MC5_DB_INT_CAUSE);
425
426         if ((cause & F_PARITYERR) && mc5->parity_enabled) {
427                 CH_ALERT(adap, "MC5 parity error\n");
428                 mc5->stats.parity_err++;
429         }
430
431         if (cause & F_REQQPARERR) {
432                 CH_ALERT(adap, "MC5 request queue parity error\n");
433                 mc5->stats.reqq_parity_err++;
434         }
435
436         if (cause & F_DISPQPARERR) {
437                 CH_ALERT(adap, "MC5 dispatch queue parity error\n");
438                 mc5->stats.dispq_parity_err++;
439         }
440
441         if (cause & F_ACTRGNFULL)
442                 mc5->stats.active_rgn_full++;
443         if (cause & F_NFASRCHFAIL)
444                 mc5->stats.nfa_srch_err++;
445         if (cause & F_UNKNOWNCMD)
446                 mc5->stats.unknown_cmd++;
447         if (cause & F_DELACTEMPTY)
448                 mc5->stats.del_act_empty++;
449         if (cause & MC5_INT_FATAL)
450                 t3_fatal_err(adap);
451
452         t3_write_reg(adap, A_MC5_DB_INT_CAUSE, cause);
453 }
454
455 void __devinit t3_mc5_prep(struct adapter *adapter, struct mc5 *mc5, int mode)
456 {
457 #define K * 1024
458
459         static unsigned int tcam_part_size[] = {        /* in K 72-bit entries */
460                 64 K, 128 K, 256 K, 32 K
461         };
462
463 #undef K
464
465         u32 cfg = t3_read_reg(adapter, A_MC5_DB_CONFIG);
466
467         mc5->adapter = adapter;
468         mc5->mode = (unsigned char)mode;
469         mc5->part_type = (unsigned char)G_TMTYPE(cfg);
470         if (cfg & F_TMTYPEHI)
471                 mc5->part_type |= 4;
472
473         mc5->tcam_size = tcam_part_size[G_TMPARTSIZE(cfg)];
474         if (mode == MC5_MODE_144_BIT)
475                 mc5->tcam_size /= 2;
476 }