emlxs_sli4.c (1a5e258f) emlxs_sli4.c (8f23e9fa)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
8 * You can obtain a copy of the license at
9 * http://www.opensource.org/licenses/cddl1.txt.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2010 Emulex. All rights reserved.
23 * Copyright (c) 2004-2012 Emulex. All rights reserved.
24 * Use is subject to license terms.
25 */
26
24 * Use is subject to license terms.
25 */
26
27
28#include <emlxs.h>
29
27#include <emlxs.h>
28
29
30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
31EMLXS_MSG_DEF(EMLXS_SLI4_C);
32
30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
31EMLXS_MSG_DEF(EMLXS_SLI4_C);
32
33static int emlxs_sli4_init_extents(emlxs_hba_t *hba,
34 MAILBOXQ *mbq);
35static uint32_t emlxs_sli4_read_status(emlxs_hba_t *hba);
36
37static int emlxs_init_bootstrap_mb(emlxs_hba_t *hba);
38
39static uint32_t emlxs_sli4_read_sema(emlxs_hba_t *hba);
40
41static uint32_t emlxs_sli4_read_mbdb(emlxs_hba_t *hba);
42
43static void emlxs_sli4_write_mbdb(emlxs_hba_t *hba, uint32_t value);
44
45static void emlxs_sli4_write_wqdb(emlxs_hba_t *hba, uint32_t value);
46
47static void emlxs_sli4_write_mqdb(emlxs_hba_t *hba, uint32_t value);
48
49static void emlxs_sli4_write_rqdb(emlxs_hba_t *hba, uint32_t value);
50
51static void emlxs_sli4_write_cqdb(emlxs_hba_t *hba, uint32_t value);
52
33static int emlxs_sli4_create_queues(emlxs_hba_t *hba,
34 MAILBOXQ *mbq);
35static int emlxs_sli4_post_hdr_tmplates(emlxs_hba_t *hba,
36 MAILBOXQ *mbq);
37static int emlxs_sli4_post_sgl_pages(emlxs_hba_t *hba,
38 MAILBOXQ *mbq);
39
40static int emlxs_sli4_read_eq(emlxs_hba_t *hba, EQ_DESC_t *eq);
41
53static int emlxs_sli4_create_queues(emlxs_hba_t *hba,
54 MAILBOXQ *mbq);
55static int emlxs_sli4_post_hdr_tmplates(emlxs_hba_t *hba,
56 MAILBOXQ *mbq);
57static int emlxs_sli4_post_sgl_pages(emlxs_hba_t *hba,
58 MAILBOXQ *mbq);
59
60static int emlxs_sli4_read_eq(emlxs_hba_t *hba, EQ_DESC_t *eq);
61
42extern void emlxs_parse_prog_types(emlxs_hba_t *hba, char *types);
43
44extern int32_t emlxs_parse_vpd(emlxs_hba_t *hba, uint8_t *vpd,
45 uint32_t size);
46extern void emlxs_decode_label(char *label, char *buffer, int bige);
47
48extern void emlxs_build_prog_types(emlxs_hba_t *hba,
49 char *prog_types);
50
51extern int emlxs_pci_model_count;
52
53extern emlxs_model_t emlxs_pci_model[];
54
55static int emlxs_sli4_map_hdw(emlxs_hba_t *hba);
56
57static void emlxs_sli4_unmap_hdw(emlxs_hba_t *hba);
58
59static int32_t emlxs_sli4_online(emlxs_hba_t *hba);
60
62static int emlxs_sli4_map_hdw(emlxs_hba_t *hba);
63
64static void emlxs_sli4_unmap_hdw(emlxs_hba_t *hba);
65
66static int32_t emlxs_sli4_online(emlxs_hba_t *hba);
67
61static void emlxs_sli4_offline(emlxs_hba_t *hba);
68static void emlxs_sli4_offline(emlxs_hba_t *hba,
69 uint32_t reset_requested);
62
63static uint32_t emlxs_sli4_hba_reset(emlxs_hba_t *hba, uint32_t restart,
64 uint32_t skip_post, uint32_t quiesce);
65static void emlxs_sli4_hba_kill(emlxs_hba_t *hba);
66
67static uint32_t emlxs_sli4_hba_init(emlxs_hba_t *hba);
68
69static uint32_t emlxs_sli4_bde_setup(emlxs_port_t *port,
70 emlxs_buf_t *sbp);
71
70
71static uint32_t emlxs_sli4_hba_reset(emlxs_hba_t *hba, uint32_t restart,
72 uint32_t skip_post, uint32_t quiesce);
73static void emlxs_sli4_hba_kill(emlxs_hba_t *hba);
74
75static uint32_t emlxs_sli4_hba_init(emlxs_hba_t *hba);
76
77static uint32_t emlxs_sli4_bde_setup(emlxs_port_t *port,
78 emlxs_buf_t *sbp);
79
72
73static void emlxs_sli4_issue_iocb_cmd(emlxs_hba_t *hba,
74 CHANNEL *cp, IOCBQ *iocb_cmd);
75static uint32_t emlxs_sli4_issue_mbox_cmd(emlxs_hba_t *hba,
76 MAILBOXQ *mbq, int32_t flg, uint32_t tmo);
77static uint32_t emlxs_sli4_issue_mbox_cmd4quiesce(emlxs_hba_t *hba,
78 MAILBOXQ *mbq, int32_t flg, uint32_t tmo);
79#ifdef SFCT_SUPPORT
80static uint32_t emlxs_sli4_prep_fct_iocb(emlxs_port_t *port,
81 emlxs_buf_t *cmd_sbp, int channel);
80static void emlxs_sli4_issue_iocb_cmd(emlxs_hba_t *hba,
81 CHANNEL *cp, IOCBQ *iocb_cmd);
82static uint32_t emlxs_sli4_issue_mbox_cmd(emlxs_hba_t *hba,
83 MAILBOXQ *mbq, int32_t flg, uint32_t tmo);
84static uint32_t emlxs_sli4_issue_mbox_cmd4quiesce(emlxs_hba_t *hba,
85 MAILBOXQ *mbq, int32_t flg, uint32_t tmo);
86#ifdef SFCT_SUPPORT
87static uint32_t emlxs_sli4_prep_fct_iocb(emlxs_port_t *port,
88 emlxs_buf_t *cmd_sbp, int channel);
89static uint32_t emlxs_sli4_fct_bde_setup(emlxs_port_t *port,
90 emlxs_buf_t *sbp);
82#endif /* SFCT_SUPPORT */
83
84static uint32_t emlxs_sli4_prep_fcp_iocb(emlxs_port_t *port,
85 emlxs_buf_t *sbp, int ring);
86static uint32_t emlxs_sli4_prep_ip_iocb(emlxs_port_t *port,
87 emlxs_buf_t *sbp);
88static uint32_t emlxs_sli4_prep_els_iocb(emlxs_port_t *port,
89 emlxs_buf_t *sbp);
90static uint32_t emlxs_sli4_prep_ct_iocb(emlxs_port_t *port,
91 emlxs_buf_t *sbp);
91#endif /* SFCT_SUPPORT */
92
93static uint32_t emlxs_sli4_prep_fcp_iocb(emlxs_port_t *port,
94 emlxs_buf_t *sbp, int ring);
95static uint32_t emlxs_sli4_prep_ip_iocb(emlxs_port_t *port,
96 emlxs_buf_t *sbp);
97static uint32_t emlxs_sli4_prep_els_iocb(emlxs_port_t *port,
98 emlxs_buf_t *sbp);
99static uint32_t emlxs_sli4_prep_ct_iocb(emlxs_port_t *port,
100 emlxs_buf_t *sbp);
92static void emlxs_sli4_poll_intr(emlxs_hba_t *hba,
93 uint32_t att_bit);
101static void emlxs_sli4_poll_intr(emlxs_hba_t *hba);
94static int32_t emlxs_sli4_intx_intr(char *arg);
95
96#ifdef MSI_SUPPORT
97static uint32_t emlxs_sli4_msi_intr(char *arg1, char *arg2);
98#endif /* MSI_SUPPORT */
99
100static void emlxs_sli4_resource_free(emlxs_hba_t *hba);
101
102static int emlxs_sli4_resource_alloc(emlxs_hba_t *hba);
102static int32_t emlxs_sli4_intx_intr(char *arg);
103
104#ifdef MSI_SUPPORT
105static uint32_t emlxs_sli4_msi_intr(char *arg1, char *arg2);
106#endif /* MSI_SUPPORT */
107
108static void emlxs_sli4_resource_free(emlxs_hba_t *hba);
109
110static int emlxs_sli4_resource_alloc(emlxs_hba_t *hba);
111extern void emlxs_sli4_zero_queue_stat(emlxs_hba_t *hba);
103
112
104static XRIobj_t *emlxs_sli4_alloc_xri(emlxs_hba_t *hba,
105 emlxs_buf_t *sbp, RPIobj_t *rpip);
113static XRIobj_t *emlxs_sli4_alloc_xri(emlxs_port_t *port,
114 emlxs_buf_t *sbp, RPIobj_t *rpip,
115 uint32_t type);
106static void emlxs_sli4_enable_intr(emlxs_hba_t *hba);
107
108static void emlxs_sli4_disable_intr(emlxs_hba_t *hba, uint32_t att);
109
116static void emlxs_sli4_enable_intr(emlxs_hba_t *hba);
117
118static void emlxs_sli4_disable_intr(emlxs_hba_t *hba, uint32_t att);
119
110extern void emlxs_sli4_timer(emlxs_hba_t *hba);
120static void emlxs_sli4_timer(emlxs_hba_t *hba);
111
112static void emlxs_sli4_timer_check_mbox(emlxs_hba_t *hba);
113
114static void emlxs_sli4_poll_erratt(emlxs_hba_t *hba);
115
121
122static void emlxs_sli4_timer_check_mbox(emlxs_hba_t *hba);
123
124static void emlxs_sli4_poll_erratt(emlxs_hba_t *hba);
125
116static XRIobj_t *emlxs_sli4_register_xri(emlxs_hba_t *hba,
117 emlxs_buf_t *sbp, uint16_t xri);
118
119static XRIobj_t *emlxs_sli4_reserve_xri(emlxs_hba_t *hba,
120 RPIobj_t *rpip);
126extern XRIobj_t *emlxs_sli4_reserve_xri(emlxs_port_t *port,
127 RPIobj_t *rpip, uint32_t type, uint16_t rx_id);
121static int emlxs_check_hdw_ready(emlxs_hba_t *);
122
128static int emlxs_check_hdw_ready(emlxs_hba_t *);
129
130static uint32_t emlxs_sli4_reg_did(emlxs_port_t *port,
131 uint32_t did, SERV_PARM *param,
132 emlxs_buf_t *sbp, fc_unsol_buf_t *ubp,
133 IOCBQ *iocbq);
123
134
135static uint32_t emlxs_sli4_unreg_node(emlxs_port_t *port,
136 emlxs_node_t *node, emlxs_buf_t *sbp,
137 fc_unsol_buf_t *ubp, IOCBQ *iocbq);
138
139static void emlxs_sli4_handle_fc_link_att(emlxs_hba_t *hba,
140 CQE_ASYNC_t *cqe);
141static void emlxs_sli4_handle_fcoe_link_event(emlxs_hba_t *hba,
142 CQE_ASYNC_t *cqe);
143
144
145static uint16_t emlxs_sli4_rqid_to_index(emlxs_hba_t *hba,
146 uint16_t rqid);
147static uint16_t emlxs_sli4_wqid_to_index(emlxs_hba_t *hba,
148 uint16_t wqid);
149static uint16_t emlxs_sli4_cqid_to_index(emlxs_hba_t *hba,
150 uint16_t cqid);
151
124/* Define SLI4 API functions */
125emlxs_sli_api_t emlxs_sli4_api = {
126 emlxs_sli4_map_hdw,
127 emlxs_sli4_unmap_hdw,
128 emlxs_sli4_online,
129 emlxs_sli4_offline,
130 emlxs_sli4_hba_reset,
131 emlxs_sli4_hba_kill,

--- 8 unchanged lines hidden (view full) ---

140 emlxs_sli4_prep_ip_iocb,
141 emlxs_sli4_prep_els_iocb,
142 emlxs_sli4_prep_ct_iocb,
143 emlxs_sli4_poll_intr,
144 emlxs_sli4_intx_intr,
145 emlxs_sli4_msi_intr,
146 emlxs_sli4_disable_intr,
147 emlxs_sli4_timer,
152/* Define SLI4 API functions */
153emlxs_sli_api_t emlxs_sli4_api = {
154 emlxs_sli4_map_hdw,
155 emlxs_sli4_unmap_hdw,
156 emlxs_sli4_online,
157 emlxs_sli4_offline,
158 emlxs_sli4_hba_reset,
159 emlxs_sli4_hba_kill,

--- 8 unchanged lines hidden (view full) ---

168 emlxs_sli4_prep_ip_iocb,
169 emlxs_sli4_prep_els_iocb,
170 emlxs_sli4_prep_ct_iocb,
171 emlxs_sli4_poll_intr,
172 emlxs_sli4_intx_intr,
173 emlxs_sli4_msi_intr,
174 emlxs_sli4_disable_intr,
175 emlxs_sli4_timer,
148 emlxs_sli4_poll_erratt
176 emlxs_sli4_poll_erratt,
177 emlxs_sli4_reg_did,
178 emlxs_sli4_unreg_node
149};
150
151
152/* ************************************************************************** */
153
179};
180
181
182/* ************************************************************************** */
183
184static void
185emlxs_sli4_set_default_params(emlxs_hba_t *hba)
186{
187 emlxs_port_t *port = &PPORT;
154
188
189 bzero((char *)&hba->sli.sli4.param, sizeof (sli_params_t));
190
191 hba->sli.sli4.param.ProtocolType = 0x3; /* FC/FCoE */
192
193 hba->sli.sli4.param.SliHint2 = 0;
194 hba->sli.sli4.param.SliHint1 = 0;
195 hba->sli.sli4.param.IfType = 0;
196 hba->sli.sli4.param.SliFamily = 0;
197 hba->sli.sli4.param.Revision = 0x4; /* SLI4 */
198 hba->sli.sli4.param.FT = 0;
199
200 hba->sli.sli4.param.EqeCntMethod = 0x1; /* Bit pattern */
201 hba->sli.sli4.param.EqPageSize = 0x1; /* 4096 */
202 hba->sli.sli4.param.EqeSize = 0x1; /* 4 byte */
203 hba->sli.sli4.param.EqPageCnt = 8;
204 hba->sli.sli4.param.EqeCntMask = 0x1F; /* 256-4096 elements */
205
206 hba->sli.sli4.param.CqeCntMethod = 0x1; /* Bit pattern */
207 hba->sli.sli4.param.CqPageSize = 0x1; /* 4096 */
208 hba->sli.sli4.param.CQV = 0;
209 hba->sli.sli4.param.CqeSize = 0x3; /* 16 byte */
210 hba->sli.sli4.param.CqPageCnt = 4;
211 hba->sli.sli4.param.CqeCntMask = 0x70; /* 256-1024 elements */
212
213 hba->sli.sli4.param.MqeCntMethod = 0x1; /* Bit pattern */
214 hba->sli.sli4.param.MqPageSize = 0x1; /* 4096 */
215 hba->sli.sli4.param.MQV = 0;
216 hba->sli.sli4.param.MqPageCnt = 8;
217 hba->sli.sli4.param.MqeCntMask = 0x0F; /* 16-128 elements */
218
219 hba->sli.sli4.param.WqeCntMethod = 0; /* Page Count */
220 hba->sli.sli4.param.WqPageSize = 0x1; /* 4096 */
221 hba->sli.sli4.param.WQV = 0;
222 hba->sli.sli4.param.WqeSize = 0x5; /* 64 byte */
223 hba->sli.sli4.param.WqPageCnt = 4;
224 hba->sli.sli4.param.WqeCntMask = 0x10; /* 256 elements */
225
226 hba->sli.sli4.param.RqeCntMethod = 0; /* Page Count */
227 hba->sli.sli4.param.RqPageSize = 0x1; /* 4096 */
228 hba->sli.sli4.param.RQV = 0;
229 hba->sli.sli4.param.RqeSize = 0x2; /* 8 byte */
230 hba->sli.sli4.param.RqPageCnt = 8;
231 hba->sli.sli4.param.RqDbWin = 1;
232 hba->sli.sli4.param.RqeCntMask = 0x100; /* 4096 elements */
233
234 hba->sli.sli4.param.Loopback = 0xf; /* unsupported */
235 hba->sli.sli4.param.PHWQ = 0;
236 hba->sli.sli4.param.PHON = 0;
237 hba->sli.sli4.param.TRIR = 0;
238 hba->sli.sli4.param.TRTY = 0;
239 hba->sli.sli4.param.TCCA = 0;
240 hba->sli.sli4.param.MWQE = 0;
241 hba->sli.sli4.param.ASSI = 0;
242 hba->sli.sli4.param.TERP = 0;
243 hba->sli.sli4.param.TGT = 0;
244 hba->sli.sli4.param.AREG = 0;
245 hba->sli.sli4.param.FBRR = 0;
246 hba->sli.sli4.param.SGLR = 1;
247 hba->sli.sli4.param.HDRR = 1;
248 hba->sli.sli4.param.EXT = 0;
249 hba->sli.sli4.param.FCOE = 1;
250
251 hba->sli.sli4.param.SgeLength = (64 * 1024);
252 hba->sli.sli4.param.SglAlign = 0x7 /* 4096 */;
253 hba->sli.sli4.param.SglPageSize = 0x1; /* 4096 */
254 hba->sli.sli4.param.SglPageCnt = 2;
255
256 hba->sli.sli4.param.MinRqSize = 128;
257 hba->sli.sli4.param.MaxRqSize = 2048;
258
259 hba->sli.sli4.param.RPIMax = 0x3ff;
260 hba->sli.sli4.param.XRIMax = 0x3ff;
261 hba->sli.sli4.param.VFIMax = 0xff;
262 hba->sli.sli4.param.VPIMax = 0xff;
263
264 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
265 "Default SLI4 parameters set.");
266
267} /* emlxs_sli4_set_default_params() */
268
269
155/*
156 * emlxs_sli4_online()
157 *
158 * This routine will start initialization of the SLI4 HBA.
159 */
160static int32_t
161emlxs_sli4_online(emlxs_hba_t *hba)
162{

--- 10 unchanged lines hidden (view full) ---

173 uint32_t sli_mode;
174 uint8_t *outptr;
175 uint32_t status;
176 uint32_t fw_check;
177 uint32_t kern_update = 0;
178 emlxs_firmware_t hba_fw;
179 emlxs_firmware_t *fw;
180 uint16_t ssvid;
270/*
271 * emlxs_sli4_online()
272 *
273 * This routine will start initialization of the SLI4 HBA.
274 */
275static int32_t
276emlxs_sli4_online(emlxs_hba_t *hba)
277{

--- 10 unchanged lines hidden (view full) ---

288 uint32_t sli_mode;
289 uint8_t *outptr;
290 uint32_t status;
291 uint32_t fw_check;
292 uint32_t kern_update = 0;
293 emlxs_firmware_t hba_fw;
294 emlxs_firmware_t *fw;
295 uint16_t ssvid;
296 char buf[64];
181
182 cfg = &CFG;
183 vpd = &VPD;
184
185 sli_mode = EMLXS_HBA_SLI4_MODE;
186 hba->sli_mode = sli_mode;
187
188 /* Set the fw_check flag */

--- 5 unchanged lines hidden (view full) ---

194 }
195
196 hba->mbox_queue_flag = 0;
197 hba->fc_edtov = FF_DEF_EDTOV;
198 hba->fc_ratov = FF_DEF_RATOV;
199 hba->fc_altov = FF_DEF_ALTOV;
200 hba->fc_arbtov = FF_DEF_ARBTOV;
201
297
298 cfg = &CFG;
299 vpd = &VPD;
300
301 sli_mode = EMLXS_HBA_SLI4_MODE;
302 hba->sli_mode = sli_mode;
303
304 /* Set the fw_check flag */

--- 5 unchanged lines hidden (view full) ---

310 }
311
312 hba->mbox_queue_flag = 0;
313 hba->fc_edtov = FF_DEF_EDTOV;
314 hba->fc_ratov = FF_DEF_RATOV;
315 hba->fc_altov = FF_DEF_ALTOV;
316 hba->fc_arbtov = FF_DEF_ARBTOV;
317
202 /* Target mode not supported */
203 if (hba->tgt_mode) {
204 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
205 "Target mode not supported in SLI4.");
206
207 return (ENOMEM);
208 }
209
210 /* Networking not supported */
211 if (cfg[CFG_NETWORK_ON].current) {
212 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
318 /* Networking not supported */
319 if (cfg[CFG_NETWORK_ON].current) {
320 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
213 "Networking not supported in SLI4, turning it off");
321 "Networking is not supported in SLI4, turning it off");
214 cfg[CFG_NETWORK_ON].current = 0;
215 }
216
217 hba->chan_count = hba->intr_count * cfg[CFG_NUM_WQ].current;
218 if (hba->chan_count > MAX_CHANNEL) {
219 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
220 "Max channels exceeded, dropping num-wq from %d to 1",
221 cfg[CFG_NUM_WQ].current);

--- 41 unchanged lines hidden (view full) ---

263 "Unable to init hba.");
264
265 rval = EIO;
266 goto failed1;
267 }
268
269#ifdef FMA_SUPPORT
270 /* Access handle validation */
322 cfg[CFG_NETWORK_ON].current = 0;
323 }
324
325 hba->chan_count = hba->intr_count * cfg[CFG_NUM_WQ].current;
326 if (hba->chan_count > MAX_CHANNEL) {
327 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
328 "Max channels exceeded, dropping num-wq from %d to 1",
329 cfg[CFG_NUM_WQ].current);

--- 41 unchanged lines hidden (view full) ---

371 "Unable to init hba.");
372
373 rval = EIO;
374 goto failed1;
375 }
376
377#ifdef FMA_SUPPORT
378 /* Access handle validation */
271 if ((emlxs_fm_check_acc_handle(hba, hba->pci_acc_handle)
272 != DDI_FM_OK) ||
273 (emlxs_fm_check_acc_handle(hba, hba->sli.sli4.bar1_acc_handle)
274 != DDI_FM_OK) ||
275 (emlxs_fm_check_acc_handle(hba, hba->sli.sli4.bar2_acc_handle)
276 != DDI_FM_OK)) {
277 EMLXS_MSGF(EMLXS_CONTEXT,
278 &emlxs_invalid_access_handle_msg, NULL);
379 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
380 case SLI_INTF_IF_TYPE_2:
381 if ((emlxs_fm_check_acc_handle(hba,
382 hba->pci_acc_handle) != DDI_FM_OK) ||
383 (emlxs_fm_check_acc_handle(hba,
384 hba->sli.sli4.bar0_acc_handle) != DDI_FM_OK)) {
385 EMLXS_MSGF(EMLXS_CONTEXT,
386 &emlxs_invalid_access_handle_msg, NULL);
279
387
280 rval = EIO;
281 goto failed1;
388 rval = EIO;
389 goto failed1;
390 }
391 break;
392
393 default :
394 if ((emlxs_fm_check_acc_handle(hba,
395 hba->pci_acc_handle) != DDI_FM_OK) ||
396 (emlxs_fm_check_acc_handle(hba,
397 hba->sli.sli4.bar1_acc_handle) != DDI_FM_OK) ||
398 (emlxs_fm_check_acc_handle(hba,
399 hba->sli.sli4.bar2_acc_handle) != DDI_FM_OK)) {
400 EMLXS_MSGF(EMLXS_CONTEXT,
401 &emlxs_invalid_access_handle_msg, NULL);
402
403 rval = EIO;
404 goto failed1;
405 }
406 break;
282 }
283#endif /* FMA_SUPPORT */
284
285 /*
286 * Setup and issue mailbox READ REV command
287 */
288 vpd->opFwRev = 0;
289 vpd->postKernRev = 0;

--- 12 unchanged lines hidden (view full) ---

302 vpd->opFwLabel[0] = 0;
303 vpd->sli1FwLabel[0] = 0;
304 vpd->sli2FwLabel[0] = 0;
305 vpd->sli3FwLabel[0] = 0;
306 vpd->sli4FwLabel[0] = 0;
307
308 EMLXS_STATE_CHANGE(hba, FC_INIT_REV);
309
407 }
408#endif /* FMA_SUPPORT */
409
410 /*
411 * Setup and issue mailbox READ REV command
412 */
413 vpd->opFwRev = 0;
414 vpd->postKernRev = 0;

--- 12 unchanged lines hidden (view full) ---

427 vpd->opFwLabel[0] = 0;
428 vpd->sli1FwLabel[0] = 0;
429 vpd->sli2FwLabel[0] = 0;
430 vpd->sli3FwLabel[0] = 0;
431 vpd->sli4FwLabel[0] = 0;
432
433 EMLXS_STATE_CHANGE(hba, FC_INIT_REV);
434
435 emlxs_mb_get_sli4_params(hba, mbq);
436 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
437 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
438 "Unable to read parameters. Mailbox cmd=%x status=%x",
439 mb->mbxCommand, mb->mbxStatus);
440
441 /* Set param defaults */
442 emlxs_sli4_set_default_params(hba);
443
444 } else {
445 /* Save parameters */
446 bcopy((char *)&mb->un.varSLIConfig.payload,
447 (char *)&hba->sli.sli4.param, sizeof (sli_params_t));
448
449 emlxs_data_dump(port, "SLI_PARMS",
450 (uint32_t *)&hba->sli.sli4.param,
451 sizeof (sli_params_t), 0);
452 }
453
454 /* Reuse mbq from previous mbox */
455 bzero(mbq, sizeof (MAILBOXQ));
456
457 emlxs_mb_get_port_name(hba, mbq);
458 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
459 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
460 "Unable to get port names. Mailbox cmd=%x status=%x",
461 mb->mbxCommand, mb->mbxStatus);
462
463 bzero(hba->sli.sli4.port_name,
464 sizeof (hba->sli.sli4.port_name));
465 } else {
466 /* Save port names */
467 bcopy((char *)&mb->un.varSLIConfig.payload,
468 (char *)&hba->sli.sli4.port_name,
469 sizeof (hba->sli.sli4.port_name));
470 }
471
472 /* Reuse mbq from previous mbox */
473 bzero(mbq, sizeof (MAILBOXQ));
474
310 emlxs_mb_read_rev(hba, mbq, 0);
311 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
312 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
313 "Unable to read rev. Mailbox cmd=%x status=%x",
314 mb->mbxCommand, mb->mbxStatus);
315
316 rval = EIO;
317 goto failed1;
318
319 }
320
475 emlxs_mb_read_rev(hba, mbq, 0);
476 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
477 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
478 "Unable to read rev. Mailbox cmd=%x status=%x",
479 mb->mbxCommand, mb->mbxStatus);
480
481 rval = EIO;
482 goto failed1;
483
484 }
485
321emlxs_data_dump(port, "RD_REV", (uint32_t *)mb, 18, 0);
486 emlxs_data_dump(port, "RD_REV", (uint32_t *)mb, 18, 0);
322 if (mb->un.varRdRev4.sliLevel != 4) {
323 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
324 "Invalid read rev Version for SLI4: 0x%x",
325 mb->un.varRdRev4.sliLevel);
326
327 rval = EIO;
328 goto failed1;
329 }

--- 11 unchanged lines hidden (view full) ---

341 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
342 "Invalid read rev dcbx mode for SLI4: 0x%x",
343 mb->un.varRdRev4.dcbxMode);
344
345 rval = EIO;
346 goto failed1;
347 }
348
487 if (mb->un.varRdRev4.sliLevel != 4) {
488 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
489 "Invalid read rev Version for SLI4: 0x%x",
490 mb->un.varRdRev4.sliLevel);
491
492 rval = EIO;
493 goto failed1;
494 }

--- 11 unchanged lines hidden (view full) ---

506 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
507 "Invalid read rev dcbx mode for SLI4: 0x%x",
508 mb->un.varRdRev4.dcbxMode);
509
510 rval = EIO;
511 goto failed1;
512 }
513
514 /* Set FC/FCoE mode */
515 if (mb->un.varRdRev4.FCoE) {
516 hba->sli.sli4.flag |= EMLXS_SLI4_FCOE_MODE;
517 } else {
518 hba->sli.sli4.flag &= ~EMLXS_SLI4_FCOE_MODE;
519 }
349
350 /* Save information as VPD data */
351 vpd->rBit = 1;
352
353 vpd->sli4FwRev = (mb->un.varRdRev4.ULPFwId);
354 bcopy((char *)mb->un.varRdRev4.ULPFwName, vpd->sli4FwName, 16);
355
356 vpd->opFwRev = (mb->un.varRdRev4.ULPFwId);
357 bcopy((char *)mb->un.varRdRev4.ULPFwName, vpd->opFwName, 16);
358
359 vpd->postKernRev = (mb->un.varRdRev4.ARMFwId);
360 bcopy((char *)mb->un.varRdRev4.ARMFwName, vpd->postKernName, 16);
361
520
521 /* Save information as VPD data */
522 vpd->rBit = 1;
523
524 vpd->sli4FwRev = (mb->un.varRdRev4.ULPFwId);
525 bcopy((char *)mb->un.varRdRev4.ULPFwName, vpd->sli4FwName, 16);
526
527 vpd->opFwRev = (mb->un.varRdRev4.ULPFwId);
528 bcopy((char *)mb->un.varRdRev4.ULPFwName, vpd->opFwName, 16);
529
530 vpd->postKernRev = (mb->un.varRdRev4.ARMFwId);
531 bcopy((char *)mb->un.varRdRev4.ARMFwName, vpd->postKernName, 16);
532
533 vpd->biuRev = mb->un.varRdRev4.HwRev1;
362 vpd->fcphHigh = mb->un.varRdRev4.fcphHigh;
363 vpd->fcphLow = mb->un.varRdRev4.fcphLow;
364 vpd->feaLevelHigh = mb->un.varRdRev4.feaLevelHigh;
365 vpd->feaLevelLow = mb->un.varRdRev4.feaLevelLow;
366
367 /* Decode FW labels */
534 vpd->fcphHigh = mb->un.varRdRev4.fcphHigh;
535 vpd->fcphLow = mb->un.varRdRev4.fcphLow;
536 vpd->feaLevelHigh = mb->un.varRdRev4.feaLevelHigh;
537 vpd->feaLevelLow = mb->un.varRdRev4.feaLevelLow;
538
539 /* Decode FW labels */
368 emlxs_decode_label(vpd->sli4FwName, vpd->sli4FwName, 0);
369 emlxs_decode_label(vpd->opFwName, vpd->opFwName, 0);
370 emlxs_decode_label(vpd->postKernName, vpd->postKernName, 0);
540 if (hba->model_info.chip == EMLXS_LANCER_CHIP) {
541 bcopy(vpd->postKernName, vpd->sli4FwName, 16);
542 }
543 emlxs_decode_label(vpd->sli4FwName, vpd->sli4FwName, 0,
544 sizeof (vpd->sli4FwName));
545 emlxs_decode_label(vpd->opFwName, vpd->opFwName, 0,
546 sizeof (vpd->opFwName));
547 emlxs_decode_label(vpd->postKernName, vpd->postKernName, 0,
548 sizeof (vpd->postKernName));
371
372 if (hba->model_info.chip == EMLXS_BE2_CHIP) {
549
550 if (hba->model_info.chip == EMLXS_BE2_CHIP) {
373 (void) strcpy(vpd->sli4FwLabel, "be2.ufi");
551 (void) strlcpy(vpd->sli4FwLabel, "be2.ufi",
552 sizeof (vpd->sli4FwLabel));
374 } else if (hba->model_info.chip == EMLXS_BE3_CHIP) {
553 } else if (hba->model_info.chip == EMLXS_BE3_CHIP) {
375 (void) strcpy(vpd->sli4FwLabel, "be3.ufi");
554 (void) strlcpy(vpd->sli4FwLabel, "be3.ufi",
555 sizeof (vpd->sli4FwLabel));
556 } else if (hba->model_info.chip == EMLXS_LANCER_CHIP) {
557 (void) strlcpy(vpd->sli4FwLabel, "xe201.grp",
558 sizeof (vpd->sli4FwLabel));
376 } else {
559 } else {
377 (void) strcpy(vpd->sli4FwLabel, "sli4.fw");
560 (void) strlcpy(vpd->sli4FwLabel, "sli4.fw",
561 sizeof (vpd->sli4FwLabel));
378 }
379
562 }
563
380 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
564 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
381 "VPD ULP:%08x %s ARM:%08x %s f:%d %d %d %d : dcbx %d",
382 vpd->opFwRev, vpd->opFwName, vpd->postKernRev, vpd->postKernName,
383 vpd->fcphHigh, vpd->fcphLow, vpd->feaLevelHigh, vpd->feaLevelLow,
384 mb->un.varRdRev4.dcbxMode);
385
386 /* No key information is needed for SLI4 products */
387
388 /* Get adapter VPD information */

--- 21 unchanged lines hidden (view full) ---

410
411#ifdef FMA_SUPPORT
412 if (hba->sli.sli4.dump_region.dma_handle) {
413 if (emlxs_fm_check_dma_handle(hba,
414 hba->sli.sli4.dump_region.dma_handle)
415 != DDI_FM_OK) {
416 EMLXS_MSGF(EMLXS_CONTEXT,
417 &emlxs_invalid_dma_handle_msg,
565 "VPD ULP:%08x %s ARM:%08x %s f:%d %d %d %d : dcbx %d",
566 vpd->opFwRev, vpd->opFwName, vpd->postKernRev, vpd->postKernName,
567 vpd->fcphHigh, vpd->fcphLow, vpd->feaLevelHigh, vpd->feaLevelLow,
568 mb->un.varRdRev4.dcbxMode);
569
570 /* No key information is needed for SLI4 products */
571
572 /* Get adapter VPD information */

--- 21 unchanged lines hidden (view full) ---

594
595#ifdef FMA_SUPPORT
596 if (hba->sli.sli4.dump_region.dma_handle) {
597 if (emlxs_fm_check_dma_handle(hba,
598 hba->sli.sli4.dump_region.dma_handle)
599 != DDI_FM_OK) {
600 EMLXS_MSGF(EMLXS_CONTEXT,
601 &emlxs_invalid_dma_handle_msg,
418 "emlxs_sli4_online: hdl=%p",
602 "sli4_online: hdl=%p",
419 hba->sli.sli4.dump_region.
420 dma_handle);
421 rval = EIO;
422 goto failed1;
423 }
424 }
425#endif /* FMA_SUPPORT */
426

--- 45 unchanged lines hidden (view full) ---

472 &hba->model_info,
473 sizeof (emlxs_model_t));
474 break;
475 }
476 }
477 }
478
479 /* HP CNA port indices start at 1 instead of 0 */
603 hba->sli.sli4.dump_region.
604 dma_handle);
605 rval = EIO;
606 goto failed1;
607 }
608 }
609#endif /* FMA_SUPPORT */
610

--- 45 unchanged lines hidden (view full) ---

656 &hba->model_info,
657 sizeof (emlxs_model_t));
658 break;
659 }
660 }
661 }
662
663 /* HP CNA port indices start at 1 instead of 0 */
480 if ((hba->model_info.chip == EMLXS_BE2_CHIP) ||
481 (hba->model_info.chip == EMLXS_BE3_CHIP)) {
482
664 if (hba->model_info.chip & EMLXS_BE_CHIPS) {
483 ssvid = ddi_get16(hba->pci_acc_handle,
484 (uint16_t *)(hba->pci_addr + PCI_SSVID_REGISTER));
485
486 if ((ssvid == PCI_SSVID_HP) && (vpd->port_index > 0)) {
487 vpd->port_index--;
488 }
489 }
490
491 /*
492 * Now lets update hba->model_info with the real
493 * VPD data, if any.
494 */
495
496 /*
497 * Replace the default model description with vpd data
498 */
499 if (vpd->model_desc[0] != 0) {
665 ssvid = ddi_get16(hba->pci_acc_handle,
666 (uint16_t *)(hba->pci_addr + PCI_SSVID_REGISTER));
667
668 if ((ssvid == PCI_SSVID_HP) && (vpd->port_index > 0)) {
669 vpd->port_index--;
670 }
671 }
672
673 /*
674 * Now lets update hba->model_info with the real
675 * VPD data, if any.
676 */
677
678 /*
679 * Replace the default model description with vpd data
680 */
681 if (vpd->model_desc[0] != 0) {
500 (void) strcpy(hba->model_info.model_desc,
501 vpd->model_desc);
682 (void) strncpy(hba->model_info.model_desc,
683 vpd->model_desc,
684 (sizeof (hba->model_info.model_desc)-1));
502 }
503
504 /* Replace the default model with vpd data */
505 if (vpd->model[0] != 0) {
685 }
686
687 /* Replace the default model with vpd data */
688 if (vpd->model[0] != 0) {
506 (void) strcpy(hba->model_info.model, vpd->model);
689 (void) strncpy(hba->model_info.model, vpd->model,
690 (sizeof (hba->model_info.model)-1));
507 }
508
509 /* Replace the default program types with vpd data */
510 if (vpd->prog_types[0] != 0) {
511 emlxs_parse_prog_types(hba, vpd->prog_types);
512 }
513 }
514

--- 7 unchanged lines hidden (view full) ---

522 "Id:%d Device id:0x%x SSDID:0x%x Model:%s",
523 hba->model_info.id, hba->model_info.device_id,
524 hba->model_info.ssdid, hba->model_info.model);
525
526 rval = EIO;
527 goto failed1;
528 }
529
691 }
692
693 /* Replace the default program types with vpd data */
694 if (vpd->prog_types[0] != 0) {
695 emlxs_parse_prog_types(hba, vpd->prog_types);
696 }
697 }
698

--- 7 unchanged lines hidden (view full) ---

706 "Id:%d Device id:0x%x SSDID:0x%x Model:%s",
707 hba->model_info.id, hba->model_info.device_id,
708 hba->model_info.ssdid, hba->model_info.model);
709
710 rval = EIO;
711 goto failed1;
712 }
713
530 (void) strcpy(vpd->boot_version, vpd->sli4FwName);
714 (void) strncpy(vpd->boot_version, vpd->sli4FwName,
715 (sizeof (vpd->boot_version)-1));
531
532 /* Get fcode version property */
533 emlxs_get_fcode_version(hba);
534
535 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
536 "Firmware: kern=%08x stub=%08x sli1=%08x", vpd->postKernRev,
537 vpd->opFwRev, vpd->sli1FwRev);
538

--- 6 unchanged lines hidden (view full) ---

545
546 /*
547 * If firmware checking is enabled and the adapter model indicates
548 * a firmware image, then perform firmware version check
549 */
550 hba->fw_flag = 0;
551 hba->fw_timer = 0;
552
716
717 /* Get fcode version property */
718 emlxs_get_fcode_version(hba);
719
720 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
721 "Firmware: kern=%08x stub=%08x sli1=%08x", vpd->postKernRev,
722 vpd->opFwRev, vpd->sli1FwRev);
723

--- 6 unchanged lines hidden (view full) ---

730
731 /*
732 * If firmware checking is enabled and the adapter model indicates
733 * a firmware image, then perform firmware version check
734 */
735 hba->fw_flag = 0;
736 hba->fw_timer = 0;
737
553 if (((fw_check & 0x1) && (hba->model_info.flags & EMLXS_SUN_BRANDED) &&
554 hba->model_info.fwid) || ((fw_check & 0x2) &&
555 hba->model_info.fwid)) {
738 if (((fw_check & 0x1) &&
739 (hba->model_info.flags & EMLXS_ORACLE_BRANDED) &&
740 hba->model_info.fwid) ||
741 ((fw_check & 0x2) && hba->model_info.fwid)) {
556
557 /* Find firmware image indicated by adapter model */
558 fw = NULL;
559 for (i = 0; i < emlxs_fw_count; i++) {
560 if (emlxs_fw_table[i].id == hba->model_info.fwid) {
561 fw = &emlxs_fw_table[i];
562 break;
563 }
564 }
565
566 /*
567 * If the image was found, then verify current firmware
568 * versions of adapter
569 */
570 if (fw) {
742
743 /* Find firmware image indicated by adapter model */
744 fw = NULL;
745 for (i = 0; i < emlxs_fw_count; i++) {
746 if (emlxs_fw_table[i].id == hba->model_info.fwid) {
747 fw = &emlxs_fw_table[i];
748 break;
749 }
750 }
751
752 /*
753 * If the image was found, then verify current firmware
754 * versions of adapter
755 */
756 if (fw) {
571
572 /* Obtain current firmware version info */
757 /* Obtain current firmware version info */
573 if ((hba->model_info.chip == EMLXS_BE2_CHIP) ||
574 (hba->model_info.chip == EMLXS_BE3_CHIP)) {
575 (void) emlxs_sli4_read_fw_version(hba, &hba_fw);
758 if (hba->model_info.chip & EMLXS_BE_CHIPS) {
759 (void) emlxs_be_read_fw_version(hba, &hba_fw);
576 } else {
577 hba_fw.kern = vpd->postKernRev;
578 hba_fw.stub = vpd->opFwRev;
579 hba_fw.sli1 = vpd->sli1FwRev;
580 hba_fw.sli2 = vpd->sli2FwRev;
581 hba_fw.sli3 = vpd->sli3FwRev;
582 hba_fw.sli4 = vpd->sli4FwRev;
583 }

--- 22 unchanged lines hidden (view full) ---

606 * If MODFW_SUPPORT is not defined, the
607 * firmware image will already be defined
608 * in the emlxs_fw_table
609 */
610 emlxs_fw_load(hba, fw);
611#endif /* MODFW_SUPPORT */
612
613 if (fw->image && fw->size) {
760 } else {
761 hba_fw.kern = vpd->postKernRev;
762 hba_fw.stub = vpd->opFwRev;
763 hba_fw.sli1 = vpd->sli1FwRev;
764 hba_fw.sli2 = vpd->sli2FwRev;
765 hba_fw.sli3 = vpd->sli3FwRev;
766 hba_fw.sli4 = vpd->sli4FwRev;
767 }

--- 22 unchanged lines hidden (view full) ---

790 * If MODFW_SUPPORT is not defined, the
791 * firmware image will already be defined
792 * in the emlxs_fw_table
793 */
794 emlxs_fw_load(hba, fw);
795#endif /* MODFW_SUPPORT */
796
797 if (fw->image && fw->size) {
614 if (emlxs_fw_download(hba,
615 (char *)fw->image, fw->size, 0)) {
798 uint32_t rc;
799
800 rc = emlxs_fw_download(hba,
801 (char *)fw->image, fw->size, 0);
802 if ((rc != FC_SUCCESS) &&
803 (rc != EMLXS_REBOOT_REQUIRED)) {
616 EMLXS_MSGF(EMLXS_CONTEXT,
617 &emlxs_init_msg,
618 "Firmware update failed.");
804 EMLXS_MSGF(EMLXS_CONTEXT,
805 &emlxs_init_msg,
806 "Firmware update failed.");
619
620 hba->fw_flag |=
621 FW_UPDATE_NEEDED;
622 }
623#ifdef MODFW_SUPPORT
624 /*
625 * Unload the firmware image from
626 * kernel memory
627 */
628 emlxs_fw_unload(hba, fw);
629#endif /* MODFW_SUPPORT */
630
631 fw_check = 0;
632
633 goto reset;
634 }
635
807 hba->fw_flag |=
808 FW_UPDATE_NEEDED;
809 }
810#ifdef MODFW_SUPPORT
811 /*
812 * Unload the firmware image from
813 * kernel memory
814 */
815 emlxs_fw_unload(hba, fw);
816#endif /* MODFW_SUPPORT */
817
818 fw_check = 0;
819
820 goto reset;
821 }
822
823 hba->fw_flag |= FW_UPDATE_NEEDED;
824
636 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
637 "Firmware image unavailable.");
638 } else {
639 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
640 "Firmware update not needed.");
641 }
642 } else {
643 /*

--- 24 unchanged lines hidden (view full) ---

668 (void) emlxs_parse_fcoe(hba,
669 (uint8_t *)hba->sli.sli4.dump_region.virt,
670 mb->un.varDmp4.rsp_cnt);
671 }
672
673 /* Reuse mbq from previous mbox */
674 bzero(mbq, sizeof (MAILBOXQ));
675
825 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
826 "Firmware image unavailable.");
827 } else {
828 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
829 "Firmware update not needed.");
830 }
831 } else {
832 /*

--- 24 unchanged lines hidden (view full) ---

857 (void) emlxs_parse_fcoe(hba,
858 (uint8_t *)hba->sli.sli4.dump_region.virt,
859 mb->un.varDmp4.rsp_cnt);
860 }
861
862 /* Reuse mbq from previous mbox */
863 bzero(mbq, sizeof (MAILBOXQ));
864
676 emlxs_mb_request_features(hba, mbq);
865 status = 0;
866 if (port->flag & EMLXS_INI_ENABLED) {
867 status |= SLI4_FEATURE_FCP_INITIATOR;
868 }
869 if (port->flag & EMLXS_TGT_ENABLED) {
870 status |= SLI4_FEATURE_FCP_TARGET;
871 }
872 if (cfg[CFG_NPIV_ENABLE].current) {
873 status |= SLI4_FEATURE_NPIV;
874 }
875 if (cfg[CFG_RQD_MODE].current) {
876 status |= SLI4_FEATURE_RQD;
877 }
878 if (cfg[CFG_PERF_HINT].current) {
879 if (hba->sli.sli4.param.PHON) {
880 status |= SLI4_FEATURE_PERF_HINT;
881 }
882 }
677
883
884 emlxs_mb_request_features(hba, mbq, status);
885
678 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
679 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
680 "Unable to REQUEST_FEATURES. Mailbox cmd=%x status=%x",
681 mb->mbxCommand, mb->mbxStatus);
682
683 rval = EIO;
684 goto failed1;
685 }
886 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
887 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
888 "Unable to REQUEST_FEATURES. Mailbox cmd=%x status=%x",
889 mb->mbxCommand, mb->mbxStatus);
890
891 rval = EIO;
892 goto failed1;
893 }
686emlxs_data_dump(port, "REQ_FEATURE", (uint32_t *)mb, 6, 0);
894 emlxs_data_dump(port, "REQ_FEATURE", (uint32_t *)mb, 6, 0);
687
895
688 /* Make sure we get the features we requested */
689 if (mb->un.varReqFeatures.featuresRequested !=
690 mb->un.varReqFeatures.featuresEnabled) {
896 /* Check to see if we get the features we requested */
897 if (status != mb->un.varReqFeatures.featuresEnabled) {
691
898
899 /* Just report descrepencies, don't abort the attach */
900
901 outptr = (uint8_t *)emlxs_request_feature_xlate(
902 mb->un.varReqFeatures.featuresRequested);
903 (void) strlcpy(buf, (char *)outptr, sizeof (buf));
904
905 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
906 "REQUEST_FEATURES: wanted:%s got:%s",
907 &buf[0], emlxs_request_feature_xlate(
908 mb->un.varReqFeatures.featuresEnabled));
909
910 }
911
912 if ((port->flag & EMLXS_INI_ENABLED) &&
913 !(mb->un.varReqFeatures.featuresEnabled &
914 SLI4_FEATURE_FCP_INITIATOR)) {
692 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
915 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
693 "Unable to get REQUESTed_FEATURES. want:x%x got:x%x",
694 mb->un.varReqFeatures.featuresRequested,
695 mb->un.varReqFeatures.featuresEnabled);
916 "Initiator mode not supported by adapter.");
696
697 rval = EIO;
917
918 rval = EIO;
919
920#ifdef SFCT_SUPPORT
921 /* Check if we can fall back to just target mode */
922 if ((hba->pm_state == EMLXS_PM_IN_ATTACH) &&
923 (mb->un.varReqFeatures.featuresEnabled &
924 SLI4_FEATURE_FCP_TARGET) &&
925 (cfg[CFG_DTM_ENABLE].current == 1) &&
926 (cfg[CFG_TARGET_MODE].current == 1)) {
927
928 cfg[CFG_DTM_ENABLE].current = 0;
929
930 EMLXS_MSGF(EMLXS_CONTEXT,
931 &emlxs_init_failed_msg,
932 "Disabling dynamic target mode. "
933 "Enabling target mode only.");
934
935 /* This will trigger the driver to reattach */
936 rval = EAGAIN;
937 }
938#endif /* SFCT_SUPPORT */
698 goto failed1;
699 }
700
939 goto failed1;
940 }
941
942 if ((port->flag & EMLXS_TGT_ENABLED) &&
943 !(mb->un.varReqFeatures.featuresEnabled &
944 SLI4_FEATURE_FCP_TARGET)) {
945 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
946 "Target mode not supported by adapter.");
947
948 rval = EIO;
949
950#ifdef SFCT_SUPPORT
951 /* Check if we can fall back to just initiator mode */
952 if ((hba->pm_state == EMLXS_PM_IN_ATTACH) &&
953 (mb->un.varReqFeatures.featuresEnabled &
954 SLI4_FEATURE_FCP_INITIATOR) &&
955 (cfg[CFG_DTM_ENABLE].current == 1) &&
956 (cfg[CFG_TARGET_MODE].current == 0)) {
957
958 cfg[CFG_DTM_ENABLE].current = 0;
959
960 EMLXS_MSGF(EMLXS_CONTEXT,
961 &emlxs_init_failed_msg,
962 "Disabling dynamic target mode. "
963 "Enabling initiator mode only.");
964
965 /* This will trigger the driver to reattach */
966 rval = EAGAIN;
967 }
968#endif /* SFCT_SUPPORT */
969 goto failed1;
970 }
971
701 if (mb->un.varReqFeatures.featuresEnabled & SLI4_FEATURE_NPIV) {
702 hba->flag |= FC_NPIV_ENABLED;
703 }
704
972 if (mb->un.varReqFeatures.featuresEnabled & SLI4_FEATURE_NPIV) {
973 hba->flag |= FC_NPIV_ENABLED;
974 }
975
705 /* Check enable-npiv driver parameter for now */
706 if (cfg[CFG_NPIV_ENABLE].current) {
707 hba->flag |= FC_NPIV_ENABLED;
976 if (mb->un.varReqFeatures.featuresEnabled & SLI4_FEATURE_PERF_HINT) {
977 hba->sli.sli4.flag |= EMLXS_SLI4_PHON;
978 if (hba->sli.sli4.param.PHWQ) {
979 hba->sli.sli4.flag |= EMLXS_SLI4_PHWQ;
980 }
708 }
709
710 /* Reuse mbq from previous mbox */
711 bzero(mbq, sizeof (MAILBOXQ));
712
713 emlxs_mb_read_config(hba, mbq);
714 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
715 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
716 "Unable to READ_CONFIG. Mailbox cmd=%x status=%x",
717 mb->mbxCommand, mb->mbxStatus);
718
719 rval = EIO;
720 goto failed1;
721 }
981 }
982
983 /* Reuse mbq from previous mbox */
984 bzero(mbq, sizeof (MAILBOXQ));
985
986 emlxs_mb_read_config(hba, mbq);
987 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
988 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
989 "Unable to READ_CONFIG. Mailbox cmd=%x status=%x",
990 mb->mbxCommand, mb->mbxStatus);
991
992 rval = EIO;
993 goto failed1;
994 }
722emlxs_data_dump(port, "READ_CONFIG4", (uint32_t *)mb, 18, 0);
995 emlxs_data_dump(port, "READ_CONFIG4", (uint32_t *)mb, 18, 0);
723
996
724 hba->sli.sli4.XRICount = (mb->un.varRdConfig4.XRICount);
725 hba->sli.sli4.XRIBase = (mb->un.varRdConfig4.XRIBase);
726 hba->sli.sli4.RPICount = (mb->un.varRdConfig4.RPICount);
727 hba->sli.sli4.RPIBase = (mb->un.varRdConfig4.RPIBase);
728 hba->sli.sli4.VPICount = (mb->un.varRdConfig4.VPICount);
729 hba->sli.sli4.VPIBase = (mb->un.varRdConfig4.VPIBase);
730 hba->sli.sli4.VFICount = (mb->un.varRdConfig4.VFICount);
731 hba->sli.sli4.VFIBase = (mb->un.varRdConfig4.VFIBase);
732 hba->sli.sli4.FCFICount = (mb->un.varRdConfig4.FCFICount);
997 /* Set default extents */
998 hba->sli.sli4.XRICount = mb->un.varRdConfig4.XRICount;
999 hba->sli.sli4.XRIExtCount = 1;
1000 hba->sli.sli4.XRIExtSize = hba->sli.sli4.XRICount;
1001 hba->sli.sli4.XRIBase[0] = mb->un.varRdConfig4.XRIBase;
733
1002
1003 hba->sli.sli4.RPICount = mb->un.varRdConfig4.RPICount;
1004 hba->sli.sli4.RPIExtCount = 1;
1005 hba->sli.sli4.RPIExtSize = hba->sli.sli4.RPICount;
1006 hba->sli.sli4.RPIBase[0] = mb->un.varRdConfig4.RPIBase;
1007
1008 hba->sli.sli4.VPICount = mb->un.varRdConfig4.VPICount;
1009 hba->sli.sli4.VPIExtCount = 1;
1010 hba->sli.sli4.VPIExtSize = hba->sli.sli4.VPICount;
1011 hba->sli.sli4.VPIBase[0] = mb->un.varRdConfig4.VPIBase;
1012
1013 hba->sli.sli4.VFICount = mb->un.varRdConfig4.VFICount;
1014 hba->sli.sli4.VFIExtCount = 1;
1015 hba->sli.sli4.VFIExtSize = hba->sli.sli4.VFICount;
1016 hba->sli.sli4.VFIBase[0] = mb->un.varRdConfig4.VFIBase;
1017
1018 hba->sli.sli4.FCFICount = mb->un.varRdConfig4.FCFICount;
1019
1020 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
1021 "CONFIG: xri:%d rpi:%d vpi:%d vfi:%d fcfi:%d",
1022 hba->sli.sli4.XRICount,
1023 hba->sli.sli4.RPICount,
1024 hba->sli.sli4.VPICount,
1025 hba->sli.sli4.VFICount,
1026 hba->sli.sli4.FCFICount);
1027
1028 if ((hba->sli.sli4.XRICount == 0) ||
1029 (hba->sli.sli4.RPICount == 0) ||
1030 (hba->sli.sli4.VPICount == 0) ||
1031 (hba->sli.sli4.VFICount == 0) ||
1032 (hba->sli.sli4.FCFICount == 0)) {
1033 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1034 "Invalid extent value(s) - xri:%d rpi:%d vpi:%d "
1035 "vfi:%d fcfi:%d",
1036 hba->sli.sli4.XRICount,
1037 hba->sli.sli4.RPICount,
1038 hba->sli.sli4.VPICount,
1039 hba->sli.sli4.VFICount,
1040 hba->sli.sli4.FCFICount);
1041
1042 rval = EIO;
1043 goto failed1;
1044 }
1045
1046 if (mb->un.varRdConfig4.extents) {
1047 if (emlxs_sli4_init_extents(hba, mbq)) {
1048 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1049 "Unable to initialize extents.");
1050
1051 rval = EIO;
1052 goto failed1;
1053 }
1054 }
1055
1056 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
1057 "CONFIG: port_name:%c %c %c %c",
1058 hba->sli.sli4.port_name[0],
1059 hba->sli.sli4.port_name[1],
1060 hba->sli.sli4.port_name[2],
1061 hba->sli.sli4.port_name[3]);
1062
1063 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
1064 "CONFIG: ldv:%d link_type:%d link_number:%d",
1065 mb->un.varRdConfig4.ldv,
1066 mb->un.varRdConfig4.link_type,
1067 mb->un.varRdConfig4.link_number);
1068
1069 if (mb->un.varRdConfig4.ldv) {
1070 hba->sli.sli4.link_number = mb->un.varRdConfig4.link_number;
1071 } else {
1072 hba->sli.sli4.link_number = (uint32_t)-1;
1073 }
1074
734 if (hba->sli.sli4.VPICount) {
735 hba->vpi_max = min(hba->sli.sli4.VPICount, MAX_VPORTS) - 1;
736 }
1075 if (hba->sli.sli4.VPICount) {
1076 hba->vpi_max = min(hba->sli.sli4.VPICount, MAX_VPORTS) - 1;
1077 }
737 hba->vpi_base = mb->un.varRdConfig4.VPIBase;
738
739 /* Set the max node count */
740 if (cfg[CFG_NUM_NODES].current > 0) {
741 hba->max_nodes =
742 min(cfg[CFG_NUM_NODES].current,
743 hba->sli.sli4.RPICount);
744 } else {
745 hba->max_nodes = hba->sli.sli4.RPICount;
746 }
747
748 /* Set the io throttle */
749 hba->io_throttle = hba->sli.sli4.XRICount - IO_THROTTLE_RESERVE;
1078
1079 /* Set the max node count */
1080 if (cfg[CFG_NUM_NODES].current > 0) {
1081 hba->max_nodes =
1082 min(cfg[CFG_NUM_NODES].current,
1083 hba->sli.sli4.RPICount);
1084 } else {
1085 hba->max_nodes = hba->sli.sli4.RPICount;
1086 }
1087
1088 /* Set the io throttle */
1089 hba->io_throttle = hba->sli.sli4.XRICount - IO_THROTTLE_RESERVE;
750 hba->max_iotag = hba->sli.sli4.XRICount;
751
1090
1091 /* Set max_iotag */
1092 /* We add 1 in case all XRI's are non-zero */
1093 hba->max_iotag = hba->sli.sli4.XRICount + 1;
1094
1095 if (cfg[CFG_NUM_IOTAGS].current) {
1096 hba->max_iotag = min(hba->max_iotag,
1097 (uint16_t)cfg[CFG_NUM_IOTAGS].current);
1098 }
1099
1100 /* Set out-of-range iotag base */
1101 hba->fc_oor_iotag = hba->max_iotag;
1102
752 /* Save the link speed capabilities */
753 vpd->link_speed = (uint16_t)mb->un.varRdConfig4.lmt;
754 emlxs_process_link_speed(hba);
755
756 /*
757 * Allocate some memory for buffers
758 */
759 if (emlxs_mem_alloc_buffer(hba) == 0) {
760 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
761 "Unable to allocate memory buffers.");
762
763 rval = ENOMEM;
764 goto failed1;
765 }
766
1103 /* Save the link speed capabilities */
1104 vpd->link_speed = (uint16_t)mb->un.varRdConfig4.lmt;
1105 emlxs_process_link_speed(hba);
1106
1107 /*
1108 * Allocate some memory for buffers
1109 */
1110 if (emlxs_mem_alloc_buffer(hba) == 0) {
1111 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1112 "Unable to allocate memory buffers.");
1113
1114 rval = ENOMEM;
1115 goto failed1;
1116 }
1117
767 /*
768 * OutOfRange (oor) iotags are used for abort or close
769 * XRI commands or any WQE that does not require a SGL
770 */
771 hba->fc_oor_iotag = hba->max_iotag;
772
773 if (emlxs_sli4_resource_alloc(hba)) {
774 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
775 "Unable to allocate resources.");
776
777 rval = ENOMEM;
778 goto failed2;
779 }
1118 if (emlxs_sli4_resource_alloc(hba)) {
1119 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1120 "Unable to allocate resources.");
1121
1122 rval = ENOMEM;
1123 goto failed2;
1124 }
780emlxs_data_dump(port, "XRIp", (uint32_t *)hba->sli.sli4.XRIp, 18, 0);
1125 emlxs_data_dump(port, "XRIp", (uint32_t *)hba->sli.sli4.XRIp, 18, 0);
1126 emlxs_sli4_zero_queue_stat(hba);
781
782#if (EMLXS_MODREV >= EMLXS_MODREV5)
783 if ((cfg[CFG_NPIV_ENABLE].current) && (hba->flag & FC_NPIV_ENABLED)) {
784 hba->fca_tran->fca_num_npivports = hba->vpi_max;
785 }
786#endif /* >= EMLXS_MODREV5 */
787
788 /* Reuse mbq from previous mbox */

--- 46 unchanged lines hidden (view full) ---

835 EMLXS_STATE_CHANGE(hba, FC_INIT_CFGPORT);
836
837 /* Get and save the current firmware version (based on sli_mode) */
838 emlxs_decode_firmware_rev(hba, vpd);
839
840
841 EMLXS_STATE_CHANGE(hba, FC_INIT_INITLINK);
842
1127
1128#if (EMLXS_MODREV >= EMLXS_MODREV5)
1129 if ((cfg[CFG_NPIV_ENABLE].current) && (hba->flag & FC_NPIV_ENABLED)) {
1130 hba->fca_tran->fca_num_npivports = hba->vpi_max;
1131 }
1132#endif /* >= EMLXS_MODREV5 */
1133
1134 /* Reuse mbq from previous mbox */

--- 46 unchanged lines hidden (view full) ---

1181 EMLXS_STATE_CHANGE(hba, FC_INIT_CFGPORT);
1182
1183 /* Get and save the current firmware version (based on sli_mode) */
1184 emlxs_decode_firmware_rev(hba, vpd);
1185
1186
1187 EMLXS_STATE_CHANGE(hba, FC_INIT_INITLINK);
1188
1189 if (SLI4_FC_MODE) {
1190 /* Reuse mbq from previous mbox */
1191 bzero(mbq, sizeof (MAILBOXQ));
1192
1193 emlxs_mb_config_link(hba, mbq);
1194 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
1195 MBX_SUCCESS) {
1196 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1197 "Unable to configure link. Mailbox cmd=%x "
1198 "status=%x",
1199 mb->mbxCommand, mb->mbxStatus);
1200
1201 rval = EIO;
1202 goto failed3;
1203 }
1204 }
1205
843 /* Reuse mbq from previous mbox */
844 bzero(mbq, sizeof (MAILBOXQ));
845
846 /*
847 * We need to get login parameters for NID
848 */
849 (void) emlxs_mb_read_sparam(hba, mbq);
850 mp = (MATCHMAP *)mbq->bp;

--- 38 unchanged lines hidden (view full) ---

889 /*
890 * Set port number and port index to zero
891 * The WWN's are unique to each port and therefore port_num
892 * must equal zero. This effects the hba_fru_details structure
893 * in fca_bind_port()
894 */
895 vpd->port_num[0] = 0;
896 vpd->port_index = 0;
1206 /* Reuse mbq from previous mbox */
1207 bzero(mbq, sizeof (MAILBOXQ));
1208
1209 /*
1210 * We need to get login parameters for NID
1211 */
1212 (void) emlxs_mb_read_sparam(hba, mbq);
1213 mp = (MATCHMAP *)mbq->bp;

--- 38 unchanged lines hidden (view full) ---

1252 /*
1253 * Set port number and port index to zero
1254 * The WWN's are unique to each port and therefore port_num
1255 * must equal zero. This effects the hba_fru_details structure
1256 * in fca_bind_port()
1257 */
1258 vpd->port_num[0] = 0;
1259 vpd->port_index = 0;
1260
1261 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
1262 "CONFIG: WWPN: port_index=0");
897 }
898
1263 }
1264
899 /* Make attempt to set a port index */
1265 /* Make final attempt to set a port index */
900 if (vpd->port_index == (uint32_t)-1) {
901 dev_info_t *p_dip;
902 dev_info_t *c_dip;
903
904 p_dip = ddi_get_parent(hba->dip);
905 c_dip = ddi_get_child(p_dip);
906
907 vpd->port_index = 0;
908 while (c_dip && (hba->dip != c_dip)) {
909 c_dip = ddi_get_next_sibling(c_dip);
910
1266 if (vpd->port_index == (uint32_t)-1) {
1267 dev_info_t *p_dip;
1268 dev_info_t *c_dip;
1269
1270 p_dip = ddi_get_parent(hba->dip);
1271 c_dip = ddi_get_child(p_dip);
1272
1273 vpd->port_index = 0;
1274 while (c_dip && (hba->dip != c_dip)) {
1275 c_dip = ddi_get_next_sibling(c_dip);
1276
911 if (strcmp(ddi_get_name(c_dip), "ethernet")) {
912 vpd->port_index++;
1277 if (strcmp(ddi_get_name(c_dip), "ethernet") == 0) {
1278 continue;
913 }
1279 }
1280
1281 vpd->port_index++;
914 }
1282 }
1283
1284 EMLXS_MSGF(EMLXS_CONTEXT,
1285 &emlxs_init_debug_msg,
1286 "CONFIG: Device tree: port_index=%d",
1287 vpd->port_index);
915 }
916
917 if (vpd->port_num[0] == 0) {
1288 }
1289
1290 if (vpd->port_num[0] == 0) {
918 if (hba->model_info.channels > 1) {
919 (void) sprintf(vpd->port_num, "%d", vpd->port_index);
1291 if (hba->model_info.channels == EMLXS_MULTI_CHANNEL) {
1292 (void) snprintf(vpd->port_num,
1293 (sizeof (vpd->port_num)-1),
1294 "%d", vpd->port_index);
920 }
921 }
922
923 if (vpd->id[0] == 0) {
1295 }
1296 }
1297
1298 if (vpd->id[0] == 0) {
924 (void) sprintf(vpd->id, "%s %d",
1299 (void) snprintf(vpd->id, (sizeof (vpd->id)-1),
1300 "%s %d",
925 hba->model_info.model_desc, vpd->port_index);
926
927 }
928
929 if (vpd->manufacturer[0] == 0) {
1301 hba->model_info.model_desc, vpd->port_index);
1302
1303 }
1304
1305 if (vpd->manufacturer[0] == 0) {
930 (void) strcpy(vpd->manufacturer, hba->model_info.manufacturer);
1306 (void) strncpy(vpd->manufacturer, hba->model_info.manufacturer,
1307 (sizeof (vpd->manufacturer)-1));
931 }
932
933 if (vpd->part_num[0] == 0) {
1308 }
1309
1310 if (vpd->part_num[0] == 0) {
934 (void) strcpy(vpd->part_num, hba->model_info.model);
1311 (void) strncpy(vpd->part_num, hba->model_info.model,
1312 (sizeof (vpd->part_num)-1));
935 }
936
937 if (vpd->model_desc[0] == 0) {
1313 }
1314
1315 if (vpd->model_desc[0] == 0) {
938 (void) sprintf(vpd->model_desc, "%s %d",
1316 (void) snprintf(vpd->model_desc, (sizeof (vpd->model_desc)-1),
1317 "%s %d",
939 hba->model_info.model_desc, vpd->port_index);
940 }
941
942 if (vpd->model[0] == 0) {
1318 hba->model_info.model_desc, vpd->port_index);
1319 }
1320
1321 if (vpd->model[0] == 0) {
943 (void) strcpy(vpd->model, hba->model_info.model);
1322 (void) strncpy(vpd->model, hba->model_info.model,
1323 (sizeof (vpd->model)-1));
944 }
945
946 if (vpd->prog_types[0] == 0) {
1324 }
1325
1326 if (vpd->prog_types[0] == 0) {
947 emlxs_build_prog_types(hba, vpd->prog_types);
1327 emlxs_build_prog_types(hba, vpd);
948 }
949
950 /* Create the symbolic names */
1328 }
1329
1330 /* Create the symbolic names */
951 (void) sprintf(hba->snn, "Emulex %s FV%s DV%s %s",
1331 (void) snprintf(hba->snn, (sizeof (hba->snn)-1),
1332 "Emulex %s FV%s DV%s %s",
952 hba->model_info.model, hba->vpd.fw_version, emlxs_version,
953 (char *)utsname.nodename);
954
1333 hba->model_info.model, hba->vpd.fw_version, emlxs_version,
1334 (char *)utsname.nodename);
1335
955 (void) sprintf(hba->spn,
1336 (void) snprintf(hba->spn, (sizeof (hba->spn)-1),
956 "Emulex PPN-%01x%01x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
957 hba->wwpn.nameType, hba->wwpn.IEEEextMsn, hba->wwpn.IEEEextLsb,
958 hba->wwpn.IEEE[0], hba->wwpn.IEEE[1], hba->wwpn.IEEE[2],
959 hba->wwpn.IEEE[3], hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]);
960
961
962 EMLXS_STATE_CHANGE(hba, FC_LINK_DOWN);
963 emlxs_sli4_enable_intr(hba);
964
1337 "Emulex PPN-%01x%01x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1338 hba->wwpn.nameType, hba->wwpn.IEEEextMsn, hba->wwpn.IEEEextLsb,
1339 hba->wwpn.IEEE[0], hba->wwpn.IEEE[1], hba->wwpn.IEEE[2],
1340 hba->wwpn.IEEE[3], hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]);
1341
1342
1343 EMLXS_STATE_CHANGE(hba, FC_LINK_DOWN);
1344 emlxs_sli4_enable_intr(hba);
1345
1346 /* Check persist-linkdown */
1347 if (cfg[CFG_PERSIST_LINKDOWN].current) {
1348 EMLXS_STATE_CHANGE(hba, FC_LINK_DOWN_PERSIST);
1349 goto done;
1350 }
1351
1352#ifdef SFCT_SUPPORT
1353 if ((port->mode == MODE_TARGET) &&
1354 !(port->fct_flags & FCT_STATE_PORT_ONLINE)) {
1355 goto done;
1356 }
1357#endif /* SFCT_SUPPORT */
1358
965 /* Reuse mbq from previous mbox */
966 bzero(mbq, sizeof (MAILBOXQ));
967
968 /*
969 * Setup and issue mailbox INITIALIZE LINK command
970 * At this point, the interrupt will be generated by the HW
1359 /* Reuse mbq from previous mbox */
1360 bzero(mbq, sizeof (MAILBOXQ));
1361
1362 /*
1363 * Setup and issue mailbox INITIALIZE LINK command
1364 * At this point, the interrupt will be generated by the HW
971 * Do this only if persist-linkdown is not set
972 */
1365 */
973 if (cfg[CFG_PERSIST_LINKDOWN].current == 0) {
974 emlxs_mb_init_link(hba, mbq,
975 cfg[CFG_TOPOLOGY].current, cfg[CFG_LINK_SPEED].current);
1366 emlxs_mb_init_link(hba, mbq,
1367 cfg[CFG_TOPOLOGY].current, cfg[CFG_LINK_SPEED].current);
976
1368
977 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0)
978 != MBX_SUCCESS) {
979 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
980 "Unable to initialize link. "
981 "Mailbox cmd=%x status=%x",
982 mb->mbxCommand, mb->mbxStatus);
1369 rval = emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_NOWAIT, 0);
1370 if ((rval != MBX_SUCCESS) && (rval != MBX_BUSY)) {
1371 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
1372 "Unable to initialize link. "
1373 "Mailbox cmd=%x status=%x",
1374 mb->mbxCommand, mb->mbxStatus);
983
1375
1376 rval = EIO;
1377 goto failed3;
1378 }
1379
1380 /* Wait for link to come up */
1381 i = cfg[CFG_LINKUP_DELAY].current;
1382 while (i && (hba->state < FC_LINK_UP)) {
1383 /* Check for hardware error */
1384 if (hba->state == FC_ERROR) {
1385 EMLXS_MSGF(EMLXS_CONTEXT,
1386 &emlxs_init_failed_msg,
1387 "Adapter error.", mb->mbxCommand,
1388 mb->mbxStatus);
1389
984 rval = EIO;
985 goto failed3;
986 }
987
1390 rval = EIO;
1391 goto failed3;
1392 }
1393
988 /* Wait for link to come up */
989 i = cfg[CFG_LINKUP_DELAY].current;
990 while (i && (hba->state < FC_LINK_UP)) {
991 /* Check for hardware error */
992 if (hba->state == FC_ERROR) {
993 EMLXS_MSGF(EMLXS_CONTEXT,
994 &emlxs_init_failed_msg,
995 "Adapter error.", mb->mbxCommand,
996 mb->mbxStatus);
997
998 rval = EIO;
999 goto failed3;
1000 }
1001
1002 DELAYMS(1000);
1003 i--;
1004 }
1005 } else {
1006 EMLXS_STATE_CHANGE(hba, FC_LINK_DOWN_PERSIST);
1394 BUSYWAIT_MS(1000);
1395 i--;
1007 }
1008
1396 }
1397
1398done:
1009 /*
1399 /*
1010 * The leadvile driver will now handle the FLOGI at the driver level
1400 * The leadville driver will now handle the FLOGI at the driver level
1011 */
1012
1013 if (mbq) {
1014 (void) kmem_free((uint8_t *)mbq, sizeof (MAILBOXQ));
1015 mbq = NULL;
1016 mb = NULL;
1017 }
1018 return (0);

--- 32 unchanged lines hidden (view full) ---

1051 }
1052
1053 return (rval);
1054
1055} /* emlxs_sli4_online() */
1056
1057
1058static void
1401 */
1402
1403 if (mbq) {
1404 (void) kmem_free((uint8_t *)mbq, sizeof (MAILBOXQ));
1405 mbq = NULL;
1406 mb = NULL;
1407 }
1408 return (0);

--- 32 unchanged lines hidden (view full) ---

1441 }
1442
1443 return (rval);
1444
1445} /* emlxs_sli4_online() */
1446
1447
1448static void
1059emlxs_sli4_offline(emlxs_hba_t *hba)
1449emlxs_sli4_offline(emlxs_hba_t *hba, uint32_t reset_requested)
1060{
1450{
1061 emlxs_port_t *port = &PPORT;
1062 MAILBOXQ mboxq;
1063
1064 /* Reverse emlxs_sli4_online */
1065
1066 mutex_enter(&EMLXS_PORT_LOCK);
1451 /* Reverse emlxs_sli4_online */
1452
1453 mutex_enter(&EMLXS_PORT_LOCK);
1067 if (!(hba->flag & FC_INTERLOCKED)) {
1454 if (hba->flag & FC_INTERLOCKED) {
1068 mutex_exit(&EMLXS_PORT_LOCK);
1455 mutex_exit(&EMLXS_PORT_LOCK);
1456 goto killed;
1457 }
1458 mutex_exit(&EMLXS_PORT_LOCK);
1069
1459
1070 /* This is the only way to disable interupts */
1071 bzero((void *)&mboxq, sizeof (MAILBOXQ));
1072 emlxs_mb_resetport(hba, &mboxq);
1073 if (emlxs_sli4_issue_mbox_cmd(hba, &mboxq,
1074 MBX_WAIT, 0) != MBX_SUCCESS) {
1075 /* Timeout occurred */
1076 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1077 "Timeout: Offline RESET");
1078 }
1079 (void) emlxs_check_hdw_ready(hba);
1080 } else {
1081 mutex_exit(&EMLXS_PORT_LOCK);
1460 if (reset_requested) {
1461 (void) emlxs_sli4_hba_reset(hba, 0, 0, 0);
1082 }
1083
1084 /* Shutdown the adapter interface */
1085 emlxs_sli4_hba_kill(hba);
1086
1462 }
1463
1464 /* Shutdown the adapter interface */
1465 emlxs_sli4_hba_kill(hba);
1466
1467killed:
1468
1087 /* Free SLI shared memory */
1088 emlxs_sli4_resource_free(hba);
1089
1090 /* Free driver shared memory */
1091 (void) emlxs_mem_free_buffer(hba);
1092
1093 /* Free the host dump region buffer */
1094 (void) emlxs_mem_free(hba, &hba->sli.sli4.dump_region);

--- 8 unchanged lines hidden (view full) ---

1103 emlxs_port_t *port = &PPORT;
1104 dev_info_t *dip;
1105 ddi_device_acc_attr_t dev_attr;
1106 int status;
1107
1108 dip = (dev_info_t *)hba->dip;
1109 dev_attr = emlxs_dev_acc_attr;
1110
1469 /* Free SLI shared memory */
1470 emlxs_sli4_resource_free(hba);
1471
1472 /* Free driver shared memory */
1473 (void) emlxs_mem_free_buffer(hba);
1474
1475 /* Free the host dump region buffer */
1476 (void) emlxs_mem_free(hba, &hba->sli.sli4.dump_region);

--- 8 unchanged lines hidden (view full) ---

1485 emlxs_port_t *port = &PPORT;
1486 dev_info_t *dip;
1487 ddi_device_acc_attr_t dev_attr;
1488 int status;
1489
1490 dip = (dev_info_t *)hba->dip;
1491 dev_attr = emlxs_dev_acc_attr;
1492
1111 /*
1112 * Map in Hardware BAR pages that will be used for
1113 * communication with HBA.
1114 */
1115 if (hba->sli.sli4.bar1_acc_handle == 0) {
1116 status = ddi_regs_map_setup(dip, PCI_BAR1_RINDEX,
1117 (caddr_t *)&hba->sli.sli4.bar1_addr,
1118 0, 0, &dev_attr, &hba->sli.sli4.bar1_acc_handle);
1119 if (status != DDI_SUCCESS) {
1120 EMLXS_MSGF(EMLXS_CONTEXT,
1121 &emlxs_attach_failed_msg,
1122 "(PCI) ddi_regs_map_setup BAR1 failed. "
1123 "stat=%d mem=%p attr=%p hdl=%p",
1124 status, &hba->sli.sli4.bar1_addr, &dev_attr,
1125 &hba->sli.sli4.bar1_acc_handle);
1126 goto failed;
1493 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1494 case SLI_INTF_IF_TYPE_0:
1495
1496 /* Map in Hardware BAR pages that will be used for */
1497 /* communication with HBA. */
1498 if (hba->sli.sli4.bar1_acc_handle == 0) {
1499 status = ddi_regs_map_setup(dip, PCI_BAR1_RINDEX,
1500 (caddr_t *)&hba->sli.sli4.bar1_addr,
1501 0, 0, &dev_attr, &hba->sli.sli4.bar1_acc_handle);
1502 if (status != DDI_SUCCESS) {
1503 EMLXS_MSGF(EMLXS_CONTEXT,
1504 &emlxs_attach_failed_msg,
1505 "(PCI) ddi_regs_map_setup BAR1 failed. "
1506 "stat=%d mem=%p attr=%p hdl=%p",
1507 status, &hba->sli.sli4.bar1_addr, &dev_attr,
1508 &hba->sli.sli4.bar1_acc_handle);
1509 goto failed;
1510 }
1127 }
1511 }
1128 }
1129
1512
1130 if (hba->sli.sli4.bar2_acc_handle == 0) {
1131 status = ddi_regs_map_setup(dip, PCI_BAR2_RINDEX,
1132 (caddr_t *)&hba->sli.sli4.bar2_addr,
1133 0, 0, &dev_attr, &hba->sli.sli4.bar2_acc_handle);
1134 if (status != DDI_SUCCESS) {
1135 EMLXS_MSGF(EMLXS_CONTEXT,
1136 &emlxs_attach_failed_msg,
1137 "ddi_regs_map_setup BAR2 failed. status=%x",
1138 status);
1139 goto failed;
1513 if (hba->sli.sli4.bar2_acc_handle == 0) {
1514 status = ddi_regs_map_setup(dip, PCI_BAR2_RINDEX,
1515 (caddr_t *)&hba->sli.sli4.bar2_addr,
1516 0, 0, &dev_attr, &hba->sli.sli4.bar2_acc_handle);
1517 if (status != DDI_SUCCESS) {
1518 EMLXS_MSGF(EMLXS_CONTEXT,
1519 &emlxs_attach_failed_msg,
1520 "ddi_regs_map_setup BAR2 failed. status=%x",
1521 status);
1522 goto failed;
1523 }
1140 }
1524 }
1525
1526 /* offset from beginning of register space */
1527 hba->sli.sli4.MPUEPSemaphore_reg_addr =
1528 (uint32_t *)(hba->sli.sli4.bar1_addr +
1529 CSR_MPU_EP_SEMAPHORE_OFFSET);
1530 hba->sli.sli4.MBDB_reg_addr =
1531 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_MB_DB_OFFSET);
1532 hba->sli.sli4.CQDB_reg_addr =
1533 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_CQ_DB_OFFSET);
1534 hba->sli.sli4.MQDB_reg_addr =
1535 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_MQ_DB_OFFSET);
1536 hba->sli.sli4.WQDB_reg_addr =
1537 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_WQ_DB_OFFSET);
1538 hba->sli.sli4.RQDB_reg_addr =
1539 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_RQ_DB_OFFSET);
1540
1541 hba->sli.sli4.STATUS_reg_addr = 0;
1542 hba->sli.sli4.CNTL_reg_addr = 0;
1543
1544 hba->sli.sli4.ERR1_reg_addr =
1545 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_LO_OFFSET);
1546 hba->sli.sli4.ERR2_reg_addr =
1547 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_HI_OFFSET);
1548
1549 hba->sli.sli4.PHYSDEV_reg_addr = 0;
1550 break;
1551
1552 case SLI_INTF_IF_TYPE_2:
1553
1554 /* Map in Hardware BAR pages that will be used for */
1555 /* communication with HBA. */
1556 if (hba->sli.sli4.bar0_acc_handle == 0) {
1557 status = ddi_regs_map_setup(dip, PCI_BAR0_RINDEX,
1558 (caddr_t *)&hba->sli.sli4.bar0_addr,
1559 0, 0, &dev_attr, &hba->sli.sli4.bar0_acc_handle);
1560 if (status != DDI_SUCCESS) {
1561 EMLXS_MSGF(EMLXS_CONTEXT,
1562 &emlxs_attach_failed_msg,
1563 "(PCI) ddi_regs_map_setup BAR0 failed. "
1564 "stat=%d mem=%p attr=%p hdl=%p",
1565 status, &hba->sli.sli4.bar0_addr, &dev_attr,
1566 &hba->sli.sli4.bar0_acc_handle);
1567 goto failed;
1568 }
1569 }
1570
1571 /* offset from beginning of register space */
1572 hba->sli.sli4.MPUEPSemaphore_reg_addr =
1573 (uint32_t *)(hba->sli.sli4.bar0_addr +
1574 SLIPORT_SEMAPHORE_OFFSET);
1575 hba->sli.sli4.MBDB_reg_addr =
1576 (uint32_t *)(hba->sli.sli4.bar0_addr + PD_MB_DB_OFFSET);
1577 hba->sli.sli4.CQDB_reg_addr =
1578 (uint32_t *)(hba->sli.sli4.bar0_addr + PD_CQ_DB_OFFSET);
1579 hba->sli.sli4.MQDB_reg_addr =
1580 (uint32_t *)(hba->sli.sli4.bar0_addr + PD_MQ_DB_OFFSET);
1581 hba->sli.sli4.WQDB_reg_addr =
1582 (uint32_t *)(hba->sli.sli4.bar0_addr + PD_WQ_DB_OFFSET);
1583 hba->sli.sli4.RQDB_reg_addr =
1584 (uint32_t *)(hba->sli.sli4.bar0_addr + PD_RQ_DB_OFFSET);
1585
1586 hba->sli.sli4.STATUS_reg_addr =
1587 (uint32_t *)(hba->sli.sli4.bar0_addr +
1588 SLIPORT_STATUS_OFFSET);
1589 hba->sli.sli4.CNTL_reg_addr =
1590 (uint32_t *)(hba->sli.sli4.bar0_addr +
1591 SLIPORT_CONTROL_OFFSET);
1592 hba->sli.sli4.ERR1_reg_addr =
1593 (uint32_t *)(hba->sli.sli4.bar0_addr +
1594 SLIPORT_ERROR1_OFFSET);
1595 hba->sli.sli4.ERR2_reg_addr =
1596 (uint32_t *)(hba->sli.sli4.bar0_addr +
1597 SLIPORT_ERROR2_OFFSET);
1598 hba->sli.sli4.PHYSDEV_reg_addr =
1599 (uint32_t *)(hba->sli.sli4.bar0_addr +
1600 PHYSDEV_CONTROL_OFFSET);
1601
1602 break;
1603
1604 case SLI_INTF_IF_TYPE_1:
1605 case SLI_INTF_IF_TYPE_3:
1606 default:
1607 EMLXS_MSGF(EMLXS_CONTEXT,
1608 &emlxs_attach_failed_msg,
1609 "Map hdw: Unsupported if_type %08x",
1610 (hba->sli_intf & SLI_INTF_IF_TYPE_MASK));
1611
1612 goto failed;
1141 }
1142
1143 if (hba->sli.sli4.bootstrapmb.virt == 0) {
1144 MBUF_INFO *buf_info;
1145 MBUF_INFO bufinfo;
1146
1147 buf_info = &bufinfo;
1148

--- 14 unchanged lines hidden (view full) ---

1163 hba->sli.sli4.bootstrapmb.size = EMLXS_BOOTSTRAP_MB_SIZE +
1164 MBOX_EXTENSION_SIZE;
1165 hba->sli.sli4.bootstrapmb.data_handle = buf_info->data_handle;
1166 hba->sli.sli4.bootstrapmb.dma_handle = buf_info->dma_handle;
1167 bzero((char *)hba->sli.sli4.bootstrapmb.virt,
1168 EMLXS_BOOTSTRAP_MB_SIZE);
1169 }
1170
1613 }
1614
1615 if (hba->sli.sli4.bootstrapmb.virt == 0) {
1616 MBUF_INFO *buf_info;
1617 MBUF_INFO bufinfo;
1618
1619 buf_info = &bufinfo;
1620

--- 14 unchanged lines hidden (view full) ---

1635 hba->sli.sli4.bootstrapmb.size = EMLXS_BOOTSTRAP_MB_SIZE +
1636 MBOX_EXTENSION_SIZE;
1637 hba->sli.sli4.bootstrapmb.data_handle = buf_info->data_handle;
1638 hba->sli.sli4.bootstrapmb.dma_handle = buf_info->dma_handle;
1639 bzero((char *)hba->sli.sli4.bootstrapmb.virt,
1640 EMLXS_BOOTSTRAP_MB_SIZE);
1641 }
1642
1171 /* offset from beginning of register space */
1172 hba->sli.sli4.MPUEPSemaphore_reg_addr =
1173 (uint32_t *)(hba->sli.sli4.bar1_addr + CSR_MPU_EP_SEMAPHORE_OFFSET);
1174 hba->sli.sli4.MBDB_reg_addr =
1175 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_MB_DB_OFFSET);
1176 hba->sli.sli4.CQDB_reg_addr =
1177 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_CQ_DB_OFFSET);
1178 hba->sli.sli4.MQDB_reg_addr =
1179 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_MQ_DB_OFFSET);
1180 hba->sli.sli4.WQDB_reg_addr =
1181 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_WQ_DB_OFFSET);
1182 hba->sli.sli4.RQDB_reg_addr =
1183 (uint32_t *)(hba->sli.sli4.bar2_addr + PD_RQ_DB_OFFSET);
1184 hba->chan_count = MAX_CHANNEL;
1185
1186 return (0);
1187
1188failed:
1189
1190 emlxs_sli4_unmap_hdw(hba);
1191 return (ENOMEM);

--- 4 unchanged lines hidden (view full) ---

1196
1197/*ARGSUSED*/
1198static void
1199emlxs_sli4_unmap_hdw(emlxs_hba_t *hba)
1200{
1201 MBUF_INFO bufinfo;
1202 MBUF_INFO *buf_info = &bufinfo;
1203
1643 hba->chan_count = MAX_CHANNEL;
1644
1645 return (0);
1646
1647failed:
1648
1649 emlxs_sli4_unmap_hdw(hba);
1650 return (ENOMEM);

--- 4 unchanged lines hidden (view full) ---

1655
1656/*ARGSUSED*/
1657static void
1658emlxs_sli4_unmap_hdw(emlxs_hba_t *hba)
1659{
1660 MBUF_INFO bufinfo;
1661 MBUF_INFO *buf_info = &bufinfo;
1662
1204 /*
1205 * Free map for Hardware BAR pages that were used for
1206 * communication with HBA.
1207 */
1663
1664 if (hba->sli.sli4.bar0_acc_handle) {
1665 ddi_regs_map_free(&hba->sli.sli4.bar0_acc_handle);
1666 hba->sli.sli4.bar0_acc_handle = 0;
1667 }
1668
1208 if (hba->sli.sli4.bar1_acc_handle) {
1209 ddi_regs_map_free(&hba->sli.sli4.bar1_acc_handle);
1210 hba->sli.sli4.bar1_acc_handle = 0;
1211 }
1212
1213 if (hba->sli.sli4.bar2_acc_handle) {
1214 ddi_regs_map_free(&hba->sli.sli4.bar2_acc_handle);
1215 hba->sli.sli4.bar2_acc_handle = 0;
1216 }
1669 if (hba->sli.sli4.bar1_acc_handle) {
1670 ddi_regs_map_free(&hba->sli.sli4.bar1_acc_handle);
1671 hba->sli.sli4.bar1_acc_handle = 0;
1672 }
1673
1674 if (hba->sli.sli4.bar2_acc_handle) {
1675 ddi_regs_map_free(&hba->sli.sli4.bar2_acc_handle);
1676 hba->sli.sli4.bar2_acc_handle = 0;
1677 }
1678
1217 if (hba->sli.sli4.bootstrapmb.virt) {
1218 bzero(buf_info, sizeof (MBUF_INFO));
1219
1220 if (hba->sli.sli4.bootstrapmb.phys) {
1221 buf_info->phys = hba->sli.sli4.bootstrapmb.phys;
1222 buf_info->data_handle =
1223 hba->sli.sli4.bootstrapmb.data_handle;
1224 buf_info->dma_handle =

--- 14 unchanged lines hidden (view full) ---

1239
1240
1241static int
1242emlxs_check_hdw_ready(emlxs_hba_t *hba)
1243{
1244 emlxs_port_t *port = &PPORT;
1245 uint32_t status;
1246 uint32_t i = 0;
1679 if (hba->sli.sli4.bootstrapmb.virt) {
1680 bzero(buf_info, sizeof (MBUF_INFO));
1681
1682 if (hba->sli.sli4.bootstrapmb.phys) {
1683 buf_info->phys = hba->sli.sli4.bootstrapmb.phys;
1684 buf_info->data_handle =
1685 hba->sli.sli4.bootstrapmb.data_handle;
1686 buf_info->dma_handle =

--- 14 unchanged lines hidden (view full) ---

1701
1702
1703static int
1704emlxs_check_hdw_ready(emlxs_hba_t *hba)
1705{
1706 emlxs_port_t *port = &PPORT;
1707 uint32_t status;
1708 uint32_t i = 0;
1709 uint32_t err1;
1710 uint32_t err2;
1247
1248 /* Wait for reset completion */
1249 while (i < 30) {
1711
1712 /* Wait for reset completion */
1713 while (i < 30) {
1250 /* Check Semaphore register to see what the ARM state is */
1251 status = READ_BAR1_REG(hba, FC_SEMA_REG(hba));
1252
1714
1253 /* Check to see if any errors occurred during init */
1254 if (status & ARM_POST_FATAL) {
1255 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1256 "SEMA Error: status=0x%x", status);
1715 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1716 case SLI_INTF_IF_TYPE_0:
1717 status = emlxs_sli4_read_sema(hba);
1257
1718
1719 /* Check to see if any errors occurred during init */
1720 if (status & ARM_POST_FATAL) {
1721 EMLXS_MSGF(EMLXS_CONTEXT,
1722 &emlxs_reset_failed_msg,
1723 "SEMA Error: status=%x", status);
1724
1725 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1726
1727 return (1);
1728 }
1729
1730 if ((status & ARM_UNRECOVERABLE_ERROR) ==
1731 ARM_UNRECOVERABLE_ERROR) {
1732 EMLXS_MSGF(EMLXS_CONTEXT,
1733 &emlxs_reset_failed_msg,
1734 "Unrecoverable Error: status=%x", status);
1735
1736 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1737
1738 return (1);
1739 }
1740
1741 if ((status & ARM_POST_MASK) == ARM_POST_READY) {
1742 /* ARM Ready !! */
1743 EMLXS_MSGF(EMLXS_CONTEXT,
1744 &emlxs_sli_detail_msg,
1745 "ARM Ready: status=%x", status);
1746
1747 return (0);
1748 }
1749 break;
1750
1751 case SLI_INTF_IF_TYPE_2:
1752 status = emlxs_sli4_read_status(hba);
1753
1754 if (status & SLI_STATUS_READY) {
1755 if (!(status & SLI_STATUS_ERROR)) {
1756 /* ARM Ready !! */
1757 EMLXS_MSGF(EMLXS_CONTEXT,
1758 &emlxs_sli_detail_msg,
1759 "ARM Ready: status=%x", status);
1760
1761 return (0);
1762 }
1763
1764 err1 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1765 hba->sli.sli4.ERR1_reg_addr);
1766 err2 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1767 hba->sli.sli4.ERR2_reg_addr);
1768
1769 if (status & SLI_STATUS_RESET_NEEDED) {
1770 EMLXS_MSGF(EMLXS_CONTEXT,
1771 &emlxs_sli_detail_msg,
1772 "ARM Ready (Reset Needed): "
1773 "status=%x err1=%x "
1774 "err2=%x",
1775 status, err1, err2);
1776
1777 return (1);
1778 }
1779
1780 EMLXS_MSGF(EMLXS_CONTEXT,
1781 &emlxs_reset_failed_msg,
1782 "Unrecoverable Error: status=%x err1=%x "
1783 "err2=%x",
1784 status, err1, err2);
1785
1786 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1787
1788 return (2);
1789 }
1790
1791 break;
1792
1793 default:
1258 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1794 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1259#ifdef FMA_SUPPORT
1260 /* Access handle validation */
1261 EMLXS_CHK_ACC_HANDLE(hba,
1262 hba->sli.sli4.bar1_acc_handle);
1263#endif /* FMA_SUPPORT */
1264 return (1);
1795
1796 return (3);
1265 }
1797 }
1266 if ((status & ARM_POST_MASK) == ARM_POST_READY) {
1267 /* ARM Ready !! */
1268 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
1269 "ARM Ready: status=0x%x", status);
1270#ifdef FMA_SUPPORT
1271 /* Access handle validation */
1272 EMLXS_CHK_ACC_HANDLE(hba,
1273 hba->sli.sli4.bar1_acc_handle);
1274#endif /* FMA_SUPPORT */
1275 return (0);
1276 }
1277
1798
1278 DELAYMS(1000);
1799 BUSYWAIT_MS(1000);
1279 i++;
1280 }
1281
1282 /* Timeout occurred */
1800 i++;
1801 }
1802
1803 /* Timeout occurred */
1283 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1284 "Timeout waiting for READY: status=0x%x", status);
1804 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1805 case SLI_INTF_IF_TYPE_0:
1806 err1 = ddi_get32(hba->pci_acc_handle,
1807 hba->sli.sli4.ERR1_reg_addr);
1808 err2 = ddi_get32(hba->pci_acc_handle,
1809 hba->sli.sli4.ERR2_reg_addr);
1810 break;
1285
1811
1812 default:
1813 err1 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1814 hba->sli.sli4.ERR1_reg_addr);
1815 err2 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1816 hba->sli.sli4.ERR2_reg_addr);
1817 break;
1818 }
1819
1820 if (status & SLI_STATUS_ERROR) {
1821 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1822 "Ready Timeout: Port Error: status=%x err1=%x err2=%x",
1823 status, err1, err2);
1824 } else {
1825 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1826 "Ready Timeout: status=%x err1=%x err2=%x",
1827 status, err1, err2);
1828 }
1829
1286 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1287
1830 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1831
1832 return (3);
1833
1834} /* emlxs_check_hdw_ready() */
1835
1836
1837static uint32_t
1838emlxs_sli4_read_status(emlxs_hba_t *hba)
1839{
1288#ifdef FMA_SUPPORT
1840#ifdef FMA_SUPPORT
1289 /* Access handle validation */
1290 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar1_acc_handle);
1841 emlxs_port_t *port = &PPORT;
1291#endif /* FMA_SUPPORT */
1842#endif /* FMA_SUPPORT */
1843 uint32_t status;
1292
1844
1293 /* Log a dump event - not supported */
1845 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1846 case SLI_INTF_IF_TYPE_2:
1847 status = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1848 hba->sli.sli4.STATUS_reg_addr);
1849#ifdef FMA_SUPPORT
1850 /* Access handle validation */
1851 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar0_acc_handle);
1852#endif /* FMA_SUPPORT */
1853 break;
1854 default:
1855 status = 0;
1856 break;
1857 }
1294
1858
1295 return (2);
1859 return (status);
1296
1860
1297} /* emlxs_check_hdw_ready() */
1861} /* emlxs_sli4_read_status() */
1298
1299
1300static uint32_t
1862
1863
1864static uint32_t
1301emlxs_check_bootstrap_ready(emlxs_hba_t *hba, uint32_t tmo)
1865emlxs_sli4_read_sema(emlxs_hba_t *hba)
1302{
1866{
1867#ifdef FMA_SUPPORT
1303 emlxs_port_t *port = &PPORT;
1868 emlxs_port_t *port = &PPORT;
1869#endif /* FMA_SUPPORT */
1304 uint32_t status;
1305
1870 uint32_t status;
1871
1872 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1873 case SLI_INTF_IF_TYPE_0:
1874 status = ddi_get32(hba->sli.sli4.bar1_acc_handle,
1875 hba->sli.sli4.MPUEPSemaphore_reg_addr);
1876#ifdef FMA_SUPPORT
1877 /* Access handle validation */
1878 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar1_acc_handle);
1879#endif /* FMA_SUPPORT */
1880 break;
1881
1882 case SLI_INTF_IF_TYPE_2:
1883 status = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1884 hba->sli.sli4.MPUEPSemaphore_reg_addr);
1885#ifdef FMA_SUPPORT
1886 /* Access handle validation */
1887 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar0_acc_handle);
1888#endif /* FMA_SUPPORT */
1889 break;
1890 default:
1891 status = 0;
1892 break;
1893 }
1894
1895 return (status);
1896
1897} /* emlxs_sli4_read_sema() */
1898
1899
1900static uint32_t
1901emlxs_sli4_read_mbdb(emlxs_hba_t *hba)
1902{
1903#ifdef FMA_SUPPORT
1904 emlxs_port_t *port = &PPORT;
1905#endif /* FMA_SUPPORT */
1906 uint32_t status;
1907
1908 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1909 case SLI_INTF_IF_TYPE_0:
1910 status = ddi_get32(hba->sli.sli4.bar2_acc_handle,
1911 hba->sli.sli4.MBDB_reg_addr);
1912
1913#ifdef FMA_SUPPORT
1914 /* Access handle validation */
1915 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar2_acc_handle);
1916#endif /* FMA_SUPPORT */
1917 break;
1918
1919 case SLI_INTF_IF_TYPE_2:
1920 status = ddi_get32(hba->sli.sli4.bar0_acc_handle,
1921 hba->sli.sli4.MBDB_reg_addr);
1922#ifdef FMA_SUPPORT
1923 /* Access handle validation */
1924 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar0_acc_handle);
1925#endif /* FMA_SUPPORT */
1926 break;
1927 default:
1928 status = 0;
1929 break;
1930 }
1931
1932 return (status);
1933
1934} /* emlxs_sli4_read_mbdb() */
1935
1936
1937static void
1938emlxs_sli4_write_mbdb(emlxs_hba_t *hba, uint32_t value)
1939{
1940 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1941 case SLI_INTF_IF_TYPE_0:
1942 ddi_put32(hba->sli.sli4.bar2_acc_handle,
1943 hba->sli.sli4.MBDB_reg_addr, value);
1944 break;
1945
1946 case SLI_INTF_IF_TYPE_2:
1947 ddi_put32(hba->sli.sli4.bar0_acc_handle,
1948 hba->sli.sli4.MBDB_reg_addr, value);
1949 break;
1950 }
1951
1952} /* emlxs_sli4_write_mbdb() */
1953
1954
1955static void
1956emlxs_sli4_write_cqdb(emlxs_hba_t *hba, uint32_t value)
1957{
1958 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1959 case SLI_INTF_IF_TYPE_0:
1960 ddi_put32(hba->sli.sli4.bar2_acc_handle,
1961 hba->sli.sli4.CQDB_reg_addr, value);
1962 break;
1963
1964 case SLI_INTF_IF_TYPE_2:
1965 ddi_put32(hba->sli.sli4.bar0_acc_handle,
1966 hba->sli.sli4.CQDB_reg_addr, value);
1967 break;
1968 }
1969
1970} /* emlxs_sli4_write_cqdb() */
1971
1972
1973static void
1974emlxs_sli4_write_rqdb(emlxs_hba_t *hba, uint32_t value)
1975{
1976 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1977 case SLI_INTF_IF_TYPE_0:
1978 ddi_put32(hba->sli.sli4.bar2_acc_handle,
1979 hba->sli.sli4.RQDB_reg_addr, value);
1980 break;
1981
1982 case SLI_INTF_IF_TYPE_2:
1983 ddi_put32(hba->sli.sli4.bar0_acc_handle,
1984 hba->sli.sli4.RQDB_reg_addr, value);
1985 break;
1986 }
1987
1988} /* emlxs_sli4_write_rqdb() */
1989
1990
1991static void
1992emlxs_sli4_write_mqdb(emlxs_hba_t *hba, uint32_t value)
1993{
1994 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
1995 case SLI_INTF_IF_TYPE_0:
1996 ddi_put32(hba->sli.sli4.bar2_acc_handle,
1997 hba->sli.sli4.MQDB_reg_addr, value);
1998 break;
1999
2000 case SLI_INTF_IF_TYPE_2:
2001 ddi_put32(hba->sli.sli4.bar0_acc_handle,
2002 hba->sli.sli4.MQDB_reg_addr, value);
2003 break;
2004 }
2005
2006} /* emlxs_sli4_write_mqdb() */
2007
2008
2009static void
2010emlxs_sli4_write_wqdb(emlxs_hba_t *hba, uint32_t value)
2011{
2012 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
2013 case SLI_INTF_IF_TYPE_0:
2014 ddi_put32(hba->sli.sli4.bar2_acc_handle,
2015 hba->sli.sli4.WQDB_reg_addr, value);
2016 break;
2017
2018 case SLI_INTF_IF_TYPE_2:
2019 ddi_put32(hba->sli.sli4.bar0_acc_handle,
2020 hba->sli.sli4.WQDB_reg_addr, value);
2021 break;
2022 }
2023
2024} /* emlxs_sli4_write_wqdb() */
2025
2026
2027static uint32_t
2028emlxs_check_bootstrap_ready(emlxs_hba_t *hba, uint32_t tmo)
2029{
2030 emlxs_port_t *port = &PPORT;
2031 uint32_t status = 0;
2032 uint32_t err1;
2033 uint32_t err2;
2034
1306 /* Wait for reset completion, tmo is in 10ms ticks */
1307 while (tmo) {
2035 /* Wait for reset completion, tmo is in 10ms ticks */
2036 while (tmo) {
1308 /* Check Semaphore register to see what the ARM state is */
1309 status = READ_BAR2_REG(hba, FC_MBDB_REG(hba));
2037 status = emlxs_sli4_read_mbdb(hba);
1310
1311 /* Check to see if any errors occurred during init */
1312 if (status & BMBX_READY) {
2038
2039 /* Check to see if any errors occurred during init */
2040 if (status & BMBX_READY) {
1313 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
2041 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
1314 "BMBX Ready: status=0x%x", status);
2042 "BMBX Ready: status=0x%x", status);
1315#ifdef FMA_SUPPORT
1316 /* Access handle validation */
1317 EMLXS_CHK_ACC_HANDLE(hba,
1318 hba->sli.sli4.bar2_acc_handle);
1319#endif /* FMA_SUPPORT */
2043
1320 return (tmo);
1321 }
1322
2044 return (tmo);
2045 }
2046
1323 DELAYMS(10);
2047 BUSYWAIT_MS(10);
1324 tmo--;
1325 }
1326
2048 tmo--;
2049 }
2050
2051 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
2052 case SLI_INTF_IF_TYPE_0:
2053 err1 = ddi_get32(hba->pci_acc_handle,
2054 hba->sli.sli4.ERR1_reg_addr);
2055 err2 = ddi_get32(hba->pci_acc_handle,
2056 hba->sli.sli4.ERR2_reg_addr);
2057 break;
2058
2059 default:
2060 err1 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
2061 hba->sli.sli4.ERR1_reg_addr);
2062 err2 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
2063 hba->sli.sli4.ERR2_reg_addr);
2064 break;
2065 }
2066
1327 /* Timeout occurred */
1328 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
2067 /* Timeout occurred */
2068 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1329 "Timeout waiting for BMailbox: status=0x%x", status);
2069 "Timeout waiting for BMailbox: status=%x err1=%x err2=%x",
2070 status, err1, err2);
1330
1331 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1332
2071
2072 EMLXS_STATE_CHANGE(hba, FC_ERROR);
2073
1333#ifdef FMA_SUPPORT
1334 /* Access handle validation */
1335 EMLXS_CHK_ACC_HANDLE(hba, hba->sli.sli4.bar2_acc_handle);
1336#endif /* FMA_SUPPORT */
1337
1338 /* Log a dump event - not supported */
1339
1340 return (0);
1341
1342} /* emlxs_check_bootstrap_ready() */
1343
1344
1345static uint32_t
1346emlxs_issue_bootstrap_mb(emlxs_hba_t *hba, uint32_t tmo)
1347{

--- 4 unchanged lines hidden (view full) ---

1352 /*
1353 * This routine assumes the bootstrap mbox is loaded
1354 * with the mailbox command to be executed.
1355 *
1356 * First, load the high 30 bits of bootstrap mailbox
1357 */
1358 addr30 = (uint32_t)((hba->sli.sli4.bootstrapmb.phys>>32) & 0xfffffffc);
1359 addr30 |= BMBX_ADDR_HI;
2074 return (0);
2075
2076} /* emlxs_check_bootstrap_ready() */
2077
2078
2079static uint32_t
2080emlxs_issue_bootstrap_mb(emlxs_hba_t *hba, uint32_t tmo)
2081{

--- 4 unchanged lines hidden (view full) ---

2086 /*
2087 * This routine assumes the bootstrap mbox is loaded
2088 * with the mailbox command to be executed.
2089 *
2090 * First, load the high 30 bits of bootstrap mailbox
2091 */
2092 addr30 = (uint32_t)((hba->sli.sli4.bootstrapmb.phys>>32) & 0xfffffffc);
2093 addr30 |= BMBX_ADDR_HI;
1360 WRITE_BAR2_REG(hba, FC_MBDB_REG(hba), addr30);
2094 emlxs_sli4_write_mbdb(hba, addr30);
1361
1362 tmo = emlxs_check_bootstrap_ready(hba, tmo);
1363 if (tmo == 0) {
1364 return (0);
1365 }
1366
1367 /* Load the low 30 bits of bootstrap mailbox */
1368 addr30 = (uint32_t)((hba->sli.sli4.bootstrapmb.phys>>2) & 0xfffffffc);
2095
2096 tmo = emlxs_check_bootstrap_ready(hba, tmo);
2097 if (tmo == 0) {
2098 return (0);
2099 }
2100
2101 /* Load the low 30 bits of bootstrap mailbox */
2102 addr30 = (uint32_t)((hba->sli.sli4.bootstrapmb.phys>>2) & 0xfffffffc);
1369 WRITE_BAR2_REG(hba, FC_MBDB_REG(hba), addr30);
2103 emlxs_sli4_write_mbdb(hba, addr30);
1370
1371 tmo = emlxs_check_bootstrap_ready(hba, tmo);
1372 if (tmo == 0) {
1373 return (0);
1374 }
1375
1376 iptr = (uint32_t *)hba->sli.sli4.bootstrapmb.virt;
1377
2104
2105 tmo = emlxs_check_bootstrap_ready(hba, tmo);
2106 if (tmo == 0) {
2107 return (0);
2108 }
2109
2110 iptr = (uint32_t *)hba->sli.sli4.bootstrapmb.virt;
2111
1378 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
2112 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
1379 "BootstrapMB: %p Completed %08x %08x %08x",
1380 hba->sli.sli4.bootstrapmb.virt,
1381 *iptr, *(iptr+1), *(iptr+2));
1382
1383 return (tmo);
1384
1385} /* emlxs_issue_bootstrap_mb() */
1386

--- 16 unchanged lines hidden (view full) ---

1403 }
1404
1405 /* NOTE: tmo is in 10ms ticks */
1406 tmo = emlxs_check_bootstrap_ready(hba, 3000);
1407 if (tmo == 0) {
1408 return (1);
1409 }
1410
2113 "BootstrapMB: %p Completed %08x %08x %08x",
2114 hba->sli.sli4.bootstrapmb.virt,
2115 *iptr, *(iptr+1), *(iptr+2));
2116
2117 return (tmo);
2118
2119} /* emlxs_issue_bootstrap_mb() */
2120

--- 16 unchanged lines hidden (view full) ---

2137 }
2138
2139 /* NOTE: tmo is in 10ms ticks */
2140 tmo = emlxs_check_bootstrap_ready(hba, 3000);
2141 if (tmo == 0) {
2142 return (1);
2143 }
2144
2145 /* Issue FW_INITIALIZE command */
2146
1411 /* Special words to initialize bootstrap mbox MUST be little endian */
1412 iptr = (uint32_t *)hba->sli.sli4.bootstrapmb.virt;
2147 /* Special words to initialize bootstrap mbox MUST be little endian */
2148 iptr = (uint32_t *)hba->sli.sli4.bootstrapmb.virt;
1413 *iptr++ = LE_SWAP32(MQE_SPECIAL_WORD0);
1414 *iptr = LE_SWAP32(MQE_SPECIAL_WORD1);
2149 *iptr = LE_SWAP32(FW_INITIALIZE_WORD0);
2150 *(iptr+1) = LE_SWAP32(FW_INITIALIZE_WORD1);
1415
1416 EMLXS_MPDATA_SYNC(hba->sli.sli4.bootstrapmb.dma_handle, 0,
1417 MAILBOX_CMD_BSIZE, DDI_DMA_SYNC_FORDEV);
1418
2151
2152 EMLXS_MPDATA_SYNC(hba->sli.sli4.bootstrapmb.dma_handle, 0,
2153 MAILBOX_CMD_BSIZE, DDI_DMA_SYNC_FORDEV);
2154
1419emlxs_data_dump(port, "EndianIN", (uint32_t *)iptr, 6, 0);
2155 emlxs_data_dump(port, "FW_INIT", (uint32_t *)iptr, 6, 0);
1420 if (!emlxs_issue_bootstrap_mb(hba, tmo)) {
1421 return (1);
1422 }
2156 if (!emlxs_issue_bootstrap_mb(hba, tmo)) {
2157 return (1);
2158 }
1423 EMLXS_MPDATA_SYNC(hba->sli.sli4.bootstrapmb.dma_handle, 0,
1424 MAILBOX_CMD_BSIZE, DDI_DMA_SYNC_FORKERNEL);
1425emlxs_data_dump(port, "EndianOUT", (uint32_t *)iptr, 6, 0);
1426
1427#ifdef FMA_SUPPORT
1428 if (emlxs_fm_check_dma_handle(hba, hba->sli.sli4.bootstrapmb.dma_handle)
1429 != DDI_FM_OK) {
1430 EMLXS_MSGF(EMLXS_CONTEXT,
1431 &emlxs_invalid_dma_handle_msg,
2159
2160#ifdef FMA_SUPPORT
2161 if (emlxs_fm_check_dma_handle(hba, hba->sli.sli4.bootstrapmb.dma_handle)
2162 != DDI_FM_OK) {
2163 EMLXS_MSGF(EMLXS_CONTEXT,
2164 &emlxs_invalid_dma_handle_msg,
1432 "emlxs_init_bootstrap_mb: hdl=%p",
2165 "init_bootstrap_mb: hdl=%p",
1433 hba->sli.sli4.bootstrapmb.dma_handle);
1434 return (1);
1435 }
1436#endif
1437 hba->flag |= FC_BOOTSTRAPMB_INIT;
1438 return (0);
1439
1440} /* emlxs_init_bootstrap_mb() */
1441
1442
2166 hba->sli.sli4.bootstrapmb.dma_handle);
2167 return (1);
2168 }
2169#endif
2170 hba->flag |= FC_BOOTSTRAPMB_INIT;
2171 return (0);
2172
2173} /* emlxs_init_bootstrap_mb() */
2174
2175
2176
2177
1443static uint32_t
1444emlxs_sli4_hba_init(emlxs_hba_t *hba)
1445{
1446 int rc;
1447 uint16_t i;
1448 emlxs_port_t *vport;
1449 emlxs_config_t *cfg = &CFG;
1450 CHANNEL *cp;
2178static uint32_t
2179emlxs_sli4_hba_init(emlxs_hba_t *hba)
2180{
2181 int rc;
2182 uint16_t i;
2183 emlxs_port_t *vport;
2184 emlxs_config_t *cfg = &CFG;
2185 CHANNEL *cp;
2186 VPIobj_t *vpip;
1451
1452 /* Restart the adapter */
1453 if (emlxs_sli4_hba_reset(hba, 1, 0, 0)) {
1454 return (1);
1455 }
1456
1457 for (i = 0; i < hba->chan_count; i++) {
1458 cp = &hba->chan[i];
1459 cp->iopath = (void *)&hba->sli.sli4.wq[i];
1460 }
1461
1462 /* Initialize all the port objects */
2187
2188 /* Restart the adapter */
2189 if (emlxs_sli4_hba_reset(hba, 1, 0, 0)) {
2190 return (1);
2191 }
2192
2193 for (i = 0; i < hba->chan_count; i++) {
2194 cp = &hba->chan[i];
2195 cp->iopath = (void *)&hba->sli.sli4.wq[i];
2196 }
2197
2198 /* Initialize all the port objects */
1463 hba->vpi_base = 0;
1464 hba->vpi_max = 0;
1465 for (i = 0; i < MAX_VPORTS; i++) {
1466 vport = &VPORT(i);
1467 vport->hba = hba;
1468 vport->vpi = i;
1469
2199 hba->vpi_max = 0;
2200 for (i = 0; i < MAX_VPORTS; i++) {
2201 vport = &VPORT(i);
2202 vport->hba = hba;
2203 vport->vpi = i;
2204
1470 vport->VPIobj.index = i;
1471 vport->VPIobj.VPI = i;
1472 vport->VPIobj.port = vport;
2205 vpip = &vport->VPIobj;
2206 vpip->index = i;
2207 vpip->VPI = i;
2208 vpip->port = vport;
2209 vpip->state = VPI_STATE_OFFLINE;
2210 vport->vpip = vpip;
1473 }
1474
1475 /* Set the max node count */
1476 if (hba->max_nodes == 0) {
1477 if (cfg[CFG_NUM_NODES].current > 0) {
1478 hba->max_nodes = cfg[CFG_NUM_NODES].current;
1479 } else {
1480 hba->max_nodes = 4096;

--- 4 unchanged lines hidden (view full) ---

1485 if (rc) {
1486 return (rc);
1487 }
1488
1489 hba->sli.sli4.cfgFCOE.FCMap[0] = FCOE_FCF_MAP0;
1490 hba->sli.sli4.cfgFCOE.FCMap[1] = FCOE_FCF_MAP1;
1491 hba->sli.sli4.cfgFCOE.FCMap[2] = FCOE_FCF_MAP2;
1492
2211 }
2212
2213 /* Set the max node count */
2214 if (hba->max_nodes == 0) {
2215 if (cfg[CFG_NUM_NODES].current > 0) {
2216 hba->max_nodes = cfg[CFG_NUM_NODES].current;
2217 } else {
2218 hba->max_nodes = 4096;

--- 4 unchanged lines hidden (view full) ---

2223 if (rc) {
2224 return (rc);
2225 }
2226
2227 hba->sli.sli4.cfgFCOE.FCMap[0] = FCOE_FCF_MAP0;
2228 hba->sli.sli4.cfgFCOE.FCMap[1] = FCOE_FCF_MAP1;
2229 hba->sli.sli4.cfgFCOE.FCMap[2] = FCOE_FCF_MAP2;
2230
1493 /* Cache the UE MASK registers value for UE error detection */
1494 hba->sli.sli4.ue_mask_lo = ddi_get32(hba->pci_acc_handle,
1495 (uint32_t *)(hba->pci_addr + PCICFG_UE_MASK_LO_OFFSET));
1496 hba->sli.sli4.ue_mask_hi = ddi_get32(hba->pci_acc_handle,
1497 (uint32_t *)(hba->pci_addr + PCICFG_UE_MASK_HI_OFFSET));
2231 if ((hba->sli_intf & SLI_INTF_IF_TYPE_MASK) == SLI_INTF_IF_TYPE_0) {
2232 /* Cache the UE MASK registers value for UE error detection */
2233 hba->sli.sli4.ue_mask_lo = ddi_get32(hba->pci_acc_handle,
2234 (uint32_t *)(hba->pci_addr + PCICFG_UE_MASK_LO_OFFSET));
2235 hba->sli.sli4.ue_mask_hi = ddi_get32(hba->pci_acc_handle,
2236 (uint32_t *)(hba->pci_addr + PCICFG_UE_MASK_HI_OFFSET));
2237 }
1498
1499 return (0);
1500
1501} /* emlxs_sli4_hba_init() */
1502
1503
1504/*ARGSUSED*/
1505static uint32_t
1506emlxs_sli4_hba_reset(emlxs_hba_t *hba, uint32_t restart, uint32_t skip_post,
1507 uint32_t quiesce)
1508{
1509 emlxs_port_t *port = &PPORT;
1510 emlxs_port_t *vport;
1511 CHANNEL *cp;
1512 emlxs_config_t *cfg = &CFG;
1513 MAILBOXQ mboxq;
2238
2239 return (0);
2240
2241} /* emlxs_sli4_hba_init() */
2242
2243
2244/*ARGSUSED*/
2245static uint32_t
2246emlxs_sli4_hba_reset(emlxs_hba_t *hba, uint32_t restart, uint32_t skip_post,
2247 uint32_t quiesce)
2248{
2249 emlxs_port_t *port = &PPORT;
2250 emlxs_port_t *vport;
2251 CHANNEL *cp;
2252 emlxs_config_t *cfg = &CFG;
2253 MAILBOXQ mboxq;
2254 uint32_t value;
1514 uint32_t i;
1515 uint32_t rc;
1516 uint16_t channelno;
2255 uint32_t i;
2256 uint32_t rc;
2257 uint16_t channelno;
2258 uint32_t status;
2259 uint32_t err1;
2260 uint32_t err2;
2261 uint8_t generate_event = 0;
1517
1518 if (!cfg[CFG_RESET_ENABLE].current) {
1519 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1520 "Adapter reset disabled.");
1521 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1522
1523 return (1);
1524 }
1525
2262
2263 if (!cfg[CFG_RESET_ENABLE].current) {
2264 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
2265 "Adapter reset disabled.");
2266 EMLXS_STATE_CHANGE(hba, FC_ERROR);
2267
2268 return (1);
2269 }
2270
1526 if (quiesce == 0) {
1527 emlxs_sli4_hba_kill(hba);
2271 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
2272 case SLI_INTF_IF_TYPE_0:
2273 if (quiesce == 0) {
2274 emlxs_sli4_hba_kill(hba);
1528
2275
1529 /*
1530 * Initalize Hardware that will be used to bring
1531 * SLI4 online.
1532 */
1533 rc = emlxs_init_bootstrap_mb(hba);
1534 if (rc) {
1535 return (rc);
2276 /*
2277 * Initalize Hardware that will be used to bring
2278 * SLI4 online.
2279 */
2280 rc = emlxs_init_bootstrap_mb(hba);
2281 if (rc) {
2282 return (rc);
2283 }
1536 }
2284 }
1537 }
1538
2285
1539 bzero((void *)&mboxq, sizeof (MAILBOXQ));
1540 emlxs_mb_resetport(hba, &mboxq);
2286 bzero((void *)&mboxq, sizeof (MAILBOXQ));
2287 emlxs_mb_resetport(hba, &mboxq);
1541
2288
1542 if (quiesce == 0) {
1543 if (emlxs_sli4_issue_mbox_cmd(hba, &mboxq,
1544 MBX_POLL, 0) != MBX_SUCCESS) {
1545 /* Timeout occurred */
1546 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_reset_failed_msg,
1547 "Timeout: RESET");
1548 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1549 /* Log a dump event - not supported */
1550 return (1);
2289 if (quiesce == 0) {
2290 if (emlxs_sli4_issue_mbox_cmd(hba, &mboxq,
2291 MBX_POLL, 0) != MBX_SUCCESS) {
2292 /* Timeout occurred */
2293 EMLXS_MSGF(EMLXS_CONTEXT,
2294 &emlxs_reset_failed_msg,
2295 "Timeout: RESET");
2296 EMLXS_STATE_CHANGE(hba, FC_ERROR);
2297 /* Log a dump event - not supported */
2298 return (1);
2299 }
2300 } else {
2301 if (emlxs_sli4_issue_mbox_cmd4quiesce(hba, &mboxq,
2302 MBX_POLL, 0) != MBX_SUCCESS) {
2303 EMLXS_STATE_CHANGE(hba, FC_ERROR);
2304 /* Log a dump event - not supported */
2305 return (1);
2306 }
1551 }
2307 }
1552 } else {
1553 if (emlxs_sli4_issue_mbox_cmd4quiesce(hba, &mboxq,
1554 MBX_POLL, 0) != MBX_SUCCESS) {
1555 EMLXS_STATE_CHANGE(hba, FC_ERROR);
1556 /* Log a dump event - not supported */
2308 emlxs_data_dump(port, "resetPort", (uint32_t *)&mboxq, 12, 0);
2309 break;
2310
2311 case SLI_INTF_IF_TYPE_2:
2312 if (quiesce == 0) {
2313 emlxs_sli4_hba_kill(hba);
2314 }
2315
2316 rc = emlxs_check_hdw_ready(hba);
2317 if (rc > 1) {
2318 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
2319 "Adapter not ready for reset.");
1557 return (1);
1558 }
2320 return (1);
2321 }
2322
2323 if (rc == 1) {
2324 err1 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
2325 hba->sli.sli4.ERR1_reg_addr);
2326 err2 = ddi_get32(hba->sli.sli4.bar0_acc_handle,
2327 hba->sli.sli4.ERR2_reg_addr);
2328
2329 /* Don't generate an event if dump was forced */
2330 if ((err1 != 0x2) || (err2 != 0x2)) {
2331 generate_event = 1;
2332 }
2333 }
2334
2335 /* Reset the port now */
2336
2337 mutex_enter(&EMLXS_PORT_LOCK);
2338 value = SLI_CNTL_INIT_PORT;
2339
2340 ddi_put32(hba->sli.sli4.bar0_acc_handle,
2341 hba->sli.sli4.CNTL_reg_addr, value);
2342 mutex_exit(&EMLXS_PORT_LOCK);
2343
2344 break;
1559 }
2345 }
1560emlxs_data_dump(port, "resetPort", (uint32_t *)&mboxq, 12, 0);
1561
1562 /* Reset the hba structure */
1563 hba->flag &= FC_RESET_MASK;
1564
1565 for (channelno = 0; channelno < hba->chan_count; channelno++) {
1566 cp = &hba->chan[channelno];
1567 cp->hba = hba;
1568 cp->channelno = channelno;

--- 32 unchanged lines hidden (view full) ---

1601 vport->ub_count = EMLXS_UB_TOKEN_OFFSET;
1602 }
1603 }
1604
1605 if (emlxs_check_hdw_ready(hba)) {
1606 return (1);
1607 }
1608
2346
2347 /* Reset the hba structure */
2348 hba->flag &= FC_RESET_MASK;
2349
2350 for (channelno = 0; channelno < hba->chan_count; channelno++) {
2351 cp = &hba->chan[channelno];
2352 cp->hba = hba;
2353 cp->channelno = channelno;

--- 32 unchanged lines hidden (view full) ---

2386 vport->ub_count = EMLXS_UB_TOKEN_OFFSET;
2387 }
2388 }
2389
2390 if (emlxs_check_hdw_ready(hba)) {
2391 return (1);
2392 }
2393
2394 if (generate_event) {
2395 status = emlxs_sli4_read_status(hba);
2396 if (status & SLI_STATUS_DUMP_IMAGE_PRESENT) {
2397 emlxs_log_dump_event(port, NULL, 0);
2398 }
2399 }
2400
1609 return (0);
1610
1611} /* emlxs_sli4_hba_reset */
1612
1613
1614#define SGL_CMD 0
1615#define SGL_RESP 1
1616#define SGL_DATA 2
1617#define SGL_LAST 0x80
1618
1619/*ARGSUSED*/
2401 return (0);
2402
2403} /* emlxs_sli4_hba_reset */
2404
2405
2406#define SGL_CMD 0
2407#define SGL_RESP 1
2408#define SGL_DATA 2
2409#define SGL_LAST 0x80
2410
2411/*ARGSUSED*/
1620ULP_SGE64 *
1621emlxs_pkt_to_sgl(emlxs_port_t *port, ULP_SGE64 *sge, fc_packet_t *pkt,
2412static ULP_SGE64 *
2413emlxs_pkt_to_sgl(emlxs_port_t *port, fc_packet_t *pkt, ULP_SGE64 *sge,
1622 uint32_t sgl_type, uint32_t *pcnt)
1623{
1624#ifdef DEBUG_SGE
1625 emlxs_hba_t *hba = HBA;
2414 uint32_t sgl_type, uint32_t *pcnt)
2415{
2416#ifdef DEBUG_SGE
2417 emlxs_hba_t *hba = HBA;
1626#endif
2418#endif /* DEBUG_SGE */
1627 ddi_dma_cookie_t *cp;
1628 uint_t i;
1629 uint_t last;
1630 int32_t size;
1631 int32_t sge_size;
1632 uint64_t sge_addr;
1633 int32_t len;
1634 uint32_t cnt;

--- 18 unchanged lines hidden (view full) ---

1653 break;
1654
1655
1656 case SGL_DATA:
1657 cp = pkt->pkt_data_cookie;
1658 cookie_cnt = pkt->pkt_data_cookie_cnt;
1659 size = (int32_t)pkt->pkt_datalen;
1660 break;
2419 ddi_dma_cookie_t *cp;
2420 uint_t i;
2421 uint_t last;
2422 int32_t size;
2423 int32_t sge_size;
2424 uint64_t sge_addr;
2425 int32_t len;
2426 uint32_t cnt;

--- 18 unchanged lines hidden (view full) ---

2445 break;
2446
2447
2448 case SGL_DATA:
2449 cp = pkt->pkt_data_cookie;
2450 cookie_cnt = pkt->pkt_data_cookie_cnt;
2451 size = (int32_t)pkt->pkt_datalen;
2452 break;
2453
2454 default:
2455 return (NULL);
1661 }
1662
1663#else
1664 switch (sgl_type) {
1665 case SGL_CMD:
1666 cp = &pkt->pkt_cmd_cookie;
1667 cookie_cnt = 1;
1668 size = (int32_t)pkt->pkt_cmdlen;

--- 6 unchanged lines hidden (view full) ---

1675 break;
1676
1677
1678 case SGL_DATA:
1679 cp = &pkt->pkt_data_cookie;
1680 cookie_cnt = 1;
1681 size = (int32_t)pkt->pkt_datalen;
1682 break;
2456 }
2457
2458#else
2459 switch (sgl_type) {
2460 case SGL_CMD:
2461 cp = &pkt->pkt_cmd_cookie;
2462 cookie_cnt = 1;
2463 size = (int32_t)pkt->pkt_cmdlen;

--- 6 unchanged lines hidden (view full) ---

2470 break;
2471
2472
2473 case SGL_DATA:
2474 cp = &pkt->pkt_data_cookie;
2475 cookie_cnt = 1;
2476 size = (int32_t)pkt->pkt_datalen;
2477 break;
2478
2479 default:
2480 return (NULL);
1683 }
1684#endif /* >= EMLXS_MODREV3 */
1685
1686 stage_sge.offset = 0;
2481 }
2482#endif /* >= EMLXS_MODREV3 */
2483
2484 stage_sge.offset = 0;
1687 stage_sge.reserved = 0;
2485 stage_sge.type = 0;
1688 stage_sge.last = 0;
1689 cnt = 0;
1690 for (i = 0; i < cookie_cnt && size > 0; i++, cp++) {
1691
1692 sge_size = cp->dmac_size;
1693 sge_addr = cp->dmac_laddress;
1694 while (sge_size && size) {
1695 if (cnt) {

--- 11 unchanged lines hidden (view full) ---

1707 PADDR_LO(sge_addr);
1708 stage_sge.length = len;
1709 if (sgl_type == SGL_DATA) {
1710 stage_sge.offset = cnt;
1711 }
1712#ifdef DEBUG_SGE
1713 emlxs_data_dump(port, "SGE", (uint32_t *)&stage_sge,
1714 4, 0);
2486 stage_sge.last = 0;
2487 cnt = 0;
2488 for (i = 0; i < cookie_cnt && size > 0; i++, cp++) {
2489
2490 sge_size = cp->dmac_size;
2491 sge_addr = cp->dmac_laddress;
2492 while (sge_size && size) {
2493 if (cnt) {

--- 11 unchanged lines hidden (view full) ---

2505 PADDR_LO(sge_addr);
2506 stage_sge.length = len;
2507 if (sgl_type == SGL_DATA) {
2508 stage_sge.offset = cnt;
2509 }
2510#ifdef DEBUG_SGE
2511 emlxs_data_dump(port, "SGE", (uint32_t *)&stage_sge,
2512 4, 0);
1715#endif
2513#endif /* DEBUG_SGE */
1716 sge_addr += len;
1717 sge_size -= len;
1718
1719 cnt += len;
1720 size -= len;
1721 }
1722 }
1723
1724 if (last) {
1725 stage_sge.last = 1;
1726 }
1727 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
1728 sizeof (ULP_SGE64));
1729
1730 sge++;
1731
2514 sge_addr += len;
2515 sge_size -= len;
2516
2517 cnt += len;
2518 size -= len;
2519 }
2520 }
2521
2522 if (last) {
2523 stage_sge.last = 1;
2524 }
2525 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
2526 sizeof (ULP_SGE64));
2527
2528 sge++;
2529
1732 *pcnt = cnt;
2530 if (pcnt) {
2531 *pcnt = cnt;
2532 }
1733 return (sge);
1734
1735} /* emlxs_pkt_to_sgl */
1736
1737
1738/*ARGSUSED*/
1739uint32_t
1740emlxs_sli4_bde_setup(emlxs_port_t *port, emlxs_buf_t *sbp)
1741{
2533 return (sge);
2534
2535} /* emlxs_pkt_to_sgl */
2536
2537
2538/*ARGSUSED*/
2539uint32_t
2540emlxs_sli4_bde_setup(emlxs_port_t *port, emlxs_buf_t *sbp)
2541{
2542 emlxs_hba_t *hba = HBA;
1742 fc_packet_t *pkt;
1743 XRIobj_t *xrip;
1744 ULP_SGE64 *sge;
1745 emlxs_wqe_t *wqe;
1746 IOCBQ *iocbq;
1747 ddi_dma_cookie_t *cp_cmd;
2543 fc_packet_t *pkt;
2544 XRIobj_t *xrip;
2545 ULP_SGE64 *sge;
2546 emlxs_wqe_t *wqe;
2547 IOCBQ *iocbq;
2548 ddi_dma_cookie_t *cp_cmd;
2549 ddi_dma_cookie_t *cp_data;
2550 uint64_t sge_addr;
1748 uint32_t cmd_cnt;
1749 uint32_t resp_cnt;
2551 uint32_t cmd_cnt;
2552 uint32_t resp_cnt;
1750 uint32_t cnt;
1751
1752 iocbq = (IOCBQ *) &sbp->iocbq;
1753 wqe = &iocbq->wqe;
1754 pkt = PRIV2PKT(sbp);
1755 xrip = sbp->xrip;
1756 sge = xrip->SGList.virt;
1757
1758#if (EMLXS_MODREV >= EMLXS_MODREV3)
1759 cp_cmd = pkt->pkt_cmd_cookie;
2553
2554 iocbq = (IOCBQ *) &sbp->iocbq;
2555 wqe = &iocbq->wqe;
2556 pkt = PRIV2PKT(sbp);
2557 xrip = sbp->xrip;
2558 sge = xrip->SGList.virt;
2559
2560#if (EMLXS_MODREV >= EMLXS_MODREV3)
2561 cp_cmd = pkt->pkt_cmd_cookie;
2562 cp_data = pkt->pkt_data_cookie;
1760#else
1761 cp_cmd = &pkt->pkt_cmd_cookie;
2563#else
2564 cp_cmd = &pkt->pkt_cmd_cookie;
2565 cp_data = &pkt->pkt_data_cookie;
1762#endif /* >= EMLXS_MODREV3 */
1763
1764 iocbq = &sbp->iocbq;
1765 if (iocbq->flag & IOCB_FCP_CMD) {
1766
1767 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
1768 return (1);
1769 }
1770
1771 /* CMD payload */
2566#endif /* >= EMLXS_MODREV3 */
2567
2568 iocbq = &sbp->iocbq;
2569 if (iocbq->flag & IOCB_FCP_CMD) {
2570
2571 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
2572 return (1);
2573 }
2574
2575 /* CMD payload */
1772 sge = emlxs_pkt_to_sgl(port, sge, pkt, SGL_CMD, &cmd_cnt);
2576 sge = emlxs_pkt_to_sgl(port, pkt, sge, SGL_CMD, &cmd_cnt);
2577 if (! sge) {
2578 return (1);
2579 }
1773
1774 /* DATA payload */
1775 if (pkt->pkt_datalen != 0) {
1776 /* RSP payload */
2580
2581 /* DATA payload */
2582 if (pkt->pkt_datalen != 0) {
2583 /* RSP payload */
1777 sge = emlxs_pkt_to_sgl(port, sge, pkt,
2584 sge = emlxs_pkt_to_sgl(port, pkt, sge,
1778 SGL_RESP, &resp_cnt);
2585 SGL_RESP, &resp_cnt);
2586 if (! sge) {
2587 return (1);
2588 }
1779
2589
1780 /* Data portion */
1781 sge = emlxs_pkt_to_sgl(port, sge, pkt,
1782 SGL_DATA | SGL_LAST, &cnt);
2590 /* Data payload */
2591 sge = emlxs_pkt_to_sgl(port, pkt, sge,
2592 SGL_DATA | SGL_LAST, 0);
2593 if (! sge) {
2594 return (1);
2595 }
2596sgl_done:
2597 if (hba->sli.sli4.flag & EMLXS_SLI4_PHON) {
2598 sge_addr = cp_data->dmac_laddress;
2599 wqe->FirstData.addrHigh = PADDR_HI(sge_addr);
2600 wqe->FirstData.addrLow = PADDR_LO(sge_addr);
2601 wqe->FirstData.tus.f.bdeSize =
2602 cp_data->dmac_size;
2603 }
1783 } else {
1784 /* RSP payload */
2604 } else {
2605 /* RSP payload */
1785 sge = emlxs_pkt_to_sgl(port, sge, pkt,
2606 sge = emlxs_pkt_to_sgl(port, pkt, sge,
1786 SGL_RESP | SGL_LAST, &resp_cnt);
2607 SGL_RESP | SGL_LAST, &resp_cnt);
2608 if (! sge) {
2609 return (1);
2610 }
1787 }
1788
1789 wqe->un.FcpCmd.Payload.addrHigh =
1790 PADDR_HI(cp_cmd->dmac_laddress);
1791 wqe->un.FcpCmd.Payload.addrLow =
1792 PADDR_LO(cp_cmd->dmac_laddress);
1793 wqe->un.FcpCmd.Payload.tus.f.bdeSize = cmd_cnt;
1794 wqe->un.FcpCmd.PayloadLength = cmd_cnt + resp_cnt;
1795
1796 } else {
1797
1798 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
1799 /* CMD payload */
2611 }
2612
2613 wqe->un.FcpCmd.Payload.addrHigh =
2614 PADDR_HI(cp_cmd->dmac_laddress);
2615 wqe->un.FcpCmd.Payload.addrLow =
2616 PADDR_LO(cp_cmd->dmac_laddress);
2617 wqe->un.FcpCmd.Payload.tus.f.bdeSize = cmd_cnt;
2618 wqe->un.FcpCmd.PayloadLength = cmd_cnt + resp_cnt;
2619
2620 } else {
2621
2622 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
2623 /* CMD payload */
1800 sge = emlxs_pkt_to_sgl(port, sge, pkt,
2624 sge = emlxs_pkt_to_sgl(port, pkt, sge,
1801 SGL_CMD | SGL_LAST, &cmd_cnt);
2625 SGL_CMD | SGL_LAST, &cmd_cnt);
2626 if (! sge) {
2627 return (1);
2628 }
1802 } else {
1803 /* CMD payload */
2629 } else {
2630 /* CMD payload */
1804 sge = emlxs_pkt_to_sgl(port, sge, pkt,
2631 sge = emlxs_pkt_to_sgl(port, pkt, sge,
1805 SGL_CMD, &cmd_cnt);
2632 SGL_CMD, &cmd_cnt);
2633 if (! sge) {
2634 return (1);
2635 }
1806
1807 /* RSP payload */
2636
2637 /* RSP payload */
1808 sge = emlxs_pkt_to_sgl(port, sge, pkt,
2638 sge = emlxs_pkt_to_sgl(port, pkt, sge,
1809 SGL_RESP | SGL_LAST, &resp_cnt);
2639 SGL_RESP | SGL_LAST, &resp_cnt);
2640 if (! sge) {
2641 return (1);
2642 }
1810 wqe->un.GenReq.PayloadLength = cmd_cnt;
1811 }
1812
1813 wqe->un.GenReq.Payload.addrHigh =
1814 PADDR_HI(cp_cmd->dmac_laddress);
1815 wqe->un.GenReq.Payload.addrLow =
1816 PADDR_LO(cp_cmd->dmac_laddress);
1817 wqe->un.GenReq.Payload.tus.f.bdeSize = cmd_cnt;
1818 }
1819 return (0);
1820} /* emlxs_sli4_bde_setup */
1821
1822
1823
1824
2643 wqe->un.GenReq.PayloadLength = cmd_cnt;
2644 }
2645
2646 wqe->un.GenReq.Payload.addrHigh =
2647 PADDR_HI(cp_cmd->dmac_laddress);
2648 wqe->un.GenReq.Payload.addrLow =
2649 PADDR_LO(cp_cmd->dmac_laddress);
2650 wqe->un.GenReq.Payload.tus.f.bdeSize = cmd_cnt;
2651 }
2652 return (0);
2653} /* emlxs_sli4_bde_setup */
2654
2655
2656
2657
2658#ifdef SFCT_SUPPORT
2659/*ARGSUSED*/
2660static uint32_t
2661emlxs_sli4_fct_bde_setup(emlxs_port_t *port, emlxs_buf_t *sbp)
2662{
2663 emlxs_hba_t *hba = HBA;
2664 emlxs_wqe_t *wqe;
2665 ULP_SGE64 stage_sge;
2666 ULP_SGE64 *sge;
2667 IOCB *iocb;
2668 IOCBQ *iocbq;
2669 MATCHMAP *mp;
2670 MATCHMAP *fct_mp;
2671 XRIobj_t *xrip;
2672 uint64_t sge_addr;
2673 uint32_t sge_size;
2674 uint32_t cnt;
2675 uint32_t len;
2676 uint32_t size;
2677 uint32_t *xrdy_vaddr;
2678 stmf_data_buf_t *dbuf;
2679
2680 iocbq = &sbp->iocbq;
2681 iocb = &iocbq->iocb;
2682 wqe = &iocbq->wqe;
2683 xrip = sbp->xrip;
2684
2685 if (!sbp->fct_buf) {
2686 return (0);
2687 }
2688
2689 size = sbp->fct_buf->db_data_size;
2690
2691 /*
2692 * The hardware will automaticlly round up
2693 * to multiple of 4.
2694 *
2695 * if (size & 3) {
2696 * size = (size + 3) & 0xfffffffc;
2697 * }
2698 */
2699 fct_mp = (MATCHMAP *)sbp->fct_buf->db_port_private;
2700
2701 if (sbp->fct_buf->db_sglist_length != 1) {
2702 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fct_error_msg,
2703 "fct_bde_setup: Only 1 sglist entry supported: %d",
2704 sbp->fct_buf->db_sglist_length);
2705 return (1);
2706 }
2707
2708 sge = xrip->SGList.virt;
2709
2710 if (iocb->ULPCOMMAND == CMD_FCP_TRECEIVE64_CX) {
2711
2712 mp = emlxs_mem_buf_alloc(hba, EMLXS_XFER_RDY_SIZE);
2713 if (!mp || !mp->virt || !mp->phys) {
2714 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fct_error_msg,
2715 "fct_bde_setup: Cannot allocate XRDY memory");
2716 return (1);
2717 }
2718 /* Save the MATCHMAP info to free this memory later */
2719 iocbq->bp = mp;
2720
2721 /* Point to XRDY payload */
2722 xrdy_vaddr = (uint32_t *)(mp->virt);
2723
2724 /* Fill in burstsize in payload */
2725 *xrdy_vaddr++ = 0;
2726 *xrdy_vaddr++ = LE_SWAP32(size);
2727 *xrdy_vaddr = 0;
2728
2729 /* First 2 SGEs are XRDY and SKIP */
2730 stage_sge.addrHigh = PADDR_HI(mp->phys);
2731 stage_sge.addrLow = PADDR_LO(mp->phys);
2732 stage_sge.length = EMLXS_XFER_RDY_SIZE;
2733 stage_sge.offset = 0;
2734 stage_sge.type = 0;
2735 stage_sge.last = 0;
2736
2737 /* Words 0-3 */
2738 wqe->un.FcpCmd.Payload.addrHigh = stage_sge.addrHigh;
2739 wqe->un.FcpCmd.Payload.addrLow = stage_sge.addrLow;
2740 wqe->un.FcpCmd.Payload.tus.f.bdeSize = EMLXS_XFER_RDY_SIZE;
2741 wqe->un.FcpCmd.PayloadLength = EMLXS_XFER_RDY_SIZE;
2742
2743 } else { /* CMD_FCP_TSEND64_CX */
2744 /* First 2 SGEs are SKIP */
2745 stage_sge.addrHigh = 0;
2746 stage_sge.addrLow = 0;
2747 stage_sge.length = 0;
2748 stage_sge.offset = 0;
2749 stage_sge.type = EMLXS_SGE_TYPE_SKIP;
2750 stage_sge.last = 0;
2751
2752 /* Words 0-3 */
2753 wqe->un.FcpCmd.Payload.addrHigh = PADDR_HI(fct_mp->phys);
2754 wqe->un.FcpCmd.Payload.addrLow = PADDR_LO(fct_mp->phys);
2755
2756 /* The BDE should match the contents of the first SGE payload */
2757 len = MIN(EMLXS_MAX_SGE_SIZE, size);
2758 wqe->un.FcpCmd.Payload.tus.f.bdeSize = len;
2759
2760 /* The PayloadLength should be set to 0 for TSEND64. */
2761 wqe->un.FcpCmd.PayloadLength = 0;
2762 }
2763
2764 dbuf = sbp->fct_buf;
2765 /*
2766 * TotalTransferCount equals to Relative Offset field (Word 4)
2767 * in both TSEND64 and TRECEIVE64 WQE.
2768 */
2769 wqe->un.FcpCmd.TotalTransferCount = dbuf->db_relative_offset;
2770
2771 /* Copy staged SGE into SGL */
2772 BE_SWAP32_BCOPY((uint8_t *)&stage_sge,
2773 (uint8_t *)sge, sizeof (ULP_SGE64));
2774 sge++;
2775
2776 stage_sge.addrHigh = 0;
2777 stage_sge.addrLow = 0;
2778 stage_sge.length = 0;
2779 stage_sge.offset = 0;
2780 stage_sge.type = EMLXS_SGE_TYPE_SKIP;
2781 stage_sge.last = 0;
2782
2783 /* Copy staged SGE into SGL */
2784 BE_SWAP32_BCOPY((uint8_t *)&stage_sge,
2785 (uint8_t *)sge, sizeof (ULP_SGE64));
2786 sge++;
2787
2788 sge_size = size;
2789 sge_addr = fct_mp->phys;
2790 cnt = 0;
2791
2792 /* Build SGEs */
2793 while (sge_size) {
2794 if (cnt) {
2795 /* Copy staged SGE before we build next one */
2796 BE_SWAP32_BCOPY((uint8_t *)&stage_sge,
2797 (uint8_t *)sge, sizeof (ULP_SGE64));
2798 sge++;
2799 }
2800
2801 len = MIN(EMLXS_MAX_SGE_SIZE, sge_size);
2802
2803 stage_sge.addrHigh = PADDR_HI(sge_addr);
2804 stage_sge.addrLow = PADDR_LO(sge_addr);
2805 stage_sge.length = len;
2806 stage_sge.offset = cnt;
2807 stage_sge.type = EMLXS_SGE_TYPE_DATA;
2808
2809 sge_addr += len;
2810 sge_size -= len;
2811 cnt += len;
2812 }
2813
2814 stage_sge.last = 1;
2815
2816 if (hba->sli.sli4.flag & EMLXS_SLI4_PHON) {
2817 wqe->FirstData.addrHigh = stage_sge.addrHigh;
2818 wqe->FirstData.addrLow = stage_sge.addrLow;
2819 wqe->FirstData.tus.f.bdeSize = stage_sge.length;
2820 }
2821 /* Copy staged SGE into SGL */
2822 BE_SWAP32_BCOPY((uint8_t *)&stage_sge,
2823 (uint8_t *)sge, sizeof (ULP_SGE64));
2824
2825 return (0);
2826
2827} /* emlxs_sli4_fct_bde_setup */
2828#endif /* SFCT_SUPPORT */
2829
2830
1825static void
1826emlxs_sli4_issue_iocb_cmd(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
1827{
1828 emlxs_port_t *port = &PPORT;
1829 emlxs_buf_t *sbp;
1830 uint32_t channelno;
1831 int32_t throttle;
1832 emlxs_wqe_t *wqe;
1833 emlxs_wqe_t *wqeslot;
1834 WQ_DESC_t *wq;
1835 uint32_t flag;
1836 uint32_t wqdb;
1837 uint16_t next_wqe;
1838 off_t offset;
2831static void
2832emlxs_sli4_issue_iocb_cmd(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
2833{
2834 emlxs_port_t *port = &PPORT;
2835 emlxs_buf_t *sbp;
2836 uint32_t channelno;
2837 int32_t throttle;
2838 emlxs_wqe_t *wqe;
2839 emlxs_wqe_t *wqeslot;
2840 WQ_DESC_t *wq;
2841 uint32_t flag;
2842 uint32_t wqdb;
2843 uint16_t next_wqe;
2844 off_t offset;
2845#ifdef NODE_THROTTLE_SUPPORT
2846 int32_t node_throttle;
2847 NODELIST *marked_node = NULL;
2848#endif /* NODE_THROTTLE_SUPPORT */
1839
1840
1841 channelno = cp->channelno;
1842 wq = (WQ_DESC_t *)cp->iopath;
1843
2849
2850
2851 channelno = cp->channelno;
2852 wq = (WQ_DESC_t *)cp->iopath;
2853
1844#ifdef SLI4_FASTPATH_DEBUG
2854#ifdef DEBUG_FASTPATH
1845 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
1846 "ISSUE WQE channel: %x %p", channelno, wq);
2855 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2856 "ISSUE WQE channel: %x %p", channelno, wq);
1847#endif
2857#endif /* DEBUG_FASTPATH */
1848
1849 throttle = 0;
1850
1851 /* Check if FCP ring and adapter is not ready */
1852 /* We may use any ring for FCP_CMD */
1853 if (iocbq && (iocbq->flag & IOCB_FCP_CMD) && (hba->state != FC_READY)) {
1854 if (!(iocbq->flag & IOCB_SPECIAL) || !iocbq->port ||
2858
2859 throttle = 0;
2860
2861 /* Check if FCP ring and adapter is not ready */
2862 /* We may use any ring for FCP_CMD */
2863 if (iocbq && (iocbq->flag & IOCB_FCP_CMD) && (hba->state != FC_READY)) {
2864 if (!(iocbq->flag & IOCB_SPECIAL) || !iocbq->port ||
1855 !(((emlxs_port_t *)iocbq->port)->tgt_mode)) {
2865 (((emlxs_port_t *)iocbq->port)->mode == MODE_INITIATOR)) {
1856 emlxs_tx_put(iocbq, 1);
1857 return;
1858 }
1859 }
1860
1861 /* Attempt to acquire CMD_RING lock */
1862 if (mutex_tryenter(&EMLXS_QUE_LOCK(channelno)) == 0) {
1863 /* Queue it for later */

--- 63 unchanged lines hidden (view full) ---

1927 mutex_exit(&EMLXS_TX_CHANNEL_LOCK);
1928 } else {
1929 iocbq = emlxs_tx_get(cp, 1);
1930 }
1931
1932sendit:
1933 /* Process each iocbq */
1934 while (iocbq) {
2866 emlxs_tx_put(iocbq, 1);
2867 return;
2868 }
2869 }
2870
2871 /* Attempt to acquire CMD_RING lock */
2872 if (mutex_tryenter(&EMLXS_QUE_LOCK(channelno)) == 0) {
2873 /* Queue it for later */

--- 63 unchanged lines hidden (view full) ---

2937 mutex_exit(&EMLXS_TX_CHANNEL_LOCK);
2938 } else {
2939 iocbq = emlxs_tx_get(cp, 1);
2940 }
2941
2942sendit:
2943 /* Process each iocbq */
2944 while (iocbq) {
2945 sbp = iocbq->sbp;
1935
2946
2947#ifdef NODE_THROTTLE_SUPPORT
2948 if (sbp && sbp->node && sbp->node->io_throttle) {
2949 node_throttle = sbp->node->io_throttle -
2950 sbp->node->io_active;
2951 if (node_throttle <= 0) {
2952 /* Node is busy */
2953 /* Queue this iocb and get next iocb from */
2954 /* channel */
2955
2956 if (!marked_node) {
2957 marked_node = sbp->node;
2958 }
2959
2960 mutex_enter(&EMLXS_TX_CHANNEL_LOCK);
2961 emlxs_tx_put(iocbq, 0);
2962
2963 if (cp->nodeq.q_first == marked_node) {
2964 mutex_exit(&EMLXS_TX_CHANNEL_LOCK);
2965 goto busy;
2966 }
2967
2968 iocbq = emlxs_tx_get(cp, 0);
2969 mutex_exit(&EMLXS_TX_CHANNEL_LOCK);
2970 continue;
2971 }
2972 }
2973 marked_node = 0;
2974#endif /* NODE_THROTTLE_SUPPORT */
2975
1936 wqe = &iocbq->wqe;
2976 wqe = &iocbq->wqe;
1937#ifdef SLI4_FASTPATH_DEBUG
2977#ifdef DEBUG_FASTPATH
1938 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2978 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
1939 "ISSUE QID %d WQE iotag: %x xri: %x", wq->qid,
2979 "ISSUE QID %d WQE iotag:%x xri:%d", wq->qid,
1940 wqe->RequestTag, wqe->XRITag);
2980 wqe->RequestTag, wqe->XRITag);
1941#endif
2981#endif /* DEBUG_FASTPATH */
1942
2982
1943 sbp = iocbq->sbp;
1944 if (sbp) {
1945 /* If exchange removed after wqe was prep'ed, drop it */
1946 if (!(sbp->xrip)) {
1947 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2983 if (sbp) {
2984 /* If exchange removed after wqe was prep'ed, drop it */
2985 if (!(sbp->xrip)) {
2986 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
1948 "Xmit WQE iotag: %x xri: %x aborted",
2987 "Xmit WQE iotag:%x xri:%d aborted",
1949 wqe->RequestTag, wqe->XRITag);
1950
1951 /* Get next iocb from the tx queue */
1952 iocbq = emlxs_tx_get(cp, 1);
1953 continue;
1954 }
1955
1956 if (sbp->pkt_flags & PACKET_DELAY_REQUIRED) {
1957
1958 /* Perform delay */
1959 if ((channelno == hba->channel_els) &&
1960 !(iocbq->flag & IOCB_FCP_CMD)) {
1961 drv_usecwait(100000);
1962 } else {
1963 drv_usecwait(20000);
1964 }
1965 }
2988 wqe->RequestTag, wqe->XRITag);
2989
2990 /* Get next iocb from the tx queue */
2991 iocbq = emlxs_tx_get(cp, 1);
2992 continue;
2993 }
2994
2995 if (sbp->pkt_flags & PACKET_DELAY_REQUIRED) {
2996
2997 /* Perform delay */
2998 if ((channelno == hba->channel_els) &&
2999 !(iocbq->flag & IOCB_FCP_CMD)) {
3000 drv_usecwait(100000);
3001 } else {
3002 drv_usecwait(20000);
3003 }
3004 }
1966 }
1967
3005
1968 /*
1969 * At this point, we have a command ring slot available
1970 * and an iocb to send
1971 */
1972 wq->release_depth--;
1973 if (wq->release_depth == 0) {
1974 wq->release_depth = WQE_RELEASE_DEPTH;
1975 wqe->WQEC = 1;
1976 }
1977
1978
1979 HBASTATS.IocbIssued[channelno]++;
1980
1981 /* Check for ULP pkt request */
1982 if (sbp) {
3006 /* Check for ULP pkt request */
1983 mutex_enter(&sbp->mtx);
1984
1985 if (sbp->node == NULL) {
1986 /* Set node to base node by default */
1987 iocbq->node = (void *)&port->node_base;
1988 sbp->node = (void *)&port->node_base;
1989 }
1990
1991 sbp->pkt_flags |= PACKET_IN_CHIPQ;
1992 mutex_exit(&sbp->mtx);
1993
1994 atomic_inc_32(&hba->io_active);
3007 mutex_enter(&sbp->mtx);
3008
3009 if (sbp->node == NULL) {
3010 /* Set node to base node by default */
3011 iocbq->node = (void *)&port->node_base;
3012 sbp->node = (void *)&port->node_base;
3013 }
3014
3015 sbp->pkt_flags |= PACKET_IN_CHIPQ;
3016 mutex_exit(&sbp->mtx);
3017
3018 atomic_inc_32(&hba->io_active);
1995 sbp->xrip->flag |= EMLXS_XRI_PENDING_IO;
1996 }
3019#ifdef NODE_THROTTLE_SUPPORT
3020 if (sbp->node) {
3021 atomic_inc_32(&sbp->node->io_active);
3022 }
3023#endif /* NODE_THROTTLE_SUPPORT */
1997
3024
1998
1999 /* Free the local iocb if there is no sbp tracking it */
2000 if (sbp) {
3025 sbp->xrip->flag |= EMLXS_XRI_PENDING_IO;
2001#ifdef SFCT_SUPPORT
2002#ifdef FCT_IO_TRACE
2003 if (sbp->fct_cmd) {
2004 emlxs_fct_io_trace(port, sbp->fct_cmd,
2005 EMLXS_FCT_IOCB_ISSUED);
2006 emlxs_fct_io_trace(port, sbp->fct_cmd,
2007 icmd->ULPCOMMAND);
2008 }
2009#endif /* FCT_IO_TRACE */
2010#endif /* SFCT_SUPPORT */
2011 cp->hbaSendCmd_sbp++;
2012 iocbq->channel = cp;
2013 } else {
2014 cp->hbaSendCmd++;
2015 }
2016
2017 flag = iocbq->flag;
2018
3026#ifdef SFCT_SUPPORT
3027#ifdef FCT_IO_TRACE
3028 if (sbp->fct_cmd) {
3029 emlxs_fct_io_trace(port, sbp->fct_cmd,
3030 EMLXS_FCT_IOCB_ISSUED);
3031 emlxs_fct_io_trace(port, sbp->fct_cmd,
3032 icmd->ULPCOMMAND);
3033 }
3034#endif /* FCT_IO_TRACE */
3035#endif /* SFCT_SUPPORT */
3036 cp->hbaSendCmd_sbp++;
3037 iocbq->channel = cp;
3038 } else {
3039 cp->hbaSendCmd++;
3040 }
3041
3042 flag = iocbq->flag;
3043
3044 /*
3045 * At this point, we have a command ring slot available
3046 * and an iocb to send
3047 */
3048 wq->release_depth--;
3049 if (wq->release_depth == 0) {
3050 wq->release_depth = WQE_RELEASE_DEPTH;
3051 wqe->WQEC = 1;
3052 }
3053
3054 HBASTATS.IocbIssued[channelno]++;
3055 wq->num_proc++;
3056
2019 /* Send the iocb */
2020 wqeslot = (emlxs_wqe_t *)wq->addr.virt;
2021 wqeslot += wq->host_index;
2022
2023 wqe->CQId = wq->cqid;
3057 /* Send the iocb */
3058 wqeslot = (emlxs_wqe_t *)wq->addr.virt;
3059 wqeslot += wq->host_index;
3060
3061 wqe->CQId = wq->cqid;
3062 if (hba->sli.sli4.param.PHWQ) {
3063 WQE_PHWQ_WQID(wqe, wq->qid);
3064 }
2024 BE_SWAP32_BCOPY((uint8_t *)wqe, (uint8_t *)wqeslot,
2025 sizeof (emlxs_wqe_t));
2026#ifdef DEBUG_WQE
2027 emlxs_data_dump(port, "WQE", (uint32_t *)wqe, 18, 0);
3065 BE_SWAP32_BCOPY((uint8_t *)wqe, (uint8_t *)wqeslot,
3066 sizeof (emlxs_wqe_t));
3067#ifdef DEBUG_WQE
3068 emlxs_data_dump(port, "WQE", (uint32_t *)wqe, 18, 0);
2028#endif
3069#endif /* DEBUG_WQE */
2029 offset = (off_t)((uint64_t)((unsigned long)
2030 wq->addr.virt) -
2031 (uint64_t)((unsigned long)
2032 hba->sli.sli4.slim2.virt));
2033
2034 EMLXS_MPDATA_SYNC(wq->addr.dma_handle, offset,
2035 4096, DDI_DMA_SYNC_FORDEV);
2036
2037 /* Ring the WQ Doorbell */
2038 wqdb = wq->qid;
2039 wqdb |= ((1 << 24) | (wq->host_index << 16));
2040
3070 offset = (off_t)((uint64_t)((unsigned long)
3071 wq->addr.virt) -
3072 (uint64_t)((unsigned long)
3073 hba->sli.sli4.slim2.virt));
3074
3075 EMLXS_MPDATA_SYNC(wq->addr.dma_handle, offset,
3076 4096, DDI_DMA_SYNC_FORDEV);
3077
3078 /* Ring the WQ Doorbell */
3079 wqdb = wq->qid;
3080 wqdb |= ((1 << 24) | (wq->host_index << 16));
3081
3082 /*
3083 * After this, the sbp / iocb / wqe should not be
3084 * accessed in the xmit path.
3085 */
2041
3086
2042 WRITE_BAR2_REG(hba, FC_WQDB_REG(hba), wqdb);
3087 emlxs_sli4_write_wqdb(hba, wqdb);
2043 wq->host_index = next_wqe;
2044
3088 wq->host_index = next_wqe;
3089
2045#ifdef SLI4_FASTPATH_DEBUG
3090#ifdef DEBUG_FASTPATH
2046 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2047 "WQ RING: %08x", wqdb);
3091 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3092 "WQ RING: %08x", wqdb);
2048#endif
3093#endif /* DEBUG_FASTPATH */
2049
3094
2050 /*
2051 * After this, the sbp / iocb / wqe should not be
2052 * accessed in the xmit path.
2053 */
2054
2055 if (!sbp) {
2056 emlxs_mem_put(hba, MEM_IOCB, (void *)iocbq);
2057 }
2058
2059 if (iocbq && (!(flag & IOCB_SPECIAL))) {
2060 /* Check if HBA is full */
2061 throttle = hba->io_throttle - hba->io_active;
2062 if (throttle <= 0) {

--- 7 unchanged lines hidden (view full) ---

2070 next_wqe = 0;
2071 }
2072
2073 if (next_wqe == wq->port_index) {
2074 /* Queue it for later */
2075 goto busy;
2076 }
2077
3095 if (!sbp) {
3096 emlxs_mem_put(hba, MEM_IOCB, (void *)iocbq);
3097 }
3098
3099 if (iocbq && (!(flag & IOCB_SPECIAL))) {
3100 /* Check if HBA is full */
3101 throttle = hba->io_throttle - hba->io_active;
3102 if (throttle <= 0) {

--- 7 unchanged lines hidden (view full) ---

3110 next_wqe = 0;
3111 }
3112
3113 if (next_wqe == wq->port_index) {
3114 /* Queue it for later */
3115 goto busy;
3116 }
3117
2078
2079 /* Get the next iocb from the tx queue if there is one */
2080 iocbq = emlxs_tx_get(cp, 1);
2081 }
2082
2083 mutex_exit(&EMLXS_QUE_LOCK(channelno));
2084
2085 return;
2086
2087busy:
3118 /* Get the next iocb from the tx queue if there is one */
3119 iocbq = emlxs_tx_get(cp, 1);
3120 }
3121
3122 mutex_exit(&EMLXS_QUE_LOCK(channelno));
3123
3124 return;
3125
3126busy:
3127 wq->num_busy++;
2088 if (throttle <= 0) {
2089 HBASTATS.IocbThrottled++;
2090 } else {
2091 HBASTATS.IocbRingFull[channelno]++;
2092 }
2093
2094 mutex_exit(&EMLXS_QUE_LOCK(channelno));
2095

--- 79 unchanged lines hidden (view full) ---

2175 mqdb = hba->sli.sli4.mq.qid;
2176 mqdb |= ((1 << MQ_DB_POP_SHIFT) & MQ_DB_POP_MASK);
2177
2178 if (mb->mbxCommand != MBX_HEARTBEAT) {
2179 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2180 "MQ RING: %08x", mqdb);
2181 }
2182
3128 if (throttle <= 0) {
3129 HBASTATS.IocbThrottled++;
3130 } else {
3131 HBASTATS.IocbRingFull[channelno]++;
3132 }
3133
3134 mutex_exit(&EMLXS_QUE_LOCK(channelno));
3135

--- 79 unchanged lines hidden (view full) ---

3215 mqdb = hba->sli.sli4.mq.qid;
3216 mqdb |= ((1 << MQ_DB_POP_SHIFT) & MQ_DB_POP_MASK);
3217
3218 if (mb->mbxCommand != MBX_HEARTBEAT) {
3219 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3220 "MQ RING: %08x", mqdb);
3221 }
3222
2183 WRITE_BAR2_REG(hba, FC_MQDB_REG(hba), mqdb);
3223 emlxs_sli4_write_mqdb(hba, mqdb);
3224
2184 return (MBX_SUCCESS);
2185
2186} /* emlxs_sli4_issue_mq() */
2187
2188
2189/*ARGSUSED*/
2190static uint32_t
2191emlxs_sli4_issue_bootstrap(emlxs_hba_t *hba, MAILBOX *mb, uint32_t tmo)

--- 97 unchanged lines hidden (view full) ---

2289 }
2290
2291#ifdef FMA_SUPPORT
2292 if (nonembed && mp) {
2293 if (emlxs_fm_check_dma_handle(hba, mp->dma_handle)
2294 != DDI_FM_OK) {
2295 EMLXS_MSGF(EMLXS_CONTEXT,
2296 &emlxs_invalid_dma_handle_msg,
3225 return (MBX_SUCCESS);
3226
3227} /* emlxs_sli4_issue_mq() */
3228
3229
3230/*ARGSUSED*/
3231static uint32_t
3232emlxs_sli4_issue_bootstrap(emlxs_hba_t *hba, MAILBOX *mb, uint32_t tmo)

--- 97 unchanged lines hidden (view full) ---

3330 }
3331
3332#ifdef FMA_SUPPORT
3333 if (nonembed && mp) {
3334 if (emlxs_fm_check_dma_handle(hba, mp->dma_handle)
3335 != DDI_FM_OK) {
3336 EMLXS_MSGF(EMLXS_CONTEXT,
3337 &emlxs_invalid_dma_handle_msg,
2297 "emlxs_sli4_issue_bootstrap: mp_hdl=%p",
3338 "sli4_issue_bootstrap: mp_hdl=%p",
2298 mp->dma_handle);
2299 return (MBXERR_DMA_ERROR);
2300 }
2301 }
2302
2303 if (emlxs_fm_check_dma_handle(hba,
2304 hba->sli.sli4.bootstrapmb.dma_handle)
2305 != DDI_FM_OK) {
2306 EMLXS_MSGF(EMLXS_CONTEXT,
2307 &emlxs_invalid_dma_handle_msg,
3339 mp->dma_handle);
3340 return (MBXERR_DMA_ERROR);
3341 }
3342 }
3343
3344 if (emlxs_fm_check_dma_handle(hba,
3345 hba->sli.sli4.bootstrapmb.dma_handle)
3346 != DDI_FM_OK) {
3347 EMLXS_MSGF(EMLXS_CONTEXT,
3348 &emlxs_invalid_dma_handle_msg,
2308 "emlxs_sli4_issue_bootstrap: hdl=%p",
3349 "sli4_issue_bootstrap: hdl=%p",
2309 hba->sli.sli4.bootstrapmb.dma_handle);
2310 return (MBXERR_DMA_ERROR);
2311 }
2312#endif
2313
2314 return (MBX_SUCCESS);
2315
2316} /* emlxs_sli4_issue_bootstrap() */

--- 32 unchanged lines hidden (view full) ---

2349 case MBX_DOWN_LOAD:
2350 case MBX_UPDATE_CFG:
2351 case MBX_LOAD_AREA:
2352 case MBX_LOAD_EXP_ROM:
2353 case MBX_WRITE_NV:
2354 case MBX_FLASH_WR_ULA:
2355 case MBX_DEL_LD_ENTRY:
2356 case MBX_LOAD_SM:
3350 hba->sli.sli4.bootstrapmb.dma_handle);
3351 return (MBXERR_DMA_ERROR);
3352 }
3353#endif
3354
3355 return (MBX_SUCCESS);
3356
3357} /* emlxs_sli4_issue_bootstrap() */

--- 32 unchanged lines hidden (view full) ---

3390 case MBX_DOWN_LOAD:
3391 case MBX_UPDATE_CFG:
3392 case MBX_LOAD_AREA:
3393 case MBX_LOAD_EXP_ROM:
3394 case MBX_WRITE_NV:
3395 case MBX_FLASH_WR_ULA:
3396 case MBX_DEL_LD_ENTRY:
3397 case MBX_LOAD_SM:
3398 case MBX_DUMP_MEMORY:
3399 case MBX_WRITE_VPARMS:
3400 case MBX_ACCESS_VDATA:
2357 if (tmo < 300) {
2358 tmo = 300;
2359 }
2360 break;
2361
3401 if (tmo < 300) {
3402 tmo = 300;
3403 }
3404 break;
3405
3406 case MBX_SLI_CONFIG: {
3407 mbox_req_hdr_t *hdr_req;
3408
3409 hdr_req = (mbox_req_hdr_t *)
3410 &mb4->un.varSLIConfig.be.un_hdr.hdr_req;
3411
3412 if (hdr_req->subsystem == IOCTL_SUBSYSTEM_COMMON) {
3413 switch (hdr_req->opcode) {
3414 case COMMON_OPCODE_WRITE_OBJ:
3415 case COMMON_OPCODE_READ_OBJ:
3416 case COMMON_OPCODE_READ_OBJ_LIST:
3417 case COMMON_OPCODE_DELETE_OBJ:
3418 case COMMON_OPCODE_SET_BOOT_CFG:
3419 case COMMON_OPCODE_GET_PROFILE_CFG:
3420 case COMMON_OPCODE_SET_PROFILE_CFG:
3421 case COMMON_OPCODE_GET_PROFILE_LIST:
3422 case COMMON_OPCODE_SET_ACTIVE_PROFILE:
3423 case COMMON_OPCODE_GET_PROFILE_CAPS:
3424 case COMMON_OPCODE_GET_MR_PROFILE_CAPS:
3425 case COMMON_OPCODE_SET_MR_PROFILE_CAPS:
3426 case COMMON_OPCODE_SET_FACTORY_PROFILE_CFG:
3427 case COMMON_OPCODE_SEND_ACTIVATION:
3428 case COMMON_OPCODE_RESET_LICENSES:
3429 case COMMON_OPCODE_SET_PHYSICAL_LINK_CFG_V1:
3430 case COMMON_OPCODE_GET_VPD_DATA:
3431 if (tmo < 300) {
3432 tmo = 300;
3433 }
3434 break;
3435 default:
3436 if (tmo < 30) {
3437 tmo = 30;
3438 }
3439 }
3440 } else if (hdr_req->subsystem == IOCTL_SUBSYSTEM_FCOE) {
3441 switch (hdr_req->opcode) {
3442 case FCOE_OPCODE_SET_FCLINK_SETTINGS:
3443 if (tmo < 300) {
3444 tmo = 300;
3445 }
3446 break;
3447 default:
3448 if (tmo < 30) {
3449 tmo = 30;
3450 }
3451 }
3452 } else {
3453 if (tmo < 30) {
3454 tmo = 30;
3455 }
3456 }
3457
3458 /*
3459 * Also: VENDOR_MANAGE_FFV (0x13, 0x02) (not currently used)
3460 */
3461
3462 break;
3463 }
2362 default:
2363 if (tmo < 30) {
2364 tmo = 30;
2365 }
2366 break;
2367 }
2368
2369 /* Convert tmo seconds to 10 millisecond tics */

--- 29 unchanged lines hidden (view full) ---

2399 (mb4->un.varSLIConfig.be.un_hdr.hdr_req.opcode ==
2400 COMMON_OPCODE_RESET))) {
2401 mb->mbxStatus = MBX_HARDWARE_ERROR;
2402
2403 mutex_exit(&EMLXS_PORT_LOCK);
2404
2405 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mbox_detail_msg,
2406 "Hardware error reported. %s failed. status=%x mb=%p",
3464 default:
3465 if (tmo < 30) {
3466 tmo = 30;
3467 }
3468 break;
3469 }
3470
3471 /* Convert tmo seconds to 10 millisecond tics */

--- 29 unchanged lines hidden (view full) ---

3501 (mb4->un.varSLIConfig.be.un_hdr.hdr_req.opcode ==
3502 COMMON_OPCODE_RESET))) {
3503 mb->mbxStatus = MBX_HARDWARE_ERROR;
3504
3505 mutex_exit(&EMLXS_PORT_LOCK);
3506
3507 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mbox_detail_msg,
3508 "Hardware error reported. %s failed. status=%x mb=%p",
2407 emlxs_mb_cmd_xlate(mb->mbxCommand), mb->mbxStatus, mb);
3509 emlxs_mb_cmd_xlate(mb->mbxCommand), mb->mbxStatus, mb);
2408
2409 return (MBX_HARDWARE_ERROR);
2410 }
2411
2412 if (hba->mbox_queue_flag) {
2413 /* If we are not polling, then queue it for later */
2414 if (flag == MBX_NOWAIT) {
2415 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mbox_detail_msg,

--- 20 unchanged lines hidden (view full) ---

2436 tmo);
2437
2438 /* Non-lethalStatus mailbox timeout */
2439 /* Does not indicate a hardware error */
2440 mb->mbxStatus = MBX_TIMEOUT;
2441 return (MBX_TIMEOUT);
2442 }
2443
3510
3511 return (MBX_HARDWARE_ERROR);
3512 }
3513
3514 if (hba->mbox_queue_flag) {
3515 /* If we are not polling, then queue it for later */
3516 if (flag == MBX_NOWAIT) {
3517 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mbox_detail_msg,

--- 20 unchanged lines hidden (view full) ---

3538 tmo);
3539
3540 /* Non-lethalStatus mailbox timeout */
3541 /* Does not indicate a hardware error */
3542 mb->mbxStatus = MBX_TIMEOUT;
3543 return (MBX_TIMEOUT);
3544 }
3545
2444 DELAYMS(10);
3546 BUSYWAIT_MS(10);
2445 mutex_enter(&EMLXS_PORT_LOCK);
3547 mutex_enter(&EMLXS_PORT_LOCK);
3548
3549 /* Check for hardware error ; special case SLI_CONFIG */
3550 if ((hba->flag & FC_HARDWARE_ERROR) &&
3551 ! ((mb4->mbxCommand == MBX_SLI_CONFIG) &&
3552 (mb4->un.varSLIConfig.be.un_hdr.hdr_req.opcode ==
3553 COMMON_OPCODE_RESET))) {
3554 mb->mbxStatus = MBX_HARDWARE_ERROR;
3555
3556 mutex_exit(&EMLXS_PORT_LOCK);
3557
3558 EMLXS_MSGF(EMLXS_CONTEXT,
3559 &emlxs_mbox_detail_msg,
3560 "Hardware error reported. %s failed. "
3561 "status=%x mb=%p",
3562 emlxs_mb_cmd_xlate(mb->mbxCommand),
3563 mb->mbxStatus, mb);
3564
3565 return (MBX_HARDWARE_ERROR);
3566 }
2446 }
2447 }
2448
2449 /* Initialize mailbox area */
2450 emlxs_mb_init(hba, mbq, flag, tmo);
2451
2452 if (mb->mbxCommand == MBX_DOWN_LINK) {
2453 hba->sli.sli4.flag |= EMLXS_SLI4_DOWN_LINK;

--- 259 unchanged lines hidden (view full) ---

2713 return (rc);
2714
2715} /* emlxs_sli4_issue_mbox_cmd4quiesce() */
2716
2717
2718
2719#ifdef SFCT_SUPPORT
2720/*ARGSUSED*/
3567 }
3568 }
3569
3570 /* Initialize mailbox area */
3571 emlxs_mb_init(hba, mbq, flag, tmo);
3572
3573 if (mb->mbxCommand == MBX_DOWN_LINK) {
3574 hba->sli.sli4.flag |= EMLXS_SLI4_DOWN_LINK;

--- 259 unchanged lines hidden (view full) ---

3834 return (rc);
3835
3836} /* emlxs_sli4_issue_mbox_cmd4quiesce() */
3837
3838
3839
3840#ifdef SFCT_SUPPORT
3841/*ARGSUSED*/
2721static uint32_t
3842extern uint32_t
2722emlxs_sli4_prep_fct_iocb(emlxs_port_t *port, emlxs_buf_t *cmd_sbp, int channel)
2723{
3843emlxs_sli4_prep_fct_iocb(emlxs_port_t *port, emlxs_buf_t *cmd_sbp, int channel)
3844{
2724 return (IOERR_NO_RESOURCES);
3845 emlxs_hba_t *hba = HBA;
3846 emlxs_config_t *cfg = &CFG;
3847 fct_cmd_t *fct_cmd;
3848 stmf_data_buf_t *dbuf;
3849 scsi_task_t *fct_task;
3850 fc_packet_t *pkt;
3851 CHANNEL *cp;
3852 XRIobj_t *xrip;
3853 emlxs_node_t *ndlp;
3854 IOCBQ *iocbq;
3855 IOCB *iocb;
3856 emlxs_wqe_t *wqe;
3857 ULP_SGE64 stage_sge;
3858 ULP_SGE64 *sge;
3859 RPIobj_t *rpip;
3860 int32_t sge_size;
3861 uint64_t sge_addr;
3862 uint32_t did;
3863 uint32_t timeout;
2725
3864
3865 ddi_dma_cookie_t *cp_cmd;
3866
3867 pkt = PRIV2PKT(cmd_sbp);
3868
3869 cp = (CHANNEL *)cmd_sbp->channel;
3870
3871 iocbq = &cmd_sbp->iocbq;
3872 iocb = &iocbq->iocb;
3873
3874 did = cmd_sbp->did;
3875 if (iocb->ULPCOMMAND == CMD_ABORT_XRI_CX) {
3876
3877 ndlp = cmd_sbp->node;
3878 rpip = EMLXS_NODE_TO_RPI(port, ndlp);
3879
3880 if (!rpip) {
3881 /* Use the fabric rpi */
3882 rpip = port->vpip->fabric_rpip;
3883 }
3884
3885 /* Next allocate an Exchange for this command */
3886 xrip = emlxs_sli4_alloc_xri(port, cmd_sbp, rpip,
3887 EMLXS_XRI_SOL_BLS_TYPE);
3888
3889 if (!xrip) {
3890 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3891 "Adapter Busy. Unable to allocate exchange. "
3892 "did=0x%x", did);
3893
3894 return (FC_TRAN_BUSY);
3895 }
3896
3897 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3898 "FCT Abort Request: xri=%d iotag=%d sbp=%p rxid=%x",
3899 xrip->XRI, xrip->iotag, cmd_sbp, pkt->pkt_cmd_fhdr.rx_id);
3900
3901 cmd_sbp->xrip = xrip;
3902
3903 cp->ulpSendCmd++;
3904
3905 /* Initalize iocbq */
3906 iocbq->port = (void *)port;
3907 iocbq->node = (void *)ndlp;
3908 iocbq->channel = (void *)cp;
3909
3910 /*
3911 * Don't give the abort priority, we want the IOCB
3912 * we are aborting to be processed first.
3913 */
3914 iocbq->flag |= IOCB_SPECIAL;
3915
3916 wqe = &iocbq->wqe;
3917 bzero((void *)wqe, sizeof (emlxs_wqe_t));
3918
3919 wqe = &iocbq->wqe;
3920 wqe->un.Abort.Criteria = ABORT_XRI_TAG;
3921 wqe->RequestTag = xrip->iotag;
3922 wqe->AbortTag = pkt->pkt_cmd_fhdr.rx_id;
3923 wqe->Command = CMD_ABORT_XRI_CX;
3924 wqe->Class = CLASS3;
3925 wqe->CQId = 0xffff;
3926 wqe->CmdType = WQE_TYPE_ABORT;
3927
3928 if (hba->state >= FC_LINK_UP) {
3929 wqe->un.Abort.IA = 0;
3930 } else {
3931 wqe->un.Abort.IA = 1;
3932 }
3933
3934 /* Set the pkt timer */
3935 cmd_sbp->ticks = hba->timer_tics + pkt->pkt_timeout +
3936 ((pkt->pkt_timeout > 0xff) ? 0 : 10);
3937
3938 return (IOERR_SUCCESS);
3939
3940 } else if (iocb->ULPCOMMAND == CMD_FCP_TRSP64_CX) {
3941
3942 timeout = pkt->pkt_timeout;
3943 ndlp = cmd_sbp->node;
3944 if (!ndlp) {
3945 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3946 "Unable to find rpi. did=0x%x", did);
3947
3948 emlxs_set_pkt_state(cmd_sbp, IOSTAT_LOCAL_REJECT,
3949 IOERR_INVALID_RPI, 0);
3950 return (0xff);
3951 }
3952
3953 cp->ulpSendCmd++;
3954
3955 /* Initalize iocbq */
3956 iocbq->port = (void *)port;
3957 iocbq->node = (void *)ndlp;
3958 iocbq->channel = (void *)cp;
3959
3960 wqe = &iocbq->wqe;
3961 bzero((void *)wqe, sizeof (emlxs_wqe_t));
3962
3963 xrip = emlxs_sli4_register_xri(port, cmd_sbp,
3964 pkt->pkt_cmd_fhdr.rx_id, did);
3965
3966 if (!xrip) {
3967 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3968 "Unable to register xri %x. did=0x%x",
3969 pkt->pkt_cmd_fhdr.rx_id, did);
3970
3971 emlxs_set_pkt_state(cmd_sbp, IOSTAT_LOCAL_REJECT,
3972 IOERR_NO_XRI, 0);
3973 return (0xff);
3974 }
3975
3976 cmd_sbp->iotag = xrip->iotag;
3977 cmd_sbp->channel = cp;
3978
3979#if (EMLXS_MODREV >= EMLXS_MODREV3)
3980 cp_cmd = pkt->pkt_cmd_cookie;
3981#else
3982 cp_cmd = &pkt->pkt_cmd_cookie;
3983#endif /* >= EMLXS_MODREV3 */
3984
3985 sge_size = pkt->pkt_cmdlen;
3986 /* Make size a multiple of 4 */
3987 if (sge_size & 3) {
3988 sge_size = (sge_size + 3) & 0xfffffffc;
3989 }
3990 sge_addr = cp_cmd->dmac_laddress;
3991 sge = xrip->SGList.virt;
3992
3993 stage_sge.addrHigh = PADDR_HI(sge_addr);
3994 stage_sge.addrLow = PADDR_LO(sge_addr);
3995 stage_sge.length = sge_size;
3996 stage_sge.offset = 0;
3997 stage_sge.type = 0;
3998 stage_sge.last = 1;
3999
4000 /* Copy staged SGE into SGL */
4001 BE_SWAP32_BCOPY((uint8_t *)&stage_sge,
4002 (uint8_t *)sge, sizeof (ULP_SGE64));
4003
4004 /* Words 0-3 */
4005 wqe->un.FcpCmd.Payload.addrHigh = stage_sge.addrHigh;
4006 wqe->un.FcpCmd.Payload.addrLow = stage_sge.addrLow;
4007 wqe->un.FcpCmd.Payload.tus.f.bdeSize = sge_size;
4008 wqe->un.FcpCmd.PayloadLength = sge_size;
4009
4010 /* Word 6 */
4011 wqe->ContextTag = ndlp->nlp_Rpi;
4012 wqe->XRITag = xrip->XRI;
4013
4014 /* Word 7 */
4015 wqe->Command = iocb->ULPCOMMAND;
4016 wqe->Class = cmd_sbp->class;
4017 wqe->ContextType = WQE_RPI_CONTEXT;
4018 wqe->Timer = ((timeout > 0xff) ? 0 : timeout);
4019
4020 /* Word 8 */
4021 wqe->AbortTag = 0;
4022
4023 /* Word 9 */
4024 wqe->RequestTag = xrip->iotag;
4025 wqe->OXId = (uint16_t)xrip->rx_id;
4026
4027 /* Word 10 */
4028 if (xrip->flag & EMLXS_XRI_BUSY) {
4029 wqe->XC = 1;
4030 }
4031
4032 if (!(hba->sli.sli4.param.PHWQ)) {
4033 wqe->QOSd = 1;
4034 wqe->DBDE = 1; /* Data type for BDE 0 */
4035 }
4036
4037 /* Word 11 */
4038 wqe->CmdType = WQE_TYPE_TRSP;
4039 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
4040
4041 /* Set the pkt timer */
4042 cmd_sbp->ticks = hba->timer_tics + timeout +
4043 ((timeout > 0xff) ? 0 : 10);
4044
4045 if (pkt->pkt_cmdlen) {
4046 EMLXS_MPDATA_SYNC(pkt->pkt_cmd_dma, 0, pkt->pkt_cmdlen,
4047 DDI_DMA_SYNC_FORDEV);
4048 }
4049
4050 return (IOERR_SUCCESS);
4051 }
4052
4053 fct_cmd = cmd_sbp->fct_cmd;
4054 did = fct_cmd->cmd_rportid;
4055 dbuf = cmd_sbp->fct_buf;
4056 fct_task = (scsi_task_t *)fct_cmd->cmd_specific;
4057 ndlp = *(emlxs_node_t **)fct_cmd->cmd_rp->rp_fca_private;
4058 if (!ndlp) {
4059 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4060 "Unable to find rpi. did=0x%x", did);
4061
4062 emlxs_set_pkt_state(cmd_sbp, IOSTAT_LOCAL_REJECT,
4063 IOERR_INVALID_RPI, 0);
4064 return (0xff);
4065 }
4066
4067
4068 /* Initalize iocbq */
4069 iocbq->port = (void *) port;
4070 iocbq->node = (void *)ndlp;
4071 iocbq->channel = (void *) cp;
4072
4073 wqe = &iocbq->wqe;
4074 bzero((void *)wqe, sizeof (emlxs_wqe_t));
4075
4076 xrip = cmd_sbp->xrip;
4077 if (!xrip) {
4078 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4079 "Unable to find xri. did=0x%x", did);
4080
4081 emlxs_set_pkt_state(cmd_sbp, IOSTAT_LOCAL_REJECT,
4082 IOERR_NO_XRI, 0);
4083 return (0xff);
4084 }
4085
4086 if (emlxs_sli4_register_xri(port, cmd_sbp,
4087 xrip->XRI, ndlp->nlp_DID) == NULL) {
4088 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4089 "Unable to register xri. did=0x%x", did);
4090
4091 emlxs_set_pkt_state(cmd_sbp, IOSTAT_LOCAL_REJECT,
4092 IOERR_NO_XRI, 0);
4093 return (0xff);
4094 }
4095 cmd_sbp->iotag = xrip->iotag;
4096 cmd_sbp->channel = cp;
4097
4098 if (cfg[CFG_TIMEOUT_ENABLE].current) {
4099 timeout =
4100 ((2 * hba->fc_ratov) < 60) ? 60 : (2 * hba->fc_ratov);
4101 } else {
4102 timeout = 0x80000000;
4103 }
4104 cmd_sbp->ticks =
4105 hba->timer_tics + timeout + ((timeout > 0xff) ? 0 : 10);
4106
4107
4108 iocb->ULPCT = 0;
4109 if (fct_task->task_flags & TF_WRITE_DATA) {
4110 iocb->ULPCOMMAND = CMD_FCP_TRECEIVE64_CX;
4111 wqe->CmdType = WQE_TYPE_TRECEIVE; /* Word 11 */
4112
4113 } else { /* TF_READ_DATA */
4114
4115 iocb->ULPCOMMAND = CMD_FCP_TSEND64_CX;
4116 wqe->CmdType = WQE_TYPE_TSEND; /* Word 11 */
4117
4118 if ((dbuf->db_data_size >=
4119 fct_task->task_expected_xfer_length)) {
4120 /* enable auto-rsp AP feature */
4121 wqe->AR = 0x1;
4122 iocb->ULPCT = 0x1; /* for cmpl */
4123 }
4124 }
4125
4126 (void) emlxs_sli4_fct_bde_setup(port, cmd_sbp);
4127
4128 /* Word 6 */
4129 wqe->ContextTag = ndlp->nlp_Rpi;
4130 wqe->XRITag = xrip->XRI;
4131
4132 /* Word 7 */
4133 wqe->Command = iocb->ULPCOMMAND;
4134 wqe->Class = cmd_sbp->class;
4135 wqe->ContextType = WQE_RPI_CONTEXT;
4136 wqe->Timer = ((timeout > 0xff) ? 0 : timeout);
4137 wqe->PU = 1;
4138
4139 /* Word 8 */
4140 wqe->AbortTag = 0;
4141
4142 /* Word 9 */
4143 wqe->RequestTag = xrip->iotag;
4144 wqe->OXId = (uint16_t)fct_cmd->cmd_oxid;
4145
4146 /* Word 10 */
4147 if (xrip->flag & EMLXS_XRI_BUSY) {
4148 wqe->XC = 1;
4149 }
4150
4151 if (!(hba->sli.sli4.param.PHWQ)) {
4152 wqe->QOSd = 1;
4153 wqe->DBDE = 1; /* Data type for BDE 0 */
4154 }
4155
4156 /* Word 11 */
4157 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
4158
4159 /* Word 12 */
4160 wqe->CmdSpecific = dbuf->db_data_size;
4161
4162 return (IOERR_SUCCESS);
4163
2726} /* emlxs_sli4_prep_fct_iocb() */
2727#endif /* SFCT_SUPPORT */
2728
2729
2730/*ARGSUSED*/
2731extern uint32_t
2732emlxs_sli4_prep_fcp_iocb(emlxs_port_t *port, emlxs_buf_t *sbp, int channel)
2733{
2734 emlxs_hba_t *hba = HBA;
2735 fc_packet_t *pkt;
2736 CHANNEL *cp;
2737 RPIobj_t *rpip;
2738 XRIobj_t *xrip;
2739 emlxs_wqe_t *wqe;
2740 IOCBQ *iocbq;
4164} /* emlxs_sli4_prep_fct_iocb() */
4165#endif /* SFCT_SUPPORT */
4166
4167
4168/*ARGSUSED*/
4169extern uint32_t
4170emlxs_sli4_prep_fcp_iocb(emlxs_port_t *port, emlxs_buf_t *sbp, int channel)
4171{
4172 emlxs_hba_t *hba = HBA;
4173 fc_packet_t *pkt;
4174 CHANNEL *cp;
4175 RPIobj_t *rpip;
4176 XRIobj_t *xrip;
4177 emlxs_wqe_t *wqe;
4178 IOCBQ *iocbq;
4179 IOCB *iocb;
2741 NODELIST *node;
2742 uint16_t iotag;
2743 uint32_t did;
2744 off_t offset;
2745
2746 pkt = PRIV2PKT(sbp);
2747 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
2748 cp = &hba->chan[channel];
2749
2750 iocbq = &sbp->iocbq;
2751 iocbq->channel = (void *) cp;
2752 iocbq->port = (void *) port;
2753
2754 wqe = &iocbq->wqe;
4180 NODELIST *node;
4181 uint16_t iotag;
4182 uint32_t did;
4183 off_t offset;
4184
4185 pkt = PRIV2PKT(sbp);
4186 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
4187 cp = &hba->chan[channel];
4188
4189 iocbq = &sbp->iocbq;
4190 iocbq->channel = (void *) cp;
4191 iocbq->port = (void *) port;
4192
4193 wqe = &iocbq->wqe;
4194 iocb = &iocbq->iocb;
2755 bzero((void *)wqe, sizeof (emlxs_wqe_t));
4195 bzero((void *)wqe, sizeof (emlxs_wqe_t));
4196 bzero((void *)iocb, sizeof (IOCB));
2756
2757 /* Find target node object */
2758 node = (NODELIST *)iocbq->node;
2759 rpip = EMLXS_NODE_TO_RPI(port, node);
2760
2761 if (!rpip) {
2762 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
2763 "Unable to find rpi. did=0x%x", did);
2764
2765 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
2766 IOERR_INVALID_RPI, 0);
2767 return (0xff);
2768 }
2769
2770 sbp->channel = cp;
2771 /* Next allocate an Exchange for this command */
4197
4198 /* Find target node object */
4199 node = (NODELIST *)iocbq->node;
4200 rpip = EMLXS_NODE_TO_RPI(port, node);
4201
4202 if (!rpip) {
4203 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4204 "Unable to find rpi. did=0x%x", did);
4205
4206 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4207 IOERR_INVALID_RPI, 0);
4208 return (0xff);
4209 }
4210
4211 sbp->channel = cp;
4212 /* Next allocate an Exchange for this command */
2772 xrip = emlxs_sli4_alloc_xri(hba, sbp, rpip);
4213 xrip = emlxs_sli4_alloc_xri(port, sbp, rpip,
4214 EMLXS_XRI_SOL_FCP_TYPE);
2773
2774 if (!xrip) {
2775 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
2776 "Adapter Busy. Unable to allocate exchange. did=0x%x", did);
2777
2778 return (FC_TRAN_BUSY);
2779 }
2780 sbp->bmp = NULL;
2781 iotag = sbp->iotag;
2782
4215
4216 if (!xrip) {
4217 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4218 "Adapter Busy. Unable to allocate exchange. did=0x%x", did);
4219
4220 return (FC_TRAN_BUSY);
4221 }
4222 sbp->bmp = NULL;
4223 iotag = sbp->iotag;
4224
2783#ifdef SLI4_FASTPATH_DEBUG
2784 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, /* DEBUG */
2785 "Prep FCP iotag: %x xri: %x", iotag, xrip->XRI);
2786#endif
4225#ifdef DEBUG_FASTPATH
4226 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4227 "FCP: Prep xri=%d iotag=%d oxid=%x rpi=%d",
4228 xrip->XRI, xrip->iotag, xrip->rx_id, rpip->RPI);
4229#endif /* DEBUG_FASTPATH */
2787
2788 /* Indicate this is a FCP cmd */
2789 iocbq->flag |= IOCB_FCP_CMD;
2790
2791 if (emlxs_sli4_bde_setup(port, sbp)) {
4230
4231 /* Indicate this is a FCP cmd */
4232 iocbq->flag |= IOCB_FCP_CMD;
4233
4234 if (emlxs_sli4_bde_setup(port, sbp)) {
2792 emlxs_sli4_free_xri(hba, sbp, xrip, 1);
4235 emlxs_sli4_free_xri(port, sbp, xrip, 1);
2793 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
2794 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
2795
2796 return (FC_TRAN_BUSY);
2797 }
2798
4236 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4237 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
4238
4239 return (FC_TRAN_BUSY);
4240 }
4241
2799
2800 /* DEBUG */
2801#ifdef DEBUG_FCP
2802 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4242 /* DEBUG */
4243#ifdef DEBUG_FCP
4244 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2803 "SGLaddr virt %p phys %p size %d", xrip->SGList.virt,
4245 "FCP: SGLaddr virt %p phys %p size %d", xrip->SGList.virt,
2804 xrip->SGList.phys, pkt->pkt_datalen);
4246 xrip->SGList.phys, pkt->pkt_datalen);
2805 emlxs_data_dump(port, "SGL", (uint32_t *)xrip->SGList.virt, 20, 0);
4247 emlxs_data_dump(port, "FCP: SGL", (uint32_t *)xrip->SGList.virt, 20, 0);
2806 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4248 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2807 "CMD virt %p len %d:%d:%d",
4249 "FCP: CMD virt %p len %d:%d:%d",
2808 pkt->pkt_cmd, pkt->pkt_cmdlen, pkt->pkt_rsplen, pkt->pkt_datalen);
4250 pkt->pkt_cmd, pkt->pkt_cmdlen, pkt->pkt_rsplen, pkt->pkt_datalen);
2809 emlxs_data_dump(port, "FCP CMD", (uint32_t *)pkt->pkt_cmd, 10, 0);
2810#endif
4251 emlxs_data_dump(port, "FCP: CMD", (uint32_t *)pkt->pkt_cmd, 10, 0);
4252#endif /* DEBUG_FCP */
2811
2812 offset = (off_t)((uint64_t)((unsigned long)
2813 xrip->SGList.virt) -
2814 (uint64_t)((unsigned long)
2815 hba->sli.sli4.slim2.virt));
2816
2817 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
2818 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
2819
2820 /* if device is FCP-2 device, set the following bit */
2821 /* that says to run the FC-TAPE protocol. */
2822 if (node->nlp_fcp_info & NLP_FCP_2_DEVICE) {
2823 wqe->ERP = 1;
2824 }
2825
2826 if (pkt->pkt_datalen == 0) {
4253
4254 offset = (off_t)((uint64_t)((unsigned long)
4255 xrip->SGList.virt) -
4256 (uint64_t)((unsigned long)
4257 hba->sli.sli4.slim2.virt));
4258
4259 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
4260 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
4261
4262 /* if device is FCP-2 device, set the following bit */
4263 /* that says to run the FC-TAPE protocol. */
4264 if (node->nlp_fcp_info & NLP_FCP_2_DEVICE) {
4265 wqe->ERP = 1;
4266 }
4267
4268 if (pkt->pkt_datalen == 0) {
4269 iocb->ULPCOMMAND = CMD_FCP_ICMND64_CR;
2827 wqe->Command = CMD_FCP_ICMND64_CR;
2828 wqe->CmdType = WQE_TYPE_FCP_DATA_IN;
2829 } else if (pkt->pkt_tran_type == FC_PKT_FCP_READ) {
4270 wqe->Command = CMD_FCP_ICMND64_CR;
4271 wqe->CmdType = WQE_TYPE_FCP_DATA_IN;
4272 } else if (pkt->pkt_tran_type == FC_PKT_FCP_READ) {
4273 iocb->ULPCOMMAND = CMD_FCP_IREAD64_CR;
2830 wqe->Command = CMD_FCP_IREAD64_CR;
2831 wqe->CmdType = WQE_TYPE_FCP_DATA_IN;
4274 wqe->Command = CMD_FCP_IREAD64_CR;
4275 wqe->CmdType = WQE_TYPE_FCP_DATA_IN;
2832 wqe->PU = PARM_READ_CHECK;
4276 wqe->PU = PARM_XFER_CHECK;
2833 } else {
4277 } else {
4278 iocb->ULPCOMMAND = CMD_FCP_IWRITE64_CR;
2834 wqe->Command = CMD_FCP_IWRITE64_CR;
2835 wqe->CmdType = WQE_TYPE_FCP_DATA_OUT;
2836 }
2837 wqe->un.FcpCmd.TotalTransferCount = pkt->pkt_datalen;
2838
4279 wqe->Command = CMD_FCP_IWRITE64_CR;
4280 wqe->CmdType = WQE_TYPE_FCP_DATA_OUT;
4281 }
4282 wqe->un.FcpCmd.TotalTransferCount = pkt->pkt_datalen;
4283
4284 if (!(hba->sli.sli4.param.PHWQ)) {
4285 wqe->DBDE = 1; /* Data type for BDE 0 */
4286 }
2839 wqe->ContextTag = rpip->RPI;
2840 wqe->ContextType = WQE_RPI_CONTEXT;
2841 wqe->XRITag = xrip->XRI;
2842 wqe->Timer =
2843 ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
2844
2845 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_CHAINED_SEQ) {
2846 wqe->CCPE = 1;

--- 6 unchanged lines hidden (view full) ---

2853 break;
2854 case FC_TRAN_CLASS3:
2855 default:
2856 wqe->Class = CLASS3;
2857 break;
2858 }
2859 sbp->class = wqe->Class;
2860 wqe->RequestTag = iotag;
4287 wqe->ContextTag = rpip->RPI;
4288 wqe->ContextType = WQE_RPI_CONTEXT;
4289 wqe->XRITag = xrip->XRI;
4290 wqe->Timer =
4291 ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
4292
4293 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_CHAINED_SEQ) {
4294 wqe->CCPE = 1;

--- 6 unchanged lines hidden (view full) ---

4301 break;
4302 case FC_TRAN_CLASS3:
4303 default:
4304 wqe->Class = CLASS3;
4305 break;
4306 }
4307 sbp->class = wqe->Class;
4308 wqe->RequestTag = iotag;
2861 wqe->CQId = 0x3ff; /* default CQ for response */
4309 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
4310
2862 return (FC_SUCCESS);
2863} /* emlxs_sli4_prep_fcp_iocb() */
2864
2865
2866/*ARGSUSED*/
2867static uint32_t
2868emlxs_sli4_prep_ip_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)
2869{

--- 7 unchanged lines hidden (view full) ---

2877emlxs_sli4_prep_els_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)
2878{
2879 emlxs_hba_t *hba = HBA;
2880 fc_packet_t *pkt;
2881 IOCBQ *iocbq;
2882 IOCB *iocb;
2883 emlxs_wqe_t *wqe;
2884 FCFIobj_t *fcfp;
4311 return (FC_SUCCESS);
4312} /* emlxs_sli4_prep_fcp_iocb() */
4313
4314
4315/*ARGSUSED*/
4316static uint32_t
4317emlxs_sli4_prep_ip_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)
4318{

--- 7 unchanged lines hidden (view full) ---

4326emlxs_sli4_prep_els_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)
4327{
4328 emlxs_hba_t *hba = HBA;
4329 fc_packet_t *pkt;
4330 IOCBQ *iocbq;
4331 IOCB *iocb;
4332 emlxs_wqe_t *wqe;
4333 FCFIobj_t *fcfp;
4334 RPIobj_t *reserved_rpip = NULL;
2885 RPIobj_t *rpip = NULL;
2886 XRIobj_t *xrip;
2887 CHANNEL *cp;
2888 uint32_t did;
2889 uint32_t cmd;
2890 ULP_SGE64 stage_sge;
2891 ULP_SGE64 *sge;
2892 ddi_dma_cookie_t *cp_cmd;

--- 27 unchanged lines hidden (view full) ---

2920#endif /* >= EMLXS_MODREV3 */
2921
2922 /* CMD payload */
2923 sge = &stage_sge;
2924 sge->addrHigh = PADDR_HI(cp_cmd->dmac_laddress);
2925 sge->addrLow = PADDR_LO(cp_cmd->dmac_laddress);
2926 sge->length = pkt->pkt_cmdlen;
2927 sge->offset = 0;
4335 RPIobj_t *rpip = NULL;
4336 XRIobj_t *xrip;
4337 CHANNEL *cp;
4338 uint32_t did;
4339 uint32_t cmd;
4340 ULP_SGE64 stage_sge;
4341 ULP_SGE64 *sge;
4342 ddi_dma_cookie_t *cp_cmd;

--- 27 unchanged lines hidden (view full) ---

4370#endif /* >= EMLXS_MODREV3 */
4371
4372 /* CMD payload */
4373 sge = &stage_sge;
4374 sge->addrHigh = PADDR_HI(cp_cmd->dmac_laddress);
4375 sge->addrLow = PADDR_LO(cp_cmd->dmac_laddress);
4376 sge->length = pkt->pkt_cmdlen;
4377 sge->offset = 0;
2928 sge->reserved = 0;
4378 sge->type = 0;
2929
4379
4380 cmd = *((uint32_t *)pkt->pkt_cmd);
4381 cmd &= ELS_CMD_MASK;
4382
2930 /* Initalize iocb */
2931 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
2932 /* ELS Response */
2933
4383 /* Initalize iocb */
4384 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
4385 /* ELS Response */
4386
2934 xrip = emlxs_sli4_register_xri(hba, sbp,
2935 pkt->pkt_cmd_fhdr.rx_id);
4387 sbp->xrip = 0;
4388 xrip = emlxs_sli4_register_xri(port, sbp,
4389 pkt->pkt_cmd_fhdr.rx_id, did);
2936
2937 if (!xrip) {
2938 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
2939 "Unable to find XRI. rxid=%x",
2940 pkt->pkt_cmd_fhdr.rx_id);
2941
2942 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
2943 IOERR_NO_XRI, 0);

--- 11 unchanged lines hidden (view full) ---

2955 pkt->pkt_cmd_fhdr.rx_id);
2956
2957 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
2958 IOERR_INVALID_RPI, 0);
2959 return (0xff);
2960 }
2961
2962 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4390
4391 if (!xrip) {
4392 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
4393 "Unable to find XRI. rxid=%x",
4394 pkt->pkt_cmd_fhdr.rx_id);
4395
4396 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4397 IOERR_NO_XRI, 0);

--- 11 unchanged lines hidden (view full) ---

4409 pkt->pkt_cmd_fhdr.rx_id);
4410
4411 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4412 IOERR_INVALID_RPI, 0);
4413 return (0xff);
4414 }
4415
4416 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2963 "Prep ELS XRI: xri=%x iotag=%x oxid=%x rpi=%x",
4417 "ELS: Prep xri=%d iotag=%d oxid=%x rpi=%d",
2964 xrip->XRI, xrip->iotag, xrip->rx_id, rpip->RPI);
2965
4418 xrip->XRI, xrip->iotag, xrip->rx_id, rpip->RPI);
4419
4420 iocb->ULPCOMMAND = CMD_XMIT_ELS_RSP64_CX;
2966 wqe->Command = CMD_XMIT_ELS_RSP64_CX;
2967 wqe->CmdType = WQE_TYPE_GEN;
4421 wqe->Command = CMD_XMIT_ELS_RSP64_CX;
4422 wqe->CmdType = WQE_TYPE_GEN;
4423 if (!(hba->sli.sli4.param.PHWQ)) {
4424 wqe->DBDE = 1; /* Data type for BDE 0 */
4425 }
2968
2969 wqe->un.ElsRsp.Payload.addrHigh = sge->addrHigh;
2970 wqe->un.ElsRsp.Payload.addrLow = sge->addrLow;
2971 wqe->un.ElsRsp.Payload.tus.f.bdeSize = pkt->pkt_cmdlen;
4426
4427 wqe->un.ElsRsp.Payload.addrHigh = sge->addrHigh;
4428 wqe->un.ElsRsp.Payload.addrLow = sge->addrLow;
4429 wqe->un.ElsRsp.Payload.tus.f.bdeSize = pkt->pkt_cmdlen;
4430 wqe->un.ElsCmd.PayloadLength = pkt->pkt_cmdlen;
2972
2973 wqe->un.ElsRsp.RemoteId = did;
2974 wqe->PU = 0x3;
4431
4432 wqe->un.ElsRsp.RemoteId = did;
4433 wqe->PU = 0x3;
4434 wqe->OXId = xrip->rx_id;
2975
2976 sge->last = 1;
2977 /* Now sge is fully staged */
2978
2979 sge = xrip->SGList.virt;
2980 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
2981 sizeof (ULP_SGE64));
2982
4435
4436 sge->last = 1;
4437 /* Now sge is fully staged */
4438
4439 sge = xrip->SGList.virt;
4440 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
4441 sizeof (ULP_SGE64));
4442
2983 wqe->ContextTag = port->VPIobj.VPI;
2984 wqe->ContextType = WQE_VPI_CONTEXT;
2985 wqe->OXId = xrip->rx_id;
4443 if (rpip->RPI == FABRIC_RPI) {
4444 wqe->ContextTag = port->vpip->VPI;
4445 wqe->ContextType = WQE_VPI_CONTEXT;
4446 } else {
4447 wqe->ContextTag = rpip->RPI;
4448 wqe->ContextType = WQE_RPI_CONTEXT;
4449 }
2986
4450
4451 if ((cmd == ELS_CMD_ACC) && (sbp->ucmd == ELS_CMD_FLOGI)) {
4452 wqe->un.ElsCmd.SP = 1;
4453 wqe->un.ElsCmd.LocalId = 0xFFFFFE;
4454 }
4455
2987 } else {
2988 /* ELS Request */
2989
4456 } else {
4457 /* ELS Request */
4458
4459 fcfp = port->vpip->vfip->fcfp;
2990 node = (emlxs_node_t *)iocbq->node;
2991 rpip = EMLXS_NODE_TO_RPI(port, node);
4460 node = (emlxs_node_t *)iocbq->node;
4461 rpip = EMLXS_NODE_TO_RPI(port, node);
2992 fcfp = port->VPIobj.vfip->fcfp;
2993
2994 if (!rpip) {
4462
4463 if (!rpip) {
2995 rpip = port->VPIobj.rpip;
4464 /* Use the fabric rpi */
4465 rpip = port->vpip->fabric_rpip;
2996 }
2997
2998 /* Next allocate an Exchange for this command */
4466 }
4467
4468 /* Next allocate an Exchange for this command */
2999 xrip = emlxs_sli4_alloc_xri(hba, sbp, rpip);
4469 xrip = emlxs_sli4_alloc_xri(port, sbp, rpip,
4470 EMLXS_XRI_SOL_ELS_TYPE);
3000
3001 if (!xrip) {
3002 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3003 "Adapter Busy. Unable to allocate exchange. "
3004 "did=0x%x", did);
3005
3006 return (FC_TRAN_BUSY);
3007 }
3008
3009 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4471
4472 if (!xrip) {
4473 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4474 "Adapter Busy. Unable to allocate exchange. "
4475 "did=0x%x", did);
4476
4477 return (FC_TRAN_BUSY);
4478 }
4479
4480 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3010 "Prep ELS XRI: xri=%x iotag=%x rpi=%x", xrip->XRI,
3011 xrip->iotag, rpip->RPI);
4481 "ELS: Prep xri=%d iotag=%d rpi=%d",
4482 xrip->XRI, xrip->iotag, rpip->RPI);
3012
4483
4484 iocb->ULPCOMMAND = CMD_ELS_REQUEST64_CR;
3013 wqe->Command = CMD_ELS_REQUEST64_CR;
3014 wqe->CmdType = WQE_TYPE_ELS;
4485 wqe->Command = CMD_ELS_REQUEST64_CR;
4486 wqe->CmdType = WQE_TYPE_ELS;
4487 if (!(hba->sli.sli4.param.PHWQ)) {
4488 wqe->DBDE = 1; /* Data type for BDE 0 */
4489 }
3015
3016 wqe->un.ElsCmd.Payload.addrHigh = sge->addrHigh;
3017 wqe->un.ElsCmd.Payload.addrLow = sge->addrLow;
3018 wqe->un.ElsCmd.Payload.tus.f.bdeSize = pkt->pkt_cmdlen;
3019
4490
4491 wqe->un.ElsCmd.Payload.addrHigh = sge->addrHigh;
4492 wqe->un.ElsCmd.Payload.addrLow = sge->addrLow;
4493 wqe->un.ElsCmd.Payload.tus.f.bdeSize = pkt->pkt_cmdlen;
4494
4495 wqe->un.ElsCmd.RemoteId = did;
4496 wqe->Timer = ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
4497
3020 /* setup for rsp */
3021 iocb->un.elsreq64.remoteID = (did == BCAST_DID) ? 0 : did;
3022 iocb->ULPPU = 1; /* Wd4 is relative offset */
3023
3024 sge->last = 0;
3025
3026 sge = xrip->SGList.virt;
3027 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,

--- 12 unchanged lines hidden (view full) ---

3040 /* Now sge is fully staged */
3041
3042 sge = xrip->SGList.virt;
3043 sge++;
3044 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
3045 sizeof (ULP_SGE64));
3046#ifdef DEBUG_ELS
3047 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4498 /* setup for rsp */
4499 iocb->un.elsreq64.remoteID = (did == BCAST_DID) ? 0 : did;
4500 iocb->ULPPU = 1; /* Wd4 is relative offset */
4501
4502 sge->last = 0;
4503
4504 sge = xrip->SGList.virt;
4505 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,

--- 12 unchanged lines hidden (view full) ---

4518 /* Now sge is fully staged */
4519
4520 sge = xrip->SGList.virt;
4521 sge++;
4522 BE_SWAP32_BCOPY((uint8_t *)&stage_sge, (uint8_t *)sge,
4523 sizeof (ULP_SGE64));
4524#ifdef DEBUG_ELS
4525 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3048 "SGLaddr virt %p phys %p",
4526 "ELS: SGLaddr virt %p phys %p",
3049 xrip->SGList.virt, xrip->SGList.phys);
3050 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4527 xrip->SGList.virt, xrip->SGList.phys);
4528 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3051 "PAYLOAD virt %p phys %p",
4529 "ELS: PAYLOAD virt %p phys %p",
3052 pkt->pkt_cmd, cp_cmd->dmac_laddress);
4530 pkt->pkt_cmd, cp_cmd->dmac_laddress);
3053 emlxs_data_dump(port, "SGL", (uint32_t *)xrip->SGList.virt,
4531 emlxs_data_dump(port, "ELS: SGL", (uint32_t *)xrip->SGList.virt,
3054 12, 0);
4532 12, 0);
3055#endif
4533#endif /* DEBUG_ELS */
3056
4534
3057 cmd = *((uint32_t *)pkt->pkt_cmd);
3058 cmd &= ELS_CMD_MASK;
3059
3060 switch (cmd) {
3061 case ELS_CMD_FLOGI:
3062 wqe->un.ElsCmd.SP = 1;
4535 switch (cmd) {
4536 case ELS_CMD_FLOGI:
4537 wqe->un.ElsCmd.SP = 1;
3063 wqe->ContextTag = fcfp->FCFI;
3064 wqe->ContextType = WQE_FCFI_CONTEXT;
4538
4539 if ((hba->sli_intf & SLI_INTF_IF_TYPE_MASK) ==
4540 SLI_INTF_IF_TYPE_0) {
4541 wqe->ContextTag = fcfp->FCFI;
4542 wqe->ContextType = WQE_FCFI_CONTEXT;
4543 } else {
4544 wqe->ContextTag = port->vpip->VPI;
4545 wqe->ContextType = WQE_VPI_CONTEXT;
4546 }
4547
3065 if (hba->flag & FC_FIP_SUPPORTED) {
3066 wqe->CmdType |= WQE_TYPE_MASK_FIP;
4548 if (hba->flag & FC_FIP_SUPPORTED) {
4549 wqe->CmdType |= WQE_TYPE_MASK_FIP;
3067 wqe->ELSId |= WQE_ELSID_FLOGI;
3068 }
4550 }
4551
4552 if (hba->topology == TOPOLOGY_LOOP) {
4553 wqe->un.ElsCmd.LocalId = port->did;
4554 }
4555
4556 wqe->ELSId = WQE_ELSID_FLOGI;
3069 break;
3070 case ELS_CMD_FDISC:
3071 wqe->un.ElsCmd.SP = 1;
4557 break;
4558 case ELS_CMD_FDISC:
4559 wqe->un.ElsCmd.SP = 1;
3072 wqe->ContextTag = port->VPIobj.VPI;
4560 wqe->ContextTag = port->vpip->VPI;
3073 wqe->ContextType = WQE_VPI_CONTEXT;
4561 wqe->ContextType = WQE_VPI_CONTEXT;
4562
3074 if (hba->flag & FC_FIP_SUPPORTED) {
3075 wqe->CmdType |= WQE_TYPE_MASK_FIP;
4563 if (hba->flag & FC_FIP_SUPPORTED) {
4564 wqe->CmdType |= WQE_TYPE_MASK_FIP;
3076 wqe->ELSId |= WQE_ELSID_FDISC;
3077 }
4565 }
4566
4567 wqe->ELSId = WQE_ELSID_FDISC;
3078 break;
3079 case ELS_CMD_LOGO:
4568 break;
4569 case ELS_CMD_LOGO:
3080 if (did == FABRIC_DID) {
3081 wqe->ContextTag = fcfp->FCFI;
3082 wqe->ContextType = WQE_FCFI_CONTEXT;
3083 if (hba->flag & FC_FIP_SUPPORTED) {
3084 wqe->CmdType |= WQE_TYPE_MASK_FIP;
3085 wqe->ELSId |= WQE_ELSID_LOGO;
4570 if ((did == FABRIC_DID) &&
4571 (hba->flag & FC_FIP_SUPPORTED)) {
4572 wqe->CmdType |= WQE_TYPE_MASK_FIP;
4573 }
4574
4575 wqe->ContextTag = port->vpip->VPI;
4576 wqe->ContextType = WQE_VPI_CONTEXT;
4577 wqe->ELSId = WQE_ELSID_LOGO;
4578 break;
4579 case ELS_CMD_PLOGI:
4580 if (rpip->RPI == FABRIC_RPI) {
4581 if (hba->flag & FC_PT_TO_PT) {
4582 wqe->un.ElsCmd.SP = 1;
4583 wqe->un.ElsCmd.LocalId = port->did;
3086 }
4584 }
3087 } else {
3088 wqe->ContextTag = port->VPIobj.VPI;
4585
4586 wqe->ContextTag = port->vpip->VPI;
3089 wqe->ContextType = WQE_VPI_CONTEXT;
4587 wqe->ContextType = WQE_VPI_CONTEXT;
4588 } else {
4589 wqe->ContextTag = rpip->RPI;
4590 wqe->ContextType = WQE_RPI_CONTEXT;
3090 }
4591 }
3091 break;
3092
4592
3093 case ELS_CMD_SCR:
3094 case ELS_CMD_PLOGI:
3095 case ELS_CMD_PRLI:
4593 wqe->ELSId = WQE_ELSID_PLOGI;
4594 break;
3096 default:
4595 default:
3097 wqe->ContextTag = port->VPIobj.VPI;
3098 wqe->ContextType = WQE_VPI_CONTEXT;
4596 if (rpip->RPI == FABRIC_RPI) {
4597 wqe->ContextTag = port->vpip->VPI;
4598 wqe->ContextType = WQE_VPI_CONTEXT;
4599 } else {
4600 wqe->ContextTag = rpip->RPI;
4601 wqe->ContextType = WQE_RPI_CONTEXT;
4602 }
4603
4604 wqe->ELSId = WQE_ELSID_CMD;
3099 break;
3100 }
4605 break;
4606 }
3101 wqe->un.ElsCmd.RemoteId = did;
3102 wqe->Timer = ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
4607
4608#ifdef SFCT_SUPPORT
4609 /* This allows fct to abort the request */
4610 if (sbp->fct_cmd) {
4611 sbp->fct_cmd->cmd_oxid = xrip->XRI;
4612 sbp->fct_cmd->cmd_rxid = 0xFFFF;
4613 }
4614#endif /* SFCT_SUPPORT */
3103 }
3104
4615 }
4616
4617 if (wqe->ContextType == WQE_VPI_CONTEXT) {
4618 reserved_rpip = emlxs_rpi_reserve_notify(port, did, xrip);
4619
4620 if (!reserved_rpip) {
4621 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
4622 "Unable to alloc reserved RPI. rxid=%x. Rejecting.",
4623 pkt->pkt_cmd_fhdr.rx_id);
4624
4625 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4626 IOERR_INVALID_RPI, 0);
4627 return (0xff);
4628 }
4629
4630 /* Store the reserved rpi */
4631 if (wqe->Command == CMD_ELS_REQUEST64_CR) {
4632 wqe->OXId = reserved_rpip->RPI;
4633 } else {
4634 wqe->CmdSpecific = reserved_rpip->RPI;
4635 }
4636 }
4637
3105 offset = (off_t)((uint64_t)((unsigned long)
3106 xrip->SGList.virt) -
3107 (uint64_t)((unsigned long)
3108 hba->sli.sli4.slim2.virt));
3109
3110 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
3111 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
3112

--- 9 unchanged lines hidden (view full) ---

3122 case FC_TRAN_CLASS3:
3123 default:
3124 wqe->Class = CLASS3;
3125 break;
3126 }
3127 sbp->class = wqe->Class;
3128 wqe->XRITag = xrip->XRI;
3129 wqe->RequestTag = xrip->iotag;
4638 offset = (off_t)((uint64_t)((unsigned long)
4639 xrip->SGList.virt) -
4640 (uint64_t)((unsigned long)
4641 hba->sli.sli4.slim2.virt));
4642
4643 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
4644 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
4645

--- 9 unchanged lines hidden (view full) ---

4655 case FC_TRAN_CLASS3:
4656 default:
4657 wqe->Class = CLASS3;
4658 break;
4659 }
4660 sbp->class = wqe->Class;
4661 wqe->XRITag = xrip->XRI;
4662 wqe->RequestTag = xrip->iotag;
3130 wqe->CQId = 0x3ff;
4663 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
3131 return (FC_SUCCESS);
3132
3133} /* emlxs_sli4_prep_els_iocb() */
3134
3135
3136/*ARGSUSED*/
3137static uint32_t
3138emlxs_sli4_prep_ct_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)

--- 26 unchanged lines hidden (view full) ---

3165
3166 sbp->bmp = NULL;
3167 sbp->channel = cp;
3168
3169 /* Initalize wqe */
3170 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
3171 /* CT Response */
3172
4664 return (FC_SUCCESS);
4665
4666} /* emlxs_sli4_prep_els_iocb() */
4667
4668
4669/*ARGSUSED*/
4670static uint32_t
4671emlxs_sli4_prep_ct_iocb(emlxs_port_t *port, emlxs_buf_t *sbp)

--- 26 unchanged lines hidden (view full) ---

4698
4699 sbp->bmp = NULL;
4700 sbp->channel = cp;
4701
4702 /* Initalize wqe */
4703 if (pkt->pkt_tran_type == FC_PKT_OUTBOUND) {
4704 /* CT Response */
4705
3173 xrip = emlxs_sli4_register_xri(hba, sbp,
3174 pkt->pkt_cmd_fhdr.rx_id);
4706 sbp->xrip = 0;
4707 xrip = emlxs_sli4_register_xri(port, sbp,
4708 pkt->pkt_cmd_fhdr.rx_id, did);
3175
3176 if (!xrip) {
3177 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
3178 "Unable to find XRI. rxid=%x",
3179 pkt->pkt_cmd_fhdr.rx_id);
3180
3181 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
3182 IOERR_NO_XRI, 0);

--- 11 unchanged lines hidden (view full) ---

3194 pkt->pkt_cmd_fhdr.rx_id);
3195
3196 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
3197 IOERR_INVALID_RPI, 0);
3198 return (0xff);
3199 }
3200
3201 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4709
4710 if (!xrip) {
4711 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
4712 "Unable to find XRI. rxid=%x",
4713 pkt->pkt_cmd_fhdr.rx_id);
4714
4715 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4716 IOERR_NO_XRI, 0);

--- 11 unchanged lines hidden (view full) ---

4728 pkt->pkt_cmd_fhdr.rx_id);
4729
4730 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4731 IOERR_INVALID_RPI, 0);
4732 return (0xff);
4733 }
4734
4735 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3202 "Prep CT XRI: xri=%x iotag=%x oxid=%x", xrip->XRI,
3203 xrip->iotag, xrip->rx_id);
4736 "CT: Prep xri=%d iotag=%d oxid=%x rpi=%d",
4737 xrip->XRI, xrip->iotag, xrip->rx_id, rpip->RPI);
3204
3205 if (emlxs_sli4_bde_setup(port, sbp)) {
3206 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3207 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
3208
3209 return (FC_TRAN_BUSY);
3210 }
3211
4738
4739 if (emlxs_sli4_bde_setup(port, sbp)) {
4740 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4741 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
4742
4743 return (FC_TRAN_BUSY);
4744 }
4745
4746 if (!(hba->model_info.chip & EMLXS_BE_CHIPS)) {
4747 wqe->un.XmitSeq.Rsvd0 = 0; /* Word3 now reserved */
4748 }
4749
4750 if (!(hba->sli.sli4.param.PHWQ)) {
4751 wqe->DBDE = 1; /* Data type for BDE 0 */
4752 }
4753
4754 iocb->ULPCOMMAND = CMD_XMIT_SEQUENCE64_CR;
3212 wqe->CmdType = WQE_TYPE_GEN;
3213 wqe->Command = CMD_XMIT_SEQUENCE64_CR;
4755 wqe->CmdType = WQE_TYPE_GEN;
4756 wqe->Command = CMD_XMIT_SEQUENCE64_CR;
3214 wqe->un.XmitSeq.la = 1;
4757 wqe->LenLoc = 2;
3215
4758
4759 if (((SLI_CT_REQUEST *) pkt->pkt_cmd)->CommandResponse.bits.
4760 CmdRsp == (LE_SWAP16(SLI_CT_LOOPBACK))) {
4761 wqe->un.XmitSeq.xo = 1;
4762 } else {
4763 wqe->un.XmitSeq.xo = 0;
4764 }
4765
3216 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_LAST_SEQ) {
3217 wqe->un.XmitSeq.ls = 1;
3218 }
3219
3220 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_SEQ_INITIATIVE) {
3221 wqe->un.XmitSeq.si = 1;
3222 }
3223
3224 wqe->un.XmitSeq.DFctl = pkt->pkt_cmd_fhdr.df_ctl;
3225 wqe->un.XmitSeq.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
3226 wqe->un.XmitSeq.Type = pkt->pkt_cmd_fhdr.type;
3227 wqe->OXId = xrip->rx_id;
3228 wqe->XC = 0; /* xri_tag is a new exchange */
4766 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_LAST_SEQ) {
4767 wqe->un.XmitSeq.ls = 1;
4768 }
4769
4770 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_SEQ_INITIATIVE) {
4771 wqe->un.XmitSeq.si = 1;
4772 }
4773
4774 wqe->un.XmitSeq.DFctl = pkt->pkt_cmd_fhdr.df_ctl;
4775 wqe->un.XmitSeq.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
4776 wqe->un.XmitSeq.Type = pkt->pkt_cmd_fhdr.type;
4777 wqe->OXId = xrip->rx_id;
4778 wqe->XC = 0; /* xri_tag is a new exchange */
3229 wqe->CmdSpecific[0] = wqe->un.GenReq.Payload.tus.f.bdeSize;
4779 wqe->CmdSpecific = wqe->un.GenReq.Payload.tus.f.bdeSize;
3230
3231 } else {
3232 /* CT Request */
3233
3234 node = (emlxs_node_t *)iocbq->node;
3235 rpip = EMLXS_NODE_TO_RPI(port, node);
3236
3237 if (!rpip) {
3238 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
4780
4781 } else {
4782 /* CT Request */
4783
4784 node = (emlxs_node_t *)iocbq->node;
4785 rpip = EMLXS_NODE_TO_RPI(port, node);
4786
4787 if (!rpip) {
4788 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg,
3239 "Unable to find rpi. did=0x%x rpi=%x",
4789 "Unable to find rpi. did=0x%x rpi=%d",
3240 did, node->nlp_Rpi);
3241
3242 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
3243 IOERR_INVALID_RPI, 0);
3244 return (0xff);
3245 }
3246
3247 /* Next allocate an Exchange for this command */
4790 did, node->nlp_Rpi);
4791
4792 emlxs_set_pkt_state(sbp, IOSTAT_LOCAL_REJECT,
4793 IOERR_INVALID_RPI, 0);
4794 return (0xff);
4795 }
4796
4797 /* Next allocate an Exchange for this command */
3248 xrip = emlxs_sli4_alloc_xri(hba, sbp, rpip);
4798 xrip = emlxs_sli4_alloc_xri(port, sbp, rpip,
4799 EMLXS_XRI_SOL_CT_TYPE);
3249
3250 if (!xrip) {
3251 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3252 "Adapter Busy. Unable to allocate exchange. "
3253 "did=0x%x", did);
3254
3255 return (FC_TRAN_BUSY);
3256 }
3257
3258 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4800
4801 if (!xrip) {
4802 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4803 "Adapter Busy. Unable to allocate exchange. "
4804 "did=0x%x", did);
4805
4806 return (FC_TRAN_BUSY);
4807 }
4808
4809 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3259 "Prep CT XRI: %x iotag %x", xrip->XRI, xrip->iotag);
4810 "CT: Prep xri=%d iotag=%d oxid=%x rpi=%d",
4811 xrip->XRI, xrip->iotag, xrip->rx_id, rpip->RPI);
3260
3261 if (emlxs_sli4_bde_setup(port, sbp)) {
3262 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
3263 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
3264
4812
4813 if (emlxs_sli4_bde_setup(port, sbp)) {
4814 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
4815 "Adapter Busy. Unable to setup SGE. did=0x%x", did);
4816
3265 emlxs_sli4_free_xri(hba, sbp, xrip, 1);
4817 emlxs_sli4_free_xri(port, sbp, xrip, 1);
3266 return (FC_TRAN_BUSY);
3267 }
3268
4818 return (FC_TRAN_BUSY);
4819 }
4820
4821 if (!(hba->sli.sli4.param.PHWQ)) {
4822 wqe->DBDE = 1; /* Data type for BDE 0 */
4823 }
4824
4825 iocb->ULPCOMMAND = CMD_GEN_REQUEST64_CR;
3269 wqe->CmdType = WQE_TYPE_GEN;
3270 wqe->Command = CMD_GEN_REQUEST64_CR;
3271 wqe->un.GenReq.la = 1;
3272 wqe->un.GenReq.DFctl = pkt->pkt_cmd_fhdr.df_ctl;
3273 wqe->un.GenReq.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
3274 wqe->un.GenReq.Type = pkt->pkt_cmd_fhdr.type;
4826 wqe->CmdType = WQE_TYPE_GEN;
4827 wqe->Command = CMD_GEN_REQUEST64_CR;
4828 wqe->un.GenReq.la = 1;
4829 wqe->un.GenReq.DFctl = pkt->pkt_cmd_fhdr.df_ctl;
4830 wqe->un.GenReq.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
4831 wqe->un.GenReq.Type = pkt->pkt_cmd_fhdr.type;
3275 wqe->Timer = ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
3276
3277#ifdef DEBUG_CT
3278 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4832
4833#ifdef DEBUG_CT
4834 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3279 "SGLaddr virt %p phys %p", xrip->SGList.virt,
4835 "CT: SGLaddr virt %p phys %p", xrip->SGList.virt,
3280 xrip->SGList.phys);
4836 xrip->SGList.phys);
3281 emlxs_data_dump(port, "SGL", (uint32_t *)xrip->SGList.virt,
4837 emlxs_data_dump(port, "CT: SGL", (uint32_t *)xrip->SGList.virt,
3282 12, 0);
3283 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4838 12, 0);
4839 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3284 "CMD virt %p len %d:%d",
4840 "CT: CMD virt %p len %d:%d",
3285 pkt->pkt_cmd, pkt->pkt_cmdlen, pkt->pkt_rsplen);
4841 pkt->pkt_cmd, pkt->pkt_cmdlen, pkt->pkt_rsplen);
3286 emlxs_data_dump(port, "DATA", (uint32_t *)pkt->pkt_cmd, 20, 0);
4842 emlxs_data_dump(port, "CT: DATA", (uint32_t *)pkt->pkt_cmd,
4843 20, 0);
3287#endif /* DEBUG_CT */
4844#endif /* DEBUG_CT */
4845
4846#ifdef SFCT_SUPPORT
4847 /* This allows fct to abort the request */
4848 if (sbp->fct_cmd) {
4849 sbp->fct_cmd->cmd_oxid = xrip->XRI;
4850 sbp->fct_cmd->cmd_rxid = 0xFFFF;
4851 }
4852#endif /* SFCT_SUPPORT */
3288 }
3289
3290 /* Setup for rsp */
3291 iocb->un.genreq64.w5.hcsw.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
3292 iocb->un.genreq64.w5.hcsw.Type = pkt->pkt_cmd_fhdr.type;
3293 iocb->un.genreq64.w5.hcsw.Dfctl = pkt->pkt_cmd_fhdr.df_ctl;
3294 iocb->ULPPU = 1; /* Wd4 is relative offset */
3295
3296 offset = (off_t)((uint64_t)((unsigned long)
3297 xrip->SGList.virt) -
3298 (uint64_t)((unsigned long)
3299 hba->sli.sli4.slim2.virt));
3300
3301 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
3302 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
3303
3304 wqe->ContextTag = rpip->RPI;
3305 wqe->ContextType = WQE_RPI_CONTEXT;
3306 wqe->XRITag = xrip->XRI;
4853 }
4854
4855 /* Setup for rsp */
4856 iocb->un.genreq64.w5.hcsw.Rctl = pkt->pkt_cmd_fhdr.r_ctl;
4857 iocb->un.genreq64.w5.hcsw.Type = pkt->pkt_cmd_fhdr.type;
4858 iocb->un.genreq64.w5.hcsw.Dfctl = pkt->pkt_cmd_fhdr.df_ctl;
4859 iocb->ULPPU = 1; /* Wd4 is relative offset */
4860
4861 offset = (off_t)((uint64_t)((unsigned long)
4862 xrip->SGList.virt) -
4863 (uint64_t)((unsigned long)
4864 hba->sli.sli4.slim2.virt));
4865
4866 EMLXS_MPDATA_SYNC(xrip->SGList.dma_handle, offset,
4867 xrip->SGList.size, DDI_DMA_SYNC_FORDEV);
4868
4869 wqe->ContextTag = rpip->RPI;
4870 wqe->ContextType = WQE_RPI_CONTEXT;
4871 wqe->XRITag = xrip->XRI;
4872 wqe->Timer = ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout);
3307
3308 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_CHAINED_SEQ) {
3309 wqe->CCPE = 1;
3310 wqe->CCP = pkt->pkt_cmd_fhdr.rsvd;
3311 }
3312
3313 switch (FC_TRAN_CLASS(pkt->pkt_tran_flags)) {
3314 case FC_TRAN_CLASS2:
3315 wqe->Class = CLASS2;
3316 break;
3317 case FC_TRAN_CLASS3:
3318 default:
3319 wqe->Class = CLASS3;
3320 break;
3321 }
3322 sbp->class = wqe->Class;
3323 wqe->RequestTag = xrip->iotag;
4873
4874 if (pkt->pkt_cmd_fhdr.f_ctl & F_CTL_CHAINED_SEQ) {
4875 wqe->CCPE = 1;
4876 wqe->CCP = pkt->pkt_cmd_fhdr.rsvd;
4877 }
4878
4879 switch (FC_TRAN_CLASS(pkt->pkt_tran_flags)) {
4880 case FC_TRAN_CLASS2:
4881 wqe->Class = CLASS2;
4882 break;
4883 case FC_TRAN_CLASS3:
4884 default:
4885 wqe->Class = CLASS3;
4886 break;
4887 }
4888 sbp->class = wqe->Class;
4889 wqe->RequestTag = xrip->iotag;
3324 wqe->CQId = 0x3ff;
4890 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
3325 return (FC_SUCCESS);
3326
3327} /* emlxs_sli4_prep_ct_iocb() */
3328
3329
3330/*ARGSUSED*/
3331static int
3332emlxs_sli4_read_eq(emlxs_hba_t *hba, EQ_DESC_t *eq)
3333{
3334 uint32_t *ptr;
3335 EQE_u eqe;
3336 int rc = 0;
3337 off_t offset;
3338
4891 return (FC_SUCCESS);
4892
4893} /* emlxs_sli4_prep_ct_iocb() */
4894
4895
4896/*ARGSUSED*/
4897static int
4898emlxs_sli4_read_eq(emlxs_hba_t *hba, EQ_DESC_t *eq)
4899{
4900 uint32_t *ptr;
4901 EQE_u eqe;
4902 int rc = 0;
4903 off_t offset;
4904
3339 /* EMLXS_PORT_LOCK must be held when entering this routine */
4905 mutex_enter(&EMLXS_PORT_LOCK);
4906
3340 ptr = eq->addr.virt;
3341 ptr += eq->host_index;
3342
3343 offset = (off_t)((uint64_t)((unsigned long)
3344 eq->addr.virt) -
3345 (uint64_t)((unsigned long)
3346 hba->sli.sli4.slim2.virt));
3347
3348 EMLXS_MPDATA_SYNC(eq->addr.dma_handle, offset,
3349 4096, DDI_DMA_SYNC_FORKERNEL);
3350
4907 ptr = eq->addr.virt;
4908 ptr += eq->host_index;
4909
4910 offset = (off_t)((uint64_t)((unsigned long)
4911 eq->addr.virt) -
4912 (uint64_t)((unsigned long)
4913 hba->sli.sli4.slim2.virt));
4914
4915 EMLXS_MPDATA_SYNC(eq->addr.dma_handle, offset,
4916 4096, DDI_DMA_SYNC_FORKERNEL);
4917
3351 mutex_enter(&EMLXS_PORT_LOCK);
3352
3353 eqe.word = *ptr;
3354 eqe.word = BE_SWAP32(eqe.word);
3355
3356 if (eqe.word & EQE_VALID) {
3357 rc = 1;
3358 }
3359
3360 mutex_exit(&EMLXS_PORT_LOCK);
3361
3362 return (rc);
3363
3364} /* emlxs_sli4_read_eq */
3365
3366
4918 eqe.word = *ptr;
4919 eqe.word = BE_SWAP32(eqe.word);
4920
4921 if (eqe.word & EQE_VALID) {
4922 rc = 1;
4923 }
4924
4925 mutex_exit(&EMLXS_PORT_LOCK);
4926
4927 return (rc);
4928
4929} /* emlxs_sli4_read_eq */
4930
4931
3367/*ARGSUSED*/
3368static void
4932static void
3369emlxs_sli4_poll_intr(emlxs_hba_t *hba, uint32_t att_bit)
4933emlxs_sli4_poll_intr(emlxs_hba_t *hba)
3370{
3371 int rc = 0;
3372 int i;
3373 char arg[] = {0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
4934{
4935 int rc = 0;
4936 int i;
4937 char arg[] = {0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
3374 char arg2;
3375
4938
3376 /*
3377 * Poll the eqe to see if the valid bit is set or not
3378 */
4939 /* Check attention bits once and process if required */
3379
4940
3380 for (;;) {
3381 if (hba->intr_type == DDI_INTR_TYPE_FIXED) {
3382 /* only poll eqe0 */
3383 rc = emlxs_sli4_read_eq(hba,
3384 &hba->sli.sli4.eq[0]);
3385 if (rc == 1) {
3386 (void) bcopy((char *)&arg[0],
3387 (char *)&arg2, sizeof (char));
3388 break;
3389 }
3390 } else {
3391 /* poll every msi vector */
3392 for (i = 0; i < hba->intr_count; i++) {
3393 rc = emlxs_sli4_read_eq(hba,
3394 &hba->sli.sli4.eq[i]);
3395
3396 if (rc == 1) {
3397 break;
3398 }
3399 }
3400 if ((i != hba->intr_count) && (rc == 1)) {
3401 (void) bcopy((char *)&arg[i],
3402 (char *)&arg2, sizeof (char));
3403 break;
3404 }
4941 for (i = 0; i < hba->intr_count; i++) {
4942 rc = emlxs_sli4_read_eq(hba, &hba->sli.sli4.eq[i]);
4943 if (rc == 1) {
4944 break;
3405 }
3406 }
3407
4945 }
4946 }
4947
3408 /* process it here */
3409 rc = emlxs_sli4_msi_intr((char *)hba, (char *)&arg2);
4948 if (rc != 1) {
4949 return;
4950 }
3410
4951
4952 (void) emlxs_sli4_msi_intr((char *)hba,
4953 (char *)(unsigned long)arg[i]);
4954
3411 return;
3412
3413} /* emlxs_sli4_poll_intr() */
3414
3415
3416/*ARGSUSED*/
3417static void
3418emlxs_sli4_process_async_event(emlxs_hba_t *hba, CQE_ASYNC_t *cqe)
3419{
3420 emlxs_port_t *port = &PPORT;
4955 return;
4956
4957} /* emlxs_sli4_poll_intr() */
4958
4959
4960/*ARGSUSED*/
4961static void
4962emlxs_sli4_process_async_event(emlxs_hba_t *hba, CQE_ASYNC_t *cqe)
4963{
4964 emlxs_port_t *port = &PPORT;
4965 uint8_t status;
3421
3422 /* Save the event tag */
4966
4967 /* Save the event tag */
4968 if (hba->link_event_tag == cqe->un.link.event_tag) {
4969 HBASTATS.LinkMultiEvent++;
4970 } else if (hba->link_event_tag + 1 < cqe->un.link.event_tag) {
4971 HBASTATS.LinkMultiEvent++;
4972 }
3423 hba->link_event_tag = cqe->un.link.event_tag;
3424
3425 switch (cqe->event_code) {
4973 hba->link_event_tag = cqe->un.link.event_tag;
4974
4975 switch (cqe->event_code) {
3426 case ASYNC_EVENT_CODE_LINK_STATE:
4976 case ASYNC_EVENT_CODE_FCOE_LINK_STATE:
4977 HBASTATS.LinkEvent++;
4978
3427 switch (cqe->un.link.link_status) {
3428 case ASYNC_EVENT_PHYS_LINK_UP:
3429 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4979 switch (cqe->un.link.link_status) {
4980 case ASYNC_EVENT_PHYS_LINK_UP:
4981 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3430 "Link Async Event: PHYS_LINK_UP. val=%d type=%x",
3431 cqe->valid, cqe->event_type);
4982 "Link Async Event: PHYS_LINK_UP. val=%d "
4983 "type=%x event=%x",
4984 cqe->valid, cqe->event_type, HBASTATS.LinkEvent);
3432 break;
3433
4985 break;
4986
3434 case ASYNC_EVENT_PHYS_LINK_DOWN:
3435 case ASYNC_EVENT_LOGICAL_LINK_DOWN:
4987 case ASYNC_EVENT_LOGICAL_LINK_UP:
3436 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4988 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3437 "Link Async Event: LINK_DOWN. val=%d type=%x",
3438 cqe->valid, cqe->event_type);
4989 "Link Async Event: LOGICAL_LINK_UP. val=%d "
4990 "type=%x event=%x",
4991 cqe->valid, cqe->event_type, HBASTATS.LinkEvent);
3439
4992
3440 (void) emlxs_fcf_linkdown_notify(port);
3441
3442 mutex_enter(&EMLXS_PORT_LOCK);
3443 hba->sli.sli4.flag &= ~EMLXS_SLI4_DOWN_LINK;
3444 mutex_exit(&EMLXS_PORT_LOCK);
4993 emlxs_sli4_handle_fcoe_link_event(hba, cqe);
3445 break;
3446
4994 break;
4995
3447 case ASYNC_EVENT_LOGICAL_LINK_UP:
4996 case ASYNC_EVENT_PHYS_LINK_DOWN:
3448 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4997 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3449 "Link Async Event: LOGICAL_LINK_UP. val=%d type=%x",
3450 cqe->valid, cqe->event_type);
4998 "Link Async Event: PHYS_LINK_DOWN. val=%d "
4999 "type=%x event=%x",
5000 cqe->valid, cqe->event_type, HBASTATS.LinkEvent);
3451
5001
3452 if (cqe->un.link.port_speed == PHY_1GHZ_LINK) {
3453 hba->linkspeed = LA_1GHZ_LINK;
3454 } else {
3455 hba->linkspeed = LA_10GHZ_LINK;
3456 }
3457 hba->topology = TOPOLOGY_PT_PT;
3458 hba->qos_linkspeed = cqe->un.link.qos_link_speed;
5002 emlxs_sli4_handle_fcoe_link_event(hba, cqe);
5003 break;
3459
5004
3460 (void) emlxs_fcf_linkup_notify(port);
5005 case ASYNC_EVENT_LOGICAL_LINK_DOWN:
5006 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5007 "Link Async Event: LOGICAL_LINK_DOWN. val=%d "
5008 "type=%x event=%x",
5009 cqe->valid, cqe->event_type, HBASTATS.LinkEvent);
5010
5011 emlxs_sli4_handle_fcoe_link_event(hba, cqe);
3461 break;
5012 break;
5013 default:
5014 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5015 "Link Async Event: Unknown link status=%d event=%x",
5016 cqe->un.link.link_status, HBASTATS.LinkEvent);
5017 break;
3462 }
3463 break;
3464 case ASYNC_EVENT_CODE_FCOE_FIP:
3465 switch (cqe->un.fcoe.evt_type) {
3466 case ASYNC_EVENT_NEW_FCF_DISC:
3467 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5018 }
5019 break;
5020 case ASYNC_EVENT_CODE_FCOE_FIP:
5021 switch (cqe->un.fcoe.evt_type) {
5022 case ASYNC_EVENT_NEW_FCF_DISC:
5023 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3468 "FCOE Async Event: FCF_FOUND %d:%d",
5024 "FIP Async Event: FCF_FOUND %d:%d",
3469 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
3470
3471 (void) emlxs_fcf_found_notify(port,
3472 cqe->un.fcoe.ref_index);
3473 break;
3474 case ASYNC_EVENT_FCF_TABLE_FULL:
3475 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5025 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
5026
5027 (void) emlxs_fcf_found_notify(port,
5028 cqe->un.fcoe.ref_index);
5029 break;
5030 case ASYNC_EVENT_FCF_TABLE_FULL:
5031 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3476 "FCOE Async Event: FCFTAB_FULL %d:%d",
5032 "FIP Async Event: FCFTAB_FULL %d:%d",
3477 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
3478
3479 (void) emlxs_fcf_full_notify(port);
3480 break;
3481 case ASYNC_EVENT_FCF_DEAD:
3482 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5033 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
5034
5035 (void) emlxs_fcf_full_notify(port);
5036 break;
5037 case ASYNC_EVENT_FCF_DEAD:
5038 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3483 "FCOE Async Event: FCF_LOST %d:%d",
5039 "FIP Async Event: FCF_LOST %d:%d",
3484 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
3485
3486 (void) emlxs_fcf_lost_notify(port,
3487 cqe->un.fcoe.ref_index);
3488 break;
3489 case ASYNC_EVENT_VIRT_LINK_CLEAR:
3490 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5040 cqe->un.fcoe.ref_index, cqe->un.fcoe.fcf_count);
5041
5042 (void) emlxs_fcf_lost_notify(port,
5043 cqe->un.fcoe.ref_index);
5044 break;
5045 case ASYNC_EVENT_VIRT_LINK_CLEAR:
5046 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3491 "FCOE Async Event: CVL %d",
5047 "FIP Async Event: CVL %d",
3492 cqe->un.fcoe.ref_index);
3493
3494 (void) emlxs_fcf_cvl_notify(port,
5048 cqe->un.fcoe.ref_index);
5049
5050 (void) emlxs_fcf_cvl_notify(port,
3495 (cqe->un.fcoe.ref_index - hba->vpi_base));
5051 emlxs_sli4_vpi_to_index(hba,
5052 cqe->un.fcoe.ref_index));
3496 break;
3497
3498 case ASYNC_EVENT_FCF_MODIFIED:
3499 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5053 break;
5054
5055 case ASYNC_EVENT_FCF_MODIFIED:
5056 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3500 "FCOE Async Event: FCF_CHANGED %d",
5057 "FIP Async Event: FCF_CHANGED %d",
3501 cqe->un.fcoe.ref_index);
3502
3503 (void) emlxs_fcf_changed_notify(port,
3504 cqe->un.fcoe.ref_index);
3505 break;
5058 cqe->un.fcoe.ref_index);
5059
5060 (void) emlxs_fcf_changed_notify(port,
5061 cqe->un.fcoe.ref_index);
5062 break;
5063 default:
5064 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5065 "FIP Async Event: Unknown event type=%d",
5066 cqe->un.fcoe.evt_type);
5067 break;
3506 }
3507 break;
3508 case ASYNC_EVENT_CODE_DCBX:
3509 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5068 }
5069 break;
5070 case ASYNC_EVENT_CODE_DCBX:
5071 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3510 "DCBX Async Event Code %d: Not supported",
3511 cqe->event_code);
5072 "DCBX Async Event: type=%d. Not supported.",
5073 cqe->event_type);
3512 break;
3513 case ASYNC_EVENT_CODE_GRP_5:
3514 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5074 break;
5075 case ASYNC_EVENT_CODE_GRP_5:
5076 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3515 "Group 5 Async Event type %d", cqe->event_type);
5077 "Group 5 Async Event: type=%d.", cqe->event_type);
3516 if (cqe->event_type == ASYNC_EVENT_QOS_SPEED) {
3517 hba->qos_linkspeed = cqe->un.qos.qos_link_speed;
3518 }
3519 break;
5078 if (cqe->event_type == ASYNC_EVENT_QOS_SPEED) {
5079 hba->qos_linkspeed = cqe->un.qos.qos_link_speed;
5080 }
5081 break;
5082 case ASYNC_EVENT_CODE_FC_EVENT:
5083 switch (cqe->event_type) {
5084 case ASYNC_EVENT_FC_LINK_ATT:
5085 HBASTATS.LinkEvent++;
5086
5087 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5088 "FC Async Event: Link Attention. event=%x",
5089 HBASTATS.LinkEvent);
5090
5091 emlxs_sli4_handle_fc_link_att(hba, cqe);
5092 break;
5093 case ASYNC_EVENT_FC_SHARED_LINK_ATT:
5094 HBASTATS.LinkEvent++;
5095
5096 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5097 "FC Async Event: Shared Link Attention. event=%x",
5098 HBASTATS.LinkEvent);
5099
5100 emlxs_sli4_handle_fc_link_att(hba, cqe);
5101 break;
5102 default:
5103 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5104 "FC Async Event: Unknown event. type=%d event=%x",
5105 cqe->event_type, HBASTATS.LinkEvent);
5106 }
5107 break;
5108 case ASYNC_EVENT_CODE_PORT:
5109 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5110 "SLI Port Async Event: type=%d", cqe->event_type);
5111 if (cqe->event_type == ASYNC_EVENT_MISCONFIG_PORT) {
5112 *((uint32_t *)cqe->un.port.link_status) =
5113 BE_SWAP32(*((uint32_t *)cqe->un.port.link_status));
5114 status =
5115 cqe->un.port.link_status[hba->sli.sli4.link_number];
5116
5117 switch (status) {
5118 case 0 :
5119 break;
5120
5121 case 1 :
5122 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5123 "SLI Port Async Event: Physical media not "
5124 "detected");
5125 cmn_err(CE_WARN,
5126 "^%s%d: Optics faulted/incorrectly "
5127 "installed/not installed - Reseat optics, "
5128 "if issue not resolved, replace.",
5129 DRIVER_NAME, hba->ddiinst);
5130 break;
5131
5132 case 2 :
5133 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5134 "SLI Port Async Event: Wrong physical "
5135 "media detected");
5136 cmn_err(CE_WARN,
5137 "^%s%d: Optics of two types installed - "
5138 "Remove one optic or install matching"
5139 "pair of optics.",
5140 DRIVER_NAME, hba->ddiinst);
5141 break;
5142
5143 case 3 :
5144 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5145 "SLI Port Async Event: Unsupported "
5146 "physical media detected");
5147 cmn_err(CE_WARN,
5148 "^%s%d: Incompatible optics - Replace "
5149 "with compatible optics for card to "
5150 "function.",
5151 DRIVER_NAME, hba->ddiinst);
5152 break;
5153
5154 default :
5155 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5156 "SLI Port Async Event: Physical media "
5157 "error, status=%x", status);
5158 cmn_err(CE_WARN,
5159 "^%s%d: Misconfigured port: status=0x%x - "
5160 "Check optics on card.",
5161 DRIVER_NAME, hba->ddiinst, status);
5162 break;
5163 }
5164 }
5165 break;
5166 case ASYNC_EVENT_CODE_VF:
5167 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5168 "VF Async Event: type=%d",
5169 cqe->event_type);
5170 break;
5171 case ASYNC_EVENT_CODE_MR:
5172 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5173 "MR Async Event: type=%d",
5174 cqe->event_type);
5175 break;
3520 default:
3521 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5176 default:
5177 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3522 "Unknown Async Event Code %d", cqe->event_code);
5178 "Unknown Async Event: code=%d type=%d.",
5179 cqe->event_code, cqe->event_type);
3523 break;
3524 }
3525
3526} /* emlxs_sli4_process_async_event() */
3527
3528
3529/*ARGSUSED*/
3530static void

--- 114 unchanged lines hidden (view full) ---

3645 mbox_bp = (MATCHMAP *)mbq->bp;
3646 EMLXS_MPDATA_SYNC(mbox_bp->dma_handle, 0, mbox_bp->size,
3647 DDI_DMA_SYNC_FORKERNEL);
3648#ifdef FMA_SUPPORT
3649 if (emlxs_fm_check_dma_handle(hba, mbox_bp->dma_handle)
3650 != DDI_FM_OK) {
3651 EMLXS_MSGF(EMLXS_CONTEXT,
3652 &emlxs_invalid_dma_handle_msg,
5180 break;
5181 }
5182
5183} /* emlxs_sli4_process_async_event() */
5184
5185
5186/*ARGSUSED*/
5187static void

--- 114 unchanged lines hidden (view full) ---

5302 mbox_bp = (MATCHMAP *)mbq->bp;
5303 EMLXS_MPDATA_SYNC(mbox_bp->dma_handle, 0, mbox_bp->size,
5304 DDI_DMA_SYNC_FORKERNEL);
5305#ifdef FMA_SUPPORT
5306 if (emlxs_fm_check_dma_handle(hba, mbox_bp->dma_handle)
5307 != DDI_FM_OK) {
5308 EMLXS_MSGF(EMLXS_CONTEXT,
5309 &emlxs_invalid_dma_handle_msg,
3653 "emlxs_sli4_process_mbox_event: hdl=%p",
5310 "sli4_process_mbox_event: hdl=%p",
3654 mbox_bp->dma_handle);
3655
3656 mb->mbxStatus = MBXERR_DMA_ERROR;
3657}
3658#endif
3659 }
3660
3661 /* Now sync the memory buffer if one was used */

--- 5 unchanged lines hidden (view full) ---

3667 iptr = (uint32_t *)((uint8_t *)mbox_nonembed->virt);
3668 BE_SWAP32_BCOPY((uint8_t *)iptr, (uint8_t *)iptr, size);
3669
3670#ifdef FMA_SUPPORT
3671 if (emlxs_fm_check_dma_handle(hba,
3672 mbox_nonembed->dma_handle) != DDI_FM_OK) {
3673 EMLXS_MSGF(EMLXS_CONTEXT,
3674 &emlxs_invalid_dma_handle_msg,
5311 mbox_bp->dma_handle);
5312
5313 mb->mbxStatus = MBXERR_DMA_ERROR;
5314}
5315#endif
5316 }
5317
5318 /* Now sync the memory buffer if one was used */

--- 5 unchanged lines hidden (view full) ---

5324 iptr = (uint32_t *)((uint8_t *)mbox_nonembed->virt);
5325 BE_SWAP32_BCOPY((uint8_t *)iptr, (uint8_t *)iptr, size);
5326
5327#ifdef FMA_SUPPORT
5328 if (emlxs_fm_check_dma_handle(hba,
5329 mbox_nonembed->dma_handle) != DDI_FM_OK) {
5330 EMLXS_MSGF(EMLXS_CONTEXT,
5331 &emlxs_invalid_dma_handle_msg,
3675 "emlxs_sli4_process_mbox_event: hdl=%p",
5332 "sli4_process_mbox_event: hdl=%p",
3676 mbox_nonembed->dma_handle);
3677
3678 mb->mbxStatus = MBXERR_DMA_ERROR;
3679 }
3680#endif
5333 mbox_nonembed->dma_handle);
5334
5335 mb->mbxStatus = MBXERR_DMA_ERROR;
5336 }
5337#endif
3681emlxs_data_dump(port, "EXT AREA", (uint32_t *)iptr, 24, 0);
5338 emlxs_data_dump(port, "EXT AREA", (uint32_t *)iptr, 24, 0);
3682 }
3683
3684 /* Mailbox has been completely received at this point */
3685
3686 if (mb->mbxCommand == MBX_HEARTBEAT) {
3687 hba->heartbeat_active = 0;
3688 goto done;
3689 }

--- 54 unchanged lines hidden (view full) ---

3744
3745} /* emlxs_sli4_process_mbox_event() */
3746
3747
3748/*ARGSUSED*/
3749static void
3750emlxs_CQE_to_IOCB(emlxs_hba_t *hba, CQE_CmplWQ_t *cqe, emlxs_buf_t *sbp)
3751{
5339 }
5340
5341 /* Mailbox has been completely received at this point */
5342
5343 if (mb->mbxCommand == MBX_HEARTBEAT) {
5344 hba->heartbeat_active = 0;
5345 goto done;
5346 }

--- 54 unchanged lines hidden (view full) ---

5401
5402} /* emlxs_sli4_process_mbox_event() */
5403
5404
5405/*ARGSUSED*/
5406static void
5407emlxs_CQE_to_IOCB(emlxs_hba_t *hba, CQE_CmplWQ_t *cqe, emlxs_buf_t *sbp)
5408{
3752#ifdef SLI4_FASTPATH_DEBUG
5409#ifdef DEBUG_FASTPATH
3753 emlxs_port_t *port = &PPORT;
5410 emlxs_port_t *port = &PPORT;
3754#endif
5411#endif /* DEBUG_FASTPATH */
3755 IOCBQ *iocbq;
3756 IOCB *iocb;
3757 uint32_t *iptr;
3758 fc_packet_t *pkt;
3759 emlxs_wqe_t *wqe;
3760
3761 iocbq = &sbp->iocbq;
3762 wqe = &iocbq->wqe;
3763 iocb = &iocbq->iocb;
3764
5412 IOCBQ *iocbq;
5413 IOCB *iocb;
5414 uint32_t *iptr;
5415 fc_packet_t *pkt;
5416 emlxs_wqe_t *wqe;
5417
5418 iocbq = &sbp->iocbq;
5419 wqe = &iocbq->wqe;
5420 iocb = &iocbq->iocb;
5421
3765#ifdef SLI4_FASTPATH_DEBUG
5422#ifdef DEBUG_FASTPATH
3766 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5423 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3767 "CQE to IOCB: cmd:x%x tag:x%x xri:x%x", wqe->Command,
5424 "CQE to IOCB: cmd:%x tag:%x xri:%d", wqe->Command,
3768 wqe->RequestTag, wqe->XRITag);
5425 wqe->RequestTag, wqe->XRITag);
3769#endif
5426#endif /* DEBUG_FASTPATH */
3770
3771 iocb->ULPSTATUS = cqe->Status;
3772 iocb->un.ulpWord[4] = cqe->Parameter;
3773 iocb->ULPIOTAG = cqe->RequestTag;
3774 iocb->ULPCONTEXT = wqe->XRITag;
3775
3776 switch (wqe->Command) {
3777
3778 case CMD_FCP_ICMND64_CR:
3779 iocb->ULPCOMMAND = CMD_FCP_ICMND64_CX;
3780 break;
3781
3782 case CMD_FCP_IREAD64_CR:
3783 iocb->ULPCOMMAND = CMD_FCP_IREAD64_CX;
5427
5428 iocb->ULPSTATUS = cqe->Status;
5429 iocb->un.ulpWord[4] = cqe->Parameter;
5430 iocb->ULPIOTAG = cqe->RequestTag;
5431 iocb->ULPCONTEXT = wqe->XRITag;
5432
5433 switch (wqe->Command) {
5434
5435 case CMD_FCP_ICMND64_CR:
5436 iocb->ULPCOMMAND = CMD_FCP_ICMND64_CX;
5437 break;
5438
5439 case CMD_FCP_IREAD64_CR:
5440 iocb->ULPCOMMAND = CMD_FCP_IREAD64_CX;
3784 iocb->ULPPU = PARM_READ_CHECK;
5441 iocb->ULPPU = PARM_XFER_CHECK;
3785 if (iocb->ULPSTATUS == IOSTAT_FCP_RSP_ERROR) {
3786 iocb->un.fcpi64.fcpi_parm =
3787 wqe->un.FcpCmd.TotalTransferCount -
3788 cqe->CmdSpecific;
3789 }
3790 break;
3791
3792 case CMD_FCP_IWRITE64_CR:
3793 iocb->ULPCOMMAND = CMD_FCP_IWRITE64_CX;
5442 if (iocb->ULPSTATUS == IOSTAT_FCP_RSP_ERROR) {
5443 iocb->un.fcpi64.fcpi_parm =
5444 wqe->un.FcpCmd.TotalTransferCount -
5445 cqe->CmdSpecific;
5446 }
5447 break;
5448
5449 case CMD_FCP_IWRITE64_CR:
5450 iocb->ULPCOMMAND = CMD_FCP_IWRITE64_CX;
5451 if (iocb->ULPSTATUS == IOSTAT_FCP_RSP_ERROR) {
5452 if (wqe->un.FcpCmd.TotalTransferCount >
5453 cqe->CmdSpecific) {
5454 iocb->un.fcpi64.fcpi_parm =
5455 wqe->un.FcpCmd.TotalTransferCount -
5456 cqe->CmdSpecific;
5457 } else {
5458 iocb->un.fcpi64.fcpi_parm = 0;
5459 }
5460 }
3794 break;
3795
3796 case CMD_ELS_REQUEST64_CR:
3797 iocb->ULPCOMMAND = CMD_ELS_REQUEST64_CX;
3798 iocb->un.elsreq64.bdl.bdeSize = cqe->CmdSpecific;
3799 if (iocb->ULPSTATUS == 0) {
3800 iocb->unsli3.ext_iocb.rsplen = cqe->CmdSpecific;
3801 }

--- 10 unchanged lines hidden (view full) ---

3812 iocb->ULPCOMMAND = CMD_GEN_REQUEST64_CX;
3813 iocb->unsli3.ext_iocb.rsplen = cqe->CmdSpecific;
3814 break;
3815
3816 case CMD_XMIT_SEQUENCE64_CR:
3817 iocb->ULPCOMMAND = CMD_XMIT_SEQUENCE64_CX;
3818 break;
3819
5461 break;
5462
5463 case CMD_ELS_REQUEST64_CR:
5464 iocb->ULPCOMMAND = CMD_ELS_REQUEST64_CX;
5465 iocb->un.elsreq64.bdl.bdeSize = cqe->CmdSpecific;
5466 if (iocb->ULPSTATUS == 0) {
5467 iocb->unsli3.ext_iocb.rsplen = cqe->CmdSpecific;
5468 }

--- 10 unchanged lines hidden (view full) ---

5479 iocb->ULPCOMMAND = CMD_GEN_REQUEST64_CX;
5480 iocb->unsli3.ext_iocb.rsplen = cqe->CmdSpecific;
5481 break;
5482
5483 case CMD_XMIT_SEQUENCE64_CR:
5484 iocb->ULPCOMMAND = CMD_XMIT_SEQUENCE64_CX;
5485 break;
5486
5487 case CMD_ABORT_XRI_CX:
5488 iocb->ULPCONTEXT = wqe->AbortTag;
5489 break;
5490
5491 case CMD_FCP_TRECEIVE64_CX:
5492 /* free memory for XRDY */
5493 if (iocbq->bp) {
5494 emlxs_mem_buf_free(hba, iocbq->bp);
5495 iocbq->bp = 0;
5496 }
5497
5498 /*FALLTHROUGH*/
5499
5500 case CMD_FCP_TSEND64_CX:
5501 case CMD_FCP_TRSP64_CX:
3820 default:
3821 iocb->ULPCOMMAND = wqe->Command;
3822
3823 }
5502 default:
5503 iocb->ULPCOMMAND = wqe->Command;
5504
5505 }
3824
3825} /* emlxs_CQE_to_IOCB() */
3826
3827
3828/*ARGSUSED*/
3829static void
3830emlxs_sli4_hba_flush_chipq(emlxs_hba_t *hba)
3831{
5506} /* emlxs_CQE_to_IOCB() */
5507
5508
5509/*ARGSUSED*/
5510static void
5511emlxs_sli4_hba_flush_chipq(emlxs_hba_t *hba)
5512{
3832#ifdef SFCT_SUPPORT
3833#ifdef FCT_IO_TRACE
3834 emlxs_port_t *port = &PPORT;
5513 emlxs_port_t *port = &PPORT;
3835#endif /* FCT_IO_TRACE */
3836#endif /* SFCT_SUPPORT */
3837 CHANNEL *cp;
3838 emlxs_buf_t *sbp;
3839 IOCBQ *iocbq;
3840 uint16_t i;
5514 CHANNEL *cp;
5515 emlxs_buf_t *sbp;
5516 IOCBQ *iocbq;
5517 uint16_t i;
3841 uint32_t trigger;
5518 uint32_t trigger = 0;
3842 CQE_CmplWQ_t cqe;
3843
3844 mutex_enter(&EMLXS_FCTAB_LOCK);
3845 for (i = 0; i < hba->max_iotag; i++) {
3846 sbp = hba->fc_table[i];
3847 if (sbp == NULL || sbp == STALE_PACKET) {
3848 continue;
3849 }

--- 14 unchanged lines hidden (view full) ---

3864#ifdef FCT_IO_TRACE
3865 if (sbp->fct_cmd) {
3866 emlxs_fct_io_trace(port, sbp->fct_cmd,
3867 EMLXS_FCT_IOCB_COMPLETE);
3868 }
3869#endif /* FCT_IO_TRACE */
3870#endif /* SFCT_SUPPORT */
3871
5519 CQE_CmplWQ_t cqe;
5520
5521 mutex_enter(&EMLXS_FCTAB_LOCK);
5522 for (i = 0; i < hba->max_iotag; i++) {
5523 sbp = hba->fc_table[i];
5524 if (sbp == NULL || sbp == STALE_PACKET) {
5525 continue;
5526 }

--- 14 unchanged lines hidden (view full) ---

5541#ifdef FCT_IO_TRACE
5542 if (sbp->fct_cmd) {
5543 emlxs_fct_io_trace(port, sbp->fct_cmd,
5544 EMLXS_FCT_IOCB_COMPLETE);
5545 }
5546#endif /* FCT_IO_TRACE */
5547#endif /* SFCT_SUPPORT */
5548
3872 atomic_dec_32(&hba->io_active);
5549 if (sbp->pkt_flags & PACKET_IN_CHIPQ) {
5550 atomic_dec_32(&hba->io_active);
5551#ifdef NODE_THROTTLE_SUPPORT
5552 if (sbp->node) {
5553 atomic_dec_32(&sbp->node->io_active);
5554 }
5555#endif /* NODE_THROTTLE_SUPPORT */
5556 }
3873
3874 /* Copy entry to sbp's iocbq */
3875 iocbq = &sbp->iocbq;
3876 emlxs_CQE_to_IOCB(hba, &cqe, sbp);
3877
3878 iocbq->next = NULL;
3879
3880 /* Exchange is no longer busy on-chip, free it */
5557
5558 /* Copy entry to sbp's iocbq */
5559 iocbq = &sbp->iocbq;
5560 emlxs_CQE_to_IOCB(hba, &cqe, sbp);
5561
5562 iocbq->next = NULL;
5563
5564 /* Exchange is no longer busy on-chip, free it */
3881 emlxs_sli4_free_xri(hba, sbp, sbp->xrip, 1);
5565 emlxs_sli4_free_xri(port, sbp, sbp->xrip, 1);
3882
3883 if (!(sbp->pkt_flags &
3884 (PACKET_POLLED | PACKET_ALLOCATED))) {
3885 /* Add the IOCB to the channel list */
3886 mutex_enter(&cp->rsp_lock);
3887 if (cp->rsp_head == NULL) {
3888 cp->rsp_head = iocbq;
3889 cp->rsp_tail = iocbq;

--- 26 unchanged lines hidden (view full) ---

3916/*ARGSUSED*/
3917static void
3918emlxs_sli4_process_oor_wqe_cmpl(emlxs_hba_t *hba,
3919 CQ_DESC_t *cq, CQE_CmplWQ_t *cqe)
3920{
3921 emlxs_port_t *port = &PPORT;
3922 CHANNEL *cp;
3923 uint16_t request_tag;
5566
5567 if (!(sbp->pkt_flags &
5568 (PACKET_POLLED | PACKET_ALLOCATED))) {
5569 /* Add the IOCB to the channel list */
5570 mutex_enter(&cp->rsp_lock);
5571 if (cp->rsp_head == NULL) {
5572 cp->rsp_head = iocbq;
5573 cp->rsp_tail = iocbq;

--- 26 unchanged lines hidden (view full) ---

5600/*ARGSUSED*/
5601static void
5602emlxs_sli4_process_oor_wqe_cmpl(emlxs_hba_t *hba,
5603 CQ_DESC_t *cq, CQE_CmplWQ_t *cqe)
5604{
5605 emlxs_port_t *port = &PPORT;
5606 CHANNEL *cp;
5607 uint16_t request_tag;
3924 CQE_u *cq_entry;
3925
3926 request_tag = cqe->RequestTag;
3927
5608
5609 request_tag = cqe->RequestTag;
5610
3928 cq_entry = (CQE_u *)cqe;
3929
3930 /* 1 to 1 mapping between CQ and channel */
3931 cp = cq->channelp;
3932
3933 cp->hbaCmplCmd++;
3934
3935 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5611 /* 1 to 1 mapping between CQ and channel */
5612 cp = cq->channelp;
5613
5614 cp->hbaCmplCmd++;
5615
5616 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3936 "CQ ENTRY: OOR Cmpl: tag=%x", request_tag);
5617 "CQ ENTRY: OOR Cmpl: iotag=%d", request_tag);
3937
5618
3938 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3939 "CQ ENTRY: %08x %08x %08x %08x", cq_entry->word[0],
3940 cq_entry->word[1], cq_entry->word[2], cq_entry->word[3]);
5619 emlxs_data_dump(port, "CQE", (uint32_t *)cqe, 4, 0);
3941
3942} /* emlxs_sli4_process_oor_wqe_cmpl() */
3943
3944
3945/*ARGSUSED*/
3946static void
3947emlxs_sli4_process_wqe_cmpl(emlxs_hba_t *hba, CQ_DESC_t *cq, CQE_CmplWQ_t *cqe)
3948{
3949 emlxs_port_t *port = &PPORT;
3950 CHANNEL *cp;
3951 emlxs_buf_t *sbp;
3952 IOCBQ *iocbq;
3953 uint16_t request_tag;
3954#ifdef SFCT_SUPPORT
5620
5621} /* emlxs_sli4_process_oor_wqe_cmpl() */
5622
5623
5624/*ARGSUSED*/
5625static void
5626emlxs_sli4_process_wqe_cmpl(emlxs_hba_t *hba, CQ_DESC_t *cq, CQE_CmplWQ_t *cqe)
5627{
5628 emlxs_port_t *port = &PPORT;
5629 CHANNEL *cp;
5630 emlxs_buf_t *sbp;
5631 IOCBQ *iocbq;
5632 uint16_t request_tag;
5633#ifdef SFCT_SUPPORT
5634#ifdef FCT_IO_TRACE
3955 fct_cmd_t *fct_cmd;
3956 emlxs_buf_t *cmd_sbp;
5635 fct_cmd_t *fct_cmd;
5636 emlxs_buf_t *cmd_sbp;
5637#endif /* FCT_IO_TRACE */
3957#endif /* SFCT_SUPPORT */
3958
3959 request_tag = cqe->RequestTag;
3960
3961 /* 1 to 1 mapping between CQ and channel */
3962 cp = cq->channelp;
3963
3964 mutex_enter(&EMLXS_FCTAB_LOCK);
3965 sbp = hba->fc_table[request_tag];
5638#endif /* SFCT_SUPPORT */
5639
5640 request_tag = cqe->RequestTag;
5641
5642 /* 1 to 1 mapping between CQ and channel */
5643 cp = cq->channelp;
5644
5645 mutex_enter(&EMLXS_FCTAB_LOCK);
5646 sbp = hba->fc_table[request_tag];
3966 atomic_dec_32(&hba->io_active);
3967
5647
5648 if (!sbp) {
5649 cp->hbaCmplCmd++;
5650 mutex_exit(&EMLXS_FCTAB_LOCK);
5651 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5652 "CQ ENTRY: NULL sbp. iotag=%d. Dropping...",
5653 request_tag);
5654 return;
5655 }
5656
3968 if (sbp == STALE_PACKET) {
3969 cp->hbaCmplCmd_sbp++;
3970 mutex_exit(&EMLXS_FCTAB_LOCK);
3971 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5657 if (sbp == STALE_PACKET) {
5658 cp->hbaCmplCmd_sbp++;
5659 mutex_exit(&EMLXS_FCTAB_LOCK);
5660 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3972 "CQ ENTRY: Stale sbp. tag=%x. Dropping...", request_tag);
5661 "CQ ENTRY: Stale sbp. iotag=%d. Dropping...", request_tag);
3973 return;
3974 }
3975
5662 return;
5663 }
5664
3976 if (!sbp || !(sbp->xrip)) {
5665 if (sbp->pkt_flags & PACKET_IN_CHIPQ) {
5666 atomic_add_32(&hba->io_active, -1);
5667#ifdef NODE_THROTTLE_SUPPORT
5668 if (sbp->node) {
5669 atomic_add_32(&sbp->node->io_active, -1);
5670 }
5671#endif /* NODE_THROTTLE_SUPPORT */
5672 }
5673
5674 if (!(sbp->xrip)) {
3977 cp->hbaCmplCmd++;
3978 mutex_exit(&EMLXS_FCTAB_LOCK);
3979 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5675 cp->hbaCmplCmd++;
5676 mutex_exit(&EMLXS_FCTAB_LOCK);
5677 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3980 "CQ ENTRY: NULL sbp %p. tag=%x. Dropping...",
5678 "CQ ENTRY: NULL sbp xrip %p. iotag=%d. Dropping...",
3981 sbp, request_tag);
3982 return;
3983 }
3984
5679 sbp, request_tag);
5680 return;
5681 }
5682
3985#ifdef SLI4_FASTPATH_DEBUG
5683#ifdef DEBUG_FASTPATH
3986 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
3987 "CQ ENTRY: process wqe compl");
5684 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5685 "CQ ENTRY: process wqe compl");
3988#endif
3989
5686#endif /* DEBUG_FASTPATH */
3990 cp->hbaCmplCmd_sbp++;
3991
3992 /* Copy entry to sbp's iocbq */
3993 iocbq = &sbp->iocbq;
3994 emlxs_CQE_to_IOCB(hba, cqe, sbp);
3995
3996 iocbq->next = NULL;
3997
3998 if (cqe->XB) {
3999 /* Mark exchange as ABORT in progress */
4000 sbp->xrip->flag &= ~EMLXS_XRI_PENDING_IO;
5687 cp->hbaCmplCmd_sbp++;
5688
5689 /* Copy entry to sbp's iocbq */
5690 iocbq = &sbp->iocbq;
5691 emlxs_CQE_to_IOCB(hba, cqe, sbp);
5692
5693 iocbq->next = NULL;
5694
5695 if (cqe->XB) {
5696 /* Mark exchange as ABORT in progress */
5697 sbp->xrip->flag &= ~EMLXS_XRI_PENDING_IO;
4001 sbp->xrip->flag |= EMLXS_XRI_ABORT_INP;
5698 sbp->xrip->flag |= EMLXS_XRI_BUSY;
4002
4003 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5699
5700 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4004 "CQ ENTRY: ABORT INP: tag=%x xri=%x", request_tag,
5701 "CQ ENTRY: XRI BUSY: iotag=%d xri=%d", request_tag,
4005 sbp->xrip->XRI);
4006
5702 sbp->xrip->XRI);
5703
4007 emlxs_sli4_free_xri(hba, sbp, 0, 0);
5704 emlxs_sli4_free_xri(port, sbp, 0, 0);
4008 } else {
4009 /* Exchange is no longer busy on-chip, free it */
5705 } else {
5706 /* Exchange is no longer busy on-chip, free it */
4010 emlxs_sli4_free_xri(hba, sbp, sbp->xrip, 0);
5707 emlxs_sli4_free_xri(port, sbp, sbp->xrip, 0);
4011 }
4012
4013 mutex_exit(&EMLXS_FCTAB_LOCK);
4014
4015#ifdef SFCT_SUPPORT
5708 }
5709
5710 mutex_exit(&EMLXS_FCTAB_LOCK);
5711
5712#ifdef SFCT_SUPPORT
5713#ifdef FCT_IO_TRACE
4016 fct_cmd = sbp->fct_cmd;
4017 if (fct_cmd) {
4018 cmd_sbp = (emlxs_buf_t *)fct_cmd->cmd_fca_private;
4019 mutex_enter(&cmd_sbp->fct_mtx);
4020 EMLXS_FCT_STATE_CHG(fct_cmd, cmd_sbp, EMLXS_FCT_IOCB_COMPLETE);
4021 mutex_exit(&cmd_sbp->fct_mtx);
4022 }
5714 fct_cmd = sbp->fct_cmd;
5715 if (fct_cmd) {
5716 cmd_sbp = (emlxs_buf_t *)fct_cmd->cmd_fca_private;
5717 mutex_enter(&cmd_sbp->fct_mtx);
5718 EMLXS_FCT_STATE_CHG(fct_cmd, cmd_sbp, EMLXS_FCT_IOCB_COMPLETE);
5719 mutex_exit(&cmd_sbp->fct_mtx);
5720 }
5721#endif /* FCT_IO_TRACE */
4023#endif /* SFCT_SUPPORT */
4024
4025 /*
4026 * If this is NOT a polled command completion
4027 * or a driver allocated pkt, then defer pkt
4028 * completion.
4029 */
4030 if (!(sbp->pkt_flags &

--- 18 unchanged lines hidden (view full) ---

4049} /* emlxs_sli4_process_wqe_cmpl() */
4050
4051
4052/*ARGSUSED*/
4053static void
4054emlxs_sli4_process_release_wqe(emlxs_hba_t *hba, CQ_DESC_t *cq,
4055 CQE_RelWQ_t *cqe)
4056{
5722#endif /* SFCT_SUPPORT */
5723
5724 /*
5725 * If this is NOT a polled command completion
5726 * or a driver allocated pkt, then defer pkt
5727 * completion.
5728 */
5729 if (!(sbp->pkt_flags &

--- 18 unchanged lines hidden (view full) ---

5748} /* emlxs_sli4_process_wqe_cmpl() */
5749
5750
5751/*ARGSUSED*/
5752static void
5753emlxs_sli4_process_release_wqe(emlxs_hba_t *hba, CQ_DESC_t *cq,
5754 CQE_RelWQ_t *cqe)
5755{
4057#ifdef SLI4_FASTPATH_DEBUG
4058 emlxs_port_t *port = &PPORT;
5756 emlxs_port_t *port = &PPORT;
4059#endif
4060 WQ_DESC_t *wq;
4061 CHANNEL *cp;
4062 uint32_t i;
5757 WQ_DESC_t *wq;
5758 CHANNEL *cp;
5759 uint32_t i;
5760 uint16_t wqi;
4063
5761
4064 i = cqe->WQid;
4065 wq = &hba->sli.sli4.wq[hba->sli.sli4.wq_map[i]];
5762 wqi = emlxs_sli4_wqid_to_index(hba, (uint16_t)cqe->WQid);
4066
5763
4067#ifdef SLI4_FASTPATH_DEBUG
5764 /* Verify WQ index */
5765 if (wqi == 0xffff) {
5766 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5767 "CQ ENTRY: Invalid WQid:%d. Dropping...",
5768 cqe->WQid);
5769 return;
5770 }
5771
5772 wq = &hba->sli.sli4.wq[wqi];
5773
5774#ifdef DEBUG_FASTPATH
4068 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4069 "CQ ENTRY: process release wqe: old %d new %d", wq->port_index,
4070 cqe->WQindex);
5775 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5776 "CQ ENTRY: process release wqe: old %d new %d", wq->port_index,
5777 cqe->WQindex);
4071#endif
5778#endif /* DEBUG_FASTPATH */
4072
4073 wq->port_index = cqe->WQindex;
4074
4075 /* Cmd ring may be available. Try sending more iocbs */
4076 for (i = 0; i < hba->chan_count; i++) {
4077 cp = &hba->chan[i];
4078 if (wq == (WQ_DESC_t *)cp->iopath) {
4079 emlxs_sli4_issue_iocb_cmd(hba, cp, 0);

--- 115 unchanged lines hidden (view full) ---

4195 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4196 "RQ POST: rqid=%d count=1", rqid);
4197
4198 /* Ring the RQ doorbell once to repost the RQ buffer */
4199 rqdb.word = 0;
4200 rqdb.db.Qid = rqid;
4201 rqdb.db.NumPosted = 1;
4202
5779
5780 wq->port_index = cqe->WQindex;
5781
5782 /* Cmd ring may be available. Try sending more iocbs */
5783 for (i = 0; i < hba->chan_count; i++) {
5784 cp = &hba->chan[i];
5785 if (wq == (WQ_DESC_t *)cp->iopath) {
5786 emlxs_sli4_issue_iocb_cmd(hba, cp, 0);

--- 115 unchanged lines hidden (view full) ---

5902 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5903 "RQ POST: rqid=%d count=1", rqid);
5904
5905 /* Ring the RQ doorbell once to repost the RQ buffer */
5906 rqdb.word = 0;
5907 rqdb.db.Qid = rqid;
5908 rqdb.db.NumPosted = 1;
5909
4203 WRITE_BAR2_REG(hba, FC_RQDB_REG(hba), rqdb.word);
5910 emlxs_sli4_write_rqdb(hba, rqdb.word);
4204
4205} /* emlxs_sli4_rq_post() */
4206
4207
4208/*ARGSUSED*/
4209static void
4210emlxs_sli4_process_unsol_rcv(emlxs_hba_t *hba, CQ_DESC_t *cq,
4211 CQE_UnsolRcv_t *cqe)
4212{
4213 emlxs_port_t *port = &PPORT;
4214 emlxs_port_t *vport;
4215 RQ_DESC_t *hdr_rq;
4216 RQ_DESC_t *data_rq;
4217 MBUF_INFO *hdr_mp;
4218 MBUF_INFO *data_mp;
4219 MATCHMAP *seq_mp;
4220 uint32_t *data;
4221 fc_frame_hdr_t fchdr;
5911
5912} /* emlxs_sli4_rq_post() */
5913
5914
5915/*ARGSUSED*/
5916static void
5917emlxs_sli4_process_unsol_rcv(emlxs_hba_t *hba, CQ_DESC_t *cq,
5918 CQE_UnsolRcv_t *cqe)
5919{
5920 emlxs_port_t *port = &PPORT;
5921 emlxs_port_t *vport;
5922 RQ_DESC_t *hdr_rq;
5923 RQ_DESC_t *data_rq;
5924 MBUF_INFO *hdr_mp;
5925 MBUF_INFO *data_mp;
5926 MATCHMAP *seq_mp;
5927 uint32_t *data;
5928 fc_frame_hdr_t fchdr;
4222 uint32_t hdr_rqi;
5929 uint16_t hdr_rqi;
4223 uint32_t host_index;
4224 emlxs_iocbq_t *iocbq = NULL;
4225 emlxs_iocb_t *iocb;
5930 uint32_t host_index;
5931 emlxs_iocbq_t *iocbq = NULL;
5932 emlxs_iocb_t *iocb;
4226 emlxs_node_t *node;
5933 emlxs_node_t *node = NULL;
4227 uint32_t i;
4228 uint32_t seq_len;
4229 uint32_t seq_cnt;
4230 uint32_t buf_type;
4231 char label[32];
4232 emlxs_wqe_t *wqe;
4233 CHANNEL *cp;
5934 uint32_t i;
5935 uint32_t seq_len;
5936 uint32_t seq_cnt;
5937 uint32_t buf_type;
5938 char label[32];
5939 emlxs_wqe_t *wqe;
5940 CHANNEL *cp;
4234 uint16_t iotag;
4235 XRIobj_t *xrip;
4236 RPIobj_t *rpip = NULL;
4237 uint32_t cmd;
4238 uint32_t posted = 0;
4239 uint32_t abort = 1;
4240 off_t offset;
5941 XRIobj_t *xrip;
5942 RPIobj_t *rpip = NULL;
5943 uint32_t cmd;
5944 uint32_t posted = 0;
5945 uint32_t abort = 1;
5946 off_t offset;
5947 uint32_t status;
5948 uint32_t data_size;
5949 uint16_t rqid;
5950 uint32_t hdr_size;
5951 fc_packet_t *pkt;
5952 emlxs_buf_t *sbp;
4241
5953
4242 hdr_rqi = hba->sli.sli4.rq_map[cqe->RQid];
4243 hdr_rq = &hba->sli.sli4.rq[hdr_rqi];
4244 data_rq = &hba->sli.sli4.rq[hdr_rqi + 1];
5954 if (cqe->Code == CQE_TYPE_UNSOL_RCV_V1) {
5955 CQE_UnsolRcvV1_t *cqeV1 = (CQE_UnsolRcvV1_t *)cqe;
4245
5956
4246 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4247 "CQ ENTRY: Unsol Rcv: RQid=%d,%d index=%d status=%x "
4248 "hdr_size=%d data_size=%d",
4249 cqe->RQid, hdr_rqi, hdr_rq->host_index, cqe->Status, cqe->hdr_size,
4250 cqe->data_size);
5957 status = cqeV1->Status;
5958 data_size = cqeV1->data_size;
5959 rqid = cqeV1->RQid;
5960 hdr_size = cqeV1->hdr_size;
5961 } else {
5962 status = cqe->Status;
5963 data_size = cqe->data_size;
5964 rqid = cqe->RQid;
5965 hdr_size = cqe->hdr_size;
5966 }
4251
4252 /* Validate the CQE */
4253
4254 /* Check status */
5967
5968 /* Validate the CQE */
5969
5970 /* Check status */
4255 switch (cqe->Status) {
5971 switch (status) {
4256 case RQ_STATUS_SUCCESS: /* 0x10 */
4257 break;
4258
4259 case RQ_STATUS_BUFLEN_EXCEEDED: /* 0x11 */
4260 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4261 "CQ ENTRY: Unsol Rcv: Payload truncated.");
4262 break;
4263

--- 5 unchanged lines hidden (view full) ---

4269 case RQ_STATUS_FRAME_DISCARDED: /* 0x13 */
4270 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4271 "CQ ENTRY: Unsol Rcv: Payload buffer discarded.");
4272 return;
4273
4274 default:
4275 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4276 "CQ ENTRY: Unsol Rcv: Unknown status=%x.",
5972 case RQ_STATUS_SUCCESS: /* 0x10 */
5973 break;
5974
5975 case RQ_STATUS_BUFLEN_EXCEEDED: /* 0x11 */
5976 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5977 "CQ ENTRY: Unsol Rcv: Payload truncated.");
5978 break;
5979

--- 5 unchanged lines hidden (view full) ---

5985 case RQ_STATUS_FRAME_DISCARDED: /* 0x13 */
5986 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5987 "CQ ENTRY: Unsol Rcv: Payload buffer discarded.");
5988 return;
5989
5990 default:
5991 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5992 "CQ ENTRY: Unsol Rcv: Unknown status=%x.",
4277 cqe->Status);
5993 status);
4278 break;
4279 }
4280
4281 /* Make sure there is a frame header */
5994 break;
5995 }
5996
5997 /* Make sure there is a frame header */
4282 if (cqe->hdr_size < sizeof (fc_frame_hdr_t)) {
5998 if (hdr_size < sizeof (fc_frame_hdr_t)) {
4283 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4284 "CQ ENTRY: Unsol Rcv: FC header too small. Dropping...");
4285 return;
4286 }
4287
5999 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6000 "CQ ENTRY: Unsol Rcv: FC header too small. Dropping...");
6001 return;
6002 }
6003
6004 hdr_rqi = emlxs_sli4_rqid_to_index(hba, rqid);
6005
6006 /* Verify RQ index */
6007 if (hdr_rqi == 0xffff) {
6008 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6009 "CQ ENTRY: Unsol Rcv: Invalid RQID:%d. Dropping...",
6010 rqid);
6011 return;
6012 }
6013
6014 hdr_rq = &hba->sli.sli4.rq[hdr_rqi];
6015 data_rq = &hba->sli.sli4.rq[hdr_rqi + 1];
6016
6017 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6018 "CQ ENTRY: Unsol Rcv:%x rqid=%d,%d index=%d status=%x "
6019 "hdr_size=%d data_size=%d",
6020 cqe->Code, rqid, hdr_rqi, hdr_rq->host_index, status, hdr_size,
6021 data_size);
6022
6023 hdr_rq->num_proc++;
6024
4288 /* Update host index */
4289 mutex_enter(&hba->sli.sli4.rq[hdr_rqi].lock);
4290 host_index = hdr_rq->host_index;
4291 hdr_rq->host_index++;
6025 /* Update host index */
6026 mutex_enter(&hba->sli.sli4.rq[hdr_rqi].lock);
6027 host_index = hdr_rq->host_index;
6028 hdr_rq->host_index++;
6029
4292 if (hdr_rq->host_index >= hdr_rq->max_index) {
4293 hdr_rq->host_index = 0;
4294 }
4295 data_rq->host_index = hdr_rq->host_index;
4296 mutex_exit(&hba->sli.sli4.rq[hdr_rqi].lock);
4297
4298 /* Get the next header rqb */
4299 hdr_mp = &hdr_rq->rqb[host_index];

--- 26 unchanged lines hidden (view full) ---

4326 "RQ ENTRY: Unexpected FC rctl (0x%x) "
4327 "received. Dropping...",
4328 fchdr.r_ctl);
4329
4330 goto done;
4331 }
4332
4333 /* Make sure there is no payload */
6030 if (hdr_rq->host_index >= hdr_rq->max_index) {
6031 hdr_rq->host_index = 0;
6032 }
6033 data_rq->host_index = hdr_rq->host_index;
6034 mutex_exit(&hba->sli.sli4.rq[hdr_rqi].lock);
6035
6036 /* Get the next header rqb */
6037 hdr_mp = &hdr_rq->rqb[host_index];

--- 26 unchanged lines hidden (view full) ---

6064 "RQ ENTRY: Unexpected FC rctl (0x%x) "
6065 "received. Dropping...",
6066 fchdr.r_ctl);
6067
6068 goto done;
6069 }
6070
6071 /* Make sure there is no payload */
4334 if (cqe->data_size != 0) {
6072 if (data_size != 0) {
4335 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4336 "RQ ENTRY: ABTS payload provided. Dropping...");
4337
4338 goto done;
4339 }
4340
4341 buf_type = 0xFFFFFFFF;
6073 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6074 "RQ ENTRY: ABTS payload provided. Dropping...");
6075
6076 goto done;
6077 }
6078
6079 buf_type = 0xFFFFFFFF;
4342 (void) strcpy(label, "ABTS");
6080 (void) strlcpy(label, "ABTS", sizeof (label));
4343 cp = &hba->chan[hba->channel_els];
4344 break;
4345
4346 case 0x01: /* ELS */
4347 /* Make sure there is a payload */
6081 cp = &hba->chan[hba->channel_els];
6082 break;
6083
6084 case 0x01: /* ELS */
6085 /* Make sure there is a payload */
4348 if (cqe->data_size == 0) {
6086 if (data_size == 0) {
4349 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4350 "RQ ENTRY: Unsol Rcv: No ELS payload provided. "
4351 "Dropping...");
4352
4353 goto done;
4354 }
4355
4356 buf_type = MEM_ELSBUF;
6087 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6088 "RQ ENTRY: Unsol Rcv: No ELS payload provided. "
6089 "Dropping...");
6090
6091 goto done;
6092 }
6093
6094 buf_type = MEM_ELSBUF;
4357 (void) strcpy(label, "Unsol ELS");
6095 (void) strlcpy(label, "Unsol ELS", sizeof (label));
4358 cp = &hba->chan[hba->channel_els];
4359 break;
4360
4361 case 0x20: /* CT */
4362 /* Make sure there is a payload */
6096 cp = &hba->chan[hba->channel_els];
6097 break;
6098
6099 case 0x20: /* CT */
6100 /* Make sure there is a payload */
4363 if (cqe->data_size == 0) {
6101 if (data_size == 0) {
4364 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4365 "RQ ENTRY: Unsol Rcv: No CT payload provided. "
4366 "Dropping...");
4367
4368 goto done;
4369 }
4370
4371 buf_type = MEM_CTBUF;
6102 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6103 "RQ ENTRY: Unsol Rcv: No CT payload provided. "
6104 "Dropping...");
6105
6106 goto done;
6107 }
6108
6109 buf_type = MEM_CTBUF;
4372 (void) strcpy(label, "Unsol CT");
6110 (void) strlcpy(label, "Unsol CT", sizeof (label));
4373 cp = &hba->chan[hba->channel_ct];
4374 break;
4375
6111 cp = &hba->chan[hba->channel_ct];
6112 break;
6113
6114 case 0x08: /* FCT */
6115 /* Make sure there is a payload */
6116 if (data_size == 0) {
6117 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6118 "RQ ENTRY: Unsol Rcv: No FCP payload provided. "
6119 "Dropping...");
6120
6121 goto done;
6122 }
6123
6124 buf_type = MEM_FCTBUF;
6125 (void) strlcpy(label, "Unsol FCT", sizeof (label));
6126 cp = &hba->chan[hba->CHANNEL_FCT];
6127 break;
6128
4376 default:
4377 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4378 "RQ ENTRY: Unexpected FC type (0x%x) received. Dropping...",
4379 fchdr.type);
4380
4381 goto done;
4382 }
4383 /* Fc Header is valid */

--- 8 unchanged lines hidden (view full) ---

4392 "RQ ENTRY: %s: First of sequence not"
4393 " set. Dropping...",
4394 label);
4395
4396 goto done;
4397 }
4398 }
4399
6129 default:
6130 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6131 "RQ ENTRY: Unexpected FC type (0x%x) received. Dropping...",
6132 fchdr.type);
6133
6134 goto done;
6135 }
6136 /* Fc Header is valid */

--- 8 unchanged lines hidden (view full) ---

6145 "RQ ENTRY: %s: First of sequence not"
6146 " set. Dropping...",
6147 label);
6148
6149 goto done;
6150 }
6151 }
6152
4400 if (fchdr.seq_cnt != 0) {
6153 if ((fchdr.type != 0) && (fchdr.seq_cnt != 0)) {
4401 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4402 "RQ ENTRY: %s: Sequence count not zero (%d). "
4403 "Dropping...",
4404 label, fchdr.seq_cnt);
4405
4406 goto done;
4407 }
4408
6154 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6155 "RQ ENTRY: %s: Sequence count not zero (%d). "
6156 "Dropping...",
6157 label, fchdr.seq_cnt);
6158
6159 goto done;
6160 }
6161
4409 /* Find vport (defaults to physical port) */
6162 /* Find vport */
4410 for (i = 0; i < MAX_VPORTS; i++) {
4411 vport = &VPORT(i);
4412
4413 if (vport->did == fchdr.d_id) {
4414 port = vport;
4415 break;
4416 }
4417 }
4418
6163 for (i = 0; i < MAX_VPORTS; i++) {
6164 vport = &VPORT(i);
6165
6166 if (vport->did == fchdr.d_id) {
6167 port = vport;
6168 break;
6169 }
6170 }
6171
6172 if (i == MAX_VPORTS) {
6173 /* Allow unsol FLOGI & PLOGI for P2P */
6174 if ((fchdr.type != 1 /* ELS*/) ||
6175 ((fchdr.d_id != FABRIC_DID) &&
6176 !(hba->flag & FC_PT_TO_PT))) {
6177 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6178 "RQ ENTRY: %s: Invalid did=%x. Dropping...",
6179 label, fchdr.d_id);
6180
6181 goto done;
6182 }
6183 }
6184
4419 /* Allocate an IOCBQ */
6185 /* Allocate an IOCBQ */
4420 iocbq = (emlxs_iocbq_t *)emlxs_mem_get(hba,
4421 MEM_IOCB, 1);
6186 iocbq = (emlxs_iocbq_t *)emlxs_mem_get(hba, MEM_IOCB);
4422
4423 if (!iocbq) {
4424 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4425 "RQ ENTRY: %s: Out of IOCB "
4426 "resources. Dropping...",
4427 label);
4428
4429 goto done;
4430 }
4431
4432 seq_mp = NULL;
4433 if (fchdr.type != 0) {
4434 /* Allocate a buffer */
6187
6188 if (!iocbq) {
6189 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6190 "RQ ENTRY: %s: Out of IOCB "
6191 "resources. Dropping...",
6192 label);
6193
6194 goto done;
6195 }
6196
6197 seq_mp = NULL;
6198 if (fchdr.type != 0) {
6199 /* Allocate a buffer */
4435 seq_mp = (MATCHMAP *)emlxs_mem_get(hba, buf_type, 1);
6200 seq_mp = (MATCHMAP *)emlxs_mem_get(hba, buf_type);
4436
4437 if (!seq_mp) {
4438 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4439 "RQ ENTRY: %s: Out of buffer "
4440 "resources. Dropping...",
4441 label);
4442
4443 goto done;
4444 }
4445
4446 iocbq->bp = (uint8_t *)seq_mp;
4447 }
4448
6201
6202 if (!seq_mp) {
6203 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6204 "RQ ENTRY: %s: Out of buffer "
6205 "resources. Dropping...",
6206 label);
6207
6208 goto done;
6209 }
6210
6211 iocbq->bp = (uint8_t *)seq_mp;
6212 }
6213
4449 node = (void *)emlxs_node_find_did(port, fchdr.s_id);
6214 node = (void *)emlxs_node_find_did(port, fchdr.s_id, 1);
4450 if (node == NULL) {
4451 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4452 "RQ ENTRY: %s: Node not found. sid=%x",
4453 label, fchdr.s_id);
4454 }
4455
4456 /* Initialize the iocbq */
4457 iocbq->port = port;

--- 25 unchanged lines hidden (view full) ---

4483 label, fchdr.seq_cnt, seq_cnt);
4484
4485 goto done;
4486 }
4487 }
4488
4489 /* We now have an iocbq */
4490
6215 if (node == NULL) {
6216 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6217 "RQ ENTRY: %s: Node not found. sid=%x",
6218 label, fchdr.s_id);
6219 }
6220
6221 /* Initialize the iocbq */
6222 iocbq->port = port;

--- 25 unchanged lines hidden (view full) ---

6248 label, fchdr.seq_cnt, seq_cnt);
6249
6250 goto done;
6251 }
6252 }
6253
6254 /* We now have an iocbq */
6255
4491 if (!port->VPIobj.vfip) {
6256 if (!port->vpip->vfip) {
4492 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4493 "RQ ENTRY: %s: No fabric connection. "
4494 "Dropping...",
4495 label);
4496
4497 goto done;
4498 }
4499
4500 /* Save the frame data to our seq buffer */
6257 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6258 "RQ ENTRY: %s: No fabric connection. "
6259 "Dropping...",
6260 label);
6261
6262 goto done;
6263 }
6264
6265 /* Save the frame data to our seq buffer */
4501 if (cqe->data_size && seq_mp) {
6266 if (data_size && seq_mp) {
4502 /* Get the next data rqb */
4503 data_mp = &data_rq->rqb[host_index];
4504
4505 offset = (off_t)((uint64_t)((unsigned long)
4506 data_mp->virt) -
4507 (uint64_t)((unsigned long)
4508 hba->sli.sli4.slim2.virt));
4509
4510 EMLXS_MPDATA_SYNC(data_mp->dma_handle, offset,
6267 /* Get the next data rqb */
6268 data_mp = &data_rq->rqb[host_index];
6269
6270 offset = (off_t)((uint64_t)((unsigned long)
6271 data_mp->virt) -
6272 (uint64_t)((unsigned long)
6273 hba->sli.sli4.slim2.virt));
6274
6275 EMLXS_MPDATA_SYNC(data_mp->dma_handle, offset,
4511 cqe->data_size, DDI_DMA_SYNC_FORKERNEL);
6276 data_size, DDI_DMA_SYNC_FORKERNEL);
4512
4513 data = (uint32_t *)data_mp->virt;
4514
4515 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4516 "RQ DAT[%d]: %08x %08x %08x %08x %08x %08x ...",
4517 host_index, data[0], data[1], data[2], data[3],
4518 data[4], data[5]);
4519
4520 /* Check sequence length */
6277
6278 data = (uint32_t *)data_mp->virt;
6279
6280 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6281 "RQ DAT[%d]: %08x %08x %08x %08x %08x %08x ...",
6282 host_index, data[0], data[1], data[2], data[3],
6283 data[4], data[5]);
6284
6285 /* Check sequence length */
4521 if ((seq_len + cqe->data_size) > seq_mp->size) {
6286 if ((seq_len + data_size) > seq_mp->size) {
4522 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4523 "RQ ENTRY: %s: Sequence buffer overflow. "
4524 "(%d > %d). Dropping...",
6287 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6288 "RQ ENTRY: %s: Sequence buffer overflow. "
6289 "(%d > %d). Dropping...",
4525 label, (seq_len + cqe->data_size), seq_mp->size);
6290 label, (seq_len + data_size), seq_mp->size);
4526
4527 goto done;
4528 }
4529
4530 /* Copy data to local receive buffer */
4531 bcopy((uint8_t *)data, ((uint8_t *)seq_mp->virt +
6291
6292 goto done;
6293 }
6294
6295 /* Copy data to local receive buffer */
6296 bcopy((uint8_t *)data, ((uint8_t *)seq_mp->virt +
4532 seq_len), cqe->data_size);
6297 seq_len), data_size);
4533
6298
4534 seq_len += cqe->data_size;
6299 seq_len += data_size;
4535 }
4536
4537 /* If this is not the last frame of sequence, queue it. */
4538 if (!(fchdr.f_ctl & F_CTL_END_SEQ)) {
4539 /* Save sequence header */
4540 if (seq_cnt == 0) {
4541 bcopy((uint8_t *)&fchdr, (uint8_t *)iocb->RXFCHDR,
4542 sizeof (fc_frame_hdr_t));

--- 28 unchanged lines hidden (view full) ---

4571 bzero((uint8_t *)iocb, sizeof (emlxs_iocb_t));
4572 }
4573
4574 /* Build rcv iocb and process it */
4575 switch (fchdr.type) {
4576 case 0: /* BLS */
4577
4578 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6300 }
6301
6302 /* If this is not the last frame of sequence, queue it. */
6303 if (!(fchdr.f_ctl & F_CTL_END_SEQ)) {
6304 /* Save sequence header */
6305 if (seq_cnt == 0) {
6306 bcopy((uint8_t *)&fchdr, (uint8_t *)iocb->RXFCHDR,
6307 sizeof (fc_frame_hdr_t));

--- 28 unchanged lines hidden (view full) ---

6336 bzero((uint8_t *)iocb, sizeof (emlxs_iocb_t));
6337 }
6338
6339 /* Build rcv iocb and process it */
6340 switch (fchdr.type) {
6341 case 0: /* BLS */
6342
6343 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4579 "RQ ENTRY: %s: xid:%x sid:%x. Sending BLS ACC...",
4580 label, fchdr.ox_id, fchdr.s_id);
6344 "RQ ENTRY: %s: oxid:%x rxid %x sid:%x. Sending BLS ACC...",
6345 label, fchdr.ox_id, fchdr.rx_id, fchdr.s_id);
4581
6346
4582 iocbq->flag |= (IOCB_PRIORITY | IOCB_SPECIAL);
6347 /* Try to send abort response */
6348 if (!(pkt = emlxs_pkt_alloc(port, 0, 0, 0, KM_NOSLEEP))) {
6349 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6350 "RQ ENTRY: %s: Unable to alloc pkt. Dropping...",
6351 label);
6352 goto done;
6353 }
4583
6354
4584 /* Set up an iotag using special Abort iotags */
4585 mutex_enter(&EMLXS_FCTAB_LOCK);
4586 if ((hba->fc_oor_iotag >= EMLXS_MAX_ABORT_TAG)) {
4587 hba->fc_oor_iotag = hba->max_iotag;
6355 /* Setup sbp / iocb for driver initiated cmd */
6356 sbp = PKT2PRIV(pkt);
6357
6358 /* Free the temporary iocbq */
6359 emlxs_mem_put(hba, MEM_IOCB, (void *)iocbq);
6360
6361 iocbq = (emlxs_iocbq_t *)&sbp->iocbq;
6362 iocbq->port = port;
6363 iocbq->channel = cp;
6364 iocbq->node = node;
6365
6366 sbp->pkt_flags &= ~PACKET_ULP_OWNED;
6367
6368 if (node) {
6369 sbp->node = node;
6370 sbp->did = node->nlp_DID;
4588 }
6371 }
4589 iotag = hba->fc_oor_iotag++;
4590 mutex_exit(&EMLXS_FCTAB_LOCK);
4591
6372
6373 iocbq->flag |= (IOCB_PRIORITY | IOCB_SPECIAL);
6374
4592 /* BLS ACC Response */
4593 wqe = &iocbq->wqe;
4594 bzero((void *)wqe, sizeof (emlxs_wqe_t));
4595
6375 /* BLS ACC Response */
6376 wqe = &iocbq->wqe;
6377 bzero((void *)wqe, sizeof (emlxs_wqe_t));
6378
6379 iocbq->iocb.ULPCOMMAND = CMD_XMIT_BLS_RSP64_CX;
4596 wqe->Command = CMD_XMIT_BLS_RSP64_CX;
4597 wqe->CmdType = WQE_TYPE_GEN;
4598
4599 wqe->un.BlsRsp.Payload0 = 0x80;
4600 wqe->un.BlsRsp.Payload1 = fchdr.seq_id;
4601
4602 wqe->un.BlsRsp.OXId = fchdr.ox_id;
4603 wqe->un.BlsRsp.RXId = fchdr.rx_id;
4604
4605 wqe->un.BlsRsp.SeqCntLow = 0;
4606 wqe->un.BlsRsp.SeqCntHigh = 0xFFFF;
4607
6380 wqe->Command = CMD_XMIT_BLS_RSP64_CX;
6381 wqe->CmdType = WQE_TYPE_GEN;
6382
6383 wqe->un.BlsRsp.Payload0 = 0x80;
6384 wqe->un.BlsRsp.Payload1 = fchdr.seq_id;
6385
6386 wqe->un.BlsRsp.OXId = fchdr.ox_id;
6387 wqe->un.BlsRsp.RXId = fchdr.rx_id;
6388
6389 wqe->un.BlsRsp.SeqCntLow = 0;
6390 wqe->un.BlsRsp.SeqCntHigh = 0xFFFF;
6391
4608 wqe->un.BlsRsp.XO = 0;
6392 wqe->un.BlsRsp.XO = ((fchdr.f_ctl & F_CTL_XCHG_CONTEXT)? 1:0);
4609 wqe->un.BlsRsp.AR = 0;
6393 wqe->un.BlsRsp.AR = 0;
4610 wqe->un.BlsRsp.PT = 1;
4611 wqe->un.BlsRsp.RemoteId = fchdr.s_id;
4612
6394
4613 wqe->PU = 0x3;
4614 wqe->ContextTag = port->VPIobj.VPI;
4615 wqe->ContextType = WQE_VPI_CONTEXT;
4616 wqe->OXId = (volatile uint16_t) fchdr.ox_id;
4617 wqe->XRITag = 0xffff;
6395 rpip = EMLXS_NODE_TO_RPI(port, node);
4618
6396
6397 if (rpip) {
6398 wqe->ContextType = WQE_RPI_CONTEXT;
6399 wqe->ContextTag = rpip->RPI;
6400 } else {
6401 wqe->ContextType = WQE_VPI_CONTEXT;
6402 wqe->ContextTag = port->vpip->VPI;
6403
6404 rpip = emlxs_rpi_reserve_notify(port, fchdr.s_id, 0);
6405
6406 if (!rpip) {
6407 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6408 "RQ ENTRY: %s: Unable to alloc "
6409 "reserved RPI. Dropping...",
6410 label);
6411
6412 goto done;
6413 }
6414
6415 /* Store the reserved rpi */
6416 wqe->CmdSpecific = rpip->RPI;
6417
6418 wqe->un.BlsRsp.RemoteId = fchdr.s_id;
6419 wqe->un.BlsRsp.LocalId = fchdr.d_id;
6420 }
6421
4619 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
4620 wqe->CCPE = 1;
4621 wqe->CCP = fchdr.rsvd;
4622 }
4623
6422 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
6423 wqe->CCPE = 1;
6424 wqe->CCP = fchdr.rsvd;
6425 }
6426
6427 /* Allocate an exchange for this command */
6428 xrip = emlxs_sli4_alloc_xri(port, sbp, rpip,
6429 EMLXS_XRI_SOL_BLS_TYPE);
6430
6431 if (!xrip) {
6432 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6433 "RQ ENTRY: %s: Unable to alloc XRI. Dropping...",
6434 label);
6435 goto done;
6436 }
6437
6438 wqe->XRITag = xrip->XRI;
4624 wqe->Class = CLASS3;
6439 wqe->Class = CLASS3;
4625 wqe->RequestTag = iotag;
4626 wqe->CQId = 0x3ff;
6440 wqe->RequestTag = xrip->iotag;
6441 wqe->CQId = (uint16_t)0xffff; /* default CQ for response */
4627
6442
6443 sbp->ticks = hba->timer_tics + 30;
6444
4628 emlxs_sli4_issue_iocb_cmd(hba, iocbq->channel, iocbq);
4629
6445 emlxs_sli4_issue_iocb_cmd(hba, iocbq->channel, iocbq);
6446
6447 /* The temporary iocbq has been freed already */
6448 iocbq = NULL;
6449
4630 break;
4631
4632 case 1: /* ELS */
6450 break;
6451
6452 case 1: /* ELS */
4633 if (!(port->VPIobj.flag & EMLXS_VPI_PORT_ENABLED)) {
4634 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4635 "RQ ENTRY: %s: Port not yet enabled. "
4636 "Dropping...",
4637 label);
6453 cmd = *((uint32_t *)seq_mp->virt);
6454 cmd &= ELS_CMD_MASK;
4638
6455
4639 goto done;
6456 if (!(port->vpip->flag & EMLXS_VPI_PORT_ENABLED)) {
6457 uint32_t dropit = 1;
6458
6459 /* Allow for P2P handshaking */
6460 switch (cmd) {
6461 case ELS_CMD_FLOGI:
6462 dropit = 0;
6463 break;
6464
6465 case ELS_CMD_PLOGI:
6466 case ELS_CMD_PRLI:
6467 if (hba->flag & FC_PT_TO_PT) {
6468 dropit = 0;
6469 }
6470 break;
6471 }
6472
6473 if (dropit) {
6474 EMLXS_MSGF(EMLXS_CONTEXT,
6475 &emlxs_sli_detail_msg,
6476 "RQ ENTRY: %s: Port not yet enabled. "
6477 "Dropping...",
6478 label);
6479 goto done;
6480 }
4640 }
4641
6481 }
6482
4642 cmd = *((uint32_t *)seq_mp->virt);
4643 cmd &= ELS_CMD_MASK;
4644 rpip = NULL;
4645
4646 if (cmd != ELS_CMD_LOGO) {
4647 rpip = EMLXS_NODE_TO_RPI(port, node);
4648 }
4649
4650 if (!rpip) {
6483 rpip = NULL;
6484
6485 if (cmd != ELS_CMD_LOGO) {
6486 rpip = EMLXS_NODE_TO_RPI(port, node);
6487 }
6488
6489 if (!rpip) {
4651 rpip = port->VPIobj.rpip;
6490 /* Use the fabric rpi */
6491 rpip = port->vpip->fabric_rpip;
4652 }
4653
6492 }
6493
4654 xrip = emlxs_sli4_reserve_xri(hba, rpip);
6494 xrip = emlxs_sli4_reserve_xri(port, rpip,
6495 EMLXS_XRI_UNSOL_ELS_TYPE, fchdr.ox_id);
4655
4656 if (!xrip) {
4657 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4658 "RQ ENTRY: %s: Out of exchange "
4659 "resources. Dropping...",
4660 label);
4661
4662 goto done;
4663 }
4664
6496
6497 if (!xrip) {
6498 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6499 "RQ ENTRY: %s: Out of exchange "
6500 "resources. Dropping...",
6501 label);
6502
6503 goto done;
6504 }
6505
4665 xrip->rx_id = fchdr.ox_id;
4666
4667 /* Build CMD_RCV_ELS64_CX */
4668 iocb->un.rcvels64.elsReq.tus.f.bdeFlags = 0;
4669 iocb->un.rcvels64.elsReq.tus.f.bdeSize = seq_len;
4670 iocb->un.rcvels64.elsReq.addrLow = PADDR_LO(seq_mp->phys);
4671 iocb->un.rcvels64.elsReq.addrHigh = PADDR_HI(seq_mp->phys);
4672 iocb->ULPBDECOUNT = 1;
4673
4674 iocb->un.rcvels64.remoteID = fchdr.s_id;
4675 iocb->un.rcvels64.parmRo = fchdr.d_id;
4676
4677 iocb->ULPPU = 0x3;
4678 iocb->ULPCONTEXT = xrip->XRI;
4679 iocb->ULPIOTAG = ((node)? node->nlp_Rpi:0);
4680 iocb->ULPCLASS = CLASS3;
4681 iocb->ULPCOMMAND = CMD_RCV_ELS64_CX;
4682
4683 iocb->unsli3.ext_rcv.seq_len = seq_len;
6506 /* Build CMD_RCV_ELS64_CX */
6507 iocb->un.rcvels64.elsReq.tus.f.bdeFlags = 0;
6508 iocb->un.rcvels64.elsReq.tus.f.bdeSize = seq_len;
6509 iocb->un.rcvels64.elsReq.addrLow = PADDR_LO(seq_mp->phys);
6510 iocb->un.rcvels64.elsReq.addrHigh = PADDR_HI(seq_mp->phys);
6511 iocb->ULPBDECOUNT = 1;
6512
6513 iocb->un.rcvels64.remoteID = fchdr.s_id;
6514 iocb->un.rcvels64.parmRo = fchdr.d_id;
6515
6516 iocb->ULPPU = 0x3;
6517 iocb->ULPCONTEXT = xrip->XRI;
6518 iocb->ULPIOTAG = ((node)? node->nlp_Rpi:0);
6519 iocb->ULPCLASS = CLASS3;
6520 iocb->ULPCOMMAND = CMD_RCV_ELS64_CX;
6521
6522 iocb->unsli3.ext_rcv.seq_len = seq_len;
6523 iocb->unsli3.ext_rcv.vpi = port->vpip->VPI;
6524 iocb->unsli3.ext_rcv.oxid = fchdr.ox_id;
6525
6526 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
6527 iocb->unsli3.ext_rcv.ccpe = 1;
6528 iocb->unsli3.ext_rcv.ccp = fchdr.rsvd;
6529 }
6530
6531 if (port->mode == MODE_INITIATOR) {
6532 (void) emlxs_els_handle_unsol_req(port, iocbq->channel,
6533 iocbq, seq_mp, seq_len);
6534 }
6535#ifdef SFCT_SUPPORT
6536 else if (port->mode == MODE_TARGET) {
6537 (void) emlxs_fct_handle_unsol_els(port, iocbq->channel,
6538 iocbq, seq_mp, seq_len);
6539 }
6540#endif /* SFCT_SUPPORT */
6541 break;
6542
6543#ifdef SFCT_SUPPORT
6544 case 8: /* FCT */
6545 if (!(port->VPIobj.flag & EMLXS_VPI_PORT_ENABLED)) {
6546 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6547 "RQ ENTRY: %s: Port not yet enabled. "
6548 "Dropping...",
6549 label);
6550
6551 goto done;
6552 }
6553
6554 rpip = EMLXS_NODE_TO_RPI(port, node);
6555
6556 if (!rpip) {
6557 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6558 "RQ ENTRY: %s: Port not logged in. "
6559 "Dropping...",
6560 label);
6561
6562 goto done;
6563 }
6564
6565 xrip = emlxs_sli4_reserve_xri(port, rpip,
6566 EMLXS_XRI_UNSOL_FCP_TYPE, fchdr.ox_id);
6567
6568 if (!xrip) {
6569 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6570 "RQ ENTRY: %s: Out of exchange "
6571 "resources. Dropping...",
6572 label);
6573
6574 goto done;
6575 }
6576
6577 /* Build CMD_RCV_SEQUENCE64_CX */
6578 iocb->un.rcvseq64.rcvBde.tus.f.bdeFlags = 0;
6579 iocb->un.rcvseq64.rcvBde.tus.f.bdeSize = seq_len;
6580 iocb->un.rcvseq64.rcvBde.addrLow = PADDR_LO(seq_mp->phys);
6581 iocb->un.rcvseq64.rcvBde.addrHigh = PADDR_HI(seq_mp->phys);
6582 iocb->ULPBDECOUNT = 1;
6583
6584 iocb->ULPPU = 0x3;
6585 iocb->ULPCONTEXT = xrip->XRI;
6586 iocb->ULPIOTAG = ((node)? node->nlp_Rpi:0);
6587 iocb->ULPCLASS = CLASS3;
6588 iocb->ULPCOMMAND = CMD_RCV_ELS64_CX;
6589
6590 iocb->unsli3.ext_rcv.seq_len = seq_len;
4684 iocb->unsli3.ext_rcv.vpi = port->VPIobj.VPI;
6591 iocb->unsli3.ext_rcv.vpi = port->VPIobj.VPI;
6592 iocb->unsli3.ext_rcv.oxid = fchdr.ox_id;
4685
4686 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
4687 iocb->unsli3.ext_rcv.ccpe = 1;
4688 iocb->unsli3.ext_rcv.ccp = fchdr.rsvd;
4689 }
4690
6593
6594 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
6595 iocb->unsli3.ext_rcv.ccpe = 1;
6596 iocb->unsli3.ext_rcv.ccp = fchdr.rsvd;
6597 }
6598
4691 (void) emlxs_els_handle_unsol_req(port, iocbq->channel,
4692 iocbq, seq_mp, seq_len);
6599 /* pass xrip to FCT in the iocbq */
6600 iocbq->sbp = xrip;
4693
6601
6602#define EMLXS_FIX_CISCO_BUG1
6603#ifdef EMLXS_FIX_CISCO_BUG1
6604{
6605uint8_t *ptr;
6606ptr = ((uint8_t *)seq_mp->virt);
6607if (((*ptr+12) != 0xa0) && (*(ptr+20) == 0x8) && (*(ptr+21) == 0x8)) {
6608 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6609 "RQ ENTRY: Bad CDB fixed");
6610 *ptr++ = 0;
6611 *ptr = 0;
6612}
6613}
6614#endif
6615 (void) emlxs_fct_handle_unsol_req(port, cp, iocbq,
6616 seq_mp, seq_len);
4694 break;
6617 break;
6618#endif /* SFCT_SUPPORT */
4695
4696 case 0x20: /* CT */
6619
6620 case 0x20: /* CT */
4697 if (!(port->VPIobj.flag & EMLXS_VPI_PORT_ENABLED)) {
6621 if (!(port->vpip->flag & EMLXS_VPI_PORT_ENABLED) &&
6622 !(hba->flag & FC_LOOPBACK_MODE)) {
4698 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4699 "RQ ENTRY: %s: Port not yet enabled. "
4700 "Dropping...",
4701 label);
4702
4703 goto done;
4704 }
4705

--- 5 unchanged lines hidden (view full) ---

4711
4712 goto done;
4713 }
4714
4715 rpip = EMLXS_NODE_TO_RPI(port, node);
4716
4717 if (!rpip) {
4718 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6623 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6624 "RQ ENTRY: %s: Port not yet enabled. "
6625 "Dropping...",
6626 label);
6627
6628 goto done;
6629 }
6630

--- 5 unchanged lines hidden (view full) ---

6636
6637 goto done;
6638 }
6639
6640 rpip = EMLXS_NODE_TO_RPI(port, node);
6641
6642 if (!rpip) {
6643 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4719 "RQ ENTRY: %s: RPI not found (did=%x rpi=%x). "
6644 "RQ ENTRY: %s: RPI not found (did=%x rpi=%d). "
4720 "Dropping...",
4721 label, fchdr.d_id, node->nlp_Rpi);
4722
4723 goto done;
4724 }
4725
6645 "Dropping...",
6646 label, fchdr.d_id, node->nlp_Rpi);
6647
6648 goto done;
6649 }
6650
4726 xrip = emlxs_sli4_reserve_xri(hba, rpip);
6651 xrip = emlxs_sli4_reserve_xri(port, rpip,
6652 EMLXS_XRI_UNSOL_CT_TYPE, fchdr.ox_id);
4727
4728 if (!xrip) {
4729 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4730 "RQ ENTRY: %s: Out of exchange "
4731 "resources. Dropping...",
4732 label);
4733
4734 goto done;
4735 }
4736
6653
6654 if (!xrip) {
6655 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6656 "RQ ENTRY: %s: Out of exchange "
6657 "resources. Dropping...",
6658 label);
6659
6660 goto done;
6661 }
6662
4737 xrip->rx_id = fchdr.ox_id;
4738
4739 /* Build CMD_RCV_SEQ64_CX */
4740 iocb->un.rcvseq64.rcvBde.tus.f.bdeFlags = 0;
4741 iocb->un.rcvseq64.rcvBde.tus.f.bdeSize = seq_len;
4742 iocb->un.rcvseq64.rcvBde.addrLow = PADDR_LO(seq_mp->phys);
4743 iocb->un.rcvseq64.rcvBde.addrHigh = PADDR_HI(seq_mp->phys);
4744 iocb->ULPBDECOUNT = 1;
4745
4746 iocb->un.rcvseq64.xrsqRo = 0;

--- 4 unchanged lines hidden (view full) ---

4751
4752 iocb->ULPPU = 0x3;
4753 iocb->ULPCONTEXT = xrip->XRI;
4754 iocb->ULPIOTAG = rpip->RPI;
4755 iocb->ULPCLASS = CLASS3;
4756 iocb->ULPCOMMAND = CMD_RCV_SEQ64_CX;
4757
4758 iocb->unsli3.ext_rcv.seq_len = seq_len;
6663 /* Build CMD_RCV_SEQ64_CX */
6664 iocb->un.rcvseq64.rcvBde.tus.f.bdeFlags = 0;
6665 iocb->un.rcvseq64.rcvBde.tus.f.bdeSize = seq_len;
6666 iocb->un.rcvseq64.rcvBde.addrLow = PADDR_LO(seq_mp->phys);
6667 iocb->un.rcvseq64.rcvBde.addrHigh = PADDR_HI(seq_mp->phys);
6668 iocb->ULPBDECOUNT = 1;
6669
6670 iocb->un.rcvseq64.xrsqRo = 0;

--- 4 unchanged lines hidden (view full) ---

6675
6676 iocb->ULPPU = 0x3;
6677 iocb->ULPCONTEXT = xrip->XRI;
6678 iocb->ULPIOTAG = rpip->RPI;
6679 iocb->ULPCLASS = CLASS3;
6680 iocb->ULPCOMMAND = CMD_RCV_SEQ64_CX;
6681
6682 iocb->unsli3.ext_rcv.seq_len = seq_len;
4759 iocb->unsli3.ext_rcv.vpi = port->VPIobj.VPI;
6683 iocb->unsli3.ext_rcv.vpi = port->vpip->VPI;
4760
4761 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
4762 iocb->unsli3.ext_rcv.ccpe = 1;
4763 iocb->unsli3.ext_rcv.ccp = fchdr.rsvd;
4764 }
4765
4766 (void) emlxs_ct_handle_unsol_req(port, iocbq->channel,
4767 iocbq, seq_mp, seq_len);

--- 15 unchanged lines hidden (view full) ---

4783 /* !!! Currently, we have no implementation for this !!! */
4784 abort = 0;
4785 }
4786
4787 /* Return memory resources to pools */
4788 if (iocbq) {
4789 if (iocbq->bp) {
4790 emlxs_mem_put(hba, buf_type, (void *)iocbq->bp);
6684
6685 if (fchdr.f_ctl & F_CTL_CHAINED_SEQ) {
6686 iocb->unsli3.ext_rcv.ccpe = 1;
6687 iocb->unsli3.ext_rcv.ccp = fchdr.rsvd;
6688 }
6689
6690 (void) emlxs_ct_handle_unsol_req(port, iocbq->channel,
6691 iocbq, seq_mp, seq_len);

--- 15 unchanged lines hidden (view full) ---

6707 /* !!! Currently, we have no implementation for this !!! */
6708 abort = 0;
6709 }
6710
6711 /* Return memory resources to pools */
6712 if (iocbq) {
6713 if (iocbq->bp) {
6714 emlxs_mem_put(hba, buf_type, (void *)iocbq->bp);
6715 iocbq->bp = 0;
4791 }
4792
4793 emlxs_mem_put(hba, MEM_IOCB, (void *)iocbq);
4794 }
4795
4796#ifdef FMA_SUPPORT
4797 if (emlxs_fm_check_dma_handle(hba,
4798 hba->sli.sli4.slim2.dma_handle)
4799 != DDI_FM_OK) {
4800 EMLXS_MSGF(EMLXS_CONTEXT,
4801 &emlxs_invalid_dma_handle_msg,
6716 }
6717
6718 emlxs_mem_put(hba, MEM_IOCB, (void *)iocbq);
6719 }
6720
6721#ifdef FMA_SUPPORT
6722 if (emlxs_fm_check_dma_handle(hba,
6723 hba->sli.sli4.slim2.dma_handle)
6724 != DDI_FM_OK) {
6725 EMLXS_MSGF(EMLXS_CONTEXT,
6726 &emlxs_invalid_dma_handle_msg,
4802 "emlxs_sli4_process_unsol_rcv: hdl=%p",
6727 "sli4_process_unsol_rcv: hdl=%p",
4803 hba->sli.sli4.slim2.dma_handle);
4804
4805 emlxs_thread_spawn(hba, emlxs_restart_thread,
4806 0, 0);
4807 }
4808#endif
4809 return;
4810

--- 5 unchanged lines hidden (view full) ---

4816emlxs_sli4_process_xri_aborted(emlxs_hba_t *hba, CQ_DESC_t *cq,
4817 CQE_XRI_Abort_t *cqe)
4818{
4819 emlxs_port_t *port = &PPORT;
4820 XRIobj_t *xrip;
4821
4822 mutex_enter(&EMLXS_FCTAB_LOCK);
4823
6728 hba->sli.sli4.slim2.dma_handle);
6729
6730 emlxs_thread_spawn(hba, emlxs_restart_thread,
6731 0, 0);
6732 }
6733#endif
6734 return;
6735

--- 5 unchanged lines hidden (view full) ---

6741emlxs_sli4_process_xri_aborted(emlxs_hba_t *hba, CQ_DESC_t *cq,
6742 CQE_XRI_Abort_t *cqe)
6743{
6744 emlxs_port_t *port = &PPORT;
6745 XRIobj_t *xrip;
6746
6747 mutex_enter(&EMLXS_FCTAB_LOCK);
6748
4824 xrip = emlxs_sli4_find_xri(hba, cqe->XRI);
6749 xrip = emlxs_sli4_find_xri(port, cqe->XRI);
4825 if (xrip == NULL) {
6750 if (xrip == NULL) {
4826 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4827 "CQ ENTRY: process xri aborted ignored");
6751 /* EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg, */
6752 /* "CQ ENTRY: process xri aborted ignored"); */
4828
4829 mutex_exit(&EMLXS_FCTAB_LOCK);
4830 return;
4831 }
4832
4833 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6753
6754 mutex_exit(&EMLXS_FCTAB_LOCK);
6755 return;
6756 }
6757
6758 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4834 "CQ ENTRY: process xri x%x aborted: IA %d EO %d BR %d",
6759 "CQ ENTRY: XRI Aborted: xri=%d IA=%d EO=%d BR=%d",
4835 cqe->XRI, cqe->IA, cqe->EO, cqe->BR);
4836
6760 cqe->XRI, cqe->IA, cqe->EO, cqe->BR);
6761
4837 if (!(xrip->flag & EMLXS_XRI_ABORT_INP)) {
6762 if (!(xrip->flag & EMLXS_XRI_BUSY)) {
4838 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6763 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
4839 "XRI Aborted: Bad state: x%x xri x%x",
4840 xrip->flag, xrip->XRI);
6764 "CQ ENTRY: XRI Aborted: xri=%d flag=%x. Bad state.",
6765 xrip->XRI, xrip->flag);
4841
4842 mutex_exit(&EMLXS_FCTAB_LOCK);
4843 return;
4844 }
4845
4846 /* Exchange is no longer busy on-chip, free it */
6766
6767 mutex_exit(&EMLXS_FCTAB_LOCK);
6768 return;
6769 }
6770
6771 /* Exchange is no longer busy on-chip, free it */
4847 emlxs_sli4_free_xri(hba, 0, xrip, 0);
6772 emlxs_sli4_free_xri(port, 0, xrip, 0);
4848
4849 mutex_exit(&EMLXS_FCTAB_LOCK);
4850
4851 return;
4852
4853} /* emlxs_sli4_process_xri_aborted () */
4854
4855

--- 18 unchanged lines hidden (view full) ---

4874 (uint64_t)((unsigned long)
4875 hba->sli.sli4.slim2.virt));
4876
4877 EMLXS_MPDATA_SYNC(cq->addr.dma_handle, offset,
4878 4096, DDI_DMA_SYNC_FORKERNEL);
4879
4880 for (;;) {
4881 cq_entry.word[3] = BE_SWAP32(cqe->word[3]);
6773
6774 mutex_exit(&EMLXS_FCTAB_LOCK);
6775
6776 return;
6777
6778} /* emlxs_sli4_process_xri_aborted () */
6779
6780

--- 18 unchanged lines hidden (view full) ---

6799 (uint64_t)((unsigned long)
6800 hba->sli.sli4.slim2.virt));
6801
6802 EMLXS_MPDATA_SYNC(cq->addr.dma_handle, offset,
6803 4096, DDI_DMA_SYNC_FORKERNEL);
6804
6805 for (;;) {
6806 cq_entry.word[3] = BE_SWAP32(cqe->word[3]);
4882 if (!(cq_entry.word[3] & CQE_VALID))
6807 if (!(cq_entry.word[3] & CQE_VALID)) {
4883 break;
6808 break;
6809 }
4884
4885 cq_entry.word[2] = BE_SWAP32(cqe->word[2]);
4886 cq_entry.word[1] = BE_SWAP32(cqe->word[1]);
4887 cq_entry.word[0] = BE_SWAP32(cqe->word[0]);
4888
6810
6811 cq_entry.word[2] = BE_SWAP32(cqe->word[2]);
6812 cq_entry.word[1] = BE_SWAP32(cqe->word[1]);
6813 cq_entry.word[0] = BE_SWAP32(cqe->word[0]);
6814
4889#ifdef SLI4_FASTPATH_DEBUG
4890 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4891 "CQ ENTRY: %08x %08x %08x %08x", cq_entry.word[0],
4892 cq_entry.word[1], cq_entry.word[2], cq_entry.word[3]);
4893#endif
4894
6815#ifdef DEBUG_CQE
6816 emlxs_data_dump(port, "CQE", (uint32_t *)cqe, 6, 0);
6817#endif /* DEBUG_CQE */
4895 num_entries++;
4896 cqe->word[3] = 0;
4897
4898 cq->host_index++;
4899 if (cq->host_index >= cq->max_index) {
4900 cq->host_index = 0;
4901 cqe = (CQE_u *)cq->addr.virt;
4902 } else {

--- 22 unchanged lines hidden (view full) ---

4925 (CQE_CmplWQ_t *)&cq_entry);
4926 }
4927 break;
4928 case CQE_TYPE_RELEASE_WQE:
4929 emlxs_sli4_process_release_wqe(hba, cq,
4930 (CQE_RelWQ_t *)&cq_entry);
4931 break;
4932 case CQE_TYPE_UNSOL_RCV:
6818 num_entries++;
6819 cqe->word[3] = 0;
6820
6821 cq->host_index++;
6822 if (cq->host_index >= cq->max_index) {
6823 cq->host_index = 0;
6824 cqe = (CQE_u *)cq->addr.virt;
6825 } else {

--- 22 unchanged lines hidden (view full) ---

6848 (CQE_CmplWQ_t *)&cq_entry);
6849 }
6850 break;
6851 case CQE_TYPE_RELEASE_WQE:
6852 emlxs_sli4_process_release_wqe(hba, cq,
6853 (CQE_RelWQ_t *)&cq_entry);
6854 break;
6855 case CQE_TYPE_UNSOL_RCV:
6856 case CQE_TYPE_UNSOL_RCV_V1:
4933 emlxs_sli4_process_unsol_rcv(hba, cq,
4934 (CQE_UnsolRcv_t *)&cq_entry);
4935 break;
4936 case CQE_TYPE_XRI_ABORTED:
4937 emlxs_sli4_process_xri_aborted(hba, cq,
4938 (CQE_XRI_Abort_t *)&cq_entry);
4939 break;
4940 default:

--- 4 unchanged lines hidden (view full) ---

4945 cq_entry.word[3]);
4946 break;
4947 }
4948 }
4949
4950 mutex_enter(&EMLXS_PORT_LOCK);
4951 }
4952
6857 emlxs_sli4_process_unsol_rcv(hba, cq,
6858 (CQE_UnsolRcv_t *)&cq_entry);
6859 break;
6860 case CQE_TYPE_XRI_ABORTED:
6861 emlxs_sli4_process_xri_aborted(hba, cq,
6862 (CQE_XRI_Abort_t *)&cq_entry);
6863 break;
6864 default:

--- 4 unchanged lines hidden (view full) ---

6869 cq_entry.word[3]);
6870 break;
6871 }
6872 }
6873
6874 mutex_enter(&EMLXS_PORT_LOCK);
6875 }
6876
6877 /* Number of times this routine gets called for this CQ */
6878 cq->isr_count++;
6879
6880 /* num_entries is the number of CQEs we process in this specific CQ */
6881 cq->num_proc += num_entries;
6882 if (cq->max_proc < num_entries)
6883 cq->max_proc = num_entries;
6884
4953 cqdb = cq->qid;
4954 cqdb |= CQ_DB_REARM;
4955 if (num_entries != 0) {
4956 cqdb |= ((num_entries << CQ_DB_POP_SHIFT) & CQ_DB_POP_MASK);
4957 }
4958
6885 cqdb = cq->qid;
6886 cqdb |= CQ_DB_REARM;
6887 if (num_entries != 0) {
6888 cqdb |= ((num_entries << CQ_DB_POP_SHIFT) & CQ_DB_POP_MASK);
6889 }
6890
4959#ifdef SLI4_FASTPATH_DEBUG
6891#ifdef DEBUG_FASTPATH
4960 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6892 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
4961 "CQ CLEAR: %08x: pops:x%x", cqdb, num_entries);
4962#endif
6893 "CQE: CLEAR cqdb=%08x: pops=%d", cqdb, num_entries);
6894#endif /* DEBUG_FASTPATH */
4963
6895
4964 WRITE_BAR2_REG(hba, FC_CQDB_REG(hba), cqdb);
6896 emlxs_sli4_write_cqdb(hba, cqdb);
4965
4966 /* EMLXS_PORT_LOCK must be held when exiting this routine */
4967
4968} /* emlxs_sli4_process_cq() */
4969
4970
4971/*ARGSUSED*/
4972static void
4973emlxs_sli4_process_eq(emlxs_hba_t *hba, EQ_DESC_t *eq)
4974{
6897
6898 /* EMLXS_PORT_LOCK must be held when exiting this routine */
6899
6900} /* emlxs_sli4_process_cq() */
6901
6902
6903/*ARGSUSED*/
6904static void
6905emlxs_sli4_process_eq(emlxs_hba_t *hba, EQ_DESC_t *eq)
6906{
4975#ifdef SLI4_FASTPATH_DEBUG
4976 emlxs_port_t *port = &PPORT;
6907 emlxs_port_t *port = &PPORT;
4977#endif
4978 uint32_t eqdb;
4979 uint32_t *ptr;
4980 CHANNEL *cp;
4981 EQE_u eqe;
4982 uint32_t i;
6908 uint32_t eqdb;
6909 uint32_t *ptr;
6910 CHANNEL *cp;
6911 EQE_u eqe;
6912 uint32_t i;
4983 uint32_t value;
6913 uint16_t cqi;
4984 int num_entries = 0;
4985 off_t offset;
4986
4987 /* EMLXS_PORT_LOCK must be held when entering this routine */
4988
6914 int num_entries = 0;
6915 off_t offset;
6916
6917 /* EMLXS_PORT_LOCK must be held when entering this routine */
6918
6919 hba->intr_busy_cnt ++;
6920
4989 ptr = eq->addr.virt;
4990 ptr += eq->host_index;
4991
4992 offset = (off_t)((uint64_t)((unsigned long)
4993 eq->addr.virt) -
4994 (uint64_t)((unsigned long)
4995 hba->sli.sli4.slim2.virt));
4996
4997 EMLXS_MPDATA_SYNC(eq->addr.dma_handle, offset,
4998 4096, DDI_DMA_SYNC_FORKERNEL);
4999
5000 for (;;) {
5001 eqe.word = *ptr;
5002 eqe.word = BE_SWAP32(eqe.word);
5003
6921 ptr = eq->addr.virt;
6922 ptr += eq->host_index;
6923
6924 offset = (off_t)((uint64_t)((unsigned long)
6925 eq->addr.virt) -
6926 (uint64_t)((unsigned long)
6927 hba->sli.sli4.slim2.virt));
6928
6929 EMLXS_MPDATA_SYNC(eq->addr.dma_handle, offset,
6930 4096, DDI_DMA_SYNC_FORKERNEL);
6931
6932 for (;;) {
6933 eqe.word = *ptr;
6934 eqe.word = BE_SWAP32(eqe.word);
6935
5004 if (!(eqe.word & EQE_VALID))
6936 if (!(eqe.word & EQE_VALID)) {
5005 break;
6937 break;
6938 }
5006
6939
5007#ifdef SLI4_FASTPATH_DEBUG
6940#ifdef DEBUG_FASTPATH
5008 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6941 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5009 "EQ ENTRY: %08x", eqe.word);
5010#endif
6942 "EQE00: %08x", eqe.word);
6943#endif /* DEBUG_FASTPATH */
5011
5012 *ptr = 0;
5013 num_entries++;
5014 eq->host_index++;
5015 if (eq->host_index >= eq->max_index) {
5016 eq->host_index = 0;
5017 ptr = eq->addr.virt;
5018 } else {
5019 ptr++;
5020 }
5021
6944
6945 *ptr = 0;
6946 num_entries++;
6947 eq->host_index++;
6948 if (eq->host_index >= eq->max_index) {
6949 eq->host_index = 0;
6950 ptr = eq->addr.virt;
6951 } else {
6952 ptr++;
6953 }
6954
5022 value = hba->sli.sli4.cq_map[eqe.entry.CQId];
6955 cqi = emlxs_sli4_cqid_to_index(hba, eqe.entry.CQId);
5023
6956
5024#ifdef SLI4_FASTPATH_DEBUG
6957 /* Verify CQ index */
6958 if (cqi == 0xffff) {
6959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
6960 "EQE: Invalid CQid: %d. Dropping...",
6961 eqe.entry.CQId);
6962 continue;
6963 }
6964
6965#ifdef DEBUG_FASTPATH
5025 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6966 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5026 "EQ ENTRY: CQIndex:x%x: cqid:x%x", value, eqe.entry.CQId);
5027#endif
6967 "EQE: CQIndex:%x cqid:%x", cqi, eqe.entry.CQId);
6968#endif /* DEBUG_FASTPATH */
5028
6969
5029 emlxs_sli4_process_cq(hba, &hba->sli.sli4.cq[value]);
6970 emlxs_sli4_process_cq(hba, &hba->sli.sli4.cq[cqi]);
5030 }
5031
6971 }
6972
6973 /* Number of times the ISR for this EQ gets called */
6974 eq->isr_count++;
6975
6976 /* num_entries is the number of EQEs we process in this specific ISR */
6977 eq->num_proc += num_entries;
6978 if (eq->max_proc < num_entries) {
6979 eq->max_proc = num_entries;
6980 }
6981
5032 eqdb = eq->qid;
5033 eqdb |= (EQ_DB_CLEAR | EQ_DB_EVENT | EQ_DB_REARM);
5034
6982 eqdb = eq->qid;
6983 eqdb |= (EQ_DB_CLEAR | EQ_DB_EVENT | EQ_DB_REARM);
6984
5035#ifdef SLI4_FASTPATH_DEBUG
6985#ifdef DEBUG_FASTPATH
5036 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6986 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5037 "EQ CLEAR: %08x: pops:x%x", eqdb, num_entries);
5038#endif
6987 "EQE: CLEAR eqdb=%08x pops=%d", eqdb, num_entries);
6988#endif /* DEBUG_FASTPATH */
5039
5040 if (num_entries != 0) {
5041 eqdb |= ((num_entries << EQ_DB_POP_SHIFT) & EQ_DB_POP_MASK);
5042 for (i = 0; i < hba->chan_count; i++) {
5043 cp = &hba->chan[i];
5044 if (cp->chan_flag & EMLXS_NEEDS_TRIGGER) {
5045 cp->chan_flag &= ~EMLXS_NEEDS_TRIGGER;
5046 emlxs_thread_trigger2(&cp->intr_thread,
5047 emlxs_proc_channel, cp);
5048 }
5049 }
5050 }
5051
6989
6990 if (num_entries != 0) {
6991 eqdb |= ((num_entries << EQ_DB_POP_SHIFT) & EQ_DB_POP_MASK);
6992 for (i = 0; i < hba->chan_count; i++) {
6993 cp = &hba->chan[i];
6994 if (cp->chan_flag & EMLXS_NEEDS_TRIGGER) {
6995 cp->chan_flag &= ~EMLXS_NEEDS_TRIGGER;
6996 emlxs_thread_trigger2(&cp->intr_thread,
6997 emlxs_proc_channel, cp);
6998 }
6999 }
7000 }
7001
5052 WRITE_BAR2_REG(hba, FC_CQDB_REG(hba), eqdb);
7002 emlxs_sli4_write_cqdb(hba, eqdb);
5053
5054 /* EMLXS_PORT_LOCK must be held when exiting this routine */
5055
7003
7004 /* EMLXS_PORT_LOCK must be held when exiting this routine */
7005
7006 hba->intr_busy_cnt --;
7007
5056} /* emlxs_sli4_process_eq() */
5057
5058
5059#ifdef MSI_SUPPORT
5060/*ARGSUSED*/
5061static uint32_t
5062emlxs_sli4_msi_intr(char *arg1, char *arg2)
5063{
5064 emlxs_hba_t *hba = (emlxs_hba_t *)arg1;
7008} /* emlxs_sli4_process_eq() */
7009
7010
7011#ifdef MSI_SUPPORT
7012/*ARGSUSED*/
7013static uint32_t
7014emlxs_sli4_msi_intr(char *arg1, char *arg2)
7015{
7016 emlxs_hba_t *hba = (emlxs_hba_t *)arg1;
5065#ifdef SLI4_FASTPATH_DEBUG
7017#ifdef DEBUG_FASTPATH
5066 emlxs_port_t *port = &PPORT;
7018 emlxs_port_t *port = &PPORT;
5067#endif
7019#endif /* DEBUG_FASTPATH */
5068 uint16_t msgid;
5069 int rc;
5070
7020 uint16_t msgid;
7021 int rc;
7022
5071#ifdef SLI4_FASTPATH_DEBUG
7023#ifdef DEBUG_FASTPATH
5072 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5073 "msiINTR arg1:%p arg2:%p", arg1, arg2);
7024 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7025 "msiINTR arg1:%p arg2:%p", arg1, arg2);
5074#endif
7026#endif /* DEBUG_FASTPATH */
5075
5076 /* Check for legacy interrupt handling */
5077 if (hba->intr_type == DDI_INTR_TYPE_FIXED) {
5078 rc = emlxs_sli4_intx_intr(arg1);
5079 return (rc);
5080 }
5081
5082 /* Get MSI message id */

--- 20 unchanged lines hidden (view full) ---

5103#endif /* MSI_SUPPORT */
5104
5105
5106/*ARGSUSED*/
5107static int
5108emlxs_sli4_intx_intr(char *arg)
5109{
5110 emlxs_hba_t *hba = (emlxs_hba_t *)arg;
7027
7028 /* Check for legacy interrupt handling */
7029 if (hba->intr_type == DDI_INTR_TYPE_FIXED) {
7030 rc = emlxs_sli4_intx_intr(arg1);
7031 return (rc);
7032 }
7033
7034 /* Get MSI message id */

--- 20 unchanged lines hidden (view full) ---

7055#endif /* MSI_SUPPORT */
7056
7057
7058/*ARGSUSED*/
7059static int
7060emlxs_sli4_intx_intr(char *arg)
7061{
7062 emlxs_hba_t *hba = (emlxs_hba_t *)arg;
5111#ifdef SLI4_FASTPATH_DEBUG
7063#ifdef DEBUG_FASTPATH
5112 emlxs_port_t *port = &PPORT;
7064 emlxs_port_t *port = &PPORT;
5113#endif
7065#endif /* DEBUG_FASTPATH */
5114
7066
5115#ifdef SLI4_FASTPATH_DEBUG
7067#ifdef DEBUG_FASTPATH
5116 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5117 "intxINTR arg:%p", arg);
7068 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7069 "intxINTR arg:%p", arg);
5118#endif
7070#endif /* DEBUG_FASTPATH */
5119
5120 mutex_enter(&EMLXS_PORT_LOCK);
5121
5122 if ((hba->state == FC_KILLED) || (hba->flag & FC_OFFLINE_MODE)) {
5123 mutex_exit(&EMLXS_PORT_LOCK);
5124 return (DDI_INTR_UNCLAIMED);
5125 }
5126

--- 16 unchanged lines hidden (view full) ---

5143
5144 mutex_exit(&EMLXS_PORT_LOCK);
5145
5146 return;
5147 }
5148
5149 j = 0;
5150 while (j++ < 10000) {
7071
7072 mutex_enter(&EMLXS_PORT_LOCK);
7073
7074 if ((hba->state == FC_KILLED) || (hba->flag & FC_OFFLINE_MODE)) {
7075 mutex_exit(&EMLXS_PORT_LOCK);
7076 return (DDI_INTR_UNCLAIMED);
7077 }
7078

--- 16 unchanged lines hidden (view full) ---

7095
7096 mutex_exit(&EMLXS_PORT_LOCK);
7097
7098 return;
7099 }
7100
7101 j = 0;
7102 while (j++ < 10000) {
5151 if (hba->mbox_queue_flag == 0) {
7103 if ((hba->mbox_queue_flag == 0) &&
7104 (hba->intr_busy_cnt == 0)) {
5152 break;
5153 }
5154
5155 mutex_exit(&EMLXS_PORT_LOCK);
7105 break;
7106 }
7107
7108 mutex_exit(&EMLXS_PORT_LOCK);
5156 DELAYUS(100);
7109 BUSYWAIT_US(100);
5157 mutex_enter(&EMLXS_PORT_LOCK);
5158 }
5159
7110 mutex_enter(&EMLXS_PORT_LOCK);
7111 }
7112
5160 if (hba->mbox_queue_flag != 0) {
7113 if ((hba->mbox_queue_flag != 0) || (hba->intr_busy_cnt > 0)) {
5161 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
7114 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
5162 "Board kill failed. Mailbox busy.");
7115 "Board kill failed. Adapter busy, %d, %d.",
7116 hba->mbox_queue_flag, hba->intr_busy_cnt);
5163 mutex_exit(&EMLXS_PORT_LOCK);
5164 return;
5165 }
5166
5167 hba->flag |= FC_INTERLOCKED;
5168
5169 EMLXS_STATE_CHANGE_LOCKED(hba, FC_KILLED);
5170
5171 mutex_exit(&EMLXS_PORT_LOCK);
5172
5173} /* emlxs_sli4_hba_kill() */
5174
5175
7117 mutex_exit(&EMLXS_PORT_LOCK);
7118 return;
7119 }
7120
7121 hba->flag |= FC_INTERLOCKED;
7122
7123 EMLXS_STATE_CHANGE_LOCKED(hba, FC_KILLED);
7124
7125 mutex_exit(&EMLXS_PORT_LOCK);
7126
7127} /* emlxs_sli4_hba_kill() */
7128
7129
7130extern void
7131emlxs_sli4_hba_reset_all(emlxs_hba_t *hba, uint32_t flag)
7132{
7133 emlxs_port_t *port = &PPORT;
7134 uint32_t value;
7135
7136 mutex_enter(&EMLXS_PORT_LOCK);
7137
7138 if ((hba->sli_intf & SLI_INTF_IF_TYPE_MASK) != SLI_INTF_IF_TYPE_2) {
7139 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
7140 "Reset All failed. Invalid Operation.");
7141 mutex_exit(&EMLXS_PORT_LOCK);
7142 return;
7143 }
7144
7145 /* Issue a Firmware Reset All Request */
7146 if (flag) {
7147 value = SLI_PHYDEV_FRST | SLI_PHYDEV_FRL_ALL | SLI_PHYDEV_DD;
7148 } else {
7149 value = SLI_PHYDEV_FRST | SLI_PHYDEV_FRL_ALL;
7150 }
7151
7152 ddi_put32(hba->sli.sli4.bar0_acc_handle,
7153 hba->sli.sli4.PHYSDEV_reg_addr, value);
7154
7155 mutex_exit(&EMLXS_PORT_LOCK);
7156
7157} /* emlxs_sli4_hba_reset_all() */
7158
7159
5176static void
5177emlxs_sli4_enable_intr(emlxs_hba_t *hba)
5178{
5179 emlxs_config_t *cfg = &CFG;
5180 int i;
5181 int num_cq;
5182 uint32_t data;
5183
5184 hba->sli.sli4.flag |= EMLXS_SLI4_INTR_ENABLED;
5185
5186 num_cq = (hba->intr_count * cfg[CFG_NUM_WQ].current) +
5187 EMLXS_CQ_OFFSET_WQ;
5188
5189 /* ARM EQ / CQs */
5190 for (i = 0; i < num_cq; i++) {
5191 data = hba->sli.sli4.cq[i].qid;
5192 data |= CQ_DB_REARM;
7160static void
7161emlxs_sli4_enable_intr(emlxs_hba_t *hba)
7162{
7163 emlxs_config_t *cfg = &CFG;
7164 int i;
7165 int num_cq;
7166 uint32_t data;
7167
7168 hba->sli.sli4.flag |= EMLXS_SLI4_INTR_ENABLED;
7169
7170 num_cq = (hba->intr_count * cfg[CFG_NUM_WQ].current) +
7171 EMLXS_CQ_OFFSET_WQ;
7172
7173 /* ARM EQ / CQs */
7174 for (i = 0; i < num_cq; i++) {
7175 data = hba->sli.sli4.cq[i].qid;
7176 data |= CQ_DB_REARM;
5193 WRITE_BAR2_REG(hba, FC_CQDB_REG(hba), data);
7177 emlxs_sli4_write_cqdb(hba, data);
5194 }
5195 for (i = 0; i < hba->intr_count; i++) {
5196 data = hba->sli.sli4.eq[i].qid;
5197 data |= (EQ_DB_REARM | EQ_DB_EVENT);
7178 }
7179 for (i = 0; i < hba->intr_count; i++) {
7180 data = hba->sli.sli4.eq[i].qid;
7181 data |= (EQ_DB_REARM | EQ_DB_EVENT);
5198 WRITE_BAR2_REG(hba, FC_CQDB_REG(hba), data);
7182 emlxs_sli4_write_cqdb(hba, data);
5199 }
5200} /* emlxs_sli4_enable_intr() */
5201
5202
5203static void
5204emlxs_sli4_disable_intr(emlxs_hba_t *hba, uint32_t att)
5205{
5206 if (att) {

--- 8 unchanged lines hidden (view full) ---

5215
5216static void
5217emlxs_sli4_resource_free(emlxs_hba_t *hba)
5218{
5219 emlxs_port_t *port = &PPORT;
5220 MBUF_INFO *buf_info;
5221 uint32_t i;
5222
7183 }
7184} /* emlxs_sli4_enable_intr() */
7185
7186
7187static void
7188emlxs_sli4_disable_intr(emlxs_hba_t *hba, uint32_t att)
7189{
7190 if (att) {

--- 8 unchanged lines hidden (view full) ---

7199
7200static void
7201emlxs_sli4_resource_free(emlxs_hba_t *hba)
7202{
7203 emlxs_port_t *port = &PPORT;
7204 MBUF_INFO *buf_info;
7205 uint32_t i;
7206
7207 buf_info = &hba->sli.sli4.slim2;
7208 if (buf_info->virt == 0) {
7209 /* Already free */
7210 return;
7211 }
7212
5223 emlxs_fcf_fini(hba);
5224
5225 buf_info = &hba->sli.sli4.HeaderTmplate;
5226 if (buf_info->virt) {
5227 bzero(buf_info, sizeof (MBUF_INFO));
5228 }
5229
5230 if (hba->sli.sli4.XRIp) {
5231 if ((hba->sli.sli4.XRIinuse_f !=
5232 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f) ||
5233 (hba->sli.sli4.XRIinuse_b !=
5234 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f)) {
5235 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
7213 emlxs_fcf_fini(hba);
7214
7215 buf_info = &hba->sli.sli4.HeaderTmplate;
7216 if (buf_info->virt) {
7217 bzero(buf_info, sizeof (MBUF_INFO));
7218 }
7219
7220 if (hba->sli.sli4.XRIp) {
7221 if ((hba->sli.sli4.XRIinuse_f !=
7222 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f) ||
7223 (hba->sli.sli4.XRIinuse_b !=
7224 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f)) {
7225 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
5236 "XRIs inuse during free!: %p %p != %p\n",
7226 "XRIs in use during free!: %p %p != %p\n",
5237 hba->sli.sli4.XRIinuse_f,
5238 hba->sli.sli4.XRIinuse_b,
5239 &hba->sli.sli4.XRIinuse_f);
5240 }
5241 kmem_free(hba->sli.sli4.XRIp,
5242 (sizeof (XRIobj_t) * hba->sli.sli4.XRICount));
5243 hba->sli.sli4.XRIp = NULL;
5244
5245 hba->sli.sli4.XRIfree_f =
5246 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5247 hba->sli.sli4.XRIfree_b =
5248 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5249 hba->sli.sli4.xrif_count = 0;
5250 }
5251
7227 hba->sli.sli4.XRIinuse_f,
7228 hba->sli.sli4.XRIinuse_b,
7229 &hba->sli.sli4.XRIinuse_f);
7230 }
7231 kmem_free(hba->sli.sli4.XRIp,
7232 (sizeof (XRIobj_t) * hba->sli.sli4.XRICount));
7233 hba->sli.sli4.XRIp = NULL;
7234
7235 hba->sli.sli4.XRIfree_f =
7236 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7237 hba->sli.sli4.XRIfree_b =
7238 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7239 hba->sli.sli4.xrif_count = 0;
7240 }
7241
5252 for (i = 0; i < EMLXS_MAX_EQS; i++) {
7242 for (i = 0; i < hba->intr_count; i++) {
5253 mutex_destroy(&hba->sli.sli4.eq[i].lastwq_lock);
5254 bzero(&hba->sli.sli4.eq[i], sizeof (EQ_DESC_t));
7243 mutex_destroy(&hba->sli.sli4.eq[i].lastwq_lock);
7244 bzero(&hba->sli.sli4.eq[i], sizeof (EQ_DESC_t));
7245 hba->sli.sli4.eq[i].qid = 0xffff;
5255 }
5256 for (i = 0; i < EMLXS_MAX_CQS; i++) {
5257 bzero(&hba->sli.sli4.cq[i], sizeof (CQ_DESC_t));
7246 }
7247 for (i = 0; i < EMLXS_MAX_CQS; i++) {
7248 bzero(&hba->sli.sli4.cq[i], sizeof (CQ_DESC_t));
7249 hba->sli.sli4.cq[i].qid = 0xffff;
5258 }
5259 for (i = 0; i < EMLXS_MAX_WQS; i++) {
5260 bzero(&hba->sli.sli4.wq[i], sizeof (WQ_DESC_t));
7250 }
7251 for (i = 0; i < EMLXS_MAX_WQS; i++) {
7252 bzero(&hba->sli.sli4.wq[i], sizeof (WQ_DESC_t));
7253 hba->sli.sli4.wq[i].qid = 0xffff;
5261 }
7254 }
5262 for (i = 0; i < EMLXS_MAX_RQS; i++) {
5263 mutex_destroy(&hba->sli.sli4.rq[i].lock);
7255 for (i = 0; i < EMLXS_MAX_RXQS; i++) {
5264 mutex_destroy(&hba->sli.sli4.rxq[i].lock);
5265 bzero(&hba->sli.sli4.rxq[i], sizeof (RXQ_DESC_t));
7256 mutex_destroy(&hba->sli.sli4.rxq[i].lock);
7257 bzero(&hba->sli.sli4.rxq[i], sizeof (RXQ_DESC_t));
7258 }
7259 for (i = 0; i < EMLXS_MAX_RQS; i++) {
7260 mutex_destroy(&hba->sli.sli4.rq[i].lock);
5266 bzero(&hba->sli.sli4.rq[i], sizeof (RQ_DESC_t));
7261 bzero(&hba->sli.sli4.rq[i], sizeof (RQ_DESC_t));
7262 hba->sli.sli4.rq[i].qid = 0xffff;
5267 }
5268
5269 /* Free the MQ */
5270 bzero(&hba->sli.sli4.mq, sizeof (MQ_DESC_t));
5271
5272 buf_info = &hba->sli.sli4.slim2;
5273 if (buf_info->virt) {
5274 buf_info->flags = FC_MBUF_DMA;
5275 emlxs_mem_free(hba, buf_info);
5276 bzero(buf_info, sizeof (MBUF_INFO));
5277 }
5278
7263 }
7264
7265 /* Free the MQ */
7266 bzero(&hba->sli.sli4.mq, sizeof (MQ_DESC_t));
7267
7268 buf_info = &hba->sli.sli4.slim2;
7269 if (buf_info->virt) {
7270 buf_info->flags = FC_MBUF_DMA;
7271 emlxs_mem_free(hba, buf_info);
7272 bzero(buf_info, sizeof (MBUF_INFO));
7273 }
7274
5279 /* Cleanup queue ordinal mapping */
5280 for (i = 0; i < EMLXS_MAX_EQ_IDS; i++) {
5281 hba->sli.sli4.eq_map[i] = 0xffff;
5282 }
5283 for (i = 0; i < EMLXS_MAX_CQ_IDS; i++) {
5284 hba->sli.sli4.cq_map[i] = 0xffff;
5285 }
5286 for (i = 0; i < EMLXS_MAX_WQ_IDS; i++) {
5287 hba->sli.sli4.wq_map[i] = 0xffff;
5288 }
5289
5290} /* emlxs_sli4_resource_free() */
5291
5292
5293static int
5294emlxs_sli4_resource_alloc(emlxs_hba_t *hba)
5295{
5296 emlxs_port_t *port = &PPORT;
5297 emlxs_config_t *cfg = &CFG;
5298 MBUF_INFO *buf_info;
7275} /* emlxs_sli4_resource_free() */
7276
7277
7278static int
7279emlxs_sli4_resource_alloc(emlxs_hba_t *hba)
7280{
7281 emlxs_port_t *port = &PPORT;
7282 emlxs_config_t *cfg = &CFG;
7283 MBUF_INFO *buf_info;
5299 uint16_t index;
5300 int num_eq;
5301 int num_wq;
5302 uint16_t i;
5303 uint32_t j;
5304 uint32_t k;
7284 int num_eq;
7285 int num_wq;
7286 uint16_t i;
7287 uint32_t j;
7288 uint32_t k;
7289 uint16_t cq_depth;
7290 uint32_t cq_size;
5305 uint32_t word;
5306 XRIobj_t *xrip;
7291 uint32_t word;
7292 XRIobj_t *xrip;
5307 char buf[64];
5308 RQE_t *rqe;
5309 MBUF_INFO *rqb;
5310 uint64_t phys;
5311 uint64_t tmp_phys;
5312 char *virt;
5313 char *tmp_virt;
5314 void *data_handle;
5315 void *dma_handle;
5316 int32_t size;
5317 off_t offset;
5318 uint32_t count = 0;
7293 RQE_t *rqe;
7294 MBUF_INFO *rqb;
7295 uint64_t phys;
7296 uint64_t tmp_phys;
7297 char *virt;
7298 char *tmp_virt;
7299 void *data_handle;
7300 void *dma_handle;
7301 int32_t size;
7302 off_t offset;
7303 uint32_t count = 0;
7304 uint32_t hddr_size = 0;
7305 uint32_t align;
7306 uint32_t iotag;
5319
7307
7308 buf_info = &hba->sli.sli4.slim2;
7309 if (buf_info->virt) {
7310 /* Already allocated */
7311 return (0);
7312 }
7313
5320 emlxs_fcf_init(hba);
5321
7314 emlxs_fcf_init(hba);
7315
7316 switch (hba->sli.sli4.param.CQV) {
7317 case 0:
7318 cq_depth = CQ_DEPTH;
7319 break;
7320 case 2:
7321 default:
7322 cq_depth = CQ_DEPTH_V2;
7323 break;
7324 }
7325 cq_size = (cq_depth * CQE_SIZE);
7326
5322 /* EQs - 1 per Interrupt vector */
5323 num_eq = hba->intr_count;
7327 /* EQs - 1 per Interrupt vector */
7328 num_eq = hba->intr_count;
7329
5324 /* CQs - number of WQs + 1 for RQs + 1 for mbox/async events */
5325 num_wq = cfg[CFG_NUM_WQ].current * num_eq;
5326
5327 /* Calculate total dmable memory we need */
7330 /* CQs - number of WQs + 1 for RQs + 1 for mbox/async events */
7331 num_wq = cfg[CFG_NUM_WQ].current * num_eq;
7332
7333 /* Calculate total dmable memory we need */
7334 /* WARNING: make sure each section is aligned on 4K boundary */
7335
5328 /* EQ */
5329 count += num_eq * 4096;
7336 /* EQ */
7337 count += num_eq * 4096;
7338
5330 /* CQ */
7339 /* CQ */
5331 count += (num_wq + EMLXS_CQ_OFFSET_WQ) * 4096;
7340 count += (num_wq + EMLXS_CQ_OFFSET_WQ) * cq_size;
7341
5332 /* WQ */
5333 count += num_wq * (4096 * EMLXS_NUM_WQ_PAGES);
7342 /* WQ */
7343 count += num_wq * (4096 * EMLXS_NUM_WQ_PAGES);
7344
5334 /* MQ */
5335 count += EMLXS_MAX_MQS * 4096;
7345 /* MQ */
7346 count += EMLXS_MAX_MQS * 4096;
7347
5336 /* RQ */
5337 count += EMLXS_MAX_RQS * 4096;
7348 /* RQ */
7349 count += EMLXS_MAX_RQS * 4096;
7350
5338 /* RQB/E */
5339 count += RQB_COUNT * (RQB_DATA_SIZE + RQB_HEADER_SIZE);
7351 /* RQB/E */
7352 count += RQB_COUNT * (RQB_DATA_SIZE + RQB_HEADER_SIZE);
7353 count += (4096 - (count%4096)); /* Ensure 4K alignment */
7354
5340 /* SGL */
7355 /* SGL */
5341 count += hba->sli.sli4.XRICount * hba->sli.sli4.mem_sgl_size;
5342 /* RPI Head Template */
5343 count += hba->sli.sli4.RPICount * sizeof (RPIHdrTmplate_t);
7356 count += hba->sli.sli4.XRIExtSize * hba->sli.sli4.mem_sgl_size;
7357 count += (4096 - (count%4096)); /* Ensure 4K alignment */
5344
7358
7359 /* RPI Header Templates */
7360 if (hba->sli.sli4.param.HDRR) {
7361 /* Bytes per extent */
7362 j = hba->sli.sli4.RPIExtSize * sizeof (RPIHdrTmplate_t);
7363
7364 /* Pages required per extent (page == 4096 bytes) */
7365 k = (j/4096) + ((j%4096)? 1:0);
7366
7367 /* Total size */
7368 hddr_size = (k * hba->sli.sli4.RPIExtCount * 4096);
7369
7370 count += hddr_size;
7371 }
7372
5345 /* Allocate slim2 for SLI4 */
5346 buf_info = &hba->sli.sli4.slim2;
5347 buf_info->size = count;
5348 buf_info->flags = FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5349 buf_info->align = ddi_ptob(hba->dip, 1L);
5350
5351 (void) emlxs_mem_alloc(hba, buf_info);
5352

--- 10 unchanged lines hidden (view full) ---

5363
5364 /* Assign memory to SGL, Head Template, EQ, CQ, WQ, RQ and MQ */
5365 data_handle = buf_info->data_handle;
5366 dma_handle = buf_info->dma_handle;
5367 phys = buf_info->phys;
5368 virt = (char *)buf_info->virt;
5369
5370 /* Allocate space for queues */
7373 /* Allocate slim2 for SLI4 */
7374 buf_info = &hba->sli.sli4.slim2;
7375 buf_info->size = count;
7376 buf_info->flags = FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7377 buf_info->align = ddi_ptob(hba->dip, 1L);
7378
7379 (void) emlxs_mem_alloc(hba, buf_info);
7380

--- 10 unchanged lines hidden (view full) ---

7391
7392 /* Assign memory to SGL, Head Template, EQ, CQ, WQ, RQ and MQ */
7393 data_handle = buf_info->data_handle;
7394 dma_handle = buf_info->dma_handle;
7395 phys = buf_info->phys;
7396 virt = (char *)buf_info->virt;
7397
7398 /* Allocate space for queues */
7399
7400 /* EQ */
5371 size = 4096;
5372 for (i = 0; i < num_eq; i++) {
7401 size = 4096;
7402 for (i = 0; i < num_eq; i++) {
7403 bzero(&hba->sli.sli4.eq[i], sizeof (EQ_DESC_t));
7404
5373 buf_info = &hba->sli.sli4.eq[i].addr;
7405 buf_info = &hba->sli.sli4.eq[i].addr;
5374 if (buf_info->virt == NULL) {
5375 bzero(&hba->sli.sli4.eq[i], sizeof (EQ_DESC_t));
5376 buf_info->size = size;
5377 buf_info->flags =
5378 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5379 buf_info->align = ddi_ptob(hba->dip, 1L);
5380 buf_info->phys = phys;
5381 buf_info->virt = (void *)virt;
5382 buf_info->data_handle = data_handle;
5383 buf_info->dma_handle = dma_handle;
7406 buf_info->size = size;
7407 buf_info->flags =
7408 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7409 buf_info->align = ddi_ptob(hba->dip, 1L);
7410 buf_info->phys = phys;
7411 buf_info->virt = (void *)virt;
7412 buf_info->data_handle = data_handle;
7413 buf_info->dma_handle = dma_handle;
5384
7414
5385 phys += size;
5386 virt += size;
7415 phys += size;
7416 virt += size;
5387
7417
5388 hba->sli.sli4.eq[i].max_index = EQ_DEPTH;
5389 }
7418 hba->sli.sli4.eq[i].max_index = EQ_DEPTH;
7419 hba->sli.sli4.eq[i].qid = 0xffff;
5390
7420
5391 (void) sprintf(buf, "%s_eq%d_lastwq_lock mutex",
5392 DRIVER_NAME, i);
5393 mutex_init(&hba->sli.sli4.eq[i].lastwq_lock, buf,
7421 mutex_init(&hba->sli.sli4.eq[i].lastwq_lock, NULL,
5394 MUTEX_DRIVER, NULL);
5395 }
5396
7422 MUTEX_DRIVER, NULL);
7423 }
7424
5397 size = 4096;
7425
7426 /* CQ */
5398 for (i = 0; i < (num_wq + EMLXS_CQ_OFFSET_WQ); i++) {
7427 for (i = 0; i < (num_wq + EMLXS_CQ_OFFSET_WQ); i++) {
7428 bzero(&hba->sli.sli4.cq[i], sizeof (CQ_DESC_t));
7429
5399 buf_info = &hba->sli.sli4.cq[i].addr;
7430 buf_info = &hba->sli.sli4.cq[i].addr;
5400 if (buf_info->virt == NULL) {
5401 bzero(&hba->sli.sli4.cq[i], sizeof (CQ_DESC_t));
5402 buf_info->size = size;
5403 buf_info->flags =
5404 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5405 buf_info->align = ddi_ptob(hba->dip, 1L);
5406 buf_info->phys = phys;
5407 buf_info->virt = (void *)virt;
5408 buf_info->data_handle = data_handle;
5409 buf_info->dma_handle = dma_handle;
7431 buf_info->size = cq_size;
7432 buf_info->flags =
7433 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7434 buf_info->align = ddi_ptob(hba->dip, 1L);
7435 buf_info->phys = phys;
7436 buf_info->virt = (void *)virt;
7437 buf_info->data_handle = data_handle;
7438 buf_info->dma_handle = dma_handle;
5410
7439
5411 phys += size;
5412 virt += size;
7440 phys += cq_size;
7441 virt += cq_size;
5413
7442
5414 hba->sli.sli4.cq[i].max_index = CQ_DEPTH;
5415 }
7443 hba->sli.sli4.cq[i].max_index = cq_depth;
7444 hba->sli.sli4.cq[i].qid = 0xffff;
5416 }
5417
7445 }
7446
5418 /* WQs - NUM_WQ config parameter * number of EQs */
7447
7448 /* WQ */
5419 size = 4096 * EMLXS_NUM_WQ_PAGES;
5420 for (i = 0; i < num_wq; i++) {
7449 size = 4096 * EMLXS_NUM_WQ_PAGES;
7450 for (i = 0; i < num_wq; i++) {
5421 buf_info = &hba->sli.sli4.wq[i].addr;
5422 if (buf_info->virt == NULL) {
5423 bzero(&hba->sli.sli4.wq[i], sizeof (WQ_DESC_t));
5424 buf_info->size = size;
5425 buf_info->flags =
5426 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5427 buf_info->align = ddi_ptob(hba->dip, 1L);
5428 buf_info->phys = phys;
5429 buf_info->virt = (void *)virt;
5430 buf_info->data_handle = data_handle;
5431 buf_info->dma_handle = dma_handle;
7451 bzero(&hba->sli.sli4.wq[i], sizeof (WQ_DESC_t));
5432
7452
5433 phys += size;
5434 virt += size;
5435
5436 hba->sli.sli4.wq[i].max_index = WQ_DEPTH;
5437 hba->sli.sli4.wq[i].release_depth = WQE_RELEASE_DEPTH;
5438 }
5439 }
5440
5441 /* MQ */
5442 size = 4096;
5443 buf_info = &hba->sli.sli4.mq.addr;
5444 if (!buf_info->virt) {
5445 bzero(&hba->sli.sli4.mq, sizeof (MQ_DESC_t));
7453 buf_info = &hba->sli.sli4.wq[i].addr;
5446 buf_info->size = size;
5447 buf_info->flags =
5448 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5449 buf_info->align = ddi_ptob(hba->dip, 1L);
5450 buf_info->phys = phys;
5451 buf_info->virt = (void *)virt;
5452 buf_info->data_handle = data_handle;
5453 buf_info->dma_handle = dma_handle;
5454
5455 phys += size;
5456 virt += size;
5457
7454 buf_info->size = size;
7455 buf_info->flags =
7456 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7457 buf_info->align = ddi_ptob(hba->dip, 1L);
7458 buf_info->phys = phys;
7459 buf_info->virt = (void *)virt;
7460 buf_info->data_handle = data_handle;
7461 buf_info->dma_handle = dma_handle;
7462
7463 phys += size;
7464 virt += size;
7465
5458 hba->sli.sli4.mq.max_index = MQ_DEPTH;
7466 hba->sli.sli4.wq[i].max_index = WQ_DEPTH;
7467 hba->sli.sli4.wq[i].release_depth = WQE_RELEASE_DEPTH;
7468 hba->sli.sli4.wq[i].qid = 0xFFFF;
5459 }
5460
7469 }
7470
5461 /* RXQs */
7471
7472 /* MQ */
7473 size = 4096;
7474 bzero(&hba->sli.sli4.mq, sizeof (MQ_DESC_t));
7475
7476 buf_info = &hba->sli.sli4.mq.addr;
7477 buf_info->size = size;
7478 buf_info->flags =
7479 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7480 buf_info->align = ddi_ptob(hba->dip, 1L);
7481 buf_info->phys = phys;
7482 buf_info->virt = (void *)virt;
7483 buf_info->data_handle = data_handle;
7484 buf_info->dma_handle = dma_handle;
7485
7486 phys += size;
7487 virt += size;
7488
7489 hba->sli.sli4.mq.max_index = MQ_DEPTH;
7490
7491
7492 /* RXQ */
5462 for (i = 0; i < EMLXS_MAX_RXQS; i++) {
5463 bzero(&hba->sli.sli4.rxq[i], sizeof (RXQ_DESC_t));
5464
7493 for (i = 0; i < EMLXS_MAX_RXQS; i++) {
7494 bzero(&hba->sli.sli4.rxq[i], sizeof (RXQ_DESC_t));
7495
5465 (void) sprintf(buf, "%s_rxq%d_lock mutex", DRIVER_NAME, i);
5466 mutex_init(&hba->sli.sli4.rxq[i].lock, buf, MUTEX_DRIVER, NULL);
7496 mutex_init(&hba->sli.sli4.rxq[i].lock, NULL, MUTEX_DRIVER,
7497 NULL);
5467 }
5468
7498 }
7499
5469 /* RQs */
7500
7501 /* RQ */
5470 size = 4096;
5471 for (i = 0; i < EMLXS_MAX_RQS; i++) {
7502 size = 4096;
7503 for (i = 0; i < EMLXS_MAX_RQS; i++) {
5472 buf_info = &hba->sli.sli4.rq[i].addr;
5473 if (buf_info->virt) {
5474 continue;
5475 }
5476
5477 bzero(&hba->sli.sli4.rq[i], sizeof (RQ_DESC_t));
7504 bzero(&hba->sli.sli4.rq[i], sizeof (RQ_DESC_t));
7505
7506 buf_info = &hba->sli.sli4.rq[i].addr;
5478 buf_info->size = size;
5479 buf_info->flags =
5480 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5481 buf_info->align = ddi_ptob(hba->dip, 1L);
5482 buf_info->phys = phys;
5483 buf_info->virt = (void *)virt;
5484 buf_info->data_handle = data_handle;
5485 buf_info->dma_handle = dma_handle;
5486
5487 phys += size;
5488 virt += size;
5489
5490 hba->sli.sli4.rq[i].max_index = RQ_DEPTH;
7507 buf_info->size = size;
7508 buf_info->flags =
7509 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7510 buf_info->align = ddi_ptob(hba->dip, 1L);
7511 buf_info->phys = phys;
7512 buf_info->virt = (void *)virt;
7513 buf_info->data_handle = data_handle;
7514 buf_info->dma_handle = dma_handle;
7515
7516 phys += size;
7517 virt += size;
7518
7519 hba->sli.sli4.rq[i].max_index = RQ_DEPTH;
7520 hba->sli.sli4.rq[i].qid = 0xFFFF;
5491
7521
5492 (void) sprintf(buf, "%s_rq%d_lock mutex", DRIVER_NAME, i);
5493 mutex_init(&hba->sli.sli4.rq[i].lock, buf, MUTEX_DRIVER, NULL);
7522 mutex_init(&hba->sli.sli4.rq[i].lock, NULL, MUTEX_DRIVER, NULL);
5494 }
5495
7523 }
7524
5496 /* Setup RQE */
7525
7526 /* RQB/E */
5497 for (i = 0; i < EMLXS_MAX_RQS; i++) {
5498 size = (i & 0x1) ? RQB_DATA_SIZE : RQB_HEADER_SIZE;
5499 tmp_phys = phys;
5500 tmp_virt = virt;
5501
5502 /* Initialize the RQEs */
5503 rqe = (RQE_t *)hba->sli.sli4.rq[i].addr.virt;
5504 for (j = 0; j < (RQ_DEPTH/RQB_COUNT); j++) {

--- 14 unchanged lines hidden (view full) ---

5519 rqb->align = ddi_ptob(hba->dip, 1L);
5520 rqb->phys = phys;
5521 rqb->virt = (void *)virt;
5522 rqb->data_handle = data_handle;
5523 rqb->dma_handle = dma_handle;
5524
5525 phys += size;
5526 virt += size;
7527 for (i = 0; i < EMLXS_MAX_RQS; i++) {
7528 size = (i & 0x1) ? RQB_DATA_SIZE : RQB_HEADER_SIZE;
7529 tmp_phys = phys;
7530 tmp_virt = virt;
7531
7532 /* Initialize the RQEs */
7533 rqe = (RQE_t *)hba->sli.sli4.rq[i].addr.virt;
7534 for (j = 0; j < (RQ_DEPTH/RQB_COUNT); j++) {

--- 14 unchanged lines hidden (view full) ---

7549 rqb->align = ddi_ptob(hba->dip, 1L);
7550 rqb->phys = phys;
7551 rqb->virt = (void *)virt;
7552 rqb->data_handle = data_handle;
7553 rqb->dma_handle = dma_handle;
7554
7555 phys += size;
7556 virt += size;
5527#ifdef RQ_DEBUG
7557#ifdef DEBUG_RQE
5528 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7558 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5529 "RQ_ALLOC: rq[%d] rqb[%d,%d]=%p tag=%08x",
7559 "RQ_ALLOC: rq[%d] rqb[%d,%d]=%p iotag=%d",
5530 i, j, k, mp, mp->tag);
7560 i, j, k, mp, mp->tag);
5531#endif
7561#endif /* DEBUG_RQE */
5532
5533 rqe++;
5534 }
5535 }
5536
5537 offset = (off_t)((uint64_t)((unsigned long)
5538 hba->sli.sli4.rq[i].addr.virt) -
5539 (uint64_t)((unsigned long)
5540 hba->sli.sli4.slim2.virt));
5541
5542 /* Sync the RQ buffer list */
5543 EMLXS_MPDATA_SYNC(hba->sli.sli4.rq[i].addr.dma_handle, offset,
5544 hba->sli.sli4.rq[i].addr.size, DDI_DMA_SYNC_FORDEV);
5545 }
5546
7562
7563 rqe++;
7564 }
7565 }
7566
7567 offset = (off_t)((uint64_t)((unsigned long)
7568 hba->sli.sli4.rq[i].addr.virt) -
7569 (uint64_t)((unsigned long)
7570 hba->sli.sli4.slim2.virt));
7571
7572 /* Sync the RQ buffer list */
7573 EMLXS_MPDATA_SYNC(hba->sli.sli4.rq[i].addr.dma_handle, offset,
7574 hba->sli.sli4.rq[i].addr.size, DDI_DMA_SYNC_FORDEV);
7575 }
7576
5547 if ((!hba->sli.sli4.XRIp) && (hba->sli.sli4.XRICount)) {
5548 /* Initialize double linked lists */
5549 hba->sli.sli4.XRIinuse_f =
5550 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f;
5551 hba->sli.sli4.XRIinuse_b =
5552 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f;
5553 hba->sli.sli4.xria_count = 0;
7577 /* 4K Alignment */
7578 align = (4096 - (phys%4096));
7579 phys += align;
7580 virt += align;
5554
7581
5555 hba->sli.sli4.XRIfree_f =
5556 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5557 hba->sli.sli4.XRIfree_b =
5558 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5559 hba->sli.sli4.xria_count = 0;
7582 /* SGL */
7583 /* Initialize double linked lists */
7584 hba->sli.sli4.XRIinuse_f =
7585 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f;
7586 hba->sli.sli4.XRIinuse_b =
7587 (XRIobj_t *)&hba->sli.sli4.XRIinuse_f;
7588 hba->sli.sli4.xria_count = 0;
5560
7589
5561 hba->sli.sli4.XRIp = (XRIobj_t *)kmem_zalloc(
5562 (sizeof (XRIobj_t) * hba->sli.sli4.XRICount), KM_SLEEP);
7590 hba->sli.sli4.XRIfree_f =
7591 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7592 hba->sli.sli4.XRIfree_b =
7593 (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7594 hba->sli.sli4.xria_count = 0;
5563
7595
5564 xrip = hba->sli.sli4.XRIp;
5565 index = hba->sli.sli4.XRIBase;
5566 size = hba->sli.sli4.mem_sgl_size;
5567 for (i = 0; i < hba->sli.sli4.XRICount; i++) {
5568 xrip->sge_count =
5569 (hba->sli.sli4.mem_sgl_size / sizeof (ULP_SGE64));
5570 xrip->XRI = index;
5571 xrip->iotag = i;
5572 if ((xrip->XRI == 0) || (xrip->iotag == 0)) {
5573 index++; /* Skip XRI 0 or IOTag 0 */
5574 xrip++;
5575 continue;
5576 }
5577 /* Add xrip to end of free list */
5578 xrip->_b = hba->sli.sli4.XRIfree_b;
5579 hba->sli.sli4.XRIfree_b->_f = xrip;
5580 xrip->_f = (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5581 hba->sli.sli4.XRIfree_b = xrip;
5582 hba->sli.sli4.xrif_count++;
7596 hba->sli.sli4.XRIp = (XRIobj_t *)kmem_zalloc(
7597 (sizeof (XRIobj_t) * hba->sli.sli4.XRICount), KM_SLEEP);
5583
7598
5584 /* Allocate SGL for this xrip */
5585 buf_info = &xrip->SGList;
5586 buf_info->size = size;
5587 buf_info->flags =
5588 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
5589 buf_info->align = size;
5590 buf_info->phys = phys;
5591 buf_info->virt = (void *)virt;
5592 buf_info->data_handle = data_handle;
5593 buf_info->dma_handle = dma_handle;
7599 xrip = hba->sli.sli4.XRIp;
7600 size = hba->sli.sli4.mem_sgl_size;
7601 iotag = 1;
7602 for (i = 0; i < hba->sli.sli4.XRICount; i++) {
7603 xrip->XRI = emlxs_sli4_index_to_xri(hba, i);
5594
7604
5595 phys += size;
5596 virt += size;
5597
7605 /* We don't use XRI==0, since it also represents an */
7606 /* uninitialized exchange */
7607 if (xrip->XRI == 0) {
5598 xrip++;
7608 xrip++;
5599 index++;
7609 continue;
5600 }
7610 }
7611
7612 xrip->iotag = iotag++;
7613 xrip->sge_count =
7614 (hba->sli.sli4.mem_sgl_size / sizeof (ULP_SGE64));
7615
7616 /* Add xrip to end of free list */
7617 xrip->_b = hba->sli.sli4.XRIfree_b;
7618 hba->sli.sli4.XRIfree_b->_f = xrip;
7619 xrip->_f = (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7620 hba->sli.sli4.XRIfree_b = xrip;
7621 hba->sli.sli4.xrif_count++;
7622
7623 /* Allocate SGL for this xrip */
7624 buf_info = &xrip->SGList;
7625 buf_info->size = size;
7626 buf_info->flags =
7627 FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
7628 buf_info->align = size;
7629 buf_info->phys = phys;
7630 buf_info->virt = (void *)virt;
7631 buf_info->data_handle = data_handle;
7632 buf_info->dma_handle = dma_handle;
7633
7634 phys += size;
7635 virt += size;
7636
7637 xrip++;
5601 }
5602
7638 }
7639
5603 size = sizeof (RPIHdrTmplate_t) * hba->sli.sli4.RPICount;
5604 buf_info = &hba->sli.sli4.HeaderTmplate;
5605 if ((buf_info->virt == NULL) && (hba->sli.sli4.RPICount)) {
7640 /* 4K Alignment */
7641 align = (4096 - (phys%4096));
7642 phys += align;
7643 virt += align;
7644
7645 /* RPI Header Templates */
7646 if (hba->sli.sli4.param.HDRR) {
7647 buf_info = &hba->sli.sli4.HeaderTmplate;
5606 bzero(buf_info, sizeof (MBUF_INFO));
7648 bzero(buf_info, sizeof (MBUF_INFO));
5607 buf_info->size = size;
7649 buf_info->size = hddr_size;
5608 buf_info->flags = FC_MBUF_DMA | FC_MBUF_DMA32;
5609 buf_info->align = ddi_ptob(hba->dip, 1L);
5610 buf_info->phys = phys;
5611 buf_info->virt = (void *)virt;
5612 buf_info->data_handle = data_handle;
5613 buf_info->dma_handle = dma_handle;
5614 }
5615
5616#ifdef FMA_SUPPORT
5617 if (hba->sli.sli4.slim2.dma_handle) {
5618 if (emlxs_fm_check_dma_handle(hba,
5619 hba->sli.sli4.slim2.dma_handle)
5620 != DDI_FM_OK) {
5621 EMLXS_MSGF(EMLXS_CONTEXT,
5622 &emlxs_invalid_dma_handle_msg,
7650 buf_info->flags = FC_MBUF_DMA | FC_MBUF_DMA32;
7651 buf_info->align = ddi_ptob(hba->dip, 1L);
7652 buf_info->phys = phys;
7653 buf_info->virt = (void *)virt;
7654 buf_info->data_handle = data_handle;
7655 buf_info->dma_handle = dma_handle;
7656 }
7657
7658#ifdef FMA_SUPPORT
7659 if (hba->sli.sli4.slim2.dma_handle) {
7660 if (emlxs_fm_check_dma_handle(hba,
7661 hba->sli.sli4.slim2.dma_handle)
7662 != DDI_FM_OK) {
7663 EMLXS_MSGF(EMLXS_CONTEXT,
7664 &emlxs_invalid_dma_handle_msg,
5623 "emlxs_sli4_resource_alloc: hdl=%p",
7665 "sli4_resource_alloc: hdl=%p",
5624 hba->sli.sli4.slim2.dma_handle);
5625 goto failed;
5626 }
5627 }
7666 hba->sli.sli4.slim2.dma_handle);
7667 goto failed;
7668 }
7669 }
5628#endif
7670#endif /* FMA_SUPPORT */
5629
5630 return (0);
5631
5632failed:
5633
5634 (void) emlxs_sli4_resource_free(hba);
5635 return (ENOMEM);
5636
5637} /* emlxs_sli4_resource_alloc */
5638
5639
7671
7672 return (0);
7673
7674failed:
7675
7676 (void) emlxs_sli4_resource_free(hba);
7677 return (ENOMEM);
7678
7679} /* emlxs_sli4_resource_alloc */
7680
7681
5640static XRIobj_t *
5641emlxs_sli4_reserve_xri(emlxs_hba_t *hba, RPIobj_t *rpip)
7682extern void
7683emlxs_sli4_zero_queue_stat(emlxs_hba_t *hba)
5642{
7684{
5643 emlxs_port_t *port = &PPORT;
7685 uint32_t i;
7686 uint32_t num_wq;
7687 emlxs_config_t *cfg = &CFG;
7688 clock_t time;
7689
7690 /* EQ */
7691 for (i = 0; i < hba->intr_count; i++) {
7692 hba->sli.sli4.eq[i].num_proc = 0;
7693 hba->sli.sli4.eq[i].max_proc = 0;
7694 hba->sli.sli4.eq[i].isr_count = 0;
7695 }
7696 num_wq = cfg[CFG_NUM_WQ].current * hba->intr_count;
7697 /* CQ */
7698 for (i = 0; i < (num_wq + EMLXS_CQ_OFFSET_WQ); i++) {
7699 hba->sli.sli4.cq[i].num_proc = 0;
7700 hba->sli.sli4.cq[i].max_proc = 0;
7701 hba->sli.sli4.cq[i].isr_count = 0;
7702 }
7703 /* WQ */
7704 for (i = 0; i < num_wq; i++) {
7705 hba->sli.sli4.wq[i].num_proc = 0;
7706 hba->sli.sli4.wq[i].num_busy = 0;
7707 }
7708 /* RQ */
7709 for (i = 0; i < EMLXS_MAX_RQS; i++) {
7710 hba->sli.sli4.rq[i].num_proc = 0;
7711 }
7712 (void) drv_getparm(LBOLT, &time);
7713 hba->sli.sli4.que_stat_timer = (uint32_t)time;
7714
7715} /* emlxs_sli4_zero_queue_stat */
7716
7717
7718extern XRIobj_t *
7719emlxs_sli4_reserve_xri(emlxs_port_t *port, RPIobj_t *rpip, uint32_t type,
7720 uint16_t rx_id)
7721{
7722 emlxs_hba_t *hba = HBA;
5644 XRIobj_t *xrip;
5645 uint16_t iotag;
5646
5647 mutex_enter(&EMLXS_FCTAB_LOCK);
5648
5649 xrip = hba->sli.sli4.XRIfree_f;
5650
5651 if (xrip == (XRIobj_t *)&hba->sli.sli4.XRIfree_f) {
5652 mutex_exit(&EMLXS_FCTAB_LOCK);
5653
5654 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
7723 XRIobj_t *xrip;
7724 uint16_t iotag;
7725
7726 mutex_enter(&EMLXS_FCTAB_LOCK);
7727
7728 xrip = hba->sli.sli4.XRIfree_f;
7729
7730 if (xrip == (XRIobj_t *)&hba->sli.sli4.XRIfree_f) {
7731 mutex_exit(&EMLXS_FCTAB_LOCK);
7732
7733 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5655 "Unable to reserve XRI");
7734 "Unable to reserve XRI. type=%d",
7735 type);
5656
5657 return (NULL);
5658 }
5659
5660 iotag = xrip->iotag;
5661
5662 if ((!iotag) ||
5663 ((hba->fc_table[iotag] != NULL) &&
5664 (hba->fc_table[iotag] != STALE_PACKET))) {
5665 /*
5666 * No more command slots available, retry later
5667 */
5668 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
7736
7737 return (NULL);
7738 }
7739
7740 iotag = xrip->iotag;
7741
7742 if ((!iotag) ||
7743 ((hba->fc_table[iotag] != NULL) &&
7744 (hba->fc_table[iotag] != STALE_PACKET))) {
7745 /*
7746 * No more command slots available, retry later
7747 */
7748 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
5669 "Adapter Busy. Unable to reserve iotag");
7749 "Adapter Busy. Unable to reserve iotag. type=%d",
7750 type);
5670
5671 mutex_exit(&EMLXS_FCTAB_LOCK);
5672 return (NULL);
5673 }
5674
5675 xrip->state = XRI_STATE_ALLOCATED;
7751
7752 mutex_exit(&EMLXS_FCTAB_LOCK);
7753 return (NULL);
7754 }
7755
7756 xrip->state = XRI_STATE_ALLOCATED;
7757 xrip->type = type;
5676 xrip->flag = EMLXS_XRI_RESERVED;
7758 xrip->flag = EMLXS_XRI_RESERVED;
5677 xrip->rpip = rpip;
5678 xrip->sbp = NULL;
5679
7759 xrip->sbp = NULL;
7760
5680 if (rpip) {
5681 rpip->xri_count++;
5682 }
7761 xrip->rpip = rpip;
7762 xrip->rx_id = rx_id;
7763 rpip->xri_count++;
5683
5684 /* Take it off free list */
5685 (xrip->_b)->_f = xrip->_f;
5686 (xrip->_f)->_b = xrip->_b;
5687 xrip->_f = NULL;
5688 xrip->_b = NULL;
5689 hba->sli.sli4.xrif_count--;
5690

--- 6 unchanged lines hidden (view full) ---

5697
5698 mutex_exit(&EMLXS_FCTAB_LOCK);
5699 return (xrip);
5700
5701} /* emlxs_sli4_reserve_xri() */
5702
5703
5704extern uint32_t
7764
7765 /* Take it off free list */
7766 (xrip->_b)->_f = xrip->_f;
7767 (xrip->_f)->_b = xrip->_b;
7768 xrip->_f = NULL;
7769 xrip->_b = NULL;
7770 hba->sli.sli4.xrif_count--;
7771

--- 6 unchanged lines hidden (view full) ---

7778
7779 mutex_exit(&EMLXS_FCTAB_LOCK);
7780 return (xrip);
7781
7782} /* emlxs_sli4_reserve_xri() */
7783
7784
7785extern uint32_t
5705emlxs_sli4_unreserve_xri(emlxs_hba_t *hba, uint16_t xri, uint32_t lock)
7786emlxs_sli4_unreserve_xri(emlxs_port_t *port, uint16_t xri, uint32_t lock)
5706{
7787{
5707 emlxs_port_t *port = &PPORT;
7788 emlxs_hba_t *hba = HBA;
5708 XRIobj_t *xrip;
5709
5710 if (lock) {
5711 mutex_enter(&EMLXS_FCTAB_LOCK);
5712 }
5713
7789 XRIobj_t *xrip;
7790
7791 if (lock) {
7792 mutex_enter(&EMLXS_FCTAB_LOCK);
7793 }
7794
5714 xrip = emlxs_sli4_find_xri(hba, xri);
7795 xrip = emlxs_sli4_find_xri(port, xri);
5715
5716 if (!xrip || xrip->state == XRI_STATE_FREE) {
5717 if (lock) {
5718 mutex_exit(&EMLXS_FCTAB_LOCK);
5719 }
5720
5721 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7796
7797 if (!xrip || xrip->state == XRI_STATE_FREE) {
7798 if (lock) {
7799 mutex_exit(&EMLXS_FCTAB_LOCK);
7800 }
7801
7802 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5722 "emlxs_sli4_unreserve_xri: xri=%x already freed.",
5723 xrip->XRI);
7803 "sli4_unreserve_xri:%d already freed.", xri);
5724 return (0);
5725 }
5726
7804 return (0);
7805 }
7806
7807 /* Flush this unsolicited ct command */
7808 if (xrip->type == EMLXS_XRI_UNSOL_CT_TYPE) {
7809 (void) emlxs_flush_ct_event(port, xrip->rx_id);
7810 }
7811
5727 if (!(xrip->flag & EMLXS_XRI_RESERVED)) {
5728 if (lock) {
5729 mutex_exit(&EMLXS_FCTAB_LOCK);
5730 }
5731
5732 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7812 if (!(xrip->flag & EMLXS_XRI_RESERVED)) {
7813 if (lock) {
7814 mutex_exit(&EMLXS_FCTAB_LOCK);
7815 }
7816
7817 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5733 "emlxs_sli4_unreserve_xri: xri=%x in use.", xrip->XRI);
7818 "sli4_unreserve_xri:%d in use. type=%d",
7819 xrip->XRI, xrip->type);
5734 return (1);
5735 }
5736
5737 if (xrip->iotag &&
5738 (hba->fc_table[xrip->iotag] != NULL) &&
5739 (hba->fc_table[xrip->iotag] != STALE_PACKET)) {
5740 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
7820 return (1);
7821 }
7822
7823 if (xrip->iotag &&
7824 (hba->fc_table[xrip->iotag] != NULL) &&
7825 (hba->fc_table[xrip->iotag] != STALE_PACKET)) {
7826 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
5741 "emlxs_sli4_unreserve_xri:%x sbp dropped:%p",
5742 xrip->XRI, hba->fc_table[xrip->iotag]);
7827 "sli4_unreserve_xri:%d sbp dropped:%p type=%d",
7828 xrip->XRI, hba->fc_table[xrip->iotag], xrip->type);
5743
5744 hba->fc_table[xrip->iotag] = NULL;
5745 hba->io_count--;
5746 }
5747
7829
7830 hba->fc_table[xrip->iotag] = NULL;
7831 hba->io_count--;
7832 }
7833
7834 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
7835 "sli4_unreserve_xri:%d unreserved. type=%d",
7836 xrip->XRI, xrip->type);
7837
5748 xrip->state = XRI_STATE_FREE;
7838 xrip->state = XRI_STATE_FREE;
7839 xrip->type = 0;
5749
5750 if (xrip->rpip) {
5751 xrip->rpip->xri_count--;
5752 xrip->rpip = NULL;
5753 }
5754
7840
7841 if (xrip->rpip) {
7842 xrip->rpip->xri_count--;
7843 xrip->rpip = NULL;
7844 }
7845
7846 if (xrip->reserved_rpip) {
7847 xrip->reserved_rpip->xri_count--;
7848 xrip->reserved_rpip = NULL;
7849 }
7850
5755 /* Take it off inuse list */
5756 (xrip->_b)->_f = xrip->_f;
5757 (xrip->_f)->_b = xrip->_b;
5758 xrip->_f = NULL;
5759 xrip->_b = NULL;
5760 hba->sli.sli4.xria_count--;
5761
5762 /* Add it to end of free list */
5763 xrip->_b = hba->sli.sli4.XRIfree_b;
5764 hba->sli.sli4.XRIfree_b->_f = xrip;
5765 xrip->_f = (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
5766 hba->sli.sli4.XRIfree_b = xrip;
5767 hba->sli.sli4.xrif_count++;
5768
7851 /* Take it off inuse list */
7852 (xrip->_b)->_f = xrip->_f;
7853 (xrip->_f)->_b = xrip->_b;
7854 xrip->_f = NULL;
7855 xrip->_b = NULL;
7856 hba->sli.sli4.xria_count--;
7857
7858 /* Add it to end of free list */
7859 xrip->_b = hba->sli.sli4.XRIfree_b;
7860 hba->sli.sli4.XRIfree_b->_f = xrip;
7861 xrip->_f = (XRIobj_t *)&hba->sli.sli4.XRIfree_f;
7862 hba->sli.sli4.XRIfree_b = xrip;
7863 hba->sli.sli4.xrif_count++;
7864
5769 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5770 "emlxs_sli4_unreserve_xri: xri=%x unreserved.", xrip->XRI);
5771
5772 if (lock) {
5773 mutex_exit(&EMLXS_FCTAB_LOCK);
5774 }
5775
5776 return (0);
5777
5778} /* emlxs_sli4_unreserve_xri() */
5779
5780
7865 if (lock) {
7866 mutex_exit(&EMLXS_FCTAB_LOCK);
7867 }
7868
7869 return (0);
7870
7871} /* emlxs_sli4_unreserve_xri() */
7872
7873
5781static XRIobj_t *
5782emlxs_sli4_register_xri(emlxs_hba_t *hba, emlxs_buf_t *sbp, uint16_t xri)
7874XRIobj_t *
7875emlxs_sli4_register_xri(emlxs_port_t *port, emlxs_buf_t *sbp, uint16_t xri,
7876 uint32_t did)
5783{
7877{
5784 emlxs_port_t *port = &PPORT;
7878 emlxs_hba_t *hba = HBA;
5785 uint16_t iotag;
5786 XRIobj_t *xrip;
7879 uint16_t iotag;
7880 XRIobj_t *xrip;
7881 emlxs_node_t *node;
7882 RPIobj_t *rpip;
5787
5788 mutex_enter(&EMLXS_FCTAB_LOCK);
5789
7883
7884 mutex_enter(&EMLXS_FCTAB_LOCK);
7885
5790 xrip = emlxs_sli4_find_xri(hba, xri);
5791
7886 xrip = sbp->xrip;
5792 if (!xrip) {
7887 if (!xrip) {
5793 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
5794 "emlxs_sli4_register_xri: XRI not found.");
7888 xrip = emlxs_sli4_find_xri(port, xri);
5795
7889
7890 if (!xrip) {
7891 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
7892 "sli4_register_xri:%d XRI not found.", xri);
5796
7893
5797 mutex_exit(&EMLXS_FCTAB_LOCK);
5798 return (NULL);
7894 mutex_exit(&EMLXS_FCTAB_LOCK);
7895 return (NULL);
7896 }
5799 }
5800
5801 if ((xrip->state == XRI_STATE_FREE) ||
5802 !(xrip->flag & EMLXS_XRI_RESERVED)) {
5803
5804 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
7897 }
7898
7899 if ((xrip->state == XRI_STATE_FREE) ||
7900 !(xrip->flag & EMLXS_XRI_RESERVED)) {
7901
7902 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
5805 "emlxs_sli4_register_xri: Invalid XRI. xrip=%p "
7903 "sli4_register_xri:%d Invalid XRI. xrip=%p "
5806 "state=%x flag=%x",
7904 "state=%x flag=%x",
5807 xrip, xrip->state, xrip->flag);
7905 xrip->XRI, xrip, xrip->state, xrip->flag);
5808
5809 mutex_exit(&EMLXS_FCTAB_LOCK);
5810 return (NULL);
5811 }
5812
5813 iotag = xrip->iotag;
5814
5815 if ((!iotag) ||
5816 ((hba->fc_table[iotag] != NULL) &&
5817 (hba->fc_table[iotag] != STALE_PACKET))) {
5818
5819 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
7906
7907 mutex_exit(&EMLXS_FCTAB_LOCK);
7908 return (NULL);
7909 }
7910
7911 iotag = xrip->iotag;
7912
7913 if ((!iotag) ||
7914 ((hba->fc_table[iotag] != NULL) &&
7915 (hba->fc_table[iotag] != STALE_PACKET))) {
7916
7917 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
5820 "emlxs_sli4_register_xri: Invalid fc_table entry. "
5821 "iotag=%x entry=%p",
5822 iotag, hba->fc_table[iotag]);
7918 "sli4_register_xri:%d Invalid fc_table entry. "
7919 "iotag=%d entry=%p",
7920 xrip->XRI, iotag, hba->fc_table[iotag]);
5823
5824 mutex_exit(&EMLXS_FCTAB_LOCK);
5825 return (NULL);
5826 }
5827
5828 hba->fc_table[iotag] = sbp;
5829 hba->io_count++;
5830
5831 sbp->iotag = iotag;
5832 sbp->xrip = xrip;
5833
5834 xrip->flag &= ~EMLXS_XRI_RESERVED;
5835 xrip->sbp = sbp;
5836
7921
7922 mutex_exit(&EMLXS_FCTAB_LOCK);
7923 return (NULL);
7924 }
7925
7926 hba->fc_table[iotag] = sbp;
7927 hba->io_count++;
7928
7929 sbp->iotag = iotag;
7930 sbp->xrip = xrip;
7931
7932 xrip->flag &= ~EMLXS_XRI_RESERVED;
7933 xrip->sbp = sbp;
7934
7935 /* If we did not have a registered RPI when we reserved */
7936 /* this exchange, check again now. */
7937 if (xrip->rpip && (xrip->rpip->RPI == FABRIC_RPI)) {
7938 node = emlxs_node_find_did(port, did, 1);
7939 rpip = EMLXS_NODE_TO_RPI(port, node);
7940
7941 if (rpip && (rpip->RPI != FABRIC_RPI)) {
7942 /* Move the XRI to the new RPI */
7943 xrip->rpip->xri_count--;
7944 xrip->rpip = rpip;
7945 rpip->xri_count++;
7946 }
7947 }
7948
5837 mutex_exit(&EMLXS_FCTAB_LOCK);
5838
5839 return (xrip);
5840
5841} /* emlxs_sli4_register_xri() */
5842
5843
5844/* Performs both reserve and register functions for XRI */
5845static XRIobj_t *
7949 mutex_exit(&EMLXS_FCTAB_LOCK);
7950
7951 return (xrip);
7952
7953} /* emlxs_sli4_register_xri() */
7954
7955
7956/* Performs both reserve and register functions for XRI */
7957static XRIobj_t *
5846emlxs_sli4_alloc_xri(emlxs_hba_t *hba, emlxs_buf_t *sbp, RPIobj_t *rpip)
7958emlxs_sli4_alloc_xri(emlxs_port_t *port, emlxs_buf_t *sbp, RPIobj_t *rpip,
7959 uint32_t type)
5847{
7960{
5848 emlxs_port_t *port = &PPORT;
7961 emlxs_hba_t *hba = HBA;
5849 XRIobj_t *xrip;
5850 uint16_t iotag;
5851
5852 mutex_enter(&EMLXS_FCTAB_LOCK);
5853
5854 xrip = hba->sli.sli4.XRIfree_f;
5855
5856 if (xrip == (XRIobj_t *)&hba->sli.sli4.XRIfree_f) {

--- 7 unchanged lines hidden (view full) ---

5864
5865 if ((!iotag) ||
5866 ((hba->fc_table[iotag] != NULL) &&
5867 (hba->fc_table[iotag] != STALE_PACKET))) {
5868 /*
5869 * No more command slots available, retry later
5870 */
5871 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
7962 XRIobj_t *xrip;
7963 uint16_t iotag;
7964
7965 mutex_enter(&EMLXS_FCTAB_LOCK);
7966
7967 xrip = hba->sli.sli4.XRIfree_f;
7968
7969 if (xrip == (XRIobj_t *)&hba->sli.sli4.XRIfree_f) {

--- 7 unchanged lines hidden (view full) ---

7977
7978 if ((!iotag) ||
7979 ((hba->fc_table[iotag] != NULL) &&
7980 (hba->fc_table[iotag] != STALE_PACKET))) {
7981 /*
7982 * No more command slots available, retry later
7983 */
7984 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg,
5872 "Adapter Busy. Unable to alloc iotag:(0x%x)(%p)",
5873 iotag, hba->fc_table[iotag]);
7985 "Adapter Busy. Unable to alloc iotag:(0x%x)(%p) type=%d",
7986 iotag, hba->fc_table[iotag], type);
5874
5875 mutex_exit(&EMLXS_FCTAB_LOCK);
5876 return (NULL);
5877 }
5878
5879 hba->fc_table[iotag] = sbp;
5880 hba->io_count++;
5881
5882 sbp->iotag = iotag;
5883 sbp->xrip = xrip;
5884
5885 xrip->state = XRI_STATE_ALLOCATED;
7987
7988 mutex_exit(&EMLXS_FCTAB_LOCK);
7989 return (NULL);
7990 }
7991
7992 hba->fc_table[iotag] = sbp;
7993 hba->io_count++;
7994
7995 sbp->iotag = iotag;
7996 sbp->xrip = xrip;
7997
7998 xrip->state = XRI_STATE_ALLOCATED;
7999 xrip->type = type;
5886 xrip->flag = 0;
8000 xrip->flag = 0;
5887 xrip->rpip = rpip;
5888 xrip->sbp = sbp;
5889
8001 xrip->sbp = sbp;
8002
5890 if (rpip) {
5891 rpip->xri_count++;
5892 }
8003 xrip->rpip = rpip;
8004 rpip->xri_count++;
5893
5894 /* Take it off free list */
5895 (xrip->_b)->_f = xrip->_f;
5896 (xrip->_f)->_b = xrip->_b;
5897 xrip->_f = NULL;
5898 xrip->_b = NULL;
5899 hba->sli.sli4.xrif_count--;
5900

--- 8 unchanged lines hidden (view full) ---

5909
5910 return (xrip);
5911
5912} /* emlxs_sli4_alloc_xri() */
5913
5914
5915/* EMLXS_FCTAB_LOCK must be held to enter */
5916extern XRIobj_t *
8005
8006 /* Take it off free list */
8007 (xrip->_b)->_f = xrip->_f;
8008 (xrip->_f)->_b = xrip->_b;
8009 xrip->_f = NULL;
8010 xrip->_b = NULL;
8011 hba->sli.sli4.xrif_count--;
8012

--- 8 unchanged lines hidden (view full) ---

8021
8022 return (xrip);
8023
8024} /* emlxs_sli4_alloc_xri() */
8025
8026
8027/* EMLXS_FCTAB_LOCK must be held to enter */
8028extern XRIobj_t *
5917emlxs_sli4_find_xri(emlxs_hba_t *hba, uint16_t xri)
8029emlxs_sli4_find_xri(emlxs_port_t *port, uint16_t xri)
5918{
8030{
5919 emlxs_port_t *port = &PPORT;
8031 emlxs_hba_t *hba = HBA;
5920 XRIobj_t *xrip;
5921
5922 xrip = (XRIobj_t *)hba->sli.sli4.XRIinuse_f;
5923 while (xrip != (XRIobj_t *)&hba->sli.sli4.XRIinuse_f) {
5924 if ((xrip->state >= XRI_STATE_ALLOCATED) &&
5925 (xrip->XRI == xri)) {
5926 return (xrip);
5927 }

--- 6 unchanged lines hidden (view full) ---

5934 return (NULL);
5935
5936} /* emlxs_sli4_find_xri() */
5937
5938
5939
5940
5941extern void
8032 XRIobj_t *xrip;
8033
8034 xrip = (XRIobj_t *)hba->sli.sli4.XRIinuse_f;
8035 while (xrip != (XRIobj_t *)&hba->sli.sli4.XRIinuse_f) {
8036 if ((xrip->state >= XRI_STATE_ALLOCATED) &&
8037 (xrip->XRI == xri)) {
8038 return (xrip);
8039 }

--- 6 unchanged lines hidden (view full) ---

8046 return (NULL);
8047
8048} /* emlxs_sli4_find_xri() */
8049
8050
8051
8052
8053extern void
5942emlxs_sli4_free_xri(emlxs_hba_t *hba, emlxs_buf_t *sbp, XRIobj_t *xrip,
8054emlxs_sli4_free_xri(emlxs_port_t *port, emlxs_buf_t *sbp, XRIobj_t *xrip,
5943 uint8_t lock)
5944{
8055 uint8_t lock)
8056{
5945 emlxs_port_t *port = &PPORT;
8057 emlxs_hba_t *hba = HBA;
5946
5947 if (lock) {
5948 mutex_enter(&EMLXS_FCTAB_LOCK);
5949 }
5950
5951 if (xrip) {
5952 if (xrip->state == XRI_STATE_FREE) {
5953 if (lock) {
5954 mutex_exit(&EMLXS_FCTAB_LOCK);
5955 }
5956 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8058
8059 if (lock) {
8060 mutex_enter(&EMLXS_FCTAB_LOCK);
8061 }
8062
8063 if (xrip) {
8064 if (xrip->state == XRI_STATE_FREE) {
8065 if (lock) {
8066 mutex_exit(&EMLXS_FCTAB_LOCK);
8067 }
8068 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5957 "Free XRI:%x, Already freed", xrip->XRI);
8069 "Free XRI:%x, Already freed. type=%d",
8070 xrip->XRI, xrip->type);
5958 return;
5959 }
5960
8071 return;
8072 }
8073
8074 if (xrip->type == EMLXS_XRI_UNSOL_CT_TYPE) {
8075 (void) emlxs_flush_ct_event(port, xrip->rx_id);
8076 }
8077
5961 if (xrip->iotag &&
5962 (hba->fc_table[xrip->iotag] != NULL) &&
5963 (hba->fc_table[xrip->iotag] != STALE_PACKET)) {
5964 hba->fc_table[xrip->iotag] = NULL;
5965 hba->io_count--;
5966 }
5967
5968 xrip->state = XRI_STATE_FREE;
8078 if (xrip->iotag &&
8079 (hba->fc_table[xrip->iotag] != NULL) &&
8080 (hba->fc_table[xrip->iotag] != STALE_PACKET)) {
8081 hba->fc_table[xrip->iotag] = NULL;
8082 hba->io_count--;
8083 }
8084
8085 xrip->state = XRI_STATE_FREE;
8086 xrip->type = 0;
5969 xrip->flag = 0;
5970
5971 if (xrip->rpip) {
5972 xrip->rpip->xri_count--;
5973 xrip->rpip = NULL;
5974 }
5975
8087 xrip->flag = 0;
8088
8089 if (xrip->rpip) {
8090 xrip->rpip->xri_count--;
8091 xrip->rpip = NULL;
8092 }
8093
8094 if (xrip->reserved_rpip) {
8095 xrip->reserved_rpip->xri_count--;
8096 xrip->reserved_rpip = NULL;
8097 }
8098
5976 /* Take it off inuse list */
5977 (xrip->_b)->_f = xrip->_f;
5978 (xrip->_f)->_b = xrip->_b;
5979 xrip->_f = NULL;
5980 xrip->_b = NULL;
5981 hba->sli.sli4.xria_count--;
5982
5983 /* Add it to end of free list */

--- 7 unchanged lines hidden (view full) ---

5991 if (sbp) {
5992 if (!(sbp->pkt_flags & PACKET_VALID) ||
5993 (sbp->pkt_flags &
5994 (PACKET_ULP_OWNED|PACKET_COMPLETED|PACKET_IN_COMPLETION))) {
5995 if (lock) {
5996 mutex_exit(&EMLXS_FCTAB_LOCK);
5997 }
5998 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8099 /* Take it off inuse list */
8100 (xrip->_b)->_f = xrip->_f;
8101 (xrip->_f)->_b = xrip->_b;
8102 xrip->_f = NULL;
8103 xrip->_b = NULL;
8104 hba->sli.sli4.xria_count--;
8105
8106 /* Add it to end of free list */

--- 7 unchanged lines hidden (view full) ---

8114 if (sbp) {
8115 if (!(sbp->pkt_flags & PACKET_VALID) ||
8116 (sbp->pkt_flags &
8117 (PACKET_ULP_OWNED|PACKET_COMPLETED|PACKET_IN_COMPLETION))) {
8118 if (lock) {
8119 mutex_exit(&EMLXS_FCTAB_LOCK);
8120 }
8121 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
5999 "Free XRI: sbp invalid. sbp=%p flags=%x xri=%x",
8122 "Free XRI: sbp invalid. sbp=%p flags=%x xri=%d",
6000 sbp, sbp->pkt_flags, ((xrip)? xrip->XRI:0));
6001 return;
6002 }
6003
8123 sbp, sbp->pkt_flags, ((xrip)? xrip->XRI:0));
8124 return;
8125 }
8126
6004 sbp->xrip = 0;
6005
6006 if (xrip && (xrip->iotag != sbp->iotag)) {
6007 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
8127 if (xrip && (xrip->iotag != sbp->iotag)) {
8128 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
6008 "sbp / iotag mismatch %p iotag:%d %d", sbp,
8129 "sbp/iotag mismatch %p iotag:%d %d", sbp,
6009 sbp->iotag, xrip->iotag);
6010 }
6011
6012 if (sbp->iotag) {
6013 if (sbp == hba->fc_table[sbp->iotag]) {
6014 hba->fc_table[sbp->iotag] = NULL;
6015 hba->io_count--;
8130 sbp->iotag, xrip->iotag);
8131 }
8132
8133 if (sbp->iotag) {
8134 if (sbp == hba->fc_table[sbp->iotag]) {
8135 hba->fc_table[sbp->iotag] = NULL;
8136 hba->io_count--;
8137
8138 if (sbp->xrip) {
8139 /* Exchange is still reserved */
8140 sbp->xrip->flag |= EMLXS_XRI_RESERVED;
8141 }
6016 }
6017 sbp->iotag = 0;
6018 }
6019
8142 }
8143 sbp->iotag = 0;
8144 }
8145
8146 if (xrip) {
8147 sbp->xrip = 0;
8148 }
8149
6020 if (lock) {
6021 mutex_exit(&EMLXS_FCTAB_LOCK);
6022 }
6023
6024 /* Clean up the sbp */
6025 mutex_enter(&sbp->mtx);
6026
6027 if (sbp->pkt_flags & PACKET_IN_TXQ) {

--- 18 unchanged lines hidden (view full) ---

6046static int
6047emlxs_sli4_post_sgl_pages(emlxs_hba_t *hba, MAILBOXQ *mbq)
6048{
6049 MAILBOX4 *mb = (MAILBOX4 *)mbq;
6050 emlxs_port_t *port = &PPORT;
6051 XRIobj_t *xrip;
6052 MATCHMAP *mp;
6053 mbox_req_hdr_t *hdr_req;
8150 if (lock) {
8151 mutex_exit(&EMLXS_FCTAB_LOCK);
8152 }
8153
8154 /* Clean up the sbp */
8155 mutex_enter(&sbp->mtx);
8156
8157 if (sbp->pkt_flags & PACKET_IN_TXQ) {

--- 18 unchanged lines hidden (view full) ---

8176static int
8177emlxs_sli4_post_sgl_pages(emlxs_hba_t *hba, MAILBOXQ *mbq)
8178{
8179 MAILBOX4 *mb = (MAILBOX4 *)mbq;
8180 emlxs_port_t *port = &PPORT;
8181 XRIobj_t *xrip;
8182 MATCHMAP *mp;
8183 mbox_req_hdr_t *hdr_req;
6054 uint32_t i, cnt, xri_cnt;
8184 uint32_t i;
8185 uint32_t cnt;
8186 uint32_t xri_cnt;
8187 uint32_t j;
6055 uint32_t size;
6056 IOCTL_FCOE_CFG_POST_SGL_PAGES *post_sgl;
6057
6058 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
6059 mbq->bp = NULL;
6060 mbq->mbox_cmpl = NULL;
6061
6062 if ((mp = emlxs_mem_buf_alloc(hba, EMLXS_MAX_NONEMBED_SIZE)) == 0) {

--- 10 unchanged lines hidden (view full) ---

6073 mb->un.varSLIConfig.be.embedded = 0;
6074 mb->mbxCommand = MBX_SLI_CONFIG;
6075 mb->mbxOwner = OWN_HOST;
6076
6077 hdr_req = (mbox_req_hdr_t *)mp->virt;
6078 post_sgl =
6079 (IOCTL_FCOE_CFG_POST_SGL_PAGES *)(hdr_req + 1);
6080
8188 uint32_t size;
8189 IOCTL_FCOE_CFG_POST_SGL_PAGES *post_sgl;
8190
8191 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
8192 mbq->bp = NULL;
8193 mbq->mbox_cmpl = NULL;
8194
8195 if ((mp = emlxs_mem_buf_alloc(hba, EMLXS_MAX_NONEMBED_SIZE)) == 0) {

--- 10 unchanged lines hidden (view full) ---

8206 mb->un.varSLIConfig.be.embedded = 0;
8207 mb->mbxCommand = MBX_SLI_CONFIG;
8208 mb->mbxOwner = OWN_HOST;
8209
8210 hdr_req = (mbox_req_hdr_t *)mp->virt;
8211 post_sgl =
8212 (IOCTL_FCOE_CFG_POST_SGL_PAGES *)(hdr_req + 1);
8213
6081
6082 xrip = hba->sli.sli4.XRIp;
8214 xrip = hba->sli.sli4.XRIp;
6083 cnt = hba->sli.sli4.XRICount;
6084 while (cnt) {
6085 bzero((void *) hdr_req, mp->size);
6086 size = mp->size - IOCTL_HEADER_SZ;
6087
8215
6088 mb->un.varSLIConfig.be.payload_length =
6089 mp->size;
6090 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
6091 IOCTL_SUBSYSTEM_FCOE;
6092 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
6093 FCOE_OPCODE_CFG_POST_SGL_PAGES;
6094 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
6095 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length = size;
8216 /* For each extent */
8217 for (j = 0; j < hba->sli.sli4.XRIExtCount; j++) {
8218 cnt = hba->sli.sli4.XRIExtSize;
8219 while (cnt) {
8220 if (xrip->XRI == 0) {
8221 cnt--;
8222 xrip++;
8223 continue;
8224 }
6096
8225
6097 hdr_req->subsystem = IOCTL_SUBSYSTEM_FCOE;
6098 hdr_req->opcode = FCOE_OPCODE_CFG_POST_SGL_PAGES;
6099 hdr_req->timeout = 0;
6100 hdr_req->req_length = size;
8226 bzero((void *) hdr_req, mp->size);
8227 size = mp->size - IOCTL_HEADER_SZ;
6101
8228
6102 post_sgl->params.request.xri_count = 0;
6103 post_sgl->params.request.xri_start = xrip->XRI;
6104 xri_cnt = (size - sizeof (IOCTL_FCOE_CFG_POST_SGL_PAGES)) /
6105 sizeof (FCOE_SGL_PAGES);
6106 for (i = 0; i < xri_cnt; i++) {
8229 mb->un.varSLIConfig.be.payload_length =
8230 mp->size;
8231 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
8232 IOCTL_SUBSYSTEM_FCOE;
8233 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
8234 FCOE_OPCODE_CFG_POST_SGL_PAGES;
8235 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
8236 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length = size;
6107
8237
6108 post_sgl->params.request.xri_count++;
6109 post_sgl->params.request.pages[i].sgl_page0.addrLow =
6110 PADDR_LO(xrip->SGList.phys);
6111 post_sgl->params.request.pages[i].sgl_page0.addrHigh =
6112 PADDR_HI(xrip->SGList.phys);
6113 cnt--;
6114 xrip++;
6115 if (cnt == 0) {
6116 break;
8238 hdr_req->subsystem = IOCTL_SUBSYSTEM_FCOE;
8239 hdr_req->opcode = FCOE_OPCODE_CFG_POST_SGL_PAGES;
8240 hdr_req->timeout = 0;
8241 hdr_req->req_length = size;
8242
8243 post_sgl->params.request.xri_count = 0;
8244 post_sgl->params.request.xri_start = xrip->XRI;
8245
8246 xri_cnt = (size -
8247 sizeof (IOCTL_FCOE_CFG_POST_SGL_PAGES)) /
8248 sizeof (FCOE_SGL_PAGES);
8249
8250 for (i = 0; (i < xri_cnt) && cnt; i++) {
8251 post_sgl->params.request.xri_count++;
8252 post_sgl->params.request.pages[i].\
8253 sgl_page0.addrLow =
8254 PADDR_LO(xrip->SGList.phys);
8255 post_sgl->params.request.pages[i].\
8256 sgl_page0.addrHigh =
8257 PADDR_HI(xrip->SGList.phys);
8258
8259 cnt--;
8260 xrip++;
6117 }
8261 }
8262
8263 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8264 MBX_SUCCESS) {
8265 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8266 "Unable to POST_SGL. Mailbox cmd=%x "
8267 "status=%x XRI cnt:%d start:%d",
8268 mb->mbxCommand, mb->mbxStatus,
8269 post_sgl->params.request.xri_count,
8270 post_sgl->params.request.xri_start);
8271 emlxs_mem_buf_free(hba, mp);
8272 mbq->nonembed = NULL;
8273 return (EIO);
8274 }
6118 }
8275 }
6119 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6120 MBX_SUCCESS) {
6121 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6122 "Unable to POST_SGL. Mailbox cmd=%x status=%x "
6123 "XRI cnt:%d start:%d",
6124 mb->mbxCommand, mb->mbxStatus,
6125 post_sgl->params.request.xri_count,
6126 post_sgl->params.request.xri_start);
6127 emlxs_mem_buf_free(hba, mp);
6128 mbq->nonembed = NULL;
6129 return (EIO);
6130 }
6131 }
8276 }
8277
6132 emlxs_mem_buf_free(hba, mp);
6133 mbq->nonembed = NULL;
6134 return (0);
6135
6136} /* emlxs_sli4_post_sgl_pages() */
6137
6138
6139static int
6140emlxs_sli4_post_hdr_tmplates(emlxs_hba_t *hba, MAILBOXQ *mbq)
6141{
6142 MAILBOX4 *mb = (MAILBOX4 *)mbq;
6143 emlxs_port_t *port = &PPORT;
8278 emlxs_mem_buf_free(hba, mp);
8279 mbq->nonembed = NULL;
8280 return (0);
8281
8282} /* emlxs_sli4_post_sgl_pages() */
8283
8284
8285static int
8286emlxs_sli4_post_hdr_tmplates(emlxs_hba_t *hba, MAILBOXQ *mbq)
8287{
8288 MAILBOX4 *mb = (MAILBOX4 *)mbq;
8289 emlxs_port_t *port = &PPORT;
6144 int i, cnt;
8290 uint32_t j;
8291 uint32_t k;
6145 uint64_t addr;
6146 IOCTL_FCOE_POST_HDR_TEMPLATES *post_hdr;
8292 uint64_t addr;
8293 IOCTL_FCOE_POST_HDR_TEMPLATES *post_hdr;
8294 uint16_t num_pages;
6147
8295
6148 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
6149 mbq->bp = NULL;
6150 mbq->mbox_cmpl = NULL;
8296 if (!(hba->sli.sli4.param.HDRR)) {
8297 return (0);
8298 }
6151
8299
6152 /*
6153 * Signifies an embedded command
6154 */
6155 mb->un.varSLIConfig.be.embedded = 1;
8300 /* Bytes per extent */
8301 j = hba->sli.sli4.RPIExtSize * sizeof (RPIHdrTmplate_t);
6156
8302
6157 mb->mbxCommand = MBX_SLI_CONFIG;
6158 mb->mbxOwner = OWN_HOST;
6159 mb->un.varSLIConfig.be.payload_length =
6160 sizeof (IOCTL_FCOE_POST_HDR_TEMPLATES) + IOCTL_HEADER_SZ;
6161 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
6162 IOCTL_SUBSYSTEM_FCOE;
6163 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
6164 FCOE_OPCODE_POST_HDR_TEMPLATES;
6165 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
6166 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
6167 sizeof (IOCTL_FCOE_POST_HDR_TEMPLATES);
6168 post_hdr =
6169 (IOCTL_FCOE_POST_HDR_TEMPLATES *)&mb->un.varSLIConfig.payload;
8303 /* Pages required per extent (page == 4096 bytes) */
8304 num_pages = (j/4096) + ((j%4096)? 1:0);
8305
6170 addr = hba->sli.sli4.HeaderTmplate.phys;
8306 addr = hba->sli.sli4.HeaderTmplate.phys;
6171 post_hdr->params.request.num_pages = 0;
6172 i = 0;
6173 cnt = hba->sli.sli4.HeaderTmplate.size;
6174 while (cnt > 0) {
6175 post_hdr->params.request.num_pages++;
6176 post_hdr->params.request.pages[i].addrLow = PADDR_LO(addr);
6177 post_hdr->params.request.pages[i].addrHigh = PADDR_HI(addr);
6178 i++;
6179 addr += 4096;
6180 cnt -= 4096;
6181 }
6182 post_hdr->params.request.starting_rpi_index = hba->sli.sli4.RPIBase;
6183
8307
6184 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6185 MBX_SUCCESS) {
6186 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6187 "Unable to POST_HDR_TEMPLATES. Mailbox cmd=%x status=%x ",
6188 mb->mbxCommand, mb->mbxStatus);
6189 return (EIO);
8308 /* For each extent */
8309 for (j = 0; j < hba->sli.sli4.RPIExtCount; j++) {
8310 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
8311 mbq->bp = NULL;
8312 mbq->mbox_cmpl = NULL;
8313
8314 /*
8315 * Signifies an embedded command
8316 */
8317 mb->un.varSLIConfig.be.embedded = 1;
8318
8319 mb->mbxCommand = MBX_SLI_CONFIG;
8320 mb->mbxOwner = OWN_HOST;
8321 mb->un.varSLIConfig.be.payload_length =
8322 sizeof (IOCTL_FCOE_POST_HDR_TEMPLATES) + IOCTL_HEADER_SZ;
8323 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
8324 IOCTL_SUBSYSTEM_FCOE;
8325 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
8326 FCOE_OPCODE_POST_HDR_TEMPLATES;
8327 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
8328 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
8329 sizeof (IOCTL_FCOE_POST_HDR_TEMPLATES);
8330
8331 post_hdr =
8332 (IOCTL_FCOE_POST_HDR_TEMPLATES *)
8333 &mb->un.varSLIConfig.payload;
8334 post_hdr->params.request.num_pages = num_pages;
8335 post_hdr->params.request.rpi_offset = hba->sli.sli4.RPIBase[j];
8336
8337 for (k = 0; k < num_pages; k++) {
8338 post_hdr->params.request.pages[k].addrLow =
8339 PADDR_LO(addr);
8340 post_hdr->params.request.pages[k].addrHigh =
8341 PADDR_HI(addr);
8342 addr += 4096;
8343 }
8344
8345 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8346 MBX_SUCCESS) {
8347 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8348 "Unable to POST_HDR_TEMPLATES. Mailbox cmd=%x "
8349 "status=%x ",
8350 mb->mbxCommand, mb->mbxStatus);
8351 return (EIO);
8352 }
8353 emlxs_data_dump(port, "POST_HDR", (uint32_t *)mb, 18, 0);
6190 }
8354 }
6191emlxs_data_dump(port, "POST_HDR", (uint32_t *)mb, 18, 0);
8355
6192 return (0);
6193
6194} /* emlxs_sli4_post_hdr_tmplates() */
6195
6196
6197static int
6198emlxs_sli4_create_queues(emlxs_hba_t *hba, MAILBOXQ *mbq)
6199{
6200 MAILBOX4 *mb = (MAILBOX4 *)mbq;
6201 emlxs_port_t *port = &PPORT;
6202 emlxs_config_t *cfg = &CFG;
6203 IOCTL_COMMON_EQ_CREATE *eq;
6204 IOCTL_COMMON_CQ_CREATE *cq;
6205 IOCTL_FCOE_WQ_CREATE *wq;
6206 IOCTL_FCOE_RQ_CREATE *rq;
6207 IOCTL_COMMON_MQ_CREATE *mq;
8356 return (0);
8357
8358} /* emlxs_sli4_post_hdr_tmplates() */
8359
8360
8361static int
8362emlxs_sli4_create_queues(emlxs_hba_t *hba, MAILBOXQ *mbq)
8363{
8364 MAILBOX4 *mb = (MAILBOX4 *)mbq;
8365 emlxs_port_t *port = &PPORT;
8366 emlxs_config_t *cfg = &CFG;
8367 IOCTL_COMMON_EQ_CREATE *eq;
8368 IOCTL_COMMON_CQ_CREATE *cq;
8369 IOCTL_FCOE_WQ_CREATE *wq;
8370 IOCTL_FCOE_RQ_CREATE *rq;
8371 IOCTL_COMMON_MQ_CREATE *mq;
6208 IOCTL_COMMON_MCC_CREATE_EXT *mcc_ext;
8372 IOCTL_COMMON_MQ_CREATE_EXT *mq_ext;
6209 emlxs_rqdbu_t rqdb;
6210 uint16_t i, j;
6211 uint16_t num_cq, total_cq;
6212 uint16_t num_wq, total_wq;
6213
6214 /*
6215 * The first CQ is reserved for ASYNC events,
6216 * the second is reserved for unsol rcv, the rest
6217 * correspond to WQs. (WQ0 -> CQ2, WQ1 -> CQ3, ...)
6218 */
6219
8373 emlxs_rqdbu_t rqdb;
8374 uint16_t i, j;
8375 uint16_t num_cq, total_cq;
8376 uint16_t num_wq, total_wq;
8377
8378 /*
8379 * The first CQ is reserved for ASYNC events,
8380 * the second is reserved for unsol rcv, the rest
8381 * correspond to WQs. (WQ0 -> CQ2, WQ1 -> CQ3, ...)
8382 */
8383
6220 /* First initialize queue ordinal mapping */
6221 for (i = 0; i < EMLXS_MAX_EQ_IDS; i++) {
6222 hba->sli.sli4.eq_map[i] = 0xffff;
6223 }
6224 for (i = 0; i < EMLXS_MAX_CQ_IDS; i++) {
6225 hba->sli.sli4.cq_map[i] = 0xffff;
6226 }
6227 for (i = 0; i < EMLXS_MAX_WQ_IDS; i++) {
6228 hba->sli.sli4.wq_map[i] = 0xffff;
6229 }
6230 for (i = 0; i < EMLXS_MAX_RQ_IDS; i++) {
6231 hba->sli.sli4.rq_map[i] = 0xffff;
6232 }
6233
6234 total_cq = 0;
6235 total_wq = 0;
6236
6237 /* Create EQ's */
6238 for (i = 0; i < hba->intr_count; i++) {
6239 emlxs_mb_eq_create(hba, mbq, i);
6240 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6241 MBX_SUCCESS) {
6242 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
6243 "Unable to Create EQ %d: Mailbox cmd=%x status=%x ",
6244 i, mb->mbxCommand, mb->mbxStatus);
6245 return (EIO);
6246 }
6247 eq = (IOCTL_COMMON_EQ_CREATE *)&mb->un.varSLIConfig.payload;
6248 hba->sli.sli4.eq[i].qid = eq->params.response.EQId;
8384 total_cq = 0;
8385 total_wq = 0;
8386
8387 /* Create EQ's */
8388 for (i = 0; i < hba->intr_count; i++) {
8389 emlxs_mb_eq_create(hba, mbq, i);
8390 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8391 MBX_SUCCESS) {
8392 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
8393 "Unable to Create EQ %d: Mailbox cmd=%x status=%x ",
8394 i, mb->mbxCommand, mb->mbxStatus);
8395 return (EIO);
8396 }
8397 eq = (IOCTL_COMMON_EQ_CREATE *)&mb->un.varSLIConfig.payload;
8398 hba->sli.sli4.eq[i].qid = eq->params.response.EQId;
6249 hba->sli.sli4.eq_map[eq->params.response.EQId] = i;
6250 hba->sli.sli4.eq[i].lastwq = total_wq;
8399 hba->sli.sli4.eq[i].lastwq = total_wq;
8400 hba->sli.sli4.eq[i].msix_vector = i;
6251
8401
6252emlxs_data_dump(port, "EQ0_CREATE", (uint32_t *)mb, 18, 0);
8402 emlxs_data_dump(port, "EQ0_CREATE", (uint32_t *)mb, 18, 0);
6253 num_wq = cfg[CFG_NUM_WQ].current;
6254 num_cq = num_wq;
6255 if (i == 0) {
6256 /* One for RQ handling, one for mbox/event handling */
6257 num_cq += EMLXS_CQ_OFFSET_WQ;
6258 }
6259
8403 num_wq = cfg[CFG_NUM_WQ].current;
8404 num_cq = num_wq;
8405 if (i == 0) {
8406 /* One for RQ handling, one for mbox/event handling */
8407 num_cq += EMLXS_CQ_OFFSET_WQ;
8408 }
8409
8410 /* Create CQ's */
6260 for (j = 0; j < num_cq; j++) {
6261 /* Reuse mbq from previous mbox */
6262 bzero(mbq, sizeof (MAILBOXQ));
6263
6264 hba->sli.sli4.cq[total_cq].eqid =
6265 hba->sli.sli4.eq[i].qid;
6266
6267 emlxs_mb_cq_create(hba, mbq, total_cq);

--- 4 unchanged lines hidden (view full) ---

6272 "CQ %d: Mailbox cmd=%x status=%x ",
6273 total_cq, mb->mbxCommand, mb->mbxStatus);
6274 return (EIO);
6275 }
6276 cq = (IOCTL_COMMON_CQ_CREATE *)
6277 &mb->un.varSLIConfig.payload;
6278 hba->sli.sli4.cq[total_cq].qid =
6279 cq->params.response.CQId;
8411 for (j = 0; j < num_cq; j++) {
8412 /* Reuse mbq from previous mbox */
8413 bzero(mbq, sizeof (MAILBOXQ));
8414
8415 hba->sli.sli4.cq[total_cq].eqid =
8416 hba->sli.sli4.eq[i].qid;
8417
8418 emlxs_mb_cq_create(hba, mbq, total_cq);

--- 4 unchanged lines hidden (view full) ---

8423 "CQ %d: Mailbox cmd=%x status=%x ",
8424 total_cq, mb->mbxCommand, mb->mbxStatus);
8425 return (EIO);
8426 }
8427 cq = (IOCTL_COMMON_CQ_CREATE *)
8428 &mb->un.varSLIConfig.payload;
8429 hba->sli.sli4.cq[total_cq].qid =
8430 cq->params.response.CQId;
6280 hba->sli.sli4.cq_map[cq->params.response.CQId] =
6281 total_cq;
6282
6283 switch (total_cq) {
6284 case EMLXS_CQ_MBOX:
6285 /* First CQ is for async event handling */
6286 hba->sli.sli4.cq[total_cq].type =
6287 EMLXS_CQ_TYPE_GROUP1;
6288 break;
6289

--- 6 unchanged lines hidden (view full) ---

6296 default:
6297 /* Setup CQ to channel mapping */
6298 hba->sli.sli4.cq[total_cq].type =
6299 EMLXS_CQ_TYPE_GROUP2;
6300 hba->sli.sli4.cq[total_cq].channelp =
6301 &hba->chan[total_cq - EMLXS_CQ_OFFSET_WQ];
6302 break;
6303 }
8431
8432 switch (total_cq) {
8433 case EMLXS_CQ_MBOX:
8434 /* First CQ is for async event handling */
8435 hba->sli.sli4.cq[total_cq].type =
8436 EMLXS_CQ_TYPE_GROUP1;
8437 break;
8438

--- 6 unchanged lines hidden (view full) ---

8445 default:
8446 /* Setup CQ to channel mapping */
8447 hba->sli.sli4.cq[total_cq].type =
8448 EMLXS_CQ_TYPE_GROUP2;
8449 hba->sli.sli4.cq[total_cq].channelp =
8450 &hba->chan[total_cq - EMLXS_CQ_OFFSET_WQ];
8451 break;
8452 }
6304emlxs_data_dump(port, "CQX_CREATE", (uint32_t *)mb, 18, 0);
8453 emlxs_data_dump(port, "CQX_CREATE", (uint32_t *)mb,
8454 18, 0);
6305 total_cq++;
6306 }
6307
8455 total_cq++;
8456 }
8457
8458 /* Create WQ's */
6308 for (j = 0; j < num_wq; j++) {
6309 /* Reuse mbq from previous mbox */
6310 bzero(mbq, sizeof (MAILBOXQ));
6311
6312 hba->sli.sli4.wq[total_wq].cqid =
6313 hba->sli.sli4.cq[total_wq + EMLXS_CQ_OFFSET_WQ].qid;
6314
6315 emlxs_mb_wq_create(hba, mbq, total_wq);

--- 4 unchanged lines hidden (view full) ---

6320 "WQ %d: Mailbox cmd=%x status=%x ",
6321 total_wq, mb->mbxCommand, mb->mbxStatus);
6322 return (EIO);
6323 }
6324 wq = (IOCTL_FCOE_WQ_CREATE *)
6325 &mb->un.varSLIConfig.payload;
6326 hba->sli.sli4.wq[total_wq].qid =
6327 wq->params.response.WQId;
8459 for (j = 0; j < num_wq; j++) {
8460 /* Reuse mbq from previous mbox */
8461 bzero(mbq, sizeof (MAILBOXQ));
8462
8463 hba->sli.sli4.wq[total_wq].cqid =
8464 hba->sli.sli4.cq[total_wq + EMLXS_CQ_OFFSET_WQ].qid;
8465
8466 emlxs_mb_wq_create(hba, mbq, total_wq);

--- 4 unchanged lines hidden (view full) ---

8471 "WQ %d: Mailbox cmd=%x status=%x ",
8472 total_wq, mb->mbxCommand, mb->mbxStatus);
8473 return (EIO);
8474 }
8475 wq = (IOCTL_FCOE_WQ_CREATE *)
8476 &mb->un.varSLIConfig.payload;
8477 hba->sli.sli4.wq[total_wq].qid =
8478 wq->params.response.WQId;
6328 hba->sli.sli4.wq_map[wq->params.response.WQId] =
6329 total_wq;
6330
6331 hba->sli.sli4.wq[total_wq].cqid =
6332 hba->sli.sli4.cq[total_wq+EMLXS_CQ_OFFSET_WQ].qid;
8479
8480 hba->sli.sli4.wq[total_wq].cqid =
8481 hba->sli.sli4.cq[total_wq+EMLXS_CQ_OFFSET_WQ].qid;
6333emlxs_data_dump(port, "WQ_CREATE", (uint32_t *)mb, 18, 0);
8482 emlxs_data_dump(port, "WQ_CREATE", (uint32_t *)mb,
8483 18, 0);
6334 total_wq++;
6335 }
6336 hba->last_msiid = i;
6337 }
6338
6339 /* We assume 1 RQ pair will handle ALL incoming data */
6340 /* Create RQs */
6341 for (i = 0; i < EMLXS_MAX_RQS; i++) {

--- 17 unchanged lines hidden (view full) ---

6359 emlxs_mb_rq_create(hba, mbq, i);
6360 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6361 MBX_SUCCESS) {
6362 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
6363 "Unable to Create RQ %d: Mailbox cmd=%x status=%x ",
6364 i, mb->mbxCommand, mb->mbxStatus);
6365 return (EIO);
6366 }
8484 total_wq++;
8485 }
8486 hba->last_msiid = i;
8487 }
8488
8489 /* We assume 1 RQ pair will handle ALL incoming data */
8490 /* Create RQs */
8491 for (i = 0; i < EMLXS_MAX_RQS; i++) {

--- 17 unchanged lines hidden (view full) ---

8509 emlxs_mb_rq_create(hba, mbq, i);
8510 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8511 MBX_SUCCESS) {
8512 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
8513 "Unable to Create RQ %d: Mailbox cmd=%x status=%x ",
8514 i, mb->mbxCommand, mb->mbxStatus);
8515 return (EIO);
8516 }
8517
6367 rq = (IOCTL_FCOE_RQ_CREATE *)&mb->un.varSLIConfig.payload;
6368 hba->sli.sli4.rq[i].qid = rq->params.response.RQId;
8518 rq = (IOCTL_FCOE_RQ_CREATE *)&mb->un.varSLIConfig.payload;
8519 hba->sli.sli4.rq[i].qid = rq->params.response.RQId;
6369 hba->sli.sli4.rq_map[rq->params.response.RQId] = i;
6370emlxs_data_dump(port, "RQ CREATE", (uint32_t *)mb, 18, 0);
8520 emlxs_data_dump(port, "RQ CREATE", (uint32_t *)mb, 18, 0);
6371
6372 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6373 "RQ CREATE: rq[%d].qid=%d cqid=%d",
6374 i, hba->sli.sli4.rq[i].qid, hba->sli.sli4.rq[i].cqid);
6375
6376 /* Initialize the host_index */
6377 hba->sli.sli4.rq[i].host_index = 0;
6378
6379 /* If Data queue was just created, */
6380 /* then post buffers using the header qid */
6381 if ((i & 0x1)) {
6382 /* Ring the RQ doorbell to post buffers */
6383 rqdb.word = 0;
6384 rqdb.db.Qid = hba->sli.sli4.rq[i-1].qid;
6385 rqdb.db.NumPosted = RQB_COUNT;
6386
8521
8522 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8523 "RQ CREATE: rq[%d].qid=%d cqid=%d",
8524 i, hba->sli.sli4.rq[i].qid, hba->sli.sli4.rq[i].cqid);
8525
8526 /* Initialize the host_index */
8527 hba->sli.sli4.rq[i].host_index = 0;
8528
8529 /* If Data queue was just created, */
8530 /* then post buffers using the header qid */
8531 if ((i & 0x1)) {
8532 /* Ring the RQ doorbell to post buffers */
8533 rqdb.word = 0;
8534 rqdb.db.Qid = hba->sli.sli4.rq[i-1].qid;
8535 rqdb.db.NumPosted = RQB_COUNT;
8536
6387 WRITE_BAR2_REG(hba, FC_RQDB_REG(hba), rqdb.word);
8537 emlxs_sli4_write_rqdb(hba, rqdb.word);
6388
6389 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6390 "RQ CREATE: Doorbell rang: qid=%d count=%d",
6391 hba->sli.sli4.rq[i-1].qid, RQB_COUNT);
6392 }
6393 }
6394
6395 /* Create MQ */
6396
6397 /* Personalize the MQ */
6398 hba->sli.sli4.mq.cqid = hba->sli.sli4.cq[EMLXS_CQ_MBOX].qid;
6399
6400 /* Reuse mbq from previous mbox */
6401 bzero(mbq, sizeof (MAILBOXQ));
6402
8538
8539 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8540 "RQ CREATE: Doorbell rang: qid=%d count=%d",
8541 hba->sli.sli4.rq[i-1].qid, RQB_COUNT);
8542 }
8543 }
8544
8545 /* Create MQ */
8546
8547 /* Personalize the MQ */
8548 hba->sli.sli4.mq.cqid = hba->sli.sli4.cq[EMLXS_CQ_MBOX].qid;
8549
8550 /* Reuse mbq from previous mbox */
8551 bzero(mbq, sizeof (MAILBOXQ));
8552
6403 emlxs_mb_mcc_create_ext(hba, mbq);
8553 emlxs_mb_mq_create_ext(hba, mbq);
6404 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6405 MBX_SUCCESS) {
6406 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
8554 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8555 MBX_SUCCESS) {
8556 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
6407 "Unable to Create MCC_EXT %d: Mailbox cmd=%x status=%x ",
8557 "Unable to Create MQ_EXT %d: Mailbox cmd=%x status=%x ",
6408 i, mb->mbxCommand, mb->mbxStatus);
6409
6410 /* Reuse mbq from previous mbox */
6411 bzero(mbq, sizeof (MAILBOXQ));
6412
6413 emlxs_mb_mq_create(hba, mbq);
6414 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
6415 MBX_SUCCESS) {
6416 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
6417 "Unable to Create MQ %d: Mailbox cmd=%x status=%x ",
6418 i, mb->mbxCommand, mb->mbxStatus);
6419 return (EIO);
6420 }
6421
6422 mq = (IOCTL_COMMON_MQ_CREATE *)&mb->un.varSLIConfig.payload;
6423 hba->sli.sli4.mq.qid = mq->params.response.MQId;
6424 return (0);
6425 }
6426
8558 i, mb->mbxCommand, mb->mbxStatus);
8559
8560 /* Reuse mbq from previous mbox */
8561 bzero(mbq, sizeof (MAILBOXQ));
8562
8563 emlxs_mb_mq_create(hba, mbq);
8564 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) !=
8565 MBX_SUCCESS) {
8566 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
8567 "Unable to Create MQ %d: Mailbox cmd=%x status=%x ",
8568 i, mb->mbxCommand, mb->mbxStatus);
8569 return (EIO);
8570 }
8571
8572 mq = (IOCTL_COMMON_MQ_CREATE *)&mb->un.varSLIConfig.payload;
8573 hba->sli.sli4.mq.qid = mq->params.response.MQId;
8574 return (0);
8575 }
8576
6427 mcc_ext = (IOCTL_COMMON_MCC_CREATE_EXT *)&mb->un.varSLIConfig.payload;
6428 hba->sli.sli4.mq.qid = mcc_ext->params.response.id;
8577 mq_ext = (IOCTL_COMMON_MQ_CREATE_EXT *)&mb->un.varSLIConfig.payload;
8578 hba->sli.sli4.mq.qid = mq_ext->params.response.MQId;
6429 return (0);
6430
6431} /* emlxs_sli4_create_queues() */
6432
6433
8579 return (0);
8580
8581} /* emlxs_sli4_create_queues() */
8582
8583
6434/*ARGSUSED*/
6435extern int
6436emlxs_sli4_check_fcf_config(emlxs_hba_t *hba, FCF_RECORD_t *fcfrec)
6437{
6438 int i;
6439
6440 if (!(hba->flag & FC_FIP_SUPPORTED)) {
6441 if (!hba->sli.sli4.cfgFCOE.length) {
6442 /* Nothing specified, so everything matches */
6443 /* For nonFIP only use index 0 */
6444 if (fcfrec->fcf_index == 0) {
6445 return (1); /* success */
6446 }
6447 return (0);
6448 }
6449
6450 /* Just check FCMap for now */
6451 if (bcmp((char *)fcfrec->fc_map,
6452 hba->sli.sli4.cfgFCOE.FCMap, 3) == 0) {
6453 return (1); /* success */
6454 }
6455 return (0);
6456 }
6457
6458 /* For FIP mode, the FCF record must match Config Region 23 */
6459
6460 if (!hba->sli.sli4.cfgFCF.length) {
6461 /* Nothing specified, so everything matches */
6462 return (1); /* success */
6463 }
6464
6465 /* Just check FabricName for now */
6466 for (i = 0; i < MAX_FCFCONNECTLIST_ENTRIES; i++) {
6467 if ((hba->sli.sli4.cfgFCF.entry[i].FabricNameValid) &&
6468 (bcmp((char *)fcfrec->fabric_name_identifier,
6469 hba->sli.sli4.cfgFCF.entry[i].FabricName, 8) == 0)) {
6470 return (1); /* success */
6471 }
6472 }
6473 return (0);
6474
6475} /* emlxs_sli4_check_fcf_config() */
6476
6477
6478extern void
6479emlxs_sli4_timer(emlxs_hba_t *hba)
6480{
6481 /* Perform SLI4 level timer checks */
6482
6483 emlxs_fcf_timer_notify(hba);
6484
6485 emlxs_sli4_timer_check_mbox(hba);

--- 81 unchanged lines hidden (view full) ---

6567} /* emlxs_sli4_timer_check_mbox() */
6568
6569
6570extern void
6571emlxs_data_dump(emlxs_port_t *port, char *str, uint32_t *iptr, int cnt, int err)
6572{
6573 void *msg;
6574
8584extern void
8585emlxs_sli4_timer(emlxs_hba_t *hba)
8586{
8587 /* Perform SLI4 level timer checks */
8588
8589 emlxs_fcf_timer_notify(hba);
8590
8591 emlxs_sli4_timer_check_mbox(hba);

--- 81 unchanged lines hidden (view full) ---

8673} /* emlxs_sli4_timer_check_mbox() */
8674
8675
8676extern void
8677emlxs_data_dump(emlxs_port_t *port, char *str, uint32_t *iptr, int cnt, int err)
8678{
8679 void *msg;
8680
8681 if (!port || !str || !iptr || !cnt) {
8682 return;
8683 }
8684
6575 if (err) {
6576 msg = &emlxs_sli_err_msg;
6577 } else {
6578 msg = &emlxs_sli_detail_msg;
6579 }
6580
6581 if (cnt) {
6582 EMLXS_MSGF(EMLXS_CONTEXT, msg,
8685 if (err) {
8686 msg = &emlxs_sli_err_msg;
8687 } else {
8688 msg = &emlxs_sli_detail_msg;
8689 }
8690
8691 if (cnt) {
8692 EMLXS_MSGF(EMLXS_CONTEXT, msg,
6583 "%s00: %08x %08x %08x %08x %08x %08x", str, *iptr,
8693 "%s00: %08x %08x %08x %08x %08x %08x", str, *iptr,
6584 *(iptr+1), *(iptr+2), *(iptr+3), *(iptr+4), *(iptr+5));
6585 }
6586 if (cnt > 6) {
6587 EMLXS_MSGF(EMLXS_CONTEXT, msg,
8694 *(iptr+1), *(iptr+2), *(iptr+3), *(iptr+4), *(iptr+5));
8695 }
8696 if (cnt > 6) {
8697 EMLXS_MSGF(EMLXS_CONTEXT, msg,
6588 "%s06: %08x %08x %08x %08x %08x %08x", str, *(iptr+6),
8698 "%s06: %08x %08x %08x %08x %08x %08x", str, *(iptr+6),
6589 *(iptr+7), *(iptr+8), *(iptr+9), *(iptr+10), *(iptr+11));
6590 }
6591 if (cnt > 12) {
6592 EMLXS_MSGF(EMLXS_CONTEXT, msg,
6593 "%s12: %08x %08x %08x %08x %08x %08x", str, *(iptr+12),
6594 *(iptr+13), *(iptr+14), *(iptr+15), *(iptr+16), *(iptr+17));
6595 }
6596 if (cnt > 18) {

--- 19 unchanged lines hidden (view full) ---

6616
6617} /* emlxs_data_dump() */
6618
6619
6620extern void
6621emlxs_ue_dump(emlxs_hba_t *hba, char *str)
6622{
6623 emlxs_port_t *port = &PPORT;
8699 *(iptr+7), *(iptr+8), *(iptr+9), *(iptr+10), *(iptr+11));
8700 }
8701 if (cnt > 12) {
8702 EMLXS_MSGF(EMLXS_CONTEXT, msg,
8703 "%s12: %08x %08x %08x %08x %08x %08x", str, *(iptr+12),
8704 *(iptr+13), *(iptr+14), *(iptr+15), *(iptr+16), *(iptr+17));
8705 }
8706 if (cnt > 18) {

--- 19 unchanged lines hidden (view full) ---

8726
8727} /* emlxs_data_dump() */
8728
8729
8730extern void
8731emlxs_ue_dump(emlxs_hba_t *hba, char *str)
8732{
8733 emlxs_port_t *port = &PPORT;
8734 uint32_t status;
6624 uint32_t ue_h;
6625 uint32_t ue_l;
6626 uint32_t on1;
6627 uint32_t on2;
6628
8735 uint32_t ue_h;
8736 uint32_t ue_l;
8737 uint32_t on1;
8738 uint32_t on2;
8739
6629 ue_l = ddi_get32(hba->pci_acc_handle,
6630 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_LO_OFFSET));
6631 ue_h = ddi_get32(hba->pci_acc_handle,
6632 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_HI_OFFSET));
6633 on1 = ddi_get32(hba->pci_acc_handle,
6634 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_ONLINE1));
6635 on2 = ddi_get32(hba->pci_acc_handle,
6636 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_ONLINE2));
8740 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
8741 case SLI_INTF_IF_TYPE_0:
8742 ue_l = ddi_get32(hba->pci_acc_handle,
8743 hba->sli.sli4.ERR1_reg_addr);
8744 ue_h = ddi_get32(hba->pci_acc_handle,
8745 hba->sli.sli4.ERR2_reg_addr);
6637
8746
6638 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6639 "%s: ueLow:%08x ueHigh:%08x on1:%08x on2:%08x", str,
6640 ue_l, ue_h, on1, on2);
8747 on1 = ddi_get32(hba->pci_acc_handle,
8748 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_ONLINE1));
8749 on2 = ddi_get32(hba->pci_acc_handle,
8750 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_ONLINE2));
6641
8751
8752 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8753 "%s: ueLow:%08x ueHigh:%08x on1:%08x on2:%08x", str,
8754 ue_l, ue_h, on1, on2);
8755 break;
8756
8757 case SLI_INTF_IF_TYPE_2:
8758 status = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8759 hba->sli.sli4.STATUS_reg_addr);
8760
8761 ue_l = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8762 hba->sli.sli4.ERR1_reg_addr);
8763 ue_h = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8764 hba->sli.sli4.ERR2_reg_addr);
8765
8766 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8767 "%s: status:%08x err1:%08x err2:%08x", str,
8768 status, ue_l, ue_h);
8769
8770 break;
8771 }
8772
6642#ifdef FMA_SUPPORT
6643 /* Access handle validation */
6644 EMLXS_CHK_ACC_HANDLE(hba, hba->pci_acc_handle);
6645#endif /* FMA_SUPPORT */
6646
6647} /* emlxs_ue_dump() */
6648
6649
6650static void
6651emlxs_sli4_poll_erratt(emlxs_hba_t *hba)
6652{
6653 emlxs_port_t *port = &PPORT;
8773#ifdef FMA_SUPPORT
8774 /* Access handle validation */
8775 EMLXS_CHK_ACC_HANDLE(hba, hba->pci_acc_handle);
8776#endif /* FMA_SUPPORT */
8777
8778} /* emlxs_ue_dump() */
8779
8780
8781static void
8782emlxs_sli4_poll_erratt(emlxs_hba_t *hba)
8783{
8784 emlxs_port_t *port = &PPORT;
8785 uint32_t status;
6654 uint32_t ue_h;
6655 uint32_t ue_l;
8786 uint32_t ue_h;
8787 uint32_t ue_l;
8788 uint32_t error = 0;
6656
6657 if (hba->flag & FC_HARDWARE_ERROR) {
6658 return;
6659 }
6660
8789
8790 if (hba->flag & FC_HARDWARE_ERROR) {
8791 return;
8792 }
8793
6661 ue_l = ddi_get32(hba->pci_acc_handle,
6662 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_LO_OFFSET));
6663 ue_h = ddi_get32(hba->pci_acc_handle,
6664 (uint32_t *)(hba->pci_addr + PCICFG_UE_STATUS_HI_OFFSET));
8794 switch (hba->sli_intf & SLI_INTF_IF_TYPE_MASK) {
8795 case SLI_INTF_IF_TYPE_0:
8796 ue_l = ddi_get32(hba->pci_acc_handle,
8797 hba->sli.sli4.ERR1_reg_addr);
8798 ue_h = ddi_get32(hba->pci_acc_handle,
8799 hba->sli.sli4.ERR2_reg_addr);
6665
8800
6666 if ((~hba->sli.sli4.ue_mask_lo & ue_l) ||
6667 (~hba->sli.sli4.ue_mask_hi & ue_h) ||
6668 (hba->sli.sli4.flag & EMLXS_SLI4_HW_ERROR)) {
6669 /* Unrecoverable error detected */
6670 /* Shut the HBA down */
6671 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_hardware_error_msg,
6672 "Host Error: ueLow:%08x ueHigh:%08x maskLow:%08x "
6673 "maskHigh:%08x",
6674 ue_l, ue_h, hba->sli.sli4.ue_mask_lo,
6675 hba->sli.sli4.ue_mask_hi);
8801 if ((~hba->sli.sli4.ue_mask_lo & ue_l) ||
8802 (~hba->sli.sli4.ue_mask_hi & ue_h) ||
8803 (hba->sli.sli4.flag & EMLXS_SLI4_HW_ERROR)) {
8804 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_hardware_error_msg,
8805 "Host Error: ueLow:%08x ueHigh:%08x maskLow:%08x "
8806 "maskHigh:%08x flag:%08x",
8807 ue_l, ue_h, hba->sli.sli4.ue_mask_lo,
8808 hba->sli.sli4.ue_mask_hi, hba->sli.sli4.flag);
6676
8809
8810 error = 2;
8811 }
8812 break;
8813
8814 case SLI_INTF_IF_TYPE_2:
8815 status = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8816 hba->sli.sli4.STATUS_reg_addr);
8817
8818 if ((status & SLI_STATUS_ERROR) ||
8819 (hba->sli.sli4.flag & EMLXS_SLI4_HW_ERROR)) {
8820 ue_l = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8821 hba->sli.sli4.ERR1_reg_addr);
8822 ue_h = ddi_get32(hba->sli.sli4.bar0_acc_handle,
8823 hba->sli.sli4.ERR2_reg_addr);
8824
8825 error = (status & SLI_STATUS_RESET_NEEDED)? 1:2;
8826
8827 if (error == 1) {
8828 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
8829 "Host Error: status:%08x err1:%08x "
8830 "err2:%08x flag:%08x",
8831 status, ue_l, ue_h, hba->sli.sli4.flag);
8832 } else {
8833 EMLXS_MSGF(EMLXS_CONTEXT,
8834 &emlxs_hardware_error_msg,
8835 "Host Error: status:%08x err1:%08x "
8836 "err2:%08x flag:%08x",
8837 status, ue_l, ue_h, hba->sli.sli4.flag);
8838 }
8839 }
8840 break;
8841 }
8842
8843 if (error == 2) {
6677 EMLXS_STATE_CHANGE(hba, FC_ERROR);
6678
6679 emlxs_sli4_hba_flush_chipq(hba);
6680
6681 emlxs_thread_spawn(hba, emlxs_shutdown_thread, 0, 0);
8844 EMLXS_STATE_CHANGE(hba, FC_ERROR);
8845
8846 emlxs_sli4_hba_flush_chipq(hba);
8847
8848 emlxs_thread_spawn(hba, emlxs_shutdown_thread, 0, 0);
8849
8850 } else if (error == 1) {
8851 EMLXS_STATE_CHANGE(hba, FC_ERROR);
8852
8853 emlxs_sli4_hba_flush_chipq(hba);
8854
8855 emlxs_thread_spawn(hba, emlxs_restart_thread, 0, 0);
6682 }
6683
8856 }
8857
8858#ifdef FMA_SUPPORT
8859 /* Access handle validation */
8860 EMLXS_CHK_ACC_HANDLE(hba, hba->pci_acc_handle);
8861#endif /* FMA_SUPPORT */
8862
6684} /* emlxs_sli4_poll_erratt() */
6685
6686
8863} /* emlxs_sli4_poll_erratt() */
8864
8865
6687extern uint32_t
8866static uint32_t
6688emlxs_sli4_reg_did(emlxs_port_t *port, uint32_t did, SERV_PARM *param,
6689 emlxs_buf_t *sbp, fc_unsol_buf_t *ubp, IOCBQ *iocbq)
6690{
6691 emlxs_hba_t *hba = HBA;
6692 NODELIST *node;
6693 RPIobj_t *rpip;
6694 uint32_t rval;
6695
6696 /* Check for invalid node ids to register */
6697 if ((did == 0) && (!(hba->flag & FC_LOOPBACK_MODE))) {
6698 return (1);
6699 }
6700
6701 if (did & 0xff000000) {
6702 return (1);
6703 }
6704
8867emlxs_sli4_reg_did(emlxs_port_t *port, uint32_t did, SERV_PARM *param,
8868 emlxs_buf_t *sbp, fc_unsol_buf_t *ubp, IOCBQ *iocbq)
8869{
8870 emlxs_hba_t *hba = HBA;
8871 NODELIST *node;
8872 RPIobj_t *rpip;
8873 uint32_t rval;
8874
8875 /* Check for invalid node ids to register */
8876 if ((did == 0) && (!(hba->flag & FC_LOOPBACK_MODE))) {
8877 return (1);
8878 }
8879
8880 if (did & 0xff000000) {
8881 return (1);
8882 }
8883
6705 if ((rval = emlxs_mb_check_sparm(hba, param))) {
6706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_node_create_failed_msg,
6707 "Invalid service parameters. did=%06x rval=%d", did,
6708 rval);
6709
8884 /* We don't register our own did */
8885 if ((did == port->did) && (!(hba->flag & FC_LOOPBACK_MODE))) {
6710 return (1);
6711 }
6712
8886 return (1);
8887 }
8888
8889 if (did != FABRIC_DID) {
8890 if ((rval = emlxs_mb_check_sparm(hba, param))) {
8891 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_node_create_failed_msg,
8892 "Invalid service parameters. did=%06x rval=%d", did,
8893 rval);
8894
8895 return (1);
8896 }
8897 }
8898
6713 /* Check if the node limit has been reached */
6714 if (port->node_count >= hba->max_nodes) {
6715 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_node_create_failed_msg,
6716 "Limit reached. did=%06x count=%d", did,
6717 port->node_count);
6718
6719 return (1);
6720 }
6721
8899 /* Check if the node limit has been reached */
8900 if (port->node_count >= hba->max_nodes) {
8901 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_node_create_failed_msg,
8902 "Limit reached. did=%06x count=%d", did,
8903 port->node_count);
8904
8905 return (1);
8906 }
8907
6722 node = emlxs_node_find_did(port, did);
8908 node = emlxs_node_find_did(port, did, 1);
6723 rpip = EMLXS_NODE_TO_RPI(port, node);
6724
6725 rval = emlxs_rpi_online_notify(port, rpip, did, param, (void *)sbp,
6726 (void *)ubp, (void *)iocbq);
6727
6728 return (rval);
6729
6730} /* emlxs_sli4_reg_did() */
6731
6732
8909 rpip = EMLXS_NODE_TO_RPI(port, node);
8910
8911 rval = emlxs_rpi_online_notify(port, rpip, did, param, (void *)sbp,
8912 (void *)ubp, (void *)iocbq);
8913
8914 return (rval);
8915
8916} /* emlxs_sli4_reg_did() */
8917
8918
6733extern uint32_t
8919static uint32_t
6734emlxs_sli4_unreg_node(emlxs_port_t *port, emlxs_node_t *node,
6735 emlxs_buf_t *sbp, fc_unsol_buf_t *ubp, IOCBQ *iocbq)
6736{
6737 RPIobj_t *rpip;
6738 uint32_t rval;
6739
6740 if (!node) {
6741 /* Unreg all nodes */

--- 18 unchanged lines hidden (view full) ---

6760
6761 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6762 "unreg_node:%p did=%x rpi=%d",
6763 node, node->nlp_DID, node->nlp_Rpi);
6764
6765 rpip = EMLXS_NODE_TO_RPI(port, node);
6766
6767 if (!rpip) {
8920emlxs_sli4_unreg_node(emlxs_port_t *port, emlxs_node_t *node,
8921 emlxs_buf_t *sbp, fc_unsol_buf_t *ubp, IOCBQ *iocbq)
8922{
8923 RPIobj_t *rpip;
8924 uint32_t rval;
8925
8926 if (!node) {
8927 /* Unreg all nodes */

--- 18 unchanged lines hidden (view full) ---

8946
8947 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
8948 "unreg_node:%p did=%x rpi=%d",
8949 node, node->nlp_DID, node->nlp_Rpi);
8950
8951 rpip = EMLXS_NODE_TO_RPI(port, node);
8952
8953 if (!rpip) {
6768 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_err_msg,
8954 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
6769 "unreg_node:%p did=%x rpi=%d. RPI not found.",
6770 node, node->nlp_DID, node->nlp_Rpi);
6771
6772 emlxs_node_rm(port, node);
6773 return (1);
6774 }
6775
6776 rval = emlxs_rpi_offline_notify(port, rpip, (void *)sbp, (void *)ubp,

--- 55 unchanged lines hidden (view full) ---

6832 }
6833
6834 (void) emlxs_sli4_unreg_node(port, nlp, 0, 0, 0);
6835 }
6836
6837 return (0);
6838
6839} /* emlxs_sli4_unreg_all_nodes() */
8955 "unreg_node:%p did=%x rpi=%d. RPI not found.",
8956 node, node->nlp_DID, node->nlp_Rpi);
8957
8958 emlxs_node_rm(port, node);
8959 return (1);
8960 }
8961
8962 rval = emlxs_rpi_offline_notify(port, rpip, (void *)sbp, (void *)ubp,

--- 55 unchanged lines hidden (view full) ---

9018 }
9019
9020 (void) emlxs_sli4_unreg_node(port, nlp, 0, 0, 0);
9021 }
9022
9023 return (0);
9024
9025} /* emlxs_sli4_unreg_all_nodes() */
9026
9027
9028static void
9029emlxs_sli4_handle_fcoe_link_event(emlxs_hba_t *hba, CQE_ASYNC_t *cqe)
9030{
9031 emlxs_port_t *port = &PPORT;
9032
9033 /* Handle link down */
9034 if ((cqe->un.link.link_status == ASYNC_EVENT_LOGICAL_LINK_DOWN) ||
9035 (cqe->un.link.link_status == ASYNC_EVENT_PHYS_LINK_DOWN)) {
9036 (void) emlxs_fcf_linkdown_notify(port);
9037
9038 mutex_enter(&EMLXS_PORT_LOCK);
9039 hba->sli.sli4.flag &= ~EMLXS_SLI4_DOWN_LINK;
9040 mutex_exit(&EMLXS_PORT_LOCK);
9041 return;
9042 }
9043
9044 /* Link is up */
9045
9046 /* Set linkspeed */
9047 switch (cqe->un.link.port_speed) {
9048 case PHY_1GHZ_LINK:
9049 hba->linkspeed = LA_1GHZ_LINK;
9050 break;
9051 case PHY_10GHZ_LINK:
9052 hba->linkspeed = LA_10GHZ_LINK;
9053 break;
9054 default:
9055 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
9056 "sli4_handle_fcoe_link_event: Unknown link speed=%x.",
9057 cqe->un.link.port_speed);
9058 hba->linkspeed = 0;
9059 break;
9060 }
9061
9062 /* Set qos_linkspeed */
9063 hba->qos_linkspeed = cqe->un.link.qos_link_speed;
9064
9065 /* Set topology */
9066 hba->topology = TOPOLOGY_PT_PT;
9067
9068 mutex_enter(&EMLXS_PORT_LOCK);
9069 hba->sli.sli4.flag &= ~EMLXS_SLI4_DOWN_LINK;
9070 mutex_exit(&EMLXS_PORT_LOCK);
9071
9072 (void) emlxs_fcf_linkup_notify(port);
9073
9074 return;
9075
9076} /* emlxs_sli4_handle_fcoe_link_event() */
9077
9078
9079static void
9080emlxs_sli4_handle_fc_link_att(emlxs_hba_t *hba, CQE_ASYNC_t *cqe)
9081{
9082 emlxs_port_t *port = &PPORT;
9083
9084 /* Handle link down */
9085 if (cqe->un.fc.att_type == ATT_TYPE_LINK_DOWN) {
9086 (void) emlxs_fcf_linkdown_notify(port);
9087
9088 mutex_enter(&EMLXS_PORT_LOCK);
9089 hba->sli.sli4.flag &= ~EMLXS_SLI4_DOWN_LINK;
9090 mutex_exit(&EMLXS_PORT_LOCK);
9091 return;
9092 }
9093
9094 /* Link is up */
9095
9096 /* Set linkspeed */
9097 switch (cqe->un.fc.port_speed) {
9098 case 1:
9099 hba->linkspeed = LA_1GHZ_LINK;
9100 break;
9101 case 2:
9102 hba->linkspeed = LA_2GHZ_LINK;
9103 break;
9104 case 4:
9105 hba->linkspeed = LA_4GHZ_LINK;
9106 break;
9107 case 8:
9108 hba->linkspeed = LA_8GHZ_LINK;
9109 break;
9110 case 10:
9111 hba->linkspeed = LA_10GHZ_LINK;
9112 break;
9113 case 16:
9114 hba->linkspeed = LA_16GHZ_LINK;
9115 break;
9116 default:
9117 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
9118 "sli4_handle_fc_link_att: Unknown link speed=%x.",
9119 cqe->un.fc.port_speed);
9120 hba->linkspeed = 0;
9121 break;
9122 }
9123
9124 /* Set qos_linkspeed */
9125 hba->qos_linkspeed = cqe->un.fc.link_speed;
9126
9127 /* Set topology */
9128 hba->topology = cqe->un.fc.topology;
9129
9130 mutex_enter(&EMLXS_PORT_LOCK);
9131 hba->sli.sli4.flag &= ~EMLXS_SLI4_DOWN_LINK;
9132 mutex_exit(&EMLXS_PORT_LOCK);
9133
9134 (void) emlxs_fcf_linkup_notify(port);
9135
9136 return;
9137
9138} /* emlxs_sli4_handle_fc_link_att() */
9139
9140
9141static int
9142emlxs_sli4_init_extents(emlxs_hba_t *hba, MAILBOXQ *mbq)
9143{
9144 emlxs_port_t *port = &PPORT;
9145 MAILBOX4 *mb4;
9146 IOCTL_COMMON_EXTENTS *ep;
9147 uint32_t i;
9148 uint32_t ExtentCnt;
9149
9150 if (!(hba->sli.sli4.param.EXT)) {
9151 return (0);
9152 }
9153
9154 mb4 = (MAILBOX4 *) mbq;
9155
9156 /* Discover XRI Extents */
9157 bzero(mbq, sizeof (MAILBOXQ));
9158 emlxs_mb_get_extents_info(hba, mbq, RSC_TYPE_FCOE_XRI);
9159
9160 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9161 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9162 "Unable to discover XRI extents. Mailbox cmd=%x status=%x",
9163 mb4->mbxCommand, mb4->mbxStatus);
9164
9165 return (EIO);
9166 }
9167
9168 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9169 hba->sli.sli4.XRIExtSize = ep->params.response.ExtentSize;
9170 ExtentCnt = ep->params.response.ExtentCnt;
9171
9172 /* Allocate XRI Extents */
9173 bzero(mbq, sizeof (MAILBOXQ));
9174 emlxs_mb_alloc_extents(hba, mbq, RSC_TYPE_FCOE_XRI, ExtentCnt);
9175
9176 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9177 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9178 "Unable to allocate XRI extents. Mailbox cmd=%x status=%x",
9179 mb4->mbxCommand, mb4->mbxStatus);
9180
9181 return (EIO);
9182 }
9183 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9184
9185 bcopy((uint8_t *)ep->params.response.RscId,
9186 (uint8_t *)hba->sli.sli4.XRIBase,
9187 (ep->params.response.ExtentCnt * sizeof (uint16_t)));
9188
9189 hba->sli.sli4.XRIExtCount = ep->params.response.ExtentCnt;
9190 hba->sli.sli4.XRICount = hba->sli.sli4.XRIExtCount *
9191 hba->sli.sli4.XRIExtSize;
9192
9193 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9194 "XRI Ext: size=%d cnt=%d/%d",
9195 hba->sli.sli4.XRIExtSize,
9196 hba->sli.sli4.XRIExtCount, ExtentCnt);
9197
9198 for (i = 0; i < ep->params.response.ExtentCnt; i += 4) {
9199 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9200 "XRI Ext%d: %d, %d, %d, %d", i,
9201 hba->sli.sli4.XRIBase[i],
9202 hba->sli.sli4.XRIBase[i+1],
9203 hba->sli.sli4.XRIBase[i+2],
9204 hba->sli.sli4.XRIBase[i+3]);
9205 }
9206
9207
9208 /* Discover RPI Extents */
9209 bzero(mbq, sizeof (MAILBOXQ));
9210 emlxs_mb_get_extents_info(hba, mbq, RSC_TYPE_FCOE_RPI);
9211
9212 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9213 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9214 "Unable to discover RPI extents. Mailbox cmd=%x status=%x",
9215 mb4->mbxCommand, mb4->mbxStatus);
9216
9217 return (EIO);
9218 }
9219
9220 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9221 hba->sli.sli4.RPIExtSize = ep->params.response.ExtentSize;
9222 ExtentCnt = ep->params.response.ExtentCnt;
9223
9224 /* Allocate RPI Extents */
9225 bzero(mbq, sizeof (MAILBOXQ));
9226 emlxs_mb_alloc_extents(hba, mbq, RSC_TYPE_FCOE_RPI, ExtentCnt);
9227
9228 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9229 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9230 "Unable to allocate RPI extents. Mailbox cmd=%x status=%x",
9231 mb4->mbxCommand, mb4->mbxStatus);
9232
9233 return (EIO);
9234 }
9235 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9236
9237 bcopy((uint8_t *)ep->params.response.RscId,
9238 (uint8_t *)hba->sli.sli4.RPIBase,
9239 (ep->params.response.ExtentCnt * sizeof (uint16_t)));
9240
9241 hba->sli.sli4.RPIExtCount = ep->params.response.ExtentCnt;
9242 hba->sli.sli4.RPICount = hba->sli.sli4.RPIExtCount *
9243 hba->sli.sli4.RPIExtSize;
9244
9245 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9246 "RPI Ext: size=%d cnt=%d/%d",
9247 hba->sli.sli4.RPIExtSize,
9248 hba->sli.sli4.RPIExtCount, ExtentCnt);
9249
9250 for (i = 0; i < ep->params.response.ExtentCnt; i += 4) {
9251 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9252 "RPI Ext%d: %d, %d, %d, %d", i,
9253 hba->sli.sli4.RPIBase[i],
9254 hba->sli.sli4.RPIBase[i+1],
9255 hba->sli.sli4.RPIBase[i+2],
9256 hba->sli.sli4.RPIBase[i+3]);
9257 }
9258
9259
9260 /* Discover VPI Extents */
9261 bzero(mbq, sizeof (MAILBOXQ));
9262 emlxs_mb_get_extents_info(hba, mbq, RSC_TYPE_FCOE_VPI);
9263
9264 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9265 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9266 "Unable to discover VPI extents. Mailbox cmd=%x status=%x",
9267 mb4->mbxCommand, mb4->mbxStatus);
9268
9269 return (EIO);
9270 }
9271
9272 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9273 hba->sli.sli4.VPIExtSize = ep->params.response.ExtentSize;
9274 ExtentCnt = ep->params.response.ExtentCnt;
9275
9276 /* Allocate VPI Extents */
9277 bzero(mbq, sizeof (MAILBOXQ));
9278 emlxs_mb_alloc_extents(hba, mbq, RSC_TYPE_FCOE_VPI, ExtentCnt);
9279
9280 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9281 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9282 "Unable to allocate VPI extents. Mailbox cmd=%x status=%x",
9283 mb4->mbxCommand, mb4->mbxStatus);
9284
9285 return (EIO);
9286 }
9287 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9288
9289 bcopy((uint8_t *)ep->params.response.RscId,
9290 (uint8_t *)hba->sli.sli4.VPIBase,
9291 (ep->params.response.ExtentCnt * sizeof (uint16_t)));
9292
9293 hba->sli.sli4.VPIExtCount = ep->params.response.ExtentCnt;
9294 hba->sli.sli4.VPICount = hba->sli.sli4.VPIExtCount *
9295 hba->sli.sli4.VPIExtSize;
9296
9297 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9298 "VPI Ext: size=%d cnt=%d/%d",
9299 hba->sli.sli4.VPIExtSize,
9300 hba->sli.sli4.VPIExtCount, ExtentCnt);
9301
9302 for (i = 0; i < ep->params.response.ExtentCnt; i += 4) {
9303 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9304 "VPI Ext%d: %d, %d, %d, %d", i,
9305 hba->sli.sli4.VPIBase[i],
9306 hba->sli.sli4.VPIBase[i+1],
9307 hba->sli.sli4.VPIBase[i+2],
9308 hba->sli.sli4.VPIBase[i+3]);
9309 }
9310
9311 /* Discover VFI Extents */
9312 bzero(mbq, sizeof (MAILBOXQ));
9313 emlxs_mb_get_extents_info(hba, mbq, RSC_TYPE_FCOE_VFI);
9314
9315 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9316 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9317 "Unable to discover VFI extents. Mailbox cmd=%x status=%x",
9318 mb4->mbxCommand, mb4->mbxStatus);
9319
9320 return (EIO);
9321 }
9322
9323 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9324 hba->sli.sli4.VFIExtSize = ep->params.response.ExtentSize;
9325 ExtentCnt = ep->params.response.ExtentCnt;
9326
9327 /* Allocate VFI Extents */
9328 bzero(mbq, sizeof (MAILBOXQ));
9329 emlxs_mb_alloc_extents(hba, mbq, RSC_TYPE_FCOE_VFI, ExtentCnt);
9330
9331 if (emlxs_sli4_issue_mbox_cmd(hba, mbq, MBX_WAIT, 0) != MBX_SUCCESS) {
9332 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
9333 "Unable to allocate VFI extents. Mailbox cmd=%x status=%x",
9334 mb4->mbxCommand, mb4->mbxStatus);
9335
9336 return (EIO);
9337 }
9338 ep = (IOCTL_COMMON_EXTENTS *)&mb4->un.varSLIConfig.payload;
9339
9340 bcopy((uint8_t *)ep->params.response.RscId,
9341 (uint8_t *)hba->sli.sli4.VFIBase,
9342 (ep->params.response.ExtentCnt * sizeof (uint16_t)));
9343
9344 hba->sli.sli4.VFIExtCount = ep->params.response.ExtentCnt;
9345 hba->sli.sli4.VFICount = hba->sli.sli4.VFIExtCount *
9346 hba->sli.sli4.VFIExtSize;
9347
9348 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9349 "VFI Ext: size=%d cnt=%d/%d",
9350 hba->sli.sli4.VFIExtSize,
9351 hba->sli.sli4.VFIExtCount, ExtentCnt);
9352
9353 for (i = 0; i < ep->params.response.ExtentCnt; i += 4) {
9354 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
9355 "VFI Ext%d: %d, %d, %d, %d", i,
9356 hba->sli.sli4.VFIBase[i],
9357 hba->sli.sli4.VFIBase[i+1],
9358 hba->sli.sli4.VFIBase[i+2],
9359 hba->sli.sli4.VFIBase[i+3]);
9360 }
9361
9362 return (0);
9363
9364} /* emlxs_sli4_init_extents() */
9365
9366
9367extern uint32_t
9368emlxs_sli4_index_to_rpi(emlxs_hba_t *hba, uint32_t index)
9369{
9370 uint32_t i;
9371 uint32_t j;
9372 uint32_t rpi;
9373
9374 i = index / hba->sli.sli4.RPIExtSize;
9375 j = index % hba->sli.sli4.RPIExtSize;
9376 rpi = hba->sli.sli4.RPIBase[i] + j;
9377
9378 return (rpi);
9379
9380} /* emlxs_sli4_index_to_rpi */
9381
9382
9383extern uint32_t
9384emlxs_sli4_rpi_to_index(emlxs_hba_t *hba, uint32_t rpi)
9385{
9386 uint32_t i;
9387 uint32_t lo;
9388 uint32_t hi;
9389 uint32_t index = hba->sli.sli4.RPICount;
9390
9391 for (i = 0; i < hba->sli.sli4.RPIExtCount; i++) {
9392 lo = hba->sli.sli4.RPIBase[i];
9393 hi = lo + hba->sli.sli4.RPIExtSize;
9394
9395 if ((rpi < hi) && (rpi >= lo)) {
9396 index = (i * hba->sli.sli4.RPIExtSize) + (rpi - lo);
9397 break;
9398 }
9399 }
9400
9401 return (index);
9402
9403} /* emlxs_sli4_rpi_to_index */
9404
9405
9406extern uint32_t
9407emlxs_sli4_index_to_xri(emlxs_hba_t *hba, uint32_t index)
9408{
9409 uint32_t i;
9410 uint32_t j;
9411 uint32_t xri;
9412
9413 i = index / hba->sli.sli4.XRIExtSize;
9414 j = index % hba->sli.sli4.XRIExtSize;
9415 xri = hba->sli.sli4.XRIBase[i] + j;
9416
9417 return (xri);
9418
9419} /* emlxs_sli4_index_to_xri */
9420
9421
9422
9423
9424extern uint32_t
9425emlxs_sli4_index_to_vpi(emlxs_hba_t *hba, uint32_t index)
9426{
9427 uint32_t i;
9428 uint32_t j;
9429 uint32_t vpi;
9430
9431 i = index / hba->sli.sli4.VPIExtSize;
9432 j = index % hba->sli.sli4.VPIExtSize;
9433 vpi = hba->sli.sli4.VPIBase[i] + j;
9434
9435 return (vpi);
9436
9437} /* emlxs_sli4_index_to_vpi */
9438
9439
9440extern uint32_t
9441emlxs_sli4_vpi_to_index(emlxs_hba_t *hba, uint32_t vpi)
9442{
9443 uint32_t i;
9444 uint32_t lo;
9445 uint32_t hi;
9446 uint32_t index = hba->sli.sli4.VPICount;
9447
9448 for (i = 0; i < hba->sli.sli4.VPIExtCount; i++) {
9449 lo = hba->sli.sli4.VPIBase[i];
9450 hi = lo + hba->sli.sli4.VPIExtSize;
9451
9452 if ((vpi < hi) && (vpi >= lo)) {
9453 index = (i * hba->sli.sli4.VPIExtSize) + (vpi - lo);
9454 break;
9455 }
9456 }
9457
9458 return (index);
9459
9460} /* emlxs_sli4_vpi_to_index */
9461
9462
9463
9464
9465extern uint32_t
9466emlxs_sli4_index_to_vfi(emlxs_hba_t *hba, uint32_t index)
9467{
9468 uint32_t i;
9469 uint32_t j;
9470 uint32_t vfi;
9471
9472 i = index / hba->sli.sli4.VFIExtSize;
9473 j = index % hba->sli.sli4.VFIExtSize;
9474 vfi = hba->sli.sli4.VFIBase[i] + j;
9475
9476 return (vfi);
9477
9478} /* emlxs_sli4_index_to_vfi */
9479
9480
9481static uint16_t
9482emlxs_sli4_rqid_to_index(emlxs_hba_t *hba, uint16_t rqid)
9483{
9484 uint16_t i;
9485
9486 if (rqid < 0xffff) {
9487 for (i = 0; i < EMLXS_MAX_RQS; i++) {
9488 if (hba->sli.sli4.rq[i].qid == rqid) {
9489 return (i);
9490 }
9491 }
9492 }
9493
9494 return (0xffff);
9495
9496} /* emlxs_sli4_rqid_to_index */
9497
9498
9499static uint16_t
9500emlxs_sli4_wqid_to_index(emlxs_hba_t *hba, uint16_t wqid)
9501{
9502 uint16_t i;
9503
9504 if (wqid < 0xffff) {
9505 for (i = 0; i < EMLXS_MAX_WQS; i++) {
9506 if (hba->sli.sli4.wq[i].qid == wqid) {
9507 return (i);
9508 }
9509 }
9510 }
9511
9512 return (0xffff);
9513
9514} /* emlxs_sli4_wqid_to_index */
9515
9516
9517static uint16_t
9518emlxs_sli4_cqid_to_index(emlxs_hba_t *hba, uint16_t cqid)
9519{
9520 uint16_t i;
9521
9522 if (cqid < 0xffff) {
9523 for (i = 0; i < EMLXS_MAX_CQS; i++) {
9524 if (hba->sli.sli4.cq[i].qid == cqid) {
9525 return (i);
9526 }
9527 }
9528 }
9529
9530 return (0xffff);
9531
9532} /* emlxs_sli4_cqid_to_index */