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