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 } 4250