Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2010 Cisco Systems, Inc. |
| 3 | * |
| 4 | * Portions based on tcm_loop_fabric_scsi.c and libfc/fc_fcp.c |
| 5 | * |
| 6 | * Copyright (c) 2007 Intel Corporation. All rights reserved. |
| 7 | * Copyright (c) 2008 Red Hat, Inc. All rights reserved. |
| 8 | * Copyright (c) 2008 Mike Christie |
| 9 | * Copyright (c) 2009 Rising Tide, Inc. |
| 10 | * Copyright (c) 2009 Linux-iSCSI.org |
| 11 | * Copyright (c) 2009 Nicholas A. Bellinger <nab@linux-iscsi.org> |
| 12 | * |
| 13 | * This program is free software; you can redistribute it and/or modify it |
| 14 | * under the terms and conditions of the GNU General Public License, |
| 15 | * version 2, as published by the Free Software Foundation. |
| 16 | * |
| 17 | * This program is distributed in the hope it will be useful, but WITHOUT |
| 18 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 19 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 20 | * more details. |
| 21 | * |
| 22 | * You should have received a copy of the GNU General Public License along with |
| 23 | * this program; if not, write to the Free Software Foundation, Inc., |
| 24 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. |
| 25 | */ |
| 26 | |
| 27 | /* XXX TBD some includes may be extraneous */ |
| 28 | |
| 29 | #include <linux/module.h> |
| 30 | #include <linux/moduleparam.h> |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 31 | #include <linux/utsname.h> |
| 32 | #include <linux/init.h> |
| 33 | #include <linux/slab.h> |
| 34 | #include <linux/kthread.h> |
| 35 | #include <linux/types.h> |
| 36 | #include <linux/string.h> |
| 37 | #include <linux/configfs.h> |
| 38 | #include <linux/ctype.h> |
| 39 | #include <linux/hash.h> |
Andy Grover | 6708bb2 | 2011-06-08 10:36:43 -0700 | [diff] [blame] | 40 | #include <linux/ratelimit.h> |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 41 | #include <asm/unaligned.h> |
| 42 | #include <scsi/scsi.h> |
| 43 | #include <scsi/scsi_host.h> |
| 44 | #include <scsi/scsi_device.h> |
| 45 | #include <scsi/scsi_cmnd.h> |
| 46 | #include <scsi/libfc.h> |
| 47 | #include <scsi/fc_encode.h> |
| 48 | |
| 49 | #include <target/target_core_base.h> |
Christoph Hellwig | c4795fb | 2011-11-16 09:46:48 -0500 | [diff] [blame] | 50 | #include <target/target_core_fabric.h> |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 51 | #include <target/target_core_configfs.h> |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 52 | #include <target/configfs_macros.h> |
| 53 | |
| 54 | #include "tcm_fc.h" |
| 55 | |
| 56 | /* |
| 57 | * Deliver read data back to initiator. |
| 58 | * XXX TBD handle resource problems later. |
| 59 | */ |
| 60 | int ft_queue_data_in(struct se_cmd *se_cmd) |
| 61 | { |
| 62 | struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 63 | struct fc_frame *fp = NULL; |
| 64 | struct fc_exch *ep; |
| 65 | struct fc_lport *lport; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 66 | struct scatterlist *sg = NULL; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 67 | size_t remaining; |
| 68 | u32 f_ctl = FC_FC_EX_CTX | FC_FC_REL_OFF; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 69 | u32 mem_off = 0; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 70 | u32 fh_off = 0; |
| 71 | u32 frame_off = 0; |
| 72 | size_t frame_len = 0; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 73 | size_t mem_len = 0; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 74 | size_t tlen; |
| 75 | size_t off_in_page; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 76 | struct page *page = NULL; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 77 | int use_sg; |
| 78 | int error; |
| 79 | void *page_addr; |
| 80 | void *from; |
| 81 | void *to = NULL; |
| 82 | |
Mark Rustad | e1c4038 | 2012-04-03 10:24:41 -0700 | [diff] [blame] | 83 | if (cmd->aborted) |
| 84 | return 0; |
Nicholas Bellinger | b3e5fe1 | 2014-06-05 16:27:53 -0700 | [diff] [blame] | 85 | |
| 86 | if (se_cmd->scsi_status == SAM_STAT_TASK_SET_FULL) |
| 87 | goto queue_status; |
| 88 | |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 89 | ep = fc_seq_exch(cmd->seq); |
| 90 | lport = ep->lp; |
| 91 | cmd->seq = lport->tt.seq_start_next(cmd->seq); |
| 92 | |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 93 | remaining = se_cmd->data_length; |
| 94 | |
| 95 | /* |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 96 | * Setup to use first mem list entry, unless no data. |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 97 | */ |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 98 | BUG_ON(remaining && !se_cmd->t_data_sg); |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 99 | if (remaining) { |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 100 | sg = se_cmd->t_data_sg; |
| 101 | mem_len = sg->length; |
| 102 | mem_off = sg->offset; |
| 103 | page = sg_page(sg); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | /* no scatter/gather in skb for odd word length due to fc_seq_send() */ |
| 107 | use_sg = !(remaining % 4); |
| 108 | |
| 109 | while (remaining) { |
Mark Rustad | d3682b1 | 2013-04-22 09:49:55 -0700 | [diff] [blame] | 110 | struct fc_seq *seq = cmd->seq; |
| 111 | |
| 112 | if (!seq) { |
| 113 | pr_debug("%s: Command aborted, xid 0x%x\n", |
| 114 | __func__, ep->xid); |
| 115 | break; |
| 116 | } |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 117 | if (!mem_len) { |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 118 | sg = sg_next(sg); |
| 119 | mem_len = min((size_t)sg->length, remaining); |
| 120 | mem_off = sg->offset; |
| 121 | page = sg_page(sg); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 122 | } |
| 123 | if (!frame_len) { |
| 124 | /* |
| 125 | * If lport's has capability of Large Send Offload LSO) |
| 126 | * , then allow 'frame_len' to be as big as 'lso_max' |
| 127 | * if indicated transfer length is >= lport->lso_max |
| 128 | */ |
| 129 | frame_len = (lport->seq_offload) ? lport->lso_max : |
| 130 | cmd->sess->max_frame; |
| 131 | frame_len = min(frame_len, remaining); |
| 132 | fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len); |
| 133 | if (!fp) |
| 134 | return -ENOMEM; |
| 135 | to = fc_frame_payload_get(fp, 0); |
| 136 | fh_off = frame_off; |
| 137 | frame_off += frame_len; |
| 138 | /* |
| 139 | * Setup the frame's max payload which is used by base |
| 140 | * driver to indicate HW about max frame size, so that |
| 141 | * HW can do fragmentation appropriately based on |
| 142 | * "gso_max_size" of underline netdev. |
| 143 | */ |
| 144 | fr_max_payload(fp) = cmd->sess->max_frame; |
| 145 | } |
| 146 | tlen = min(mem_len, frame_len); |
| 147 | |
| 148 | if (use_sg) { |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 149 | off_in_page = mem_off; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 150 | BUG_ON(!page); |
| 151 | get_page(page); |
| 152 | skb_fill_page_desc(fp_skb(fp), |
| 153 | skb_shinfo(fp_skb(fp))->nr_frags, |
| 154 | page, off_in_page, tlen); |
| 155 | fr_len(fp) += tlen; |
| 156 | fp_skb(fp)->data_len += tlen; |
| 157 | fp_skb(fp)->truesize += |
| 158 | PAGE_SIZE << compound_order(page); |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 159 | } else { |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 160 | BUG_ON(!page); |
Cong Wang | ca747d6 | 2011-11-25 23:14:25 +0800 | [diff] [blame] | 161 | from = kmap_atomic(page + (mem_off >> PAGE_SHIFT)); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 162 | page_addr = from; |
| 163 | from += mem_off & ~PAGE_MASK; |
| 164 | tlen = min(tlen, (size_t)(PAGE_SIZE - |
| 165 | (mem_off & ~PAGE_MASK))); |
| 166 | memcpy(to, from, tlen); |
Cong Wang | ca747d6 | 2011-11-25 23:14:25 +0800 | [diff] [blame] | 167 | kunmap_atomic(page_addr); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 168 | to += tlen; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | mem_off += tlen; |
| 172 | mem_len -= tlen; |
| 173 | frame_len -= tlen; |
| 174 | remaining -= tlen; |
| 175 | |
| 176 | if (frame_len && |
| 177 | (skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN)) |
| 178 | continue; |
| 179 | if (!remaining) |
| 180 | f_ctl |= FC_FC_END_SEQ; |
| 181 | fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid, |
| 182 | FC_TYPE_FCP, f_ctl, fh_off); |
Mark Rustad | d3682b1 | 2013-04-22 09:49:55 -0700 | [diff] [blame] | 183 | error = lport->tt.seq_send(lport, seq, fp); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 184 | if (error) { |
Nicholas Bellinger | b3e5fe1 | 2014-06-05 16:27:53 -0700 | [diff] [blame] | 185 | pr_info_ratelimited("%s: Failed to send frame %p, " |
Nicholas Bellinger | 95efa286 | 2011-06-23 23:28:46 +0000 | [diff] [blame] | 186 | "xid <0x%x>, remaining %zu, " |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 187 | "lso_max <0x%x>\n", |
| 188 | __func__, fp, ep->xid, |
| 189 | remaining, lport->lso_max); |
Nicholas Bellinger | b3e5fe1 | 2014-06-05 16:27:53 -0700 | [diff] [blame] | 190 | /* |
| 191 | * Go ahead and set TASK_SET_FULL status ignoring the |
| 192 | * rest of the DataIN, and immediately attempt to |
| 193 | * send the response via ft_queue_status() in order |
| 194 | * to notify the initiator that it should reduce it's |
| 195 | * per LUN queue_depth. |
| 196 | */ |
| 197 | se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL; |
| 198 | break; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 199 | } |
| 200 | } |
Nicholas Bellinger | b3e5fe1 | 2014-06-05 16:27:53 -0700 | [diff] [blame] | 201 | queue_status: |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 202 | return ft_queue_status(se_cmd); |
| 203 | } |
| 204 | |
Christoph Hellwig | b8b2253 | 2012-07-08 15:58:45 -0400 | [diff] [blame] | 205 | static void ft_execute_work(struct work_struct *work) |
| 206 | { |
| 207 | struct ft_cmd *cmd = container_of(work, struct ft_cmd, work); |
| 208 | |
| 209 | target_execute_cmd(&cmd->se_cmd); |
| 210 | } |
| 211 | |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 212 | /* |
| 213 | * Receive write data frame. |
| 214 | */ |
| 215 | void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp) |
| 216 | { |
| 217 | struct se_cmd *se_cmd = &cmd->se_cmd; |
| 218 | struct fc_seq *seq = cmd->seq; |
| 219 | struct fc_exch *ep; |
| 220 | struct fc_lport *lport; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 221 | struct fc_frame_header *fh; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 222 | struct scatterlist *sg = NULL; |
| 223 | u32 mem_off = 0; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 224 | u32 rel_off; |
| 225 | size_t frame_len; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 226 | size_t mem_len = 0; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 227 | size_t tlen; |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 228 | struct page *page = NULL; |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 229 | void *page_addr; |
| 230 | void *from; |
| 231 | void *to; |
| 232 | u32 f_ctl; |
| 233 | void *buf; |
| 234 | |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 235 | fh = fc_frame_header_get(fp); |
| 236 | if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF)) |
| 237 | goto drop; |
| 238 | |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 239 | f_ctl = ntoh24(fh->fh_f_ctl); |
| 240 | ep = fc_seq_exch(seq); |
| 241 | lport = ep->lp; |
| 242 | if (cmd->was_ddp_setup) { |
| 243 | BUG_ON(!ep); |
| 244 | BUG_ON(!lport); |
Kiran Patil | 079587b | 2011-08-26 09:25:25 -0700 | [diff] [blame] | 245 | /* |
| 246 | * Since DDP (Large Rx offload) was setup for this request, |
| 247 | * payload is expected to be copied directly to user buffers. |
| 248 | */ |
| 249 | buf = fc_frame_payload_get(fp, 1); |
| 250 | if (buf) |
| 251 | pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, " |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 252 | "cmd->sg_cnt 0x%x. DDP was setup" |
| 253 | " hence not expected to receive frame with " |
Kiran Patil | 079587b | 2011-08-26 09:25:25 -0700 | [diff] [blame] | 254 | "payload, Frame will be dropped if" |
| 255 | "'Sequence Initiative' bit in f_ctl is" |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 256 | "not set\n", __func__, ep->xid, f_ctl, |
Roland Dreier | e182d68 | 2012-03-30 11:29:11 -0700 | [diff] [blame] | 257 | se_cmd->t_data_sg, se_cmd->t_data_nents); |
Kiran Patil | 079587b | 2011-08-26 09:25:25 -0700 | [diff] [blame] | 258 | /* |
| 259 | * Invalidate HW DDP context if it was setup for respective |
| 260 | * command. Invalidation of HW DDP context is requited in both |
| 261 | * situation (success and error). |
| 262 | */ |
| 263 | ft_invl_hw_context(cmd); |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 264 | |
Kiran Patil | 079587b | 2011-08-26 09:25:25 -0700 | [diff] [blame] | 265 | /* |
| 266 | * If "Sequence Initiative (TSI)" bit set in f_ctl, means last |
| 267 | * write data frame is received successfully where payload is |
| 268 | * posted directly to user buffer and only the last frame's |
| 269 | * header is posted in receive queue. |
| 270 | * |
| 271 | * If "Sequence Initiative (TSI)" bit is not set, means error |
| 272 | * condition w.r.t. DDP, hence drop the packet and let explict |
| 273 | * ABORTS from other end of exchange timer trigger the recovery. |
| 274 | */ |
| 275 | if (f_ctl & FC_FC_SEQ_INIT) |
| 276 | goto last_frame; |
| 277 | else |
| 278 | goto drop; |
| 279 | } |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 280 | |
| 281 | rel_off = ntohl(fh->fh_parm_offset); |
| 282 | frame_len = fr_len(fp); |
| 283 | if (frame_len <= sizeof(*fh)) |
| 284 | goto drop; |
| 285 | frame_len -= sizeof(*fh); |
| 286 | from = fc_frame_payload_get(fp, 0); |
| 287 | if (rel_off >= se_cmd->data_length) |
| 288 | goto drop; |
| 289 | if (frame_len + rel_off > se_cmd->data_length) |
| 290 | frame_len = se_cmd->data_length - rel_off; |
| 291 | |
| 292 | /* |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 293 | * Setup to use first mem list entry, unless no data. |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 294 | */ |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 295 | BUG_ON(frame_len && !se_cmd->t_data_sg); |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 296 | if (frame_len) { |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 297 | sg = se_cmd->t_data_sg; |
| 298 | mem_len = sg->length; |
| 299 | mem_off = sg->offset; |
| 300 | page = sg_page(sg); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | while (frame_len) { |
| 304 | if (!mem_len) { |
Andy Grover | ec98f78 | 2011-07-20 19:28:46 +0000 | [diff] [blame] | 305 | sg = sg_next(sg); |
| 306 | mem_len = sg->length; |
| 307 | mem_off = sg->offset; |
| 308 | page = sg_page(sg); |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 309 | } |
| 310 | if (rel_off >= mem_len) { |
| 311 | rel_off -= mem_len; |
| 312 | mem_len = 0; |
| 313 | continue; |
| 314 | } |
| 315 | mem_off += rel_off; |
| 316 | mem_len -= rel_off; |
| 317 | rel_off = 0; |
| 318 | |
| 319 | tlen = min(mem_len, frame_len); |
| 320 | |
Cong Wang | ca747d6 | 2011-11-25 23:14:25 +0800 | [diff] [blame] | 321 | to = kmap_atomic(page + (mem_off >> PAGE_SHIFT)); |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 322 | page_addr = to; |
| 323 | to += mem_off & ~PAGE_MASK; |
| 324 | tlen = min(tlen, (size_t)(PAGE_SIZE - |
| 325 | (mem_off & ~PAGE_MASK))); |
| 326 | memcpy(to, from, tlen); |
Cong Wang | ca747d6 | 2011-11-25 23:14:25 +0800 | [diff] [blame] | 327 | kunmap_atomic(page_addr); |
Andy Grover | 05d1c7c | 2011-07-20 19:13:28 +0000 | [diff] [blame] | 328 | |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 329 | from += tlen; |
| 330 | frame_len -= tlen; |
| 331 | mem_off += tlen; |
| 332 | mem_len -= tlen; |
| 333 | cmd->write_data_len += tlen; |
| 334 | } |
| 335 | last_frame: |
Christoph Hellwig | b8b2253 | 2012-07-08 15:58:45 -0400 | [diff] [blame] | 336 | if (cmd->write_data_len == se_cmd->data_length) { |
| 337 | INIT_WORK(&cmd->work, ft_execute_work); |
| 338 | queue_work(cmd->sess->tport->tpg->workqueue, &cmd->work); |
| 339 | } |
Kiran Patil | 3699d92 | 2011-04-18 16:24:14 -0700 | [diff] [blame] | 340 | drop: |
| 341 | fc_frame_free(fp); |
| 342 | } |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 343 | |
| 344 | /* |
| 345 | * Handle and cleanup any HW specific resources if |
| 346 | * received ABORTS, errors, timeouts. |
| 347 | */ |
| 348 | void ft_invl_hw_context(struct ft_cmd *cmd) |
| 349 | { |
Wei Yongjun | 7875f17 | 2012-09-07 14:55:32 +0800 | [diff] [blame] | 350 | struct fc_seq *seq; |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 351 | struct fc_exch *ep = NULL; |
| 352 | struct fc_lport *lport = NULL; |
| 353 | |
| 354 | BUG_ON(!cmd); |
Wei Yongjun | 7875f17 | 2012-09-07 14:55:32 +0800 | [diff] [blame] | 355 | seq = cmd->seq; |
Kiran Patil | dcd998c | 2011-08-03 09:20:01 +0000 | [diff] [blame] | 356 | |
| 357 | /* Cleanup the DDP context in HW if DDP was setup */ |
| 358 | if (cmd->was_ddp_setup && seq) { |
| 359 | ep = fc_seq_exch(seq); |
| 360 | if (ep) { |
| 361 | lport = ep->lp; |
| 362 | if (lport && (ep->xid <= lport->lro_xid)) |
| 363 | /* |
| 364 | * "ddp_done" trigger invalidation of HW |
| 365 | * specific DDP context |
| 366 | */ |
| 367 | cmd->write_data_len = lport->tt.ddp_done(lport, |
| 368 | ep->xid); |
| 369 | |
| 370 | /* |
| 371 | * Resetting same variable to indicate HW's |
| 372 | * DDP context has been invalidated to avoid |
| 373 | * re_invalidation of same context (context is |
| 374 | * identified using ep->xid) |
| 375 | */ |
| 376 | cmd->was_ddp_setup = 0; |
| 377 | } |
| 378 | } |
| 379 | } |