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