1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Marvell Fibre Channel HBA Driver
4  * Copyright (c)  2021     Marvell
5  */
6 #include "qla_def.h"
7 #include "qla_edif.h"
8 
9 #include <linux/kthread.h>
10 #include <linux/vmalloc.h>
11 #include <linux/delay.h>
12 #include <scsi/scsi_tcq.h>
13 
14 static struct edif_sa_index_entry *qla_edif_sadb_find_sa_index_entry(uint16_t nport_handle,
15 		struct list_head *sa_list);
16 static uint16_t qla_edif_sadb_get_sa_index(fc_port_t *fcport,
17 		struct qla_sa_update_frame *sa_frame);
18 static int qla_edif_sadb_delete_sa_index(fc_port_t *fcport, uint16_t nport_handle,
19 		uint16_t sa_index);
20 static int qla_pur_get_pending(scsi_qla_host_t *, fc_port_t *, struct bsg_job *);
21 
22 struct edb_node {
23 	struct  list_head	list;
24 	uint32_t		ntype;
25 	union {
26 		port_id_t	plogi_did;
27 		uint32_t	async;
28 		port_id_t	els_sid;
29 		struct edif_sa_update_aen	sa_aen;
30 	} u;
31 };
32 
33 static struct els_sub_cmd {
34 	uint16_t cmd;
35 	const char *str;
36 } sc_str[] = {
37 	{SEND_ELS, "send ELS"},
38 	{SEND_ELS_REPLY, "send ELS Reply"},
39 	{PULL_ELS, "retrieve ELS"},
40 };
41 
sc_to_str(uint16_t cmd)42 const char *sc_to_str(uint16_t cmd)
43 {
44 	int i;
45 	struct els_sub_cmd *e;
46 
47 	for (i = 0; i < ARRAY_SIZE(sc_str); i++) {
48 		e = sc_str + i;
49 		if (cmd == e->cmd)
50 			return e->str;
51 	}
52 	return "unknown";
53 }
54 
qla_edb_getnext(scsi_qla_host_t * vha)55 static struct edb_node *qla_edb_getnext(scsi_qla_host_t *vha)
56 {
57 	unsigned long   flags;
58 	struct edb_node *edbnode = NULL;
59 
60 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
61 
62 	/* db nodes are fifo - no qualifications done */
63 	if (!list_empty(&vha->e_dbell.head)) {
64 		edbnode = list_first_entry(&vha->e_dbell.head,
65 					   struct edb_node, list);
66 		list_del_init(&edbnode->list);
67 	}
68 
69 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
70 
71 	return edbnode;
72 }
73 
qla_edb_node_free(scsi_qla_host_t * vha,struct edb_node * node)74 static void qla_edb_node_free(scsi_qla_host_t *vha, struct edb_node *node)
75 {
76 	list_del_init(&node->list);
77 	kfree(node);
78 }
79 
qla_edif_list_find_sa_index(fc_port_t * fcport,uint16_t handle)80 static struct edif_list_entry *qla_edif_list_find_sa_index(fc_port_t *fcport,
81 		uint16_t handle)
82 {
83 	struct edif_list_entry *entry;
84 	struct edif_list_entry *tentry;
85 	struct list_head *indx_list = &fcport->edif.edif_indx_list;
86 
87 	list_for_each_entry_safe(entry, tentry, indx_list, next) {
88 		if (entry->handle == handle)
89 			return entry;
90 	}
91 	return NULL;
92 }
93 
94 /* timeout called when no traffic and delayed rx sa_index delete */
qla2x00_sa_replace_iocb_timeout(struct timer_list * t)95 static void qla2x00_sa_replace_iocb_timeout(struct timer_list *t)
96 {
97 	struct edif_list_entry *edif_entry = from_timer(edif_entry, t, timer);
98 	fc_port_t *fcport = edif_entry->fcport;
99 	struct scsi_qla_host *vha = fcport->vha;
100 	struct  edif_sa_ctl *sa_ctl;
101 	uint16_t nport_handle;
102 	unsigned long flags = 0;
103 
104 	ql_dbg(ql_dbg_edif, vha, 0x3069,
105 	    "%s:  nport_handle 0x%x,  SA REPL Delay Timeout, %8phC portid=%06x\n",
106 	    __func__, edif_entry->handle, fcport->port_name, fcport->d_id.b24);
107 
108 	/*
109 	 * if delete_sa_index is valid then no one has serviced this
110 	 * delayed delete
111 	 */
112 	spin_lock_irqsave(&fcport->edif.indx_list_lock, flags);
113 
114 	/*
115 	 * delete_sa_index is invalidated when we find the new sa_index in
116 	 * the incoming data stream.  If it is not invalidated then we are
117 	 * still looking for the new sa_index because there is no I/O and we
118 	 * need to just force the rx delete and move on.  Otherwise
119 	 * we could get another rekey which will result in an error 66.
120 	 */
121 	if (edif_entry->delete_sa_index != INVALID_EDIF_SA_INDEX) {
122 		uint16_t delete_sa_index = edif_entry->delete_sa_index;
123 
124 		edif_entry->delete_sa_index = INVALID_EDIF_SA_INDEX;
125 		nport_handle = edif_entry->handle;
126 		spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
127 
128 		sa_ctl = qla_edif_find_sa_ctl_by_index(fcport,
129 		    delete_sa_index, 0);
130 
131 		if (sa_ctl) {
132 			ql_dbg(ql_dbg_edif, vha, 0x3063,
133 			    "%s: sa_ctl: %p, delete index %d, update index: %d, lid: 0x%x\n",
134 			    __func__, sa_ctl, delete_sa_index, edif_entry->update_sa_index,
135 			    nport_handle);
136 
137 			sa_ctl->flags = EDIF_SA_CTL_FLG_DEL;
138 			set_bit(EDIF_SA_CTL_REPL, &sa_ctl->state);
139 			qla_post_sa_replace_work(fcport->vha, fcport,
140 			    nport_handle, sa_ctl);
141 
142 		} else {
143 			ql_dbg(ql_dbg_edif, vha, 0x3063,
144 			    "%s: sa_ctl not found for delete_sa_index: %d\n",
145 			    __func__, edif_entry->delete_sa_index);
146 		}
147 	} else {
148 		spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
149 	}
150 }
151 
152 /*
153  * create a new list entry for this nport handle and
154  * add an sa_update index to the list - called for sa_update
155  */
qla_edif_list_add_sa_update_index(fc_port_t * fcport,uint16_t sa_index,uint16_t handle)156 static int qla_edif_list_add_sa_update_index(fc_port_t *fcport,
157 		uint16_t sa_index, uint16_t handle)
158 {
159 	struct edif_list_entry *entry;
160 	unsigned long flags = 0;
161 
162 	/* if the entry exists, then just update the sa_index */
163 	entry = qla_edif_list_find_sa_index(fcport, handle);
164 	if (entry) {
165 		entry->update_sa_index = sa_index;
166 		entry->count = 0;
167 		return 0;
168 	}
169 
170 	/*
171 	 * This is the normal path - there should be no existing entry
172 	 * when update is called.  The exception is at startup
173 	 * when update is called for the first two sa_indexes
174 	 * followed by a delete of the first sa_index
175 	 */
176 	entry = kzalloc((sizeof(struct edif_list_entry)), GFP_ATOMIC);
177 	if (!entry)
178 		return -ENOMEM;
179 
180 	INIT_LIST_HEAD(&entry->next);
181 	entry->handle = handle;
182 	entry->update_sa_index = sa_index;
183 	entry->delete_sa_index = INVALID_EDIF_SA_INDEX;
184 	entry->count = 0;
185 	entry->flags = 0;
186 	timer_setup(&entry->timer, qla2x00_sa_replace_iocb_timeout, 0);
187 	spin_lock_irqsave(&fcport->edif.indx_list_lock, flags);
188 	list_add_tail(&entry->next, &fcport->edif.edif_indx_list);
189 	spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
190 	return 0;
191 }
192 
193 /* remove an entry from the list */
qla_edif_list_delete_sa_index(fc_port_t * fcport,struct edif_list_entry * entry)194 static void qla_edif_list_delete_sa_index(fc_port_t *fcport, struct edif_list_entry *entry)
195 {
196 	unsigned long flags = 0;
197 
198 	spin_lock_irqsave(&fcport->edif.indx_list_lock, flags);
199 	list_del(&entry->next);
200 	spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
201 }
202 
qla_post_sa_replace_work(struct scsi_qla_host * vha,fc_port_t * fcport,uint16_t nport_handle,struct edif_sa_ctl * sa_ctl)203 int qla_post_sa_replace_work(struct scsi_qla_host *vha,
204 	 fc_port_t *fcport, uint16_t nport_handle, struct edif_sa_ctl *sa_ctl)
205 {
206 	struct qla_work_evt *e;
207 
208 	e = qla2x00_alloc_work(vha, QLA_EVT_SA_REPLACE);
209 	if (!e)
210 		return QLA_FUNCTION_FAILED;
211 
212 	e->u.sa_update.fcport = fcport;
213 	e->u.sa_update.sa_ctl = sa_ctl;
214 	e->u.sa_update.nport_handle = nport_handle;
215 	fcport->flags |= FCF_ASYNC_ACTIVE;
216 	return qla2x00_post_work(vha, e);
217 }
218 
219 static void
qla_edif_sa_ctl_init(scsi_qla_host_t * vha,struct fc_port * fcport)220 qla_edif_sa_ctl_init(scsi_qla_host_t *vha, struct fc_port  *fcport)
221 {
222 	ql_dbg(ql_dbg_edif, vha, 0x2058,
223 	    "Init SA_CTL List for fcport - nn %8phN pn %8phN portid=%06x.\n",
224 	    fcport->node_name, fcport->port_name, fcport->d_id.b24);
225 
226 	fcport->edif.tx_rekey_cnt = 0;
227 	fcport->edif.rx_rekey_cnt = 0;
228 
229 	fcport->edif.tx_bytes = 0;
230 	fcport->edif.rx_bytes = 0;
231 }
232 
qla_bsg_check(scsi_qla_host_t * vha,struct bsg_job * bsg_job,fc_port_t * fcport)233 static int qla_bsg_check(scsi_qla_host_t *vha, struct bsg_job *bsg_job,
234 fc_port_t *fcport)
235 {
236 	struct extra_auth_els *p;
237 	struct fc_bsg_reply *bsg_reply = bsg_job->reply;
238 	struct qla_bsg_auth_els_request *req =
239 	    (struct qla_bsg_auth_els_request *)bsg_job->request;
240 
241 	if (!vha->hw->flags.edif_enabled) {
242 		ql_dbg(ql_dbg_edif, vha, 0x9105,
243 		    "%s edif not enabled\n", __func__);
244 		goto done;
245 	}
246 	if (DBELL_INACTIVE(vha)) {
247 		ql_dbg(ql_dbg_edif, vha, 0x09102,
248 		    "%s doorbell not enabled\n", __func__);
249 		goto done;
250 	}
251 
252 	p = &req->e;
253 
254 	/* Get response */
255 	if (p->sub_cmd == PULL_ELS) {
256 		struct qla_bsg_auth_els_reply *rpl =
257 			(struct qla_bsg_auth_els_reply *)bsg_job->reply;
258 
259 		qla_pur_get_pending(vha, fcport, bsg_job);
260 
261 		ql_dbg(ql_dbg_edif, vha, 0x911d,
262 			"%s %s %8phN sid=%x. xchg %x, nb=%xh bsg ptr %p\n",
263 			__func__, sc_to_str(p->sub_cmd), fcport->port_name,
264 			fcport->d_id.b24, rpl->rx_xchg_address,
265 			rpl->r.reply_payload_rcv_len, bsg_job);
266 
267 		goto done;
268 	}
269 	return 0;
270 
271 done:
272 
273 	bsg_job_done(bsg_job, bsg_reply->result,
274 			bsg_reply->reply_payload_rcv_len);
275 	return -EIO;
276 }
277 
278 fc_port_t *
qla2x00_find_fcport_by_pid(scsi_qla_host_t * vha,port_id_t * id)279 qla2x00_find_fcport_by_pid(scsi_qla_host_t *vha, port_id_t *id)
280 {
281 	fc_port_t *f, *tf;
282 
283 	f = NULL;
284 	list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
285 		if (f->d_id.b24 == id->b24)
286 			return f;
287 	}
288 	return NULL;
289 }
290 
291 /**
292  * qla_edif_app_check(): check for valid application id.
293  * @vha: host adapter pointer
294  * @appid: application id
295  * Return: false = fail, true = pass
296  */
297 static bool
qla_edif_app_check(scsi_qla_host_t * vha,struct app_id appid)298 qla_edif_app_check(scsi_qla_host_t *vha, struct app_id appid)
299 {
300 	/* check that the app is allow/known to the driver */
301 
302 	if (appid.app_vid != EDIF_APP_ID) {
303 		ql_dbg(ql_dbg_edif, vha, 0x911d, "%s app id not ok (%x)",
304 		    __func__, appid.app_vid);
305 		return false;
306 	}
307 
308 	if (appid.version != EDIF_VERSION1) {
309 		ql_dbg(ql_dbg_edif, vha, 0x911d, "%s app version is not ok (%x)",
310 		    __func__, appid.version);
311 		return false;
312 	}
313 
314 	return true;
315 }
316 
317 static void
qla_edif_free_sa_ctl(fc_port_t * fcport,struct edif_sa_ctl * sa_ctl,int index)318 qla_edif_free_sa_ctl(fc_port_t *fcport, struct edif_sa_ctl *sa_ctl,
319 	int index)
320 {
321 	unsigned long flags = 0;
322 
323 	spin_lock_irqsave(&fcport->edif.sa_list_lock, flags);
324 	list_del(&sa_ctl->next);
325 	spin_unlock_irqrestore(&fcport->edif.sa_list_lock, flags);
326 	if (index >= 512)
327 		fcport->edif.tx_rekey_cnt--;
328 	else
329 		fcport->edif.rx_rekey_cnt--;
330 	kfree(sa_ctl);
331 }
332 
333 /* return an index to the freepool */
qla_edif_add_sa_index_to_freepool(fc_port_t * fcport,int dir,uint16_t sa_index)334 static void qla_edif_add_sa_index_to_freepool(fc_port_t *fcport, int dir,
335 		uint16_t sa_index)
336 {
337 	void *sa_id_map;
338 	struct scsi_qla_host *vha = fcport->vha;
339 	struct qla_hw_data *ha = vha->hw;
340 	unsigned long flags = 0;
341 	u16 lsa_index = sa_index;
342 
343 	ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x3063,
344 	    "%s: entry\n", __func__);
345 
346 	if (dir) {
347 		sa_id_map = ha->edif_tx_sa_id_map;
348 		lsa_index -= EDIF_TX_SA_INDEX_BASE;
349 	} else {
350 		sa_id_map = ha->edif_rx_sa_id_map;
351 	}
352 
353 	spin_lock_irqsave(&ha->sadb_fp_lock, flags);
354 	clear_bit(lsa_index, sa_id_map);
355 	spin_unlock_irqrestore(&ha->sadb_fp_lock, flags);
356 	ql_dbg(ql_dbg_edif, vha, 0x3063,
357 	    "%s: index %d added to free pool\n", __func__, sa_index);
358 }
359 
__qla2x00_release_all_sadb(struct scsi_qla_host * vha,struct fc_port * fcport,struct edif_sa_index_entry * entry,int pdir)360 static void __qla2x00_release_all_sadb(struct scsi_qla_host *vha,
361 	struct fc_port *fcport, struct edif_sa_index_entry *entry,
362 	int pdir)
363 {
364 	struct edif_list_entry *edif_entry;
365 	struct  edif_sa_ctl *sa_ctl;
366 	int i, dir;
367 	int key_cnt = 0;
368 
369 	for (i = 0; i < 2; i++) {
370 		if (entry->sa_pair[i].sa_index == INVALID_EDIF_SA_INDEX)
371 			continue;
372 
373 		if (fcport->loop_id != entry->handle) {
374 			ql_dbg(ql_dbg_edif, vha, 0x3063,
375 			    "%s: ** WARNING %d** entry handle: 0x%x, lid: 0x%x, sa_index: %d\n",
376 			    __func__, i, entry->handle, fcport->loop_id,
377 			    entry->sa_pair[i].sa_index);
378 		}
379 
380 		/* release the sa_ctl */
381 		sa_ctl = qla_edif_find_sa_ctl_by_index(fcport,
382 				entry->sa_pair[i].sa_index, pdir);
383 		if (sa_ctl &&
384 		    qla_edif_find_sa_ctl_by_index(fcport, sa_ctl->index, pdir)) {
385 			ql_dbg(ql_dbg_edif, vha, 0x3063,
386 			    "%s: freeing sa_ctl for index %d\n", __func__, sa_ctl->index);
387 			qla_edif_free_sa_ctl(fcport, sa_ctl, sa_ctl->index);
388 		} else {
389 			ql_dbg(ql_dbg_edif, vha, 0x3063,
390 			    "%s: sa_ctl NOT freed, sa_ctl: %p\n", __func__, sa_ctl);
391 		}
392 
393 		/* Release the index */
394 		ql_dbg(ql_dbg_edif, vha, 0x3063,
395 			"%s: freeing sa_index %d, nph: 0x%x\n",
396 			__func__, entry->sa_pair[i].sa_index, entry->handle);
397 
398 		dir = (entry->sa_pair[i].sa_index <
399 			EDIF_TX_SA_INDEX_BASE) ? 0 : 1;
400 		qla_edif_add_sa_index_to_freepool(fcport, dir,
401 			entry->sa_pair[i].sa_index);
402 
403 		/* Delete timer on RX */
404 		if (pdir != SAU_FLG_TX) {
405 			edif_entry =
406 				qla_edif_list_find_sa_index(fcport, entry->handle);
407 			if (edif_entry) {
408 				ql_dbg(ql_dbg_edif, vha, 0x5033,
409 				    "%s: remove edif_entry %p, update_sa_index: 0x%x, delete_sa_index: 0x%x\n",
410 				    __func__, edif_entry, edif_entry->update_sa_index,
411 				    edif_entry->delete_sa_index);
412 				qla_edif_list_delete_sa_index(fcport, edif_entry);
413 				/*
414 				 * valid delete_sa_index indicates there is a rx
415 				 * delayed delete queued
416 				 */
417 				if (edif_entry->delete_sa_index !=
418 						INVALID_EDIF_SA_INDEX) {
419 					del_timer(&edif_entry->timer);
420 
421 					/* build and send the aen */
422 					fcport->edif.rx_sa_set = 1;
423 					fcport->edif.rx_sa_pending = 0;
424 					qla_edb_eventcreate(vha,
425 							VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
426 							QL_VND_SA_STAT_SUCCESS,
427 							QL_VND_RX_SA_KEY, fcport);
428 				}
429 				ql_dbg(ql_dbg_edif, vha, 0x5033,
430 				    "%s: release edif_entry %p, update_sa_index: 0x%x, delete_sa_index: 0x%x\n",
431 				    __func__, edif_entry, edif_entry->update_sa_index,
432 				    edif_entry->delete_sa_index);
433 
434 				kfree(edif_entry);
435 			}
436 		}
437 		key_cnt++;
438 	}
439 	ql_dbg(ql_dbg_edif, vha, 0x3063,
440 	    "%s: %d %s keys released\n",
441 	    __func__, key_cnt, pdir ? "tx" : "rx");
442 }
443 
444 /* find an release all outstanding sadb sa_indicies */
qla2x00_release_all_sadb(struct scsi_qla_host * vha,struct fc_port * fcport)445 void qla2x00_release_all_sadb(struct scsi_qla_host *vha, struct fc_port *fcport)
446 {
447 	struct edif_sa_index_entry *entry, *tmp;
448 	struct qla_hw_data *ha = vha->hw;
449 	unsigned long flags;
450 
451 	ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x3063,
452 	    "%s: Starting...\n", __func__);
453 
454 	spin_lock_irqsave(&ha->sadb_lock, flags);
455 
456 	list_for_each_entry_safe(entry, tmp, &ha->sadb_rx_index_list, next) {
457 		if (entry->fcport == fcport) {
458 			list_del(&entry->next);
459 			spin_unlock_irqrestore(&ha->sadb_lock, flags);
460 			__qla2x00_release_all_sadb(vha, fcport, entry, 0);
461 			kfree(entry);
462 			spin_lock_irqsave(&ha->sadb_lock, flags);
463 			break;
464 		}
465 	}
466 
467 	list_for_each_entry_safe(entry, tmp, &ha->sadb_tx_index_list, next) {
468 		if (entry->fcport == fcport) {
469 			list_del(&entry->next);
470 			spin_unlock_irqrestore(&ha->sadb_lock, flags);
471 
472 			__qla2x00_release_all_sadb(vha, fcport, entry, SAU_FLG_TX);
473 
474 			kfree(entry);
475 			spin_lock_irqsave(&ha->sadb_lock, flags);
476 			break;
477 		}
478 	}
479 	spin_unlock_irqrestore(&ha->sadb_lock, flags);
480 }
481 
482 /**
483  * qla_edif_app_start:  application has announce its present
484  * @vha: host adapter pointer
485  * @bsg_job: user request
486  *
487  * Set/activate doorbell.  Reset current sessions and re-login with
488  * secure flag.
489  */
490 static int
qla_edif_app_start(scsi_qla_host_t * vha,struct bsg_job * bsg_job)491 qla_edif_app_start(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
492 {
493 	int32_t			rval = 0;
494 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
495 	struct app_start	appstart;
496 	struct app_start_reply	appreply;
497 	struct fc_port  *fcport, *tf;
498 
499 	ql_log(ql_log_info, vha, 0x1313,
500 	       "EDIF application registration with driver, FC device connections will be re-established.\n");
501 
502 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
503 	    bsg_job->request_payload.sg_cnt, &appstart,
504 	    sizeof(struct app_start));
505 
506 	ql_dbg(ql_dbg_edif, vha, 0x911d, "%s app_vid=%x app_start_flags %x\n",
507 	     __func__, appstart.app_info.app_vid, appstart.app_start_flags);
508 
509 	if (DBELL_INACTIVE(vha)) {
510 		/* mark doorbell as active since an app is now present */
511 		vha->e_dbell.db_flags |= EDB_ACTIVE;
512 	} else {
513 		goto out;
514 	}
515 
516 	if (N2N_TOPO(vha->hw)) {
517 		list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list)
518 			fcport->n2n_link_reset_cnt = 0;
519 
520 		if (vha->hw->flags.n2n_fw_acc_sec) {
521 			list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list)
522 				qla_edif_sa_ctl_init(vha, fcport);
523 
524 			/*
525 			 * While authentication app was not running, remote device
526 			 * could still try to login with this local port.  Let's
527 			 * clear the state and try again.
528 			 */
529 			qla2x00_wait_for_sess_deletion(vha);
530 
531 			/* bounce the link to get the other guy to relogin */
532 			if (!vha->hw->flags.n2n_bigger) {
533 				set_bit(N2N_LINK_RESET, &vha->dpc_flags);
534 				qla2xxx_wake_dpc(vha);
535 			}
536 		} else {
537 			qla2x00_wait_for_hba_online(vha);
538 			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
539 			qla2xxx_wake_dpc(vha);
540 			qla2x00_wait_for_hba_online(vha);
541 		}
542 	} else {
543 		list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list) {
544 			ql_dbg(ql_dbg_edif, vha, 0x2058,
545 			       "FCSP - nn %8phN pn %8phN portid=%06x.\n",
546 			       fcport->node_name, fcport->port_name,
547 			       fcport->d_id.b24);
548 			ql_dbg(ql_dbg_edif, vha, 0xf084,
549 			       "%s: se_sess %p / sess %p from port %8phC "
550 			       "loop_id %#04x s_id %06x logout %d "
551 			       "keep %d els_logo %d disc state %d auth state %d"
552 			       "stop state %d\n",
553 			       __func__, fcport->se_sess, fcport,
554 			       fcport->port_name, fcport->loop_id,
555 			       fcport->d_id.b24, fcport->logout_on_delete,
556 			       fcport->keep_nport_handle, fcport->send_els_logo,
557 			       fcport->disc_state, fcport->edif.auth_state,
558 			       fcport->edif.app_stop);
559 
560 			if (atomic_read(&vha->loop_state) == LOOP_DOWN)
561 				break;
562 
563 			fcport->login_retry = vha->hw->login_retry_count;
564 
565 			fcport->edif.app_stop = 0;
566 			fcport->edif.app_sess_online = 0;
567 
568 			if (fcport->scan_state != QLA_FCPORT_FOUND)
569 				continue;
570 
571 			if (fcport->port_type == FCT_UNKNOWN &&
572 			    !fcport->fc4_features)
573 				rval = qla24xx_async_gffid(vha, fcport, true);
574 
575 			if (!rval && !(fcport->fc4_features & FC4_FF_TARGET ||
576 			    fcport->port_type & (FCT_TARGET|FCT_NVME_TARGET)))
577 				continue;
578 
579 			rval = 0;
580 
581 			ql_dbg(ql_dbg_edif, vha, 0x911e,
582 			       "%s wwpn %8phC calling qla_edif_reset_auth_wait\n",
583 			       __func__, fcport->port_name);
584 			qlt_schedule_sess_for_deletion(fcport);
585 			qla_edif_sa_ctl_init(vha, fcport);
586 		}
587 		set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
588 	}
589 
590 	if (vha->pur_cinfo.enode_flags != ENODE_ACTIVE) {
591 		/* mark as active since an app is now present */
592 		vha->pur_cinfo.enode_flags = ENODE_ACTIVE;
593 	} else {
594 		ql_dbg(ql_dbg_edif, vha, 0x911f, "%s enode already active\n",
595 		     __func__);
596 	}
597 
598 out:
599 	appreply.host_support_edif = vha->hw->flags.edif_enabled;
600 	appreply.edif_enode_active = vha->pur_cinfo.enode_flags;
601 	appreply.edif_edb_active = vha->e_dbell.db_flags;
602 	appreply.version = EDIF_VERSION1;
603 
604 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
605 
606 	SET_DID_STATUS(bsg_reply->result, DID_OK);
607 
608 	bsg_reply->reply_payload_rcv_len = sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
609 							       bsg_job->reply_payload.sg_cnt,
610 							       &appreply,
611 							       sizeof(struct app_start_reply));
612 
613 	ql_dbg(ql_dbg_edif, vha, 0x911d,
614 	    "%s app start completed with 0x%x\n",
615 	    __func__, rval);
616 
617 	return rval;
618 }
619 
620 /**
621  * qla_edif_app_stop - app has announced it's exiting.
622  * @vha: host adapter pointer
623  * @bsg_job: user space command pointer
624  *
625  * Free any in flight messages, clear all doorbell events
626  * to application. Reject any message relate to security.
627  */
628 static int
qla_edif_app_stop(scsi_qla_host_t * vha,struct bsg_job * bsg_job)629 qla_edif_app_stop(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
630 {
631 	struct app_stop         appstop;
632 	struct fc_bsg_reply     *bsg_reply = bsg_job->reply;
633 	struct fc_port  *fcport, *tf;
634 
635 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
636 	    bsg_job->request_payload.sg_cnt, &appstop,
637 	    sizeof(struct app_stop));
638 
639 	ql_dbg(ql_dbg_edif, vha, 0x911d, "%s Stopping APP: app_vid=%x\n",
640 	    __func__, appstop.app_info.app_vid);
641 
642 	/* Call db stop and enode stop functions */
643 
644 	/* if we leave this running short waits are operational < 16 secs */
645 	qla_enode_stop(vha);        /* stop enode */
646 	qla_edb_stop(vha);          /* stop db */
647 
648 	list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list) {
649 		if (!(fcport->flags & FCF_FCSP_DEVICE))
650 			continue;
651 
652 		if (fcport->flags & FCF_FCSP_DEVICE) {
653 			ql_dbg(ql_dbg_edif, vha, 0xf084,
654 			    "%s: sess %p from port %8phC lid %#04x s_id %06x logout %d keep %d els_logo %d\n",
655 			    __func__, fcport,
656 			    fcport->port_name, fcport->loop_id, fcport->d_id.b24,
657 			    fcport->logout_on_delete, fcport->keep_nport_handle,
658 			    fcport->send_els_logo);
659 
660 			if (atomic_read(&vha->loop_state) == LOOP_DOWN)
661 				break;
662 
663 			fcport->edif.app_stop = 1;
664 			ql_dbg(ql_dbg_edif, vha, 0x911e,
665 				"%s wwpn %8phC calling qla_edif_reset_auth_wait\n",
666 				__func__, fcport->port_name);
667 
668 			fcport->send_els_logo = 1;
669 			qlt_schedule_sess_for_deletion(fcport);
670 		}
671 	}
672 
673 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
674 	SET_DID_STATUS(bsg_reply->result, DID_OK);
675 
676 	/* no return interface to app - it assumes we cleaned up ok */
677 
678 	return 0;
679 }
680 
681 static int
qla_edif_app_chk_sa_update(scsi_qla_host_t * vha,fc_port_t * fcport,struct app_plogi_reply * appplogireply)682 qla_edif_app_chk_sa_update(scsi_qla_host_t *vha, fc_port_t *fcport,
683 		struct app_plogi_reply *appplogireply)
684 {
685 	int	ret = 0;
686 
687 	if (!(fcport->edif.rx_sa_set && fcport->edif.tx_sa_set)) {
688 		ql_dbg(ql_dbg_edif, vha, 0x911e,
689 		    "%s: wwpn %8phC Both SA indexes has not been SET TX %d, RX %d.\n",
690 		    __func__, fcport->port_name, fcport->edif.tx_sa_set,
691 		    fcport->edif.rx_sa_set);
692 		appplogireply->prli_status = 0;
693 		ret = 1;
694 	} else  {
695 		ql_dbg(ql_dbg_edif, vha, 0x911e,
696 		    "%s wwpn %8phC Both SA(s) updated.\n", __func__,
697 		    fcport->port_name);
698 		fcport->edif.rx_sa_set = fcport->edif.tx_sa_set = 0;
699 		fcport->edif.rx_sa_pending = fcport->edif.tx_sa_pending = 0;
700 		appplogireply->prli_status = 1;
701 	}
702 	return ret;
703 }
704 
705 /**
706  * qla_edif_app_authok - authentication by app succeeded.  Driver can proceed
707  *   with prli
708  * @vha: host adapter pointer
709  * @bsg_job: user request
710  */
711 static int
qla_edif_app_authok(scsi_qla_host_t * vha,struct bsg_job * bsg_job)712 qla_edif_app_authok(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
713 {
714 	struct auth_complete_cmd appplogiok;
715 	struct app_plogi_reply	appplogireply = {0};
716 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
717 	fc_port_t		*fcport = NULL;
718 	port_id_t		portid = {0};
719 
720 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
721 	    bsg_job->request_payload.sg_cnt, &appplogiok,
722 	    sizeof(struct auth_complete_cmd));
723 
724 	/* silent unaligned access warning */
725 	portid.b.domain = appplogiok.u.d_id.b.domain;
726 	portid.b.area   = appplogiok.u.d_id.b.area;
727 	portid.b.al_pa  = appplogiok.u.d_id.b.al_pa;
728 
729 	appplogireply.version = EDIF_VERSION1;
730 	switch (appplogiok.type) {
731 	case PL_TYPE_WWPN:
732 		fcport = qla2x00_find_fcport_by_wwpn(vha,
733 		    appplogiok.u.wwpn, 0);
734 		if (!fcport)
735 			ql_dbg(ql_dbg_edif, vha, 0x911d,
736 			    "%s wwpn lookup failed: %8phC\n",
737 			    __func__, appplogiok.u.wwpn);
738 		break;
739 	case PL_TYPE_DID:
740 		fcport = qla2x00_find_fcport_by_pid(vha, &portid);
741 		if (!fcport)
742 			ql_dbg(ql_dbg_edif, vha, 0x911d,
743 			    "%s d_id lookup failed: %x\n", __func__,
744 			    portid.b24);
745 		break;
746 	default:
747 		ql_dbg(ql_dbg_edif, vha, 0x911d,
748 		    "%s undefined type: %x\n", __func__,
749 		    appplogiok.type);
750 		break;
751 	}
752 
753 	if (!fcport) {
754 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
755 		goto errstate_exit;
756 	}
757 
758 	/*
759 	 * if port is online then this is a REKEY operation
760 	 * Only do sa update checking
761 	 */
762 	if (atomic_read(&fcport->state) == FCS_ONLINE) {
763 		ql_dbg(ql_dbg_edif, vha, 0x911d,
764 		    "%s Skipping PRLI complete based on rekey\n", __func__);
765 		appplogireply.prli_status = 1;
766 		SET_DID_STATUS(bsg_reply->result, DID_OK);
767 		qla_edif_app_chk_sa_update(vha, fcport, &appplogireply);
768 		goto errstate_exit;
769 	}
770 
771 	/* make sure in AUTH_PENDING or else reject */
772 	if (fcport->disc_state != DSC_LOGIN_AUTH_PEND) {
773 		ql_dbg(ql_dbg_edif, vha, 0x911e,
774 		    "%s wwpn %8phC is not in auth pending state (%x)\n",
775 		    __func__, fcport->port_name, fcport->disc_state);
776 		SET_DID_STATUS(bsg_reply->result, DID_OK);
777 		appplogireply.prli_status = 0;
778 		goto errstate_exit;
779 	}
780 
781 	SET_DID_STATUS(bsg_reply->result, DID_OK);
782 	appplogireply.prli_status = 1;
783 	fcport->edif.authok = 1;
784 	if (!(fcport->edif.rx_sa_set && fcport->edif.tx_sa_set)) {
785 		ql_dbg(ql_dbg_edif, vha, 0x911e,
786 		    "%s: wwpn %8phC Both SA indexes has not been SET TX %d, RX %d.\n",
787 		    __func__, fcport->port_name, fcport->edif.tx_sa_set,
788 		    fcport->edif.rx_sa_set);
789 		SET_DID_STATUS(bsg_reply->result, DID_OK);
790 		appplogireply.prli_status = 0;
791 		goto errstate_exit;
792 
793 	} else {
794 		ql_dbg(ql_dbg_edif, vha, 0x911e,
795 		    "%s wwpn %8phC Both SA(s) updated.\n", __func__,
796 		    fcport->port_name);
797 		fcport->edif.rx_sa_set = fcport->edif.tx_sa_set = 0;
798 		fcport->edif.rx_sa_pending = fcport->edif.tx_sa_pending = 0;
799 	}
800 
801 	if (qla_ini_mode_enabled(vha)) {
802 		ql_dbg(ql_dbg_edif, vha, 0x911e,
803 		    "%s AUTH complete - RESUME with prli for wwpn %8phC\n",
804 		    __func__, fcport->port_name);
805 		qla24xx_post_prli_work(vha, fcport);
806 	}
807 
808 errstate_exit:
809 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
810 	bsg_reply->reply_payload_rcv_len = sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
811 							       bsg_job->reply_payload.sg_cnt,
812 							       &appplogireply,
813 							       sizeof(struct app_plogi_reply));
814 
815 	return 0;
816 }
817 
818 /**
819  * qla_edif_app_authfail - authentication by app has failed.  Driver is given
820  *   notice to tear down current session.
821  * @vha: host adapter pointer
822  * @bsg_job: user request
823  */
824 static int
qla_edif_app_authfail(scsi_qla_host_t * vha,struct bsg_job * bsg_job)825 qla_edif_app_authfail(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
826 {
827 	int32_t			rval = 0;
828 	struct auth_complete_cmd appplogifail;
829 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
830 	fc_port_t		*fcport = NULL;
831 	port_id_t		portid = {0};
832 
833 	ql_dbg(ql_dbg_edif, vha, 0x911d, "%s app auth fail\n", __func__);
834 
835 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
836 	    bsg_job->request_payload.sg_cnt, &appplogifail,
837 	    sizeof(struct auth_complete_cmd));
838 
839 	/* silent unaligned access warning */
840 	portid.b.domain = appplogifail.u.d_id.b.domain;
841 	portid.b.area   = appplogifail.u.d_id.b.area;
842 	portid.b.al_pa  = appplogifail.u.d_id.b.al_pa;
843 
844 	/*
845 	 * TODO: edif: app has failed this plogi. Inform driver to
846 	 * take any action (if any).
847 	 */
848 	switch (appplogifail.type) {
849 	case PL_TYPE_WWPN:
850 		fcport = qla2x00_find_fcport_by_wwpn(vha,
851 		    appplogifail.u.wwpn, 0);
852 		SET_DID_STATUS(bsg_reply->result, DID_OK);
853 		break;
854 	case PL_TYPE_DID:
855 		fcport = qla2x00_find_fcport_by_pid(vha, &portid);
856 		if (!fcport)
857 			ql_dbg(ql_dbg_edif, vha, 0x911d,
858 			    "%s d_id lookup failed: %x\n", __func__,
859 			    portid.b24);
860 		SET_DID_STATUS(bsg_reply->result, DID_OK);
861 		break;
862 	default:
863 		ql_dbg(ql_dbg_edif, vha, 0x911e,
864 		    "%s undefined type: %x\n", __func__,
865 		    appplogifail.type);
866 		bsg_job->reply_len = sizeof(struct fc_bsg_reply);
867 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
868 		rval = -1;
869 		break;
870 	}
871 
872 	ql_dbg(ql_dbg_edif, vha, 0x911d,
873 	    "%s fcport is 0x%p\n", __func__, fcport);
874 
875 	if (fcport) {
876 		/* set/reset edif values and flags */
877 		ql_dbg(ql_dbg_edif, vha, 0x911e,
878 		    "%s reset the auth process - %8phC, loopid=%x portid=%06x.\n",
879 		    __func__, fcport->port_name, fcport->loop_id, fcport->d_id.b24);
880 
881 		if (qla_ini_mode_enabled(fcport->vha)) {
882 			fcport->send_els_logo = 1;
883 			qlt_schedule_sess_for_deletion(fcport);
884 		}
885 	}
886 
887 	return rval;
888 }
889 
890 /**
891  * qla_edif_app_getfcinfo - app would like to read session info (wwpn, nportid,
892  *   [initiator|target] mode.  It can specific session with specific nport id or
893  *   all sessions.
894  * @vha: host adapter pointer
895  * @bsg_job: user request pointer
896  */
897 static int
qla_edif_app_getfcinfo(scsi_qla_host_t * vha,struct bsg_job * bsg_job)898 qla_edif_app_getfcinfo(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
899 {
900 	int32_t			rval = 0;
901 	int32_t			pcnt = 0;
902 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
903 	struct app_pinfo_req	app_req;
904 	struct app_pinfo_reply	*app_reply;
905 	port_id_t		tdid;
906 
907 	ql_dbg(ql_dbg_edif, vha, 0x911d, "%s app get fcinfo\n", __func__);
908 
909 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
910 	    bsg_job->request_payload.sg_cnt, &app_req,
911 	    sizeof(struct app_pinfo_req));
912 
913 	app_reply = kzalloc((sizeof(struct app_pinfo_reply) +
914 	    sizeof(struct app_pinfo) * app_req.num_ports), GFP_KERNEL);
915 
916 	if (!app_reply) {
917 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
918 		rval = -1;
919 	} else {
920 		struct fc_port	*fcport = NULL, *tf;
921 
922 		app_reply->version = EDIF_VERSION1;
923 
924 		list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list) {
925 			if (!(fcport->flags & FCF_FCSP_DEVICE))
926 				continue;
927 
928 			tdid = app_req.remote_pid;
929 
930 			ql_dbg(ql_dbg_edif, vha, 0x2058,
931 			    "APP request entry - portid=%06x.\n", tdid.b24);
932 
933 			/* Ran out of space */
934 			if (pcnt >= app_req.num_ports)
935 				break;
936 
937 			if (tdid.b24 != 0 && tdid.b24 != fcport->d_id.b24)
938 				continue;
939 
940 			if (!N2N_TOPO(vha->hw)) {
941 				if (fcport->scan_state != QLA_FCPORT_FOUND)
942 					continue;
943 
944 				if (fcport->port_type == FCT_UNKNOWN &&
945 				    !fcport->fc4_features)
946 					rval = qla24xx_async_gffid(vha, fcport,
947 								   true);
948 
949 				if (!rval &&
950 				    !(fcport->fc4_features & FC4_FF_TARGET ||
951 				      fcport->port_type &
952 				      (FCT_TARGET | FCT_NVME_TARGET)))
953 					continue;
954 			}
955 
956 			rval = 0;
957 
958 			app_reply->ports[pcnt].version = EDIF_VERSION1;
959 			app_reply->ports[pcnt].remote_type =
960 				VND_CMD_RTYPE_UNKNOWN;
961 			if (fcport->port_type & (FCT_NVME_TARGET | FCT_TARGET))
962 				app_reply->ports[pcnt].remote_type |=
963 					VND_CMD_RTYPE_TARGET;
964 			if (fcport->port_type & (FCT_NVME_INITIATOR | FCT_INITIATOR))
965 				app_reply->ports[pcnt].remote_type |=
966 					VND_CMD_RTYPE_INITIATOR;
967 
968 			app_reply->ports[pcnt].remote_pid = fcport->d_id;
969 
970 			ql_dbg(ql_dbg_edif, vha, 0x2058,
971 			    "Found FC_SP fcport - nn %8phN pn %8phN pcnt %d portid=%06x secure %d.\n",
972 			    fcport->node_name, fcport->port_name, pcnt,
973 			    fcport->d_id.b24, fcport->flags & FCF_FCSP_DEVICE);
974 
975 			switch (fcport->edif.auth_state) {
976 			case VND_CMD_AUTH_STATE_ELS_RCVD:
977 				if (fcport->disc_state == DSC_LOGIN_AUTH_PEND) {
978 					fcport->edif.auth_state = VND_CMD_AUTH_STATE_NEEDED;
979 					app_reply->ports[pcnt].auth_state =
980 						VND_CMD_AUTH_STATE_NEEDED;
981 				} else {
982 					app_reply->ports[pcnt].auth_state =
983 						VND_CMD_AUTH_STATE_ELS_RCVD;
984 				}
985 				break;
986 			default:
987 				app_reply->ports[pcnt].auth_state = fcport->edif.auth_state;
988 				break;
989 			}
990 
991 			memcpy(app_reply->ports[pcnt].remote_wwpn,
992 			    fcport->port_name, 8);
993 
994 			app_reply->ports[pcnt].remote_state =
995 				(atomic_read(&fcport->state) ==
996 				    FCS_ONLINE ? 1 : 0);
997 
998 			pcnt++;
999 
1000 			if (tdid.b24 != 0)
1001 				break;
1002 		}
1003 		app_reply->port_count = pcnt;
1004 		SET_DID_STATUS(bsg_reply->result, DID_OK);
1005 	}
1006 
1007 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1008 	bsg_reply->reply_payload_rcv_len = sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1009 							       bsg_job->reply_payload.sg_cnt,
1010 							       app_reply,
1011 							       sizeof(struct app_pinfo_reply) + sizeof(struct app_pinfo) * pcnt);
1012 
1013 	kfree(app_reply);
1014 
1015 	return rval;
1016 }
1017 
1018 /**
1019  * qla_edif_app_getstats - app would like to read various statistics info
1020  * @vha: host adapter pointer
1021  * @bsg_job: user request
1022  */
1023 static int32_t
qla_edif_app_getstats(scsi_qla_host_t * vha,struct bsg_job * bsg_job)1024 qla_edif_app_getstats(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
1025 {
1026 	int32_t			rval = 0;
1027 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
1028 	uint32_t size;
1029 
1030 	struct app_sinfo_req	app_req;
1031 	struct app_stats_reply	*app_reply;
1032 	uint32_t pcnt = 0;
1033 
1034 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1035 	    bsg_job->request_payload.sg_cnt, &app_req,
1036 	    sizeof(struct app_sinfo_req));
1037 	if (app_req.num_ports == 0) {
1038 		ql_dbg(ql_dbg_async, vha, 0x911d,
1039 		   "%s app did not indicate number of ports to return\n",
1040 		    __func__);
1041 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1042 		rval = -1;
1043 	}
1044 
1045 	size = sizeof(struct app_stats_reply) +
1046 	    (sizeof(struct app_sinfo) * app_req.num_ports);
1047 
1048 	app_reply = kzalloc(size, GFP_KERNEL);
1049 	if (!app_reply) {
1050 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1051 		rval = -1;
1052 	} else {
1053 		struct fc_port	*fcport = NULL, *tf;
1054 
1055 		app_reply->version = EDIF_VERSION1;
1056 
1057 		list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list) {
1058 			if (fcport->edif.enable) {
1059 				if (pcnt > app_req.num_ports)
1060 					break;
1061 
1062 				app_reply->elem[pcnt].rekey_count =
1063 				    fcport->edif.rekey_cnt;
1064 				app_reply->elem[pcnt].tx_bytes =
1065 				    fcport->edif.tx_bytes;
1066 				app_reply->elem[pcnt].rx_bytes =
1067 				    fcport->edif.rx_bytes;
1068 
1069 				memcpy(app_reply->elem[pcnt].remote_wwpn,
1070 				    fcport->port_name, 8);
1071 
1072 				pcnt++;
1073 			}
1074 		}
1075 		app_reply->elem_count = pcnt;
1076 		SET_DID_STATUS(bsg_reply->result, DID_OK);
1077 	}
1078 
1079 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1080 	bsg_reply->reply_payload_rcv_len =
1081 	    sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1082 	       bsg_job->reply_payload.sg_cnt, app_reply,
1083 	       sizeof(struct app_stats_reply) + (sizeof(struct app_sinfo) * pcnt));
1084 
1085 	kfree(app_reply);
1086 
1087 	return rval;
1088 }
1089 
1090 static int32_t
qla_edif_ack(scsi_qla_host_t * vha,struct bsg_job * bsg_job)1091 qla_edif_ack(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
1092 {
1093 	struct fc_port *fcport;
1094 	struct aen_complete_cmd ack;
1095 	struct fc_bsg_reply     *bsg_reply = bsg_job->reply;
1096 
1097 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1098 			  bsg_job->request_payload.sg_cnt, &ack, sizeof(ack));
1099 
1100 	ql_dbg(ql_dbg_edif, vha, 0x70cf,
1101 	       "%s: %06x event_code %x\n",
1102 	       __func__, ack.port_id.b24, ack.event_code);
1103 
1104 	fcport = qla2x00_find_fcport_by_pid(vha, &ack.port_id);
1105 	SET_DID_STATUS(bsg_reply->result, DID_OK);
1106 
1107 	if (!fcport) {
1108 		ql_dbg(ql_dbg_edif, vha, 0x70cf,
1109 		       "%s: unable to find fcport %06x \n",
1110 		       __func__, ack.port_id.b24);
1111 		return 0;
1112 	}
1113 
1114 	switch (ack.event_code) {
1115 	case VND_CMD_AUTH_STATE_SESSION_SHUTDOWN:
1116 		fcport->edif.sess_down_acked = 1;
1117 		break;
1118 	default:
1119 		break;
1120 	}
1121 	return 0;
1122 }
1123 
qla_edif_consume_dbell(scsi_qla_host_t * vha,struct bsg_job * bsg_job)1124 static int qla_edif_consume_dbell(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
1125 {
1126 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
1127 	u32 sg_skip, reply_payload_len;
1128 	bool keep;
1129 	struct edb_node *dbnode = NULL;
1130 	struct edif_app_dbell ap;
1131 	int dat_size = 0;
1132 
1133 	sg_skip = 0;
1134 	reply_payload_len = bsg_job->reply_payload.payload_len;
1135 
1136 	while ((reply_payload_len - sg_skip) >= sizeof(struct edb_node)) {
1137 		dbnode = qla_edb_getnext(vha);
1138 		if (dbnode) {
1139 			keep = true;
1140 			dat_size = 0;
1141 			ap.event_code = dbnode->ntype;
1142 			switch (dbnode->ntype) {
1143 			case VND_CMD_AUTH_STATE_SESSION_SHUTDOWN:
1144 			case VND_CMD_AUTH_STATE_NEEDED:
1145 				ap.port_id = dbnode->u.plogi_did;
1146 				dat_size += sizeof(ap.port_id);
1147 				break;
1148 			case VND_CMD_AUTH_STATE_ELS_RCVD:
1149 				ap.port_id = dbnode->u.els_sid;
1150 				dat_size += sizeof(ap.port_id);
1151 				break;
1152 			case VND_CMD_AUTH_STATE_SAUPDATE_COMPL:
1153 				ap.port_id = dbnode->u.sa_aen.port_id;
1154 				memcpy(&ap.event_data, &dbnode->u,
1155 				    sizeof(struct edif_sa_update_aen));
1156 				dat_size += sizeof(struct edif_sa_update_aen);
1157 				break;
1158 			default:
1159 				keep = false;
1160 				ql_log(ql_log_warn, vha, 0x09102,
1161 					"%s unknown DB type=%d %p\n",
1162 					__func__, dbnode->ntype, dbnode);
1163 				break;
1164 			}
1165 			ap.event_data_size = dat_size;
1166 			/* 8 = sizeof(ap.event_code + ap.event_data_size) */
1167 			dat_size += 8;
1168 			if (keep)
1169 				sg_skip += sg_copy_buffer(bsg_job->reply_payload.sg_list,
1170 						bsg_job->reply_payload.sg_cnt,
1171 						&ap, dat_size, sg_skip, false);
1172 
1173 			ql_dbg(ql_dbg_edif, vha, 0x09102,
1174 				"%s Doorbell consumed : type=%d %p\n",
1175 				__func__, dbnode->ntype, dbnode);
1176 
1177 			kfree(dbnode);
1178 		} else {
1179 			break;
1180 		}
1181 	}
1182 
1183 	SET_DID_STATUS(bsg_reply->result, DID_OK);
1184 	bsg_reply->reply_payload_rcv_len = sg_skip;
1185 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1186 
1187 	return 0;
1188 }
1189 
__qla_edif_dbell_bsg_done(scsi_qla_host_t * vha,struct bsg_job * bsg_job,u32 delay)1190 static void __qla_edif_dbell_bsg_done(scsi_qla_host_t *vha, struct bsg_job *bsg_job,
1191 	u32 delay)
1192 {
1193 	struct fc_bsg_reply *bsg_reply = bsg_job->reply;
1194 
1195 	/* small sleep for doorbell events to accumulate */
1196 	if (delay)
1197 		msleep(delay);
1198 
1199 	qla_edif_consume_dbell(vha, bsg_job);
1200 
1201 	bsg_job_done(bsg_job, bsg_reply->result, bsg_reply->reply_payload_rcv_len);
1202 }
1203 
qla_edif_dbell_bsg_done(scsi_qla_host_t * vha)1204 static void qla_edif_dbell_bsg_done(scsi_qla_host_t *vha)
1205 {
1206 	unsigned long flags;
1207 	struct bsg_job *prev_bsg_job = NULL;
1208 
1209 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
1210 	if (vha->e_dbell.dbell_bsg_job) {
1211 		prev_bsg_job = vha->e_dbell.dbell_bsg_job;
1212 		vha->e_dbell.dbell_bsg_job = NULL;
1213 	}
1214 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
1215 
1216 	if (prev_bsg_job)
1217 		__qla_edif_dbell_bsg_done(vha, prev_bsg_job, 0);
1218 }
1219 
1220 static int
qla_edif_dbell_bsg(scsi_qla_host_t * vha,struct bsg_job * bsg_job)1221 qla_edif_dbell_bsg(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
1222 {
1223 	unsigned long flags;
1224 	bool return_bsg = false;
1225 
1226 	/* flush previous dbell bsg */
1227 	qla_edif_dbell_bsg_done(vha);
1228 
1229 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
1230 	if (list_empty(&vha->e_dbell.head) && DBELL_ACTIVE(vha)) {
1231 		/*
1232 		 * when the next db event happens, bsg_job will return.
1233 		 * Otherwise, timer will return it.
1234 		 */
1235 		vha->e_dbell.dbell_bsg_job = bsg_job;
1236 		vha->e_dbell.bsg_expire = jiffies + 10 * HZ;
1237 	} else {
1238 		return_bsg = true;
1239 	}
1240 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
1241 
1242 	if (return_bsg)
1243 		__qla_edif_dbell_bsg_done(vha, bsg_job, 1);
1244 
1245 	return 0;
1246 }
1247 
1248 int32_t
qla_edif_app_mgmt(struct bsg_job * bsg_job)1249 qla_edif_app_mgmt(struct bsg_job *bsg_job)
1250 {
1251 	struct fc_bsg_request	*bsg_request = bsg_job->request;
1252 	struct fc_bsg_reply	*bsg_reply = bsg_job->reply;
1253 	struct Scsi_Host *host = fc_bsg_to_shost(bsg_job);
1254 	scsi_qla_host_t		*vha = shost_priv(host);
1255 	struct app_id		appcheck;
1256 	bool done = true;
1257 	int32_t         rval = 0;
1258 	uint32_t	vnd_sc = bsg_request->rqst_data.h_vendor.vendor_cmd[1];
1259 	u32 level = ql_dbg_edif;
1260 
1261 	/* doorbell is high traffic */
1262 	if (vnd_sc == QL_VND_SC_READ_DBELL)
1263 		level = 0;
1264 
1265 	ql_dbg(level, vha, 0x911d, "%s vnd subcmd=%x\n",
1266 	    __func__, vnd_sc);
1267 
1268 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1269 	    bsg_job->request_payload.sg_cnt, &appcheck,
1270 	    sizeof(struct app_id));
1271 
1272 	if (!vha->hw->flags.edif_enabled ||
1273 		test_bit(VPORT_DELETE, &vha->dpc_flags)) {
1274 		ql_dbg(level, vha, 0x911d,
1275 		    "%s edif not enabled or vp delete. bsg ptr done %p. dpc_flags %lx\n",
1276 		    __func__, bsg_job, vha->dpc_flags);
1277 
1278 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1279 		goto done;
1280 	}
1281 
1282 	if (!qla_edif_app_check(vha, appcheck)) {
1283 		ql_dbg(level, vha, 0x911d,
1284 		    "%s app checked failed.\n",
1285 		    __func__);
1286 
1287 		bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1288 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1289 		goto done;
1290 	}
1291 
1292 	switch (vnd_sc) {
1293 	case QL_VND_SC_SA_UPDATE:
1294 		done = false;
1295 		rval = qla24xx_sadb_update(bsg_job);
1296 		break;
1297 	case QL_VND_SC_APP_START:
1298 		rval = qla_edif_app_start(vha, bsg_job);
1299 		break;
1300 	case QL_VND_SC_APP_STOP:
1301 		rval = qla_edif_app_stop(vha, bsg_job);
1302 		break;
1303 	case QL_VND_SC_AUTH_OK:
1304 		rval = qla_edif_app_authok(vha, bsg_job);
1305 		break;
1306 	case QL_VND_SC_AUTH_FAIL:
1307 		rval = qla_edif_app_authfail(vha, bsg_job);
1308 		break;
1309 	case QL_VND_SC_GET_FCINFO:
1310 		rval = qla_edif_app_getfcinfo(vha, bsg_job);
1311 		break;
1312 	case QL_VND_SC_GET_STATS:
1313 		rval = qla_edif_app_getstats(vha, bsg_job);
1314 		break;
1315 	case QL_VND_SC_AEN_COMPLETE:
1316 		rval = qla_edif_ack(vha, bsg_job);
1317 		break;
1318 	case QL_VND_SC_READ_DBELL:
1319 		rval = qla_edif_dbell_bsg(vha, bsg_job);
1320 		done = false;
1321 		break;
1322 	default:
1323 		ql_dbg(ql_dbg_edif, vha, 0x911d, "%s unknown cmd=%x\n",
1324 		    __func__,
1325 		    bsg_request->rqst_data.h_vendor.vendor_cmd[1]);
1326 		rval = EXT_STATUS_INVALID_PARAM;
1327 		done = false;
1328 		break;
1329 	}
1330 
1331 done:
1332 	if (done) {
1333 		ql_dbg(level, vha, 0x7009,
1334 		    "%s: %d  bsg ptr done %p\n", __func__, __LINE__, bsg_job);
1335 		bsg_job_done(bsg_job, bsg_reply->result,
1336 		    bsg_reply->reply_payload_rcv_len);
1337 	}
1338 
1339 	return rval;
1340 }
1341 
1342 static struct edif_sa_ctl *
qla_edif_add_sa_ctl(fc_port_t * fcport,struct qla_sa_update_frame * sa_frame,int dir)1343 qla_edif_add_sa_ctl(fc_port_t *fcport, struct qla_sa_update_frame *sa_frame,
1344 	int dir)
1345 {
1346 	struct	edif_sa_ctl *sa_ctl;
1347 	struct qla_sa_update_frame *sap;
1348 	int	index = sa_frame->fast_sa_index;
1349 	unsigned long flags = 0;
1350 
1351 	sa_ctl = kzalloc(sizeof(*sa_ctl), GFP_KERNEL);
1352 	if (!sa_ctl) {
1353 		/* couldn't get space */
1354 		ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1355 		    "unable to allocate SA CTL\n");
1356 		return NULL;
1357 	}
1358 
1359 	/*
1360 	 * need to allocate sa_index here and save it
1361 	 * in both sa_ctl->index and sa_frame->fast_sa_index;
1362 	 * If alloc fails then delete sa_ctl and return NULL
1363 	 */
1364 	INIT_LIST_HEAD(&sa_ctl->next);
1365 	sap = &sa_ctl->sa_frame;
1366 	*sap = *sa_frame;
1367 	sa_ctl->index = index;
1368 	sa_ctl->fcport = fcport;
1369 	sa_ctl->flags = 0;
1370 	sa_ctl->state = 0L;
1371 	ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1372 	    "%s: Added sa_ctl %p, index %d, state 0x%lx\n",
1373 	    __func__, sa_ctl, sa_ctl->index, sa_ctl->state);
1374 	spin_lock_irqsave(&fcport->edif.sa_list_lock, flags);
1375 	if (dir == SAU_FLG_TX)
1376 		list_add_tail(&sa_ctl->next, &fcport->edif.tx_sa_list);
1377 	else
1378 		list_add_tail(&sa_ctl->next, &fcport->edif.rx_sa_list);
1379 	spin_unlock_irqrestore(&fcport->edif.sa_list_lock, flags);
1380 
1381 	return sa_ctl;
1382 }
1383 
1384 void
qla_edif_flush_sa_ctl_lists(fc_port_t * fcport)1385 qla_edif_flush_sa_ctl_lists(fc_port_t *fcport)
1386 {
1387 	struct edif_sa_ctl *sa_ctl, *tsa_ctl;
1388 	unsigned long flags = 0;
1389 
1390 	spin_lock_irqsave(&fcport->edif.sa_list_lock, flags);
1391 
1392 	list_for_each_entry_safe(sa_ctl, tsa_ctl, &fcport->edif.tx_sa_list,
1393 	    next) {
1394 		list_del(&sa_ctl->next);
1395 		kfree(sa_ctl);
1396 	}
1397 
1398 	list_for_each_entry_safe(sa_ctl, tsa_ctl, &fcport->edif.rx_sa_list,
1399 	    next) {
1400 		list_del(&sa_ctl->next);
1401 		kfree(sa_ctl);
1402 	}
1403 
1404 	spin_unlock_irqrestore(&fcport->edif.sa_list_lock, flags);
1405 }
1406 
1407 struct edif_sa_ctl *
qla_edif_find_sa_ctl_by_index(fc_port_t * fcport,int index,int dir)1408 qla_edif_find_sa_ctl_by_index(fc_port_t *fcport, int index, int dir)
1409 {
1410 	struct edif_sa_ctl *sa_ctl, *tsa_ctl;
1411 	struct list_head *sa_list;
1412 
1413 	if (dir == SAU_FLG_TX)
1414 		sa_list = &fcport->edif.tx_sa_list;
1415 	else
1416 		sa_list = &fcport->edif.rx_sa_list;
1417 
1418 	list_for_each_entry_safe(sa_ctl, tsa_ctl, sa_list, next) {
1419 		if (test_bit(EDIF_SA_CTL_USED, &sa_ctl->state) &&
1420 		    sa_ctl->index == index)
1421 			return sa_ctl;
1422 	}
1423 	return NULL;
1424 }
1425 
1426 /* add the sa to the correct list */
1427 static int
qla24xx_check_sadb_avail_slot(struct bsg_job * bsg_job,fc_port_t * fcport,struct qla_sa_update_frame * sa_frame)1428 qla24xx_check_sadb_avail_slot(struct bsg_job *bsg_job, fc_port_t *fcport,
1429 	struct qla_sa_update_frame *sa_frame)
1430 {
1431 	struct edif_sa_ctl *sa_ctl = NULL;
1432 	int dir;
1433 	uint16_t sa_index;
1434 
1435 	dir = (sa_frame->flags & SAU_FLG_TX);
1436 
1437 	/* map the spi to an sa_index */
1438 	sa_index = qla_edif_sadb_get_sa_index(fcport, sa_frame);
1439 	if (sa_index == RX_DELETE_NO_EDIF_SA_INDEX) {
1440 		/* process rx delete */
1441 		ql_dbg(ql_dbg_edif, fcport->vha, 0x3063,
1442 		    "%s: rx delete for lid 0x%x, spi 0x%x, no entry found\n",
1443 		    __func__, fcport->loop_id, sa_frame->spi);
1444 
1445 		/* build and send the aen */
1446 		fcport->edif.rx_sa_set = 1;
1447 		fcport->edif.rx_sa_pending = 0;
1448 		qla_edb_eventcreate(fcport->vha,
1449 		    VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
1450 		    QL_VND_SA_STAT_SUCCESS,
1451 		    QL_VND_RX_SA_KEY, fcport);
1452 
1453 		/* force a return of good bsg status; */
1454 		return RX_DELETE_NO_EDIF_SA_INDEX;
1455 	} else if (sa_index == INVALID_EDIF_SA_INDEX) {
1456 		ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1457 		    "%s: Failed to get sa_index for spi 0x%x, dir: %d\n",
1458 		    __func__, sa_frame->spi, dir);
1459 		return INVALID_EDIF_SA_INDEX;
1460 	}
1461 
1462 	ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1463 	    "%s: index %d allocated to spi 0x%x, dir: %d, nport_handle: 0x%x\n",
1464 	    __func__, sa_index, sa_frame->spi, dir, fcport->loop_id);
1465 
1466 	/* This is a local copy of sa_frame. */
1467 	sa_frame->fast_sa_index = sa_index;
1468 	/* create the sa_ctl */
1469 	sa_ctl = qla_edif_add_sa_ctl(fcport, sa_frame, dir);
1470 	if (!sa_ctl) {
1471 		ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1472 		    "%s: Failed to add sa_ctl for spi 0x%x, dir: %d, sa_index: %d\n",
1473 		    __func__, sa_frame->spi, dir, sa_index);
1474 		return -1;
1475 	}
1476 
1477 	set_bit(EDIF_SA_CTL_USED, &sa_ctl->state);
1478 
1479 	if (dir == SAU_FLG_TX)
1480 		fcport->edif.tx_rekey_cnt++;
1481 	else
1482 		fcport->edif.rx_rekey_cnt++;
1483 
1484 	ql_dbg(ql_dbg_edif, fcport->vha, 0x9100,
1485 	    "%s: Found sa_ctl %p, index %d, state 0x%lx, tx_cnt %d, rx_cnt %d, nport_handle: 0x%x\n",
1486 	    __func__, sa_ctl, sa_ctl->index, sa_ctl->state,
1487 	    fcport->edif.tx_rekey_cnt,
1488 	    fcport->edif.rx_rekey_cnt, fcport->loop_id);
1489 
1490 	return 0;
1491 }
1492 
1493 #define QLA_SA_UPDATE_FLAGS_RX_KEY      0x0
1494 #define QLA_SA_UPDATE_FLAGS_TX_KEY      0x2
1495 #define EDIF_MSLEEP_INTERVAL 100
1496 #define EDIF_RETRY_COUNT  50
1497 
1498 int
qla24xx_sadb_update(struct bsg_job * bsg_job)1499 qla24xx_sadb_update(struct bsg_job *bsg_job)
1500 {
1501 	struct	fc_bsg_reply	*bsg_reply = bsg_job->reply;
1502 	struct Scsi_Host *host = fc_bsg_to_shost(bsg_job);
1503 	scsi_qla_host_t *vha = shost_priv(host);
1504 	fc_port_t		*fcport = NULL;
1505 	srb_t			*sp = NULL;
1506 	struct edif_list_entry *edif_entry = NULL;
1507 	int			found = 0;
1508 	int			rval = 0;
1509 	int result = 0, cnt;
1510 	struct qla_sa_update_frame sa_frame;
1511 	struct srb_iocb *iocb_cmd;
1512 	port_id_t portid;
1513 
1514 	ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x911d,
1515 	    "%s entered, vha: 0x%p\n", __func__, vha);
1516 
1517 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1518 	    bsg_job->request_payload.sg_cnt, &sa_frame,
1519 	    sizeof(struct qla_sa_update_frame));
1520 
1521 	/* Check if host is online */
1522 	if (!vha->flags.online) {
1523 		ql_log(ql_log_warn, vha, 0x70a1, "Host is not online\n");
1524 		rval = -EIO;
1525 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1526 		goto done;
1527 	}
1528 
1529 	if (DBELL_INACTIVE(vha)) {
1530 		ql_log(ql_log_warn, vha, 0x70a1, "App not started\n");
1531 		rval = -EIO;
1532 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1533 		goto done;
1534 	}
1535 
1536 	/* silent unaligned access warning */
1537 	portid.b.domain = sa_frame.port_id.b.domain;
1538 	portid.b.area   = sa_frame.port_id.b.area;
1539 	portid.b.al_pa  = sa_frame.port_id.b.al_pa;
1540 
1541 	fcport = qla2x00_find_fcport_by_pid(vha, &portid);
1542 	if (fcport) {
1543 		found = 1;
1544 		if (sa_frame.flags == QLA_SA_UPDATE_FLAGS_TX_KEY)
1545 			fcport->edif.tx_bytes = 0;
1546 		if (sa_frame.flags == QLA_SA_UPDATE_FLAGS_RX_KEY)
1547 			fcport->edif.rx_bytes = 0;
1548 	}
1549 
1550 	if (!found) {
1551 		ql_dbg(ql_dbg_edif, vha, 0x70a3, "Failed to find port= %06x\n",
1552 		    sa_frame.port_id.b24);
1553 		rval = -EINVAL;
1554 		SET_DID_STATUS(bsg_reply->result, DID_NO_CONNECT);
1555 		goto done;
1556 	}
1557 
1558 	/* make sure the nport_handle is valid */
1559 	if (fcport->loop_id == FC_NO_LOOP_ID) {
1560 		ql_dbg(ql_dbg_edif, vha, 0x70e1,
1561 		    "%s: %8phN lid=FC_NO_LOOP_ID, spi: 0x%x, DS %d, returning NO_CONNECT\n",
1562 		    __func__, fcport->port_name, sa_frame.spi,
1563 		    fcport->disc_state);
1564 		rval = -EINVAL;
1565 		SET_DID_STATUS(bsg_reply->result, DID_NO_CONNECT);
1566 		goto done;
1567 	}
1568 
1569 	/* allocate and queue an sa_ctl */
1570 	result = qla24xx_check_sadb_avail_slot(bsg_job, fcport, &sa_frame);
1571 
1572 	/* failure of bsg */
1573 	if (result == INVALID_EDIF_SA_INDEX) {
1574 		ql_dbg(ql_dbg_edif, vha, 0x70e1,
1575 		    "%s: %8phN, skipping update.\n",
1576 		    __func__, fcport->port_name);
1577 		rval = -EINVAL;
1578 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1579 		goto done;
1580 
1581 	/* rx delete failure */
1582 	} else if (result == RX_DELETE_NO_EDIF_SA_INDEX) {
1583 		ql_dbg(ql_dbg_edif, vha, 0x70e1,
1584 		    "%s: %8phN, skipping rx delete.\n",
1585 		    __func__, fcport->port_name);
1586 		SET_DID_STATUS(bsg_reply->result, DID_OK);
1587 		goto done;
1588 	}
1589 
1590 	ql_dbg(ql_dbg_edif, vha, 0x70e1,
1591 	    "%s: %8phN, sa_index in sa_frame: %d flags %xh\n",
1592 	    __func__, fcport->port_name, sa_frame.fast_sa_index,
1593 	    sa_frame.flags);
1594 
1595 	/* looking for rx index and delete */
1596 	if (((sa_frame.flags & SAU_FLG_TX) == 0) &&
1597 	    (sa_frame.flags & SAU_FLG_INV)) {
1598 		uint16_t nport_handle = fcport->loop_id;
1599 		uint16_t sa_index = sa_frame.fast_sa_index;
1600 
1601 		/*
1602 		 * make sure we have an existing rx key, otherwise just process
1603 		 * this as a straight delete just like TX
1604 		 * This is NOT a normal case, it indicates an error recovery or key cleanup
1605 		 * by the ipsec code above us.
1606 		 */
1607 		edif_entry = qla_edif_list_find_sa_index(fcport, fcport->loop_id);
1608 		if (!edif_entry) {
1609 			ql_dbg(ql_dbg_edif, vha, 0x911d,
1610 			    "%s: WARNING: no active sa_index for nport_handle 0x%x, forcing delete for sa_index 0x%x\n",
1611 			    __func__, fcport->loop_id, sa_index);
1612 			goto force_rx_delete;
1613 		}
1614 
1615 		/*
1616 		 * if we have a forced delete for rx, remove the sa_index from the edif list
1617 		 * and proceed with normal delete.  The rx delay timer should not be running
1618 		 */
1619 		if ((sa_frame.flags & SAU_FLG_FORCE_DELETE) == SAU_FLG_FORCE_DELETE) {
1620 			qla_edif_list_delete_sa_index(fcport, edif_entry);
1621 			ql_dbg(ql_dbg_edif, vha, 0x911d,
1622 			    "%s: FORCE DELETE flag found for nport_handle 0x%x, sa_index 0x%x, forcing DELETE\n",
1623 			    __func__, fcport->loop_id, sa_index);
1624 			kfree(edif_entry);
1625 			goto force_rx_delete;
1626 		}
1627 
1628 		/*
1629 		 * delayed rx delete
1630 		 *
1631 		 * if delete_sa_index is not invalid then there is already
1632 		 * a delayed index in progress, return bsg bad status
1633 		 */
1634 		if (edif_entry->delete_sa_index != INVALID_EDIF_SA_INDEX) {
1635 			struct edif_sa_ctl *sa_ctl;
1636 
1637 			ql_dbg(ql_dbg_edif, vha, 0x911d,
1638 			    "%s: delete for lid 0x%x, delete_sa_index %d is pending\n",
1639 			    __func__, edif_entry->handle, edif_entry->delete_sa_index);
1640 
1641 			/* free up the sa_ctl that was allocated with the sa_index */
1642 			sa_ctl = qla_edif_find_sa_ctl_by_index(fcport, sa_index,
1643 			    (sa_frame.flags & SAU_FLG_TX));
1644 			if (sa_ctl) {
1645 				ql_dbg(ql_dbg_edif, vha, 0x3063,
1646 				    "%s: freeing sa_ctl for index %d\n",
1647 				    __func__, sa_ctl->index);
1648 				qla_edif_free_sa_ctl(fcport, sa_ctl, sa_ctl->index);
1649 			}
1650 
1651 			/* release the sa_index */
1652 			ql_dbg(ql_dbg_edif, vha, 0x3063,
1653 			    "%s: freeing sa_index %d, nph: 0x%x\n",
1654 			    __func__, sa_index, nport_handle);
1655 			qla_edif_sadb_delete_sa_index(fcport, nport_handle, sa_index);
1656 
1657 			rval = -EINVAL;
1658 			SET_DID_STATUS(bsg_reply->result, DID_ERROR);
1659 			goto done;
1660 		}
1661 
1662 		fcport->edif.rekey_cnt++;
1663 
1664 		/* configure and start the rx delay timer */
1665 		edif_entry->fcport = fcport;
1666 		edif_entry->timer.expires = jiffies + RX_DELAY_DELETE_TIMEOUT * HZ;
1667 
1668 		ql_dbg(ql_dbg_edif, vha, 0x911d,
1669 		    "%s: adding timer, entry: %p, delete sa_index %d, lid 0x%x to edif_list\n",
1670 		    __func__, edif_entry, sa_index, nport_handle);
1671 
1672 		/*
1673 		 * Start the timer when we queue the delayed rx delete.
1674 		 * This is an activity timer that goes off if we have not
1675 		 * received packets with the new sa_index
1676 		 */
1677 		add_timer(&edif_entry->timer);
1678 
1679 		/*
1680 		 * sa_delete for rx key with an active rx key including this one
1681 		 * add the delete rx sa index to the hash so we can look for it
1682 		 * in the rsp queue.  Do this after making any changes to the
1683 		 * edif_entry as part of the rx delete.
1684 		 */
1685 
1686 		ql_dbg(ql_dbg_edif, vha, 0x911d,
1687 		    "%s: delete sa_index %d, lid 0x%x to edif_list. bsg done ptr %p\n",
1688 		    __func__, sa_index, nport_handle, bsg_job);
1689 
1690 		edif_entry->delete_sa_index = sa_index;
1691 
1692 		bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1693 		bsg_reply->result = DID_OK << 16;
1694 
1695 		goto done;
1696 
1697 	/*
1698 	 * rx index and update
1699 	 * add the index to the list and continue with normal update
1700 	 */
1701 	} else if (((sa_frame.flags & SAU_FLG_TX) == 0) &&
1702 	    ((sa_frame.flags & SAU_FLG_INV) == 0)) {
1703 		/* sa_update for rx key */
1704 		uint32_t nport_handle = fcport->loop_id;
1705 		uint16_t sa_index = sa_frame.fast_sa_index;
1706 		int result;
1707 
1708 		/*
1709 		 * add the update rx sa index to the hash so we can look for it
1710 		 * in the rsp queue and continue normally
1711 		 */
1712 
1713 		ql_dbg(ql_dbg_edif, vha, 0x911d,
1714 		    "%s:  adding update sa_index %d, lid 0x%x to edif_list\n",
1715 		    __func__, sa_index, nport_handle);
1716 
1717 		result = qla_edif_list_add_sa_update_index(fcport, sa_index,
1718 		    nport_handle);
1719 		if (result) {
1720 			ql_dbg(ql_dbg_edif, vha, 0x911d,
1721 			    "%s: SA_UPDATE failed to add new sa index %d to list for lid 0x%x\n",
1722 			    __func__, sa_index, nport_handle);
1723 		}
1724 	}
1725 	if (sa_frame.flags & SAU_FLG_GMAC_MODE)
1726 		fcport->edif.aes_gmac = 1;
1727 	else
1728 		fcport->edif.aes_gmac = 0;
1729 
1730 force_rx_delete:
1731 	/*
1732 	 * sa_update for both rx and tx keys, sa_delete for tx key
1733 	 * immediately process the request
1734 	 */
1735 	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
1736 	if (!sp) {
1737 		rval = -ENOMEM;
1738 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
1739 		goto done;
1740 	}
1741 
1742 	sp->type = SRB_SA_UPDATE;
1743 	sp->name = "bsg_sa_update";
1744 	sp->u.bsg_job = bsg_job;
1745 	/* sp->free = qla2x00_bsg_sp_free; */
1746 	sp->free = qla2x00_rel_sp;
1747 	sp->done = qla2x00_bsg_job_done;
1748 	iocb_cmd = &sp->u.iocb_cmd;
1749 	iocb_cmd->u.sa_update.sa_frame  = sa_frame;
1750 	cnt = 0;
1751 retry:
1752 	rval = qla2x00_start_sp(sp);
1753 	switch (rval) {
1754 	case QLA_SUCCESS:
1755 		break;
1756 	case EAGAIN:
1757 		msleep(EDIF_MSLEEP_INTERVAL);
1758 		cnt++;
1759 		if (cnt < EDIF_RETRY_COUNT)
1760 			goto retry;
1761 
1762 		fallthrough;
1763 	default:
1764 		ql_log(ql_dbg_edif, vha, 0x70e3,
1765 		       "%s qla2x00_start_sp failed=%d.\n",
1766 		       __func__, rval);
1767 
1768 		qla2x00_rel_sp(sp);
1769 		rval = -EIO;
1770 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
1771 		goto done;
1772 	}
1773 
1774 	ql_dbg(ql_dbg_edif, vha, 0x911d,
1775 	    "%s:  %s sent, hdl=%x, portid=%06x.\n",
1776 	    __func__, sp->name, sp->handle, fcport->d_id.b24);
1777 
1778 	fcport->edif.rekey_cnt++;
1779 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1780 	SET_DID_STATUS(bsg_reply->result, DID_OK);
1781 
1782 	return 0;
1783 
1784 /*
1785  * send back error status
1786  */
1787 done:
1788 	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1789 	ql_dbg(ql_dbg_edif, vha, 0x911d,
1790 	    "%s:status: FAIL, result: 0x%x, bsg ptr done %p\n",
1791 	    __func__, bsg_reply->result, bsg_job);
1792 	bsg_job_done(bsg_job, bsg_reply->result,
1793 	    bsg_reply->reply_payload_rcv_len);
1794 
1795 	return 0;
1796 }
1797 
1798 static void
qla_enode_free(scsi_qla_host_t * vha,struct enode * node)1799 qla_enode_free(scsi_qla_host_t *vha, struct enode *node)
1800 {
1801 	node->ntype = N_UNDEF;
1802 	kfree(node);
1803 }
1804 
1805 /**
1806  * qla_enode_init - initialize enode structs & lock
1807  * @vha: host adapter pointer
1808  *
1809  * should only be called when driver attaching
1810  */
1811 void
qla_enode_init(scsi_qla_host_t * vha)1812 qla_enode_init(scsi_qla_host_t *vha)
1813 {
1814 	struct	qla_hw_data *ha = vha->hw;
1815 	char	name[32];
1816 
1817 	if (vha->pur_cinfo.enode_flags == ENODE_ACTIVE) {
1818 		/* list still active - error */
1819 		ql_dbg(ql_dbg_edif, vha, 0x09102, "%s enode still active\n",
1820 		    __func__);
1821 		return;
1822 	}
1823 
1824 	/* initialize lock which protects pur_core & init list */
1825 	spin_lock_init(&vha->pur_cinfo.pur_lock);
1826 	INIT_LIST_HEAD(&vha->pur_cinfo.head);
1827 
1828 	snprintf(name, sizeof(name), "%s_%d_purex", QLA2XXX_DRIVER_NAME,
1829 	    ha->pdev->device);
1830 }
1831 
1832 /**
1833  * qla_enode_stop - stop and clear and enode data
1834  * @vha: host adapter pointer
1835  *
1836  * called when app notified it is exiting
1837  */
1838 void
qla_enode_stop(scsi_qla_host_t * vha)1839 qla_enode_stop(scsi_qla_host_t *vha)
1840 {
1841 	unsigned long flags;
1842 	struct enode *node, *q;
1843 
1844 	if (vha->pur_cinfo.enode_flags != ENODE_ACTIVE) {
1845 		/* doorbell list not enabled */
1846 		ql_dbg(ql_dbg_edif, vha, 0x09102,
1847 		    "%s enode not active\n", __func__);
1848 		return;
1849 	}
1850 
1851 	/* grab lock so list doesn't move */
1852 	spin_lock_irqsave(&vha->pur_cinfo.pur_lock, flags);
1853 
1854 	vha->pur_cinfo.enode_flags &= ~ENODE_ACTIVE; /* mark it not active */
1855 
1856 	/* hopefully this is a null list at this point */
1857 	list_for_each_entry_safe(node, q, &vha->pur_cinfo.head, list) {
1858 		ql_dbg(ql_dbg_edif, vha, 0x910f,
1859 		    "%s freeing enode type=%x, cnt=%x\n", __func__, node->ntype,
1860 		    node->dinfo.nodecnt);
1861 		list_del_init(&node->list);
1862 		qla_enode_free(vha, node);
1863 	}
1864 	spin_unlock_irqrestore(&vha->pur_cinfo.pur_lock, flags);
1865 }
1866 
qla_enode_clear(scsi_qla_host_t * vha,port_id_t portid)1867 static void qla_enode_clear(scsi_qla_host_t *vha, port_id_t portid)
1868 {
1869 	unsigned    long flags;
1870 	struct enode    *e, *tmp;
1871 	struct purexevent   *purex;
1872 	LIST_HEAD(enode_list);
1873 
1874 	if (vha->pur_cinfo.enode_flags != ENODE_ACTIVE) {
1875 		ql_dbg(ql_dbg_edif, vha, 0x09102,
1876 		       "%s enode not active\n", __func__);
1877 		return;
1878 	}
1879 	spin_lock_irqsave(&vha->pur_cinfo.pur_lock, flags);
1880 	list_for_each_entry_safe(e, tmp, &vha->pur_cinfo.head, list) {
1881 		purex = &e->u.purexinfo;
1882 		if (purex->pur_info.pur_sid.b24 == portid.b24) {
1883 			ql_dbg(ql_dbg_edif, vha, 0x911d,
1884 			    "%s free ELS sid=%06x. xchg %x, nb=%xh\n",
1885 			    __func__, portid.b24,
1886 			    purex->pur_info.pur_rx_xchg_address,
1887 			    purex->pur_info.pur_bytes_rcvd);
1888 
1889 			list_del_init(&e->list);
1890 			list_add_tail(&e->list, &enode_list);
1891 		}
1892 	}
1893 	spin_unlock_irqrestore(&vha->pur_cinfo.pur_lock, flags);
1894 
1895 	list_for_each_entry_safe(e, tmp, &enode_list, list) {
1896 		list_del_init(&e->list);
1897 		qla_enode_free(vha, e);
1898 	}
1899 }
1900 
1901 /*
1902  *  allocate enode struct and populate buffer
1903  *  returns: enode pointer with buffers
1904  *           NULL on error
1905  */
1906 static struct enode *
qla_enode_alloc(scsi_qla_host_t * vha,uint32_t ntype)1907 qla_enode_alloc(scsi_qla_host_t *vha, uint32_t ntype)
1908 {
1909 	struct enode		*node;
1910 	struct purexevent	*purex;
1911 
1912 	node = kzalloc(RX_ELS_SIZE, GFP_ATOMIC);
1913 	if (!node)
1914 		return NULL;
1915 
1916 	purex = &node->u.purexinfo;
1917 	purex->msgp = (u8 *)(node + 1);
1918 	purex->msgp_len = ELS_MAX_PAYLOAD;
1919 
1920 	node->ntype = ntype;
1921 	INIT_LIST_HEAD(&node->list);
1922 	return node;
1923 }
1924 
1925 static void
qla_enode_add(scsi_qla_host_t * vha,struct enode * ptr)1926 qla_enode_add(scsi_qla_host_t *vha, struct enode *ptr)
1927 {
1928 	unsigned long flags;
1929 
1930 	ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x9109,
1931 	    "%s add enode for type=%x, cnt=%x\n",
1932 	    __func__, ptr->ntype, ptr->dinfo.nodecnt);
1933 
1934 	spin_lock_irqsave(&vha->pur_cinfo.pur_lock, flags);
1935 	list_add_tail(&ptr->list, &vha->pur_cinfo.head);
1936 	spin_unlock_irqrestore(&vha->pur_cinfo.pur_lock, flags);
1937 
1938 	return;
1939 }
1940 
1941 static struct enode *
qla_enode_find(scsi_qla_host_t * vha,uint32_t ntype,uint32_t p1,uint32_t p2)1942 qla_enode_find(scsi_qla_host_t *vha, uint32_t ntype, uint32_t p1, uint32_t p2)
1943 {
1944 	struct enode		*node_rtn = NULL;
1945 	struct enode		*list_node, *q;
1946 	unsigned long		flags;
1947 	uint32_t		sid;
1948 	struct purexevent	*purex;
1949 
1950 	/* secure the list from moving under us */
1951 	spin_lock_irqsave(&vha->pur_cinfo.pur_lock, flags);
1952 
1953 	list_for_each_entry_safe(list_node, q, &vha->pur_cinfo.head, list) {
1954 
1955 		/* node type determines what p1 and p2 are */
1956 		purex = &list_node->u.purexinfo;
1957 		sid = p1;
1958 
1959 		if (purex->pur_info.pur_sid.b24 == sid) {
1960 			/* found it and its complete */
1961 			node_rtn = list_node;
1962 			list_del(&list_node->list);
1963 			break;
1964 		}
1965 	}
1966 
1967 	spin_unlock_irqrestore(&vha->pur_cinfo.pur_lock, flags);
1968 
1969 	return node_rtn;
1970 }
1971 
1972 /**
1973  * qla_pur_get_pending - read/return authentication message sent
1974  *  from remote port
1975  * @vha: host adapter pointer
1976  * @fcport: session pointer
1977  * @bsg_job: user request where the message is copy to.
1978  */
1979 static int
qla_pur_get_pending(scsi_qla_host_t * vha,fc_port_t * fcport,struct bsg_job * bsg_job)1980 qla_pur_get_pending(scsi_qla_host_t *vha, fc_port_t *fcport,
1981 	struct bsg_job *bsg_job)
1982 {
1983 	struct enode		*ptr;
1984 	struct purexevent	*purex;
1985 	struct qla_bsg_auth_els_reply *rpl =
1986 	    (struct qla_bsg_auth_els_reply *)bsg_job->reply;
1987 
1988 	bsg_job->reply_len = sizeof(*rpl);
1989 
1990 	ptr = qla_enode_find(vha, N_PUREX, fcport->d_id.b24, PUR_GET);
1991 	if (!ptr) {
1992 		ql_dbg(ql_dbg_edif, vha, 0x9111,
1993 		    "%s no enode data found for %8phN sid=%06x\n",
1994 		    __func__, fcport->port_name, fcport->d_id.b24);
1995 		SET_DID_STATUS(rpl->r.result, DID_IMM_RETRY);
1996 		return -EIO;
1997 	}
1998 
1999 	/*
2000 	 * enode is now off the linked list and is ours to deal with
2001 	 */
2002 	purex = &ptr->u.purexinfo;
2003 
2004 	/* Copy info back to caller */
2005 	rpl->rx_xchg_address = purex->pur_info.pur_rx_xchg_address;
2006 
2007 	SET_DID_STATUS(rpl->r.result, DID_OK);
2008 	rpl->r.reply_payload_rcv_len =
2009 	    sg_pcopy_from_buffer(bsg_job->reply_payload.sg_list,
2010 		bsg_job->reply_payload.sg_cnt, purex->msgp,
2011 		purex->pur_info.pur_bytes_rcvd, 0);
2012 
2013 	/* data copy / passback completed - destroy enode */
2014 	qla_enode_free(vha, ptr);
2015 
2016 	return 0;
2017 }
2018 
2019 /* it is assume qpair lock is held */
2020 static int
qla_els_reject_iocb(scsi_qla_host_t * vha,struct qla_qpair * qp,struct qla_els_pt_arg * a)2021 qla_els_reject_iocb(scsi_qla_host_t *vha, struct qla_qpair *qp,
2022 	struct qla_els_pt_arg *a)
2023 {
2024 	struct els_entry_24xx *els_iocb;
2025 
2026 	els_iocb = __qla2x00_alloc_iocbs(qp, NULL);
2027 	if (!els_iocb) {
2028 		ql_log(ql_log_warn, vha, 0x700c,
2029 		    "qla2x00_alloc_iocbs failed.\n");
2030 		return QLA_FUNCTION_FAILED;
2031 	}
2032 
2033 	qla_els_pt_iocb(vha, els_iocb, a);
2034 
2035 	ql_dbg(ql_dbg_edif, vha, 0x0183,
2036 	    "Sending ELS reject ox_id %04x s:%06x -> d:%06x\n",
2037 	    a->ox_id, a->sid.b24, a->did.b24);
2038 	ql_dump_buffer(ql_dbg_edif + ql_dbg_verbose, vha, 0x0185,
2039 	    vha->hw->elsrej.c, sizeof(*vha->hw->elsrej.c));
2040 	/* flush iocb to mem before notifying hw doorbell */
2041 	wmb();
2042 	qla2x00_start_iocbs(vha, qp->req);
2043 	return 0;
2044 }
2045 
2046 void
qla_edb_init(scsi_qla_host_t * vha)2047 qla_edb_init(scsi_qla_host_t *vha)
2048 {
2049 	if (DBELL_ACTIVE(vha)) {
2050 		/* list already init'd - error */
2051 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2052 		    "edif db already initialized, cannot reinit\n");
2053 		return;
2054 	}
2055 
2056 	/* initialize lock which protects doorbell & init list */
2057 	spin_lock_init(&vha->e_dbell.db_lock);
2058 	INIT_LIST_HEAD(&vha->e_dbell.head);
2059 }
2060 
qla_edb_clear(scsi_qla_host_t * vha,port_id_t portid)2061 static void qla_edb_clear(scsi_qla_host_t *vha, port_id_t portid)
2062 {
2063 	unsigned long flags;
2064 	struct edb_node *e, *tmp;
2065 	port_id_t sid;
2066 	LIST_HEAD(edb_list);
2067 
2068 	if (DBELL_INACTIVE(vha)) {
2069 		/* doorbell list not enabled */
2070 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2071 		       "%s doorbell not enabled\n", __func__);
2072 		return;
2073 	}
2074 
2075 	/* grab lock so list doesn't move */
2076 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
2077 	list_for_each_entry_safe(e, tmp, &vha->e_dbell.head, list) {
2078 		switch (e->ntype) {
2079 		case VND_CMD_AUTH_STATE_NEEDED:
2080 		case VND_CMD_AUTH_STATE_SESSION_SHUTDOWN:
2081 			sid = e->u.plogi_did;
2082 			break;
2083 		case VND_CMD_AUTH_STATE_ELS_RCVD:
2084 			sid = e->u.els_sid;
2085 			break;
2086 		case VND_CMD_AUTH_STATE_SAUPDATE_COMPL:
2087 			/* app wants to see this  */
2088 			continue;
2089 		default:
2090 			ql_log(ql_log_warn, vha, 0x09102,
2091 			       "%s unknown node type: %x\n", __func__, e->ntype);
2092 			sid.b24 = 0;
2093 			break;
2094 		}
2095 		if (sid.b24 == portid.b24) {
2096 			ql_dbg(ql_dbg_edif, vha, 0x910f,
2097 			       "%s free doorbell event : node type = %x %p\n",
2098 			       __func__, e->ntype, e);
2099 			list_del_init(&e->list);
2100 			list_add_tail(&e->list, &edb_list);
2101 		}
2102 	}
2103 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
2104 
2105 	list_for_each_entry_safe(e, tmp, &edb_list, list)
2106 		qla_edb_node_free(vha, e);
2107 }
2108 
2109 /* function called when app is stopping */
2110 
2111 void
qla_edb_stop(scsi_qla_host_t * vha)2112 qla_edb_stop(scsi_qla_host_t *vha)
2113 {
2114 	unsigned long flags;
2115 	struct edb_node *node, *q;
2116 
2117 	if (DBELL_INACTIVE(vha)) {
2118 		/* doorbell list not enabled */
2119 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2120 		    "%s doorbell not enabled\n", __func__);
2121 		return;
2122 	}
2123 
2124 	/* grab lock so list doesn't move */
2125 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
2126 
2127 	vha->e_dbell.db_flags &= ~EDB_ACTIVE; /* mark it not active */
2128 	/* hopefully this is a null list at this point */
2129 	list_for_each_entry_safe(node, q, &vha->e_dbell.head, list) {
2130 		ql_dbg(ql_dbg_edif, vha, 0x910f,
2131 		    "%s freeing edb_node type=%x\n",
2132 		    __func__, node->ntype);
2133 		qla_edb_node_free(vha, node);
2134 	}
2135 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
2136 
2137 	qla_edif_dbell_bsg_done(vha);
2138 }
2139 
2140 static struct edb_node *
qla_edb_node_alloc(scsi_qla_host_t * vha,uint32_t ntype)2141 qla_edb_node_alloc(scsi_qla_host_t *vha, uint32_t ntype)
2142 {
2143 	struct edb_node	*node;
2144 
2145 	node = kzalloc(sizeof(*node), GFP_ATOMIC);
2146 	if (!node) {
2147 		/* couldn't get space */
2148 		ql_dbg(ql_dbg_edif, vha, 0x9100,
2149 		    "edb node unable to be allocated\n");
2150 		return NULL;
2151 	}
2152 
2153 	node->ntype = ntype;
2154 	INIT_LIST_HEAD(&node->list);
2155 	return node;
2156 }
2157 
2158 /* adds a already allocated enode to the linked list */
2159 static bool
qla_edb_node_add(scsi_qla_host_t * vha,struct edb_node * ptr)2160 qla_edb_node_add(scsi_qla_host_t *vha, struct edb_node *ptr)
2161 {
2162 	unsigned long		flags;
2163 
2164 	if (DBELL_INACTIVE(vha)) {
2165 		/* doorbell list not enabled */
2166 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2167 		    "%s doorbell not enabled\n", __func__);
2168 		return false;
2169 	}
2170 
2171 	spin_lock_irqsave(&vha->e_dbell.db_lock, flags);
2172 	list_add_tail(&ptr->list, &vha->e_dbell.head);
2173 	spin_unlock_irqrestore(&vha->e_dbell.db_lock, flags);
2174 
2175 	return true;
2176 }
2177 
2178 /* adds event to doorbell list */
2179 void
qla_edb_eventcreate(scsi_qla_host_t * vha,uint32_t dbtype,uint32_t data,uint32_t data2,fc_port_t * sfcport)2180 qla_edb_eventcreate(scsi_qla_host_t *vha, uint32_t dbtype,
2181 	uint32_t data, uint32_t data2, fc_port_t	*sfcport)
2182 {
2183 	struct edb_node	*edbnode;
2184 	fc_port_t *fcport = sfcport;
2185 	port_id_t id;
2186 
2187 	if (!vha->hw->flags.edif_enabled) {
2188 		/* edif not enabled */
2189 		return;
2190 	}
2191 
2192 	if (DBELL_INACTIVE(vha)) {
2193 		if (fcport)
2194 			fcport->edif.auth_state = dbtype;
2195 		/* doorbell list not enabled */
2196 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2197 		    "%s doorbell not enabled (type=%d\n", __func__, dbtype);
2198 		return;
2199 	}
2200 
2201 	edbnode = qla_edb_node_alloc(vha, dbtype);
2202 	if (!edbnode) {
2203 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2204 		    "%s unable to alloc db node\n", __func__);
2205 		return;
2206 	}
2207 
2208 	if (!fcport) {
2209 		id.b.domain = (data >> 16) & 0xff;
2210 		id.b.area = (data >> 8) & 0xff;
2211 		id.b.al_pa = data & 0xff;
2212 		ql_dbg(ql_dbg_edif, vha, 0x09222,
2213 		    "%s: Arrived s_id: %06x\n", __func__,
2214 		    id.b24);
2215 		fcport = qla2x00_find_fcport_by_pid(vha, &id);
2216 		if (!fcport) {
2217 			ql_dbg(ql_dbg_edif, vha, 0x09102,
2218 			    "%s can't find fcport for sid= 0x%x - ignoring\n",
2219 			__func__, id.b24);
2220 			kfree(edbnode);
2221 			return;
2222 		}
2223 	}
2224 
2225 	/* populate the edb node */
2226 	switch (dbtype) {
2227 	case VND_CMD_AUTH_STATE_NEEDED:
2228 	case VND_CMD_AUTH_STATE_SESSION_SHUTDOWN:
2229 		edbnode->u.plogi_did.b24 = fcport->d_id.b24;
2230 		break;
2231 	case VND_CMD_AUTH_STATE_ELS_RCVD:
2232 		edbnode->u.els_sid.b24 = fcport->d_id.b24;
2233 		break;
2234 	case VND_CMD_AUTH_STATE_SAUPDATE_COMPL:
2235 		edbnode->u.sa_aen.port_id = fcport->d_id;
2236 		edbnode->u.sa_aen.status =  data;
2237 		edbnode->u.sa_aen.key_type =  data2;
2238 		edbnode->u.sa_aen.version = EDIF_VERSION1;
2239 		break;
2240 	default:
2241 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2242 			"%s unknown type: %x\n", __func__, dbtype);
2243 		kfree(edbnode);
2244 		edbnode = NULL;
2245 		break;
2246 	}
2247 
2248 	if (edbnode) {
2249 		if (!qla_edb_node_add(vha, edbnode)) {
2250 			ql_dbg(ql_dbg_edif, vha, 0x09102,
2251 			    "%s unable to add dbnode\n", __func__);
2252 			kfree(edbnode);
2253 			return;
2254 		}
2255 		ql_dbg(ql_dbg_edif, vha, 0x09102,
2256 		    "%s Doorbell produced : type=%d %p\n", __func__, dbtype, edbnode);
2257 		qla_edif_dbell_bsg_done(vha);
2258 		if (fcport)
2259 			fcport->edif.auth_state = dbtype;
2260 	}
2261 }
2262 
2263 void
qla_edif_timer(scsi_qla_host_t * vha)2264 qla_edif_timer(scsi_qla_host_t *vha)
2265 {
2266 	struct qla_hw_data *ha = vha->hw;
2267 
2268 	if (!vha->vp_idx && N2N_TOPO(ha) && ha->flags.n2n_fw_acc_sec) {
2269 		if (DBELL_INACTIVE(vha) &&
2270 		    ha->edif_post_stop_cnt_down) {
2271 			ha->edif_post_stop_cnt_down--;
2272 
2273 			/*
2274 			 * turn off auto 'Plogi Acc + secure=1' feature
2275 			 * Set Add FW option[3]
2276 			 * BIT_15, if.
2277 			 */
2278 			if (ha->edif_post_stop_cnt_down == 0) {
2279 				ql_dbg(ql_dbg_async, vha, 0x911d,
2280 				       "%s chip reset to turn off PLOGI ACC + secure\n",
2281 				       __func__);
2282 				set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2283 			}
2284 		} else {
2285 			ha->edif_post_stop_cnt_down = 60;
2286 		}
2287 	}
2288 
2289 	if (vha->e_dbell.dbell_bsg_job && time_after_eq(jiffies, vha->e_dbell.bsg_expire))
2290 		qla_edif_dbell_bsg_done(vha);
2291 }
2292 
qla_noop_sp_done(srb_t * sp,int res)2293 static void qla_noop_sp_done(srb_t *sp, int res)
2294 {
2295 	sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
2296 	/* ref: INIT */
2297 	kref_put(&sp->cmd_kref, qla2x00_sp_release);
2298 }
2299 
2300 /*
2301  * Called from work queue
2302  * build and send the sa_update iocb to delete an rx sa_index
2303  */
2304 int
qla24xx_issue_sa_replace_iocb(scsi_qla_host_t * vha,struct qla_work_evt * e)2305 qla24xx_issue_sa_replace_iocb(scsi_qla_host_t *vha, struct qla_work_evt *e)
2306 {
2307 	srb_t *sp;
2308 	fc_port_t	*fcport = NULL;
2309 	struct srb_iocb *iocb_cmd = NULL;
2310 	int rval = QLA_SUCCESS;
2311 	struct	edif_sa_ctl *sa_ctl = e->u.sa_update.sa_ctl;
2312 	uint16_t nport_handle = e->u.sa_update.nport_handle;
2313 
2314 	ql_dbg(ql_dbg_edif, vha, 0x70e6,
2315 	    "%s: starting,  sa_ctl: %p\n", __func__, sa_ctl);
2316 
2317 	if (!sa_ctl) {
2318 		ql_dbg(ql_dbg_edif, vha, 0x70e6,
2319 		    "sa_ctl allocation failed\n");
2320 		rval =  -ENOMEM;
2321 		goto done;
2322 	}
2323 
2324 	fcport = sa_ctl->fcport;
2325 
2326 	/* Alloc SRB structure */
2327 	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
2328 	if (!sp) {
2329 		ql_dbg(ql_dbg_edif, vha, 0x70e6,
2330 		 "SRB allocation failed\n");
2331 		rval = -ENOMEM;
2332 		goto done;
2333 	}
2334 
2335 	fcport->flags |= FCF_ASYNC_SENT;
2336 	iocb_cmd = &sp->u.iocb_cmd;
2337 	iocb_cmd->u.sa_update.sa_ctl = sa_ctl;
2338 
2339 	ql_dbg(ql_dbg_edif, vha, 0x3073,
2340 	    "Enter: SA REPL portid=%06x, sa_ctl %p, index %x, nport_handle: 0x%x\n",
2341 	    fcport->d_id.b24, sa_ctl, sa_ctl->index, nport_handle);
2342 	/*
2343 	 * if this is a sadb cleanup delete, mark it so the isr can
2344 	 * take the correct action
2345 	 */
2346 	if (sa_ctl->flags & EDIF_SA_CTL_FLG_CLEANUP_DEL) {
2347 		/* mark this srb as a cleanup delete */
2348 		sp->flags |= SRB_EDIF_CLEANUP_DELETE;
2349 		ql_dbg(ql_dbg_edif, vha, 0x70e6,
2350 		    "%s: sp 0x%p flagged as cleanup delete\n", __func__, sp);
2351 	}
2352 
2353 	sp->type = SRB_SA_REPLACE;
2354 	sp->name = "SA_REPLACE";
2355 	sp->fcport = fcport;
2356 	sp->free = qla2x00_rel_sp;
2357 	sp->done = qla_noop_sp_done;
2358 
2359 	rval = qla2x00_start_sp(sp);
2360 
2361 	if (rval != QLA_SUCCESS) {
2362 		goto done_free_sp;
2363 	}
2364 
2365 	return rval;
2366 done_free_sp:
2367 	kref_put(&sp->cmd_kref, qla2x00_sp_release);
2368 	fcport->flags &= ~FCF_ASYNC_SENT;
2369 done:
2370 	fcport->flags &= ~FCF_ASYNC_ACTIVE;
2371 	return rval;
2372 }
2373 
qla24xx_sa_update_iocb(srb_t * sp,struct sa_update_28xx * sa_update_iocb)2374 void qla24xx_sa_update_iocb(srb_t *sp, struct sa_update_28xx *sa_update_iocb)
2375 {
2376 	int	itr = 0;
2377 	struct	scsi_qla_host		*vha = sp->vha;
2378 	struct	qla_sa_update_frame	*sa_frame =
2379 		&sp->u.iocb_cmd.u.sa_update.sa_frame;
2380 	u8 flags = 0;
2381 
2382 	switch (sa_frame->flags & (SAU_FLG_INV | SAU_FLG_TX)) {
2383 	case 0:
2384 		ql_dbg(ql_dbg_edif, vha, 0x911d,
2385 		    "%s: EDIF SA UPDATE RX IOCB  vha: 0x%p  index: %d\n",
2386 		    __func__, vha, sa_frame->fast_sa_index);
2387 		break;
2388 	case 1:
2389 		ql_dbg(ql_dbg_edif, vha, 0x911d,
2390 		    "%s: EDIF SA DELETE RX IOCB  vha: 0x%p  index: %d\n",
2391 		    __func__, vha, sa_frame->fast_sa_index);
2392 		flags |= SA_FLAG_INVALIDATE;
2393 		break;
2394 	case 2:
2395 		ql_dbg(ql_dbg_edif, vha, 0x911d,
2396 		    "%s: EDIF SA UPDATE TX IOCB  vha: 0x%p  index: %d\n",
2397 		    __func__, vha, sa_frame->fast_sa_index);
2398 		flags |= SA_FLAG_TX;
2399 		break;
2400 	case 3:
2401 		ql_dbg(ql_dbg_edif, vha, 0x911d,
2402 		    "%s: EDIF SA DELETE TX IOCB  vha: 0x%p  index: %d\n",
2403 		    __func__, vha, sa_frame->fast_sa_index);
2404 		flags |= SA_FLAG_TX | SA_FLAG_INVALIDATE;
2405 		break;
2406 	}
2407 
2408 	sa_update_iocb->entry_type = SA_UPDATE_IOCB_TYPE;
2409 	sa_update_iocb->entry_count = 1;
2410 	sa_update_iocb->sys_define = 0;
2411 	sa_update_iocb->entry_status = 0;
2412 	sa_update_iocb->handle = sp->handle;
2413 	sa_update_iocb->u.nport_handle = cpu_to_le16(sp->fcport->loop_id);
2414 	sa_update_iocb->vp_index = sp->fcport->vha->vp_idx;
2415 	sa_update_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
2416 	sa_update_iocb->port_id[1] = sp->fcport->d_id.b.area;
2417 	sa_update_iocb->port_id[2] = sp->fcport->d_id.b.domain;
2418 
2419 	sa_update_iocb->flags = flags;
2420 	sa_update_iocb->salt = cpu_to_le32(sa_frame->salt);
2421 	sa_update_iocb->spi = cpu_to_le32(sa_frame->spi);
2422 	sa_update_iocb->sa_index = cpu_to_le16(sa_frame->fast_sa_index);
2423 
2424 	sa_update_iocb->sa_control |= SA_CNTL_ENC_FCSP;
2425 	if (sp->fcport->edif.aes_gmac)
2426 		sa_update_iocb->sa_control |= SA_CNTL_AES_GMAC;
2427 
2428 	if (sa_frame->flags & SAU_FLG_KEY256) {
2429 		sa_update_iocb->sa_control |= SA_CNTL_KEY256;
2430 		for (itr = 0; itr < 32; itr++)
2431 			sa_update_iocb->sa_key[itr] = sa_frame->sa_key[itr];
2432 	} else {
2433 		sa_update_iocb->sa_control |= SA_CNTL_KEY128;
2434 		for (itr = 0; itr < 16; itr++)
2435 			sa_update_iocb->sa_key[itr] = sa_frame->sa_key[itr];
2436 	}
2437 
2438 	ql_dbg(ql_dbg_edif, vha, 0x921d,
2439 	    "%s SAU Port ID = %02x%02x%02x, flags=%xh, index=%u, ctl=%xh, SPI 0x%x flags 0x%x hdl=%x gmac %d\n",
2440 	    __func__, sa_update_iocb->port_id[2], sa_update_iocb->port_id[1],
2441 	    sa_update_iocb->port_id[0], sa_update_iocb->flags, sa_update_iocb->sa_index,
2442 	    sa_update_iocb->sa_control, sa_update_iocb->spi, sa_frame->flags, sp->handle,
2443 	    sp->fcport->edif.aes_gmac);
2444 
2445 	if (sa_frame->flags & SAU_FLG_TX)
2446 		sp->fcport->edif.tx_sa_pending = 1;
2447 	else
2448 		sp->fcport->edif.rx_sa_pending = 1;
2449 
2450 	sp->fcport->vha->qla_stats.control_requests++;
2451 }
2452 
2453 void
qla24xx_sa_replace_iocb(srb_t * sp,struct sa_update_28xx * sa_update_iocb)2454 qla24xx_sa_replace_iocb(srb_t *sp, struct sa_update_28xx *sa_update_iocb)
2455 {
2456 	struct	scsi_qla_host		*vha = sp->vha;
2457 	struct srb_iocb *srb_iocb = &sp->u.iocb_cmd;
2458 	struct	edif_sa_ctl		*sa_ctl = srb_iocb->u.sa_update.sa_ctl;
2459 	uint16_t nport_handle = sp->fcport->loop_id;
2460 
2461 	sa_update_iocb->entry_type = SA_UPDATE_IOCB_TYPE;
2462 	sa_update_iocb->entry_count = 1;
2463 	sa_update_iocb->sys_define = 0;
2464 	sa_update_iocb->entry_status = 0;
2465 	sa_update_iocb->handle = sp->handle;
2466 
2467 	sa_update_iocb->u.nport_handle = cpu_to_le16(nport_handle);
2468 
2469 	sa_update_iocb->vp_index = sp->fcport->vha->vp_idx;
2470 	sa_update_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
2471 	sa_update_iocb->port_id[1] = sp->fcport->d_id.b.area;
2472 	sa_update_iocb->port_id[2] = sp->fcport->d_id.b.domain;
2473 
2474 	/* Invalidate the index. salt, spi, control & key are ignore */
2475 	sa_update_iocb->flags = SA_FLAG_INVALIDATE;
2476 	sa_update_iocb->salt = 0;
2477 	sa_update_iocb->spi = 0;
2478 	sa_update_iocb->sa_index = cpu_to_le16(sa_ctl->index);
2479 	sa_update_iocb->sa_control = 0;
2480 
2481 	ql_dbg(ql_dbg_edif, vha, 0x921d,
2482 	    "%s SAU DELETE RX Port ID = %02x:%02x:%02x, lid %d flags=%xh, index=%u, hdl=%x\n",
2483 	    __func__, sa_update_iocb->port_id[2], sa_update_iocb->port_id[1],
2484 	    sa_update_iocb->port_id[0], nport_handle, sa_update_iocb->flags,
2485 	    sa_update_iocb->sa_index, sp->handle);
2486 
2487 	sp->fcport->vha->qla_stats.control_requests++;
2488 }
2489 
qla24xx_auth_els(scsi_qla_host_t * vha,void ** pkt,struct rsp_que ** rsp)2490 void qla24xx_auth_els(scsi_qla_host_t *vha, void **pkt, struct rsp_que **rsp)
2491 {
2492 	struct purex_entry_24xx *p = *pkt;
2493 	struct enode		*ptr;
2494 	int		sid;
2495 	u16 totlen;
2496 	struct purexevent	*purex;
2497 	struct scsi_qla_host *host = NULL;
2498 	int rc;
2499 	struct fc_port *fcport;
2500 	struct qla_els_pt_arg a;
2501 	be_id_t beid;
2502 
2503 	memset(&a, 0, sizeof(a));
2504 
2505 	a.els_opcode = ELS_AUTH_ELS;
2506 	a.nport_handle = p->nport_handle;
2507 	a.rx_xchg_address = p->rx_xchg_addr;
2508 	a.did.b.domain = p->s_id[2];
2509 	a.did.b.area   = p->s_id[1];
2510 	a.did.b.al_pa  = p->s_id[0];
2511 	a.tx_byte_count = a.tx_len = sizeof(struct fc_els_ls_rjt);
2512 	a.tx_addr = vha->hw->elsrej.cdma;
2513 	a.vp_idx = vha->vp_idx;
2514 	a.control_flags = EPD_ELS_RJT;
2515 	a.ox_id = le16_to_cpu(p->ox_id);
2516 
2517 	sid = p->s_id[0] | (p->s_id[1] << 8) | (p->s_id[2] << 16);
2518 
2519 	totlen = (le16_to_cpu(p->frame_size) & 0x0fff) - PURX_ELS_HEADER_SIZE;
2520 	if (le16_to_cpu(p->status_flags) & 0x8000) {
2521 		totlen = le16_to_cpu(p->trunc_frame_size);
2522 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2523 		__qla_consume_iocb(vha, pkt, rsp);
2524 		return;
2525 	}
2526 
2527 	if (totlen > ELS_MAX_PAYLOAD) {
2528 		ql_dbg(ql_dbg_edif, vha, 0x0910d,
2529 		    "%s WARNING: verbose ELS frame received (totlen=%x)\n",
2530 		    __func__, totlen);
2531 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2532 		__qla_consume_iocb(vha, pkt, rsp);
2533 		return;
2534 	}
2535 
2536 	if (!vha->hw->flags.edif_enabled) {
2537 		/* edif support not enabled */
2538 		ql_dbg(ql_dbg_edif, vha, 0x910e, "%s edif not enabled\n",
2539 		    __func__);
2540 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2541 		__qla_consume_iocb(vha, pkt, rsp);
2542 		return;
2543 	}
2544 
2545 	ptr = qla_enode_alloc(vha, N_PUREX);
2546 	if (!ptr) {
2547 		ql_dbg(ql_dbg_edif, vha, 0x09109,
2548 		    "WARNING: enode alloc failed for sid=%x\n",
2549 		    sid);
2550 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2551 		__qla_consume_iocb(vha, pkt, rsp);
2552 		return;
2553 	}
2554 
2555 	purex = &ptr->u.purexinfo;
2556 	purex->pur_info.pur_sid = a.did;
2557 	purex->pur_info.pur_bytes_rcvd = totlen;
2558 	purex->pur_info.pur_rx_xchg_address = le32_to_cpu(p->rx_xchg_addr);
2559 	purex->pur_info.pur_nphdl = le16_to_cpu(p->nport_handle);
2560 	purex->pur_info.pur_did.b.domain =  p->d_id[2];
2561 	purex->pur_info.pur_did.b.area =  p->d_id[1];
2562 	purex->pur_info.pur_did.b.al_pa =  p->d_id[0];
2563 	purex->pur_info.vp_idx = p->vp_idx;
2564 
2565 	a.sid = purex->pur_info.pur_did;
2566 
2567 	rc = __qla_copy_purex_to_buffer(vha, pkt, rsp, purex->msgp,
2568 		purex->msgp_len);
2569 	if (rc) {
2570 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2571 		qla_enode_free(vha, ptr);
2572 		return;
2573 	}
2574 	beid.al_pa = purex->pur_info.pur_did.b.al_pa;
2575 	beid.area   = purex->pur_info.pur_did.b.area;
2576 	beid.domain = purex->pur_info.pur_did.b.domain;
2577 	host = qla_find_host_by_d_id(vha, beid);
2578 	if (!host) {
2579 		ql_log(ql_log_fatal, vha, 0x508b,
2580 		    "%s Drop ELS due to unable to find host %06x\n",
2581 		    __func__, purex->pur_info.pur_did.b24);
2582 
2583 		qla_els_reject_iocb(vha, (*rsp)->qpair, &a);
2584 		qla_enode_free(vha, ptr);
2585 		return;
2586 	}
2587 
2588 	fcport = qla2x00_find_fcport_by_pid(host, &purex->pur_info.pur_sid);
2589 
2590 	if (DBELL_INACTIVE(vha)) {
2591 		ql_dbg(ql_dbg_edif, host, 0x0910c, "%s e_dbell.db_flags =%x %06x\n",
2592 		    __func__, host->e_dbell.db_flags,
2593 		    fcport ? fcport->d_id.b24 : 0);
2594 
2595 		qla_els_reject_iocb(host, (*rsp)->qpair, &a);
2596 		qla_enode_free(host, ptr);
2597 		return;
2598 	}
2599 
2600 	if (fcport && EDIF_SESSION_DOWN(fcport)) {
2601 		ql_dbg(ql_dbg_edif, host, 0x13b6,
2602 		    "%s terminate exchange. Send logo to 0x%x\n",
2603 		    __func__, a.did.b24);
2604 
2605 		a.tx_byte_count = a.tx_len = 0;
2606 		a.tx_addr = 0;
2607 		a.control_flags = EPD_RX_XCHG;  /* EPD_RX_XCHG = terminate cmd */
2608 		qla_els_reject_iocb(host, (*rsp)->qpair, &a);
2609 		qla_enode_free(host, ptr);
2610 		/* send logo to let remote port knows to tear down session */
2611 		fcport->send_els_logo = 1;
2612 		qlt_schedule_sess_for_deletion(fcport);
2613 		return;
2614 	}
2615 
2616 	/* add the local enode to the list */
2617 	qla_enode_add(host, ptr);
2618 
2619 	ql_dbg(ql_dbg_edif, host, 0x0910c,
2620 	    "%s COMPLETE purex->pur_info.pur_bytes_rcvd =%xh s:%06x -> d:%06x xchg=%xh\n",
2621 	    __func__, purex->pur_info.pur_bytes_rcvd, purex->pur_info.pur_sid.b24,
2622 	    purex->pur_info.pur_did.b24, purex->pur_info.pur_rx_xchg_address);
2623 
2624 	qla_edb_eventcreate(host, VND_CMD_AUTH_STATE_ELS_RCVD, sid, 0, NULL);
2625 }
2626 
qla_edif_get_sa_index_from_freepool(fc_port_t * fcport,int dir)2627 static uint16_t  qla_edif_get_sa_index_from_freepool(fc_port_t *fcport, int dir)
2628 {
2629 	struct scsi_qla_host *vha = fcport->vha;
2630 	struct qla_hw_data *ha = vha->hw;
2631 	void *sa_id_map;
2632 	unsigned long flags = 0;
2633 	u16 sa_index;
2634 
2635 	ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x3063,
2636 	    "%s: entry\n", __func__);
2637 
2638 	if (dir)
2639 		sa_id_map = ha->edif_tx_sa_id_map;
2640 	else
2641 		sa_id_map = ha->edif_rx_sa_id_map;
2642 
2643 	spin_lock_irqsave(&ha->sadb_fp_lock, flags);
2644 	sa_index = find_first_zero_bit(sa_id_map, EDIF_NUM_SA_INDEX);
2645 	if (sa_index >=  EDIF_NUM_SA_INDEX) {
2646 		spin_unlock_irqrestore(&ha->sadb_fp_lock, flags);
2647 		return INVALID_EDIF_SA_INDEX;
2648 	}
2649 	set_bit(sa_index, sa_id_map);
2650 	spin_unlock_irqrestore(&ha->sadb_fp_lock, flags);
2651 
2652 	if (dir)
2653 		sa_index += EDIF_TX_SA_INDEX_BASE;
2654 
2655 	ql_dbg(ql_dbg_edif, vha, 0x3063,
2656 	    "%s: index retrieved from free pool %d\n", __func__, sa_index);
2657 
2658 	return sa_index;
2659 }
2660 
2661 /* find an sadb entry for an nport_handle */
2662 static struct edif_sa_index_entry *
qla_edif_sadb_find_sa_index_entry(uint16_t nport_handle,struct list_head * sa_list)2663 qla_edif_sadb_find_sa_index_entry(uint16_t nport_handle,
2664 		struct list_head *sa_list)
2665 {
2666 	struct edif_sa_index_entry *entry;
2667 	struct edif_sa_index_entry *tentry;
2668 	struct list_head *indx_list = sa_list;
2669 
2670 	list_for_each_entry_safe(entry, tentry, indx_list, next) {
2671 		if (entry->handle == nport_handle)
2672 			return entry;
2673 	}
2674 	return NULL;
2675 }
2676 
2677 /* remove an sa_index from the nport_handle and return it to the free pool */
qla_edif_sadb_delete_sa_index(fc_port_t * fcport,uint16_t nport_handle,uint16_t sa_index)2678 static int qla_edif_sadb_delete_sa_index(fc_port_t *fcport, uint16_t nport_handle,
2679 		uint16_t sa_index)
2680 {
2681 	struct edif_sa_index_entry *entry;
2682 	struct list_head *sa_list;
2683 	int dir = (sa_index < EDIF_TX_SA_INDEX_BASE) ? 0 : 1;
2684 	int slot = 0;
2685 	int free_slot_count = 0;
2686 	scsi_qla_host_t *vha = fcport->vha;
2687 	struct qla_hw_data *ha = vha->hw;
2688 	unsigned long flags = 0;
2689 
2690 	ql_dbg(ql_dbg_edif, vha, 0x3063,
2691 	    "%s: entry\n", __func__);
2692 
2693 	if (dir)
2694 		sa_list = &ha->sadb_tx_index_list;
2695 	else
2696 		sa_list = &ha->sadb_rx_index_list;
2697 
2698 	entry = qla_edif_sadb_find_sa_index_entry(nport_handle, sa_list);
2699 	if (!entry) {
2700 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2701 		    "%s: no entry found for nport_handle 0x%x\n",
2702 		    __func__, nport_handle);
2703 		return -1;
2704 	}
2705 
2706 	spin_lock_irqsave(&ha->sadb_lock, flags);
2707 	/*
2708 	 * each tx/rx direction has up to 2 sa indexes/slots. 1 slot for in flight traffic
2709 	 * the other is use at re-key time.
2710 	 */
2711 	for (slot = 0; slot < 2; slot++) {
2712 		if (entry->sa_pair[slot].sa_index == sa_index) {
2713 			entry->sa_pair[slot].sa_index = INVALID_EDIF_SA_INDEX;
2714 			entry->sa_pair[slot].spi = 0;
2715 			free_slot_count++;
2716 			qla_edif_add_sa_index_to_freepool(fcport, dir, sa_index);
2717 		} else if (entry->sa_pair[slot].sa_index == INVALID_EDIF_SA_INDEX) {
2718 			free_slot_count++;
2719 		}
2720 	}
2721 
2722 	if (free_slot_count == 2) {
2723 		list_del(&entry->next);
2724 		kfree(entry);
2725 	}
2726 	spin_unlock_irqrestore(&ha->sadb_lock, flags);
2727 
2728 	ql_dbg(ql_dbg_edif, vha, 0x3063,
2729 	    "%s: sa_index %d removed, free_slot_count: %d\n",
2730 	    __func__, sa_index, free_slot_count);
2731 
2732 	return 0;
2733 }
2734 
2735 void
qla28xx_sa_update_iocb_entry(scsi_qla_host_t * v,struct req_que * req,struct sa_update_28xx * pkt)2736 qla28xx_sa_update_iocb_entry(scsi_qla_host_t *v, struct req_que *req,
2737 	struct sa_update_28xx *pkt)
2738 {
2739 	const char *func = "SA_UPDATE_RESPONSE_IOCB";
2740 	srb_t *sp;
2741 	struct edif_sa_ctl *sa_ctl;
2742 	int old_sa_deleted = 1;
2743 	uint16_t nport_handle;
2744 	struct scsi_qla_host *vha;
2745 
2746 	sp = qla2x00_get_sp_from_handle(v, func, req, pkt);
2747 
2748 	if (!sp) {
2749 		ql_dbg(ql_dbg_edif, v, 0x3063,
2750 			"%s: no sp found for pkt\n", __func__);
2751 		return;
2752 	}
2753 	/* use sp->vha due to npiv */
2754 	vha = sp->vha;
2755 
2756 	switch (pkt->flags & (SA_FLAG_INVALIDATE | SA_FLAG_TX)) {
2757 	case 0:
2758 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2759 		    "%s: EDIF SA UPDATE RX IOCB  vha: 0x%p  index: %d\n",
2760 		    __func__, vha, pkt->sa_index);
2761 		break;
2762 	case 1:
2763 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2764 		    "%s: EDIF SA DELETE RX IOCB  vha: 0x%p  index: %d\n",
2765 		    __func__, vha, pkt->sa_index);
2766 		break;
2767 	case 2:
2768 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2769 		    "%s: EDIF SA UPDATE TX IOCB  vha: 0x%p  index: %d\n",
2770 		    __func__, vha, pkt->sa_index);
2771 		break;
2772 	case 3:
2773 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2774 		    "%s: EDIF SA DELETE TX IOCB  vha: 0x%p  index: %d\n",
2775 		    __func__, vha, pkt->sa_index);
2776 		break;
2777 	}
2778 
2779 	/*
2780 	 * dig the nport handle out of the iocb, fcport->loop_id can not be trusted
2781 	 * to be correct during cleanup sa_update iocbs.
2782 	 */
2783 	nport_handle = sp->fcport->loop_id;
2784 
2785 	ql_dbg(ql_dbg_edif, vha, 0x3063,
2786 	    "%s: %8phN comp status=%x old_sa_info=%x new_sa_info=%x lid %d, index=0x%x pkt_flags %xh hdl=%x\n",
2787 	    __func__, sp->fcport->port_name, pkt->u.comp_sts, pkt->old_sa_info, pkt->new_sa_info,
2788 	    nport_handle, pkt->sa_index, pkt->flags, sp->handle);
2789 
2790 	/* if rx delete, remove the timer */
2791 	if ((pkt->flags & (SA_FLAG_INVALIDATE | SA_FLAG_TX)) ==  SA_FLAG_INVALIDATE) {
2792 		struct edif_list_entry *edif_entry;
2793 
2794 		sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
2795 
2796 		edif_entry = qla_edif_list_find_sa_index(sp->fcport, nport_handle);
2797 		if (edif_entry) {
2798 			ql_dbg(ql_dbg_edif, vha, 0x5033,
2799 			    "%s: removing edif_entry %p, new sa_index: 0x%x\n",
2800 			    __func__, edif_entry, pkt->sa_index);
2801 			qla_edif_list_delete_sa_index(sp->fcport, edif_entry);
2802 			del_timer(&edif_entry->timer);
2803 
2804 			ql_dbg(ql_dbg_edif, vha, 0x5033,
2805 			    "%s: releasing edif_entry %p, new sa_index: 0x%x\n",
2806 			    __func__, edif_entry, pkt->sa_index);
2807 
2808 			kfree(edif_entry);
2809 		}
2810 	}
2811 
2812 	/*
2813 	 * if this is a delete for either tx or rx, make sure it succeeded.
2814 	 * The new_sa_info field should be 0xffff on success
2815 	 */
2816 	if (pkt->flags & SA_FLAG_INVALIDATE)
2817 		old_sa_deleted = (le16_to_cpu(pkt->new_sa_info) == 0xffff) ? 1 : 0;
2818 
2819 	/* Process update and delete the same way */
2820 
2821 	/* If this is an sadb cleanup delete, bypass sending events to IPSEC */
2822 	if (sp->flags & SRB_EDIF_CLEANUP_DELETE) {
2823 		sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
2824 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2825 		    "%s: nph 0x%x, sa_index %d removed from fw\n",
2826 		    __func__, sp->fcport->loop_id, pkt->sa_index);
2827 
2828 	} else if ((pkt->entry_status == 0) && (pkt->u.comp_sts == 0) &&
2829 	    old_sa_deleted) {
2830 		/*
2831 		 * Note: Wa are only keeping track of latest SA,
2832 		 * so we know when we can start enableing encryption per I/O.
2833 		 * If all SA's get deleted, let FW reject the IOCB.
2834 
2835 		 * TODO: edif: don't set enabled here I think
2836 		 * TODO: edif: prli complete is where it should be set
2837 		 */
2838 		ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x3063,
2839 			"SA(%x)updated for s_id %02x%02x%02x\n",
2840 			pkt->new_sa_info,
2841 			pkt->port_id[2], pkt->port_id[1], pkt->port_id[0]);
2842 		sp->fcport->edif.enable = 1;
2843 		if (pkt->flags & SA_FLAG_TX) {
2844 			sp->fcport->edif.tx_sa_set = 1;
2845 			sp->fcport->edif.tx_sa_pending = 0;
2846 			qla_edb_eventcreate(vha, VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
2847 				QL_VND_SA_STAT_SUCCESS,
2848 				QL_VND_TX_SA_KEY, sp->fcport);
2849 		} else {
2850 			sp->fcport->edif.rx_sa_set = 1;
2851 			sp->fcport->edif.rx_sa_pending = 0;
2852 			qla_edb_eventcreate(vha, VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
2853 				QL_VND_SA_STAT_SUCCESS,
2854 				QL_VND_RX_SA_KEY, sp->fcport);
2855 		}
2856 	} else {
2857 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2858 		    "%s: %8phN SA update FAILED: sa_index: %d, new_sa_info %d, %02x%02x%02x\n",
2859 		    __func__, sp->fcport->port_name, pkt->sa_index, pkt->new_sa_info,
2860 		    pkt->port_id[2], pkt->port_id[1], pkt->port_id[0]);
2861 
2862 		if (pkt->flags & SA_FLAG_TX)
2863 			qla_edb_eventcreate(vha, VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
2864 				(le16_to_cpu(pkt->u.comp_sts) << 16) | QL_VND_SA_STAT_FAILED,
2865 				QL_VND_TX_SA_KEY, sp->fcport);
2866 		else
2867 			qla_edb_eventcreate(vha, VND_CMD_AUTH_STATE_SAUPDATE_COMPL,
2868 				(le16_to_cpu(pkt->u.comp_sts) << 16) | QL_VND_SA_STAT_FAILED,
2869 				QL_VND_RX_SA_KEY, sp->fcport);
2870 	}
2871 
2872 	/* for delete, release sa_ctl, sa_index */
2873 	if (pkt->flags & SA_FLAG_INVALIDATE) {
2874 		/* release the sa_ctl */
2875 		sa_ctl = qla_edif_find_sa_ctl_by_index(sp->fcport,
2876 		    le16_to_cpu(pkt->sa_index), (pkt->flags & SA_FLAG_TX));
2877 		if (sa_ctl &&
2878 		    qla_edif_find_sa_ctl_by_index(sp->fcport, sa_ctl->index,
2879 			(pkt->flags & SA_FLAG_TX)) != NULL) {
2880 			ql_dbg(ql_dbg_edif + ql_dbg_verbose, vha, 0x3063,
2881 			    "%s: freeing sa_ctl for index %d\n",
2882 			    __func__, sa_ctl->index);
2883 			qla_edif_free_sa_ctl(sp->fcport, sa_ctl, sa_ctl->index);
2884 		} else {
2885 			ql_dbg(ql_dbg_edif, vha, 0x3063,
2886 			    "%s: sa_ctl NOT freed, sa_ctl: %p\n",
2887 			    __func__, sa_ctl);
2888 		}
2889 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2890 		    "%s: freeing sa_index %d, nph: 0x%x\n",
2891 		    __func__, le16_to_cpu(pkt->sa_index), nport_handle);
2892 		qla_edif_sadb_delete_sa_index(sp->fcport, nport_handle,
2893 		    le16_to_cpu(pkt->sa_index));
2894 	/*
2895 	 * check for a failed sa_update and remove
2896 	 * the sadb entry.
2897 	 */
2898 	} else if (pkt->u.comp_sts) {
2899 		ql_dbg(ql_dbg_edif, vha, 0x3063,
2900 		    "%s: freeing sa_index %d, nph: 0x%x\n",
2901 		    __func__, pkt->sa_index, nport_handle);
2902 		qla_edif_sadb_delete_sa_index(sp->fcport, nport_handle,
2903 		    le16_to_cpu(pkt->sa_index));
2904 		switch (le16_to_cpu(pkt->u.comp_sts)) {
2905 		case CS_PORT_EDIF_UNAVAIL:
2906 		case CS_PORT_EDIF_LOGOUT:
2907 			qlt_schedule_sess_for_deletion(sp->fcport);
2908 			break;
2909 		default:
2910 			break;
2911 		}
2912 	}
2913 
2914 	sp->done(sp, 0);
2915 }
2916 
2917 /**
2918  * qla28xx_start_scsi_edif() - Send a SCSI type 6 command to the ISP
2919  * @sp: command to send to the ISP
2920  *
2921  * Return: non-zero if a failure occurred, else zero.
2922  */
2923 int
qla28xx_start_scsi_edif(srb_t * sp)2924 qla28xx_start_scsi_edif(srb_t *sp)
2925 {
2926 	int             nseg;
2927 	unsigned long   flags;
2928 	struct scsi_cmnd *cmd;
2929 	uint32_t        *clr_ptr;
2930 	uint32_t        index, i;
2931 	uint32_t        handle;
2932 	uint16_t        cnt;
2933 	int16_t        req_cnt;
2934 	uint16_t        tot_dsds;
2935 	__be32 *fcp_dl;
2936 	uint8_t additional_cdb_len;
2937 	struct ct6_dsd *ctx;
2938 	struct scsi_qla_host *vha = sp->vha;
2939 	struct qla_hw_data *ha = vha->hw;
2940 	struct cmd_type_6 *cmd_pkt;
2941 	struct dsd64	*cur_dsd;
2942 	uint8_t		avail_dsds = 0;
2943 	struct scatterlist *sg;
2944 	struct req_que *req = sp->qpair->req;
2945 	spinlock_t *lock = sp->qpair->qp_lock_ptr;
2946 
2947 	/* Setup device pointers. */
2948 	cmd = GET_CMD_SP(sp);
2949 
2950 	/* So we know we haven't pci_map'ed anything yet */
2951 	tot_dsds = 0;
2952 
2953 	/* Send marker if required */
2954 	if (vha->marker_needed != 0) {
2955 		if (qla2x00_marker(vha, sp->qpair, 0, 0, MK_SYNC_ALL) !=
2956 			QLA_SUCCESS) {
2957 			ql_log(ql_log_warn, vha, 0x300c,
2958 			    "qla2x00_marker failed for cmd=%p.\n", cmd);
2959 			return QLA_FUNCTION_FAILED;
2960 		}
2961 		vha->marker_needed = 0;
2962 	}
2963 
2964 	/* Acquire ring specific lock */
2965 	spin_lock_irqsave(lock, flags);
2966 
2967 	/* Check for room in outstanding command list. */
2968 	handle = req->current_outstanding_cmd;
2969 	for (index = 1; index < req->num_outstanding_cmds; index++) {
2970 		handle++;
2971 		if (handle == req->num_outstanding_cmds)
2972 			handle = 1;
2973 		if (!req->outstanding_cmds[handle])
2974 			break;
2975 	}
2976 	if (index == req->num_outstanding_cmds)
2977 		goto queuing_error;
2978 
2979 	/* Map the sg table so we have an accurate count of sg entries needed */
2980 	if (scsi_sg_count(cmd)) {
2981 		nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
2982 		    scsi_sg_count(cmd), cmd->sc_data_direction);
2983 		if (unlikely(!nseg))
2984 			goto queuing_error;
2985 	} else {
2986 		nseg = 0;
2987 	}
2988 
2989 	tot_dsds = nseg;
2990 	req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
2991 
2992 	sp->iores.res_type = RESOURCE_INI;
2993 	sp->iores.iocb_cnt = req_cnt;
2994 	if (qla_get_iocbs(sp->qpair, &sp->iores))
2995 		goto queuing_error;
2996 
2997 	if (req->cnt < (req_cnt + 2)) {
2998 		cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
2999 		    rd_reg_dword(req->req_q_out);
3000 		if (req->ring_index < cnt)
3001 			req->cnt = cnt - req->ring_index;
3002 		else
3003 			req->cnt = req->length -
3004 			    (req->ring_index - cnt);
3005 		if (req->cnt < (req_cnt + 2))
3006 			goto queuing_error;
3007 	}
3008 
3009 	ctx = sp->u.scmd.ct6_ctx =
3010 	    mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
3011 	if (!ctx) {
3012 		ql_log(ql_log_fatal, vha, 0x3010,
3013 		    "Failed to allocate ctx for cmd=%p.\n", cmd);
3014 		goto queuing_error;
3015 	}
3016 
3017 	memset(ctx, 0, sizeof(struct ct6_dsd));
3018 	ctx->fcp_cmnd = dma_pool_zalloc(ha->fcp_cmnd_dma_pool,
3019 	    GFP_ATOMIC, &ctx->fcp_cmnd_dma);
3020 	if (!ctx->fcp_cmnd) {
3021 		ql_log(ql_log_fatal, vha, 0x3011,
3022 		    "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd);
3023 		goto queuing_error;
3024 	}
3025 
3026 	/* Initialize the DSD list and dma handle */
3027 	INIT_LIST_HEAD(&ctx->dsd_list);
3028 	ctx->dsd_use_cnt = 0;
3029 
3030 	if (cmd->cmd_len > 16) {
3031 		additional_cdb_len = cmd->cmd_len - 16;
3032 		if ((cmd->cmd_len % 4) != 0) {
3033 			/*
3034 			 * SCSI command bigger than 16 bytes must be
3035 			 * multiple of 4
3036 			 */
3037 			ql_log(ql_log_warn, vha, 0x3012,
3038 			    "scsi cmd len %d not multiple of 4 for cmd=%p.\n",
3039 			    cmd->cmd_len, cmd);
3040 			goto queuing_error_fcp_cmnd;
3041 		}
3042 		ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4;
3043 	} else {
3044 		additional_cdb_len = 0;
3045 		ctx->fcp_cmnd_len = 12 + 16 + 4;
3046 	}
3047 
3048 	cmd_pkt = (struct cmd_type_6 *)req->ring_ptr;
3049 	cmd_pkt->handle = make_handle(req->id, handle);
3050 
3051 	/*
3052 	 * Zero out remaining portion of packet.
3053 	 * tagged queuing modifier -- default is TSK_SIMPLE (0).
3054 	 */
3055 	clr_ptr = (uint32_t *)cmd_pkt + 2;
3056 	memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
3057 	cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
3058 
3059 	/* No data transfer */
3060 	if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
3061 		cmd_pkt->byte_count = cpu_to_le32(0);
3062 		goto no_dsds;
3063 	}
3064 
3065 	/* Set transfer direction */
3066 	if (cmd->sc_data_direction == DMA_TO_DEVICE) {
3067 		cmd_pkt->control_flags = cpu_to_le16(CF_WRITE_DATA);
3068 		vha->qla_stats.output_bytes += scsi_bufflen(cmd);
3069 		vha->qla_stats.output_requests++;
3070 		sp->fcport->edif.tx_bytes += scsi_bufflen(cmd);
3071 	} else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
3072 		cmd_pkt->control_flags = cpu_to_le16(CF_READ_DATA);
3073 		vha->qla_stats.input_bytes += scsi_bufflen(cmd);
3074 		vha->qla_stats.input_requests++;
3075 		sp->fcport->edif.rx_bytes += scsi_bufflen(cmd);
3076 	}
3077 
3078 	cmd_pkt->control_flags |= cpu_to_le16(CF_EN_EDIF);
3079 	cmd_pkt->control_flags &= ~(cpu_to_le16(CF_NEW_SA));
3080 
3081 	/* One DSD is available in the Command Type 6 IOCB */
3082 	avail_dsds = 1;
3083 	cur_dsd = &cmd_pkt->fcp_dsd;
3084 
3085 	/* Load data segments */
3086 	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
3087 		dma_addr_t      sle_dma;
3088 		cont_a64_entry_t *cont_pkt;
3089 
3090 		/* Allocate additional continuation packets? */
3091 		if (avail_dsds == 0) {
3092 			/*
3093 			 * Five DSDs are available in the Continuation
3094 			 * Type 1 IOCB.
3095 			 */
3096 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha, req);
3097 			cur_dsd = cont_pkt->dsd;
3098 			avail_dsds = 5;
3099 		}
3100 
3101 		sle_dma = sg_dma_address(sg);
3102 		put_unaligned_le64(sle_dma, &cur_dsd->address);
3103 		cur_dsd->length = cpu_to_le32(sg_dma_len(sg));
3104 		cur_dsd++;
3105 		avail_dsds--;
3106 	}
3107 
3108 no_dsds:
3109 	/* Set NPORT-ID and LUN number*/
3110 	cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3111 	cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
3112 	cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
3113 	cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
3114 	cmd_pkt->vp_index = sp->vha->vp_idx;
3115 
3116 	cmd_pkt->entry_type = COMMAND_TYPE_6;
3117 
3118 	/* Set total data segment count. */
3119 	cmd_pkt->entry_count = (uint8_t)req_cnt;
3120 
3121 	int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
3122 	host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
3123 
3124 	/* build FCP_CMND IU */
3125 	int_to_scsilun(cmd->device->lun, &ctx->fcp_cmnd->lun);
3126 	ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len;
3127 
3128 	if (cmd->sc_data_direction == DMA_TO_DEVICE)
3129 		ctx->fcp_cmnd->additional_cdb_len |= 1;
3130 	else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
3131 		ctx->fcp_cmnd->additional_cdb_len |= 2;
3132 
3133 	/* Populate the FCP_PRIO. */
3134 	if (ha->flags.fcp_prio_enabled)
3135 		ctx->fcp_cmnd->task_attribute |=
3136 		    sp->fcport->fcp_prio << 3;
3137 
3138 	memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
3139 
3140 	fcp_dl = (__be32 *)(ctx->fcp_cmnd->cdb + 16 +
3141 	    additional_cdb_len);
3142 	*fcp_dl = htonl((uint32_t)scsi_bufflen(cmd));
3143 
3144 	cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len);
3145 	put_unaligned_le64(ctx->fcp_cmnd_dma, &cmd_pkt->fcp_cmnd_dseg_address);
3146 
3147 	sp->flags |= SRB_FCP_CMND_DMA_VALID;
3148 	cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
3149 	/* Set total data segment count. */
3150 	cmd_pkt->entry_count = (uint8_t)req_cnt;
3151 	cmd_pkt->entry_status = 0;
3152 
3153 	/* Build command packet. */
3154 	req->current_outstanding_cmd = handle;
3155 	req->outstanding_cmds[handle] = sp;
3156 	sp->handle = handle;
3157 	cmd->host_scribble = (unsigned char *)(unsigned long)handle;
3158 	req->cnt -= req_cnt;
3159 
3160 	/* Adjust ring index. */
3161 	wmb();
3162 	req->ring_index++;
3163 	if (req->ring_index == req->length) {
3164 		req->ring_index = 0;
3165 		req->ring_ptr = req->ring;
3166 	} else {
3167 		req->ring_ptr++;
3168 	}
3169 
3170 	sp->qpair->cmd_cnt++;
3171 	/* Set chip new ring index. */
3172 	wrt_reg_dword(req->req_q_in, req->ring_index);
3173 
3174 	spin_unlock_irqrestore(lock, flags);
3175 
3176 	return QLA_SUCCESS;
3177 
3178 queuing_error_fcp_cmnd:
3179 	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma);
3180 queuing_error:
3181 	if (tot_dsds)
3182 		scsi_dma_unmap(cmd);
3183 
3184 	if (sp->u.scmd.ct6_ctx) {
3185 		mempool_free(sp->u.scmd.ct6_ctx, ha->ctx_mempool);
3186 		sp->u.scmd.ct6_ctx = NULL;
3187 	}
3188 	qla_put_iocbs(sp->qpair, &sp->iores);
3189 	spin_unlock_irqrestore(lock, flags);
3190 
3191 	return QLA_FUNCTION_FAILED;
3192 }
3193 
3194 /**********************************************
3195  * edif update/delete sa_index list functions *
3196  **********************************************/
3197 
3198 /* clear the edif_indx_list for this port */
qla_edif_list_del(fc_port_t * fcport)3199 void qla_edif_list_del(fc_port_t *fcport)
3200 {
3201 	struct edif_list_entry *indx_lst;
3202 	struct edif_list_entry *tindx_lst;
3203 	struct list_head *indx_list = &fcport->edif.edif_indx_list;
3204 	unsigned long flags = 0;
3205 
3206 	spin_lock_irqsave(&fcport->edif.indx_list_lock, flags);
3207 	list_for_each_entry_safe(indx_lst, tindx_lst, indx_list, next) {
3208 		list_del(&indx_lst->next);
3209 		kfree(indx_lst);
3210 	}
3211 	spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
3212 }
3213 
3214 /******************
3215  * SADB functions *
3216  ******************/
3217 
3218 /* allocate/retrieve an sa_index for a given spi */
qla_edif_sadb_get_sa_index(fc_port_t * fcport,struct qla_sa_update_frame * sa_frame)3219 static uint16_t qla_edif_sadb_get_sa_index(fc_port_t *fcport,
3220 		struct qla_sa_update_frame *sa_frame)
3221 {
3222 	struct edif_sa_index_entry *entry;
3223 	struct list_head *sa_list;
3224 	uint16_t sa_index;
3225 	int dir = sa_frame->flags & SAU_FLG_TX;
3226 	int slot = 0;
3227 	int free_slot = -1;
3228 	scsi_qla_host_t *vha = fcport->vha;
3229 	struct qla_hw_data *ha = vha->hw;
3230 	unsigned long flags = 0;
3231 	uint16_t nport_handle = fcport->loop_id;
3232 
3233 	ql_dbg(ql_dbg_edif, vha, 0x3063,
3234 	    "%s: entry  fc_port: %p, nport_handle: 0x%x\n",
3235 	    __func__, fcport, nport_handle);
3236 
3237 	if (dir)
3238 		sa_list = &ha->sadb_tx_index_list;
3239 	else
3240 		sa_list = &ha->sadb_rx_index_list;
3241 
3242 	entry = qla_edif_sadb_find_sa_index_entry(nport_handle, sa_list);
3243 	if (!entry) {
3244 		if ((sa_frame->flags & (SAU_FLG_TX | SAU_FLG_INV)) == SAU_FLG_INV) {
3245 			ql_dbg(ql_dbg_edif, vha, 0x3063,
3246 			    "%s: rx delete request with no entry\n", __func__);
3247 			return RX_DELETE_NO_EDIF_SA_INDEX;
3248 		}
3249 
3250 		/* if there is no entry for this nport, add one */
3251 		entry = kzalloc((sizeof(struct edif_sa_index_entry)), GFP_ATOMIC);
3252 		if (!entry)
3253 			return INVALID_EDIF_SA_INDEX;
3254 
3255 		sa_index = qla_edif_get_sa_index_from_freepool(fcport, dir);
3256 		if (sa_index == INVALID_EDIF_SA_INDEX) {
3257 			kfree(entry);
3258 			return INVALID_EDIF_SA_INDEX;
3259 		}
3260 
3261 		INIT_LIST_HEAD(&entry->next);
3262 		entry->handle = nport_handle;
3263 		entry->fcport = fcport;
3264 		entry->sa_pair[0].spi = sa_frame->spi;
3265 		entry->sa_pair[0].sa_index = sa_index;
3266 		entry->sa_pair[1].spi = 0;
3267 		entry->sa_pair[1].sa_index = INVALID_EDIF_SA_INDEX;
3268 		spin_lock_irqsave(&ha->sadb_lock, flags);
3269 		list_add_tail(&entry->next, sa_list);
3270 		spin_unlock_irqrestore(&ha->sadb_lock, flags);
3271 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3272 		    "%s: Created new sadb entry for nport_handle 0x%x, spi 0x%x, returning sa_index %d\n",
3273 		    __func__, nport_handle, sa_frame->spi, sa_index);
3274 
3275 		return sa_index;
3276 	}
3277 
3278 	spin_lock_irqsave(&ha->sadb_lock, flags);
3279 
3280 	/* see if we already have an entry for this spi */
3281 	for (slot = 0; slot < 2; slot++) {
3282 		if (entry->sa_pair[slot].sa_index == INVALID_EDIF_SA_INDEX) {
3283 			free_slot = slot;
3284 		} else {
3285 			if (entry->sa_pair[slot].spi == sa_frame->spi) {
3286 				spin_unlock_irqrestore(&ha->sadb_lock, flags);
3287 				ql_dbg(ql_dbg_edif, vha, 0x3063,
3288 				    "%s: sadb slot %d entry for lid 0x%x, spi 0x%x found, sa_index %d\n",
3289 				    __func__, slot, entry->handle, sa_frame->spi,
3290 				    entry->sa_pair[slot].sa_index);
3291 				return entry->sa_pair[slot].sa_index;
3292 			}
3293 		}
3294 	}
3295 	spin_unlock_irqrestore(&ha->sadb_lock, flags);
3296 
3297 	/* both slots are used */
3298 	if (free_slot == -1) {
3299 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3300 		    "%s: WARNING: No free slots in sadb for nport_handle 0x%x, spi: 0x%x\n",
3301 		    __func__, entry->handle, sa_frame->spi);
3302 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3303 		    "%s: Slot 0  spi: 0x%x  sa_index: %d,  Slot 1  spi: 0x%x  sa_index: %d\n",
3304 		    __func__, entry->sa_pair[0].spi, entry->sa_pair[0].sa_index,
3305 		    entry->sa_pair[1].spi, entry->sa_pair[1].sa_index);
3306 
3307 		return INVALID_EDIF_SA_INDEX;
3308 	}
3309 
3310 	/* there is at least one free slot, use it */
3311 	sa_index = qla_edif_get_sa_index_from_freepool(fcport, dir);
3312 	if (sa_index == INVALID_EDIF_SA_INDEX) {
3313 		ql_dbg(ql_dbg_edif, fcport->vha, 0x3063,
3314 		    "%s: empty freepool!!\n", __func__);
3315 		return INVALID_EDIF_SA_INDEX;
3316 	}
3317 
3318 	spin_lock_irqsave(&ha->sadb_lock, flags);
3319 	entry->sa_pair[free_slot].spi = sa_frame->spi;
3320 	entry->sa_pair[free_slot].sa_index = sa_index;
3321 	spin_unlock_irqrestore(&ha->sadb_lock, flags);
3322 	ql_dbg(ql_dbg_edif, fcport->vha, 0x3063,
3323 	    "%s: sadb slot %d entry for nport_handle 0x%x, spi 0x%x added, returning sa_index %d\n",
3324 	    __func__, free_slot, entry->handle, sa_frame->spi, sa_index);
3325 
3326 	return sa_index;
3327 }
3328 
3329 /* release any sadb entries -- only done at teardown */
qla_edif_sadb_release(struct qla_hw_data * ha)3330 void qla_edif_sadb_release(struct qla_hw_data *ha)
3331 {
3332 	struct edif_sa_index_entry *entry, *tmp;
3333 
3334 	list_for_each_entry_safe(entry, tmp, &ha->sadb_rx_index_list, next) {
3335 		list_del(&entry->next);
3336 		kfree(entry);
3337 	}
3338 
3339 	list_for_each_entry_safe(entry, tmp, &ha->sadb_tx_index_list, next) {
3340 		list_del(&entry->next);
3341 		kfree(entry);
3342 	}
3343 }
3344 
3345 /**************************
3346  * sadb freepool functions
3347  **************************/
3348 
3349 /* build the rx and tx sa_index free pools -- only done at fcport init */
qla_edif_sadb_build_free_pool(struct qla_hw_data * ha)3350 int qla_edif_sadb_build_free_pool(struct qla_hw_data *ha)
3351 {
3352 	ha->edif_tx_sa_id_map =
3353 	    kcalloc(BITS_TO_LONGS(EDIF_NUM_SA_INDEX), sizeof(long), GFP_KERNEL);
3354 
3355 	if (!ha->edif_tx_sa_id_map) {
3356 		ql_log_pci(ql_log_fatal, ha->pdev, 0x0009,
3357 		    "Unable to allocate memory for sadb tx.\n");
3358 		return -ENOMEM;
3359 	}
3360 
3361 	ha->edif_rx_sa_id_map =
3362 	    kcalloc(BITS_TO_LONGS(EDIF_NUM_SA_INDEX), sizeof(long), GFP_KERNEL);
3363 	if (!ha->edif_rx_sa_id_map) {
3364 		kfree(ha->edif_tx_sa_id_map);
3365 		ha->edif_tx_sa_id_map = NULL;
3366 		ql_log_pci(ql_log_fatal, ha->pdev, 0x0009,
3367 		    "Unable to allocate memory for sadb rx.\n");
3368 		return -ENOMEM;
3369 	}
3370 	return 0;
3371 }
3372 
3373 /* release the free pool - only done during fcport teardown */
qla_edif_sadb_release_free_pool(struct qla_hw_data * ha)3374 void qla_edif_sadb_release_free_pool(struct qla_hw_data *ha)
3375 {
3376 	kfree(ha->edif_tx_sa_id_map);
3377 	ha->edif_tx_sa_id_map = NULL;
3378 	kfree(ha->edif_rx_sa_id_map);
3379 	ha->edif_rx_sa_id_map = NULL;
3380 }
3381 
__chk_edif_rx_sa_delete_pending(scsi_qla_host_t * vha,fc_port_t * fcport,uint32_t handle,uint16_t sa_index)3382 static void __chk_edif_rx_sa_delete_pending(scsi_qla_host_t *vha,
3383 		fc_port_t *fcport, uint32_t handle, uint16_t sa_index)
3384 {
3385 	struct edif_list_entry *edif_entry;
3386 	struct edif_sa_ctl *sa_ctl;
3387 	uint16_t delete_sa_index = INVALID_EDIF_SA_INDEX;
3388 	unsigned long flags = 0;
3389 	uint16_t nport_handle = fcport->loop_id;
3390 	uint16_t cached_nport_handle;
3391 
3392 	spin_lock_irqsave(&fcport->edif.indx_list_lock, flags);
3393 	edif_entry = qla_edif_list_find_sa_index(fcport, nport_handle);
3394 	if (!edif_entry) {
3395 		spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
3396 		return;		/* no pending delete for this handle */
3397 	}
3398 
3399 	/*
3400 	 * check for no pending delete for this index or iocb does not
3401 	 * match rx sa_index
3402 	 */
3403 	if (edif_entry->delete_sa_index == INVALID_EDIF_SA_INDEX ||
3404 	    edif_entry->update_sa_index != sa_index) {
3405 		spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
3406 		return;
3407 	}
3408 
3409 	/*
3410 	 * wait until we have seen at least EDIF_DELAY_COUNT transfers before
3411 	 * queueing RX delete
3412 	 */
3413 	if (edif_entry->count++ < EDIF_RX_DELETE_FILTER_COUNT) {
3414 		spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
3415 		return;
3416 	}
3417 
3418 	ql_dbg(ql_dbg_edif, vha, 0x5033,
3419 	    "%s: invalidating delete_sa_index,  update_sa_index: 0x%x sa_index: 0x%x, delete_sa_index: 0x%x\n",
3420 	    __func__, edif_entry->update_sa_index, sa_index, edif_entry->delete_sa_index);
3421 
3422 	delete_sa_index = edif_entry->delete_sa_index;
3423 	edif_entry->delete_sa_index = INVALID_EDIF_SA_INDEX;
3424 	cached_nport_handle = edif_entry->handle;
3425 	spin_unlock_irqrestore(&fcport->edif.indx_list_lock, flags);
3426 
3427 	/* sanity check on the nport handle */
3428 	if (nport_handle != cached_nport_handle) {
3429 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3430 		    "%s: POST SA DELETE nport_handle mismatch: lid: 0x%x, edif_entry nph: 0x%x\n",
3431 		    __func__, nport_handle, cached_nport_handle);
3432 	}
3433 
3434 	/* find the sa_ctl for the delete and schedule the delete */
3435 	sa_ctl = qla_edif_find_sa_ctl_by_index(fcport, delete_sa_index, 0);
3436 	if (sa_ctl) {
3437 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3438 		    "%s: POST SA DELETE sa_ctl: %p, index recvd %d\n",
3439 		    __func__, sa_ctl, sa_index);
3440 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3441 		    "delete index %d, update index: %d, nport handle: 0x%x, handle: 0x%x\n",
3442 		    delete_sa_index,
3443 		    edif_entry->update_sa_index, nport_handle, handle);
3444 
3445 		sa_ctl->flags = EDIF_SA_CTL_FLG_DEL;
3446 		set_bit(EDIF_SA_CTL_REPL, &sa_ctl->state);
3447 		qla_post_sa_replace_work(fcport->vha, fcport,
3448 		    nport_handle, sa_ctl);
3449 	} else {
3450 		ql_dbg(ql_dbg_edif, vha, 0x3063,
3451 		    "%s: POST SA DELETE sa_ctl not found for delete_sa_index: %d\n",
3452 		    __func__, delete_sa_index);
3453 	}
3454 }
3455 
qla_chk_edif_rx_sa_delete_pending(scsi_qla_host_t * vha,srb_t * sp,struct sts_entry_24xx * sts24)3456 void qla_chk_edif_rx_sa_delete_pending(scsi_qla_host_t *vha,
3457 		srb_t *sp, struct sts_entry_24xx *sts24)
3458 {
3459 	fc_port_t *fcport = sp->fcport;
3460 	/* sa_index used by this iocb */
3461 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
3462 	uint32_t handle;
3463 
3464 	handle = (uint32_t)LSW(sts24->handle);
3465 
3466 	/* find out if this status iosb is for a scsi read */
3467 	if (cmd->sc_data_direction != DMA_FROM_DEVICE)
3468 		return;
3469 
3470 	return __chk_edif_rx_sa_delete_pending(vha, fcport, handle,
3471 	   le16_to_cpu(sts24->edif_sa_index));
3472 }
3473 
qlt_chk_edif_rx_sa_delete_pending(scsi_qla_host_t * vha,fc_port_t * fcport,struct ctio7_from_24xx * pkt)3474 void qlt_chk_edif_rx_sa_delete_pending(scsi_qla_host_t *vha, fc_port_t *fcport,
3475 		struct ctio7_from_24xx *pkt)
3476 {
3477 	__chk_edif_rx_sa_delete_pending(vha, fcport,
3478 	    pkt->handle, le16_to_cpu(pkt->edif_sa_index));
3479 }
3480 
qla_parse_auth_els_ctl(struct srb * sp)3481 static void qla_parse_auth_els_ctl(struct srb *sp)
3482 {
3483 	struct qla_els_pt_arg *a = &sp->u.bsg_cmd.u.els_arg;
3484 	struct bsg_job *bsg_job = sp->u.bsg_cmd.bsg_job;
3485 	struct fc_bsg_request *request = bsg_job->request;
3486 	struct qla_bsg_auth_els_request *p =
3487 	    (struct qla_bsg_auth_els_request *)bsg_job->request;
3488 
3489 	a->tx_len = a->tx_byte_count = sp->remap.req.len;
3490 	a->tx_addr = sp->remap.req.dma;
3491 	a->rx_len = a->rx_byte_count = sp->remap.rsp.len;
3492 	a->rx_addr = sp->remap.rsp.dma;
3493 
3494 	if (p->e.sub_cmd == SEND_ELS_REPLY) {
3495 		a->control_flags = p->e.extra_control_flags << 13;
3496 		a->rx_xchg_address = cpu_to_le32(p->e.extra_rx_xchg_address);
3497 		if (p->e.extra_control_flags == BSG_CTL_FLAG_LS_ACC)
3498 			a->els_opcode = ELS_LS_ACC;
3499 		else if (p->e.extra_control_flags == BSG_CTL_FLAG_LS_RJT)
3500 			a->els_opcode = ELS_LS_RJT;
3501 	}
3502 	a->did = sp->fcport->d_id;
3503 	a->els_opcode =  request->rqst_data.h_els.command_code;
3504 	a->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3505 	a->vp_idx = sp->vha->vp_idx;
3506 }
3507 
qla_edif_process_els(scsi_qla_host_t * vha,struct bsg_job * bsg_job)3508 int qla_edif_process_els(scsi_qla_host_t *vha, struct bsg_job *bsg_job)
3509 {
3510 	struct fc_bsg_request *bsg_request = bsg_job->request;
3511 	struct fc_bsg_reply *bsg_reply = bsg_job->reply;
3512 	fc_port_t *fcport = NULL;
3513 	struct qla_hw_data *ha = vha->hw;
3514 	srb_t *sp;
3515 	int rval =  (DID_ERROR << 16), cnt;
3516 	port_id_t d_id;
3517 	struct qla_bsg_auth_els_request *p =
3518 	    (struct qla_bsg_auth_els_request *)bsg_job->request;
3519 	struct qla_bsg_auth_els_reply *rpl =
3520 	    (struct qla_bsg_auth_els_reply *)bsg_job->reply;
3521 
3522 	rpl->version = EDIF_VERSION1;
3523 
3524 	d_id.b.al_pa = bsg_request->rqst_data.h_els.port_id[2];
3525 	d_id.b.area = bsg_request->rqst_data.h_els.port_id[1];
3526 	d_id.b.domain = bsg_request->rqst_data.h_els.port_id[0];
3527 
3528 	/* find matching d_id in fcport list */
3529 	fcport = qla2x00_find_fcport_by_pid(vha, &d_id);
3530 	if (!fcport) {
3531 		ql_dbg(ql_dbg_edif, vha, 0x911a,
3532 		    "%s fcport not find online portid=%06x.\n",
3533 		    __func__, d_id.b24);
3534 		SET_DID_STATUS(bsg_reply->result, DID_ERROR);
3535 		return -EIO;
3536 	}
3537 
3538 	if (qla_bsg_check(vha, bsg_job, fcport))
3539 		return 0;
3540 
3541 	if (EDIF_SESS_DELETE(fcport)) {
3542 		ql_dbg(ql_dbg_edif, vha, 0x910d,
3543 		    "%s ELS code %x, no loop id.\n", __func__,
3544 		    bsg_request->rqst_data.r_els.els_code);
3545 		SET_DID_STATUS(bsg_reply->result, DID_BAD_TARGET);
3546 		return -ENXIO;
3547 	}
3548 
3549 	if (!vha->flags.online) {
3550 		ql_log(ql_log_warn, vha, 0x7005, "Host not online.\n");
3551 		SET_DID_STATUS(bsg_reply->result, DID_BAD_TARGET);
3552 		rval = -EIO;
3553 		goto done;
3554 	}
3555 
3556 	/* pass through is supported only for ISP 4Gb or higher */
3557 	if (!IS_FWI2_CAPABLE(ha)) {
3558 		ql_dbg(ql_dbg_user, vha, 0x7001,
3559 		    "ELS passthru not supported for ISP23xx based adapters.\n");
3560 		SET_DID_STATUS(bsg_reply->result, DID_BAD_TARGET);
3561 		rval = -EPERM;
3562 		goto done;
3563 	}
3564 
3565 	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
3566 	if (!sp) {
3567 		ql_dbg(ql_dbg_user, vha, 0x7004,
3568 		    "Failed get sp pid=%06x\n", fcport->d_id.b24);
3569 		rval = -ENOMEM;
3570 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
3571 		goto done;
3572 	}
3573 
3574 	sp->remap.req.len = bsg_job->request_payload.payload_len;
3575 	sp->remap.req.buf = dma_pool_alloc(ha->purex_dma_pool,
3576 	    GFP_KERNEL, &sp->remap.req.dma);
3577 	if (!sp->remap.req.buf) {
3578 		ql_dbg(ql_dbg_user, vha, 0x7005,
3579 		    "Failed allocate request dma len=%x\n",
3580 		    bsg_job->request_payload.payload_len);
3581 		rval = -ENOMEM;
3582 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
3583 		goto done_free_sp;
3584 	}
3585 
3586 	sp->remap.rsp.len = bsg_job->reply_payload.payload_len;
3587 	sp->remap.rsp.buf = dma_pool_alloc(ha->purex_dma_pool,
3588 	    GFP_KERNEL, &sp->remap.rsp.dma);
3589 	if (!sp->remap.rsp.buf) {
3590 		ql_dbg(ql_dbg_user, vha, 0x7006,
3591 		    "Failed allocate response dma len=%x\n",
3592 		    bsg_job->reply_payload.payload_len);
3593 		rval = -ENOMEM;
3594 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
3595 		goto done_free_remap_req;
3596 	}
3597 	sg_copy_to_buffer(bsg_job->request_payload.sg_list,
3598 	    bsg_job->request_payload.sg_cnt, sp->remap.req.buf,
3599 	    sp->remap.req.len);
3600 	sp->remap.remapped = true;
3601 
3602 	sp->type = SRB_ELS_CMD_HST_NOLOGIN;
3603 	sp->name = "SPCN_BSG_HST_NOLOGIN";
3604 	sp->u.bsg_cmd.bsg_job = bsg_job;
3605 	qla_parse_auth_els_ctl(sp);
3606 
3607 	sp->free = qla2x00_bsg_sp_free;
3608 	sp->done = qla2x00_bsg_job_done;
3609 
3610 	cnt = 0;
3611 retry:
3612 	rval = qla2x00_start_sp(sp);
3613 	switch (rval) {
3614 	case QLA_SUCCESS:
3615 		ql_dbg(ql_dbg_edif, vha, 0x700a,
3616 		       "%s %s %8phN xchg %x ctlflag %x hdl %x reqlen %xh bsg ptr %p\n",
3617 		       __func__, sc_to_str(p->e.sub_cmd), fcport->port_name,
3618 		       p->e.extra_rx_xchg_address, p->e.extra_control_flags,
3619 		       sp->handle, sp->remap.req.len, bsg_job);
3620 		break;
3621 	case EAGAIN:
3622 		msleep(EDIF_MSLEEP_INTERVAL);
3623 		cnt++;
3624 		if (cnt < EDIF_RETRY_COUNT)
3625 			goto retry;
3626 		fallthrough;
3627 	default:
3628 		ql_log(ql_log_warn, vha, 0x700e,
3629 		    "%s qla2x00_start_sp failed = %d\n", __func__, rval);
3630 		SET_DID_STATUS(bsg_reply->result, DID_IMM_RETRY);
3631 		rval = -EIO;
3632 		goto done_free_remap_rsp;
3633 	}
3634 	return rval;
3635 
3636 done_free_remap_rsp:
3637 	dma_pool_free(ha->purex_dma_pool, sp->remap.rsp.buf,
3638 	    sp->remap.rsp.dma);
3639 done_free_remap_req:
3640 	dma_pool_free(ha->purex_dma_pool, sp->remap.req.buf,
3641 	    sp->remap.req.dma);
3642 done_free_sp:
3643 	qla2x00_rel_sp(sp);
3644 
3645 done:
3646 	return rval;
3647 }
3648 
qla_edif_sess_down(struct scsi_qla_host * vha,struct fc_port * sess)3649 void qla_edif_sess_down(struct scsi_qla_host *vha, struct fc_port *sess)
3650 {
3651 	u16 cnt = 0;
3652 
3653 	if (sess->edif.app_sess_online && DBELL_ACTIVE(vha)) {
3654 		ql_dbg(ql_dbg_disc, vha, 0xf09c,
3655 			"%s: sess %8phN send port_offline event\n",
3656 			__func__, sess->port_name);
3657 		sess->edif.app_sess_online = 0;
3658 		sess->edif.sess_down_acked = 0;
3659 		qla_edb_eventcreate(vha, VND_CMD_AUTH_STATE_SESSION_SHUTDOWN,
3660 		    sess->d_id.b24, 0, sess);
3661 		qla2x00_post_aen_work(vha, FCH_EVT_PORT_OFFLINE, sess->d_id.b24);
3662 
3663 		while (!READ_ONCE(sess->edif.sess_down_acked) &&
3664 		       !test_bit(VPORT_DELETE, &vha->dpc_flags)) {
3665 			msleep(100);
3666 			cnt++;
3667 			if (cnt > 100)
3668 				break;
3669 		}
3670 		sess->edif.sess_down_acked = 0;
3671 		ql_dbg(ql_dbg_disc, vha, 0xf09c,
3672 		       "%s: sess %8phN port_offline event completed\n",
3673 		       __func__, sess->port_name);
3674 	}
3675 }
3676 
qla_edif_clear_appdata(struct scsi_qla_host * vha,struct fc_port * fcport)3677 void qla_edif_clear_appdata(struct scsi_qla_host *vha, struct fc_port *fcport)
3678 {
3679 	if (!(fcport->flags & FCF_FCSP_DEVICE))
3680 		return;
3681 
3682 	qla_edb_clear(vha, fcport->d_id);
3683 	qla_enode_clear(vha, fcport->d_id);
3684 }
3685