2 * Copyright (C) 2005 - 2011 Emulex
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
12 * Contact Information:
13 * linux-drivers@emulex.com
17 * Costa Mesa, CA 92626
20 #include <linux/bsg-lib.h>
21 #include <scsi/scsi_transport_iscsi.h>
22 #include <scsi/scsi_bsg_iscsi.h>
27 * mgmt_reopen_session()- Reopen a session based on reopen_type
28 * @phba: Device priv structure instance
29 * @reopen_type: Type of reopen_session FW should do.
30 * @sess_handle: Session Handle of the session to be re-opened
33 * the TAG used for MBOX Command
36 unsigned int mgmt_reopen_session(struct beiscsi_hba *phba,
37 unsigned int reopen_type,
38 unsigned int sess_handle)
40 struct be_ctrl_info *ctrl = &phba->ctrl;
41 struct be_mcc_wrb *wrb;
42 struct be_cmd_reopen_session_req *req;
45 beiscsi_log(phba, KERN_INFO,
46 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
47 "BG_%d : In bescsi_get_boot_target\n");
49 spin_lock(&ctrl->mbox_lock);
50 tag = alloc_mcc_tag(phba);
52 spin_unlock(&ctrl->mbox_lock);
56 wrb = wrb_from_mccq(phba);
57 req = embedded_payload(wrb);
59 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
60 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
61 OPCODE_ISCSI_INI_DRIVER_REOPEN_ALL_SESSIONS,
62 sizeof(struct be_cmd_reopen_session_resp));
64 /* set the reopen_type,sess_handle */
65 req->reopen_type = reopen_type;
66 req->session_handle = sess_handle;
69 spin_unlock(&ctrl->mbox_lock);
73 unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba)
75 struct be_ctrl_info *ctrl = &phba->ctrl;
76 struct be_mcc_wrb *wrb;
77 struct be_cmd_get_boot_target_req *req;
80 beiscsi_log(phba, KERN_INFO,
81 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
82 "BG_%d : In bescsi_get_boot_target\n");
84 spin_lock(&ctrl->mbox_lock);
85 tag = alloc_mcc_tag(phba);
87 spin_unlock(&ctrl->mbox_lock);
91 wrb = wrb_from_mccq(phba);
92 req = embedded_payload(wrb);
94 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
95 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
96 OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET,
97 sizeof(struct be_cmd_get_boot_target_resp));
100 spin_unlock(&ctrl->mbox_lock);
104 unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
105 u32 boot_session_handle,
106 struct be_dma_mem *nonemb_cmd)
108 struct be_ctrl_info *ctrl = &phba->ctrl;
109 struct be_mcc_wrb *wrb;
110 unsigned int tag = 0;
111 struct be_cmd_get_session_req *req;
112 struct be_cmd_get_session_resp *resp;
115 beiscsi_log(phba, KERN_INFO,
116 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
117 "BG_%d : In beiscsi_get_session_info\n");
119 spin_lock(&ctrl->mbox_lock);
120 tag = alloc_mcc_tag(phba);
122 spin_unlock(&ctrl->mbox_lock);
126 nonemb_cmd->size = sizeof(*resp);
127 req = nonemb_cmd->va;
128 memset(req, 0, sizeof(*req));
129 wrb = wrb_from_mccq(phba);
130 sge = nonembedded_sgl(wrb);
135 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
136 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
137 OPCODE_ISCSI_INI_SESSION_GET_A_SESSION,
139 req->session_handle = boot_session_handle;
140 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
141 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
142 sge->len = cpu_to_le32(nonemb_cmd->size);
145 spin_unlock(&ctrl->mbox_lock);
149 int mgmt_get_fw_config(struct be_ctrl_info *ctrl,
150 struct beiscsi_hba *phba)
152 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
153 struct be_fw_cfg *req = embedded_payload(wrb);
156 spin_lock(&ctrl->mbox_lock);
157 memset(wrb, 0, sizeof(*wrb));
159 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
161 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
162 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req));
163 status = be_mbox_notify(ctrl);
165 struct be_fw_cfg *pfw_cfg;
167 phba->fw_config.phys_port = pfw_cfg->phys_port;
168 phba->fw_config.iscsi_icd_start =
169 pfw_cfg->ulp[0].icd_base;
170 phba->fw_config.iscsi_icd_count =
171 pfw_cfg->ulp[0].icd_count;
172 phba->fw_config.iscsi_cid_start =
173 pfw_cfg->ulp[0].sq_base;
174 phba->fw_config.iscsi_cid_count =
175 pfw_cfg->ulp[0].sq_count;
176 if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) {
177 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
178 "BG_%d : FW reported MAX CXNS as %d\t"
179 "Max Supported = %d.\n",
180 phba->fw_config.iscsi_cid_count,
182 phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2;
185 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
186 "BG_%d : Failed in mgmt_get_fw_config\n");
189 spin_unlock(&ctrl->mbox_lock);
193 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
194 struct beiscsi_hba *phba)
196 struct be_dma_mem nonemb_cmd;
197 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
198 struct be_mgmt_controller_attributes *req;
199 struct be_sge *sge = nonembedded_sgl(wrb);
202 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
203 sizeof(struct be_mgmt_controller_attributes),
205 if (nonemb_cmd.va == NULL) {
206 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
207 "BG_%d : Failed to allocate memory for "
208 "mgmt_check_supported_fw\n");
211 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
213 memset(req, 0, sizeof(*req));
214 spin_lock(&ctrl->mbox_lock);
215 memset(wrb, 0, sizeof(*wrb));
216 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
217 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
218 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req));
219 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma));
220 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
221 sge->len = cpu_to_le32(nonemb_cmd.size);
222 status = be_mbox_notify(ctrl);
224 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va;
225 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
226 "BG_%d : Firmware Version of CMD : %s\n"
227 "Firmware Version is : %s\n"
228 "Developer Build, not performing version check...\n",
229 resp->params.hba_attribs
230 .flashrom_version_string,
231 resp->params.hba_attribs.
232 firmware_version_string);
234 phba->fw_config.iscsi_features =
235 resp->params.hba_attribs.iscsi_features;
236 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
237 "BM_%d : phba->fw_config.iscsi_features = %d\n",
238 phba->fw_config.iscsi_features);
240 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
241 "BG_%d : Failed in mgmt_check_supported_fw\n");
242 spin_unlock(&ctrl->mbox_lock);
244 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
245 nonemb_cmd.va, nonemb_cmd.dma);
250 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
251 struct beiscsi_hba *phba,
253 struct be_dma_mem *nonemb_cmd)
255 struct be_cmd_resp_hdr *resp;
256 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
257 struct be_sge *mcc_sge = nonembedded_sgl(wrb);
258 unsigned int tag = 0;
259 struct iscsi_bsg_request *bsg_req = job->request;
260 struct be_bsg_vendor_cmd *req = nonemb_cmd->va;
261 unsigned short region, sector_size, sector, offset;
263 nonemb_cmd->size = job->request_payload.payload_len;
264 memset(nonemb_cmd->va, 0, nonemb_cmd->size);
265 resp = nonemb_cmd->va;
266 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
267 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2];
268 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3];
269 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4];
270 req->region = region;
271 req->sector = sector;
272 req->offset = offset;
273 spin_lock(&ctrl->mbox_lock);
274 memset(wrb, 0, sizeof(*wrb));
276 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) {
277 case BEISCSI_WRITE_FLASH:
278 offset = sector * sector_size + offset;
279 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
280 OPCODE_COMMON_WRITE_FLASH, sizeof(*req));
281 sg_copy_to_buffer(job->request_payload.sg_list,
282 job->request_payload.sg_cnt,
283 nonemb_cmd->va + offset, job->request_len);
285 case BEISCSI_READ_FLASH:
286 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
287 OPCODE_COMMON_READ_FLASH, sizeof(*req));
290 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
291 "BG_%d : Unsupported cmd = 0x%x\n\n",
292 bsg_req->rqst_data.h_vendor.vendor_cmd[0]);
294 spin_unlock(&ctrl->mbox_lock);
298 tag = alloc_mcc_tag(phba);
300 spin_unlock(&ctrl->mbox_lock);
304 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false,
305 job->request_payload.sg_cnt);
306 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
307 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
308 mcc_sge->len = cpu_to_le32(nonemb_cmd->size);
313 spin_unlock(&ctrl->mbox_lock);
317 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
319 struct be_ctrl_info *ctrl = &phba->ctrl;
320 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
321 struct iscsi_cleanup_req *req = embedded_payload(wrb);
324 spin_lock(&ctrl->mbox_lock);
325 memset(wrb, 0, sizeof(*wrb));
327 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
328 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
329 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
332 req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba));
333 req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba));
335 status = be_mcc_notify_wait(phba);
337 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
338 "BG_%d : mgmt_epfw_cleanup , FAILED\n");
339 spin_unlock(&ctrl->mbox_lock);
343 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba,
344 struct invalidate_command_table *inv_tbl,
345 unsigned int num_invalidate, unsigned int cid,
346 struct be_dma_mem *nonemb_cmd)
349 struct be_ctrl_info *ctrl = &phba->ctrl;
350 struct be_mcc_wrb *wrb;
352 struct invalidate_commands_params_in *req;
353 unsigned int i, tag = 0;
355 spin_lock(&ctrl->mbox_lock);
356 tag = alloc_mcc_tag(phba);
358 spin_unlock(&ctrl->mbox_lock);
362 req = nonemb_cmd->va;
363 memset(req, 0, sizeof(*req));
364 wrb = wrb_from_mccq(phba);
365 sge = nonembedded_sgl(wrb);
368 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
369 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
370 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS,
373 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE;
374 for (i = 0; i < num_invalidate; i++) {
375 req->table[i].icd = inv_tbl->icd;
376 req->table[i].cid = inv_tbl->cid;
380 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
381 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
382 sge->len = cpu_to_le32(nonemb_cmd->size);
385 spin_unlock(&ctrl->mbox_lock);
389 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba,
390 struct beiscsi_endpoint *beiscsi_ep,
392 unsigned short issue_reset,
393 unsigned short savecfg_flag)
395 struct be_ctrl_info *ctrl = &phba->ctrl;
396 struct be_mcc_wrb *wrb;
397 struct iscsi_invalidate_connection_params_in *req;
398 unsigned int tag = 0;
400 spin_lock(&ctrl->mbox_lock);
401 tag = alloc_mcc_tag(phba);
403 spin_unlock(&ctrl->mbox_lock);
406 wrb = wrb_from_mccq(phba);
408 req = embedded_payload(wrb);
410 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
411 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
412 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION,
414 req->session_handle = beiscsi_ep->fw_handle;
417 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST;
419 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
420 req->save_cfg = savecfg_flag;
422 spin_unlock(&ctrl->mbox_lock);
426 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba,
427 unsigned short cid, unsigned int upload_flag)
429 struct be_ctrl_info *ctrl = &phba->ctrl;
430 struct be_mcc_wrb *wrb;
431 struct tcp_upload_params_in *req;
432 unsigned int tag = 0;
434 spin_lock(&ctrl->mbox_lock);
435 tag = alloc_mcc_tag(phba);
437 spin_unlock(&ctrl->mbox_lock);
440 wrb = wrb_from_mccq(phba);
441 req = embedded_payload(wrb);
444 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
445 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD,
446 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req));
447 req->id = (unsigned short)cid;
448 req->upload_type = (unsigned char)upload_flag;
450 spin_unlock(&ctrl->mbox_lock);
454 int mgmt_open_connection(struct beiscsi_hba *phba,
455 struct sockaddr *dst_addr,
456 struct beiscsi_endpoint *beiscsi_ep,
457 struct be_dma_mem *nonemb_cmd)
459 struct hwi_controller *phwi_ctrlr;
460 struct hwi_context_memory *phwi_context;
461 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr;
462 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr;
463 struct be_ctrl_info *ctrl = &phba->ctrl;
464 struct be_mcc_wrb *wrb;
465 struct tcp_connect_and_offload_in *req;
466 unsigned short def_hdr_id;
467 unsigned short def_data_id;
468 struct phys_addr template_address = { 0, 0 };
469 struct phys_addr *ptemplate_address;
470 unsigned int tag = 0;
472 unsigned short cid = beiscsi_ep->ep_cid;
475 phwi_ctrlr = phba->phwi_ctrlr;
476 phwi_context = phwi_ctrlr->phwi_ctxt;
477 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba);
478 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba);
480 ptemplate_address = &template_address;
481 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address);
482 spin_lock(&ctrl->mbox_lock);
483 tag = alloc_mcc_tag(phba);
485 spin_unlock(&ctrl->mbox_lock);
488 wrb = wrb_from_mccq(phba);
489 memset(wrb, 0, sizeof(*wrb));
490 sge = nonembedded_sgl(wrb);
492 req = nonemb_cmd->va;
493 memset(req, 0, sizeof(*req));
496 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
497 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
498 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD,
500 if (dst_addr->sa_family == PF_INET) {
501 __be32 s_addr = daddr_in->sin_addr.s_addr;
502 req->ip_address.ip_type = BE2_IPV4;
503 req->ip_address.addr[0] = s_addr & 0x000000ff;
504 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8;
505 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16;
506 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24;
507 req->tcp_port = ntohs(daddr_in->sin_port);
508 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr;
509 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port);
510 beiscsi_ep->ip_type = BE2_IPV4;
511 } else if (dst_addr->sa_family == PF_INET6) {
512 req->ip_address.ip_type = BE2_IPV6;
513 memcpy(&req->ip_address.addr,
514 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
515 req->tcp_port = ntohs(daddr_in6->sin6_port);
516 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port);
517 memcpy(&beiscsi_ep->dst6_addr,
518 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
519 beiscsi_ep->ip_type = BE2_IPV6;
521 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
522 "BG_%d : unknown addr family %d\n",
523 dst_addr->sa_family);
524 spin_unlock(&ctrl->mbox_lock);
525 free_mcc_tag(&phba->ctrl, tag);
530 i = phba->nxt_cqid++;
531 if (phba->nxt_cqid == phba->num_cpus)
533 req->cq_id = phwi_context->be_cq[i].id;
534 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
535 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id);
536 req->defq_id = def_hdr_id;
537 req->hdr_ring_id = def_hdr_id;
538 req->data_ring_id = def_data_id;
540 req->dataout_template_pa.lo = ptemplate_address->lo;
541 req->dataout_template_pa.hi = ptemplate_address->hi;
542 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
543 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
544 sge->len = cpu_to_le32(nonemb_cmd->size);
546 spin_unlock(&ctrl->mbox_lock);
550 unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba)
552 struct be_ctrl_info *ctrl = &phba->ctrl;
553 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
554 struct be_cmd_get_all_if_id_req *req = embedded_payload(wrb);
555 struct be_cmd_get_all_if_id_req *pbe_allid = req;
558 memset(wrb, 0, sizeof(*wrb));
560 spin_lock(&ctrl->mbox_lock);
562 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
563 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
564 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID,
566 status = be_mbox_notify(ctrl);
568 phba->interface_handle = pbe_allid->if_hndl_list[0];
570 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
571 "BG_%d : Failed in mgmt_get_all_if_id\n");
573 spin_unlock(&ctrl->mbox_lock);
578 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
579 struct be_dma_mem *nonemb_cmd, void *resp_buf,
582 struct be_ctrl_info *ctrl = &phba->ctrl;
583 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
584 unsigned short status, extd_status;
589 spin_lock(&ctrl->mbox_lock);
590 tag = alloc_mcc_tag(phba);
592 spin_unlock(&ctrl->mbox_lock);
596 memset(wrb, 0, sizeof(*wrb));
598 sge = nonembedded_sgl(wrb);
600 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1);
601 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
602 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
603 sge->len = cpu_to_le32(nonemb_cmd->size);
606 spin_unlock(&ctrl->mbox_lock);
608 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
609 phba->ctrl.mcc_numtag[tag]);
611 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
612 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
613 if (status || extd_status) {
614 beiscsi_log(phba, KERN_ERR,
615 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
616 "BG_%d : mgmt_exec_nonemb_cmd Failed status = %d"
617 "extd_status = %d\n", status, extd_status);
623 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
626 free_mcc_tag(&phba->ctrl, tag);
628 pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
629 nonemb_cmd->va, nonemb_cmd->dma);
633 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd,
634 int iscsi_cmd, int size)
636 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
638 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
639 "BG_%d : Failed to allocate memory for if info\n");
642 memset(cmd->va, 0, size);
644 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size);
649 mgmt_static_ip_modify(struct beiscsi_hba *phba,
650 struct be_cmd_get_if_info_resp *if_info,
651 struct iscsi_iface_param_info *ip_param,
652 struct iscsi_iface_param_info *subnet_param,
655 struct be_cmd_set_ip_addr_req *req;
656 struct be_dma_mem nonemb_cmd;
660 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
661 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR,
666 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
667 BE2_IPV6 : BE2_IPV4 ;
670 req->ip_params.record_entry_count = 1;
671 req->ip_params.ip_record.action = ip_action;
672 req->ip_params.ip_record.interface_hndl =
673 phba->interface_handle;
674 req->ip_params.ip_record.ip_addr.size_of_structure =
675 sizeof(struct be_ip_addr_subnet_format);
676 req->ip_params.ip_record.ip_addr.ip_type = ip_type;
678 if (ip_action == IP_ACTION_ADD) {
679 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value,
683 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
684 subnet_param->value, subnet_param->len);
686 memcpy(req->ip_params.ip_record.ip_addr.addr,
687 if_info->ip_addr.addr, ip_param->len);
689 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
690 if_info->ip_addr.subnet_mask, ip_param->len);
693 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
695 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
696 "BG_%d : Failed to Modify existing IP Address\n");
700 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr,
701 uint32_t gtway_action, uint32_t param_len)
703 struct be_cmd_set_def_gateway_req *req;
704 struct be_dma_mem nonemb_cmd;
708 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
709 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY,
715 req->action = gtway_action;
716 req->ip_addr.ip_type = BE2_IPV4;
718 memcpy(req->ip_addr.addr, gt_addr, param_len);
720 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
723 int mgmt_set_ip(struct beiscsi_hba *phba,
724 struct iscsi_iface_param_info *ip_param,
725 struct iscsi_iface_param_info *subnet_param,
728 struct be_cmd_get_def_gateway_resp gtway_addr_set;
729 struct be_cmd_get_if_info_resp if_info;
730 struct be_cmd_set_dhcp_req *dhcpreq;
731 struct be_cmd_rel_dhcp_req *reldhcp;
732 struct be_dma_mem nonemb_cmd;
737 if (mgmt_get_all_if_id(phba))
740 memset(&if_info, 0, sizeof(if_info));
741 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
742 BE2_IPV6 : BE2_IPV4 ;
744 rc = mgmt_get_if_info(phba, ip_type, &if_info);
748 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
749 if (if_info.dhcp_state) {
750 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
751 "BG_%d : DHCP Already Enabled\n");
754 /* The ip_param->len is 1 in DHCP case. Setting
755 proper IP len as this it is used while
756 freeing the Static IP.
758 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
759 IP_V6_LEN : IP_V4_LEN;
762 if (if_info.dhcp_state) {
764 memset(&if_info, 0, sizeof(if_info));
765 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
766 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR,
772 reldhcp = nonemb_cmd.va;
773 reldhcp->interface_hndl = phba->interface_handle;
774 reldhcp->ip_type = ip_type;
776 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
778 beiscsi_log(phba, KERN_WARNING,
780 "BG_%d : Failed to Delete existing dhcp\n");
786 /* Delete the Static IP Set */
787 if (if_info.ip_addr.addr[0]) {
788 rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL,
794 /* Delete the Gateway settings if mode change is to DHCP */
795 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
796 memset(>way_addr_set, 0, sizeof(gtway_addr_set));
797 rc = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set);
799 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
800 "BG_%d : Failed to Get Gateway Addr\n");
804 if (gtway_addr_set.ip_addr.addr[0]) {
805 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr;
806 rc = mgmt_modify_gateway(phba, gtway_addr,
807 IP_ACTION_DEL, IP_V4_LEN);
810 beiscsi_log(phba, KERN_WARNING,
812 "BG_%d : Failed to clear Gateway Addr Set\n");
818 /* Set Adapter to DHCP/Static Mode */
819 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
820 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
821 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR,
826 dhcpreq = nonemb_cmd.va;
827 dhcpreq->flags = BLOCKING;
828 dhcpreq->retry_count = 1;
829 dhcpreq->interface_hndl = phba->interface_handle;
830 dhcpreq->ip_type = BE2_DHCP_V4;
832 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
834 return mgmt_static_ip_modify(phba, &if_info, ip_param,
835 subnet_param, IP_ACTION_ADD);
841 int mgmt_set_gateway(struct beiscsi_hba *phba,
842 struct iscsi_iface_param_info *gateway_param)
844 struct be_cmd_get_def_gateway_resp gtway_addr_set;
848 memset(>way_addr_set, 0, sizeof(gtway_addr_set));
849 rt_val = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set);
851 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
852 "BG_%d : Failed to Get Gateway Addr\n");
856 if (gtway_addr_set.ip_addr.addr[0]) {
857 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr;
858 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL,
861 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
862 "BG_%d : Failed to clear Gateway Addr Set\n");
867 gtway_addr = (uint8_t *)&gateway_param->value;
868 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD,
872 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
873 "BG_%d : Failed to Set Gateway Addr\n");
878 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
879 struct be_cmd_get_def_gateway_resp *gateway)
881 struct be_cmd_get_def_gateway_req *req;
882 struct be_dma_mem nonemb_cmd;
885 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
886 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY,
892 req->ip_type = ip_type;
894 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway,
898 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
899 struct be_cmd_get_if_info_resp *if_info)
901 struct be_cmd_get_if_info_req *req;
902 struct be_dma_mem nonemb_cmd;
905 if (mgmt_get_all_if_id(phba))
908 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
909 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO,
915 req->interface_hndl = phba->interface_handle;
916 req->ip_type = ip_type;
918 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info,
922 int mgmt_get_nic_conf(struct beiscsi_hba *phba,
923 struct be_cmd_get_nic_conf_resp *nic)
925 struct be_dma_mem nonemb_cmd;
928 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
929 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
934 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic));
939 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
941 unsigned int tag = 0;
942 struct be_mcc_wrb *wrb;
943 struct be_cmd_hba_name *req;
944 struct be_ctrl_info *ctrl = &phba->ctrl;
946 spin_lock(&ctrl->mbox_lock);
947 tag = alloc_mcc_tag(phba);
949 spin_unlock(&ctrl->mbox_lock);
953 wrb = wrb_from_mccq(phba);
954 req = embedded_payload(wrb);
956 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
957 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
958 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
962 spin_unlock(&ctrl->mbox_lock);
966 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
968 unsigned int tag = 0;
969 struct be_mcc_wrb *wrb;
970 struct be_cmd_ntwk_link_status_req *req;
971 struct be_ctrl_info *ctrl = &phba->ctrl;
973 spin_lock(&ctrl->mbox_lock);
974 tag = alloc_mcc_tag(phba);
976 spin_unlock(&ctrl->mbox_lock);
980 wrb = wrb_from_mccq(phba);
981 req = embedded_payload(wrb);
983 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
984 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
985 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
989 spin_unlock(&ctrl->mbox_lock);
994 * be_mgmt_get_boot_shandle()- Get the session handle
995 * @phba: device priv structure instance
996 * @s_handle: session handle returned for boot session.
998 * Get the boot target session handle. In case of
999 * crashdump mode driver has to issue and MBX Cmd
1000 * for FW to login to boot target
1004 * Failure: Non-Zero value
1007 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba,
1008 unsigned int *s_handle)
1010 struct be_cmd_get_boot_target_resp *boot_resp;
1011 struct be_mcc_wrb *wrb;
1012 unsigned int tag, wrb_num;
1013 uint8_t boot_retry = 3;
1014 unsigned short status, extd_status;
1015 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
1018 /* Get the Boot Target Session Handle and Count*/
1019 tag = mgmt_get_boot_target(phba);
1021 beiscsi_log(phba, KERN_ERR,
1022 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
1023 "BG_%d : Getting Boot Target Info Failed\n");
1026 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1027 phba->ctrl.mcc_numtag[tag]);
1029 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
1030 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
1031 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
1032 if (status || extd_status) {
1033 beiscsi_log(phba, KERN_ERR,
1034 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1035 "BG_%d : mgmt_get_boot_target Failed"
1036 " status = %d extd_status = %d\n",
1037 status, extd_status);
1038 free_mcc_tag(&phba->ctrl, tag);
1041 wrb = queue_get_wrb(mccq, wrb_num);
1042 free_mcc_tag(&phba->ctrl, tag);
1043 boot_resp = embedded_payload(wrb);
1045 /* Check if the there are any Boot targets configured */
1046 if (!boot_resp->boot_session_count) {
1047 beiscsi_log(phba, KERN_INFO,
1048 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1049 "BG_%d ;No boot targets configured\n");
1053 /* FW returns the session handle of the boot session */
1054 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) {
1055 *s_handle = boot_resp->boot_session_handle;
1059 /* Issue MBX Cmd to FW to login to the boot target */
1060 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS,
1061 INVALID_SESS_HANDLE);
1063 beiscsi_log(phba, KERN_ERR,
1064 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1065 "BG_%d : mgmt_reopen_session Failed\n");
1068 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1069 phba->ctrl.mcc_numtag[tag]);
1071 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
1072 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
1073 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
1074 if (status || extd_status) {
1075 beiscsi_log(phba, KERN_ERR,
1076 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1077 "BG_%d : mgmt_reopen_session Failed"
1078 " status = %d extd_status = %d\n",
1079 status, extd_status);
1080 free_mcc_tag(&phba->ctrl, tag);
1083 free_mcc_tag(&phba->ctrl, tag);
1085 } while (--boot_retry);
1087 /* Couldn't log into the boot target */
1088 beiscsi_log(phba, KERN_ERR,
1089 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1090 "BG_%d : Login to Boot Target Failed\n");
1095 * mgmt_set_vlan()- Issue and wait for CMD completion
1096 * @phba: device private structure instance
1097 * @vlan_tag: VLAN tag
1099 * Issue the MBX Cmd and wait for the completion of the
1104 * Failure: Non-Xero Value
1106 int mgmt_set_vlan(struct beiscsi_hba *phba,
1109 unsigned int tag, wrb_num;
1110 unsigned short status, extd_status;
1112 tag = be_cmd_set_vlan(phba, vlan_tag);
1114 beiscsi_log(phba, KERN_ERR,
1115 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1116 "BG_%d : VLAN Setting Failed\n");
1119 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1120 phba->ctrl.mcc_numtag[tag]);
1122 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
1123 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
1124 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
1126 if (status || extd_status) {
1127 beiscsi_log(phba, KERN_ERR,
1128 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1129 "BS_%d : status : %d extd_status : %d\n",
1130 status, extd_status);
1132 free_mcc_tag(&phba->ctrl, tag);
1136 free_mcc_tag(&phba->ctrl, tag);
1141 * beiscsi_drvr_ver_disp()- Display the driver Name and Version
1142 * @dev: ptr to device not used.
1143 * @attr: device attribute, not used.
1144 * @buf: contains formatted text driver name and version
1147 * size of the formatted string
1150 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr,
1153 return snprintf(buf, PAGE_SIZE, BE_NAME "\n");
1156 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params,
1157 struct wrb_handle *pwrb_handle,
1158 struct be_mem_descriptor *mem_descr)
1160 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1162 memset(pwrb, 0, sizeof(*pwrb));
1163 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1164 max_send_data_segment_length, pwrb,
1165 params->dw[offsetof(struct amap_beiscsi_offload_params,
1166 max_send_data_segment_length) / 32]);
1167 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb,
1168 BE_TGT_CTX_UPDT_CMD);
1169 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1172 params->dw[offsetof(struct amap_beiscsi_offload_params,
1173 first_burst_length) / 32]);
1174 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb,
1175 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1176 erl) / 32] & OFFLD_PARAMS_ERL));
1177 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb,
1178 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1179 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1180 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb,
1181 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1182 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1183 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb,
1184 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1185 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1186 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb,
1187 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1188 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1189 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn,
1191 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1192 exp_statsn) / 32] + 1));
1193 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx,
1194 pwrb, pwrb_handle->wrb_index);
1196 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1197 max_burst_length, pwrb, params->dw[offsetof
1198 (struct amap_beiscsi_offload_params,
1199 max_burst_length) / 32]);
1201 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb,
1202 pwrb, pwrb_handle->nxt_wrb_index);
1203 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1204 session_state, pwrb, 0);
1205 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack,
1207 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq,
1209 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb,
1212 mem_descr += ISCSI_MEM_GLOBAL_HEADER;
1213 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1214 pad_buffer_addr_hi, pwrb,
1215 mem_descr->mem_array[0].bus_address.u.a32.address_hi);
1216 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1217 pad_buffer_addr_lo, pwrb,
1218 mem_descr->mem_array[0].bus_address.u.a32.address_lo);
1221 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params,
1222 struct wrb_handle *pwrb_handle)
1224 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1226 memset(pwrb, 0, sizeof(*pwrb));
1228 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1229 max_burst_length, pwrb, params->dw[offsetof
1230 (struct amap_beiscsi_offload_params,
1231 max_burst_length) / 32]);
1232 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1233 max_burst_length, pwrb, params->dw[offsetof
1234 (struct amap_beiscsi_offload_params,
1235 max_burst_length) / 32]);
1236 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1238 BE_TGT_CTX_UPDT_CMD);
1239 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1241 pwrb, pwrb_handle->nxt_wrb_index);
1242 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx,
1243 pwrb, pwrb_handle->wrb_index);
1244 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1245 max_send_data_segment_length, pwrb,
1246 params->dw[offsetof(struct amap_beiscsi_offload_params,
1247 max_send_data_segment_length) / 32]);
1248 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1249 first_burst_length, pwrb,
1250 params->dw[offsetof(struct amap_beiscsi_offload_params,
1251 first_burst_length) / 32]);
1252 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1253 max_recv_dataseg_len, pwrb, BEISCSI_MAX_RECV_DATASEG_LEN);
1254 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1255 max_cxns, pwrb, BEISCSI_MAX_CXNS);
1256 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb,
1257 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1258 erl) / 32] & OFFLD_PARAMS_ERL));
1259 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb,
1260 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1261 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1262 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb,
1263 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1264 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1265 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1267 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1268 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1269 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb,
1270 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1271 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1272 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1275 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1276 data_seq_inorder) / 32] &
1277 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6);
1278 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1281 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1282 pdu_seq_inorder) / 32] &
1283 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7);
1284 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t,
1286 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1288 OFFLD_PARAMS_MAX_R2T) >> 8);
1289 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn,
1291 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1292 exp_statsn) / 32] + 1));