1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved. 25 */ 26 27 #include <sys/note.h> 28 29 /* 30 * Generic SCSI Host Bus Adapter interface implementation 31 */ 32 #include <sys/scsi/scsi.h> 33 #include <sys/scsi/generic/sas.h> 34 #include <sys/file.h> 35 #include <sys/disp.h> /* for minclsyspri */ 36 #include <sys/ddi_impldefs.h> 37 #include <sys/ndi_impldefs.h> 38 #include <sys/sunndi.h> 39 #include <sys/ddi.h> 40 #include <sys/sunmdi.h> 41 #include <sys/mdi_impldefs.h> 42 #include <sys/callb.h> 43 #include <sys/epm.h> 44 #include <sys/damap.h> 45 #include <sys/time.h> 46 #include <sys/sunldi.h> 47 #include <sys/fm/protocol.h> 48 49 extern struct scsi_pkt *scsi_init_cache_pkt(struct scsi_address *, 50 struct scsi_pkt *, struct buf *, int, int, int, int, 51 int (*)(caddr_t), caddr_t); 52 extern void scsi_free_cache_pkt(struct scsi_address *, struct scsi_pkt *); 53 extern void scsi_cache_dmafree(struct scsi_address *, struct scsi_pkt *); 54 extern void scsi_sync_cache_pkt(struct scsi_address *, struct scsi_pkt *); 55 extern int modrootloaded; 56 57 /* 58 * Round up all allocations so that we can guarantee 59 * long-long alignment. This is the same alignment 60 * provided by kmem_alloc(). 61 */ 62 #define ROUNDUP(x) (((x) + 0x07) & ~0x07) 63 64 /* Magic number to track correct allocations in wrappers */ 65 #define PKT_WRAPPER_MAGIC 0xa110ced /* alloced correctly */ 66 67 kmutex_t scsi_flag_nointr_mutex; 68 kcondvar_t scsi_flag_nointr_cv; 69 kmutex_t scsi_log_mutex; 70 71 /* asynchronous probe barrier deletion data structures */ 72 static kmutex_t scsi_hba_barrier_mutex; 73 static kcondvar_t scsi_hba_barrier_cv; 74 static struct scsi_hba_barrier { 75 struct scsi_hba_barrier *barrier_next; 76 clock_t barrier_endtime; 77 dev_info_t *barrier_probe; 78 } *scsi_hba_barrier_list; 79 static int scsi_hba_devi_is_barrier(dev_info_t *probe); 80 static void scsi_hba_barrier_tran_tgt_free(dev_info_t *probe); 81 static void scsi_hba_barrier_add(dev_info_t *probe, int seconds); 82 static int scsi_hba_remove_node(dev_info_t *child); 83 static void scsi_hba_barrier_daemon(void *arg); 84 85 /* LUN-change ASC/ASCQ processing data structures (stage1 and stage2) */ 86 static kmutex_t scsi_lunchg1_mutex; 87 static kcondvar_t scsi_lunchg1_cv; 88 static struct scsi_pkt *scsi_lunchg1_list; 89 static void scsi_lunchg1_daemon(void *arg); 90 static kmutex_t scsi_lunchg2_mutex; 91 static kcondvar_t scsi_lunchg2_cv; 92 static struct scsi_lunchg2 { 93 struct scsi_lunchg2 *lunchg2_next; 94 char *lunchg2_path; 95 } *scsi_lunchg2_list; 96 static void scsi_lunchg2_daemon(void *arg); 97 98 static int scsi_findchild(dev_info_t *self, char *name, char *addr, 99 int init, dev_info_t **dchildp, mdi_pathinfo_t **pchildp, int *ppi); 100 101 /* return value defines for scsi_findchild */ 102 #define CHILD_TYPE_NONE 0 103 #define CHILD_TYPE_DEVINFO 1 104 #define CHILD_TYPE_PATHINFO 2 105 106 /* 107 * Enumeration code path currently being followed. SE_BUSCONFIG results in 108 * DEVI_SID_NODEID, and SE_HP (hotplug) results in DEVI_SID_HP_NODEID. 109 * 110 * Since hotplug enumeration is based on information obtained from hardware 111 * (tgtmap/report_lun) the type/severity of enumeration error messages is 112 * sometimes based SE_HP (indirectly via ndi_dev_is_hotplug_node()). By 113 * convention, these messages are all produced by scsi_enumeration_failed(). 114 */ 115 typedef enum { SE_BUSCONFIG = 0, SE_HP = 1 } scsi_enum_t; 116 117 /* compatible properties of driver to use during probe/enumeration operations */ 118 static char *compatible_probe = "scsa,probe"; 119 static char *compatible_nodev = "scsa,nodev"; 120 static char *scsi_probe_ascii[] = SCSIPROBE_ASCII; 121 122 /* number of LUNs we attempt to get on the first SCMD_REPORT_LUNS command */ 123 int scsi_lunrpt_default_max = 256; 124 int scsi_lunrpt_timeout = 3; /* seconds */ 125 126 /* 127 * Only enumerate one lun if reportluns fails on a SCSI_VERSION_3 device 128 * (tunable based on calling context). 129 */ 130 int scsi_lunrpt_failed_do1lun = (1 << SE_HP); 131 132 /* 'scsi-binding-set' value for legacy enumerated 'spi' transports */ 133 char *scsi_binding_set_spi = "spi"; 134 135 /* enable NDI_DEVI_DEBUG for bus_[un]config operations */ 136 int scsi_hba_bus_config_debug = 0; 137 138 /* DEBUG: enable NDI_DEVI_REMOVE for bus_unconfig of dynamic node */ 139 int scsi_hba_bus_unconfig_remove = 0; 140 141 /* number of probe serilization messages */ 142 int scsi_hba_wait_msg = 5; 143 144 /* 145 * Establish the timeout used to cache (in the probe node) the fact that the 146 * device does not exist. This replaces the target specific probe cache. 147 */ 148 int scsi_hba_barrier_timeout = (60); /* seconds */ 149 150 #ifdef DEBUG 151 int scsi_hba_bus_config_failure_msg = 0; 152 int scsi_hba_bus_config_failure_dbg = 0; 153 int scsi_hba_bus_config_success_msg = 0; 154 int scsi_hba_bus_config_success_dbg = 0; 155 #endif /* DEBUG */ 156 157 /* 158 * Structure for scsi_hba_iportmap_* implementation/wrap. 159 */ 160 typedef struct impl_scsi_iportmap { 161 dev_info_t *iportmap_hba_dip; 162 damap_t *iportmap_dam; 163 int iportmap_create_window; 164 uint64_t iportmap_create_time; /* clock64_t */ 165 int iportmap_create_csync_usec; 166 int iportmap_settle_usec; 167 int iportmap_sync_cnt; 168 } impl_scsi_iportmap_t; 169 170 /* 171 * Structure for scsi_hba_tgtmap_* implementation/wrap. 172 * 173 * Every call to scsi_hba_tgtmap_set_begin will increment tgtmap_reports, 174 * and a call to scsi_hba_tgtmap_set_end will reset tgtmap_reports to zero. 175 * If, in scsi_hba_tgtmap_set_begin, we detect a tgtmap_reports value of 176 * scsi_hba_tgtmap_reports_max we produce a message to indicate that 177 * the caller is never completing an observation (i.e. we are not making 178 * any forward progress). If this message occurs, it indicates that the 179 * solaris hotplug ramifications at the target and lun level are no longer 180 * tracking. 181 * 182 * NOTE: LUNMAPSIZE OK for now, but should be dynamic in reportlun code. 183 */ 184 typedef struct impl_scsi_tgtmap { 185 scsi_hba_tran_t *tgtmap_tran; 186 int tgtmap_reports; /* _begin, no _end */ 187 int tgtmap_noisy; 188 scsi_tgt_activate_cb_t tgtmap_activate_cb; 189 scsi_tgt_deactivate_cb_t tgtmap_deactivate_cb; 190 void *tgtmap_mappriv; 191 damap_t *tgtmap_dam[SCSI_TGT_NTYPES]; 192 int tgtmap_create_window; 193 uint64_t tgtmap_create_time; /* clock64_t */ 194 int tgtmap_create_csync_usec; 195 int tgtmap_settle_usec; 196 int tgtmap_sync_cnt; 197 } impl_scsi_tgtmap_t; 198 #define LUNMAPSIZE 256 /* 256 LUNs/target */ 199 200 /* Produce warning if number of begins without an end exceed this value */ 201 int scsi_hba_tgtmap_reports_max = 256; 202 203 static int scsi_tgtmap_sync(scsi_hba_tgtmap_t *, int); 204 205 /* Default settle_usec damap_sync factor */ 206 int scsi_hba_map_settle_f = 10; 207 208 209 /* Prototype for static dev_ops devo_*() functions */ 210 static int scsi_hba_info( 211 dev_info_t *self, 212 ddi_info_cmd_t infocmd, 213 void *arg, 214 void **result); 215 216 /* Prototypes for static bus_ops bus_*() functions */ 217 static int scsi_hba_bus_ctl( 218 dev_info_t *self, 219 dev_info_t *child, 220 ddi_ctl_enum_t op, 221 void *arg, 222 void *result); 223 224 static int scsi_hba_map_fault( 225 dev_info_t *self, 226 dev_info_t *child, 227 struct hat *hat, 228 struct seg *seg, 229 caddr_t addr, 230 struct devpage *dp, 231 pfn_t pfn, 232 uint_t prot, 233 uint_t lock); 234 235 static int scsi_hba_get_eventcookie( 236 dev_info_t *self, 237 dev_info_t *child, 238 char *name, 239 ddi_eventcookie_t *eventp); 240 241 static int scsi_hba_add_eventcall( 242 dev_info_t *self, 243 dev_info_t *child, 244 ddi_eventcookie_t event, 245 void (*callback)( 246 dev_info_t *dip, 247 ddi_eventcookie_t event, 248 void *arg, 249 void *bus_impldata), 250 void *arg, 251 ddi_callback_id_t *cb_id); 252 253 static int scsi_hba_remove_eventcall( 254 dev_info_t *self, 255 ddi_callback_id_t id); 256 257 static int scsi_hba_post_event( 258 dev_info_t *self, 259 dev_info_t *child, 260 ddi_eventcookie_t event, 261 void *bus_impldata); 262 263 static int scsi_hba_bus_config( 264 dev_info_t *self, 265 uint_t flags, 266 ddi_bus_config_op_t op, 267 void *arg, 268 dev_info_t **childp); 269 270 static int scsi_hba_bus_unconfig( 271 dev_info_t *self, 272 uint_t flags, 273 ddi_bus_config_op_t op, 274 void *arg); 275 276 static int scsi_hba_fm_init_child( 277 dev_info_t *self, 278 dev_info_t *child, 279 int cap, 280 ddi_iblock_cookie_t *ibc); 281 282 static int scsi_hba_bus_power( 283 dev_info_t *self, 284 void *impl_arg, 285 pm_bus_power_op_t op, 286 void *arg, 287 void *result); 288 289 /* bus_ops vector for SCSI HBA's. */ 290 static struct bus_ops scsi_hba_busops = { 291 BUSO_REV, 292 nullbusmap, /* bus_map */ 293 NULL, /* bus_get_intrspec */ 294 NULL, /* bus_add_intrspec */ 295 NULL, /* bus_remove_intrspec */ 296 scsi_hba_map_fault, /* bus_map_fault */ 297 NULL, /* bus_dma_map */ 298 ddi_dma_allochdl, /* bus_dma_allochdl */ 299 ddi_dma_freehdl, /* bus_dma_freehdl */ 300 ddi_dma_bindhdl, /* bus_dma_bindhdl */ 301 ddi_dma_unbindhdl, /* bus_unbindhdl */ 302 ddi_dma_flush, /* bus_dma_flush */ 303 ddi_dma_win, /* bus_dma_win */ 304 ddi_dma_mctl, /* bus_dma_ctl */ 305 scsi_hba_bus_ctl, /* bus_ctl */ 306 ddi_bus_prop_op, /* bus_prop_op */ 307 scsi_hba_get_eventcookie, /* bus_get_eventcookie */ 308 scsi_hba_add_eventcall, /* bus_add_eventcall */ 309 scsi_hba_remove_eventcall, /* bus_remove_eventcall */ 310 scsi_hba_post_event, /* bus_post_event */ 311 NULL, /* bus_intr_ctl */ 312 scsi_hba_bus_config, /* bus_config */ 313 scsi_hba_bus_unconfig, /* bus_unconfig */ 314 scsi_hba_fm_init_child, /* bus_fm_init */ 315 NULL, /* bus_fm_fini */ 316 NULL, /* bus_fm_access_enter */ 317 NULL, /* bus_fm_access_exit */ 318 scsi_hba_bus_power /* bus_power */ 319 }; 320 321 /* cb_ops for hotplug :devctl and :scsi support */ 322 static struct cb_ops scsi_hba_cbops = { 323 scsi_hba_open, 324 scsi_hba_close, 325 nodev, /* strategy */ 326 nodev, /* print */ 327 nodev, /* dump */ 328 nodev, /* read */ 329 nodev, /* write */ 330 scsi_hba_ioctl, /* ioctl */ 331 nodev, /* devmap */ 332 nodev, /* mmap */ 333 nodev, /* segmap */ 334 nochpoll, /* poll */ 335 ddi_prop_op, /* prop_op */ 336 NULL, /* stream */ 337 D_NEW|D_MP|D_HOTPLUG, /* cb_flag */ 338 CB_REV, /* rev */ 339 nodev, /* int (*cb_aread)() */ 340 nodev /* int (*cb_awrite)() */ 341 }; 342 343 /* Prototypes for static scsi_hba.c/SCSA private lunmap interfaces */ 344 static int scsi_lunmap_create( 345 dev_info_t *self, 346 impl_scsi_tgtmap_t *tgtmap, 347 char *tgt_addr); 348 static void scsi_lunmap_destroy( 349 dev_info_t *self, 350 impl_scsi_tgtmap_t *tgtmap, 351 char *tgt_addr); 352 static void scsi_lunmap_set_begin( 353 dev_info_t *self, 354 damap_t *lundam); 355 static int scsi_lunmap_set_add( 356 dev_info_t *self, 357 damap_t *lundam, 358 char *taddr, 359 scsi_lun64_t lun_num, 360 int lun_sfunc); 361 static void scsi_lunmap_set_end( 362 dev_info_t *self, 363 damap_t *lundam); 364 365 /* Prototypes for static misc. scsi_hba.c private bus_config interfaces */ 366 static int scsi_hba_bus_config_iports(dev_info_t *self, uint_t flags, 367 ddi_bus_config_op_t op, void *arg, dev_info_t **childp); 368 static int scsi_hba_bus_config_spi(dev_info_t *self, uint_t flags, 369 ddi_bus_config_op_t op, void *arg, dev_info_t **childp); 370 static dev_info_t *scsi_hba_bus_config_port(dev_info_t *self, 371 char *nameaddr, scsi_enum_t se); 372 373 #ifdef sparc 374 static int scsi_hba_bus_config_prom_node(dev_info_t *self, uint_t flags, 375 void *arg, dev_info_t **childp); 376 #endif /* sparc */ 377 378 379 /* 380 * SCSI_HBA_LOG is used for all messages. A logging level is specified when 381 * generating a message. Some levels correspond directly to cmn_err levels, 382 * some are associated with increasing levels diagnostic/debug output (LOG1-4), 383 * and others are associated with specific levels of interface (LOGMAP). 384 * For _LOG() messages, a __func__ prefix will identify the function origin 385 * of the message. For _LOG_NF messages, there is no function prefix or 386 * self/child context. Filtering of messages is provided based on logging 387 * level, but messages with cmn_err logging level and messages generated 388 * generated with _LOG_NF() are never filtered. 389 * 390 * For debugging, more complete information can be displayed with each message 391 * (full device path and pointer values) by adjusting scsi_hba_log_info. 392 */ 393 /* logging levels */ 394 #define SCSI_HBA_LOGCONT CE_CONT 395 #define SCSI_HBA_LOGNOTE CE_NOTE 396 #define SCSI_HBA_LOGWARN CE_WARN 397 #define SCSI_HBA_LOGPANIC CE_PANIC 398 #define SCSI_HBA_LOGIGNORE CE_IGNORE 399 #define SCSI_HBA_LOG_CE_MASK 0x0000000F /* no filter for these levels */ 400 #define SCSI_HBA_LOG1 0x00000010 /* DIAG1 level enable */ 401 #define SCSI_HBA_LOG2 0x00000020 /* DIAG2 level enable */ 402 #define SCSI_HBA_LOG3 0x00000040 /* DIAG3 level enable */ 403 #define SCSI_HBA_LOG4 0x00000080 /* DIAG4 level enable */ 404 #define SCSI_HBA_LOGMAPPHY 0x00000100 /* MAPPHY level enable */ 405 #define SCSI_HBA_LOGMAPIPT 0x00000200 /* MAPIPT level enable */ 406 #define SCSI_HBA_LOGMAPTGT 0x00000400 /* MAPTGT level enable */ 407 #define SCSI_HBA_LOGMAPLUN 0x00000800 /* MAPLUN level enable */ 408 #define SCSI_HBA_LOGMAPCFG 0x00001000 /* MAPCFG level enable */ 409 #define SCSI_HBA_LOGMAPUNCFG 0x00002000 /* MAPUNCFG level enable */ 410 #define SCSI_HBA_LOGTRACE 0x00010000 /* TRACE enable */ 411 #if (CE_CONT | CE_NOTE | CE_WARN | CE_PANIC | CE_IGNORE) > SCSI_HBA_LOG_CE_MASK 412 Error, problem with CE_ definitions 413 #endif 414 415 /* 416 * Tunable log message augmentation and filters: filters do not apply to 417 * SCSI_HBA_LOG_CE_MASK level messages or LOG_NF() messages. 418 * 419 * An example set of /etc/system tunings to simplify debug a SCSA pHCI HBA 420 * driver called "pmcs", including "scsi_vhci" operation, by capturing 421 * log information in the system log might be: 422 * 423 * echo "set scsi:scsi_hba_log_filter_level=0x3ff0" >> /etc/system 424 * echo "set scsi:scsi_hba_log_filter_phci=\"pmcs\"" >> /etc/system 425 * echo "set scsi:scsi_hba_log_filter_vhci=\"scsi_vhci\"" >> /etc/system 426 * 427 * To capture information on just HBA-SCSAv3 *map operation, use 428 * echo "set scsi:scsi_hba_log_filter_level=0x3f10" >> /etc/system 429 * 430 * For debugging an HBA driver, you may also want to set: 431 * 432 * echo "set scsi:scsi_hba_log_align=1" >> /etc/system 433 * echo "set scsi:scsi_hba_log_mt_disable=0x6" >> /etc/system 434 * echo "set mtc_off=1" >> /etc/system 435 * echo "set mdi_mtc_off=1" >> /etc/system 436 * echo "set scsi:scsi_hba_log_fcif=0" >> /etc/system 437 */ 438 int scsi_hba_log_filter_level = 439 SCSI_HBA_LOG1 | 440 0; 441 char *scsi_hba_log_filter_phci = "\0\0\0\0\0\0\0\0\0\0\0\0"; 442 char *scsi_hba_log_filter_vhci = "\0\0\0\0\0\0\0\0\0\0\0\0"; 443 int scsi_hba_log_align = 0; /* NOTE: will not cause truncation */ 444 int scsi_hba_log_fcif = '!'; /* "^!?" first char in format */ 445 /* NOTE: iff level > SCSI_HBA_LOG1 */ 446 /* '\0'0x00 -> console and system log */ 447 /* '^' 0x5e -> console_only */ 448 /* '!' 0x21 -> system log only */ 449 /* '?' 0x2F -> See cmn_err(9F) */ 450 int scsi_hba_log_info = /* augmentation: extra info output */ 451 (0 << 0) | /* 0x0001: process information */ 452 (0 << 1) | /* 0x0002: full /devices path */ 453 (0 << 2); /* 0x0004: devinfo pointer */ 454 455 int scsi_hba_log_mt_disable = 456 /* SCSI_ENUMERATION_MT_LUN_DISABLE | (ie 0x02) */ 457 /* SCSI_ENUMERATION_MT_TARGET_DISABLE | (ie 0x04) */ 458 0; 459 460 /* static data for HBA logging subsystem */ 461 static kmutex_t scsi_hba_log_mutex; 462 static char scsi_hba_log_i[512]; 463 static char scsi_hba_log_buf[512]; 464 static char scsi_hba_fmt[512]; 465 466 /* Macros to use in scsi_hba.c source code below */ 467 #define SCSI_HBA_LOG(x) scsi_hba_log x 468 #define _LOG(level) SCSI_HBA_LOG##level, __func__ 469 #define _MAP(map) SCSI_HBA_LOGMAP##map, __func__ 470 #define _LOG_NF(level) SCSI_HBA_LOG##level, NULL, NULL, NULL 471 #define _LOG_TRACE _LOG(TRACE) 472 #define _LOGLUN _MAP(LUN) 473 #define _LOGTGT _MAP(TGT) 474 #define _LOGIPT _MAP(IPT) 475 #define _LOGPHY _MAP(PHY) 476 #define _LOGCFG _MAP(CFG) 477 #define _LOGUNCFG _MAP(UNCFG) 478 479 /*PRINTFLIKE5*/ 480 static void 481 scsi_hba_log(int level, const char *func, dev_info_t *self, dev_info_t *child, 482 const char *fmt, ...) 483 { 484 va_list ap; 485 int clevel; 486 int align; 487 char *info; 488 char *f; 489 char *ua; 490 491 /* derive self from child's parent */ 492 if ((self == NULL) && child) 493 self = ddi_get_parent(child); 494 495 /* no filtering of SCSI_HBA_LOG_CE_MASK or LOG_NF messages */ 496 if (((level & SCSI_HBA_LOG_CE_MASK) != level) && (func != NULL)) { 497 /* scsi_hba_log_filter_level: filter on level as bitmask */ 498 if ((level & scsi_hba_log_filter_level) == 0) 499 return; 500 501 /* scsi_hba_log_filter_phci/vhci: on name of driver */ 502 if (*scsi_hba_log_filter_phci && 503 ((self == NULL) || 504 (ddi_driver_name(self) == NULL) || 505 strcmp(ddi_driver_name(self), scsi_hba_log_filter_phci))) { 506 /* does not match pHCI, check vHCI */ 507 if (*scsi_hba_log_filter_vhci && 508 ((self == NULL) || 509 (ddi_driver_name(self) == NULL) || 510 strcmp(ddi_driver_name(self), 511 scsi_hba_log_filter_vhci))) { 512 /* does not match vHCI */ 513 return; 514 } 515 } 516 517 518 /* passed filters, determine align */ 519 align = scsi_hba_log_align; 520 521 /* shorten func for filtered output */ 522 if (strncmp(func, "scsi_hba_", 9) == 0) 523 func += 9; 524 if (strncmp(func, "scsi_", 5) == 0) 525 func += 5; 526 } else { 527 /* don't align output that is never filtered */ 528 align = 0; 529 } 530 531 /* determine the cmn_err form from the level */ 532 clevel = ((level & SCSI_HBA_LOG_CE_MASK) == level) ? level : CE_CONT; 533 534 /* protect common buffers used to format output */ 535 mutex_enter(&scsi_hba_log_mutex); 536 537 /* skip special first characters, we add them back below */ 538 f = (char *)fmt; 539 if (*f && strchr("^!?", *f)) 540 f++; 541 va_start(ap, fmt); 542 (void) vsprintf(scsi_hba_log_buf, f, ap); 543 va_end(ap); 544 545 /* augment message with 'information' */ 546 info = scsi_hba_log_i; 547 *info = '\0'; 548 if ((scsi_hba_log_info & 0x0001) && curproc && PTOU(curproc)->u_comm) { 549 (void) sprintf(info, "%s[%d]%p ", 550 PTOU(curproc)->u_comm, curproc->p_pid, (void *)curthread); 551 info += strlen(info); 552 } 553 if (self) { 554 if ((scsi_hba_log_info & 0x0004) && (child || self)) { 555 (void) sprintf(info, "%p ", 556 (void *)(child ? child : self)); 557 info += strlen(info); 558 } 559 if (scsi_hba_log_info & 0x0002) { 560 (void) ddi_pathname(child ? child : self, info); 561 (void) strcat(info, " "); 562 info += strlen(info); 563 } 564 565 /* always provide 'default' information about self &child */ 566 (void) sprintf(info, "%s%d ", ddi_driver_name(self), 567 ddi_get_instance(self)); 568 info += strlen(info); 569 if (child) { 570 ua = ddi_get_name_addr(child); 571 (void) sprintf(info, "%s@%s ", 572 ddi_node_name(child), (ua && *ua) ? ua : ""); 573 info += strlen(info); 574 } 575 } 576 577 /* turn off alignment if truncation would occur */ 578 if (align && ((strlen(func) > 18) || (strlen(scsi_hba_log_i) > 36))) 579 align = 0; 580 581 /* adjust for aligned output */ 582 if (align) { 583 if (func == NULL) 584 func = ""; 585 /* remove trailing blank with align output */ 586 if ((info != scsi_hba_log_i) && (*(info -1) == '\b')) 587 *(info - 1) = '\0'; 588 } 589 590 /* special "first character in format" must be in format itself */ 591 f = scsi_hba_fmt; 592 if (fmt[0] && strchr("^!?", fmt[0])) 593 *f++ = fmt[0]; 594 else if (scsi_hba_log_fcif && (level > SCSI_HBA_LOG1)) 595 *f++ = (char)scsi_hba_log_fcif; /* add global fcif */ 596 if (align) 597 (void) sprintf(f, "%s", "%-18.18s: %36.36s: %s%s"); 598 else 599 (void) sprintf(f, "%s", func ? "%s: %s%s%s" : "%s%s%s"); 600 601 if (func) 602 cmn_err(clevel, scsi_hba_fmt, func, scsi_hba_log_i, 603 scsi_hba_log_buf, clevel == CE_CONT ? "\n" : ""); 604 else 605 cmn_err(clevel, scsi_hba_fmt, scsi_hba_log_i, 606 scsi_hba_log_buf, clevel == CE_CONT ? "\n" : ""); 607 mutex_exit(&scsi_hba_log_mutex); 608 } 609 610 int scsi_enumeration_failed_panic = 0; 611 int scsi_enumeration_failed_hotplug = 1; 612 613 static void 614 scsi_enumeration_failed(dev_info_t *child, scsi_enum_t se, 615 char *arg, char *when) 616 { 617 /* If 'se' is -1 the 'se' value comes from child. */ 618 if (se == -1) { 619 ASSERT(child); 620 se = ndi_dev_is_hotplug_node(child) ? SE_HP : SE_BUSCONFIG; 621 } 622 623 if (scsi_enumeration_failed_panic) { 624 /* set scsi_enumeration_failed_panic to debug */ 625 SCSI_HBA_LOG((_LOG(PANIC), NULL, child, 626 "%s%senumeration failed during %s", 627 arg ? arg : "", arg ? " " : "", when)); 628 } else if (scsi_enumeration_failed_hotplug && (se == SE_HP)) { 629 /* set scsi_enumeration_failed_hotplug for console messages */ 630 SCSI_HBA_LOG((_LOG(WARN), NULL, child, 631 "%s%senumeration failed during %s", 632 arg ? arg : "", arg ? " " : "", when)); 633 } else { 634 /* default */ 635 SCSI_HBA_LOG((_LOG(2), NULL, child, 636 "%s%senumeration failed during %s", 637 arg ? arg : "", arg ? " " : "", when)); 638 } 639 } 640 641 /* 642 * scsi_hba version of [nm]di_devi_enter/[nm]di_devi_exit that detects if HBA 643 * is a PHCI, and chooses mdi/ndi locking implementation. 644 */ 645 static void 646 scsi_hba_devi_enter(dev_info_t *self, int *circp) 647 { 648 if (MDI_PHCI(self)) 649 mdi_devi_enter(self, circp); 650 else 651 ndi_devi_enter(self, circp); 652 } 653 654 static int 655 scsi_hba_devi_tryenter(dev_info_t *self, int *circp) 656 { 657 if (MDI_PHCI(self)) 658 return (mdi_devi_tryenter(self, circp)); 659 else 660 return (ndi_devi_tryenter(self, circp)); 661 } 662 663 static void 664 scsi_hba_devi_exit(dev_info_t *self, int circ) 665 { 666 if (MDI_PHCI(self)) 667 mdi_devi_exit(self, circ); 668 else 669 ndi_devi_exit(self, circ); 670 } 671 672 static void 673 scsi_hba_devi_enter_phci(dev_info_t *self, int *circp) 674 { 675 if (MDI_PHCI(self)) 676 mdi_devi_enter_phci(self, circp); 677 } 678 679 static void 680 scsi_hba_devi_exit_phci(dev_info_t *self, int circ) 681 { 682 if (MDI_PHCI(self)) 683 mdi_devi_exit_phci(self, circ); 684 } 685 686 static int 687 scsi_hba_dev_is_sid(dev_info_t *child) 688 { 689 /* 690 * Use ndi_dev_is_persistent_node instead of ddi_dev_is_sid to avoid 691 * any possible locking issues in mixed nexus devctl code (like usb). 692 */ 693 return (ndi_dev_is_persistent_node(child)); 694 } 695 696 /* 697 * Called from _init() when loading "scsi" module 698 */ 699 void 700 scsi_initialize_hba_interface() 701 { 702 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__)); 703 704 /* We need "scsiprobe" and "scsinodev" as an alias or a driver. */ 705 if (ddi_name_to_major(compatible_probe) == DDI_MAJOR_T_NONE) { 706 SCSI_HBA_LOG((_LOG_NF(WARN), "failed to resolve '%s' " 707 "driver alias, defaulting to 'nulldriver'", 708 compatible_probe)); 709 710 /* If no "nulldriver" driver nothing will work... */ 711 compatible_probe = "nulldriver"; 712 if (ddi_name_to_major(compatible_probe) == DDI_MAJOR_T_NONE) 713 SCSI_HBA_LOG((_LOG_NF(WARN), "no probe '%s' driver, " 714 "system misconfigured", compatible_probe)); 715 } 716 if (ddi_name_to_major(compatible_nodev) == DDI_MAJOR_T_NONE) { 717 SCSI_HBA_LOG((_LOG_NF(WARN), "failed to resolve '%s' " 718 "driver alias, defaulting to 'nulldriver'", 719 compatible_nodev)); 720 721 /* If no "nulldriver" driver nothing will work... */ 722 compatible_nodev = "nulldriver"; 723 if (ddi_name_to_major(compatible_nodev) == DDI_MAJOR_T_NONE) 724 SCSI_HBA_LOG((_LOG_NF(WARN), "no nodev '%s' driver, " 725 "system misconfigured", compatible_nodev)); 726 } 727 728 /* 729 * Verify our special node name "probe" will not be used in other ways. 730 * Don't expect things to work if they are. 731 */ 732 if (ddi_major_to_name(ddi_name_to_major("probe"))) 733 SCSI_HBA_LOG((_LOG_NF(WARN), 734 "driver already using special node name 'probe'")); 735 736 mutex_init(&scsi_log_mutex, NULL, MUTEX_DRIVER, NULL); 737 mutex_init(&scsi_flag_nointr_mutex, NULL, MUTEX_DRIVER, NULL); 738 cv_init(&scsi_flag_nointr_cv, NULL, CV_DRIVER, NULL); 739 mutex_init(&scsi_hba_log_mutex, NULL, MUTEX_DRIVER, NULL); 740 741 /* initialize the asynchronous barrier deletion daemon */ 742 mutex_init(&scsi_hba_barrier_mutex, NULL, MUTEX_DRIVER, NULL); 743 cv_init(&scsi_hba_barrier_cv, NULL, CV_DRIVER, NULL); 744 (void) thread_create(NULL, 0, 745 (void (*)())scsi_hba_barrier_daemon, NULL, 746 0, &p0, TS_RUN, minclsyspri); 747 748 /* initialize lun change ASC/ASCQ processing daemon (stage1 & stage2) */ 749 mutex_init(&scsi_lunchg1_mutex, NULL, MUTEX_DRIVER, NULL); 750 cv_init(&scsi_lunchg1_cv, NULL, CV_DRIVER, NULL); 751 (void) thread_create(NULL, 0, 752 (void (*)())scsi_lunchg1_daemon, NULL, 753 0, &p0, TS_RUN, minclsyspri); 754 mutex_init(&scsi_lunchg2_mutex, NULL, MUTEX_DRIVER, NULL); 755 cv_init(&scsi_lunchg2_cv, NULL, CV_DRIVER, NULL); 756 (void) thread_create(NULL, 0, 757 (void (*)())scsi_lunchg2_daemon, NULL, 758 0, &p0, TS_RUN, minclsyspri); 759 } 760 761 int 762 scsi_hba_pkt_constructor(void *buf, void *arg, int kmflag) 763 { 764 struct scsi_pkt_cache_wrapper *pktw; 765 struct scsi_pkt *pkt; 766 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 767 int pkt_len; 768 char *ptr; 769 770 /* 771 * allocate a chunk of memory for the following: 772 * scsi_pkt 773 * pcw_* fields 774 * pkt_ha_private 775 * pkt_cdbp, if needed 776 * (pkt_private always null) 777 * pkt_scbp, if needed 778 */ 779 pkt_len = tran->tran_hba_len + sizeof (struct scsi_pkt_cache_wrapper); 780 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) 781 pkt_len += DEFAULT_CDBLEN; 782 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB) 783 pkt_len += DEFAULT_SCBLEN; 784 bzero(buf, pkt_len); 785 786 ptr = buf; 787 pktw = buf; 788 ptr += sizeof (struct scsi_pkt_cache_wrapper); 789 pkt = &(pktw->pcw_pkt); 790 pkt->pkt_ha_private = (opaque_t)ptr; 791 792 pktw->pcw_magic = PKT_WRAPPER_MAGIC; /* alloced correctly */ 793 /* 794 * keep track of the granularity at the time this handle was 795 * allocated 796 */ 797 pktw->pcw_granular = tran->tran_dma_attr.dma_attr_granular; 798 799 if (ddi_dma_alloc_handle(tran->tran_hba_dip, &tran->tran_dma_attr, 800 kmflag == KM_SLEEP ? SLEEP_FUNC: NULL_FUNC, NULL, 801 &pkt->pkt_handle) != DDI_SUCCESS) { 802 803 return (-1); 804 } 805 ptr += tran->tran_hba_len; 806 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) { 807 pkt->pkt_cdbp = (opaque_t)ptr; 808 ptr += DEFAULT_CDBLEN; 809 } 810 pkt->pkt_private = NULL; 811 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB) 812 pkt->pkt_scbp = (opaque_t)ptr; 813 if (tran->tran_pkt_constructor) 814 return ((*tran->tran_pkt_constructor)(pkt, arg, kmflag)); 815 else 816 return (0); 817 } 818 819 #define P_TO_TRAN(pkt) ((pkt)->pkt_address.a_hba_tran) 820 821 void 822 scsi_hba_pkt_destructor(void *buf, void *arg) 823 { 824 struct scsi_pkt_cache_wrapper *pktw = buf; 825 struct scsi_pkt *pkt = &(pktw->pcw_pkt); 826 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 827 828 ASSERT(pktw->pcw_magic == PKT_WRAPPER_MAGIC); 829 ASSERT((pktw->pcw_flags & PCW_BOUND) == 0); 830 if (tran->tran_pkt_destructor) 831 (*tran->tran_pkt_destructor)(pkt, arg); 832 833 /* make sure nobody messed with our pointers */ 834 ASSERT(pkt->pkt_ha_private == (opaque_t)((char *)pkt + 835 sizeof (struct scsi_pkt_cache_wrapper))); 836 ASSERT(((tran->tran_hba_flags & SCSI_HBA_TRAN_SCB) == 0) || 837 (pkt->pkt_scbp == (opaque_t)((char *)pkt + 838 tran->tran_hba_len + 839 (((tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) == 0) ? 840 0 : DEFAULT_CDBLEN) + 841 DEFAULT_PRIVLEN + sizeof (struct scsi_pkt_cache_wrapper)))); 842 ASSERT(((tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) == 0) || 843 (pkt->pkt_cdbp == (opaque_t)((char *)pkt + 844 tran->tran_hba_len + 845 sizeof (struct scsi_pkt_cache_wrapper)))); 846 ASSERT(pkt->pkt_handle); 847 ddi_dma_free_handle(&pkt->pkt_handle); 848 pkt->pkt_handle = NULL; 849 pkt->pkt_numcookies = 0; 850 pktw->pcw_total_xfer = 0; 851 pktw->pcw_totalwin = 0; 852 pktw->pcw_curwin = 0; 853 } 854 855 /* 856 * Called by an HBA from _init() to plumb in common SCSA bus_ops and 857 * cb_ops for the HBA's :devctl and :scsi minor nodes. 858 */ 859 int 860 scsi_hba_init(struct modlinkage *modlp) 861 { 862 struct dev_ops *hba_dev_ops; 863 864 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__)); 865 866 /* 867 * Get a pointer to the dev_ops structure of the HBA and plumb our 868 * bus_ops vector into the HBA's dev_ops structure. 869 */ 870 hba_dev_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 871 ASSERT(hba_dev_ops->devo_bus_ops == NULL); 872 hba_dev_ops->devo_bus_ops = &scsi_hba_busops; 873 874 /* 875 * Plumb our cb_ops vector into the HBA's dev_ops structure to 876 * provide getinfo and hotplugging ioctl support if the HBA driver 877 * does not already provide this support. 878 */ 879 if (hba_dev_ops->devo_cb_ops == NULL) { 880 hba_dev_ops->devo_cb_ops = &scsi_hba_cbops; 881 } 882 if (hba_dev_ops->devo_cb_ops->cb_open == scsi_hba_open) { 883 ASSERT(hba_dev_ops->devo_cb_ops->cb_close == scsi_hba_close); 884 hba_dev_ops->devo_getinfo = scsi_hba_info; 885 } 886 return (0); 887 } 888 889 /* 890 * Called by an HBA attach(9E) to allocate a scsi_hba_tran(9S) structure. An 891 * HBA driver will then initialize the structure and then call 892 * scsi_hba_attach_setup(9F). 893 */ 894 /*ARGSUSED*/ 895 scsi_hba_tran_t * 896 scsi_hba_tran_alloc( 897 dev_info_t *self, 898 int flags) 899 { 900 scsi_hba_tran_t *tran; 901 902 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__)); 903 904 /* allocate SCSA flavors for self */ 905 ndi_flavorv_alloc(self, SCSA_NFLAVORS); 906 907 tran = kmem_zalloc(sizeof (scsi_hba_tran_t), 908 (flags & SCSI_HBA_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP); 909 910 if (tran) { 911 tran->tran_interconnect_type = INTERCONNECT_PARALLEL; 912 913 /* 914 * HBA driver called scsi_hba_tran_alloc(), so tran structure 915 * is proper size and unused/newer fields are zero. 916 * 917 * NOTE: We use SCSA_HBA_SCSA_TA as an obtuse form of 918 * versioning to detect old HBA drivers that do not use 919 * scsi_hba_tran_alloc, and would present garbage data 920 * (instead of valid/zero data) for newer tran fields. 921 */ 922 tran->tran_hba_flags |= SCSI_HBA_SCSA_TA; 923 } 924 925 return (tran); 926 } 927 928 /* 929 * Called by an HBA to free a scsi_hba_tran structure 930 */ 931 void 932 scsi_hba_tran_free( 933 scsi_hba_tran_t *tran) 934 { 935 SCSI_HBA_LOG((_LOG_TRACE, tran->tran_hba_dip, NULL, __func__)); 936 937 kmem_free(tran, sizeof (scsi_hba_tran_t)); 938 } 939 940 int 941 scsi_tran_ext_alloc( 942 scsi_hba_tran_t *tran, 943 size_t length, 944 int flags) 945 { 946 void *tran_ext; 947 int ret = DDI_FAILURE; 948 949 tran_ext = kmem_zalloc(length, 950 (flags & SCSI_HBA_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP); 951 if (tran_ext != NULL) { 952 tran->tran_extension = tran_ext; 953 ret = DDI_SUCCESS; 954 } 955 return (ret); 956 } 957 958 void 959 scsi_tran_ext_free( 960 scsi_hba_tran_t *tran, 961 size_t length) 962 { 963 if (tran->tran_extension != NULL) { 964 kmem_free(tran->tran_extension, length); 965 tran->tran_extension = NULL; 966 } 967 } 968 969 /* 970 * Obsolete: Called by an HBA to attach an instance of the driver 971 * Implement this older interface in terms of the new. 972 */ 973 /*ARGSUSED*/ 974 int 975 scsi_hba_attach( 976 dev_info_t *self, 977 ddi_dma_lim_t *hba_lim, 978 scsi_hba_tran_t *tran, 979 int flags, 980 void *hba_options) 981 { 982 ddi_dma_attr_t hba_dma_attr; 983 984 bzero(&hba_dma_attr, sizeof (ddi_dma_attr_t)); 985 hba_dma_attr.dma_attr_burstsizes = hba_lim->dlim_burstsizes; 986 hba_dma_attr.dma_attr_minxfer = hba_lim->dlim_minxfer; 987 988 return (scsi_hba_attach_setup(self, &hba_dma_attr, tran, flags)); 989 } 990 991 /* 992 * Common nexus teardown code: used by both scsi_hba_detach() on SCSA HBA node 993 * and iport_postdetach_tran_scsi_device() on a SCSA HBA iport node (and for 994 * failure cleanup). Undo scsa_nexus_setup in reverse order. 995 * 996 * NOTE: Since we are in the Solaris IO framework, we can depend on 997 * undocumented cleanup operations performed by other parts of the framework: 998 * like detach_node() calling ddi_prop_remove_all() and 999 * ddi_remove_minor_node(,NULL). 1000 */ 1001 static void 1002 scsa_nexus_teardown(dev_info_t *self, scsi_hba_tran_t *tran) 1003 { 1004 /* Teardown FMA. */ 1005 if (tran->tran_hba_flags & SCSI_HBA_SCSA_FM) { 1006 ddi_fm_fini(self); 1007 tran->tran_hba_flags &= ~SCSI_HBA_SCSA_FM; 1008 } 1009 } 1010 1011 /* 1012 * Common nexus setup code: used by both scsi_hba_attach_setup() on SCSA HBA 1013 * node and iport_preattach_tran_scsi_device() on a SCSA HBA iport node. 1014 * 1015 * This code makes no assumptions about tran use by scsi_device children. 1016 */ 1017 static int 1018 scsa_nexus_setup(dev_info_t *self, scsi_hba_tran_t *tran) 1019 { 1020 int capable; 1021 int scsa_minor; 1022 1023 /* 1024 * NOTE: SCSA maintains an 'fm-capable' domain, in tran_fm_capable, 1025 * that is not dependent (limited by) the capabilities of its parents. 1026 * For example a devinfo node in a branch that is not 1027 * DDI_FM_EREPORT_CAPABLE may report as capable, via tran_fm_capable, 1028 * to its scsi_device children. 1029 * 1030 * Get 'fm-capable' property from driver.conf, if present. If not 1031 * present, default to the scsi_fm_capable global (which has 1032 * DDI_FM_EREPORT_CAPABLE set by default). 1033 */ 1034 if (tran->tran_fm_capable == DDI_FM_NOT_CAPABLE) 1035 tran->tran_fm_capable = ddi_prop_get_int(DDI_DEV_T_ANY, self, 1036 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1037 "fm-capable", scsi_fm_capable); 1038 1039 /* 1040 * If an HBA is *not* doing its own fma support by calling 1041 * ddi_fm_init() prior to scsi_hba_attach_setup(), we provide a minimal 1042 * common SCSA implementation so that scsi_device children can generate 1043 * ereports via scsi_fm_ereport_post(). We use ddi_fm_capable() to 1044 * detect an HBA calling ddi_fm_init() prior to scsi_hba_attach_setup(). 1045 */ 1046 if (tran->tran_fm_capable && 1047 (ddi_fm_capable(self) == DDI_FM_NOT_CAPABLE)) { 1048 /* 1049 * We are capable of something, pass our capabilities up the 1050 * tree, but use a local variable so our parent can't limit 1051 * our capabilities (we don't want our parent to clear 1052 * DDI_FM_EREPORT_CAPABLE). 1053 * 1054 * NOTE: iblock cookies are not important because scsi HBAs 1055 * always interrupt below LOCK_LEVEL. 1056 */ 1057 capable = tran->tran_fm_capable; 1058 ddi_fm_init(self, &capable, NULL); 1059 1060 /* 1061 * Set SCSI_HBA_SCSA_FM bit to mark us as using the common 1062 * minimal SCSA fm implementation - we called ddi_fm_init(), 1063 * so we are responsible for calling ddi_fm_fini() in 1064 * scsi_hba_detach(). 1065 * 1066 * NOTE: if ddi_fm_init fails to establish handle, SKIP cleanup. 1067 */ 1068 if (DEVI(self)->devi_fmhdl) 1069 tran->tran_hba_flags |= SCSI_HBA_SCSA_FM; 1070 } 1071 1072 /* If SCSA responsible for for minor nodes, create :devctl minor. */ 1073 scsa_minor = (ddi_get_driver(self)->devo_cb_ops->cb_open == 1074 scsi_hba_open) ? 1 : 0; 1075 if (scsa_minor && ((ddi_create_minor_node(self, "devctl", S_IFCHR, 1076 INST2DEVCTL(ddi_get_instance(self)), DDI_NT_SCSI_NEXUS, 0) != 1077 DDI_SUCCESS))) { 1078 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 1079 "can't create :devctl minor node")); 1080 goto fail; 1081 } 1082 1083 return (DDI_SUCCESS); 1084 1085 fail: scsa_nexus_teardown(self, tran); 1086 return (DDI_FAILURE); 1087 } 1088 1089 /* 1090 * Common tran teardown code: used by iport_postdetach_tran_scsi_device() on a 1091 * SCSA HBA iport node and (possibly) by scsi_hba_detach() on SCSA HBA node 1092 * (and for failure cleanup). Undo scsa_tran_setup in reverse order. 1093 * 1094 * NOTE: Since we are in the Solaris IO framework, we can depend on 1095 * undocumented cleanup operations performed by other parts of the framework: 1096 * like detach_node() calling ddi_prop_remove_all() and 1097 * ddi_remove_minor_node(,NULL). 1098 */ 1099 static void 1100 scsa_tran_teardown(dev_info_t *self, scsi_hba_tran_t *tran) 1101 { 1102 tran->tran_iport_dip = NULL; 1103 1104 /* Teardown pHCI registration */ 1105 if (tran->tran_hba_flags & SCSI_HBA_SCSA_PHCI) { 1106 (void) mdi_phci_unregister(self, 0); 1107 tran->tran_hba_flags &= ~SCSI_HBA_SCSA_PHCI; 1108 } 1109 } 1110 1111 /* 1112 * Common tran setup code: used by iport_preattach_tran_scsi_device() on a 1113 * SCSA HBA iport node and (possibly) by scsi_hba_attach_setup() on SCSA HBA 1114 * node. 1115 */ 1116 static int 1117 scsa_tran_setup(dev_info_t *self, scsi_hba_tran_t *tran) 1118 { 1119 int scsa_minor; 1120 int id; 1121 char *scsi_binding_set; 1122 static const char *interconnect[] = INTERCONNECT_TYPE_ASCII; 1123 1124 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__)); 1125 1126 /* If SCSA responsible for for minor nodes, create ":scsi" */ 1127 scsa_minor = (ddi_get_driver(self)->devo_cb_ops->cb_open == 1128 scsi_hba_open) ? 1 : 0; 1129 if (scsa_minor && (ddi_create_minor_node(self, "scsi", S_IFCHR, 1130 INST2SCSI(ddi_get_instance(self)), 1131 DDI_NT_SCSI_ATTACHMENT_POINT, 0) != DDI_SUCCESS)) { 1132 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 1133 "can't create :scsi minor node")); 1134 goto fail; 1135 } 1136 1137 /* 1138 * If the property does not already exist on self then see if we can 1139 * pull it from further up the tree and define it on self. If the 1140 * property does not exist above (including options.conf) then use the 1141 * default value specified (global variable). We pull things down from 1142 * above for faster "DDI_PROP_NOTPROM | DDI_PROP_DONTPASS" runtime 1143 * access. 1144 * 1145 * Future: Should we avoid creating properties when value == global? 1146 */ 1147 #define CONFIG_INT_PROP(s, p, dv) { \ 1148 if ((ddi_prop_exists(DDI_DEV_T_ANY, s, \ 1149 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, p) == 0) && \ 1150 (ndi_prop_update_int(DDI_DEV_T_NONE, s, p, \ 1151 ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(s), \ 1152 DDI_PROP_NOTPROM, p, dv)) != DDI_PROP_SUCCESS)) \ 1153 SCSI_HBA_LOG((_LOG(WARN), NULL, s, \ 1154 "can't create property '%s'", p)); \ 1155 } 1156 1157 /* Decorate with scsi configuration properties */ 1158 CONFIG_INT_PROP(self, "scsi-enumeration", scsi_enumeration); 1159 CONFIG_INT_PROP(self, "scsi-options", scsi_options); 1160 CONFIG_INT_PROP(self, "scsi-reset-delay", scsi_reset_delay); 1161 CONFIG_INT_PROP(self, "scsi-watchdog-tick", scsi_watchdog_tick); 1162 CONFIG_INT_PROP(self, "scsi-selection-timeout", scsi_selection_timeout); 1163 CONFIG_INT_PROP(self, "scsi-tag-age-limit", scsi_tag_age_limit); 1164 1165 /* 1166 * Pull down the scsi-initiator-id from further up the tree, or as 1167 * defined by OBP. Place on node for faster access. NOTE: there is 1168 * some confusion about what the name of the property should be. 1169 */ 1170 id = ddi_prop_get_int(DDI_DEV_T_ANY, self, 0, "initiator-id", -1); 1171 if (id == -1) 1172 id = ddi_prop_get_int(DDI_DEV_T_ANY, self, 0, 1173 "scsi-initiator-id", -1); 1174 if (id != -1) 1175 CONFIG_INT_PROP(self, "scsi-initiator-id", id); 1176 1177 /* 1178 * If we are responsible for tran allocation, establish 1179 * 'initiator-interconnect-type'. 1180 */ 1181 if ((tran->tran_hba_flags & SCSI_HBA_SCSA_TA) && 1182 (tran->tran_interconnect_type > 0) && 1183 (tran->tran_interconnect_type < INTERCONNECT_MAX)) { 1184 if (ndi_prop_update_string(DDI_DEV_T_NONE, self, 1185 "initiator-interconnect-type", 1186 (char *)interconnect[tran->tran_interconnect_type]) 1187 != DDI_PROP_SUCCESS) { 1188 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 1189 "failed to establish " 1190 "'initiator-interconnect-type'")); 1191 goto fail; 1192 } 1193 } 1194 1195 /* 1196 * The 'scsi-binding-set' property can be defined in driver.conf 1197 * files of legacy drivers on an as-needed basis. If 'scsi-binding-set' 1198 * is not driver.conf defined, and the HBA is not implementing its own 1199 * private bus_config, we define scsi-binding-set to the default 1200 * 'spi' legacy value. 1201 * 1202 * NOTE: This default 'spi' value will be deleted if an HBA driver 1203 * ends up using the scsi_hba_tgtmap_create() enumeration services. 1204 * 1205 * NOTE: If we were ever to decide to derive 'scsi-binding-set' from 1206 * the IEEE-1275 'device_type' property then this is where that code 1207 * should go - there is not enough consistency in 'device_type' to do 1208 * this correctly at this point in time. 1209 */ 1210 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self, 1211 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-binding-set", 1212 &scsi_binding_set) == DDI_PROP_SUCCESS) { 1213 SCSI_HBA_LOG((_LOG(2), NULL, self, 1214 "external 'scsi-binding-set' \"%s\"", scsi_binding_set)); 1215 ddi_prop_free(scsi_binding_set); 1216 } else if (scsi_binding_set_spi && 1217 ((tran->tran_bus_config == NULL) || 1218 (tran->tran_bus_config == scsi_hba_bus_config_spi))) { 1219 if (ndi_prop_update_string(DDI_DEV_T_NONE, self, 1220 "scsi-binding-set", scsi_binding_set_spi) != 1221 DDI_PROP_SUCCESS) { 1222 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 1223 "failed to establish 'scsi_binding_set' default")); 1224 goto fail; 1225 } 1226 SCSI_HBA_LOG((_LOG(2), NULL, self, 1227 "default 'scsi-binding-set' \"%s\"", scsi_binding_set_spi)); 1228 } else 1229 SCSI_HBA_LOG((_LOG(2), NULL, self, 1230 "no 'scsi-binding-set'")); 1231 1232 /* 1233 * If SCSI_HBA_TRAN_PHCI is set, take care of pHCI registration of the 1234 * initiator. 1235 */ 1236 if ((tran->tran_hba_flags & SCSI_HBA_TRAN_PHCI) && 1237 (mdi_phci_register(MDI_HCI_CLASS_SCSI, self, 0) == MDI_SUCCESS)) 1238 tran->tran_hba_flags |= SCSI_HBA_SCSA_PHCI; 1239 1240 /* NOTE: tran_hba_dip is for DMA operation at the HBA node level */ 1241 tran->tran_iport_dip = self; /* for iport association */ 1242 return (DDI_SUCCESS); 1243 1244 fail: scsa_tran_teardown(self, tran); 1245 return (DDI_FAILURE); 1246 } 1247 1248 /* 1249 * Called by a SCSA HBA driver to attach an instance of the driver to 1250 * SCSA HBA node enumerated by PCI. 1251 */ 1252 int 1253 scsi_hba_attach_setup( 1254 dev_info_t *self, 1255 ddi_dma_attr_t *hba_dma_attr, 1256 scsi_hba_tran_t *tran, 1257 int flags) 1258 { 1259 int len; 1260 char cache_name[96]; 1261 1262 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__)); 1263 1264 /* 1265 * Verify that we are a driver so other code does not need to 1266 * check for NULL ddi_get_driver() result. 1267 */ 1268 if (ddi_get_driver(self) == NULL) 1269 return (DDI_FAILURE); 1270 1271 /* 1272 * Verify that we are called on a SCSA HBA node (function enumerated 1273 * by PCI), not on an iport node. 1274 */ 1275 ASSERT(scsi_hba_iport_unit_address(self) == NULL); 1276 if (scsi_hba_iport_unit_address(self)) 1277 return (DDI_FAILURE); /* self can't be an iport */ 1278 1279 /* Caller must provide the tran. */ 1280 ASSERT(tran); 1281 if (tran == NULL) 1282 return (DDI_FAILURE); 1283 1284 /* 1285 * Verify correct scsi_hba_tran_t form: 1286 * 1287 * o Both or none of tran_get_name/tran_get_addr. 1288 * NOTE: Older SCSA HBA drivers for SCSI transports with addressing 1289 * that did not fit the SPI "struct scsi_address" model were required 1290 * to implement tran_get_name and tran_get_addr. This is no longer 1291 * true - modern transport drivers should now use common SCSA 1292 * enumeration services. The SCSA enumeration code will represent 1293 * the unit-address using well-known address properties 1294 * (SCSI_ADDR_PROP_TARGET_PORT, SCSI_ADDR_PROP_LUN64) during 1295 * devinfo/pathinfo node creation. The HBA driver can obtain values 1296 * using scsi_device_prop_lookup_*() from its tran_tgt_init(9E). 1297 * 1298 */ 1299 if ((tran->tran_get_name == NULL) ^ (tran->tran_get_bus_addr == NULL)) { 1300 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 1301 "should support both or neither: " 1302 "tran_get_name, tran_get_bus_addr")); 1303 return (DDI_FAILURE); 1304 } 1305 1306 /* 1307 * Establish the devinfo context of this tran structure, preserving 1308 * knowledge of how the tran was allocated. 1309 */ 1310 tran->tran_hba_dip = self; /* for DMA */ 1311 tran->tran_hba_flags = (flags & ~SCSI_HBA_SCSA_TA) | 1312 (tran->tran_hba_flags & SCSI_HBA_SCSA_TA); 1313 1314 /* Establish flavor of transport (and ddi_get_driver_private()) */ 1315 ndi_flavorv_set(self, SCSA_FLAVOR_SCSI_DEVICE, tran); 1316 1317 /* 1318 * Note: We only need dma_attr_minxfer and dma_attr_burstsizes 1319 * from the DMA attributes. scsi_hba_attach(9f) only guarantees 1320 * that these two fields are initialized properly. If this 1321 * changes, be sure to revisit the implementation of 1322 * scsi_hba_attach(9F). 1323 */ 1324 (void) memcpy(&tran->tran_dma_attr, hba_dma_attr, 1325 sizeof (ddi_dma_attr_t)); 1326 1327 /* Create tran_setup_pkt(9E) kmem_cache. */ 1328 if (tran->tran_setup_pkt) { 1329 ASSERT(tran->tran_init_pkt == NULL); 1330 ASSERT(tran->tran_destroy_pkt == NULL); 1331 if (tran->tran_init_pkt || tran->tran_destroy_pkt) 1332 goto fail; 1333 1334 tran->tran_init_pkt = scsi_init_cache_pkt; 1335 tran->tran_destroy_pkt = scsi_free_cache_pkt; 1336 tran->tran_sync_pkt = scsi_sync_cache_pkt; 1337 tran->tran_dmafree = scsi_cache_dmafree; 1338 1339 len = sizeof (struct scsi_pkt_cache_wrapper); 1340 len += ROUNDUP(tran->tran_hba_len); 1341 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) 1342 len += ROUNDUP(DEFAULT_CDBLEN); 1343 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB) 1344 len += ROUNDUP(DEFAULT_SCBLEN); 1345 1346 (void) snprintf(cache_name, sizeof (cache_name), 1347 "pkt_cache_%s_%d", ddi_driver_name(self), 1348 ddi_get_instance(self)); 1349 1350 tran->tran_pkt_cache_ptr = kmem_cache_create( 1351 cache_name, len, 8, scsi_hba_pkt_constructor, 1352 scsi_hba_pkt_destructor, NULL, tran, NULL, 0); 1353 } 1354 1355 /* Perform node setup independent of initiator role */ 1356 if (scsa_nexus_setup(self, tran) != DDI_SUCCESS) 1357 goto fail; 1358 1359 /* 1360 * The SCSI_HBA_HBA flag is passed to scsi_hba_attach_setup when the 1361 * HBA driver knows that *all* children of the SCSA HBA node will be 1362 * 'iports'. If the SCSA HBA node can have iport children and also 1363 * function as an initiator for xxx_device children then it should 1364 * not specify SCSI_HBA_HBA in its scsi_hba_attach_setup call. An 1365 * HBA driver that does not manage iports should not set SCSA_HBA_HBA. 1366 */ 1367 if (tran->tran_hba_flags & SCSI_HBA_HBA) { 1368 /* 1369 * Set the 'ddi-config-driver-node' property on the nexus 1370 * node that notify attach_driver_nodes() to configure all 1371 * immediate children so that nodes which bind to the 1372 * same driver as parent are able to be added into per-driver 1373 * list. 1374 */ 1375 if (ndi_prop_create_boolean(DDI_DEV_T_NONE, 1376 self, "ddi-config-driver-node") != DDI_PROP_SUCCESS) 1377 goto fail; 1378 } else { 1379 if (scsa_tran_setup(self, tran) != DDI_SUCCESS) 1380 goto fail; 1381 } 1382 1383 return (DDI_SUCCESS); 1384 1385 fail: (void) scsi_hba_detach(self); 1386 return (DDI_FAILURE); 1387 } 1388 1389 /* 1390 * Called by an HBA to detach an instance of the driver. This may be called 1391 * for SCSA HBA nodes and for SCSA iport nodes. 1392 */ 1393 int 1394 scsi_hba_detach(dev_info_t *self) 1395 { 1396 scsi_hba_tran_t *tran; 1397 1398 ASSERT(scsi_hba_iport_unit_address(self) == NULL); 1399 if (scsi_hba_iport_unit_address(self)) 1400 return (DDI_FAILURE); /* self can't be an iport */ 1401 1402 /* Check all error return conditions upfront */ 1403 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 1404 ASSERT(tran); 1405 if (tran == NULL) 1406 return (DDI_FAILURE); 1407 1408 ASSERT(tran->tran_open_flag == 0); 1409 if (tran->tran_open_flag) 1410 return (DDI_FAILURE); 1411 1412 if (!(tran->tran_hba_flags & SCSI_HBA_HBA)) 1413 scsa_tran_teardown(self, tran); 1414 scsa_nexus_teardown(self, tran); 1415 1416 /* Teardown tran_setup_pkt(9E) kmem_cache. */ 1417 if (tran->tran_pkt_cache_ptr) { 1418 kmem_cache_destroy(tran->tran_pkt_cache_ptr); 1419 tran->tran_pkt_cache_ptr = NULL; 1420 } 1421 1422 (void) memset(&tran->tran_dma_attr, 0, sizeof (ddi_dma_attr_t)); 1423 1424 /* Teardown flavor of transport (and ddi_get_driver_private()) */ 1425 ndi_flavorv_set(self, SCSA_FLAVOR_SCSI_DEVICE, NULL); 1426 1427 tran->tran_hba_dip = NULL; 1428 1429 return (DDI_SUCCESS); 1430 } 1431 1432 1433 /* 1434 * Called by an HBA from _fini() 1435 */ 1436 void 1437 scsi_hba_fini(struct modlinkage *modlp) 1438 { 1439 struct dev_ops *hba_dev_ops; 1440 1441 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__)); 1442 1443 /* Get the devops structure of this module and clear bus_ops vector. */ 1444 hba_dev_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 1445 1446 if (hba_dev_ops->devo_cb_ops == &scsi_hba_cbops) 1447 hba_dev_ops->devo_cb_ops = NULL; 1448 1449 if (hba_dev_ops->devo_getinfo == scsi_hba_info) 1450 hba_dev_ops->devo_getinfo = NULL; 1451 1452 hba_dev_ops->devo_bus_ops = (struct bus_ops *)NULL; 1453 } 1454 1455 /* 1456 * SAS specific functions 1457 */ 1458 smp_hba_tran_t * 1459 smp_hba_tran_alloc(dev_info_t *self) 1460 { 1461 /* allocate SCSA flavors for self */ 1462 ndi_flavorv_alloc(self, SCSA_NFLAVORS); 1463 return (kmem_zalloc(sizeof (smp_hba_tran_t), KM_SLEEP)); 1464 } 1465 1466 void 1467 smp_hba_tran_free(smp_hba_tran_t *tran) 1468 { 1469 kmem_free(tran, sizeof (smp_hba_tran_t)); 1470 } 1471 1472 int 1473 smp_hba_attach_setup( 1474 dev_info_t *self, 1475 smp_hba_tran_t *tran) 1476 { 1477 ASSERT(scsi_hba_iport_unit_address(self) == NULL); 1478 if (scsi_hba_iport_unit_address(self)) 1479 return (DDI_FAILURE); /* self can't be an iport */ 1480 1481 /* 1482 * The owner of the this devinfo_t was responsible 1483 * for informing the framework already about 1484 * additional flavors. 1485 */ 1486 ndi_flavorv_set(self, SCSA_FLAVOR_SMP, tran); 1487 return (DDI_SUCCESS); 1488 } 1489 1490 int 1491 smp_hba_detach(dev_info_t *self) 1492 { 1493 ASSERT(scsi_hba_iport_unit_address(self) == NULL); 1494 if (scsi_hba_iport_unit_address(self)) 1495 return (DDI_FAILURE); /* self can't be an iport */ 1496 1497 ndi_flavorv_set(self, SCSA_FLAVOR_SMP, NULL); 1498 return (DDI_SUCCESS); 1499 } 1500 1501 /* 1502 * SMP child flavored functions 1503 */ 1504 static int 1505 smp_busctl_ua(dev_info_t *child, char *addr, int maxlen) 1506 { 1507 char *tport; 1508 char *wwn; 1509 1510 /* limit ndi_devi_findchild_by_callback to expected flavor */ 1511 if (ndi_flavor_get(child) != SCSA_FLAVOR_SMP) 1512 return (DDI_FAILURE); 1513 1514 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 1515 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1516 SCSI_ADDR_PROP_TARGET_PORT, &tport) == DDI_SUCCESS) { 1517 (void) snprintf(addr, maxlen, "%s", tport); 1518 ddi_prop_free(tport); 1519 return (DDI_SUCCESS); 1520 } 1521 1522 /* 1523 * NOTE: the following code should be deleted when mpt is changed to 1524 * use SCSI_ADDR_PROP_TARGET_PORT instead of SMP_WWN. 1525 */ 1526 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 1527 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1528 SMP_WWN, &wwn) == DDI_SUCCESS) { 1529 (void) snprintf(addr, maxlen, "w%s", wwn); 1530 ddi_prop_free(wwn); 1531 return (DDI_SUCCESS); 1532 } 1533 return (DDI_FAILURE); 1534 } 1535 1536 static int 1537 smp_busctl_reportdev(dev_info_t *child) 1538 { 1539 dev_info_t *self = ddi_get_parent(child); 1540 char *tport; 1541 char *wwn; 1542 1543 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 1544 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1545 SCSI_ADDR_PROP_TARGET_PORT, &tport) == DDI_SUCCESS) { 1546 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: target-port %s", 1547 ddi_driver_name(child), ddi_get_instance(child), 1548 ddi_driver_name(self), ddi_get_instance(self), tport)); 1549 ddi_prop_free(tport); 1550 return (DDI_SUCCESS); 1551 } 1552 1553 /* 1554 * NOTE: the following code should be deleted when mpt is changed to 1555 * use SCSI_ADDR_PROP_TARGET_PORT instead of SMP_WWN. 1556 */ 1557 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 1558 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1559 SMP_WWN, &wwn) == DDI_SUCCESS) { 1560 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: wwn %s", 1561 ddi_driver_name(child), ddi_get_instance(child), 1562 ddi_driver_name(self), ddi_get_instance(self), wwn)); 1563 ddi_prop_free(wwn); 1564 return (DDI_SUCCESS); 1565 } 1566 return (DDI_FAILURE); 1567 } 1568 1569 static int 1570 smp_busctl_initchild(dev_info_t *child) 1571 { 1572 dev_info_t *self = ddi_get_parent(child); 1573 smp_hba_tran_t *tran; 1574 dev_info_t *dup; 1575 char addr[SCSI_MAXNAMELEN]; 1576 struct smp_device *smp_sd; 1577 uint64_t wwn; 1578 1579 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SMP); 1580 ASSERT(tran); 1581 if (tran == NULL) 1582 return (DDI_FAILURE); 1583 1584 if (smp_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS) 1585 return (DDI_NOT_WELL_FORMED); 1586 if (scsi_wwnstr_to_wwn(addr, &wwn)) 1587 return (DDI_NOT_WELL_FORMED); 1588 1589 /* Prevent duplicate nodes. */ 1590 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr, 1591 smp_busctl_ua); 1592 if (dup) { 1593 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_SMP); 1594 if (ndi_flavor_get(dup) != SCSA_FLAVOR_SMP) { 1595 SCSI_HBA_LOG((_LOG(1), NULL, child, 1596 "init failed: %s@%s: not SMP flavored", 1597 ddi_node_name(child), addr)); 1598 return (DDI_FAILURE); 1599 } 1600 if (dup != child) { 1601 SCSI_HBA_LOG((_LOG(4), NULL, child, 1602 "init failed: %s@%s: detected duplicate %p", 1603 ddi_node_name(child), addr, (void *)dup)); 1604 return (DDI_FAILURE); 1605 } 1606 } 1607 1608 1609 /* set the node @addr string */ 1610 ddi_set_name_addr(child, addr); 1611 1612 /* Allocate and initialize smp_device. */ 1613 smp_sd = kmem_zalloc(sizeof (struct smp_device), KM_SLEEP); 1614 smp_sd->smp_sd_dev = child; 1615 smp_sd->smp_sd_address.smp_a_hba_tran = tran; 1616 bcopy(&wwn, smp_sd->smp_sd_address.smp_a_wwn, SAS_WWN_BYTE_SIZE); 1617 1618 ddi_set_driver_private(child, smp_sd); 1619 1620 if (tran->smp_tran_init && ((*tran->smp_tran_init)(self, child, 1621 tran, smp_sd) != DDI_SUCCESS)) { 1622 kmem_free(smp_sd, sizeof (struct smp_device)); 1623 scsi_enumeration_failed(child, -1, NULL, "smp_tran_init"); 1624 ddi_set_driver_private(child, NULL); 1625 ddi_set_name_addr(child, NULL); 1626 return (DDI_FAILURE); 1627 } 1628 1629 return (DDI_SUCCESS); 1630 } 1631 1632 /*ARGSUSED*/ 1633 static int 1634 smp_busctl_uninitchild(dev_info_t *child) 1635 { 1636 dev_info_t *self = ddi_get_parent(child); 1637 struct smp_device *smp_sd = ddi_get_driver_private(child); 1638 smp_hba_tran_t *tran; 1639 1640 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SMP); 1641 ASSERT(smp_sd && tran); 1642 if ((smp_sd == NULL) || (tran == NULL)) 1643 return (DDI_FAILURE); 1644 1645 if (tran->smp_tran_free) 1646 (*tran->smp_tran_free) (self, child, tran, smp_sd); 1647 1648 kmem_free(smp_sd, sizeof (*smp_sd)); 1649 ddi_set_driver_private(child, NULL); 1650 ddi_set_name_addr(child, NULL); 1651 return (DDI_SUCCESS); 1652 } 1653 1654 /* Find an "smp" child at the specified address. */ 1655 static dev_info_t * 1656 smp_findchild(dev_info_t *self, char *addr) 1657 { 1658 dev_info_t *child; 1659 1660 /* Search "smp" devinfo child at specified address. */ 1661 ASSERT(self && DEVI_BUSY_OWNED(self) && addr); 1662 for (child = ddi_get_child(self); child; 1663 child = ddi_get_next_sibling(child)) { 1664 /* skip non-"smp" nodes */ 1665 if (ndi_flavor_get(child) != SCSA_FLAVOR_SMP) 1666 continue; 1667 1668 /* Attempt initchild to establish unit-address */ 1669 if (i_ddi_node_state(child) < DS_INITIALIZED) 1670 (void) ddi_initchild(self, child); 1671 1672 /* Verify state and non-NULL unit-address. */ 1673 if ((i_ddi_node_state(child) < DS_INITIALIZED) || 1674 (ddi_get_name_addr(child) == NULL)) 1675 continue; 1676 1677 /* Return "smp" child if unit-address matches. */ 1678 if (strcmp(ddi_get_name_addr(child), addr) == 0) 1679 return (child); 1680 } 1681 return (NULL); 1682 } 1683 1684 /* 1685 * Search for "smp" child of self at the specified address. If found, online 1686 * and return with a hold. Unlike general SCSI configuration, we can assume 1687 * the the device is actually there when we are called (i.e., device is 1688 * created by hotplug, not by bus_config). 1689 */ 1690 int 1691 smp_hba_bus_config(dev_info_t *self, char *addr, dev_info_t **childp) 1692 { 1693 dev_info_t *child; 1694 int circ; 1695 1696 ASSERT(self && addr && childp); 1697 *childp = NULL; 1698 1699 /* Search for "smp" child. */ 1700 scsi_hba_devi_enter(self, &circ); 1701 if ((child = smp_findchild(self, addr)) == NULL) { 1702 scsi_hba_devi_exit(self, circ); 1703 return (NDI_FAILURE); 1704 } 1705 1706 /* Attempt online. */ 1707 if (ndi_devi_online(child, 0) != NDI_SUCCESS) { 1708 scsi_hba_devi_exit(self, circ); 1709 return (NDI_FAILURE); 1710 } 1711 1712 /* On success, return with active hold. */ 1713 ndi_hold_devi(child); 1714 scsi_hba_devi_exit(self, circ); 1715 *childp = child; 1716 return (NDI_SUCCESS); 1717 } 1718 1719 1720 1721 /* Create "smp" child devinfo node at specified unit-address. */ 1722 int 1723 smp_hba_bus_config_taddr(dev_info_t *self, char *addr) 1724 { 1725 dev_info_t *child; 1726 int circ; 1727 1728 /* 1729 * NOTE: If we ever uses a generic node name (.vs. a driver name) 1730 * or define a 'compatible' property, this code will need to use 1731 * a 'probe' node (ala scsi_device support) to obtain identity 1732 * information from the device. 1733 */ 1734 1735 /* Search for "smp" child. */ 1736 scsi_hba_devi_enter(self, &circ); 1737 child = smp_findchild(self, addr); 1738 if (child) { 1739 /* Child exists, note if this was a new reinsert. */ 1740 if (ndi_devi_device_insert(child)) 1741 SCSI_HBA_LOG((_LOGCFG, self, NULL, 1742 "devinfo smp@%s device_reinsert", addr)); 1743 1744 scsi_hba_devi_exit(self, circ); 1745 return (NDI_SUCCESS); 1746 } 1747 1748 /* Allocate "smp" child devinfo node and establish flavor of child. */ 1749 ndi_devi_alloc_sleep(self, "smp", DEVI_SID_HP_NODEID, &child); 1750 ASSERT(child); 1751 ndi_flavor_set(child, SCSA_FLAVOR_SMP); 1752 1753 /* Add unit-address property to child. */ 1754 if (ndi_prop_update_string(DDI_DEV_T_NONE, child, 1755 SCSI_ADDR_PROP_TARGET_PORT, addr) != DDI_PROP_SUCCESS) { 1756 (void) ndi_devi_free(child); 1757 scsi_hba_devi_exit(self, circ); 1758 return (NDI_FAILURE); 1759 } 1760 1761 /* Attempt to online the new "smp" node. */ 1762 (void) ndi_devi_online(child, 0); 1763 1764 scsi_hba_devi_exit(self, circ); 1765 return (NDI_SUCCESS); 1766 } 1767 1768 /* 1769 * Wrapper to scsi_ua_get which takes a devinfo argument instead of a 1770 * scsi_device structure. 1771 */ 1772 static int 1773 scsi_busctl_ua(dev_info_t *child, char *addr, int maxlen) 1774 { 1775 struct scsi_device *sd; 1776 1777 /* limit ndi_devi_findchild_by_callback to expected flavor */ 1778 if (ndi_flavor_get(child) != SCSA_FLAVOR_SCSI_DEVICE) 1779 return (DDI_FAILURE); 1780 1781 /* nodes are named by tran_get_name or default "tgt,lun" */ 1782 sd = ddi_get_driver_private(child); 1783 if (sd && (scsi_ua_get(sd, addr, maxlen) == 1)) 1784 return (DDI_SUCCESS); 1785 1786 return (DDI_FAILURE); 1787 } 1788 1789 static int 1790 scsi_busctl_reportdev(dev_info_t *child) 1791 { 1792 dev_info_t *self = ddi_get_parent(child); 1793 struct scsi_device *sd = ddi_get_driver_private(child); 1794 scsi_hba_tran_t *tran; 1795 char ua[SCSI_MAXNAMELEN]; 1796 char ra[SCSI_MAXNAMELEN]; 1797 1798 SCSI_HBA_LOG((_LOG_TRACE, NULL, child, __func__)); 1799 1800 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 1801 ASSERT(tran && sd); 1802 if ((tran == NULL) || (sd == NULL)) 1803 return (DDI_FAILURE); 1804 1805 /* get the unit_address and bus_addr information */ 1806 if ((scsi_ua_get(sd, ua, sizeof (ua)) == 0) || 1807 (scsi_ua_get_reportdev(sd, ra, sizeof (ra)) == 0)) { 1808 SCSI_HBA_LOG((_LOG(WARN), NULL, child, "REPORTDEV failure")); 1809 return (DDI_FAILURE); 1810 } 1811 1812 if (tran->tran_get_name == NULL) 1813 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: %s", 1814 ddi_driver_name(child), ddi_get_instance(child), 1815 ddi_driver_name(self), ddi_get_instance(self), ra)); 1816 else if (*ra) 1817 SCSI_HBA_LOG((_LOG_NF(CONT), 1818 "?%s%d at %s%d: unit-address %s: %s", 1819 ddi_driver_name(child), ddi_get_instance(child), 1820 ddi_driver_name(self), ddi_get_instance(self), ua, ra)); 1821 else 1822 SCSI_HBA_LOG((_LOG_NF(CONT), 1823 "?%s%d at %s%d: unit-address %s", 1824 ddi_driver_name(child), ddi_get_instance(child), 1825 ddi_driver_name(self), ddi_get_instance(self), ua)); 1826 1827 return (DDI_SUCCESS); 1828 } 1829 1830 1831 /* 1832 * scsi_busctl_initchild is called to initialize the SCSA transport for 1833 * communication with a particular child scsi target device. Successful 1834 * initialization requires properties on the node which describe the address 1835 * of the target device. If the address of the target device can't be 1836 * determined from properties then DDI_NOT_WELL_FORMED is returned. Nodes that 1837 * are DDI_NOT_WELL_FORMED are considered an implementation artifact and 1838 * are hidden from devinfo snapshots by calling ndi_devi_set_hidden(). 1839 * The child may be one of the following types of devinfo nodes: 1840 * 1841 * OBP node: 1842 * OBP does not enumerate target devices attached a SCSI bus. These 1843 * template/stub/wild-card nodes are a legacy artifact for support of old 1844 * driver loading methods. Since they have no properties, 1845 * DDI_NOT_WELL_FORMED will be returned. 1846 * 1847 * SID node: 1848 * The node may be either a: 1849 * o probe/barrier SID node 1850 * o a dynamic SID target node 1851 * 1852 * driver.conf node: The situation for this nexus is different than most. 1853 * Typically a driver.conf node definition is used to either define a 1854 * new child devinfo node or to further decorate (via merge) a SID 1855 * child with properties. In our case we use the nodes for *both* 1856 * purposes. 1857 * 1858 * In both the SID node and driver.conf node cases we must form the nodes 1859 * "@addr" from the well-known scsi(9P) device unit-address properties on 1860 * the node. 1861 * 1862 * For HBA drivers that implement the deprecated tran_get_name interface, 1863 * "@addr" construction involves having that driver interpret properties via 1864 * scsi_busctl_ua -> scsi_ua_get -> tran_get_name: there is no 1865 * requirement for the property names to be well-known. 1866 * 1867 * NOTE: We don't currently support "merge". When this support is added a 1868 * specific property, like "unit-address", should *always* identify a 1869 * driver.conf node that needs to be merged into a specific SID node. When 1870 * enumeration is enabled, a .conf node without the "unit-address" property 1871 * should be ignored. The best way to establish the "unit-address" property 1872 * would be to have the system assign parent= and unit-address= from an 1873 * instance=# driver.conf entry (by using the instance tree). 1874 */ 1875 static int 1876 scsi_busctl_initchild(dev_info_t *child) 1877 { 1878 dev_info_t *self = ddi_get_parent(child); 1879 dev_info_t *dup; 1880 scsi_hba_tran_t *tran; 1881 struct scsi_device *sd; 1882 scsi_hba_tran_t *tran_clone; 1883 char *class; 1884 int tgt; 1885 int lun; 1886 int sfunc; 1887 int err = DDI_FAILURE; 1888 char addr[SCSI_MAXNAMELEN]; 1889 1890 ASSERT(DEVI_BUSY_OWNED(self)); 1891 SCSI_HBA_LOG((_LOG(4), NULL, child, "init begin")); 1892 1893 /* 1894 * For a driver like fp with multiple upper-layer-protocols 1895 * it is possible for scsi_hba_init in _init to plumb SCSA 1896 * and have the load of fcp (which does scsi_hba_attach_setup) 1897 * to fail. In this case we may get here with a NULL hba. 1898 */ 1899 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 1900 if (tran == NULL) 1901 return (DDI_NOT_WELL_FORMED); 1902 1903 /* 1904 * OBP may create template/stub/wild-card nodes for legacy driver 1905 * loading methods. These nodes have no properties, so we lack the 1906 * addressing properties to initchild them. Hide the node and return 1907 * DDI_NOT_WELL_FORMED. 1908 * 1909 * Future: define/use a ndi_devi_has_properties(dip) type interface. 1910 * 1911 * NOTE: It would be nice if we could delete these ill formed nodes by 1912 * implementing a DDI_NOT_WELL_FORMED_DELETE return code. This can't 1913 * be done until leadville debug code removes its dependencies 1914 * on the devinfo still being present after a failed ndi_devi_online. 1915 */ 1916 if ((DEVI(child)->devi_hw_prop_ptr == NULL) && 1917 (DEVI(child)->devi_drv_prop_ptr == NULL) && 1918 (DEVI(child)->devi_sys_prop_ptr == NULL)) { 1919 SCSI_HBA_LOG((_LOG(4), NULL, child, 1920 "init failed: no properties")); 1921 ndi_devi_set_hidden(child); 1922 return (DDI_NOT_WELL_FORMED); 1923 } 1924 1925 /* get legacy SPI addressing properties */ 1926 if ((tgt = ddi_prop_get_int(DDI_DEV_T_ANY, child, 1927 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1928 SCSI_ADDR_PROP_TARGET, -1)) == -1) { 1929 tgt = 0; 1930 /* 1931 * A driver.conf node for merging always has a target= property, 1932 * even if it is just a dummy that does not contain the real 1933 * target address. However drivers that register devids may 1934 * create stub driver.conf nodes without a target= property so 1935 * that pathological devid resolution works. Hide the stub 1936 * node and return DDI_NOT_WELL_FORMED. 1937 */ 1938 if (!scsi_hba_dev_is_sid(child)) { 1939 SCSI_HBA_LOG((_LOG(4), NULL, child, 1940 "init failed: stub .conf node")); 1941 ndi_devi_set_hidden(child); 1942 return (DDI_NOT_WELL_FORMED); 1943 } 1944 } 1945 lun = ddi_prop_get_int(DDI_DEV_T_ANY, child, 1946 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, SCSI_ADDR_PROP_LUN, 0); 1947 sfunc = ddi_prop_get_int(DDI_DEV_T_ANY, child, 1948 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, SCSI_ADDR_PROP_SFUNC, -1); 1949 1950 /* 1951 * The scsi_address structure may not specify all the addressing 1952 * information. For an old HBA that doesn't support tran_get_name 1953 * (most pre-SCSI-3 HBAs) the scsi_address structure is still used, 1954 * so the target property must exist and the LUN must be < 256. 1955 */ 1956 if ((tran->tran_get_name == NULL) && 1957 ((tgt >= USHRT_MAX) || (lun >= 256))) { 1958 SCSI_HBA_LOG((_LOG(1), NULL, child, 1959 "init failed: illegal/missing properties")); 1960 ndi_devi_set_hidden(child); 1961 return (DDI_NOT_WELL_FORMED); 1962 } 1963 1964 /* 1965 * We need to initialize a fair amount of our environment to invoke 1966 * tran_get_name (via scsi_busctl_ua and scsi_ua_get) to 1967 * produce the "@addr" name from addressing properties. Allocate and 1968 * initialize scsi device structure. 1969 */ 1970 sd = kmem_zalloc(sizeof (struct scsi_device), KM_SLEEP); 1971 mutex_init(&sd->sd_mutex, NULL, MUTEX_DRIVER, NULL); 1972 sd->sd_dev = child; 1973 sd->sd_pathinfo = NULL; 1974 sd->sd_uninit_prevent = 0; 1975 ddi_set_driver_private(child, sd); 1976 1977 if (tran->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX) { 1978 /* 1979 * For a SCSI_HBA_ADDR_COMPLEX transport we store a pointer to 1980 * scsi_device in the scsi_address structure. This allows an 1981 * HBA driver to find its per-scsi_device private data 1982 * (accessible to the HBA given just the scsi_address by using 1983 * scsi_address_device(9F)/scsi_device_hba_private_get(9F)). 1984 */ 1985 sd->sd_address.a.a_sd = sd; 1986 tran_clone = NULL; 1987 } else { 1988 /* 1989 * Initialize the scsi_address so that a SCSI-2 target driver 1990 * talking to a SCSI-2 device on a SCSI-3 bus (spi) continues 1991 * to work. We skew the secondary function value so that we 1992 * can tell from the address structure if we are processing 1993 * a secondary function request. 1994 */ 1995 sd->sd_address.a_target = (ushort_t)tgt; 1996 sd->sd_address.a_lun = (uchar_t)lun; 1997 if (sfunc == -1) 1998 sd->sd_address.a_sublun = (uchar_t)0; 1999 else 2000 sd->sd_address.a_sublun = (uchar_t)sfunc + 1; 2001 2002 /* 2003 * NOTE: Don't limit LUNs to scsi_options value because a 2004 * scsi_device discovered via SPI dynamic enumeration might 2005 * still support SCMD_REPORT_LUNS. 2006 */ 2007 2008 /* 2009 * Deprecated: Use SCSI_HBA_ADDR_COMPLEX: 2010 * Clone transport structure if requested. Cloning allows 2011 * an HBA to maintain target-specific information if 2012 * necessary, such as target addressing information that 2013 * does not adhere to the scsi_address structure format. 2014 */ 2015 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE) { 2016 tran_clone = kmem_alloc( 2017 sizeof (scsi_hba_tran_t), KM_SLEEP); 2018 bcopy((caddr_t)tran, 2019 (caddr_t)tran_clone, sizeof (scsi_hba_tran_t)); 2020 tran = tran_clone; 2021 tran->tran_sd = sd; 2022 } else { 2023 tran_clone = NULL; 2024 ASSERT(tran->tran_sd == NULL); 2025 } 2026 } 2027 2028 /* establish scsi_address pointer to the HBA's tran structure */ 2029 sd->sd_address.a_hba_tran = tran; 2030 2031 /* 2032 * This is a grotty hack that allows direct-access (non-scsa) drivers 2033 * (like chs, ata, and mlx which all make cmdk children) to put its 2034 * own vector in the 'a_hba_tran' field. When all the drivers that do 2035 * this are fixed, please remove this hack. 2036 * 2037 * NOTE: This hack is also shows up in the DEVP_TO_TRAN implementation 2038 * in scsi_confsubr.c. 2039 */ 2040 sd->sd_tran_safe = tran; 2041 2042 /* 2043 * If the class property is not already established, set it to "scsi". 2044 * This is done so that parent= driver.conf nodes have class. 2045 */ 2046 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 2047 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "class", 2048 &class) == DDI_PROP_SUCCESS) { 2049 ddi_prop_free(class); 2050 } else if (ndi_prop_update_string(DDI_DEV_T_NONE, child, 2051 "class", "scsi") != DDI_PROP_SUCCESS) { 2052 SCSI_HBA_LOG((_LOG(2), NULL, child, "init failed: class")); 2053 ndi_devi_set_hidden(child); 2054 err = DDI_NOT_WELL_FORMED; 2055 goto failure; 2056 } 2057 2058 /* Establish the @addr name of the child. */ 2059 *addr = '\0'; 2060 if (scsi_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS) { 2061 /* 2062 * Some driver.conf files add bogus target properties (relative 2063 * to their nexus representation of target) to their stub 2064 * nodes, causing the check above to not filter them. 2065 */ 2066 SCSI_HBA_LOG((_LOG(3), NULL, child, 2067 "init failed: scsi_busctl_ua call")); 2068 ndi_devi_set_hidden(child); 2069 err = DDI_NOT_WELL_FORMED; 2070 goto failure; 2071 } 2072 if (*addr == '\0') { 2073 SCSI_HBA_LOG((_LOG(2), NULL, child, "init failed: ua")); 2074 ndi_devi_set_hidden(child); 2075 err = DDI_NOT_WELL_FORMED; 2076 goto failure; 2077 } 2078 2079 /* Prevent duplicate nodes. */ 2080 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr, 2081 scsi_busctl_ua); 2082 if (dup) { 2083 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_SCSI_DEVICE); 2084 if (ndi_flavor_get(dup) != SCSA_FLAVOR_SCSI_DEVICE) { 2085 SCSI_HBA_LOG((_LOG(1), NULL, child, 2086 "init failed: %s@%s: not SCSI_DEVICE flavored", 2087 ddi_node_name(child), addr)); 2088 goto failure; 2089 } 2090 if (dup != child) { 2091 SCSI_HBA_LOG((_LOG(4), NULL, child, 2092 "init failed: %s@%s: detected duplicate %p", 2093 ddi_node_name(child), addr, (void *)dup)); 2094 goto failure; 2095 } 2096 } 2097 2098 /* set the node @addr string */ 2099 ddi_set_name_addr(child, addr); 2100 2101 /* call HBA's target init entry point if it exists */ 2102 if (tran->tran_tgt_init != NULL) { 2103 SCSI_HBA_LOG((_LOG(4), NULL, child, "init tran_tgt_init")); 2104 sd->sd_tran_tgt_free_done = 0; 2105 if ((*tran->tran_tgt_init) 2106 (self, child, tran, sd) != DDI_SUCCESS) { 2107 scsi_enumeration_failed(child, -1, NULL, 2108 "tran_tgt_init"); 2109 goto failure; 2110 } 2111 } 2112 2113 SCSI_HBA_LOG((_LOG(3), NULL, child, "init successful")); 2114 return (DDI_SUCCESS); 2115 2116 failure: 2117 if (tran_clone) 2118 kmem_free(tran_clone, sizeof (scsi_hba_tran_t)); 2119 mutex_destroy(&sd->sd_mutex); 2120 kmem_free(sd, sizeof (*sd)); 2121 ddi_set_driver_private(child, NULL); 2122 ddi_set_name_addr(child, NULL); 2123 2124 return (err); /* remove the node */ 2125 } 2126 2127 static int 2128 scsi_busctl_uninitchild(dev_info_t *child) 2129 { 2130 dev_info_t *self = ddi_get_parent(child); 2131 struct scsi_device *sd = ddi_get_driver_private(child); 2132 scsi_hba_tran_t *tran; 2133 scsi_hba_tran_t *tran_clone; 2134 2135 ASSERT(DEVI_BUSY_OWNED(self)); 2136 2137 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 2138 ASSERT(tran && sd); 2139 if ((tran == NULL) || (sd == NULL)) 2140 return (DDI_FAILURE); 2141 2142 /* 2143 * We use sd_uninit_prevent to avoid uninitializing barrier/probe 2144 * nodes that are still in use. Since barrier/probe nodes are not 2145 * attached we can't prevent their state demotion via ndi_hold_devi. 2146 */ 2147 if (sd->sd_uninit_prevent) { 2148 SCSI_HBA_LOG((_LOG(2), NULL, child, "uninit prevented")); 2149 return (DDI_FAILURE); 2150 } 2151 2152 /* 2153 * Don't uninitialize a client node if it still has paths. 2154 */ 2155 if (MDI_CLIENT(child) && mdi_client_get_path_count(child)) { 2156 SCSI_HBA_LOG((_LOG(2), NULL, child, 2157 "uninit prevented, client has paths")); 2158 return (DDI_FAILURE); 2159 } 2160 2161 SCSI_HBA_LOG((_LOG(3), NULL, child, "uninit begin")); 2162 2163 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE) { 2164 tran_clone = sd->sd_address.a_hba_tran; 2165 2166 /* ... grotty hack, involving sd_tran_safe, continued. */ 2167 if (tran_clone != sd->sd_tran_safe) { 2168 tran_clone = sd->sd_tran_safe; 2169 #ifdef DEBUG 2170 /* 2171 * Complain so things get fixed and hack can, at 2172 * some point in time, be removed. 2173 */ 2174 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 2175 "'%s' is corrupting a_hba_tran", sd->sd_dev ? 2176 ddi_driver_name(sd->sd_dev) : "unknown_driver")); 2177 #endif /* DEBUG */ 2178 } 2179 2180 ASSERT(tran_clone->tran_hba_flags & SCSI_HBA_TRAN_CLONE); 2181 ASSERT(tran_clone->tran_sd == sd); 2182 tran = tran_clone; 2183 } else { 2184 tran_clone = NULL; 2185 ASSERT(tran->tran_sd == NULL); 2186 } 2187 2188 /* 2189 * To simplify host adapter drivers we guarantee that multiple 2190 * tran_tgt_init(9E) calls of the same unit address are never 2191 * active at the same time. This requires that we always call 2192 * tran_tgt_free on probe/barrier nodes directly prior to 2193 * uninitchild. 2194 * 2195 * NOTE: To correctly support SCSI_HBA_TRAN_CLONE, we must use 2196 * the (possibly cloned) hba_tran pointer from the scsi_device 2197 * instead of hba_tran. 2198 */ 2199 if (tran->tran_tgt_free) { 2200 if (!sd->sd_tran_tgt_free_done) { 2201 SCSI_HBA_LOG((_LOG(4), NULL, child, 2202 "uninit tran_tgt_free")); 2203 (*tran->tran_tgt_free) (self, child, tran, sd); 2204 sd->sd_tran_tgt_free_done = 1; 2205 } else { 2206 SCSI_HBA_LOG((_LOG(4), NULL, child, 2207 "uninit tran_tgt_free already done")); 2208 } 2209 } 2210 2211 /* 2212 * If a inquiry data is still allocated (by scsi_probe()) we 2213 * free the allocation here. This keeps scsi_inq valid for the 2214 * same duration as the corresponding inquiry properties. It 2215 * also allows a tran_tgt_init() implementation that establishes 2216 * sd_inq to deal with deallocation in its tran_tgt_free 2217 * (setting sd_inq back to NULL) without upsetting the 2218 * framework. Moving the inquiry free here also allows setting 2219 * of sd_uninit_prevent to preserve the data for lun0 based 2220 * scsi_get_device_type_scsi_options() calls. 2221 */ 2222 if (sd->sd_inq) { 2223 kmem_free(sd->sd_inq, SUN_INQSIZE); 2224 sd->sd_inq = (struct scsi_inquiry *)NULL; 2225 } 2226 2227 mutex_destroy(&sd->sd_mutex); 2228 if (tran_clone) 2229 kmem_free(tran_clone, sizeof (scsi_hba_tran_t)); 2230 kmem_free(sd, sizeof (*sd)); 2231 2232 ddi_set_driver_private(child, NULL); 2233 SCSI_HBA_LOG((_LOG(3), NULL, child, "uninit complete")); 2234 ddi_set_name_addr(child, NULL); 2235 return (DDI_SUCCESS); 2236 } 2237 2238 static int 2239 iport_busctl_ua(dev_info_t *child, char *addr, int maxlen) 2240 { 2241 char *iport_ua; 2242 2243 /* limit ndi_devi_findchild_by_callback to expected flavor */ 2244 if (ndi_flavor_get(child) != SCSA_FLAVOR_IPORT) 2245 return (DDI_FAILURE); 2246 2247 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 2248 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 2249 SCSI_ADDR_PROP_IPORTUA, &iport_ua) != DDI_SUCCESS) { 2250 return (DDI_FAILURE); 2251 } 2252 2253 (void) snprintf(addr, maxlen, "%s", iport_ua); 2254 ddi_prop_free(iport_ua); 2255 return (DDI_SUCCESS); 2256 } 2257 2258 static int 2259 iport_busctl_reportdev(dev_info_t *child) 2260 { 2261 dev_info_t *self = ddi_get_parent(child); 2262 char *iport_ua; 2263 char *initiator_port = NULL; 2264 2265 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 2266 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 2267 SCSI_ADDR_PROP_IPORTUA, &iport_ua) != DDI_SUCCESS) 2268 return (DDI_FAILURE); 2269 2270 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, child, 2271 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 2272 SCSI_ADDR_PROP_INITIATOR_PORT, &initiator_port); 2273 2274 if (initiator_port) { 2275 SCSI_HBA_LOG((_LOG_NF(CONT), 2276 "?%s%d at %s%d: %s %s %s %s", 2277 ddi_driver_name(child), ddi_get_instance(child), 2278 ddi_driver_name(self), ddi_get_instance(self), 2279 SCSI_ADDR_PROP_INITIATOR_PORT, initiator_port, 2280 SCSI_ADDR_PROP_IPORTUA, iport_ua)); 2281 ddi_prop_free(initiator_port); 2282 } else { 2283 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: %s %s", 2284 ddi_driver_name(child), ddi_get_instance(child), 2285 ddi_driver_name(self), ddi_get_instance(self), 2286 SCSI_ADDR_PROP_IPORTUA, iport_ua)); 2287 } 2288 ddi_prop_free(iport_ua); 2289 return (DDI_SUCCESS); 2290 } 2291 2292 /* initchild SCSA iport 'child' node */ 2293 static int 2294 iport_busctl_initchild(dev_info_t *child) 2295 { 2296 dev_info_t *self = ddi_get_parent(child); 2297 dev_info_t *dup = NULL; 2298 char addr[SCSI_MAXNAMELEN]; 2299 2300 if (iport_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS) 2301 return (DDI_NOT_WELL_FORMED); 2302 2303 /* Prevent duplicate nodes. */ 2304 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr, 2305 iport_busctl_ua); 2306 if (dup) { 2307 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_IPORT); 2308 if (ndi_flavor_get(dup) != SCSA_FLAVOR_IPORT) { 2309 SCSI_HBA_LOG((_LOG(1), NULL, child, 2310 "init failed: %s@%s: not IPORT flavored", 2311 ddi_node_name(child), addr)); 2312 return (DDI_FAILURE); 2313 } 2314 if (dup != child) { 2315 SCSI_HBA_LOG((_LOG(4), NULL, child, 2316 "init failed: %s@%s: detected duplicate %p", 2317 ddi_node_name(child), addr, (void *)dup)); 2318 return (DDI_FAILURE); 2319 } 2320 } 2321 2322 /* set the node @addr string */ 2323 ddi_set_name_addr(child, addr); 2324 2325 return (DDI_SUCCESS); 2326 } 2327 2328 /* uninitchild SCSA iport 'child' node */ 2329 static int 2330 iport_busctl_uninitchild(dev_info_t *child) 2331 { 2332 ddi_set_name_addr(child, NULL); 2333 return (DDI_SUCCESS); 2334 } 2335 2336 /* Uninitialize scsi_device flavor of transport on SCSA iport 'child' node. */ 2337 static void 2338 iport_postdetach_tran_scsi_device(dev_info_t *child) 2339 { 2340 scsi_hba_tran_t *tran; 2341 2342 tran = ndi_flavorv_get(child, SCSA_FLAVOR_SCSI_DEVICE); 2343 if (tran == NULL) 2344 return; 2345 2346 scsa_tran_teardown(child, tran); 2347 scsa_nexus_teardown(child, tran); 2348 2349 ndi_flavorv_set(child, SCSA_FLAVOR_SCSI_DEVICE, NULL); 2350 scsi_hba_tran_free(tran); 2351 } 2352 2353 /* Initialize scsi_device flavor of transport on SCSA iport 'child' node. */ 2354 static void 2355 iport_preattach_tran_scsi_device(dev_info_t *child) 2356 { 2357 dev_info_t *hba = ddi_get_parent(child); 2358 scsi_hba_tran_t *htran; 2359 scsi_hba_tran_t *tran; 2360 2361 /* parent HBA node scsi_device tran is required */ 2362 htran = ndi_flavorv_get(hba, SCSA_FLAVOR_SCSI_DEVICE); 2363 ASSERT(htran); 2364 2365 /* Allocate iport child's scsi_device transport vector */ 2366 tran = scsi_hba_tran_alloc(child, SCSI_HBA_CANSLEEP); 2367 ASSERT(tran); 2368 2369 /* Structure-copy scsi_device transport of HBA to iport. */ 2370 *tran = *htran; 2371 2372 /* 2373 * Reset scsi_device transport fields not shared with the 2374 * parent, and not established below. 2375 */ 2376 tran->tran_open_flag = 0; 2377 tran->tran_hba_private = NULL; 2378 2379 /* Establish the devinfo context of this tran structure. */ 2380 tran->tran_iport_dip = child; 2381 2382 /* Clear SCSI_HBA_SCSA flags (except TA) */ 2383 tran->tran_hba_flags &= 2384 ~(SCSI_HBA_SCSA_FM | SCSI_HBA_SCSA_PHCI); /* clear parent state */ 2385 tran->tran_hba_flags |= SCSI_HBA_SCSA_TA; /* always TA */ 2386 tran->tran_hba_flags &= ~SCSI_HBA_HBA; /* never HBA */ 2387 2388 /* Establish flavor of transport (and ddi_get_driver_private()) */ 2389 ndi_flavorv_set(child, SCSA_FLAVOR_SCSI_DEVICE, tran); 2390 2391 /* Setup iport node */ 2392 if ((scsa_nexus_setup(child, tran) != DDI_SUCCESS) || 2393 (scsa_tran_setup(child, tran) != DDI_SUCCESS)) 2394 iport_postdetach_tran_scsi_device(child); 2395 } 2396 2397 /* Uninitialize smp_device flavor of transport on SCSA iport 'child' node. */ 2398 static void 2399 iport_postdetach_tran_smp_device(dev_info_t *child) 2400 { 2401 smp_hba_tran_t *tran; 2402 2403 tran = ndi_flavorv_get(child, SCSA_FLAVOR_SMP); 2404 if (tran == NULL) 2405 return; 2406 2407 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, NULL); 2408 smp_hba_tran_free(tran); 2409 } 2410 2411 /* Initialize smp_device flavor of transport on SCSA iport 'child' node. */ 2412 static void 2413 iport_preattach_tran_smp_device(dev_info_t *child) 2414 { 2415 dev_info_t *hba = ddi_get_parent(child); 2416 smp_hba_tran_t *htran; 2417 smp_hba_tran_t *tran; 2418 2419 /* parent HBA node smp_device tran is optional */ 2420 htran = ndi_flavorv_get(hba, SCSA_FLAVOR_SMP); 2421 if (htran == NULL) { 2422 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, NULL); 2423 return; 2424 } 2425 2426 /* Allocate iport child's smp_device transport vector */ 2427 tran = smp_hba_tran_alloc(child); 2428 2429 /* Structure-copy smp_device transport of HBA to iport. */ 2430 *tran = *htran; 2431 2432 /* Establish flavor of transport */ 2433 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, tran); 2434 } 2435 2436 /* 2437 * Generic bus_ctl operations for SCSI HBA's, 2438 * hiding the busctl interface from the HBA. 2439 */ 2440 /*ARGSUSED*/ 2441 static int 2442 scsi_hba_bus_ctl( 2443 dev_info_t *self, 2444 dev_info_t *child, 2445 ddi_ctl_enum_t op, 2446 void *arg, 2447 void *result) 2448 { 2449 int child_flavor = 0; 2450 int val; 2451 ddi_dma_attr_t *attr; 2452 scsi_hba_tran_t *tran; 2453 struct attachspec *as; 2454 struct detachspec *ds; 2455 2456 /* For some ops, child is 'arg'. */ 2457 if ((op == DDI_CTLOPS_INITCHILD) || (op == DDI_CTLOPS_UNINITCHILD)) 2458 child = (dev_info_t *)arg; 2459 2460 /* Determine the flavor of the child: scsi, smp, iport */ 2461 child_flavor = ndi_flavor_get(child); 2462 2463 switch (op) { 2464 case DDI_CTLOPS_INITCHILD: 2465 switch (child_flavor) { 2466 case SCSA_FLAVOR_SCSI_DEVICE: 2467 return (scsi_busctl_initchild(child)); 2468 case SCSA_FLAVOR_SMP: 2469 return (smp_busctl_initchild(child)); 2470 case SCSA_FLAVOR_IPORT: 2471 return (iport_busctl_initchild(child)); 2472 default: 2473 return (DDI_FAILURE); 2474 } 2475 /* NOTREACHED */ 2476 2477 case DDI_CTLOPS_UNINITCHILD: 2478 switch (child_flavor) { 2479 case SCSA_FLAVOR_SCSI_DEVICE: 2480 return (scsi_busctl_uninitchild(child)); 2481 case SCSA_FLAVOR_SMP: 2482 return (smp_busctl_uninitchild(child)); 2483 case SCSA_FLAVOR_IPORT: 2484 return (iport_busctl_uninitchild(child)); 2485 default: 2486 return (DDI_FAILURE); 2487 } 2488 /* NOTREACHED */ 2489 2490 case DDI_CTLOPS_REPORTDEV: 2491 switch (child_flavor) { 2492 case SCSA_FLAVOR_SCSI_DEVICE: 2493 return (scsi_busctl_reportdev(child)); 2494 case SCSA_FLAVOR_SMP: 2495 return (smp_busctl_reportdev(child)); 2496 case SCSA_FLAVOR_IPORT: 2497 return (iport_busctl_reportdev(child)); 2498 default: 2499 return (DDI_FAILURE); 2500 } 2501 /* NOTREACHED */ 2502 2503 case DDI_CTLOPS_ATTACH: 2504 as = (struct attachspec *)arg; 2505 2506 if (child_flavor != SCSA_FLAVOR_IPORT) 2507 return (DDI_SUCCESS); 2508 2509 /* iport processing */ 2510 if (as->when == DDI_PRE) { 2511 /* setup pre attach(9E) */ 2512 iport_preattach_tran_scsi_device(child); 2513 iport_preattach_tran_smp_device(child); 2514 } else if ((as->when == DDI_POST) && 2515 (as->result != DDI_SUCCESS)) { 2516 /* cleanup if attach(9E) failed */ 2517 iport_postdetach_tran_scsi_device(child); 2518 iport_postdetach_tran_smp_device(child); 2519 } 2520 return (DDI_SUCCESS); 2521 2522 case DDI_CTLOPS_DETACH: 2523 ds = (struct detachspec *)arg; 2524 2525 if (child_flavor != SCSA_FLAVOR_IPORT) 2526 return (DDI_SUCCESS); 2527 2528 /* iport processing */ 2529 if ((ds->when == DDI_POST) && 2530 (ds->result == DDI_SUCCESS)) { 2531 /* cleanup if detach(9E) was successful */ 2532 iport_postdetach_tran_scsi_device(child); 2533 iport_postdetach_tran_smp_device(child); 2534 } 2535 return (DDI_SUCCESS); 2536 2537 case DDI_CTLOPS_IOMIN: 2538 tran = ddi_get_driver_private(self); 2539 ASSERT(tran); 2540 if (tran == NULL) 2541 return (DDI_FAILURE); 2542 2543 /* 2544 * The 'arg' value of nonzero indicates 'streaming' 2545 * mode. If in streaming mode, pick the largest 2546 * of our burstsizes available and say that that 2547 * is our minimum value (modulo what minxfer is). 2548 */ 2549 attr = &tran->tran_dma_attr; 2550 val = *((int *)result); 2551 val = maxbit(val, attr->dma_attr_minxfer); 2552 *((int *)result) = maxbit(val, ((intptr_t)arg ? 2553 (1<<ddi_ffs(attr->dma_attr_burstsizes)-1) : 2554 (1<<(ddi_fls(attr->dma_attr_burstsizes)-1)))); 2555 2556 return (ddi_ctlops(self, child, op, arg, result)); 2557 2558 case DDI_CTLOPS_SIDDEV: 2559 return (ndi_dev_is_persistent_node(child) ? 2560 DDI_SUCCESS : DDI_FAILURE); 2561 2562 case DDI_CTLOPS_POWER: 2563 return (DDI_SUCCESS); 2564 2565 /* 2566 * These ops correspond to functions that "shouldn't" be called 2567 * by a SCSI target driver. So we whine when we're called. 2568 */ 2569 case DDI_CTLOPS_DMAPMAPC: 2570 case DDI_CTLOPS_REPORTINT: 2571 case DDI_CTLOPS_REGSIZE: 2572 case DDI_CTLOPS_NREGS: 2573 case DDI_CTLOPS_SLAVEONLY: 2574 case DDI_CTLOPS_AFFINITY: 2575 case DDI_CTLOPS_POKE: 2576 case DDI_CTLOPS_PEEK: 2577 SCSI_HBA_LOG((_LOG(WARN), self, NULL, "invalid op (%d)", op)); 2578 return (DDI_FAILURE); 2579 2580 /* Everything else we pass up */ 2581 case DDI_CTLOPS_PTOB: 2582 case DDI_CTLOPS_BTOP: 2583 case DDI_CTLOPS_BTOPR: 2584 case DDI_CTLOPS_DVMAPAGESIZE: 2585 default: 2586 return (ddi_ctlops(self, child, op, arg, result)); 2587 } 2588 /* NOTREACHED */ 2589 } 2590 2591 /* 2592 * Private wrapper for scsi_pkt's allocated via scsi_hba_pkt_alloc() 2593 */ 2594 struct scsi_pkt_wrapper { 2595 struct scsi_pkt scsi_pkt; 2596 int pkt_wrapper_magic; 2597 int pkt_wrapper_len; 2598 }; 2599 2600 #if !defined(lint) 2601 _NOTE(SCHEME_PROTECTS_DATA("unique per thread", scsi_pkt_wrapper)) 2602 _NOTE(SCHEME_PROTECTS_DATA("Unshared Data", dev_ops)) 2603 #endif 2604 2605 /* 2606 * Called by an HBA to allocate a scsi_pkt 2607 */ 2608 /*ARGSUSED*/ 2609 struct scsi_pkt * 2610 scsi_hba_pkt_alloc( 2611 dev_info_t *self, 2612 struct scsi_address *ap, 2613 int cmdlen, 2614 int statuslen, 2615 int tgtlen, 2616 int hbalen, 2617 int (*callback)(caddr_t arg), 2618 caddr_t arg) 2619 { 2620 struct scsi_pkt *pkt; 2621 struct scsi_pkt_wrapper *hba_pkt; 2622 caddr_t p; 2623 int acmdlen, astatuslen, atgtlen, ahbalen; 2624 int pktlen; 2625 2626 /* Sanity check */ 2627 if (callback != SLEEP_FUNC && callback != NULL_FUNC) 2628 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 2629 "callback must be SLEEP_FUNC or NULL_FUNC")); 2630 2631 /* 2632 * Round up so everything gets allocated on long-word boundaries 2633 */ 2634 acmdlen = ROUNDUP(cmdlen); 2635 astatuslen = ROUNDUP(statuslen); 2636 atgtlen = ROUNDUP(tgtlen); 2637 ahbalen = ROUNDUP(hbalen); 2638 pktlen = sizeof (struct scsi_pkt_wrapper) + 2639 acmdlen + astatuslen + atgtlen + ahbalen; 2640 2641 hba_pkt = kmem_zalloc(pktlen, 2642 (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP); 2643 if (hba_pkt == NULL) { 2644 ASSERT(callback == NULL_FUNC); 2645 return (NULL); 2646 } 2647 2648 /* 2649 * Set up our private info on this pkt 2650 */ 2651 hba_pkt->pkt_wrapper_len = pktlen; 2652 hba_pkt->pkt_wrapper_magic = PKT_WRAPPER_MAGIC; /* alloced correctly */ 2653 pkt = &hba_pkt->scsi_pkt; 2654 2655 /* 2656 * Set up pointers to private data areas, cdb, and status. 2657 */ 2658 p = (caddr_t)(hba_pkt + 1); 2659 if (hbalen > 0) { 2660 pkt->pkt_ha_private = (opaque_t)p; 2661 p += ahbalen; 2662 } 2663 if (tgtlen > 0) { 2664 pkt->pkt_private = (opaque_t)p; 2665 p += atgtlen; 2666 } 2667 if (statuslen > 0) { 2668 pkt->pkt_scbp = (uchar_t *)p; 2669 p += astatuslen; 2670 } 2671 if (cmdlen > 0) { 2672 pkt->pkt_cdbp = (uchar_t *)p; 2673 } 2674 2675 /* 2676 * Initialize the pkt's scsi_address 2677 */ 2678 pkt->pkt_address = *ap; 2679 2680 /* 2681 * NB: It may not be safe for drivers, esp target drivers, to depend 2682 * on the following fields being set until all the scsi_pkt 2683 * allocation violations discussed in scsi_pkt.h are all resolved. 2684 */ 2685 pkt->pkt_cdblen = cmdlen; 2686 pkt->pkt_tgtlen = tgtlen; 2687 pkt->pkt_scblen = statuslen; 2688 2689 return (pkt); 2690 } 2691 2692 /* 2693 * Called by an HBA to free a scsi_pkt 2694 */ 2695 /*ARGSUSED*/ 2696 void 2697 scsi_hba_pkt_free( 2698 struct scsi_address *ap, 2699 struct scsi_pkt *pkt) 2700 { 2701 kmem_free(pkt, ((struct scsi_pkt_wrapper *)pkt)->pkt_wrapper_len); 2702 } 2703 2704 /* 2705 * Return 1 if the scsi_pkt used a proper allocator. 2706 * 2707 * The DDI does not allow a driver to allocate it's own scsi_pkt(9S), a 2708 * driver should not have *any* compiled in dependencies on "sizeof (struct 2709 * scsi_pkt)". While this has been the case for many years, a number of 2710 * drivers have still not been fixed. This function can be used to detect 2711 * improperly allocated scsi_pkt structures, and produce messages identifying 2712 * drivers that need to be fixed. 2713 * 2714 * While drivers in violation are being fixed, this function can also 2715 * be used by the framework to detect packets that violated allocation 2716 * rules. 2717 * 2718 * NB: It is possible, but very unlikely, for this code to return a false 2719 * positive (finding correct magic, but for wrong reasons). Careful 2720 * consideration is needed for callers using this interface to condition 2721 * access to newer scsi_pkt fields (those after pkt_reason). 2722 * 2723 * NB: As an aid to minimizing the amount of work involved in 'fixing' legacy 2724 * drivers that violate scsi_*(9S) allocation rules, private 2725 * scsi_pkt_size()/scsi_size_clean() functions are available (see their 2726 * implementation for details). 2727 * 2728 * *** Non-legacy use of scsi_pkt_size() is discouraged. *** 2729 * 2730 * NB: When supporting broken HBA drivers is not longer a concern, this 2731 * code should be removed. 2732 */ 2733 int 2734 scsi_pkt_allocated_correctly(struct scsi_pkt *pkt) 2735 { 2736 struct scsi_pkt_wrapper *hba_pkt = (struct scsi_pkt_wrapper *)pkt; 2737 int magic; 2738 major_t major; 2739 #ifdef DEBUG 2740 int *pspwm, *pspcwm; 2741 2742 /* 2743 * We are getting scsi packets from two 'correct' wrapper schemes, 2744 * make sure we are looking at the same place in both to detect 2745 * proper allocation. 2746 */ 2747 pspwm = &((struct scsi_pkt_wrapper *)0)->pkt_wrapper_magic; 2748 pspcwm = &((struct scsi_pkt_cache_wrapper *)0)->pcw_magic; 2749 ASSERT(pspwm == pspcwm); 2750 #endif /* DEBUG */ 2751 2752 2753 /* 2754 * Check to see if driver is scsi_size_clean(), assume it 2755 * is using the scsi_pkt_size() interface everywhere it needs to 2756 * if the driver indicates it is scsi_size_clean(). 2757 */ 2758 major = ddi_driver_major(P_TO_TRAN(pkt)->tran_hba_dip); 2759 if (devnamesp[major].dn_flags & DN_SCSI_SIZE_CLEAN) 2760 return (1); /* ok */ 2761 2762 /* 2763 * Special case crossing a page boundary. If the scsi_pkt was not 2764 * allocated correctly, then across a page boundary we have a 2765 * fault hazard. 2766 */ 2767 if ((((uintptr_t)(&hba_pkt->scsi_pkt)) & MMU_PAGEMASK) == 2768 (((uintptr_t)(&hba_pkt->pkt_wrapper_magic)) & MMU_PAGEMASK)) { 2769 /* fastpath, no cross-page hazard */ 2770 magic = hba_pkt->pkt_wrapper_magic; 2771 } else { 2772 /* add protection for cross-page hazard */ 2773 if (ddi_peek32((dev_info_t *)NULL, 2774 &hba_pkt->pkt_wrapper_magic, &magic) == DDI_FAILURE) { 2775 return (0); /* violation */ 2776 } 2777 } 2778 2779 /* properly allocated packet always has correct magic */ 2780 return ((magic == PKT_WRAPPER_MAGIC) ? 1 : 0); 2781 } 2782 2783 /* 2784 * Private interfaces to simplify conversion of legacy drivers so they don't 2785 * depend on scsi_*(9S) size. Instead of using these private interface, HBA 2786 * drivers should use DDI sanctioned allocation methods: 2787 * 2788 * scsi_pkt Use scsi_hba_pkt_alloc(9F), or implement 2789 * tran_setup_pkt(9E). 2790 * 2791 * scsi_device You are doing something strange/special, a scsi_device 2792 * structure should only be allocated by scsi_hba.c 2793 * initchild code or scsi_vhci.c code. 2794 * 2795 * scsi_hba_tran Use scsi_hba_tran_alloc(9F). 2796 */ 2797 size_t 2798 scsi_pkt_size() 2799 { 2800 return (sizeof (struct scsi_pkt)); 2801 } 2802 2803 size_t 2804 scsi_hba_tran_size() 2805 { 2806 return (sizeof (scsi_hba_tran_t)); 2807 } 2808 2809 size_t 2810 scsi_device_size() 2811 { 2812 return (sizeof (struct scsi_device)); 2813 } 2814 2815 /* 2816 * Legacy compliance to scsi_pkt(9S) allocation rules through use of 2817 * scsi_pkt_size() is detected by the 'scsi-size-clean' driver.conf property 2818 * or an HBA driver calling to scsi_size_clean() from attach(9E). A driver 2819 * developer should only indicate that a legacy driver is clean after using 2820 * SCSI_SIZE_CLEAN_VERIFY to ensure compliance (see scsi_pkt.h). 2821 */ 2822 void 2823 scsi_size_clean(dev_info_t *self) 2824 { 2825 major_t major; 2826 struct devnames *dnp; 2827 2828 ASSERT(self); 2829 major = ddi_driver_major(self); 2830 ASSERT(major < devcnt); 2831 if (major >= devcnt) { 2832 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 2833 "scsi_pkt_size: bogus major: %d", major)); 2834 return; 2835 } 2836 2837 /* Set DN_SCSI_SIZE_CLEAN flag in dn_flags. */ 2838 dnp = &devnamesp[major]; 2839 if ((dnp->dn_flags & DN_SCSI_SIZE_CLEAN) == 0) { 2840 LOCK_DEV_OPS(&dnp->dn_lock); 2841 dnp->dn_flags |= DN_SCSI_SIZE_CLEAN; 2842 UNLOCK_DEV_OPS(&dnp->dn_lock); 2843 } 2844 } 2845 2846 2847 /* 2848 * Called by an HBA to map strings to capability indices 2849 */ 2850 int 2851 scsi_hba_lookup_capstr( 2852 char *capstr) 2853 { 2854 /* 2855 * Capability strings: only add entries to mask the legacy 2856 * '_' vs. '-' misery. All new capabilities should use '-', 2857 * and be captured be added to SCSI_CAP_ASCII. 2858 */ 2859 static struct cap_strings { 2860 char *cap_string; 2861 int cap_index; 2862 } cap_strings[] = { 2863 { "dma_max", SCSI_CAP_DMA_MAX }, 2864 { "msg_out", SCSI_CAP_MSG_OUT }, 2865 { "wide_xfer", SCSI_CAP_WIDE_XFER }, 2866 { NULL, 0 } 2867 }; 2868 static char *cap_ascii[] = SCSI_CAP_ASCII; 2869 char **cap; 2870 int i; 2871 struct cap_strings *cp; 2872 2873 for (cap = cap_ascii, i = 0; *cap != NULL; cap++, i++) 2874 if (strcmp(*cap, capstr) == 0) 2875 return (i); 2876 2877 for (cp = cap_strings; cp->cap_string != NULL; cp++) 2878 if (strcmp(cp->cap_string, capstr) == 0) 2879 return (cp->cap_index); 2880 2881 return (-1); 2882 } 2883 2884 /* 2885 * Called by an HBA to determine if the system is in 'panic' state. 2886 */ 2887 int 2888 scsi_hba_in_panic() 2889 { 2890 return (panicstr != NULL); 2891 } 2892 2893 /* 2894 * If a SCSI target driver attempts to mmap memory, 2895 * the buck stops here. 2896 */ 2897 /*ARGSUSED*/ 2898 static int 2899 scsi_hba_map_fault( 2900 dev_info_t *self, 2901 dev_info_t *child, 2902 struct hat *hat, 2903 struct seg *seg, 2904 caddr_t addr, 2905 struct devpage *dp, 2906 pfn_t pfn, 2907 uint_t prot, 2908 uint_t lock) 2909 { 2910 return (DDI_FAILURE); 2911 } 2912 2913 static int 2914 scsi_hba_get_eventcookie( 2915 dev_info_t *self, 2916 dev_info_t *child, 2917 char *name, 2918 ddi_eventcookie_t *eventp) 2919 { 2920 scsi_hba_tran_t *tran; 2921 2922 tran = ddi_get_driver_private(self); 2923 if (tran->tran_get_eventcookie && 2924 ((*tran->tran_get_eventcookie)(self, 2925 child, name, eventp) == DDI_SUCCESS)) { 2926 return (DDI_SUCCESS); 2927 } 2928 2929 return (ndi_busop_get_eventcookie(self, child, name, eventp)); 2930 } 2931 2932 static int 2933 scsi_hba_add_eventcall( 2934 dev_info_t *self, 2935 dev_info_t *child, 2936 ddi_eventcookie_t event, 2937 void (*callback)( 2938 dev_info_t *self, 2939 ddi_eventcookie_t event, 2940 void *arg, 2941 void *bus_impldata), 2942 void *arg, 2943 ddi_callback_id_t *cb_id) 2944 { 2945 scsi_hba_tran_t *tran; 2946 2947 tran = ddi_get_driver_private(self); 2948 if (tran->tran_add_eventcall && 2949 ((*tran->tran_add_eventcall)(self, child, 2950 event, callback, arg, cb_id) == DDI_SUCCESS)) { 2951 return (DDI_SUCCESS); 2952 } 2953 2954 return (DDI_FAILURE); 2955 } 2956 2957 static int 2958 scsi_hba_remove_eventcall(dev_info_t *self, ddi_callback_id_t cb_id) 2959 { 2960 scsi_hba_tran_t *tran; 2961 ASSERT(cb_id); 2962 2963 tran = ddi_get_driver_private(self); 2964 if (tran->tran_remove_eventcall && 2965 ((*tran->tran_remove_eventcall)( 2966 self, cb_id) == DDI_SUCCESS)) { 2967 return (DDI_SUCCESS); 2968 } 2969 2970 return (DDI_FAILURE); 2971 } 2972 2973 static int 2974 scsi_hba_post_event( 2975 dev_info_t *self, 2976 dev_info_t *child, 2977 ddi_eventcookie_t event, 2978 void *bus_impldata) 2979 { 2980 scsi_hba_tran_t *tran; 2981 2982 tran = ddi_get_driver_private(self); 2983 if (tran->tran_post_event && 2984 ((*tran->tran_post_event)(self, 2985 child, event, bus_impldata) == DDI_SUCCESS)) { 2986 return (DDI_SUCCESS); 2987 } 2988 2989 return (DDI_FAILURE); 2990 } 2991 2992 /* 2993 * Default getinfo(9e) for scsi_hba 2994 */ 2995 /* ARGSUSED */ 2996 static int 2997 scsi_hba_info(dev_info_t *self, ddi_info_cmd_t infocmd, void *arg, 2998 void **result) 2999 { 3000 int error = DDI_SUCCESS; 3001 3002 switch (infocmd) { 3003 case DDI_INFO_DEVT2INSTANCE: 3004 *result = (void *)(intptr_t)(MINOR2INST(getminor((dev_t)arg))); 3005 break; 3006 default: 3007 error = DDI_FAILURE; 3008 } 3009 return (error); 3010 } 3011 3012 /* 3013 * Default open and close routine for scsi_hba 3014 */ 3015 /* ARGSUSED */ 3016 int 3017 scsi_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 3018 { 3019 dev_info_t *self; 3020 scsi_hba_tran_t *tran; 3021 int rv = 0; 3022 3023 if (otyp != OTYP_CHR) 3024 return (EINVAL); 3025 3026 if ((self = e_ddi_hold_devi_by_dev(*devp, 0)) == NULL) 3027 return (ENXIO); 3028 3029 tran = ddi_get_driver_private(self); 3030 if (tran == NULL) { 3031 ddi_release_devi(self); 3032 return (ENXIO); 3033 } 3034 3035 /* 3036 * tran_open_flag bit field: 3037 * 0: closed 3038 * 1: shared open by minor at bit position 3039 * 1 at 31st bit: exclusive open 3040 */ 3041 mutex_enter(&(tran->tran_open_lock)); 3042 if (flags & FEXCL) { 3043 if (tran->tran_open_flag != 0) { 3044 rv = EBUSY; /* already open */ 3045 } else { 3046 tran->tran_open_flag = TRAN_OPEN_EXCL; 3047 } 3048 } else { 3049 if (tran->tran_open_flag == TRAN_OPEN_EXCL) { 3050 rv = EBUSY; /* already excl. open */ 3051 } else { 3052 int minor = getminor(*devp) & TRAN_MINOR_MASK; 3053 tran->tran_open_flag |= (1 << minor); 3054 /* 3055 * Ensure that the last framework reserved minor 3056 * is unused. Otherwise, the exclusive open 3057 * mechanism may break. 3058 */ 3059 ASSERT(minor != 31); 3060 } 3061 } 3062 mutex_exit(&(tran->tran_open_lock)); 3063 3064 ddi_release_devi(self); 3065 return (rv); 3066 } 3067 3068 /* ARGSUSED */ 3069 int 3070 scsi_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 3071 { 3072 dev_info_t *self; 3073 scsi_hba_tran_t *tran; 3074 3075 if (otyp != OTYP_CHR) 3076 return (EINVAL); 3077 3078 if ((self = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 3079 return (ENXIO); 3080 3081 tran = ddi_get_driver_private(self); 3082 if (tran == NULL) { 3083 ddi_release_devi(self); 3084 return (ENXIO); 3085 } 3086 3087 mutex_enter(&(tran->tran_open_lock)); 3088 if (tran->tran_open_flag == TRAN_OPEN_EXCL) { 3089 tran->tran_open_flag = 0; 3090 } else { 3091 int minor = getminor(dev) & TRAN_MINOR_MASK; 3092 tran->tran_open_flag &= ~(1 << minor); 3093 } 3094 mutex_exit(&(tran->tran_open_lock)); 3095 3096 ddi_release_devi(self); 3097 return (0); 3098 } 3099 3100 /* 3101 * standard ioctl commands for SCSI hotplugging 3102 */ 3103 /* ARGSUSED */ 3104 int 3105 scsi_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 3106 int *rvalp) 3107 { 3108 dev_info_t *self; 3109 struct devctl_iocdata *dcp = NULL; 3110 dev_info_t *child = NULL; 3111 mdi_pathinfo_t *path = NULL; 3112 struct scsi_device *sd; 3113 scsi_hba_tran_t *tran; 3114 uint_t bus_state; 3115 int rv = 0; 3116 int circ; 3117 char *name; 3118 char *addr; 3119 3120 self = e_ddi_hold_devi_by_dev(dev, 0); 3121 if (self == NULL) { 3122 rv = ENXIO; 3123 goto out; 3124 } 3125 3126 tran = ddi_get_driver_private(self); 3127 if (tran == NULL) { 3128 rv = ENXIO; 3129 goto out; 3130 } 3131 3132 /* Ioctls for which the generic implementation suffices. */ 3133 switch (cmd) { 3134 case DEVCTL_BUS_GETSTATE: 3135 rv = ndi_devctl_ioctl(self, cmd, arg, mode, 0); 3136 goto out; 3137 } 3138 3139 /* read devctl ioctl data */ 3140 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) { 3141 rv = EFAULT; 3142 goto out; 3143 } 3144 3145 /* Ioctls that require child identification */ 3146 switch (cmd) { 3147 case DEVCTL_DEVICE_GETSTATE: 3148 case DEVCTL_DEVICE_ONLINE: 3149 case DEVCTL_DEVICE_OFFLINE: 3150 case DEVCTL_DEVICE_REMOVE: 3151 case DEVCTL_DEVICE_RESET: 3152 name = ndi_dc_getname(dcp); 3153 addr = ndi_dc_getaddr(dcp); 3154 if ((name == NULL) || (addr == NULL)) { 3155 rv = EINVAL; 3156 goto out; 3157 } 3158 3159 /* 3160 * Find child with name@addr - might find a devinfo 3161 * child (child), a pathinfo child (path), or nothing. 3162 */ 3163 scsi_hba_devi_enter(self, &circ); 3164 3165 (void) scsi_findchild(self, name, addr, 1, &child, &path, NULL); 3166 if (path) { 3167 /* Found a pathinfo */ 3168 ASSERT(path && (child == NULL)); 3169 mdi_hold_path(path); 3170 scsi_hba_devi_exit_phci(self, circ); 3171 sd = NULL; 3172 } else if (child) { 3173 /* Found a devinfo */ 3174 ASSERT(child && (path == NULL)); 3175 3176 /* verify scsi_device of child */ 3177 if (ndi_flavor_get(child) == SCSA_FLAVOR_SCSI_DEVICE) 3178 sd = ddi_get_driver_private(child); 3179 else 3180 sd = NULL; 3181 } else { 3182 ASSERT((path == NULL) && (child == NULL)); 3183 scsi_hba_devi_exit(self, circ); 3184 rv = ENXIO; /* found nothing */ 3185 goto out; 3186 } 3187 break; 3188 3189 case DEVCTL_BUS_RESETALL: /* ioctl that operate on any child */ 3190 /* 3191 * Find a child's scsi_address so we can invoke tran_reset. 3192 * 3193 * Future: If no child exists, we could fake a child. This will 3194 * be a enhancement for the future - for now, we fall back to 3195 * BUS_RESET. 3196 */ 3197 scsi_hba_devi_enter(self, &circ); 3198 child = ddi_get_child(self); 3199 sd = NULL; 3200 while (child) { 3201 /* verify scsi_device of child */ 3202 if (ndi_flavor_get(child) == SCSA_FLAVOR_SCSI_DEVICE) 3203 sd = ddi_get_driver_private(child); 3204 if (sd != NULL) { 3205 /* 3206 * NOTE: node has a scsi_device structure, so 3207 * it must be initialized. 3208 */ 3209 ndi_hold_devi(child); 3210 break; 3211 } 3212 child = ddi_get_next_sibling(child); 3213 } 3214 scsi_hba_devi_exit(self, circ); 3215 break; 3216 } 3217 3218 switch (cmd) { 3219 case DEVCTL_DEVICE_GETSTATE: 3220 if (path) { 3221 if (mdi_dc_return_dev_state(path, dcp) != MDI_SUCCESS) 3222 rv = EFAULT; 3223 } else if (child) { 3224 if (ndi_dc_return_dev_state(child, dcp) != NDI_SUCCESS) 3225 rv = EFAULT; 3226 } else { 3227 rv = ENXIO; 3228 } 3229 break; 3230 3231 case DEVCTL_DEVICE_RESET: 3232 if (sd == NULL) { 3233 rv = ENOTTY; 3234 break; 3235 } 3236 if (tran->tran_reset == NULL) { 3237 rv = ENOTSUP; 3238 break; 3239 } 3240 3241 /* Start with the small stick */ 3242 if (scsi_reset(&sd->sd_address, RESET_LUN) == 1) 3243 break; /* LUN reset worked */ 3244 if (scsi_reset(&sd->sd_address, RESET_TARGET) != 1) 3245 rv = EIO; /* Target reset failed */ 3246 break; 3247 3248 case DEVCTL_BUS_QUIESCE: 3249 if ((ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS) && 3250 (bus_state == BUS_QUIESCED)) 3251 rv = EALREADY; 3252 else if (tran->tran_quiesce == NULL) 3253 rv = ENOTSUP; /* man ioctl(7I) says ENOTTY */ 3254 else if (tran->tran_quiesce(self) != 0) 3255 rv = EIO; 3256 else if (ndi_set_bus_state(self, BUS_QUIESCED) != NDI_SUCCESS) 3257 rv = EIO; 3258 break; 3259 3260 case DEVCTL_BUS_UNQUIESCE: 3261 if ((ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS) && 3262 (bus_state == BUS_ACTIVE)) 3263 rv = EALREADY; 3264 else if (tran->tran_unquiesce == NULL) 3265 rv = ENOTSUP; /* man ioctl(7I) says ENOTTY */ 3266 else if (tran->tran_unquiesce(self) != 0) 3267 rv = EIO; 3268 else if (ndi_set_bus_state(self, BUS_ACTIVE) != NDI_SUCCESS) 3269 rv = EIO; 3270 break; 3271 3272 case DEVCTL_BUS_RESET: 3273 if (tran->tran_bus_reset == NULL) 3274 rv = ENOTSUP; /* man ioctl(7I) says ENOTTY */ 3275 else if (tran->tran_bus_reset(self, RESET_BUS) != 1) 3276 rv = EIO; 3277 break; 3278 3279 case DEVCTL_BUS_RESETALL: 3280 if ((sd != NULL) && 3281 (scsi_reset(&sd->sd_address, RESET_ALL) == 1)) { 3282 break; /* reset all worked */ 3283 } 3284 if (tran->tran_bus_reset == NULL) { 3285 rv = ENOTSUP; /* man ioctl(7I) says ENOTTY */ 3286 break; 3287 } 3288 if (tran->tran_bus_reset(self, RESET_BUS) != 1) 3289 rv = EIO; /* bus reset failed */ 3290 break; 3291 3292 case DEVCTL_BUS_CONFIGURE: 3293 if (ndi_devi_config(self, NDI_DEVFS_CLEAN | NDI_DEVI_PERSIST | 3294 NDI_CONFIG_REPROBE) != NDI_SUCCESS) { 3295 rv = EIO; 3296 } 3297 break; 3298 3299 case DEVCTL_BUS_UNCONFIGURE: 3300 if (ndi_devi_unconfig(self, 3301 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) != NDI_SUCCESS) { 3302 rv = EBUSY; 3303 } 3304 break; 3305 3306 case DEVCTL_DEVICE_ONLINE: 3307 ASSERT(child || path); 3308 if (path) { 3309 if (mdi_pi_online(path, NDI_USER_REQ) != MDI_SUCCESS) 3310 rv = EIO; 3311 } else { 3312 if (ndi_devi_online(child, 0) != NDI_SUCCESS) 3313 rv = EIO; 3314 } 3315 break; 3316 3317 case DEVCTL_DEVICE_OFFLINE: 3318 ASSERT(child || path); 3319 if (sd != NULL) 3320 (void) scsi_clear_task_set(&sd->sd_address); 3321 if (path) { 3322 if (mdi_pi_offline(path, NDI_USER_REQ) != MDI_SUCCESS) 3323 rv = EIO; 3324 } else { 3325 if (ndi_devi_offline(child, 3326 NDI_DEVFS_CLEAN) != NDI_SUCCESS) 3327 rv = EIO; 3328 } 3329 break; 3330 3331 case DEVCTL_DEVICE_REMOVE: 3332 ASSERT(child || path); 3333 if (sd != NULL) 3334 (void) scsi_clear_task_set(&sd->sd_address); 3335 if (path) { 3336 /* NOTE: don't pass NDI_DEVI_REMOVE to mdi_pi_offline */ 3337 if (mdi_pi_offline(path, NDI_USER_REQ) == MDI_SUCCESS) { 3338 scsi_hba_devi_enter_phci(self, &circ); 3339 mdi_rele_path(path); 3340 3341 /* ... here is the DEVICE_REMOVE part. */ 3342 (void) mdi_pi_free(path, 0); 3343 path = NULL; 3344 } else { 3345 rv = EIO; 3346 } 3347 } else { 3348 if (ndi_devi_offline(child, 3349 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) != NDI_SUCCESS) 3350 rv = EIO; 3351 } 3352 break; 3353 3354 default: 3355 ASSERT(dcp != NULL); 3356 rv = ENOTTY; 3357 break; 3358 } 3359 3360 /* all done -- clean up and return */ 3361 out: 3362 /* release hold on what we found */ 3363 if (path) { 3364 scsi_hba_devi_enter_phci(self, &circ); 3365 mdi_rele_path(path); 3366 } 3367 if (path || child) 3368 scsi_hba_devi_exit(self, circ); 3369 3370 if (dcp) 3371 ndi_dc_freehdl(dcp); 3372 3373 if (self) 3374 ddi_release_devi(self); 3375 3376 *rvalp = rv; 3377 3378 return (rv); 3379 } 3380 3381 /*ARGSUSED*/ 3382 static int 3383 scsi_hba_fm_init_child(dev_info_t *self, dev_info_t *child, int cap, 3384 ddi_iblock_cookie_t *ibc) 3385 { 3386 scsi_hba_tran_t *tran = ddi_get_driver_private(self); 3387 3388 return (tran ? tran->tran_fm_capable : scsi_fm_capable); 3389 } 3390 3391 static int 3392 scsi_hba_bus_power(dev_info_t *self, void *impl_arg, pm_bus_power_op_t op, 3393 void *arg, void *result) 3394 { 3395 scsi_hba_tran_t *tran; 3396 3397 tran = ddi_get_driver_private(self); 3398 if (tran && tran->tran_bus_power) { 3399 return (tran->tran_bus_power(self, impl_arg, 3400 op, arg, result)); 3401 } 3402 3403 return (pm_busop_bus_power(self, impl_arg, op, arg, result)); 3404 } 3405 3406 /* 3407 * Return the lun64 value from a address string: "addr,lun[,sfunc]". Either 3408 * the lun is after the first ',' or the entire address string is the lun. 3409 * Return SCSI_LUN64_ILLEGAL if the format is incorrect. A lun64 is at most 3410 * 16 hex digits long. 3411 * 3412 * If the address string specified has incorrect syntax (busconfig one of 3413 * bogus /devices path) then scsi_addr_to_lun64 can return SCSI_LUN64_ILLEGAL. 3414 */ 3415 static scsi_lun64_t 3416 scsi_addr_to_lun64(char *addr) 3417 { 3418 scsi_lun64_t lun64; 3419 char *s; 3420 int i; 3421 3422 if (addr) { 3423 s = strchr(addr, ','); /* "addr,lun" */ 3424 if (s) 3425 s++; /* skip ',', at lun */ 3426 else 3427 s = addr; /* "lun" */ 3428 3429 for (lun64 = 0, i = 0; *s && (i < 16); s++, i++) { 3430 if (*s >= '0' && *s <= '9') 3431 lun64 = (lun64 << 4) + (*s - '0'); 3432 else if (*s >= 'A' && *s <= 'F') 3433 lun64 = (lun64 << 4) + 10 + (*s - 'A'); 3434 else if (*s >= 'a' && *s <= 'f') 3435 lun64 = (lun64 << 4) + 10 + (*s - 'a'); 3436 else 3437 break; 3438 } 3439 if (*s && (*s != ',')) /* [,sfunc] is OK */ 3440 lun64 = SCSI_LUN64_ILLEGAL; 3441 } else 3442 lun64 = SCSI_LUN64_ILLEGAL; 3443 3444 if (lun64 == SCSI_LUN64_ILLEGAL) 3445 SCSI_HBA_LOG((_LOG(2), NULL, NULL, 3446 "addr_to_lun64 %s lun %" PRIlun64, 3447 addr ? addr : "NULL", lun64)); 3448 return (lun64); 3449 } 3450 3451 /* 3452 * Return the sfunc value from a address string: "addr,lun[,sfunc]". Either the 3453 * sfunc is after the second ',' or the entire address string is the sfunc. 3454 * Return -1 if there is only one ',' in the address string or the string is 3455 * invalid. An sfunc is at most two hex digits long. 3456 */ 3457 static int 3458 scsi_addr_to_sfunc(char *addr) 3459 { 3460 int sfunc; 3461 char *s; 3462 int i; 3463 3464 if (addr) { 3465 s = strchr(addr, ','); /* "addr,lun" */ 3466 if (s) { 3467 s++; /* skip ',', at lun */ 3468 s = strchr(s, ','); /* "lun,sfunc" */ 3469 if (s == NULL) 3470 return (-1); /* no ",sfunc" */ 3471 s++; /* skip ',', at sfunc */ 3472 } else 3473 s = addr; /* "sfunc" */ 3474 3475 for (sfunc = 0, i = 0; *s && (i < 2); s++, i++) { 3476 if (*s >= '0' && *s <= '9') 3477 sfunc = (sfunc << 4) + (*s - '0'); 3478 else if (*s >= 'A' && *s <= 'F') 3479 sfunc = (sfunc << 4) + 10 + (*s - 'A'); 3480 else if (*s >= 'a' && *s <= 'f') 3481 sfunc = (sfunc << 4) + 10 + (*s - 'a'); 3482 else 3483 break; 3484 } 3485 if (*s) 3486 sfunc = -1; /* illegal */ 3487 } else 3488 sfunc = -1; 3489 return (sfunc); 3490 } 3491 3492 /* 3493 * Convert scsi ascii string data to NULL terminated (semi) legal IEEE 1275 3494 * "compatible" (name) property form. 3495 * 3496 * For ASCII INQUIRY data, a one-way conversion algorithm is needed to take 3497 * SCSI_ASCII (20h - 7Eh) to a 1275-like compatible form. The 1275 spec allows 3498 * letters, digits, one ",", and ". _ + -", all limited by a maximum 31 3499 * character length. Since ", ." are used as separators in the compatible 3500 * string itself, they are converted to "_". All SCSI_ASCII characters that 3501 * are illegal in 1275, as well as any illegal SCSI_ASCII characters 3502 * encountered, are converted to "_". To reduce length, trailing blanks are 3503 * trimmed from SCSI_ASCII fields prior to conversion. 3504 * 3505 * Example: SCSI_ASCII "ST32550W SUN2.1G" -> "ST32550W_SUN2_1G" 3506 * 3507 * NOTE: the 1275 string form is always less than or equal to the scsi form. 3508 */ 3509 static char * 3510 string_scsi_to_1275(char *s_1275, char *s_scsi, int len) 3511 { 3512 (void) strncpy(s_1275, s_scsi, len); 3513 s_1275[len--] = '\0'; 3514 3515 while (len >= 0) { 3516 if (s_1275[len] == ' ') 3517 s_1275[len--] = '\0'; /* trim trailing " " */ 3518 else 3519 break; 3520 } 3521 3522 while (len >= 0) { 3523 if (((s_1275[len] >= 'a') && (s_1275[len] <= 'z')) || 3524 ((s_1275[len] >= 'A') && (s_1275[len] <= 'Z')) || 3525 ((s_1275[len] >= '0') && (s_1275[len] <= '9')) || 3526 (s_1275[len] == '_') || 3527 (s_1275[len] == '+') || 3528 (s_1275[len] == '-')) 3529 len--; /* legal 1275 */ 3530 else 3531 s_1275[len--] = '_'; /* illegal SCSI_ASCII | 1275 */ 3532 } 3533 3534 return (s_1275); 3535 } 3536 3537 /* 3538 * Given the inquiry data, binding_set, and dtype_node for a scsi device, 3539 * return the nodename and compatible property for the device. The "compatible" 3540 * concept comes from IEEE-1275. The compatible information is returned is in 3541 * the correct form for direct use defining the "compatible" string array 3542 * property. Internally, "compatible" is also used to determine the nodename 3543 * to return. 3544 * 3545 * This function is provided as a separate entry point for use by drivers that 3546 * currently issue their own non-SCSA inquiry command and perform their own 3547 * node creation based their own private compiled in tables. Converting these 3548 * drivers to use this interface provides a quick easy way of obtaining 3549 * consistency as well as the flexibility associated with the 1275 techniques. 3550 * 3551 * The dtype_node is passed as a separate argument (instead of having the 3552 * implementation use inq_dtype). It indicates that information about 3553 * a secondary function embedded service should be produced. 3554 * 3555 * Callers must always use scsi_hba_nodename_compatible_free, even if 3556 * *nodenamep is null, to free the nodename and compatible information 3557 * when done. 3558 * 3559 * If a nodename can't be determined then **compatiblep will point to a 3560 * diagnostic string containing all the compatible forms. 3561 * 3562 * NOTE: some compatible strings may violate the 31 character restriction 3563 * imposed by IEEE-1275. This is not a problem because Solaris does not care 3564 * about this 31 character limit. 3565 * 3566 * Each compatible form belongs to a form-group. The form-groups currently 3567 * defined are generic ("scsiclass"), binding-set ("scsa.b"), and failover 3568 * ("scsa.f"). 3569 * 3570 * The following compatible forms, in high to low precedence 3571 * order, are defined for SCSI target device nodes. 3572 * 3573 * scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (1 *1&2) 3574 * scsiclass,DDEE.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (2 *1) 3575 * scsiclass,DDFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (3 *2) 3576 * scsiclass,DD.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (4) 3577 * scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP (5 *1&2) 3578 * scsiclass,DDEE.vVVVVVVVV.pPPPPPPPPPPPPPPPP (6 *1) 3579 * scsiclass,DDFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP (7 *2) 3580 * scsiclass,DD.vVVVVVVVV.pPPPPPPPPPPPPPPPP (8) 3581 * scsa,DD.bBBBBBBBB (8.5 *3) 3582 * scsiclass,DDEEFFF (9 *1&2) 3583 * scsiclass,DDEE (10 *1) 3584 * scsiclass,DDFFF (11 *2) 3585 * scsiclass,DD (12) 3586 * scsa.fFFF (12.5 *4) 3587 * scsiclass (13) 3588 * 3589 * *1 only produced on a secondary function node 3590 * *2 only produced when generic form-group flags exist. 3591 * *3 only produced when binding-set form-group legacy support is needed 3592 * *4 only produced when failover form-group flags exist. 3593 * 3594 * where: 3595 * 3596 * v is the letter 'v'. Denotest the 3597 * beginning of VVVVVVVV. 3598 * 3599 * VVVVVVVV Translated scsi_vendor. 3600 * 3601 * p is the letter 'p'. Denotes the 3602 * beginning of PPPPPPPPPPPPPPPP. 3603 * 3604 * PPPPPPPPPPPPPPPP Translated scsi_product. 3605 * 3606 * r is the letter 'r'. Denotes the 3607 * beginning of RRRR. 3608 * 3609 * RRRR Translated scsi_revision. 3610 * 3611 * DD is a two digit ASCII hexadecimal 3612 * number. The value of the two digits is 3613 * based one the SCSI "Peripheral device 3614 * type" command set associated with the 3615 * node. On a primary node this is the 3616 * scsi_dtype of the primary command set, 3617 * on a secondary node this is the 3618 * scsi_dtype associated with the secondary 3619 * function embedded command set. 3620 * 3621 * EE Same encoding used for DD. This form is 3622 * only generated on secondary function 3623 * nodes. The DD secondary function is embedded 3624 * in an EE device. 3625 * 3626 * FFF Concatenation, in alphabetical order, 3627 * of the flag characters within a form-group. 3628 * For a given form-group, the following 3629 * flags are defined. 3630 * 3631 * scsiclass: (generic form-group): 3632 * R Removable_Media: Used when 3633 * inq_rmb is set. 3634 * S SAF-TE device: Used when 3635 * inquiry information indicates 3636 * SAF-TE devices. 3637 * 3638 * scsa.f: (failover form-group): 3639 * E Explicit Target_Port_Group: Used 3640 * when inq_tpgse is set and 'G' is 3641 * alse present. 3642 * G GUID: Used when a GUID can be 3643 * generated for the device. 3644 * I Implicit Target_Port_Group: Used 3645 * when inq_tpgs is set and 'G' is 3646 * also present. 3647 * 3648 * Forms using FFF are only be generated 3649 * if there are applicable flag 3650 * characters. 3651 * 3652 * b is the letter 'b'. Denotes the 3653 * beginning of BBBBBBBB. 3654 * 3655 * BBBBBBBB Binding-set. Operating System Specific: 3656 * scsi-binding-set property of HBA. 3657 */ 3658 #define NCOMPAT (1 + (13 + 2) + 1) 3659 #define COMPAT_LONGEST (strlen( \ 3660 "scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR" + 1)) 3661 3662 /* 3663 * Private version with extra device 'identity' arguments to allow code 3664 * to determine GUID FFF support. 3665 */ 3666 static void 3667 scsi_hba_ident_nodename_compatible_get(struct scsi_inquiry *inq, 3668 uchar_t *inq80, size_t inq80len, uchar_t *inq83, size_t inq83len, 3669 char *binding_set, int dtype_node, char *compat0, 3670 char **nodenamep, char **drivernamep, 3671 char ***compatiblep, int *ncompatiblep) 3672 { 3673 char vid[sizeof (inq->inq_vid) + 1 ]; 3674 char pid[sizeof (inq->inq_pid) + 1]; 3675 char rev[sizeof (inq->inq_revision) + 1]; 3676 char gf[sizeof ("RS\0")]; 3677 char ff[sizeof ("EGI\0")]; 3678 int dtype_device; 3679 int ncompat; /* number of compatible */ 3680 char **compatp; /* compatible ptrs */ 3681 int i; 3682 char *nname; /* nodename */ 3683 char *dname; /* driver name */ 3684 char **csp; 3685 char *p; 3686 int tlen; 3687 int len; 3688 major_t major; 3689 ddi_devid_t devid; 3690 char *guid; 3691 uchar_t *iqd = (uchar_t *)inq; 3692 3693 /* 3694 * Nodename_aliases: This table was originally designed to be 3695 * implemented via a new nodename_aliases file - a peer to the 3696 * driver_aliases that selects a nodename based on compatible 3697 * forms in much the same say driver_aliases is used to select 3698 * driver bindings from compatible forms. Each compatible form 3699 * is an 'alias'. Until a more general need for a 3700 * nodename_aliases file exists, which may never occur, the 3701 * scsi mappings are described here via a compiled in table. 3702 * 3703 * This table contains nodename mappings for self-identifying 3704 * scsi devices enumerated by the Solaris kernel. For a given 3705 * device, the highest precedence "compatible" form with a 3706 * mapping is used to select the nodename for the device. This 3707 * will typically be a generic nodename, however in some legacy 3708 * compatibility cases a driver nodename mapping may be selected. 3709 * 3710 * Because of possible breakage associated with switching SCSI 3711 * target devices from driver nodenames to generic nodenames, 3712 * we are currently unable to support generic nodenames for all 3713 * SCSI devices (binding-sets). Although /devices paths are 3714 * defined as unstable, avoiding possible breakage is 3715 * important. Some of the newer SCSI transports (USB) already 3716 * use generic nodenames. All new SCSI transports and target 3717 * devices should use generic nodenames. At times this decision 3718 * may be architecture dependent (sparc .vs. intel) based on when 3719 * a transport was supported on a particular architecture. 3720 * 3721 * We provide a base set of generic nodename mappings based on 3722 * scsiclass dtype and higher-precedence driver nodename 3723 * mappings based on scsa "binding-set" to cover legacy 3724 * issues. The binding-set is typically associated with 3725 * "scsi-binding-set" property value of the HBA. The legacy 3726 * mappings are provided independent of whether the driver they 3727 * refer to is installed. This allows a correctly named node 3728 * be created at discovery time, and binding to occur when/if 3729 * an add_drv of the legacy driver occurs. 3730 * 3731 * We also have mappings for legacy SUN hardware that 3732 * misidentifies itself (enclosure services which identify 3733 * themselves as processors). All future hardware should use 3734 * the correct dtype. 3735 * 3736 * As SCSI HBAs are modified to use the SCSA interfaces for 3737 * self-identifying SCSI target devices (PSARC/2004/116) the 3738 * nodename_aliases table (PSARC/2004/420) should be augmented 3739 * with legacy mappings in order to maintain compatibility with 3740 * existing /devices paths, especially for devices that house 3741 * an OS. Failure to do this may cause upgrade problems. 3742 * Additions for new target devices or transports should not 3743 * add scsa binding-set compatible mappings. 3744 */ 3745 static struct nodename_aliases { 3746 char *na_nodename; /* nodename */ 3747 char *na_alias; /* compatible form match */ 3748 } na[] = { 3749 /* # mapping to generic nodenames based on scsi dtype */ 3750 {"disk", "scsiclass,00"}, 3751 {"tape", "scsiclass,01"}, 3752 {"printer", "scsiclass,02"}, 3753 {"processor", "scsiclass,03"}, 3754 {"worm", "scsiclass,04"}, 3755 {"cdrom", "scsiclass,05"}, 3756 {"scanner", "scsiclass,06"}, 3757 {"optical-disk", "scsiclass,07"}, 3758 {"medium-changer", "scsiclass,08"}, 3759 {"obsolete", "scsiclass,09"}, 3760 {"prepress-a", "scsiclass,0a"}, 3761 {"prepress-b", "scsiclass,0b"}, 3762 {"array-controller", "scsiclass,0c"}, 3763 {"enclosure", "scsiclass,0d"}, 3764 {"disk", "scsiclass,0e"}, 3765 {"card-reader", "scsiclass,0f"}, 3766 {"bridge", "scsiclass,10"}, 3767 {"object-store", "scsiclass,11"}, 3768 {"reserved", "scsiclass,12"}, 3769 {"reserved", "scsiclass,13"}, 3770 {"reserved", "scsiclass,14"}, 3771 {"reserved", "scsiclass,15"}, 3772 {"reserved", "scsiclass,16"}, 3773 {"reserved", "scsiclass,17"}, 3774 {"reserved", "scsiclass,18"}, 3775 {"reserved", "scsiclass,19"}, 3776 {"reserved", "scsiclass,1a"}, 3777 {"reserved", "scsiclass,1b"}, 3778 {"reserved", "scsiclass,1c"}, 3779 {"reserved", "scsiclass,1d"}, 3780 {"well-known-lun", "scsiclass,1e"}, 3781 {"unknown", "scsiclass,1f"}, 3782 3783 #ifdef sparc 3784 /* # legacy mapping to driver nodenames for fcp binding-set */ 3785 {"ssd", "scsa,00.bfcp"}, 3786 {"st", "scsa,01.bfcp"}, 3787 {"sgen", "scsa,08.bfcp"}, 3788 {"ses", "scsa,0d.bfcp"}, 3789 3790 /* # legacy mapping to driver nodenames for vhci binding-set */ 3791 {"ssd", "scsa,00.bvhci"}, 3792 {"st", "scsa,01.bvhci"}, 3793 {"sgen", "scsa,08.bvhci"}, 3794 {"ses", "scsa,0d.bvhci"}, 3795 #else /* sparc */ 3796 /* # for x86 fcp and vhci use generic nodenames */ 3797 #endif /* sparc */ 3798 3799 /* # legacy mapping to driver nodenames for spi binding-set */ 3800 {"sd", "scsa,00.bspi"}, 3801 {"sd", "scsa,05.bspi"}, 3802 {"sd", "scsa,07.bspi"}, 3803 {"st", "scsa,01.bspi"}, 3804 {"ses", "scsa,0d.bspi"}, 3805 3806 /* # SUN misidentified spi hardware */ 3807 {"ses", "scsiclass,03.vSUN.pD2"}, 3808 {"ses", "scsiclass,03.vSYMBIOS.pD1000"}, 3809 3810 /* # legacy mapping to driver nodenames for atapi binding-set */ 3811 {"sd", "scsa,00.batapi"}, 3812 {"sd", "scsa,05.batapi"}, 3813 {"sd", "scsa,07.batapi"}, 3814 {"st", "scsa,01.batapi"}, 3815 {"unknown", "scsa,0d.batapi"}, 3816 3817 /* # legacy mapping to generic nodenames for usb binding-set */ 3818 {"disk", "scsa,05.busb"}, 3819 {"disk", "scsa,07.busb"}, 3820 {"changer", "scsa,08.busb"}, 3821 {"comm", "scsa,09.busb"}, 3822 {"array_ctlr", "scsa,0c.busb"}, 3823 {"esi", "scsa,0d.busb"}, 3824 3825 /* 3826 * mapping nodenames for mpt based on scsi dtype 3827 * for being compatible with the original node names 3828 * under mpt controller 3829 */ 3830 {"sd", "scsa,00.bmpt"}, 3831 {"sd", "scsa,05.bmpt"}, 3832 {"sd", "scsa,07.bmpt"}, 3833 {"st", "scsa,01.bmpt"}, 3834 {"ses", "scsa,0d.bmpt"}, 3835 {"sgen", "scsa,08.bmpt"}, 3836 {NULL, NULL} 3837 }; 3838 struct nodename_aliases *nap; 3839 3840 /* NOTE: drivernamep can be NULL */ 3841 ASSERT(nodenamep && compatiblep && ncompatiblep && 3842 (binding_set == NULL || (strlen(binding_set) <= 8))); 3843 if ((nodenamep == NULL) || (compatiblep == NULL) || 3844 (ncompatiblep == NULL)) 3845 return; 3846 3847 /* 3848 * In order to reduce runtime we allocate one block of memory that 3849 * contains both the NULL terminated array of pointers to compatible 3850 * forms and the individual compatible strings. This block is 3851 * somewhat larger than needed, but is short lived - it only exists 3852 * until the caller can transfer the information into the "compatible" 3853 * string array property and call scsi_hba_nodename_compatible_free. 3854 */ 3855 tlen = NCOMPAT * COMPAT_LONGEST; 3856 compatp = kmem_alloc((NCOMPAT * sizeof (char *)) + tlen, KM_SLEEP); 3857 3858 /* convert inquiry data from SCSI ASCII to 1275 string */ 3859 (void) string_scsi_to_1275(vid, inq->inq_vid, 3860 sizeof (inq->inq_vid)); 3861 (void) string_scsi_to_1275(pid, inq->inq_pid, 3862 sizeof (inq->inq_pid)); 3863 (void) string_scsi_to_1275(rev, inq->inq_revision, 3864 sizeof (inq->inq_revision)); 3865 ASSERT((strlen(vid) <= sizeof (inq->inq_vid)) && 3866 (strlen(pid) <= sizeof (inq->inq_pid)) && 3867 (strlen(rev) <= sizeof (inq->inq_revision))); 3868 3869 /* 3870 * Form flags in ***ALPHABETICAL*** order within form-group: 3871 * 3872 * NOTE: When adding a new flag to an existing form-group, careful 3873 * consideration must be given to not breaking existing bindings 3874 * based on that form-group. 3875 */ 3876 3877 /* 3878 * generic form-group flags 3879 * R removable: 3880 * Set when inq_rmb is set and for well known scsi dtypes. For a 3881 * bus where the entire device is removable (like USB), we expect 3882 * the HBA to intercept the inquiry data and set inq_rmb. 3883 * Since OBP does not distinguish removable media in its generic 3884 * name selection we avoid setting the 'R' flag if the root is not 3885 * yet mounted. 3886 * S SAF-TE device 3887 * Set when the device type is SAT-TE. 3888 */ 3889 i = 0; 3890 dtype_device = inq->inq_dtype & DTYPE_MASK; 3891 if (modrootloaded && (inq->inq_rmb || 3892 (dtype_device == DTYPE_WORM) || 3893 (dtype_device == DTYPE_RODIRECT) || 3894 (dtype_device == DTYPE_OPTICAL))) 3895 gf[i++] = 'R'; /* removable */ 3896 gf[i] = '\0'; 3897 3898 if (modrootloaded && 3899 (dtype_device == DTYPE_PROCESSOR) && 3900 (strncmp((char *)&iqd[44], "SAF-TE", 4) == 0)) 3901 gf[i++] = 'S'; 3902 gf[i] = '\0'; 3903 3904 /* 3905 * failover form-group flags 3906 * E Explicit Target_Port_Group_Supported: 3907 * Set for a device that has a GUID if inq_tpgse also set. 3908 * G GUID: 3909 * Set when we have identity information, can determine a devid 3910 * from the identity information, and can generate a guid from 3911 * that devid. 3912 * I Implicit Target_Port_Group_Supported: 3913 * Set for a device that has a GUID if inq_tpgs also set. 3914 */ 3915 i = 0; 3916 if ((inq80 || inq83) && 3917 (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST, NULL, 3918 (uchar_t *)inq, sizeof (*inq), inq80, inq80len, inq83, inq83len, 3919 &devid) == DDI_SUCCESS)) { 3920 guid = ddi_devid_to_guid(devid); 3921 ddi_devid_free(devid); 3922 } else 3923 guid = NULL; 3924 if (guid && (inq->inq_tpgs & TPGS_FAILOVER_EXPLICIT)) 3925 ff[i++] = 'E'; /* EXPLICIT TPGS */ 3926 if (guid) 3927 ff[i++] = 'G'; /* GUID */ 3928 if (guid && (inq->inq_tpgs & TPGS_FAILOVER_IMPLICIT)) 3929 ff[i++] = 'I'; /* IMPLICIT TPGS */ 3930 ff[i] = '\0'; 3931 if (guid) 3932 ddi_devid_free_guid(guid); 3933 3934 /* 3935 * Construct all applicable compatible forms. See comment at the 3936 * head of the function for a description of the compatible forms. 3937 */ 3938 csp = compatp; 3939 p = (char *)(compatp + NCOMPAT); 3940 3941 /* ( 0) driver (optional, not documented in scsi(4)) */ 3942 if (compat0) { 3943 *csp++ = p; 3944 (void) snprintf(p, tlen, "%s", compat0); 3945 len = strlen(p) + 1; 3946 p += len; 3947 tlen -= len; 3948 } 3949 3950 /* ( 1) scsiclass,DDEEFFF.vV.pP.rR */ 3951 if ((dtype_device != dtype_node) && *gf && *vid && *pid && *rev) { 3952 *csp++ = p; 3953 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s.v%s.p%s.r%s", 3954 dtype_node, dtype_device, gf, vid, pid, rev); 3955 len = strlen(p) + 1; 3956 p += len; 3957 tlen -= len; 3958 } 3959 3960 /* ( 2) scsiclass,DDEE.vV.pP.rR */ 3961 if ((dtype_device != dtype_node) && *vid && *pid && *rev) { 3962 *csp++ = p; 3963 (void) snprintf(p, tlen, "scsiclass,%02x%02x.v%s.p%s.r%s", 3964 dtype_node, dtype_device, vid, pid, rev); 3965 len = strlen(p) + 1; 3966 p += len; 3967 tlen -= len; 3968 } 3969 3970 /* ( 3) scsiclass,DDFFF.vV.pP.rR */ 3971 if (*gf && *vid && *pid && *rev) { 3972 *csp++ = p; 3973 (void) snprintf(p, tlen, "scsiclass,%02x%s.v%s.p%s.r%s", 3974 dtype_node, gf, vid, pid, rev); 3975 len = strlen(p) + 1; 3976 p += len; 3977 tlen -= len; 3978 } 3979 3980 /* ( 4) scsiclass,DD.vV.pP.rR */ 3981 if (*vid && *pid && *rev) { 3982 *csp++ = p; 3983 (void) snprintf(p, tlen, "scsiclass,%02x.v%s.p%s.r%s", 3984 dtype_node, vid, pid, rev); 3985 len = strlen(p) + 1; 3986 p += len; 3987 tlen -= len; 3988 } 3989 3990 /* ( 5) scsiclass,DDEEFFF.vV.pP */ 3991 if ((dtype_device != dtype_node) && *gf && *vid && *pid) { 3992 *csp++ = p; 3993 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s.v%s.p%s", 3994 dtype_node, dtype_device, gf, vid, pid); 3995 len = strlen(p) + 1; 3996 p += len; 3997 tlen -= len; 3998 } 3999 4000 /* ( 6) scsiclass,DDEE.vV.pP */ 4001 if ((dtype_device != dtype_node) && *vid && *pid) { 4002 *csp++ = p; 4003 (void) snprintf(p, tlen, "scsiclass,%02x%02x.v%s.p%s", 4004 dtype_node, dtype_device, vid, pid); 4005 len = strlen(p) + 1; 4006 p += len; 4007 tlen -= len; 4008 } 4009 4010 /* ( 7) scsiclass,DDFFF.vV.pP */ 4011 if (*gf && *vid && *pid) { 4012 *csp++ = p; 4013 (void) snprintf(p, tlen, "scsiclass,%02x%s.v%s.p%s", 4014 dtype_node, gf, vid, pid); 4015 len = strlen(p) + 1; 4016 p += len; 4017 tlen -= len; 4018 } 4019 4020 /* ( 8) scsiclass,DD.vV.pP */ 4021 if (*vid && *pid) { 4022 *csp++ = p; 4023 (void) snprintf(p, tlen, "scsiclass,%02x.v%s.p%s", 4024 dtype_node, vid, pid); 4025 len = strlen(p) + 1; 4026 p += len; 4027 tlen -= len; 4028 } 4029 4030 /* (8.5) scsa,DD.bB (not documented in scsi(4)) */ 4031 if (binding_set) { 4032 *csp++ = p; 4033 (void) snprintf(p, tlen, "scsa,%02x.b%s", 4034 dtype_node, binding_set); 4035 len = strlen(p) + 1; 4036 p += len; 4037 tlen -= len; 4038 } 4039 4040 /* ( 9) scsiclass,DDEEFFF */ 4041 if ((dtype_device != dtype_node) && *gf) { 4042 *csp++ = p; 4043 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s", 4044 dtype_node, dtype_device, gf); 4045 len = strlen(p) + 1; 4046 p += len; 4047 tlen -= len; 4048 } 4049 4050 /* (10) scsiclass,DDEE */ 4051 if (dtype_device != dtype_node) { 4052 *csp++ = p; 4053 (void) snprintf(p, tlen, "scsiclass,%02x%02x", 4054 dtype_node, dtype_device); 4055 len = strlen(p) + 1; 4056 p += len; 4057 tlen -= len; 4058 } 4059 4060 /* (11) scsiclass,DDFFF */ 4061 if (*gf) { 4062 *csp++ = p; 4063 (void) snprintf(p, tlen, "scsiclass,%02x%s", 4064 dtype_node, gf); 4065 len = strlen(p) + 1; 4066 p += len; 4067 tlen -= len; 4068 } 4069 4070 /* (12) scsiclass,DD */ 4071 *csp++ = p; 4072 (void) snprintf(p, tlen, "scsiclass,%02x", dtype_node); 4073 len = strlen(p) + 1; 4074 p += len; 4075 tlen -= len; 4076 4077 /* (12.5) scsa.fFFF */ 4078 if (*ff) { 4079 *csp++ = p; 4080 (void) snprintf(p, tlen, "scsa.f%s", ff); 4081 len = strlen(p) + 1; 4082 p += len; 4083 tlen -= len; 4084 } 4085 4086 /* (13) scsiclass */ 4087 *csp++ = p; 4088 (void) snprintf(p, tlen, "scsiclass"); 4089 len = strlen(p) + 1; 4090 p += len; 4091 tlen -= len; 4092 ASSERT(tlen >= 0); 4093 4094 *csp = NULL; /* NULL terminate array of pointers */ 4095 ncompat = csp - compatp; 4096 4097 /* 4098 * When determining a nodename, a nodename_aliases specified 4099 * mapping has precedence over using a driver_aliases specified 4100 * driver binding as a nodename. 4101 * 4102 * See if any of the compatible forms have a nodename_aliases 4103 * specified nodename. These mappings are described by 4104 * nodename_aliases entries like: 4105 * 4106 * disk "scsiclass,00" 4107 * enclosure "scsiclass,03.vSYMBIOS.pD1000" 4108 * ssd "scsa,00.bfcp" 4109 * 4110 * All nodename_aliases mappings should idealy be to generic 4111 * names, however a higher precedence legacy mapping to a 4112 * driver name may exist. The highest precedence mapping 4113 * provides the nodename, so legacy driver nodename mappings 4114 * (if they exist) take precedence over generic nodename 4115 * mappings. 4116 */ 4117 for (nname = NULL, csp = compatp; (nname == NULL) && *csp; csp++) { 4118 for (nap = na; nap->na_nodename; nap++) { 4119 if (strcmp(*csp, nap->na_alias) == 0) { 4120 nname = nap->na_nodename; 4121 break; 4122 } 4123 } 4124 } 4125 4126 /* 4127 * Determine the driver name based on compatible (which may 4128 * have the passed in compat0 as the first item). The driver_aliases 4129 * file has entries like 4130 * 4131 * sd "scsiclass,00" 4132 * 4133 * that map compatible forms to specific drivers. These entries are 4134 * established by add_drv/update_drv. We use the most specific 4135 * driver binding as the nodename. This matches the eventual 4136 * ddi_driver_compatible_major() binding that will be 4137 * established by bind_node() 4138 */ 4139 for (dname = NULL, csp = compatp; *csp; csp++) { 4140 major = ddi_name_to_major(*csp); 4141 if ((major == DDI_MAJOR_T_NONE) || 4142 (devnamesp[major].dn_flags & DN_DRIVER_REMOVED)) 4143 continue; 4144 if (dname = ddi_major_to_name(major)) 4145 break; 4146 } 4147 4148 /* 4149 * If no nodename_aliases mapping exists then use the 4150 * driver_aliases specified driver binding as a nodename. 4151 */ 4152 if (nname == NULL) 4153 nname = dname; 4154 4155 /* return results */ 4156 if (nname) { 4157 *nodenamep = kmem_alloc(strlen(nname) + 1, KM_SLEEP); 4158 (void) strcpy(*nodenamep, nname); 4159 } else { 4160 *nodenamep = NULL; 4161 4162 /* 4163 * If no nodename could be determined return a special 4164 * 'compatible' to be used for a diagnostic message. This 4165 * compatible contains all compatible forms concatenated 4166 * into a single string pointed to by the first element. 4167 */ 4168 for (csp = compatp; *(csp + 1); csp++) 4169 *((*csp) + strlen(*csp)) = ' '; 4170 *(compatp + 1) = NULL; 4171 ncompat = 1; 4172 4173 } 4174 if (drivernamep) { 4175 if (dname) { 4176 *drivernamep = kmem_alloc(strlen(dname) + 1, KM_SLEEP); 4177 (void) strcpy(*drivernamep, dname); 4178 } else 4179 *drivernamep = NULL; 4180 } 4181 *compatiblep = compatp; 4182 *ncompatiblep = ncompat; 4183 } 4184 4185 /* 4186 * Free allocations associated with scsi_hba_ident_nodename_compatible_get. 4187 */ 4188 static void 4189 scsi_hba_ident_nodename_compatible_free(char *nodename, char *drivername, 4190 char **compatible) 4191 { 4192 if (nodename) 4193 kmem_free(nodename, strlen(nodename) + 1); 4194 if (drivername) 4195 kmem_free(drivername, strlen(drivername) + 1); 4196 if (compatible) 4197 kmem_free(compatible, (NCOMPAT * sizeof (char *)) + 4198 (NCOMPAT * COMPAT_LONGEST)); 4199 } 4200 4201 void 4202 scsi_hba_nodename_compatible_get(struct scsi_inquiry *inq, 4203 char *binding_set, int dtype_node, char *compat0, 4204 char **nodenamep, char ***compatiblep, int *ncompatiblep) 4205 { 4206 scsi_hba_ident_nodename_compatible_get(inq, 4207 NULL, 0, NULL, 0, binding_set, dtype_node, compat0, nodenamep, 4208 NULL, compatiblep, ncompatiblep); 4209 } 4210 4211 void 4212 scsi_hba_nodename_compatible_free(char *nodename, char **compatible) 4213 { 4214 scsi_hba_ident_nodename_compatible_free(nodename, NULL, compatible); 4215 } 4216 4217 /* return the unit_address associated with a scsi_device */ 4218 char * 4219 scsi_device_unit_address(struct scsi_device *sd) 4220 { 4221 mdi_pathinfo_t *pip; 4222 4223 ASSERT(sd && sd->sd_dev); 4224 if ((sd == NULL) || (sd->sd_dev == NULL)) 4225 return (NULL); 4226 4227 pip = (mdi_pathinfo_t *)sd->sd_pathinfo; 4228 if (pip) 4229 return (mdi_pi_get_addr(pip)); 4230 else 4231 return (ddi_get_name_addr(sd->sd_dev)); 4232 } 4233 4234 /* scsi_device property interfaces */ 4235 #define _TYPE_DEFINED(flags) \ 4236 (((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_PATH) || \ 4237 ((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_DEVICE)) 4238 4239 #define _DEVICE_PIP(sd, flags) \ 4240 ((((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_PATH) && \ 4241 sd->sd_pathinfo) ? (mdi_pathinfo_t *)sd->sd_pathinfo : NULL) 4242 4243 int 4244 scsi_device_prop_get_int(struct scsi_device *sd, uint_t flags, 4245 char *name, int defval) 4246 { 4247 mdi_pathinfo_t *pip; 4248 int v = defval; 4249 int data; 4250 int rv; 4251 4252 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4253 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4254 !_TYPE_DEFINED(flags)) 4255 return (v); 4256 4257 pip = _DEVICE_PIP(sd, flags); 4258 if (pip) { 4259 rv = mdi_prop_lookup_int(pip, name, &data); 4260 if (rv == DDI_PROP_SUCCESS) 4261 v = data; 4262 } else 4263 v = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev, 4264 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v); 4265 return (v); 4266 } 4267 4268 4269 int64_t 4270 scsi_device_prop_get_int64(struct scsi_device *sd, uint_t flags, 4271 char *name, int64_t defval) 4272 { 4273 mdi_pathinfo_t *pip; 4274 int64_t v = defval; 4275 int64_t data; 4276 int rv; 4277 4278 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4279 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4280 !_TYPE_DEFINED(flags)) 4281 return (v); 4282 4283 pip = _DEVICE_PIP(sd, flags); 4284 if (pip) { 4285 rv = mdi_prop_lookup_int64(pip, name, &data); 4286 if (rv == DDI_PROP_SUCCESS) 4287 v = data; 4288 } else 4289 v = ddi_prop_get_int64(DDI_DEV_T_ANY, sd->sd_dev, 4290 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v); 4291 return (v); 4292 } 4293 4294 int 4295 scsi_device_prop_lookup_byte_array(struct scsi_device *sd, uint_t flags, 4296 char *name, uchar_t **data, uint_t *nelements) 4297 { 4298 mdi_pathinfo_t *pip; 4299 int rv; 4300 4301 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4302 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4303 !_TYPE_DEFINED(flags)) 4304 return (DDI_PROP_INVAL_ARG); 4305 4306 pip = _DEVICE_PIP(sd, flags); 4307 if (pip) 4308 rv = mdi_prop_lookup_byte_array(pip, name, data, nelements); 4309 else 4310 rv = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, sd->sd_dev, 4311 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4312 name, data, nelements); 4313 return (rv); 4314 } 4315 4316 int 4317 scsi_device_prop_lookup_int_array(struct scsi_device *sd, uint_t flags, 4318 char *name, int **data, uint_t *nelements) 4319 { 4320 mdi_pathinfo_t *pip; 4321 int rv; 4322 4323 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4324 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4325 !_TYPE_DEFINED(flags)) 4326 return (DDI_PROP_INVAL_ARG); 4327 4328 pip = _DEVICE_PIP(sd, flags); 4329 if (pip) 4330 rv = mdi_prop_lookup_int_array(pip, name, data, nelements); 4331 else 4332 rv = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, sd->sd_dev, 4333 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4334 name, data, nelements); 4335 return (rv); 4336 } 4337 4338 4339 int 4340 scsi_device_prop_lookup_string(struct scsi_device *sd, uint_t flags, 4341 char *name, char **data) 4342 { 4343 mdi_pathinfo_t *pip; 4344 int rv; 4345 4346 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4347 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4348 !_TYPE_DEFINED(flags)) 4349 return (DDI_PROP_INVAL_ARG); 4350 4351 pip = _DEVICE_PIP(sd, flags); 4352 if (pip) 4353 rv = mdi_prop_lookup_string(pip, name, data); 4354 else 4355 rv = ddi_prop_lookup_string(DDI_DEV_T_ANY, sd->sd_dev, 4356 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4357 name, data); 4358 return (rv); 4359 } 4360 4361 int 4362 scsi_device_prop_lookup_string_array(struct scsi_device *sd, uint_t flags, 4363 char *name, char ***data, uint_t *nelements) 4364 { 4365 mdi_pathinfo_t *pip; 4366 int rv; 4367 4368 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4369 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4370 !_TYPE_DEFINED(flags)) 4371 return (DDI_PROP_INVAL_ARG); 4372 4373 pip = _DEVICE_PIP(sd, flags); 4374 if (pip) 4375 rv = mdi_prop_lookup_string_array(pip, name, data, nelements); 4376 else 4377 rv = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, sd->sd_dev, 4378 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4379 name, data, nelements); 4380 return (rv); 4381 } 4382 4383 int 4384 scsi_device_prop_update_byte_array(struct scsi_device *sd, uint_t flags, 4385 char *name, uchar_t *data, uint_t nelements) 4386 { 4387 mdi_pathinfo_t *pip; 4388 int rv; 4389 4390 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4391 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4392 !_TYPE_DEFINED(flags)) 4393 return (DDI_PROP_INVAL_ARG); 4394 4395 pip = _DEVICE_PIP(sd, flags); 4396 if (pip) 4397 rv = mdi_prop_update_byte_array(pip, name, data, nelements); 4398 else 4399 rv = ndi_prop_update_byte_array(DDI_DEV_T_NONE, sd->sd_dev, 4400 name, data, nelements); 4401 return (rv); 4402 } 4403 4404 int 4405 scsi_device_prop_update_int(struct scsi_device *sd, uint_t flags, 4406 char *name, int data) 4407 { 4408 mdi_pathinfo_t *pip; 4409 int rv; 4410 4411 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4412 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4413 !_TYPE_DEFINED(flags)) 4414 return (DDI_PROP_INVAL_ARG); 4415 4416 pip = _DEVICE_PIP(sd, flags); 4417 if (pip) 4418 rv = mdi_prop_update_int(pip, name, data); 4419 else 4420 rv = ndi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 4421 name, data); 4422 return (rv); 4423 } 4424 4425 int 4426 scsi_device_prop_update_int64(struct scsi_device *sd, uint_t flags, 4427 char *name, int64_t data) 4428 { 4429 mdi_pathinfo_t *pip; 4430 int rv; 4431 4432 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4433 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4434 !_TYPE_DEFINED(flags)) 4435 return (DDI_PROP_INVAL_ARG); 4436 4437 pip = _DEVICE_PIP(sd, flags); 4438 if (pip) 4439 rv = mdi_prop_update_int64(pip, name, data); 4440 else 4441 rv = ndi_prop_update_int64(DDI_DEV_T_NONE, sd->sd_dev, 4442 name, data); 4443 return (rv); 4444 } 4445 4446 int 4447 scsi_device_prop_update_int_array(struct scsi_device *sd, uint_t flags, 4448 char *name, int *data, uint_t nelements) 4449 { 4450 mdi_pathinfo_t *pip; 4451 int rv; 4452 4453 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4454 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4455 !_TYPE_DEFINED(flags)) 4456 return (DDI_PROP_INVAL_ARG); 4457 4458 pip = _DEVICE_PIP(sd, flags); 4459 if (pip) 4460 rv = mdi_prop_update_int_array(pip, name, data, nelements); 4461 else 4462 rv = ndi_prop_update_int_array(DDI_DEV_T_NONE, sd->sd_dev, 4463 name, data, nelements); 4464 return (rv); 4465 } 4466 4467 int 4468 scsi_device_prop_update_string(struct scsi_device *sd, uint_t flags, 4469 char *name, char *data) 4470 { 4471 mdi_pathinfo_t *pip; 4472 int rv; 4473 4474 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4475 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4476 !_TYPE_DEFINED(flags)) 4477 return (DDI_PROP_INVAL_ARG); 4478 4479 pip = _DEVICE_PIP(sd, flags); 4480 if (pip) 4481 rv = mdi_prop_update_string(pip, name, data); 4482 else 4483 rv = ndi_prop_update_string(DDI_DEV_T_NONE, sd->sd_dev, 4484 name, data); 4485 return (rv); 4486 } 4487 4488 int 4489 scsi_device_prop_update_string_array(struct scsi_device *sd, uint_t flags, 4490 char *name, char **data, uint_t nelements) 4491 { 4492 mdi_pathinfo_t *pip; 4493 int rv; 4494 4495 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4496 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4497 !_TYPE_DEFINED(flags)) 4498 return (DDI_PROP_INVAL_ARG); 4499 4500 pip = _DEVICE_PIP(sd, flags); 4501 if (pip) 4502 rv = mdi_prop_update_string_array(pip, name, data, nelements); 4503 else 4504 rv = ndi_prop_update_string_array(DDI_DEV_T_NONE, sd->sd_dev, 4505 name, data, nelements); 4506 return (rv); 4507 } 4508 4509 int 4510 scsi_device_prop_remove(struct scsi_device *sd, uint_t flags, char *name) 4511 { 4512 mdi_pathinfo_t *pip; 4513 int rv; 4514 4515 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags)); 4516 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) || 4517 !_TYPE_DEFINED(flags)) 4518 return (DDI_PROP_INVAL_ARG); 4519 4520 pip = _DEVICE_PIP(sd, flags); 4521 if (pip) 4522 rv = mdi_prop_remove(pip, name); 4523 else 4524 rv = ndi_prop_remove(DDI_DEV_T_NONE, sd->sd_dev, name); 4525 return (rv); 4526 } 4527 4528 void 4529 scsi_device_prop_free(struct scsi_device *sd, uint_t flags, void *data) 4530 { 4531 mdi_pathinfo_t *pip; 4532 4533 ASSERT(sd && data && sd->sd_dev && _TYPE_DEFINED(flags)); 4534 if ((sd == NULL) || (data == NULL) || (sd->sd_dev == NULL) || 4535 !_TYPE_DEFINED(flags)) 4536 return; 4537 4538 pip = _DEVICE_PIP(sd, flags); 4539 if (pip) 4540 (void) mdi_prop_free(data); 4541 else 4542 ddi_prop_free(data); 4543 } 4544 4545 /* SMP device property interfaces */ 4546 int 4547 smp_device_prop_get_int(struct smp_device *smp_sd, char *name, int defval) 4548 { 4549 int v = defval; 4550 4551 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4552 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4553 return (v); 4554 4555 v = ddi_prop_get_int(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4556 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v); 4557 return (v); 4558 } 4559 4560 4561 int64_t 4562 smp_device_prop_get_int64(struct smp_device *smp_sd, char *name, int64_t defval) 4563 { 4564 int64_t v = defval; 4565 4566 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4567 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4568 return (v); 4569 4570 v = ddi_prop_get_int64(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4571 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v); 4572 return (v); 4573 } 4574 4575 int 4576 smp_device_prop_lookup_byte_array(struct smp_device *smp_sd, char *name, 4577 uchar_t **data, uint_t *nelements) 4578 { 4579 int rv; 4580 4581 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4582 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4583 return (DDI_PROP_INVAL_ARG); 4584 4585 rv = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4586 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4587 name, data, nelements); 4588 return (rv); 4589 } 4590 4591 int 4592 smp_device_prop_lookup_int_array(struct smp_device *smp_sd, char *name, 4593 int **data, uint_t *nelements) 4594 { 4595 int rv; 4596 4597 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4598 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4599 return (DDI_PROP_INVAL_ARG); 4600 4601 rv = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4602 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4603 name, data, nelements); 4604 return (rv); 4605 } 4606 4607 4608 int 4609 smp_device_prop_lookup_string(struct smp_device *smp_sd, char *name, 4610 char **data) 4611 { 4612 int rv; 4613 4614 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4615 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4616 return (DDI_PROP_INVAL_ARG); 4617 4618 rv = ddi_prop_lookup_string(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4619 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4620 name, data); 4621 return (rv); 4622 } 4623 4624 int 4625 smp_device_prop_lookup_string_array(struct smp_device *smp_sd, char *name, 4626 char ***data, uint_t *nelements) 4627 { 4628 int rv; 4629 4630 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4631 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4632 return (DDI_PROP_INVAL_ARG); 4633 4634 rv = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev, 4635 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 4636 name, data, nelements); 4637 return (rv); 4638 } 4639 4640 int 4641 smp_device_prop_update_byte_array(struct smp_device *smp_sd, char *name, 4642 uchar_t *data, uint_t nelements) 4643 { 4644 int rv; 4645 4646 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4647 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4648 return (DDI_PROP_INVAL_ARG); 4649 4650 rv = ndi_prop_update_byte_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4651 name, data, nelements); 4652 return (rv); 4653 } 4654 4655 int 4656 smp_device_prop_update_int(struct smp_device *smp_sd, char *name, int data) 4657 { 4658 int rv; 4659 4660 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4661 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4662 return (DDI_PROP_INVAL_ARG); 4663 4664 rv = ndi_prop_update_int(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4665 name, data); 4666 return (rv); 4667 } 4668 4669 int 4670 smp_device_prop_update_int64(struct smp_device *smp_sd, char *name, 4671 int64_t data) 4672 { 4673 int rv; 4674 4675 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4676 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4677 return (DDI_PROP_INVAL_ARG); 4678 4679 rv = ndi_prop_update_int64(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4680 name, data); 4681 return (rv); 4682 } 4683 4684 int 4685 smp_device_prop_update_int_array(struct smp_device *smp_sd, char *name, 4686 int *data, uint_t nelements) 4687 { 4688 int rv; 4689 4690 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4691 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4692 return (DDI_PROP_INVAL_ARG); 4693 4694 rv = ndi_prop_update_int_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4695 name, data, nelements); 4696 return (rv); 4697 } 4698 4699 int 4700 smp_device_prop_update_string(struct smp_device *smp_sd, char *name, char *data) 4701 { 4702 int rv; 4703 4704 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4705 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4706 return (DDI_PROP_INVAL_ARG); 4707 4708 rv = ndi_prop_update_string(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4709 name, data); 4710 return (rv); 4711 } 4712 4713 int 4714 smp_device_prop_update_string_array(struct smp_device *smp_sd, char *name, 4715 char **data, uint_t nelements) 4716 { 4717 int rv; 4718 4719 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4720 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4721 return (DDI_PROP_INVAL_ARG); 4722 4723 rv = ndi_prop_update_string_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, 4724 name, data, nelements); 4725 return (rv); 4726 } 4727 4728 int 4729 smp_device_prop_remove(struct smp_device *smp_sd, char *name) 4730 { 4731 int rv; 4732 4733 ASSERT(smp_sd && name && smp_sd->smp_sd_dev); 4734 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL)) 4735 return (DDI_PROP_INVAL_ARG); 4736 4737 rv = ndi_prop_remove(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, name); 4738 return (rv); 4739 } 4740 4741 void 4742 smp_device_prop_free(struct smp_device *smp_sd, void *data) 4743 { 4744 ASSERT(smp_sd && data && smp_sd->smp_sd_dev); 4745 if ((smp_sd == NULL) || (data == NULL) || (smp_sd->smp_sd_dev == NULL)) 4746 return; 4747 4748 ddi_prop_free(data); 4749 } 4750 4751 /* 4752 * scsi_hba_ua_set: given "unit-address" string, set properties. 4753 * 4754 * Function to set the properties on a devinfo or pathinfo node from 4755 * the "unit-address" part of a "name@unit-address" /devices path 'name' 4756 * string. 4757 * 4758 * This function works in conjunction with scsi_ua_get()/scsi_hba_ua_get() 4759 * (and possibly with an HBA driver's tran_tgt_init() implementation). 4760 */ 4761 static int 4762 scsi_hba_ua_set(char *ua, dev_info_t *dchild, mdi_pathinfo_t *pchild) 4763 { 4764 char *p; 4765 int tgt; 4766 char *tgt_port_end; 4767 char *tgt_port; 4768 int tgt_port_len; 4769 int sfunc; 4770 scsi_lun64_t lun64; 4771 4772 /* Caller must choose to decorate devinfo *or* pathinfo */ 4773 ASSERT((dchild != NULL) ^ (pchild != NULL)); 4774 if (dchild && pchild) 4775 return (0); 4776 4777 /* 4778 * generic implementation based on "tgt,lun[,sfunc]" address form. 4779 * parse hex "tgt" part of "tgt,lun[,sfunc]" 4780 */ 4781 p = ua; 4782 tgt_port_end = NULL; 4783 for (tgt = 0; *p && *p != ','; p++) { 4784 if (*p >= '0' && *p <= '9') 4785 tgt = (tgt << 4) + (*p - '0'); 4786 else if (*p >= 'a' && *p <= 'f') 4787 tgt = (tgt << 4) + 10 + (*p - 'a'); 4788 else 4789 tgt = -1; /* non-numeric */ 4790 4791 /* 4792 * if non-numeric or our of range set tgt to -1 and 4793 * skip forward 4794 */ 4795 if (tgt < 0) { 4796 tgt = -1; 4797 for (; *p && *p != ','; p++) 4798 ; 4799 break; 4800 } 4801 } 4802 tgt_port_end = p; 4803 4804 /* parse hex ",lun" part of "tgt,lun[,sfunc]" */ 4805 if (*p) 4806 p++; 4807 for (lun64 = 0; *p && *p != ','; p++) { 4808 if (*p >= '0' && *p <= '9') 4809 lun64 = (lun64 << 4) + (*p - '0'); 4810 else if (*p >= 'a' && *p <= 'f') 4811 lun64 = (lun64 << 4) + 10 + (*p - 'a'); 4812 else 4813 return (0); 4814 } 4815 4816 /* parse hex ",sfunc" part of "tgt,lun[,sfunc]" */ 4817 if (*p) { 4818 p++; 4819 for (sfunc = 0; *p; p++) { 4820 if (*p >= '0' && *p <= '9') 4821 sfunc = (sfunc << 4) + (*p - '0'); 4822 else if (*p >= 'a' && *p <= 'f') 4823 sfunc = (sfunc << 4) + 10 + (*p - 'a'); 4824 else 4825 return (0); 4826 } 4827 } else 4828 sfunc = -1; 4829 4830 if (dchild) { 4831 /* 4832 * Decorate a devinfo node with unit address properties. 4833 * This adds the the addressing properties needed to 4834 * DDI_CTLOPS_UNINITCHILD the devinfo node (i.e. perform 4835 * the reverse operation - form unit address from properties). 4836 */ 4837 if ((tgt != -1) && (ndi_prop_update_int(DDI_DEV_T_NONE, dchild, 4838 SCSI_ADDR_PROP_TARGET, tgt) != DDI_PROP_SUCCESS)) 4839 return (0); 4840 4841 if (tgt_port_end) { 4842 tgt_port_len = tgt_port_end - ua + 1; 4843 tgt_port = kmem_alloc(tgt_port_len, KM_SLEEP); 4844 (void) strlcpy(tgt_port, ua, tgt_port_len); 4845 if (ndi_prop_update_string(DDI_DEV_T_NONE, dchild, 4846 SCSI_ADDR_PROP_TARGET_PORT, tgt_port) != 4847 DDI_PROP_SUCCESS) { 4848 kmem_free(tgt_port, tgt_port_len); 4849 return (0); 4850 } 4851 kmem_free(tgt_port, tgt_port_len); 4852 } 4853 4854 /* Set the appropriate lun properties. */ 4855 if (lun64 < SCSI_32LUNS_PER_TARGET) { 4856 if (ndi_prop_update_int(DDI_DEV_T_NONE, dchild, 4857 SCSI_ADDR_PROP_LUN, (int)lun64) != DDI_PROP_SUCCESS) 4858 return (0); 4859 } 4860 if (ndi_prop_update_int64(DDI_DEV_T_NONE, dchild, 4861 SCSI_ADDR_PROP_LUN64, lun64) != DDI_PROP_SUCCESS) 4862 return (0); 4863 4864 /* Set the sfunc property */ 4865 if ((sfunc != -1) && 4866 (ndi_prop_update_int(DDI_DEV_T_NONE, dchild, 4867 SCSI_ADDR_PROP_SFUNC, (int)sfunc) != DDI_PROP_SUCCESS)) 4868 return (0); 4869 } else if (pchild) { 4870 /* 4871 * Decorate a pathinfo node with unit address properties. 4872 */ 4873 if ((tgt != -1) && (mdi_prop_update_int(pchild, 4874 SCSI_ADDR_PROP_TARGET, tgt) != DDI_PROP_SUCCESS)) 4875 return (0); 4876 4877 if (tgt_port_end) { 4878 tgt_port_len = tgt_port_end - ua + 1; 4879 tgt_port = kmem_alloc(tgt_port_len, KM_SLEEP); 4880 (void) strlcpy(tgt_port, ua, tgt_port_len); 4881 if (mdi_prop_update_string(pchild, 4882 SCSI_ADDR_PROP_TARGET_PORT, tgt_port) != 4883 DDI_PROP_SUCCESS) { 4884 kmem_free(tgt_port, tgt_port_len); 4885 return (0); 4886 } 4887 kmem_free(tgt_port, tgt_port_len); 4888 } 4889 4890 /* Set the appropriate lun properties */ 4891 if (lun64 < SCSI_32LUNS_PER_TARGET) { 4892 if (mdi_prop_update_int(pchild, SCSI_ADDR_PROP_LUN, 4893 (int)lun64) != DDI_PROP_SUCCESS) 4894 return (0); 4895 } 4896 4897 if (mdi_prop_update_int64(pchild, SCSI_ADDR_PROP_LUN64, 4898 lun64) != DDI_PROP_SUCCESS) 4899 return (0); 4900 4901 /* Set the sfunc property */ 4902 if ((sfunc != -1) && 4903 (mdi_prop_update_int(pchild, 4904 SCSI_ADDR_PROP_SFUNC, (int)sfunc) != DDI_PROP_SUCCESS)) 4905 return (0); 4906 } 4907 return (1); 4908 } 4909 4910 /* 4911 * Private ndi_devi_find/mdi_pi_find implementation - find the child 4912 * dev_info/path_info of self whose phci name matches "name@caddr". 4913 * We have our own implementation because we need to search with both 4914 * forms of sibling lists (dev_info and path_info) and we need to be able 4915 * to search with a NULL name in order to find siblings already associated 4916 * with a given unit-address (same @addr). NOTE: NULL name search will never 4917 * return probe node. 4918 * 4919 * If pchildp is NULL and we find a pathinfo child, we return the client 4920 * devinfo node in *dchildp. 4921 * 4922 * The init flag argument should be clear when called from places where 4923 * recursion could occur (like scsi_busctl_initchild) and when the caller 4924 * has already performed a search for name@addr with init set (performance). 4925 * 4926 * Future: Integrate ndi_devi_findchild_by_callback into scsi_findchild. 4927 */ 4928 static int 4929 scsi_findchild(dev_info_t *self, char *name, char *addr, int init, 4930 dev_info_t **dchildp, mdi_pathinfo_t **pchildp, int *ppi) 4931 { 4932 dev_info_t *dchild; /* devinfo child */ 4933 mdi_pathinfo_t *pchild; /* pathinfo child */ 4934 int found = CHILD_TYPE_NONE; 4935 char *daddr; 4936 4937 ASSERT(self && DEVI_BUSY_OWNED(self)); 4938 ASSERT(addr && dchildp); 4939 if ((self == NULL) || (addr == NULL) || (dchildp == NULL)) 4940 return (CHILD_TYPE_NONE); 4941 4942 *dchildp = NULL; 4943 if (pchildp) 4944 *pchildp = NULL; 4945 if (ppi) 4946 *ppi = 0; 4947 4948 /* Walk devinfo child list to find a match */ 4949 for (dchild = ddi_get_child(self); dchild; 4950 dchild = ddi_get_next_sibling(dchild)) { 4951 if (i_ddi_node_state(dchild) < DS_INITIALIZED) 4952 continue; 4953 4954 daddr = ddi_get_name_addr(dchild); 4955 if (daddr && (strcmp(addr, daddr) == 0) && 4956 ((name == NULL) || 4957 (strcmp(name, DEVI(dchild)->devi_node_name) == 0))) { 4958 /* 4959 * If we are asked to find "anything" at a given 4960 * unit-address (name == NULL), we don't realy want 4961 * to find the 'probe' node. The existance of 4962 * a probe node on a 'name == NULL' search should 4963 * fail. This will trigger slow-path code where 4964 * we explicity look for, and synchronize against, 4965 * a node named "probe" at the unit-address. 4966 */ 4967 if ((name == NULL) && 4968 scsi_hba_devi_is_barrier(dchild)) { 4969 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 4970 "%s@%s 'probe' devinfo found, skip", 4971 name ? name : "", addr)); 4972 continue; 4973 } 4974 4975 /* We have found a match. */ 4976 found |= CHILD_TYPE_DEVINFO; 4977 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 4978 "%s@%s devinfo found", name ? name : "", addr)); 4979 *dchildp = dchild; /* devinfo found */ 4980 break; 4981 } 4982 } 4983 4984 /* 4985 * Walk pathinfo child list to find a match. 4986 * 4987 * NOTE: Unlike devinfo nodes, pathinfo nodes have a string searchable 4988 * unit-address from creation - so there is no need for an 'init' 4989 * search block of code for pathinfo nodes below. 4990 */ 4991 pchild = mdi_pi_find(self, NULL, addr); 4992 if (pchild) { 4993 /* 4994 * NOTE: If name specified and we match a pathinfo unit 4995 * address, we don't check the client node name. 4996 */ 4997 if (ppi) 4998 *ppi = mdi_pi_get_path_instance(pchild); 4999 found |= CHILD_TYPE_PATHINFO; 5000 5001 if (pchildp) { 5002 SCSI_HBA_LOG((_LOG(4), self, NULL, 5003 "%s pathinfo found", mdi_pi_spathname(pchild))); 5004 *pchildp = pchild; /* pathinfo found */ 5005 } else if (*dchildp == NULL) { 5006 /* 5007 * Did not find a devinfo node, found a pathinfo node, 5008 * but caller did not ask us to return a pathinfo node: 5009 * we return the 'client' devinfo node instead (but 5010 * with CHILD_TYPE_PATHINFO 'found' return value). 5011 */ 5012 dchild = mdi_pi_get_client(pchild); 5013 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5014 "%s pathinfo found, client switch", 5015 mdi_pi_spathname(pchild))); 5016 5017 /* 5018 * A pathinfo node always has a 'client' devinfo node, 5019 * but we need to ensure that the 'client' is 5020 * initialized and has a scsi_device structure too. 5021 */ 5022 ASSERT(dchild); 5023 if (i_ddi_node_state(dchild) < DS_INITIALIZED) { 5024 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5025 "%s found client, initchild", 5026 mdi_pi_spathname(pchild))); 5027 (void) ddi_initchild(ddi_get_parent(dchild), 5028 dchild); 5029 } 5030 if (i_ddi_node_state(dchild) >= DS_INITIALIZED) { 5031 /* client found and initialized */ 5032 *dchildp = dchild; 5033 } else { 5034 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5035 "%s found client, but failed initchild", 5036 mdi_pi_spathname(pchild))); 5037 } 5038 } 5039 } 5040 5041 /* Try devinfo again with initchild of uninitialized nodes */ 5042 if ((found == CHILD_TYPE_NONE) && init) { 5043 for (dchild = ddi_get_child(self); dchild; 5044 dchild = ddi_get_next_sibling(dchild)) { 5045 /* skip if checked above */ 5046 if (i_ddi_node_state(dchild) >= DS_INITIALIZED) 5047 continue; 5048 /* attempt initchild to establish unit-address */ 5049 (void) ddi_initchild(self, dchild); 5050 if (i_ddi_node_state(dchild) < DS_INITIALIZED) 5051 continue; 5052 daddr = ddi_get_name_addr(dchild); 5053 if (daddr && 5054 ((name == NULL) || (strcmp(name, 5055 DEVI(dchild)->devi_node_name) == 0)) && 5056 (strcmp(addr, daddr) == 0)) { 5057 found |= CHILD_TYPE_DEVINFO; 5058 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5059 "%s@%s devinfo found post initchild", 5060 name ? name : "", addr)); 5061 *dchildp = dchild; /* devinfo found */ 5062 break; /* node found */ 5063 } 5064 } 5065 } 5066 5067 /* 5068 * We should never find devinfo and pathinfo at the same 5069 * unit-address. 5070 */ 5071 ASSERT(found != (CHILD_TYPE_DEVINFO | CHILD_TYPE_PATHINFO)); 5072 if (found == (CHILD_TYPE_DEVINFO | CHILD_TYPE_PATHINFO)) { 5073 found = CHILD_TYPE_NONE; 5074 *dchildp = NULL; 5075 *pchildp = NULL; 5076 } 5077 return (found); 5078 } 5079 5080 /* 5081 * Given information about a child device (contained on probe node) construct 5082 * and return a pointer to the dynamic SID devinfo node associated with the 5083 * device. In the creation of this SID node a compatible property for the 5084 * device is formed and used to establish a nodename (via 5085 * /etc/nodename_aliases) and to bind a driver (via /etc/driver_aliases). 5086 * 5087 * If this routine is called then we got a response from a device and 5088 * obtained the inquiry data from the device. Some inquiry results indicate 5089 * that the specific LUN we addressed does not exist, and we don't want to 5090 * bind a standard target driver to the node we create. Even though the 5091 * specific LUN is not usable, the framework may still want to bind a 5092 * target driver to the device for internal communication with the device - 5093 * an example would be issuing a report_lun to enumerate other LUNs under a 5094 * DPQ_NEVER LUN0. Another example would be wanting to known that the 5095 * DPQ_NEVER LUN0 device exists in BUS_CONFIG_ONE for non-existent LUN 5096 * caching optimizations. To support this we let the caller specify a 5097 * compatible property (or driver). If LUN0 inquiry data indicates that the 5098 * LUN does not exist then we establish compat0 as the highest precedence(0) 5099 * compatible form. If used, this compat0 driver will never be called on to 5100 * issue external commands to the device. 5101 * 5102 * If no driver binds to the device using driver_alias we establish the driver 5103 * passed in as the node name. 5104 */ 5105 5106 extern int e_devid_cache_pathinfo(mdi_pathinfo_t *, ddi_devid_t); 5107 5108 static int 5109 scsi_device_createchild(dev_info_t *self, char *addr, scsi_enum_t se, 5110 struct scsi_device *sdprobe, dev_info_t **dchildp, mdi_pathinfo_t **pchildp) 5111 { 5112 scsi_lun64_t lun64; 5113 int dtype; 5114 int dpq; 5115 int dpq_vu; 5116 int dtype_node; 5117 int lunexists; 5118 char *compat0; 5119 char *nname; 5120 char **compat = NULL; 5121 int ncompat; 5122 dev_info_t *dchild = NULL; 5123 mdi_pathinfo_t *pchild = NULL; 5124 dev_info_t *probe = sdprobe->sd_dev; 5125 struct scsi_inquiry *inq = sdprobe->sd_inq; 5126 uchar_t *inq80 = NULL; 5127 uchar_t *inq83 = NULL; 5128 uint_t inq80len, inq83len; 5129 char *binding_set = NULL; 5130 char *dname = NULL; 5131 ddi_devid_t devid; 5132 int have_devid = 0; 5133 ddi_devid_t cdevid; 5134 int have_cdevid = 0; 5135 char *devid_str; 5136 char *guid = NULL; 5137 5138 ASSERT(self && addr && *addr && DEVI_BUSY_OWNED(self)); 5139 ASSERT(dchildp && pchildp); 5140 5141 /* 5142 * Determine the lun and whether the lun exists. We may need to create 5143 * a node for LUN0 (with compat0 driver binding) even if the lun does 5144 * not exist - so we can run report_lun to find additional LUNs. 5145 */ 5146 lun64 = scsi_addr_to_lun64(addr); 5147 dtype = inq->inq_dtype & DTYPE_MASK; /* device */ 5148 dpq = inq->inq_dtype & DPQ_MASK; 5149 dpq_vu = inq->inq_dtype & DPQ_VUNIQ ? 1 : 0; 5150 5151 dtype_node = scsi_addr_to_sfunc(addr); /* secondary function */ 5152 if (dtype_node == -1) 5153 dtype_node = dtype; /* node for device */ 5154 5155 lunexists = (dtype != dtype_node) || /* override */ 5156 ((dpq_vu == 0) && (dpq == DPQ_POSSIBLE)) || /* ANSII */ 5157 (dpq_vu && (lun64 == 0)); /* VU LUN0 */ 5158 if (dtype == DTYPE_UNKNOWN) 5159 lunexists = 0; 5160 5161 SCSI_HBA_LOG((_LOG(4), self, NULL, 5162 "@%s dtype %x %x dpq_vu %d dpq %x: %d", 5163 addr, dtype, dtype_node, dpq_vu, dpq, lunexists)); 5164 5165 /* A non-existent LUN0 uses compatible_nodev. */ 5166 if (lunexists) { 5167 compat0 = NULL; /* compat0 not needed */ 5168 } else if (lun64 == 0) { 5169 compat0 = compatible_nodev; 5170 SCSI_HBA_LOG((_LOG(2), self, NULL, 5171 "@%s lun 0 with compat0 %s", addr, compat0)); 5172 } else 5173 goto out; /* no node created */ 5174 5175 /* Obtain identity information from probe node. */ 5176 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, probe, 5177 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "inquiry-page-80", 5178 &inq80, &inq80len) != DDI_PROP_SUCCESS) 5179 inq80 = NULL; 5180 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, probe, 5181 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "inquiry-page-83", 5182 &inq83, &inq83len) != DDI_PROP_SUCCESS) 5183 inq83 = NULL; 5184 5185 /* Get "scsi-binding-set" property (if there is one). */ 5186 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self, 5187 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 5188 "scsi-binding-set", &binding_set) == DDI_PROP_SUCCESS) 5189 SCSI_HBA_LOG((_LOG(2), NULL, probe, 5190 "binding_set '%s'", binding_set)); 5191 5192 /* determine the node name and compatible information */ 5193 scsi_hba_ident_nodename_compatible_get(inq, 5194 inq80, inq80len, inq83, inq83len, binding_set, dtype_node, 5195 compat0, &nname, &dname, &compat, &ncompat); 5196 5197 if (nname == NULL) { 5198 /* 5199 * We will not be able to create a node because we could not 5200 * determine a node name. Print out a NODRIVER level warning 5201 * message with the compatible forms for the device. Note that 5202 * there may be a driver.conf node that attaches to the device, 5203 * which is why we only produce this warning message for debug 5204 * kernels. 5205 */ 5206 SCSI_HBA_LOG((_LOG(1), NULL, self, 5207 "no node_name for device @%s:\n compatible: %s", 5208 addr, *compat)); 5209 goto out; 5210 } 5211 5212 /* 5213 * FUTURE: some day we may want an accurate "compatible" on the probe 5214 * node so that vhci_is_dev_supported() in scsi_vhci could, at 5215 * least in part, determine/configure based on "compatible". 5216 * 5217 * if (ndi_prop_update_string_array(DDI_DEV_T_NONE, probe, 5218 * "compatible", compat, ncompat) != DDI_PROP_SUCCESS) { 5219 * SCSI_HBA_LOG((_LOG(3), self, NULL, 5220 * "%s@%s failed probe compatible decoration", 5221 * nname, addr)); 5222 * goto out; 5223 * } 5224 */ 5225 5226 /* Encode devid from identity information. */ 5227 if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST, dname, 5228 (uchar_t *)inq, sizeof (*inq), inq80, inq80len, inq83, inq83len, 5229 &devid) == DDI_SUCCESS) { 5230 have_devid = 1; 5231 5232 /* Attempt to form guid from devid. */ 5233 guid = ddi_devid_to_guid(devid); 5234 5235 /* Produce string devid for debug. */ 5236 devid_str = ddi_devid_str_encode(devid, NULL); 5237 SCSI_HBA_LOG((_LOG(3), self, probe, "devid '%s' guid '%s'", 5238 devid_str ? devid_str : "NULL", guid ? guid : "NULL")); 5239 ddi_devid_str_free(devid_str); 5240 } 5241 5242 5243 /* 5244 * Determine if the device should be enumerated as under the vHCI 5245 * (client node) or under the pHCI. By convention scsi_vhci expects 5246 * the "cinfo" argument identity information to be represented as a 5247 * devinfo node with the needed information (i.e. the pHCI probe node). 5248 */ 5249 if ((guid == NULL) || 5250 (mdi_is_dev_supported(MDI_HCI_CLASS_SCSI, self, sdprobe) != 5251 MDI_SUCCESS)) { 5252 SCSI_HBA_LOG((_LOG(3), self, probe, "==> devinfo")); 5253 5254 /* 5255 * Enumerate under pHCI: 5256 * 5257 * Create dynamic SID dchild node. No attempt is made to 5258 * transfer information (except the addressing and identity 5259 * information) from the probe node to the dynamic node since 5260 * there may be HBA specific side effects that the framework 5261 * does not known how to transfer. 5262 */ 5263 ndi_devi_alloc_sleep(self, nname, 5264 (se == SE_HP) ? DEVI_SID_HP_NODEID : DEVI_SID_NODEID, 5265 &dchild); 5266 ASSERT(dchild); 5267 ndi_flavor_set(dchild, SCSA_FLAVOR_SCSI_DEVICE); 5268 5269 /* 5270 * Decorate new node with addressing properties (via 5271 * scsi_hba_ua_set()), compatible, identity information, and 5272 * class. 5273 */ 5274 if ((scsi_hba_ua_set(addr, dchild, NULL) == 0) || 5275 (ndi_prop_update_string_array(DDI_DEV_T_NONE, dchild, 5276 "compatible", compat, ncompat) != DDI_PROP_SUCCESS) || 5277 (inq80 && (ndi_prop_update_byte_array(DDI_DEV_T_NONE, 5278 dchild, "inquiry-page-80", inq80, inq80len) != 5279 DDI_PROP_SUCCESS)) || 5280 (inq83 && (ndi_prop_update_byte_array(DDI_DEV_T_NONE, 5281 dchild, "inquiry-page-83", inq83, inq83len) != 5282 DDI_PROP_SUCCESS)) || 5283 (ndi_prop_update_string(DDI_DEV_T_NONE, dchild, 5284 "class", "scsi") != DDI_PROP_SUCCESS)) { 5285 SCSI_HBA_LOG((_LOG(2), self, NULL, 5286 "devinfo @%s failed decoration", addr)); 5287 (void) scsi_hba_remove_node(dchild); 5288 dchild = NULL; 5289 goto out; 5290 } 5291 5292 /* Bind the driver */ 5293 if (ndi_devi_bind_driver(dchild, 0) != NDI_SUCCESS) { 5294 /* need to bind in order to register a devid */ 5295 SCSI_HBA_LOG((_LOGCFG, NULL, dchild, 5296 "devinfo @%s created, no driver-> " 5297 "no devid_register", addr)); 5298 goto out; 5299 } 5300 5301 /* Register devid */ 5302 if (have_devid) { 5303 if (ddi_devid_register(dchild, devid) == DDI_FAILURE) 5304 SCSI_HBA_LOG((_LOG(1), NULL, dchild, 5305 "devinfo @%s created, " 5306 "devid register failed", addr)); 5307 else 5308 SCSI_HBA_LOG((_LOG(2), NULL, dchild, 5309 "devinfo @%s created with devid", addr)); 5310 } else 5311 SCSI_HBA_LOG((_LOG(2), NULL, dchild, 5312 "devinfo @%s created, no devid", addr)); 5313 } else { 5314 /* 5315 * Enumerate under vHCI: 5316 * 5317 * Create a pathinfo pchild node. 5318 */ 5319 SCSI_HBA_LOG((_LOG(3), self, probe, "==>pathinfo")); 5320 5321 if (mdi_pi_alloc_compatible(self, nname, guid, addr, compat, 5322 ncompat, 0, &pchild) != MDI_SUCCESS) { 5323 SCSI_HBA_LOG((_LOG(2), self, probe, 5324 "pathinfo alloc failed")); 5325 goto out; 5326 } 5327 5328 ASSERT(pchild); 5329 dchild = mdi_pi_get_client(pchild); 5330 ASSERT(dchild); 5331 ndi_flavor_set(dchild, SCSA_FLAVOR_SCSI_DEVICE); 5332 5333 /* 5334 * Decorate new node with addressing properties via 5335 * scsi_hba_ua_set(). 5336 */ 5337 if (scsi_hba_ua_set(addr, NULL, pchild) == 0) { 5338 SCSI_HBA_LOG((_LOG(1), self, NULL, 5339 "pathinfo %s decoration failed", 5340 mdi_pi_spathname(pchild))); 5341 (void) mdi_pi_free(pchild, 0); 5342 pchild = NULL; 5343 goto out; 5344 } 5345 5346 /* Bind the driver */ 5347 if (ndi_devi_bind_driver(dchild, 0) != NDI_SUCCESS) { 5348 /* need to bind in order to register a devid */ 5349 SCSI_HBA_LOG((_LOGCFG, self, NULL, 5350 "pathinfo %s created, no client driver-> " 5351 "no devid_register", mdi_pi_spathname(pchild))); 5352 goto out; 5353 } 5354 5355 /* Watch out for inconsistancies in devids. */ 5356 if (ddi_devid_get(dchild, &cdevid) == DDI_SUCCESS) 5357 have_cdevid = 1; 5358 5359 if (have_devid && !have_cdevid) { 5360 /* Client does not yet have devid, register ours. */ 5361 if (ddi_devid_register(dchild, devid) == DDI_FAILURE) 5362 SCSI_HBA_LOG((_LOG(1), self, NULL, 5363 "pathinfo %s created, " 5364 "devid register failed", 5365 mdi_pi_spathname(pchild))); 5366 else 5367 SCSI_HBA_LOG((_LOG(2), self, NULL, 5368 "pathinfo %s created with devid", 5369 mdi_pi_spathname(pchild))); 5370 } else if (have_devid && have_cdevid) { 5371 /* 5372 * We have devid and client already has devid: 5373 * they must be the same. 5374 */ 5375 if (ddi_devid_compare(cdevid, devid) != 0) { 5376 SCSI_HBA_LOG((_LOG(WARN), NULL, dchild, 5377 "mismatched devid on path %s", 5378 mdi_pi_spathname(pchild))); 5379 } 5380 } else if (!have_devid && have_cdevid) { 5381 /* 5382 * Client already has a devid, but we don't: 5383 * we should not have missing devids. 5384 */ 5385 SCSI_HBA_LOG((_LOG(WARN), NULL, dchild, 5386 "missing devid on path %s", 5387 mdi_pi_spathname(pchild))); 5388 } else if (!have_cdevid && !have_devid) { 5389 /* devid not supported */ 5390 SCSI_HBA_LOG((_LOG(2), self, NULL, 5391 "pathinfo %s created, no devid", 5392 mdi_pi_spathname(pchild))); 5393 } 5394 5395 /* 5396 * The above has registered devid for the device under 5397 * the client node. Now register it under the full pHCI 5398 * path to the device. We'll get an entry equivalent to 5399 * booting with mpxio disabled. This is needed for 5400 * telemetry during enumeration. 5401 */ 5402 if (e_devid_cache_pathinfo(pchild, devid) == DDI_SUCCESS) { 5403 SCSI_HBA_LOG((_LOG(2), NULL, dchild, 5404 "pathinfo @%s created with devid", addr)); 5405 } else { 5406 SCSI_HBA_LOG((_LOG(1), NULL, dchild, 5407 "pathinfo @%s devid cache failed", addr)); 5408 } 5409 } 5410 5411 /* free the node name and compatible information */ 5412 out: if (have_devid) 5413 ddi_devid_free(devid); 5414 if (have_cdevid) 5415 ddi_devid_free(cdevid); 5416 if (guid) 5417 ddi_devid_free_guid(guid); 5418 if (compat) 5419 scsi_hba_ident_nodename_compatible_free(nname, dname, compat); 5420 if (inq80) 5421 ddi_prop_free(inq80); 5422 if (inq83) 5423 ddi_prop_free(inq83); 5424 if (binding_set) 5425 ddi_prop_free(binding_set); 5426 5427 /* return child_type results */ 5428 if (pchild) { 5429 *dchildp = NULL; 5430 *pchildp = pchild; 5431 return (CHILD_TYPE_PATHINFO); 5432 } else if (dchild) { 5433 *dchildp = dchild; 5434 *pchildp = NULL; 5435 return (CHILD_TYPE_DEVINFO); 5436 } 5437 5438 return (CHILD_TYPE_NONE); 5439 } 5440 5441 /* 5442 * Call scsi_device_createchild and then initchild the new node. 5443 */ 5444 static dev_info_t * 5445 scsi_device_configchild(dev_info_t *self, char *addr, scsi_enum_t se, 5446 struct scsi_device *sdprobe, int *circp, int *ppi) 5447 { 5448 int child_type; 5449 dev_info_t *dchild; 5450 mdi_pathinfo_t *pchild; 5451 dev_info_t *child; 5452 int rval; 5453 5454 ASSERT(self && addr && *addr && DEVI_BUSY_OWNED(self)); 5455 if (ppi) 5456 *ppi = 0; 5457 5458 child_type = scsi_device_createchild(self, addr, se, sdprobe, 5459 &dchild, &pchild); 5460 5461 /* 5462 * Prevent multiple initialized (tran_tgt_init) nodes associated with 5463 * the same @addr at the same time by calling tran_tgt_free() on the 5464 * probe node prior to promotion of the 'real' node. After the call 5465 * to scsi_hba_barrier_tran_tgt_free(), the HBA no longer has any 5466 * probe node context. 5467 */ 5468 scsi_hba_barrier_tran_tgt_free(sdprobe->sd_dev); 5469 5470 switch (child_type) { 5471 case CHILD_TYPE_NONE: 5472 child = NULL; 5473 break; 5474 5475 case CHILD_TYPE_PATHINFO: 5476 /* 5477 * Online pathinfo: Hold the path and exit the pHCI while 5478 * calling mdi_pi_online() to avoid deadlock with power 5479 * management of pHCI. 5480 */ 5481 ASSERT(MDI_PHCI(self)); 5482 mdi_hold_path(pchild); 5483 scsi_hba_devi_exit_phci(self, *circp); 5484 5485 rval = mdi_pi_online(pchild, 0); 5486 5487 scsi_hba_devi_enter_phci(self, circp); 5488 mdi_rele_path(pchild); 5489 5490 if (rval != MDI_SUCCESS) { 5491 /* pathinfo form of "failed during tran_tgt_init" */ 5492 scsi_enumeration_failed(NULL, se, 5493 mdi_pi_spathname(pchild), "path online"); 5494 (void) mdi_pi_free(pchild, 0); 5495 return (NULL); 5496 } 5497 5498 /* 5499 * Return the path_instance of the pathinfo node. 5500 * 5501 * NOTE: We assume that sd_inq is not path-specific. 5502 */ 5503 if (ppi) 5504 *ppi = mdi_pi_get_path_instance(pchild); 5505 5506 5507 /* 5508 * Fallthrough into CHILD_TYPE_DEVINFO code to promote 5509 * the 'client' devinfo node as a dchild. 5510 */ 5511 dchild = mdi_pi_get_client(pchild); 5512 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5513 "pathinfo online successful")); 5514 /* FALLTHROUGH */ 5515 5516 case CHILD_TYPE_DEVINFO: 5517 /* 5518 * For now, we ndi_devi_online() the child because some other 5519 * parts of the IO framework, like degenerate devid code, 5520 * depend on bus_config driving nodes to DS_ATTACHED. At some 5521 * point in the future, to keep things light-weight, we would 5522 * like to change the ndi_devi_online call below to be 5523 * 5524 * if (ddi_initchild(self, dchild) != DDI_SUCCESS) 5525 * 5526 * This would promote the node so that framework code could 5527 * find the child with an @addr search, but does not incur 5528 * attach(9E) overhead for BUS_CONFIG_ALL cases where the 5529 * framework is not interested in attach of the node. 5530 * 5531 * NOTE: If the addr specified has incorrect syntax (busconfig 5532 * one of bogus /devices path) then call below can fail. 5533 */ 5534 if (ndi_devi_online(dchild, 0) != NDI_SUCCESS) { 5535 SCSI_HBA_LOG((_LOG(2), NULL, dchild, 5536 "devinfo online failed")); 5537 5538 /* failed online does not remove the node */ 5539 (void) scsi_hba_remove_node(dchild); 5540 return (NULL); 5541 } 5542 SCSI_HBA_LOG((_LOG(4), NULL, dchild, 5543 "devinfo initchild successful")); 5544 child = dchild; 5545 break; 5546 } 5547 return (child); 5548 } 5549 5550 void 5551 scsi_hba_pkt_comp(struct scsi_pkt *pkt) 5552 { 5553 scsi_hba_tran_t *tran; 5554 uint8_t *sensep; 5555 5556 ASSERT(pkt); 5557 5558 /* 5559 * Catch second call on the same packet before doing anything else. 5560 */ 5561 if (pkt->pkt_flags & FLAG_PKT_COMP_CALLED) { 5562 cmn_err( 5563 #ifdef DEBUG 5564 CE_PANIC, 5565 #else 5566 CE_WARN, 5567 #endif 5568 "%s duplicate scsi_hba_pkt_comp(9F) on same scsi_pkt(9S)", 5569 mod_containing_pc(caller())); 5570 } 5571 5572 pkt->pkt_flags |= FLAG_PKT_COMP_CALLED; 5573 5574 if (pkt->pkt_comp == NULL) 5575 return; 5576 5577 /* 5578 * For HBA drivers that implement tran_setup_pkt(9E), if we are 5579 * completing a 'consistent' mode DMA operation then we must 5580 * perform dma_sync prior to calling pkt_comp to ensure that 5581 * the target driver sees the correct data in memory. 5582 */ 5583 ASSERT((pkt->pkt_flags & FLAG_NOINTR) == 0); 5584 if (((pkt->pkt_dma_flags & DDI_DMA_CONSISTENT) && 5585 (pkt->pkt_dma_flags & DDI_DMA_READ)) && 5586 ((P_TO_TRAN(pkt)->tran_setup_pkt) != NULL)) { 5587 scsi_sync_pkt(pkt); 5588 } 5589 5590 /* 5591 * If the HBA driver is using SCSAv3 scsi_hba_tgtmap_create enumeration 5592 * then we detect the special ASC/ASCQ completion codes that indicate 5593 * that the lun configuration of a target has changed. Since we need to 5594 * be determine scsi_device given scsi_address enbedded in 5595 * scsi_pkt (via scsi_address_device(9F)), we also require use of 5596 * SCSI_HBA_ADDR_COMPLEX. 5597 */ 5598 tran = pkt->pkt_address.a_hba_tran; 5599 ASSERT(tran); 5600 if ((tran->tran_tgtmap == NULL) || 5601 !(tran->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX)) 5602 goto comp; /* not using tgtmap */ 5603 5604 /* 5605 * Check for lun-change notification and queue the scsi_pkt for 5606 * lunchg1 processing. The 'pkt_comp' call to the target driver 5607 * is part of lunchg1 processing. 5608 */ 5609 if ((pkt->pkt_reason == CMD_CMPLT) && 5610 (((*pkt->pkt_scbp) & STATUS_MASK) == STATUS_CHECK) && 5611 (pkt->pkt_state & STATE_ARQ_DONE)) { 5612 sensep = (uint8_t *)&(((struct scsi_arq_status *)(uintptr_t) 5613 (pkt->pkt_scbp))->sts_sensedata); 5614 if (((scsi_sense_key(sensep) == KEY_UNIT_ATTENTION) && 5615 (scsi_sense_asc(sensep) == 0x3f) && 5616 (scsi_sense_ascq(sensep) == 0x0e)) || 5617 5618 ((scsi_sense_key(sensep) == KEY_UNIT_ATTENTION) && 5619 (scsi_sense_asc(sensep) == 0x25) && 5620 (scsi_sense_ascq(sensep) == 0x00))) { 5621 /* 5622 * The host adaptor is done with the packet, we use 5623 * pkt_stmp stage-temporary to link the packet for 5624 * lunchg1 processing. 5625 * 5626 * NOTE: pkt_ha_private is not available since its use 5627 * extends to tran_teardown_pkt. 5628 */ 5629 mutex_enter(&scsi_lunchg1_mutex); 5630 pkt->pkt_stmp = scsi_lunchg1_list; 5631 scsi_lunchg1_list = pkt; 5632 if (pkt->pkt_stmp == NULL) 5633 (void) cv_signal(&scsi_lunchg1_cv); 5634 mutex_exit(&scsi_lunchg1_mutex); 5635 return; 5636 } 5637 } 5638 5639 comp: (*pkt->pkt_comp)(pkt); 5640 } 5641 5642 /* 5643 * return 1 if the specified node is a barrier/probe node 5644 */ 5645 static int 5646 scsi_hba_devi_is_barrier(dev_info_t *probe) 5647 { 5648 if (probe && (strcmp(ddi_node_name(probe), "probe") == 0)) 5649 return (1); 5650 return (0); 5651 } 5652 5653 /* 5654 * A host adapter driver is easier to write if we prevent multiple initialized 5655 * (tran_tgt_init) scsi_device structures to the same unit-address at the same 5656 * time. We prevent this from occurring all the time during the barrier/probe 5657 * node to real child hand-off by calling scsi_hba_barrier_tran_tgt_free 5658 * on the probe node prior to ddi_inichild of the 'real' node. As part of 5659 * this early tran_tgt_free implementation, we must also call this function 5660 * as we put a probe node on the scsi_hba_barrier_list. 5661 */ 5662 static void 5663 scsi_hba_barrier_tran_tgt_free(dev_info_t *probe) 5664 { 5665 struct scsi_device *sdprobe; 5666 dev_info_t *self; 5667 scsi_hba_tran_t *tran; 5668 5669 ASSERT(probe && scsi_hba_devi_is_barrier(probe)); 5670 5671 /* Return if we never called tran_tgt_init(9E). */ 5672 if (i_ddi_node_state(probe) < DS_INITIALIZED) 5673 return; 5674 5675 sdprobe = ddi_get_driver_private(probe); 5676 self = ddi_get_parent(probe); 5677 ASSERT(sdprobe && self); 5678 tran = ddi_get_driver_private(self); 5679 ASSERT(tran); 5680 5681 if (tran->tran_tgt_free) { 5682 /* 5683 * To correctly support TRAN_CLONE, we need to use the same 5684 * cloned scsi_hba_tran(9S) structure for both tran_tgt_init(9E) 5685 * and tran_tgt_free(9E). 5686 */ 5687 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE) 5688 tran = sdprobe->sd_address.a_hba_tran; 5689 5690 if (!sdprobe->sd_tran_tgt_free_done) { 5691 SCSI_HBA_LOG((_LOG(4), NULL, probe, 5692 "tran_tgt_free EARLY")); 5693 (*tran->tran_tgt_free) (self, probe, tran, sdprobe); 5694 sdprobe->sd_tran_tgt_free_done = 1; 5695 } else { 5696 SCSI_HBA_LOG((_LOG(4), NULL, probe, 5697 "tran_tgt_free EARLY already done")); 5698 } 5699 } 5700 } 5701 5702 /* 5703 * Add an entry to the list of barrier nodes to be asynchronously deleted by 5704 * the scsi_hba_barrier_daemon after the specified timeout. Nodes on 5705 * the barrier list are used to implement the bus_config probe cache 5706 * of non-existent devices. The nodes are at DS_INITIALIZED, so their 5707 * @addr is established for searching. Since devi_ref of a DS_INITIALIZED 5708 * node will *not* prevent demotion, demotion is prevented by setting 5709 * sd_uninit_prevent. Devinfo snapshots attempt to attach probe cache 5710 * nodes, and on failure attempt to demote the node (without the participation 5711 * of bus_unconfig) to DS_BOUND - this demotion is prevented via 5712 * sd_uninit_prevent causing any attempted DDI_CTLOPS_UNINITCHILD to fail. 5713 * Probe nodes are bound to nulldriver. The list is sorted by 5714 * expiration time. 5715 * 5716 * NOTE: If we drove a probe node to DS_ATTACHED, we could use ndi_hold_devi() 5717 * to prevent demotion (instead of sd_uninit_prevent). 5718 */ 5719 static void 5720 scsi_hba_barrier_add(dev_info_t *probe, int seconds) 5721 { 5722 struct scsi_hba_barrier *nb; 5723 struct scsi_hba_barrier *b; 5724 struct scsi_hba_barrier **bp; 5725 clock_t endtime; 5726 5727 ASSERT(scsi_hba_devi_is_barrier(probe)); 5728 5729 /* HBA is no longer responsible for nodes on the barrier list. */ 5730 scsi_hba_barrier_tran_tgt_free(probe); 5731 nb = kmem_alloc(sizeof (struct scsi_hba_barrier), KM_SLEEP); 5732 mutex_enter(&scsi_hba_barrier_mutex); 5733 endtime = ddi_get_lbolt() + drv_usectohz(seconds * MICROSEC); 5734 for (bp = &scsi_hba_barrier_list; (b = *bp) != NULL; 5735 bp = &b->barrier_next) 5736 if (b->barrier_endtime > endtime) 5737 break; 5738 nb->barrier_next = *bp; 5739 nb->barrier_endtime = endtime; 5740 nb->barrier_probe = probe; 5741 *bp = nb; 5742 if (bp == &scsi_hba_barrier_list) 5743 (void) cv_signal(&scsi_hba_barrier_cv); 5744 mutex_exit(&scsi_hba_barrier_mutex); 5745 } 5746 5747 /* 5748 * Attempt to remove devinfo node node, return 1 if removed. We 5749 * don't try to remove barrier nodes that have sd_uninit_prevent set 5750 * (even though they should fail device_uninitchild). 5751 */ 5752 static int 5753 scsi_hba_remove_node(dev_info_t *child) 5754 { 5755 dev_info_t *self = ddi_get_parent(child); 5756 struct scsi_device *sd; 5757 int circ; 5758 int remove = 1; 5759 int ret = 0; 5760 char na[SCSI_MAXNAMELEN]; 5761 5762 scsi_hba_devi_enter(self, &circ); 5763 5764 /* Honor sd_uninit_prevent on barrier nodes */ 5765 if (scsi_hba_devi_is_barrier(child)) { 5766 sd = ddi_get_driver_private(child); 5767 if (sd && sd->sd_uninit_prevent) 5768 remove = 0; 5769 } 5770 5771 if (remove) { 5772 (void) ddi_deviname(child, na); 5773 if (ddi_remove_child(child, 0) != DDI_SUCCESS) { 5774 SCSI_HBA_LOG((_LOG(2), NULL, child, 5775 "remove_node failed")); 5776 } else { 5777 child = NULL; /* child is gone */ 5778 SCSI_HBA_LOG((_LOG(4), self, NULL, 5779 "remove_node removed %s", *na ? &na[1] : na)); 5780 ret = 1; 5781 } 5782 } else { 5783 SCSI_HBA_LOG((_LOG(4), NULL, child, "remove_node prevented")); 5784 } 5785 scsi_hba_devi_exit(self, circ); 5786 return (ret); 5787 } 5788 5789 /* 5790 * The asynchronous barrier deletion daemon. Waits for a barrier timeout 5791 * to expire, then deletes the barrier (removes it as a child). 5792 */ 5793 /*ARGSUSED*/ 5794 static void 5795 scsi_hba_barrier_daemon(void *arg) 5796 { 5797 struct scsi_hba_barrier *b; 5798 dev_info_t *probe; 5799 callb_cpr_t cprinfo; 5800 int circ; 5801 dev_info_t *self; 5802 5803 CALLB_CPR_INIT(&cprinfo, &scsi_hba_barrier_mutex, 5804 callb_generic_cpr, "scsi_hba_barrier_daemon"); 5805 again: mutex_enter(&scsi_hba_barrier_mutex); 5806 for (;;) { 5807 b = scsi_hba_barrier_list; 5808 if (b == NULL) { 5809 /* all barriers expired, wait for barrier_add */ 5810 CALLB_CPR_SAFE_BEGIN(&cprinfo); 5811 (void) cv_wait(&scsi_hba_barrier_cv, 5812 &scsi_hba_barrier_mutex); 5813 CALLB_CPR_SAFE_END(&cprinfo, &scsi_hba_barrier_mutex); 5814 } else { 5815 if (ddi_get_lbolt() >= b->barrier_endtime) { 5816 /* 5817 * Drop and retry if ordering issue. Do this 5818 * before calling scsi_hba_remove_node() and 5819 * deadlocking. 5820 */ 5821 probe = b->barrier_probe; 5822 self = ddi_get_parent(probe); 5823 if (scsi_hba_devi_tryenter(self, &circ) == 0) { 5824 delay: mutex_exit(&scsi_hba_barrier_mutex); 5825 delay_random(5); 5826 goto again; 5827 } 5828 5829 /* process expired barrier */ 5830 if (!scsi_hba_remove_node(probe)) { 5831 /* remove failed, delay and retry */ 5832 SCSI_HBA_LOG((_LOG(4), NULL, probe, 5833 "delay expire")); 5834 scsi_hba_devi_exit(self, circ); 5835 goto delay; 5836 } 5837 scsi_hba_barrier_list = b->barrier_next; 5838 kmem_free(b, sizeof (struct scsi_hba_barrier)); 5839 scsi_hba_devi_exit(self, circ); 5840 } else { 5841 /* establish timeout for next barrier expire */ 5842 (void) cv_timedwait(&scsi_hba_barrier_cv, 5843 &scsi_hba_barrier_mutex, 5844 b->barrier_endtime); 5845 } 5846 } 5847 } 5848 } 5849 5850 /* 5851 * Remove all barriers associated with the specified HBA. This is called 5852 * from from the bus_unconfig implementation to remove probe nodes associated 5853 * with the specified HBA (self) so that probe nodes that have not expired 5854 * will not prevent DR of the HBA. 5855 */ 5856 static void 5857 scsi_hba_barrier_purge(dev_info_t *self) 5858 { 5859 struct scsi_hba_barrier **bp; 5860 struct scsi_hba_barrier *b; 5861 5862 mutex_enter(&scsi_hba_barrier_mutex); 5863 for (bp = &scsi_hba_barrier_list; (b = *bp) != NULL; ) { 5864 if (ddi_get_parent(b->barrier_probe) == self) { 5865 if (scsi_hba_remove_node(b->barrier_probe)) { 5866 *bp = b->barrier_next; 5867 kmem_free(b, sizeof (struct scsi_hba_barrier)); 5868 } else { 5869 SCSI_HBA_LOG((_LOG(4), NULL, b->barrier_probe, 5870 "skip purge")); 5871 } 5872 } else 5873 bp = &b->barrier_next; 5874 } 5875 5876 mutex_exit(&scsi_hba_barrier_mutex); 5877 } 5878 5879 /* 5880 * LUN-change processing daemons: processing occurs in two stages: 5881 * 5882 * Stage 1: Daemon waits for a lunchg1 queued scsi_pkt, dequeues the pkt, 5883 * forms the path, completes the scsi_pkt (pkt_comp), and 5884 * queues the path for stage 2 processing. The use of stage 1 5885 * avoids issues related to memory allocation in interrupt context 5886 * (scsi_hba_pkt_comp()). We delay the pkt_comp completion until 5887 * after lunchg1 processing forms the path for stage 2 - this is 5888 * done to prevent the target driver from detaching until the 5889 * path formation is complete (driver with outstanding commands 5890 * should not detach). 5891 * 5892 * Stage 2: Daemon waits for a lunchg2 queued request, dequeues the 5893 * request, and opens the path using ldi_open_by_name(). The 5894 * path opened uses a special "@taddr,*" unit address that will 5895 * trigger lun enumeration in scsi_hba_bus_configone(). We 5896 * trigger lun enumeration in stage 2 to avoid problems when 5897 * initial ASC/ASCQ trigger occurs during discovery. 5898 */ 5899 /*ARGSUSED*/ 5900 static void 5901 scsi_lunchg1_daemon(void *arg) 5902 { 5903 callb_cpr_t cprinfo; 5904 struct scsi_pkt *pkt; 5905 scsi_hba_tran_t *tran; 5906 dev_info_t *self; 5907 struct scsi_device *sd; 5908 char *ua, *p; 5909 char taddr[SCSI_MAXNAMELEN]; 5910 char path[MAXPATHLEN]; 5911 struct scsi_lunchg2 *lunchg2; 5912 5913 CALLB_CPR_INIT(&cprinfo, &scsi_lunchg1_mutex, 5914 callb_generic_cpr, "scsi_lunchg1_daemon"); 5915 mutex_enter(&scsi_lunchg1_mutex); 5916 for (;;) { 5917 pkt = scsi_lunchg1_list; 5918 if (pkt == NULL) { 5919 /* All lunchg1 processing requests serviced, wait. */ 5920 CALLB_CPR_SAFE_BEGIN(&cprinfo); 5921 (void) cv_wait(&scsi_lunchg1_cv, 5922 &scsi_lunchg1_mutex); 5923 CALLB_CPR_SAFE_END(&cprinfo, &scsi_lunchg1_mutex); 5924 continue; 5925 } 5926 5927 /* Unlink and perform lunchg1 processing on pkt. */ 5928 scsi_lunchg1_list = pkt->pkt_stmp; 5929 5930 /* Determine initiator port (self) from the pkt_address. */ 5931 tran = pkt->pkt_address.a_hba_tran; 5932 ASSERT(tran && tran->tran_tgtmap && tran->tran_iport_dip); 5933 self = tran->tran_iport_dip; 5934 5935 /* 5936 * Determine scsi_devie from pkt_address (depends on 5937 * SCSI_HBA_ADDR_COMPLEX). 5938 */ 5939 sd = scsi_address_device(&(pkt->pkt_address)); 5940 ASSERT(sd); 5941 if (sd == NULL) { 5942 (*pkt->pkt_comp)(pkt); 5943 continue; 5944 } 5945 5946 /* Determine unit-address from scsi_device. */ 5947 ua = scsi_device_unit_address(sd); 5948 5949 /* Extract taddr from the unit-address. */ 5950 for (p = taddr; (*ua != ',') && (*ua != '\0'); ) 5951 *p++ = *ua++; 5952 *p = '\0'; /* NULL terminate taddr */ 5953 5954 /* 5955 * Form path using special "@taddr,*" notation to trigger 5956 * lun enumeration. 5957 */ 5958 (void) ddi_pathname(self, path); 5959 (void) strcat(path, "/luns@"); 5960 (void) strcat(path, taddr); 5961 (void) strcat(path, ",*"); 5962 5963 /* 5964 * Now that we have the path, complete the pkt that 5965 * triggered lunchg1 processing. 5966 */ 5967 (*pkt->pkt_comp)(pkt); 5968 5969 /* Allocate element for stage2 processing queue. */ 5970 lunchg2 = kmem_alloc(sizeof (*lunchg2), KM_SLEEP); 5971 lunchg2->lunchg2_path = strdup(path); 5972 5973 /* Queue and dispatch to stage 2. */ 5974 SCSI_HBA_LOG((_LOG(2), self, NULL, 5975 "lunchg stage1: queue %s", lunchg2->lunchg2_path)); 5976 mutex_enter(&scsi_lunchg2_mutex); 5977 lunchg2->lunchg2_next = scsi_lunchg2_list; 5978 scsi_lunchg2_list = lunchg2; 5979 if (lunchg2->lunchg2_next == NULL) 5980 (void) cv_signal(&scsi_lunchg2_cv); 5981 mutex_exit(&scsi_lunchg2_mutex); 5982 } 5983 } 5984 5985 /*ARGSUSED*/ 5986 static void 5987 scsi_lunchg2_daemon(void *arg) 5988 { 5989 callb_cpr_t cprinfo; 5990 struct scsi_lunchg2 *lunchg2; 5991 ldi_ident_t li; 5992 ldi_handle_t lh; 5993 5994 CALLB_CPR_INIT(&cprinfo, &scsi_lunchg2_mutex, 5995 callb_generic_cpr, "scsi_lunchg2_daemon"); 5996 5997 li = ldi_ident_from_anon(); 5998 mutex_enter(&scsi_lunchg2_mutex); 5999 for (;;) { 6000 lunchg2 = scsi_lunchg2_list; 6001 if (lunchg2 == NULL) { 6002 /* All lunchg2 processing requests serviced, wait. */ 6003 CALLB_CPR_SAFE_BEGIN(&cprinfo); 6004 (void) cv_wait(&scsi_lunchg2_cv, 6005 &scsi_lunchg2_mutex); 6006 CALLB_CPR_SAFE_END(&cprinfo, &scsi_lunchg2_mutex); 6007 continue; 6008 } 6009 6010 /* Unlink and perform lunchg2 processing on pkt. */ 6011 scsi_lunchg2_list = lunchg2->lunchg2_next; 6012 6013 /* 6014 * Open and close the path to trigger lun enumeration. We 6015 * don't expect the open to succeed, but we do expect code in 6016 * scsi_hba_bus_configone() to trigger lun enumeration. 6017 */ 6018 SCSI_HBA_LOG((_LOG(2), NULL, NULL, 6019 "lunchg stage2: open %s", lunchg2->lunchg2_path)); 6020 if (ldi_open_by_name(lunchg2->lunchg2_path, 6021 FREAD, kcred, &lh, li) == 0) 6022 (void) ldi_close(lh, FREAD, kcred); 6023 6024 /* Free path and linked element. */ 6025 strfree(lunchg2->lunchg2_path); 6026 kmem_free(lunchg2, sizeof (*lunchg2)); 6027 } 6028 } 6029 6030 /* 6031 * Enumerate a child at the specified @addr. If a device exists @addr then 6032 * ensure that we have the appropriately named devinfo node for it. Name is 6033 * NULL in the bus_config_all case. This routine has no knowledge of the 6034 * format of an @addr string or associated addressing properties. 6035 * 6036 * The caller must guarantee that there is an open scsi_hba_devi_enter on the 6037 * parent. We return the scsi_device structure for the child device. This 6038 * scsi_device structure is valid until the caller scsi_hba_devi_exit the 6039 * parent. The caller can add do ndi_hold_devi of the child prior to the 6040 * scsi_hba_devi_exit to extend the validity of the child. 6041 * 6042 * In some cases the returned scsi_device structure may be used to drive 6043 * additional SCMD_REPORT_LUNS operations by bus_config_all callers. 6044 * 6045 * The first operation performed is to see if there is a dynamic SID nodes 6046 * already attached at the specified "name@addr". This is the fastpath 6047 * case for resolving a reference to a node that has already been created. 6048 * All other references are serialized for a given @addr prior to probing 6049 * to determine the type of device, if any, at the specified @addr. 6050 * If no device is present then NDI_FAILURE is returned. The fact that a 6051 * device does not exist may be determined via the barrier/probe cache, 6052 * minimizing the probes of non-existent devices. 6053 * 6054 * When there is a device present the dynamic SID node is created based on 6055 * the device found. If a driver.conf node exists for the same @addr it 6056 * will either merge into the dynamic SID node (if the SID node bound to 6057 * that driver), or exist independently. To prevent the actions of one driver 6058 * causing side effects in another, code prevents multiple SID nodes from 6059 * binding to the same "@addr" at the same time. There is autodetach code 6060 * to allow one device to be replaced with another at the same @addr for 6061 * slot addressed SCSI bus implementations (SPI). For compatibility with 6062 * legacy driver.conf behavior, the code does not prevent multiple driver.conf 6063 * nodes from attaching to the same @addr at the same time. 6064 * 6065 * This routine may have the side effect of creating nodes for devices other 6066 * than the one being sought. It is possible that there is a different type of 6067 * target device at that target/lun address than we were asking for. In that 6068 * It is the caller's responsibility to determine whether the device we found, 6069 * if any, at the specified address, is the one it really wanted. 6070 */ 6071 static struct scsi_device * 6072 scsi_device_config(dev_info_t *self, char *name, char *addr, scsi_enum_t se, 6073 int *circp, int *ppi) 6074 { 6075 dev_info_t *child = NULL; 6076 dev_info_t *probe = NULL; 6077 struct scsi_device *sdchild; 6078 struct scsi_device *sdprobe; 6079 dev_info_t *dsearch; 6080 mdi_pathinfo_t *psearch; 6081 major_t major; 6082 int sp; 6083 int pi = 0; 6084 int wait_msg = scsi_hba_wait_msg; 6085 int chg; 6086 6087 ASSERT(self && addr && DEVI_BUSY_OWNED(self)); 6088 6089 SCSI_HBA_LOG((_LOG(4), self, NULL, "%s@%s wanted", 6090 name ? name : "", addr)); 6091 6092 /* playing with "probe" node name is dangerous */ 6093 if (name && (strcmp(name, "probe") == 0)) 6094 return (NULL); 6095 6096 /* 6097 * NOTE: use 'goto done;' or 'goto fail;'. There should only be one 6098 * 'return' statement from here to the end of the function - the one 6099 * on the last line of the function. 6100 */ 6101 6102 /* 6103 * Fastpath: search to see if we are requesting a named SID node that 6104 * already exists (we already created) - probe node does not count. 6105 * scsi_findchild() does not hold the returned devinfo node, but 6106 * this is OK since the caller has a scsi_hba_devi_enter on the 6107 * attached parent HBA (self). The caller is responsible for attaching 6108 * and placing a hold on the child (directly via ndi_hold_devi or 6109 * indirectly via ndi_busop_bus_config) before doing an 6110 * scsi_hba_devi_exit on the parent. 6111 * 6112 * NOTE: This fastpath prevents detecting a driver binding change 6113 * (autodetach) if the same nodename is used for old and new binding. 6114 */ 6115 /* first call is with init set */ 6116 (void) scsi_findchild(self, name, addr, 1, &dsearch, NULL, &pi); 6117 if (dsearch && scsi_hba_dev_is_sid(dsearch) && 6118 !scsi_hba_devi_is_barrier(dsearch)) { 6119 SCSI_HBA_LOG((_LOG(4), NULL, dsearch, 6120 "%s@%s devinfo fastpath", name ? name : "", addr)); 6121 child = dsearch; 6122 goto done; 6123 } 6124 6125 /* 6126 * Create a barrier devinfo node used to "probe" the device with. We 6127 * need to drive this node to DS_INITIALIZED so that the 6128 * DDI_CTLOPS_INITCHILD has occurred, bringing the SCSA transport to 6129 * a state useable state for issuing our "probe" commands. We establish 6130 * this barrier node with a node name of "probe" and compatible 6131 * property of "scsiprobe". The compatible property must be associated 6132 * in /etc/driver_aliases with a scsi target driver available in the 6133 * root file system (sd). 6134 * 6135 * The "probe" that we perform on the barrier node, after it is 6136 * DS_INITIALIZED, is used to find the information needed to create a 6137 * dynamic devinfo (SID) node. This "probe" is separate from the 6138 * probe(9E) call associated with the transition of a node from 6139 * DS_INITIALIZED to DS_PROBED. The probe(9E) call that eventually 6140 * occurs against the created SID node should find ddi_dev_is_sid and 6141 * just return DDI_PROBE_DONTCARE. 6142 * 6143 * Trying to avoid the use of a barrier node is not a good idea 6144 * because we may have an HBA driver that uses generic bus_config 6145 * (this code) but implements its own DDI_CTLOPS_INITCHILD with side 6146 * effects that we can't duplicate (such as the ATA nexus driver). 6147 * 6148 * The probe/barrier node plays an integral part of the locking scheme. 6149 * The objective is to single thread probes of the same device (same 6150 * @addr) while allowing parallelism for probes of different devices 6151 * with the same parent. At this point we are serialized on our self. 6152 * For parallelism we will need to release our self. Prior to release 6153 * we construct a barrier for probes of the same device to serialize 6154 * against. The "probe@addr" node acts as this barrier. An entering 6155 * thread must wait until the probe node does not exist - it can then 6156 * create and link the probe node - dropping the HBA (self) lock after 6157 * the node is linked and visible (after ddi_initchild). A side effect 6158 * of this is that transports should not "go over the wire" (i.e. do 6159 * things that incur significant delays) until after tran_target_init. 6160 * This means that the first "over the wire" operation should occur 6161 * at tran_target_probe time - when things are running in parallel 6162 * again. 6163 * 6164 * If the probe node exists then another probe with the same @addr is 6165 * in progress, we must wait until there is no probe in progress 6166 * before proceeding, and when we proceed we must continue to hold the 6167 * HBA (self) until we have linked a new probe node as a barrier. 6168 * 6169 * When a device is found to *not* exist, its probe/barrier node may be 6170 * marked with DEVICE_REMOVED with node deletion scheduled for some 6171 * future time (seconds). This asynchronous deletion allows the 6172 * framework to detect repeated requests to the same non-existent 6173 * device and avoid overhead associated with contacting a non-existent 6174 * device again and again. 6175 */ 6176 for (;;) { 6177 /* 6178 * Search for probe node - they should only exist as devinfo 6179 * nodes. 6180 */ 6181 (void) scsi_findchild(self, "probe", addr, 6182 0, &probe, &psearch, NULL); 6183 if (probe == NULL) { 6184 if (psearch) 6185 SCSI_HBA_LOG((_LOG(2), self, 6186 mdi_pi_get_client(psearch), 6187 "???? @%s 'probe' search found " 6188 "pathinfo: %p", addr, (void *)psearch)); 6189 break; 6190 } 6191 6192 /* 6193 * The barrier node may cache the non-existence of a device 6194 * by leaving the barrier node in place (with 6195 * DEVI_DEVICE_REMOVED flag set ) for some amount of time after 6196 * the failure of a probe. This flag is used to fail 6197 * additional probes until the barrier probe node is deleted, 6198 * which will occur from a timeout some time after a failed 6199 * probe. The failed probe will use DEVI_SET_DEVICE_REMOVED 6200 * and schedule probe node deletion from a timeout. The callers 6201 * scsi_hba_devi_exit on the way out of the first failure will 6202 * do the cv_broadcast associated with the cv_wait below - this 6203 * handles threads that wait prior to DEVI_DEVICE_REMOVED being 6204 * set. 6205 */ 6206 if (DEVI_IS_DEVICE_REMOVED(probe)) { 6207 SCSI_HBA_LOG((_LOG(3), NULL, probe, 6208 "detected probe DEVICE_REMOVED")); 6209 probe = NULL; /* deletion already scheduled */ 6210 goto fail; 6211 } 6212 6213 /* 6214 * Drop the lock on the HBA (self) and wait until the probe in 6215 * progress has completed. A changes in the sibling list from 6216 * removing the probe node will cause cv_wait to return 6217 * (scsi_hba_devi_exit does the cv_broadcast). 6218 */ 6219 if (wait_msg) { 6220 wait_msg--; 6221 SCSI_HBA_LOG((_LOG(2), NULL, probe, 6222 "exists, probe already in progress: %s", wait_msg ? 6223 "waiting..." : "last msg, but still waiting...")); 6224 } 6225 6226 /* 6227 * NOTE: we could avoid rare case of one second delay by 6228 * implementing scsi_hba_devi_exit_and_wait based on 6229 * ndi/mdi_devi_exit_and_wait (and consider switching devcfg.c 6230 * code to use these ndi/mdi interfaces too). 6231 */ 6232 scsi_hba_devi_exit(self, *circp); 6233 mutex_enter(&DEVI(self)->devi_lock); 6234 (void) cv_timedwait(&DEVI(self)->devi_cv, 6235 &DEVI(self)->devi_lock, 6236 ddi_get_lbolt() + drv_usectohz(MICROSEC)); 6237 mutex_exit(&DEVI(self)->devi_lock); 6238 scsi_hba_devi_enter(self, circp); 6239 } 6240 ASSERT(probe == NULL); 6241 6242 /* 6243 * Search to see if we are requesting a SID node that already exists. 6244 * We hold the HBA (self) and there is not another probe in progress at 6245 * the same @addr. scsi_findchild() does not hold the returned 6246 * devinfo node but this is OK since we hold the HBA (self). 6247 */ 6248 if (name) { 6249 (void) scsi_findchild(self, name, addr, 1, &dsearch, NULL, &pi); 6250 if (dsearch && scsi_hba_dev_is_sid(dsearch)) { 6251 SCSI_HBA_LOG((_LOG(4), NULL, dsearch, 6252 "%s@%s probe devinfo fastpath", 6253 name ? name : "", addr)); 6254 child = dsearch; 6255 goto done; 6256 } 6257 } 6258 6259 /* 6260 * We are looking for a SID node that does not exist or a driver.conf 6261 * node. 6262 * 6263 * To avoid probe side effects, before we probe the device at the 6264 * specified address we need to check to see if there is already an 6265 * initialized child "@addr". 6266 * 6267 * o If we find an initialized SID child and name is NULL or matches 6268 * the name or the name of the attached driver then we return the 6269 * existing node. 6270 * 6271 * o If we find a non-matching SID node, we will attempt to autodetach 6272 * and remove the node in preference to our new node. 6273 * 6274 * o If SID node found does not match and can't be autodetached, we 6275 * fail: we only allow one SID node at an address. 6276 * 6277 * NOTE: This code depends on SID nodes showing up prior to 6278 * driver.conf nodes in the sibling list. 6279 */ 6280 for (;;) { 6281 /* first NULL name call is with init set */ 6282 (void) scsi_findchild(self, NULL, addr, 1, &dsearch, NULL, &pi); 6283 if (dsearch == NULL) 6284 break; 6285 ASSERT(!scsi_hba_devi_is_barrier(dsearch)); 6286 6287 /* 6288 * To detect changes in driver binding that should attempt 6289 * autodetach we determine the major number of the driver 6290 * that should currently be associated with the device based 6291 * on the compatible property. 6292 */ 6293 major = DDI_MAJOR_T_NONE; 6294 if (scsi_hba_dev_is_sid(dsearch)) 6295 major = ddi_compatible_driver_major(dsearch, NULL); 6296 if ((major == DDI_MAJOR_T_NONE) && (name == NULL)) 6297 major = ddi_driver_major(dsearch); 6298 6299 if ((scsi_hba_dev_is_sid(dsearch) || 6300 (i_ddi_node_state(dsearch) >= DS_INITIALIZED)) && 6301 ((name == NULL) || 6302 (strcmp(ddi_node_name(dsearch), name) == 0) || 6303 (strcmp(ddi_driver_name(dsearch), name) == 0)) && 6304 (major == ddi_driver_major(dsearch))) { 6305 SCSI_HBA_LOG((_LOG(3), NULL, dsearch, 6306 "already attached @addr")); 6307 child = dsearch; 6308 goto done; 6309 } 6310 6311 if (!scsi_hba_dev_is_sid(dsearch)) 6312 break; /* driver.conf node */ 6313 6314 /* 6315 * Implement autodetach of SID node for situations like a 6316 * previously "scsinodev" LUN0 coming into existence (or a 6317 * disk/tape on an SPI transport at same addr but never both 6318 * powered on at the same time). Try to autodetach the existing 6319 * SID node @addr. If that works, search again - otherwise fail. 6320 */ 6321 SCSI_HBA_LOG((_LOG(2), NULL, dsearch, 6322 "looking for %s@%s: SID @addr exists, autodetach", 6323 name ? name : "", addr)); 6324 if (!scsi_hba_remove_node(dsearch)) { 6325 SCSI_HBA_LOG((_LOG(2), NULL, dsearch, 6326 "autodetach @%s failed: fail %s@%s", 6327 addr, name ? name : "", addr)); 6328 goto fail; 6329 } 6330 SCSI_HBA_LOG((_LOG(2), self, NULL, "autodetach @%s OK", addr)); 6331 } 6332 6333 /* 6334 * We will be creating a new SID node, allocate probe node 6335 * used to find out information about the device located @addr. 6336 * The probe node also acts as a barrier against additional 6337 * configuration at the same address, and in the case of non-existent 6338 * devices it will (for some amount of time) avoid re-learning that 6339 * the device does not exist on every reference. Once the probe 6340 * node is DS_LINKED we can drop the HBA (self). 6341 * 6342 * The probe node is allocated as a hidden node so that it does not 6343 * show up in devinfo snapshots. 6344 */ 6345 ndi_devi_alloc_sleep(self, "probe", 6346 (se == SE_HP) ? DEVI_SID_HP_HIDDEN_NODEID : DEVI_SID_HIDDEN_NODEID, 6347 &probe); 6348 ASSERT(probe); 6349 ndi_flavor_set(probe, SCSA_FLAVOR_SCSI_DEVICE); 6350 6351 /* 6352 * Decorate the probe node with the property representation of @addr 6353 * unit-address string prior to initchild so that initchild can 6354 * construct the name of the node from properties and tran_tgt_init 6355 * implementation can determine what LUN is being referenced. 6356 * 6357 * If the addr specified has incorrect syntax (busconfig one of bogus 6358 * /devices path) then scsi_hba_ua_set can fail. If the address 6359 * is not understood by the SCSA HBA driver then this operation will 6360 * work, but tran_tgt_init may still fail (for example the HBA 6361 * driver may not support secondary functions). 6362 */ 6363 if (scsi_hba_ua_set(addr, probe, NULL) == 0) { 6364 SCSI_HBA_LOG((_LOG(2), NULL, probe, 6365 "@%s failed scsi_hba_ua_set", addr)); 6366 goto fail; 6367 } 6368 6369 /* 6370 * Set the class property to "scsi". This is sufficient to distinguish 6371 * the node for HBAs that have multiple classes of children (like uata 6372 * - which has "dada" class for ATA children and "scsi" class for 6373 * ATAPI children) and may not use our scsi_busctl_initchild() 6374 * implementation. We also add a "compatible" property of "scsiprobe" 6375 * to select the probe driver. 6376 */ 6377 if ((ndi_prop_update_string(DDI_DEV_T_NONE, probe, 6378 "class", "scsi") != DDI_PROP_SUCCESS) || 6379 (ndi_prop_update_string_array(DDI_DEV_T_NONE, probe, 6380 "compatible", &compatible_probe, 1) != DDI_PROP_SUCCESS)) { 6381 SCSI_HBA_LOG((_LOG(1), NULL, probe, 6382 "@%s failed node decoration", addr)); 6383 goto fail; 6384 } 6385 6386 /* 6387 * Promote probe node to DS_INITIALIZED so that transport can be used 6388 * for scsi_probe. After this the node is linked and visible as a 6389 * barrier for serialization of other @addr operations. 6390 * 6391 * NOTE: If we attached the probe node, we could get rid of 6392 * uninit_prevent. 6393 */ 6394 if (ddi_initchild(self, probe) != DDI_SUCCESS) { 6395 SCSI_HBA_LOG((_LOG(2), NULL, probe, 6396 "@%s failed initchild", addr)); 6397 6398 /* probe node will be removed in fail exit path */ 6399 goto fail; 6400 } 6401 6402 /* get the scsi_device structure of the probe node */ 6403 sdprobe = ddi_get_driver_private(probe); 6404 ASSERT(sdprobe); 6405 6406 /* 6407 * Do scsi_probe. The probe node is linked and visible as a barrier. 6408 * We prevent uninitialization of the probe node and drop our HBA (self) 6409 * while we run scsi_probe() of this "@addr". This allows the framework 6410 * to support multiple scsi_probes for different devices attached to 6411 * the same HBA (self) in parallel. We prevent node demotion of the 6412 * probe node from DS_INITIALIZED by setting sd_uninit_prevent. The 6413 * probe node can not be successfully demoted below DS_INITIALIZED 6414 * (scsi_busctl_uninitchild will fail) until we zero sd_uninit_prevent 6415 * as we are freeing the node via scsi_hba_remove_node(probe). 6416 */ 6417 sdprobe->sd_uninit_prevent++; 6418 scsi_hba_devi_exit(self, *circp); 6419 sp = scsi_probe(sdprobe, SLEEP_FUNC); 6420 6421 /* Introduce a small delay here to increase parallelism. */ 6422 delay_random(5); 6423 6424 if (sp == SCSIPROBE_EXISTS) { 6425 /* 6426 * For a device that exists, while still running in parallel, 6427 * also get identity information from device. This is done 6428 * separate from scsi_probe/tran_tgt_probe/scsi_hba_probe 6429 * since the probe code path may still be used for HBAs 6430 * that don't use common bus_config services (we don't want 6431 * to expose that code path to a behavior change). This 6432 * operation is called 'identity' to avoid confusion with 6433 * deprecated identify(9E). 6434 * 6435 * Future: We may eventually want to allow HBA customization via 6436 * scsi_identity/tran_tgt_identity/scsi_device_identity, but for 6437 * now we just scsi_device_identity. 6438 * 6439 * The identity operation will establish additional properties 6440 * on the probe node related to device identity: 6441 * 6442 * "inquiry-page-80" byte array of SCSI page 80 6443 * "inquiry-page-83" byte array of SCSI page 83 6444 * 6445 * These properties will be used to generate a devid 6446 * (ddi_devid_scsi_encode) and guid - and to register 6447 * (ddi_devid_register) a devid for the device. 6448 * 6449 * If identify fails (non-zero return), the we had allocation 6450 * problems or the device returned inconsistent results then 6451 * we pretend that device does not exist. 6452 */ 6453 if (scsi_device_identity(sdprobe, SLEEP_FUNC)) { 6454 scsi_enumeration_failed(probe, -1, NULL, "identify"); 6455 sp = SCSIPROBE_FAILURE; 6456 } 6457 6458 /* 6459 * Future: Is there anything more we can do here to help avoid 6460 * serialization on iport parent during scsi_device attach(9E)? 6461 */ 6462 } 6463 scsi_hba_devi_enter(self, circp); 6464 sdprobe->sd_uninit_prevent--; 6465 6466 if (sp != SCSIPROBE_EXISTS) { 6467 scsi_enumeration_failed(probe, -1, NULL, "probe"); 6468 6469 if ((se != SE_HP) && scsi_hba_barrier_timeout) { 6470 /* 6471 * Target does not exist. Mark the barrier probe node 6472 * as DEVICE_REMOVED and schedule an asynchronous 6473 * deletion of the node in scsi_hba_barrier_timeout 6474 * seconds. We keep our hold on the probe node 6475 * until we are ready perform the asynchronous node 6476 * deletion. 6477 */ 6478 SCSI_HBA_LOG((_LOG(3), NULL, probe, 6479 "set probe DEVICE_REMOVED")); 6480 mutex_enter(&DEVI(probe)->devi_lock); 6481 DEVI_SET_DEVICE_REMOVED(probe); 6482 mutex_exit(&DEVI(probe)->devi_lock); 6483 6484 scsi_hba_barrier_add(probe, scsi_hba_barrier_timeout); 6485 probe = NULL; 6486 } 6487 goto fail; 6488 } 6489 6490 /* Create the child node from the inquiry data in the probe node. */ 6491 if ((child = scsi_device_configchild(self, addr, se, sdprobe, 6492 circp, &pi)) == NULL) { 6493 /* 6494 * This may fail because there was no driver binding identified 6495 * via driver_alias. We may still have a conf node. 6496 */ 6497 if (name) { 6498 (void) scsi_findchild(self, name, addr, 6499 0, &child, NULL, &pi); 6500 if (child) 6501 SCSI_HBA_LOG((_LOG(2), NULL, child, 6502 "using driver.conf driver binding")); 6503 } 6504 if (child == NULL) { 6505 SCSI_HBA_LOG((_LOG(2), NULL, probe, 6506 "device not configured")); 6507 goto fail; 6508 } 6509 } 6510 6511 /* 6512 * Transfer the inquiry data from the probe node to the child 6513 * SID node to avoid an extra scsi_probe. Callers depend on 6514 * established inquiry data for the returned scsi_device. 6515 */ 6516 sdchild = ddi_get_driver_private(child); 6517 if (sdchild && (sdchild->sd_inq == NULL)) { 6518 sdchild->sd_inq = sdprobe->sd_inq; 6519 sdprobe->sd_inq = NULL; 6520 } 6521 6522 /* 6523 * If we are doing a bus_configone and the node we created has the 6524 * wrong node and driver name then switch the return result to a 6525 * driver.conf node with the correct name - if such a node exists. 6526 */ 6527 if (name && (strcmp(ddi_node_name(child), name) != 0) && 6528 (strcmp(ddi_driver_name(child), name) != 0)) { 6529 (void) scsi_findchild(self, name, addr, 6530 0, &dsearch, NULL, &pi); 6531 if (dsearch == NULL) { 6532 SCSI_HBA_LOG((_LOG(2), NULL, child, 6533 "wrong device configured %s@%s", name, addr)); 6534 /* 6535 * We can't remove when modrootloaded == 0 in case 6536 * boot-device a uses generic name and 6537 * scsi_hba_nodename_compatible_get() returned a 6538 * legacy binding-set driver oriented name. 6539 */ 6540 if (modrootloaded) { 6541 (void) scsi_hba_remove_node(child); 6542 child = NULL; 6543 goto fail; 6544 } 6545 } else { 6546 SCSI_HBA_LOG((_LOG(2), NULL, dsearch, 6547 "device configured, but switching to driver.conf")); 6548 child = dsearch; 6549 } 6550 } 6551 6552 /* get the scsi_device structure from the node */ 6553 SCSI_HBA_LOG((_LOG(3), NULL, child, "device configured")); 6554 6555 if (child) { 6556 done: ASSERT(child); 6557 sdchild = ddi_get_driver_private(child); 6558 ASSERT(sdchild); 6559 6560 /* 6561 * We may have ended up here after promotion of a previously 6562 * demoted node, where demotion deleted sd_inq data in 6563 * scsi_busctl_uninitchild. We redo the scsi_probe() to 6564 * reestablish sd_inq. We also want to redo the scsi_probe 6565 * for devices are currently device_isremove in order to 6566 * detect new device_insert. 6567 */ 6568 if ((sdchild->sd_inq == NULL) || 6569 ((pi == NULL) && ndi_devi_device_isremoved(child))) { 6570 6571 /* hotplug_node can only be revived via hotplug. */ 6572 if ((se == SE_HP) || !ndi_dev_is_hotplug_node(child)) { 6573 SCSI_HBA_LOG((_LOG(3), NULL, child, 6574 "scsi_probe() demoted devinfo")); 6575 6576 sp = scsi_probe(sdchild, SLEEP_FUNC); 6577 6578 if (sp == SCSIPROBE_EXISTS) { 6579 ASSERT(sdchild->sd_inq); 6580 6581 /* 6582 * Devinfo child exists and we are 6583 * talking to the device, report 6584 * reinsert and note if this was a 6585 * new reinsert. 6586 */ 6587 chg = ndi_devi_device_insert(child); 6588 SCSI_HBA_LOG((_LOGCFG, NULL, child, 6589 "devinfo %s@%s device_reinsert%s", 6590 name ? name : "", addr, 6591 chg ? "" : "ed already")); 6592 } else { 6593 scsi_enumeration_failed(child, se, 6594 NULL, "reprobe"); 6595 6596 chg = ndi_devi_device_remove(child); 6597 SCSI_HBA_LOG((_LOG(2), NULL, child, 6598 "%s device_remove%s", 6599 (sp > (sizeof (scsi_probe_ascii) / 6600 sizeof (scsi_probe_ascii[0]))) ? 6601 "UNKNOWN" : scsi_probe_ascii[sp], 6602 chg ? "" : "ed already")); 6603 6604 child = NULL; 6605 sdchild = NULL; 6606 } 6607 } else { 6608 SCSI_HBA_LOG((_LOG(2), NULL, child, 6609 "no reprobe")); 6610 6611 child = NULL; 6612 sdchild = NULL; 6613 } 6614 } 6615 } else { 6616 fail: ASSERT(child == NULL); 6617 sdchild = NULL; 6618 } 6619 if (probe) { 6620 /* 6621 * Clean up probe node, destroying node if uninit_prevent 6622 * it is going to zero. Destroying the probe node (deleting 6623 * from the sibling list) will wake up any people waiting on 6624 * the probe node barrier. 6625 */ 6626 SCSI_HBA_LOG((_LOG(4), NULL, probe, "remove probe")); 6627 if (!scsi_hba_remove_node(probe)) { 6628 /* 6629 * Probe node removal should not fail, but if it 6630 * does we hand that responsibility over to the 6631 * async barrier deletion thread - other references 6632 * to the same unit-address can hang until the 6633 * probe node delete completes. 6634 */ 6635 SCSI_HBA_LOG((_LOG(4), NULL, probe, 6636 "remove probe failed, go async")); 6637 scsi_hba_barrier_add(probe, 1); 6638 } 6639 probe = NULL; 6640 } 6641 6642 /* 6643 * If we successfully resolved via a pathinfo node, we need to find 6644 * the pathinfo node and ensure that it is online (if possible). This 6645 * is done for the case where the device was open when 6646 * scsi_device_unconfig occurred, so mdi_pi_free did not occur. If the 6647 * device has now been reinserted, we want the path back online. 6648 * NOTE: This needs to occur after destruction of the probe node to 6649 * avoid ASSERT related to two nodes at the same unit-address. 6650 */ 6651 if (sdchild && pi && (probe == NULL)) { 6652 ASSERT(MDI_PHCI(self)); 6653 6654 (void) scsi_findchild(self, NULL, addr, 6655 0, &dsearch, &psearch, NULL); 6656 ASSERT((psearch == NULL) || 6657 (mdi_pi_get_client(psearch) == child)); 6658 6659 if (psearch && mdi_pi_device_isremoved(psearch)) { 6660 /* 6661 * Verify that we can talk to the device, and if 6662 * so note if this is a new device_insert. 6663 * 6664 * NOTE: We depend on mdi_path_select(), when given 6665 * a specific path_instance, to select that path 6666 * even if the path is offline. 6667 * 6668 * NOTE: A Client node is not ndi_dev_is_hotplug_node(). 6669 */ 6670 if (se == SE_HP) { 6671 SCSI_HBA_LOG((_LOG(3), NULL, child, 6672 "%s scsi_probe() demoted pathinfo", 6673 mdi_pi_spathname(psearch))); 6674 6675 sp = scsi_hba_probe_pi(sdchild, SLEEP_FUNC, pi); 6676 6677 if (sp == SCSIPROBE_EXISTS) { 6678 /* 6679 * Pathinfo child exists and we are 6680 * talking to the device, report 6681 * reinsert and note if this 6682 * was a new reinsert. 6683 */ 6684 chg = mdi_pi_device_insert(psearch); 6685 SCSI_HBA_LOG((_LOGCFG, self, NULL, 6686 "pathinfo %s device_reinsert%s", 6687 mdi_pi_spathname(psearch), 6688 chg ? "" : "ed already")); 6689 6690 if (chg) 6691 (void) mdi_pi_online(psearch, 6692 0); 6693 6694 /* 6695 * Report client reinsert and note if 6696 * this was a new reinsert. 6697 */ 6698 chg = ndi_devi_device_insert(child); 6699 SCSI_HBA_LOG((_LOGCFG, NULL, child, 6700 "client devinfo %s@%s " 6701 "device_reinsert%s", 6702 name ? name : "", addr, 6703 chg ? "" : "ed already")); 6704 } else { 6705 scsi_enumeration_failed(child, se, 6706 mdi_pi_spathname(psearch), 6707 "reprobe"); 6708 child = NULL; 6709 sdchild = NULL; 6710 } 6711 6712 } else { 6713 SCSI_HBA_LOG((_LOG(2), NULL, child, 6714 "%s no reprobe", 6715 mdi_pi_spathname(psearch))); 6716 6717 child = NULL; 6718 sdchild = NULL; 6719 } 6720 } 6721 } 6722 6723 /* If asked for path_instance, return it. */ 6724 if (ppi) 6725 *ppi = pi; 6726 6727 return (sdchild); 6728 } 6729 6730 static void 6731 scsi_device_unconfig(dev_info_t *self, char *name, char *addr, int *circp) 6732 { 6733 dev_info_t *child = NULL; 6734 mdi_pathinfo_t *path = NULL; 6735 char *spathname; 6736 int rval; 6737 6738 ASSERT(self && addr && DEVI_BUSY_OWNED(self)); 6739 6740 /* 6741 * We have a catch-22. We may have a demoted node that we need to find 6742 * and offline/remove. To find the node if it isn't demoted, we 6743 * use scsi_findchild. If it's demoted, we then use 6744 * ndi_devi_findchild_by_callback. 6745 */ 6746 (void) scsi_findchild(self, name, addr, 0, &child, &path, NULL); 6747 6748 if ((child == NULL) && (path == NULL)) { 6749 child = ndi_devi_findchild_by_callback(self, name, addr, 6750 scsi_busctl_ua); 6751 if (child) { 6752 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6753 "devinfo %s@%s found by callback", 6754 name ? name : "", addr)); 6755 ASSERT(ndi_flavor_get(child) == 6756 SCSA_FLAVOR_SCSI_DEVICE); 6757 if (ndi_flavor_get(child) != SCSA_FLAVOR_SCSI_DEVICE) { 6758 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6759 "devinfo %s@%s not SCSI_DEVICE flavored", 6760 name ? name : "", addr)); 6761 child = NULL; 6762 } 6763 } 6764 } 6765 6766 if (child) { 6767 ASSERT(child && (path == NULL)); 6768 6769 /* Don't unconfig probe nodes. */ 6770 if (scsi_hba_devi_is_barrier(child)) { 6771 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6772 "devinfo %s@%s is_barrier, skip", 6773 name ? name : "", addr)); 6774 return; 6775 } 6776 6777 /* Attempt to offline/remove the devinfo node */ 6778 if (ndi_devi_offline(child, 6779 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) { 6780 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6781 "devinfo %s@%s offlined and removed", 6782 name ? name : "", addr)); 6783 } else if (ndi_devi_device_remove(child)) { 6784 /* Offline/remove failed, note new device_remove */ 6785 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6786 "devinfo %s@%s offline failed, device_remove", 6787 name ? name : "", addr)); 6788 } 6789 } else if (path) { 6790 ASSERT(path && (child == NULL)); 6791 6792 /* 6793 * Attempt to offline/remove the pathinfo node. 6794 * 6795 * NOTE: mdi_pi_offline of last path will fail if the 6796 * device is open (i.e. the client can't be offlined). 6797 * 6798 * NOTE: For mdi there is no REMOVE flag for mdi_pi_offline(). 6799 * When mdi_pi_offline returns MDI_SUCCESS, we are responsible 6800 * for remove via mdi_pi_free(). 6801 */ 6802 mdi_hold_path(path); 6803 spathname = mdi_pi_spathname(path); /* valid after free */ 6804 scsi_hba_devi_exit_phci(self, *circp); 6805 rval = mdi_pi_offline(path, 0); 6806 scsi_hba_devi_enter_phci(self, circp); 6807 6808 /* Note new device_remove */ 6809 if (mdi_pi_device_remove(path)) 6810 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6811 "pathinfo %s note device_remove", spathname)); 6812 6813 mdi_rele_path(path); 6814 if (rval == MDI_SUCCESS) { 6815 (void) mdi_pi_free(path, 0); 6816 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6817 "pathinfo %s offlined, then freed", spathname)); 6818 } 6819 } else { 6820 ASSERT((path == NULL) && (child == NULL)); 6821 6822 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 6823 "%s@%s not found", name ? name : "", addr)); 6824 } 6825 } 6826 6827 /* 6828 * configure the device at the specified "@addr" address. 6829 */ 6830 static struct scsi_device * 6831 scsi_hba_bus_configone_addr(dev_info_t *self, char *addr, scsi_enum_t se) 6832 { 6833 int circ; 6834 struct scsi_device *sd; 6835 6836 scsi_hba_devi_enter(self, &circ); 6837 sd = scsi_device_config(self, NULL, addr, se, &circ, NULL); 6838 scsi_hba_devi_exit(self, circ); 6839 return (sd); 6840 } 6841 6842 /* 6843 * unconfigure the device at the specified "@addr" address. 6844 */ 6845 static void 6846 scsi_hba_bus_unconfigone_addr(dev_info_t *self, char *addr) 6847 { 6848 int circ; 6849 6850 scsi_hba_devi_enter(self, &circ); 6851 (void) scsi_device_unconfig(self, NULL, addr, &circ); 6852 scsi_hba_devi_exit(self, circ); 6853 } 6854 6855 /* 6856 * The bus_config_all operations are multi-threaded for performance. A 6857 * separate thread per target and per LUN is used. The config handle is used 6858 * to coordinate all the threads at a given level and the config thread data 6859 * contains the required information for a specific thread to identify what it 6860 * is processing and the handle under which this is being processed. 6861 */ 6862 6863 /* multi-threaded config handle */ 6864 struct scsi_hba_mte_h { 6865 dev_info_t *h_self; /* initiator port */ 6866 int h_thr_count; 6867 kmutex_t h_lock; 6868 kcondvar_t h_cv; 6869 }; 6870 6871 /* target of 'self' config thread data */ 6872 struct scsi_hba_mte_td { 6873 struct scsi_hba_mte_h *td_h; 6874 char *td_taddr; /* target port */ 6875 int td_mt; 6876 scsi_enum_t td_se; 6877 }; 6878 6879 /* Invoke callback on a vector of taddrs from multiple threads */ 6880 static void 6881 scsi_hba_thread_taddrs(dev_info_t *self, char **taddrs, int mt, 6882 scsi_enum_t se, void (*callback)(void *arg)) 6883 { 6884 struct scsi_hba_mte_h *h; /* HBA header */ 6885 struct scsi_hba_mte_td *td; /* target data */ 6886 char **taddr; 6887 6888 /* allocate and initialize the handle */ 6889 h = kmem_zalloc(sizeof (*h), KM_SLEEP); 6890 mutex_init(&h->h_lock, NULL, MUTEX_DEFAULT, NULL); 6891 cv_init(&h->h_cv, NULL, CV_DEFAULT, NULL); 6892 h->h_self = self; 6893 6894 /* loop over all the targets */ 6895 for (taddr = taddrs; *taddr; taddr++) { 6896 /* allocate a thread data structure for target */ 6897 td = kmem_alloc(sizeof (*td), KM_SLEEP); 6898 td->td_h = h; 6899 td->td_taddr = *taddr; 6900 td->td_mt = mt; 6901 td->td_se = se; 6902 6903 /* process the target */ 6904 mutex_enter(&h->h_lock); 6905 h->h_thr_count++; 6906 mutex_exit(&h->h_lock); 6907 6908 if (mt & SCSI_ENUMERATION_MT_TARGET_DISABLE) 6909 callback((void *)td); 6910 else 6911 (void) thread_create(NULL, 0, callback, (void *)td, 6912 0, &p0, TS_RUN, minclsyspri); 6913 } 6914 6915 /* wait for all the target threads to complete */ 6916 mutex_enter(&h->h_lock); 6917 while (h->h_thr_count > 0) 6918 cv_wait(&h->h_cv, &h->h_lock); 6919 mutex_exit(&h->h_lock); 6920 6921 /* free the handle */ 6922 cv_destroy(&h->h_cv); 6923 mutex_destroy(&h->h_lock); 6924 kmem_free(h, sizeof (*h)); 6925 } 6926 6927 6928 /* lun/secondary function of lun0 config thread data */ 6929 struct scsi_hba_mte_ld { 6930 struct scsi_hba_mte_h *ld_h; 6931 char *ld_taddr; /* target port */ 6932 scsi_lun64_t ld_lun64; /* lun */ 6933 int ld_sfunc; /* secondary function */ 6934 scsi_enum_t ld_se; 6935 }; 6936 6937 /* 6938 * Enumerate the LUNs and secondary functions of the specified target. The 6939 * target portion of the "@addr" is already represented as a string in the 6940 * thread data, we add a ",lun" representation to this and perform a 6941 * bus_configone byte of enumeration on that "@addr". 6942 */ 6943 static void 6944 scsi_hba_enum_lsf_of_tgt_thr(void *arg) 6945 { 6946 struct scsi_hba_mte_ld *ld = (struct scsi_hba_mte_ld *)arg; 6947 struct scsi_hba_mte_h *h = ld->ld_h; 6948 dev_info_t *self = h->h_self; 6949 char addr[SCSI_MAXNAMELEN]; 6950 6951 /* make string form of "@taddr,lun[,sfunc]" and see if it exists */ 6952 if (ld->ld_sfunc == -1) 6953 (void) snprintf(addr, sizeof (addr), 6954 "%s,%" PRIx64, ld->ld_taddr, ld->ld_lun64); 6955 else 6956 (void) snprintf(addr, sizeof (addr), 6957 "%s,%" PRIx64 ",%x", 6958 ld->ld_taddr, ld->ld_lun64, ld->ld_sfunc); 6959 6960 /* configure device at that unit-address address */ 6961 (void) scsi_hba_bus_configone_addr(self, addr, ld->ld_se); 6962 6963 /* signal completion of this LUN thread to the target */ 6964 mutex_enter(&h->h_lock); 6965 if (--h->h_thr_count == 0) 6966 cv_broadcast(&h->h_cv); 6967 mutex_exit(&h->h_lock); 6968 6969 /* free config thread data */ 6970 kmem_free(ld, sizeof (*ld)); 6971 } 6972 6973 /* Format of SCSI REPORT_LUNS report */ 6974 typedef struct scsi_lunrpt { 6975 uchar_t lunrpt_len_msb; /* # LUNs being reported */ 6976 uchar_t lunrpt_len_mmsb; 6977 uchar_t lunrpt_len_mlsb; 6978 uchar_t lunrpt_len_lsb; 6979 uchar_t lunrpt_reserved[4]; 6980 scsi_lun_t lunrpt_luns[1]; /* LUNs, variable size */ 6981 } scsi_lunrpt_t; 6982 6983 /* 6984 * scsi_device_reportluns() 6985 * 6986 * Callers of this routine should ensure that the 'sd0' scsi_device structure 6987 * and 'pi' path_instance specified are associated with a responding LUN0. 6988 * This should not be called for SCSI-1 devices. 6989 * 6990 * To get a LUN report, we must allocate a buffer. To know how big to make the 6991 * buffer, we must know the number of LUNs. To know the number of LUNs, we must 6992 * get a LUN report. We first issue a SCMD_REPORT_LUNS command using a 6993 * reasonably sized buffer that's big enough to report all LUNs for most 6994 * typical devices. If it turns out that we needed a bigger buffer, we attempt 6995 * to allocate a buffer of sufficient size, and reissue the command. If the 6996 * first command succeeds, but the second fails, we return whatever we were 6997 * able to get the first time. We return enough information for the caller to 6998 * tell whether he got all the LUNs or only a subset. 6999 * 7000 * If successful, we allocate an array of scsi_lun_t to hold the results. The 7001 * caller must kmem_free(*lunarrayp, *sizep) when finished with it. Upon 7002 * successful return return value is NDI_SUCCESS and: 7003 * 7004 * *lunarrayp points to the allocated array, 7005 * *nlunsp is the number of valid LUN entries in the array, 7006 * *tlunsp is the total number of LUNs in the target, 7007 * *sizep is the size of the lunarrayp array, which must be freed. 7008 * 7009 * If the *nlunsp is less than *tlunsp, then we were only able to retrieve a 7010 * subset of the total set of LUNs in the target. 7011 */ 7012 static int 7013 scsi_device_reportluns(struct scsi_device *sd0, char *taddr, int pi, 7014 scsi_lun_t **lunarrayp, uint32_t *nlunsp, uint32_t *tlunsp, size_t *sizep) 7015 { 7016 struct buf *lunrpt_bp; 7017 struct scsi_pkt *lunrpt_pkt; 7018 scsi_lunrpt_t *lunrpt; 7019 uint32_t bsize; 7020 uint32_t tluns, nluns; 7021 int default_maxluns = scsi_lunrpt_default_max; 7022 dev_info_t *child; 7023 7024 ASSERT(sd0 && lunarrayp && nlunsp && tlunsp && sizep); 7025 7026 /* 7027 * NOTE: child should only be used in SCSI_HBA_LOG context since with 7028 * vHCI enumeration it may be the vHCI 'client' devinfo child instead 7029 * of a child of the 'self' pHCI we are enumerating. 7030 */ 7031 child = sd0->sd_dev; 7032 7033 /* first try, look for up to scsi_lunrpt_default_max LUNs */ 7034 nluns = default_maxluns; 7035 7036 again: bsize = sizeof (struct scsi_lunrpt) + 7037 ((nluns - 1) * sizeof (struct scsi_lun)); 7038 7039 lunrpt_bp = scsi_alloc_consistent_buf(&sd0->sd_address, 7040 (struct buf *)NULL, bsize, B_READ, SLEEP_FUNC, NULL); 7041 if (lunrpt_bp == NULL) { 7042 SCSI_HBA_LOG((_LOG(1), NULL, child, "failed alloc")); 7043 return (NDI_NOMEM); 7044 } 7045 7046 lunrpt_pkt = scsi_init_pkt(&sd0->sd_address, 7047 (struct scsi_pkt *)NULL, lunrpt_bp, CDB_GROUP5, 7048 sizeof (struct scsi_arq_status), 0, PKT_CONSISTENT, 7049 SLEEP_FUNC, NULL); 7050 if (lunrpt_pkt == NULL) { 7051 SCSI_HBA_LOG((_LOG(1), NULL, child, "failed init")); 7052 scsi_free_consistent_buf(lunrpt_bp); 7053 return (NDI_NOMEM); 7054 } 7055 7056 (void) scsi_setup_cdb((union scsi_cdb *)lunrpt_pkt->pkt_cdbp, 7057 SCMD_REPORT_LUNS, 0, bsize, 0); 7058 7059 lunrpt_pkt->pkt_time = scsi_lunrpt_timeout; 7060 7061 /* 7062 * When sd0 is a vHCI scsi device, we need reportlun to be issued 7063 * against a specific LUN0 path_instance that we are enumerating. 7064 */ 7065 lunrpt_pkt->pkt_path_instance = pi; 7066 lunrpt_pkt->pkt_flags |= FLAG_PKT_PATH_INSTANCE; 7067 7068 /* 7069 * NOTE: scsi_poll may not allow HBA specific recovery from TRAN_BUSY. 7070 */ 7071 if (scsi_poll(lunrpt_pkt) < 0) { 7072 SCSI_HBA_LOG((_LOG(2), NULL, child, "reportlun not supported")); 7073 scsi_destroy_pkt(lunrpt_pkt); 7074 scsi_free_consistent_buf(lunrpt_bp); 7075 return (NDI_FAILURE); 7076 } 7077 7078 scsi_destroy_pkt(lunrpt_pkt); 7079 7080 lunrpt = (scsi_lunrpt_t *)lunrpt_bp->b_un.b_addr; 7081 7082 /* Compute the total number of LUNs in the target */ 7083 tluns = (((uint_t)lunrpt->lunrpt_len_msb << 24) | 7084 ((uint_t)lunrpt->lunrpt_len_mmsb << 16) | 7085 ((uint_t)lunrpt->lunrpt_len_mlsb << 8) | 7086 ((uint_t)lunrpt->lunrpt_len_lsb)) >> 3; 7087 7088 if (tluns == 0) { 7089 /* Illegal response -- this target is broken */ 7090 SCSI_HBA_LOG((_LOG(1), NULL, child, "illegal tluns of zero")); 7091 scsi_free_consistent_buf(lunrpt_bp); 7092 return (DDI_NOT_WELL_FORMED); 7093 } 7094 7095 if (tluns > nluns) { 7096 /* have more than we allocated space for */ 7097 if (nluns == default_maxluns) { 7098 /* first time around, reallocate larger */ 7099 scsi_free_consistent_buf(lunrpt_bp); 7100 nluns = tluns; 7101 goto again; 7102 } 7103 7104 /* uh oh, we got a different tluns the second time! */ 7105 SCSI_HBA_LOG((_LOG(1), NULL, child, 7106 "tluns changed from %d to %d", nluns, tluns)); 7107 } else 7108 nluns = tluns; 7109 7110 /* 7111 * Now we have: 7112 * lunrpt_bp is the buffer we're using; 7113 * tluns is the total number of LUNs the target says it has; 7114 * nluns is the number of LUNs we were able to get into the buffer. 7115 * 7116 * Copy the data out of scarce iopb memory into regular kmem. 7117 * The caller must kmem_free(*lunarrayp, *sizep) when finished with it. 7118 */ 7119 *lunarrayp = (scsi_lun_t *)kmem_alloc( 7120 nluns * sizeof (scsi_lun_t), KM_SLEEP); 7121 if (*lunarrayp == NULL) { 7122 SCSI_HBA_LOG((_LOG(1), NULL, child, "NULL lunarray")); 7123 scsi_free_consistent_buf(lunrpt_bp); 7124 return (NDI_NOMEM); 7125 } 7126 7127 *sizep = nluns * sizeof (scsi_lun_t); 7128 *nlunsp = nluns; 7129 *tlunsp = tluns; 7130 bcopy((void *)&lunrpt->lunrpt_luns, (void *)*lunarrayp, *sizep); 7131 scsi_free_consistent_buf(lunrpt_bp); 7132 SCSI_HBA_LOG((_LOG(3), NULL, child, 7133 "@%s,0 path %d: %d/%d luns", taddr, pi, nluns, tluns)); 7134 return (NDI_SUCCESS); 7135 } 7136 7137 /* 7138 * Enumerate all the LUNs and secondary functions of the specified 'taddr' 7139 * target port as accessed via 'self' pHCI. Note that sd0 may be associated 7140 * with a child of the vHCI instead of 'self' - in this case the 'pi' 7141 * path_instance is used to ensure that the SCMD_REPORT_LUNS command is issued 7142 * through the 'self' pHCI path. 7143 * 7144 * We multi-thread across all the LUNs and secondary functions and enumerate 7145 * them. Which LUNs exist is based on SCMD_REPORT_LUNS data. 7146 * 7147 * The scsi_device we are called with should be for LUN0 and has been probed. 7148 * 7149 * This function is structured so that an HBA that has a different target 7150 * addressing structure can still use this function to enumerate the its 7151 * LUNs if it uses "taddr,lun" for its LUN space. 7152 * 7153 * We make assumptions about other LUNs associated with the target: 7154 * 7155 * For SCSI-2 and SCSI-3 target we will issue the SCSI report_luns 7156 * command. If this fails or we have a SCSI-1 then the number of 7157 * LUNs is determined based on SCSI_OPTIONS_NLUNS. For a SCSI-1 7158 * target we never probe above LUN 8, even if SCSI_OPTIONS_NLUNS 7159 * indicates we should. 7160 * 7161 * HBA drivers wanting a different set of assumptions should implement their 7162 * own LUN enumeration code. 7163 */ 7164 static int 7165 scsi_hba_enum_lsf_of_t(struct scsi_device *sd0, 7166 dev_info_t *self, char *taddr, int pi, int mt, scsi_enum_t se) 7167 { 7168 dev_info_t *child; 7169 scsi_hba_tran_t *tran; 7170 impl_scsi_tgtmap_t *tgtmap; 7171 damap_id_t tgtid; 7172 damap_t *tgtdam; 7173 damap_t *lundam = NULL; 7174 struct scsi_hba_mte_h *h; 7175 struct scsi_hba_mte_ld *ld; 7176 int aver; 7177 scsi_lun_t *lunp = NULL; 7178 int lun; 7179 uint32_t nluns; 7180 uint32_t tluns; 7181 size_t size; 7182 scsi_lun64_t lun64; 7183 int maxluns; 7184 7185 /* 7186 * If LUN0 failed then we have no other LUNs. 7187 * 7188 * NOTE: We need sd_inq to be valid to check ansi version. Since 7189 * scsi_unprobe is now a noop (sd_inq freeded in 7190 * scsi_busctl_uninitchild) sd_inq remains valid even if a target 7191 * driver detach(9E) occurs, resulting in a scsi_unprobe call 7192 * (sd_uninit_prevent keeps sd_inq valid by failing any 7193 * device_uninitchild attempts). 7194 */ 7195 ASSERT(sd0 && sd0->sd_uninit_prevent && sd0->sd_dev && sd0->sd_inq); 7196 if ((sd0 == NULL) || (sd0->sd_dev == NULL) || (sd0->sd_inq == NULL)) { 7197 SCSI_HBA_LOG((_LOG(1), NULL, sd0 ? sd0->sd_dev : NULL, 7198 "not setup correctly:%s%s%s", 7199 (sd0 == NULL) ? " device" : "", 7200 (sd0 && (sd0->sd_dev == NULL)) ? " dip" : "", 7201 (sd0 && (sd0->sd_inq == NULL)) ? " inq" : "")); 7202 return (DDI_FAILURE); 7203 } 7204 7205 /* 7206 * NOTE: child should only be used in SCSI_HBA_LOG context since with 7207 * vHCI enumeration it may be the vHCI 'client' devinfo child instead 7208 * of a child of the 'self' pHCI we are enumerating. 7209 */ 7210 child = sd0->sd_dev; 7211 7212 /* Determine if we are reporting lun observations into lunmap. */ 7213 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 7214 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap; 7215 if (tgtmap) { 7216 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]; 7217 tgtid = damap_lookup(tgtdam, taddr); 7218 if (tgtid != NODAM) { 7219 lundam = damap_id_priv_get(tgtdam, tgtid); 7220 damap_id_rele(tgtdam, tgtid); 7221 ASSERT(lundam); 7222 } 7223 } 7224 7225 if (lundam) { 7226 /* If using lunmap, start the observation */ 7227 scsi_lunmap_set_begin(self, lundam); 7228 } else { 7229 /* allocate and initialize the LUN handle */ 7230 h = kmem_zalloc(sizeof (*h), KM_SLEEP); 7231 mutex_init(&h->h_lock, NULL, MUTEX_DEFAULT, NULL); 7232 cv_init(&h->h_cv, NULL, CV_DEFAULT, NULL); 7233 h->h_self = self; 7234 } 7235 7236 /* See if SCMD_REPORT_LUNS works for SCSI-2 and beyond */ 7237 aver = sd0->sd_inq->inq_ansi; 7238 if ((aver >= SCSI_VERSION_2) && (scsi_device_reportluns(sd0, 7239 taddr, pi, &lunp, &nluns, &tluns, &size) == NDI_SUCCESS)) { 7240 7241 ASSERT(lunp && (size > 0) && (nluns > 0) && (tluns > 0)); 7242 7243 /* loop over the reported LUNs */ 7244 SCSI_HBA_LOG((_LOG(2), NULL, child, 7245 "@%s,0 path %d: enumerating %d reported lun%s", taddr, pi, 7246 nluns, nluns > 1 ? "s" : "")); 7247 7248 for (lun = 0; lun < nluns; lun++) { 7249 lun64 = scsi_lun_to_lun64(lunp[lun]); 7250 7251 if (lundam) { 7252 if (scsi_lunmap_set_add(self, lundam, 7253 taddr, lun64, -1) != DDI_SUCCESS) { 7254 SCSI_HBA_LOG((_LOG_NF(WARN), 7255 "@%s,%" PRIx64 " failed to create", 7256 taddr, lun64)); 7257 } 7258 } else { 7259 if (lun64 == 0) 7260 continue; 7261 7262 /* allocate a thread data structure for LUN */ 7263 ld = kmem_alloc(sizeof (*ld), KM_SLEEP); 7264 ld->ld_h = h; 7265 ld->ld_taddr = taddr; 7266 ld->ld_lun64 = lun64; 7267 ld->ld_sfunc = -1; 7268 ld->ld_se = se; 7269 7270 /* process the LUN */ 7271 mutex_enter(&h->h_lock); 7272 h->h_thr_count++; 7273 mutex_exit(&h->h_lock); 7274 7275 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE) 7276 scsi_hba_enum_lsf_of_tgt_thr( 7277 (void *)ld); 7278 else 7279 (void) thread_create(NULL, 0, 7280 scsi_hba_enum_lsf_of_tgt_thr, 7281 (void *)ld, 0, &p0, TS_RUN, 7282 minclsyspri); 7283 } 7284 } 7285 7286 /* free the LUN array allocated by scsi_device_reportluns */ 7287 kmem_free(lunp, size); 7288 } else { 7289 /* Determine the number of LUNs to enumerate. */ 7290 maxluns = scsi_get_scsi_maxluns(sd0); 7291 7292 /* Couldn't get SCMD_REPORT_LUNS data */ 7293 if (aver >= SCSI_VERSION_3) { 7294 scsi_enumeration_failed(child, se, taddr, "report_lun"); 7295 7296 /* 7297 * Based on calling context tunable, only enumerate one 7298 * lun (lun0) if scsi_device_reportluns() fails on a 7299 * SCSI_VERSION_3 or greater device. 7300 */ 7301 if (scsi_lunrpt_failed_do1lun & (1 << se)) 7302 maxluns = 1; 7303 } 7304 7305 /* loop over possible LUNs, skipping LUN0 */ 7306 if (maxluns > 1) 7307 SCSI_HBA_LOG((_LOG(2), NULL, child, 7308 "@%s,0 path %d: enumerating luns 1-%d", taddr, pi, 7309 maxluns - 1)); 7310 else 7311 SCSI_HBA_LOG((_LOG(2), NULL, child, 7312 "@%s,0 path %d: enumerating just lun0", taddr, pi)); 7313 7314 for (lun64 = 0; lun64 < maxluns; lun64++) { 7315 if (lundam) { 7316 if (scsi_lunmap_set_add(self, lundam, 7317 taddr, lun64, -1) != DDI_SUCCESS) { 7318 SCSI_HBA_LOG((_LOG_NF(WARN), 7319 "@%s,%" PRIx64 " failed to create", 7320 taddr, lun64)); 7321 } 7322 } else { 7323 if (lun64 == 0) 7324 continue; 7325 7326 /* allocate a thread data structure for LUN */ 7327 ld = kmem_alloc(sizeof (*ld), KM_SLEEP); 7328 ld->ld_h = h; 7329 ld->ld_taddr = taddr; 7330 ld->ld_lun64 = lun64; 7331 ld->ld_sfunc = -1; 7332 ld->ld_se = se; 7333 7334 /* process the LUN */ 7335 mutex_enter(&h->h_lock); 7336 h->h_thr_count++; 7337 mutex_exit(&h->h_lock); 7338 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE) 7339 scsi_hba_enum_lsf_of_tgt_thr( 7340 (void *)ld); 7341 else 7342 (void) thread_create(NULL, 0, 7343 scsi_hba_enum_lsf_of_tgt_thr, 7344 (void *)ld, 0, &p0, TS_RUN, 7345 minclsyspri); 7346 } 7347 } 7348 } 7349 7350 /* 7351 * If we have an embedded service as a secondary function on LUN0 and 7352 * the primary LUN0 function is different than the secondary function 7353 * then enumerate the secondary function. The sfunc value is the dtype 7354 * associated with the embedded service. 7355 * 7356 * inq_encserv: enclosure service and our dtype is not DTYPE_ESI 7357 * or DTYPE_UNKNOWN then create a separate DTYPE_ESI node for 7358 * enclosure service access. 7359 */ 7360 ASSERT(sd0->sd_inq); 7361 if (sd0->sd_inq->inq_encserv && 7362 ((sd0->sd_inq->inq_dtype & DTYPE_MASK) != DTYPE_UNKNOWN) && 7363 ((sd0->sd_inq->inq_dtype & DTYPE_MASK) != DTYPE_ESI) && 7364 ((sd0->sd_inq->inq_ansi >= SCSI_VERSION_3))) { 7365 if (lundam) { 7366 if (scsi_lunmap_set_add(self, lundam, 7367 taddr, 0, DTYPE_ESI) != DDI_SUCCESS) { 7368 SCSI_HBA_LOG((_LOG_NF(WARN), 7369 "@%s,0,%x failed to create", 7370 taddr, DTYPE_ESI)); 7371 } 7372 } else { 7373 /* allocate a thread data structure for sfunc */ 7374 ld = kmem_alloc(sizeof (*ld), KM_SLEEP); 7375 ld->ld_h = h; 7376 ld->ld_taddr = taddr; 7377 ld->ld_lun64 = 0; 7378 ld->ld_sfunc = DTYPE_ESI; 7379 ld->ld_se = se; 7380 7381 /* process the LUN */ 7382 mutex_enter(&h->h_lock); 7383 h->h_thr_count++; 7384 mutex_exit(&h->h_lock); 7385 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE) 7386 scsi_hba_enum_lsf_of_tgt_thr((void *)ld); 7387 else 7388 (void) thread_create(NULL, 0, 7389 scsi_hba_enum_lsf_of_tgt_thr, (void *)ld, 7390 0, &p0, TS_RUN, minclsyspri); 7391 } 7392 } 7393 7394 /* 7395 * Future: Add secondary function support for: 7396 * inq_mchngr (DTYPE_CHANGER) 7397 * inq_sccs (DTYPE_ARRAY_CTRL) 7398 */ 7399 7400 if (lundam) { 7401 /* If using lunmap, end the observation */ 7402 scsi_lunmap_set_end(self, lundam); 7403 } else { 7404 /* wait for all the LUN threads of this target to complete */ 7405 mutex_enter(&h->h_lock); 7406 while (h->h_thr_count > 0) 7407 cv_wait(&h->h_cv, &h->h_lock); 7408 mutex_exit(&h->h_lock); 7409 7410 /* free the target handle */ 7411 cv_destroy(&h->h_cv); 7412 mutex_destroy(&h->h_lock); 7413 kmem_free(h, sizeof (*h)); 7414 } 7415 7416 return (DDI_SUCCESS); 7417 } 7418 7419 /* 7420 * Enumerate LUN0 and all other LUNs and secondary functions associated with 7421 * the specified target address. 7422 * 7423 * Return NDI_SUCCESS if we might have created a new node. 7424 * Return NDI_FAILURE if we definitely did not create a new node. 7425 */ 7426 static int 7427 scsi_hba_bus_config_taddr(dev_info_t *self, char *taddr, int mt, scsi_enum_t se) 7428 { 7429 char addr[SCSI_MAXNAMELEN]; 7430 struct scsi_device *sd; 7431 int circ; 7432 int ret; 7433 int pi; 7434 7435 /* See if LUN0 of the specified target exists. */ 7436 (void) snprintf(addr, sizeof (addr), "%s,0", taddr); 7437 7438 scsi_hba_devi_enter(self, &circ); 7439 sd = scsi_device_config(self, NULL, addr, se, &circ, &pi); 7440 7441 if (sd) { 7442 /* 7443 * LUN0 exists, enumerate all the other LUNs. 7444 * 7445 * With vHCI enumeration, when 'self' is a pHCI the sd 7446 * scsi_device may be associated with the vHCI 'client'. 7447 * In this case 'pi' is the path_instance needed to 7448 * continue enumeration communication LUN0 via 'self' 7449 * pHCI and specific 'taddr' target address. 7450 * 7451 * We prevent the removal of LUN0 until we are done with 7452 * prevent/allow because we must exit the parent for 7453 * multi-threaded scsi_hba_enum_lsf_of_t(). 7454 * 7455 * NOTE: scsi_unprobe is a noop, sd->sd_inq is valid until 7456 * device_uninitchild - so sd_uninit_prevent keeps sd_inq valid 7457 * by failing any device_uninitchild attempts. 7458 */ 7459 ret = NDI_SUCCESS; 7460 sd->sd_uninit_prevent++; 7461 scsi_hba_devi_exit(self, circ); 7462 7463 (void) scsi_hba_enum_lsf_of_t(sd, self, taddr, pi, mt, se); 7464 7465 scsi_hba_devi_enter(self, &circ); 7466 sd->sd_uninit_prevent--; 7467 } else 7468 ret = NDI_FAILURE; 7469 scsi_hba_devi_exit(self, circ); 7470 return (ret); 7471 } 7472 7473 /* Config callout from scsi_hba_thread_taddrs */ 7474 static void 7475 scsi_hba_taddr_config_thr(void *arg) 7476 { 7477 struct scsi_hba_mte_td *td = (struct scsi_hba_mte_td *)arg; 7478 struct scsi_hba_mte_h *h = td->td_h; 7479 7480 (void) scsi_hba_bus_config_taddr(h->h_self, td->td_taddr, 7481 td->td_mt, td->td_se); 7482 7483 /* signal completion of this target thread to the HBA */ 7484 mutex_enter(&h->h_lock); 7485 if (--h->h_thr_count == 0) 7486 cv_broadcast(&h->h_cv); 7487 mutex_exit(&h->h_lock); 7488 7489 /* free config thread data */ 7490 kmem_free(td, sizeof (*td)); 7491 } 7492 7493 /* 7494 * Enumerate all the children of the specified SCSI parallel interface (spi). 7495 * An HBA associated with a non-parallel scsi bus should be using another bus 7496 * level enumeration implementation (possibly their own) and calling 7497 * scsi_hba_bus_config_taddr to do enumeration of devices associated with a 7498 * particular target address. 7499 * 7500 * On an spi bus the targets are sequentially enumerated based on the 7501 * width of the bus. We also take care to try to skip the HBAs own initiator 7502 * id. See scsi_hba_enum_lsf_of_t() for LUN and secondary function enumeration. 7503 * 7504 * Return NDI_SUCCESS if we might have created a new node. 7505 * Return NDI_FAILURE if we definitely did not create a new node. 7506 * 7507 * Note: At some point we may want to expose this interface in transport.h 7508 * if we find an hba that implements bus_config but still uses spi-like target 7509 * addresses. 7510 */ 7511 static int 7512 scsi_hba_bus_configall_spi(dev_info_t *self, int mt) 7513 { 7514 int options; 7515 int ntargets; 7516 int id; 7517 int tgt; 7518 char **taddrs; 7519 char **taddr; 7520 char *tbuf; 7521 7522 /* 7523 * Find the number of targets supported on the bus. Look at the per 7524 * bus scsi-options property on the HBA node and check its 7525 * SCSI_OPTIONS_WIDE setting. 7526 */ 7527 options = ddi_prop_get_int(DDI_DEV_T_ANY, self, 7528 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-options", -1); 7529 if ((options != -1) && ((options & SCSI_OPTIONS_WIDE) == 0)) 7530 ntargets = NTARGETS; /* 8 */ 7531 else 7532 ntargets = NTARGETS_WIDE; /* 16 */ 7533 7534 /* 7535 * Find the initiator-id for the HBA so we can skip that. We get the 7536 * cached value on the HBA node, established in scsi_hba_attach_setup. 7537 * If we were unable to determine the id then we rely on the HBA to 7538 * fail gracefully when asked to enumerate itself. 7539 */ 7540 id = ddi_prop_get_int(DDI_DEV_T_ANY, self, 7541 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-initiator-id", -1); 7542 if (id > ntargets) { 7543 SCSI_HBA_LOG((_LOG(1), self, NULL, 7544 "'scsi-initiator-id' bogus for %d target bus: %d", 7545 ntargets, id)); 7546 id = -1; 7547 } 7548 SCSI_HBA_LOG((_LOG(2), self, NULL, 7549 "enumerating targets 0-%d skip %d", ntargets, id)); 7550 7551 /* form vector of target addresses */ 7552 taddrs = kmem_zalloc(sizeof (char *) * (ntargets + 1), KM_SLEEP); 7553 for (tgt = 0, taddr = taddrs; tgt < ntargets; tgt++) { 7554 /* skip initiator */ 7555 if (tgt == id) 7556 continue; 7557 7558 /* convert to string and enumerate the target address */ 7559 tbuf = kmem_alloc(((tgt/16) + 1) + 1, KM_SLEEP); 7560 (void) sprintf(tbuf, "%x", tgt); 7561 ASSERT(strlen(tbuf) == ((tgt/16) + 1)); 7562 *taddr++ = tbuf; 7563 } 7564 7565 /* null terminate vector of target addresses */ 7566 *taddr = NULL; 7567 7568 /* configure vector of target addresses */ 7569 scsi_hba_thread_taddrs(self, taddrs, mt, SE_BUSCONFIG, 7570 scsi_hba_taddr_config_thr); 7571 7572 /* free vector of target addresses */ 7573 for (taddr = taddrs; *taddr; taddr++) 7574 kmem_free(*taddr, strlen(*taddr) + 1); 7575 kmem_free(taddrs, sizeof (char *) * (ntargets + 1)); 7576 return (NDI_SUCCESS); 7577 } 7578 7579 /* 7580 * Transport independent bus_configone BUS_CONFIG_ONE implementation. Takes 7581 * same arguments, minus op, as scsi_hba_bus_config(), tran_bus_config(), 7582 * and scsi_hba_bus_config_spi(). 7583 */ 7584 int 7585 scsi_hba_bus_configone(dev_info_t *self, uint_t flags, char *arg, 7586 dev_info_t **childp) 7587 { 7588 int ret; 7589 int circ; 7590 char *name, *addr; 7591 char *lcp; 7592 char sc1, sc2; 7593 char nameaddr[SCSI_MAXNAMELEN]; 7594 extern int i_ndi_make_spec_children(dev_info_t *, uint_t); 7595 struct scsi_device *sd0, *sd; 7596 scsi_lun64_t lun64; 7597 int mt; 7598 7599 /* parse_name modifies arg1, we must duplicate "name@addr" */ 7600 (void) strcpy(nameaddr, arg); 7601 i_ddi_parse_name(nameaddr, &name, &addr, NULL); 7602 7603 /* verify the form of the node - we need an @addr */ 7604 if ((name == NULL) || (addr == NULL) || 7605 (*name == '\0') || (*addr == '\0')) { 7606 /* 7607 * OBP may create ill formed template/stub/wild-card 7608 * nodes (no @addr) for legacy driver loading methods - 7609 * ignore them. 7610 */ 7611 SCSI_HBA_LOG((_LOG(2), self, NULL, "%s ill formed", arg)); 7612 return (NDI_FAILURE); 7613 } 7614 7615 /* 7616 * Check to see if this is a non-scsi flavor configuration operation. 7617 */ 7618 if (strcmp(name, "smp") == 0) { 7619 /* 7620 * Configure the child, and if we're successful return with 7621 * active hold. 7622 */ 7623 return (smp_hba_bus_config(self, addr, childp)); 7624 } 7625 7626 /* 7627 * The framework does not ensure the creation of driver.conf 7628 * nodes prior to calling a nexus bus_config. For legacy 7629 * support of driver.conf file nodes we want to create our 7630 * driver.conf file children now so that we can detect if we 7631 * are being asked to bus_configone one of these nodes. 7632 * 7633 * Needing driver.conf file nodes prior to bus config is unique 7634 * to scsi_enumeration mixed mode (legacy driver.conf and 7635 * dynamic SID node) support. There is no general need for the 7636 * framework to make driver.conf children prior to bus_config. 7637 * 7638 * We enter our HBA (self) prior to scsi_device_config, and 7639 * pass it our circ. The scsi_device_config may exit the 7640 * HBA around scsi_probe() operations to allow for parallelism. 7641 * This is done after the probe node "@addr" is available as a 7642 * barrier to prevent parallel probes of the same device. The 7643 * probe node is also configured in a way that it can't be 7644 * removed by the framework until we are done with it. 7645 * 7646 * NOTE: The framework is currently preventing many parallel 7647 * sibling operations (such as attaches), so the parallelism 7648 * we are providing is of marginal use until that is improved. 7649 * The most logical way to solve this would be to have separate 7650 * target and lun nodes. This would be a large change in the 7651 * format of /devices paths and is not being pursued at this 7652 * time. The need for parallelism will become more of an issue 7653 * with top-down attach for mpxio/vhci and for iSCSI support. 7654 * We may want to eventually want a dual mode implementation, 7655 * where the HBA determines if we should construct separate 7656 * target and lun devinfo nodes. 7657 */ 7658 scsi_hba_devi_enter(self, &circ); 7659 SCSI_HBA_LOG((_LOG(4), self, NULL, "%s@%s config_one", name, addr)); 7660 (void) i_ndi_make_spec_children(self, flags); 7661 7662 /* 7663 * For bus_configone, we make sure that we can find LUN0 7664 * first. This allows the delayed probe/barrier deletion for a 7665 * non-existent LUN0 (if enabled in scsi_device_config) to 7666 * cover all LUNs on the target. This is done to minimize the 7667 * number of independent target selection timeouts that occur 7668 * when a target with many LUNs is no longer accessible 7669 * (powered off). This removes the need for target driver 7670 * probe cache implementations. 7671 * 7672 * This optimization may not be desirable in a pure bridge 7673 * environment where targets on the other side of the bridge 7674 * show up as LUNs to the host. If we ever need to support 7675 * such a configuration then we should consider implementing a 7676 * SCSI_OPTIONS_ILUN0 bit. 7677 * 7678 * NOTE: we are *not* applying any target limitation filtering 7679 * to bus_configone, which means that we are relying on the 7680 * HBA tran_tgt_init entry point invoked by scsi_busctl_initchild 7681 * to fail. 7682 */ 7683 sd0 = (struct scsi_device *)-1; 7684 lcp = strchr(addr, ','); /* "addr,lun[,sfunc]" */ 7685 if (lcp) { 7686 /* 7687 * With "tgt,lun[,sfunc]" addressing, multiple addressing levels 7688 * have been compressed into single devinfo node unit-address. 7689 * This presents a mismatch - there is no bus_config to discover 7690 * LUNs below a specific target, the only choice is to 7691 * BUS_CONFIG_ALL the HBA. To support BUS_CONFIG_ALL_LUNS below 7692 * a specific target, a bus_configone with lun address of "*" 7693 * triggers lun discovery below a target. 7694 */ 7695 if (*(lcp + 1) == '*') { 7696 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self, 7697 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 7698 "scsi-enumeration", scsi_enumeration); 7699 mt |= scsi_hba_log_mt_disable; 7700 7701 SCSI_HBA_LOG((_LOG(2), self, NULL, 7702 "%s@%s lun enumeration triggered", name, addr)); 7703 *lcp = '\0'; /* turn ',' into '\0' */ 7704 scsi_hba_devi_exit(self, circ); 7705 (void) scsi_hba_bus_config_taddr(self, addr, 7706 mt, SE_BUSCONFIG); 7707 return (NDI_FAILURE); 7708 } 7709 7710 /* convert hex lun number from ascii */ 7711 lun64 = scsi_addr_to_lun64(lcp + 1); 7712 7713 if ((lun64 != 0) && (lun64 != SCSI_LUN64_ILLEGAL)) { 7714 /* 7715 * configure ",0" lun first, saving off 7716 * original lun characters. 7717 */ 7718 sc1 = *(lcp + 1); 7719 sc2 = *(lcp + 2); 7720 *(lcp + 1) = '0'; 7721 *(lcp + 2) = '\0'; 7722 sd0 = scsi_device_config(self, 7723 NULL, addr, SE_BUSCONFIG, &circ, NULL); 7724 7725 /* restore original lun */ 7726 *(lcp + 1) = sc1; 7727 *(lcp + 2) = sc2; 7728 7729 /* 7730 * Apply maxlun filtering. 7731 * 7732 * Future: We still have the kludged 7733 * scsi_check_ss2_LUN_limit() filtering off 7734 * scsi_probe() to catch bogus driver.conf 7735 * entries. 7736 */ 7737 if (sd0 && (lun64 < SCSI_32LUNS_PER_TARGET) && 7738 (lun64 >= scsi_get_scsi_maxluns(sd0))) { 7739 sd0 = NULL; 7740 SCSI_HBA_LOG((_LOG(4), self, NULL, 7741 "%s@%s filtered", name, addr)); 7742 } else 7743 SCSI_HBA_LOG((_LOG(4), self, NULL, 7744 "%s@%s lun 0 %s", name, addr, 7745 sd0 ? "worked" : "failed")); 7746 } 7747 } 7748 7749 /* 7750 * configure the requested device if LUN0 exists or we were 7751 * unable to determine the lun format to determine if LUN0 7752 * exists. 7753 */ 7754 if (sd0) { 7755 sd = scsi_device_config(self, 7756 name, addr, SE_BUSCONFIG, &circ, NULL); 7757 } else { 7758 sd = NULL; 7759 SCSI_HBA_LOG((_LOG(2), self, NULL, 7760 "%s@%s no lun 0 or filtered lun", name, addr)); 7761 } 7762 7763 /* 7764 * We know what we found, to reduce overhead we finish BUS_CONFIG_ONE 7765 * processing without calling back to the frameworks 7766 * ndi_busop_bus_config (unless we goto framework below). 7767 * 7768 * If the reference is to a driver name and we created a generic name 7769 * (bound to that driver) we will still succeed. This is important 7770 * for correctly resolving old drivername references to device that now 7771 * uses a generic names across the transition to generic naming. This 7772 * is effectively an internal implementation of the NDI_DRIVERNAME flag. 7773 * 7774 * We also need to special case the resolve_pathname OBP boot-device 7775 * case (modrootloaded == 0) where reference is to a generic name but 7776 * we created a legacy driver name node by returning just returning 7777 * the node created. 7778 */ 7779 if (sd && sd->sd_dev && 7780 ((strcmp(ddi_node_name(sd->sd_dev), name) == 0) || 7781 (strcmp(ddi_driver_name(sd->sd_dev), name) == 0) || 7782 (modrootloaded == 0)) && 7783 (ndi_devi_online(sd->sd_dev, 7784 flags & NDI_NO_EVENT) == NDI_SUCCESS)) { 7785 7786 /* device attached, return devinfo node with hold */ 7787 ret = NDI_SUCCESS; 7788 *childp = sd->sd_dev; 7789 ndi_hold_devi(sd->sd_dev); 7790 } else { 7791 /* 7792 * In the process of failing we may have added nodes to the HBA 7793 * (self), clearing DEVI_MADE_CHILDREN. To reduce the overhead 7794 * associated with the frameworks reaction to this we clear the 7795 * flag here. 7796 */ 7797 mutex_enter(&DEVI(self)->devi_lock); 7798 DEVI(self)->devi_flags &= ~DEVI_MADE_CHILDREN; 7799 mutex_exit(&DEVI(self)->devi_lock); 7800 ret = NDI_FAILURE; 7801 7802 /* 7803 * The framework may still be able to succeed with 7804 * with its GENERIC_PROP code. 7805 */ 7806 scsi_hba_devi_exit(self, circ); 7807 if (flags & NDI_DRV_CONF_REPROBE) 7808 flags |= NDI_CONFIG_REPROBE; 7809 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */ 7810 return (ndi_busop_bus_config(self, flags, BUS_CONFIG_ONE, 7811 (void *)arg, childp, 0)); 7812 } 7813 7814 scsi_hba_devi_exit(self, circ); 7815 return (ret); 7816 } 7817 7818 /* 7819 * Perform SCSI Parallel Interconnect bus_config 7820 */ 7821 static int 7822 scsi_hba_bus_config_spi(dev_info_t *self, uint_t flags, 7823 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 7824 { 7825 int ret; 7826 int mt; 7827 7828 /* 7829 * Enumerate scsi target devices: See if we are doing generic dynamic 7830 * enumeration: if driver.conf has not specified the 'scsi-enumeration' 7831 * knob then use the global scsi_enumeration knob. 7832 */ 7833 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self, 7834 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 7835 "scsi-enumeration", scsi_enumeration); 7836 mt |= scsi_hba_log_mt_disable; 7837 7838 if ((mt & SCSI_ENUMERATION_ENABLE) == 0) { 7839 /* 7840 * Static driver.conf file enumeration: 7841 * 7842 * Force reprobe for BUS_CONFIG_ONE or when manually 7843 * reconfiguring via devfsadm(1m) to emulate deferred attach. 7844 * Reprobe only discovers driver.conf enumerated nodes, more 7845 * dynamic implementations probably require their own 7846 * bus_config. 7847 */ 7848 if ((op == BUS_CONFIG_ONE) || (flags & NDI_DRV_CONF_REPROBE)) 7849 flags |= NDI_CONFIG_REPROBE; 7850 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */ 7851 return (ndi_busop_bus_config(self, flags, op, arg, childp, 0)); 7852 } 7853 7854 if (scsi_hba_bus_config_debug) 7855 flags |= NDI_DEVI_DEBUG; 7856 7857 /* 7858 * Generic spi dynamic bus config enumeration to discover and enumerate 7859 * the target device nodes we are looking for. 7860 */ 7861 switch (op) { 7862 case BUS_CONFIG_ONE: /* enumerate the named child */ 7863 ret = scsi_hba_bus_configone(self, flags, (char *)arg, childp); 7864 break; 7865 7866 case BUS_CONFIG_ALL: /* enumerate all children on the bus */ 7867 case BUS_CONFIG_DRIVER: /* enumerate all children that bind to driver */ 7868 SCSI_HBA_LOG((_LOG(3), self, NULL, 7869 "BUS_CONFIG_%s mt %x", 7870 (op == BUS_CONFIG_ALL) ? "ALL" : "DRIVER", mt)); 7871 7872 /* 7873 * Enumerate targets on SCSI parallel interconnect and let the 7874 * framework finish the operation (attach the nodes). 7875 */ 7876 if ((ret = scsi_hba_bus_configall_spi(self, mt)) == NDI_SUCCESS) 7877 ret = ndi_busop_bus_config(self, flags, op, 7878 arg, childp, 0); 7879 break; 7880 7881 default: 7882 ret = NDI_FAILURE; 7883 break; 7884 } 7885 return (ret); 7886 } 7887 7888 /* 7889 * Perform SCSI Parallel Interconnect bus_unconfig 7890 */ 7891 static int 7892 scsi_hba_bus_unconfig_spi(dev_info_t *self, uint_t flags, 7893 ddi_bus_config_op_t op, void *arg) 7894 { 7895 int mt; 7896 int circ; 7897 int ret; 7898 7899 /* 7900 * See if we are doing generic dynamic enumeration: if driver.conf has 7901 * not specified the 'scsi-enumeration' knob then use the global 7902 * scsi_enumeration knob. 7903 */ 7904 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self, 7905 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 7906 "scsi-enumeration", scsi_enumeration); 7907 mt |= scsi_hba_log_mt_disable; 7908 7909 if ((mt & SCSI_ENUMERATION_ENABLE) == 0) 7910 return (ndi_busop_bus_unconfig(self, flags, op, arg)); 7911 7912 if (scsi_hba_bus_config_debug) 7913 flags |= NDI_DEVI_DEBUG; 7914 7915 scsi_hba_devi_enter(self, &circ); 7916 switch (op) { 7917 case BUS_UNCONFIG_ONE: 7918 SCSI_HBA_LOG((_LOG(3), self, NULL, 7919 "unconfig one: %s", (char *)arg)); 7920 ret = NDI_SUCCESS; 7921 break; 7922 7923 case BUS_UNCONFIG_ALL: 7924 case BUS_UNCONFIG_DRIVER: 7925 ret = NDI_SUCCESS; 7926 break; 7927 7928 default: 7929 ret = NDI_FAILURE; 7930 break; 7931 } 7932 7933 /* Perform the generic default bus unconfig */ 7934 if (ret == NDI_SUCCESS) 7935 ret = ndi_busop_bus_unconfig(self, flags, op, arg); 7936 7937 scsi_hba_devi_exit(self, circ); 7938 7939 return (ret); 7940 } 7941 7942 static int 7943 scsi_hba_bus_config_tgtmap(dev_info_t *self, uint_t flags, 7944 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 7945 { 7946 scsi_hba_tran_t *tran; 7947 impl_scsi_tgtmap_t *tgtmap; 7948 uint64_t tsa = 0; /* clock64_t */ 7949 int maxdev; 7950 int sync_usec; 7951 int synced; 7952 int ret = NDI_FAILURE; 7953 7954 if ((op != BUS_CONFIG_ONE) && (op != BUS_CONFIG_ALL) && 7955 (op != BUS_CONFIG_DRIVER)) 7956 goto out; 7957 7958 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 7959 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap; 7960 ASSERT(tgtmap); 7961 7962 /* 7963 * MPXIO is never a sure thing (and we have mixed children), so 7964 * set NDI_NDI_FALLBACK so that ndi_busop_bus_config will 7965 * search for both devinfo and pathinfo children. 7966 * 7967 * Future: Remove NDI_MDI_FALLBACK since devcfg.c now looks for 7968 * devinfo/pathinfo children in parallel (instead of old way of 7969 * looking for one form of child and then doing "fallback" to 7970 * look for other form of child). 7971 */ 7972 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */ 7973 7974 /* 7975 * If bus_config occurred within the map create-to-hotplug_sync window, 7976 * we need the framework to wait for children that are physicaly 7977 * present at map create time to show up (via tgtmap hotplug config). 7978 * 7979 * The duration of this window is specified by the HBA driver at 7980 * scsi_hba_tgtmap_create(9F) time (during attach(9E)). Its 7981 * 'csync_usec' value is selected based on how long it takes the HBA 7982 * driver to get from map creation to initial observation for something 7983 * already plugged in. Estimate high, a low estimate can result in 7984 * devices not showing up correctly on first reference. The call to 7985 * ndi_busop_bus_config needs a timeout value large enough so that 7986 * the map sync call further down is not a noop (i.e. done against 7987 * an empty map when something is infact plugged in). With 7988 * BUS_CONFIG_ONE, the call to ndi_busop_bus_config will return as 7989 * soon as the desired device is enumerated via hotplug - so we are 7990 * not committed to waiting the entire time. 7991 * 7992 * We are typically outside the window, so timeout is 0. 7993 */ 7994 sync_usec = tgtmap->tgtmap_create_csync_usec; 7995 if (tgtmap->tgtmap_create_window) { 7996 tsa = ddi_get_lbolt64() - tgtmap->tgtmap_create_time; 7997 if (tsa < drv_usectohz(sync_usec)) { 7998 tsa = drv_usectohz(sync_usec) - tsa; 7999 ret = ndi_busop_bus_config(self, 8000 flags, op, arg, childp, (clock_t)tsa); 8001 } else 8002 tsa = 0; /* passed window */ 8003 8004 /* First one out closes the window. */ 8005 tgtmap->tgtmap_create_window = 0; 8006 } else if (op == BUS_CONFIG_ONE) 8007 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0); 8008 8009 /* Return if doing a BUS_CONFIG_ONE and we found what we want. */ 8010 if ((op == BUS_CONFIG_ONE) && (ret == NDI_SUCCESS)) 8011 goto out; /* performance path */ 8012 8013 /* 8014 * We sync if we were in the window, on the first bus_config_one, and 8015 * every bus_config_all (or bus_config_driver). 8016 */ 8017 if (tsa || (tgtmap->tgtmap_sync_cnt == 0) || 8018 (op != BUS_CONFIG_ONE)) { 8019 /* 8020 * Sync current observations in the map and look again. We 8021 * place an upper bound on the amount of time we will wait for 8022 * sync to complete to avoid a bad device causing this 8023 * busconfig operation to hang. 8024 * 8025 * We are typically stable, so damap_sync returns immediately. 8026 * 8027 * Max time to wait for sync is settle_usec per possible device. 8028 */ 8029 tgtmap->tgtmap_sync_cnt++; 8030 maxdev = damap_size(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]); 8031 maxdev = (maxdev > scsi_hba_map_settle_f) ? maxdev : 8032 scsi_hba_map_settle_f; 8033 sync_usec = maxdev * tgtmap->tgtmap_settle_usec; 8034 synced = scsi_tgtmap_sync((scsi_hba_tgtmap_t *)tgtmap, 8035 sync_usec); 8036 if (!synced) 8037 SCSI_HBA_LOG((_LOGCFG, self, NULL, 8038 "tgtmap_sync timeout")); 8039 } else 8040 synced = -1; 8041 8042 if (op == BUS_CONFIG_ONE) 8043 ret = scsi_hba_bus_configone(self, flags, arg, childp); 8044 else 8045 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0); 8046 8047 out: 8048 #ifdef DEBUG 8049 if (ret != NDI_SUCCESS) { 8050 if (scsi_hba_bus_config_failure_msg || 8051 scsi_hba_bus_config_failure_dbg) { 8052 scsi_hba_bus_config_failure_msg--; 8053 printf("%s%d: bus_config_tgtmap %p failure on %s: " 8054 "%d %d\n", 8055 ddi_driver_name(self), ddi_get_instance(self), 8056 (void *)tgtmap, 8057 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL", 8058 (int)tsa, synced); 8059 } 8060 if (scsi_hba_bus_config_failure_dbg) { 8061 scsi_hba_bus_config_failure_dbg--; 8062 debug_enter("config_tgtmap failure"); 8063 } 8064 } else if (scsi_hba_bus_config_success_msg || 8065 scsi_hba_bus_config_success_dbg) { 8066 scsi_hba_bus_config_success_msg--; 8067 printf("%s%d: bus_config_tgtmap %p success on %s: %d %d\n", 8068 ddi_driver_name(self), ddi_get_instance(self), 8069 (void *)tgtmap, 8070 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL", 8071 (int)tsa, synced); 8072 if (scsi_hba_bus_config_success_dbg) { 8073 scsi_hba_bus_config_success_dbg--; 8074 debug_enter("config_tgtmap success"); 8075 } 8076 } 8077 #endif /* DEBUG */ 8078 return (ret); 8079 } 8080 8081 static int 8082 scsi_hba_bus_unconfig_tgtmap(dev_info_t *self, uint_t flags, 8083 ddi_bus_config_op_t op, void *arg) 8084 { 8085 int ret = NDI_FAILURE; 8086 8087 switch (op) { 8088 case BUS_UNCONFIG_ONE: 8089 case BUS_UNCONFIG_DRIVER: 8090 case BUS_UNCONFIG_ALL: 8091 ret = NDI_SUCCESS; 8092 break; 8093 default: 8094 break; 8095 } 8096 8097 if (ret == NDI_SUCCESS) { 8098 flags &= ~NDI_DEVI_REMOVE; 8099 ret = ndi_busop_bus_unconfig(self, flags, op, arg); 8100 } 8101 return (ret); 8102 } 8103 8104 static int 8105 scsi_hba_bus_config_iportmap(dev_info_t *self, uint_t flags, 8106 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 8107 { 8108 scsi_hba_tran_t *tran; 8109 impl_scsi_iportmap_t *iportmap; 8110 dev_info_t *child; 8111 int circ; 8112 uint64_t tsa = 0; /* clock64_t */ 8113 int sync_usec; 8114 int synced; 8115 int ret = NDI_FAILURE; 8116 8117 if ((op != BUS_CONFIG_ONE) && (op != BUS_CONFIG_ALL) && 8118 (op != BUS_CONFIG_DRIVER)) 8119 goto out; 8120 8121 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 8122 iportmap = (impl_scsi_iportmap_t *)tran->tran_iportmap; 8123 ASSERT(iportmap); 8124 8125 /* 8126 * MPXIO is never a sure thing (and we have mixed children), so 8127 * set NDI_NDI_FALLBACK so that ndi_busop_bus_config will 8128 * search for both devinfo and pathinfo children. 8129 * 8130 * Future: Remove NDI_MDI_FALLBACK since devcfg.c now looks for 8131 * devinfo/pathinfo children in parallel (instead of old way of 8132 * looking for one form of child and then doing "fallback" to 8133 * look for other form of child). 8134 */ 8135 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */ 8136 8137 /* 8138 * If bus_config occurred within the map create-to-hotplug_sync window, 8139 * we need the framework to wait for children that are physicaly 8140 * present at map create time to show up (via iportmap hotplug config). 8141 * 8142 * The duration of this window is specified by the HBA driver at 8143 * scsi_hba_iportmap_create(9F) time (during attach(9E)). Its 8144 * 'csync_usec' value is selected based on how long it takes the HBA 8145 * driver to get from map creation to initial observation for something 8146 * already plugged in. Estimate high, a low estimate can result in 8147 * devices not showing up correctly on first reference. The call to 8148 * ndi_busop_bus_config needs a timeout value large enough so that 8149 * the map sync call further down is not a noop (i.e. done against 8150 * an empty map when something is infact plugged in). With 8151 * BUS_CONFIG_ONE, the call to ndi_busop_bus_config will return as 8152 * soon as the desired device is enumerated via hotplug - so we are 8153 * not committed to waiting the entire time. 8154 * 8155 * We are typically outside the window, so timeout is 0. 8156 */ 8157 sync_usec = iportmap->iportmap_create_csync_usec; 8158 if (iportmap->iportmap_create_window) { 8159 tsa = ddi_get_lbolt64() - iportmap->iportmap_create_time; 8160 if (tsa < drv_usectohz(sync_usec)) { 8161 tsa = drv_usectohz(sync_usec) - tsa; 8162 ret = ndi_busop_bus_config(self, 8163 flags, op, arg, childp, (clock_t)tsa); 8164 } else 8165 tsa = 0; /* passed window */ 8166 8167 /* First one out closes the window. */ 8168 iportmap->iportmap_create_window = 0; 8169 } else if (op == BUS_CONFIG_ONE) 8170 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0); 8171 8172 /* Return if doing a BUS_CONFIG_ONE and we found what we want. */ 8173 if ((op == BUS_CONFIG_ONE) && (ret == NDI_SUCCESS)) 8174 goto out; /* performance path */ 8175 8176 /* 8177 * We sync if we were in the window, on the first bus_config_one, and 8178 * every bus_config_all (or bus_config_driver). 8179 */ 8180 if (tsa || (iportmap->iportmap_sync_cnt == 0) || 8181 (op != BUS_CONFIG_ONE)) { 8182 /* 8183 * Sync current observations in the map and look again. We 8184 * place an upper bound on the amount of time we will wait for 8185 * sync to complete to avoid a bad device causing this 8186 * busconfig operation to hang. 8187 * 8188 * We are typically stable, so damap_sync returns immediately. 8189 * 8190 * Max time to wait for sync is settle_usec times settle factor. 8191 */ 8192 iportmap->iportmap_sync_cnt++; 8193 synced = damap_sync(iportmap->iportmap_dam, sync_usec); 8194 if (!synced) 8195 SCSI_HBA_LOG((_LOGCFG, self, NULL, 8196 "iportmap_sync timeout")); 8197 } else 8198 synced = -1; 8199 8200 if (op == BUS_CONFIG_ONE) { 8201 /* create the iport node child */ 8202 scsi_hba_devi_enter(self, &circ); 8203 if ((child = scsi_hba_bus_config_port(self, (char *)arg, 8204 SE_BUSCONFIG)) != NULL) { 8205 if (childp) { 8206 ndi_hold_devi(child); 8207 *childp = child; 8208 } 8209 ret = NDI_SUCCESS; 8210 } 8211 scsi_hba_devi_exit(self, circ); 8212 } else 8213 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0); 8214 8215 out: 8216 #ifdef DEBUG 8217 if (ret != NDI_SUCCESS) { 8218 if (scsi_hba_bus_config_failure_msg || 8219 scsi_hba_bus_config_failure_dbg) { 8220 scsi_hba_bus_config_failure_msg--; 8221 printf("%s%d: bus_config_iportmap %p failure on %s: " 8222 "%d %d\n", 8223 ddi_driver_name(self), ddi_get_instance(self), 8224 (void *)iportmap, 8225 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL", 8226 (int)tsa, synced); 8227 } 8228 if (scsi_hba_bus_config_failure_dbg) { 8229 scsi_hba_bus_config_failure_dbg--; 8230 debug_enter("config_iportmap failure"); 8231 } 8232 } else if (scsi_hba_bus_config_success_msg || 8233 scsi_hba_bus_config_success_dbg) { 8234 scsi_hba_bus_config_success_msg--; 8235 printf("%s%d: bus_config_iportmap %p success on %s: %d %d\n", 8236 ddi_driver_name(self), ddi_get_instance(self), 8237 (void *)iportmap, 8238 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL", 8239 (int)tsa, synced); 8240 if (scsi_hba_bus_config_success_dbg) { 8241 scsi_hba_bus_config_success_dbg--; 8242 debug_enter("config_iportmap success"); 8243 } 8244 } 8245 #endif /* DEBUG */ 8246 return (ret); 8247 } 8248 8249 static int 8250 scsi_hba_bus_unconfig_iportmap(dev_info_t *self, uint_t flags, 8251 ddi_bus_config_op_t op, void *arg) 8252 { 8253 flags &= ~NDI_DEVI_REMOVE; 8254 return (ndi_busop_bus_unconfig(self, flags, op, arg)); 8255 } 8256 8257 /* 8258 * SCSI HBA bus config enumeration entry point. Called via the bus_ops 8259 * bus_config entry point for all SCSA HBA drivers. 8260 * 8261 * o If an HBA implements its own bus_config via tran_bus_config then we 8262 * invoke it. An HBA that implements its own tran_bus_config entry point 8263 * may still call back into common SCSA code bus_config code for: 8264 * 8265 * o SPI bus_config (scsi_hba_bus_spi) 8266 * o LUN and secondary function enumeration (scsi_hba_enum_lsf_of_t()). 8267 * o configuration of a specific device (scsi_device_config). 8268 * o determining 1275 SCSI nodename and compatible property 8269 * (scsi_hba_nodename_compatible_get/_free). 8270 * 8271 * o Otherwise we implement a SCSI parallel interface (spi) bus config. 8272 * 8273 * Return NDI_SUCCESS if we might have created a new node. 8274 * Return NDI_FAILURE if we definitely did not create a new node. 8275 */ 8276 static int 8277 scsi_hba_bus_config(dev_info_t *self, uint_t flags, 8278 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 8279 { 8280 scsi_hba_tran_t *tran; 8281 int ret; 8282 8283 /* make sure that we will not disappear */ 8284 ASSERT(DEVI(self)->devi_ref); 8285 8286 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 8287 if (tran == NULL) { 8288 /* NULL tran driver.conf config (used by cmdk). */ 8289 if ((op == BUS_CONFIG_ONE) || (flags & NDI_DRV_CONF_REPROBE)) 8290 flags |= NDI_CONFIG_REPROBE; 8291 return (ndi_busop_bus_config(self, flags, op, arg, childp, 0)); 8292 } 8293 8294 /* Check if self is HBA-only node. */ 8295 if (tran->tran_hba_flags & SCSI_HBA_HBA) { 8296 /* The bus_config request is to configure iports below HBA. */ 8297 8298 #ifdef sparc 8299 /* 8300 * Sparc's 'boot-device' OBP property value lacks an /iport@X/ 8301 * component. Prior to the mount of root, we drive a disk@ 8302 * BUS_CONFIG_ONE operatino down a level to resolve an 8303 * OBP 'boot-device' path. 8304 * 8305 * Future: Add (modrootloaded == 0) below, and insure that 8306 * all attempts bus_conf of 'bo_name' (in OBP form) occur 8307 * prior to 'modrootloaded = 1;' assignment in vfs_mountroot. 8308 */ 8309 if ((op == BUS_CONFIG_ONE) && 8310 (strncmp((char *)arg, "disk@", strlen("disk@")) == 0)) { 8311 return (scsi_hba_bus_config_prom_node(self, 8312 flags, arg, childp)); 8313 } 8314 #endif /* sparc */ 8315 8316 if (tran->tran_iportmap) { 8317 /* config based on scsi_hba_iportmap API */ 8318 ret = scsi_hba_bus_config_iportmap(self, 8319 flags, op, arg, childp); 8320 } else { 8321 /* config based on 'iport_register' API */ 8322 ret = scsi_hba_bus_config_iports(self, 8323 flags, op, arg, childp); 8324 } 8325 return (ret); 8326 } 8327 8328 /* Check to see how the iport/HBA does target/lun bus config. */ 8329 if (tran->tran_bus_config) { 8330 /* HBA config based on Sun-private/legacy tran_bus_config */ 8331 ret = tran->tran_bus_config(self, flags, op, arg, childp); 8332 } else if (tran->tran_tgtmap) { 8333 /* SCSAv3 config based on scsi_hba_tgtmap_*() API */ 8334 ret = scsi_hba_bus_config_tgtmap(self, flags, op, arg, childp); 8335 } else { 8336 /* SCSA config based on SCSI Parallel Interconnect */ 8337 ret = scsi_hba_bus_config_spi(self, flags, op, arg, childp); 8338 } 8339 return (ret); 8340 } 8341 8342 /* 8343 * Called via the bus_ops bus_unconfig entry point for SCSI HBA drivers. 8344 */ 8345 static int 8346 scsi_hba_bus_unconfig(dev_info_t *self, uint_t flags, 8347 ddi_bus_config_op_t op, void *arg) 8348 { 8349 int circ; 8350 scsi_hba_tran_t *tran; 8351 int ret; 8352 8353 tran = ddi_get_driver_private(self); 8354 if (tran == NULL) { 8355 /* NULL tran driver.conf unconfig (used by cmdk). */ 8356 return (ndi_busop_bus_unconfig(self, flags, op, arg)); 8357 } 8358 8359 /* 8360 * Purge barrier/probe node children. We do this prior to 8361 * tran_bus_unconfig in case the unconfig implementation calls back 8362 * into the common code at a different enumeration level, such a 8363 * scsi_device_config, which still creates barrier/probe nodes. 8364 */ 8365 scsi_hba_devi_enter(self, &circ); 8366 scsi_hba_barrier_purge(self); 8367 scsi_hba_devi_exit(self, circ); 8368 8369 /* DEBUG: for testing, allow bus_unconfig do drive removal. */ 8370 if (scsi_hba_bus_unconfig_remove) 8371 flags |= NDI_DEVI_REMOVE; 8372 8373 /* Check if self is HBA-only node. */ 8374 if (tran->tran_hba_flags & SCSI_HBA_HBA) { 8375 /* The bus_config request is to unconfigure iports below HBA. */ 8376 if (tran->tran_iportmap) { 8377 /* SCSAv3 unconfig based on scsi_hba_iportmap API */ 8378 ret = scsi_hba_bus_unconfig_iportmap(self, 8379 flags, op, arg); 8380 } else if (tran->tran_bus_unconfig) { 8381 /* HBA unconfig based on Sun-private/legacy API */ 8382 ret = tran->tran_bus_unconfig(self, flags, op, arg); 8383 } else { 8384 /* Standard framework unconfig. */ 8385 ret = ndi_busop_bus_unconfig(self, flags, op, arg); 8386 } 8387 return (ret); 8388 } 8389 8390 /* Check to see how the iport/HBA does target/lun bus unconfig. */ 8391 if (tran->tran_bus_unconfig) { 8392 /* HBA unconfig based on Sun-private/legacy tran_bus_unconfig */ 8393 ret = tran->tran_bus_unconfig(self, flags, op, arg); 8394 } else if (tran->tran_tgtmap) { 8395 /* SCSAv3 unconfig based on scsi_hba_tgtmap_*() API */ 8396 ret = scsi_hba_bus_unconfig_tgtmap(self, flags, op, arg); 8397 } else { 8398 /* SCSA unconfig based on SCSI Parallel Interconnect */ 8399 ret = scsi_hba_bus_unconfig_spi(self, flags, op, arg); 8400 } 8401 return (ret); 8402 } 8403 8404 static int 8405 scsi_tgtmap_scsi_config(void *arg, damap_t *mapp, damap_id_t tgtid) 8406 { 8407 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 8408 dev_info_t *self = tran->tran_iport_dip; 8409 impl_scsi_tgtmap_t *tgtmap; 8410 char *tgtaddr; 8411 int cfg_status, mt; 8412 8413 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap; 8414 tgtaddr = damap_id2addr(mapp, tgtid); 8415 8416 if (scsi_lunmap_create(self, tgtmap, tgtaddr) != DDI_SUCCESS) { 8417 SCSI_HBA_LOG((_LOG_NF(WARN), 8418 "failed to create lunmap for %s", tgtaddr)); 8419 } 8420 8421 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self, 8422 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration", 8423 scsi_enumeration); 8424 mt |= scsi_hba_log_mt_disable; 8425 8426 cfg_status = scsi_hba_bus_config_taddr(self, tgtaddr, mt, SE_HP); 8427 if (cfg_status != NDI_SUCCESS) { 8428 SCSI_HBA_LOG((_LOGCFG, self, NULL, "%s @%s config status %d", 8429 damap_name(mapp), tgtaddr, cfg_status)); 8430 scsi_lunmap_destroy(self, tgtmap, tgtaddr); 8431 return (DAM_FAILURE); 8432 } 8433 8434 return (DAM_SUCCESS); 8435 } 8436 8437 8438 static int 8439 scsi_tgtmap_scsi_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid) 8440 { 8441 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 8442 dev_info_t *self = tran->tran_iport_dip; 8443 impl_scsi_tgtmap_t *tgtmap; 8444 char *tgt_addr; 8445 8446 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap; 8447 tgt_addr = damap_id2addr(mapp, tgtid); 8448 8449 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, "%s @%s", damap_name(mapp), 8450 tgt_addr)); 8451 scsi_lunmap_destroy(self, tgtmap, tgt_addr); 8452 return (DAM_SUCCESS); 8453 } 8454 8455 static int 8456 scsi_tgtmap_smp_config(void *arg, damap_t *mapp, damap_id_t tgtid) 8457 { 8458 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 8459 dev_info_t *self = tran->tran_iport_dip; 8460 char *addr; 8461 8462 addr = damap_id2addr(mapp, tgtid); 8463 SCSI_HBA_LOG((_LOGCFG, self, NULL, "%s @%s", damap_name(mapp), addr)); 8464 8465 return ((smp_hba_bus_config_taddr(self, addr) == NDI_SUCCESS) ? 8466 DAM_SUCCESS : DAM_FAILURE); 8467 } 8468 8469 static int 8470 scsi_tgtmap_smp_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid) 8471 { 8472 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg; 8473 dev_info_t *self = tran->tran_iport_dip; 8474 char *addr; 8475 dev_info_t *child; 8476 char nameaddr[SCSI_MAXNAMELEN]; 8477 int circ; 8478 8479 addr = damap_id2addr(mapp, tgtid); 8480 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, "%s @%s", damap_name(mapp), addr)); 8481 8482 (void) snprintf(nameaddr, sizeof (nameaddr), "smp@%s", addr); 8483 scsi_hba_devi_enter(self, &circ); 8484 if ((child = ndi_devi_findchild(self, nameaddr)) == NULL) { 8485 scsi_hba_devi_exit(self, circ); 8486 return (DAM_SUCCESS); 8487 } 8488 8489 if (ndi_devi_offline(child, 8490 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) { 8491 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 8492 "devinfo smp@%s offlined and removed", addr)); 8493 } else if (ndi_devi_device_remove(child)) { 8494 /* Offline/remove failed, note new device_remove */ 8495 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 8496 "devinfo smp@%s offline failed, device_remove", 8497 addr)); 8498 } 8499 scsi_hba_devi_exit(self, circ); 8500 return (DAM_SUCCESS); 8501 } 8502 8503 /* ARGSUSED1 */ 8504 static void 8505 scsi_tgtmap_smp_activate(void *map_priv, char *tgt_addr, int addrid, 8506 void **tgt_privp) 8507 { 8508 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv; 8509 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8510 8511 if (tgtmap->tgtmap_activate_cb) { 8512 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s activated", 8513 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]), 8514 tgt_addr)); 8515 8516 (*tgtmap->tgtmap_activate_cb)(tgtmap->tgtmap_mappriv, 8517 tgt_addr, SCSI_TGT_SMP_DEVICE, tgt_privp); 8518 } 8519 } 8520 8521 /* ARGSUSED1 */ 8522 static void 8523 scsi_tgtmap_smp_deactivate(void *map_priv, char *tgt_addr, int addrid, 8524 void *tgt_privp, damap_deact_rsn_t damap_rsn) 8525 { 8526 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv; 8527 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8528 boolean_t tgtmap_rereport; 8529 scsi_tgtmap_deact_rsn_t tgtmap_rsn; 8530 8531 if (tgtmap->tgtmap_deactivate_cb) { 8532 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s deactivated %d", 8533 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]), 8534 tgt_addr, damap_rsn)); 8535 8536 if (damap_rsn == DAMAP_DEACT_RSN_GONE) 8537 tgtmap_rsn = SCSI_TGT_DEACT_RSN_GONE; 8538 else if (damap_rsn == DAMAP_DEACT_RSN_CFG_FAIL) 8539 tgtmap_rsn = SCSI_TGT_DEACT_RSN_CFG_FAIL; 8540 else if (damap_rsn == DAMAP_DEACT_RSN_UNSTBL) 8541 tgtmap_rsn = SCSI_TGT_DEACT_RSN_UNSTBL; 8542 else { 8543 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 8544 "%s @%s deactivated with unknown rsn", 8545 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]), 8546 tgt_addr)); 8547 return; 8548 } 8549 8550 tgtmap_rereport = (*tgtmap->tgtmap_deactivate_cb) 8551 (tgtmap->tgtmap_mappriv, tgt_addr, 8552 SCSI_TGT_SMP_DEVICE, tgt_privp, tgtmap_rsn); 8553 8554 if ((tgtmap_rsn == SCSI_TGT_DEACT_RSN_CFG_FAIL) && 8555 (tgtmap_rereport == B_FALSE)) { 8556 SCSI_HBA_LOG((_LOG(WARN), NULL, self, 8557 "%s enumeration failed, no more retries until " 8558 "config change occurs", tgt_addr)); 8559 } 8560 } 8561 } 8562 8563 /* ARGSUSED1 */ 8564 static void 8565 scsi_tgtmap_scsi_activate(void *map_priv, char *tgt_addr, int addrid, 8566 void **tgt_privp) 8567 { 8568 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv; 8569 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8570 8571 if (tgtmap->tgtmap_activate_cb) { 8572 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s activated", 8573 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]), 8574 tgt_addr)); 8575 8576 (*tgtmap->tgtmap_activate_cb)(tgtmap->tgtmap_mappriv, 8577 tgt_addr, SCSI_TGT_SCSI_DEVICE, tgt_privp); 8578 } 8579 } 8580 8581 /* ARGSUSED1 */ 8582 static void 8583 scsi_tgtmap_scsi_deactivate(void *map_priv, char *tgt_addr, int addrid, 8584 void *tgt_privp, damap_deact_rsn_t damap_rsn) 8585 { 8586 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv; 8587 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8588 boolean_t tgtmap_rereport; 8589 scsi_tgtmap_deact_rsn_t tgtmap_rsn; 8590 8591 if (tgtmap->tgtmap_deactivate_cb) { 8592 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s deactivated %d", 8593 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]), 8594 tgt_addr, damap_rsn)); 8595 8596 if (damap_rsn == DAMAP_DEACT_RSN_GONE) 8597 tgtmap_rsn = SCSI_TGT_DEACT_RSN_GONE; 8598 else if (damap_rsn == DAMAP_DEACT_RSN_CFG_FAIL) 8599 tgtmap_rsn = SCSI_TGT_DEACT_RSN_CFG_FAIL; 8600 else if (damap_rsn == DAMAP_DEACT_RSN_UNSTBL) 8601 tgtmap_rsn = SCSI_TGT_DEACT_RSN_UNSTBL; 8602 else { 8603 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 8604 "%s @%s deactivated with unknown rsn", damap_name( 8605 tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]), 8606 tgt_addr)); 8607 return; 8608 } 8609 8610 tgtmap_rereport = (*tgtmap->tgtmap_deactivate_cb) 8611 (tgtmap->tgtmap_mappriv, tgt_addr, 8612 SCSI_TGT_SCSI_DEVICE, tgt_privp, tgtmap_rsn); 8613 8614 if ((tgtmap_rsn == SCSI_TGT_DEACT_RSN_CFG_FAIL) && 8615 (tgtmap_rereport == B_FALSE)) { 8616 SCSI_HBA_LOG((_LOG(WARN), NULL, self, 8617 "%s enumeration failed, no more retries until " 8618 "config change occurs", tgt_addr)); 8619 } 8620 } 8621 } 8622 8623 8624 int 8625 scsi_hba_tgtmap_create(dev_info_t *self, scsi_tgtmap_mode_t mode, 8626 int csync_usec, int settle_usec, void *tgtmap_priv, 8627 scsi_tgt_activate_cb_t activate_cb, scsi_tgt_deactivate_cb_t deactivate_cb, 8628 scsi_hba_tgtmap_t **handle) 8629 { 8630 scsi_hba_tran_t *tran; 8631 damap_t *mapp; 8632 char context[64]; 8633 impl_scsi_tgtmap_t *tgtmap; 8634 damap_rptmode_t rpt_style; 8635 char *scsi_binding_set; 8636 int optflags; 8637 8638 if (self == NULL || csync_usec == 0 || 8639 settle_usec == 0 || handle == NULL) 8640 return (DDI_FAILURE); 8641 8642 *handle = NULL; 8643 8644 if (scsi_hba_iport_unit_address(self) == NULL) 8645 return (DDI_FAILURE); 8646 8647 switch (mode) { 8648 case SCSI_TM_FULLSET: 8649 rpt_style = DAMAP_REPORT_FULLSET; 8650 break; 8651 case SCSI_TM_PERADDR: 8652 rpt_style = DAMAP_REPORT_PERADDR; 8653 break; 8654 default: 8655 return (DDI_FAILURE); 8656 } 8657 8658 tran = (scsi_hba_tran_t *)ddi_get_driver_private(self); 8659 ASSERT(tran); 8660 if (tran == NULL) 8661 return (DDI_FAILURE); 8662 8663 tgtmap = kmem_zalloc(sizeof (*tgtmap), KM_SLEEP); 8664 tgtmap->tgtmap_tran = tran; 8665 tgtmap->tgtmap_activate_cb = activate_cb; 8666 tgtmap->tgtmap_deactivate_cb = deactivate_cb; 8667 tgtmap->tgtmap_mappriv = tgtmap_priv; 8668 8669 tgtmap->tgtmap_create_window = 1; /* start with window */ 8670 tgtmap->tgtmap_create_time = ddi_get_lbolt64(); 8671 tgtmap->tgtmap_create_csync_usec = csync_usec; 8672 tgtmap->tgtmap_settle_usec = settle_usec; 8673 tgtmap->tgtmap_sync_cnt = 0; 8674 8675 optflags = (ddi_prop_get_int(DDI_DEV_T_ANY, self, 8676 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration", 8677 scsi_enumeration) & SCSI_ENUMERATION_MT_TARGET_DISABLE) ? 8678 DAMAP_SERIALCONFIG : DAMAP_MTCONFIG; 8679 8680 (void) snprintf(context, sizeof (context), "%s%d.tgtmap.scsi", 8681 ddi_driver_name(self), ddi_get_instance(self)); 8682 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context)); 8683 if (damap_create(context, rpt_style, optflags, settle_usec, 8684 tgtmap, scsi_tgtmap_scsi_activate, scsi_tgtmap_scsi_deactivate, 8685 tran, scsi_tgtmap_scsi_config, scsi_tgtmap_scsi_unconfig, 8686 &mapp) != DAM_SUCCESS) { 8687 kmem_free(tgtmap, sizeof (*tgtmap)); 8688 return (DDI_FAILURE); 8689 } 8690 tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE] = mapp; 8691 8692 (void) snprintf(context, sizeof (context), "%s%d.tgtmap.smp", 8693 ddi_driver_name(self), ddi_get_instance(self)); 8694 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context)); 8695 if (damap_create(context, rpt_style, optflags, 8696 settle_usec, tgtmap, scsi_tgtmap_smp_activate, 8697 scsi_tgtmap_smp_deactivate, 8698 tran, scsi_tgtmap_smp_config, scsi_tgtmap_smp_unconfig, 8699 &mapp) != DAM_SUCCESS) { 8700 damap_destroy(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]); 8701 kmem_free(tgtmap, sizeof (*tgtmap)); 8702 return (DDI_FAILURE); 8703 } 8704 tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE] = mapp; 8705 8706 tran->tran_tgtmap = (scsi_hba_tgtmap_t *)tgtmap; 8707 *handle = (scsi_hba_tgtmap_t *)tgtmap; 8708 8709 /* 8710 * We have now set tran_tgtmap, marking the tran as using tgtmap 8711 * enumeration services. To prevent the generation of legacy spi 8712 * 'binding-set' compatible forms, remove the 'scsi-binding-set' 8713 * property. 8714 */ 8715 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self, 8716 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-binding-set", 8717 &scsi_binding_set) == DDI_PROP_SUCCESS) { 8718 if (strcmp(scsi_binding_set, scsi_binding_set_spi) == 0) 8719 (void) ndi_prop_remove(DDI_DEV_T_NONE, self, 8720 "scsi-binding-set"); 8721 ddi_prop_free(scsi_binding_set); 8722 } 8723 return (DDI_SUCCESS); 8724 } 8725 8726 void 8727 scsi_hba_tgtmap_destroy(scsi_hba_tgtmap_t *handle) 8728 { 8729 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8730 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8731 int i; 8732 8733 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8734 if (tgtmap->tgtmap_dam[i]) { 8735 SCSI_HBA_LOG((_LOGTGT, self, NULL, 8736 "%s", damap_name(tgtmap->tgtmap_dam[i]))); 8737 damap_destroy(tgtmap->tgtmap_dam[i]); 8738 } 8739 } 8740 kmem_free(tgtmap, sizeof (*tgtmap)); 8741 } 8742 8743 /* return 1 if all maps ended up syned */ 8744 static int 8745 scsi_tgtmap_sync(scsi_hba_tgtmap_t *handle, int sync_usec) 8746 { 8747 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8748 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8749 int all_synced = 1; 8750 int synced; 8751 int i; 8752 8753 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8754 if (tgtmap->tgtmap_dam[i]) { 8755 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s sync begin", 8756 damap_name(tgtmap->tgtmap_dam[i]))); 8757 synced = damap_sync(tgtmap->tgtmap_dam[i], sync_usec); 8758 all_synced &= synced; 8759 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s sync end %d", 8760 damap_name(tgtmap->tgtmap_dam[i]), synced)); 8761 8762 } 8763 } 8764 return (all_synced); 8765 } 8766 8767 /* return 1 if all maps ended up empty */ 8768 static int 8769 scsi_tgtmap_is_empty(scsi_hba_tgtmap_t *handle) 8770 { 8771 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8772 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8773 int all_empty = 1; 8774 int empty; 8775 int i; 8776 8777 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8778 if (tgtmap->tgtmap_dam[i]) { 8779 empty = damap_is_empty(tgtmap->tgtmap_dam[i]); 8780 all_empty &= empty; 8781 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s is_empty %d", 8782 damap_name(tgtmap->tgtmap_dam[i]), empty)); 8783 } 8784 } 8785 8786 return (all_empty); 8787 } 8788 8789 static int 8790 scsi_tgtmap_beginf(scsi_hba_tgtmap_t *handle, boolean_t do_begin) 8791 { 8792 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8793 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8794 char *context; 8795 int rv = DAM_SUCCESS; 8796 int i; 8797 8798 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8799 if (tgtmap->tgtmap_dam[i] == NULL) { 8800 continue; 8801 } 8802 8803 context = damap_name(tgtmap->tgtmap_dam[i]); 8804 if (do_begin == B_TRUE) { 8805 if (i == SCSI_TGT_SCSI_DEVICE) { 8806 /* 8807 * In scsi_device context, so we have the 8808 * 'context' string, diagnose the case where 8809 * the tgtmap caller is failing to make 8810 * forward progress, i.e. the caller is never 8811 * completing an observation by calling 8812 * scsi_hbg_tgtmap_set_end. If this occurs, 8813 * the solaris target/lun state may be out 8814 * of sync with hardware. 8815 */ 8816 if (tgtmap->tgtmap_reports++ >= 8817 scsi_hba_tgtmap_reports_max) { 8818 tgtmap->tgtmap_noisy++; 8819 if (tgtmap->tgtmap_noisy == 1) { 8820 SCSI_HBA_LOG((_LOG(WARN), 8821 self, NULL, 8822 "%s: failing tgtmap begin", 8823 context)); 8824 } 8825 } 8826 } 8827 8828 rv = damap_addrset_begin(tgtmap->tgtmap_dam[i]); 8829 } else { 8830 rv = damap_addrset_flush(tgtmap->tgtmap_dam[i]); 8831 } 8832 8833 if (rv != DAM_SUCCESS) { 8834 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s FAIL", context)); 8835 } else { 8836 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context)); 8837 } 8838 } 8839 8840 return ((rv == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 8841 } 8842 8843 8844 int 8845 scsi_hba_tgtmap_set_begin(scsi_hba_tgtmap_t *handle) 8846 { 8847 return (scsi_tgtmap_beginf(handle, B_TRUE)); 8848 } 8849 8850 int 8851 scsi_hba_tgtmap_set_flush(scsi_hba_tgtmap_t *handle) 8852 { 8853 return (scsi_tgtmap_beginf(handle, B_FALSE)); 8854 } 8855 8856 int 8857 scsi_hba_tgtmap_set_add(scsi_hba_tgtmap_t *handle, 8858 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr, void *tgt_priv) 8859 { 8860 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8861 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8862 8863 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type]) 8864 return (DDI_FAILURE); 8865 8866 SCSI_HBA_LOG((_LOGTGT, self, NULL, 8867 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr)); 8868 8869 return ((damap_addrset_add(tgtmap->tgtmap_dam[tgt_type], tgt_addr, 8870 NULL, NULL, tgt_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 8871 } 8872 8873 /*ARGSUSED*/ 8874 int 8875 scsi_hba_tgtmap_set_end(scsi_hba_tgtmap_t *handle, uint_t flags) 8876 { 8877 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8878 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8879 char *context; 8880 int rv = DDI_SUCCESS; 8881 int i; 8882 8883 tgtmap->tgtmap_reports = tgtmap->tgtmap_noisy = 0; 8884 8885 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8886 if (tgtmap->tgtmap_dam[i] == NULL) 8887 continue; 8888 context = damap_name(tgtmap->tgtmap_dam[i]); 8889 if (damap_addrset_end( 8890 tgtmap->tgtmap_dam[i], 0) != DAM_SUCCESS) { 8891 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s FAIL", context)); 8892 rv = DDI_FAILURE; 8893 continue; 8894 } 8895 8896 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context)); 8897 } 8898 return (rv); 8899 } 8900 8901 int 8902 scsi_hba_tgtmap_tgt_add(scsi_hba_tgtmap_t *handle, 8903 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr, void *tgt_priv) 8904 8905 { 8906 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8907 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8908 8909 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type]) 8910 return (DDI_FAILURE); 8911 8912 SCSI_HBA_LOG((_LOGTGT, self, NULL, 8913 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr)); 8914 8915 return ((damap_addr_add(tgtmap->tgtmap_dam[tgt_type], tgt_addr, NULL, 8916 NULL, tgt_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 8917 } 8918 8919 int 8920 scsi_hba_tgtmap_tgt_remove(scsi_hba_tgtmap_t *handle, 8921 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr) 8922 { 8923 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8924 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8925 8926 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type]) 8927 return (DDI_FAILURE); 8928 8929 SCSI_HBA_LOG((_LOGTGT, self, NULL, 8930 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr)); 8931 8932 return ((damap_addr_del(tgtmap->tgtmap_dam[tgt_type], 8933 tgt_addr) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 8934 } 8935 8936 int 8937 scsi_hba_tgtmap_lookup(scsi_hba_tgtmap_t *handle, 8938 char *tgt_addr, scsi_tgtmap_tgt_type_t *r_type) 8939 { 8940 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle; 8941 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip; 8942 damap_id_t tgtid; 8943 int i; 8944 8945 for (i = 0; i < SCSI_TGT_NTYPES; i++) { 8946 tgtid = damap_lookup(tgtmap->tgtmap_dam[i], tgt_addr); 8947 if (tgtid != NODAM) { 8948 *r_type = i; 8949 SCSI_HBA_LOG((_LOG(3), self, NULL, 8950 "%s @%s found: type %d", 8951 damap_name(tgtmap->tgtmap_dam[i]), tgt_addr, i)); 8952 damap_id_rele(tgtmap->tgtmap_dam[i], tgtid); 8953 return (DDI_SUCCESS); 8954 } 8955 } 8956 8957 SCSI_HBA_LOG((_LOG(3), self, NULL, 8958 "%s%d.tgtmap @%s not found", 8959 ddi_driver_name(self), ddi_get_instance(self), tgt_addr)); 8960 return (DDI_FAILURE); 8961 } 8962 8963 /* 8964 * Return the unit-address of an 'iport' node, or NULL for non-iport node. 8965 */ 8966 char * 8967 scsi_hba_iport_unit_address(dev_info_t *self) 8968 { 8969 /* 8970 * NOTE: Since 'self' could be a SCSA iport node or a SCSA HBA node, 8971 * we can't use SCSA flavors: the flavor of a SCSA HBA node is not 8972 * established/owned by SCSA, it is established by the nexus that 8973 * created the SCSA HBA node (PCI) as a child. 8974 * 8975 * NOTE: If we want to support a node_name other than "iport" for 8976 * an iport node then we can add support for a "scsa-iport-node-name" 8977 * property on the SCSA HBA node. A SCSA HBA driver would set this 8978 * property on the SCSA HBA node prior to using the iport API. 8979 */ 8980 if (strcmp(ddi_node_name(self), "iport") == 0) 8981 return (ddi_get_name_addr(self)); 8982 else 8983 return (NULL); 8984 } 8985 8986 /* 8987 * Define a SCSI initiator port (bus/channel) for an HBA card that needs to 8988 * support multiple SCSI ports, but only has a single HBA devinfo node. This 8989 * function should be called from the HBA's attach(9E) implementation (when 8990 * processing the HBA devinfo node attach) after the number of SCSI ports on 8991 * the card is known or when the HBA driver DR handler detects a new port. 8992 * The function returns 0 on failure and 1 on success. 8993 * 8994 * The implementation will add the port value into the "scsi-iports" property 8995 * value maintained on the HBA node as. These properties are used by the generic 8996 * scsi bus_config implementation to dynamicaly enumerate the specified iport 8997 * children. The enumeration code will, on demand, create the appropriate 8998 * iport children with a SCSI_ADDR_PROP_IPORTUA unit address. This node will 8999 * bind to the same driver as the HBA node itself. This means that an HBA 9000 * driver that uses iports should expect probe(9E), attach(9E), and detach(9E) 9001 * calls on the iport children of the HBA. If configuration for all ports was 9002 * already done during HBA node attach, the driver should just return 9003 * DDI_SUCCESS when confronted with an iport node. 9004 * 9005 * A maximum of 32 iport ports are supported per HBA devinfo node. 9006 * 9007 * A NULL "port" can be used to indicate that the framework should enumerate 9008 * target children on the HBA node itself, in addition to enumerating target 9009 * children on any iport nodes declared. There are two reasons that an HBA may 9010 * wish to have target children enumerated on both the HBA node and iport 9011 * node(s): 9012 * 9013 * o If, in the past, HBA hardware had only a single physical port but now 9014 * supports multiple physical ports, the updated driver that supports 9015 * multiple physical ports may want to avoid /devices path upgrade issues 9016 * by enumerating the first physical port under the HBA instead of as a 9017 * iport. 9018 * 9019 * o Some hardware RAID HBA controllers (mlx, chs, etc) support multiple 9020 * SCSI physical ports configured so that various physical devices on 9021 * the physical ports are amalgamated into virtual devices on a virtual 9022 * port. Amalgamated physical devices no longer appear to the host OS 9023 * on the physical ports, but other non-amalgamated devices may still be 9024 * visible on the physical ports. These drivers use a model where the 9025 * physical ports are iport nodes and the HBA node is the virtual port to 9026 * the configured virtual devices. 9027 */ 9028 int 9029 scsi_hba_iport_register(dev_info_t *self, char *port) 9030 { 9031 unsigned int ports = 0; 9032 int rval, i; 9033 char **iports, **newiports; 9034 9035 ASSERT(self); 9036 if (self == NULL) 9037 return (DDI_FAILURE); 9038 9039 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self, 9040 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports, 9041 &ports); 9042 9043 if (ports >= SCSI_HBA_MAX_IPORTS) { 9044 ddi_prop_free(iports); 9045 return (DDI_FAILURE); 9046 } 9047 9048 if (rval == DDI_PROP_SUCCESS) { 9049 for (i = 0; i < ports; i++) { 9050 if (strcmp(port, iports[i]) == 0) { 9051 /* iport already registered */ 9052 ddi_prop_free(iports); 9053 return (DDI_SUCCESS); 9054 } 9055 } 9056 } 9057 9058 newiports = kmem_alloc((sizeof (char *) * (ports + 1)), KM_SLEEP); 9059 9060 for (i = 0; i < ports; i++) { 9061 newiports[i] = strdup(iports[i]); 9062 } 9063 newiports[ports] = strdup(port); 9064 ports++; 9065 9066 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, self, 9067 "scsi-iports", newiports, ports) != DDI_PROP_SUCCESS) { 9068 SCSI_HBA_LOG((_LOG(WARN), self, NULL, 9069 "failed to establish %s %s", 9070 SCSI_ADDR_PROP_IPORTUA, port)); 9071 rval = DDI_FAILURE; 9072 } else { 9073 rval = DDI_SUCCESS; 9074 } 9075 9076 /* If there is iport exist, free property */ 9077 if (ports > 1) 9078 ddi_prop_free(iports); 9079 for (i = 0; i < ports; i++) { 9080 strfree(newiports[i]); 9081 } 9082 kmem_free(newiports, (sizeof (char *)) * ports); 9083 9084 return (rval); 9085 } 9086 9087 /* 9088 * Check if the HBA has any scsi_hba_iport_register()ed children. 9089 */ 9090 int 9091 scsi_hba_iport_exist(dev_info_t *self) 9092 { 9093 unsigned int ports = 0; 9094 char **iports; 9095 int rval; 9096 9097 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self, 9098 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports, 9099 &ports); 9100 9101 if (rval != DDI_PROP_SUCCESS) 9102 return (0); 9103 9104 /* If there is now at least 1 iport, then iports is valid */ 9105 if (ports > 0) { 9106 rval = 1; 9107 } else 9108 rval = 0; 9109 ddi_prop_free(iports); 9110 9111 return (rval); 9112 } 9113 9114 dev_info_t * 9115 scsi_hba_iport_find(dev_info_t *self, char *portnm) 9116 { 9117 char *addr = NULL; 9118 char **iports; 9119 unsigned int num_iports = 0; 9120 int rval = DDI_FAILURE; 9121 int i = 0; 9122 dev_info_t *child = NULL; 9123 9124 /* check to see if this is an HBA that defined scsi iports */ 9125 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self, 9126 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports, 9127 &num_iports); 9128 9129 if (rval != DDI_SUCCESS) { 9130 return (NULL); 9131 } 9132 ASSERT(num_iports > 0); 9133 9134 /* check to see if this port was registered */ 9135 for (i = 0; i < num_iports; i++) { 9136 if (strcmp(iports[i], portnm) == 0) 9137 break; 9138 } 9139 9140 if (i == num_iports) { 9141 child = NULL; 9142 goto out; 9143 } 9144 9145 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP); 9146 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s", portnm); 9147 rval = ndi_devi_config_one(self, addr, &child, NDI_NO_EVENT); 9148 kmem_free(addr, SCSI_MAXNAMELEN); 9149 9150 if (rval != DDI_SUCCESS) { 9151 child = NULL; 9152 } 9153 out: 9154 ddi_prop_free(iports); 9155 return (child); 9156 } 9157 9158 /* 9159 * Search/create the specified iport node 9160 */ 9161 static dev_info_t * 9162 scsi_hba_bus_config_port(dev_info_t *self, char *nameaddr, scsi_enum_t se) 9163 { 9164 dev_info_t *child; /* iport child of HBA node */ 9165 scsi_hba_tran_t *tran; 9166 char *addr; 9167 char *compat; 9168 9169 /* 9170 * See if the iport node already exists. 9171 */ 9172 addr = nameaddr + strlen("iport@"); 9173 if (child = ndi_devi_findchild(self, nameaddr)) { 9174 if (ndi_devi_device_isremoved(child)) { 9175 if ((se == SE_HP) || !ndi_dev_is_hotplug_node(child)) { 9176 if (ndi_devi_device_insert(child)) 9177 SCSI_HBA_LOG((_LOGCFG, self, NULL, 9178 "devinfo iport@%s device_reinsert", 9179 addr)); 9180 } else 9181 return (NULL); 9182 } 9183 return (child); 9184 } 9185 9186 9187 /* 9188 * If config based on scsi_hba_iportmap API, only allow create 9189 * from hotplug. 9190 */ 9191 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE); 9192 ASSERT(tran); 9193 if (tran->tran_iportmap && (se != SE_HP)) 9194 return (NULL); 9195 9196 /* allocate and initialize a new "iport" node */ 9197 ndi_devi_alloc_sleep(self, "iport", 9198 (se == SE_HP) ? DEVI_SID_HP_NODEID : DEVI_SID_NODEID, 9199 &child); 9200 ASSERT(child); 9201 /* 9202 * Set the flavor of the child to be IPORT flavored 9203 */ 9204 ndi_flavor_set(child, SCSA_FLAVOR_IPORT); 9205 9206 /* 9207 * Add the SCSI_ADDR_PROP_IPORTUA addressing property for this child. 9208 * This property is used to identify a iport node, and to represent the 9209 * nodes @addr form via node properties. 9210 * 9211 * Add "compatible" property to the "scsi-iport" node to cause it bind 9212 * to the same driver as the HBA driver. Use the "driver" name 9213 * instead of the "binding name" to distinguish from hw node. 9214 * 9215 * Give the HBA a chance, via tran_set_name_prop, to set additional 9216 * iport node properties or to change the "compatible" binding 9217 * prior to init_child. 9218 * 9219 * NOTE: the order of these operations is important so that 9220 * scsi_hba_iport works when called. 9221 */ 9222 compat = (char *)ddi_driver_name(self); 9223 if ((ndi_prop_update_string(DDI_DEV_T_NONE, child, 9224 SCSI_ADDR_PROP_IPORTUA, addr) != DDI_PROP_SUCCESS) || 9225 (ndi_prop_update_string_array(DDI_DEV_T_NONE, child, 9226 "compatible", &compat, 1) != DDI_PROP_SUCCESS) || 9227 ddi_pathname_obp_set(child, NULL) != DDI_SUCCESS) { 9228 SCSI_HBA_LOG((_LOG_NF(WARN), "%s failed dynamic decoration", 9229 nameaddr)); 9230 (void) ddi_remove_child(child, 0); 9231 child = NULL; 9232 } else { 9233 /* 9234 * Online/attach in order to get events so devfsadm will 9235 * create public names. 9236 */ 9237 ndi_hold_devi(child); 9238 if (ndi_devi_online(child, 0) != NDI_SUCCESS) { 9239 ndi_rele_devi(child); 9240 ndi_prop_remove_all(child); 9241 (void) ndi_devi_free(child); 9242 child = NULL; 9243 } else 9244 ndi_rele_devi(child); 9245 } 9246 9247 return (child); 9248 } 9249 9250 #ifdef sparc 9251 /* 9252 * Future: When iportmap boot support is added, consider rewriting this to 9253 * perform a scsi_hba_bus_config(BUS_CONFIG_ALL) on self (HBA) followed by 9254 * a scsi_hba_bus_config(BUS_CONFIG_ONE) on each child of self (each iport). 9255 */ 9256 /* ARGSUSED */ 9257 static int 9258 scsi_hba_bus_config_prom_node(dev_info_t *self, uint_t flags, 9259 void *arg, dev_info_t **childp) 9260 { 9261 char **iports; 9262 int circ, i; 9263 int ret = NDI_FAILURE; 9264 unsigned int num_iports = 0; 9265 dev_info_t *pdip = NULL; 9266 char *addr = NULL; 9267 9268 /* check to see if this is an HBA that defined scsi iports */ 9269 ret = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self, 9270 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports, 9271 &num_iports); 9272 9273 if (ret != DDI_SUCCESS) { 9274 return (ret); 9275 } 9276 9277 ASSERT(num_iports > 0); 9278 9279 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP); 9280 9281 ret = NDI_FAILURE; 9282 9283 scsi_hba_devi_enter(self, &circ); 9284 9285 /* create iport nodes for each scsi port/bus */ 9286 for (i = 0; i < num_iports; i++) { 9287 bzero(addr, SCSI_MAXNAMELEN); 9288 /* Prepend the iport name */ 9289 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s", 9290 iports[i]); 9291 if (pdip = scsi_hba_bus_config_port(self, addr, SE_BUSCONFIG)) { 9292 if (ndi_busop_bus_config(self, NDI_NO_EVENT, 9293 BUS_CONFIG_ONE, addr, &pdip, 0) != 9294 NDI_SUCCESS) { 9295 continue; 9296 } 9297 /* 9298 * Try to configure child under iport see wehter 9299 * request node is the child of the iport node 9300 */ 9301 if (ndi_devi_config_one(pdip, arg, childp, 9302 NDI_NO_EVENT) == NDI_SUCCESS) { 9303 ret = NDI_SUCCESS; 9304 break; 9305 } 9306 } 9307 } 9308 9309 scsi_hba_devi_exit(self, circ); 9310 9311 kmem_free(addr, SCSI_MAXNAMELEN); 9312 9313 ddi_prop_free(iports); 9314 9315 return (ret); 9316 } 9317 #endif 9318 9319 /* 9320 * Perform iport port/bus bus_config. 9321 */ 9322 static int 9323 scsi_hba_bus_config_iports(dev_info_t *self, uint_t flags, 9324 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 9325 { 9326 char *nameaddr, *addr; 9327 char **iports; 9328 int circ, i; 9329 int ret = NDI_FAILURE; 9330 unsigned int num_iports = 0; 9331 9332 /* check to see if this is an HBA that defined scsi iports */ 9333 ret = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self, 9334 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports, 9335 &num_iports); 9336 9337 if (ret != DDI_SUCCESS) { 9338 return (ret); 9339 } 9340 9341 ASSERT(num_iports > 0); 9342 9343 scsi_hba_devi_enter(self, &circ); 9344 9345 switch (op) { 9346 case BUS_CONFIG_ONE: 9347 /* return if this operation is not against an iport node */ 9348 nameaddr = (char *)arg; 9349 if ((nameaddr == NULL) || 9350 (strncmp(nameaddr, "iport@", strlen("iport@")) != 0)) { 9351 ret = NDI_FAILURE; 9352 scsi_hba_devi_exit(self, circ); 9353 ddi_prop_free(iports); 9354 return (ret); 9355 } 9356 9357 /* parse the port number from "iport@%s" */ 9358 addr = nameaddr + strlen("iport@"); 9359 9360 /* check to see if this port was registered */ 9361 for (i = 0; i < num_iports; i++) { 9362 if (strcmp((iports[i]), addr) == 0) 9363 break; 9364 } 9365 9366 if (i == num_iports) { 9367 ret = NDI_FAILURE; 9368 break; 9369 } 9370 9371 /* create the iport node child */ 9372 if (scsi_hba_bus_config_port(self, nameaddr, SE_BUSCONFIG)) { 9373 ret = NDI_SUCCESS; 9374 } 9375 break; 9376 9377 case BUS_CONFIG_ALL: 9378 case BUS_CONFIG_DRIVER: 9379 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP); 9380 /* create iport nodes for each scsi port/bus */ 9381 for (i = 0; i < num_iports; i++) { 9382 bzero(addr, SCSI_MAXNAMELEN); 9383 /* Prepend the iport name */ 9384 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s", 9385 iports[i]); 9386 (void) scsi_hba_bus_config_port(self, addr, 9387 SE_BUSCONFIG); 9388 } 9389 9390 kmem_free(addr, SCSI_MAXNAMELEN); 9391 ret = NDI_SUCCESS; 9392 break; 9393 } 9394 if (ret == NDI_SUCCESS) { 9395 #ifdef sparc 9396 /* 9397 * Mask NDI_PROMNAME since PROM doesn't have iport 9398 * node at all. 9399 */ 9400 flags &= (~NDI_PROMNAME); 9401 #endif 9402 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */ 9403 ret = ndi_busop_bus_config(self, flags, op, 9404 arg, childp, 0); 9405 } 9406 scsi_hba_devi_exit(self, circ); 9407 9408 ddi_prop_free(iports); 9409 9410 return (ret); 9411 } 9412 9413 static int 9414 scsi_iportmap_config(void *arg, damap_t *mapp, damap_id_t tgtid) 9415 { 9416 dev_info_t *self = (dev_info_t *)arg; 9417 int circ; 9418 char nameaddr[SCSI_MAXNAMELEN]; 9419 char *iport_addr; 9420 dev_info_t *childp; 9421 9422 scsi_hba_devi_enter(self, &circ); 9423 9424 iport_addr = damap_id2addr(mapp, tgtid); 9425 SCSI_HBA_LOG((_LOGIPT, self, NULL, 9426 "%s @%s", damap_name(mapp), iport_addr)); 9427 9428 (void) snprintf(nameaddr, sizeof (nameaddr), "iport@%s", iport_addr); 9429 childp = scsi_hba_bus_config_port(self, nameaddr, SE_HP); 9430 scsi_hba_devi_exit(self, circ); 9431 return (childp != NULL ? DAM_SUCCESS : DAM_FAILURE); 9432 } 9433 9434 static int 9435 scsi_iportmap_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid) 9436 { 9437 dev_info_t *self = arg; 9438 dev_info_t *childp; /* iport child of HBA node */ 9439 int circ, empty; 9440 char *addr; 9441 char nameaddr[SCSI_MAXNAMELEN]; 9442 scsi_hba_tran_t *tran; 9443 9444 addr = damap_id2addr(mapp, tgtid); 9445 SCSI_HBA_LOG((_LOGIPT, self, NULL, "%s @%s", damap_name(mapp), addr)); 9446 9447 (void) snprintf(nameaddr, sizeof (nameaddr), "iport@%s", addr); 9448 scsi_hba_devi_enter(self, &circ); 9449 if ((childp = ndi_devi_findchild(self, nameaddr)) == NULL) { 9450 scsi_hba_devi_exit(self, circ); 9451 return (DAM_FAILURE); 9452 } 9453 9454 tran = ddi_get_driver_private(childp); 9455 ASSERT(tran); 9456 9457 ndi_hold_devi(childp); 9458 scsi_hba_devi_exit(self, circ); 9459 9460 /* 9461 * A begin/end (clear) against the iport's 9462 * tgtmap will trigger unconfigure of all 9463 * targets on the iport. 9464 * 9465 * Future: This bit of code only works if the 9466 * target map reporting style is are full 9467 * reports and not per-address. Maybe we 9468 * should plan on handling this by 9469 * auto-unconfiguration when destroying the 9470 * target map(s). 9471 */ 9472 (void) scsi_hba_tgtmap_set_begin(tran->tran_tgtmap); 9473 (void) scsi_hba_tgtmap_set_end(tran->tran_tgtmap, 0); 9474 9475 /* wait for unconfigure */ 9476 (void) scsi_tgtmap_sync(tran->tran_tgtmap, 0); 9477 empty = scsi_tgtmap_is_empty(tran->tran_tgtmap); 9478 9479 scsi_hba_devi_enter(self, &circ); 9480 ndi_rele_devi(childp); 9481 9482 /* If begin/end/sync ends in empty map, offline/remove. */ 9483 if (empty) { 9484 if (ndi_devi_offline(childp, 9485 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) { 9486 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 9487 "devinfo iport@%s offlined and removed", 9488 addr)); 9489 } else if (ndi_devi_device_remove(childp)) { 9490 /* Offline/rem failed, note new device_remove */ 9491 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, 9492 "devinfo iport@%s offline failed, " 9493 "device_remove", addr)); 9494 } 9495 } 9496 scsi_hba_devi_exit(self, circ); 9497 return (empty ? DAM_SUCCESS : DAM_FAILURE); 9498 } 9499 9500 9501 int 9502 scsi_hba_iportmap_create(dev_info_t *self, int csync_usec, int settle_usec, 9503 scsi_hba_iportmap_t **handle) 9504 { 9505 scsi_hba_tran_t *tran; 9506 damap_t *mapp; 9507 char context[64]; 9508 impl_scsi_iportmap_t *iportmap; 9509 9510 if (self == NULL || csync_usec == 0 || 9511 settle_usec == 0 || handle == NULL) 9512 return (DDI_FAILURE); 9513 9514 *handle = NULL; 9515 9516 if (scsi_hba_iport_unit_address(self) != NULL) 9517 return (DDI_FAILURE); 9518 9519 tran = (scsi_hba_tran_t *)ddi_get_driver_private(self); 9520 ASSERT(tran); 9521 if (tran == NULL) 9522 return (DDI_FAILURE); 9523 9524 (void) snprintf(context, sizeof (context), "%s%d.iportmap", 9525 ddi_driver_name(self), ddi_get_instance(self)); 9526 9527 if (damap_create(context, DAMAP_REPORT_PERADDR, DAMAP_SERIALCONFIG, 9528 settle_usec, NULL, NULL, NULL, self, 9529 scsi_iportmap_config, scsi_iportmap_unconfig, &mapp) != 9530 DAM_SUCCESS) { 9531 return (DDI_FAILURE); 9532 } 9533 iportmap = kmem_zalloc(sizeof (*iportmap), KM_SLEEP); 9534 iportmap->iportmap_hba_dip = self; 9535 iportmap->iportmap_dam = mapp; 9536 9537 iportmap->iportmap_create_window = 1; /* start with window */ 9538 iportmap->iportmap_create_time = ddi_get_lbolt64(); 9539 iportmap->iportmap_create_csync_usec = csync_usec; 9540 iportmap->iportmap_settle_usec = settle_usec; 9541 iportmap->iportmap_sync_cnt = 0; 9542 9543 tran->tran_iportmap = (scsi_hba_iportmap_t *)iportmap; 9544 *handle = (scsi_hba_iportmap_t *)iportmap; 9545 9546 SCSI_HBA_LOG((_LOGIPT, self, NULL, "%s", damap_name(mapp))); 9547 return (DDI_SUCCESS); 9548 } 9549 9550 void 9551 scsi_hba_iportmap_destroy(scsi_hba_iportmap_t *handle) 9552 { 9553 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle; 9554 dev_info_t *self = iportmap->iportmap_hba_dip; 9555 9556 SCSI_HBA_LOG((_LOGIPT, self, NULL, 9557 "%s", damap_name(iportmap->iportmap_dam))); 9558 9559 damap_destroy(iportmap->iportmap_dam); 9560 kmem_free(iportmap, sizeof (*iportmap)); 9561 } 9562 9563 int 9564 scsi_hba_iportmap_iport_add(scsi_hba_iportmap_t *handle, 9565 char *iport_addr, void *iport_priv) 9566 { 9567 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle; 9568 dev_info_t *self = iportmap->iportmap_hba_dip; 9569 9570 SCSI_HBA_LOG((_LOGIPT, self, NULL, 9571 "%s @%s", damap_name(iportmap->iportmap_dam), iport_addr)); 9572 9573 return ((damap_addr_add(iportmap->iportmap_dam, iport_addr, NULL, 9574 NULL, iport_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 9575 } 9576 9577 int 9578 scsi_hba_iportmap_iport_remove(scsi_hba_iportmap_t *handle, 9579 char *iport_addr) 9580 { 9581 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle; 9582 dev_info_t *self = iportmap->iportmap_hba_dip; 9583 9584 SCSI_HBA_LOG((_LOGIPT, self, NULL, 9585 "%s @%s", damap_name(iportmap->iportmap_dam), iport_addr)); 9586 9587 return ((damap_addr_del(iportmap->iportmap_dam, 9588 iport_addr) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 9589 } 9590 9591 int 9592 scsi_hba_iportmap_lookup(scsi_hba_iportmap_t *handle, 9593 char *iport_addr) 9594 { 9595 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle; 9596 dev_info_t *self = iportmap->iportmap_hba_dip; 9597 damap_id_t iportid; 9598 9599 iportid = damap_lookup(iportmap->iportmap_dam, iport_addr); 9600 if (iportid != NODAM) { 9601 SCSI_HBA_LOG((_LOG(3), self, NULL, 9602 "%s @%s found", 9603 damap_name(iportmap->iportmap_dam), iport_addr)); 9604 damap_id_rele(iportmap->iportmap_dam, iportid); 9605 return (DDI_SUCCESS); 9606 } 9607 9608 SCSI_HBA_LOG((_LOG(3), self, NULL, 9609 "%s @%s not found", 9610 damap_name(iportmap->iportmap_dam), iport_addr)); 9611 return (DDI_FAILURE); 9612 } 9613 9614 9615 static int 9616 scsi_lunmap_config(void *arg, damap_t *lundam, damap_id_t lunid) 9617 { 9618 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)arg; 9619 scsi_hba_tran_t *tran = tgtmap->tgtmap_tran; 9620 dev_info_t *self = tran->tran_iport_dip; 9621 char *addr; 9622 9623 addr = damap_id2addr(lundam, lunid); 9624 SCSI_HBA_LOG((_LOGLUN, self, NULL, 9625 "%s @%s", damap_name(lundam), addr)); 9626 if (scsi_hba_bus_configone_addr(self, addr, SE_HP) != NULL) 9627 return (DAM_SUCCESS); 9628 else 9629 return (DAM_FAILURE); 9630 } 9631 9632 static int 9633 scsi_lunmap_unconfig(void *arg, damap_t *lundam, damap_id_t lunid) 9634 { 9635 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)arg; 9636 scsi_hba_tran_t *tran = tgtmap->tgtmap_tran; 9637 dev_info_t *self = tran->tran_iport_dip; 9638 char *addr; 9639 9640 addr = damap_id2addr(lundam, lunid); 9641 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s @%s", damap_name(lundam), 9642 addr)); 9643 9644 scsi_hba_bus_unconfigone_addr(self, addr); 9645 return (DAM_SUCCESS); 9646 } 9647 9648 static int 9649 scsi_lunmap_create(dev_info_t *self, impl_scsi_tgtmap_t *tgtmap, char *taddr) 9650 { 9651 char context[64]; 9652 damap_t *tgtdam; 9653 damap_id_t tgtid; 9654 damap_t *lundam; 9655 int optflags; 9656 9657 (void) snprintf(context, sizeof (context), "%s%d.%s.lunmap", 9658 ddi_driver_name(self), ddi_get_instance(self), taddr); 9659 9660 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]; 9661 tgtid = damap_lookup(tgtdam, taddr); 9662 if (tgtid == NODAM) { 9663 SCSI_HBA_LOG((_LOG(1), self, NULL, 9664 "target %s not found", context)); 9665 return (DDI_FAILURE); 9666 } 9667 9668 lundam = damap_id_priv_get(tgtdam, tgtid); 9669 if (lundam) { 9670 SCSI_HBA_LOG((_LOG(1), self, NULL, 9671 "lunmap %s already created", context)); 9672 damap_id_rele(tgtdam, tgtid); 9673 return (DDI_FAILURE); 9674 } 9675 9676 optflags = (ddi_prop_get_int(DDI_DEV_T_ANY, self, 9677 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration", 9678 scsi_enumeration) & SCSI_ENUMERATION_MT_LUN_DISABLE) ? 9679 DAMAP_SERIALCONFIG : DAMAP_MTCONFIG; 9680 9681 /* NOTE: expected ref at tgtid/taddr: 2: caller + lookup. */ 9682 ASSERT(damap_id_ref(tgtdam, tgtid) == 2); 9683 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s creat, id %d ref %d", 9684 context, tgtid, damap_id_ref(tgtdam, tgtid))); 9685 9686 /* create lundam */ 9687 if (damap_create(context, DAMAP_REPORT_FULLSET, optflags, 1, 9688 NULL, NULL, NULL, tgtmap, scsi_lunmap_config, scsi_lunmap_unconfig, 9689 &lundam) != DAM_SUCCESS) { 9690 SCSI_HBA_LOG((_LOG(1), self, NULL, 9691 "%s create failed, id %d ref %d", 9692 context, tgtid, damap_id_ref(tgtdam, tgtid))); 9693 damap_id_rele(tgtdam, tgtid); 9694 return (DDI_FAILURE); 9695 } 9696 9697 /* 9698 * Return with damap_id_hold at tgtid/taddr from damap_lookup to 9699 * account for damap_id_prv_set below. 9700 */ 9701 damap_id_priv_set(tgtdam, tgtid, lundam); 9702 return (DDI_SUCCESS); 9703 } 9704 9705 static void 9706 scsi_lunmap_destroy(dev_info_t *self, impl_scsi_tgtmap_t *tgtmap, char *taddr) 9707 { 9708 char context[64]; 9709 damap_t *tgtdam; 9710 damap_id_t tgtid; 9711 damap_t *lundam; 9712 9713 (void) snprintf(context, sizeof (context), "%s%d.%s.lunmap", 9714 ddi_driver_name(self), ddi_get_instance(self), taddr); 9715 9716 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]; 9717 tgtid = damap_lookup(tgtdam, taddr); 9718 if (tgtid == NODAM) { 9719 SCSI_HBA_LOG((_LOG(1), self, NULL, 9720 "target %s not found", context)); 9721 return; 9722 } 9723 9724 lundam = (damap_t *)damap_id_priv_get(tgtdam, tgtid); 9725 if (lundam == NULL) { 9726 damap_id_rele(tgtdam, tgtid); /* from damap_lookup */ 9727 SCSI_HBA_LOG((_LOG(1), self, NULL, 9728 "lunmap %s already destroyed", context)); 9729 return; 9730 } 9731 9732 /* NOTE: expected ref at tgtid/taddr: 3: priv_set + caller + lookup. */ 9733 ASSERT(damap_id_ref(tgtdam, tgtid) == 3); 9734 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s, id %d ref %d", 9735 damap_name(lundam), tgtid, damap_id_ref(tgtdam, tgtid))); 9736 9737 /* 9738 * A begin/end (clear) against a target's lunmap will trigger 9739 * unconfigure of all LUNs on the target. 9740 */ 9741 scsi_lunmap_set_begin(self, lundam); 9742 scsi_lunmap_set_end(self, lundam); 9743 9744 SCSI_HBA_LOG((_LOGLUN, self, NULL, 9745 "%s sync begin", damap_name(lundam))); 9746 9747 (void) damap_sync(lundam, 0); /* wait for unconfigure */ 9748 9749 SCSI_HBA_LOG((_LOGLUN, self, NULL, 9750 "%s sync end", damap_name(lundam))); 9751 9752 damap_id_priv_set(tgtdam, tgtid, NULL); 9753 9754 /* release hold established by damap_lookup above */ 9755 damap_id_rele(tgtdam, tgtid); 9756 9757 /* release hold established since scsi_lunmap_create() */ 9758 damap_id_rele(tgtdam, tgtid); 9759 9760 damap_destroy(lundam); 9761 } 9762 9763 static void 9764 scsi_lunmap_set_begin(dev_info_t *self, damap_t *lundam) 9765 { 9766 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s", damap_name(lundam))); 9767 9768 (void) damap_addrset_begin(lundam); 9769 } 9770 9771 static int 9772 scsi_lunmap_set_add(dev_info_t *self, damap_t *lundam, 9773 char *taddr, scsi_lun64_t lun64, int sfunc) 9774 { 9775 char ua[SCSI_MAXNAMELEN]; 9776 9777 /* make unit address string form of "@taddr,lun[,sfunc]" */ 9778 if (sfunc == -1) 9779 (void) snprintf(ua, sizeof (ua), "%s,%" PRIx64, taddr, lun64); 9780 else 9781 (void) snprintf(ua, sizeof (ua), "%s,%" PRIx64 ",%x", 9782 taddr, lun64, sfunc); 9783 9784 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s @%s", damap_name(lundam), ua)); 9785 9786 return ((damap_addrset_add(lundam, ua, NULL, NULL, 9787 NULL) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 9788 } 9789 9790 static void 9791 scsi_lunmap_set_end(dev_info_t *self, damap_t *lundam) 9792 { 9793 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s", damap_name(lundam))); 9794 9795 (void) damap_addrset_end(lundam, 0); 9796 } 9797 9798 int 9799 scsi_lunmap_lookup(dev_info_t *self, damap_t *lundam, char *addr) 9800 { 9801 damap_id_t lunid; 9802 9803 if ((lunid = damap_lookup(lundam, addr)) != NODAM) { 9804 SCSI_HBA_LOG((_LOG(3), self, NULL, 9805 "%s @%s found", damap_name(lundam), addr)); 9806 damap_id_rele(lundam, lunid); 9807 return (DDI_SUCCESS); 9808 } 9809 9810 SCSI_HBA_LOG((_LOG(3), self, NULL, 9811 "%s @%s not found", damap_name(lundam), addr)); 9812 return (DDI_FAILURE); 9813 } 9814 9815 /* 9816 * phymap implementation 9817 * 9818 * We manage the timed aggregation of phys into a phy map * by creating a 9819 * SAS port construct (based upon 'name' of "local,remote" SAS addresses) 9820 * upon the first link up. As time goes on additional phys may join that port. 9821 * After an appropriate amount of settle time, we trigger the activation 9822 * callback which will then take the resultant bit mask of phys (phymask) in 9823 * the SAS port and use that to call back to the callback function 9824 * provided by the additional caller. 9825 * 9826 * We cross check to make sure that phys only exist in one SAS port at a 9827 * time by having soft state for each phy point back to the created 9828 * SAS port. 9829 * 9830 * NOTE: Make SAS_PHY_UA_LEN max(SAS_PHY_PHYMASK_LEN, SAS_PHY_NAME_LEN) 9831 * so we have enough space if sas_phymap_bitset2phymaskua phymask address 9832 * is already in use, and we end up using port name as unit address. 9833 */ 9834 #define SAS_PHY_NAME_FMT "%" PRIx64 ",%" PRIx64 9835 #define SAS_PHY_NAME_LEN (16 + 1 + 16 + 1) 9836 #define SAS_PHY_NPHY (SAS2_PHYNUM_MAX + 1) 9837 #define SAS_PHY_PHYMASK_LEN ((roundup(SAS_PHY_NPHY, 4)) / 4) 9838 #if (SAS_PHY_PHYMASK_LEN > SAS_PHY_NAME_LEN) 9839 #define SAS_PHY_UA_LEN SAS_PHY_PHYMASK_LEN 9840 #else 9841 #define SAS_PHY_UA_LEN SAS_PHY_NAME_LEN 9842 #endif 9843 typedef struct impl_sas_physet { /* needed for name2phys destroy */ 9844 struct impl_sas_physet *physet_next; 9845 char *physet_name; 9846 bitset_t *physet_phys; 9847 } impl_sas_physet_t; 9848 typedef struct impl_sas_phymap { 9849 dev_info_t *phymap_self; 9850 9851 kmutex_t phymap_lock; 9852 damap_t *phymap_dam; 9853 void *phymap_phy2name; 9854 ddi_soft_state_bystr *phymap_name2phys; /* bitset */ 9855 ddi_soft_state_bystr *phymap_name2ua; 9856 ddi_soft_state_bystr *phymap_ua2name; 9857 9858 /* Noisy phy information - ensure forward progress for noisy phys */ 9859 int phymap_phy_max; /* max phy# */ 9860 int phymap_reports; /* per period */ 9861 int phymap_reports_max; /* scales */ 9862 int phymap_phys_noisy; /* detected */ 9863 9864 /* These are for callbacks to the consumer. */ 9865 sas_phymap_activate_cb_t phymap_acp; 9866 sas_phymap_deactivate_cb_t phymap_dcp; 9867 void *phymap_private; 9868 9869 struct impl_sas_physet *phymap_physets; 9870 } impl_sas_phymap_t; 9871 9872 /* Detect noisy phy: max changes per stabilization period per phy. */ 9873 static int sas_phymap_phy_max_factor = 16; 9874 9875 /* 9876 * Convert bitset into a unit-address string. The maximum string length would 9877 * be the maximum number of phys, rounded up by 4 and divided by 4. 9878 */ 9879 static void 9880 sas_phymap_bitset2phymaskua(bitset_t *phys, char *buf) 9881 { 9882 char *ptr; 9883 int grp; 9884 int cur; 9885 uint_t bit; 9886 9887 bit = roundup(SAS_PHY_NPHY, 4); 9888 grp = 4; 9889 ptr = buf; 9890 cur = 0; 9891 do { 9892 bit -= 1; 9893 grp -= 1; 9894 if (bitset_in_set(phys, bit)) { 9895 cur |= (1 << grp); 9896 } 9897 if (grp == 0) { 9898 grp = 4; 9899 if (cur || ptr != buf) { 9900 *ptr++ = "0123456789abcdef"[cur]; 9901 *ptr = 0; 9902 } 9903 cur = 0; 9904 } 9905 } while (bit != 0); 9906 if (ptr == buf) { 9907 *ptr++ = '0'; 9908 *ptr = 0; 9909 } 9910 } 9911 9912 static int 9913 sas_phymap_config(void *arg, damap_t *phydam, damap_id_t phyid) 9914 { 9915 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)arg; 9916 char *context = damap_name(phymap->phymap_dam); 9917 char *damn; 9918 char *name; 9919 bitset_t *phys; 9920 char *ua; 9921 void *ua_priv; 9922 9923 ASSERT(context); 9924 9925 mutex_enter(&phymap->phymap_lock); 9926 phymap->phymap_reports = phymap->phymap_phys_noisy = 0; 9927 9928 /* Get the name ("local,remote" address string) from damap. */ 9929 damn = damap_id2addr(phydam, phyid); 9930 9931 /* Get the bitset of phys currently forming the port. */ 9932 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, damn); 9933 if (phys == NULL) { 9934 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: no phys", 9935 context, damn)); 9936 mutex_exit(&phymap->phymap_lock); 9937 return (DAM_FAILURE); 9938 } 9939 9940 /* allocate, get, and initialize name index of name2ua map */ 9941 if (ddi_soft_state_bystr_zalloc(phymap->phymap_name2ua, damn) != 9942 DDI_SUCCESS) { 9943 SCSI_HBA_LOG((_LOG_NF(WARN), 9944 "%s: %s: failed name2ua alloc", context, damn)); 9945 mutex_exit(&phymap->phymap_lock); 9946 return (DAM_FAILURE); 9947 } 9948 if (!(ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, damn))) { 9949 SCSI_HBA_LOG((_LOG_NF(WARN), 9950 "%s: %s: no name2ua", context, damn)); 9951 mutex_exit(&phymap->phymap_lock); 9952 return (DAM_FAILURE); 9953 } 9954 sas_phymap_bitset2phymaskua(phys, ua); /* set ua */ 9955 9956 /* see if phymask ua index already allocated in ua2name map */ 9957 if (name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua)) { 9958 /* 9959 * The 'phymask' sas_phymap_bitset2phymaskua ua is 9960 * already in use. This means that original phys have 9961 * formed into a new port, and that the original port 9962 * still exists (it has migrated to some completely 9963 * different set of phys). In this corner-case we use 9964 * "local,remote" name as a 'temporary' unit address. 9965 * Reset ua in name2ua map. 9966 */ 9967 (void) strlcpy(ua, damn, SAS_PHY_NAME_LEN); 9968 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua); 9969 if (name) { 9970 /* The "local,remote" ua should be new... */ 9971 SCSI_HBA_LOG((_LOG_NF(WARN), 9972 "%s: %s ua already configured", 9973 context, ua)); 9974 mutex_exit(&phymap->phymap_lock); 9975 return (DAM_SUCCESS); 9976 } 9977 } 9978 9979 /* allocate, get, and init ua index of ua2name map */ 9980 if (ddi_soft_state_bystr_zalloc(phymap->phymap_ua2name, ua) != 9981 DDI_SUCCESS) { 9982 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn); 9983 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: failed ua2name alloc", 9984 context, damn)); 9985 mutex_exit(&phymap->phymap_lock); 9986 return (DAM_FAILURE); 9987 } 9988 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua); 9989 if (name == NULL) { 9990 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn); 9991 SCSI_HBA_LOG((_LOG_NF(WARN), 9992 "%s: %s: no ua2name", context, ua)); 9993 mutex_exit(&phymap->phymap_lock); 9994 return (DAM_FAILURE); 9995 } 9996 9997 /* set name in ua2name map */ 9998 (void) strlcpy(name, damn, SAS_PHY_NAME_LEN); 9999 10000 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10001 "%s: %s: ua %s: activate", context, damn, ua)); 10002 10003 if (phymap->phymap_acp) { 10004 /* 10005 * drop our lock and invoke the activation callback 10006 */ 10007 mutex_exit(&phymap->phymap_lock); 10008 ua_priv = NULL; 10009 (phymap->phymap_acp)(phymap->phymap_private, ua, &ua_priv); 10010 mutex_enter(&phymap->phymap_lock); 10011 damap_id_priv_set(phydam, phyid, ua_priv); 10012 } 10013 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10014 "%s: %s: ua %s: activate complete", context, damn, ua)); 10015 mutex_exit(&phymap->phymap_lock); 10016 return (DAM_SUCCESS); 10017 } 10018 10019 /*ARGSUSED*/ 10020 static int 10021 sas_phymap_unconfig(void *arg, damap_t *phydam, damap_id_t phyid) 10022 { 10023 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)arg; 10024 char *context = damap_name(phymap->phymap_dam); 10025 char *damn; 10026 char *ua; 10027 void *ua_priv; 10028 10029 ASSERT(context); 10030 10031 mutex_enter(&phymap->phymap_lock); 10032 phymap->phymap_reports = phymap->phymap_phys_noisy = 0; 10033 10034 /* Get the name ("local,remote" address string) from damap. */ 10035 damn = damap_id2addr(phydam, phyid); 10036 10037 if (!(ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, damn))) { 10038 SCSI_HBA_LOG((_LOG_NF(WARN), 10039 "%s: %s: no name2ua", context, damn)); 10040 mutex_exit(&phymap->phymap_lock); 10041 return (DAM_FAILURE); 10042 } 10043 10044 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10045 "%s: %s: ua %s: deactivate", context, damn, ua)); 10046 if (phymap->phymap_dcp) { 10047 ua_priv = damap_id_priv_get(phydam, phyid); 10048 mutex_exit(&phymap->phymap_lock); 10049 (phymap->phymap_dcp)(phymap->phymap_private, ua, ua_priv); 10050 mutex_enter(&phymap->phymap_lock); 10051 } 10052 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10053 "%s: %s: ua %s: deactivate complete", context, damn, ua)); 10054 10055 /* delete ua<->name mappings */ 10056 ddi_soft_state_bystr_free(phymap->phymap_ua2name, ua); 10057 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn); 10058 mutex_exit(&phymap->phymap_lock); 10059 return (DAM_SUCCESS); 10060 } 10061 10062 int 10063 sas_phymap_create(dev_info_t *self, int settle_usec, 10064 sas_phymap_mode_t mode, void *mode_argument, void *phymap_priv, 10065 sas_phymap_activate_cb_t activate_cb, 10066 sas_phymap_deactivate_cb_t deactivate_cb, 10067 sas_phymap_t **handlep) 10068 { 10069 _NOTE(ARGUNUSED(mode_argument)); 10070 char context[64]; 10071 impl_sas_phymap_t *phymap; 10072 10073 if (self == NULL || settle_usec == 0 || handlep == NULL) 10074 return (DDI_FAILURE); 10075 10076 if (mode != PHYMAP_MODE_SIMPLE) 10077 return (DDI_FAILURE); 10078 10079 phymap = kmem_zalloc(sizeof (*phymap), KM_SLEEP); 10080 phymap->phymap_self = self; 10081 phymap->phymap_reports_max = 1 * sas_phymap_phy_max_factor; 10082 phymap->phymap_acp = activate_cb; 10083 phymap->phymap_dcp = deactivate_cb; 10084 phymap->phymap_private = phymap_priv; 10085 mutex_init(&phymap->phymap_lock, NULL, MUTEX_DRIVER, NULL); 10086 10087 (void) snprintf(context, sizeof (context), "%s%d.phymap", 10088 ddi_driver_name(self), ddi_get_instance(self)); 10089 SCSI_HBA_LOG((_LOGPHY, self, NULL, "%s", context)); 10090 10091 if (ddi_soft_state_init(&phymap->phymap_phy2name, 10092 SAS_PHY_NAME_LEN, SAS_PHY_NPHY) != 0) 10093 goto fail; 10094 if (ddi_soft_state_bystr_init(&phymap->phymap_name2phys, 10095 sizeof (bitset_t), SAS_PHY_NPHY) != 0) 10096 goto fail; 10097 10098 if (ddi_soft_state_bystr_init(&phymap->phymap_name2ua, 10099 SAS_PHY_UA_LEN, SAS_PHY_NPHY) != 0) 10100 goto fail; 10101 if (ddi_soft_state_bystr_init(&phymap->phymap_ua2name, 10102 SAS_PHY_NAME_LEN, SAS_PHY_NPHY) != 0) 10103 goto fail; 10104 10105 if (damap_create(context, DAMAP_REPORT_PERADDR, DAMAP_SERIALCONFIG, 10106 settle_usec, NULL, NULL, NULL, 10107 phymap, sas_phymap_config, sas_phymap_unconfig, 10108 &phymap->phymap_dam) != DAM_SUCCESS) 10109 goto fail; 10110 10111 10112 *handlep = (sas_phymap_t *)phymap; 10113 return (DDI_SUCCESS); 10114 10115 fail: sas_phymap_destroy((sas_phymap_t *)phymap); 10116 *handlep = NULL; 10117 return (DDI_FAILURE); 10118 } 10119 10120 void 10121 sas_phymap_destroy(sas_phymap_t *handle) 10122 { 10123 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10124 char *context; 10125 struct impl_sas_physet *physet, *nphyset; 10126 bitset_t *phys; 10127 char *name; 10128 10129 context = phymap->phymap_dam ? 10130 damap_name(phymap->phymap_dam) : "unknown"; 10131 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s", context)); 10132 10133 if (phymap->phymap_dam) 10134 damap_destroy(phymap->phymap_dam); 10135 10136 /* free the bitsets of allocated physets */ 10137 for (physet = phymap->phymap_physets; physet; physet = nphyset) { 10138 nphyset = physet->physet_next; 10139 phys = physet->physet_phys; 10140 name = physet->physet_name; 10141 10142 if (phys) 10143 bitset_fini(phys); 10144 if (name) { 10145 ddi_soft_state_bystr_free( 10146 phymap->phymap_name2phys, name); 10147 strfree(name); 10148 } 10149 kmem_free(physet, sizeof (*physet)); 10150 } 10151 10152 /* free the maps */ 10153 if (phymap->phymap_ua2name) 10154 ddi_soft_state_bystr_fini(&phymap->phymap_ua2name); 10155 if (phymap->phymap_name2ua) 10156 ddi_soft_state_bystr_fini(&phymap->phymap_name2ua); 10157 10158 if (phymap->phymap_name2phys) 10159 ddi_soft_state_bystr_fini(&phymap->phymap_name2phys); 10160 if (phymap->phymap_phy2name) 10161 ddi_soft_state_fini(&phymap->phymap_phy2name); 10162 10163 mutex_destroy(&phymap->phymap_lock); 10164 kmem_free(phymap, sizeof (*phymap)); 10165 } 10166 10167 10168 int 10169 sas_phymap_phy_add(sas_phymap_t *handle, 10170 int phy, uint64_t local, uint64_t remote) 10171 { 10172 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10173 char *context = damap_name(phymap->phymap_dam); 10174 char port[SAS_PHY_NAME_LEN]; 10175 char *name; 10176 int phy2name_allocated = 0; 10177 bitset_t *phys; 10178 struct impl_sas_physet *physet; 10179 int rv; 10180 10181 /* Create the SAS port name from the local and remote addresses. */ 10182 (void) snprintf(port, SAS_PHY_NAME_LEN, SAS_PHY_NAME_FMT, 10183 local, remote); 10184 10185 mutex_enter(&phymap->phymap_lock); 10186 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s: %s: add phy %d", 10187 context, port, phy)); 10188 10189 /* Check for conflict in phy2name map */ 10190 name = ddi_get_soft_state(phymap->phymap_phy2name, phy); 10191 if (name) { 10192 if (strcmp(name, port) != 0) 10193 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: add phy %d: " 10194 "already in %s", context, port, phy, name)); 10195 else 10196 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: add phy %d: " 10197 "duplicate add", context, port, phy)); 10198 mutex_exit(&phymap->phymap_lock); 10199 return (DDI_FAILURE); 10200 } 10201 10202 /* allocate, get, and initialize phy index of phy2name map */ 10203 if (ddi_soft_state_zalloc( 10204 phymap->phymap_phy2name, phy) != DDI_SUCCESS) { 10205 SCSI_HBA_LOG((_LOG_NF(WARN), 10206 "%s: %s: failed phy2name alloc", context, port)); 10207 goto fail; 10208 } 10209 name = ddi_get_soft_state(phymap->phymap_phy2name, phy); 10210 if (name == NULL) { 10211 SCSI_HBA_LOG((_LOG_NF(WARN), 10212 "%s: %s: no phy2name", context, port)); 10213 goto fail; 10214 } 10215 phy2name_allocated = 1; 10216 (void) strlcpy(name, port, SAS_PHY_NAME_LEN); /* set name */ 10217 10218 /* Find/alloc, initialize name index of name2phys map */ 10219 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name); 10220 if (phys == NULL) { 10221 if (ddi_soft_state_bystr_zalloc(phymap->phymap_name2phys, 10222 name) != DDI_SUCCESS) { 10223 SCSI_HBA_LOG((_LOG_NF(WARN), 10224 "%s: %s: failed name2phys alloc", context, name)); 10225 goto fail; 10226 } 10227 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name); 10228 if (phys == NULL) { 10229 SCSI_HBA_LOG((_LOG_NF(WARN), 10230 "%s: %s: no name2phys", context, name)); 10231 goto fail; 10232 } 10233 10234 /* Initialize bitset of phys. */ 10235 bitset_init(phys); 10236 bitset_resize(phys, SAS_PHY_NPHY); 10237 10238 /* Keep a list of information for destroy. */ 10239 physet = kmem_zalloc(sizeof (*physet), KM_SLEEP); 10240 physet->physet_name = strdup(name); 10241 physet->physet_phys = phys; 10242 physet->physet_next = phymap->phymap_physets; 10243 phymap->phymap_physets = physet; 10244 } 10245 ASSERT(phys); 10246 10247 /* Reflect 'add' in phys bitset. */ 10248 if (bitset_atomic_test_and_add(phys, phy) < 0) { 10249 /* It is an error if the phy was already recorded. */ 10250 SCSI_HBA_LOG((_LOG_NF(WARN), 10251 "%s: %s: phy bit %d already in port", context, name, phy)); 10252 goto fail; 10253 } 10254 10255 /* 10256 * Check to see if we have a new phy_max for this map, and if so 10257 * scale phymap_reports_max to the new number of phys. 10258 */ 10259 if (phy > phymap->phymap_phy_max) { 10260 phymap->phymap_phy_max = phy + 1; 10261 phymap->phymap_reports_max = phymap->phymap_phy_max * 10262 sas_phymap_phy_max_factor; 10263 } 10264 10265 /* 10266 * If we have not reached phymap_reports_max, start/restart the 10267 * activate timer. Otherwise, if phymap->phymap_reports add/rem reports 10268 * ever exceeds phymap_reports_max due to noisy phys, then report the 10269 * noise and force stabilization by stopping reports into the damap. 10270 * 10271 * The first config/unconfig callout out of the damap will reset 10272 * phymap->phymap_reports. 10273 */ 10274 rv = DDI_SUCCESS; 10275 if (phymap->phymap_reports++ < phymap->phymap_reports_max) { 10276 if (damap_addr_add(phymap->phymap_dam, name, 10277 NULL, NULL, NULL) == DAM_SUCCESS) { 10278 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10279 "%s: %s: damap_addr_add", context, name)); 10280 } else { 10281 SCSI_HBA_LOG((_LOG_NF(WARN), 10282 "%s: %s: damap_addr_add failed", context, name)); 10283 rv = DDI_FAILURE; 10284 } 10285 } else { 10286 phymap->phymap_phys_noisy++; 10287 if (phymap->phymap_phys_noisy == 1) 10288 SCSI_HBA_LOG((_LOG_NF(WARN), 10289 "%s: %s: noisy phys", context, name)); 10290 } 10291 mutex_exit(&phymap->phymap_lock); 10292 return (rv); 10293 10294 fail: if (phy2name_allocated) 10295 ddi_soft_state_free(phymap->phymap_phy2name, phy); 10296 mutex_exit(&phymap->phymap_lock); 10297 return (DDI_FAILURE); 10298 } 10299 10300 int 10301 sas_phymap_phy_rem(sas_phymap_t *handle, int phy) 10302 { 10303 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10304 char *context = damap_name(phymap->phymap_dam); 10305 char *name; 10306 bitset_t *phys; 10307 int rv = DDI_FAILURE; 10308 10309 ASSERT(context); 10310 10311 mutex_enter(&phymap->phymap_lock); 10312 phymap->phymap_reports++; 10313 10314 /* Find and free phy index of phy2name map */ 10315 name = ddi_get_soft_state(phymap->phymap_phy2name, phy); 10316 if (name == NULL) { 10317 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: rem phy %d: never added", 10318 context, phy)); 10319 goto fail; 10320 } 10321 /* NOTE: always free phy index of phy2name map before return... */ 10322 10323 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s: %s: rem phy %d", 10324 context, name, phy)); 10325 10326 /* Get bitset of phys currently associated with named port. */ 10327 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name); 10328 if (phys == NULL) { 10329 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: name2phys failed", 10330 context, name)); 10331 goto fail; 10332 } 10333 10334 /* Reflect 'rem' in phys bitset. */ 10335 if (bitset_atomic_test_and_del(phys, phy) < 0) { 10336 /* It is an error if the phy wasn't one of the port's phys. */ 10337 SCSI_HBA_LOG((_LOG_NF(WARN), 10338 "%s: %s: phy bit %d not in port", context, name, phy)); 10339 goto fail; 10340 } 10341 10342 /* If this was the last phy in the port, start the deactivate timer. */ 10343 if (bitset_is_null(phys) && 10344 (phymap->phymap_reports++ < phymap->phymap_reports_max)) { 10345 if (damap_addr_del(phymap->phymap_dam, name) == DAM_SUCCESS) { 10346 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, 10347 "%s: %s: damap_addr_del", context, name)); 10348 } else { 10349 SCSI_HBA_LOG((_LOG_NF(WARN), 10350 "%s: %s: damap_addr_del failure", context, name)); 10351 goto fail; 10352 } 10353 } 10354 rv = DDI_SUCCESS; 10355 10356 /* free phy index of phy2name map */ 10357 fail: if (name) 10358 ddi_soft_state_free(phymap->phymap_phy2name, phy); /* free */ 10359 mutex_exit(&phymap->phymap_lock); 10360 return (rv); 10361 } 10362 10363 char * 10364 sas_phymap_lookup_ua(sas_phymap_t *handle, uint64_t local, uint64_t remote) 10365 { 10366 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10367 char *context = damap_name(phymap->phymap_dam); 10368 char name[SAS_PHY_NAME_LEN]; 10369 char *ua; 10370 10371 ASSERT(context); 10372 10373 (void) snprintf(name, SAS_PHY_NAME_LEN, SAS_PHY_NAME_FMT, 10374 local, remote); 10375 10376 mutex_enter(&phymap->phymap_lock); 10377 ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, name); 10378 SCSI_HBA_LOG((_LOG(3), phymap->phymap_self, NULL, 10379 "%s: %s: ua %s", context, name, ua ? ua : "NULL")); 10380 mutex_exit(&phymap->phymap_lock); 10381 return (ua); 10382 } 10383 10384 void * 10385 sas_phymap_lookup_uapriv(sas_phymap_t *handle, char *ua) 10386 { 10387 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10388 char *context = damap_name(phymap->phymap_dam); 10389 char *name; 10390 damap_id_t phyid; 10391 void *ua_priv = NULL; 10392 10393 ASSERT(context); 10394 10395 mutex_enter(&phymap->phymap_lock); 10396 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua); 10397 if (name) { 10398 phyid = damap_lookup(phymap->phymap_dam, name); 10399 if (phyid != NODAM) { 10400 ua_priv = damap_id_priv_get(phymap->phymap_dam, phyid); 10401 damap_id_rele(phymap->phymap_dam, phyid); 10402 } 10403 } 10404 10405 SCSI_HBA_LOG((_LOG(3), phymap->phymap_self, NULL, 10406 "%s: %s: ua %s ua_priv %p", context, name, 10407 ua ? ua : "NULL", ua_priv)); 10408 mutex_exit(&phymap->phymap_lock); 10409 return (ua_priv); 10410 } 10411 10412 int 10413 sas_phymap_uahasphys(sas_phymap_t *handle, char *ua) 10414 { 10415 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10416 char *name; 10417 bitset_t *phys; 10418 int n = 0; 10419 10420 mutex_enter(&phymap->phymap_lock); 10421 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua); 10422 if (name) { 10423 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name); 10424 if (phys) 10425 n = bitset_is_null(phys) ? 0 : 1; 10426 } 10427 mutex_exit(&phymap->phymap_lock); 10428 return (n); 10429 } 10430 10431 sas_phymap_phys_t * 10432 sas_phymap_ua2phys(sas_phymap_t *handle, char *ua) 10433 { 10434 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10435 char *name; 10436 bitset_t *phys; 10437 bitset_t *cphys = NULL; 10438 10439 mutex_enter(&phymap->phymap_lock); 10440 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua); 10441 if (name == NULL) 10442 goto fail; 10443 10444 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name); 10445 if (phys == NULL) 10446 goto fail; 10447 10448 /* dup the phys and return */ 10449 cphys = kmem_alloc(sizeof (*cphys), KM_SLEEP); 10450 bitset_init(cphys); 10451 bitset_resize(cphys, SAS_PHY_NPHY); 10452 bitset_copy(phys, cphys); 10453 10454 fail: mutex_exit(&phymap->phymap_lock); 10455 return ((sas_phymap_phys_t *)cphys); 10456 } 10457 10458 int 10459 sas_phymap_phys_next(sas_phymap_phys_t *phys) 10460 { 10461 bitset_t *cphys = (bitset_t *)phys; 10462 int phy; 10463 10464 phy = bitset_find(cphys); 10465 if (phy != -1) 10466 bitset_del(cphys, phy); 10467 return (phy); 10468 } 10469 10470 void 10471 sas_phymap_phys_free(sas_phymap_phys_t *phys) 10472 { 10473 bitset_t *cphys = (bitset_t *)phys; 10474 10475 if (cphys) { 10476 bitset_fini(cphys); 10477 kmem_free(cphys, sizeof (*cphys)); 10478 } 10479 } 10480 10481 char * 10482 sas_phymap_phy2ua(sas_phymap_t *handle, int phy) 10483 { 10484 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle; 10485 char *name; 10486 char *ua; 10487 char *rua = NULL; 10488 10489 mutex_enter(&phymap->phymap_lock); 10490 name = ddi_get_soft_state(phymap->phymap_phy2name, phy); 10491 if (name == NULL) 10492 goto fail; 10493 ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, name); 10494 if (ua == NULL) 10495 goto fail; 10496 10497 /* dup the ua and return */ 10498 rua = strdup(ua); 10499 10500 fail: mutex_exit(&phymap->phymap_lock); 10501 return (rua); 10502 } 10503 10504 void 10505 sas_phymap_ua_free(char *ua) 10506 { 10507 if (ua) 10508 strfree(ua); 10509 } 10510