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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <unistd.h> 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <stdarg.h> 30 #include <string.h> 31 #include <strings.h> 32 #include <limits.h> 33 #include <alloca.h> 34 #include <kstat.h> 35 #include <fcntl.h> 36 #include <errno.h> 37 #include <libnvpair.h> 38 #include <sys/types.h> 39 #include <sys/bitmap.h> 40 #include <sys/processor.h> 41 #include <sys/param.h> 42 #include <sys/fm/protocol.h> 43 #include <sys/systeminfo.h> 44 #include <sys/mc.h> 45 #include <sys/mc_amd.h> 46 #include <sys/mc_intel.h> 47 #include <fm/topo_mod.h> 48 49 #include "chip.h" 50 51 #ifndef MAX 52 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 53 #endif 54 55 static const topo_pgroup_info_t dimm_channel_pgroup = 56 { PGNAME(CHAN), TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; 57 static const topo_pgroup_info_t dimm_pgroup = 58 { PGNAME(DIMM), TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; 59 static const topo_pgroup_info_t rank_pgroup = 60 { PGNAME(RANK), TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; 61 static const topo_pgroup_info_t mc_pgroup = 62 { PGNAME(MCT), TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; 63 64 static const topo_method_t dimm_methods[] = { 65 { SIMPLE_DIMM_LBL, "Property method", 0, TOPO_STABILITY_INTERNAL, 66 simple_dimm_label}, 67 { SIMPLE_DIMM_LBL_MP, "Property method", 0, TOPO_STABILITY_INTERNAL, 68 simple_dimm_label_mp}, 69 { SEQ_DIMM_LBL, "Property method", 0, TOPO_STABILITY_INTERNAL, 70 seq_dimm_label}, 71 { NULL } 72 }; 73 74 extern const topo_method_t rank_methods[]; 75 extern const topo_method_t ntv_page_retire_methods[]; 76 77 static int mc_fd; 78 79 int 80 mc_offchip_open() 81 { 82 mc_fd = open("/dev/mc/mc", O_RDONLY); 83 return (mc_fd != -1); 84 } 85 86 static int 87 mc_onchip(topo_instance_t id) 88 { 89 char path[64]; 90 91 (void) snprintf(path, sizeof (path), "/dev/mc/mc%d", id); 92 mc_fd = open(path, O_RDONLY); 93 return (mc_fd != -1); 94 } 95 96 static void 97 mc_add_ranks(topo_mod_t *mod, tnode_t *dnode, nvlist_t *auth, int dimm, 98 nvlist_t **ranks_nvp, int start_rank, int nranks, char *serial, char *part, 99 char *rev, int maxranks) 100 { 101 int i; 102 int rank; 103 tnode_t *rnode; 104 nvpair_t *nvp; 105 nvlist_t *fmri; 106 int err = 0; 107 108 /* 109 * If start_rank is defined, it is assigned to the first rank of this 110 * dimm. 111 */ 112 rank = start_rank >= 0 ? start_rank : dimm * maxranks; 113 if (topo_node_range_create(mod, dnode, RANK, rank, 114 rank + nranks - 1) < 0) { 115 whinge(mod, NULL, "mc_add_ranks: node range create failed" 116 " for rank\n"); 117 return; 118 } 119 for (i = 0; i < nranks; i++) { 120 fmri = topo_mod_hcfmri(mod, dnode, FM_HC_SCHEME_VERSION, 121 RANK, rank, NULL, auth, part, rev, serial); 122 if (fmri == NULL) { 123 whinge(mod, NULL, 124 "mc_add_ranks: topo_mod_hcfmri failed\n"); 125 return; 126 } 127 if ((rnode = topo_node_bind(mod, dnode, RANK, rank, 128 fmri)) == NULL) { 129 nvlist_free(fmri); 130 whinge(mod, NULL, "mc_add_ranks: node bind failed" 131 " for ranks\n"); 132 return; 133 } 134 (void) topo_node_fru_set(rnode, NULL, 0, &err); 135 136 if (topo_method_register(mod, rnode, rank_methods) < 0) 137 whinge(mod, &err, "rank_create: " 138 "topo_method_register failed"); 139 140 if (! is_xpv() && topo_method_register(mod, rnode, 141 ntv_page_retire_methods) < 0) 142 whinge(mod, &err, "mc_add_ranks: " 143 "topo_method_register failed"); 144 145 (void) topo_node_asru_set(rnode, fmri, TOPO_ASRU_COMPUTE, &err); 146 147 if (FM_AWARE_SMBIOS(mod)) 148 (void) topo_node_label_set(rnode, NULL, &err); 149 150 nvlist_free(fmri); 151 152 (void) topo_pgroup_create(rnode, &rank_pgroup, &err); 153 for (nvp = nvlist_next_nvpair(ranks_nvp[i], NULL); nvp != NULL; 154 nvp = nvlist_next_nvpair(ranks_nvp[i], nvp)) { 155 (void) nvprop_add(mod, nvp, PGNAME(RANK), rnode); 156 } 157 rank++; 158 } 159 } 160 161 static void 162 mc_add_dimms(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode, 163 nvlist_t *auth, nvlist_t **nvl, uint_t ndimms, int maxdimms, int maxranks) 164 { 165 int i; 166 nvlist_t *fmri; 167 tnode_t *dnode; 168 nvpair_t *nvp; 169 int err; 170 nvlist_t **ranks_nvp; 171 int32_t start_rank = -1; 172 uint_t nranks = 0; 173 uint32_t dimm_number; 174 char *serial = NULL; 175 char *part = NULL; 176 char *rev = NULL; 177 char *label = NULL; 178 char *name; 179 id_t smbid; 180 181 if (topo_node_range_create(mod, pnode, DIMM, 0, 182 maxdimms ? maxdimms-1 : ndimms-1) < 0) { 183 whinge(mod, NULL, 184 "mc_add_dimms: node range create failed\n"); 185 return; 186 } 187 for (i = 0; i < ndimms; i++) { 188 dimm_number = i; 189 for (nvp = nvlist_next_nvpair(nvl[i], NULL); nvp != NULL; 190 nvp = nvlist_next_nvpair(nvl[i], nvp)) { 191 name = nvpair_name(nvp); 192 if (strcmp(name, MCINTEL_NVLIST_RANKS) == 0) { 193 (void) nvpair_value_nvlist_array(nvp, 194 &ranks_nvp, &nranks); 195 } else if (strcmp(name, MCINTEL_NVLIST_1ST_RANK) == 0) { 196 (void) nvpair_value_int32(nvp, &start_rank); 197 } else if (strcmp(name, FM_FMRI_HC_SERIAL_ID) == 0) { 198 (void) nvpair_value_string(nvp, &serial); 199 } else if (strcmp(name, FM_FMRI_HC_PART) == 0) { 200 (void) nvpair_value_string(nvp, &part); 201 } else if (strcmp(name, FM_FMRI_HC_REVISION) == 0) { 202 (void) nvpair_value_string(nvp, &rev); 203 } else if (strcmp(name, FM_FAULT_FRU_LABEL) == 0) { 204 (void) nvpair_value_string(nvp, &label); 205 } else if (strcmp(name, MCINTEL_NVLIST_DIMM_NUM) == 0) { 206 (void) nvpair_value_uint32(nvp, &dimm_number); 207 } 208 } 209 fmri = NULL; 210 211 if (FM_AWARE_SMBIOS(mod)) { 212 int channum; 213 214 channum = topo_node_instance(pnode); 215 smbid = memnode_to_smbiosid(mod, chip_smbid, 216 DIMM_NODE_NAME, i, &channum); 217 if (serial == NULL) 218 serial = (char *)chip_serial_smbios_get(mod, 219 smbid); 220 if (part == NULL) 221 part = (char *)chip_part_smbios_get(mod, 222 smbid); 223 if (rev == NULL) 224 rev = (char *)chip_rev_smbios_get(mod, 225 smbid); 226 } 227 228 fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 229 DIMM, dimm_number, NULL, auth, part, rev, serial); 230 if (fmri == NULL) { 231 whinge(mod, NULL, 232 "mc_add_dimms: topo_mod_hcfmri failed\n"); 233 return; 234 } 235 if ((dnode = topo_node_bind(mod, pnode, DIMM, dimm_number, 236 fmri)) == NULL) { 237 nvlist_free(fmri); 238 whinge(mod, NULL, "mc_add_dimms: node bind failed" 239 " for dimm\n"); 240 return; 241 } 242 243 if (!FM_AWARE_SMBIOS(mod)) 244 if (topo_method_register(mod, dnode, dimm_methods) < 0) 245 whinge(mod, NULL, "mc_add_dimms: " 246 "topo_method_register failed"); 247 248 (void) topo_pgroup_create(dnode, &dimm_pgroup, &err); 249 250 for (nvp = nvlist_next_nvpair(nvl[i], NULL); nvp != NULL; 251 nvp = nvlist_next_nvpair(nvl[i], nvp)) { 252 name = nvpair_name(nvp); 253 if (strcmp(name, MCINTEL_NVLIST_RANKS) != 0 && 254 strcmp(name, FM_FAULT_FRU_LABEL) != 0 && 255 strcmp(name, MCINTEL_NVLIST_1ST_RANK) != 0) { 256 (void) nvprop_add(mod, nvp, PGNAME(DIMM), 257 dnode); 258 } 259 } 260 261 if (FM_AWARE_SMBIOS(mod)) { 262 nvlist_free(fmri); 263 (void) topo_node_resource(dnode, &fmri, &err); 264 /* 265 * We will use a full absolute parent/child label 266 */ 267 label = (char *)chip_label_smbios_get(mod, 268 pnode, smbid, label); 269 } 270 271 (void) topo_node_label_set(dnode, label, &err); 272 273 if (FM_AWARE_SMBIOS(mod)) 274 topo_mod_strfree(mod, label); 275 276 (void) topo_node_fru_set(dnode, fmri, 0, &err); 277 (void) topo_node_asru_set(dnode, fmri, 0, &err); 278 nvlist_free(fmri); 279 280 if (nranks) { 281 mc_add_ranks(mod, dnode, auth, dimm_number, ranks_nvp, 282 start_rank, nranks, serial, part, rev, maxranks); 283 } 284 } 285 } 286 287 static int 288 mc_add_channel(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode, 289 int channel, nvlist_t *auth, nvlist_t *nvl, int maxdimms, int maxranks) 290 { 291 tnode_t *mc_channel; 292 nvlist_t *fmri; 293 nvlist_t **dimm_nvl; 294 nvpair_t *nvp; 295 char *name; 296 uint_t ndimms; 297 int err; 298 299 if (mkrsrc(mod, pnode, DRAMCHANNEL, channel, auth, &fmri) != 0) { 300 whinge(mod, NULL, "mc_add_channel: mkrsrc failed\n"); 301 return (-1); 302 } 303 if ((mc_channel = topo_node_bind(mod, pnode, DRAMCHANNEL, channel, 304 fmri)) == NULL) { 305 whinge(mod, NULL, "mc_add_channel: node bind failed for %s\n", 306 DRAMCHANNEL); 307 nvlist_free(fmri); 308 return (-1); 309 } 310 (void) topo_node_fru_set(mc_channel, NULL, 0, &err); 311 nvlist_free(fmri); 312 (void) topo_pgroup_create(mc_channel, &dimm_channel_pgroup, &err); 313 314 if (FM_AWARE_SMBIOS(mod)) 315 (void) topo_node_label_set(mc_channel, NULL, &err); 316 317 if (nvlist_lookup_nvlist_array(nvl, MCINTEL_NVLIST_DIMMS, &dimm_nvl, 318 &ndimms) == 0) { 319 mc_add_dimms(mod, chip_smbid, mc_channel, auth, dimm_nvl, 320 ndimms, maxdimms, maxranks); 321 } 322 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 323 nvp = nvlist_next_nvpair(nvl, nvp)) { 324 name = nvpair_name(nvp); 325 if (strcmp(name, MCINTEL_NVLIST_DIMMS) != 0) { 326 (void) nvprop_add(mod, nvp, PGNAME(CHAN), 327 mc_channel); 328 } 329 } 330 331 return (0); 332 } 333 334 static int 335 mc_nb_create(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode, 336 const char *name, nvlist_t *auth, nvlist_t *nvl) 337 { 338 int err; 339 int i, j; 340 int channel; 341 uint8_t nmc; 342 uint8_t maxranks; 343 uint8_t maxdimms; 344 tnode_t *mcnode; 345 nvlist_t *fmri; 346 nvlist_t **channel_nvl; 347 nvpair_t *nvp; 348 char *pname; 349 uint_t nchannels; 350 351 if (nvlist_lookup_nvlist_array(nvl, MCINTEL_NVLIST_MC, &channel_nvl, 352 &nchannels) != 0) { 353 whinge(mod, NULL, 354 "mc_nb_create: failed to find channel information\n"); 355 return (-1); 356 } 357 if (nvlist_lookup_uint8(nvl, MCINTEL_NVLIST_NMEM, &nmc) == 0) { 358 /* 359 * Assume channels are evenly divided among the controllers. 360 * Convert nchannels to channels per controller 361 */ 362 nchannels = nchannels / nmc; 363 } else { 364 /* 365 * if number of memory controllers is not specified then there 366 * are two channels per controller and the nchannels is total 367 * we will set up nmc as number of controllers and convert 368 * nchannels to channels per controller 369 */ 370 nmc = nchannels / 2; 371 nchannels = nchannels / nmc; 372 } 373 if (nvlist_lookup_uint8(nvl, MCINTEL_NVLIST_NRANKS, &maxranks) != 0) 374 maxranks = 2; 375 if (nvlist_lookup_uint8(nvl, MCINTEL_NVLIST_NDIMMS, &maxdimms) != 0) 376 maxdimms = 0; 377 if (topo_node_range_create(mod, pnode, name, 0, nmc-1) < 0) { 378 whinge(mod, NULL, 379 "mc_nb_create: node range create failed\n"); 380 return (-1); 381 } 382 channel = 0; 383 for (i = 0; i < nmc; i++) { 384 if (mkrsrc(mod, pnode, name, i, auth, &fmri) != 0) { 385 whinge(mod, NULL, "mc_nb_create: mkrsrc failed\n"); 386 return (-1); 387 } 388 if ((mcnode = topo_node_bind(mod, pnode, name, i, 389 fmri)) == NULL) { 390 whinge(mod, NULL, "mc_nb_create: node bind failed" 391 " for memory-controller\n"); 392 nvlist_free(fmri); 393 return (-1); 394 } 395 396 (void) topo_node_fru_set(mcnode, NULL, 0, &err); 397 nvlist_free(fmri); 398 (void) topo_pgroup_create(mcnode, &mc_pgroup, &err); 399 400 if (FM_AWARE_SMBIOS(mod)) 401 (void) topo_node_label_set(mcnode, NULL, &err); 402 403 if (topo_node_range_create(mod, mcnode, DRAMCHANNEL, channel, 404 channel + nchannels - 1) < 0) { 405 whinge(mod, NULL, 406 "mc_nb_create: channel node range create failed\n"); 407 return (-1); 408 } 409 for (j = 0; j < nchannels; j++) { 410 if (mc_add_channel(mod, chip_smbid, mcnode, channel, 411 auth, channel_nvl[channel], maxdimms, 412 maxranks) < 0) { 413 return (-1); 414 } 415 channel++; 416 } 417 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 418 nvp = nvlist_next_nvpair(nvl, nvp)) { 419 pname = nvpair_name(nvp); 420 if (strcmp(pname, MCINTEL_NVLIST_MC) != 0 && 421 strcmp(pname, MCINTEL_NVLIST_NMEM) != 0 && 422 strcmp(pname, MCINTEL_NVLIST_NRANKS) != 0 && 423 strcmp(pname, MCINTEL_NVLIST_NDIMMS) != 0 && 424 strcmp(pname, MCINTEL_NVLIST_VERSTR) != 0 && 425 strcmp(pname, MCINTEL_NVLIST_MEM) != 0) { 426 (void) nvprop_add(mod, nvp, PGNAME(MCT), 427 mcnode); 428 } 429 } 430 } 431 432 return (0); 433 } 434 435 int 436 mc_node_create(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode, 437 const char *name, nvlist_t *auth) 438 { 439 mc_snapshot_info_t mcs; 440 void *buf = NULL; 441 nvlist_t *nvl; 442 uint8_t ver; 443 int rc; 444 445 if (ioctl(mc_fd, MC_IOC_SNAPSHOT_INFO, &mcs) == -1 || 446 (buf = topo_mod_alloc(mod, mcs.mcs_size)) == NULL || 447 ioctl(mc_fd, MC_IOC_SNAPSHOT, buf) == -1) { 448 449 whinge(mod, NULL, "mc failed to snapshot %s\n", 450 strerror(errno)); 451 452 free(buf); 453 (void) close(mc_fd); 454 return (0); 455 } 456 (void) close(mc_fd); 457 (void) nvlist_unpack(buf, mcs.mcs_size, &nvl, 0); 458 topo_mod_free(mod, buf, mcs.mcs_size); 459 460 if (nvlist_lookup_uint8(nvl, MCINTEL_NVLIST_VERSTR, &ver) != 0) { 461 whinge(mod, NULL, "mc nvlist is not versioned\n"); 462 nvlist_free(nvl); 463 return (0); 464 } else if (ver != MCINTEL_NVLIST_VERS0) { 465 whinge(mod, NULL, "mc nvlist version mismatch\n"); 466 nvlist_free(nvl); 467 return (0); 468 } 469 470 rc = mc_nb_create(mod, chip_smbid, pnode, name, auth, nvl); 471 472 nvlist_free(nvl); 473 return (rc); 474 } 475 476 void 477 onchip_mc_create(topo_mod_t *mod, uint16_t chip_smbid, tnode_t *pnode, 478 const char *name, nvlist_t *auth) 479 { 480 if (mc_onchip(topo_node_instance(pnode))) 481 (void) mc_node_create(mod, chip_smbid, pnode, name, auth); 482 } 483 484 int 485 mc_offchip_create(topo_mod_t *mod, tnode_t *pnode, const char *name, 486 nvlist_t *auth) 487 { 488 return (mc_node_create(mod, IGNORE_ID, pnode, name, auth)); 489 } 490