1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 26 */ 27 28 #include <sys/types.h> 29 #include <sys/time.h> 30 #include <sys/nvpair.h> 31 #include <sys/cmn_err.h> 32 #include <sys/cred.h> 33 #include <sys/open.h> 34 #include <sys/ddi.h> 35 #include <sys/sunddi.h> 36 #include <sys/conf.h> 37 #include <sys/modctl.h> 38 #include <sys/cyclic.h> 39 #include <sys/errorq.h> 40 #include <sys/stat.h> 41 #include <sys/cpuvar.h> 42 #include <sys/mc_intel.h> 43 #include <sys/mc.h> 44 #include <sys/fm/protocol.h> 45 #include "nb_log.h" 46 #include "nb5000.h" 47 48 nvlist_t *inb_mc_nvl; 49 krwlock_t inb_mc_lock; 50 51 char *inb_mc_snapshot; 52 uint_t nb_config_gen; 53 uint_t inb_mc_snapshotgen; 54 size_t inb_mc_snapshotsz; 55 static dev_info_t *inb_dip; 56 int nb_allow_detach = 0; 57 int nb_no_smbios; 58 59 static uint64_t 60 rank_to_base(uint8_t branch, uint8_t rank, uint8_t *interleave, uint64_t *limit, 61 uint64_t *hole_base, uint64_t *hole_size, uint8_t *wayp, 62 uint8_t *branch_interleavep) 63 { 64 uint8_t i, j; 65 uint64_t base = 0; 66 uint64_t lt = 0; 67 uint64_t h = 0; 68 uint64_t hs = 0; 69 uint8_t il = 1; 70 uint8_t way = 0; 71 uint8_t branch_interleave = 0; 72 73 for (i = 0; i < NB_MEM_RANK_SELECT; i++) { 74 for (j = 0; j < NB_RANKS_IN_SELECT; j++) { 75 if (nb_ranks[branch][i].rank[j] == rank) { 76 base = nb_ranks[branch][i].base; 77 lt = nb_ranks[branch][i].limit; 78 il = nb_ranks[branch][i].interleave; 79 h = nb_ranks[branch][i].hole_base; 80 hs = nb_ranks[branch][i].hole_size; 81 way = j; 82 branch_interleave = 83 nb_ranks[branch][i].branch_interleave; 84 i = NB_MEM_RANK_SELECT; 85 break; 86 } 87 } 88 } 89 if (lt == 0) { 90 for (i = 0; lt == 0 && i < NB_MEM_BRANCH_SELECT; i++) { 91 if (nb_banks[i].way[branch] && 92 base >= nb_banks[i].base && 93 base < nb_banks[i].base + nb_banks[i].limit) { 94 lt = nb_banks[i].limit; 95 break; 96 } 97 } 98 } 99 *interleave = il; 100 *limit = lt; 101 *hole_base = h; 102 *hole_size = hs; 103 *wayp = way; 104 *branch_interleavep = branch_interleave; 105 return (base); 106 } 107 108 /*ARGSUSED*/ 109 void 110 inb_rank(nvlist_t *newdimm, nb_dimm_t *nb_dimm, uint8_t channel, uint32_t dimm) 111 { 112 nvlist_t **newrank; 113 int i; 114 115 newrank = kmem_zalloc(sizeof (nvlist_t *) * nb_dimm->nranks, KM_SLEEP); 116 for (i = 0; i < nb_dimm->nranks; i++) { 117 uint64_t dimm_base; 118 uint64_t limit; 119 uint8_t interleave; 120 uint8_t way; 121 uint8_t branch_interleave; 122 uint64_t hole_base; 123 uint64_t hole_size; 124 125 dimm_base = rank_to_base(channel/nb_channels_per_branch, 126 nb_dimm->start_rank + i, &interleave, 127 &limit, &hole_base, &hole_size, &way, &branch_interleave); 128 (void) nvlist_alloc(&newrank[i], NV_UNIQUE_NAME, KM_SLEEP); 129 130 (void) nvlist_add_uint64(newrank[i], "dimm-rank-base", 131 dimm_base); 132 if (hole_size) { 133 (void) nvlist_add_uint64(newrank[i], "dimm-hole", 134 hole_base); 135 (void) nvlist_add_uint64(newrank[i], "dimm-hole-size", 136 hole_size); 137 } 138 (void) nvlist_add_uint64(newrank[i], "dimm-rank-limit", 139 limit); 140 if (interleave > 1) { 141 (void) nvlist_add_uint32(newrank[i], 142 "dimm-rank-interleave", (uint32_t)interleave); 143 (void) nvlist_add_uint32(newrank[i], 144 "dimm-rank-interleave-way", (uint32_t)way); 145 if (branch_interleave) { 146 (void) nvlist_add_uint32(newrank[i], 147 "dimm-rank-interleave-branch", (uint32_t)1); 148 } 149 } 150 } 151 (void) nvlist_add_nvlist_array(newdimm, MCINTEL_NVLIST_RANKS, newrank, 152 nb_dimm->nranks); 153 for (i = 0; i < nb_dimm->nranks; i++) 154 nvlist_free(newrank[i]); 155 kmem_free(newrank, sizeof (nvlist_t *) * nb_dimm->nranks); 156 } 157 158 nvlist_t * 159 inb_dimm(nb_dimm_t *nb_dimm, uint8_t channel, uint32_t dimm) 160 { 161 nvlist_t *newdimm; 162 uint8_t t; 163 char sbuf[65]; 164 165 (void) nvlist_alloc(&newdimm, NV_UNIQUE_NAME, KM_SLEEP); 166 (void) nvlist_add_uint32(newdimm, "dimm-number", dimm); 167 168 if (nb_dimm->dimm_size >= 1024*1024*1024) { 169 (void) snprintf(sbuf, sizeof (sbuf), "%dG", 170 (int)(nb_dimm->dimm_size / (1024*1024*1024))); 171 } else { 172 (void) snprintf(sbuf, sizeof (sbuf), "%dM", 173 (int)(nb_dimm->dimm_size / (1024*1024))); 174 } 175 (void) nvlist_add_string(newdimm, "dimm-size", sbuf); 176 (void) nvlist_add_uint64(newdimm, "size", nb_dimm->dimm_size); 177 (void) nvlist_add_uint32(newdimm, "nbanks", (uint32_t)nb_dimm->nbanks); 178 (void) nvlist_add_uint32(newdimm, "ncolumn", 179 (uint32_t)nb_dimm->ncolumn); 180 (void) nvlist_add_uint32(newdimm, "nrow", (uint32_t)nb_dimm->nrow); 181 (void) nvlist_add_uint32(newdimm, "width", (uint32_t)nb_dimm->width); 182 (void) nvlist_add_int32(newdimm, MCINTEL_NVLIST_1ST_RANK, 183 (int32_t)nb_dimm->start_rank); 184 (void) nvlist_add_uint32(newdimm, "ranks", (uint32_t)nb_dimm->nranks); 185 inb_rank(newdimm, nb_dimm, channel, dimm); 186 (void) nvlist_add_uint32(newdimm, "manufacture-id", 187 (uint32_t)nb_dimm->manufacture_id); 188 (void) nvlist_add_uint32(newdimm, "manufacture-location", 189 (uint32_t)nb_dimm->manufacture_location); 190 (void) nvlist_add_uint32(newdimm, "manufacture-week", 191 (uint32_t)nb_dimm->manufacture_week); 192 (void) nvlist_add_uint32(newdimm, "manufacture-year", 193 (uint32_t)nb_dimm->manufacture_year + 2000); 194 /* create Sun Serial number from SPD data */ 195 (void) snprintf(sbuf, sizeof (sbuf), "%04x%02x%02x%02x%08x", 196 (uint32_t)nb_dimm->manufacture_id & 0x7fff, 197 (uint32_t)nb_dimm->manufacture_location, 198 (uint32_t)nb_dimm->manufacture_year, 199 (uint32_t)nb_dimm->manufacture_week, 200 nb_dimm->serial_number); 201 (void) nvlist_add_string(newdimm, FM_FMRI_HC_SERIAL_ID, sbuf); 202 if (nb_dimm->part_number && nb_dimm->part_number[0]) { 203 t = sizeof (nb_dimm->part_number); 204 (void) strncpy(sbuf, nb_dimm->part_number, t); 205 sbuf[t] = 0; 206 (void) nvlist_add_string(newdimm, FM_FMRI_HC_PART, sbuf); 207 } 208 if (nb_dimm->revision && nb_dimm->revision[0]) { 209 t = sizeof (nb_dimm->revision); 210 (void) strncpy(sbuf, nb_dimm->revision, t); 211 sbuf[t] = 0; 212 (void) nvlist_add_string(newdimm, FM_FMRI_HC_REVISION, sbuf); 213 } 214 t = sizeof (nb_dimm->label); 215 (void) strncpy(sbuf, nb_dimm->label, t); 216 sbuf[t] = 0; 217 (void) nvlist_add_string(newdimm, FM_FAULT_FRU_LABEL, sbuf); 218 return (newdimm); 219 } 220 221 static void 222 inb_dimmlist(nvlist_t *nvl) 223 { 224 nvlist_t **dimmlist; 225 nvlist_t **newchannel; 226 int nchannels = nb_number_memory_controllers * nb_channels_per_branch; 227 int nd; 228 uint8_t i, j; 229 nb_dimm_t **dimmpp; 230 nb_dimm_t *dimmp; 231 232 dimmlist = kmem_zalloc(sizeof (nvlist_t *) * nb_dimms_per_channel, 233 KM_SLEEP); 234 newchannel = kmem_zalloc(sizeof (nvlist_t *) * nchannels, KM_SLEEP); 235 dimmpp = nb_dimms; 236 for (i = 0; i < nchannels; i++) { 237 (void) nvlist_alloc(&newchannel[i], NV_UNIQUE_NAME, KM_SLEEP); 238 nd = 0; 239 for (j = 0; j < nb_dimms_per_channel; j++) { 240 dimmp = *dimmpp; 241 if (dimmp != NULL) { 242 dimmlist[nd] = inb_dimm(dimmp, i, (uint32_t)j); 243 nd++; 244 } 245 dimmpp++; 246 } 247 if (nd) { 248 (void) nvlist_add_nvlist_array(newchannel[i], 249 "memory-dimms", dimmlist, nd); 250 for (j = 0; j < nd; j++) 251 nvlist_free(dimmlist[j]); 252 } 253 } 254 (void) nvlist_add_nvlist_array(nvl, MCINTEL_NVLIST_MC, newchannel, 255 nchannels); 256 for (i = 0; i < nchannels; i++) 257 nvlist_free(newchannel[i]); 258 kmem_free(dimmlist, sizeof (nvlist_t *) * nb_dimms_per_channel); 259 kmem_free(newchannel, sizeof (nvlist_t *) * nchannels); 260 } 261 262 static char * 263 inb_mc_name() 264 { 265 char *mc; 266 267 switch (nb_chipset) { 268 case INTEL_NB_7300: 269 mc = "Intel 7300"; 270 break; 271 case INTEL_NB_5400: 272 mc = "Intel 5400"; 273 break; 274 case INTEL_NB_5400A: 275 mc = "Intel 5400A"; 276 break; 277 case INTEL_NB_5400B: 278 mc = "Intel 5400B"; 279 break; 280 case INTEL_NB_5100: 281 mc = "Intel 5100"; 282 break; 283 case INTEL_NB_5000P: 284 mc = "Intel 5000P"; 285 break; 286 case INTEL_NB_5000V: 287 mc = "Intel 5000V"; 288 break; 289 case INTEL_NB_5000X: 290 mc = "Intel 5000X"; 291 break; 292 case INTEL_NB_5000Z: 293 mc = "Intel 5000Z"; 294 break; 295 default: 296 mc = "Intel 5000"; 297 break; 298 } 299 return (mc); 300 } 301 302 static void 303 inb_create_nvl() 304 { 305 nvlist_t *nvl; 306 307 (void) nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP); 308 (void) nvlist_add_uint8(nvl, MCINTEL_NVLIST_VERSTR, 309 MCINTEL_NVLIST_VERS); 310 (void) nvlist_add_string(nvl, "memory-controller", inb_mc_name()); 311 if (nb_chipset == INTEL_NB_5100) 312 (void) nvlist_add_uint8(nvl, MCINTEL_NVLIST_NMEM, 313 (uint8_t)nb_number_memory_controllers); 314 inb_dimmlist(nvl); 315 316 nvlist_free(inb_mc_nvl); 317 inb_mc_nvl = nvl; 318 } 319 320 static void 321 inb_mc_snapshot_destroy() 322 { 323 ASSERT(RW_LOCK_HELD(&inb_mc_lock)); 324 325 if (inb_mc_snapshot == NULL) 326 return; 327 328 kmem_free(inb_mc_snapshot, inb_mc_snapshotsz); 329 inb_mc_snapshot = NULL; 330 inb_mc_snapshotsz = 0; 331 inb_mc_snapshotgen++; 332 } 333 334 static int 335 inb_mc_snapshot_update() 336 { 337 ASSERT(RW_LOCK_HELD(&inb_mc_lock)); 338 339 if (inb_mc_snapshot != NULL) 340 return (0); 341 342 if (nvlist_pack(inb_mc_nvl, &inb_mc_snapshot, &inb_mc_snapshotsz, 343 NV_ENCODE_XDR, KM_SLEEP) != 0) 344 return (-1); 345 346 return (0); 347 } 348 349 /*ARGSUSED*/ 350 static int 351 inb_mc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 352 int *rvalp) 353 { 354 int rc = 0; 355 mc_snapshot_info_t mcs; 356 357 if (cmd != MC_IOC_SNAPSHOT_INFO && cmd != MC_IOC_SNAPSHOT) 358 return (EINVAL); 359 360 rw_enter(&inb_mc_lock, RW_READER); 361 if (inb_mc_nvl == NULL || inb_mc_snapshotgen != nb_config_gen) { 362 if (!rw_tryupgrade(&inb_mc_lock)) { 363 rw_exit(&inb_mc_lock); 364 return (EAGAIN); 365 } 366 if (inb_mc_nvl) 367 inb_mc_snapshot_destroy(); 368 inb_create_nvl(); 369 nb_config_gen = inb_mc_snapshotgen; 370 (void) inb_mc_snapshot_update(); 371 } 372 switch (cmd) { 373 case MC_IOC_SNAPSHOT_INFO: 374 mcs.mcs_size = (uint32_t)inb_mc_snapshotsz; 375 mcs.mcs_gen = inb_mc_snapshotgen; 376 377 if (ddi_copyout(&mcs, (void *)arg, sizeof (mc_snapshot_info_t), 378 mode) < 0) 379 rc = EFAULT; 380 break; 381 case MC_IOC_SNAPSHOT: 382 if (ddi_copyout(inb_mc_snapshot, (void *)arg, inb_mc_snapshotsz, 383 mode) < 0) 384 rc = EFAULT; 385 break; 386 } 387 rw_exit(&inb_mc_lock); 388 return (rc); 389 } 390 391 /*ARGSUSED*/ 392 static int 393 inb_mc_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 394 void **result) 395 { 396 if ((infocmd != DDI_INFO_DEVT2DEVINFO && 397 infocmd != DDI_INFO_DEVT2INSTANCE) || inb_dip == NULL) { 398 *result = NULL; 399 return (DDI_FAILURE); 400 } 401 if (infocmd == DDI_INFO_DEVT2DEVINFO) 402 *result = inb_dip; 403 else 404 *result = (void *)(uintptr_t)ddi_get_instance(inb_dip); 405 return (0); 406 } 407 408 static int 409 inb_mc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 410 { 411 if (cmd == DDI_RESUME) { 412 nb_dev_reinit(); 413 return (DDI_SUCCESS); 414 } 415 if (cmd != DDI_ATTACH) 416 return (DDI_FAILURE); 417 if (inb_dip == NULL) { 418 inb_dip = dip; 419 nb_no_smbios = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 420 DDI_PROP_DONTPASS, "no-smbios", 0); 421 nb_pci_cfg_setup(dip); 422 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, "model", 423 inb_mc_name()); 424 if (nb_dev_init()) { 425 nb_pci_cfg_free(); 426 inb_dip = NULL; 427 return (DDI_FAILURE); 428 } 429 if (ddi_create_minor_node(dip, "mc-intel", S_IFCHR, 0, 430 "ddi_mem_ctrl", 0) != DDI_SUCCESS) { 431 cmn_err(CE_WARN, "failed to create minor node" 432 " for memory controller\n"); 433 } 434 cmi_hdl_walk(inb_mc_register, NULL, NULL, NULL); 435 } 436 437 return (DDI_SUCCESS); 438 } 439 440 /*ARGSUSED*/ 441 static int 442 inb_mc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 443 { 444 if (nb_allow_detach && cmd == DDI_DETACH && dip == inb_dip) { 445 rw_enter(&inb_mc_lock, RW_WRITER); 446 inb_mc_snapshot_destroy(); 447 rw_exit(&inb_mc_lock); 448 inb_dip = NULL; 449 return (DDI_SUCCESS); 450 } else if (cmd == DDI_SUSPEND || cmd == DDI_PM_SUSPEND) { 451 return (DDI_SUCCESS); 452 } else { 453 return (DDI_FAILURE); 454 } 455 } 456 457 /*ARGSUSED*/ 458 static int 459 inb_mc_open(dev_t *devp, int flag, int otyp, cred_t *credp) 460 { 461 if (otyp != OTYP_CHR) 462 return (EINVAL); 463 464 rw_enter(&inb_mc_lock, RW_READER); 465 if (getminor(*devp) >= 1) { 466 rw_exit(&inb_mc_lock); 467 return (EINVAL); 468 } 469 rw_exit(&inb_mc_lock); 470 471 return (0); 472 } 473 474 /*ARGSUSED*/ 475 static int 476 inb_mc_close(dev_t dev, int flag, int otyp, cred_t *credp) 477 { 478 return (0); 479 } 480 481 482 static struct cb_ops inb_mc_cb_ops = { 483 inb_mc_open, 484 inb_mc_close, 485 nodev, /* not a block driver */ 486 nodev, /* no print routine */ 487 nodev, /* no dump routine */ 488 nodev, /* no read routine */ 489 nodev, /* no write routine */ 490 inb_mc_ioctl, 491 nodev, /* no devmap routine */ 492 nodev, /* no mmap routine */ 493 nodev, /* no segmap routine */ 494 nochpoll, /* no chpoll routine */ 495 ddi_prop_op, 496 0, /* not a STREAMS driver */ 497 D_NEW | D_MP, /* safe for multi-thread/multi-processor */ 498 }; 499 500 static struct dev_ops inb_mc_ops = { 501 DEVO_REV, /* devo_rev */ 502 0, /* devo_refcnt */ 503 inb_mc_getinfo, /* devo_getinfo */ 504 nulldev, /* devo_identify */ 505 nulldev, /* devo_probe */ 506 inb_mc_attach, /* devo_attach */ 507 inb_mc_detach, /* devo_detach */ 508 nodev, /* devo_reset */ 509 &inb_mc_cb_ops, /* devo_cb_ops */ 510 NULL, /* devo_bus_ops */ 511 NULL, /* devo_power */ 512 ddi_quiesce_not_needed, /* devo_quiesce */ 513 }; 514 515 static struct modldrv modldrv = { 516 &mod_driverops, 517 "Intel 5000 Memory Controller Hub Module", 518 &inb_mc_ops 519 }; 520 521 static struct modlinkage modlinkage = { 522 MODREV_1, 523 (void *)&modldrv, 524 NULL 525 }; 526 527 int 528 _init(void) 529 { 530 int err; 531 532 err = nb_init(); 533 if (err == 0 && (err = mod_install(&modlinkage)) == 0) 534 rw_init(&inb_mc_lock, NULL, RW_DRIVER, NULL); 535 536 return (err); 537 } 538 539 int 540 _info(struct modinfo *modinfop) 541 { 542 return (mod_info(&modlinkage, modinfop)); 543 } 544 545 int 546 _fini(void) 547 { 548 int err; 549 550 if ((err = mod_remove(&modlinkage)) == 0) { 551 nb_unload(); 552 rw_destroy(&inb_mc_lock); 553 } 554 555 return (err); 556 } 557