1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 27 */ 28 29 /* 30 * SCSI device structure. 31 * 32 * All SCSI target drivers will have one of these per target/lun/sfunc. 33 * It is allocated and initialized by the framework SCSA HBA nexus code 34 * for each SCSI target dev_info_t node during HBA nexus DDI_CTLOPS_INITCHILD 35 * processing of a child device node just prior to tran_tgt_init(9E). A 36 * pointer the the scsi_device(9S) structure is stored in the 37 * driver-private data field of the target device's dev_info_t node (in 38 * 'devi_driver_data') and can be retrieved by ddi_get_driver_private(9F). 39 */ 40 #ifndef _SYS_SCSI_CONF_DEVICE_H 41 #define _SYS_SCSI_CONF_DEVICE_H 42 43 #include <sys/scsi/scsi_types.h> 44 45 #ifdef __cplusplus 46 extern "C" { 47 #endif 48 49 struct scsi_device { 50 /* 51 * Routing information for a SCSI device (target/lun/sfunc). 52 * 53 * The scsi_address(9S) structure contains a pointer to the 54 * scsi_hba_tran(9S) of the transport. 55 * 56 * For devices below an HBA that uses SCSI_HBA_ADDR_SPI 57 * unit-addressing, the scsi_address(9S) information contains 58 * decoded target/lun addressing information. 59 * 60 * For devices below an HBA that uses SCSI_HBA_ADDR_COMPLEX 61 * unit-addressing, the scsi_address(9S) information contains a 62 * pointer to the scsi_device(9S) structure and the HBA can maintain 63 * its private per-unit-address/per-scsi_device information using 64 * scsi_address_device(9F) and scsi_device_hba_private_[gs]et(9F). 65 * 66 * NOTE: The scsi_address(9S) structure gets structure-copied into 67 * the scsi_pkt(9S) 'pkt_address' field. Having a pointer to the 68 * scsi_device(9S) structure within the scsi_address(9S) allows 69 * the SCSA framework to reflect generic changes in device state 70 * at scsi_pkt_comp(9F) time (given just a scsi_pkt(9S) pointer). 71 * 72 * NOTE: The older SCSI_HBA_TRAN_CLONE method of supporting 73 * SCSI-3 devices is still supported, but use is discouraged. 74 */ 75 struct scsi_address sd_address; 76 77 /* Cross-reference to target device's dev_info_t. */ 78 dev_info_t *sd_dev; 79 80 /* 81 * Target driver mutex for this device. Initialized by SCSA HBA 82 * framework code prior to probe(9E) or attach(9E) of scsi_device. 83 */ 84 kmutex_t sd_mutex; 85 86 /* 87 * SCSA private: use is associated with implementation of 88 * SCSI_HBA_ADDR_COMPLEX scsi_device_hba_private_[gs]et(9F). 89 * The HBA driver can store a pointer to per-scsi_device(9S) 90 * HBA private data during its tran_tgt_init(9E) implementation 91 * by calling scsi_device_hba_private_set(9F), and free that 92 * pointer during tran_tgt_fini(9E). At tran_send(9E) time, the 93 * HBA driver can use scsi_address_device(9F) to obtain a pointer 94 * to the scsi_device(9S) structure, and then gain access to 95 * its per-scsi_device(9S) hba private data by calling 96 * scsi_device_hba_private_get(9F). 97 */ 98 void *sd_hba_private; 99 100 /* 101 * If scsi_slave is used to probe out this device, a scsi_inquiry data 102 * structure will be allocated and an INQUIRY command will be run to 103 * fill it in. 104 * 105 * The inquiry data is allocated/refreshed by scsi_probe/scsi_slave 106 * and freed by uninitchild (inquiry data is no longer freed by 107 * scsi_unprobe/scsi_unslave). 108 * 109 * NOTE: Additional device identity information may be available 110 * as properties of sd_dev. 111 */ 112 struct scsi_inquiry *sd_inq; 113 114 /* 115 * Place to point to an extended request sense buffer. 116 * The target driver is responsible for managing this. 117 */ 118 struct scsi_extended_sense *sd_sense; 119 120 /* 121 * Target driver 'private' information. Typically a pointer to target 122 * driver private ddi_soft_state(9F) information for the device. This 123 * information is typically established in target driver attach(9E), 124 * and freed in the target driver detach(9E). 125 * 126 * LEGACY: For a scsi_device structure allocated by scsi_vhci during 127 * online of a path, this was set by scsi_vhci to point to the 128 * pathinfo node. Please use sd_pathinfo instead. 129 */ 130 void *sd_private; 131 132 /* 133 * FMA capabilities of scsi_device. 134 */ 135 int sd_fm_capable; 136 137 /* 138 * mdi_pathinfo_t pointer to pathinfo node for scsi_device structure 139 * allocated by the scsi_vhci for transport to a specific pHCI path. 140 */ 141 void *sd_pathinfo; 142 143 /* 144 * sd_uninit_prevent - Counter that prevents demotion of 145 * DS_INITIALIZED node (esp loss of devi_addr) by causing 146 * DDI_CTLOPS_UNINITCHILD failure - devi_ref will not protect 147 * demotion of DS_INITIALIZED node. 148 * 149 * sd_tran_tgt_free_done - in some cases SCSA will call 150 * tran_tgt_free(9E) independent of devinfo node state, this means 151 * that uninitchild code should not call tran_tgt_free(9E). 152 */ 153 unsigned sd_uninit_prevent:16, 154 sd_tran_tgt_free_done:1, 155 sd_flags_pad:15; 156 157 /* 158 * The 'sd_tran_safe' field is a grotty hack that allows direct-access 159 * (non-scsa) drivers (like chs, ata, and mlx - which all make cmdk 160 * children) to *illegally* put their own vector in the scsi_address(9S) 161 * 'a_hba_tran' field. When all the drivers that overwrite 162 * 'a_hba_tran' are fixed, we can remove sd_tran_safe (and make 163 * scsi_hba.c code trust that the 'sd_address.a_hba_tran' established 164 * during initchild is still valid when uninitchild occurs). 165 * 166 * NOTE: This hack is also shows up in the DEVP_TO_TRAN implementation 167 * in scsi_confsubr.c. 168 * 169 * NOTE: The 'sd_tran_safe' field is only referenced by SCSA framework 170 * code, so always keeping it at the end of the scsi_device structure 171 * (until it can be removed) is OK. It use to be called 'sd_reserved'. 172 */ 173 struct scsi_hba_tran *sd_tran_safe; 174 175 #ifdef SCSI_SIZE_CLEAN_VERIFY 176 /* 177 * Must be last: Building a driver with-and-without 178 * -DSCSI_SIZE_CLEAN_VERIFY, and checking driver modules for 179 * differences with a tools like 'wsdiff' allows a developer to verify 180 * that their driver has no dependencies on scsi*(9S) size. 181 */ 182 int _pad[8]; 183 #endif /* SCSI_SIZE_CLEAN_VERIFY */ 184 }; 185 186 #ifdef _KERNEL 187 188 /* ==== The following interfaces are public ==== */ 189 190 int scsi_probe(struct scsi_device *sd, int (*callback)(void)); 191 void scsi_unprobe(struct scsi_device *sd); 192 193 /* ==== The following interfaces are private (currently) ==== */ 194 195 char *scsi_device_unit_address(struct scsi_device *sd); 196 197 /* 198 * scsi_device_prop_*() property interfaces: flags 199 * 200 * SCSI_DEVICE_PROP_PATH: property of path-to-device. 201 * The property is associated with the sd_pathinfo pathinfo node 202 * as established by scsi_vhci. If sd_pathinfo is NULL then the 203 * property is associated with the sd_dev devinfo node. 204 * Implementation uses mdi_prop_*() interfaces applied to 205 * mdi_pathinfo_t (sd_pathinfo) nodes. 206 * 207 * SCSI_DEVICE_PROP_DEVICE: property of device. 208 * The property is always associated with the sd_dev devinfo 209 * node. Implementation uses ndi_prop_*() interfaces applied 210 * dev_info_t (sd_dev) nodes. 211 */ 212 #define SCSI_DEVICE_PROP_PATH 0x1 /* type is property-of-path */ 213 #define SCSI_DEVICE_PROP_DEVICE 0x2 /* type is property-of-device */ 214 #define SCSI_DEVICE_PROP_TYPE_MSK 0xF 215 216 int scsi_device_prop_get_int(struct scsi_device *sd, 217 uint_t flags, char *name, int defvalue); 218 int64_t scsi_device_prop_get_int64(struct scsi_device *, 219 uint_t flags, char *name, int64_t defvalue); 220 221 int scsi_device_prop_lookup_byte_array(struct scsi_device *sd, 222 uint_t flags, char *name, uchar_t **, uint_t *); 223 int scsi_device_prop_lookup_int_array(struct scsi_device *sd, 224 uint_t flags, char *name, int **, uint_t *); 225 int scsi_device_prop_lookup_string(struct scsi_device *sd, 226 uint_t flags, char *name, char **); 227 int scsi_device_prop_lookup_string_array(struct scsi_device *sd, 228 uint_t flags, char *name, char ***, uint_t *); 229 230 int scsi_device_prop_update_byte_array(struct scsi_device *sd, 231 uint_t flags, char *name, uchar_t *, uint_t); 232 int scsi_device_prop_update_int(struct scsi_device *sd, 233 uint_t flags, char *name, int); 234 int scsi_device_prop_update_int64(struct scsi_device *sd, 235 uint_t flags, char *name, int64_t); 236 int scsi_device_prop_update_int_array(struct scsi_device *sd, 237 uint_t flags, char *name, int *, uint_t); 238 int scsi_device_prop_update_string(struct scsi_device *sd, 239 uint_t flags, char *name, char *); 240 int scsi_device_prop_update_string_array(struct scsi_device *sd, 241 uint_t flags, char *name, char **, uint_t); 242 243 int scsi_device_prop_remove(struct scsi_device *sd, 244 uint_t flags, char *name); 245 void scsi_device_prop_free(struct scsi_device *sd, 246 uint_t flags, void *data); 247 248 /* SCSI_HBA_ADDR_COMPLEX interfaces */ 249 struct scsi_device *scsi_address_device(struct scsi_address *sa); 250 void scsi_device_hba_private_set(struct scsi_device *sd, void *data); 251 void *scsi_device_hba_private_get(struct scsi_device *sd); 252 253 /* ==== The following interfaces are private ==== */ 254 255 size_t scsi_device_size(); 256 257 /* ==== The following interfaces are obsolete ==== */ 258 259 int scsi_slave(struct scsi_device *sd, int (*callback)(void)); 260 void scsi_unslave(struct scsi_device *sd); 261 262 #endif /* _KERNEL */ 263 264 #ifdef __cplusplus 265 } 266 #endif 267 268 #endif /* _SYS_SCSI_CONF_DEVICE_H */ 269