SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/cxgb3/mc5.c

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