arch/mips/cavium-octeon/executive/octeon-model.c

   1 /***********************license start***************
   2  * Author: Cavium Networks
   3  *
   4  * Contact: support@caviumnetworks.com
   5  * This file is part of the OCTEON SDK
   6  *
   7  * Copyright (c) 2003-2017 Cavium, Inc.
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this file; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  * or visit http://www.gnu.org/licenses/.
  23  *
  24  * This file may also be available under a different license from Cavium.
  25  * Contact Cavium Networks for more information
  26  ***********************license end**************************************/
  27
  28 #include <asm/octeon/octeon.h>
  29
  30 enum octeon_feature_bits __octeon_feature_bits __read_mostly;
  31 EXPORT_SYMBOL_GPL(__octeon_feature_bits);
  32
  33 /**
  34  * Read a byte of fuse data
  35  * @byte_addr:   address to read
  36  *
  37  * Returns fuse value: 0 or 1
  38  */
  39 static uint8_t __init cvmx_fuse_read_byte(int byte_addr)
  40 {
  41         union cvmx_mio_fus_rcmd read_cmd;
  42
  43         read_cmd.u64 = 0;
  44         read_cmd.s.addr = byte_addr;
  45         read_cmd.s.pend = 1;
  46         cvmx_write_csr(CVMX_MIO_FUS_RCMD, read_cmd.u64);
  47         while ((read_cmd.u64 = cvmx_read_csr(CVMX_MIO_FUS_RCMD))
  48                && read_cmd.s.pend)
  49                 ;
  50         return read_cmd.s.dat;
  51 }
  52
  53 /*
  54  * Version of octeon_model_get_string() that takes buffer as argument,
  55  * as running early in u-boot static/global variables don't work when
  56  * running from flash.
  57  */
  58 static const char *__init octeon_model_get_string_buffer(uint32_t chip_id,
  59                                                          char *buffer)
  60 {
  61         const char *family;
  62         const char *core_model;
  63         char pass[4];
  64         int clock_mhz;
  65         const char *suffix;
  66         int num_cores;
  67         union cvmx_mio_fus_dat2 fus_dat2;
  68         union cvmx_mio_fus_dat3 fus_dat3;
  69         char fuse_model[10];
  70         uint32_t fuse_data = 0;
  71         uint64_t l2d_fus3 = 0;
  72
  73         if (OCTEON_IS_MODEL(OCTEON_CN3XXX) || OCTEON_IS_MODEL(OCTEON_CN5XXX))
  74                 l2d_fus3 = (cvmx_read_csr(CVMX_L2D_FUS3) >> 34) & 0x3;
  75         fus_dat2.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT2);
  76         fus_dat3.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT3);
  77         num_cores = cvmx_octeon_num_cores();
  78
  79         /* Make sure the non existent devices look disabled */
  80         switch ((chip_id >> 8) & 0xff) {
  81         case 6:         /* CN50XX */
  82         case 2:         /* CN30XX */
  83                 fus_dat3.s.nodfa_dte = 1;
  84                 fus_dat3.s.nozip = 1;
  85                 break;
  86         case 4:         /* CN57XX or CN56XX */
  87                 fus_dat3.s.nodfa_dte = 1;
  88                 break;
  89         default:
  90                 break;
  91         }
  92
  93         /* Make a guess at the suffix */
  94         /* NSP = everything */
  95         /* EXP = No crypto */
  96         /* SCP = No DFA, No zip */
  97         /* CP = No DFA, No crypto, No zip */
  98         if (fus_dat3.s.nodfa_dte) {
  99                 if (fus_dat2.s.nocrypto)
 100                         suffix = "CP";
 101                 else
 102                         suffix = "SCP";
 103         } else if (fus_dat2.s.nocrypto)
 104                 suffix = "EXP";
 105         else
 106                 suffix = "NSP";
 107
 108         if (!fus_dat2.s.nocrypto)
 109                 __octeon_feature_bits |= OCTEON_HAS_CRYPTO;
 110
 111         /*
 112          * Assume pass number is encoded using <5:3><2:0>. Exceptions
 113          * will be fixed later.
 114          */
 115         sprintf(pass, "%d.%d", (int)((chip_id >> 3) & 7) + 1, (int)chip_id & 7);
 116
 117         /*
 118          * Use the number of cores to determine the last 2 digits of
 119          * the model number. There are some exceptions that are fixed
 120          * later.
 121          */
 122         switch (num_cores) {
 123         case 48:
 124                 core_model = "90";
 125                 break;
 126         case 44:
 127                 core_model = "88";
 128                 break;
 129         case 40:
 130                 core_model = "85";
 131                 break;
 132         case 32:
 133                 core_model = "80";
 134                 break;
 135         case 24:
 136                 core_model = "70";
 137                 break;
 138         case 16:
 139                 core_model = "60";
 140                 break;
 141         case 15:
 142                 core_model = "58";
 143                 break;
 144         case 14:
 145                 core_model = "55";
 146                 break;
 147         case 13:
 148                 core_model = "52";
 149                 break;
 150         case 12:
 151                 core_model = "50";
 152                 break;
 153         case 11:
 154                 core_model = "48";
 155                 break;
 156         case 10:
 157                 core_model = "45";
 158                 break;
 159         case 9:
 160                 core_model = "42";
 161                 break;
 162         case 8:
 163                 core_model = "40";
 164                 break;
 165         case 7:
 166                 core_model = "38";
 167                 break;
 168         case 6:
 169                 core_model = "34";
 170                 break;
 171         case 5:
 172                 core_model = "32";
 173                 break;
 174         case 4:
 175                 core_model = "30";
 176                 break;
 177         case 3:
 178                 core_model = "25";
 179                 break;
 180         case 2:
 181                 core_model = "20";
 182                 break;
 183         case 1:
 184                 core_model = "10";
 185                 break;
 186         default:
 187                 core_model = "XX";
 188                 break;
 189         }
 190
 191         /* Now figure out the family, the first two digits */
 192         switch ((chip_id >> 8) & 0xff) {
 193         case 0:         /* CN38XX, CN37XX or CN36XX */
 194                 if (l2d_fus3) {
 195                         /*
 196                          * For some unknown reason, the 16 core one is
 197                          * called 37 instead of 36.
 198                          */
 199                         if (num_cores >= 16)
 200                                 family = "37";
 201                         else
 202                                 family = "36";
 203                 } else
 204                         family = "38";
 205                 /*
 206                  * This series of chips didn't follow the standard
 207                  * pass numbering.
 208                  */
 209                 switch (chip_id & 0xf) {
 210                 case 0:
 211                         strcpy(pass, "1.X");
 212                         break;
 213                 case 1:
 214                         strcpy(pass, "2.X");
 215                         break;
 216                 case 3:
 217                         strcpy(pass, "3.X");
 218                         break;
 219                 default:
 220                         strcpy(pass, "X.X");
 221                         break;
 222                 }
 223                 break;
 224         case 1:         /* CN31XX or CN3020 */
 225                 if ((chip_id & 0x10) || l2d_fus3)
 226                         family = "30";
 227                 else
 228                         family = "31";
 229                 /*
 230                  * This series of chips didn't follow the standard
 231                  * pass numbering.
 232                  */
 233                 switch (chip_id & 0xf) {
 234                 case 0:
 235                         strcpy(pass, "1.0");
 236                         break;
 237                 case 2:
 238                         strcpy(pass, "1.1");
 239                         break;
 240                 default:
 241                         strcpy(pass, "X.X");
 242                         break;
 243                 }
 244                 break;
 245         case 2:         /* CN3010 or CN3005 */
 246                 family = "30";
 247                 /* A chip with half cache is an 05 */
 248                 if (l2d_fus3)
 249                         core_model = "05";
 250                 /*
 251                  * This series of chips didn't follow the standard
 252                  * pass numbering.
 253                  */
 254                 switch (chip_id & 0xf) {
 255                 case 0:
 256                         strcpy(pass, "1.0");
 257                         break;
 258                 case 2:
 259                         strcpy(pass, "1.1");
 260                         break;
 261                 default:
 262                         strcpy(pass, "X.X");
 263                         break;
 264                 }
 265                 break;
 266         case 3:         /* CN58XX */
 267                 family = "58";
 268                 /* Special case. 4 core, half cache (CP with half cache) */
 269                 if ((num_cores == 4) && l2d_fus3 && !strncmp(suffix, "CP", 2))
 270                         core_model = "29";
 271
 272                 /* Pass 1 uses different encodings for pass numbers */
 273                 if ((chip_id & 0xFF) < 0x8) {
 274                         switch (chip_id & 0x3) {
 275                         case 0:
 276                                 strcpy(pass, "1.0");
 277                                 break;
 278                         case 1:
 279                                 strcpy(pass, "1.1");
 280                                 break;
 281                         case 3:
 282                                 strcpy(pass, "1.2");
 283                                 break;
 284                         default:
 285                                 strcpy(pass, "1.X");
 286                                 break;
 287                         }
 288                 }
 289                 break;
 290         case 4:         /* CN57XX, CN56XX, CN55XX, CN54XX */
 291                 if (fus_dat2.cn56xx.raid_en) {
 292                         if (l2d_fus3)
 293                                 family = "55";
 294                         else
 295                                 family = "57";
 296                         if (fus_dat2.cn56xx.nocrypto)
 297                                 suffix = "SP";
 298                         else
 299                                 suffix = "SSP";
 300                 } else {
 301                         if (fus_dat2.cn56xx.nocrypto)
 302                                 suffix = "CP";
 303                         else {
 304                                 suffix = "NSP";
 305                                 if (fus_dat3.s.nozip)
 306                                         suffix = "SCP";
 307
 308                                 if (fus_dat3.cn38xx.bar2_en)
 309                                         suffix = "NSPB2";
 310                         }
 311                         if (l2d_fus3)
 312                                 family = "54";
 313                         else
 314                                 family = "56";
 315                 }
 316                 break;
 317         case 6:         /* CN50XX */
 318                 family = "50";
 319                 break;
 320         case 7:         /* CN52XX */
 321                 if (l2d_fus3)
 322                         family = "51";
 323                 else
 324                         family = "52";
 325                 break;
 326         case 0x93:              /* CN61XX */
 327                 family = "61";
 328                 if (fus_dat2.cn61xx.nocrypto && fus_dat2.cn61xx.dorm_crypto)
 329                         suffix = "AP";
 330                 if (fus_dat2.cn61xx.nocrypto)
 331                         suffix = "CP";
 332                 else if (fus_dat2.cn61xx.dorm_crypto)
 333                         suffix = "DAP";
 334                 else if (fus_dat3.cn61xx.nozip)
 335                         suffix = "SCP";
 336                 break;
 337         case 0x90:              /* CN63XX */
 338                 family = "63";
 339                 if (fus_dat3.s.l2c_crip == 2)
 340                         family = "62";
 341                 if (num_cores == 6)     /* Other core counts match generic */
 342                         core_model = "35";
 343                 if (fus_dat2.cn63xx.nocrypto)
 344                         suffix = "CP";
 345                 else if (fus_dat2.cn63xx.dorm_crypto)
 346                         suffix = "DAP";
 347                 else if (fus_dat3.cn61xx.nozip)
 348                         suffix = "SCP";
 349                 else
 350                         suffix = "AAP";
 351                 break;
 352         case 0x92:              /* CN66XX */
 353                 family = "66";
 354                 if (num_cores == 6)     /* Other core counts match generic */
 355                         core_model = "35";
 356                 if (fus_dat2.cn66xx.nocrypto && fus_dat2.cn66xx.dorm_crypto)
 357                         suffix = "AP";
 358                 if (fus_dat2.cn66xx.nocrypto)
 359                         suffix = "CP";
 360                 else if (fus_dat2.cn66xx.dorm_crypto)
 361                         suffix = "DAP";
 362                 else if (fus_dat3.cn61xx.nozip)
 363                         suffix = "SCP";
 364                 else
 365                         suffix = "AAP";
 366                 break;
 367         case 0x91:              /* CN68XX */
 368                 family = "68";
 369                 if (fus_dat2.cn68xx.nocrypto && fus_dat3.cn61xx.nozip)
 370                         suffix = "CP";
 371                 else if (fus_dat2.cn68xx.dorm_crypto)
 372                         suffix = "DAP";
 373                 else if (fus_dat3.cn61xx.nozip)
 374                         suffix = "SCP";
 375                 else if (fus_dat2.cn68xx.nocrypto)
 376                         suffix = "SP";
 377                 else
 378                         suffix = "AAP";
 379                 break;
 380         case 0x94:              /* CNF71XX */
 381                 family = "F71";
 382                 if (fus_dat3.cn61xx.nozip)
 383                         suffix = "SCP";
 384                 else
 385                         suffix = "AAP";
 386                 break;
 387         case 0x95:              /* CN78XX */
 388                 if (num_cores == 6)     /* Other core counts match generic */
 389                         core_model = "35";
 390                 if (OCTEON_IS_MODEL(OCTEON_CN76XX))
 391                         family = "76";
 392                 else
 393                         family = "78";
 394                 if (fus_dat3.cn78xx.l2c_crip == 2)
 395                         family = "77";
 396                 if (fus_dat3.cn78xx.nozip
 397                     && fus_dat3.cn78xx.nodfa_dte
 398                     && fus_dat3.cn78xx.nohna_dte) {
 399                         if (fus_dat3.cn78xx.nozip &&
 400                                 !fus_dat2.cn78xx.raid_en &&
 401                                 fus_dat3.cn78xx.nohna_dte) {
 402                                 suffix = "CP";
 403                         } else {
 404                                 suffix = "SCP";
 405                         }
 406                 } else if (fus_dat2.cn78xx.raid_en == 0)
 407                         suffix = "HCP";
 408                 else
 409                         suffix = "AAP";
 410                 break;
 411         case 0x96:              /* CN70XX */
 412                 family = "70";
 413                 if (cvmx_read_csr(CVMX_MIO_FUS_PDF) & (0x1ULL << 32))
 414                         family = "71";
 415                 if (fus_dat2.cn70xx.nocrypto)
 416                         suffix = "CP";
 417                 else if (fus_dat3.cn70xx.nodfa_dte)
 418                         suffix = "SCP";
 419                 else
 420                         suffix = "AAP";
 421                 break;
 422         case 0x97:              /* CN73XX */
 423                 if (num_cores == 6)     /* Other core counts match generic */
 424                         core_model = "35";
 425                 family = "73";
 426                 if (fus_dat3.cn73xx.l2c_crip == 2)
 427                         family = "72";
 428                 if (fus_dat3.cn73xx.nozip
 429                                 && fus_dat3.cn73xx.nodfa_dte
 430                                 && fus_dat3.cn73xx.nohna_dte) {
 431                         if (!fus_dat2.cn73xx.raid_en)
 432                                 suffix = "CP";
 433                         else
 434                                 suffix = "SCP";
 435                 } else
 436                         suffix = "AAP";
 437                 break;
 438         case 0x98:              /* CN75XX */
 439                 family = "F75";
 440                 if (fus_dat3.cn78xx.nozip
 441                     && fus_dat3.cn78xx.nodfa_dte
 442                     && fus_dat3.cn78xx.nohna_dte)
 443                         suffix = "SCP";
 444                 else
 445                         suffix = "AAP";
 446                 break;
 447         default:
 448                 family = "XX";
 449                 core_model = "XX";
 450                 strcpy(pass, "X.X");
 451                 suffix = "XXX";
 452                 break;
 453         }
 454
 455         clock_mhz = octeon_get_clock_rate() / 1000000;
 456         if (family[0] != '3') {
 457                 int fuse_base = 384 / 8;
 458                 if (family[0] == '6')
 459                         fuse_base = 832 / 8;
 460
 461                 /* Check for model in fuses, overrides normal decode */
 462                 /* This is _not_ valid for Octeon CN3XXX models */
 463                 fuse_data |= cvmx_fuse_read_byte(fuse_base + 3);
 464                 fuse_data = fuse_data << 8;
 465                 fuse_data |= cvmx_fuse_read_byte(fuse_base + 2);
 466                 fuse_data = fuse_data << 8;
 467                 fuse_data |= cvmx_fuse_read_byte(fuse_base + 1);
 468                 fuse_data = fuse_data << 8;
 469                 fuse_data |= cvmx_fuse_read_byte(fuse_base);
 470                 if (fuse_data & 0x7ffff) {
 471                         int model = fuse_data & 0x3fff;
 472                         int suffix = (fuse_data >> 14) & 0x1f;
 473                         if (suffix && model) {
 474                                 /* Have both number and suffix in fuses, so both */
 475                                 sprintf(fuse_model, "%d%c", model, 'A' + suffix - 1);
 476                                 core_model = "";
 477                                 family = fuse_model;
 478                         } else if (suffix && !model) {
 479                                 /* Only have suffix, so add suffix to 'normal' model number */
 480                                 sprintf(fuse_model, "%s%c", core_model, 'A' + suffix - 1);
 481                                 core_model = fuse_model;
 482                         } else {
 483                                 /* Don't have suffix, so just use model from fuses */
 484                                 sprintf(fuse_model, "%d", model);
 485                                 core_model = "";
 486                                 family = fuse_model;
 487                         }
 488                 }
 489         }
 490         sprintf(buffer, "CN%s%sp%s-%d-%s", family, core_model, pass, clock_mhz, suffix);
 491         return buffer;
 492 }
 493
 494 /**
 495  * Given the chip processor ID from COP0, this function returns a
 496  * string representing the chip model number. The string is of the
 497  * form CNXXXXpX.X-FREQ-SUFFIX.
 498  * - XXXX = The chip model number
 499  * - X.X = Chip pass number
 500  * - FREQ = Current frequency in Mhz
 501  * - SUFFIX = NSP, EXP, SCP, SSP, or CP
 502  *
 503  * @chip_id: Chip ID
 504  *
 505  * Returns Model string
 506  */
 507 const char *__init octeon_model_get_string(uint32_t chip_id)
 508 {
 509         static char buffer[32];
 510         return octeon_model_get_string_buffer(chip_id, buffer);
 511 }