projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] be2iscsi: Fix for MBX timeout issue
[linux-2.6-block.git] / drivers / scsi / be2iscsi / be_mgmt.c
CommitLineData
6733b39a 1/**
5faf17b4 2 * Copyright (C) 2005 - 2012 Emulex
6733b39a
JK		 3 * All rights reserved.
4 *
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.
9 *
255fa9a3 10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
6733b39a
JK		 11 *
12 * Contact Information:
255fa9a3 13 * linux-drivers@emulex.com
6733b39a 14 *
255fa9a3
JK		 15 * Emulex
16 * 3333 Susan Street
17 * Costa Mesa, CA 92626
6733b39a
JK		 18 */
19
ffce3e2e
JK		 20#include <linux/bsg-lib.h>
21#include <scsi/scsi_transport_iscsi.h>
22#include <scsi/scsi_bsg_iscsi.h>
6733b39a
JK		 23#include "be_mgmt.h"
24#include "be_iscsi.h"
c7acc5b8 25
9aef4200
JSJ		 26/**
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
31 *
32 * return
33 * the TAG used for MBOX Command
34 *
35 **/
36unsigned int mgmt_reopen_session(struct beiscsi_hba *phba,
37 unsigned int reopen_type,
38 unsigned int sess_handle)
39{
40 struct be_ctrl_info *ctrl = &phba->ctrl;
41 struct be_mcc_wrb *wrb;
42 struct be_cmd_reopen_session_req *req;
43 unsigned int tag = 0;
44
99bc5d55
JSJ		 45 beiscsi_log(phba, KERN_INFO,
46 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
47 "BG_%d : In bescsi_get_boot_target\n");
48
9aef4200
JSJ		 49 spin_lock(&ctrl->mbox_lock);
50 tag = alloc_mcc_tag(phba);
51 if (!tag) {
52 spin_unlock(&ctrl->mbox_lock);
53 return tag;
54 }
55
56 wrb = wrb_from_mccq(phba);
57 req = embedded_payload(wrb);
58 wrb->tag0 |= tag;
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));
63
64 /* set the reopen_type,sess_handle */
65 req->reopen_type = reopen_type;
66 req->session_handle = sess_handle;
67
68 be_mcc_notify(phba);
69 spin_unlock(&ctrl->mbox_lock);
70 return tag;
71}
72
0e43895e 73unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba)
c7acc5b8
JK		 74{
75 struct be_ctrl_info *ctrl = &phba->ctrl;
76 struct be_mcc_wrb *wrb;
0e43895e 77 struct be_cmd_get_boot_target_req *req;
c7acc5b8
JK		 78 unsigned int tag = 0;
79
99bc5d55
JSJ		 80 beiscsi_log(phba, KERN_INFO,
81 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
82 "BG_%d : In bescsi_get_boot_target\n");
83
c7acc5b8
JK		 84 spin_lock(&ctrl->mbox_lock);
85 tag = alloc_mcc_tag(phba);
86 if (!tag) {
87 spin_unlock(&ctrl->mbox_lock);
88 return tag;
89 }
90
91 wrb = wrb_from_mccq(phba);
92 req = embedded_payload(wrb);
93 wrb->tag0 |= tag;
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,
0e43895e 97 sizeof(struct be_cmd_get_boot_target_resp));
c7acc5b8
JK		 98
99 be_mcc_notify(phba);
100 spin_unlock(&ctrl->mbox_lock);
101 return tag;
102}
103
0e43895e
MC		 104unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
105 u32 boot_session_handle,
106 struct be_dma_mem *nonemb_cmd)
c7acc5b8
JK		 107{
108 struct be_ctrl_info *ctrl = &phba->ctrl;
109 struct be_mcc_wrb *wrb;
110 unsigned int tag = 0;
0e43895e
MC		 111 struct be_cmd_get_session_req *req;
112 struct be_cmd_get_session_resp *resp;
c7acc5b8
JK		 113 struct be_sge *sge;
114
99bc5d55
JSJ		 115 beiscsi_log(phba, KERN_INFO,
116 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
117 "BG_%d : In beiscsi_get_session_info\n");
118
c7acc5b8
JK		 119 spin_lock(&ctrl->mbox_lock);
120 tag = alloc_mcc_tag(phba);
121 if (!tag) {
122 spin_unlock(&ctrl->mbox_lock);
123 return tag;
124 }
125
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);
131 wrb->tag0 |= tag;
132
133
134 wrb->tag0 |= tag;
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,
138 sizeof(*resp));
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);
143
144 be_mcc_notify(phba);
145 spin_unlock(&ctrl->mbox_lock);
146 return tag;
147}
6733b39a 148
03a12310 149int mgmt_get_fw_config(struct be_ctrl_info *ctrl,
6733b39a
JK		 150 struct beiscsi_hba *phba)
151{
152 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
153 struct be_fw_cfg *req = embedded_payload(wrb);
154 int status = 0;
155
156 spin_lock(&ctrl->mbox_lock);
157 memset(wrb, 0, sizeof(*wrb));
158
159 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
160
161 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
162 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req));
6733b39a
JK		 163 status = be_mbox_notify(ctrl);
164 if (!status) {
165 struct be_fw_cfg *pfw_cfg;
166 pfw_cfg = req;
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;
7da50879 176 if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) {
99bc5d55
JSJ		 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,
181 BE2_MAX_SESSIONS);
a3babda5 182 phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2;
7da50879 183 }
6733b39a 184 } else {
99bc5d55
JSJ		 185 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
186 "BG_%d : Failed in mgmt_get_fw_config\n");
6733b39a
JK		 187 }
188
189 spin_unlock(&ctrl->mbox_lock);
190 return status;
191}
192
03a12310 193int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
bfead3b2 194 struct beiscsi_hba *phba)
6733b39a
JK		 195{
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);
200 int status = 0;
201
202 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
203 sizeof(struct be_mgmt_controller_attributes),
204 &nonemb_cmd.dma);
205 if (nonemb_cmd.va == NULL) {
99bc5d55
JSJ		 206 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
207 "BG_%d : Failed to allocate memory for "
208 "mgmt_check_supported_fw\n");
d3ad2bb3 209 return -ENOMEM;
6733b39a
JK		 210 }
211 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
212 req = nonemb_cmd.va;
f98c96b0 213 memset(req, 0, sizeof(*req));
6733b39a
JK		 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);
6733b39a
JK		 222 status = be_mbox_notify(ctrl);
223 if (!status) {
224 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va;
99bc5d55
JSJ		 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);
233
bfead3b2
JK		 234 phba->fw_config.iscsi_features =
235 resp->params.hba_attribs.iscsi_features;
99bc5d55
JSJ		 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);
6733b39a 239 } else
99bc5d55
JSJ		 240 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
241 "BG_%d : Failed in mgmt_check_supported_fw\n");
bfead3b2 242 spin_unlock(&ctrl->mbox_lock);
6733b39a
JK		 243 if (nonemb_cmd.va)
244 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
245 nonemb_cmd.va, nonemb_cmd.dma);
246
6733b39a
JK		 247 return status;
248}
249
ffce3e2e
JK		 250unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
251 struct beiscsi_hba *phba,
252 struct bsg_job *job,
253 struct be_dma_mem *nonemb_cmd)
254{
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;
262
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));
275
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);
284 break;
285 case BEISCSI_READ_FLASH:
286 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
287 OPCODE_COMMON_READ_FLASH, sizeof(*req));
288 break;
289 default:
99bc5d55
JSJ		 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]);
293
ffce3e2e
JK		 294 spin_unlock(&ctrl->mbox_lock);
295 return -ENOSYS;
296 }
297
298 tag = alloc_mcc_tag(phba);
299 if (!tag) {
300 spin_unlock(&ctrl->mbox_lock);
301 return tag;
302 }
303
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);
309 wrb->tag0 |= tag;
310
311 be_mcc_notify(phba);
312
313 spin_unlock(&ctrl->mbox_lock);
314 return tag;
315}
316
03a12310 317int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
6733b39a
JK		 318{
319 struct be_ctrl_info *ctrl = &phba->ctrl;
bfead3b2 320 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
6733b39a
JK		 321 struct iscsi_cleanup_req *req = embedded_payload(wrb);
322 int status = 0;
323
324 spin_lock(&ctrl->mbox_lock);
325 memset(wrb, 0, sizeof(*wrb));
326
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));
330
331 req->chute = chute;
069adc7b
JK		 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));
6733b39a 334
bfead3b2 335 status = be_mcc_notify_wait(phba);
6733b39a 336 if (status)
99bc5d55
JSJ		 337 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
338 "BG_%d : mgmt_epfw_cleanup , FAILED\n");
6733b39a
JK		 339 spin_unlock(&ctrl->mbox_lock);
340 return status;
341}
342
03a12310 343unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba,
4183122d 344 struct invalidate_command_table *inv_tbl,
3cbb7a74
JK		 345 unsigned int num_invalidate, unsigned int cid,
346 struct be_dma_mem *nonemb_cmd)
347
6733b39a 348{
6733b39a 349 struct be_ctrl_info *ctrl = &phba->ctrl;
756d29c8
JK		 350 struct be_mcc_wrb *wrb;
351 struct be_sge *sge;
6733b39a 352 struct invalidate_commands_params_in *req;
4183122d 353 unsigned int i, tag = 0;
756d29c8
JK		 354
355 spin_lock(&ctrl->mbox_lock);
356 tag = alloc_mcc_tag(phba);
357 if (!tag) {
358 spin_unlock(&ctrl->mbox_lock);
359 return tag;
360 }
6733b39a 361
3cbb7a74 362 req = nonemb_cmd->va;
f98c96b0 363 memset(req, 0, sizeof(*req));
756d29c8
JK		 364 wrb = wrb_from_mccq(phba);
365 sge = nonembedded_sgl(wrb);
366 wrb->tag0 |= tag;
6733b39a
JK		 367
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,
371 sizeof(*req));
372 req->ref_handle = 0;
373 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE;
4183122d
JK		 374 for (i = 0; i < num_invalidate; i++) {
375 req->table[i].icd = inv_tbl->icd;
376 req->table[i].cid = inv_tbl->cid;
377 req->icd_count++;
378 inv_tbl++;
379 }
3cbb7a74
JK		 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);
6733b39a 383
756d29c8 384 be_mcc_notify(phba);
6733b39a 385 spin_unlock(&ctrl->mbox_lock);
756d29c8 386 return tag;
6733b39a
JK		 387}
388
03a12310 389unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba,
6733b39a
JK		 390 struct beiscsi_endpoint *beiscsi_ep,
391 unsigned short cid,
392 unsigned short issue_reset,
393 unsigned short savecfg_flag)
394{
395 struct be_ctrl_info *ctrl = &phba->ctrl;
756d29c8
JK		 396 struct be_mcc_wrb *wrb;
397 struct iscsi_invalidate_connection_params_in *req;
398 unsigned int tag = 0;
6733b39a
JK		 399
400 spin_lock(&ctrl->mbox_lock);
756d29c8
JK		 401 tag = alloc_mcc_tag(phba);
402 if (!tag) {
403 spin_unlock(&ctrl->mbox_lock);
404 return tag;
405 }
406 wrb = wrb_from_mccq(phba);
407 wrb->tag0 |= tag;
408 req = embedded_payload(wrb);
6733b39a
JK		 409
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,
413 sizeof(*req));
414 req->session_handle = beiscsi_ep->fw_handle;
415 req->cid = cid;
416 if (issue_reset)
417 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST;
418 else
419 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
420 req->save_cfg = savecfg_flag;
756d29c8 421 be_mcc_notify(phba);
6733b39a 422 spin_unlock(&ctrl->mbox_lock);
756d29c8 423 return tag;
6733b39a
JK		 424}
425
03a12310 426unsigned int mgmt_upload_connection(struct beiscsi_hba *phba,
6733b39a
JK		 427 unsigned short cid, unsigned int upload_flag)
428{
429 struct be_ctrl_info *ctrl = &phba->ctrl;
756d29c8
JK		 430 struct be_mcc_wrb *wrb;
431 struct tcp_upload_params_in *req;
432 unsigned int tag = 0;
6733b39a
JK		 433
434 spin_lock(&ctrl->mbox_lock);
756d29c8
JK		 435 tag = alloc_mcc_tag(phba);
436 if (!tag) {
437 spin_unlock(&ctrl->mbox_lock);
438 return tag;
439 }
440 wrb = wrb_from_mccq(phba);
441 req = embedded_payload(wrb);
442 wrb->tag0 |= tag;
6733b39a
JK		 443
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;
756d29c8 449 be_mcc_notify(phba);
6733b39a 450 spin_unlock(&ctrl->mbox_lock);
756d29c8 451 return tag;
6733b39a
JK		 452}
453
454int mgmt_open_connection(struct beiscsi_hba *phba,
455 struct sockaddr *dst_addr,
3cbb7a74
JK		 456 struct beiscsi_endpoint *beiscsi_ep,
457 struct be_dma_mem *nonemb_cmd)
6733b39a
JK		 458{
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;
756d29c8
JK		 464 struct be_mcc_wrb *wrb;
465 struct tcp_connect_and_offload_in *req;
6733b39a
JK		 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;
756d29c8 470 unsigned int tag = 0;
bfead3b2 471 unsigned int i;
6733b39a 472 unsigned short cid = beiscsi_ep->ep_cid;
3cbb7a74 473 struct be_sge *sge;
6733b39a
JK		 474
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);
479
480 ptemplate_address = &template_address;
481 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address);
482 spin_lock(&ctrl->mbox_lock);
756d29c8
JK		 483 tag = alloc_mcc_tag(phba);
484 if (!tag) {
485 spin_unlock(&ctrl->mbox_lock);
486 return tag;
487 }
488 wrb = wrb_from_mccq(phba);
3cbb7a74
JK		 489 memset(wrb, 0, sizeof(*wrb));
490 sge = nonembedded_sgl(wrb);
491
492 req = nonemb_cmd->va;
493 memset(req, 0, sizeof(*req));
756d29c8 494 wrb->tag0 |= tag;
6733b39a 495
b15d05b0 496 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
6733b39a
JK		 497 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
498 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD,
499 sizeof(*req));
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;
0e43895e
MC		 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;
6733b39a
JK		 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;
0e43895e 513 memcpy(&req->ip_address.addr,
6733b39a
JK		 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;
520 } else{
99bc5d55
JSJ		 521 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
522 "BG_%d : unknown addr family %d\n",
523 dst_addr->sa_family);
6733b39a 524 spin_unlock(&ctrl->mbox_lock);
5db3f33d 525 free_mcc_tag(&phba->ctrl, tag);
6733b39a
JK		 526 return -EINVAL;
527
528 }
529 req->cid = cid;
bfead3b2
JK		 530 i = phba->nxt_cqid++;
531 if (phba->nxt_cqid == phba->num_cpus)
532 phba->nxt_cqid = 0;
533 req->cq_id = phwi_context->be_cq[i].id;
99bc5d55
JSJ		 534 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
535 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id);
6733b39a
JK		 536 req->defq_id = def_hdr_id;
537 req->hdr_ring_id = def_hdr_id;
538 req->data_ring_id = def_data_id;
539 req->do_offload = 1;
540 req->dataout_template_pa.lo = ptemplate_address->lo;
541 req->dataout_template_pa.hi = ptemplate_address->hi;
3cbb7a74
JK		 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);
756d29c8 545 be_mcc_notify(phba);
6733b39a 546 spin_unlock(&ctrl->mbox_lock);
756d29c8 547 return tag;
6733b39a 548}
bfead3b2 549
0e43895e 550unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba)
bfead3b2
JK		 551{
552 struct be_ctrl_info *ctrl = &phba->ctrl;
0e43895e
MC		 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;
556 int status = 0;
557
558 memset(wrb, 0, sizeof(*wrb));
559
560 spin_lock(&ctrl->mbox_lock);
561
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,
565 sizeof(*req));
566 status = be_mbox_notify(ctrl);
567 if (!status)
568 phba->interface_handle = pbe_allid->if_hndl_list[0];
569 else {
99bc5d55
JSJ		 570 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
571 "BG_%d : Failed in mgmt_get_all_if_id\n");
0e43895e
MC		 572 }
573 spin_unlock(&ctrl->mbox_lock);
574
575 return status;
576}
577
e175defe
JSJ		 578/*
579 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd
580 * @phba: Driver priv structure
581 * @nonemb_cmd: Address of the MBX command issued
582 * @resp_buf: Buffer to copy the MBX cmd response
583 * @resp_buf_len: respone lenght to be copied
584 *
585 **/
0e43895e
MC		 586static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
587 struct be_dma_mem *nonemb_cmd, void *resp_buf,
588 int resp_buf_len)
589{
590 struct be_ctrl_info *ctrl = &phba->ctrl;
591 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
0e43895e
MC		 592 struct be_sge *sge;
593 unsigned int tag;
594 int rc = 0;
bfead3b2 595
bfead3b2 596 spin_lock(&ctrl->mbox_lock);
756d29c8
JK		 597 tag = alloc_mcc_tag(phba);
598 if (!tag) {
599 spin_unlock(&ctrl->mbox_lock);
0e43895e
MC		 600 rc = -ENOMEM;
601 goto free_cmd;
756d29c8 602 }
0e43895e 603 memset(wrb, 0, sizeof(*wrb));
756d29c8 604 wrb->tag0 |= tag;
0e43895e
MC		 605 sge = nonembedded_sgl(wrb);
606
607 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1);
608 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
e175defe 609 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma));
0e43895e 610 sge->len = cpu_to_le32(nonemb_cmd->size);
bfead3b2 611
756d29c8 612 be_mcc_notify(phba);
bfead3b2 613 spin_unlock(&ctrl->mbox_lock);
0e43895e 614
e175defe
JSJ		 615 rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd->va);
616 if (rc) {
99bc5d55
JSJ		 617 beiscsi_log(phba, KERN_ERR,
618 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
e175defe
JSJ		 619 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n");
620
0e43895e 621 rc = -EIO;
e175defe 622 goto free_cmd;
0e43895e
MC		 623 }
624
625 if (resp_buf)
626 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
627
0e43895e
MC		 628free_cmd:
629 pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
630 nonemb_cmd->va, nonemb_cmd->dma);
631 return rc;
632}
633
634static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd,
635 int iscsi_cmd, int size)
636{
b83d543f 637 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
0e43895e 638 if (!cmd->va) {
99bc5d55
JSJ		 639 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
640 "BG_%d : Failed to allocate memory for if info\n");
0e43895e
MC		 641 return -ENOMEM;
642 }
b83d543f 643 memset(cmd->va, 0, size);
0e43895e
MC		 644 cmd->size = size;
645 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size);
646 return 0;
bfead3b2
JK		 647}
648
0e43895e
MC		 649static int
650mgmt_static_ip_modify(struct beiscsi_hba *phba,
651 struct be_cmd_get_if_info_resp *if_info,
652 struct iscsi_iface_param_info *ip_param,
653 struct iscsi_iface_param_info *subnet_param,
654 uint32_t ip_action)
655{
656 struct be_cmd_set_ip_addr_req *req;
657 struct be_dma_mem nonemb_cmd;
658 uint32_t ip_type;
659 int rc;
660
661 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
662 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR,
663 sizeof(*req));
664 if (rc)
665 return rc;
666
667 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
668 BE2_IPV6 : BE2_IPV4 ;
669
670 req = nonemb_cmd.va;
671 req->ip_params.record_entry_count = 1;
672 req->ip_params.ip_record.action = ip_action;
673 req->ip_params.ip_record.interface_hndl =
674 phba->interface_handle;
675 req->ip_params.ip_record.ip_addr.size_of_structure =
676 sizeof(struct be_ip_addr_subnet_format);
677 req->ip_params.ip_record.ip_addr.ip_type = ip_type;
678
679 if (ip_action == IP_ACTION_ADD) {
680 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value,
681 ip_param->len);
682
683 if (subnet_param)
684 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
685 subnet_param->value, subnet_param->len);
686 } else {
687 memcpy(req->ip_params.ip_record.ip_addr.addr,
688 if_info->ip_addr.addr, ip_param->len);
689
690 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
691 if_info->ip_addr.subnet_mask, ip_param->len);
692 }
693
694 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
695 if (rc < 0)
99bc5d55
JSJ		 696 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
697 "BG_%d : Failed to Modify existing IP Address\n");
0e43895e
MC		 698 return rc;
699}
700
701static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr,
702 uint32_t gtway_action, uint32_t param_len)
703{
704 struct be_cmd_set_def_gateway_req *req;
705 struct be_dma_mem nonemb_cmd;
706 int rt_val;
707
708
709 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
710 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY,
711 sizeof(*req));
712 if (rt_val)
713 return rt_val;
714
715 req = nonemb_cmd.va;
716 req->action = gtway_action;
717 req->ip_addr.ip_type = BE2_IPV4;
718
719 memcpy(req->ip_addr.addr, gt_addr, param_len);
720
721 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
722}
723
724int mgmt_set_ip(struct beiscsi_hba *phba,
725 struct iscsi_iface_param_info *ip_param,
726 struct iscsi_iface_param_info *subnet_param,
727 uint32_t boot_proto)
728{
729 struct be_cmd_get_def_gateway_resp gtway_addr_set;
730 struct be_cmd_get_if_info_resp if_info;
731 struct be_cmd_set_dhcp_req *dhcpreq;
732 struct be_cmd_rel_dhcp_req *reldhcp;
733 struct be_dma_mem nonemb_cmd;
734 uint8_t *gtway_addr;
735 uint32_t ip_type;
736 int rc;
737
738 if (mgmt_get_all_if_id(phba))
739 return -EIO;
740
741 memset(&if_info, 0, sizeof(if_info));
742 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
743 BE2_IPV6 : BE2_IPV4 ;
744
745 rc = mgmt_get_if_info(phba, ip_type, &if_info);
746 if (rc)
747 return rc;
748
749 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
750 if (if_info.dhcp_state) {
99bc5d55
JSJ		 751 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
752 "BG_%d : DHCP Already Enabled\n");
0e43895e
MC		 753 return 0;
754 }
755 /* The ip_param->len is 1 in DHCP case. Setting
756 proper IP len as this it is used while
757 freeing the Static IP.
758 */
759 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
760 IP_V6_LEN : IP_V4_LEN;
761
762 } else {
763 if (if_info.dhcp_state) {
764
765 memset(&if_info, 0, sizeof(if_info));
766 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
767 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR,
768 sizeof(*reldhcp));
769
770 if (rc)
771 return rc;
772
773 reldhcp = nonemb_cmd.va;
774 reldhcp->interface_hndl = phba->interface_handle;
775 reldhcp->ip_type = ip_type;
776
777 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
778 if (rc < 0) {
99bc5d55
JSJ		 779 beiscsi_log(phba, KERN_WARNING,
780 BEISCSI_LOG_CONFIG,
781 "BG_%d : Failed to Delete existing dhcp\n");
0e43895e
MC		 782 return rc;
783 }
784 }
785 }
786
787 /* Delete the Static IP Set */
788 if (if_info.ip_addr.addr[0]) {
789 rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL,
790 IP_ACTION_DEL);
791 if (rc)
792 return rc;
793 }
794
795 /* Delete the Gateway settings if mode change is to DHCP */
796 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
797 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
798 rc = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
799 if (rc) {
99bc5d55
JSJ		 800 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
801 "BG_%d : Failed to Get Gateway Addr\n");
0e43895e
MC		 802 return rc;
803 }
804
805 if (gtway_addr_set.ip_addr.addr[0]) {
806 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
807 rc = mgmt_modify_gateway(phba, gtway_addr,
808 IP_ACTION_DEL, IP_V4_LEN);
809
810 if (rc) {
99bc5d55
JSJ		 811 beiscsi_log(phba, KERN_WARNING,
812 BEISCSI_LOG_CONFIG,
813 "BG_%d : Failed to clear Gateway Addr Set\n");
0e43895e
MC		 814 return rc;
815 }
816 }
817 }
818
819 /* Set Adapter to DHCP/Static Mode */
820 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
821 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
822 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR,
823 sizeof(*dhcpreq));
824 if (rc)
825 return rc;
826
827 dhcpreq = nonemb_cmd.va;
828 dhcpreq->flags = BLOCKING;
829 dhcpreq->retry_count = 1;
830 dhcpreq->interface_hndl = phba->interface_handle;
831 dhcpreq->ip_type = BE2_DHCP_V4;
832
833 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
834 } else {
835 return mgmt_static_ip_modify(phba, &if_info, ip_param,
836 subnet_param, IP_ACTION_ADD);
837 }
838
839 return rc;
840}
841
842int mgmt_set_gateway(struct beiscsi_hba *phba,
843 struct iscsi_iface_param_info *gateway_param)
844{
845 struct be_cmd_get_def_gateway_resp gtway_addr_set;
846 uint8_t *gtway_addr;
847 int rt_val;
848
849 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
850 rt_val = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
851 if (rt_val) {
99bc5d55
JSJ		 852 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
853 "BG_%d : Failed to Get Gateway Addr\n");
0e43895e
MC		 854 return rt_val;
855 }
856
857 if (gtway_addr_set.ip_addr.addr[0]) {
858 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
859 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL,
860 gateway_param->len);
861 if (rt_val) {
99bc5d55
JSJ		 862 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
863 "BG_%d : Failed to clear Gateway Addr Set\n");
0e43895e
MC		 864 return rt_val;
865 }
866 }
867
868 gtway_addr = (uint8_t *)&gateway_param->value;
869 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD,
870 gateway_param->len);
871
872 if (rt_val)
99bc5d55
JSJ		 873 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
874 "BG_%d : Failed to Set Gateway Addr\n");
0e43895e
MC		 875
876 return rt_val;
877}
878
879int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
880 struct be_cmd_get_def_gateway_resp *gateway)
881{
882 struct be_cmd_get_def_gateway_req *req;
883 struct be_dma_mem nonemb_cmd;
884 int rc;
885
886 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
887 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY,
888 sizeof(*gateway));
889 if (rc)
890 return rc;
891
892 req = nonemb_cmd.va;
893 req->ip_type = ip_type;
894
895 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway,
896 sizeof(*gateway));
897}
898
899int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
900 struct be_cmd_get_if_info_resp *if_info)
901{
902 struct be_cmd_get_if_info_req *req;
903 struct be_dma_mem nonemb_cmd;
904 int rc;
905
906 if (mgmt_get_all_if_id(phba))
907 return -EIO;
908
909 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
910 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO,
911 sizeof(*if_info));
912 if (rc)
913 return rc;
914
915 req = nonemb_cmd.va;
916 req->interface_hndl = phba->interface_handle;
917 req->ip_type = ip_type;
918
919 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info,
920 sizeof(*if_info));
921}
922
923int mgmt_get_nic_conf(struct beiscsi_hba *phba,
924 struct be_cmd_get_nic_conf_resp *nic)
925{
926 struct be_dma_mem nonemb_cmd;
927 int rc;
928
929 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
930 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
931 sizeof(*nic));
932 if (rc)
933 return rc;
934
935 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic));
936}
937
938
939
2177199d
JSJ		 940unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
941{
942 unsigned int tag = 0;
943 struct be_mcc_wrb *wrb;
944 struct be_cmd_hba_name *req;
945 struct be_ctrl_info *ctrl = &phba->ctrl;
946
947 spin_lock(&ctrl->mbox_lock);
948 tag = alloc_mcc_tag(phba);
949 if (!tag) {
950 spin_unlock(&ctrl->mbox_lock);
951 return tag;
952 }
953
954 wrb = wrb_from_mccq(phba);
955 req = embedded_payload(wrb);
956 wrb->tag0 |= tag;
957 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
958 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
959 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
960 sizeof(*req));
961
962 be_mcc_notify(phba);
963 spin_unlock(&ctrl->mbox_lock);
964 return tag;
965}
c62eef0d
JSJ		 966
967unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
968{
969 unsigned int tag = 0;
970 struct be_mcc_wrb *wrb;
971 struct be_cmd_ntwk_link_status_req *req;
972 struct be_ctrl_info *ctrl = &phba->ctrl;
973
974 spin_lock(&ctrl->mbox_lock);
975 tag = alloc_mcc_tag(phba);
976 if (!tag) {
977 spin_unlock(&ctrl->mbox_lock);
978 return tag;
979 }
980
981 wrb = wrb_from_mccq(phba);
982 req = embedded_payload(wrb);
983 wrb->tag0 |= tag;
984 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
985 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
986 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
987 sizeof(*req));
988
989 be_mcc_notify(phba);
990 spin_unlock(&ctrl->mbox_lock);
991 return tag;
992}
9aef4200
JSJ		 993
994/**
995 * be_mgmt_get_boot_shandle()- Get the session handle
996 * @phba: device priv structure instance
997 * @s_handle: session handle returned for boot session.
998 *
999 * Get the boot target session handle. In case of
1000 * crashdump mode driver has to issue and MBX Cmd
1001 * for FW to login to boot target
1002 *
1003 * return
1004 * Success: 0
1005 * Failure: Non-Zero value
1006 *
1007 **/
1008int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba,
1009 unsigned int *s_handle)
1010{
1011 struct be_cmd_get_boot_target_resp *boot_resp;
1012 struct be_mcc_wrb *wrb;
e175defe 1013 unsigned int tag;
9aef4200 1014 uint8_t boot_retry = 3;
e175defe 1015 int rc;
9aef4200
JSJ		 1016
1017 do {
1018 /* Get the Boot Target Session Handle and Count*/
1019 tag = mgmt_get_boot_target(phba);
1020 if (!tag) {
99bc5d55
JSJ		 1021 beiscsi_log(phba, KERN_ERR,
1022 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
1023 "BG_%d : Getting Boot Target Info Failed\n");
9aef4200 1024 return -EAGAIN;
e175defe
JSJ		 1025 }
1026
1027 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1028 if (rc) {
99bc5d55
JSJ		 1029 beiscsi_log(phba, KERN_ERR,
1030 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
e175defe 1031 "BG_%d : MBX CMD get_boot_target Failed\n");
9aef4200
JSJ		 1032 return -EBUSY;
1033 }
e175defe 1034
9aef4200
JSJ		 1035 boot_resp = embedded_payload(wrb);
1036
1037 /* Check if the there are any Boot targets configured */
1038 if (!boot_resp->boot_session_count) {
99bc5d55
JSJ		 1039 beiscsi_log(phba, KERN_INFO,
1040 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1041 "BG_%d ;No boot targets configured\n");
9aef4200
JSJ		 1042 return -ENXIO;
1043 }
1044
1045 /* FW returns the session handle of the boot session */
1046 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) {
1047 *s_handle = boot_resp->boot_session_handle;
1048 return 0;
1049 }
1050
1051 /* Issue MBX Cmd to FW to login to the boot target */
1052 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS,
1053 INVALID_SESS_HANDLE);
1054 if (!tag) {
99bc5d55
JSJ		 1055 beiscsi_log(phba, KERN_ERR,
1056 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1057 "BG_%d : mgmt_reopen_session Failed\n");
9aef4200 1058 return -EAGAIN;
e175defe
JSJ		 1059 }
1060
1061 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL);
1062 if (rc) {
99bc5d55
JSJ		 1063 beiscsi_log(phba, KERN_ERR,
1064 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
e175defe
JSJ		 1065 "BG_%d : mgmt_reopen_session Failed");
1066 return rc;
9aef4200 1067 }
9aef4200
JSJ		 1068 } while (--boot_retry);
1069
1070 /* Couldn't log into the boot target */
99bc5d55
JSJ		 1071 beiscsi_log(phba, KERN_ERR,
1072 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1073 "BG_%d : Login to Boot Target Failed\n");
9aef4200
JSJ		 1074 return -ENXIO;
1075}
6f72238e
JSJ		 1076
1077/**
1078 * mgmt_set_vlan()- Issue and wait for CMD completion
1079 * @phba: device private structure instance
1080 * @vlan_tag: VLAN tag
1081 *
1082 * Issue the MBX Cmd and wait for the completion of the
1083 * command.
1084 *
1085 * returns
1086 * Success: 0
1087 * Failure: Non-Xero Value
1088 **/
1089int mgmt_set_vlan(struct beiscsi_hba *phba,
1090 uint16_t vlan_tag)
1091{
e175defe
JSJ		 1092 int rc;
1093 unsigned int tag;
1094 struct be_mcc_wrb *wrb = NULL;
6f72238e
JSJ		 1095
1096 tag = be_cmd_set_vlan(phba, vlan_tag);
1097 if (!tag) {
1098 beiscsi_log(phba, KERN_ERR,
1099 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1100 "BG_%d : VLAN Setting Failed\n");
1101 return -EBUSY;
e175defe 1102 }
6f72238e 1103
e175defe
JSJ		 1104 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1105 if (rc) {
6f72238e
JSJ		 1106 beiscsi_log(phba, KERN_ERR,
1107 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
e175defe
JSJ		 1108 "BS_%d : VLAN MBX Cmd Failed\n");
1109 return rc;
6f72238e 1110 }
e175defe 1111 return rc;
6f72238e 1112}
5cac7596
JSJ		 1113
1114/**
1115 * beiscsi_drvr_ver_disp()- Display the driver Name and Version
1116 * @dev: ptr to device not used.
1117 * @attr: device attribute, not used.
1118 * @buf: contains formatted text driver name and version
1119 *
1120 * return
1121 * size of the formatted string
1122 **/
1123ssize_t
1124beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr,
1125 char *buf)
1126{
1127 return snprintf(buf, PAGE_SIZE, BE_NAME "\n");
1128}
acb9693c 1129
26000db7
JSJ		 1130/**
1131 * beiscsi_adap_family_disp()- Display adapter family.
1132 * @dev: ptr to device to get priv structure
1133 * @attr: device attribute, not used.
1134 * @buf: contains formatted text driver name and version
1135 *
1136 * return
1137 * size of the formatted string
1138 **/
1139ssize_t
1140beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr,
1141 char *buf)
1142{
1143 uint16_t dev_id = 0;
1144 struct Scsi_Host *shost = class_to_shost(dev);
1145 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1146
1147 dev_id = phba->pcidev->device;
1148 switch (dev_id) {
1149 case BE_DEVICE_ID1:
1150 case OC_DEVICE_ID1:
1151 case OC_DEVICE_ID2:
1152 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n");
1153 break;
1154 case BE_DEVICE_ID2:
1155 case OC_DEVICE_ID3:
1156 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n");
1157 break;
1158 case OC_SKH_ID1:
1159 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n");
1160 break;
1161 default:
1162 return snprintf(buf, PAGE_SIZE,
1163 "Unkown Adapter Family: 0x%x\n", dev_id);
1164 break;
1165 }
1166}
1167
1168
acb9693c
JSJ		 1169void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params,
1170 struct wrb_handle *pwrb_handle,
1171 struct be_mem_descriptor *mem_descr)
1172{
1173 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1174
1175 memset(pwrb, 0, sizeof(*pwrb));
1176 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1177 max_send_data_segment_length, pwrb,
1178 params->dw[offsetof(struct amap_beiscsi_offload_params,
1179 max_send_data_segment_length) / 32]);
1180 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb,
1181 BE_TGT_CTX_UPDT_CMD);
1182 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1183 first_burst_length,
1184 pwrb,
1185 params->dw[offsetof(struct amap_beiscsi_offload_params,
1186 first_burst_length) / 32]);
1187 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb,
1188 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1189 erl) / 32] & OFFLD_PARAMS_ERL));
1190 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb,
1191 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1192 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1193 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb,
1194 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1195 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1196 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb,
1197 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1198 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1199 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb,
1200 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1201 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1202 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn,
1203 pwrb,
1204 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1205 exp_statsn) / 32] + 1));
1206 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx,
1207 pwrb, pwrb_handle->wrb_index);
1208
1209 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1210 max_burst_length, pwrb, params->dw[offsetof
1211 (struct amap_beiscsi_offload_params,
1212 max_burst_length) / 32]);
1213
1214 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb,
1215 pwrb, pwrb_handle->nxt_wrb_index);
1216 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1217 session_state, pwrb, 0);
1218 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack,
1219 pwrb, 1);
1220 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq,
1221 pwrb, 0);
1222 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb,
1223 0);
1224
1225 mem_descr += ISCSI_MEM_GLOBAL_HEADER;
1226 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1227 pad_buffer_addr_hi, pwrb,
1228 mem_descr->mem_array[0].bus_address.u.a32.address_hi);
1229 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1230 pad_buffer_addr_lo, pwrb,
1231 mem_descr->mem_array[0].bus_address.u.a32.address_lo);
1232}
1233
1234void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params,
1235 struct wrb_handle *pwrb_handle)
1236{
1237 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1238
1239 memset(pwrb, 0, sizeof(*pwrb));
1240
1241 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1242 max_burst_length, pwrb, params->dw[offsetof
1243 (struct amap_beiscsi_offload_params,
1244 max_burst_length) / 32]);
1245 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1246 max_burst_length, pwrb, params->dw[offsetof
1247 (struct amap_beiscsi_offload_params,
1248 max_burst_length) / 32]);
1249 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1250 type, pwrb,
1251 BE_TGT_CTX_UPDT_CMD);
1252 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1253 ptr2nextwrb,
1254 pwrb, pwrb_handle->nxt_wrb_index);
1255 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx,
1256 pwrb, pwrb_handle->wrb_index);
1257 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1258 max_send_data_segment_length, pwrb,
1259 params->dw[offsetof(struct amap_beiscsi_offload_params,
1260 max_send_data_segment_length) / 32]);
1261 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1262 first_burst_length, pwrb,
1263 params->dw[offsetof(struct amap_beiscsi_offload_params,
1264 first_burst_length) / 32]);
1265 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1266 max_recv_dataseg_len, pwrb, BEISCSI_MAX_RECV_DATASEG_LEN);
1267 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1268 max_cxns, pwrb, BEISCSI_MAX_CXNS);
1269 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb,
1270 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1271 erl) / 32] & OFFLD_PARAMS_ERL));
1272 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb,
1273 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1274 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1275 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb,
1276 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1277 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1278 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1279 ir2t, pwrb,
1280 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1281 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1282 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb,
1283 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1284 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1285 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1286 data_seq_inorder,
1287 pwrb,
1288 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1289 data_seq_inorder) / 32] &
1290 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6);
1291 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1292 pdu_seq_inorder,
1293 pwrb,
1294 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1295 pdu_seq_inorder) / 32] &
1296 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7);
1297 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t,
1298 pwrb,
1299 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1300 max_r2t) / 32] &
1301 OFFLD_PARAMS_MAX_R2T) >> 8);
1302 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn,
1303 pwrb,
1304 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1305 exp_statsn) / 32] + 1));
1306}
Linux 6.x block layer and io_uring tree(s)