?  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 / bnx2fc / bnx2fc_els.c
blob754f2e82d955ed92927776e186e06200218d8ffb
1 /*
2 * bnx2fc_els.c: QLogic Linux FCoE offload driver.
3 * This file contains helper routines that handle ELS requests
4 * and responses.
5 *
6 * Copyright (c) 2008-2013 Broadcom Corporation
7 * Copyright (c) 2014-2016 QLogic Corporation
8 * Copyright (c) 2016-2017 Cavium Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation.
13 *
14 * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com)
15 */
16
17 #include "bnx2fc.h"
18
19 static void bnx2fc_logo_resp(struct fc_seq *seq, struct fc_frame *fp,
20 void *arg);
21 static void bnx2fc_flogi_resp(struct fc_seq *seq, struct fc_frame *fp,
22 void *arg);
23 static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
24 void *data, u32 data_len,
25 void (*cb_func)(struct bnx2fc_els_cb_arg *cb_arg),
26 struct bnx2fc_els_cb_arg *cb_arg, u32 timer_msec);
27
28 static void bnx2fc_rrq_compl(struct bnx2fc_els_cb_arg *cb_arg)
29 {
30 struct bnx2fc_cmd *orig_io_req;
31 struct bnx2fc_cmd *rrq_req;
32 int rc = 0;
33
34 BUG_ON(!cb_arg);
35 rrq_req = cb_arg->io_req;
36 orig_io_req = cb_arg->aborted_io_req;
37 BUG_ON(!orig_io_req);
38 BNX2FC_ELS_DBG("rrq_compl: orig xid = 0x%x, rrq_xid = 0x%x\n",
39 orig_io_req->xid, rrq_req->xid);
40
41 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
42
43 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &rrq_req->req_flags)) {
44 /*
45 * els req is timed out. cleanup the IO with FW and
46 * drop the completion. Remove from active_cmd_queue.
47 */
48 BNX2FC_ELS_DBG("rrq xid - 0x%x timed out, clean it up\n",
49 rrq_req->xid);
50
51 if (rrq_req->on_active_queue) {
52 list_del_init(&rrq_req->link);
53 rrq_req->on_active_queue = 0;
54 rc = bnx2fc_initiate_cleanup(rrq_req);
55 BUG_ON(rc);
56 }
57 }
58 kfree(cb_arg);
59 }
60 int bnx2fc_send_rrq(struct bnx2fc_cmd *aborted_io_req)
61 {
62
63 struct fc_els_rrq rrq;
64 struct bnx2fc_rport *tgt = aborted_io_req->tgt;
65 struct fc_lport *lport = NULL;
66 struct bnx2fc_els_cb_arg *cb_arg = NULL;
67 u32 sid = 0;
68 u32 r_a_tov = 0;
69 unsigned long start = jiffies;
70 int rc;
71
72 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags))
73 return -EINVAL;
74
75 lport = tgt->rdata->local_port;
76 sid = tgt->sid;
77 r_a_tov = lport->r_a_tov;
78
79 BNX2FC_ELS_DBG("Sending RRQ orig_xid = 0x%x\n",
80 aborted_io_req->xid);
81 memset(&rrq, 0, sizeof(rrq));
82
83 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_NOIO);
84 if (!cb_arg) {
85 printk(KERN_ERR PFX "Unable to allocate cb_arg for RRQ\n");
86 rc = -ENOMEM;
87 goto rrq_err;
88 }
89
90 cb_arg->aborted_io_req = aborted_io_req;
91
92 rrq.rrq_cmd = ELS_RRQ;
93 hton24(rrq.rrq_s_id, sid);
94 rrq.rrq_ox_id = htons(aborted_io_req->xid);
95 rrq.rrq_rx_id = htons(aborted_io_req->task->rxwr_txrd.var_ctx.rx_id);
96
97 retry_rrq:
98 rc = bnx2fc_initiate_els(tgt, ELS_RRQ, &rrq, sizeof(rrq),
99 bnx2fc_rrq_compl, cb_arg,
100 r_a_tov);
101 if (rc == -ENOMEM) {
102 if (time_after(jiffies, start + (10 * HZ))) {
103 BNX2FC_ELS_DBG("rrq Failed\n");
104 rc = FAILED;
105 goto rrq_err;
106 }
107 msleep(20);
108 goto retry_rrq;
109 }
110 rrq_err:
111 if (rc) {
112 BNX2FC_ELS_DBG("RRQ failed - release orig io req 0x%x\n",
113 aborted_io_req->xid);
114 kfree(cb_arg);
115 spin_lock_bh(&tgt->tgt_lock);
116 kref_put(&aborted_io_req->refcount, bnx2fc_cmd_release);
117 spin_unlock_bh(&tgt->tgt_lock);
118 }
119 return rc;
120 }
121
122 static void bnx2fc_l2_els_compl(struct bnx2fc_els_cb_arg *cb_arg)
123 {
124 struct bnx2fc_cmd *els_req;
125 struct bnx2fc_rport *tgt;
126 struct bnx2fc_mp_req *mp_req;
127 struct fc_frame_header *fc_hdr;
128 unsigned char *buf;
129 void *resp_buf;
130 u32 resp_len, hdr_len;
131 u16 l2_oxid;
132 int frame_len;
133 int rc = 0;
134
135 l2_oxid = cb_arg->l2_oxid;
136 BNX2FC_ELS_DBG("ELS COMPL - l2_oxid = 0x%x\n", l2_oxid);
137
138 els_req = cb_arg->io_req;
139 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &els_req->req_flags)) {
140 /*
141 * els req is timed out. cleanup the IO with FW and
142 * drop the completion. libfc will handle the els timeout
143 */
144 if (els_req->on_active_queue) {
145 list_del_init(&els_req->link);
146 els_req->on_active_queue = 0;
147 rc = bnx2fc_initiate_cleanup(els_req);
148 BUG_ON(rc);
149 }
150 goto free_arg;
151 }
152
153 tgt = els_req->tgt;
154 mp_req = &(els_req->mp_req);
155 fc_hdr = &(mp_req->resp_fc_hdr);
156 resp_len = mp_req->resp_len;
157 resp_buf = mp_req->resp_buf;
158
159 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC);
160 if (!buf) {
161 printk(KERN_ERR PFX "Unable to alloc mp buf\n");
162 goto free_arg;
163 }
164 hdr_len = sizeof(*fc_hdr);
165 if (hdr_len + resp_len > PAGE_SIZE) {
166 printk(KERN_ERR PFX "l2_els_compl: resp len is "
167 "beyond page size\n");
168 goto free_buf;
169 }
170 memcpy(buf, fc_hdr, hdr_len);
171 memcpy(buf + hdr_len, resp_buf, resp_len);
172 frame_len = hdr_len + resp_len;
173
174 bnx2fc_process_l2_frame_compl(tgt, buf, frame_len, l2_oxid);
175
176 free_buf:
177 kfree(buf);
178 free_arg:
179 kfree(cb_arg);
180 }
181
182 int bnx2fc_send_adisc(struct bnx2fc_rport *tgt, struct fc_frame *fp)
183 {
184 struct fc_els_adisc *adisc;
185 struct fc_frame_header *fh;
186 struct bnx2fc_els_cb_arg *cb_arg;
187 struct fc_lport *lport = tgt->rdata->local_port;
188 u32 r_a_tov = lport->r_a_tov;
189 int rc;
190
191 fh = fc_frame_header_get(fp);
192 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
193 if (!cb_arg) {
194 printk(KERN_ERR PFX "Unable to allocate cb_arg for ADISC\n");
195 return -ENOMEM;
196 }
197
198 cb_arg->l2_oxid = ntohs(fh->fh_ox_id);
199
200 BNX2FC_ELS_DBG("send ADISC: l2_oxid = 0x%x\n", cb_arg->l2_oxid);
201 adisc = fc_frame_payload_get(fp, sizeof(*adisc));
202 /* adisc is initialized by libfc */
203 rc = bnx2fc_initiate_els(tgt, ELS_ADISC, adisc, sizeof(*adisc),
204 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov);
205 if (rc)
206 kfree(cb_arg);
207 return rc;
208 }
209
210 int bnx2fc_send_logo(struct bnx2fc_rport *tgt, struct fc_frame *fp)
211 {
212 struct fc_els_logo *logo;
213 struct fc_frame_header *fh;
214 struct bnx2fc_els_cb_arg *cb_arg;
215 struct fc_lport *lport = tgt->rdata->local_port;
216 u32 r_a_tov = lport->r_a_tov;
217 int rc;
218
219 fh = fc_frame_header_get(fp);
220 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
221 if (!cb_arg) {
222 printk(KERN_ERR PFX "Unable to allocate cb_arg for LOGO\n");
223 return -ENOMEM;
224 }
225
226 cb_arg->l2_oxid = ntohs(fh->fh_ox_id);
227
228 BNX2FC_ELS_DBG("Send LOGO: l2_oxid = 0x%x\n", cb_arg->l2_oxid);
229 logo = fc_frame_payload_get(fp, sizeof(*logo));
230 /* logo is initialized by libfc */
231 rc = bnx2fc_initiate_els(tgt, ELS_LOGO, logo, sizeof(*logo),
232 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov);
233 if (rc)
234 kfree(cb_arg);
235 return rc;
236 }
237
238 int bnx2fc_send_rls(struct bnx2fc_rport *tgt, struct fc_frame *fp)
239 {
240 struct fc_els_rls *rls;
241 struct fc_frame_header *fh;
242 struct bnx2fc_els_cb_arg *cb_arg;
243 struct fc_lport *lport = tgt->rdata->local_port;
244 u32 r_a_tov = lport->r_a_tov;
245 int rc;
246
247 fh = fc_frame_header_get(fp);
248 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
249 if (!cb_arg) {
250 printk(KERN_ERR PFX "Unable to allocate cb_arg for LOGO\n");
251 return -ENOMEM;
252 }
253
254 cb_arg->l2_oxid = ntohs(fh->fh_ox_id);
255
256 rls = fc_frame_payload_get(fp, sizeof(*rls));
257 /* rls is initialized by libfc */
258 rc = bnx2fc_initiate_els(tgt, ELS_RLS, rls, sizeof(*rls),
259 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov);
260 if (rc)
261 kfree(cb_arg);
262 return rc;
263 }
264
265 static void bnx2fc_srr_compl(struct bnx2fc_els_cb_arg *cb_arg)
266 {
267 struct bnx2fc_mp_req *mp_req;
268 struct fc_frame_header *fc_hdr, *fh;
269 struct bnx2fc_cmd *srr_req;
270 struct bnx2fc_cmd *orig_io_req;
271 struct fc_frame *fp;
272 unsigned char *buf;
273 void *resp_buf;
274 u32 resp_len, hdr_len;
275 u8 opcode;
276 int rc = 0;
277
278 orig_io_req = cb_arg->aborted_io_req;
279 srr_req = cb_arg->io_req;
280 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &srr_req->req_flags)) {
281 /* SRR timedout */
282 BNX2FC_IO_DBG(srr_req, "srr timed out, abort "
283 "orig_io - 0x%x\n",
284 orig_io_req->xid);
285 rc = bnx2fc_initiate_abts(srr_req);
286 if (rc != SUCCESS) {
287 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
288 "failed. issue cleanup\n");
289 bnx2fc_initiate_cleanup(srr_req);
290 }
291 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags) ||
292 test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) {
293 BNX2FC_IO_DBG(srr_req, "srr_compl:xid 0x%x flags = %lx",
294 orig_io_req->xid, orig_io_req->req_flags);
295 goto srr_compl_done;
296 }
297 orig_io_req->srr_retry++;
298 if (orig_io_req->srr_retry <= SRR_RETRY_COUNT) {
299 struct bnx2fc_rport *tgt = orig_io_req->tgt;
300 spin_unlock_bh(&tgt->tgt_lock);
301 rc = bnx2fc_send_srr(orig_io_req,
302 orig_io_req->srr_offset,
303 orig_io_req->srr_rctl);
304 spin_lock_bh(&tgt->tgt_lock);
305 if (!rc)
306 goto srr_compl_done;
307 }
308
309 rc = bnx2fc_initiate_abts(orig_io_req);
310 if (rc != SUCCESS) {
311 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
312 "failed xid = 0x%x. issue cleanup\n",
313 orig_io_req->xid);
314 bnx2fc_initiate_cleanup(orig_io_req);
315 }
316 goto srr_compl_done;
317 }
318 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags) ||
319 test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) {
320 BNX2FC_IO_DBG(srr_req, "srr_compl:xid - 0x%x flags = %lx",
321 orig_io_req->xid, orig_io_req->req_flags);
322 goto srr_compl_done;
323 }
324 mp_req = &(srr_req->mp_req);
325 fc_hdr = &(mp_req->resp_fc_hdr);
326 resp_len = mp_req->resp_len;
327 resp_buf = mp_req->resp_buf;
328
329 hdr_len = sizeof(*fc_hdr);
330 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC);
331 if (!buf) {
332 printk(KERN_ERR PFX "srr buf: mem alloc failure\n");
333 goto srr_compl_done;
334 }
335 memcpy(buf, fc_hdr, hdr_len);
336 memcpy(buf + hdr_len, resp_buf, resp_len);
337
338 fp = fc_frame_alloc(NULL, resp_len);
339 if (!fp) {
340 printk(KERN_ERR PFX "fc_frame_alloc failure\n");
341 goto free_buf;
342 }
343
344 fh = (struct fc_frame_header *) fc_frame_header_get(fp);
345 /* Copy FC Frame header and payload into the frame */
346 memcpy(fh, buf, hdr_len + resp_len);
347
348 opcode = fc_frame_payload_op(fp);
349 switch (opcode) {
350 case ELS_LS_ACC:
351 BNX2FC_IO_DBG(srr_req, "SRR success\n");
352 break;
353 case ELS_LS_RJT:
354 BNX2FC_IO_DBG(srr_req, "SRR rejected\n");
355 rc = bnx2fc_initiate_abts(orig_io_req);
356 if (rc != SUCCESS) {
357 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
358 "failed xid = 0x%x. issue cleanup\n",
359 orig_io_req->xid);
360 bnx2fc_initiate_cleanup(orig_io_req);
361 }
362 break;
363 default:
364 BNX2FC_IO_DBG(srr_req, "srr compl - invalid opcode = %d\n",
365 opcode);
366 break;
367 }
368 fc_frame_free(fp);
369 free_buf:
370 kfree(buf);
371 srr_compl_done:
372 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
373 }
374
375 static void bnx2fc_rec_compl(struct bnx2fc_els_cb_arg *cb_arg)
376 {
377 struct bnx2fc_cmd *orig_io_req, *new_io_req;
378 struct bnx2fc_cmd *rec_req;
379 struct bnx2fc_mp_req *mp_req;
380 struct fc_frame_header *fc_hdr, *fh;
381 struct fc_els_ls_rjt *rjt;
382 struct fc_els_rec_acc *acc;
383 struct bnx2fc_rport *tgt;
384 struct fcoe_err_report_entry *err_entry;
385 struct scsi_cmnd *sc_cmd;
386 enum fc_rctl r_ctl;
387 unsigned char *buf;
388 void *resp_buf;
389 struct fc_frame *fp;
390 u8 opcode;
391 u32 offset;
392 u32 e_stat;
393 u32 resp_len, hdr_len;
394 int rc = 0;
395 bool send_seq_clnp = false;
396 bool abort_io = false;
397
398 BNX2FC_MISC_DBG("Entered rec_compl callback\n");
399 rec_req = cb_arg->io_req;
400 orig_io_req = cb_arg->aborted_io_req;
401 BNX2FC_IO_DBG(rec_req, "rec_compl: orig xid = 0x%x", orig_io_req->xid);
402 tgt = orig_io_req->tgt;
403
404 /* Handle REC timeout case */
405 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &rec_req->req_flags)) {
406 BNX2FC_IO_DBG(rec_req, "timed out, abort "
407 "orig_io - 0x%x\n",
408 orig_io_req->xid);
409 /* els req is timed out. send abts for els */
410 rc = bnx2fc_initiate_abts(rec_req);
411 if (rc != SUCCESS) {
412 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
413 "failed. issue cleanup\n");
414 bnx2fc_initiate_cleanup(rec_req);
415 }
416 orig_io_req->rec_retry++;
417 /* REC timedout. send ABTS to the orig IO req */
418 if (orig_io_req->rec_retry <= REC_RETRY_COUNT) {
419 spin_unlock_bh(&tgt->tgt_lock);
420 rc = bnx2fc_send_rec(orig_io_req);
421 spin_lock_bh(&tgt->tgt_lock);
422 if (!rc)
423 goto rec_compl_done;
424 }
425 rc = bnx2fc_initiate_abts(orig_io_req);
426 if (rc != SUCCESS) {
427 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
428 "failed xid = 0x%x. issue cleanup\n",
429 orig_io_req->xid);
430 bnx2fc_initiate_cleanup(orig_io_req);
431 }
432 goto rec_compl_done;
433 }
434
435 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags)) {
436 BNX2FC_IO_DBG(rec_req, "completed"
437 "orig_io - 0x%x\n",
438 orig_io_req->xid);
439 goto rec_compl_done;
440 }
441 if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) {
442 BNX2FC_IO_DBG(rec_req, "abts in prog "
443 "orig_io - 0x%x\n",
444 orig_io_req->xid);
445 goto rec_compl_done;
446 }
447
448 mp_req = &(rec_req->mp_req);
449 fc_hdr = &(mp_req->resp_fc_hdr);
450 resp_len = mp_req->resp_len;
451 acc = resp_buf = mp_req->resp_buf;
452
453 hdr_len = sizeof(*fc_hdr);
454
455 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC);
456 if (!buf) {
457 printk(KERN_ERR PFX "rec buf: mem alloc failure\n");
458 goto rec_compl_done;
459 }
460 memcpy(buf, fc_hdr, hdr_len);
461 memcpy(buf + hdr_len, resp_buf, resp_len);
462
463 fp = fc_frame_alloc(NULL, resp_len);
464 if (!fp) {
465 printk(KERN_ERR PFX "fc_frame_alloc failure\n");
466 goto free_buf;
467 }
468
469 fh = (struct fc_frame_header *) fc_frame_header_get(fp);
470 /* Copy FC Frame header and payload into the frame */
471 memcpy(fh, buf, hdr_len + resp_len);
472
473 opcode = fc_frame_payload_op(fp);
474 if (opcode == ELS_LS_RJT) {
475 BNX2FC_IO_DBG(rec_req, "opcode is RJT\n");
476 rjt = fc_frame_payload_get(fp, sizeof(*rjt));
477 if ((rjt->er_reason == ELS_RJT_LOGIC ||
478 rjt->er_reason == ELS_RJT_UNAB) &&
479 rjt->er_explan == ELS_EXPL_OXID_RXID) {
480 BNX2FC_IO_DBG(rec_req, "handle CMD LOST case\n");
481 new_io_req = bnx2fc_cmd_alloc(tgt);
482 if (!new_io_req)
483 goto abort_io;
484 new_io_req->sc_cmd = orig_io_req->sc_cmd;
485 /* cleanup orig_io_req that is with the FW */
486 set_bit(BNX2FC_FLAG_CMD_LOST,
487 &orig_io_req->req_flags);
488 bnx2fc_initiate_cleanup(orig_io_req);
489 /* Post a new IO req with the same sc_cmd */
490 BNX2FC_IO_DBG(rec_req, "Post IO request again\n");
491 rc = bnx2fc_post_io_req(tgt, new_io_req);
492 if (!rc)
493 goto free_frame;
494 BNX2FC_IO_DBG(rec_req, "REC: io post err\n");
495 }
496 abort_io:
497 rc = bnx2fc_initiate_abts(orig_io_req);
498 if (rc != SUCCESS) {
499 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
500 "failed. issue cleanup\n");
501 bnx2fc_initiate_cleanup(orig_io_req);
502 }
503 } else if (opcode == ELS_LS_ACC) {
504 /* REVISIT: Check if the exchange is already aborted */
505 offset = ntohl(acc->reca_fc4value);
506 e_stat = ntohl(acc->reca_e_stat);
507 if (e_stat & ESB_ST_SEQ_INIT) {
508 BNX2FC_IO_DBG(rec_req, "target has the seq init\n");
509 goto free_frame;
510 }
511 BNX2FC_IO_DBG(rec_req, "e_stat = 0x%x, offset = 0x%x\n",
512 e_stat, offset);
513 /* Seq initiative is with us */
514 err_entry = (struct fcoe_err_report_entry *)
515 &orig_io_req->err_entry;
516 sc_cmd = orig_io_req->sc_cmd;
517 if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
518 /* SCSI WRITE command */
519 if (offset == orig_io_req->data_xfer_len) {
520 BNX2FC_IO_DBG(rec_req, "WRITE - resp lost\n");
521 /* FCP_RSP lost */
522 r_ctl = FC_RCTL_DD_CMD_STATUS;
523 offset = 0;
524 } else {
525 /* start transmitting from offset */
526 BNX2FC_IO_DBG(rec_req, "XFER_RDY/DATA lost\n");
527 send_seq_clnp = true;
528 r_ctl = FC_RCTL_DD_DATA_DESC;
529 if (bnx2fc_initiate_seq_cleanup(orig_io_req,
530 offset, r_ctl))
531 abort_io = true;
532 /* XFER_RDY */
533 }
534 } else {
535 /* SCSI READ command */
536 if (err_entry->data.rx_buf_off ==
537 orig_io_req->data_xfer_len) {
538 /* FCP_RSP lost */
539 BNX2FC_IO_DBG(rec_req, "READ - resp lost\n");
540 r_ctl = FC_RCTL_DD_CMD_STATUS;
541 offset = 0;
542 } else {
543 /* request retransmission from this offset */
544 send_seq_clnp = true;
545 offset = err_entry->data.rx_buf_off;
546 BNX2FC_IO_DBG(rec_req, "RD DATA lost\n");
547 /* FCP_DATA lost */
548 r_ctl = FC_RCTL_DD_SOL_DATA;
549 if (bnx2fc_initiate_seq_cleanup(orig_io_req,
550 offset, r_ctl))
551 abort_io = true;
552 }
553 }
554 if (abort_io) {
555 rc = bnx2fc_initiate_abts(orig_io_req);
556 if (rc != SUCCESS) {
557 BNX2FC_IO_DBG(rec_req, "rec_compl:initiate_abts"
558 " failed. issue cleanup\n");
559 bnx2fc_initiate_cleanup(orig_io_req);
560 }
561 } else if (!send_seq_clnp) {
562 BNX2FC_IO_DBG(rec_req, "Send SRR - FCP_RSP\n");
563 spin_unlock_bh(&tgt->tgt_lock);
564 rc = bnx2fc_send_srr(orig_io_req, offset, r_ctl);
565 spin_lock_bh(&tgt->tgt_lock);
566
567 if (rc) {
568 BNX2FC_IO_DBG(rec_req, "Unable to send SRR"
569 " IO will abort\n");
570 }
571 }
572 }
573 free_frame:
574 fc_frame_free(fp);
575 free_buf:
576 kfree(buf);
577 rec_compl_done:
578 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
579 kfree(cb_arg);
580 }
581
582 int bnx2fc_send_rec(struct bnx2fc_cmd *orig_io_req)
583 {
584 struct fc_els_rec rec;
585 struct bnx2fc_rport *tgt = orig_io_req->tgt;
586 struct fc_lport *lport = tgt->rdata->local_port;
587 struct bnx2fc_els_cb_arg *cb_arg = NULL;
588 u32 sid = tgt->sid;
589 u32 r_a_tov = lport->r_a_tov;
590 int rc;
591
592 BNX2FC_IO_DBG(orig_io_req, "Sending REC\n");
593 memset(&rec, 0, sizeof(rec));
594
595 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
596 if (!cb_arg) {
597 printk(KERN_ERR PFX "Unable to allocate cb_arg for REC\n");
598 rc = -ENOMEM;
599 goto rec_err;
600 }
601 kref_get(&orig_io_req->refcount);
602
603 cb_arg->aborted_io_req = orig_io_req;
604
605 rec.rec_cmd = ELS_REC;
606 hton24(rec.rec_s_id, sid);
607 rec.rec_ox_id = htons(orig_io_req->xid);
608 rec.rec_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id);
609
610 rc = bnx2fc_initiate_els(tgt, ELS_REC, &rec, sizeof(rec),
611 bnx2fc_rec_compl, cb_arg,
612 r_a_tov);
613 if (rc) {
614 BNX2FC_IO_DBG(orig_io_req, "REC failed - release\n");
615 spin_lock_bh(&tgt->tgt_lock);
616 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
617 spin_unlock_bh(&tgt->tgt_lock);
618 kfree(cb_arg);
619 }
620 rec_err:
621 return rc;
622 }
623
624 int bnx2fc_send_srr(struct bnx2fc_cmd *orig_io_req, u32 offset, u8 r_ctl)
625 {
626 struct fcp_srr srr;
627 struct bnx2fc_rport *tgt = orig_io_req->tgt;
628 struct fc_lport *lport = tgt->rdata->local_port;
629 struct bnx2fc_els_cb_arg *cb_arg = NULL;
630 u32 r_a_tov = lport->r_a_tov;
631 int rc;
632
633 BNX2FC_IO_DBG(orig_io_req, "Sending SRR\n");
634 memset(&srr, 0, sizeof(srr));
635
636 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
637 if (!cb_arg) {
638 printk(KERN_ERR PFX "Unable to allocate cb_arg for SRR\n");
639 rc = -ENOMEM;
640 goto srr_err;
641 }
642 kref_get(&orig_io_req->refcount);
643
644 cb_arg->aborted_io_req = orig_io_req;
645
646 srr.srr_op = ELS_SRR;
647 srr.srr_ox_id = htons(orig_io_req->xid);
648 srr.srr_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id);
649 srr.srr_rel_off = htonl(offset);
650 srr.srr_r_ctl = r_ctl;
651 orig_io_req->srr_offset = offset;
652 orig_io_req->srr_rctl = r_ctl;
653
654 rc = bnx2fc_initiate_els(tgt, ELS_SRR, &srr, sizeof(srr),
655 bnx2fc_srr_compl, cb_arg,
656 r_a_tov);
657 if (rc) {
658 BNX2FC_IO_DBG(orig_io_req, "SRR failed - release\n");
659 spin_lock_bh(&tgt->tgt_lock);
660 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
661 spin_unlock_bh(&tgt->tgt_lock);
662 kfree(cb_arg);
663 } else
664 set_bit(BNX2FC_FLAG_SRR_SENT, &orig_io_req->req_flags);
665
666 srr_err:
667 return rc;
668 }
669
670 static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
671 void *data, u32 data_len,
672 void (*cb_func)(struct bnx2fc_els_cb_arg *cb_arg),
673 struct bnx2fc_els_cb_arg *cb_arg, u32 timer_msec)
674 {
675 struct fcoe_port *port = tgt->port;
676 struct bnx2fc_interface *interface = port->priv;
677 struct fc_rport *rport = tgt->rport;
678 struct fc_lport *lport = port->lport;
679 struct bnx2fc_cmd *els_req;
680 struct bnx2fc_mp_req *mp_req;
681 struct fc_frame_header *fc_hdr;
682 struct fcoe_task_ctx_entry *task;
683 struct fcoe_task_ctx_entry *task_page;
684 int rc = 0;
685 int task_idx, index;
686 u32 did, sid;
687 u16 xid;
688
689 rc = fc_remote_port_chkready(rport);
690 if (rc) {
691 printk(KERN_ERR PFX "els 0x%x: rport not ready\n", op);
692 rc = -EINVAL;
693 goto els_err;
694 }
695 if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
696 printk(KERN_ERR PFX "els 0x%x: link is not ready\n", op);
697 rc = -EINVAL;
698 goto els_err;
699 }
700 if (!(test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags))) {
701 printk(KERN_ERR PFX "els 0x%x: tgt not ready\n", op);
702 rc = -EINVAL;
703 goto els_err;
704 }
705 els_req = bnx2fc_elstm_alloc(tgt, BNX2FC_ELS);
706 if (!els_req) {
707 rc = -ENOMEM;
708 goto els_err;
709 }
710
711 els_req->sc_cmd = NULL;
712 els_req->port = port;
713 els_req->tgt = tgt;
714 els_req->cb_func = cb_func;
715 cb_arg->io_req = els_req;
716 els_req->cb_arg = cb_arg;
717 els_req->data_xfer_len = data_len;
718
719 mp_req = (struct bnx2fc_mp_req *)&(els_req->mp_req);
720 rc = bnx2fc_init_mp_req(els_req);
721 if (rc == FAILED) {
722 printk(KERN_ERR PFX "ELS MP request init failed\n");
723 spin_lock_bh(&tgt->tgt_lock);
724 kref_put(&els_req->refcount, bnx2fc_cmd_release);
725 spin_unlock_bh(&tgt->tgt_lock);
726 rc = -ENOMEM;
727 goto els_err;
728 } else {
729 /* rc SUCCESS */
730 rc = 0;
731 }
732
733 /* Set the data_xfer_len to the size of ELS payload */
734 mp_req->req_len = data_len;
735 els_req->data_xfer_len = mp_req->req_len;
736
737 /* Fill ELS Payload */
738 if ((op >= ELS_LS_RJT) && (op <= ELS_AUTH_ELS)) {
739 memcpy(mp_req->req_buf, data, data_len);
740 } else {
741 printk(KERN_ERR PFX "Invalid ELS op 0x%x\n", op);
742 els_req->cb_func = NULL;
743 els_req->cb_arg = NULL;
744 spin_lock_bh(&tgt->tgt_lock);
745 kref_put(&els_req->refcount, bnx2fc_cmd_release);
746 spin_unlock_bh(&tgt->tgt_lock);
747 rc = -EINVAL;
748 }
749
750 if (rc)
751 goto els_err;
752
753 /* Fill FC header */
754 fc_hdr = &(mp_req->req_fc_hdr);
755
756 did = tgt->rport->port_id;
757 sid = tgt->sid;
758
759 if (op == ELS_SRR)
760 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS4_REQ, did, sid,
761 FC_TYPE_FCP, FC_FC_FIRST_SEQ |
762 FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
763 else
764 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS_REQ, did, sid,
765 FC_TYPE_ELS, FC_FC_FIRST_SEQ |
766 FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
767
768 /* Obtain exchange id */
769 xid = els_req->xid;
770 task_idx = xid/BNX2FC_TASKS_PER_PAGE;
771 index = xid % BNX2FC_TASKS_PER_PAGE;
772
773 /* Initialize task context for this IO request */
774 task_page = (struct fcoe_task_ctx_entry *)
775 interface->hba->task_ctx[task_idx];
776 task = &(task_page[index]);
777 bnx2fc_init_mp_task(els_req, task);
778
779 spin_lock_bh(&tgt->tgt_lock);
780
781 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) {
782 printk(KERN_ERR PFX "initiate_els.. session not ready\n");
783 els_req->cb_func = NULL;
784 els_req->cb_arg = NULL;
785 kref_put(&els_req->refcount, bnx2fc_cmd_release);
786 spin_unlock_bh(&tgt->tgt_lock);
787 return -EINVAL;
788 }
789
790 if (timer_msec)
791 bnx2fc_cmd_timer_set(els_req, timer_msec);
792 bnx2fc_add_2_sq(tgt, xid);
793
794 els_req->on_active_queue = 1;
795 list_add_tail(&els_req->link, &tgt->els_queue);
796
797 /* Ring doorbell */
798 bnx2fc_ring_doorbell(tgt);
799 spin_unlock_bh(&tgt->tgt_lock);
800
801 els_err:
802 return rc;
803 }
804
805 void bnx2fc_process_els_compl(struct bnx2fc_cmd *els_req,
806 struct fcoe_task_ctx_entry *task, u8 num_rq)
807 {
808 struct bnx2fc_mp_req *mp_req;
809 struct fc_frame_header *fc_hdr;
810 u64 *hdr;
811 u64 *temp_hdr;
812
813 BNX2FC_ELS_DBG("Entered process_els_compl xid = 0x%x"
814 "cmd_type = %d\n", els_req->xid, els_req->cmd_type);
815
816 if (test_and_set_bit(BNX2FC_FLAG_ELS_DONE,
817 &els_req->req_flags)) {
818 BNX2FC_ELS_DBG("Timer context finished processing this "
819 "els - 0x%x\n", els_req->xid);
820 /* This IO doesn't receive cleanup completion */
821 kref_put(&els_req->refcount, bnx2fc_cmd_release);
822 return;
823 }
824
825 /* Cancel the timeout_work, as we received the response */
826 if (cancel_delayed_work(&els_req->timeout_work))
827 kref_put(&els_req->refcount,
828 bnx2fc_cmd_release); /* drop timer hold */
829
830 if (els_req->on_active_queue) {
831 list_del_init(&els_req->link);
832 els_req->on_active_queue = 0;
833 }
834
835 mp_req = &(els_req->mp_req);
836 fc_hdr = &(mp_req->resp_fc_hdr);
837
838 hdr = (u64 *)fc_hdr;
839 temp_hdr = (u64 *)
840 &task->rxwr_only.union_ctx.comp_info.mp_rsp.fc_hdr;
841 hdr[0] = cpu_to_be64(temp_hdr[0]);
842 hdr[1] = cpu_to_be64(temp_hdr[1]);
843 hdr[2] = cpu_to_be64(temp_hdr[2]);
844
845 mp_req->resp_len =
846 task->rxwr_only.union_ctx.comp_info.mp_rsp.mp_payload_len;
847
848 /* Parse ELS response */
849 if ((els_req->cb_func) && (els_req->cb_arg)) {
850 els_req->cb_func(els_req->cb_arg);
851 els_req->cb_arg = NULL;
852 }
853
854 kref_put(&els_req->refcount, bnx2fc_cmd_release);
855 }
856
857 #define BNX2FC_FCOE_MAC_METHOD_GRANGED_MAC 1
858 #define BNX2FC_FCOE_MAC_METHOD_FCF_MAP 2
859 #define BNX2FC_FCOE_MAC_METHOD_FCOE_SET_MAC 3
860 static void bnx2fc_flogi_resp(struct fc_seq *seq, struct fc_frame *fp,
861 void *arg)
862 {
863 struct fcoe_ctlr *fip = arg;
864 struct fc_exch *exch = fc_seq_exch(seq);
865 struct fc_lport *lport = exch->lp;
866
867 struct fc_frame_header *fh;
868 u8 *granted_mac;
869 u8 fcoe_mac[6];
870 u8 fc_map[3];
871 int method;
872
873 if (IS_ERR(fp))
874 goto done;
875
876 fh = fc_frame_header_get(fp);
877 granted_mac = fr_cb(fp)->granted_mac;
878
879 /*
880 * We set the source MAC for FCoE traffic based on the Granted MAC
881 * address from the switch.
882 *
883 * If granted_mac is non-zero, we use that.
884 * If the granted_mac is zeroed out, create the FCoE MAC based on
885 * the sel_fcf->fc_map and the d_id fo the FLOGI frame.
886 * If sel_fcf->fc_map is 0, then we use the default FCF-MAC plus the
887 * d_id of the FLOGI frame.
888 */
889 if (!is_zero_ether_addr(granted_mac)) {
890 ether_addr_copy(fcoe_mac, granted_mac);
891 method = BNX2FC_FCOE_MAC_METHOD_GRANGED_MAC;
892 } else if (fip->sel_fcf && fip->sel_fcf->fc_map != 0) {
893 hton24(fc_map, fip->sel_fcf->fc_map);
894 fcoe_mac[0] = fc_map[0];
895 fcoe_mac[1] = fc_map[1];
896 fcoe_mac[2] = fc_map[2];
897 fcoe_mac[3] = fh->fh_d_id[0];
898 fcoe_mac[4] = fh->fh_d_id[1];
899 fcoe_mac[5] = fh->fh_d_id[2];
900 method = BNX2FC_FCOE_MAC_METHOD_FCF_MAP;
901 } else {
902 fc_fcoe_set_mac(fcoe_mac, fh->fh_d_id);
903 method = BNX2FC_FCOE_MAC_METHOD_FCOE_SET_MAC;
904 }
905
906 BNX2FC_HBA_DBG(lport, "fcoe_mac=%pM method=%d\n", fcoe_mac, method);
907 fip->update_mac(lport, fcoe_mac);
908 done:
909 fc_lport_flogi_resp(seq, fp, lport);
910 }
911
912 static void bnx2fc_logo_resp(struct fc_seq *seq, struct fc_frame *fp,
913 void *arg)
914 {
915 struct fcoe_ctlr *fip = arg;
916 struct fc_exch *exch = fc_seq_exch(seq);
917 struct fc_lport *lport = exch->lp;
918 static u8 zero_mac[ETH_ALEN] = { 0 };
919
920 if (!IS_ERR(fp))
921 fip->update_mac(lport, zero_mac);
922 fc_lport_logo_resp(seq, fp, lport);
923 }
924
925 struct fc_seq *bnx2fc_elsct_send(struct fc_lport *lport, u32 did,
926 struct fc_frame *fp, unsigned int op,
927 void (*resp)(struct fc_seq *,
928 struct fc_frame *,
929 void *),
930 void *arg, u32 timeout)
931 {
932 struct fcoe_port *port = lport_priv(lport);
933 struct bnx2fc_interface *interface = port->priv;
934 struct fcoe_ctlr *fip = bnx2fc_to_ctlr(interface);
935 struct fc_frame_header *fh = fc_frame_header_get(fp);
936
937 switch (op) {
938 case ELS_FLOGI:
939 case ELS_FDISC:
940 return fc_elsct_send(lport, did, fp, op, bnx2fc_flogi_resp,
941 fip, timeout);
942 case ELS_LOGO:
943 /* only hook onto fabric logouts, not port logouts */
944 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
945 break;
946 return fc_elsct_send(lport, did, fp, op, bnx2fc_logo_resp,
947 fip, timeout);
948 }
949 return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
950 }
Kernel DRM miscellaneous fixes and cross-tree changes