Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 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 | |
| 36 | |
| 37 | /* |
| 38 | * FC Port definitions - Following FC HBAAPI guidelines |
| 39 | * |
| 40 | * Note: Not all binary values for the different fields match HBAAPI. |
| 41 | * Instead, we use densely packed ordinal values or enums. |
| 42 | * We get away with this as we never present the actual binary values |
| 43 | * externally. For sysfs, we always present the string that describes |
| 44 | * the value. Thus, an admin doesn't need a magic HBAAPI decoder ring |
| 45 | * to understand the values. The HBAAPI user-space library is free to |
| 46 | * convert the strings into the HBAAPI-specified binary values. |
| 47 | * |
| 48 | * Note: Not all HBAAPI-defined values are contained in the definitions |
| 49 | * below. Those not appropriate to an fc_host (e.g. FCP initiator) have |
| 50 | * been removed. |
| 51 | */ |
| 52 | |
| 53 | /* |
| 54 | * fc_port_type: If you alter this, you also need to alter scsi_transport_fc.c |
| 55 | * (for the ascii descriptions). |
| 56 | */ |
| 57 | enum fc_port_type { |
| 58 | FC_PORTTYPE_UNKNOWN, |
| 59 | FC_PORTTYPE_OTHER, |
| 60 | FC_PORTTYPE_NOTPRESENT, |
| 61 | FC_PORTTYPE_NPORT, /* Attached to FPort */ |
| 62 | FC_PORTTYPE_NLPORT, /* (Public) Loop w/ FLPort */ |
| 63 | FC_PORTTYPE_LPORT, /* (Private) Loop w/o FLPort */ |
| 64 | FC_PORTTYPE_PTP, /* Point to Point w/ another NPort */ |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 65 | FC_PORTTYPE_NPIV, /* VPORT based on NPIV */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | }; |
| 67 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 68 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | /* |
| 70 | * fc_port_state: If you alter this, you also need to alter scsi_transport_fc.c |
| 71 | * (for the ascii descriptions). |
| 72 | */ |
| 73 | enum fc_port_state { |
| 74 | FC_PORTSTATE_UNKNOWN, |
| 75 | FC_PORTSTATE_NOTPRESENT, |
| 76 | FC_PORTSTATE_ONLINE, |
| 77 | FC_PORTSTATE_OFFLINE, /* User has taken Port Offline */ |
| 78 | FC_PORTSTATE_BLOCKED, |
| 79 | FC_PORTSTATE_BYPASSED, |
| 80 | FC_PORTSTATE_DIAGNOSTICS, |
| 81 | FC_PORTSTATE_LINKDOWN, |
| 82 | FC_PORTSTATE_ERROR, |
| 83 | FC_PORTSTATE_LOOPBACK, |
James.Smart@Emulex.Com | 42e3314 | 2005-12-15 09:56:22 -0500 | [diff] [blame] | 84 | FC_PORTSTATE_DELETED, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | }; |
| 86 | |
| 87 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 88 | /* |
| 89 | * fc_vport_state: If you alter this, you also need to alter |
| 90 | * scsi_transport_fc.c (for the ascii descriptions). |
| 91 | */ |
| 92 | enum fc_vport_state { |
| 93 | FC_VPORT_UNKNOWN, |
| 94 | FC_VPORT_ACTIVE, |
| 95 | FC_VPORT_DISABLED, |
| 96 | FC_VPORT_LINKDOWN, |
| 97 | FC_VPORT_INITIALIZING, |
| 98 | FC_VPORT_NO_FABRIC_SUPP, |
| 99 | FC_VPORT_NO_FABRIC_RSCS, |
| 100 | FC_VPORT_FABRIC_LOGOUT, |
| 101 | FC_VPORT_FABRIC_REJ_WWN, |
| 102 | FC_VPORT_FAILED, |
| 103 | }; |
| 104 | |
| 105 | |
| 106 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | /* |
| 108 | * FC Classes of Service |
| 109 | * Note: values are not enumerated, as they can be "or'd" together |
| 110 | * for reporting (e.g. report supported_classes). If you alter this list, |
| 111 | * you also need to alter scsi_transport_fc.c (for the ascii descriptions). |
| 112 | */ |
| 113 | #define FC_COS_UNSPECIFIED 0 |
| 114 | #define FC_COS_CLASS1 2 |
| 115 | #define FC_COS_CLASS2 4 |
| 116 | #define FC_COS_CLASS3 8 |
| 117 | #define FC_COS_CLASS4 0x10 |
| 118 | #define FC_COS_CLASS6 0x40 |
| 119 | |
| 120 | /* |
| 121 | * FC Port Speeds |
| 122 | * Note: values are not enumerated, as they can be "or'd" together |
| 123 | * for reporting (e.g. report supported_speeds). If you alter this list, |
| 124 | * you also need to alter scsi_transport_fc.c (for the ascii descriptions). |
| 125 | */ |
| 126 | #define FC_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver |
| 127 | incapable of reporting */ |
| 128 | #define FC_PORTSPEED_1GBIT 1 |
| 129 | #define FC_PORTSPEED_2GBIT 2 |
Andreas Herrmann | 1832a58 | 2005-09-16 11:01:14 +0200 | [diff] [blame] | 130 | #define FC_PORTSPEED_4GBIT 4 |
| 131 | #define FC_PORTSPEED_10GBIT 8 |
James Smart | c3d2350 | 2007-03-12 14:16:35 -0500 | [diff] [blame] | 132 | #define FC_PORTSPEED_8GBIT 0x10 |
| 133 | #define FC_PORTSPEED_16GBIT 0x20 |
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 */ |
| 166 | #define FC_VPORT_ATTR(_name,_mode,_show,_store) \ |
| 167 | struct class_device_attribute class_device_attr_vport_##_name = \ |
| 168 | __ATTR(_name,_mode,_show,_store) |
| 169 | |
| 170 | |
| 171 | /* |
| 172 | * FC Virtual Port Attributes |
| 173 | * |
| 174 | * This structure exists for each FC port is a virtual FC port. Virtual |
| 175 | * ports share the physical link with the Physical port. Each virtual |
| 176 | * ports has a unique presense on the SAN, and may be instantiated via |
| 177 | * NPIV, Virtual Fabrics, or via additional ALPAs. As the vport is a |
| 178 | * unique presense, each vport has it's own view of the fabric, |
| 179 | * authentication priviledge, and priorities. |
| 180 | * |
| 181 | * A virtual port may support 1 or more FC4 roles. Typically it is a |
| 182 | * FCP Initiator. It could be a FCP Target, or exist sole for an IP over FC |
| 183 | * roles. FC port attributes for the vport will be reported on any |
| 184 | * fc_host class object allocated for an FCP Initiator. |
| 185 | * |
| 186 | * -- |
| 187 | * |
| 188 | * Fixed attributes are not expected to change. The driver is |
| 189 | * expected to set these values after receiving the fc_vport structure |
| 190 | * via the vport_create() call from the transport. |
| 191 | * The transport fully manages all get functions w/o driver interaction. |
| 192 | * |
| 193 | * Dynamic attributes are expected to change. The driver participates |
| 194 | * in all get/set operations via functions provided by the driver. |
| 195 | * |
| 196 | * Private attributes are transport-managed values. They are fully |
| 197 | * managed by the transport w/o driver interaction. |
| 198 | */ |
| 199 | |
| 200 | #define FC_VPORT_SYMBOLIC_NAMELEN 64 |
| 201 | struct fc_vport { |
| 202 | /* Fixed Attributes */ |
| 203 | |
| 204 | /* Dynamic Attributes */ |
| 205 | |
| 206 | /* Private (Transport-managed) Attributes */ |
| 207 | enum fc_vport_state vport_state; |
| 208 | enum fc_vport_state vport_last_state; |
| 209 | u64 node_name; |
| 210 | u64 port_name; |
| 211 | u32 roles; |
| 212 | u32 vport_id; /* Admin Identifier for the vport */ |
| 213 | enum fc_port_type vport_type; |
| 214 | char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN]; |
| 215 | |
| 216 | /* exported data */ |
| 217 | void *dd_data; /* Used for driver-specific storage */ |
| 218 | |
| 219 | /* internal data */ |
| 220 | struct Scsi_Host *shost; /* Physical Port Parent */ |
| 221 | unsigned int channel; |
| 222 | u32 number; |
| 223 | u8 flags; |
| 224 | struct list_head peers; |
| 225 | struct device dev; |
| 226 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 227 | |
| 228 | /* bit field values for struct fc_vport "flags" field: */ |
| 229 | #define FC_VPORT_CREATING 0x01 |
| 230 | #define FC_VPORT_DELETING 0x02 |
| 231 | #define FC_VPORT_DELETED 0x04 |
| 232 | #define FC_VPORT_DEL 0x06 /* Any DELETE state */ |
| 233 | |
| 234 | #define dev_to_vport(d) \ |
| 235 | container_of(d, struct fc_vport, dev) |
| 236 | #define transport_class_to_vport(classdev) \ |
| 237 | dev_to_vport(classdev->dev) |
| 238 | #define vport_to_shost(v) \ |
| 239 | (v->shost) |
| 240 | #define vport_to_shost_channel(v) \ |
| 241 | (v->channel) |
| 242 | #define vport_to_parent(v) \ |
| 243 | (v->dev.parent) |
| 244 | |
| 245 | |
| 246 | /* Error return codes for vport_create() callback */ |
| 247 | #define VPCERR_UNSUPPORTED -ENOSYS /* no driver/adapter |
| 248 | support */ |
| 249 | #define VPCERR_BAD_WWN -ENOTUNIQ /* driver validation |
| 250 | of WWNs failed */ |
| 251 | #define VPCERR_NO_FABRIC_SUPP -EOPNOTSUPP /* Fabric connection |
| 252 | is loop or the |
| 253 | Fabric Port does |
| 254 | not support NPIV */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | |
| 256 | /* |
| 257 | * fc_rport_identifiers: This set of data contains all elements |
| 258 | * to uniquely identify a remote FC port. The driver uses this data |
| 259 | * to report the existence of a remote FC port in the topology. Internally, |
| 260 | * the transport uses this data for attributes and to manage consistent |
| 261 | * target id bindings. |
| 262 | */ |
| 263 | struct fc_rport_identifiers { |
| 264 | u64 node_name; |
| 265 | u64 port_name; |
| 266 | u32 port_id; |
| 267 | u32 roles; |
| 268 | }; |
| 269 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 270 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | /* Macro for use in defining Remote Port attributes */ |
| 272 | #define FC_RPORT_ATTR(_name,_mode,_show,_store) \ |
| 273 | struct class_device_attribute class_device_attr_rport_##_name = \ |
| 274 | __ATTR(_name,_mode,_show,_store) |
| 275 | |
| 276 | |
| 277 | /* |
| 278 | * FC Remote Port Attributes |
| 279 | * |
| 280 | * This structure exists for each remote FC port that a LLDD notifies |
| 281 | * the subsystem of. A remote FC port may or may not be a SCSI Target, |
| 282 | * also be a SCSI initiator, IP endpoint, etc. As such, the remote |
| 283 | * port is considered a separate entity, independent of "role" (such |
| 284 | * as scsi target). |
| 285 | * |
| 286 | * -- |
| 287 | * |
| 288 | * Attributes are based on HBAAPI V2.0 definitions. Only those |
| 289 | * attributes that are determinable by the local port (aka Host) |
| 290 | * are contained. |
| 291 | * |
| 292 | * Fixed attributes are not expected to change. The driver is |
| 293 | * expected to set these values after successfully calling |
| 294 | * fc_remote_port_add(). The transport fully manages all get functions |
| 295 | * w/o driver interaction. |
| 296 | * |
| 297 | * Dynamic attributes are expected to change. The driver participates |
| 298 | * in all get/set operations via functions provided by the driver. |
| 299 | * |
| 300 | * Private attributes are transport-managed values. They are fully |
| 301 | * managed by the transport w/o driver interaction. |
| 302 | */ |
| 303 | |
| 304 | struct fc_rport { /* aka fc_starget_attrs */ |
| 305 | /* Fixed Attributes */ |
| 306 | u32 maxframe_size; |
| 307 | u32 supported_classes; |
| 308 | |
| 309 | /* Dynamic Attributes */ |
| 310 | u32 dev_loss_tmo; /* Remote Port loss timeout in seconds. */ |
| 311 | |
| 312 | /* Private (Transport-managed) Attributes */ |
| 313 | u64 node_name; |
| 314 | u64 port_name; |
| 315 | u32 port_id; |
| 316 | u32 roles; |
| 317 | enum fc_port_state port_state; /* Will only be ONLINE or UNKNOWN */ |
| 318 | u32 scsi_target_id; |
James Smart | 0f29b96 | 2006-08-18 17:33:29 -0400 | [diff] [blame] | 319 | u32 fast_io_fail_tmo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | |
| 321 | /* exported data */ |
| 322 | void *dd_data; /* Used for driver-specific storage */ |
| 323 | |
| 324 | /* internal data */ |
| 325 | unsigned int channel; |
| 326 | u32 number; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 327 | u8 flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | struct list_head peers; |
| 329 | struct device dev; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 330 | struct delayed_work dev_loss_work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | struct work_struct scan_work; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 332 | struct delayed_work fail_io_work; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 333 | struct work_struct stgt_delete_work; |
| 334 | struct work_struct rport_delete_work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 336 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 337 | /* bit field values for struct fc_rport "flags" field: */ |
| 338 | #define FC_RPORT_DEVLOSS_PENDING 0x01 |
| 339 | #define FC_RPORT_SCAN_PENDING 0x02 |
| 340 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 341 | #define dev_to_rport(d) \ |
| 342 | container_of(d, struct fc_rport, dev) |
| 343 | #define transport_class_to_rport(classdev) \ |
| 344 | dev_to_rport(classdev->dev) |
| 345 | #define rport_to_shost(r) \ |
| 346 | dev_to_shost(r->dev.parent) |
| 347 | |
| 348 | /* |
| 349 | * FC SCSI Target Attributes |
| 350 | * |
| 351 | * The SCSI Target is considered an extention of a remote port (as |
| 352 | * a remote port can be more than a SCSI Target). Within the scsi |
| 353 | * subsystem, we leave the Target as a separate entity. Doing so |
| 354 | * provides backward compatibility with prior FC transport api's, |
| 355 | * and lets remote ports be handled entirely within the FC transport |
| 356 | * and independently from the scsi subsystem. The drawback is that |
| 357 | * some data will be duplicated. |
| 358 | */ |
| 359 | |
| 360 | struct fc_starget_attrs { /* aka fc_target_attrs */ |
| 361 | /* Dynamic Attributes */ |
| 362 | u64 node_name; |
| 363 | u64 port_name; |
| 364 | u32 port_id; |
| 365 | }; |
| 366 | |
| 367 | #define fc_starget_node_name(x) \ |
| 368 | (((struct fc_starget_attrs *)&(x)->starget_data)->node_name) |
| 369 | #define fc_starget_port_name(x) \ |
| 370 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_name) |
| 371 | #define fc_starget_port_id(x) \ |
| 372 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_id) |
| 373 | |
| 374 | #define starget_to_rport(s) \ |
| 375 | scsi_is_fc_rport(s->dev.parent) ? dev_to_rport(s->dev.parent) : NULL |
| 376 | |
| 377 | |
| 378 | /* |
| 379 | * FC Local Port (Host) Statistics |
| 380 | */ |
| 381 | |
| 382 | /* FC Statistics - Following FC HBAAPI v2.0 guidelines */ |
| 383 | struct fc_host_statistics { |
| 384 | /* port statistics */ |
| 385 | u64 seconds_since_last_reset; |
| 386 | u64 tx_frames; |
| 387 | u64 tx_words; |
| 388 | u64 rx_frames; |
| 389 | u64 rx_words; |
| 390 | u64 lip_count; |
| 391 | u64 nos_count; |
| 392 | u64 error_frames; |
| 393 | u64 dumped_frames; |
| 394 | u64 link_failure_count; |
| 395 | u64 loss_of_sync_count; |
| 396 | u64 loss_of_signal_count; |
| 397 | u64 prim_seq_protocol_err_count; |
| 398 | u64 invalid_tx_word_count; |
| 399 | u64 invalid_crc_count; |
| 400 | |
| 401 | /* fc4 statistics (only FCP supported currently) */ |
| 402 | u64 fcp_input_requests; |
| 403 | u64 fcp_output_requests; |
| 404 | u64 fcp_control_requests; |
| 405 | u64 fcp_input_megabytes; |
| 406 | u64 fcp_output_megabytes; |
| 407 | }; |
| 408 | |
| 409 | |
| 410 | /* |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 411 | * FC Event Codes - Polled and Async, following FC HBAAPI v2.0 guidelines |
| 412 | */ |
| 413 | |
| 414 | /* |
| 415 | * fc_host_event_code: If you alter this, you also need to alter |
| 416 | * scsi_transport_fc.c (for the ascii descriptions). |
| 417 | */ |
| 418 | enum fc_host_event_code { |
| 419 | FCH_EVT_LIP = 0x1, |
| 420 | FCH_EVT_LINKUP = 0x2, |
| 421 | FCH_EVT_LINKDOWN = 0x3, |
| 422 | FCH_EVT_LIPRESET = 0x4, |
| 423 | FCH_EVT_RSCN = 0x5, |
| 424 | FCH_EVT_ADAPTER_CHANGE = 0x103, |
| 425 | FCH_EVT_PORT_UNKNOWN = 0x200, |
| 426 | FCH_EVT_PORT_OFFLINE = 0x201, |
| 427 | FCH_EVT_PORT_ONLINE = 0x202, |
| 428 | FCH_EVT_PORT_FABRIC = 0x204, |
| 429 | FCH_EVT_LINK_UNKNOWN = 0x500, |
| 430 | FCH_EVT_VENDOR_UNIQUE = 0xffff, |
| 431 | }; |
| 432 | |
| 433 | |
| 434 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | * FC Local Port (Host) Attributes |
| 436 | * |
| 437 | * Attributes are based on HBAAPI V2.0 definitions. |
| 438 | * Note: OSDeviceName is determined by user-space library |
| 439 | * |
| 440 | * Fixed attributes are not expected to change. The driver is |
| 441 | * expected to set these values after successfully calling scsi_add_host(). |
| 442 | * The transport fully manages all get functions w/o driver interaction. |
| 443 | * |
| 444 | * Dynamic attributes are expected to change. The driver participates |
| 445 | * in all get/set operations via functions provided by the driver. |
| 446 | * |
| 447 | * Private attributes are transport-managed values. They are fully |
| 448 | * managed by the transport w/o driver interaction. |
| 449 | */ |
| 450 | |
| 451 | #define FC_FC4_LIST_SIZE 32 |
| 452 | #define FC_SYMBOLIC_NAME_SIZE 256 |
| 453 | #define FC_VERSION_STRING_SIZE 64 |
| 454 | #define FC_SERIAL_NUMBER_SIZE 80 |
| 455 | |
| 456 | struct fc_host_attrs { |
| 457 | /* Fixed Attributes */ |
| 458 | u64 node_name; |
| 459 | u64 port_name; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 460 | u64 permanent_port_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | u32 supported_classes; |
| 462 | u8 supported_fc4s[FC_FC4_LIST_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 463 | u32 supported_speeds; |
| 464 | u32 maxframe_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 465 | u16 max_npiv_vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | char serial_number[FC_SERIAL_NUMBER_SIZE]; |
| 467 | |
| 468 | /* Dynamic Attributes */ |
| 469 | u32 port_id; |
| 470 | enum fc_port_type port_type; |
| 471 | enum fc_port_state port_state; |
| 472 | u8 active_fc4s[FC_FC4_LIST_SIZE]; |
| 473 | u32 speed; |
| 474 | u64 fabric_name; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 475 | char symbolic_name[FC_SYMBOLIC_NAME_SIZE]; |
| 476 | char system_hostname[FC_SYMBOLIC_NAME_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | |
| 478 | /* Private (Transport-managed) Attributes */ |
| 479 | enum fc_tgtid_binding_type tgtid_bind_type; |
| 480 | |
| 481 | /* internal data */ |
| 482 | struct list_head rports; |
| 483 | struct list_head rport_bindings; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 484 | struct list_head vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | u32 next_rport_number; |
| 486 | u32 next_target_id; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 487 | u32 next_vport_number; |
| 488 | u16 npiv_vports_inuse; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 489 | |
| 490 | /* work queues for rport state manipulation */ |
| 491 | char work_q_name[KOBJ_NAME_LEN]; |
| 492 | struct workqueue_struct *work_q; |
| 493 | char devloss_work_q_name[KOBJ_NAME_LEN]; |
| 494 | struct workqueue_struct *devloss_work_q; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | }; |
| 496 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 497 | #define shost_to_fc_host(x) \ |
| 498 | ((struct fc_host_attrs *)(x)->shost_data) |
James.Smart@Emulex.Com | 42e3314 | 2005-12-15 09:56:22 -0500 | [diff] [blame] | 499 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | #define fc_host_node_name(x) \ |
| 501 | (((struct fc_host_attrs *)(x)->shost_data)->node_name) |
| 502 | #define fc_host_port_name(x) \ |
| 503 | (((struct fc_host_attrs *)(x)->shost_data)->port_name) |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 504 | #define fc_host_permanent_port_name(x) \ |
| 505 | (((struct fc_host_attrs *)(x)->shost_data)->permanent_port_name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | #define fc_host_supported_classes(x) \ |
| 507 | (((struct fc_host_attrs *)(x)->shost_data)->supported_classes) |
| 508 | #define fc_host_supported_fc4s(x) \ |
| 509 | (((struct fc_host_attrs *)(x)->shost_data)->supported_fc4s) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | #define fc_host_supported_speeds(x) \ |
| 511 | (((struct fc_host_attrs *)(x)->shost_data)->supported_speeds) |
| 512 | #define fc_host_maxframe_size(x) \ |
| 513 | (((struct fc_host_attrs *)(x)->shost_data)->maxframe_size) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 514 | #define fc_host_max_npiv_vports(x) \ |
| 515 | (((struct fc_host_attrs *)(x)->shost_data)->max_npiv_vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | #define fc_host_serial_number(x) \ |
| 517 | (((struct fc_host_attrs *)(x)->shost_data)->serial_number) |
| 518 | #define fc_host_port_id(x) \ |
| 519 | (((struct fc_host_attrs *)(x)->shost_data)->port_id) |
| 520 | #define fc_host_port_type(x) \ |
| 521 | (((struct fc_host_attrs *)(x)->shost_data)->port_type) |
| 522 | #define fc_host_port_state(x) \ |
| 523 | (((struct fc_host_attrs *)(x)->shost_data)->port_state) |
| 524 | #define fc_host_active_fc4s(x) \ |
| 525 | (((struct fc_host_attrs *)(x)->shost_data)->active_fc4s) |
| 526 | #define fc_host_speed(x) \ |
| 527 | (((struct fc_host_attrs *)(x)->shost_data)->speed) |
| 528 | #define fc_host_fabric_name(x) \ |
| 529 | (((struct fc_host_attrs *)(x)->shost_data)->fabric_name) |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 530 | #define fc_host_symbolic_name(x) \ |
| 531 | (((struct fc_host_attrs *)(x)->shost_data)->symbolic_name) |
| 532 | #define fc_host_system_hostname(x) \ |
| 533 | (((struct fc_host_attrs *)(x)->shost_data)->system_hostname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 534 | #define fc_host_tgtid_bind_type(x) \ |
| 535 | (((struct fc_host_attrs *)(x)->shost_data)->tgtid_bind_type) |
| 536 | #define fc_host_rports(x) \ |
| 537 | (((struct fc_host_attrs *)(x)->shost_data)->rports) |
| 538 | #define fc_host_rport_bindings(x) \ |
| 539 | (((struct fc_host_attrs *)(x)->shost_data)->rport_bindings) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 540 | #define fc_host_vports(x) \ |
| 541 | (((struct fc_host_attrs *)(x)->shost_data)->vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | #define fc_host_next_rport_number(x) \ |
| 543 | (((struct fc_host_attrs *)(x)->shost_data)->next_rport_number) |
| 544 | #define fc_host_next_target_id(x) \ |
| 545 | (((struct fc_host_attrs *)(x)->shost_data)->next_target_id) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 546 | #define fc_host_next_vport_number(x) \ |
| 547 | (((struct fc_host_attrs *)(x)->shost_data)->next_vport_number) |
| 548 | #define fc_host_npiv_vports_inuse(x) \ |
| 549 | (((struct fc_host_attrs *)(x)->shost_data)->npiv_vports_inuse) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 550 | #define fc_host_work_q_name(x) \ |
| 551 | (((struct fc_host_attrs *)(x)->shost_data)->work_q_name) |
| 552 | #define fc_host_work_q(x) \ |
| 553 | (((struct fc_host_attrs *)(x)->shost_data)->work_q) |
| 554 | #define fc_host_devloss_work_q_name(x) \ |
| 555 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q_name) |
| 556 | #define fc_host_devloss_work_q(x) \ |
| 557 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | |
| 559 | |
| 560 | /* The functions by which the transport class and the driver communicate */ |
| 561 | struct fc_function_template { |
| 562 | void (*get_rport_dev_loss_tmo)(struct fc_rport *); |
| 563 | void (*set_rport_dev_loss_tmo)(struct fc_rport *, u32); |
| 564 | |
| 565 | void (*get_starget_node_name)(struct scsi_target *); |
| 566 | void (*get_starget_port_name)(struct scsi_target *); |
| 567 | void (*get_starget_port_id)(struct scsi_target *); |
| 568 | |
| 569 | void (*get_host_port_id)(struct Scsi_Host *); |
| 570 | void (*get_host_port_type)(struct Scsi_Host *); |
| 571 | void (*get_host_port_state)(struct Scsi_Host *); |
| 572 | void (*get_host_active_fc4s)(struct Scsi_Host *); |
| 573 | void (*get_host_speed)(struct Scsi_Host *); |
| 574 | void (*get_host_fabric_name)(struct Scsi_Host *); |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 575 | void (*get_host_symbolic_name)(struct Scsi_Host *); |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 576 | void (*set_host_system_hostname)(struct Scsi_Host *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 577 | |
| 578 | struct fc_host_statistics * (*get_fc_host_stats)(struct Scsi_Host *); |
| 579 | void (*reset_fc_host_stats)(struct Scsi_Host *); |
| 580 | |
Andrew Vasquez | 91ca7b0 | 2005-10-27 16:03:37 -0700 | [diff] [blame] | 581 | int (*issue_fc_host_lip)(struct Scsi_Host *); |
| 582 | |
James Smart | 0f29b96 | 2006-08-18 17:33:29 -0400 | [diff] [blame] | 583 | void (*dev_loss_tmo_callbk)(struct fc_rport *); |
| 584 | void (*terminate_rport_io)(struct fc_rport *); |
| 585 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 586 | void (*set_vport_symbolic_name)(struct fc_vport *); |
| 587 | int (*vport_create)(struct fc_vport *, bool); |
| 588 | int (*vport_disable)(struct fc_vport *, bool); |
| 589 | int (*vport_delete)(struct fc_vport *); |
| 590 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 591 | /* allocation lengths for host-specific data */ |
| 592 | u32 dd_fcrport_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 593 | u32 dd_fcvport_size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | |
| 595 | /* |
| 596 | * The driver sets these to tell the transport class it |
| 597 | * wants the attributes displayed in sysfs. If the show_ flag |
| 598 | * is not set, the attribute will be private to the transport |
| 599 | * class |
| 600 | */ |
| 601 | |
| 602 | /* remote port fixed attributes */ |
| 603 | unsigned long show_rport_maxframe_size:1; |
| 604 | unsigned long show_rport_supported_classes:1; |
| 605 | unsigned long show_rport_dev_loss_tmo:1; |
| 606 | |
| 607 | /* |
| 608 | * target dynamic attributes |
| 609 | * These should all be "1" if the driver uses the remote port |
| 610 | * add/delete functions (so attributes reflect rport values). |
| 611 | */ |
| 612 | unsigned long show_starget_node_name:1; |
| 613 | unsigned long show_starget_port_name:1; |
| 614 | unsigned long show_starget_port_id:1; |
| 615 | |
| 616 | /* host fixed attributes */ |
| 617 | unsigned long show_host_node_name:1; |
| 618 | unsigned long show_host_port_name:1; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 619 | unsigned long show_host_permanent_port_name:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | unsigned long show_host_supported_classes:1; |
| 621 | unsigned long show_host_supported_fc4s:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 622 | unsigned long show_host_supported_speeds:1; |
| 623 | unsigned long show_host_maxframe_size:1; |
| 624 | unsigned long show_host_serial_number:1; |
| 625 | /* host dynamic attributes */ |
| 626 | unsigned long show_host_port_id:1; |
| 627 | unsigned long show_host_port_type:1; |
| 628 | unsigned long show_host_port_state:1; |
| 629 | unsigned long show_host_active_fc4s:1; |
| 630 | unsigned long show_host_speed:1; |
| 631 | unsigned long show_host_fabric_name:1; |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 632 | unsigned long show_host_symbolic_name:1; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 633 | unsigned long show_host_system_hostname:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 634 | }; |
| 635 | |
| 636 | |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 637 | /** |
| 638 | * fc_remote_port_chkready - called to validate the remote port state |
| 639 | * prior to initiating io to the port. |
| 640 | * |
| 641 | * Returns a scsi result code that can be returned by the LLDD. |
| 642 | * |
| 643 | * @rport: remote port to be checked |
| 644 | **/ |
| 645 | static inline int |
| 646 | fc_remote_port_chkready(struct fc_rport *rport) |
| 647 | { |
| 648 | int result; |
| 649 | |
| 650 | switch (rport->port_state) { |
| 651 | case FC_PORTSTATE_ONLINE: |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 652 | if (rport->roles & FC_PORT_ROLE_FCP_TARGET) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 653 | result = 0; |
| 654 | else if (rport->flags & FC_RPORT_DEVLOSS_PENDING) |
| 655 | result = DID_IMM_RETRY << 16; |
| 656 | else |
| 657 | result = DID_NO_CONNECT << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 658 | break; |
| 659 | case FC_PORTSTATE_BLOCKED: |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 660 | result = DID_IMM_RETRY << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 661 | break; |
| 662 | default: |
| 663 | result = DID_NO_CONNECT << 16; |
| 664 | break; |
| 665 | } |
| 666 | return result; |
| 667 | } |
| 668 | |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 669 | static inline u64 wwn_to_u64(u8 *wwn) |
| 670 | { |
| 671 | return (u64)wwn[0] << 56 | (u64)wwn[1] << 48 | |
| 672 | (u64)wwn[2] << 40 | (u64)wwn[3] << 32 | |
| 673 | (u64)wwn[4] << 24 | (u64)wwn[5] << 16 | |
| 674 | (u64)wwn[6] << 8 | (u64)wwn[7]; |
| 675 | } |
| 676 | |
| 677 | static inline void u64_to_wwn(u64 inm, u8 *wwn) |
| 678 | { |
| 679 | wwn[0] = (inm >> 56) & 0xff; |
| 680 | wwn[1] = (inm >> 48) & 0xff; |
| 681 | wwn[2] = (inm >> 40) & 0xff; |
| 682 | wwn[3] = (inm >> 32) & 0xff; |
| 683 | wwn[4] = (inm >> 24) & 0xff; |
| 684 | wwn[5] = (inm >> 16) & 0xff; |
| 685 | wwn[6] = (inm >> 8) & 0xff; |
| 686 | wwn[7] = inm & 0xff; |
| 687 | } |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 688 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 689 | /** |
| 690 | * fc_vport_set_state() - called to set a vport's state. Saves the old state, |
| 691 | * excepting the transitory states of initializing and sending the ELS |
| 692 | * traffic to instantiate the vport on the link. |
| 693 | * |
| 694 | * Assumes the driver has surrounded this with the proper locking to ensure |
| 695 | * a coherent state change. |
| 696 | * |
| 697 | * @vport: virtual port whose state is changing |
| 698 | * @new_state: new state |
| 699 | **/ |
| 700 | static inline void |
| 701 | fc_vport_set_state(struct fc_vport *vport, enum fc_vport_state new_state) |
| 702 | { |
| 703 | if ((new_state != FC_VPORT_UNKNOWN) && |
| 704 | (new_state != FC_VPORT_INITIALIZING)) |
| 705 | vport->vport_last_state = vport->vport_state; |
| 706 | vport->vport_state = new_state; |
| 707 | } |
| 708 | |
| 709 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 710 | struct scsi_transport_template *fc_attach_transport( |
| 711 | struct fc_function_template *); |
| 712 | void fc_release_transport(struct scsi_transport_template *); |
| 713 | void fc_remove_host(struct Scsi_Host *); |
| 714 | struct fc_rport *fc_remote_port_add(struct Scsi_Host *shost, |
| 715 | int channel, struct fc_rport_identifiers *ids); |
| 716 | void fc_remote_port_delete(struct fc_rport *rport); |
| 717 | void fc_remote_port_rolechg(struct fc_rport *rport, u32 roles); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 718 | int scsi_is_fc_rport(const struct device *); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 719 | u32 fc_get_event_number(void); |
| 720 | void fc_host_post_event(struct Scsi_Host *shost, u32 event_number, |
| 721 | enum fc_host_event_code event_code, u32 event_data); |
| 722 | 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] | 723 | u32 data_len, char * data_buf, u64 vendor_id); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 724 | /* Note: when specifying vendor_id to fc_host_post_vendor_event() |
| 725 | * be sure to read the Vendor Type and ID formatting requirements |
| 726 | * specified in scsi_netlink.h |
| 727 | */ |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame^] | 728 | int fc_vport_terminate(struct fc_vport *vport); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 729 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 730 | #endif /* SCSI_TRANSPORT_FC_H */ |