usr/src/uts/sun4u/os/mach_ddi_impl.c

   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 }