1 /**************************************************************************
2
3 Copyright (c) 2007, Chelsio Inc.
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Neither the name of the Chelsio Corporation nor the names of its
13 contributors may be used to endorse or promote products derived from
14 this software without specific prior written permission.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 POSSIBILITY OF SUCH DAMAGE.
27
28 ***************************************************************************/
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD: releng/11.1/sys/dev/cxgb/common/cxgb_mc5.c 259896 2013-12-25 22:45:33Z dim $");
32
33 #include <common/cxgb_common.h>
34 #include <common/cxgb_regs.h>
35
36 enum {
37 IDT75P52100 = 4,
38 IDT75N43102 = 5
39 };
40
41 /* DBGI command mode */
42 enum {
43 DBGI_MODE_MBUS = 0,
44 DBGI_MODE_IDT52100 = 5
45 };
46
47 /* IDT 75P52100 commands */
48 #define IDT_CMD_READ 0
49 #define IDT_CMD_WRITE 1
50 #define IDT_CMD_SEARCH 2
51 #define IDT_CMD_LEARN 3
52
53 /* IDT LAR register address and value for 144-bit mode (low 32 bits) */
54 #define IDT_LAR_ADR0 0x180006
55 #define IDT_LAR_MODE144 0xffff0000
56
57 /* IDT SCR and SSR addresses (low 32 bits) */
58 #define IDT_SCR_ADR0 0x180000
59 #define IDT_SSR0_ADR0 0x180002
60 #define IDT_SSR1_ADR0 0x180004
61
62 /* IDT GMR base address (low 32 bits) */
63 #define IDT_GMR_BASE_ADR0 0x180020
64
65 /* IDT data and mask array base addresses (low 32 bits) */
66 #define IDT_DATARY_BASE_ADR0 0
67 #define IDT_MSKARY_BASE_ADR0 0x80000
68
69 /* IDT 75N43102 commands */
70 #define IDT4_CMD_SEARCH144 3
71 #define IDT4_CMD_WRITE 4
72 #define IDT4_CMD_READ 5
73
74 /* IDT 75N43102 SCR address (low 32 bits) */
75 #define IDT4_SCR_ADR0 0x3
76
77 /* IDT 75N43102 GMR base addresses (low 32 bits) */
78 #define IDT4_GMR_BASE0 0x10
79 #define IDT4_GMR_BASE1 0x20
80 #define IDT4_GMR_BASE2 0x30
81
82 /* IDT 75N43102 data and mask array base addresses (low 32 bits) */
83 #define IDT4_DATARY_BASE_ADR0 0x1000000
84 #define IDT4_MSKARY_BASE_ADR0 0x2000000
85
86 #define MAX_WRITE_ATTEMPTS 5
87
88 #define MAX_ROUTES 2048
89
90 /*
91 * Issue a command to the TCAM and wait for its completion. The address and
92 * any data required by the command must have been setup by the caller.
93 */
94 static int mc5_cmd_write(adapter_t *adapter, u32 cmd)
95 {
96 t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_CMD, cmd);
97 return t3_wait_op_done(adapter, A_MC5_DB_DBGI_RSP_STATUS,
98 F_DBGIRSPVALID, 1, MAX_WRITE_ATTEMPTS, 1);
99 }
100
101 static inline void dbgi_wr_data3(adapter_t *adapter, u32 v1, u32 v2, u32 v3)
102 {
103 t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA0, v1);
104 t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA1, v2);
105 t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_DATA2, v3);
106 }
107
108 static inline void dbgi_rd_rsp3(adapter_t *adapter, u32 *v1, u32 *v2, u32 *v3)
109 {
110 *v1 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA0);
111 *v2 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA1);
112 *v3 = t3_read_reg(adapter, A_MC5_DB_DBGI_RSP_DATA2);
113 }
114
115 /*
116 * Write data to the TCAM register at address (0, 0, addr_lo) using the TCAM
117 * command cmd. The data to be written must have been set up by the caller.
118 * Returns -1 on failure, 0 on success.
119 */
120 static int mc5_write(adapter_t *adapter, u32 addr_lo, u32 cmd)
121 {
122 t3_write_reg(adapter, A_MC5_DB_DBGI_REQ_ADDR0, addr_lo);
123 if (mc5_cmd_write(adapter, cmd) == 0)
124 return 0;
125 CH_ERR(adapter, "MC5 timeout writing to TCAM address 0x%x\n", addr_lo);
126 return -1;
127 }
128
129 static int init_mask_data_array(struct mc5 *mc5, u32 mask_array_base,
130 u32 data_array_base, u32 write_cmd,
131 int addr_shift)
132 {
133 unsigned int i;
134 adapter_t *adap = mc5->adapter;
135
136 /*
137 * We need the size of the TCAM data and mask arrays in terms of
138 * 72-bit entries.
139 */
140 unsigned int size72 = mc5->tcam_size;
141 unsigned int server_base = t3_read_reg(adap, A_MC5_DB_SERVER_INDEX);
142
143 if (mc5->mode == MC5_MODE_144_BIT) {
144 size72 *= 2; /* 1 144-bit entry is 2 72-bit entries */
145 server_base *= 2;
146 }
147
148 /* Clear the data array */
149 dbgi_wr_data3(adap, 0, 0, 0);
150 for (i = 0; i < size72; i++)
151 if (mc5_write(adap, data_array_base + (i << addr_shift),
152 write_cmd))
153 return -1;
154
155 /* Initialize the mask array. */
156 for (i = 0; i < server_base; i++) {
157 dbgi_wr_data3(adap, 0x3fffffff, 0xfff80000, 0xff);
158 if (mc5_write(adap, mask_array_base + (i << addr_shift),
159 write_cmd))
160 return -1;
161 i++;
162 dbgi_wr_data3(adap, 0xffffffff, 0xffffffff, 0xff);
163 if (mc5_write(adap, mask_array_base + (i << addr_shift),
164 write_cmd))
165 return -1;
166 }
167
168 dbgi_wr_data3(adap,
169 mc5->mode == MC5_MODE_144_BIT ? 0xfffffff9 : 0xfffffffd,
170 0xffffffff, 0xff);
171 for (; i < size72; i++)
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 adapter_t *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 adapter_t *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_set_reg_field(mc5->adapter, A_MC5_DB_CONFIG, F_PRTYEN | F_MBUSEN,
307 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_set_reg_field(mc5->adapter, A_MC5_DB_CONFIG, F_DBGIEN,
314 V_PRTYEN(mc5->parity_enabled) | F_MBUSEN);
315 }
316
317 /**
318 * t3_mc5_init - initialize MC5 and the TCAM
319 * @mc5: the MC5 handle
320 * @nservers: desired number the TCP servers (listening ports)
321 * @nfilters: desired number of HW filters (classifiers)
322 * @nroutes: desired number of routes
323 *
324 * Initialize MC5 and the TCAM and partition the TCAM for the requested
325 * number of servers, filters, and routes. The number of routes is
326 * typically 0 except for specialized uses of the T3 adapters.
327 */
328 int t3_mc5_init(struct mc5 *mc5, unsigned int nservers, unsigned int nfilters,
329 unsigned int nroutes)
330 {
331 int err;
332 unsigned int tcam_size = mc5->tcam_size;
333 unsigned int mode72 = mc5->mode == MC5_MODE_72_BIT;
334 adapter_t *adap = mc5->adapter;
335
336 if (!tcam_size)
337 return 0;
338
339 if (nroutes > MAX_ROUTES || nroutes + nservers + nfilters > tcam_size)
340 return -EINVAL;
341
342 if (nfilters)
343 mc5->parity_enabled = 0;
344
345 /* Reset the TCAM */
346 t3_set_reg_field(adap, A_MC5_DB_CONFIG, F_TMMODE | F_COMPEN,
347 V_COMPEN(mode72) | V_TMMODE(mode72) | F_TMRST);
348 if (t3_wait_op_done(adap, A_MC5_DB_CONFIG, F_TMRDY, 1, 500, 0)) {
349 CH_ERR(adap, "TCAM reset timed out\n");
350 return -1;
351 }
352
353 t3_write_reg(adap, A_MC5_DB_ROUTING_TABLE_INDEX, tcam_size - nroutes);
354 t3_write_reg(adap, A_MC5_DB_FILTER_TABLE,
355 tcam_size - nroutes - nfilters);
356 t3_write_reg(adap, A_MC5_DB_SERVER_INDEX,
357 tcam_size - nroutes - nfilters - nservers);
358
359 /* All the TCAM addresses we access have only the low 32 bits non 0 */
360 t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR1, 0);
361 t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR2, 0);
362
363 mc5_dbgi_mode_enable(mc5);
364
365 switch (mc5->part_type) {
366 case IDT75P52100:
367 err = init_idt52100(mc5);
368 break;
369 case IDT75N43102:
370 err = init_idt43102(mc5);
371 break;
372 default:
373 CH_ERR(adap, "Unsupported TCAM type %d\n", mc5->part_type);
374 err = -EINVAL;
375 break;
376 }
377
378 mc5_dbgi_mode_disable(mc5);
379 return err;
380 }
381
382 /**
383 * read_mc5_range - dump a part of the memory managed by MC5
384 * @mc5: the MC5 handle
385 * @start: the start address for the dump
386 * @n: number of 72-bit words to read
387 * @buf: result buffer
388 *
389 * Read n 72-bit words from MC5 memory from the given start location.
390 */
391 int t3_read_mc5_range(const struct mc5 *mc5, unsigned int start,
392 unsigned int n, u32 *buf)
393 {
394 u32 read_cmd;
395 int err = 0;
396 adapter_t *adap = mc5->adapter;
397
398 if (mc5->part_type == IDT75P52100)
399 read_cmd = IDT_CMD_READ;
400 else if (mc5->part_type == IDT75N43102)
401 read_cmd = IDT4_CMD_READ;
402 else
403 return -EINVAL;
404
405 mc5_dbgi_mode_enable(mc5);
406
407 while (n--) {
408 t3_write_reg(adap, A_MC5_DB_DBGI_REQ_ADDR0, start++);
409 if (mc5_cmd_write(adap, read_cmd)) {
410 err = -EIO;
411 break;
412 }
413 dbgi_rd_rsp3(adap, buf + 2, buf + 1, buf);
414 buf += 3;
415 }
416
417 mc5_dbgi_mode_disable(mc5);
418 return err;
419 }
420
421 #define MC5_INT_FATAL (F_PARITYERR | F_REQQPARERR | F_DISPQPARERR)
422
423 /**
424 * t3_mc5_intr_handler - MC5 interrupt handler
425 * @mc5: the MC5 handle
426 *
427 * The MC5 interrupt handler.
428 */
429 void t3_mc5_intr_handler(struct mc5 *mc5)
430 {
431 adapter_t *adap = mc5->adapter;
432 u32 cause = t3_read_reg(adap, A_MC5_DB_INT_CAUSE);
433
434 if ((cause & F_PARITYERR) && mc5->parity_enabled) {
435 CH_ALERT(adap, "MC5 parity error\n");
436 mc5->stats.parity_err++;
437 }
438
439 if (cause & F_REQQPARERR) {
440 CH_ALERT(adap, "MC5 request queue parity error\n");
441 mc5->stats.reqq_parity_err++;
442 }
443
444 if (cause & F_DISPQPARERR) {
445 CH_ALERT(adap, "MC5 dispatch queue parity error\n");
446 mc5->stats.dispq_parity_err++;
447 }
448
449 if (cause & F_ACTRGNFULL)
450 mc5->stats.active_rgn_full++;
451 if (cause & F_NFASRCHFAIL)
452 mc5->stats.nfa_srch_err++;
453 if (cause & F_UNKNOWNCMD)
454 mc5->stats.unknown_cmd++;
455 if (cause & F_DELACTEMPTY)
456 mc5->stats.del_act_empty++;
457 if (cause & MC5_INT_FATAL)
458 t3_fatal_err(adap);
459
460 t3_write_reg(adap, A_MC5_DB_INT_CAUSE, cause);
461 }
462
463 /**
464 * t3_mc5_prep - initialize the SW state for MC5
465 * @adapter: the adapter
466 * @mc5: the MC5 handle
467 * @mode: whether the TCAM will be in 72- or 144-bit mode
468 *
469 * Initialize the SW state associated with MC5. Among other things
470 * this determines the size of the attached TCAM.
471 */
472 void __devinit t3_mc5_prep(adapter_t *adapter, struct mc5 *mc5, int mode)
473 {
474 #define K * 1024
475
476 static unsigned int tcam_part_size[] = { /* in K 72-bit entries */
477 64 K, 128 K, 256 K, 32 K
478 };
479
480 #undef K
481
482 u32 cfg = t3_read_reg(adapter, A_MC5_DB_CONFIG);
483
484 mc5->adapter = adapter;
485 mc5->parity_enabled = 1;
486 mc5->mode = (unsigned char) mode;
487 mc5->part_type = (unsigned char) G_TMTYPE(cfg);
488 if (cfg & F_TMTYPEHI)
489 mc5->part_type |= 4;
490
491 mc5->tcam_size = tcam_part_size[G_TMPARTSIZE(cfg)];
492 if (mode == MC5_MODE_144_BIT)
493 mc5->tcam_size /= 2;
494 }
Cache object: e1f451f2dd19e356493cd19d709b183e
|