James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * FiberChannel transport specific attributes exported to sysfs. |
| 3 | * |
| 4 | * Copyright (c) 2003 Silicon Graphics, Inc. All rights reserved. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | * |
| 20 | * ======== |
| 21 | * |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 22 | * Copyright (C) 2004-2007 James Smart, Emulex Corporation |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | * Rewrite for host, target, device, and remote port attributes, |
| 24 | * statistics, and service functions... |
| 25 | * |
| 26 | */ |
| 27 | #ifndef SCSI_TRANSPORT_FC_H |
| 28 | #define SCSI_TRANSPORT_FC_H |
| 29 | |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 30 | #include <linux/sched.h> |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 31 | #include <scsi/scsi.h> |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 32 | #include <scsi/scsi_netlink.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
| 34 | struct scsi_transport_template; |
| 35 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | /* |
| 37 | * FC Port definitions - Following FC HBAAPI guidelines |
| 38 | * |
| 39 | * Note: Not all binary values for the different fields match HBAAPI. |
| 40 | * Instead, we use densely packed ordinal values or enums. |
| 41 | * We get away with this as we never present the actual binary values |
| 42 | * externally. For sysfs, we always present the string that describes |
| 43 | * the value. Thus, an admin doesn't need a magic HBAAPI decoder ring |
| 44 | * to understand the values. The HBAAPI user-space library is free to |
| 45 | * convert the strings into the HBAAPI-specified binary values. |
| 46 | * |
| 47 | * Note: Not all HBAAPI-defined values are contained in the definitions |
| 48 | * below. Those not appropriate to an fc_host (e.g. FCP initiator) have |
| 49 | * been removed. |
| 50 | */ |
| 51 | |
| 52 | /* |
| 53 | * fc_port_type: If you alter this, you also need to alter scsi_transport_fc.c |
| 54 | * (for the ascii descriptions). |
| 55 | */ |
| 56 | enum fc_port_type { |
| 57 | FC_PORTTYPE_UNKNOWN, |
| 58 | FC_PORTTYPE_OTHER, |
| 59 | FC_PORTTYPE_NOTPRESENT, |
| 60 | FC_PORTTYPE_NPORT, /* Attached to FPort */ |
| 61 | FC_PORTTYPE_NLPORT, /* (Public) Loop w/ FLPort */ |
| 62 | FC_PORTTYPE_LPORT, /* (Private) Loop w/o FLPort */ |
| 63 | FC_PORTTYPE_PTP, /* Point to Point w/ another NPort */ |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 64 | FC_PORTTYPE_NPIV, /* VPORT based on NPIV */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | }; |
| 66 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 67 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | /* |
| 69 | * fc_port_state: If you alter this, you also need to alter scsi_transport_fc.c |
| 70 | * (for the ascii descriptions). |
| 71 | */ |
| 72 | enum fc_port_state { |
| 73 | FC_PORTSTATE_UNKNOWN, |
| 74 | FC_PORTSTATE_NOTPRESENT, |
| 75 | FC_PORTSTATE_ONLINE, |
| 76 | FC_PORTSTATE_OFFLINE, /* User has taken Port Offline */ |
| 77 | FC_PORTSTATE_BLOCKED, |
| 78 | FC_PORTSTATE_BYPASSED, |
| 79 | FC_PORTSTATE_DIAGNOSTICS, |
| 80 | FC_PORTSTATE_LINKDOWN, |
| 81 | FC_PORTSTATE_ERROR, |
| 82 | FC_PORTSTATE_LOOPBACK, |
James.Smart@Emulex.Com | 42e3314 | 2005-12-15 09:56:22 -0500 | [diff] [blame] | 83 | FC_PORTSTATE_DELETED, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | }; |
| 85 | |
| 86 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 87 | /* |
| 88 | * fc_vport_state: If you alter this, you also need to alter |
| 89 | * scsi_transport_fc.c (for the ascii descriptions). |
| 90 | */ |
| 91 | enum fc_vport_state { |
| 92 | FC_VPORT_UNKNOWN, |
| 93 | FC_VPORT_ACTIVE, |
| 94 | FC_VPORT_DISABLED, |
| 95 | FC_VPORT_LINKDOWN, |
| 96 | FC_VPORT_INITIALIZING, |
| 97 | FC_VPORT_NO_FABRIC_SUPP, |
| 98 | FC_VPORT_NO_FABRIC_RSCS, |
| 99 | FC_VPORT_FABRIC_LOGOUT, |
| 100 | FC_VPORT_FABRIC_REJ_WWN, |
| 101 | FC_VPORT_FAILED, |
| 102 | }; |
| 103 | |
| 104 | |
| 105 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 106 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | * FC Classes of Service |
| 108 | * Note: values are not enumerated, as they can be "or'd" together |
| 109 | * for reporting (e.g. report supported_classes). If you alter this list, |
| 110 | * you also need to alter scsi_transport_fc.c (for the ascii descriptions). |
| 111 | */ |
| 112 | #define FC_COS_UNSPECIFIED 0 |
| 113 | #define FC_COS_CLASS1 2 |
| 114 | #define FC_COS_CLASS2 4 |
| 115 | #define FC_COS_CLASS3 8 |
| 116 | #define FC_COS_CLASS4 0x10 |
| 117 | #define FC_COS_CLASS6 0x40 |
| 118 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 119 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | * FC Port Speeds |
| 121 | * Note: values are not enumerated, as they can be "or'd" together |
| 122 | * for reporting (e.g. report supported_speeds). If you alter this list, |
| 123 | * you also need to alter scsi_transport_fc.c (for the ascii descriptions). |
| 124 | */ |
| 125 | #define FC_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver |
| 126 | incapable of reporting */ |
| 127 | #define FC_PORTSPEED_1GBIT 1 |
| 128 | #define FC_PORTSPEED_2GBIT 2 |
Neerav Parikh | a9277e7 | 2012-01-22 17:29:55 -0800 | [diff] [blame] | 129 | #define FC_PORTSPEED_10GBIT 4 |
| 130 | #define FC_PORTSPEED_4GBIT 8 |
James Smart | c3d2350 | 2007-03-12 14:16:35 -0500 | [diff] [blame] | 131 | #define FC_PORTSPEED_8GBIT 0x10 |
| 132 | #define FC_PORTSPEED_16GBIT 0x20 |
Chad Dupuis | 624f28b | 2014-02-26 04:15:05 -0500 | [diff] [blame] | 133 | #define FC_PORTSPEED_32GBIT 0x40 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | #define FC_PORTSPEED_NOT_NEGOTIATED (1 << 15) /* Speed not established */ |
| 135 | |
| 136 | /* |
| 137 | * fc_tgtid_binding_type: If you alter this, you also need to alter |
| 138 | * scsi_transport_fc.c (for the ascii descriptions). |
| 139 | */ |
| 140 | enum fc_tgtid_binding_type { |
| 141 | FC_TGTID_BIND_NONE, |
| 142 | FC_TGTID_BIND_BY_WWPN, |
| 143 | FC_TGTID_BIND_BY_WWNN, |
| 144 | FC_TGTID_BIND_BY_ID, |
| 145 | }; |
| 146 | |
| 147 | /* |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 148 | * FC Port Roles |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | * Note: values are not enumerated, as they can be "or'd" together |
| 150 | * for reporting (e.g. report roles). If you alter this list, |
| 151 | * you also need to alter scsi_transport_fc.c (for the ascii descriptions). |
| 152 | */ |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 153 | #define FC_PORT_ROLE_UNKNOWN 0x00 |
| 154 | #define FC_PORT_ROLE_FCP_TARGET 0x01 |
| 155 | #define FC_PORT_ROLE_FCP_INITIATOR 0x02 |
| 156 | #define FC_PORT_ROLE_IP_PORT 0x04 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 158 | /* The following are for compatibility */ |
| 159 | #define FC_RPORT_ROLE_UNKNOWN FC_PORT_ROLE_UNKNOWN |
| 160 | #define FC_RPORT_ROLE_FCP_TARGET FC_PORT_ROLE_FCP_TARGET |
| 161 | #define FC_RPORT_ROLE_FCP_INITIATOR FC_PORT_ROLE_FCP_INITIATOR |
| 162 | #define FC_RPORT_ROLE_IP_PORT FC_PORT_ROLE_IP_PORT |
| 163 | |
| 164 | |
| 165 | /* Macro for use in defining Virtual Port attributes */ |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 166 | #define FC_VPORT_ATTR(_name,_mode,_show,_store) \ |
| 167 | struct device_attribute dev_attr_vport_##_name = \ |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 168 | __ATTR(_name,_mode,_show,_store) |
| 169 | |
Andrew Vasquez | a30c3f6 | 2008-07-18 08:32:52 -0700 | [diff] [blame] | 170 | /* |
| 171 | * fc_vport_identifiers: This set of data contains all elements |
| 172 | * to uniquely identify and instantiate a FC virtual port. |
| 173 | * |
| 174 | * Notes: |
| 175 | * symbolic_name: The driver is to append the symbolic_name string data |
| 176 | * to the symbolic_node_name data that it generates by default. |
| 177 | * the resulting combination should then be registered with the switch. |
| 178 | * It is expected that things like Xen may stuff a VM title into |
| 179 | * this field. |
| 180 | */ |
| 181 | #define FC_VPORT_SYMBOLIC_NAMELEN 64 |
| 182 | struct fc_vport_identifiers { |
| 183 | u64 node_name; |
| 184 | u64 port_name; |
| 185 | u32 roles; |
| 186 | bool disable; |
| 187 | enum fc_port_type vport_type; /* only FC_PORTTYPE_NPIV allowed */ |
| 188 | char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN]; |
| 189 | }; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 190 | |
| 191 | /* |
| 192 | * FC Virtual Port Attributes |
| 193 | * |
| 194 | * This structure exists for each FC port is a virtual FC port. Virtual |
| 195 | * ports share the physical link with the Physical port. Each virtual |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 196 | * ports has a unique presence on the SAN, and may be instantiated via |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 197 | * NPIV, Virtual Fabrics, or via additional ALPAs. As the vport is a |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 198 | * unique presence, each vport has it's own view of the fabric, |
Joe Perches | 1e4478c | 2008-02-03 17:47:00 +0200 | [diff] [blame] | 199 | * authentication privilege, and priorities. |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 200 | * |
| 201 | * A virtual port may support 1 or more FC4 roles. Typically it is a |
| 202 | * FCP Initiator. It could be a FCP Target, or exist sole for an IP over FC |
| 203 | * roles. FC port attributes for the vport will be reported on any |
| 204 | * fc_host class object allocated for an FCP Initiator. |
| 205 | * |
| 206 | * -- |
| 207 | * |
| 208 | * Fixed attributes are not expected to change. The driver is |
| 209 | * expected to set these values after receiving the fc_vport structure |
| 210 | * via the vport_create() call from the transport. |
| 211 | * The transport fully manages all get functions w/o driver interaction. |
| 212 | * |
| 213 | * Dynamic attributes are expected to change. The driver participates |
| 214 | * in all get/set operations via functions provided by the driver. |
| 215 | * |
| 216 | * Private attributes are transport-managed values. They are fully |
| 217 | * managed by the transport w/o driver interaction. |
| 218 | */ |
| 219 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 220 | struct fc_vport { |
| 221 | /* Fixed Attributes */ |
| 222 | |
| 223 | /* Dynamic Attributes */ |
| 224 | |
| 225 | /* Private (Transport-managed) Attributes */ |
| 226 | enum fc_vport_state vport_state; |
| 227 | enum fc_vport_state vport_last_state; |
| 228 | u64 node_name; |
| 229 | u64 port_name; |
| 230 | u32 roles; |
| 231 | u32 vport_id; /* Admin Identifier for the vport */ |
| 232 | enum fc_port_type vport_type; |
| 233 | char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN]; |
| 234 | |
| 235 | /* exported data */ |
| 236 | void *dd_data; /* Used for driver-specific storage */ |
| 237 | |
| 238 | /* internal data */ |
| 239 | struct Scsi_Host *shost; /* Physical Port Parent */ |
| 240 | unsigned int channel; |
| 241 | u32 number; |
| 242 | u8 flags; |
| 243 | struct list_head peers; |
| 244 | struct device dev; |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 245 | struct work_struct vport_delete_work; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 246 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 247 | |
| 248 | /* bit field values for struct fc_vport "flags" field: */ |
| 249 | #define FC_VPORT_CREATING 0x01 |
| 250 | #define FC_VPORT_DELETING 0x02 |
| 251 | #define FC_VPORT_DELETED 0x04 |
| 252 | #define FC_VPORT_DEL 0x06 /* Any DELETE state */ |
| 253 | |
| 254 | #define dev_to_vport(d) \ |
| 255 | container_of(d, struct fc_vport, dev) |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 256 | #define transport_class_to_vport(dev) \ |
| 257 | dev_to_vport(dev->parent) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 258 | #define vport_to_shost(v) \ |
| 259 | (v->shost) |
| 260 | #define vport_to_shost_channel(v) \ |
| 261 | (v->channel) |
| 262 | #define vport_to_parent(v) \ |
| 263 | (v->dev.parent) |
| 264 | |
| 265 | |
| 266 | /* Error return codes for vport_create() callback */ |
| 267 | #define VPCERR_UNSUPPORTED -ENOSYS /* no driver/adapter |
| 268 | support */ |
| 269 | #define VPCERR_BAD_WWN -ENOTUNIQ /* driver validation |
| 270 | of WWNs failed */ |
| 271 | #define VPCERR_NO_FABRIC_SUPP -EOPNOTSUPP /* Fabric connection |
| 272 | is loop or the |
| 273 | Fabric Port does |
| 274 | not support NPIV */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | |
| 276 | /* |
| 277 | * fc_rport_identifiers: This set of data contains all elements |
| 278 | * to uniquely identify a remote FC port. The driver uses this data |
| 279 | * to report the existence of a remote FC port in the topology. Internally, |
| 280 | * the transport uses this data for attributes and to manage consistent |
| 281 | * target id bindings. |
| 282 | */ |
| 283 | struct fc_rport_identifiers { |
| 284 | u64 node_name; |
| 285 | u64 port_name; |
| 286 | u32 port_id; |
| 287 | u32 roles; |
| 288 | }; |
| 289 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 290 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | /* Macro for use in defining Remote Port attributes */ |
| 292 | #define FC_RPORT_ATTR(_name,_mode,_show,_store) \ |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 293 | struct device_attribute dev_attr_rport_##_name = \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | __ATTR(_name,_mode,_show,_store) |
| 295 | |
| 296 | |
| 297 | /* |
| 298 | * FC Remote Port Attributes |
| 299 | * |
| 300 | * This structure exists for each remote FC port that a LLDD notifies |
| 301 | * the subsystem of. A remote FC port may or may not be a SCSI Target, |
| 302 | * also be a SCSI initiator, IP endpoint, etc. As such, the remote |
| 303 | * port is considered a separate entity, independent of "role" (such |
| 304 | * as scsi target). |
| 305 | * |
| 306 | * -- |
| 307 | * |
| 308 | * Attributes are based on HBAAPI V2.0 definitions. Only those |
| 309 | * attributes that are determinable by the local port (aka Host) |
| 310 | * are contained. |
| 311 | * |
| 312 | * Fixed attributes are not expected to change. The driver is |
| 313 | * expected to set these values after successfully calling |
| 314 | * fc_remote_port_add(). The transport fully manages all get functions |
| 315 | * w/o driver interaction. |
| 316 | * |
| 317 | * Dynamic attributes are expected to change. The driver participates |
| 318 | * in all get/set operations via functions provided by the driver. |
| 319 | * |
| 320 | * Private attributes are transport-managed values. They are fully |
| 321 | * managed by the transport w/o driver interaction. |
| 322 | */ |
| 323 | |
| 324 | struct fc_rport { /* aka fc_starget_attrs */ |
| 325 | /* Fixed Attributes */ |
| 326 | u32 maxframe_size; |
| 327 | u32 supported_classes; |
| 328 | |
| 329 | /* Dynamic Attributes */ |
| 330 | u32 dev_loss_tmo; /* Remote Port loss timeout in seconds. */ |
| 331 | |
| 332 | /* Private (Transport-managed) Attributes */ |
| 333 | u64 node_name; |
| 334 | u64 port_name; |
| 335 | u32 port_id; |
| 336 | u32 roles; |
| 337 | enum fc_port_state port_state; /* Will only be ONLINE or UNKNOWN */ |
| 338 | u32 scsi_target_id; |
James Smart | 0f29b96 | 2006-08-18 17:33:29 -0400 | [diff] [blame] | 339 | u32 fast_io_fail_tmo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | |
| 341 | /* exported data */ |
| 342 | void *dd_data; /* Used for driver-specific storage */ |
| 343 | |
| 344 | /* internal data */ |
| 345 | unsigned int channel; |
| 346 | u32 number; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 347 | u8 flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | struct list_head peers; |
| 349 | struct device dev; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 350 | struct delayed_work dev_loss_work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | struct work_struct scan_work; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 352 | struct delayed_work fail_io_work; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 353 | struct work_struct stgt_delete_work; |
| 354 | struct work_struct rport_delete_work; |
James Smart | 9e4f5e2 | 2009-03-26 13:33:19 -0400 | [diff] [blame] | 355 | struct request_queue *rqst_q; /* bsg support */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 357 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 358 | /* bit field values for struct fc_rport "flags" field: */ |
| 359 | #define FC_RPORT_DEVLOSS_PENDING 0x01 |
| 360 | #define FC_RPORT_SCAN_PENDING 0x02 |
James Smart | 21098c6 | 2008-11-20 10:58:01 -0500 | [diff] [blame] | 361 | #define FC_RPORT_FAST_FAIL_TIMEDOUT 0x04 |
James Smart | 4be98c0 | 2009-01-05 12:14:18 -0500 | [diff] [blame] | 362 | #define FC_RPORT_DEVLOSS_CALLBK_DONE 0x08 |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 363 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | #define dev_to_rport(d) \ |
| 365 | container_of(d, struct fc_rport, dev) |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 366 | #define transport_class_to_rport(dev) \ |
| 367 | dev_to_rport(dev->parent) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | #define rport_to_shost(r) \ |
| 369 | dev_to_shost(r->dev.parent) |
| 370 | |
| 371 | /* |
| 372 | * FC SCSI Target Attributes |
| 373 | * |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 374 | * The SCSI Target is considered an extension of a remote port (as |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | * a remote port can be more than a SCSI Target). Within the scsi |
| 376 | * subsystem, we leave the Target as a separate entity. Doing so |
| 377 | * provides backward compatibility with prior FC transport api's, |
| 378 | * and lets remote ports be handled entirely within the FC transport |
| 379 | * and independently from the scsi subsystem. The drawback is that |
| 380 | * some data will be duplicated. |
| 381 | */ |
| 382 | |
| 383 | struct fc_starget_attrs { /* aka fc_target_attrs */ |
| 384 | /* Dynamic Attributes */ |
| 385 | u64 node_name; |
| 386 | u64 port_name; |
| 387 | u32 port_id; |
| 388 | }; |
| 389 | |
| 390 | #define fc_starget_node_name(x) \ |
| 391 | (((struct fc_starget_attrs *)&(x)->starget_data)->node_name) |
| 392 | #define fc_starget_port_name(x) \ |
| 393 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_name) |
| 394 | #define fc_starget_port_id(x) \ |
| 395 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_id) |
| 396 | |
| 397 | #define starget_to_rport(s) \ |
| 398 | scsi_is_fc_rport(s->dev.parent) ? dev_to_rport(s->dev.parent) : NULL |
| 399 | |
| 400 | |
| 401 | /* |
| 402 | * FC Local Port (Host) Statistics |
| 403 | */ |
| 404 | |
| 405 | /* FC Statistics - Following FC HBAAPI v2.0 guidelines */ |
| 406 | struct fc_host_statistics { |
| 407 | /* port statistics */ |
| 408 | u64 seconds_since_last_reset; |
| 409 | u64 tx_frames; |
| 410 | u64 tx_words; |
| 411 | u64 rx_frames; |
| 412 | u64 rx_words; |
| 413 | u64 lip_count; |
| 414 | u64 nos_count; |
| 415 | u64 error_frames; |
| 416 | u64 dumped_frames; |
| 417 | u64 link_failure_count; |
| 418 | u64 loss_of_sync_count; |
| 419 | u64 loss_of_signal_count; |
| 420 | u64 prim_seq_protocol_err_count; |
| 421 | u64 invalid_tx_word_count; |
| 422 | u64 invalid_crc_count; |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 423 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | /* fc4 statistics (only FCP supported currently) */ |
| 425 | u64 fcp_input_requests; |
| 426 | u64 fcp_output_requests; |
| 427 | u64 fcp_control_requests; |
| 428 | u64 fcp_input_megabytes; |
| 429 | u64 fcp_output_megabytes; |
Vasu Dev | e58abb0 | 2012-05-25 10:26:38 -0700 | [diff] [blame] | 430 | u64 fcp_packet_alloc_failures; /* fcp packet allocation failures */ |
| 431 | u64 fcp_packet_aborts; /* fcp packet aborted */ |
| 432 | u64 fcp_frame_alloc_failures; /* fcp frame allocation failures */ |
| 433 | |
| 434 | /* fc exches statistics */ |
| 435 | u64 fc_no_free_exch; /* no free exch memory */ |
| 436 | u64 fc_no_free_exch_xid; /* no free exch id */ |
| 437 | u64 fc_xid_not_found; /* exch not found for a response */ |
| 438 | u64 fc_xid_busy; /* exch exist for new a request */ |
| 439 | u64 fc_seq_not_found; /* seq is not found for exchange */ |
| 440 | u64 fc_non_bls_resp; /* a non BLS response frame with |
| 441 | a sequence responder in new exch */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | }; |
| 443 | |
| 444 | |
| 445 | /* |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 446 | * FC Event Codes - Polled and Async, following FC HBAAPI v2.0 guidelines |
| 447 | */ |
| 448 | |
| 449 | /* |
| 450 | * fc_host_event_code: If you alter this, you also need to alter |
| 451 | * scsi_transport_fc.c (for the ascii descriptions). |
| 452 | */ |
| 453 | enum fc_host_event_code { |
| 454 | FCH_EVT_LIP = 0x1, |
| 455 | FCH_EVT_LINKUP = 0x2, |
| 456 | FCH_EVT_LINKDOWN = 0x3, |
| 457 | FCH_EVT_LIPRESET = 0x4, |
| 458 | FCH_EVT_RSCN = 0x5, |
| 459 | FCH_EVT_ADAPTER_CHANGE = 0x103, |
| 460 | FCH_EVT_PORT_UNKNOWN = 0x200, |
| 461 | FCH_EVT_PORT_OFFLINE = 0x201, |
| 462 | FCH_EVT_PORT_ONLINE = 0x202, |
| 463 | FCH_EVT_PORT_FABRIC = 0x204, |
| 464 | FCH_EVT_LINK_UNKNOWN = 0x500, |
| 465 | FCH_EVT_VENDOR_UNIQUE = 0xffff, |
| 466 | }; |
| 467 | |
| 468 | |
| 469 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | * FC Local Port (Host) Attributes |
| 471 | * |
| 472 | * Attributes are based on HBAAPI V2.0 definitions. |
| 473 | * Note: OSDeviceName is determined by user-space library |
| 474 | * |
| 475 | * Fixed attributes are not expected to change. The driver is |
| 476 | * expected to set these values after successfully calling scsi_add_host(). |
| 477 | * The transport fully manages all get functions w/o driver interaction. |
| 478 | * |
| 479 | * Dynamic attributes are expected to change. The driver participates |
| 480 | * in all get/set operations via functions provided by the driver. |
| 481 | * |
| 482 | * Private attributes are transport-managed values. They are fully |
| 483 | * managed by the transport w/o driver interaction. |
| 484 | */ |
| 485 | |
| 486 | #define FC_FC4_LIST_SIZE 32 |
| 487 | #define FC_SYMBOLIC_NAME_SIZE 256 |
| 488 | #define FC_VERSION_STRING_SIZE 64 |
| 489 | #define FC_SERIAL_NUMBER_SIZE 80 |
| 490 | |
| 491 | struct fc_host_attrs { |
| 492 | /* Fixed Attributes */ |
| 493 | u64 node_name; |
| 494 | u64 port_name; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 495 | u64 permanent_port_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | u32 supported_classes; |
| 497 | u8 supported_fc4s[FC_FC4_LIST_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | u32 supported_speeds; |
| 499 | u32 maxframe_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 500 | u16 max_npiv_vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | char serial_number[FC_SERIAL_NUMBER_SIZE]; |
Neerav Parikh | bb8ef58 | 2012-01-22 17:29:50 -0800 | [diff] [blame] | 502 | char manufacturer[FC_SERIAL_NUMBER_SIZE]; |
| 503 | char model[FC_SYMBOLIC_NAME_SIZE]; |
| 504 | char model_description[FC_SYMBOLIC_NAME_SIZE]; |
| 505 | char hardware_version[FC_VERSION_STRING_SIZE]; |
| 506 | char driver_version[FC_VERSION_STRING_SIZE]; |
| 507 | char firmware_version[FC_VERSION_STRING_SIZE]; |
| 508 | char optionrom_version[FC_VERSION_STRING_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 509 | |
| 510 | /* Dynamic Attributes */ |
| 511 | u32 port_id; |
| 512 | enum fc_port_type port_type; |
| 513 | enum fc_port_state port_state; |
| 514 | u8 active_fc4s[FC_FC4_LIST_SIZE]; |
| 515 | u32 speed; |
| 516 | u64 fabric_name; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 517 | char symbolic_name[FC_SYMBOLIC_NAME_SIZE]; |
| 518 | char system_hostname[FC_SYMBOLIC_NAME_SIZE]; |
Mike Christie | 43ca910 | 2010-09-15 16:52:32 -0500 | [diff] [blame] | 519 | u32 dev_loss_tmo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | |
| 521 | /* Private (Transport-managed) Attributes */ |
| 522 | enum fc_tgtid_binding_type tgtid_bind_type; |
| 523 | |
| 524 | /* internal data */ |
| 525 | struct list_head rports; |
| 526 | struct list_head rport_bindings; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 527 | struct list_head vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 528 | u32 next_rport_number; |
| 529 | u32 next_target_id; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 530 | u32 next_vport_number; |
| 531 | u16 npiv_vports_inuse; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 532 | |
| 533 | /* work queues for rport state manipulation */ |
Kay Sievers | aab0de2 | 2008-05-02 06:02:41 +0200 | [diff] [blame] | 534 | char work_q_name[20]; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 535 | struct workqueue_struct *work_q; |
Kay Sievers | aab0de2 | 2008-05-02 06:02:41 +0200 | [diff] [blame] | 536 | char devloss_work_q_name[20]; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 537 | struct workqueue_struct *devloss_work_q; |
James Smart | 9e4f5e2 | 2009-03-26 13:33:19 -0400 | [diff] [blame] | 538 | |
| 539 | /* bsg support */ |
| 540 | struct request_queue *rqst_q; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | }; |
| 542 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 543 | #define shost_to_fc_host(x) \ |
| 544 | ((struct fc_host_attrs *)(x)->shost_data) |
James.Smart@Emulex.Com | 42e3314 | 2005-12-15 09:56:22 -0500 | [diff] [blame] | 545 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 546 | #define fc_host_node_name(x) \ |
| 547 | (((struct fc_host_attrs *)(x)->shost_data)->node_name) |
| 548 | #define fc_host_port_name(x) \ |
| 549 | (((struct fc_host_attrs *)(x)->shost_data)->port_name) |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 550 | #define fc_host_permanent_port_name(x) \ |
| 551 | (((struct fc_host_attrs *)(x)->shost_data)->permanent_port_name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 552 | #define fc_host_supported_classes(x) \ |
| 553 | (((struct fc_host_attrs *)(x)->shost_data)->supported_classes) |
| 554 | #define fc_host_supported_fc4s(x) \ |
| 555 | (((struct fc_host_attrs *)(x)->shost_data)->supported_fc4s) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | #define fc_host_supported_speeds(x) \ |
| 557 | (((struct fc_host_attrs *)(x)->shost_data)->supported_speeds) |
| 558 | #define fc_host_maxframe_size(x) \ |
| 559 | (((struct fc_host_attrs *)(x)->shost_data)->maxframe_size) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 560 | #define fc_host_max_npiv_vports(x) \ |
| 561 | (((struct fc_host_attrs *)(x)->shost_data)->max_npiv_vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | #define fc_host_serial_number(x) \ |
| 563 | (((struct fc_host_attrs *)(x)->shost_data)->serial_number) |
Neerav Parikh | bb8ef58 | 2012-01-22 17:29:50 -0800 | [diff] [blame] | 564 | #define fc_host_manufacturer(x) \ |
| 565 | (((struct fc_host_attrs *)(x)->shost_data)->manufacturer) |
| 566 | #define fc_host_model(x) \ |
| 567 | (((struct fc_host_attrs *)(x)->shost_data)->model) |
| 568 | #define fc_host_model_description(x) \ |
| 569 | (((struct fc_host_attrs *)(x)->shost_data)->model_description) |
| 570 | #define fc_host_hardware_version(x) \ |
| 571 | (((struct fc_host_attrs *)(x)->shost_data)->hardware_version) |
| 572 | #define fc_host_driver_version(x) \ |
| 573 | (((struct fc_host_attrs *)(x)->shost_data)->driver_version) |
| 574 | #define fc_host_firmware_version(x) \ |
| 575 | (((struct fc_host_attrs *)(x)->shost_data)->firmware_version) |
| 576 | #define fc_host_optionrom_version(x) \ |
| 577 | (((struct fc_host_attrs *)(x)->shost_data)->optionrom_version) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | #define fc_host_port_id(x) \ |
| 579 | (((struct fc_host_attrs *)(x)->shost_data)->port_id) |
| 580 | #define fc_host_port_type(x) \ |
| 581 | (((struct fc_host_attrs *)(x)->shost_data)->port_type) |
| 582 | #define fc_host_port_state(x) \ |
| 583 | (((struct fc_host_attrs *)(x)->shost_data)->port_state) |
| 584 | #define fc_host_active_fc4s(x) \ |
| 585 | (((struct fc_host_attrs *)(x)->shost_data)->active_fc4s) |
| 586 | #define fc_host_speed(x) \ |
| 587 | (((struct fc_host_attrs *)(x)->shost_data)->speed) |
| 588 | #define fc_host_fabric_name(x) \ |
| 589 | (((struct fc_host_attrs *)(x)->shost_data)->fabric_name) |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 590 | #define fc_host_symbolic_name(x) \ |
| 591 | (((struct fc_host_attrs *)(x)->shost_data)->symbolic_name) |
| 592 | #define fc_host_system_hostname(x) \ |
| 593 | (((struct fc_host_attrs *)(x)->shost_data)->system_hostname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | #define fc_host_tgtid_bind_type(x) \ |
| 595 | (((struct fc_host_attrs *)(x)->shost_data)->tgtid_bind_type) |
| 596 | #define fc_host_rports(x) \ |
| 597 | (((struct fc_host_attrs *)(x)->shost_data)->rports) |
| 598 | #define fc_host_rport_bindings(x) \ |
| 599 | (((struct fc_host_attrs *)(x)->shost_data)->rport_bindings) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 600 | #define fc_host_vports(x) \ |
| 601 | (((struct fc_host_attrs *)(x)->shost_data)->vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 602 | #define fc_host_next_rport_number(x) \ |
| 603 | (((struct fc_host_attrs *)(x)->shost_data)->next_rport_number) |
| 604 | #define fc_host_next_target_id(x) \ |
| 605 | (((struct fc_host_attrs *)(x)->shost_data)->next_target_id) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 606 | #define fc_host_next_vport_number(x) \ |
| 607 | (((struct fc_host_attrs *)(x)->shost_data)->next_vport_number) |
| 608 | #define fc_host_npiv_vports_inuse(x) \ |
| 609 | (((struct fc_host_attrs *)(x)->shost_data)->npiv_vports_inuse) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 610 | #define fc_host_work_q_name(x) \ |
| 611 | (((struct fc_host_attrs *)(x)->shost_data)->work_q_name) |
| 612 | #define fc_host_work_q(x) \ |
| 613 | (((struct fc_host_attrs *)(x)->shost_data)->work_q) |
| 614 | #define fc_host_devloss_work_q_name(x) \ |
| 615 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q_name) |
| 616 | #define fc_host_devloss_work_q(x) \ |
| 617 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q) |
Mike Christie | 43ca910 | 2010-09-15 16:52:32 -0500 | [diff] [blame] | 618 | #define fc_host_dev_loss_tmo(x) \ |
| 619 | (((struct fc_host_attrs *)(x)->shost_data)->dev_loss_tmo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | |
| 621 | |
James Smart | 9e4f5e2 | 2009-03-26 13:33:19 -0400 | [diff] [blame] | 622 | struct fc_bsg_buffer { |
| 623 | unsigned int payload_len; |
| 624 | int sg_cnt; |
| 625 | struct scatterlist *sg_list; |
| 626 | }; |
| 627 | |
| 628 | /* Values for fc_bsg_job->state_flags (bitflags) */ |
| 629 | #define FC_RQST_STATE_INPROGRESS 0 |
| 630 | #define FC_RQST_STATE_DONE 1 |
| 631 | |
| 632 | struct fc_bsg_job { |
| 633 | struct Scsi_Host *shost; |
| 634 | struct fc_rport *rport; |
| 635 | struct device *dev; |
| 636 | struct request *req; |
| 637 | spinlock_t job_lock; |
| 638 | unsigned int state_flags; |
| 639 | unsigned int ref_cnt; |
| 640 | void (*job_done)(struct fc_bsg_job *); |
| 641 | |
| 642 | struct fc_bsg_request *request; |
| 643 | struct fc_bsg_reply *reply; |
| 644 | unsigned int request_len; |
| 645 | unsigned int reply_len; |
| 646 | /* |
| 647 | * On entry : reply_len indicates the buffer size allocated for |
| 648 | * the reply. |
| 649 | * |
| 650 | * Upon completion : the message handler must set reply_len |
| 651 | * to indicates the size of the reply to be returned to the |
| 652 | * caller. |
| 653 | */ |
| 654 | |
| 655 | /* DMA payloads for the request/response */ |
| 656 | struct fc_bsg_buffer request_payload; |
| 657 | struct fc_bsg_buffer reply_payload; |
| 658 | |
| 659 | void *dd_data; /* Used for driver-specific storage */ |
| 660 | }; |
| 661 | |
| 662 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 663 | /* The functions by which the transport class and the driver communicate */ |
| 664 | struct fc_function_template { |
| 665 | void (*get_rport_dev_loss_tmo)(struct fc_rport *); |
| 666 | void (*set_rport_dev_loss_tmo)(struct fc_rport *, u32); |
| 667 | |
| 668 | void (*get_starget_node_name)(struct scsi_target *); |
| 669 | void (*get_starget_port_name)(struct scsi_target *); |
| 670 | void (*get_starget_port_id)(struct scsi_target *); |
| 671 | |
| 672 | void (*get_host_port_id)(struct Scsi_Host *); |
| 673 | void (*get_host_port_type)(struct Scsi_Host *); |
| 674 | void (*get_host_port_state)(struct Scsi_Host *); |
| 675 | void (*get_host_active_fc4s)(struct Scsi_Host *); |
| 676 | void (*get_host_speed)(struct Scsi_Host *); |
| 677 | void (*get_host_fabric_name)(struct Scsi_Host *); |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 678 | void (*get_host_symbolic_name)(struct Scsi_Host *); |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 679 | void (*set_host_system_hostname)(struct Scsi_Host *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 680 | |
| 681 | struct fc_host_statistics * (*get_fc_host_stats)(struct Scsi_Host *); |
| 682 | void (*reset_fc_host_stats)(struct Scsi_Host *); |
| 683 | |
Andrew Vasquez | 91ca7b0 | 2005-10-27 16:03:37 -0700 | [diff] [blame] | 684 | int (*issue_fc_host_lip)(struct Scsi_Host *); |
| 685 | |
James Smart | 0f29b96 | 2006-08-18 17:33:29 -0400 | [diff] [blame] | 686 | void (*dev_loss_tmo_callbk)(struct fc_rport *); |
| 687 | void (*terminate_rport_io)(struct fc_rport *); |
| 688 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 689 | void (*set_vport_symbolic_name)(struct fc_vport *); |
| 690 | int (*vport_create)(struct fc_vport *, bool); |
| 691 | int (*vport_disable)(struct fc_vport *, bool); |
| 692 | int (*vport_delete)(struct fc_vport *); |
| 693 | |
FUJITA Tomonori | 7525236 | 2007-09-01 02:02:27 +0900 | [diff] [blame] | 694 | /* target-mode drivers' functions */ |
| 695 | int (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int); |
| 696 | int (* it_nexus_response)(struct Scsi_Host *, u64, int); |
| 697 | |
James Smart | 9e4f5e2 | 2009-03-26 13:33:19 -0400 | [diff] [blame] | 698 | /* bsg support */ |
| 699 | int (*bsg_request)(struct fc_bsg_job *); |
| 700 | int (*bsg_timeout)(struct fc_bsg_job *); |
| 701 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 702 | /* allocation lengths for host-specific data */ |
| 703 | u32 dd_fcrport_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 704 | u32 dd_fcvport_size; |
James Smart | 9e4f5e2 | 2009-03-26 13:33:19 -0400 | [diff] [blame] | 705 | u32 dd_bsg_size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 706 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 707 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | * The driver sets these to tell the transport class it |
| 709 | * wants the attributes displayed in sysfs. If the show_ flag |
| 710 | * is not set, the attribute will be private to the transport |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 711 | * class |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 712 | */ |
| 713 | |
| 714 | /* remote port fixed attributes */ |
| 715 | unsigned long show_rport_maxframe_size:1; |
| 716 | unsigned long show_rport_supported_classes:1; |
| 717 | unsigned long show_rport_dev_loss_tmo:1; |
| 718 | |
| 719 | /* |
| 720 | * target dynamic attributes |
| 721 | * These should all be "1" if the driver uses the remote port |
| 722 | * add/delete functions (so attributes reflect rport values). |
| 723 | */ |
| 724 | unsigned long show_starget_node_name:1; |
| 725 | unsigned long show_starget_port_name:1; |
| 726 | unsigned long show_starget_port_id:1; |
| 727 | |
| 728 | /* host fixed attributes */ |
| 729 | unsigned long show_host_node_name:1; |
| 730 | unsigned long show_host_port_name:1; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 731 | unsigned long show_host_permanent_port_name:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 732 | unsigned long show_host_supported_classes:1; |
| 733 | unsigned long show_host_supported_fc4s:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 734 | unsigned long show_host_supported_speeds:1; |
| 735 | unsigned long show_host_maxframe_size:1; |
| 736 | unsigned long show_host_serial_number:1; |
Neerav Parikh | bb8ef58 | 2012-01-22 17:29:50 -0800 | [diff] [blame] | 737 | unsigned long show_host_manufacturer:1; |
| 738 | unsigned long show_host_model:1; |
| 739 | unsigned long show_host_model_description:1; |
| 740 | unsigned long show_host_hardware_version:1; |
| 741 | unsigned long show_host_driver_version:1; |
| 742 | unsigned long show_host_firmware_version:1; |
| 743 | unsigned long show_host_optionrom_version:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | /* host dynamic attributes */ |
| 745 | unsigned long show_host_port_id:1; |
| 746 | unsigned long show_host_port_type:1; |
| 747 | unsigned long show_host_port_state:1; |
| 748 | unsigned long show_host_active_fc4s:1; |
| 749 | unsigned long show_host_speed:1; |
| 750 | unsigned long show_host_fabric_name:1; |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 751 | unsigned long show_host_symbolic_name:1; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 752 | unsigned long show_host_system_hostname:1; |
Christof Schmitt | 03f002f | 2007-08-28 09:31:21 +0200 | [diff] [blame] | 753 | |
| 754 | unsigned long disable_target_scan:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 755 | }; |
| 756 | |
| 757 | |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 758 | /** |
| 759 | * fc_remote_port_chkready - called to validate the remote port state |
| 760 | * prior to initiating io to the port. |
| 761 | * |
| 762 | * Returns a scsi result code that can be returned by the LLDD. |
| 763 | * |
| 764 | * @rport: remote port to be checked |
| 765 | **/ |
| 766 | static inline int |
| 767 | fc_remote_port_chkready(struct fc_rport *rport) |
| 768 | { |
| 769 | int result; |
| 770 | |
| 771 | switch (rport->port_state) { |
| 772 | case FC_PORTSTATE_ONLINE: |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 773 | if (rport->roles & FC_PORT_ROLE_FCP_TARGET) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 774 | result = 0; |
| 775 | else if (rport->flags & FC_RPORT_DEVLOSS_PENDING) |
Andrew Vasquez | 9a1a69a1 | 2009-04-29 13:12:39 -0500 | [diff] [blame] | 776 | result = DID_IMM_RETRY << 16; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 777 | else |
| 778 | result = DID_NO_CONNECT << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 779 | break; |
| 780 | case FC_PORTSTATE_BLOCKED: |
Mike Christie | fff9d40 | 2008-08-19 18:45:23 -0500 | [diff] [blame] | 781 | if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT) |
Mike Christie | f46e307 | 2008-08-19 18:45:27 -0500 | [diff] [blame] | 782 | result = DID_TRANSPORT_FAILFAST << 16; |
Mike Christie | fff9d40 | 2008-08-19 18:45:23 -0500 | [diff] [blame] | 783 | else |
Andrew Vasquez | 9a1a69a1 | 2009-04-29 13:12:39 -0500 | [diff] [blame] | 784 | result = DID_IMM_RETRY << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 785 | break; |
| 786 | default: |
| 787 | result = DID_NO_CONNECT << 16; |
| 788 | break; |
| 789 | } |
| 790 | return result; |
| 791 | } |
| 792 | |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 793 | static inline u64 wwn_to_u64(u8 *wwn) |
| 794 | { |
| 795 | return (u64)wwn[0] << 56 | (u64)wwn[1] << 48 | |
| 796 | (u64)wwn[2] << 40 | (u64)wwn[3] << 32 | |
| 797 | (u64)wwn[4] << 24 | (u64)wwn[5] << 16 | |
| 798 | (u64)wwn[6] << 8 | (u64)wwn[7]; |
| 799 | } |
| 800 | |
| 801 | static inline void u64_to_wwn(u64 inm, u8 *wwn) |
| 802 | { |
| 803 | wwn[0] = (inm >> 56) & 0xff; |
| 804 | wwn[1] = (inm >> 48) & 0xff; |
| 805 | wwn[2] = (inm >> 40) & 0xff; |
| 806 | wwn[3] = (inm >> 32) & 0xff; |
| 807 | wwn[4] = (inm >> 24) & 0xff; |
| 808 | wwn[5] = (inm >> 16) & 0xff; |
| 809 | wwn[6] = (inm >> 8) & 0xff; |
| 810 | wwn[7] = inm & 0xff; |
| 811 | } |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 812 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 813 | /** |
| 814 | * fc_vport_set_state() - called to set a vport's state. Saves the old state, |
| 815 | * excepting the transitory states of initializing and sending the ELS |
| 816 | * traffic to instantiate the vport on the link. |
| 817 | * |
| 818 | * Assumes the driver has surrounded this with the proper locking to ensure |
| 819 | * a coherent state change. |
| 820 | * |
| 821 | * @vport: virtual port whose state is changing |
| 822 | * @new_state: new state |
| 823 | **/ |
| 824 | static inline void |
| 825 | fc_vport_set_state(struct fc_vport *vport, enum fc_vport_state new_state) |
| 826 | { |
| 827 | if ((new_state != FC_VPORT_UNKNOWN) && |
| 828 | (new_state != FC_VPORT_INITIALIZING)) |
| 829 | vport->vport_last_state = vport->vport_state; |
| 830 | vport->vport_state = new_state; |
| 831 | } |
| 832 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 833 | struct scsi_transport_template *fc_attach_transport( |
| 834 | struct fc_function_template *); |
| 835 | void fc_release_transport(struct scsi_transport_template *); |
| 836 | void fc_remove_host(struct Scsi_Host *); |
| 837 | struct fc_rport *fc_remote_port_add(struct Scsi_Host *shost, |
| 838 | int channel, struct fc_rport_identifiers *ids); |
| 839 | void fc_remote_port_delete(struct fc_rport *rport); |
| 840 | void fc_remote_port_rolechg(struct fc_rport *rport, u32 roles); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 841 | int scsi_is_fc_rport(const struct device *); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 842 | u32 fc_get_event_number(void); |
| 843 | void fc_host_post_event(struct Scsi_Host *shost, u32 event_number, |
| 844 | enum fc_host_event_code event_code, u32 event_data); |
| 845 | void fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number, |
James Smart | f14e2e2 | 2006-08-22 09:55:23 -0400 | [diff] [blame] | 846 | u32 data_len, char * data_buf, u64 vendor_id); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 847 | /* Note: when specifying vendor_id to fc_host_post_vendor_event() |
| 848 | * be sure to read the Vendor Type and ID formatting requirements |
| 849 | * specified in scsi_netlink.h |
| 850 | */ |
Andrew Vasquez | a30c3f6 | 2008-07-18 08:32:52 -0700 | [diff] [blame] | 851 | struct fc_vport *fc_vport_create(struct Scsi_Host *shost, int channel, |
| 852 | struct fc_vport_identifiers *); |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 853 | int fc_vport_terminate(struct fc_vport *vport); |
Christof Schmitt | 2f2eb58 | 2010-03-24 16:50:30 +0100 | [diff] [blame] | 854 | int fc_block_scsi_eh(struct scsi_cmnd *cmnd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 856 | #endif /* SCSI_TRANSPORT_FC_H */ |