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