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 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * sun4u specific DDI implementation 29 */ 30 #include <sys/bootconf.h> 31 #include <sys/conf.h> 32 #include <sys/ddi_subrdefs.h> 33 #include <sys/ethernet.h> 34 #include <sys/idprom.h> 35 #include <sys/machsystm.h> 36 #include <sys/promif.h> 37 #include <sys/prom_plat.h> 38 #include <sys/sunndi.h> 39 #include <sys/systeminfo.h> 40 #include <sys/fpu/fpusystm.h> 41 #include <sys/vm.h> 42 #include <sys/fs/dv_node.h> 43 #include <sys/fs/snode.h> 44 45 /* 46 * Favored drivers of this implementation 47 * architecture. These drivers MUST be present for 48 * the system to boot at all. 49 */ 50 char *impl_module_list[] = { 51 "rootnex", 52 "options", 53 "sad", /* Referenced via init_tbl[] */ 54 "pseudo", 55 "clone", 56 "scsi_vhci", 57 (char *)0 58 }; 59 60 /* 61 * These strings passed to not_serviced in locore.s 62 */ 63 const char busname_ovec[] = "onboard "; 64 const char busname_svec[] = "SBus "; 65 const char busname_vec[] = ""; 66 67 68 static uint64_t *intr_map_reg[32]; 69 70 /* 71 * Forward declarations 72 */ 73 static int getlongprop_buf(); 74 static int get_boardnum(int nid, dev_info_t *par); 75 76 /* 77 * Check the status of the device node passed as an argument. 78 * 79 * if ((status is OKAY) || (status is DISABLED)) 80 * return DDI_SUCCESS 81 * else 82 * print a warning and return DDI_FAILURE 83 */ 84 /*ARGSUSED*/ 85 int 86 check_status(int id, char *buf, dev_info_t *parent) 87 { 88 char status_buf[64]; 89 char devtype_buf[OBP_MAXPROPNAME]; 90 char board_buf[32]; 91 char path[OBP_MAXPATHLEN]; 92 int boardnum; 93 int retval = DDI_FAILURE; 94 extern int status_okay(int, char *, int); 95 96 /* 97 * is the status okay? 98 */ 99 if (status_okay(id, status_buf, sizeof (status_buf))) 100 return (DDI_SUCCESS); 101 102 /* 103 * a status property indicating bad memory will be associated 104 * with a node which has a "device_type" property with a value of 105 * "memory-controller". in this situation, return DDI_SUCCESS 106 */ 107 if (getlongprop_buf(id, OBP_DEVICETYPE, devtype_buf, 108 sizeof (devtype_buf)) > 0) { 109 if (strcmp(devtype_buf, "memory-controller") == 0) 110 retval = DDI_SUCCESS; 111 } 112 113 /* 114 * get the full OBP pathname of this node 115 */ 116 if (prom_phandle_to_path((phandle_t)id, path, sizeof (path)) < 0) 117 cmn_err(CE_WARN, "prom_phandle_to_path(%d) failed", id); 118 119 /* 120 * get the board number, if one exists 121 */ 122 if ((boardnum = get_boardnum(id, parent)) >= 0) 123 (void) sprintf(board_buf, " on board %d", boardnum); 124 else 125 board_buf[0] = '\0'; 126 127 /* 128 * print the status property information 129 */ 130 cmn_err(CE_WARN, "status '%s' for '%s'%s", 131 status_buf, path, board_buf); 132 return (retval); 133 } 134 135 /* 136 * determine the board number associated with this nodeid 137 */ 138 static int 139 get_boardnum(int nid, dev_info_t *par) 140 { 141 int board_num; 142 143 if (prom_getprop((pnode_t)nid, OBP_BOARDNUM, 144 (caddr_t)&board_num) != -1) 145 return (board_num); 146 147 /* 148 * Look at current node and up the parent chain 149 * till we find a node with an OBP_BOARDNUM. 150 */ 151 while (par) { 152 nid = ddi_get_nodeid(par); 153 154 if (prom_getprop((pnode_t)nid, OBP_BOARDNUM, 155 (caddr_t)&board_num) != -1) 156 return (board_num); 157 158 par = ddi_get_parent(par); 159 } 160 return (-1); 161 } 162 163 /* 164 * Note that this routine does not take into account the endianness 165 * of the host or the device (or PROM) when retrieving properties. 166 */ 167 static int 168 getlongprop_buf(int id, char *name, char *buf, int maxlen) 169 { 170 int size; 171 172 size = prom_getproplen((pnode_t)id, name); 173 if (size <= 0 || (size > maxlen - 1)) 174 return (-1); 175 176 if (-1 == prom_getprop((pnode_t)id, name, buf)) 177 return (-1); 178 179 /* 180 * Workaround for bugid 1085575 - OBP may return a "name" property 181 * without null terminating the string with '\0'. When this occurs, 182 * append a '\0' and return (size + 1). 183 */ 184 if (strcmp("name", name) == 0) { 185 if (buf[size - 1] != '\0') { 186 buf[size] = '\0'; 187 size += 1; 188 } 189 } 190 191 return (size); 192 } 193 194 /* 195 * Routines to set/get UPA slave only device interrupt mapping registers. 196 * set_intr_mapping_reg() is called by the UPA master to register the address 197 * of an interrupt mapping register. The upa id is that of the master. If 198 * this routine is called on behalf of a slave device, the framework 199 * determines the upa id of the slave based on that supplied by the master. 200 * 201 * get_intr_mapping_reg() is called by the UPA nexus driver on behalf 202 * of a child device to get and program the interrupt mapping register of 203 * one of it's child nodes. It uses the upa id of the child device to 204 * index into a table of mapping registers. If the routine is called on 205 * behalf of a slave device and the mapping register has not been set, 206 * the framework determines the devinfo node of the corresponding master 207 * nexus which owns the mapping register of the slave and installs that 208 * driver. The device driver which owns the mapping register must call 209 * set_intr_mapping_reg() in its attach routine to register the slaves 210 * mapping register with the system. 211 */ 212 void 213 set_intr_mapping_reg(int upaid, uint64_t *addr, int slave) 214 { 215 int affin_upaid; 216 217 /* For UPA master devices, set the mapping reg addr and we're done */ 218 if (slave == 0) { 219 intr_map_reg[upaid] = addr; 220 return; 221 } 222 223 /* 224 * If we get here, we're adding an entry for a UPA slave only device. 225 * The UPA id of the device which has affinity with that requesting, 226 * will be the device with the same UPA id minus the slave number. 227 * If the affin_upaid is negative, silently return to the caller. 228 */ 229 if ((affin_upaid = upaid - slave) < 0) 230 return; 231 232 /* 233 * Load the address of the mapping register in the correct slot 234 * for the slave device. 235 */ 236 intr_map_reg[affin_upaid] = addr; 237 } 238 239 uint64_t * 240 get_intr_mapping_reg(int upaid, int slave) 241 { 242 int affin_upaid; 243 dev_info_t *affin_dip; 244 uint64_t *addr = intr_map_reg[upaid]; 245 246 /* If we're a UPA master, or we have a valid mapping register. */ 247 if (!slave || addr != NULL) 248 return (addr); 249 250 /* 251 * We only get here if we're a UPA slave only device whose interrupt 252 * mapping register has not been set. 253 * We need to try and install the nexus whose physical address 254 * space is where the slaves mapping register resides. They 255 * should call set_intr_mapping_reg() in their xxattach() to register 256 * the mapping register with the system. 257 */ 258 259 /* 260 * We don't know if a single- or multi-interrupt proxy is fielding 261 * our UPA slave interrupt, we must check both cases. 262 * Start out by assuming the multi-interrupt case. 263 * We assume that single- and multi- interrupters are not 264 * overlapping in UPA portid space. 265 */ 266 267 affin_upaid = upaid | 3; 268 269 /* 270 * We start looking for the multi-interrupter affinity node. 271 * We know it's ONLY a child of the root node since the root 272 * node defines UPA space. 273 */ 274 for (affin_dip = ddi_get_child(ddi_root_node()); affin_dip; 275 affin_dip = ddi_get_next_sibling(affin_dip)) 276 if (ddi_prop_get_int(DDI_DEV_T_ANY, affin_dip, 277 DDI_PROP_DONTPASS, "upa-portid", -1) == affin_upaid) 278 break; 279 280 if (affin_dip) { 281 if (i_ddi_attach_node_hierarchy(affin_dip) == DDI_SUCCESS) { 282 /* try again to get the mapping register. */ 283 addr = intr_map_reg[upaid]; 284 } 285 } 286 287 /* 288 * If we still don't have a mapping register try single -interrupter 289 * case. 290 */ 291 if (addr == NULL) { 292 293 affin_upaid = upaid | 1; 294 295 for (affin_dip = ddi_get_child(ddi_root_node()); affin_dip; 296 affin_dip = ddi_get_next_sibling(affin_dip)) 297 if (ddi_prop_get_int(DDI_DEV_T_ANY, affin_dip, 298 DDI_PROP_DONTPASS, "upa-portid", -1) == affin_upaid) 299 break; 300 301 if (affin_dip) { 302 if (i_ddi_attach_node_hierarchy(affin_dip) 303 == DDI_SUCCESS) { 304 /* try again to get the mapping register. */ 305 addr = intr_map_reg[upaid]; 306 } 307 } 308 } 309 return (addr); 310 } 311 312 313 static struct upa_dma_pfns { 314 pfn_t hipfn; 315 pfn_t lopfn; 316 } upa_dma_pfn_array[MAX_UPA]; 317 318 static int upa_dma_pfn_ndx = 0; 319 320 /* 321 * Certain UPA busses cannot accept dma transactions from any other source 322 * except for memory due to livelock conditions in their hardware. (e.g. sbus 323 * and PCI). These routines allow devices or busses on the UPA to register 324 * a physical address block within it's own register space where DMA can be 325 * performed. Currently, the FFB is the only such device which supports 326 * device DMA on the UPA. 327 */ 328 void 329 pf_set_dmacapable(pfn_t hipfn, pfn_t lopfn) 330 { 331 int i = upa_dma_pfn_ndx; 332 333 upa_dma_pfn_ndx++; 334 335 upa_dma_pfn_array[i].hipfn = hipfn; 336 upa_dma_pfn_array[i].lopfn = lopfn; 337 } 338 339 void 340 pf_unset_dmacapable(pfn_t pfn) 341 { 342 int i; 343 344 for (i = 0; i < upa_dma_pfn_ndx; i++) { 345 if (pfn <= upa_dma_pfn_array[i].hipfn && 346 pfn >= upa_dma_pfn_array[i].lopfn) { 347 upa_dma_pfn_array[i].hipfn = 348 upa_dma_pfn_array[upa_dma_pfn_ndx - 1].hipfn; 349 upa_dma_pfn_array[i].lopfn = 350 upa_dma_pfn_array[upa_dma_pfn_ndx - 1].lopfn; 351 upa_dma_pfn_ndx--; 352 break; 353 } 354 } 355 } 356 357 /* 358 * This routine should only be called using a pfn that is known to reside 359 * in IO space. The function pf_is_memory() can be used to determine this. 360 */ 361 int 362 pf_is_dmacapable(pfn_t pfn) 363 { 364 int i, j; 365 366 /* If the caller passed in a memory pfn, return true. */ 367 if (pf_is_memory(pfn)) 368 return (1); 369 370 for (i = upa_dma_pfn_ndx, j = 0; j < i; j++) 371 if (pfn <= upa_dma_pfn_array[j].hipfn && 372 pfn >= upa_dma_pfn_array[j].lopfn) 373 return (1); 374 375 return (0); 376 } 377 378 379 /* 380 * Find cpu_id corresponding to the dip of a CPU device node 381 */ 382 int 383 dip_to_cpu_id(dev_info_t *dip, processorid_t *cpu_id) 384 { 385 pnode_t nodeid; 386 int i; 387 388 nodeid = (pnode_t)ddi_get_nodeid(dip); 389 for (i = 0; i < NCPU; i++) { 390 if (cpunodes[i].nodeid == nodeid) { 391 *cpu_id = i; 392 return (DDI_SUCCESS); 393 } 394 } 395 return (DDI_FAILURE); 396 } 397 398 /* ARGSUSED */ 399 void 400 translate_devid(dev_info_t *dip) 401 { 402 } 403