Print this page
968 fct driver sets incorrect fc-ct revision
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/sys/fct.h
+++ new/usr/src/uts/common/sys/fct.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 + * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
23 24 */
24 25 #ifndef _FCT_H
25 26 #define _FCT_H
26 27
27 28 /*
28 29 * Definitions for common FC Target.
29 30 */
30 31 #include <sys/note.h>
31 32 #include <sys/stmf_defines.h>
32 33 #include <sys/fct_defines.h>
33 34 #include <sys/portif.h>
34 35
35 36 #ifdef __cplusplus
36 37 extern "C" {
37 38 #endif
38 39
39 40 typedef enum fct_struct_id {
40 41 FCT_STRUCT_LOCAL_PORT = 1,
41 42 FCT_STRUCT_REMOTE_PORT,
42 43 FCT_STRUCT_CMD_RCVD_ELS,
43 44 FCT_STRUCT_CMD_SOL_ELS,
44 45 FCT_STRUCT_CMD_SOL_CT,
45 46 FCT_STRUCT_CMD_RCVD_ABTS,
46 47 FCT_STRUCT_CMD_FCP_XCHG,
47 48 FCT_STRUCT_DBUF_STORE,
48 49
49 50 FCT_MAX_STRUCT_IDS
50 51 } fct_struct_id_t;
51 52
52 53 typedef struct fct_remote_port {
53 54 void *rp_fct_private;
54 55 void *rp_fca_private;
55 56
56 57 struct fct_local_port *rp_port;
57 58 char rp_nwwn_str[FC_WWN_BUFLEN];
58 59 char rp_pwwn_str[FC_WWN_BUFLEN];
59 60 uint8_t rp_nwwn[FC_WWN_LEN];
60 61 uint8_t rp_pwwn[FC_WWN_LEN];
61 62 uint32_t rp_id; /* 8 or 24 bit */
62 63 uint32_t rp_hard_address;
63 64 uint16_t rp_handle;
64 65 } fct_remote_port_t;
65 66
66 67 #define FCT_HANDLE_NONE 0xffff
67 68
68 69 typedef struct fct_cmd {
69 70 void *cmd_fct_private;
70 71 void *cmd_fca_private;
71 72 void *cmd_specific;
72 73
73 74 struct fct_local_port *cmd_port;
74 75
75 76 /* During cmd porting this can be set to NULL */
76 77 struct fct_remote_port *cmd_rp;
77 78
78 79 /* To link cmds together for handling things like ABTS. */
79 80 struct fct_cmd *cmd_link;
80 81 uint8_t cmd_type;
81 82 uint8_t cmd_rsvd1;
82 83
83 84 /* During cmd posting this can be set to FCT_HANDLE_NONE */
84 85 uint16_t cmd_rp_handle;
85 86 uint32_t cmd_handle;
86 87 uint32_t cmd_rportid;
87 88 uint32_t cmd_lportid;
88 89 uint32_t cmd_rsvd2;
89 90 uint16_t cmd_oxid;
90 91 uint16_t cmd_rxid;
91 92 fct_status_t cmd_comp_status;
92 93 } fct_cmd_t;
93 94
94 95 /*
95 96 * fcmd_cmd_handle: Bit definitions.
96 97 * 31 23 15 7 0
97 98 * +--------------+------------+------------+------------+
98 99 * | V |uniq_cntr |fca specific| cmd slot index |
99 100 * +--------------+------------+------------+------------+
100 101 * V = handle valid.
101 102 */
102 103 #define CMD_HANDLE_SLOT_INDEX(x) ((x) & 0xffff)
103 104 #define CMD_HANDLE_VALID(x) ((x) & 0x80000000)
104 105
105 106 enum fct_cmd_types {
106 107 FCT_CMD_FCP_XCHG = 0x0001,
107 108 FCT_CMD_RCVD_ELS = 0x0002,
108 109 FCT_CMD_SOL_ELS = 0x0004,
109 110 FCT_CMD_RCVD_ABTS = 0x0008,
110 111 FCT_CMD_SOL_CT = 0x0010,
111 112
112 113 FCT_CMD_TYPE_ALL = 0xffff
113 114 };
114 115
115 116 typedef struct fct_els {
116 117 uint16_t els_req_size;
117 118 uint16_t els_resp_size;
118 119 uint16_t els_req_alloc_size;
119 120 uint16_t els_resp_alloc_size;
120 121 uint8_t *els_req_payload;
121 122 uint8_t *els_resp_payload;
122 123 } fct_els_t;
123 124
124 125 typedef struct fct_sol_ct {
125 126 uint16_t ct_req_size;
126 127 uint16_t ct_resp_size;
127 128 uint16_t ct_req_alloc_size;
128 129 uint16_t ct_resp_alloc_size;
129 130 uint8_t *ct_req_payload;
130 131 uint8_t *ct_resp_payload;
131 132 } fct_sol_ct_t;
132 133
133 134 typedef struct fct_rcvd_abts {
134 135 uint8_t abts_resp_rctl; /* Can be BA_ACC or BA_RJT */
135 136 uint8_t abts_state;
136 137 uint16_t rsvd;
137 138 uint8_t abts_resp_payload[12];
138 139 } fct_rcvd_abts_t;
139 140
140 141 /*
141 142 * abts state
142 143 */
143 144 #define ABTS_STATE_RECEIVED 0
144 145 #define ABTS_STATE_RESPONDED 1
145 146 #define ABTS_STATE_COMPLETED 2
146 147 #define ABTS_STATE_ABORT_REQUESTED 3
147 148 #define ABTS_STATE_ABORT_COMPLETED 4
148 149
149 150 #define FCHBA_MANUFACTURER_LEN 64
150 151 #define FCHBA_SERIAL_NUMBER_LEN 64
151 152 #define FCHBA_MODEL_LEN 256
152 153 #define FCHBA_MODEL_DESCRIPTION_LEN 256
153 154 #define FCHBA_HARDWARE_VERSION_LEN 256
154 155 #define FCHBA_DRIVER_VERSION_LEN 256
155 156 #define FCHBA_OPTION_ROM_VERSION_LEN 256
156 157 #define FCHBA_FIRMWARE_VERSION_LEN 256
157 158 #define FCHBA_DRIVER_NAME_LEN 256
158 159 #define FCHBA_SYMB_NAME_LEN 255
159 160
160 161 #define FCT_INFO_LEN 160
161 162 #define FCT_TASKQ_NAME_LEN 24
162 163
163 164 #define FC_TGT_PORT_INFO_CMD (((uint32_t)'I') << 24)
164 165 #define FC_TGT_PORT_RLS FC_TGT_PORT_INFO_CMD + 0x1
165 166
166 167 typedef struct fct_port_attrs {
167 168 char manufacturer[FCHBA_MANUFACTURER_LEN];
168 169 char serial_number[FCHBA_SERIAL_NUMBER_LEN];
169 170 char model[FCHBA_MODEL_LEN];
170 171 char model_description[FCHBA_MODEL_DESCRIPTION_LEN];
171 172 char hardware_version[FCHBA_HARDWARE_VERSION_LEN];
172 173 char driver_version[FCHBA_DRIVER_VERSION_LEN];
173 174 char option_rom_version[FCHBA_OPTION_ROM_VERSION_LEN];
174 175 char firmware_version[FCHBA_FIRMWARE_VERSION_LEN];
175 176 char driver_name[FCHBA_DRIVER_NAME_LEN];
176 177 uint32_t vendor_specific_id;
177 178 uint32_t supported_cos;
178 179 uint32_t supported_speed;
179 180 uint32_t max_frame_size;
180 181 } fct_port_attrs_t;
181 182
182 183 typedef struct fct_port_link_status {
183 184 uint32_t LinkFailureCount;
184 185 uint32_t LossOfSyncCount;
185 186 uint32_t LossOfSignalsCount;
186 187 uint32_t PrimitiveSeqProtocolErrorCount;
187 188 uint32_t InvalidTransmissionWordCount;
188 189 uint32_t InvalidCRCCount;
189 190 } fct_port_link_status_t;
190 191
191 192 typedef struct fct_dbuf_store {
192 193 void *fds_fct_private;
193 194 void *fds_fca_private;
194 195 struct stmf_dbuf_store *fds_ds;
195 196
196 197 stmf_data_buf_t *(*fds_alloc_data_buf)(struct fct_local_port *port,
197 198 uint32_t size, uint32_t *pminsize, uint32_t flags);
198 199 void (*fds_free_data_buf)(struct fct_dbuf_store *fds,
199 200 stmf_data_buf_t *dbuf);
200 201 stmf_status_t (*fds_setup_dbuf)(struct fct_local_port *port,
201 202 stmf_data_buf_t *dbuf, uint32_t flags);
202 203 void (*fds_teardown_dbuf)(struct fct_dbuf_store *fds,
203 204 stmf_data_buf_t *dbuf);
204 205
205 206 uint32_t fds_max_sgl_xfer_len;
206 207 uint32_t fds_copy_threshold;
207 208 } fct_dbuf_store_t;
208 209
209 210 #define FCT_FCA_MODREV_1 1
210 211
211 212 typedef struct fct_local_port {
212 213 void *port_fct_private;
213 214 void *port_fca_private;
214 215 stmf_local_port_t *port_lport;
215 216
216 217 char port_nwwn_str[FC_WWN_BUFLEN];
217 218 char port_pwwn_str[FC_WWN_BUFLEN];
218 219 uint8_t port_nwwn[FC_WWN_LEN];
219 220 uint8_t port_pwwn[FC_WWN_LEN];
220 221 char *port_default_alias;
221 222 char *port_sym_node_name;
222 223 char *port_sym_port_name;
223 224
224 225 stmf_port_provider_t *port_pp;
225 226
226 227 uint32_t port_hard_address;
227 228 uint16_t port_max_logins;
228 229 uint16_t port_max_xchges;
229 230 uint32_t port_fca_fcp_cmd_size;
230 231 uint32_t port_fca_rp_private_size;
231 232 uint32_t port_fca_sol_els_private_size;
232 233 uint32_t port_fca_sol_ct_private_size;
233 234
234 235 /* in milliseconds */
235 236 uint32_t port_fca_abort_timeout;
236 237
237 238 fct_dbuf_store_t *port_fds;
238 239 fct_status_t (*port_get_link_info)(
239 240 struct fct_local_port *port, struct fct_link_info *li);
240 241 fct_status_t (*port_register_remote_port)(
241 242 struct fct_local_port *port, struct fct_remote_port *rp,
242 243 struct fct_cmd *login_els);
243 244 fct_status_t (*port_deregister_remote_port)(
244 245 struct fct_local_port *port, struct fct_remote_port *rp);
245 246 fct_status_t (*port_send_cmd)(fct_cmd_t *cmd);
246 247 fct_status_t (*port_xfer_scsi_data)(fct_cmd_t *cmd,
247 248 stmf_data_buf_t *dbuf, uint32_t flags);
248 249 fct_status_t (*port_send_cmd_response)(fct_cmd_t *cmd,
249 250 uint32_t ioflags);
250 251 fct_status_t (*port_abort_cmd)(struct fct_local_port *port,
251 252 fct_cmd_t *cmd, uint32_t flags);
252 253 void (*port_ctl)(struct fct_local_port *port,
253 254 int cmd, void *arg);
254 255 fct_status_t (*port_flogi_xchg)(struct fct_local_port *port,
255 256 struct fct_flogi_xchg *fx);
256 257 void (*port_populate_hba_details)(
257 258 struct fct_local_port *port, struct fct_port_attrs *port_attrs);
258 259 fct_status_t (*port_info)(uint32_t cmd,
259 260 struct fct_local_port *port, void *arg, uint8_t *buf,
260 261 uint32_t *bufsizep);
261 262 int port_fca_version;
262 263 } fct_local_port_t;
263 264
264 265 /*
265 266 * Common struct used during FLOGI exchange.
266 267 */
267 268 typedef struct fct_flogi_xchg {
268 269 uint8_t fx_op; /* ELS_OP_FLOGI or ELS_OP_ACC/RJT */
269 270 uint8_t fx_rjt_reason;
270 271 uint8_t fx_rjt_expl;
271 272 uint8_t fx_sec_timeout; /* Timeout in seconds */
272 273 uint32_t fx_fport:1, /* 0=N_port, 1=F_port */
273 274 rsvd2:31;
274 275 uint32_t fx_sid; /* 24 bit SID to use */
275 276 uint32_t fx_did; /* 24 bit DID to use */
276 277 uint8_t fx_pwwn[8];
277 278 uint8_t fx_nwwn[8];
278 279 } fct_flogi_xchg_t;
279 280
280 281 typedef struct fct_link_info {
281 282 uint32_t portid;
282 283 uint8_t port_topology;
283 284 uint8_t port_speed;
284 285
285 286 uint8_t rsvd:5,
286 287
287 288 /*
288 289 * FCA sets this bit to indicate that fct does not need to do FLOGI
289 290 * because either FCA did the FLOGI or it determined that its a private
290 291 * loop. Setting this bit by FCA is optional.
291 292 */
292 293 port_no_fct_flogi:1,
293 294
294 295 /* FCA sets this bit to indicate that it did FLOGI */
295 296 port_fca_flogi_done:1,
296 297
297 298 /* FCT sets this bit to indicate that it did FLOGI */
298 299 port_fct_flogi_done:1;
299 300
300 301 uint8_t rsvd1;
301 302
302 303 /* The fields below are only valid if someone did a successful flogi */
303 304 uint8_t port_rnwwn[8];
304 305 uint8_t port_rpwwn[8];
305 306 } fct_link_info_t;
306 307
307 308 typedef struct fct_port_stat {
308 309 kstat_named_t link_failure_cnt;
309 310 kstat_named_t loss_of_sync_cnt;
310 311 kstat_named_t loss_of_signals_cnt;
311 312 kstat_named_t prim_seq_protocol_err_cnt;
312 313 kstat_named_t invalid_tx_word_cnt;
313 314 kstat_named_t invalid_crc_cnt;
314 315 } fct_port_stat_t;
315 316
316 317 /*
317 318 * port topology
318 319 */
319 320 #define PORT_TOPOLOGY_UNKNOWN 0
320 321 #define PORT_TOPOLOGY_PT_TO_PT 1
321 322 #define PORT_TOPOLOGY_PRIVATE_LOOP 2
322 323 #define PORT_TOPOLOGY_PUBLIC_LOOP 6
323 324 #define PORT_TOPOLOGY_FABRIC_PT_TO_PT 5
324 325 #define PORT_TOPOLOGY_FABRIC_BIT 4
325 326
326 327 #define PORT_FLOGI_DONE(li) (((li)->port_fca_flogi_done) || \
327 328 ((li)->port_fct_flogi_done))
328 329
329 330 /*
330 331 * port speed
331 332 */
332 333 #define PORT_SPEED_UNKNOWN 0
333 334 #define PORT_SPEED_1G 1
334 335 #define PORT_SPEED_2G 2
335 336 #define PORT_SPEED_4G 4
336 337 #define PORT_SPEED_8G 8
337 338 #define PORT_SPEED_10G 16
338 339
339 340 /*
340 341 * Abort commands
341 342 */
342 343 #define FCT_TERMINATE_CMD 1
343 344
344 345 /*
345 346 * FCT port states.
346 347 */
347 348 #define FCT_STATE_OFFLINE 0
348 349 #define FCT_STATE_ONLINING 1
349 350 #define FCT_STATE_ONLINE 2
350 351 #define FCT_STATE_OFFLINING 3
351 352
352 353 /*
353 354 * fct ctl commands. These should not conflict with stmf ctl commands
354 355 */
355 356 #define FCT_CMD_PORT_ONLINE (STMF_LPORT_CTL_CMDS | 0x01)
356 357 #define FCT_CMD_PORT_ONLINE_COMPLETE (STMF_LPORT_CTL_CMDS | 0x02)
357 358 #define FCT_CMD_PORT_OFFLINE (STMF_LPORT_CTL_CMDS | 0x03)
358 359 #define FCT_CMD_PORT_OFFLINE_COMPLETE (STMF_LPORT_CTL_CMDS | 0x04)
359 360 #define FCT_ACK_PORT_ONLINE_COMPLETE (STMF_LPORT_CTL_CMDS | 0x05)
|
↓ open down ↓ |
327 lines elided |
↑ open up ↑ |
360 361 #define FCT_ACK_PORT_OFFLINE_COMPLETE (STMF_LPORT_CTL_CMDS | 0x06)
361 362 #define FCT_CMD_FORCE_LIP (STMF_LPORT_CTL_CMDS | 0x07)
362 363
363 364 /*
364 365 * IO flags for cmd flow.
365 366 */
366 367 #define FCT_IOF_FCA_DONE 0x10000
367 368 #define FCT_IOF_FORCE_FCA_DONE 0x20000
368 369
369 370 /*
370 - * Fill CTIU preample
371 + * Fill CTIU preamble
371 372 */
372 373 #ifdef lint
373 -#define FCT_FILL_CTIU_PREAMPLE(x_payload, x_ctop) _NOTE(EMPTY)
374 +#define FCT_FILL_CTIU_PREAMBLE(x_payload, x_ctop) _NOTE(EMPTY)
374 375 #else
375 -#define FCT_FILL_CTIU_PREAMPLE(x_payload, x_ctop) \
376 +#define FCT_FILL_CTIU_PREAMBLE(x_payload, x_ctop) \
376 377 do { \
377 - x_payload[0] = 0x02; \
378 + x_payload[0] = 0x01; \
378 379 x_payload[4] = 0xFC; \
379 380 x_payload[5] = 0x02; \
380 381 x_payload[8] = 0xFF & (x_ctop >> 8); \
381 382 x_payload[9] = 0xFF & (x_ctop); \
382 383 } while (0)
383 384 #endif
384 385
385 386 uint64_t fct_netbuf_to_value(uint8_t *buf, uint8_t nbytes);
386 387 void fct_value_to_netbuf(uint64_t value, uint8_t *buf, uint8_t nbytes);
387 388 void *fct_alloc(fct_struct_id_t struct_id, int additional_size, int flags);
388 389 void fct_free(void *ptr);
389 390 fct_cmd_t *fct_scsi_task_alloc(struct fct_local_port *port,
390 391 uint16_t rp_handle, uint32_t rportid, uint8_t *lun,
391 392 uint16_t cdb_length, uint16_t task_ext);
392 393 fct_status_t fct_register_local_port(fct_local_port_t *port);
393 394 fct_status_t fct_deregister_local_port(fct_local_port_t *port);
394 395 void fct_handle_event(fct_local_port_t *port, int event_id,
395 396 uint32_t event_flags, caddr_t arg);
396 397 void fct_post_rcvd_cmd(fct_cmd_t *cmd, stmf_data_buf_t *dbuf);
397 398 void fct_queue_cmd_for_termination(fct_cmd_t *cmd, fct_status_t s);
398 399 void fct_queue_scsi_task_for_termination(fct_cmd_t *cmd, fct_status_t s);
399 400 fct_cmd_t *fct_handle_to_cmd(fct_local_port_t *port, uint32_t fct_handle);
400 401 void fct_ctl(struct stmf_local_port *lport, int cmd, void *arg);
401 402 void fct_cmd_fca_aborted(fct_cmd_t *cmd, fct_status_t s, uint32_t ioflags);
402 403 uint16_t fct_get_rp_handle(fct_local_port_t *port, uint32_t rportid);
403 404 void fct_send_response_done(fct_cmd_t *cmd, fct_status_t s, uint32_t ioflags);
404 405 void fct_send_cmd_done(fct_cmd_t *cmd, fct_status_t s, uint32_t ioflags);
405 406 void fct_scsi_data_xfer_done(fct_cmd_t *cmd, stmf_data_buf_t *dbuf,
406 407 uint32_t ioflags);
407 408 fct_status_t fct_port_initialize(fct_local_port_t *port, uint32_t rflags,
408 409 char *additional_info);
409 410 fct_status_t fct_port_shutdown(fct_local_port_t *port, uint32_t rflags,
410 411 char *additional_info);
411 412 fct_status_t fct_handle_rcvd_flogi(fct_local_port_t *port,
412 413 fct_flogi_xchg_t *fx);
413 414 void fct_log_local_port_event(fct_local_port_t *port, char *subclass);
414 415 void fct_log_remote_port_event(fct_local_port_t *port, char *subclass,
415 416 uint8_t *rp_pwwn, uint32_t rp_id);
416 417 void fct_wwn_to_str(char *to_ptr, const uint8_t *from_ptr);
417 418
418 419 #ifdef __cplusplus
419 420 }
420 421 #endif
421 422
422 423 #endif /* _FCT_H */
|
↓ open down ↓ |
35 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX