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 | |
| 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 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 107 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 120 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 */ |
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 |
| 196 | * ports has a unique presense on the SAN, and may be instantiated via |
| 197 | * NPIV, Virtual Fabrics, or via additional ALPAs. As the vport is a |
| 198 | * unique presense, 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 356 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 357 | /* bit field values for struct fc_rport "flags" field: */ |
| 358 | #define FC_RPORT_DEVLOSS_PENDING 0x01 |
| 359 | #define FC_RPORT_SCAN_PENDING 0x02 |
| 360 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | #define dev_to_rport(d) \ |
| 362 | container_of(d, struct fc_rport, dev) |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 363 | #define transport_class_to_rport(dev) \ |
| 364 | dev_to_rport(dev->parent) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | #define rport_to_shost(r) \ |
| 366 | dev_to_shost(r->dev.parent) |
| 367 | |
| 368 | /* |
| 369 | * FC SCSI Target Attributes |
| 370 | * |
| 371 | * The SCSI Target is considered an extention of a remote port (as |
| 372 | * a remote port can be more than a SCSI Target). Within the scsi |
| 373 | * subsystem, we leave the Target as a separate entity. Doing so |
| 374 | * provides backward compatibility with prior FC transport api's, |
| 375 | * and lets remote ports be handled entirely within the FC transport |
| 376 | * and independently from the scsi subsystem. The drawback is that |
| 377 | * some data will be duplicated. |
| 378 | */ |
| 379 | |
| 380 | struct fc_starget_attrs { /* aka fc_target_attrs */ |
| 381 | /* Dynamic Attributes */ |
| 382 | u64 node_name; |
| 383 | u64 port_name; |
| 384 | u32 port_id; |
| 385 | }; |
| 386 | |
| 387 | #define fc_starget_node_name(x) \ |
| 388 | (((struct fc_starget_attrs *)&(x)->starget_data)->node_name) |
| 389 | #define fc_starget_port_name(x) \ |
| 390 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_name) |
| 391 | #define fc_starget_port_id(x) \ |
| 392 | (((struct fc_starget_attrs *)&(x)->starget_data)->port_id) |
| 393 | |
| 394 | #define starget_to_rport(s) \ |
| 395 | scsi_is_fc_rport(s->dev.parent) ? dev_to_rport(s->dev.parent) : NULL |
| 396 | |
| 397 | |
| 398 | /* |
| 399 | * FC Local Port (Host) Statistics |
| 400 | */ |
| 401 | |
| 402 | /* FC Statistics - Following FC HBAAPI v2.0 guidelines */ |
| 403 | struct fc_host_statistics { |
| 404 | /* port statistics */ |
| 405 | u64 seconds_since_last_reset; |
| 406 | u64 tx_frames; |
| 407 | u64 tx_words; |
| 408 | u64 rx_frames; |
| 409 | u64 rx_words; |
| 410 | u64 lip_count; |
| 411 | u64 nos_count; |
| 412 | u64 error_frames; |
| 413 | u64 dumped_frames; |
| 414 | u64 link_failure_count; |
| 415 | u64 loss_of_sync_count; |
| 416 | u64 loss_of_signal_count; |
| 417 | u64 prim_seq_protocol_err_count; |
| 418 | u64 invalid_tx_word_count; |
| 419 | u64 invalid_crc_count; |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 420 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | /* fc4 statistics (only FCP supported currently) */ |
| 422 | u64 fcp_input_requests; |
| 423 | u64 fcp_output_requests; |
| 424 | u64 fcp_control_requests; |
| 425 | u64 fcp_input_megabytes; |
| 426 | u64 fcp_output_megabytes; |
| 427 | }; |
| 428 | |
| 429 | |
| 430 | /* |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 431 | * FC Event Codes - Polled and Async, following FC HBAAPI v2.0 guidelines |
| 432 | */ |
| 433 | |
| 434 | /* |
| 435 | * fc_host_event_code: If you alter this, you also need to alter |
| 436 | * scsi_transport_fc.c (for the ascii descriptions). |
| 437 | */ |
| 438 | enum fc_host_event_code { |
| 439 | FCH_EVT_LIP = 0x1, |
| 440 | FCH_EVT_LINKUP = 0x2, |
| 441 | FCH_EVT_LINKDOWN = 0x3, |
| 442 | FCH_EVT_LIPRESET = 0x4, |
| 443 | FCH_EVT_RSCN = 0x5, |
| 444 | FCH_EVT_ADAPTER_CHANGE = 0x103, |
| 445 | FCH_EVT_PORT_UNKNOWN = 0x200, |
| 446 | FCH_EVT_PORT_OFFLINE = 0x201, |
| 447 | FCH_EVT_PORT_ONLINE = 0x202, |
| 448 | FCH_EVT_PORT_FABRIC = 0x204, |
| 449 | FCH_EVT_LINK_UNKNOWN = 0x500, |
| 450 | FCH_EVT_VENDOR_UNIQUE = 0xffff, |
| 451 | }; |
| 452 | |
| 453 | |
| 454 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | * FC Local Port (Host) Attributes |
| 456 | * |
| 457 | * Attributes are based on HBAAPI V2.0 definitions. |
| 458 | * Note: OSDeviceName is determined by user-space library |
| 459 | * |
| 460 | * Fixed attributes are not expected to change. The driver is |
| 461 | * expected to set these values after successfully calling scsi_add_host(). |
| 462 | * The transport fully manages all get functions w/o driver interaction. |
| 463 | * |
| 464 | * Dynamic attributes are expected to change. The driver participates |
| 465 | * in all get/set operations via functions provided by the driver. |
| 466 | * |
| 467 | * Private attributes are transport-managed values. They are fully |
| 468 | * managed by the transport w/o driver interaction. |
| 469 | */ |
| 470 | |
| 471 | #define FC_FC4_LIST_SIZE 32 |
| 472 | #define FC_SYMBOLIC_NAME_SIZE 256 |
| 473 | #define FC_VERSION_STRING_SIZE 64 |
| 474 | #define FC_SERIAL_NUMBER_SIZE 80 |
| 475 | |
| 476 | struct fc_host_attrs { |
| 477 | /* Fixed Attributes */ |
| 478 | u64 node_name; |
| 479 | u64 port_name; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 480 | u64 permanent_port_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | u32 supported_classes; |
| 482 | u8 supported_fc4s[FC_FC4_LIST_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | u32 supported_speeds; |
| 484 | u32 maxframe_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 485 | u16 max_npiv_vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | char serial_number[FC_SERIAL_NUMBER_SIZE]; |
| 487 | |
| 488 | /* Dynamic Attributes */ |
| 489 | u32 port_id; |
| 490 | enum fc_port_type port_type; |
| 491 | enum fc_port_state port_state; |
| 492 | u8 active_fc4s[FC_FC4_LIST_SIZE]; |
| 493 | u32 speed; |
| 494 | u64 fabric_name; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 495 | char symbolic_name[FC_SYMBOLIC_NAME_SIZE]; |
| 496 | char system_hostname[FC_SYMBOLIC_NAME_SIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | |
| 498 | /* Private (Transport-managed) Attributes */ |
| 499 | enum fc_tgtid_binding_type tgtid_bind_type; |
| 500 | |
| 501 | /* internal data */ |
| 502 | struct list_head rports; |
| 503 | struct list_head rport_bindings; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 504 | struct list_head vports; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 505 | u32 next_rport_number; |
| 506 | u32 next_target_id; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 507 | u32 next_vport_number; |
| 508 | u16 npiv_vports_inuse; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 509 | |
| 510 | /* work queues for rport state manipulation */ |
Kay Sievers | aab0de2 | 2008-05-02 06:02:41 +0200 | [diff] [blame] | 511 | char work_q_name[20]; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 512 | struct workqueue_struct *work_q; |
Kay Sievers | aab0de2 | 2008-05-02 06:02:41 +0200 | [diff] [blame] | 513 | char devloss_work_q_name[20]; |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 514 | struct workqueue_struct *devloss_work_q; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 515 | }; |
| 516 | |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 517 | #define shost_to_fc_host(x) \ |
| 518 | ((struct fc_host_attrs *)(x)->shost_data) |
James.Smart@Emulex.Com | 42e3314 | 2005-12-15 09:56:22 -0500 | [diff] [blame] | 519 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | #define fc_host_node_name(x) \ |
| 521 | (((struct fc_host_attrs *)(x)->shost_data)->node_name) |
| 522 | #define fc_host_port_name(x) \ |
| 523 | (((struct fc_host_attrs *)(x)->shost_data)->port_name) |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 524 | #define fc_host_permanent_port_name(x) \ |
| 525 | (((struct fc_host_attrs *)(x)->shost_data)->permanent_port_name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | #define fc_host_supported_classes(x) \ |
| 527 | (((struct fc_host_attrs *)(x)->shost_data)->supported_classes) |
| 528 | #define fc_host_supported_fc4s(x) \ |
| 529 | (((struct fc_host_attrs *)(x)->shost_data)->supported_fc4s) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 530 | #define fc_host_supported_speeds(x) \ |
| 531 | (((struct fc_host_attrs *)(x)->shost_data)->supported_speeds) |
| 532 | #define fc_host_maxframe_size(x) \ |
| 533 | (((struct fc_host_attrs *)(x)->shost_data)->maxframe_size) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 534 | #define fc_host_max_npiv_vports(x) \ |
| 535 | (((struct fc_host_attrs *)(x)->shost_data)->max_npiv_vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 536 | #define fc_host_serial_number(x) \ |
| 537 | (((struct fc_host_attrs *)(x)->shost_data)->serial_number) |
| 538 | #define fc_host_port_id(x) \ |
| 539 | (((struct fc_host_attrs *)(x)->shost_data)->port_id) |
| 540 | #define fc_host_port_type(x) \ |
| 541 | (((struct fc_host_attrs *)(x)->shost_data)->port_type) |
| 542 | #define fc_host_port_state(x) \ |
| 543 | (((struct fc_host_attrs *)(x)->shost_data)->port_state) |
| 544 | #define fc_host_active_fc4s(x) \ |
| 545 | (((struct fc_host_attrs *)(x)->shost_data)->active_fc4s) |
| 546 | #define fc_host_speed(x) \ |
| 547 | (((struct fc_host_attrs *)(x)->shost_data)->speed) |
| 548 | #define fc_host_fabric_name(x) \ |
| 549 | (((struct fc_host_attrs *)(x)->shost_data)->fabric_name) |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 550 | #define fc_host_symbolic_name(x) \ |
| 551 | (((struct fc_host_attrs *)(x)->shost_data)->symbolic_name) |
| 552 | #define fc_host_system_hostname(x) \ |
| 553 | (((struct fc_host_attrs *)(x)->shost_data)->system_hostname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | #define fc_host_tgtid_bind_type(x) \ |
| 555 | (((struct fc_host_attrs *)(x)->shost_data)->tgtid_bind_type) |
| 556 | #define fc_host_rports(x) \ |
| 557 | (((struct fc_host_attrs *)(x)->shost_data)->rports) |
| 558 | #define fc_host_rport_bindings(x) \ |
| 559 | (((struct fc_host_attrs *)(x)->shost_data)->rport_bindings) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 560 | #define fc_host_vports(x) \ |
| 561 | (((struct fc_host_attrs *)(x)->shost_data)->vports) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | #define fc_host_next_rport_number(x) \ |
| 563 | (((struct fc_host_attrs *)(x)->shost_data)->next_rport_number) |
| 564 | #define fc_host_next_target_id(x) \ |
| 565 | (((struct fc_host_attrs *)(x)->shost_data)->next_target_id) |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 566 | #define fc_host_next_vport_number(x) \ |
| 567 | (((struct fc_host_attrs *)(x)->shost_data)->next_vport_number) |
| 568 | #define fc_host_npiv_vports_inuse(x) \ |
| 569 | (((struct fc_host_attrs *)(x)->shost_data)->npiv_vports_inuse) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 570 | #define fc_host_work_q_name(x) \ |
| 571 | (((struct fc_host_attrs *)(x)->shost_data)->work_q_name) |
| 572 | #define fc_host_work_q(x) \ |
| 573 | (((struct fc_host_attrs *)(x)->shost_data)->work_q) |
| 574 | #define fc_host_devloss_work_q_name(x) \ |
| 575 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q_name) |
| 576 | #define fc_host_devloss_work_q(x) \ |
| 577 | (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | |
| 579 | |
| 580 | /* The functions by which the transport class and the driver communicate */ |
| 581 | struct fc_function_template { |
| 582 | void (*get_rport_dev_loss_tmo)(struct fc_rport *); |
| 583 | void (*set_rport_dev_loss_tmo)(struct fc_rport *, u32); |
| 584 | |
| 585 | void (*get_starget_node_name)(struct scsi_target *); |
| 586 | void (*get_starget_port_name)(struct scsi_target *); |
| 587 | void (*get_starget_port_id)(struct scsi_target *); |
| 588 | |
| 589 | void (*get_host_port_id)(struct Scsi_Host *); |
| 590 | void (*get_host_port_type)(struct Scsi_Host *); |
| 591 | void (*get_host_port_state)(struct Scsi_Host *); |
| 592 | void (*get_host_active_fc4s)(struct Scsi_Host *); |
| 593 | void (*get_host_speed)(struct Scsi_Host *); |
| 594 | void (*get_host_fabric_name)(struct Scsi_Host *); |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 595 | void (*get_host_symbolic_name)(struct Scsi_Host *); |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 596 | void (*set_host_system_hostname)(struct Scsi_Host *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | |
| 598 | struct fc_host_statistics * (*get_fc_host_stats)(struct Scsi_Host *); |
| 599 | void (*reset_fc_host_stats)(struct Scsi_Host *); |
| 600 | |
Andrew Vasquez | 91ca7b0 | 2005-10-27 16:03:37 -0700 | [diff] [blame] | 601 | int (*issue_fc_host_lip)(struct Scsi_Host *); |
| 602 | |
James Smart | 0f29b96 | 2006-08-18 17:33:29 -0400 | [diff] [blame] | 603 | void (*dev_loss_tmo_callbk)(struct fc_rport *); |
| 604 | void (*terminate_rport_io)(struct fc_rport *); |
| 605 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 606 | void (*set_vport_symbolic_name)(struct fc_vport *); |
| 607 | int (*vport_create)(struct fc_vport *, bool); |
| 608 | int (*vport_disable)(struct fc_vport *, bool); |
| 609 | int (*vport_delete)(struct fc_vport *); |
| 610 | |
FUJITA Tomonori | 7525236 | 2007-09-01 02:02:27 +0900 | [diff] [blame] | 611 | /* target-mode drivers' functions */ |
| 612 | int (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int); |
| 613 | int (* it_nexus_response)(struct Scsi_Host *, u64, int); |
| 614 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | /* allocation lengths for host-specific data */ |
| 616 | u32 dd_fcrport_size; |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 617 | u32 dd_fcvport_size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 618 | |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 619 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | * The driver sets these to tell the transport class it |
| 621 | * wants the attributes displayed in sysfs. If the show_ flag |
| 622 | * is not set, the attribute will be private to the transport |
James Smart | 9ef3e4a | 2007-05-24 19:04:44 -0400 | [diff] [blame] | 623 | * class |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 624 | */ |
| 625 | |
| 626 | /* remote port fixed attributes */ |
| 627 | unsigned long show_rport_maxframe_size:1; |
| 628 | unsigned long show_rport_supported_classes:1; |
| 629 | unsigned long show_rport_dev_loss_tmo:1; |
| 630 | |
| 631 | /* |
| 632 | * target dynamic attributes |
| 633 | * These should all be "1" if the driver uses the remote port |
| 634 | * add/delete functions (so attributes reflect rport values). |
| 635 | */ |
| 636 | unsigned long show_starget_node_name:1; |
| 637 | unsigned long show_starget_port_name:1; |
| 638 | unsigned long show_starget_port_id:1; |
| 639 | |
| 640 | /* host fixed attributes */ |
| 641 | unsigned long show_host_node_name:1; |
| 642 | unsigned long show_host_port_name:1; |
Andreas Herrmann | 6b7281d | 2006-01-13 02:16:54 +0100 | [diff] [blame] | 643 | unsigned long show_host_permanent_port_name:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 644 | unsigned long show_host_supported_classes:1; |
| 645 | unsigned long show_host_supported_fc4s:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 646 | unsigned long show_host_supported_speeds:1; |
| 647 | unsigned long show_host_maxframe_size:1; |
| 648 | unsigned long show_host_serial_number:1; |
| 649 | /* host dynamic attributes */ |
| 650 | unsigned long show_host_port_id:1; |
| 651 | unsigned long show_host_port_type:1; |
| 652 | unsigned long show_host_port_state:1; |
| 653 | unsigned long show_host_active_fc4s:1; |
| 654 | unsigned long show_host_speed:1; |
| 655 | unsigned long show_host_fabric_name:1; |
James Smart | 016131b | 2006-08-14 08:20:25 -0400 | [diff] [blame] | 656 | unsigned long show_host_symbolic_name:1; |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 657 | unsigned long show_host_system_hostname:1; |
Christof Schmitt | 03f002f | 2007-08-28 09:31:21 +0200 | [diff] [blame] | 658 | |
| 659 | unsigned long disable_target_scan:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 660 | }; |
| 661 | |
| 662 | |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 663 | /** |
| 664 | * fc_remote_port_chkready - called to validate the remote port state |
| 665 | * prior to initiating io to the port. |
| 666 | * |
| 667 | * Returns a scsi result code that can be returned by the LLDD. |
| 668 | * |
| 669 | * @rport: remote port to be checked |
| 670 | **/ |
| 671 | static inline int |
| 672 | fc_remote_port_chkready(struct fc_rport *rport) |
| 673 | { |
| 674 | int result; |
| 675 | |
| 676 | switch (rport->port_state) { |
| 677 | case FC_PORTSTATE_ONLINE: |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 678 | if (rport->roles & FC_PORT_ROLE_FCP_TARGET) |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 679 | result = 0; |
| 680 | else if (rport->flags & FC_RPORT_DEVLOSS_PENDING) |
| 681 | result = DID_IMM_RETRY << 16; |
| 682 | else |
| 683 | result = DID_NO_CONNECT << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 684 | break; |
| 685 | case FC_PORTSTATE_BLOCKED: |
James Smart | aedf349 | 2006-04-10 10:14:05 -0400 | [diff] [blame] | 686 | result = DID_IMM_RETRY << 16; |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 687 | break; |
| 688 | default: |
| 689 | result = DID_NO_CONNECT << 16; |
| 690 | break; |
| 691 | } |
| 692 | return result; |
| 693 | } |
| 694 | |
James Smart | b8d0821 | 2006-08-17 08:00:43 -0400 | [diff] [blame] | 695 | static inline u64 wwn_to_u64(u8 *wwn) |
| 696 | { |
| 697 | return (u64)wwn[0] << 56 | (u64)wwn[1] << 48 | |
| 698 | (u64)wwn[2] << 40 | (u64)wwn[3] << 32 | |
| 699 | (u64)wwn[4] << 24 | (u64)wwn[5] << 16 | |
| 700 | (u64)wwn[6] << 8 | (u64)wwn[7]; |
| 701 | } |
| 702 | |
| 703 | static inline void u64_to_wwn(u64 inm, u8 *wwn) |
| 704 | { |
| 705 | wwn[0] = (inm >> 56) & 0xff; |
| 706 | wwn[1] = (inm >> 48) & 0xff; |
| 707 | wwn[2] = (inm >> 40) & 0xff; |
| 708 | wwn[3] = (inm >> 32) & 0xff; |
| 709 | wwn[4] = (inm >> 24) & 0xff; |
| 710 | wwn[5] = (inm >> 16) & 0xff; |
| 711 | wwn[6] = (inm >> 8) & 0xff; |
| 712 | wwn[7] = inm & 0xff; |
| 713 | } |
James.Smart@Emulex.Com | 19a7b4a | 2005-10-18 12:03:35 -0400 | [diff] [blame] | 714 | |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 715 | /** |
| 716 | * fc_vport_set_state() - called to set a vport's state. Saves the old state, |
| 717 | * excepting the transitory states of initializing and sending the ELS |
| 718 | * traffic to instantiate the vport on the link. |
| 719 | * |
| 720 | * Assumes the driver has surrounded this with the proper locking to ensure |
| 721 | * a coherent state change. |
| 722 | * |
| 723 | * @vport: virtual port whose state is changing |
| 724 | * @new_state: new state |
| 725 | **/ |
| 726 | static inline void |
| 727 | fc_vport_set_state(struct fc_vport *vport, enum fc_vport_state new_state) |
| 728 | { |
| 729 | if ((new_state != FC_VPORT_UNKNOWN) && |
| 730 | (new_state != FC_VPORT_INITIALIZING)) |
| 731 | vport->vport_last_state = vport->vport_state; |
| 732 | vport->vport_state = new_state; |
| 733 | } |
| 734 | |
| 735 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 736 | struct scsi_transport_template *fc_attach_transport( |
| 737 | struct fc_function_template *); |
| 738 | void fc_release_transport(struct scsi_transport_template *); |
| 739 | void fc_remove_host(struct Scsi_Host *); |
| 740 | struct fc_rport *fc_remote_port_add(struct Scsi_Host *shost, |
| 741 | int channel, struct fc_rport_identifiers *ids); |
| 742 | void fc_remote_port_delete(struct fc_rport *rport); |
| 743 | void fc_remote_port_rolechg(struct fc_rport *rport, u32 roles); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | int scsi_is_fc_rport(const struct device *); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 745 | u32 fc_get_event_number(void); |
| 746 | void fc_host_post_event(struct Scsi_Host *shost, u32 event_number, |
| 747 | enum fc_host_event_code event_code, u32 event_data); |
| 748 | 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] | 749 | u32 data_len, char * data_buf, u64 vendor_id); |
James Smart | 84314fd | 2006-08-18 17:30:09 -0400 | [diff] [blame] | 750 | /* Note: when specifying vendor_id to fc_host_post_vendor_event() |
| 751 | * be sure to read the Vendor Type and ID formatting requirements |
| 752 | * specified in scsi_netlink.h |
| 753 | */ |
Andrew Vasquez | a30c3f6 | 2008-07-18 08:32:52 -0700 | [diff] [blame] | 754 | struct fc_vport *fc_vport_create(struct Scsi_Host *shost, int channel, |
| 755 | struct fc_vport_identifiers *); |
James Smart | a53eb5e | 2007-04-27 12:41:09 -0400 | [diff] [blame] | 756 | int fc_vport_terminate(struct fc_vport *vport); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 758 | #endif /* SCSI_TRANSPORT_FC_H */ |