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  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 /*
  26  * The InfiniBand  Nexus driver (IB nexus) is a bus nexus driver for IB bus.
  27  * It supports  Port nodes, Virtual Physical Point of Attachment nodes (VPPA)
  28  * for  HCAs registered with IBTL and IOC nodes for all the IOCs present in
  29  * the IB fabric (that are accessible to the host). It also supports Pseudo
  30  * device children to be enumerated using their .conf file(s). All Port nodes
  31  * and VPPA nodes are children of HCA drivers. All the IOC nodes and the Pseudo
  32  * device nodes are children of the IB nexus driver.
  33  *
  34  * IB nexus driver provides bus nexus entry points to all the HCA drivers.
  35  *
  36  * IB nexus  driver registers with  InfiniBand Device  Manager (IBDM) to get
  37  * information about all the HCA ports and  I/O Controllers (IOCs) connected
  38  * to the IB fabric. Based on that information, IB nexus will create all the
  39  * device tree nodes.
  40  */
  41 
  42 #include <sys/conf.h>
  43 #include <sys/stat.h>
  44 #include <sys/modctl.h>
  45 #include <sys/taskq.h>
  46 #include <sys/mdi_impldefs.h>
  47 #include <sys/sunmdi.h>
  48 #include <sys/sunpm.h>
  49 #include <sys/ib/mgt/ibdm/ibdm_impl.h>
  50 #include <sys/ib/ibnex/ibnex.h>
  51 #include <sys/ib/ibnex/ibnex_devctl.h>
  52 #include <sys/ib/ibtl/ibti.h>
  53 #include <sys/ib/ibtl/impl/ibtl_ibnex.h>
  54 #include <sys/file.h>
  55 #include <sys/hwconf.h>
  56 #include <sys/fs/dv_node.h>
  57 
  58 /* Function prototypes */
  59 static int              ibnex_attach(dev_info_t *, ddi_attach_cmd_t);
  60 static int              ibnex_getinfo(dev_info_t *, ddi_info_cmd_t,
  61                             void *, void **);
  62 static int              ibnex_detach(dev_info_t *, ddi_detach_cmd_t);
  63 int                     ibnex_busctl(dev_info_t *,
  64                             dev_info_t *, ddi_ctl_enum_t, void *, void *);
  65 int                     ibnex_map_fault(dev_info_t *,
  66                             dev_info_t *, struct hat *, struct seg *,
  67                             caddr_t, struct devpage *, pfn_t, uint_t, uint_t);
  68 static int              ibnex_init_child(dev_info_t *);
  69 static ibnex_rval_t     ibnex_comm_svc_init(char *, ibnex_node_type_t);
  70 static void             ibnex_comm_svc_fini();
  71 dev_info_t              *ibnex_commsvc_initnode(dev_info_t *,
  72                             ibdm_port_attr_t *, int, int, ib_pkey_t, int *,
  73                             int);
  74 static void             ibnex_delete_port_node_data(ibnex_node_data_t *);
  75 int                     ibnex_get_dip_from_guid(ib_guid_t, int,
  76                             ib_pkey_t, dev_info_t **);
  77 int                     ibnex_get_node_and_dip_from_guid(ib_guid_t, int,
  78                             ib_pkey_t, ibnex_node_data_t **, dev_info_t **);
  79 static ibnex_node_data_t *ibnex_is_node_data_present(ibnex_node_type_t,
  80                             void *, int, ib_pkey_t);
  81 static ibnex_node_data_t *ibnex_init_child_nodedata(ibnex_node_type_t, void *,
  82                             int, ib_pkey_t);
  83 static int              ibnex_create_port_node_prop(ibdm_port_attr_t *,
  84                             dev_info_t *, char *, ib_pkey_t);
  85 void                    ibnex_dm_callback(void *, ibdm_events_t);
  86 static int              ibnex_create_port_compatible_prop(dev_info_t *,
  87                             char *, ibdm_port_attr_t *);
  88 static int              ibnex_create_ioc_srv_props(
  89                             dev_info_t *, ibdm_ioc_info_t *);
  90 static int              ibnex_get_eventcookie(dev_info_t *,
  91                             dev_info_t *, char *, ddi_eventcookie_t *);
  92 static int              ibnex_add_eventcall(dev_info_t *, dev_info_t *,
  93                             ddi_eventcookie_t, void (*)(dev_info_t *,
  94                             ddi_eventcookie_t, void *, void *),
  95                             void *arg, ddi_callback_id_t *cb_id);
  96 static int              ibnex_remove_eventcall(dev_info_t *,
  97                             ddi_callback_id_t);
  98 static int              ibnex_post_event(dev_info_t *, dev_info_t *,
  99                             ddi_eventcookie_t, void *);
 100 static int              ibnex_bus_config(dev_info_t *, uint_t,
 101                             ddi_bus_config_op_t, void *, dev_info_t **);
 102 static int              ibnex_bus_unconfig(dev_info_t *,
 103                             uint_t, ddi_bus_config_op_t, void *);
 104 dev_info_t      *ibnex_config_port_node(dev_info_t *, char *);
 105 int             ibnex_get_pkey_commsvc_index_portnum(
 106                             char *, int *, ib_pkey_t *, uint8_t *);
 107 void            ibnex_config_all_children(dev_info_t *);
 108 static int              ibnex_devname_to_portnum(char *, uint8_t *);
 109 void            ibnex_create_vppa_nodes(dev_info_t *, ibdm_port_attr_t *);
 110 void            ibnex_create_port_nodes(
 111                             dev_info_t *, ibdm_port_attr_t *);
 112 void            ibnex_create_hcasvc_nodes(
 113                             dev_info_t *, ibdm_port_attr_t *);
 114 static int              ibnex_config_root_iocnode(dev_info_t *, char *);
 115 static int              ibnex_devname2port(char *, int *);
 116 static int              ibnex_config_ioc_node(char *, dev_info_t *);
 117 static int              ibnex_devname_to_node_n_ioc_guids(
 118                             char *, ib_guid_t *, ib_guid_t *, char **);
 119 static void             ibnex_ioc_node_cleanup();
 120 static void             ibnex_delete_ioc_node_data(ibnex_node_data_t *);
 121 int                     ibnex_ioc_initnode_all_pi(ibdm_ioc_info_t *);
 122 static int              ibnex_ioc_initnode_pdip(ibnex_node_data_t *,
 123                             ibdm_ioc_info_t *, dev_info_t *);
 124 static int              ibnex_create_ioc_node_prop(
 125                             ibdm_ioc_info_t *, dev_info_t *);
 126 static int              ibnex_create_ioc_compatible_prop(
 127                             dev_info_t *, ib_dm_ioc_ctrl_profile_t *);
 128 uint64_t                ibnex_str2hex(char *, int, int *);
 129 int             ibnex_str2int(char *, int, int *);
 130 static int              ibnex_create_ioc_portgid_prop(
 131                             dev_info_t *, ibdm_ioc_info_t *);
 132 static void             ibnex_wakeup_reprobe_ioc(ibnex_node_data_t *, int);
 133 static void             ibnex_wakeup_reprobe_all();
 134 ibt_status_t            ibnex_ibtl_callback(ibtl_ibnex_cb_args_t *);
 135 void                    ibnex_pseudo_initnodes(void);
 136 static char             *ibnex_lookup_named_prop(ddi_prop_t *, char *);
 137 static void             ibnex_pseudo_node_cleanup(void);
 138 static int              ibnex_name_child(dev_info_t *, char *, int);
 139 static int              ibnex_name_pseudo_child(dev_info_t *, char *);
 140 
 141 void                    ibnex_reprobe_ioc_dev(void *);
 142 void                    ibnex_reprobe_ioc_all();
 143 static void             ibnex_update_prop(ibnex_node_data_t *,
 144                             ibdm_ioc_info_t *);
 145 static ibnex_rval_t     ibnex_unique_svcname(char *);
 146 static void             ibnex_handle_reprobe_dev(void *arg);
 147 
 148 extern int              ibnex_open(dev_t *, int, int, cred_t *);
 149 extern int              ibnex_close(dev_t, int, int, cred_t *);
 150 extern int              ibnex_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 151 extern int              ibnex_offline_childdip(dev_info_t *);
 152 
 153 static int              ibnex_ioc_create_pi(
 154                             ibdm_ioc_info_t *, ibnex_node_data_t *,
 155                             dev_info_t *, int *);
 156 static int              ibnex_bus_power(dev_info_t *, void *,
 157                             pm_bus_power_op_t, void *, void *);
 158 int                     ibnex_pseudo_create_all_pi(ibnex_node_data_t *);
 159 static int              ibnex_pseudo_create_pi_pdip(ibnex_node_data_t *,
 160                             dev_info_t *);
 161 int             ibnex_pseudo_config_one(
 162                             ibnex_node_data_t *, char *, dev_info_t *);
 163 int             ibnex_pseudo_mdi_config_one(int, void *, dev_info_t **,
 164                             char *, char *);
 165 static void             ibnex_config_pseudo_all(dev_info_t *);
 166 int             ibnex_ioc_bus_config_one(dev_info_t **, uint_t,
 167                             ddi_bus_config_op_t, void *, dev_info_t **, int *);
 168 static int              ibnex_is_merge_node(dev_info_t *);
 169 static void             ibnex_hw_in_dev_tree(char *);
 170 static int              ibnex_ioc_config_from_pdip(ibdm_ioc_info_t *,
 171     dev_info_t *, int);
 172 static int              ibnex_ioc_pi_exists(ibnex_node_data_t *, dev_info_t *);
 173 static int              ibnex_ioc_pi_reachable(ibdm_ioc_info_t *,
 174     dev_info_t *);
 175 
 176 extern void ibnex_handle_hca_attach(void *);
 177 
 178 extern struct bus_ops ibnex_ci_busops;
 179 /*
 180  * Prototype declarations for the VHCI options
 181  */
 182 /*
 183  * Functions registered with the mpxio framework
 184  */
 185 static int ib_vhci_pi_init(dev_info_t *, mdi_pathinfo_t *, int);
 186 static int ib_vhci_pi_uninit(dev_info_t *, mdi_pathinfo_t *, int);
 187 static int ib_vhci_pi_state_change(dev_info_t *, mdi_pathinfo_t *,
 188                 mdi_pathinfo_state_t, uint32_t, int);
 189 static int ib_vhci_failover(dev_info_t *, dev_info_t *, int);
 190 
 191 
 192 static mdi_vhci_ops_t ibnex_vhci_ops = {
 193         MDI_VHCI_OPS_REV,
 194         ib_vhci_pi_init,
 195         ib_vhci_pi_uninit,
 196         ib_vhci_pi_state_change,
 197         ib_vhci_failover
 198 };
 199 
 200 
 201 /*
 202  * The  bus_ops  structure  defines the  capabilities  of IB nexus driver.
 203  * IB nexus drivers does not  support any DMA  operations for its children
 204  * as there is  no  such concept in Infiniband.  All the memory operations
 205  * and DMA operations required by the child drivers can be performed using
 206  * the IBTF API.
 207  */
 208 struct bus_ops ibnex_bus_ops = {
 209         BUSO_REV,
 210         nullbusmap,             /* bus_map */
 211         NULL,                   /* bus_get_intrspec */
 212         NULL,                   /* bus_add_intrspec */
 213         NULL,                   /* bus_remove_intrspec */
 214         ibnex_map_fault,        /* Map Fault */
 215         ddi_no_dma_map,         /* DMA related entry points */
 216         ddi_no_dma_allochdl,
 217         NULL,
 218         NULL,
 219         NULL,
 220         NULL,
 221         NULL,
 222         NULL,
 223         ibnex_busctl,           /* bus_ctl */
 224         ddi_bus_prop_op,        /* bus_prop_op */
 225         ibnex_get_eventcookie,  /* bus_get_eventcookie  */
 226         ibnex_add_eventcall,    /* bus_add_eventcall    */
 227         ibnex_remove_eventcall, /* bus_remove_eventcall */
 228         ibnex_post_event,               /* bus_post_event       */
 229         NULL,
 230         ibnex_bus_config,       /* bus config */
 231         ibnex_bus_unconfig,     /* bus unconfig */
 232         NULL,                   /* bus fm init */
 233         NULL,                   /* bus fm fini */
 234         NULL,                   /* bus fm access enter */
 235         NULL,                   /* bus fm access exit */
 236         ibnex_bus_power         /* bus power */
 237 };
 238 
 239 /* ibnex cb_ops */
 240 static struct cb_ops ibnex_cbops = {
 241         ibnex_open,             /* open */
 242         ibnex_close,            /* close */
 243         nodev,                  /* strategy */
 244         nodev,                  /* print */
 245         nodev,                  /* dump */
 246         nodev,                  /* read */
 247         nodev,                  /* write */
 248         ibnex_ioctl,            /* ioctl */
 249         nodev,                  /* devmap */
 250         nodev,                  /* mmap */
 251         nodev,                  /* segmap */
 252         nochpoll,               /* poll */
 253         ddi_prop_op,            /* prop_op */
 254         NULL,                   /* stream */
 255         D_MP,                   /* cb_flag */
 256         CB_REV,                 /* rev */
 257         nodev,                  /* int (*cb_aread)() */
 258         nodev                   /* int (*cb_awrite)() */
 259 };
 260 
 261 /*
 262  * Device options
 263  * Note: ddi_no_info needs to change during devfs time frame. The drivers
 264  *       with 1 to 1 mapping between minor node and instance should use
 265  *       ddi_1to1_info. (See bug id 4424752)
 266  */
 267 static struct dev_ops ibnex_ops = {
 268         DEVO_REV,               /* devo_rev, */
 269         0,                      /* refcnt  */
 270         ibnex_getinfo,          /* info */
 271         nulldev,                /* identify */
 272         nulldev,                /* probe */
 273         ibnex_attach,           /* attach */
 274         ibnex_detach,           /* detach */
 275         nodev,                  /* reset */
 276         &ibnex_cbops,               /* driver ops - devctl interfaces */
 277         &ibnex_bus_ops,             /* bus operations */
 278         nulldev,                /* power */
 279         ddi_quiesce_not_needed,         /* quiesce */
 280 };
 281 
 282 /* Module linkage information for the kernel.  */
 283 static struct modldrv modldrv = {
 284         &mod_driverops,             /* Driver module */
 285         "IB nexus",             /* Driver name and version */
 286         &ibnex_ops,         /* driver ops */
 287 };
 288 
 289 static struct modlinkage modlinkage = {
 290         MODREV_1, { (void *)&modldrv, NULL }
 291 };
 292 
 293 /*
 294  * Global per-instance IB Nexus data.
 295  * There is only one instance of IB Nexus supported.
 296  */
 297 ibnex_t ibnex;
 298 #ifdef __lock_lint
 299 extern ibdm_t ibdm;
 300 #endif
 301 _NOTE(MUTEX_PROTECTS_DATA(ibnex.ibnex_mutex, ibnex_s))
 302 _NOTE(DATA_READABLE_WITHOUT_LOCK(ibnex.ibnex_num_comm_svcs
 303         ibnex.ibnex_comm_svc_names ibnex.ibnex_nvppa_comm_svcs
 304         ibnex.ibnex_vppa_comm_svc_names ibnex.ibnex_nhcasvc_comm_svcs
 305         ibnex.ibnex_hcasvc_comm_svc_names ibnex.ibnex_ioc_list))
 306 _NOTE(MUTEX_PROTECTS_DATA(ibnex.ibnex_mutex, ibnex_node_data_s))
 307 _NOTE(LOCK_ORDER(ibdm.ibdm_hl_mutex ibnex.ibnex_mutex))
 308 
 309 /* The port settling time in seconds */
 310 int     ibnex_port_settling_time = 8;
 311 
 312 /* create an array of properties supported, easier to add new ones here */
 313 static struct ibnex_property {
 314         char                    *name;
 315         ibnex_node_type_t       type;
 316 } ibnex_properties[]  = {
 317         { "port-svc-list",  IBNEX_PORT_COMMSVC_NODE},
 318         { "vppa-svc-list",  IBNEX_VPPA_COMMSVC_NODE},
 319         { "hca-svc-list",       IBNEX_HCASVC_COMMSVC_NODE}
 320 };
 321 
 322 #define N_IBNEX_PROPS   (sizeof (ibnex_properties))/ \
 323                                 (sizeof (struct ibnex_property))
 324 
 325 /*
 326  * Event Definition
 327  *      Single event, event name defined in ibti_common.h.
 328  *      Event posted to specific child handler. Event posted
 329  *      at kernel priority.
 330  */
 331 static ndi_event_definition_t ibnex_ndi_event_defs[] = {
 332         {IB_EVENT_TAG_PROP_UPDATE,  IB_PROP_UPDATE_EVENT, EPL_KERNEL,
 333                 NDI_EVENT_POST_TO_TGT}
 334 };
 335 
 336 #define IB_N_NDI_EVENTS \
 337         (sizeof (ibnex_ndi_event_defs) / sizeof (ndi_event_definition_t))
 338 
 339 static ndi_event_set_t ib_ndi_events = {
 340         NDI_EVENTS_REV1, IB_N_NDI_EVENTS, ibnex_ndi_event_defs};
 341 static int      ibnex_hw_status = IBNEX_DEVTREE_NOT_CHECKED;
 342 
 343 
 344 /*
 345  * _init
 346  *      Loadable module init, called before any other module.
 347  */
 348 int
 349 _init(void)
 350 {
 351         int     error;
 352         char    **hca_driver_list;
 353         int     i, ndrivers;
 354 
 355         if (ibnex_hw_status == IBNEX_DEVTREE_NOT_CHECKED) {
 356                 ibnex_hw_status = IBNEX_HW_NOT_IN_DEVTREE;
 357                 hca_driver_list = mdi_get_phci_driver_list("ib", &ndrivers);
 358                 for (i = 0; i < ndrivers; i++) {
 359                         ibnex_hw_in_dev_tree(hca_driver_list[i]);
 360                         if (ibnex_hw_status == IBNEX_HW_IN_DEVTREE)
 361                                 break;
 362                 }
 363                 mdi_free_phci_driver_list(hca_driver_list, ndrivers);
 364         }
 365 
 366         /*
 367          * IB Nexus _init can be called while force attaching
 368          * IB Nexus driver or when a HCA is hotplugged.
 369          *
 370          * If IB HW is not in device tree or if no HCA driver
 371          * has been attached, fail IB Nexus _init().
 372          */
 373         if (ibnex_hw_status == IBNEX_HW_NOT_IN_DEVTREE &&
 374             ibt_hw_is_present() == 0) {
 375                 IBTF_DPRINTF_L4("ibnex", "\t_init: NO IB HW");
 376                 return (DDI_FAILURE);
 377         }
 378 
 379         IBTF_DPRINTF_L4("ibnex", "\t_init");
 380         mutex_init(&ibnex.ibnex_mutex, NULL, MUTEX_DRIVER, NULL);
 381         cv_init(&ibnex.ibnex_reprobe_cv, NULL, CV_DRIVER, NULL);
 382         cv_init(&ibnex.ibnex_ioc_list_cv, NULL, CV_DRIVER, NULL);
 383         if ((error = mod_install(&modlinkage)) != 0) {
 384                 IBTF_DPRINTF_L2("ibnex", "\t_init: mod_install failed");
 385                 mutex_destroy(&ibnex.ibnex_mutex);
 386                 cv_destroy(&ibnex.ibnex_reprobe_cv);
 387                 cv_destroy(&ibnex.ibnex_ioc_list_cv);
 388         } else {
 389                 ibdm_ibnex_register_callback(ibnex_dm_callback);
 390                 ibtl_ibnex_register_callback(ibnex_ibtl_callback);
 391         }
 392         return (error);
 393 }
 394 
 395 
 396 /*
 397  * _fini
 398  *      Prepares a module for unloading.
 399  */
 400 int
 401 _fini(void)
 402 {
 403         int     error;
 404 
 405         IBTF_DPRINTF_L4("ibnex", "\t_fini");
 406         if ((error = mod_remove(&modlinkage)) != 0) {
 407                 return (error);
 408         }
 409         ibdm_ibnex_unregister_callback();
 410         ibtl_ibnex_unregister_callback();
 411         mutex_destroy(&ibnex.ibnex_mutex);
 412         cv_destroy(&ibnex.ibnex_reprobe_cv);
 413         cv_destroy(&ibnex.ibnex_ioc_list_cv);
 414         return (0);
 415 }
 416 
 417 
 418 /*
 419  * _info
 420  *      Returns information about loadable module.
 421  */
 422 int
 423 _info(struct modinfo *modinfop)
 424 {
 425         IBTF_DPRINTF_L4("ibnex", "\t_info");
 426         return (mod_info(&modlinkage, modinfop));
 427 }
 428 
 429 
 430 /*
 431  * ibnex_attach
 432  *      Configure and attach an instance of the IB Nexus driver
 433  *      Only one instance of IB Nexus is supported
 434  *      Create a minor node for cfgadm purpose
 435  *      Initialize communication services
 436  *      Register callback with IBDM
 437  *      Register callback with IBTL
 438  */
 439 static int
 440 ibnex_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 441 {
 442         int             i;
 443         int             instance = ddi_get_instance(dip);
 444 
 445         IBTF_DPRINTF_L4("ibnex", "\tattach: device = %p cmd = %x)", dip, cmd);
 446 
 447         switch (cmd) {
 448         case DDI_ATTACH:
 449                 break;
 450         case DDI_RESUME:
 451                 IBTF_DPRINTF_L4("ibnex", "\tattach: RESUME");
 452                 return (DDI_SUCCESS);
 453         default:
 454                 return (DDI_FAILURE);
 455         }
 456 
 457         /* Fail attach for more than one instance */
 458         mutex_enter(&ibnex.ibnex_mutex);
 459         if (ibnex.ibnex_dip != NULL) {
 460                 mutex_exit(&ibnex.ibnex_mutex);
 461                 return (DDI_FAILURE);
 462         }
 463         mutex_exit(&ibnex.ibnex_mutex);
 464 
 465         /*
 466          * Create a IB nexus taskq
 467          */
 468 
 469         ibnex.ibnex_taskq_id = ddi_taskq_create(dip,
 470             "ibnex-enum-taskq", 1, TASKQ_DEFAULTPRI, 0);
 471         if (ibnex.ibnex_taskq_id == NULL) {
 472                 IBTF_DPRINTF_L2("ibnex",
 473                     "\tattach: ddi_taskq_create() failed");
 474                 return (DDI_FAILURE);
 475 
 476         }
 477 
 478         /* Register with MPxIO framework */
 479 
 480         if (mdi_vhci_register(MDI_HCI_CLASS_IB, dip, &ibnex_vhci_ops, 0)
 481             != MDI_SUCCESS) {
 482                 IBTF_DPRINTF_L2("ibnex",
 483                     "\tattach: mdi_vhci_register() failed");
 484                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 485                 ibnex.ibnex_taskq_id = NULL;
 486                 return (DDI_FAILURE);
 487         }
 488 
 489 
 490         /*
 491          * Create the "fabric" devctl minor-node for IB DR support.
 492          * The minor number for the "devctl" node is in the same format
 493          * as the AP minor nodes.
 494          */
 495         if (ddi_create_minor_node(dip, IBNEX_FABRIC, S_IFCHR, instance,
 496             DDI_NT_IB_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
 497                 IBTF_DPRINTF_L2("ibnex",
 498                     "\tattach: failed to create fabric minornode");
 499                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 500                 ibnex.ibnex_taskq_id = NULL;
 501                 (void) mdi_vhci_unregister(dip, 0);
 502                 return (DDI_FAILURE);
 503         }
 504 
 505         /*
 506          * Create "devctl" minor node for general ioctl interface to the
 507          * ib nexus.
 508          */
 509         if (ddi_create_minor_node(dip, "devctl", S_IFCHR, instance,
 510             DDI_NT_IB_NEXUS, 0) != DDI_SUCCESS) {
 511                 IBTF_DPRINTF_L2("ibnex",
 512                     "\tattach: failed to create devctl minornode");
 513                 (void) ddi_remove_minor_node(dip, NULL);
 514                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 515                 ibnex.ibnex_taskq_id = NULL;
 516                 (void) mdi_vhci_unregister(dip, 0);
 517                 return (DDI_FAILURE);
 518         }
 519 
 520         /*
 521          * Set pm-want-child-notification property for
 522          * power management of the phci and client
 523          */
 524         if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
 525             "pm-want-child-notification?", NULL, NULL) != DDI_PROP_SUCCESS) {
 526                 IBTF_DPRINTF_L2("ibnex",
 527                     "_attach: create pm-want-child-notification failed");
 528                 (void) ddi_remove_minor_node(dip, NULL);
 529                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 530                 ibnex.ibnex_taskq_id = NULL;
 531                 (void) mdi_vhci_unregister(dip, 0);
 532                 return (DDI_FAILURE);
 533         }
 534 
 535         mutex_enter(&ibnex.ibnex_mutex);
 536         ibnex.ibnex_dip  = dip;
 537         mutex_exit(&ibnex.ibnex_mutex);
 538 
 539         /*
 540          * Event Handling: Definition and Binding.
 541          */
 542         if (ndi_event_alloc_hdl(dip, 0, &ibnex.ibnex_ndi_event_hdl,
 543             NDI_SLEEP) != NDI_SUCCESS) {
 544                 IBTF_DPRINTF_L2("ibnex",
 545                     "_attach: ndi_event_alloc_hdl failed");
 546                 (void) ddi_remove_minor_node(dip, NULL);
 547                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 548                 ibnex.ibnex_taskq_id = NULL;
 549                 (void) mdi_vhci_unregister(dip, 0);
 550                 return (DDI_FAILURE);
 551         }
 552         if (ndi_event_bind_set(ibnex.ibnex_ndi_event_hdl, &ib_ndi_events,
 553             NDI_SLEEP) != NDI_SUCCESS) {
 554                 (void) ddi_remove_minor_node(dip, NULL);
 555                 (void) ndi_event_free_hdl(ibnex.ibnex_ndi_event_hdl);
 556                 IBTF_DPRINTF_L2("ibnex",
 557                     "_attach: ndi_event_bind_set failed");
 558                 (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 559                 ibnex.ibnex_taskq_id = NULL;
 560                 (void) mdi_vhci_unregister(dip, 0);
 561                 return (DDI_FAILURE);
 562         }
 563 
 564         for (i = 0; i < N_IBNEX_PROPS; i++) {
 565                 if (ibnex_comm_svc_init(ibnex_properties[i].name,
 566                     ibnex_properties[i].type) != IBNEX_SUCCESS) {
 567                         ibnex_comm_svc_fini();
 568                         (void) ndi_event_unbind_set(ibnex.ibnex_ndi_event_hdl,
 569                             &ib_ndi_events, NDI_SLEEP);
 570                         (void) ddi_remove_minor_node(dip, NULL);
 571                         (void) ndi_event_free_hdl(
 572                             ibnex.ibnex_ndi_event_hdl);
 573                         ibnex.ibnex_ndi_event_hdl = NULL;
 574                         IBTF_DPRINTF_L2("ibnex", "_attach: ibnex_comm_svc_init"
 575                             " failed %s", ibnex_properties[i].name);
 576                         (void) ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 577                         ibnex.ibnex_taskq_id = NULL;
 578                         (void) mdi_vhci_unregister(dip, 0);
 579                         return (DDI_FAILURE);
 580                 }
 581         }
 582 
 583         /*
 584          * before anything else comes up:
 585          * Initialize the internal list of pseudo device nodes by
 586          * getting all pseudo children of "ib" and processing them.
 587          */
 588         ibnex_pseudo_initnodes();
 589 
 590         return (DDI_SUCCESS);
 591 }
 592 
 593 
 594 /*
 595  * ibnex_getinfo()
 596  * Given the device number, return the devinfo pointer or the
 597  * instance number.
 598  * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach.
 599  */
 600 
 601 /*ARGSUSED*/
 602 static int
 603 ibnex_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 604 {
 605         int ret = DDI_SUCCESS;
 606 
 607         IBTF_DPRINTF_L4("ibnex", "\tgetinfo: Begin");
 608         switch (cmd) {
 609         case DDI_INFO_DEVT2DEVINFO:
 610                 if (ibnex.ibnex_dip != NULL)
 611                         *result = ibnex.ibnex_dip;
 612                 else {
 613                         *result = NULL;
 614                         ret = DDI_FAILURE;
 615                 }
 616                 break;
 617 
 618         case DDI_INFO_DEVT2INSTANCE:
 619                 *result = 0;
 620                 break;
 621 
 622         default:
 623                 ret = DDI_FAILURE;
 624         }
 625         return (ret);
 626 }
 627 
 628 
 629 /*
 630  * ibnex_detach
 631  *      Unregister callback with the IBDM
 632  *      Unregister callback with the IBTL
 633  *      Uninitialize the communication entries
 634  *      Remove all the minor nodes created by this instance
 635  */
 636 static int
 637 ibnex_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 638 {
 639 
 640         IBTF_DPRINTF_L4("ibnex", "\tdetach: dip = %p cmd = %x)", dip, cmd);
 641 
 642         switch (cmd) {
 643 
 644         case DDI_DETACH:
 645                 break;
 646         case DDI_SUSPEND:
 647                 IBTF_DPRINTF_L4("ibnex", "\t_detach: Suspend");
 648                 return (DDI_SUCCESS);
 649         default:
 650                 return (DDI_FAILURE);
 651         }
 652 
 653         mutex_enter(&ibnex.ibnex_mutex);
 654         if (ibt_hw_is_present()) {
 655                 IBTF_DPRINTF_L2("ibnex",
 656                     "\tdetach: IB HW is present ");
 657                 mutex_exit(&ibnex.ibnex_mutex);
 658                 return (DDI_FAILURE);
 659         }
 660         if (ndi_event_free_hdl(ibnex.ibnex_ndi_event_hdl)) {
 661                 IBTF_DPRINTF_L2("ibnex",
 662                     "\tdetach: ndi_event_free_hdl() failed");
 663                 mutex_exit(&ibnex.ibnex_mutex);
 664                 return (DDI_FAILURE);
 665         }
 666         ibnex.ibnex_ndi_event_hdl = NULL;
 667         ibnex.ibnex_prop_update_evt_cookie = NULL;
 668 
 669         ibnex_pseudo_node_cleanup();
 670         ibnex_comm_svc_fini();
 671         ibnex_ioc_node_cleanup();
 672 
 673         (void) ddi_remove_minor_node(dip, NULL);
 674         ibnex.ibnex_dip = NULL;
 675         mutex_exit(&ibnex.ibnex_mutex);
 676         (void) mdi_vhci_unregister(dip, 0);
 677 
 678         if (ibnex.ibnex_taskq_id != NULL) {
 679                 ddi_taskq_destroy(ibnex.ibnex_taskq_id);
 680                 ibnex.ibnex_taskq_id = NULL;
 681         }
 682 
 683         return (DDI_SUCCESS);
 684 }
 685 
 686 
 687 /*
 688  * ibnex_pseudo_node_cleanup()
 689  *      This checks if all the "dips" have been deallocated (implying
 690  *      that all the children have been unconfigured) first.
 691  *      If not, it just returns.
 692  *      If yes, then it frees up memory allocated for devi_name,
 693  *      node_addr, and property list.
 694  */
 695 static void
 696 ibnex_pseudo_node_cleanup(void)
 697 {
 698         ibnex_node_data_t       *nodep =  ibnex.ibnex_pseudo_node_head;
 699         ibnex_pseudo_node_t     *pseudo;
 700 
 701         IBTF_DPRINTF_L4("ibnex", "\tpseudo_node_cleanup:");
 702         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
 703 
 704         for (; nodep; nodep = nodep->node_next)
 705                 if (nodep->node_dip)
 706                         return;
 707 
 708         IBTF_DPRINTF_L4("ibnex", "\tpseudo_node_cleanup: freeing up memory");
 709         for (nodep =  ibnex.ibnex_pseudo_node_head; nodep;
 710             nodep = nodep->node_next) {
 711 
 712                 pseudo = &nodep->node_data.pseudo_node;
 713                 if (pseudo->pseudo_node_addr) {
 714                         kmem_free(pseudo->pseudo_node_addr,
 715                             strlen(pseudo-> pseudo_node_addr) + 1);
 716                         pseudo->pseudo_node_addr = NULL;
 717                 }
 718 
 719                 if (pseudo->pseudo_devi_name) {
 720                         kmem_free(pseudo->pseudo_devi_name,
 721                             strlen(pseudo-> pseudo_devi_name) + 1);
 722                         pseudo->pseudo_devi_name = NULL;
 723                 }
 724 
 725                 if (pseudo->pseudo_unit_addr) {
 726                         kmem_free(pseudo->pseudo_unit_addr,
 727                             pseudo->pseudo_unit_addr_len);
 728                 }
 729         }
 730 }
 731 
 732 
 733 /*
 734  * This functions wakes up any reprobe requests waiting for completion
 735  * of reprobe of this IOC. It also send an NDI event, if  :
 736  *
 737  *      notify_flag is set. This is set if :
 738  *              ibt_reprobe_ioc has returned with SUCCESS
 739  *              IBTF client has not been notified for this node.
 740  *      node_data->node_dip != NULL
 741  *      node_state has IBNEX_NODE_REPROBE_NOTIFY_ALWAYS set
 742  *      An NDI event cookie has been registered.
 743  */
 744 static void
 745 ibnex_wakeup_reprobe_ioc(ibnex_node_data_t *node_data, int notify_flag)
 746 {
 747         ddi_eventcookie_t       evt_cookie;
 748 
 749         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
 750         evt_cookie = ibnex.ibnex_prop_update_evt_cookie;
 751 
 752         if ((ibnex.ibnex_reprobe_state == IBNEX_REPROBE_IOC_WAIT) ||
 753             (node_data->node_reprobe_state != 0)) {
 754                 if (notify_flag && (node_data->node_dip != NULL) &&
 755                     (node_data->node_state &
 756                     IBNEX_NODE_REPROBE_NOTIFY_ALWAYS) &&
 757                     (evt_cookie != NULL)) {
 758                         ibt_prop_update_payload_t       evt_data;
 759 
 760                         mutex_exit(&ibnex.ibnex_mutex);
 761 
 762                         bzero(&evt_data, sizeof (evt_data));
 763                         if (ndi_post_event(ibnex.ibnex_dip,
 764                             node_data->node_dip,
 765                             evt_cookie, &evt_data) != NDI_SUCCESS)
 766                                 IBTF_DPRINTF_L2("ibnex",
 767                                     "\tndi_post_event failed\n");
 768 
 769                         mutex_enter(&ibnex.ibnex_mutex);
 770                 }
 771 
 772                 node_data->node_reprobe_state = 0;
 773                 cv_broadcast(&ibnex.ibnex_reprobe_cv);
 774         }
 775         node_data->node_reprobe_state = 0;
 776 }
 777 
 778 /*
 779  * This function wakes up any reprobe request waiting for completion
 780  * of reprobe of all IOCs.
 781  */
 782 static void
 783 ibnex_wakeup_reprobe_all()
 784 {
 785         ibnex_node_data_t *ioc_node;
 786 
 787         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
 788 
 789         /* Notify if another reprobe_all is pending */
 790         if (ibnex.ibnex_reprobe_state == IBNEX_REPROBE_ALL_WAIT) {
 791                 ibnex.ibnex_reprobe_state = 0;
 792                 cv_broadcast(&ibnex.ibnex_reprobe_cv);
 793         }
 794         ibnex.ibnex_reprobe_state = 0;
 795 
 796         /*
 797          * The IOC may be hot-removed after the reprobe request.
 798          * Reset the reprobe states for such IOCs.
 799          */
 800         for (ioc_node = ibnex.ibnex_ioc_node_head; ioc_node;
 801             ioc_node = ioc_node->node_next) {
 802                 if (ioc_node->node_reprobe_state != 0) {
 803                         ibnex_wakeup_reprobe_ioc(ioc_node, 1);
 804                 }
 805         }
 806 }
 807 
 808 /*
 809  * ibnex_ibnex_callback:
 810  *      IBTL_IBNEX_IBC_INIT:
 811  *              Called from ibc_init() which is called from
 812  *              HCA driver _init entry point
 813  *              Initializes the HCA dev_ops structure with default
 814  *              IB nexus structure.
 815  *      IBTL_IBNEX_IBC_FINI:
 816  *              Called from ibc_fini() which is called from
 817  *              HCA driver _fini entry point
 818  *              Un-Initializes the HCA dev_ops structure with default
 819  *              IB nexus strucuture.
 820  *      Returns IBT_SUCCESS
 821  */
 822 ibt_status_t
 823 ibnex_ibtl_callback(ibtl_ibnex_cb_args_t *cb_args)
 824 {
 825         int                     retval = IBT_SUCCESS;
 826         struct dev_ops          *hca_dev_ops;
 827         dev_info_t              *clnt_dip;
 828         ibnex_node_data_t       *node_data;
 829 
 830         IBTF_DPRINTF_L5("ibnex", "\tibtl_callback");
 831 
 832         switch (cb_args->cb_flag) {
 833         case IBTL_IBNEX_IBC_INIT:
 834                 /*
 835                  * Get the devops structure of the HCA,
 836                  * and put IB nexus default busops vector in its place.
 837                  */
 838                 hca_dev_ops = ((struct modldrv *)
 839                     (cb_args->cb_modlp->ml_linkage[0]))->drv_dev_ops;
 840                 ASSERT((hca_dev_ops) && (hca_dev_ops->devo_bus_ops == NULL));
 841                 hca_dev_ops->devo_bus_ops = &ibnex_ci_busops;
 842                 break;
 843 
 844         case IBTL_IBNEX_IBC_FINI:
 845                 hca_dev_ops = ((struct modldrv *)
 846                     (cb_args->cb_modlp->ml_linkage[0]))->drv_dev_ops;
 847                 hca_dev_ops->devo_bus_ops = NULL;
 848                 break;
 849 
 850         case IBTL_IBNEX_REPROBE_DEV_REQ:
 851                 /* IBTL pass down request for ibt_reprobe_dev */
 852                 clnt_dip = cb_args->cb_dip;
 853                 ASSERT(clnt_dip);
 854 
 855                 node_data = ddi_get_parent_data(clnt_dip);
 856                 ASSERT(node_data);
 857 
 858                 /* Reprobe for IOC nodes only */
 859                 ASSERT(node_data->node_type == IBNEX_IOC_NODE);
 860 
 861                 /*
 862                  * Start the reprobe. This could sleep as it is not
 863                  * from interrupt context.
 864                  */
 865                 if (taskq_dispatch(system_taskq, ibnex_handle_reprobe_dev,
 866                     clnt_dip, TQ_SLEEP) == 0) {
 867                         IBTF_DPRINTF_L2("ibnex",
 868                             "ibnex_ibtl_callback: taskq_dispatch failed");
 869                         mutex_enter(&ibnex.ibnex_mutex);
 870                         ibnex_wakeup_reprobe_ioc(node_data, 0);
 871                         mutex_exit(&ibnex.ibnex_mutex);
 872                         return (IBT_INSUFF_KERNEL_RESOURCE);
 873                 }
 874                 return (IBT_SUCCESS);
 875         }
 876 
 877         return (retval);
 878 }
 879 
 880 
 881 /*
 882  * Bus-ops entry points
 883  */
 884 
 885 /*
 886  * ibnex_map_fault
 887  *      IOC drivers need not map memory. Return failure to fail any
 888  *      such calls.
 889  */
 890 /*ARGSUSED*/
 891 int
 892 ibnex_map_fault(dev_info_t *dip, dev_info_t *rdip, struct hat *hat,
 893     struct seg *seg, caddr_t addr, struct devpage *dp, pfn_t pfn,
 894     uint_t prot, uint_t lock)
 895 {
 896         return (DDI_FAILURE);
 897 }
 898 
 899 
 900 /*
 901  * ibnex_busctl
 902  *      bus_ctl bus_ops entry point
 903  */
 904 /*ARGSUSED*/
 905 int
 906 ibnex_busctl(dev_info_t *dip, dev_info_t *rdip,
 907     ddi_ctl_enum_t ctlop, void *arg, void *result)
 908 {
 909         dev_info_t              *child_dip;
 910 
 911         IBTF_DPRINTF_L4("ibnex",
 912             "\tbusctl: dip = %p, rdip = %p, ctlop = %x,", dip, rdip, ctlop);
 913         IBTF_DPRINTF_L4("ibnex", "\tbusctl: targ = %p, result %p", arg, result);
 914 
 915         switch (ctlop) {
 916         case DDI_CTLOPS_REPORTDEV:
 917                 if (rdip == NULL) {
 918                         return (DDI_FAILURE);
 919                 }
 920 
 921                 /* Log the relevant details of dip to sysbuf */
 922                 cmn_err(CE_CONT, "?IB device: %s@%s, %s%d\n",
 923                     ddi_node_name(rdip), ddi_get_name_addr(rdip),
 924                     ddi_driver_name(rdip), ddi_get_instance(rdip));
 925 
 926                 return (DDI_SUCCESS);
 927 
 928         case DDI_CTLOPS_INITCHILD:
 929                 child_dip = (dev_info_t *)arg;
 930                 return (ibnex_init_child(child_dip));
 931 
 932         case DDI_CTLOPS_UNINITCHILD:
 933                 child_dip = (dev_info_t *)arg;
 934                 ddi_set_name_addr(child_dip, NULL);
 935                 return (DDI_SUCCESS);
 936 
 937         case DDI_CTLOPS_ATTACH:
 938         case DDI_CTLOPS_DETACH:
 939         case DDI_CTLOPS_POWER :
 940                 return (DDI_SUCCESS);
 941 
 942         case DDI_CTLOPS_SIDDEV:
 943                 /*
 944                  * Return DDI_SUCCESS for IOC/PORT/VPPA nodes and
 945                  * DDI_FAILURE for the nodes enumerated by a Pseudo file.
 946                  */
 947                 return (ndi_dev_is_persistent_node(rdip) ?
 948                     DDI_SUCCESS : DDI_FAILURE);
 949 
 950 
 951         case DDI_CTLOPS_IOMIN:
 952                 /*
 953                  * Return DDI_SUCCESS, so that consistent buf alloc
 954                  * gets the default DMA IO minimum for the platform
 955                  */
 956                 return (DDI_SUCCESS);
 957 
 958         /*
 959          * These ops correspond to functions that "shouldn't" be
 960          * called by IB Nexus driver.
 961          */
 962         case DDI_CTLOPS_DMAPMAPC:
 963         case DDI_CTLOPS_REPORTINT:
 964         case DDI_CTLOPS_REGSIZE:
 965         case DDI_CTLOPS_NREGS:
 966         case DDI_CTLOPS_SLAVEONLY:
 967         case DDI_CTLOPS_AFFINITY:
 968         case DDI_CTLOPS_POKE:
 969         case DDI_CTLOPS_PEEK:
 970                 IBTF_DPRINTF_L2("ibnex",
 971                     "%s%d: invalid op (%d) from %s inst%d",
 972                     ddi_get_name(dip), ddi_get_instance(dip),
 973                     ctlop, ddi_get_name(rdip), ddi_get_instance(rdip));
 974                 return (DDI_FAILURE);
 975 
 976         /*
 977          * Everything else (PTOB/BTOP/BTOPR/DVMAPAGESIZE requests) we
 978          * pass up
 979          */
 980         default:
 981                 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
 982         }
 983 }
 984 
 985 
 986 /*
 987  * ibnex_init_child()
 988  *
 989  * Initialize a child device node. This is called for the DDI_CTLOPS_INITCHILD
 990  * entry. Function returns DDI_SUCCESS,  DDI_FAILURE or DDI_NOT_WELL_FORMED.
 991  */
 992 static int
 993 ibnex_init_child(dev_info_t *child)
 994 {
 995         int                     ret;
 996         char                    name[MAXNAMELEN];
 997 
 998         IBTF_DPRINTF_L4("ibnex", "\tinit_child: child = %p", child);
 999 
1000         /* Handle Pseudo nodes of client children */
1001         if (ndi_dev_is_persistent_node(child) == 0) {
1002                 /* Skip nodes without ib-node-type="merge" */
1003                 if (ibnex_is_merge_node(child) != IBNEX_SUCCESS)
1004                         return (DDI_FAILURE);
1005 
1006                 if (ibnex_name_pseudo_child(child, name) != DDI_SUCCESS)
1007                         return (DDI_FAILURE);
1008 
1009                 ddi_set_name_addr(child, name);
1010                 /*
1011                  * Merge the .conf node
1012                  */
1013                 if (ndi_merge_node(child,
1014                     ibnex_name_child) == DDI_SUCCESS) {
1015                         ddi_set_name_addr(child, NULL);
1016                         return (DDI_FAILURE);
1017                 }
1018                 return (DDI_NOT_WELL_FORMED);
1019 
1020         }
1021 
1022         if ((ret = ibnex_name_child(child, name, 0)) != DDI_SUCCESS)
1023                 return (ret);
1024 
1025         ddi_set_name_addr(child, name);
1026 
1027         return (DDI_SUCCESS);
1028 }
1029 
1030 
1031 int
1032 ibnex_name_pseudo_child(dev_info_t *child, char *name)
1033 {
1034         char **unit_addr;
1035         uint_t n;
1036         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, child,
1037             DDI_PROP_DONTPASS, "unit-address", &unit_addr, &n) !=
1038             DDI_PROP_SUCCESS) {
1039                 IBTF_DPRINTF_L4("ibnex",
1040                     "\tname_pseudo_child: cannot find unit-address in %s.conf",
1041                     ddi_get_name(child));
1042                 return (DDI_FAILURE);
1043         }
1044         if (n != 1 || *unit_addr == NULL || **unit_addr == 0) {
1045                 cmn_err(CE_WARN, "unit-address property in %s.conf"
1046                     " not well-formed", ddi_get_name(child));
1047                 ddi_prop_free(unit_addr);
1048                 return (DDI_FAILURE);
1049         }
1050         (void) snprintf(name, MAXNAMELEN, "%s", *unit_addr);
1051         ddi_prop_free(unit_addr);
1052         return (DDI_SUCCESS);
1053 }
1054 
1055 
1056 /*ARGSUSED*/
1057 int
1058 ibnex_name_child(dev_info_t *child, char *name, int flag)
1059 {
1060         ibnex_pseudo_node_t     *pseudo;
1061         ibnex_node_data_t       *node_datap;
1062         ibnex_port_node_t       *port_node;
1063         ibnex_ioc_node_t        *ioc;
1064 
1065         node_datap = ddi_get_parent_data(child);
1066         if (node_datap == NULL) {
1067                 IBTF_DPRINTF_L2("ibnex", "\tname_child: Node data is NULL");
1068                 return (DDI_NOT_WELL_FORMED);
1069         }
1070         IBTF_DPRINTF_L4("ibnex", "\tname_sid_child: Node data %p"
1071             "Node type %x", node_datap, node_datap->node_type);
1072         switch (node_datap->node_type) {
1073         case IBNEX_PORT_COMMSVC_NODE:
1074                 port_node = &node_datap->node_data.port_node;
1075                 (void) snprintf(name, IBNEX_MAX_NODEADDR_SZ, "%x,0,%s",
1076                     port_node->port_num,
1077                     ibnex.ibnex_comm_svc_names[port_node->port_commsvc_idx]);
1078                 break;
1079         case IBNEX_VPPA_COMMSVC_NODE:
1080                 port_node = &node_datap->node_data.port_node;
1081                 (void) snprintf(name, IBNEX_MAX_NODEADDR_SZ, "%x,%x,%s",
1082                     port_node->port_num, port_node->port_pkey, ibnex.
1083                     ibnex_vppa_comm_svc_names[port_node->port_commsvc_idx]);
1084                 break;
1085         case IBNEX_HCASVC_COMMSVC_NODE:
1086                 port_node = &node_datap->node_data.port_node;
1087                 (void) snprintf(name, IBNEX_MAX_NODEADDR_SZ, "%x,0,%s",
1088                     port_node->port_num,
1089                     ibnex.ibnex_hcasvc_comm_svc_names[port_node->
1090                     port_commsvc_idx]);
1091                 break;
1092         case IBNEX_IOC_NODE:
1093                 ioc = &node_datap->node_data.ioc_node;
1094                 (void) snprintf(name, IBNEX_MAX_NODEADDR_SZ, "%llX,%llX",
1095                     (longlong_t)ioc->ioc_guid, (longlong_t)ioc->iou_guid);
1096                 break;
1097         case IBNEX_PSEUDO_NODE:
1098                 pseudo = &node_datap->node_data.pseudo_node;
1099                 (void) snprintf(name,
1100                     IBNEX_MAX_NODEADDR_SZ, pseudo->pseudo_unit_addr);
1101                 break;
1102         default:
1103                 IBTF_DPRINTF_L2("ibnex", "\name_child: Not well formed");
1104                 return (DDI_NOT_WELL_FORMED);
1105         }
1106 
1107         return (DDI_SUCCESS);
1108 }
1109 
1110 
1111 /*
1112  * ibnex_bus_config()
1113  *
1114  * BUS_CONFIG_ONE:
1115  *      Enumerate the exact instance of the driver. Use the device node name
1116  *      to locate the exact instance.
1117  *      Query IBDM to find whether the hardware exits for the instance of the
1118  *      driver. If exists, create a device node and return NDI_SUCCESS.
1119  *
1120  * BUS_CONFIG_ALL:
1121  *      Enumerate all the instances of all the possible children (seen before
1122  *      and never seen before).
1123  *
1124  * BUS_CONFIG_DRIVER:
1125  *      Enumerate all the instances of a particular driver.
1126  */
1127 
1128 static int
1129 ibnex_bus_config(dev_info_t *parent, uint_t flag,
1130     ddi_bus_config_op_t op, void *devname, dev_info_t **child)
1131 {
1132         int                     ret = IBNEX_SUCCESS, len, circ, need_bus_config;
1133         char                    *device_name, *cname = NULL, *caddr = NULL;
1134         dev_info_t              *cdip;
1135         ibnex_node_data_t       *node_data;
1136 
1137         switch (op) {
1138         case BUS_CONFIG_ONE:
1139                 IBTF_DPRINTF_L4("ibnex", "\tbus_config: CONFIG_ONE, "
1140                     "parent %p", parent);
1141 
1142                 ndi_devi_enter(parent, &circ);
1143 
1144                 len = strlen((char *)devname) + 1;
1145                 device_name = i_ddi_strdup(devname, KM_SLEEP);
1146                 i_ddi_parse_name(device_name, &cname, &caddr, NULL);
1147 
1148                 if (caddr == NULL || (strlen(caddr) == 0)) {
1149                         kmem_free(device_name, len);
1150                         ndi_devi_exit(parent, circ);
1151                         return (NDI_FAILURE);
1152                 }
1153 
1154                 cdip = ndi_devi_findchild(parent, devname);
1155                 if (cdip)
1156                         node_data = ddi_get_parent_data(cdip);
1157 
1158                 ndi_devi_exit(parent, circ);
1159 
1160                 if (cdip == NULL || (node_data != NULL &&
1161                     node_data->node_dip == NULL)) {
1162                         /* Node is not present */
1163                         if (strncmp(cname, IBNEX_IOC_CNAME, 3) == 0) {
1164                                 ret = ibnex_ioc_bus_config_one(&parent, flag,
1165                                     op, devname, child, &need_bus_config);
1166                                 if (!need_bus_config) {
1167                                         kmem_free(device_name, len);
1168                                         return (ret);
1169                                 }
1170                         } else {
1171                                 /*
1172                                  * if IB Nexus is the parent, call MDI. Bus
1173                                  * config with HCA as the parent would have
1174                                  * enumerated the Pseudo node.
1175                                  */
1176                                 ret = IBNEX_SUCCESS;
1177                                 ibnex_pseudo_initnodes();
1178                                 mutex_enter(&ibnex.ibnex_mutex);
1179                                 ret = ibnex_pseudo_mdi_config_one(flag, devname,
1180                                     child, cname, caddr);
1181                                 mutex_exit(&ibnex.ibnex_mutex);
1182                                 kmem_free(device_name, len);
1183                                 return (ret);
1184                         }
1185                 }
1186                 kmem_free(device_name, len);
1187                 break;
1188 
1189         case BUS_CONFIG_ALL:
1190                 /*FALLTHRU*/
1191         case BUS_CONFIG_DRIVER:
1192                 if (op == BUS_CONFIG_ALL)
1193                         IBTF_DPRINTF_L4("ibnex", "\tbus_config: CONFIG_ALL, "
1194                             "parent %p", parent);
1195                 else
1196                         IBTF_DPRINTF_L4("ibnex", "\tbus_config: CONFIG_DRIVER"
1197                             ", parent %p", parent);
1198 
1199                 /*
1200                  * Drive CONFIG requests for IB Nexus parent through
1201                  * MDI. This is needed to load the HCA drivers in x86 SRP
1202                  * boot case.
1203                  *
1204                  * CONFIG Requests with HCA parent will probe devices using
1205                  * ibdm and configure all children.
1206                  */
1207                 ibdm_ioc_info_t *ioc_list, *new_ioc_list;
1208 
1209                 mutex_enter(&ibnex.ibnex_mutex);
1210                 while (ibnex.ibnex_ioc_list_state !=
1211                     IBNEX_IOC_LIST_READY) {
1212                         cv_wait(&ibnex.ibnex_ioc_list_cv,
1213                             &ibnex.ibnex_mutex);
1214                 }
1215                 ibnex.ibnex_ioc_list_state = IBNEX_IOC_LIST_RENEW;
1216                 mutex_exit(&ibnex.ibnex_mutex);
1217                 /* Enumerate all the IOC's */
1218                 ibdm_ibnex_port_settle_wait(0, ibnex_port_settling_time);
1219 
1220                 new_ioc_list = ibdm_ibnex_get_ioc_list(
1221                     IBDM_IBNEX_NORMAL_PROBE);
1222                 IBTF_DPRINTF_L4("ibnex",
1223                     "\tbus_config: alloc ioc_list %p", new_ioc_list);
1224                 /*
1225                  * Optimize the calls for each BUS_CONFIG_ALL request
1226                  * to the IB Nexus dip. This is currently done for
1227                  * each PDIP.
1228                  */
1229                 mutex_enter(&ibnex.ibnex_mutex);
1230                 ioc_list = ibnex.ibnex_ioc_list;
1231                 ibnex.ibnex_ioc_list = new_ioc_list;
1232                 ibnex.ibnex_ioc_list_state = IBNEX_IOC_LIST_READY;
1233                 cv_broadcast(&ibnex.ibnex_ioc_list_cv);
1234                 mutex_exit(&ibnex.ibnex_mutex);
1235 
1236                 if (ioc_list) {
1237                         IBTF_DPRINTF_L4("ibnex",
1238                             "\tbus_config: freeing ioc_list %p",
1239                             ioc_list);
1240                         ibdm_ibnex_free_ioc_list(ioc_list);
1241                 }
1242 
1243 
1244                 ret = mdi_vhci_bus_config(parent,
1245                     flag, op, devname, child, NULL);
1246                 return (ret);
1247         default:
1248                 IBTF_DPRINTF_L4("ibnex", "\tbus_config: error");
1249                 ret = IBNEX_FAILURE;
1250                 break;
1251         }
1252 
1253         if (ret == IBNEX_SUCCESS) {
1254                 ret = ndi_busop_bus_config(
1255                     parent, flag, op, devname, child, 0);
1256                 IBTF_DPRINTF_L4("ibnex", "\tbus_config:"
1257                     "ndi_busop_bus_config : retval %d", ret);
1258                 return (ret);
1259         }
1260 
1261         return (NDI_FAILURE);
1262 }
1263 
1264 
1265 /*
1266  * ibnex_config_root_iocnode()
1267  *      Configures one particular instance of the IOC driver.
1268  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
1269  */
1270 static int
1271 ibnex_config_root_iocnode(dev_info_t *parent, char *device_name)
1272 {
1273         int                     ret, port = 0, iter = 0;
1274         boolean_t               displayed = B_FALSE;
1275         char                    *portstr;
1276         ib_guid_t               hca_guid, iou_guid, ioc_guid;
1277         ibdm_ioc_info_t         *ioc_info;
1278         ibdm_port_attr_t        *port_attr;
1279 
1280         IBTF_DPRINTF_L4("ibnex",
1281             "\tconfig_root_iocnode: name %s", device_name);
1282 
1283         portstr = strstr(device_name, ":port=");
1284         if (portstr == NULL) {
1285                 return (IBNEX_FAILURE);
1286         }
1287 
1288         portstr[0] = 0; portstr++;
1289         if (ibnex_devname2port(portstr, &port)) {
1290                 IBTF_DPRINTF_L4("ibnex", "\tconfig_root_iocnode: invalid port");
1291                 return (IBNEX_FAILURE);
1292         }
1293 
1294         if (ibnex_devname_to_node_n_ioc_guids(
1295             device_name, &iou_guid, &ioc_guid, NULL) != IBNEX_SUCCESS) {
1296                 return (IBNEX_FAILURE);
1297         }
1298 
1299         (void) snprintf(device_name, (IBNEX_MAX_NODEADDR_SZ + 4),
1300             "ioc@%llX,%llX", (longlong_t)ioc_guid, (longlong_t)iou_guid);
1301 
1302         hca_guid = ibtl_ibnex_hcadip2guid(parent);
1303         if ((port_attr = ibdm_ibnex_probe_hcaport(hca_guid, port)) == NULL) {
1304                 IBTF_DPRINTF_L2("ibnex",
1305                     "\tconfig_root_iocnode: Port does not exist");
1306                 return (IBNEX_FAILURE);
1307         }
1308 
1309         /* Wait until "port is up" */
1310         while (port_attr->pa_state != IBT_PORT_ACTIVE) {
1311                 ibdm_ibnex_free_port_attr(port_attr);
1312                 delay(drv_usectohz(10000));
1313                 if ((port_attr = ibdm_ibnex_probe_hcaport(
1314                     hca_guid, port)) == NULL) {
1315                         return (IBNEX_FAILURE);
1316                 }
1317 
1318                 if (iter++ == 400) {
1319                         if (displayed == B_FALSE) {
1320                                 cmn_err(CE_NOTE, "\tWaiting for Port %d "
1321                                     "initialization", port_attr->pa_port_num);
1322                                 displayed = B_TRUE;
1323                         }
1324                 }
1325         }
1326         ibdm_ibnex_free_port_attr(port_attr);
1327         IBTF_DPRINTF_L4("ibnex", "\tconfig_rootioc_node:"
1328             "Port is initialized");
1329 
1330         if ((ioc_info = ibdm_ibnex_probe_ioc(iou_guid, ioc_guid, 0)) == NULL) {
1331                 ibdm_ibnex_free_ioc_list(ioc_info);
1332                 return (IBNEX_FAILURE);
1333         }
1334         mutex_enter(&ibnex.ibnex_mutex);
1335         if ((ret = ibnex_ioc_config_from_pdip(ioc_info, parent, 0)) !=
1336             IBNEX_SUCCESS) {
1337                 IBTF_DPRINTF_L2("ibnex",
1338                     "\tconfig_root_ioc_node failed for pdip %p", parent);
1339         }
1340         mutex_exit(&ibnex.ibnex_mutex);
1341         ibdm_ibnex_free_ioc_list(ioc_info);
1342         return (ret);
1343 }
1344 
1345 
1346 static int
1347 ibnex_devname2port(char *portstr, int *port)
1348 {
1349         char    *temp;
1350         int     ret = IBNEX_FAILURE;
1351 
1352         IBTF_DPRINTF_L4("ibnex", "\tdevname2port: Begin");
1353 
1354         temp = strchr(portstr, '=');
1355         if (temp != NULL) {
1356                 temp++;
1357                 *port = ibnex_str2int(temp, strlen(temp), &ret);
1358         }
1359         return (ret);
1360 }
1361 
1362 
1363 /*
1364  * ibnex_config_all_children()
1365  *      Wait for lata SM initialization case before enumerating the nodes
1366  *      Get list of HCA's and HCA port information
1367  *              Create device device nodes and its node properties
1368  *              for port nodes and VPPA nodes
1369  *      Get list of all the IOC node information
1370  *              Create device nodes and its properties for all the IOCs
1371  *              if not created already
1372  *      Bind drivers for all the newly created device nodes
1373  *      Support Pseudo nodes enumerated using their .conf file
1374  */
1375 void
1376 ibnex_config_all_children(dev_info_t *parent)
1377 {
1378         int                     ii;
1379         ibdm_ioc_info_t         *ioc_list;
1380         ibdm_hca_list_t         *hca_list;
1381         ib_guid_t               hca_guid;
1382         int                     circ;
1383 
1384         IBTF_DPRINTF_L4("ibnex", "\tconfig_all_children: Begin");
1385 
1386 
1387         /*
1388          * Enumerate children of this HCA, port nodes,
1389          * VPPA & HCA_SVC nodes. Use ndi_devi_enter() for
1390          * locking. IB Nexus is enumerating the children
1391          * of HCA, not MPXIO clients.
1392          */
1393         ndi_devi_enter(parent, &circ);
1394         hca_guid = ibtl_ibnex_hcadip2guid(parent);
1395         ibdm_ibnex_port_settle_wait(hca_guid, ibnex_port_settling_time);
1396         hca_list = ibdm_ibnex_get_hca_info_by_guid(hca_guid);
1397         if (hca_list == NULL) {
1398                 ndi_devi_exit(parent, circ);
1399                 return;
1400         }
1401         ibnex_create_hcasvc_nodes(parent, hca_list->hl_hca_port_attr);
1402         for (ii = 0; ii < hca_list->hl_nports; ii++) {
1403                 ibnex_create_port_nodes(
1404                     parent, &hca_list->hl_port_attr[ii]);
1405                 ibnex_create_vppa_nodes(parent, &hca_list->hl_port_attr[ii]);
1406         }
1407         ibdm_ibnex_free_hca_list(hca_list);
1408         ndi_devi_exit(parent, circ);
1409 
1410         /*
1411          * Use mdi_devi_enter() for locking. IB Nexus is
1412          * enumerating MPxIO clients.
1413          */
1414         mdi_devi_enter(parent, &circ);
1415 
1416         ibnex_pseudo_initnodes();
1417 
1418         mutex_enter(&ibnex.ibnex_mutex);
1419         while (ibnex.ibnex_ioc_list_state != IBNEX_IOC_LIST_READY) {
1420                 cv_wait(&ibnex.ibnex_ioc_list_cv, &ibnex.ibnex_mutex);
1421         }
1422         ibnex.ibnex_ioc_list_state = IBNEX_IOC_LIST_ACCESS;
1423         ioc_list = ibnex.ibnex_ioc_list;
1424         while (ioc_list) {
1425                 (void) ibnex_ioc_config_from_pdip(ioc_list, parent, 0);
1426                 ioc_list = ioc_list->ioc_next;
1427         }
1428         ibnex.ibnex_ioc_list_state = IBNEX_IOC_LIST_READY;
1429         cv_broadcast(&ibnex.ibnex_ioc_list_cv);
1430 
1431         /* Config IBTF Pseudo clients */
1432         ibnex_config_pseudo_all(parent);
1433 
1434         mutex_exit(&ibnex.ibnex_mutex);
1435         mdi_devi_exit(parent, circ);
1436 
1437         IBTF_DPRINTF_L4("ibnex", "\tconfig_all_children: End");
1438 }
1439 
1440 
1441 /*
1442  * ibnex_create_port_nodes:
1443  *      Creates a device node per each communication service defined
1444  *      in the "port-commsvc-list" property per HCA port
1445  */
1446 void
1447 ibnex_create_port_nodes(dev_info_t *parent, ibdm_port_attr_t *port_attr)
1448 {
1449         int             idx;
1450         dev_info_t      *dip;
1451         int             rval;
1452 
1453         mutex_enter(&ibnex.ibnex_mutex);
1454         for (idx = 0; idx < ibnex.ibnex_num_comm_svcs; idx++) {
1455                 rval = ibnex_get_dip_from_guid(port_attr->pa_port_guid,
1456                     idx, 0, &dip);
1457                 if (rval != IBNEX_SUCCESS || dip == NULL) {
1458                         (void) ibnex_commsvc_initnode(parent, port_attr, idx,
1459                             IBNEX_PORT_COMMSVC_NODE, 0, &rval,
1460                             IBNEX_DEVFS_ENUMERATE);
1461                 }
1462         }
1463         mutex_exit(&ibnex.ibnex_mutex);
1464 }
1465 
1466 
1467 /*
1468  * ibnex_create_vppa_nodes:
1469  *      Creates a device node per each communication service defined
1470  *      in the "vppa-commsvc-list" property and per each PKEY that
1471  *      this particular port supports and per HCA port
1472  */
1473 void
1474 ibnex_create_vppa_nodes(
1475     dev_info_t *parent, ibdm_port_attr_t *port_attr)
1476 {
1477         int             idx, ii;
1478         int             rval;
1479         ib_pkey_t       pkey;
1480         dev_info_t      *dip;
1481 
1482         IBTF_DPRINTF_L4("ibnex", "\tcreate_vppa_nodes: Begin");
1483 
1484         mutex_enter(&ibnex.ibnex_mutex);
1485         if (port_attr->pa_state != IBT_PORT_ACTIVE) {
1486                 IBTF_DPRINTF_L4("ibnex", "\tcreate_vppa_nodes: "
1487                     "Port %d is down", port_attr->pa_port_num);
1488                 mutex_exit(&ibnex.ibnex_mutex);
1489                 return;
1490         }
1491         for (idx = 0; idx < ibnex.ibnex_nvppa_comm_svcs; idx++) {
1492                 if (strcmp("ipib", ibnex.ibnex_vppa_comm_svc_names[idx]) == 0) {
1493                         IBTF_DPRINTF_L2("ibnex", "Skipping IBD devices...");
1494                         continue;
1495                 }
1496                 for (ii = 0; ii < port_attr->pa_npkeys; ii++) {
1497                         pkey = port_attr->pa_pkey_tbl[ii].pt_pkey;
1498 
1499                         if (IBNEX_INVALID_PKEY(pkey)) {
1500                                 continue;
1501                         }
1502                         rval = ibnex_get_dip_from_guid(
1503                             port_attr->pa_port_guid, idx, pkey, &dip);
1504                         if ((rval != IBNEX_SUCCESS) || (dip == NULL)) {
1505                                 (void) ibnex_commsvc_initnode(parent, port_attr,
1506                                     idx, IBNEX_VPPA_COMMSVC_NODE,
1507                                     pkey, &rval, IBNEX_CFGADM_ENUMERATE);
1508                         }
1509                 }
1510         }
1511         mutex_exit(&ibnex.ibnex_mutex);
1512 }
1513 
1514 
1515 /*
1516  * ibnex_create_hcasvc_nodes:
1517  *      Creates a device node per each communication service defined
1518  *      in the "port-commsvc-list" property per HCA port
1519  */
1520 void
1521 ibnex_create_hcasvc_nodes(dev_info_t *parent, ibdm_port_attr_t *port_attr)
1522 {
1523         int             idx;
1524         dev_info_t      *dip;
1525         int             rval;
1526 
1527         mutex_enter(&ibnex.ibnex_mutex);
1528         for (idx = 0; idx < ibnex.ibnex_nhcasvc_comm_svcs; idx++) {
1529                 rval = ibnex_get_dip_from_guid(port_attr->pa_port_guid,
1530                     idx, 0, &dip);
1531                 if (rval != IBNEX_SUCCESS || dip == NULL) {
1532                         (void) ibnex_commsvc_initnode(parent, port_attr, idx,
1533                             IBNEX_HCASVC_COMMSVC_NODE, 0, &rval,
1534                             IBNEX_DEVFS_ENUMERATE);
1535                         IBTF_DPRINTF_L5("ibnex", "create_hcasvc_nodes: "
1536                             "commsvc_initnode failed, rval %x", rval);
1537                 }
1538         }
1539         mutex_exit(&ibnex.ibnex_mutex);
1540 }
1541 
1542 
1543 /*
1544  * ibnex_bus_unconfig()
1545  *
1546  *      Unconfigure a particular device node or all instance of a device
1547  *      driver device or all children of IBnex
1548  */
1549 static int
1550 ibnex_bus_unconfig(dev_info_t *parent,
1551     uint_t flag, ddi_bus_config_op_t op, void *device_name)
1552 {
1553         ibnex_node_data_t       *ndp;
1554         major_t                 major = (major_t)(uintptr_t)device_name;
1555         dev_info_t              *dip = NULL;
1556 
1557         if (ndi_busop_bus_unconfig(parent, flag, op, device_name) !=
1558             DDI_SUCCESS)
1559                 return (DDI_FAILURE);
1560 
1561         if ((op == BUS_UNCONFIG_ALL || op == BUS_UNCONFIG_DRIVER) &&
1562             (flag & (NDI_UNCONFIG | NDI_DETACH_DRIVER))) {
1563                 mutex_enter(&ibnex.ibnex_mutex);
1564                 /*
1565                  * IB dip. here we handle IOC and pseudo nodes which
1566                  * are the children of IB nexus. Cleanup only the nodes
1567                  * with matching major number. We also need to cleanup
1568                  * the PathInfo links to the PHCI here.
1569                  */
1570                 for (ndp = ibnex.ibnex_ioc_node_head;
1571                     ndp; ndp = ndp->node_next) {
1572                         dip = ndp->node_dip;
1573                         if (dip && (ddi_driver_major(dip) == major)) {
1574                                 (void) ibnex_offline_childdip(dip);
1575                         }
1576                 }
1577                 for (ndp = ibnex.ibnex_pseudo_node_head;
1578                     ndp; ndp = ndp->node_next) {
1579                         dip = ndp->node_dip;
1580                         if (dip && (ddi_driver_major(dip) == major)) {
1581                                 (void) ibnex_offline_childdip(dip);
1582                         }
1583                 }
1584                 mutex_exit(&ibnex.ibnex_mutex);
1585         }
1586         return (DDI_SUCCESS);
1587 }
1588 
1589 
1590 /*
1591  * ibnex_config_port_node()
1592  *
1593  *      Configures a particular port / HCA  node for a particular
1594  *      communication service.
1595  *      The format of the device_name is
1596  *              ibport@<Port#>,<pkey>,<service name>
1597  *      where pkey = 0 for port communication service nodes
1598  *                Port# = 0 for HCA_SVC communication service nodes
1599  *      Returns "dev_info_t" of the "child" node just created
1600  *      NULL when failed to enumerate the child node
1601  */
1602 dev_info_t *
1603 ibnex_config_port_node(dev_info_t *parent, char *devname)
1604 {
1605         int                     ii, index;
1606         int                     rval;
1607         uint8_t                 port_num;
1608         ib_guid_t               hca_guid, port_guid;
1609         ib_pkey_t               pkey;
1610         dev_info_t              *cdip;
1611         ibdm_port_attr_t        *port_attr;
1612         ibdm_hca_list_t         *hca_list;
1613 
1614         IBTF_DPRINTF_L4("ibnex", "\tconfig_port_node: %s", devname);
1615 
1616         if (ibnex_get_pkey_commsvc_index_portnum(devname,
1617             &index, &pkey, &port_num) != IBNEX_SUCCESS) {
1618                 IBTF_DPRINTF_L2("ibnex",
1619                     "\tconfig_port_node: Invalid Service Name");
1620                 return (NULL);
1621         }
1622 
1623         hca_guid = ibtl_ibnex_hcadip2guid(parent);
1624         if (port_num == 0) {
1625                 /*
1626                  * Use the dummy port attribute for HCA node in hca_list
1627                  * Note : pa_state is always IBT_PORT_ACTIVE.
1628                  */
1629                 hca_list = ibdm_ibnex_get_hca_info_by_guid(hca_guid);
1630                 ASSERT(hca_list != NULL);
1631                 port_attr = hca_list->hl_hca_port_attr;
1632         } else {
1633                 if ((port_attr = ibdm_ibnex_probe_hcaport(
1634                     hca_guid, port_num)) == NULL) {
1635                         IBTF_DPRINTF_L2("ibnex",
1636                             "\tconfig_port_node: Port does not exist");
1637                         return (NULL);
1638                 }
1639 
1640                 if (port_attr->pa_state != IBT_PORT_ACTIVE) {
1641                         ibdm_ibnex_port_settle_wait(
1642                             hca_guid, ibnex_port_settling_time);
1643                         ibdm_ibnex_free_port_attr(port_attr);
1644                         if ((port_attr = ibdm_ibnex_probe_hcaport(
1645                             hca_guid, port_num)) == NULL) {
1646                                 return (NULL);
1647                         }
1648                 }
1649         }
1650 
1651         port_guid = port_attr->pa_port_guid;
1652         mutex_enter(&ibnex.ibnex_mutex);
1653         rval = ibnex_get_dip_from_guid(port_guid, index, pkey, &cdip);
1654         if ((rval == IBNEX_SUCCESS) && cdip != NULL) {
1655                 IBTF_DPRINTF_L4("ibnex", "\tconfig_port_node: Node exists");
1656                 mutex_exit(&ibnex.ibnex_mutex);
1657                 if (port_num != 0)
1658                         ibdm_ibnex_free_port_attr(port_attr);
1659                 else
1660                         ibdm_ibnex_free_hca_list(hca_list);
1661                 return (cdip);
1662         }
1663 
1664         if (pkey == 0 && port_num != 0) {
1665                 cdip = ibnex_commsvc_initnode(parent,
1666                     port_attr, index, IBNEX_PORT_COMMSVC_NODE, pkey, &rval,
1667                     IBNEX_DEVFS_ENUMERATE);
1668                 IBTF_DPRINTF_L5("ibnex",
1669                     "\t ibnex_commsvc_initnode rval %x", rval);
1670         } else if (pkey == 0 && port_num == 0) {
1671                 cdip = ibnex_commsvc_initnode(parent,
1672                     port_attr, index, IBNEX_HCASVC_COMMSVC_NODE, pkey, &rval,
1673                     IBNEX_DEVFS_ENUMERATE);
1674                 IBTF_DPRINTF_L5("ibnex",
1675                     "\t ibnex_commsvc_initnode rval %x", rval);
1676         } else {
1677                 if (port_attr->pa_state != IBT_PORT_ACTIVE) {
1678                         IBTF_DPRINTF_L4("ibnex", "\tconfig_port_nodes: "
1679                             "Port %d is down", port_attr->pa_port_num);
1680                         ibdm_ibnex_free_port_attr(port_attr);
1681                         mutex_exit(&ibnex.ibnex_mutex);
1682                         return (NULL);
1683                 }
1684                 for (ii = 0; ii < port_attr->pa_npkeys; ii++) {
1685                         if (pkey == port_attr->pa_pkey_tbl[ii].pt_pkey) {
1686                                 cdip = ibnex_commsvc_initnode(parent, port_attr,
1687                                     index, IBNEX_VPPA_COMMSVC_NODE,
1688                                     pkey, &rval, IBNEX_CFGADM_ENUMERATE);
1689                                 IBTF_DPRINTF_L5("ibnex",
1690                                     "\t ibnex_commsvc_initnode rval %x", rval);
1691                                 break;
1692                         }
1693                 }
1694         }
1695         mutex_exit(&ibnex.ibnex_mutex);
1696         if (port_num != 0)
1697                 ibdm_ibnex_free_port_attr(port_attr);
1698         else
1699                 ibdm_ibnex_free_hca_list(hca_list);
1700         return (cdip);
1701 }
1702 
1703 
1704 /*
1705  * ibnex_get_pkey_commsvc_index_portnum()
1706  *      Parses the device node name and extracts PKEY, communication
1707  *      service index & Port #.
1708  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
1709  */
1710 int
1711 ibnex_get_pkey_commsvc_index_portnum(char *device_name, int *index,
1712     ib_pkey_t *pkey, uint8_t *port_num)
1713 {
1714         char    *srv, **service_name, *temp;
1715         int     ii, ncommsvcs, ret;
1716 
1717         if (ibnex_devname_to_portnum(device_name, port_num) !=
1718             IBNEX_SUCCESS) {
1719                 IBTF_DPRINTF_L2("ibnex",
1720                     "\tget_pkey_commsvc_index_portnum: Invalid Service Name");
1721                 return (IBNEX_FAILURE);
1722         }
1723         srv = strchr(device_name, ',');
1724         if (srv == 0)
1725                 return (IBNEX_FAILURE);
1726 
1727         srv++;
1728         temp = strchr(srv, ',');
1729         if (temp == 0)
1730                 return (IBNEX_FAILURE);
1731         temp++;
1732         *pkey = ibnex_str2hex(srv, (temp - srv - 1), &ret);
1733         if (ret != IBNEX_SUCCESS)
1734                 return (ret);
1735 
1736         if (*pkey == 0 && *port_num != 0) {
1737                 service_name = ibnex.ibnex_comm_svc_names;
1738                 ncommsvcs = ibnex.ibnex_num_comm_svcs;
1739         } else if (*pkey == 0 && *port_num == 0) {
1740                 service_name = ibnex.ibnex_hcasvc_comm_svc_names;
1741                 ncommsvcs = ibnex.ibnex_nhcasvc_comm_svcs;
1742         } else {
1743                 service_name = ibnex.ibnex_vppa_comm_svc_names;
1744                 ncommsvcs = ibnex.ibnex_nvppa_comm_svcs;
1745         }
1746 
1747         for (ii = 0; ii < ncommsvcs; ii++) {
1748                 if (strcmp(service_name[ii], temp) == 0) {
1749                         break;
1750                 }
1751         }
1752         if (ii == ncommsvcs)
1753                 return (IBNEX_FAILURE);
1754 
1755         *index = ii;
1756         return (IBNEX_SUCCESS);
1757 }
1758 
1759 
1760 /*
1761  * ibnex_devname_to_portnum()
1762  *      Get portguid from device name
1763  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
1764  */
1765 static int
1766 ibnex_devname_to_portnum(char *device_name, uint8_t *portnum)
1767 {
1768         int     ret;
1769         char    *temp1, *temp2;
1770 
1771         temp1 = strchr(device_name, '@');
1772         if (temp1 == NULL) {
1773                 return (IBNEX_FAILURE);
1774         }
1775         temp2 = strchr(temp1, ',');
1776         if (temp2 == NULL)
1777                 return (IBNEX_FAILURE);
1778         temp1++;
1779         *portnum = ibnex_str2hex(temp1, (temp2 - temp1), &ret);
1780         return (ret);
1781 }
1782 
1783 
1784 /*
1785  * ibnex_config_ioc_node()
1786  *      Configures one particular instance of the IOC driver.
1787  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
1788  */
1789 static int
1790 ibnex_config_ioc_node(char *device_name, dev_info_t *pdip)
1791 {
1792         int                     ret;
1793         ib_guid_t               iou_guid, ioc_guid;
1794         ibdm_ioc_info_t         *ioc_info;
1795 
1796         IBTF_DPRINTF_L4("ibnex", "\tconfig_ioc_node: Begin");
1797 
1798         if (ibnex_devname_to_node_n_ioc_guids(
1799             device_name, &iou_guid, &ioc_guid, NULL) != IBNEX_SUCCESS) {
1800                 return (IBNEX_FAILURE);
1801         }
1802 
1803         ibdm_ibnex_port_settle_wait(0, ibnex_port_settling_time);
1804 
1805         if ((ioc_info = ibdm_ibnex_probe_ioc(iou_guid, ioc_guid, 0)) ==
1806             NULL) {
1807                 ibdm_ibnex_free_ioc_list(ioc_info);
1808                 return (IBNEX_FAILURE);
1809         }
1810         mutex_enter(&ibnex.ibnex_mutex);
1811         ret = ibnex_ioc_config_from_pdip(ioc_info, pdip, 0);
1812         mutex_exit(&ibnex.ibnex_mutex);
1813         ibdm_ibnex_free_ioc_list(ioc_info);
1814         IBTF_DPRINTF_L4("ibnex", "\tconfig_ioc_node: ret %x",
1815             ret);
1816         return (ret);
1817 }
1818 
1819 
1820 /*
1821  * ibnex_devname_to_node_n_ioc_guids()
1822  *      Get node guid and ioc guid from the device name
1823  *      Format of the device node name is:
1824  *              ioc@<IOC GUID>,<IOU GUID>
1825  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
1826  */
1827 static int
1828 ibnex_devname_to_node_n_ioc_guids(
1829     char *device_name, ib_guid_t *iou_guid, ib_guid_t *ioc_guid,
1830     char **ioc_guid_strp)
1831 {
1832         char    *temp1, *temp;
1833         int     len, ret;
1834         char    *ioc_guid_str;
1835 
1836         IBTF_DPRINTF_L4("ibnex", "\tdevname_to_node_n_ioc_guids:"
1837             "Device Name %s", device_name);
1838 
1839         if ((temp = strchr(device_name, '@')) == NULL) {
1840                 return (IBNEX_FAILURE);
1841         }
1842         if ((temp1 = strchr(++temp, ',')) == NULL) {
1843                 return (IBNEX_FAILURE);
1844         }
1845         *ioc_guid = ibnex_str2hex(temp, (temp1 - temp), &ret);
1846         if (ret == IBNEX_SUCCESS) {
1847                 if (ioc_guid_strp) {
1848                         ioc_guid_str = *ioc_guid_strp = kmem_zalloc((temp1
1849                             - temp) + 1, KM_SLEEP);
1850                         (void) strncpy(ioc_guid_str, temp, temp1 - temp + 1);
1851                         ioc_guid_str[temp1 - temp] = '\0';
1852                 }
1853                 len = device_name + strlen(device_name) - ++temp1;
1854                 *iou_guid = ibnex_str2hex(temp1, len, &ret);
1855         }
1856         return (ret);
1857 }
1858 
1859 
1860 /*
1861  * ibnex_ioc_initnode()
1862  *      Allocate a pathinfo node for the IOC
1863  *      Initialize the device node
1864  *      Bind driver to the node
1865  *      Update IBnex global data
1866  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE/IBNEX_BUSY
1867  */
1868 static int
1869 ibnex_ioc_initnode_pdip(ibnex_node_data_t *node_data,
1870     ibdm_ioc_info_t *ioc_info, dev_info_t *pdip)
1871 {
1872         int                     rval, node_valid;
1873         ibnex_node_state_t      prev_state;
1874 
1875         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
1876         ASSERT(node_data);
1877 
1878 
1879         /*
1880          * Return EBUSY if another configure/unconfigure
1881          * operation is in progress
1882          */
1883         if (node_data->node_state == IBNEX_CFGADM_UNCONFIGURING) {
1884                 IBTF_DPRINTF_L4("ibnex",
1885                     "\tioc_initnode_pdip : BUSY");
1886                 return (IBNEX_BUSY);
1887         }
1888 
1889         prev_state = node_data->node_state;
1890         node_data->node_state = IBNEX_CFGADM_CONFIGURING;
1891         mutex_exit(&ibnex.ibnex_mutex);
1892 
1893         rval = ibnex_ioc_create_pi(ioc_info, node_data, pdip, &node_valid);
1894 
1895         mutex_enter(&ibnex.ibnex_mutex);
1896         if (rval == IBNEX_SUCCESS)
1897                 node_data->node_state = IBNEX_CFGADM_CONFIGURED;
1898         else if (node_valid)
1899                 node_data->node_state = prev_state;
1900 
1901         return (rval);
1902 }
1903 
1904 /*
1905  * ibnex_config_pseudo_all()
1906  *      Configure all the pseudo nodes
1907  */
1908 static void
1909 ibnex_config_pseudo_all(dev_info_t *pdip)
1910 {
1911         ibnex_node_data_t       *nodep;
1912 
1913         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
1914 
1915         for (nodep = ibnex.ibnex_pseudo_node_head;
1916             nodep; nodep = nodep->node_next) {
1917                 (void) ibnex_pseudo_config_one(nodep, NULL, pdip);
1918         }
1919 }
1920 
1921 
1922 /*
1923  * ibnex_pseudo_config_one()
1924  */
1925 int
1926 ibnex_pseudo_config_one(ibnex_node_data_t *node_data, char *caddr,
1927     dev_info_t *pdip)
1928 {
1929         int                     rval;
1930         ibnex_pseudo_node_t     *pseudo;
1931         ibnex_node_state_t      prev_state;
1932 
1933         IBTF_DPRINTF_L4("ibnex", "\tpseudo_config_one(%p, %p, %p)",
1934             node_data, caddr, pdip);
1935 
1936         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
1937 
1938         if (node_data == NULL) {
1939                 IBTF_DPRINTF_L4("ibnex",
1940                     "\tpseudo_config_one: caddr = %s", caddr);
1941 
1942                 /*
1943                  * This function is now called with PHCI / HCA driver
1944                  * as parent. The format of devicename is :
1945                  *      <driver_name>@<driver_name>,<unit_address>
1946                  * The "caddr" part of the devicename matches the
1947                  * format of pseudo_node_addr.
1948                  *
1949                  * Use "caddr" to find a matching Pseudo node entry.
1950                  */
1951                 node_data = ibnex_is_node_data_present(IBNEX_PSEUDO_NODE,
1952                     (void *)caddr, 0, 0);
1953         }
1954 
1955         if (node_data == NULL) {
1956                 IBTF_DPRINTF_L2("ibnex",
1957                     "\tpseudo_config_one: Invalid node");
1958                 return (IBNEX_FAILURE);
1959         }
1960 
1961         if (node_data->node_ap_state == IBNEX_NODE_AP_UNCONFIGURED) {
1962                 IBTF_DPRINTF_L4("ibnex",
1963                     "\tpseudo_config_one: Unconfigured node");
1964                 return (IBNEX_FAILURE);
1965         }
1966 
1967         pseudo = &node_data->node_data.pseudo_node;
1968 
1969         /*
1970          * Do not enumerate nodes with ib-node-type set as "merge"
1971          */
1972         if (pseudo->pseudo_merge_node == 1) {
1973                 IBTF_DPRINTF_L4("ibnex",
1974                     "\tpseudo_config_one: merge_node");
1975                 return (IBNEX_FAILURE);
1976         }
1977 
1978         /*
1979          * Check if a PI has already been created for the PDIP.
1980          * If so, return SUCCESS.
1981          */
1982         if (node_data->node_dip != NULL && mdi_pi_find(pdip,
1983             pseudo->pseudo_node_addr, pseudo->pseudo_node_addr) != NULL) {
1984                 IBTF_DPRINTF_L4("ibnex",
1985                     "\tpseudo_config_one: PI created,"
1986                     " pdip %p, addr %s", pdip, pseudo->pseudo_node_addr);
1987                 return (IBNEX_SUCCESS);
1988         }
1989 
1990         /*
1991          * Return EBUSY if another unconfigure
1992          * operation is in progress
1993          */
1994         if (node_data->node_state == IBNEX_CFGADM_UNCONFIGURING) {
1995                 IBTF_DPRINTF_L4("ibnex",
1996                     "\tpseudo_config_one: BUSY");
1997                 return (IBNEX_BUSY);
1998         }
1999 
2000 
2001         prev_state = node_data->node_state;
2002         node_data->node_state = IBNEX_CFGADM_CONFIGURING;
2003 
2004         mutex_exit(&ibnex.ibnex_mutex);
2005         rval = ibnex_pseudo_create_pi_pdip(node_data, pdip);
2006         mutex_enter(&ibnex.ibnex_mutex);
2007 
2008         if (rval == IBNEX_SUCCESS) {
2009                 node_data->node_state = IBNEX_CFGADM_CONFIGURED;
2010         } else {
2011                 node_data->node_state = prev_state;
2012         }
2013 
2014         IBTF_DPRINTF_L4("ibnex", "\tpseudo_config_one: ret %x",
2015             rval);
2016         return (rval);
2017 }
2018 
2019 
2020 /*
2021  * ibnex_pseudo_mdi_config_one()
2022  *      This is similar to ibnex_pseudo_config_one. Few
2023  *      differences :
2024  *      1. parent device lock not held(no ndi_devi_enter)
2025  *      2. Called for IB Nexus as parent, not IB HCA as
2026  *         parent.
2027  *      3. Calls mdi_vhci_bus_config()
2028  * This function skips checks for node_state, initializing
2029  * node_state, node_dip, etc. These checks and initializations
2030  * are done when BUS_CONFIG is called with PHCI as the parent.
2031  */
2032 int
2033 ibnex_pseudo_mdi_config_one(int flag, void *devname, dev_info_t **child,
2034     char *cname, char *caddr)
2035 {
2036         int                     rval, len;
2037         char                    *node_addr;
2038         ibnex_node_data_t       *node_data;
2039 
2040         IBTF_DPRINTF_L4("ibnex", "\tpseudo_mdi_config_one:"
2041             "cname = %s caddr = %s", cname, caddr);
2042 
2043         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
2044 
2045         len = strlen(cname) + strlen(caddr) + 2;
2046         node_addr = (char *)kmem_alloc(len, KM_SLEEP);
2047 
2048         (void) snprintf(node_addr, len, "%s,%s", cname, caddr);
2049         node_data = ibnex_is_node_data_present(IBNEX_PSEUDO_NODE,
2050             (void *)node_addr, 0, 0);
2051         kmem_free(node_addr, len);
2052 
2053         if (node_data == NULL) {
2054                 IBTF_DPRINTF_L2("ibnex",
2055                     "\tpseudo_mdi_config_one: Invalid node");
2056                 return (IBNEX_FAILURE);
2057         }
2058 
2059         mutex_exit(&ibnex.ibnex_mutex);
2060         rval = mdi_vhci_bus_config(ibnex.ibnex_dip, flag, BUS_CONFIG_ONE,
2061             devname, child, node_data->node_data.pseudo_node.pseudo_node_addr);
2062         mutex_enter(&ibnex.ibnex_mutex);
2063 
2064         return (rval);
2065 }
2066 
2067 
2068 /*
2069  * ibnex_pseudo_create_all_pi()
2070  *      Create all path infos node for a pseudo entry
2071  */
2072 int
2073 ibnex_pseudo_create_all_pi(ibnex_node_data_t *nodep)
2074 {
2075         int             hcacnt, rc;
2076         int             hcafailcnt = 0;
2077         dev_info_t      *hca_dip;
2078         ibdm_hca_list_t *hca_list, *head;
2079 
2080         IBTF_DPRINTF_L4("ibnex", "\tpseudo_create_all_pi(%p)",
2081             nodep);
2082         ibdm_ibnex_get_hca_list(&hca_list, &hcacnt);
2083 
2084         head = hca_list;
2085 
2086         /*
2087          * We return failure even if we fail for all HCAs.
2088          */
2089         for (; hca_list != NULL; hca_list = hca_list->hl_next) {
2090                 hca_dip = ibtl_ibnex_hcaguid2dip(hca_list->hl_hca_guid);
2091                 rc = ibnex_pseudo_create_pi_pdip(nodep, hca_dip);
2092                 if (rc != IBNEX_SUCCESS)
2093                         hcafailcnt++;
2094         }
2095         if (head)
2096                 ibdm_ibnex_free_hca_list(head);
2097 
2098         if (hcafailcnt == hcacnt)
2099                 rc = IBNEX_FAILURE;
2100         else
2101                 rc = IBNEX_SUCCESS;
2102 
2103         IBTF_DPRINTF_L4("ibnex", "\tpseudo_create_all_pi rc %x",
2104             rc);
2105         return (rc);
2106 }
2107 
2108 static int
2109 ibnex_pseudo_create_pi_pdip(ibnex_node_data_t *nodep, dev_info_t *hca_dip)
2110 {
2111         mdi_pathinfo_t          *pip;
2112         int                     rval;
2113         dev_info_t              *cdip = NULL;
2114         ibnex_pseudo_node_t     *pseudo;
2115         int                     first_pi = 0;
2116 
2117         IBTF_DPRINTF_L4("ibnex", "\tpseudo_create_pi_pdip: %p, %p",
2118             nodep, hca_dip);
2119 
2120         pseudo = &nodep->node_data.pseudo_node;
2121 
2122         rval = mdi_pi_alloc(hca_dip,
2123             pseudo->pseudo_devi_name, pseudo->pseudo_node_addr,
2124             pseudo->pseudo_node_addr, 0, &pip);
2125 
2126         if (rval != MDI_SUCCESS) {
2127                 IBTF_DPRINTF_L2("ibnex", "\tpseudo_create_pi_pdip:"
2128                     " mdi_pi_alloc failed");
2129                 return (IBNEX_FAILURE);
2130         }
2131         cdip = mdi_pi_get_client(pip);
2132 
2133         if (nodep->node_dip == NULL) {
2134                 IBTF_DPRINTF_L4("ibnex",
2135                     "\tpseudo_create_pi: New dip %p", cdip);
2136 
2137                 first_pi = 1;
2138                 nodep->node_dip = cdip;
2139                 ddi_set_parent_data(cdip, nodep);
2140         }
2141 
2142         rval = mdi_pi_online(pip, 0);
2143 
2144         if (rval != MDI_SUCCESS) {
2145                 IBTF_DPRINTF_L2("ibnex",
2146                     "\tpseudo_create_pi: "
2147                     "mdi_pi_online: failed for pseudo dip %p,"
2148                     " rval %d", cdip, rval);
2149                 rval = IBNEX_FAILURE;
2150                 if (first_pi == 1) {
2151                         ddi_set_parent_data(cdip, NULL);
2152                         (void) ibnex_offline_childdip(cdip);
2153                         nodep->node_dip = NULL;
2154                 } else
2155                         (void) mdi_pi_free(pip, 0);
2156         } else
2157                 rval = IBNEX_SUCCESS;
2158         return (rval);
2159 }
2160 
2161 /*
2162  * ibnex_ioc_create_pi()
2163  *      Create a pathinfo node for the ioc node
2164  */
2165 static int
2166 ibnex_ioc_create_pi(ibdm_ioc_info_t *ioc_info, ibnex_node_data_t *node_data,
2167     dev_info_t *pdip, int *node_valid)
2168 {
2169         mdi_pathinfo_t          *pip;
2170         int                     rval = DDI_FAILURE;
2171         dev_info_t              *cdip = NULL;
2172         int                     create_prop = 0;
2173         ibnex_ioc_node_t        *ioc = &node_data->node_data.ioc_node;
2174 
2175         IBTF_DPRINTF_L4("ibnex",
2176             "\tibnex_ioc_create_pi(%p, %p, %p)", ioc_info, node_data, pdip);
2177         *node_valid = 1;
2178 
2179         /*
2180          * For CONFIG_ONE requests through HCA dip, alloc
2181          * for HCA dip driving BUS_CONFIG request.
2182          */
2183         rval =  mdi_pi_alloc(pdip, IBNEX_IOC_CNAME, ioc->ioc_guid_str,
2184             ioc->ioc_phci_guid, 0, &pip);
2185         if (rval != MDI_SUCCESS) {
2186                 IBTF_DPRINTF_L2("ibnex",
2187                     "\tioc_create_pi: mdi_pi_alloc(%p, %s. %s) failed",
2188                     pdip, ioc->ioc_guid_str, ioc->ioc_phci_guid);
2189                 return (IBNEX_FAILURE);
2190         }
2191         cdip = mdi_pi_get_client(pip);
2192 
2193         IBTF_DPRINTF_L4("ibnex", "\tioc_create_pi: IOC dip %p",
2194             cdip);
2195 
2196         if (node_data->node_dip == NULL) {
2197                 node_data->node_dip = cdip;
2198                 ddi_set_parent_data(cdip, node_data);
2199                 create_prop = 1;
2200                 IBTF_DPRINTF_L4("ibnex",
2201                     "\tioc_create_pi: creating prop");
2202                 if ((rval = ibnex_create_ioc_node_prop(
2203                     ioc_info, cdip)) != IBNEX_SUCCESS) {
2204                         IBTF_DPRINTF_L4("ibnex",
2205                             "\tioc_create_pi: creating prop failed");
2206                         ibnex_delete_ioc_node_data(node_data);
2207                         *node_valid = 0;
2208                         ddi_prop_remove_all(cdip);
2209                         ddi_set_parent_data(cdip, NULL);
2210 
2211                         (void) ibnex_offline_childdip(cdip);
2212                         return (IBNEX_FAILURE);
2213                 }
2214         }
2215 
2216         rval = mdi_pi_online(pip, 0);
2217 
2218         if (rval != MDI_SUCCESS) {
2219                 IBTF_DPRINTF_L2("ibnex", "\tioc_create_pi: "
2220                     "mdi_pi_online() failed ioc dip %p, rval %d",
2221                     cdip, rval);
2222                 rval = IBNEX_FAILURE;
2223                 if (create_prop) {
2224                         ddi_set_parent_data(cdip, NULL);
2225                         ddi_prop_remove_all(cdip);
2226                         ibnex_delete_ioc_node_data(node_data);
2227                         *node_valid = 0;
2228                         (void) ibnex_offline_childdip(cdip);
2229                 } else
2230                         (void) mdi_pi_free(pip, 0);
2231         } else
2232                 rval = IBNEX_SUCCESS;
2233 
2234         IBTF_DPRINTF_L4("ibnex", "\tioc_create_pi ret %x", rval);
2235         return (rval);
2236 }
2237 
2238 
2239 /*
2240  * ibnex_create_ioc_node_prop()
2241  *      Create IOC device node properties
2242  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
2243  */
2244 static int
2245 ibnex_create_ioc_node_prop(ibdm_ioc_info_t *ioc_info, dev_info_t *cdip)
2246 {
2247         uint16_t                 capabilities;
2248         ib_dm_ioc_ctrl_profile_t *ioc_profile = &ioc_info->ioc_profile;
2249 
2250         IBTF_DPRINTF_L4("ibnex", "\tcreate_ioc_node_prop");
2251 
2252         if (ibnex_create_ioc_compatible_prop(cdip,
2253             ioc_profile) != IBNEX_SUCCESS) {
2254                 return (IBNEX_FAILURE);
2255         }
2256         if ((ioc_info->ioc_iou_dc_valid) &&
2257             (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "iou-diagcode",
2258             ioc_info->ioc_iou_diagcode)) != DDI_PROP_SUCCESS) {
2259                 IBTF_DPRINTF_L2("ibnex",
2260                     "\tcreate_ioc_node_prop: iou-diagcode create failed");
2261                 return (IBNEX_FAILURE);
2262         }
2263         if ((ioc_info->ioc_diagdeviceid) && (ioc_info->ioc_dc_valid)) {
2264                 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "ioc-diagcode",
2265                     ioc_info->ioc_diagcode) != DDI_PROP_SUCCESS) {
2266                         IBTF_DPRINTF_L2("ibnex", "\tcreate_ioc_node_prop: "
2267                             "ioc-diagcode create failed");
2268                         return (IBNEX_FAILURE);
2269                 }
2270         }
2271         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "rdma-queue-depth",
2272             ioc_profile->ioc_rdma_read_qdepth) != DDI_PROP_SUCCESS) {
2273                 IBTF_DPRINTF_L2("ibnex",
2274                     "\tcreate_ioc_node_prop: rdma-queue-depth create failed");
2275                 return (IBNEX_FAILURE);
2276         }
2277         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "rdma-transfer-size",
2278             ioc_profile->ioc_rdma_xfer_sz) != DDI_PROP_SUCCESS) {
2279                 IBTF_DPRINTF_L2("ibnex", "\tcreate_ioc_node_prop: "
2280                     "rdma-transfer-size create failed");
2281                 return (IBNEX_FAILURE);
2282         }
2283         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "send-message-size",
2284             ioc_profile->ioc_send_msg_sz) != DDI_PROP_SUCCESS) {
2285                 IBTF_DPRINTF_L2("ibnex",
2286                     "\tcreate_ioc_node_prop: send-message-size create failed");
2287                 return (IBNEX_FAILURE);
2288         }
2289         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "send-queue-depth",
2290             ioc_profile->ioc_send_msg_qdepth) != DDI_PROP_SUCCESS) {
2291                 IBTF_DPRINTF_L2("ibnex",
2292                     "\tcreate_ioc_node_prop: send-queue-depth create failed");
2293                 return (IBNEX_FAILURE);
2294         }
2295 
2296         capabilities = (ioc_profile->ioc_ctrl_opcap_mask << 8);
2297         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
2298             "capabilities", capabilities) != DDI_PROP_SUCCESS) {
2299                 IBTF_DPRINTF_L2("ibnex",
2300                     "\tcreate_ioc_node_prop: capabilities create failed");
2301                 return (IBNEX_FAILURE);
2302         }
2303         if (ndi_prop_update_string(DDI_DEV_T_NONE, cdip, "id-string",
2304             (char *)ioc_profile->ioc_id_string) != DDI_PROP_SUCCESS) {
2305                 IBTF_DPRINTF_L2("ibnex",
2306                     "\tcreate_ioc_node_prop: id-string failed");
2307                 return (IBNEX_FAILURE);
2308         }
2309 
2310         /*
2311          * Create properties to represent all the service entries supported
2312          * by the IOC. Each service entry consists of 1) Service ID (64 bits)
2313          * and 2) Service name (40 bytes). The service entry table is
2314          * represented by two properties, service-ids and service-names. The
2315          * service-id property is a array of int64's and service names is
2316          * array of strings. The first element in the "service-ids" property
2317          * corresponds to first string in the "service-names" and so on.
2318          */
2319         if ((ioc_profile->ioc_service_entries != 0) &&
2320             (ibnex_create_ioc_srv_props(cdip, ioc_info) != IBNEX_SUCCESS))
2321                 return (IBNEX_FAILURE);
2322 
2323         /* Create destination port GID properties */
2324         if (ibnex_create_ioc_portgid_prop(cdip, ioc_info) != IBNEX_SUCCESS)
2325                 return (IBNEX_FAILURE);
2326 
2327         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "protocol-version",
2328             ioc_profile->ioc_protocol_ver) != DDI_PROP_SUCCESS) {
2329                 IBTF_DPRINTF_L2("ibnex",
2330                     "\tcreate_ioc_node_prop: protocol-version create failed");
2331                 return (IBNEX_FAILURE);
2332         }
2333         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "protocol",
2334             ioc_profile->ioc_protocol) != DDI_PROP_SUCCESS) {
2335                 IBTF_DPRINTF_L2("ibnex",
2336                     "\tcreate_ioc_node_prop: protocol create failed");
2337                 return (IBNEX_FAILURE);
2338         }
2339         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "io-subclass",
2340             ioc_profile->ioc_io_subclass) != DDI_PROP_SUCCESS) {
2341                 IBTF_DPRINTF_L2("ibnex",
2342                     "\tcreate_ioc_node_prop: subclass create failed");
2343                 return (IBNEX_FAILURE);
2344         }
2345         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "io-class",
2346             ioc_profile->ioc_io_class) != DDI_PROP_SUCCESS) {
2347                 IBTF_DPRINTF_L2("ibnex",
2348                     "\tcreate_ioc_node_prop: class prop create failed");
2349                 return (IBNEX_FAILURE);
2350         }
2351         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "subsystem-id",
2352             ioc_profile->ioc_subsys_id) != DDI_PROP_SUCCESS) {
2353                 IBTF_DPRINTF_L2("ibnex",
2354                     "\tcreate_ioc_node_prop: subsys_id create failed");
2355                 return (IBNEX_FAILURE);
2356         }
2357         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "subsystem-vendor-id",
2358             ioc_profile->ioc_subsys_vendorid) != DDI_PROP_SUCCESS) {
2359                 IBTF_DPRINTF_L2("ibnex",
2360                     "\tcreate_ioc_node_prop: subsystem vendor create failed");
2361                 return (IBNEX_FAILURE);
2362         }
2363         if (ndi_prop_update_int64(DDI_DEV_T_NONE, cdip, "ioc-guid",
2364             ioc_profile->ioc_guid) != DDI_PROP_SUCCESS) {
2365                 IBTF_DPRINTF_L2("ibnex",
2366                     "\tcreate_ioc_node_prop: protocol create failed");
2367                 return (IBNEX_FAILURE);
2368         }
2369         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "device-version",
2370             ioc_profile->ioc_device_ver) != DDI_PROP_SUCCESS) {
2371                 IBTF_DPRINTF_L2("ibnex",
2372                     "\tcreate_ioc_node_prop: product-id create failed");
2373                 return (IBNEX_FAILURE);
2374         }
2375         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "device-id",
2376             ioc_profile->ioc_deviceid) != DDI_PROP_SUCCESS) {
2377                 IBTF_DPRINTF_L2("ibnex",
2378                     "\tcreate_ioc_node_prop: product-id create failed");
2379                 return (IBNEX_FAILURE);
2380         }
2381         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "vendor-id",
2382             ioc_profile->ioc_vendorid) != DDI_PROP_SUCCESS) {
2383                 IBTF_DPRINTF_L2("ibnex",
2384                     "\tcreate_ioc_node_prop: vendor-id create failed");
2385                 return (IBNEX_FAILURE);
2386         }
2387         return (IBNEX_SUCCESS);
2388 }
2389 
2390 
2391 /*
2392  * ibnex_create_ioc_portgid_prop()
2393  *      Creates "port-entries", "port-list" properties
2394  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
2395  */
2396 static int
2397 ibnex_create_ioc_portgid_prop(
2398     dev_info_t *cdip, ibdm_ioc_info_t *ioc_info)
2399 {
2400         uint64_t        *port_gids;
2401         int             length, ii, jj;
2402         int             prop_len;
2403         ibnex_node_data_t *node_data;
2404 
2405         IBTF_DPRINTF_L4("ibnex", "\tcreate_ioc_portgid_prop");
2406 
2407         node_data = ddi_get_parent_data(cdip);
2408         ASSERT(node_data);
2409 
2410         prop_len = (ioc_info->ioc_nportgids != 0) ?
2411             (2 * ioc_info->ioc_nportgids) : 1;
2412         length = sizeof (uint64_t) * prop_len;
2413         port_gids = kmem_zalloc(length, KM_SLEEP);
2414 
2415         for (ii = 0, jj = 0; ii < ioc_info->ioc_nportgids; ii++) {
2416                 port_gids[jj++] = ioc_info->ioc_gid_list[ii].gid_dgid_hi;
2417                 port_gids[jj++] = ioc_info->ioc_gid_list[ii].gid_dgid_lo;
2418         }
2419         if (ndi_prop_update_int64_array(DDI_DEV_T_NONE, cdip, "port-list",
2420             (int64_t *)port_gids, prop_len) != DDI_PROP_SUCCESS) {
2421                 IBTF_DPRINTF_L2("ibnex",
2422                     "\tcreate_ioc_portgid_prop: port-list create failed");
2423                 kmem_free(port_gids, length);
2424                 return (IBNEX_FAILURE);
2425         }
2426         if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "port-entries",
2427             ioc_info->ioc_nportgids) != DDI_PROP_SUCCESS) {
2428                 IBTF_DPRINTF_L2("ibnex",
2429                     "\tcreate_ioc_portgid_prop: port-entries create failed");
2430                 kmem_free(port_gids, length);
2431                 return (IBNEX_FAILURE);
2432         }
2433 
2434         kmem_free(port_gids, length);
2435         return (IBNEX_SUCCESS);
2436 }
2437 
2438 
2439 /*
2440  * ibnex_create_ioc_srv_props()
2441  *      Creates "service-name" and "service-id" properties
2442  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
2443  */
2444 static int
2445 ibnex_create_ioc_srv_props(
2446     dev_info_t *cdip, ibdm_ioc_info_t *ioc_info)
2447 {
2448         int                     length, ii;
2449         uint64_t                *srv_id;
2450         char                    *temp, *srv_names[IB_DM_MAX_IOCS_IN_IOU];
2451         ib_dm_ioc_ctrl_profile_t *profile = &ioc_info->ioc_profile;
2452         ibdm_srvents_info_t      *srvents = ioc_info->ioc_serv;
2453 
2454         IBTF_DPRINTF_L4("ibnex", "\tcreate_ioc_srv_props");
2455 
2456         length = profile->ioc_service_entries * sizeof (ib_dm_srv_t);
2457         srv_id = kmem_zalloc(length, KM_SLEEP);
2458         temp = (char *)((char *)srv_id + (8 * profile->ioc_service_entries));
2459         for (ii = 0; ii < profile->ioc_service_entries; ii++) {
2460                 srv_names[ii] = (char *)temp + (ii * IB_DM_MAX_SVC_NAME_LEN);
2461         }
2462 
2463         for (ii = 0; ii < profile->ioc_service_entries; ii++) {
2464                 srv_id[ii] = srvents[ii].se_attr.srv_id;
2465                 bcopy(srvents[ii].se_attr.srv_name,
2466                     srv_names[ii], (IB_DM_MAX_SVC_NAME_LEN - 1));
2467                 IBTF_DPRINTF_L4("ibnex", "\tcreate_ioc_srv_props "
2468                     "Service Names : %s", srv_names[ii]);
2469                 IBTF_DPRINTF_L4("ibnex", "\tcreate_ioc_srv_props "
2470                     "Service ID : %llX", srv_id[ii]);
2471         }
2472 
2473         if (ndi_prop_update_int64_array(DDI_DEV_T_NONE, cdip,
2474             "service-id", (int64_t *)srv_id,
2475             profile->ioc_service_entries) != DDI_PROP_SUCCESS) {
2476                 IBTF_DPRINTF_L2("ibnex",
2477                     "\tcreate_ioc_srv_props: service-id create failed");
2478                 kmem_free(srv_id, length);
2479                 return (IBNEX_FAILURE);
2480         }
2481 
2482         if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip,
2483             "service-name", (char **)srv_names,
2484             profile->ioc_service_entries) != DDI_PROP_SUCCESS) {
2485                 IBTF_DPRINTF_L2("ibnex",
2486                     "\tcreate_ioc_srv_props: service-name create failed");
2487                 kmem_free(srv_id, length);
2488                 return (IBNEX_FAILURE);
2489         }
2490         kmem_free(srv_id, length);
2491         return (IBNEX_SUCCESS);
2492 }
2493 
2494 
2495 /*
2496  * ibnex_create_ioc_compatible_prop()
2497  *      Creates "compatible" property values
2498  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
2499  */
2500 static int
2501 ibnex_create_ioc_compatible_prop(
2502     dev_info_t *cdip, ib_dm_ioc_ctrl_profile_t *ioc_profile)
2503 {
2504         char            *temp;
2505         int             rval, ii;
2506         char            *compatible[IBNEX_MAX_COMPAT_NAMES];
2507 
2508         /*
2509          * Initialize the "compatible" property string as below:
2510          * Compatible Strings :
2511          *      1. ib.V<vid>P<pid>S<subsys vid>s<subsys id>v<ver>
2512          *      2. ib.V<vid>P<pid>S<subsys vid>s<subsys id>
2513          *      3. ib.V<vid>P<pid>v<ver>
2514          *      4. ib.V<vid>P<pid>
2515          *      5. ib.C<Class>c<Subclass>p<protocol>r<protocol ver>
2516          *      6. ib.C<Class>c<Subclass>p<protocol>
2517          *
2518          * Note:
2519          *      All leading zeros must be present
2520          *      All numeric values must specified in hex without prefix "0x"
2521          */
2522 
2523         temp = kmem_alloc(IBNEX_MAX_COMPAT_PROP_SZ, KM_SLEEP);
2524         for (ii = 0; ii < IBNEX_MAX_COMPAT_NAMES; ii++)
2525                 compatible[ii] = temp + (ii * IBNEX_MAX_COMPAT_LEN);
2526 
2527         (void) snprintf(compatible[0], IBNEX_MAX_COMPAT_LEN,
2528             "ib.V%06xP%08xS%06xs%08xv%04x",
2529             ioc_profile->ioc_vendorid, ioc_profile->ioc_deviceid,
2530             ioc_profile->ioc_subsys_vendorid, ioc_profile->ioc_subsys_id,
2531             ioc_profile->ioc_device_ver);
2532 
2533         (void) snprintf(compatible[1], IBNEX_MAX_COMPAT_LEN,
2534             "ib.V%06xP%08xS%06xs%08x",
2535             ioc_profile->ioc_vendorid, ioc_profile->ioc_deviceid,
2536             ioc_profile->ioc_subsys_vendorid, ioc_profile->ioc_subsys_id);
2537 
2538         (void) snprintf(compatible[2], IBNEX_MAX_COMPAT_LEN,
2539             "ib.V%06xP%08xv%04x",
2540             ioc_profile->ioc_vendorid, ioc_profile->ioc_deviceid,
2541             ioc_profile->ioc_device_ver);
2542 
2543         (void) snprintf(compatible[3], IBNEX_MAX_COMPAT_LEN,
2544             "ib.V%06xP%08x",
2545             ioc_profile->ioc_vendorid, ioc_profile->ioc_deviceid);
2546 
2547         (void) snprintf(compatible[4], IBNEX_MAX_COMPAT_LEN,
2548             "ib.C%04xc%04xp%04xr%04x",
2549             ioc_profile->ioc_io_class, ioc_profile->ioc_io_subclass,
2550             ioc_profile->ioc_protocol, ioc_profile->ioc_protocol_ver);
2551 
2552         (void) snprintf(compatible[5], IBNEX_MAX_COMPAT_LEN,
2553             "ib.C%04xc%04xp%04x",
2554             ioc_profile->ioc_io_class, ioc_profile->ioc_io_subclass,
2555             ioc_profile->ioc_protocol);
2556         for (ii = 0; ii < IBNEX_MAX_COMPAT_NAMES; ii++)
2557                 IBTF_DPRINTF_L4("ibnex", "\tcompatible: %s", compatible[ii]);
2558 
2559         /* Create the compatible property for child cdip */
2560         rval = ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip,
2561             "compatible", (char **)compatible, IBNEX_MAX_COMPAT_NAMES);
2562 
2563         if (rval != DDI_PROP_SUCCESS) {
2564                 IBTF_DPRINTF_L2("ibnex", "\tcompatible prop_create failed");
2565                 kmem_free(temp, IBNEX_MAX_COMPAT_PROP_SZ);
2566                 return (IBNEX_FAILURE);
2567         }
2568 
2569         kmem_free(temp, IBNEX_MAX_COMPAT_PROP_SZ);
2570         return (IBNEX_SUCCESS);
2571 }
2572 
2573 
2574 static void
2575 ibnex_ioc_node_cleanup()
2576 {
2577         ibnex_node_data_t *node, *delete;
2578 
2579         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
2580         for (node = ibnex.ibnex_ioc_node_head; node; ) {
2581                 delete = node;
2582                 node = node->node_next;
2583                 mutex_exit(&ibnex.ibnex_mutex);
2584                 ibnex_delete_ioc_node_data(delete);
2585                 mutex_enter(&ibnex.ibnex_mutex);
2586         }
2587 }
2588 
2589 /*
2590  * ibnex_delete_ioc_node_data()
2591  *      Delete IOC node from the list
2592  */
2593 static void
2594 ibnex_delete_ioc_node_data(ibnex_node_data_t *node)
2595 {
2596         IBTF_DPRINTF_L4("ibnex", "\tdelete_ioc_node_data:");
2597 
2598         mutex_enter(&ibnex.ibnex_mutex);
2599         if ((node->node_next == NULL) && (node->node_prev == NULL)) {
2600                 ASSERT(ibnex.ibnex_ioc_node_head == node);
2601                 ibnex.ibnex_ioc_node_head = NULL;
2602         } else if (node->node_next == NULL)
2603                 node->node_prev->node_next = NULL;
2604         else if (node->node_prev == NULL) {
2605                 node->node_next->node_prev = NULL;
2606                 ibnex.ibnex_ioc_node_head = node->node_next;
2607         } else {
2608                 node->node_prev->node_next = node->node_next;
2609                 node->node_next->node_prev = node->node_prev;
2610         }
2611         IBTF_DPRINTF_L4("ibnex", "\tdelete_ioc_node_data: head %p",
2612             ibnex.ibnex_ioc_node_head);
2613         mutex_exit(&ibnex.ibnex_mutex);
2614         kmem_free(node, sizeof (ibnex_node_data_t));
2615 }
2616 
2617 
2618 /*
2619  * ibnex_dm_callback()
2620  *
2621  *      This routine is registered with the IBDM during IB nexus attach. It
2622  *      is called by the IBDM module when it discovers
2623  *              New HCA port
2624  *              HCA port removal
2625  *              New HCA added
2626  *              HCA removed
2627  */
2628 void
2629 ibnex_dm_callback(void *arg, ibdm_events_t flag)
2630 {
2631         char    hca_guid[IBNEX_HCAGUID_STRSZ];
2632         ibdm_ioc_info_t *ioc_list, *ioc;
2633         ibnex_node_data_t       *node_data;
2634         dev_info_t              *phci;
2635         ib_guid_t               *guid;
2636 
2637         IBTF_DPRINTF_L4("ibnex", "\tdm_callback: attr %p event %x", arg, flag);
2638 
2639         switch (flag) {
2640         case IBDM_EVENT_HCA_ADDED:
2641                 (void) snprintf(hca_guid, IBNEX_HCAGUID_STRSZ, "%llX",
2642                     (*(longlong_t *)arg));
2643                 /* Create a devctl minor node for the HCA's port  */
2644                 if (ddi_create_minor_node(ibnex.ibnex_dip, hca_guid, S_IFCHR,
2645                     ddi_get_instance(ibnex.ibnex_dip),
2646                     DDI_NT_IB_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
2647                         IBTF_DPRINTF_L4("ibnex", "\tdm_callback: failed to "
2648                             "create minor node for port w/ guid %s", hca_guid);
2649                 }
2650 
2651                 guid = kmem_alloc(sizeof (ib_guid_t), KM_SLEEP);
2652                 *guid = *(ib_guid_t *)arg;
2653                 if (ddi_taskq_dispatch(ibnex.ibnex_taskq_id,
2654                     ibnex_handle_hca_attach, guid, DDI_NOSLEEP)
2655                     != DDI_SUCCESS) {
2656                         kmem_free(guid, sizeof (ib_guid_t));
2657                         IBTF_DPRINTF_L4("ibnex", "\tdm_callback: failed to "
2658                             "dispatch HCA add event for guid %s", hca_guid);
2659                 }
2660 
2661                 break;
2662 
2663         case IBDM_EVENT_HCA_REMOVED:
2664                 (void) snprintf(hca_guid, IBNEX_HCAGUID_STRSZ, "%llX",
2665                     (*(longlong_t *)arg));
2666                 ddi_remove_minor_node(ibnex.ibnex_dip, hca_guid);
2667                 break;
2668 
2669         case IBDM_EVENT_IOC_PROP_UPDATE:
2670                 ioc = ioc_list = (ibdm_ioc_info_t *)arg;
2671                 if (ioc_list == NULL)
2672                         break;
2673 
2674                 mutex_enter(&ibnex.ibnex_mutex);
2675                 while (ioc_list) {
2676                         if ((node_data = ibnex_is_node_data_present(
2677                             IBNEX_IOC_NODE, ioc_list, 0, 0)) != NULL &&
2678                             node_data->node_dip != NULL) {
2679                                 ibnex_update_prop(node_data, ioc_list);
2680                         }
2681                         ioc_list = ioc_list->ioc_next;
2682                 }
2683                 mutex_exit(&ibnex.ibnex_mutex);
2684                 ibdm_ibnex_free_ioc_list(ioc);
2685                 break;
2686 
2687         case IBDM_EVENT_PORT_UP:
2688         case IBDM_EVENT_PORT_PKEY_CHANGE:
2689                 phci = ibtl_ibnex_hcaguid2dip(*(longlong_t *)arg);
2690                 (void) devfs_clean(phci, NULL, 0);
2691                 break;
2692         default:
2693                 break;
2694 
2695         }
2696 }
2697 
2698 
2699 /*
2700  * ibnex_get_node_and_dip_from_guid()
2701  *
2702  *      Searches the linked list of the port nodes and returns the dip for
2703  *      the of the Port / Node guid requested.
2704  *      Returns NULL if not found
2705  */
2706 int
2707 ibnex_get_node_and_dip_from_guid(ib_guid_t guid, int index, ib_pkey_t pkey,
2708     ibnex_node_data_t **nodep, dev_info_t **dip)
2709 {
2710         int                     node_index;
2711         ib_guid_t               node_guid;
2712         ib_pkey_t               node_pkey;
2713         ibnex_node_data_t       *node_data;
2714 
2715         IBTF_DPRINTF_L4("ibnex",
2716             "\tget_node_and_dip_from_guid: guid = %llX", guid);
2717 
2718         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
2719         /* Search for a matching entry in internal lists */
2720         node_data = ibnex.ibnex_port_node_head;
2721         while (node_data) {
2722                 node_guid = node_data->node_data.port_node.port_guid;
2723                 node_index = node_data->node_data.port_node.port_commsvc_idx;
2724                 node_pkey = node_data->node_data.port_node.port_pkey;
2725                 if ((node_guid == guid) && (index == node_index) &&
2726                     (node_pkey == pkey)) {
2727                         break;
2728                 }
2729                 node_data = node_data->node_next;
2730         }
2731 
2732         /* matching found with a valid dip */
2733         if (node_data && node_data->node_dip) {
2734                 *nodep = node_data;
2735                 *dip = node_data->node_dip;
2736                 return (IBNEX_SUCCESS);
2737         } else if (node_data && !node_data->node_dip) {      /* dip is invalid */
2738                 *nodep = node_data;
2739                 *dip = NULL;
2740                 return (IBNEX_SUCCESS);
2741         }
2742 
2743         /* no match found */
2744         *nodep = NULL;
2745         *dip = NULL;
2746         return (IBNEX_FAILURE);
2747 }
2748 
2749 /*
2750  * ibnex_get_dip_from_guid()
2751  *
2752  *      Searches the linked list of the port nodes and returns the dip for
2753  *      the of the Port / Node guid requested.
2754  *      Returns NULL if not found
2755  */
2756 int
2757 ibnex_get_dip_from_guid(ib_guid_t guid, int index, ib_pkey_t pkey,
2758     dev_info_t **dip)
2759 {
2760         int                     node_index;
2761         ib_guid_t               node_guid;
2762         ib_pkey_t               node_pkey;
2763         ibnex_node_data_t       *node_data;
2764 
2765         IBTF_DPRINTF_L4("ibnex",
2766             "\tget_dip_from_guid: guid = %llX", guid);
2767 
2768         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
2769         /* Search for a matching entry in internal lists */
2770         node_data = ibnex.ibnex_port_node_head;
2771         while (node_data) {
2772                 node_guid = node_data->node_data.port_node.port_guid;
2773                 node_index = node_data->node_data.port_node.port_commsvc_idx;
2774                 node_pkey = node_data->node_data.port_node.port_pkey;
2775                 if ((node_guid == guid) && (index == node_index) &&
2776                     (node_pkey == pkey)) {
2777                         break;
2778                 }
2779                 node_data = node_data->node_next;
2780         }
2781 
2782         /* matching found with a valid dip */
2783         if (node_data && node_data->node_dip) {
2784                 *dip = node_data->node_dip;
2785                 return (IBNEX_SUCCESS);
2786         } else if (node_data && !node_data->node_dip) {      /* dip is invalid */
2787                 *dip = NULL;
2788                 return (IBNEX_SUCCESS);
2789         }
2790 
2791         /* no match found */
2792         *dip = NULL;
2793         return (IBNEX_FAILURE);
2794 }
2795 
2796 
2797 /*
2798  * ibnex_comm_svc_init()
2799  *      Read the property and cache the values in the global
2800  *      structure.
2801  *      Check for max allowed length (4 bytes) of service name
2802  *      (each element of the property)
2803  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
2804  */
2805 static ibnex_rval_t
2806 ibnex_comm_svc_init(char *property, ibnex_node_type_t type)
2807 {
2808         int             i, len, count;
2809         int             ncomm_svcs;
2810         char            **comm_svcp;
2811         char            **servicep = NULL;
2812         uint_t          nservices = 0;
2813         int                     *valid = NULL;
2814 
2815         IBTF_DPRINTF_L4("ibnex", "\tcomm_svc_init : %s property, type = %x",
2816             property, type);
2817 
2818         /* lookup the string array property */
2819         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, ibnex.ibnex_dip,
2820             DDI_PROP_DONTPASS, property, &servicep, &nservices) !=
2821             DDI_PROP_SUCCESS) {
2822                 IBTF_DPRINTF_L2("ibnex", "\t%s property undefined", property);
2823                 return (IBNEX_SUCCESS);
2824         }
2825 
2826         if (nservices)
2827                 valid = kmem_zalloc(nservices * sizeof (int), KM_SLEEP);
2828 
2829 
2830         /* first read the file to get a count of valid service entries */
2831         for (ncomm_svcs = 0, count = 0; count < nservices; count++) {
2832                 int j;
2833 
2834                 len = strlen(servicep[count]);
2835                 /*
2836                  * ib.conf has NULL strings for port-svc-list &
2837                  * hca-svc-list, by default. Do not have L2 message
2838                  * for these.
2839                  */
2840                 if (len == 1 || len > 4) {
2841                         IBTF_DPRINTF_L2("ibnex", "\tcomm_svc_init : "
2842                             "Service name %s for property %s invalid : "
2843                             "length %d", servicep[count], property, len);
2844                         continue;
2845                 } else if (len == 0) {
2846                         continue;
2847                 }
2848                 if (ibnex_unique_svcname(servicep[count]) != IBNEX_SUCCESS) {
2849                         IBTF_DPRINTF_L2("ibnex", "\tcomm_svc_init : "
2850                             "Service name %s invalid : Not unique",
2851                             servicep[count]);
2852                         continue;
2853                 }
2854 
2855                 /*
2856                  * ibnex_unique_svcname checks for uniqueness in service names
2857                  * communication services fully initialized. Check uniqueness
2858                  * in service names currently initialized.
2859                  */
2860                 for (j = 0; j < count; j++)
2861                         if (valid[j] && strncmp(servicep[count],
2862                             servicep[j], 4) == 0) {
2863                                 IBTF_DPRINTF_L2("ibnex", "\tcomm_svc_init : "
2864                                     "Service name %s invalid : Not unique",
2865                                     servicep[count]);
2866                                         continue;
2867                         }
2868 
2869                 valid[count] = 1;
2870                 ncomm_svcs++;
2871         }
2872 
2873         /* if no valid entries found, bailout */
2874         if (nservices == 0 || ncomm_svcs == 0) {
2875                 IBTF_DPRINTF_L4("ibnex", "\tNo %s entries found", property);
2876                 ddi_prop_free(servicep); /* free the property */
2877                 if (valid)
2878                         kmem_free(valid, nservices * sizeof (int));
2879                 return (IBNEX_SUCCESS);
2880         }
2881 
2882         comm_svcp = kmem_zalloc((ncomm_svcs * sizeof (char *)), KM_SLEEP);
2883         if (type == IBNEX_PORT_COMMSVC_NODE) {
2884                 ibnex.ibnex_comm_svc_names = comm_svcp;
2885                 ibnex.ibnex_num_comm_svcs = ncomm_svcs;
2886         } else if (type == IBNEX_VPPA_COMMSVC_NODE) {
2887                 ibnex.ibnex_vppa_comm_svc_names = comm_svcp;
2888                 ibnex.ibnex_nvppa_comm_svcs = ncomm_svcs;
2889         } else if (type == IBNEX_HCASVC_COMMSVC_NODE) {
2890                 ibnex.ibnex_hcasvc_comm_svc_names = comm_svcp;
2891                 ibnex.ibnex_nhcasvc_comm_svcs = ncomm_svcs;
2892         }
2893 
2894         /* copy the services into an array of strings */
2895         for (i = 0, count = 0; count < nservices; count++) {
2896                 if (valid[count] == 0)  /* Skip invalid ones */
2897                         continue;
2898                 comm_svcp[i] = kmem_alloc(len + 1, KM_SLEEP);
2899                 (void) strcpy(comm_svcp[i], servicep[count]);
2900                 IBTF_DPRINTF_L4("ibnex",
2901                     "\t\tService [%d]: %s", i, comm_svcp[i]);
2902                 ++i;
2903         }
2904         ddi_prop_free(servicep);
2905         kmem_free(valid, nservices * sizeof (int));
2906         return (IBNEX_SUCCESS);
2907 }
2908 
2909 
2910 /*
2911  * ibnex_comm_svc_fini()
2912  *      Deallocate all the memory allocated for the communication
2913  *      service arrays.
2914  */
2915 static void
2916 ibnex_comm_svc_fini()
2917 {
2918         int     index;
2919 
2920         for (index = 0; index < ibnex.ibnex_num_comm_svcs; index++) {
2921                 kmem_free(ibnex.ibnex_comm_svc_names[index],
2922                     (strlen(ibnex.ibnex_comm_svc_names[index]) + 1));
2923         }
2924         if (ibnex.ibnex_comm_svc_names) {
2925                 kmem_free(ibnex.ibnex_comm_svc_names,
2926                     ibnex.ibnex_num_comm_svcs * sizeof (char *));
2927         }
2928         for (index = 0; index < ibnex.ibnex_nvppa_comm_svcs; index++) {
2929                 kmem_free(ibnex.ibnex_vppa_comm_svc_names[index],
2930                     strlen(ibnex.ibnex_vppa_comm_svc_names[index]) +1);
2931         }
2932         if (ibnex.ibnex_vppa_comm_svc_names) {
2933                 kmem_free(ibnex.ibnex_vppa_comm_svc_names,
2934                     ibnex.ibnex_nvppa_comm_svcs * sizeof (char *));
2935         }
2936         for (index = 0; index < ibnex.ibnex_nhcasvc_comm_svcs; index++) {
2937                 kmem_free(ibnex.ibnex_hcasvc_comm_svc_names[index],
2938                     strlen(ibnex.ibnex_hcasvc_comm_svc_names[index]) +1);
2939         }
2940         if (ibnex.ibnex_hcasvc_comm_svc_names) {
2941                 kmem_free(ibnex.ibnex_hcasvc_comm_svc_names,
2942                     ibnex.ibnex_nhcasvc_comm_svcs * sizeof (char *));
2943         }
2944         ibnex.ibnex_comm_svc_names = NULL;
2945         ibnex.ibnex_num_comm_svcs = 0;
2946         ibnex.ibnex_vppa_comm_svc_names = NULL;
2947         ibnex.ibnex_nvppa_comm_svcs = 0;
2948         ibnex.ibnex_hcasvc_comm_svc_names = NULL;
2949         ibnex.ibnex_nhcasvc_comm_svcs = 0;
2950 }
2951 
2952 
2953 /*
2954  * ibnex_commsvc_initnode()
2955  *      This routine is specific to port/VPPA node creation
2956  *      Creates a device node for the comm service specified by commsvc_index
2957  *      Creates all the device node properties
2958  *      Allocates and initializes the node specific data
2959  *      Binds the device driver of the device node
2960  *      Returns "dev_info_t" of the child node or NULL in case of failure
2961  *      Sets IBNEX_SUCCESS/IBNEX_FAILURE/IBNEX_BUSY in "rval" to reflect
2962  *      if the operation was successful, failed or was not performed.
2963  */
2964 dev_info_t *
2965 ibnex_commsvc_initnode(dev_info_t *parent, ibdm_port_attr_t *port_attr,
2966     int index, int node_type, ib_pkey_t pkey, int *rval, int flag)
2967 {
2968         int                     ret;
2969         char                    *svcname;
2970         dev_info_t              *cdip;
2971         ibnex_node_data_t       *node_data;
2972         ibnex_port_node_t       *port_node;
2973         char devname[MAXNAMELEN];
2974         int                     cdip_allocated = 0;
2975 
2976         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
2977 
2978         *rval = IBNEX_SUCCESS;
2979 
2980         /*
2981          * prevent any races
2982          * we have seen this node_data and it has been initialized
2983          * Note that node_dip is already NULL if unconfigure is in
2984          * progress.
2985          */
2986         node_data = ibnex_is_node_data_present(node_type, (void *)port_attr,
2987             index, pkey);
2988 
2989         /*
2990          * If this node has been explicity unconfigured by cfgadm, then it can
2991          * be configured back again only by cfgadm configure.
2992          */
2993         if (node_data && (node_data->node_ap_state ==
2994             IBNEX_NODE_AP_UNCONFIGURED)) {
2995                 *rval = IBNEX_FAILURE;
2996                 return (NULL);
2997         }
2998 
2999         if (node_data && node_data->node_dip) {
3000                 /*
3001                  * Return NULL if another configure
3002                  * operation is in progress
3003                  */
3004                 if (node_data->node_state == IBNEX_CFGADM_CONFIGURING) {
3005                         *rval = IBNEX_BUSY;
3006                         return (NULL);
3007                 } else {
3008                         return (node_data->node_dip);
3009                 }
3010         } else if (node_data == NULL) {
3011                 /* allocate a new ibnex_node_data_t */
3012                 node_data = ibnex_init_child_nodedata(node_type, port_attr,
3013                     index, pkey);
3014                 node_data->node_data.port_node.port_pdip = parent;
3015         }
3016 
3017         /*
3018          * Return NULL if another unconfigure operation is in progress
3019          */
3020         if (node_data->node_state == IBNEX_CFGADM_UNCONFIGURING) {
3021                 *rval = IBNEX_BUSY;
3022                 return (NULL);
3023         }
3024 
3025         ASSERT(node_data->node_state != IBNEX_CFGADM_CONFIGURED);
3026         node_data->node_state = IBNEX_CFGADM_CONFIGURING;
3027 
3028         switch (node_type) {
3029                 case IBNEX_VPPA_COMMSVC_NODE :
3030                         svcname = ibnex.ibnex_vppa_comm_svc_names[index];
3031                         port_node = &node_data->node_data.port_node;
3032                         (void) snprintf(devname, MAXNAMELEN, "%s@%x,%x,%s",
3033                             IBNEX_IBPORT_CNAME, port_node->port_num,
3034                             port_node->port_pkey, svcname);
3035                         break;
3036                 case IBNEX_HCASVC_COMMSVC_NODE :
3037                         svcname = ibnex.ibnex_hcasvc_comm_svc_names[index];
3038                         port_node = &node_data->node_data.port_node;
3039                         (void) snprintf(devname, MAXNAMELEN, "%s@%x,0,%s",
3040                             IBNEX_IBPORT_CNAME, port_node->port_num, svcname);
3041                         break;
3042                 case IBNEX_PORT_COMMSVC_NODE :
3043                         svcname = ibnex.ibnex_comm_svc_names[index];
3044                         port_node = &node_data->node_data.port_node;
3045                         (void) snprintf(devname, MAXNAMELEN, "%s@%x,0,%s",
3046                             IBNEX_IBPORT_CNAME, port_node->port_num, svcname);
3047                         break;
3048                 default :
3049                         IBTF_DPRINTF_L2("ibnex", "\tcommsvc_initnode:"
3050                             "\tInvalid Node type");
3051                         *rval = IBNEX_FAILURE;
3052                         ibnex_delete_port_node_data(node_data);
3053                         return (NULL);
3054         }
3055 
3056         if ((cdip = ndi_devi_findchild(parent, devname)) != NULL) {
3057                 if (i_ddi_devi_attached(cdip)) {
3058                         node_data->node_dip  = cdip;
3059                         node_data->node_data.port_node.port_pdip = parent;
3060                         node_data->node_state = IBNEX_CFGADM_CONFIGURED;
3061                         ddi_set_parent_data(cdip, node_data);
3062                         IBTF_DPRINTF_L4("ibnex", "\tcommsvc_initnode: found "
3063                             "attached cdip 0x%p for devname %s", cdip, devname);
3064                         return (cdip);
3065                 }
3066         } else {
3067                 ndi_devi_alloc_sleep(parent,
3068                     IBNEX_IBPORT_CNAME, (pnode_t)DEVI_SID_NODEID, &cdip);
3069                 cdip_allocated = 1;
3070         }
3071 
3072         node_data->node_dip  = cdip;
3073         ddi_set_parent_data(cdip, node_data);
3074         mutex_exit(&ibnex.ibnex_mutex);
3075 
3076 
3077         if (ibnex_create_port_node_prop(port_attr, cdip, svcname, pkey) ==
3078             IBNEX_SUCCESS) {
3079                 if (flag == IBNEX_DEVFS_ENUMERATE)
3080                         ret = ndi_devi_bind_driver(cdip, 0);
3081                 else
3082                         ret = ndi_devi_online(cdip, 0);
3083                 if (ret == NDI_SUCCESS) {
3084                         mutex_enter(&ibnex.ibnex_mutex);
3085                         node_data->node_state        = IBNEX_CFGADM_CONFIGURED;
3086                         node_data->node_data.port_node.port_pdip = parent;
3087                         return (cdip);
3088                 }
3089                 IBTF_DPRINTF_L4("ibnex", "\tcommsvc_initnode: BIND/ONLINE "
3090                     "of cdip 0x%p for devname %s and flag %d failed", cdip,
3091                     devname, flag);
3092         }
3093 
3094         *rval = IBNEX_FAILURE;
3095         node_data->node_dip = NULL;
3096         ddi_set_parent_data(cdip, NULL);
3097         if (cdip_allocated)
3098                 (void) ndi_devi_free(cdip);
3099         mutex_enter(&ibnex.ibnex_mutex);
3100         IBTF_DPRINTF_L4("ibnex", "\tcommsvc_initnode: failure exit");
3101         return (NULL);
3102 }
3103 
3104 
3105 /*
3106  * ibnex_create_port_node_prop()
3107  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
3108  */
3109 static int
3110 ibnex_create_port_node_prop(ibdm_port_attr_t *port_attr,
3111     dev_info_t *child_dip, char *srvname, ib_pkey_t pkey)
3112 {
3113         if (ibnex_create_port_compatible_prop(child_dip,
3114             srvname, port_attr) != DDI_PROP_SUCCESS) {
3115                 IBTF_DPRINTF_L2("ibnex",
3116                     "\tcreate_port_node_prop: compatible update failed");
3117                 return (IBNEX_FAILURE);
3118         }
3119         if ((pkey != 0) && (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip,
3120             "port-pkey", pkey) != DDI_PROP_SUCCESS)) {
3121                 IBTF_DPRINTF_L2("ibnex",
3122                     "\tcreate_port_node_prop: port-num update failed");
3123                 return (IBNEX_FAILURE);
3124         }
3125 
3126         /*
3127          * For HCA_SVC device nodes, port_num will be 0.
3128          * Do not create the "port-number" & "port-guid" properties.
3129          */
3130         if (port_attr->pa_port_num != 0) {
3131                 if (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip,
3132                     "port-number", port_attr->pa_port_num) !=
3133                     DDI_PROP_SUCCESS) {
3134                         IBTF_DPRINTF_L2("ibnex",
3135                             "\tcreate_port_node_prop: port-num update failed");
3136                         return (IBNEX_FAILURE);
3137                 }
3138                 if (ndi_prop_update_int64(DDI_DEV_T_NONE, child_dip,
3139                     "port-guid", port_attr->pa_port_guid) !=
3140                     DDI_PROP_SUCCESS) {
3141                         IBTF_DPRINTF_L2("ibnex",
3142                             "\tcreate_port_node_prop: port-guid update failed");
3143                         return (IBNEX_FAILURE);
3144                 }
3145         } else {
3146                 ibdm_hca_list_t *hca_list;
3147 
3148                 /*
3149                  * HCA_SVC nodes require "num-ports" & "port-guids"
3150                  * properties.
3151                  *
3152                  * To create the num-ports & port-guids attribute :
3153                  * 1. Get HCA list (ibdm_ibnex_get_hca_info_by_guid)
3154                  * 2. Form the array of port GUIDs.
3155                  */
3156                 if ((hca_list = ibdm_ibnex_get_hca_info_by_guid(
3157                     port_attr->pa_hca_guid)) == NULL) {
3158                         IBTF_DPRINTF_L2("ibnex",
3159                             "\tcreate_port_node_prop: hca_info_by_guid failed");
3160                         return (IBNEX_FAILURE);
3161                 }
3162 
3163                 if (hca_list->hl_nports != 0) {
3164                         ib_guid_t       *port_guids;
3165                         uint8_t         portnum;
3166 
3167                         ASSERT(hca_list->hl_port_attr != NULL);
3168 
3169                         port_guids = kmem_zalloc(
3170                             hca_list->hl_nports * sizeof (ib_guid_t),
3171                             KM_SLEEP);
3172 
3173                         for (portnum = 0; portnum < hca_list->hl_nports;
3174                             portnum++) {
3175                                 port_guids[portnum] = (hca_list->
3176                                     hl_port_attr[portnum]).pa_port_guid;
3177                         }
3178 
3179                         if (ndi_prop_update_int64_array(DDI_DEV_T_NONE,
3180                             child_dip, "port-guids", (int64_t *)port_guids,
3181                             hca_list->hl_nports) != DDI_PROP_SUCCESS) {
3182                                 IBTF_DPRINTF_L2("ibnex",
3183                                     "\tcreate_port_node_prop: port-guids "
3184                                     "create failed");
3185                                 kmem_free(port_guids, hca_list->hl_nports *
3186                                     sizeof (ib_guid_t));
3187                                 ibdm_ibnex_free_hca_list(hca_list);
3188                                 return (IBNEX_FAILURE);
3189                         }
3190                         kmem_free(port_guids, hca_list->hl_nports *
3191                             sizeof (ib_guid_t));
3192                 }
3193 
3194                 if (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip,
3195                     "num-ports", hca_list->hl_nports) != DDI_PROP_SUCCESS) {
3196                         IBTF_DPRINTF_L2("ibnex",
3197                             "\tcreate_port_node_prop: num-ports update failed");
3198                         ibdm_ibnex_free_hca_list(hca_list);
3199                         return (IBNEX_FAILURE);
3200                 }
3201                 ibdm_ibnex_free_hca_list(hca_list);
3202         }
3203 
3204         if (ndi_prop_update_int64(DDI_DEV_T_NONE, child_dip,
3205             "hca-guid", port_attr->pa_hca_guid) != DDI_PROP_SUCCESS) {
3206                 IBTF_DPRINTF_L2("ibnex",
3207                     "\tcreate_port_node_prop: hca-guid update failed");
3208                 return (IBNEX_FAILURE);
3209         }
3210         if (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip,
3211             "product-id", port_attr->pa_productid) != DDI_PROP_SUCCESS) {
3212                 IBTF_DPRINTF_L2("ibnex",
3213                     "\tcreate_port_node_prop: product-id update failed");
3214                 return (IBNEX_FAILURE);
3215         }
3216         if (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip,
3217             "vendor-id", port_attr->pa_vendorid) != DDI_PROP_SUCCESS) {
3218                 IBTF_DPRINTF_L2("ibnex",
3219                     "\tcreate_port_node_prop: vendor-id update failed");
3220                 return (IBNEX_FAILURE);
3221         }
3222         if (ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, "device-version",
3223             port_attr->pa_dev_version) != DDI_PROP_SUCCESS) {
3224                 IBTF_DPRINTF_L2("ibnex",
3225                     "\tcreate_port_node_prop: device-version update failed");
3226                 return (IBNEX_FAILURE);
3227         }
3228         return (IBNEX_SUCCESS);
3229 }
3230 
3231 
3232 /*
3233  * ibnex_str2int()
3234  *      Utility function that converts a string of length  "len" to
3235  *      integer.
3236  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
3237  */
3238 int
3239 ibnex_str2int(char *c, int len, int *ret)
3240 {
3241         int intval = 0, ii;
3242 
3243         IBTF_DPRINTF_L4("ibnex", "\tstr2int: Int string %s..", c);
3244         *ret = IBNEX_SUCCESS;
3245         for (ii = 0; ii < len; ii ++) {
3246                 if ((c[ii] >= '0') && (c[ii] <= '9'))
3247                         intval = intval * 10 +c[ii] - '0';
3248                 else {
3249                         IBTF_DPRINTF_L2("ibnex",
3250                             "\tstr2int: Invalid integer string %s..", c);
3251                         *ret = IBNEX_FAILURE;
3252                         break;
3253                 }
3254         }
3255 
3256         return (intval);
3257 }
3258 
3259 
3260 /*
3261  * ibnex_str2hex()
3262  *      Utility functions that converts a string of length  "len" to
3263  *      hex value. Note. This function does not handle strings which
3264  *      string length more than 8 bytes.
3265  *
3266  */
3267 uint64_t
3268 ibnex_str2hex(char *c, int len, int *ret)
3269 {
3270         uint64_t hex = 0, ii;
3271 
3272         *ret = IBNEX_SUCCESS;
3273         for (ii = 0; ii < len; ii ++) {
3274                 hex = (ii == 0) ? hex : (hex << 4);
3275                 if ((c[ii] >= '0') && (c[ii] <= '9'))
3276                         hex |= c[ii] - '0';
3277                 else if ((c[ii] >= 'a') && (c[ii] <= 'f'))
3278                         hex |= c[ii] - 'a' + 10;
3279                 else if ((c[ii] >= 'A') && (c[ii] <= 'F'))
3280                         hex |= c[ii] - 'A' + 10;
3281                 else {
3282                         IBTF_DPRINTF_L2("ibnex",
3283                             "\tstr2hex: Invalid integer string");
3284                         *ret = IBNEX_FAILURE;
3285                         break;
3286                 }
3287         }
3288 
3289         return (hex);
3290 }
3291 
3292 
3293 /*
3294  * ibnex_create_port_compatible_prop()
3295  *      Creates 'Compatibility' property for port / HCA_SVC device nodes
3296  *      Returns IBNEX_SUCCESS/IBNEX_FAILURE
3297  */
3298 static int
3299 ibnex_create_port_compatible_prop(dev_info_t *child_dip,
3300     char *comm_svcp, ibdm_port_attr_t *port_attr)
3301 {
3302         int     rval, i;
3303         char    *temp;
3304         char    *compatible[IBNEX_MAX_IBPORT_COMPAT_NAMES];
3305 
3306         IBTF_DPRINTF_L4("ibnex", "\tcreate_port_compatible_prop: Begin");
3307         /*
3308          * Initialize the "compatible" property string as below:
3309          * Compatible Strings :
3310          * 1. ib.V<vid>P<pid>v<revision>.<service name>.
3311          * 2. ib.V<vid>P<pid>.<service name>.
3312          * 3. ib.<service name>
3313          * Leading zeros must be present
3314          */
3315         temp = kmem_alloc(IBNEX_MAX_IBPORT_COMPAT_PROP_SZ, KM_SLEEP);
3316         for (i = 0; i < IBNEX_MAX_IBPORT_COMPAT_NAMES; i++) {
3317                 compatible[i] = temp + (i * IBNEX_MAX_COMPAT_LEN);
3318         }
3319 
3320         (void) snprintf(compatible[0], IBNEX_MAX_COMPAT_LEN,
3321             "ib.V%06xP%08xv%04x.%s",
3322             port_attr->pa_vendorid, port_attr->pa_productid,
3323             port_attr->pa_dev_version, comm_svcp);
3324         (void) snprintf(compatible[1], IBNEX_MAX_COMPAT_LEN,
3325             "ib.V%06xP%08x.%s",
3326             port_attr->pa_vendorid, port_attr->pa_productid,
3327             comm_svcp);
3328         (void) snprintf(compatible[2], IBNEX_MAX_COMPAT_LEN,
3329             "ib.%s", comm_svcp);
3330 
3331         for (i = 0; i < IBNEX_MAX_IBPORT_COMPAT_NAMES; i++)
3332                 IBTF_DPRINTF_L4("ibnex", "\tcompatible: %s", compatible[i]);
3333 
3334         rval = ndi_prop_update_string_array(DDI_DEV_T_NONE, child_dip,
3335             "compatible", (char **)compatible, IBNEX_MAX_IBPORT_COMPAT_NAMES);
3336 
3337         if (rval != DDI_PROP_SUCCESS) {
3338                 kmem_free(temp, IBNEX_MAX_IBPORT_COMPAT_PROP_SZ);
3339                 return (IBNEX_FAILURE);
3340         }
3341         kmem_free(temp, IBNEX_MAX_IBPORT_COMPAT_PROP_SZ);
3342         return (IBNEX_SUCCESS);
3343 }
3344 
3345 
3346 /*
3347  * ibnex_delete_port_node_data()
3348  *      Delete the parent private node data from the linked list
3349  *      Deallocate the memory of the port/ioc attributes
3350  *      Deallocate the memory of the node data
3351  */
3352 static void
3353 ibnex_delete_port_node_data(ibnex_node_data_t *node)
3354 {
3355         if ((node->node_next == NULL) && (node->node_prev == NULL))
3356                 ibnex.ibnex_port_node_head = NULL;
3357         else if (node->node_next == NULL)
3358                 node->node_prev->node_next = NULL;
3359         else if (node->node_prev == NULL) {
3360                 node->node_next->node_prev = NULL;
3361                 ibnex.ibnex_port_node_head = node->node_next;
3362         } else {
3363                 node->node_prev->node_next = node->node_next;
3364                 node->node_next->node_prev = node->node_prev;
3365         }
3366         kmem_free(node, sizeof (ibnex_node_data_t));
3367 }
3368 
3369 
3370 /*
3371  * ibnex_is_node_data_present()
3372  *      Checks whether ibnex_node_t is created already
3373  *      Returns ibnex_node_data_t if found, otherwise NULL
3374  */
3375 static ibnex_node_data_t *
3376 ibnex_is_node_data_present(ibnex_node_type_t node_type, void *attr,
3377     int index, ib_pkey_t pkey)
3378 {
3379         ibnex_node_data_t       *nodep;
3380         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
3381         if (node_type == IBNEX_IOC_NODE) {
3382                 ibdm_ioc_info_t *ioc_infop = (ibdm_ioc_info_t *)attr;
3383 
3384                 for (nodep = ibnex.ibnex_ioc_node_head; nodep != NULL;
3385                     nodep = nodep->node_next) {
3386                         if (nodep->node_data.ioc_node.ioc_guid ==
3387                             ioc_infop->ioc_profile.ioc_guid) {
3388                                 return (nodep);
3389                         }
3390                 }
3391 
3392         } else if (node_type == IBNEX_PSEUDO_NODE) {
3393                 for (nodep = ibnex.ibnex_pseudo_node_head; nodep;
3394                     nodep = nodep->node_next)
3395                         if (strcmp(nodep->node_data.pseudo_node.
3396                             pseudo_node_addr, (char *)attr) == 0)
3397                                 return (nodep);
3398 
3399         } else {
3400                 ibdm_port_attr_t *pattrp = (ibdm_port_attr_t *)attr;
3401 
3402                 for (nodep = ibnex.ibnex_port_node_head; nodep != NULL;
3403                     nodep = nodep->node_next) {
3404                         if ((nodep->node_data.port_node.port_guid ==
3405                             pattrp->pa_port_guid) &&
3406                             (nodep->node_data.port_node.port_commsvc_idx ==
3407                             index) &&
3408                             (nodep->node_data.port_node.port_pkey == pkey)) {
3409                                 return (nodep);
3410                         }
3411                 }
3412         }
3413         return (NULL);
3414 }
3415 
3416 /*
3417  * ibnex_lookup_unit_address_prop:
3418  *
3419  *      If property with name is found, return its value
3420  *      otherwise return NULL.
3421  */
3422 static char *
3423 ibnex_lookup_named_prop(ddi_prop_t *head, char *name)
3424 {
3425         ddi_prop_t      *propp;
3426 
3427         /* Search the list of properties for name */
3428         for (propp = head; propp != NULL; propp = propp->prop_next)  {
3429                 if (strcmp(propp->prop_name, name) != 0)
3430                         continue;
3431                 /* named property should be valid and have a value */
3432                 if (propp->prop_len <= 1)
3433                         break;
3434                 return ((char *)propp->prop_val);
3435         }
3436 
3437         return ((char *)0);
3438 }
3439 
3440 
3441 /*
3442  * ibnex_pseudo_initnodes()
3443  *      This routine is specific to pseudo node information handling
3444  *      Creates a ibnex_node_data_t all pseudo nodes children of ibnex
3445  */
3446 void
3447 ibnex_pseudo_initnodes()
3448 {
3449         int                     pnam_len, len;
3450         ibnex_node_data_t       *nodep;
3451         struct hwc_spec         *list, *spec;
3452         char                    *node_addr, *temp, *unit_addr;
3453         char                    *node_type;
3454 
3455         IBTF_DPRINTF_L4("ibnex", "\tpseudo_initnodes");
3456 
3457         mutex_enter(&ibnex.ibnex_mutex);
3458         /*
3459          * get a list of all "pseudo" children of "ib".
3460          * for these children initialize/allocate an internal
3461          * ibnex_node_data_t.
3462          */
3463         list = hwc_get_child_spec(ibnex.ibnex_dip, (major_t)-1);
3464         for (spec = list; spec != NULL; spec = spec->hwc_next) {
3465                 if (spec->hwc_devi_sys_prop_ptr == NULL)
3466                         continue;
3467 
3468                 /* Check "ib-node-type" property for IOC .conf */
3469                 node_type = ibnex_lookup_named_prop(
3470                     spec->hwc_devi_sys_prop_ptr, "ib-node-type");
3471 
3472                 /* "unit-address" property should be present */
3473                 temp = ibnex_lookup_named_prop(
3474                     spec->hwc_devi_sys_prop_ptr, "unit-address");
3475                 if (temp == NULL)
3476                         continue;
3477 
3478                 pnam_len = strlen(spec->hwc_devi_name) + strlen(temp) + 2;
3479 
3480                 node_addr = kmem_zalloc(pnam_len, KM_SLEEP);
3481 
3482                 (void) snprintf(node_addr,
3483                     pnam_len, "%s,%s", spec->hwc_devi_name, temp);
3484 
3485                 nodep = ibnex_is_node_data_present(
3486                     IBNEX_PSEUDO_NODE, (void *)node_addr, 0, 0);
3487 
3488                 if (nodep) {
3489                         kmem_free(node_addr, pnam_len);
3490                         continue;
3491                 }
3492 
3493                 nodep = ibnex_init_child_nodedata(IBNEX_PSEUDO_NODE,
3494                     (void *)spec->hwc_devi_name, 0, 0);
3495 
3496                 nodep->node_data.pseudo_node.pseudo_node_addr = node_addr;
3497                 (void) snprintf(nodep->node_data.
3498                     pseudo_node.pseudo_node_addr, pnam_len, "%s", node_addr);
3499 
3500                 len = strlen(temp) + 1;
3501                 unit_addr = (char *)kmem_alloc(len, KM_SLEEP);
3502                 nodep->node_data.pseudo_node.pseudo_unit_addr = unit_addr;
3503                 (void) snprintf(unit_addr, len, "%s", temp);
3504                 nodep->node_data.pseudo_node.pseudo_unit_addr_len = len;
3505 
3506                 if (node_type && strcmp(node_type, "merge") == 0)
3507                         nodep->node_data.pseudo_node.pseudo_merge_node = 1;
3508 
3509                 IBTF_DPRINTF_L3("ibnex", "\tpseudo_initnodes: unit addr = %s"
3510                     " : drv name = %s", unit_addr, spec->hwc_devi_name);
3511         }
3512         hwc_free_spec_list(list);
3513         mutex_exit(&ibnex.ibnex_mutex);
3514 }
3515 
3516 
3517 /*
3518  * ibnex_init_child_nodedata()
3519  *
3520  *      Allocate memory for the parent private data for device node
3521  *      Initializes the parent private child device node data.
3522  *      Returns pointer to the parent private data
3523  */
3524 static ibnex_node_data_t *
3525 ibnex_init_child_nodedata(ibnex_node_type_t node_type, void *attr, int index,
3526     ib_pkey_t pkey)
3527 {
3528         char                     *devi_name;
3529         ibdm_ioc_info_t          *ioc_info;
3530         ibnex_ioc_node_t         *ioc_node;
3531         ibnex_node_data_t        *node_data;
3532         ib_dm_ioc_ctrl_profile_t *ioc_profile;
3533 
3534         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
3535 
3536         node_data = kmem_zalloc(sizeof (ibnex_node_data_t), KM_SLEEP);
3537         node_data->node_ap_state = IBNEX_NODE_AP_CONFIGURED;
3538         node_data->node_state = IBNEX_CFGADM_CONFIGURING;
3539         node_data->node_type = node_type;
3540 
3541         if (node_type == IBNEX_IOC_NODE) {
3542                 ioc_info        = (ibdm_ioc_info_t *)attr;
3543                 ioc_profile     = &ioc_info->ioc_profile;
3544                 ioc_node        = &node_data->node_data.ioc_node;
3545 
3546                 ioc_node->iou_guid = ioc_info->ioc_iou_guid;
3547                 ioc_node->ioc_guid = ioc_profile->ioc_guid;
3548                 (void) strncpy(ioc_node->ioc_id_string,
3549                     (char *)ioc_profile->ioc_id_string,
3550                     IB_DM_IOC_ID_STRING_LEN);
3551                 ioc_node->ioc_ngids = ioc_info->ioc_nportgids;
3552 
3553                 node_data->node_next = ibnex.ibnex_ioc_node_head;
3554                 node_data->node_prev = NULL;
3555                 if (ibnex.ibnex_ioc_node_head)
3556                         ibnex.ibnex_ioc_node_head->node_prev = node_data;
3557                 ibnex.ibnex_ioc_node_head = node_data;
3558         } else if (node_type == IBNEX_PSEUDO_NODE) {
3559                 devi_name = (char *)attr;
3560                 node_data->node_data.pseudo_node.pseudo_devi_name =
3561                     kmem_zalloc(strlen(devi_name) + 1, KM_SLEEP);
3562                 (void) strncpy(node_data->node_data.pseudo_node.
3563                     pseudo_devi_name, devi_name, strlen(devi_name));
3564                 node_data->node_next = ibnex.ibnex_pseudo_node_head;
3565                 node_data->node_prev = NULL;
3566                 if (ibnex.ibnex_pseudo_node_head)
3567                         ibnex.ibnex_pseudo_node_head->node_prev = node_data;
3568                 ibnex.ibnex_pseudo_node_head = node_data;
3569         } else {
3570                 node_data->node_data.port_node.port_hcaguid =
3571                     ((ibdm_port_attr_t *)attr)->pa_hca_guid;
3572                 node_data->node_data.port_node.port_guid =
3573                     ((ibdm_port_attr_t *)attr)->pa_port_guid;
3574                 node_data->node_data.port_node.port_num =
3575                     ((ibdm_port_attr_t *)attr)->pa_port_num;
3576                 node_data->node_data.port_node.port_commsvc_idx = index;
3577                 node_data->node_data.port_node.port_pkey = pkey;
3578 
3579                 node_data->node_next = ibnex.ibnex_port_node_head;
3580                 node_data->node_prev = NULL;
3581                 if (ibnex.ibnex_port_node_head)
3582                         ibnex.ibnex_port_node_head->node_prev = node_data;
3583                 ibnex.ibnex_port_node_head = node_data;
3584         }
3585         return (node_data);
3586 }
3587 
3588 static int
3589 ibnex_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
3590     char *eventname, ddi_eventcookie_t *cookie)
3591 {
3592         int rc;
3593 
3594 
3595         IBTF_DPRINTF_L4("ibnex", "ibnex_get_eventcookie(%p, %p, %s, 0x%X)",
3596             dip, rdip, eventname, cookie);
3597 
3598         rc = ndi_event_retrieve_cookie(ibnex.ibnex_ndi_event_hdl,
3599             rdip, eventname, cookie, NDI_EVENT_NOPASS);
3600         if (rc == NDI_SUCCESS) {
3601                 mutex_enter(&ibnex.ibnex_mutex);
3602                 ibnex.ibnex_prop_update_evt_cookie = *cookie;
3603                 mutex_exit(&ibnex.ibnex_mutex);
3604         }
3605 
3606         return (rc);
3607 }
3608 
3609 static int
3610 ibnex_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
3611     ddi_eventcookie_t cookie, void (*callback)(dev_info_t *dip,
3612     ddi_eventcookie_t cookie, void *arg, void *bus_impldata),
3613     void *arg, ddi_callback_id_t *cb_id)
3614 {
3615         IBTF_DPRINTF_L4("ibnex",
3616             "ibnex_add_eventcall(%p, %p, 0x%X, %p, %p, %p)",
3617             dip, rdip, cookie, callback, arg, cb_id);
3618 
3619         return (ndi_event_add_callback(ibnex.ibnex_ndi_event_hdl,
3620             rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
3621 }
3622 
3623 static int
3624 ibnex_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
3625 {
3626         IBTF_DPRINTF_L4("ibnex", "ibnex_remove_eventcall(%p, 0x%X)",
3627             dip, cb_id);
3628 
3629         return (ndi_event_remove_callback(ibnex.ibnex_ndi_event_hdl,
3630             cb_id));
3631 }
3632 
3633 static int
3634 ibnex_post_event(dev_info_t *dip, dev_info_t *rdip,
3635     ddi_eventcookie_t cookie, void *bus_impldata)
3636 {
3637         IBTF_DPRINTF_L4("ibnex", "ibnex_post_event(%p, %p, 0x%X, %p)",
3638             dip, rdip, cookie, bus_impldata);
3639 
3640         return (ndi_event_run_callbacks(ibnex.ibnex_ndi_event_hdl, rdip,
3641             cookie, bus_impldata));
3642 }
3643 
3644 /*
3645  * ibnex_reprobe_ioc_dev()
3646  *
3647  * This could be called as a result of ibt_reprobe_dev request or
3648  * cfgadm command. The function is called from a taskq in case of
3649  * ibt_reprobe_dev and from user context for cfgadm command.
3650  *
3651  * This function reprobes the properties for one IOC dip.
3652  *
3653  * node_reprobe_state should be set before calling this function.
3654  */
3655 void
3656 ibnex_reprobe_ioc_dev(void *arg)
3657 {
3658         dev_info_t      *dip = (dev_info_t *)arg;
3659         ibnex_node_data_t       *node_data;
3660         ibnex_ioc_node_t        *ioc_data;
3661         ibdm_ioc_info_t         *ioc_info;
3662 
3663         /* ASSERT(NO_LOCKS_HELD); */
3664         ASSERT(dip != NULL);
3665 
3666         node_data = ddi_get_parent_data(dip);
3667         ASSERT(node_data);
3668 
3669         if (node_data->node_dip == NULL) {
3670                 IBTF_DPRINTF_L4("ibnex", "reprobe for unconfigured dip");
3671                 mutex_enter(&ibnex.ibnex_mutex);
3672                 ibnex_wakeup_reprobe_ioc(node_data, 0);
3673                 mutex_exit(&ibnex.ibnex_mutex);
3674                 return;
3675         }
3676         ioc_data = &(node_data->node_data.ioc_node);
3677 
3678         /* Reprobe the IOC */
3679         ioc_info = ibdm_ibnex_probe_ioc(ioc_data->iou_guid, ioc_data->ioc_guid,
3680             1);
3681         if (ioc_info == NULL) {
3682                 IBTF_DPRINTF_L2("ibnex", "Null ioc_info from reprobe");
3683                 mutex_enter(&ibnex.ibnex_mutex);
3684                 ibnex_wakeup_reprobe_ioc(node_data, 1);
3685                 mutex_exit(&ibnex.ibnex_mutex);
3686                 return;
3687         }
3688 
3689         mutex_enter(&ibnex.ibnex_mutex);
3690         if (node_data->node_dip)
3691                 ibnex_update_prop(node_data, ioc_info);
3692         ibnex_wakeup_reprobe_ioc(node_data, 0);
3693         mutex_exit(&ibnex.ibnex_mutex);
3694 
3695         ibdm_ibnex_free_ioc_list(ioc_info);
3696 }
3697 
3698 /*
3699  * ibnex_reprobe_all()
3700  *
3701  * This could be called as a result of cfgadm command. The function
3702  * is called from user context.
3703  *
3704  * This function reprobes the properties for all IOC dips.
3705  *
3706  * ibnex_reprobe_state should be set before calling this function.
3707  */
3708 void
3709 ibnex_reprobe_ioc_all()
3710 {
3711         ibnex_node_data_t       *node_data;
3712         ibdm_ioc_info_t         *ioc_info_list, *ioc;
3713 
3714         /* ASSERT(NO_LOCKS_HELD); */
3715 
3716         /* Sweep the fabric */
3717         ioc = ioc_info_list = ibdm_ibnex_get_ioc_list(
3718             IBDM_IBNEX_REPROBE_ALL);
3719         if (ioc_info_list == NULL) {
3720                 mutex_enter(&ibnex.ibnex_mutex);
3721                 ibnex_wakeup_reprobe_all();
3722                 mutex_exit(&ibnex.ibnex_mutex);
3723                 return;
3724         }
3725 
3726         mutex_enter(&ibnex.ibnex_mutex);
3727         while (ioc_info_list) {
3728                 if ((node_data = ibnex_is_node_data_present(IBNEX_IOC_NODE,
3729                     ioc_info_list, 0, 0)) != NULL &&
3730                     node_data->node_dip != NULL) {
3731                         ibnex_update_prop(node_data, ioc_info_list);
3732                 }
3733                 ioc_info_list = ioc_info_list->ioc_next;
3734         }
3735         ibnex_wakeup_reprobe_all();
3736         mutex_exit(&ibnex.ibnex_mutex);
3737 
3738         ibdm_ibnex_free_ioc_list(ioc);
3739 }
3740 
3741 /*
3742  * Update the properties, if it has modified and notify IBTF client.
3743  */
3744 static void
3745 ibnex_update_prop(ibnex_node_data_t *node_data, ibdm_ioc_info_t *ioc_info)
3746 {
3747         ibt_prop_update_payload_t       evt_data;
3748         dev_info_t      *dip = node_data->node_dip;
3749         ddi_eventcookie_t       evt_cookie;
3750         ibnex_ioc_node_t *ioc;
3751 
3752         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
3753 
3754         ASSERT(dip != NULL);
3755 
3756         ioc = &node_data->node_data.ioc_node;
3757 
3758         evt_data = ioc_info->ioc_info_updated;
3759         evt_cookie = ibnex.ibnex_prop_update_evt_cookie;
3760 
3761         /*
3762          * For a disconnected IOC :
3763          *      Store the ioc_profile for supplying cfgadm info
3764          *      ibdm maintains no info of disconnected IOC
3765          *
3766          * For reconnected IOC :
3767          *      ibdm has info of previous service entries
3768          *      ioc_profile maintained by ibnexus is used to
3769          *      update ib_srv_prop_updated.
3770          *      Free the ibnex maintained ioc_profile
3771          */
3772         if (ioc_info->ioc_nportgids == 0) {
3773                 IBTF_DPRINTF_L4("ibnex",
3774                     "\tupdate_prop:  IOC disconnected");
3775                 ioc->ioc_profile = (ib_dm_ioc_ctrl_profile_t *)kmem_zalloc(
3776                     sizeof (ib_dm_ioc_ctrl_profile_t), KM_SLEEP);
3777                 bcopy(&ioc_info->ioc_profile, ioc->ioc_profile,
3778                     sizeof (ib_dm_ioc_ctrl_profile_t));
3779 
3780                 ibnex.ibnex_num_disconnect_iocs++;
3781         } else if (ioc_info->ioc_nportgids != 0 && ioc->ioc_ngids == 0 &&
3782             ioc->ioc_profile != NULL) {
3783                 IBTF_DPRINTF_L4("ibnex",
3784                     "\tupdate_prop: IOC reconnected");
3785                 if (ioc->ioc_profile->ioc_service_entries !=
3786                     ioc_info->ioc_profile.ioc_service_entries)
3787                         evt_data.ib_srv_prop_updated = 1;
3788 
3789                 ibnex.ibnex_num_disconnect_iocs--;
3790                 kmem_free(ioc->ioc_profile, sizeof (ib_dm_ioc_ctrl_profile_t));
3791                 ioc->ioc_profile = NULL;
3792         }
3793 
3794         /* Update the properties that have changed */
3795         mutex_exit(&ibnex.ibnex_mutex);
3796         if (evt_data.ib_gid_prop_updated) {
3797                 if (ibnex_create_ioc_portgid_prop(dip, ioc_info) !=
3798                     IBNEX_SUCCESS) {
3799                         mutex_enter(&ibnex.ibnex_mutex);
3800                         return;
3801                 }
3802         }
3803         if (evt_data.ib_srv_prop_updated) {
3804                 if (ioc_info->ioc_profile.ioc_service_entries != 0 &&
3805                     (ibnex_create_ioc_srv_props(dip, ioc_info) !=
3806                     IBNEX_SUCCESS)) {
3807                         mutex_enter(&ibnex.ibnex_mutex);
3808                         return;
3809                 } else if (ioc_info->ioc_profile.ioc_service_entries == 0) {
3810                         (void) ndi_prop_remove(DDI_DEV_T_NONE, dip,
3811                             "service-id");
3812                         (void) ndi_prop_remove(DDI_DEV_T_NONE, dip,
3813                             "service-name");
3814                 }
3815         }
3816         mutex_enter(&ibnex.ibnex_mutex);
3817         ioc->ioc_ngids = ioc_info->ioc_nportgids;
3818 
3819         /*
3820          * Post an event if :
3821          *      1. Properites have changed or NOTIFY_ALWAYS is set.
3822          *      2. child dip is configured and a valid cookie for
3823          *         IB_PROP_UPDATE_EVENT.
3824          */
3825         if ((evt_data.ib_prop_updated != 0 ||
3826             (node_data->node_reprobe_state &
3827             IBNEX_NODE_REPROBE_NOTIFY_ALWAYS)) &&
3828             ((node_data->node_state == IBNEX_CFGADM_CONFIGURED) &&
3829             (evt_cookie != NULL))) {
3830                         mutex_exit(&ibnex.ibnex_mutex);
3831 
3832                         if (ndi_post_event(ibnex.ibnex_dip, dip,
3833                             evt_cookie, &evt_data) != NDI_SUCCESS)
3834                                 IBTF_DPRINTF_L2("ibnex",
3835                                     "\tndi_post_event failed\n");
3836 
3837                         mutex_enter(&ibnex.ibnex_mutex);
3838         }
3839 
3840         /*
3841          * Cleanup node_reprobe_state, for ibt_reprobe_dev
3842          * requests, when reprobe all / node reprobe is in
3843          * progress. ibnex_reprobe_ioc_dev is not called
3844          * in this case.
3845          */
3846         if (node_data->node_reprobe_state ==
3847             IBNEX_NODE_REPROBE_NOTIFY_ALWAYS)
3848                 ibnex_wakeup_reprobe_ioc(node_data, 0);
3849 }
3850 
3851 static ibnex_rval_t
3852 ibnex_unique_svcname(char *svcname)
3853 {
3854         int i;
3855 
3856         /* Check Port Services */
3857         for (i = 0; i < ibnex.ibnex_num_comm_svcs; i++)
3858                 if (ibnex.ibnex_comm_svc_names[i] && strncmp(svcname,
3859                     ibnex.ibnex_comm_svc_names[i], 4) == 0)
3860                         return (IBNEX_FAILURE);
3861 
3862         /* Check VPPA Services */
3863         for (i = 0; i < ibnex.ibnex_nvppa_comm_svcs; i++)
3864                 if (ibnex.ibnex_vppa_comm_svc_names[i] && strncmp(svcname,
3865                     ibnex.ibnex_vppa_comm_svc_names[i], 4) == 0)
3866                         return (IBNEX_FAILURE);
3867 
3868         /* Check HCA_SVC Services */
3869         for (i = 0; i < ibnex.ibnex_nhcasvc_comm_svcs; i++)
3870                 if (ibnex.ibnex_hcasvc_comm_svc_names[i] && strncmp(svcname,
3871                     ibnex.ibnex_hcasvc_comm_svc_names[i], 4) == 0)
3872                         return (IBNEX_FAILURE);
3873 
3874         return (IBNEX_SUCCESS);
3875 }
3876 
3877 static void
3878 ibnex_handle_reprobe_dev(void *arg)
3879 {
3880         dev_info_t      *dip = (dev_info_t *)arg;
3881         ibnex_node_data_t       *node_data;
3882 
3883         ASSERT(dip != NULL);
3884         node_data = ddi_get_parent_data(dip);
3885         ASSERT(node_data);
3886 
3887         /*
3888          * Return success if:
3889          *      1. Reprobe for all nodes are in progress
3890          *      2. Reprobe for this node is in progress.
3891          * The reprobe in progress will complete eventually and
3892          * update the properties, if required.
3893          */
3894         mutex_enter(&ibnex.ibnex_mutex);
3895         if (ibnex.ibnex_reprobe_state != 0 ||
3896             node_data->node_reprobe_state != 0) {
3897                 /*
3898                  * Setting NOTIFY_ALWAYS to ensure that
3899                  * DDI event is delivered always for
3900                  * ibt_reprobe_dev
3901                  */
3902                 node_data->node_reprobe_state |=
3903                     IBNEX_NODE_REPROBE_NOTIFY_ALWAYS;
3904                 mutex_exit(&ibnex.ibnex_mutex);
3905                 return;
3906         }
3907         node_data->node_reprobe_state =
3908             IBNEX_NODE_REPROBE_NOTIFY_ALWAYS;
3909         mutex_exit(&ibnex.ibnex_mutex);
3910         ibnex_reprobe_ioc_dev(arg);
3911 }
3912 
3913 
3914 /*
3915  * MPxIO pathmangement routines. Currently IB nexus does not support
3916  * any kind of pathmangement. So, just return success to make MPxIO
3917  * framework happy.
3918  */
3919 /*ARGSUSED*/
3920 static int
3921 ib_vhci_pi_init(dev_info_t *vdip, mdi_pathinfo_t *pip, int flag)
3922 {
3923         IBTF_DPRINTF_L4("ibnex", "\tpi_init: dip %p pip %p", vdip, pip);
3924         return (MDI_SUCCESS);
3925 }
3926 
3927 
3928 /*ARGSUSED*/
3929 static int
3930 ib_vhci_pi_uninit(dev_info_t *vdip, mdi_pathinfo_t *pip, int flag)
3931 {
3932         dev_info_t *cdip;
3933         ibnex_node_data_t *node_data;
3934         int clnt_num_pi;
3935         IBTF_DPRINTF_L4("ibnex", "\tpi_uninit: dip %p pip %p", vdip, pip);
3936 
3937         if (pip == NULL)
3938                 return (MDI_FAILURE);
3939         /*
3940          * Get the Client dev_info from the pathinfo.
3941          */
3942         cdip = mdi_pi_get_client(pip);
3943         if (cdip == NULL)
3944                 return (MDI_FAILURE);
3945 
3946         /*
3947          * How many PIs do we have from this cdip ?
3948          */
3949         clnt_num_pi = mdi_client_get_path_count(cdip);
3950 
3951         /*
3952          * If this is the last PI that is being free'd ( called from
3953          * mdi_pi_free) we have to clean up the node data for the cdip since
3954          * the client would have been detached by mdi_devi_offline.
3955          */
3956         if (clnt_num_pi == 1) {
3957                 node_data = ddi_get_parent_data(cdip);
3958                 if (node_data == NULL)
3959                         return (MDI_SUCCESS);
3960                 if (node_data->node_dip == cdip) {
3961                         node_data->node_dip = NULL;
3962                         node_data->node_state = IBNEX_CFGADM_UNCONFIGURED;
3963                         return (MDI_SUCCESS);
3964                 }
3965         }
3966         return (MDI_SUCCESS);
3967 }
3968 
3969 
3970 /*ARGSUSED*/
3971 static int
3972 ib_vhci_pi_state_change(dev_info_t *vdip, mdi_pathinfo_t *pip,
3973                 mdi_pathinfo_state_t state, uint32_t arg1, int arg2)
3974 {
3975         IBTF_DPRINTF_L4("ibnex",
3976             "\tpi_state_change: dip %p pip %p state %x", vdip, pip, state);
3977         return (MDI_SUCCESS);
3978 }
3979 
3980 
3981 /*ARGSUSED*/
3982 static int
3983 ib_vhci_failover(dev_info_t *dip1, dev_info_t *dip2, int arg)
3984 {
3985         return (MDI_SUCCESS);
3986 }
3987 
3988 
3989 static int
3990 ibnex_bus_power(dev_info_t *parent, void *impl_arg,
3991     pm_bus_power_op_t op, void *arg, void *result)
3992 {
3993 
3994         int ret = DDI_SUCCESS;
3995 
3996         IBTF_DPRINTF_L4("ibnex", "\tbus_power: begin: op = %d", op);
3997 
3998         /*
3999          * Generic processing in MPxIO framework
4000          */
4001         ret = mdi_bus_power(parent, impl_arg, op, arg, result);
4002 
4003         switch (ret) {
4004         case MDI_SUCCESS:
4005                 ret = DDI_SUCCESS;
4006                 break;
4007         case MDI_FAILURE:
4008                 ret = DDI_FAILURE;
4009                 break;
4010         default:
4011                 break;
4012         }
4013 
4014         return (ret);
4015 }
4016 
4017 
4018 /*
4019  * If enumerated as a child of IB Nexus / VHCI, call mdi_vhci_bus_config.
4020  * ndi_devi_enter is not held during this call. mdi_vhci_bus_config()
4021  * will have called ndi_busop_bus_config(), no need for the caller to call
4022  * ndi_busop_bus_config() again.
4023  *
4024  * If enumerated as a child of HCA device, this could be a case for
4025  * Sparc boot or device enumeration from PHCI, driven by MDI.
4026  * Hold parent lock (ndi_devi_enter). The caller will have to call
4027  * ndi_busop_bus_config() if this function returns SUCCESS.
4028  *
4029  * if the device name contains ":port", then it is the Sparc boot case.
4030  * Handle this as before.
4031  *
4032  * If the device name does *not* contain the ":port", then :
4033  *      1. ibdm to probe IOC
4034  *      2. Create a pathinfo only if the IOC is reachable from the parent dip.
4035  */
4036 int
4037 ibnex_ioc_bus_config_one(dev_info_t **pdipp, uint_t flag,
4038     ddi_bus_config_op_t op, void *devname, dev_info_t **child,
4039     int *need_bus_config)
4040 {
4041         int ret = DDI_FAILURE, circ;
4042         dev_info_t *pdip = *pdipp;
4043         ib_guid_t       iou_guid, ioc_guid;
4044         char *ioc_guid_str;
4045 
4046 
4047         *need_bus_config = 1;
4048 
4049         if (pdip == ibnex.ibnex_dip) {
4050                 if (ibnex_devname_to_node_n_ioc_guids(
4051                     (char *)devname, &iou_guid, &ioc_guid,
4052                     &ioc_guid_str) != IBNEX_SUCCESS) {
4053                         return (ret);
4054                 }
4055                 ret = mdi_vhci_bus_config(pdip, flag, op, devname, child,
4056                     ioc_guid_str);
4057                 kmem_free(ioc_guid_str, strlen(ioc_guid_str) + 1);
4058                 if (ret == MDI_SUCCESS)
4059                         *need_bus_config = 0;
4060         } else {
4061                 mdi_devi_enter(pdip, &circ);
4062                 if (strstr((char *)devname, ":port=") != NULL) {
4063                         ret = ibnex_config_root_iocnode(pdip, devname);
4064                         ASSERT(ibnex.ibnex_dip == NULL);
4065                         *pdipp = ibnex.ibnex_dip;
4066                 } else {
4067                         ret = ibnex_config_ioc_node(devname, pdip);
4068                 }
4069                 mdi_devi_exit(pdip, circ);
4070         }
4071         return (ret);
4072 }
4073 
4074 static int
4075 ibnex_is_merge_node(dev_info_t *child)
4076 {
4077         char    *node;
4078         int     ret = IBNEX_INVALID_NODE;
4079 
4080         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
4081             DDI_PROP_DONTPASS, "ib-node-type", &node) !=
4082             DDI_PROP_SUCCESS) {
4083                 return (IBNEX_FAILURE);
4084         }
4085 
4086         if (node != NULL && *node != 0) {
4087                 if (strcmp(node, "merge") == 0)
4088                         ret = IBNEX_SUCCESS;
4089                 else {
4090                         IBTF_DPRINTF_L4("ibnex",
4091                             "\tis_merge_node: ib-node-type = %s", node);
4092                 }
4093         }
4094 
4095         ddi_prop_free(node);
4096         return (ret);
4097 }
4098 
4099 /*
4100  * Checks if the dn_head for the driver has already
4101  * initialized by the prom tree.
4102  */
4103 void
4104 ibnex_hw_in_dev_tree(char *driver_name)
4105 {
4106         major_t major;
4107 
4108         IBTF_DPRINTF_L4("ibnex", "\thw_in_dev_tree(%s)", driver_name);
4109 
4110         if (devnamesp == NULL)
4111                 return;
4112 
4113         major = ddi_name_to_major(driver_name);
4114         if (major == -1)
4115                 return;
4116 
4117         if (devnamesp[major].dn_head != (dev_info_t *)NULL)
4118                 ibnex_hw_status = IBNEX_HW_IN_DEVTREE;
4119 }
4120 
4121 int
4122 ibnex_ioc_initnode_all_pi(ibdm_ioc_info_t *ioc_info)
4123 {
4124         ibdm_hca_list_t *hca_list;
4125         dev_info_t      *hca_dip;
4126         int     rc = IBNEX_FAILURE;
4127 
4128         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
4129         /*
4130          * We return failure even if we fail for all HCAs
4131          */
4132         for (hca_list = ioc_info->ioc_hca_list; hca_list;
4133             hca_list = hca_list->hl_next) {
4134                 hca_dip = ibtl_ibnex_hcaguid2dip(hca_list->hl_hca_guid);
4135                 if (ibnex_ioc_config_from_pdip(ioc_info, hca_dip, 1) ==
4136                     IBNEX_SUCCESS)
4137                         rc = IBNEX_SUCCESS;
4138         }
4139         return (rc);
4140 }
4141 
4142 static int
4143 ibnex_ioc_config_from_pdip(ibdm_ioc_info_t *ioc_info, dev_info_t *pdip,
4144     int pdip_reachable_checked)
4145 {
4146         ibnex_node_data_t       *node_data;
4147         int                     create_pdip = 0;
4148         int                     rc = IBNEX_SUCCESS;
4149 
4150 
4151         ASSERT(MUTEX_HELD(&ibnex.ibnex_mutex));
4152         IBTF_DPRINTF_L4("ibnex",
4153             "/tioc_config_from_pdip(%p, %p, %d)", ioc_info, pdip,
4154             pdip_reachable_checked);
4155 
4156         if (pdip_reachable_checked == 0) {
4157                 if (ibnex_ioc_pi_reachable(ioc_info, pdip) == IBNEX_FAILURE) {
4158                         IBTF_DPRINTF_L4("ibnex",
4159                             "/tioc_config_from_pdip: ioc %p not reachable"
4160                             "from %p", ioc_info, pdip);
4161                         return (IBNEX_FAILURE);
4162                 }
4163         }
4164 
4165         node_data = ibnex_is_node_data_present(IBNEX_IOC_NODE,
4166             (void *)ioc_info, 0, 0);
4167 
4168         if (node_data && node_data->node_ap_state ==
4169             IBNEX_NODE_AP_UNCONFIGURED) {
4170                 IBTF_DPRINTF_L4("ibnex",
4171                     "\tioc_config_from_pdip: Unconfigured node");
4172                 return (IBNEX_FAILURE);
4173         }
4174 
4175 
4176         if (node_data == NULL) {
4177                 ibnex_ioc_node_t        *ioc;
4178 
4179                 create_pdip = 1;
4180 
4181                 node_data = ibnex_init_child_nodedata(IBNEX_IOC_NODE,
4182                     ioc_info, 0, 0);
4183                 ASSERT(node_data);
4184                 ioc = &node_data->node_data.ioc_node;
4185                 (void) snprintf(ioc->ioc_guid_str, IBNEX_IOC_GUID_LEN,
4186                     "%llX",
4187                     (longlong_t)ioc_info->ioc_profile.ioc_guid);
4188                 (void) snprintf(ioc->ioc_phci_guid, IBNEX_PHCI_GUID_LEN,
4189                     "%llX,%llX",
4190                     (longlong_t)ioc_info->ioc_profile.ioc_guid,
4191                     (longlong_t)ioc_info->ioc_iou_guid);
4192         } else if (ibnex_ioc_pi_exists(node_data, pdip) == IBNEX_FAILURE) {
4193                 create_pdip = 1;
4194         }
4195 
4196         if (create_pdip) {
4197                 rc = ibnex_ioc_initnode_pdip(node_data, ioc_info, pdip);
4198         }
4199 
4200         IBTF_DPRINTF_L4("ibnex", "\tioc_config_from_pdip ret %x",
4201             rc);
4202         return (rc);
4203 }
4204 
4205 /*
4206  * This function checks if a pathinfo has already been created
4207  * for the HCA parent. The function returns SUCCESS if a pathinfo
4208  * has already been created, FAILURE if not.
4209  */
4210 static int
4211 ibnex_ioc_pi_exists(ibnex_node_data_t *node_data, dev_info_t *parent)
4212 {
4213         int     rc;
4214         ibnex_ioc_node_t        *ioc;
4215 
4216         ioc = &node_data->node_data.ioc_node;
4217         if (mdi_pi_find(parent, (char *)ioc->ioc_guid_str,
4218             (char *)ioc->ioc_phci_guid) != NULL)
4219                 rc = IBNEX_SUCCESS;
4220         else
4221                 rc = IBNEX_FAILURE;
4222 
4223         IBTF_DPRINTF_L4("ibnex", "\tioc_pi_created- client_guid %s, "
4224             "phci_guid %s, parent %p, rc %x",
4225             ioc->ioc_guid_str, ioc->ioc_phci_guid, parent, rc);
4226         return (rc);
4227 }
4228 
4229 static int
4230 ibnex_ioc_pi_reachable(ibdm_ioc_info_t *ioc_info, dev_info_t *pdip)
4231 {
4232         ibdm_hca_list_t *hca_list;
4233         dev_info_t      *hca_dip;
4234 
4235         IBTF_DPRINTF_L4("ibnex", "\tioc_pi_reachable(%p, %p)",
4236             ioc_info, pdip);
4237         for (hca_list = ioc_info->ioc_hca_list; hca_list;
4238             hca_list = hca_list->hl_next) {
4239                 hca_dip = ibtl_ibnex_hcaguid2dip(hca_list->hl_hca_guid);
4240                 if (hca_dip == pdip) {
4241                         IBTF_DPRINTF_L4("ibnex",
4242                             "\tioc_pi_reachable FAILURE");
4243                         return (IBNEX_SUCCESS);
4244                 }
4245         }
4246 
4247         IBTF_DPRINTF_L4("ibnex", "\tioc_pi_reachable FAILURE");
4248         return (IBNEX_FAILURE);
4249 }