?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: see if URB comes from a completion handler
[linux/fpc-iii.git] / drivers / scsi / be2iscsi / be_mgmt.c
blob245a9595a93a131449fd660a7b7d8bd0e9e7f3b5
1 /**
2 * Copyright (C) 2005 - 2013 Emulex
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 *
10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
11 *
12 * Contact Information:
13 * linux-drivers@emulex.com
14 *
15 * Emulex
16 * 3333 Susan Street
17 * Costa Mesa, CA 92626
18 */
19
20 #include <linux/bsg-lib.h>
21 #include <scsi/scsi_transport_iscsi.h>
22 #include <scsi/scsi_bsg_iscsi.h>
23 #include "be_mgmt.h"
24 #include "be_iscsi.h"
25 #include "be_main.h"
26
27 /* UE Status Low CSR */
28 static const char * const desc_ue_status_low[] = {
29 "CEV",
30 "CTX",
31 "DBUF",
32 "ERX",
33 "Host",
34 "MPU",
35 "NDMA",
36 "PTC ",
37 "RDMA ",
38 "RXF ",
39 "RXIPS ",
40 "RXULP0 ",
41 "RXULP1 ",
42 "RXULP2 ",
43 "TIM ",
44 "TPOST ",
45 "TPRE ",
46 "TXIPS ",
47 "TXULP0 ",
48 "TXULP1 ",
49 "UC ",
50 "WDMA ",
51 "TXULP2 ",
52 "HOST1 ",
53 "P0_OB_LINK ",
54 "P1_OB_LINK ",
55 "HOST_GPIO ",
56 "MBOX ",
57 "AXGMAC0",
58 "AXGMAC1",
59 "JTAG",
60 "MPU_INTPEND"
61 };
62
63 /* UE Status High CSR */
64 static const char * const desc_ue_status_hi[] = {
65 "LPCMEMHOST",
66 "MGMT_MAC",
67 "PCS0ONLINE",
68 "MPU_IRAM",
69 "PCS1ONLINE",
70 "PCTL0",
71 "PCTL1",
72 "PMEM",
73 "RR",
74 "TXPB",
75 "RXPP",
76 "XAUI",
77 "TXP",
78 "ARM",
79 "IPC",
80 "HOST2",
81 "HOST3",
82 "HOST4",
83 "HOST5",
84 "HOST6",
85 "HOST7",
86 "HOST8",
87 "HOST9",
88 "NETC",
89 "Unknown",
90 "Unknown",
91 "Unknown",
92 "Unknown",
93 "Unknown",
94 "Unknown",
95 "Unknown",
96 "Unknown"
97 };
98
99 /*
100 * beiscsi_ue_detec()- Detect Unrecoverable Error on adapter
101 * @phba: Driver priv structure
102 *
103 * Read registers linked to UE and check for the UE status
104 **/
105 void beiscsi_ue_detect(struct beiscsi_hba *phba)
106 {
107 uint32_t ue_hi = 0, ue_lo = 0;
108 uint32_t ue_mask_hi = 0, ue_mask_lo = 0;
109 uint8_t i = 0;
110
111 if (phba->ue_detected)
112 return;
113
114 pci_read_config_dword(phba->pcidev,
115 PCICFG_UE_STATUS_LOW, &ue_lo);
116 pci_read_config_dword(phba->pcidev,
117 PCICFG_UE_STATUS_MASK_LOW,
118 &ue_mask_lo);
119 pci_read_config_dword(phba->pcidev,
120 PCICFG_UE_STATUS_HIGH,
121 &ue_hi);
122 pci_read_config_dword(phba->pcidev,
123 PCICFG_UE_STATUS_MASK_HI,
124 &ue_mask_hi);
125
126 ue_lo = (ue_lo & ~ue_mask_lo);
127 ue_hi = (ue_hi & ~ue_mask_hi);
128
129
130 if (ue_lo || ue_hi) {
131 phba->ue_detected = true;
132 beiscsi_log(phba, KERN_ERR,
133 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
134 "BG_%d : Error detected on the adapter\n");
135 }
136
137 if (ue_lo) {
138 for (i = 0; ue_lo; ue_lo >>= 1, i++) {
139 if (ue_lo & 1)
140 beiscsi_log(phba, KERN_ERR,
141 BEISCSI_LOG_CONFIG,
142 "BG_%d : UE_LOW %s bit set\n",
143 desc_ue_status_low[i]);
144 }
145 }
146
147 if (ue_hi) {
148 for (i = 0; ue_hi; ue_hi >>= 1, i++) {
149 if (ue_hi & 1)
150 beiscsi_log(phba, KERN_ERR,
151 BEISCSI_LOG_CONFIG,
152 "BG_%d : UE_HIGH %s bit set\n",
153 desc_ue_status_hi[i]);
154 }
155 }
156 }
157
158 /**
159 * mgmt_reopen_session()- Reopen a session based on reopen_type
160 * @phba: Device priv structure instance
161 * @reopen_type: Type of reopen_session FW should do.
162 * @sess_handle: Session Handle of the session to be re-opened
163 *
164 * return
165 * the TAG used for MBOX Command
166 *
167 **/
168 unsigned int mgmt_reopen_session(struct beiscsi_hba *phba,
169 unsigned int reopen_type,
170 unsigned int sess_handle)
171 {
172 struct be_ctrl_info *ctrl = &phba->ctrl;
173 struct be_mcc_wrb *wrb;
174 struct be_cmd_reopen_session_req *req;
175 unsigned int tag = 0;
176
177 beiscsi_log(phba, KERN_INFO,
178 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
179 "BG_%d : In bescsi_get_boot_target\n");
180
181 spin_lock(&ctrl->mbox_lock);
182 tag = alloc_mcc_tag(phba);
183 if (!tag) {
184 spin_unlock(&ctrl->mbox_lock);
185 return tag;
186 }
187
188 wrb = wrb_from_mccq(phba);
189 req = embedded_payload(wrb);
190 wrb->tag0 |= tag;
191 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
192 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
193 OPCODE_ISCSI_INI_DRIVER_REOPEN_ALL_SESSIONS,
194 sizeof(struct be_cmd_reopen_session_resp));
195
196 /* set the reopen_type,sess_handle */
197 req->reopen_type = reopen_type;
198 req->session_handle = sess_handle;
199
200 be_mcc_notify(phba);
201 spin_unlock(&ctrl->mbox_lock);
202 return tag;
203 }
204
205 unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba)
206 {
207 struct be_ctrl_info *ctrl = &phba->ctrl;
208 struct be_mcc_wrb *wrb;
209 struct be_cmd_get_boot_target_req *req;
210 unsigned int tag = 0;
211
212 beiscsi_log(phba, KERN_INFO,
213 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
214 "BG_%d : In bescsi_get_boot_target\n");
215
216 spin_lock(&ctrl->mbox_lock);
217 tag = alloc_mcc_tag(phba);
218 if (!tag) {
219 spin_unlock(&ctrl->mbox_lock);
220 return tag;
221 }
222
223 wrb = wrb_from_mccq(phba);
224 req = embedded_payload(wrb);
225 wrb->tag0 |= tag;
226 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
227 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
228 OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET,
229 sizeof(struct be_cmd_get_boot_target_resp));
230
231 be_mcc_notify(phba);
232 spin_unlock(&ctrl->mbox_lock);
233 return tag;
234 }
235
236 unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
237 u32 boot_session_handle,
238 struct be_dma_mem *nonemb_cmd)
239 {
240 struct be_ctrl_info *ctrl = &phba->ctrl;
241 struct be_mcc_wrb *wrb;
242 unsigned int tag = 0;
243 struct be_cmd_get_session_req *req;
244 struct be_cmd_get_session_resp *resp;
245 struct be_sge *sge;
246
247 beiscsi_log(phba, KERN_INFO,
248 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
249 "BG_%d : In beiscsi_get_session_info\n");
250
251 spin_lock(&ctrl->mbox_lock);
252 tag = alloc_mcc_tag(phba);
253 if (!tag) {
254 spin_unlock(&ctrl->mbox_lock);
255 return tag;
256 }
257
258 nonemb_cmd->size = sizeof(*resp);
259 req = nonemb_cmd->va;
260 memset(req, 0, sizeof(*req));
261 wrb = wrb_from_mccq(phba);
262 sge = nonembedded_sgl(wrb);
263 wrb->tag0 |= tag;
264
265
266 wrb->tag0 |= tag;
267 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
268 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
269 OPCODE_ISCSI_INI_SESSION_GET_A_SESSION,
270 sizeof(*resp));
271 req->session_handle = boot_session_handle;
272 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
273 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
274 sge->len = cpu_to_le32(nonemb_cmd->size);
275
276 be_mcc_notify(phba);
277 spin_unlock(&ctrl->mbox_lock);
278 return tag;
279 }
280
281 int mgmt_get_fw_config(struct be_ctrl_info *ctrl,
282 struct beiscsi_hba *phba)
283 {
284 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
285 struct be_fw_cfg *req = embedded_payload(wrb);
286 int status = 0;
287
288 spin_lock(&ctrl->mbox_lock);
289 memset(wrb, 0, sizeof(*wrb));
290
291 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
292
293 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
294 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req));
295 status = be_mbox_notify(ctrl);
296 if (!status) {
297 struct be_fw_cfg *pfw_cfg;
298 pfw_cfg = req;
299 phba->fw_config.phys_port = pfw_cfg->phys_port;
300 phba->fw_config.iscsi_icd_start =
301 pfw_cfg->ulp[0].icd_base;
302 phba->fw_config.iscsi_icd_count =
303 pfw_cfg->ulp[0].icd_count;
304 phba->fw_config.iscsi_cid_start =
305 pfw_cfg->ulp[0].sq_base;
306 phba->fw_config.iscsi_cid_count =
307 pfw_cfg->ulp[0].sq_count;
308 if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) {
309 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
310 "BG_%d : FW reported MAX CXNS as %d\t"
311 "Max Supported = %d.\n",
312 phba->fw_config.iscsi_cid_count,
313 BE2_MAX_SESSIONS);
314 phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2;
315 }
316 } else {
317 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
318 "BG_%d : Failed in mgmt_get_fw_config\n");
319 }
320
321 spin_unlock(&ctrl->mbox_lock);
322 return status;
323 }
324
325 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
326 struct beiscsi_hba *phba)
327 {
328 struct be_dma_mem nonemb_cmd;
329 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
330 struct be_mgmt_controller_attributes *req;
331 struct be_sge *sge = nonembedded_sgl(wrb);
332 int status = 0;
333
334 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
335 sizeof(struct be_mgmt_controller_attributes),
336 &nonemb_cmd.dma);
337 if (nonemb_cmd.va == NULL) {
338 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
339 "BG_%d : Failed to allocate memory for "
340 "mgmt_check_supported_fw\n");
341 return -ENOMEM;
342 }
343 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
344 req = nonemb_cmd.va;
345 memset(req, 0, sizeof(*req));
346 spin_lock(&ctrl->mbox_lock);
347 memset(wrb, 0, sizeof(*wrb));
348 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
349 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
350 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req));
351 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma));
352 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
353 sge->len = cpu_to_le32(nonemb_cmd.size);
354 status = be_mbox_notify(ctrl);
355 if (!status) {
356 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va;
357 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
358 "BG_%d : Firmware Version of CMD : %s\n"
359 "Firmware Version is : %s\n"
360 "Developer Build, not performing version check...\n",
361 resp->params.hba_attribs
362 .flashrom_version_string,
363 resp->params.hba_attribs.
364 firmware_version_string);
365
366 phba->fw_config.iscsi_features =
367 resp->params.hba_attribs.iscsi_features;
368 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
369 "BM_%d : phba->fw_config.iscsi_features = %d\n",
370 phba->fw_config.iscsi_features);
371 memcpy(phba->fw_ver_str, resp->params.hba_attribs.
372 firmware_version_string, BEISCSI_VER_STRLEN);
373 } else
374 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
375 "BG_%d : Failed in mgmt_check_supported_fw\n");
376 spin_unlock(&ctrl->mbox_lock);
377 if (nonemb_cmd.va)
378 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
379 nonemb_cmd.va, nonemb_cmd.dma);
380
381 return status;
382 }
383
384 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
385 struct beiscsi_hba *phba,
386 struct bsg_job *job,
387 struct be_dma_mem *nonemb_cmd)
388 {
389 struct be_cmd_resp_hdr *resp;
390 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
391 struct be_sge *mcc_sge = nonembedded_sgl(wrb);
392 unsigned int tag = 0;
393 struct iscsi_bsg_request *bsg_req = job->request;
394 struct be_bsg_vendor_cmd *req = nonemb_cmd->va;
395 unsigned short region, sector_size, sector, offset;
396
397 nonemb_cmd->size = job->request_payload.payload_len;
398 memset(nonemb_cmd->va, 0, nonemb_cmd->size);
399 resp = nonemb_cmd->va;
400 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1];
401 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2];
402 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3];
403 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4];
404 req->region = region;
405 req->sector = sector;
406 req->offset = offset;
407 spin_lock(&ctrl->mbox_lock);
408 memset(wrb, 0, sizeof(*wrb));
409
410 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) {
411 case BEISCSI_WRITE_FLASH:
412 offset = sector * sector_size + offset;
413 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
414 OPCODE_COMMON_WRITE_FLASH, sizeof(*req));
415 sg_copy_to_buffer(job->request_payload.sg_list,
416 job->request_payload.sg_cnt,
417 nonemb_cmd->va + offset, job->request_len);
418 break;
419 case BEISCSI_READ_FLASH:
420 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
421 OPCODE_COMMON_READ_FLASH, sizeof(*req));
422 break;
423 default:
424 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
425 "BG_%d : Unsupported cmd = 0x%x\n\n",
426 bsg_req->rqst_data.h_vendor.vendor_cmd[0]);
427
428 spin_unlock(&ctrl->mbox_lock);
429 return -ENOSYS;
430 }
431
432 tag = alloc_mcc_tag(phba);
433 if (!tag) {
434 spin_unlock(&ctrl->mbox_lock);
435 return tag;
436 }
437
438 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false,
439 job->request_payload.sg_cnt);
440 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
441 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
442 mcc_sge->len = cpu_to_le32(nonemb_cmd->size);
443 wrb->tag0 |= tag;
444
445 be_mcc_notify(phba);
446
447 spin_unlock(&ctrl->mbox_lock);
448 return tag;
449 }
450
451 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
452 {
453 struct be_ctrl_info *ctrl = &phba->ctrl;
454 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
455 struct iscsi_cleanup_req *req = embedded_payload(wrb);
456 int status = 0;
457
458 spin_lock(&ctrl->mbox_lock);
459 memset(wrb, 0, sizeof(*wrb));
460
461 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
462 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
463 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
464
465 req->chute = chute;
466 req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba));
467 req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba));
468
469 status = be_mcc_notify_wait(phba);
470 if (status)
471 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
472 "BG_%d : mgmt_epfw_cleanup , FAILED\n");
473 spin_unlock(&ctrl->mbox_lock);
474 return status;
475 }
476
477 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba,
478 struct invalidate_command_table *inv_tbl,
479 unsigned int num_invalidate, unsigned int cid,
480 struct be_dma_mem *nonemb_cmd)
481
482 {
483 struct be_ctrl_info *ctrl = &phba->ctrl;
484 struct be_mcc_wrb *wrb;
485 struct be_sge *sge;
486 struct invalidate_commands_params_in *req;
487 unsigned int i, tag = 0;
488
489 spin_lock(&ctrl->mbox_lock);
490 tag = alloc_mcc_tag(phba);
491 if (!tag) {
492 spin_unlock(&ctrl->mbox_lock);
493 return tag;
494 }
495
496 req = nonemb_cmd->va;
497 memset(req, 0, sizeof(*req));
498 wrb = wrb_from_mccq(phba);
499 sge = nonembedded_sgl(wrb);
500 wrb->tag0 |= tag;
501
502 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
503 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
504 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS,
505 sizeof(*req));
506 req->ref_handle = 0;
507 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE;
508 for (i = 0; i < num_invalidate; i++) {
509 req->table[i].icd = inv_tbl->icd;
510 req->table[i].cid = inv_tbl->cid;
511 req->icd_count++;
512 inv_tbl++;
513 }
514 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
515 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
516 sge->len = cpu_to_le32(nonemb_cmd->size);
517
518 be_mcc_notify(phba);
519 spin_unlock(&ctrl->mbox_lock);
520 return tag;
521 }
522
523 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba,
524 struct beiscsi_endpoint *beiscsi_ep,
525 unsigned short cid,
526 unsigned short issue_reset,
527 unsigned short savecfg_flag)
528 {
529 struct be_ctrl_info *ctrl = &phba->ctrl;
530 struct be_mcc_wrb *wrb;
531 struct iscsi_invalidate_connection_params_in *req;
532 unsigned int tag = 0;
533
534 spin_lock(&ctrl->mbox_lock);
535 tag = alloc_mcc_tag(phba);
536 if (!tag) {
537 spin_unlock(&ctrl->mbox_lock);
538 return tag;
539 }
540 wrb = wrb_from_mccq(phba);
541 wrb->tag0 |= tag;
542 req = embedded_payload(wrb);
543
544 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
545 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
546 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION,
547 sizeof(*req));
548 req->session_handle = beiscsi_ep->fw_handle;
549 req->cid = cid;
550 if (issue_reset)
551 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST;
552 else
553 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
554 req->save_cfg = savecfg_flag;
555 be_mcc_notify(phba);
556 spin_unlock(&ctrl->mbox_lock);
557 return tag;
558 }
559
560 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba,
561 unsigned short cid, unsigned int upload_flag)
562 {
563 struct be_ctrl_info *ctrl = &phba->ctrl;
564 struct be_mcc_wrb *wrb;
565 struct tcp_upload_params_in *req;
566 unsigned int tag = 0;
567
568 spin_lock(&ctrl->mbox_lock);
569 tag = alloc_mcc_tag(phba);
570 if (!tag) {
571 spin_unlock(&ctrl->mbox_lock);
572 return tag;
573 }
574 wrb = wrb_from_mccq(phba);
575 req = embedded_payload(wrb);
576 wrb->tag0 |= tag;
577
578 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
579 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD,
580 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req));
581 req->id = (unsigned short)cid;
582 req->upload_type = (unsigned char)upload_flag;
583 be_mcc_notify(phba);
584 spin_unlock(&ctrl->mbox_lock);
585 return tag;
586 }
587
588 int mgmt_open_connection(struct beiscsi_hba *phba,
589 struct sockaddr *dst_addr,
590 struct beiscsi_endpoint *beiscsi_ep,
591 struct be_dma_mem *nonemb_cmd)
592 {
593 struct hwi_controller *phwi_ctrlr;
594 struct hwi_context_memory *phwi_context;
595 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr;
596 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr;
597 struct be_ctrl_info *ctrl = &phba->ctrl;
598 struct be_mcc_wrb *wrb;
599 struct tcp_connect_and_offload_in *req;
600 unsigned short def_hdr_id;
601 unsigned short def_data_id;
602 struct phys_addr template_address = { 0, 0 };
603 struct phys_addr *ptemplate_address;
604 unsigned int tag = 0;
605 unsigned int i;
606 unsigned short cid = beiscsi_ep->ep_cid;
607 struct be_sge *sge;
608
609 phwi_ctrlr = phba->phwi_ctrlr;
610 phwi_context = phwi_ctrlr->phwi_ctxt;
611 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba);
612 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba);
613
614 ptemplate_address = &template_address;
615 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address);
616 spin_lock(&ctrl->mbox_lock);
617 tag = alloc_mcc_tag(phba);
618 if (!tag) {
619 spin_unlock(&ctrl->mbox_lock);
620 return tag;
621 }
622 wrb = wrb_from_mccq(phba);
623 memset(wrb, 0, sizeof(*wrb));
624 sge = nonembedded_sgl(wrb);
625
626 req = nonemb_cmd->va;
627 memset(req, 0, sizeof(*req));
628 wrb->tag0 |= tag;
629
630 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
631 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
632 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD,
633 sizeof(*req));
634 if (dst_addr->sa_family == PF_INET) {
635 __be32 s_addr = daddr_in->sin_addr.s_addr;
636 req->ip_address.ip_type = BE2_IPV4;
637 req->ip_address.addr[0] = s_addr & 0x000000ff;
638 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8;
639 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16;
640 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24;
641 req->tcp_port = ntohs(daddr_in->sin_port);
642 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr;
643 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port);
644 beiscsi_ep->ip_type = BE2_IPV4;
645 } else if (dst_addr->sa_family == PF_INET6) {
646 req->ip_address.ip_type = BE2_IPV6;
647 memcpy(&req->ip_address.addr,
648 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
649 req->tcp_port = ntohs(daddr_in6->sin6_port);
650 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port);
651 memcpy(&beiscsi_ep->dst6_addr,
652 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
653 beiscsi_ep->ip_type = BE2_IPV6;
654 } else{
655 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
656 "BG_%d : unknown addr family %d\n",
657 dst_addr->sa_family);
658 spin_unlock(&ctrl->mbox_lock);
659 free_mcc_tag(&phba->ctrl, tag);
660 return -EINVAL;
661
662 }
663 req->cid = cid;
664 i = phba->nxt_cqid++;
665 if (phba->nxt_cqid == phba->num_cpus)
666 phba->nxt_cqid = 0;
667 req->cq_id = phwi_context->be_cq[i].id;
668 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
669 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id);
670 req->defq_id = def_hdr_id;
671 req->hdr_ring_id = def_hdr_id;
672 req->data_ring_id = def_data_id;
673 req->do_offload = 1;
674 req->dataout_template_pa.lo = ptemplate_address->lo;
675 req->dataout_template_pa.hi = ptemplate_address->hi;
676 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
677 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
678 sge->len = cpu_to_le32(nonemb_cmd->size);
679 be_mcc_notify(phba);
680 spin_unlock(&ctrl->mbox_lock);
681 return tag;
682 }
683
684 unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba)
685 {
686 struct be_ctrl_info *ctrl = &phba->ctrl;
687 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
688 struct be_cmd_get_all_if_id_req *req = embedded_payload(wrb);
689 struct be_cmd_get_all_if_id_req *pbe_allid = req;
690 int status = 0;
691
692 memset(wrb, 0, sizeof(*wrb));
693
694 spin_lock(&ctrl->mbox_lock);
695
696 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
697 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
698 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID,
699 sizeof(*req));
700 status = be_mbox_notify(ctrl);
701 if (!status)
702 phba->interface_handle = pbe_allid->if_hndl_list[0];
703 else {
704 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
705 "BG_%d : Failed in mgmt_get_all_if_id\n");
706 }
707 spin_unlock(&ctrl->mbox_lock);
708
709 return status;
710 }
711
712 /*
713 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd
714 * @phba: Driver priv structure
715 * @nonemb_cmd: Address of the MBX command issued
716 * @resp_buf: Buffer to copy the MBX cmd response
717 * @resp_buf_len: respone lenght to be copied
718 *
719 **/
720 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
721 struct be_dma_mem *nonemb_cmd, void *resp_buf,
722 int resp_buf_len)
723 {
724 struct be_ctrl_info *ctrl = &phba->ctrl;
725 struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
726 struct be_sge *sge;
727 unsigned int tag;
728 int rc = 0;
729
730 spin_lock(&ctrl->mbox_lock);
731 tag = alloc_mcc_tag(phba);
732 if (!tag) {
733 spin_unlock(&ctrl->mbox_lock);
734 rc = -ENOMEM;
735 goto free_cmd;
736 }
737 memset(wrb, 0, sizeof(*wrb));
738 wrb->tag0 |= tag;
739 sge = nonembedded_sgl(wrb);
740
741 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1);
742 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
743 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma));
744 sge->len = cpu_to_le32(nonemb_cmd->size);
745
746 be_mcc_notify(phba);
747 spin_unlock(&ctrl->mbox_lock);
748
749 rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd->va);
750 if (rc) {
751 beiscsi_log(phba, KERN_ERR,
752 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
753 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n");
754
755 rc = -EIO;
756 goto free_cmd;
757 }
758
759 if (resp_buf)
760 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
761
762 free_cmd:
763 pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
764 nonemb_cmd->va, nonemb_cmd->dma);
765 return rc;
766 }
767
768 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd,
769 int iscsi_cmd, int size)
770 {
771 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
772 if (!cmd->va) {
773 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
774 "BG_%d : Failed to allocate memory for if info\n");
775 return -ENOMEM;
776 }
777 memset(cmd->va, 0, size);
778 cmd->size = size;
779 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size);
780 return 0;
781 }
782
783 static int
784 mgmt_static_ip_modify(struct beiscsi_hba *phba,
785 struct be_cmd_get_if_info_resp *if_info,
786 struct iscsi_iface_param_info *ip_param,
787 struct iscsi_iface_param_info *subnet_param,
788 uint32_t ip_action)
789 {
790 struct be_cmd_set_ip_addr_req *req;
791 struct be_dma_mem nonemb_cmd;
792 uint32_t ip_type;
793 int rc;
794
795 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
796 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR,
797 sizeof(*req));
798 if (rc)
799 return rc;
800
801 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
802 BE2_IPV6 : BE2_IPV4 ;
803
804 req = nonemb_cmd.va;
805 req->ip_params.record_entry_count = 1;
806 req->ip_params.ip_record.action = ip_action;
807 req->ip_params.ip_record.interface_hndl =
808 phba->interface_handle;
809 req->ip_params.ip_record.ip_addr.size_of_structure =
810 sizeof(struct be_ip_addr_subnet_format);
811 req->ip_params.ip_record.ip_addr.ip_type = ip_type;
812
813 if (ip_action == IP_ACTION_ADD) {
814 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value,
815 ip_param->len);
816
817 if (subnet_param)
818 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
819 subnet_param->value, subnet_param->len);
820 } else {
821 memcpy(req->ip_params.ip_record.ip_addr.addr,
822 if_info->ip_addr.addr, ip_param->len);
823
824 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
825 if_info->ip_addr.subnet_mask, ip_param->len);
826 }
827
828 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
829 if (rc < 0)
830 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
831 "BG_%d : Failed to Modify existing IP Address\n");
832 return rc;
833 }
834
835 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr,
836 uint32_t gtway_action, uint32_t param_len)
837 {
838 struct be_cmd_set_def_gateway_req *req;
839 struct be_dma_mem nonemb_cmd;
840 int rt_val;
841
842
843 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
844 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY,
845 sizeof(*req));
846 if (rt_val)
847 return rt_val;
848
849 req = nonemb_cmd.va;
850 req->action = gtway_action;
851 req->ip_addr.ip_type = BE2_IPV4;
852
853 memcpy(req->ip_addr.addr, gt_addr, param_len);
854
855 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
856 }
857
858 int mgmt_set_ip(struct beiscsi_hba *phba,
859 struct iscsi_iface_param_info *ip_param,
860 struct iscsi_iface_param_info *subnet_param,
861 uint32_t boot_proto)
862 {
863 struct be_cmd_get_def_gateway_resp gtway_addr_set;
864 struct be_cmd_get_if_info_resp if_info;
865 struct be_cmd_set_dhcp_req *dhcpreq;
866 struct be_cmd_rel_dhcp_req *reldhcp;
867 struct be_dma_mem nonemb_cmd;
868 uint8_t *gtway_addr;
869 uint32_t ip_type;
870 int rc;
871
872 if (mgmt_get_all_if_id(phba))
873 return -EIO;
874
875 memset(&if_info, 0, sizeof(if_info));
876 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
877 BE2_IPV6 : BE2_IPV4 ;
878
879 rc = mgmt_get_if_info(phba, ip_type, &if_info);
880 if (rc)
881 return rc;
882
883 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
884 if (if_info.dhcp_state) {
885 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
886 "BG_%d : DHCP Already Enabled\n");
887 return 0;
888 }
889 /* The ip_param->len is 1 in DHCP case. Setting
890 proper IP len as this it is used while
891 freeing the Static IP.
892 */
893 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
894 IP_V6_LEN : IP_V4_LEN;
895
896 } else {
897 if (if_info.dhcp_state) {
898
899 memset(&if_info, 0, sizeof(if_info));
900 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
901 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR,
902 sizeof(*reldhcp));
903
904 if (rc)
905 return rc;
906
907 reldhcp = nonemb_cmd.va;
908 reldhcp->interface_hndl = phba->interface_handle;
909 reldhcp->ip_type = ip_type;
910
911 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
912 if (rc < 0) {
913 beiscsi_log(phba, KERN_WARNING,
914 BEISCSI_LOG_CONFIG,
915 "BG_%d : Failed to Delete existing dhcp\n");
916 return rc;
917 }
918 }
919 }
920
921 /* Delete the Static IP Set */
922 if (if_info.ip_addr.addr[0]) {
923 rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL,
924 IP_ACTION_DEL);
925 if (rc)
926 return rc;
927 }
928
929 /* Delete the Gateway settings if mode change is to DHCP */
930 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
931 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
932 rc = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
933 if (rc) {
934 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
935 "BG_%d : Failed to Get Gateway Addr\n");
936 return rc;
937 }
938
939 if (gtway_addr_set.ip_addr.addr[0]) {
940 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
941 rc = mgmt_modify_gateway(phba, gtway_addr,
942 IP_ACTION_DEL, IP_V4_LEN);
943
944 if (rc) {
945 beiscsi_log(phba, KERN_WARNING,
946 BEISCSI_LOG_CONFIG,
947 "BG_%d : Failed to clear Gateway Addr Set\n");
948 return rc;
949 }
950 }
951 }
952
953 /* Set Adapter to DHCP/Static Mode */
954 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
955 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
956 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR,
957 sizeof(*dhcpreq));
958 if (rc)
959 return rc;
960
961 dhcpreq = nonemb_cmd.va;
962 dhcpreq->flags = BLOCKING;
963 dhcpreq->retry_count = 1;
964 dhcpreq->interface_hndl = phba->interface_handle;
965 dhcpreq->ip_type = BE2_DHCP_V4;
966
967 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
968 } else {
969 return mgmt_static_ip_modify(phba, &if_info, ip_param,
970 subnet_param, IP_ACTION_ADD);
971 }
972
973 return rc;
974 }
975
976 int mgmt_set_gateway(struct beiscsi_hba *phba,
977 struct iscsi_iface_param_info *gateway_param)
978 {
979 struct be_cmd_get_def_gateway_resp gtway_addr_set;
980 uint8_t *gtway_addr;
981 int rt_val;
982
983 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
984 rt_val = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
985 if (rt_val) {
986 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
987 "BG_%d : Failed to Get Gateway Addr\n");
988 return rt_val;
989 }
990
991 if (gtway_addr_set.ip_addr.addr[0]) {
992 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
993 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL,
994 gateway_param->len);
995 if (rt_val) {
996 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
997 "BG_%d : Failed to clear Gateway Addr Set\n");
998 return rt_val;
999 }
1000 }
1001
1002 gtway_addr = (uint8_t *)&gateway_param->value;
1003 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD,
1004 gateway_param->len);
1005
1006 if (rt_val)
1007 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1008 "BG_%d : Failed to Set Gateway Addr\n");
1009
1010 return rt_val;
1011 }
1012
1013 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
1014 struct be_cmd_get_def_gateway_resp *gateway)
1015 {
1016 struct be_cmd_get_def_gateway_req *req;
1017 struct be_dma_mem nonemb_cmd;
1018 int rc;
1019
1020 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1021 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY,
1022 sizeof(*gateway));
1023 if (rc)
1024 return rc;
1025
1026 req = nonemb_cmd.va;
1027 req->ip_type = ip_type;
1028
1029 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway,
1030 sizeof(*gateway));
1031 }
1032
1033 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
1034 struct be_cmd_get_if_info_resp *if_info)
1035 {
1036 struct be_cmd_get_if_info_req *req;
1037 struct be_dma_mem nonemb_cmd;
1038 int rc;
1039
1040 if (mgmt_get_all_if_id(phba))
1041 return -EIO;
1042
1043 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1044 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO,
1045 sizeof(*if_info));
1046 if (rc)
1047 return rc;
1048
1049 req = nonemb_cmd.va;
1050 req->interface_hndl = phba->interface_handle;
1051 req->ip_type = ip_type;
1052
1053 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info,
1054 sizeof(*if_info));
1055 }
1056
1057 int mgmt_get_nic_conf(struct beiscsi_hba *phba,
1058 struct be_cmd_get_nic_conf_resp *nic)
1059 {
1060 struct be_dma_mem nonemb_cmd;
1061 int rc;
1062
1063 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1064 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
1065 sizeof(*nic));
1066 if (rc)
1067 return rc;
1068
1069 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic));
1070 }
1071
1072
1073
1074 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
1075 {
1076 unsigned int tag = 0;
1077 struct be_mcc_wrb *wrb;
1078 struct be_cmd_hba_name *req;
1079 struct be_ctrl_info *ctrl = &phba->ctrl;
1080
1081 spin_lock(&ctrl->mbox_lock);
1082 tag = alloc_mcc_tag(phba);
1083 if (!tag) {
1084 spin_unlock(&ctrl->mbox_lock);
1085 return tag;
1086 }
1087
1088 wrb = wrb_from_mccq(phba);
1089 req = embedded_payload(wrb);
1090 wrb->tag0 |= tag;
1091 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1092 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
1093 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
1094 sizeof(*req));
1095
1096 be_mcc_notify(phba);
1097 spin_unlock(&ctrl->mbox_lock);
1098 return tag;
1099 }
1100
1101 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
1102 {
1103 unsigned int tag = 0;
1104 struct be_mcc_wrb *wrb;
1105 struct be_cmd_ntwk_link_status_req *req;
1106 struct be_ctrl_info *ctrl = &phba->ctrl;
1107
1108 spin_lock(&ctrl->mbox_lock);
1109 tag = alloc_mcc_tag(phba);
1110 if (!tag) {
1111 spin_unlock(&ctrl->mbox_lock);
1112 return tag;
1113 }
1114
1115 wrb = wrb_from_mccq(phba);
1116 req = embedded_payload(wrb);
1117 wrb->tag0 |= tag;
1118 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1119 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1120 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
1121 sizeof(*req));
1122
1123 be_mcc_notify(phba);
1124 spin_unlock(&ctrl->mbox_lock);
1125 return tag;
1126 }
1127
1128 /**
1129 * be_mgmt_get_boot_shandle()- Get the session handle
1130 * @phba: device priv structure instance
1131 * @s_handle: session handle returned for boot session.
1132 *
1133 * Get the boot target session handle. In case of
1134 * crashdump mode driver has to issue and MBX Cmd
1135 * for FW to login to boot target
1136 *
1137 * return
1138 * Success: 0
1139 * Failure: Non-Zero value
1140 *
1141 **/
1142 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba,
1143 unsigned int *s_handle)
1144 {
1145 struct be_cmd_get_boot_target_resp *boot_resp;
1146 struct be_mcc_wrb *wrb;
1147 unsigned int tag;
1148 uint8_t boot_retry = 3;
1149 int rc;
1150
1151 do {
1152 /* Get the Boot Target Session Handle and Count*/
1153 tag = mgmt_get_boot_target(phba);
1154 if (!tag) {
1155 beiscsi_log(phba, KERN_ERR,
1156 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
1157 "BG_%d : Getting Boot Target Info Failed\n");
1158 return -EAGAIN;
1159 }
1160
1161 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1162 if (rc) {
1163 beiscsi_log(phba, KERN_ERR,
1164 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1165 "BG_%d : MBX CMD get_boot_target Failed\n");
1166 return -EBUSY;
1167 }
1168
1169 boot_resp = embedded_payload(wrb);
1170
1171 /* Check if the there are any Boot targets configured */
1172 if (!boot_resp->boot_session_count) {
1173 beiscsi_log(phba, KERN_INFO,
1174 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1175 "BG_%d ;No boot targets configured\n");
1176 return -ENXIO;
1177 }
1178
1179 /* FW returns the session handle of the boot session */
1180 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) {
1181 *s_handle = boot_resp->boot_session_handle;
1182 return 0;
1183 }
1184
1185 /* Issue MBX Cmd to FW to login to the boot target */
1186 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS,
1187 INVALID_SESS_HANDLE);
1188 if (!tag) {
1189 beiscsi_log(phba, KERN_ERR,
1190 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1191 "BG_%d : mgmt_reopen_session Failed\n");
1192 return -EAGAIN;
1193 }
1194
1195 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL);
1196 if (rc) {
1197 beiscsi_log(phba, KERN_ERR,
1198 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1199 "BG_%d : mgmt_reopen_session Failed");
1200 return rc;
1201 }
1202 } while (--boot_retry);
1203
1204 /* Couldn't log into the boot target */
1205 beiscsi_log(phba, KERN_ERR,
1206 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1207 "BG_%d : Login to Boot Target Failed\n");
1208 return -ENXIO;
1209 }
1210
1211 /**
1212 * mgmt_set_vlan()- Issue and wait for CMD completion
1213 * @phba: device private structure instance
1214 * @vlan_tag: VLAN tag
1215 *
1216 * Issue the MBX Cmd and wait for the completion of the
1217 * command.
1218 *
1219 * returns
1220 * Success: 0
1221 * Failure: Non-Xero Value
1222 **/
1223 int mgmt_set_vlan(struct beiscsi_hba *phba,
1224 uint16_t vlan_tag)
1225 {
1226 int rc;
1227 unsigned int tag;
1228 struct be_mcc_wrb *wrb = NULL;
1229
1230 tag = be_cmd_set_vlan(phba, vlan_tag);
1231 if (!tag) {
1232 beiscsi_log(phba, KERN_ERR,
1233 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1234 "BG_%d : VLAN Setting Failed\n");
1235 return -EBUSY;
1236 }
1237
1238 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1239 if (rc) {
1240 beiscsi_log(phba, KERN_ERR,
1241 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1242 "BS_%d : VLAN MBX Cmd Failed\n");
1243 return rc;
1244 }
1245 return rc;
1246 }
1247
1248 /**
1249 * beiscsi_drvr_ver_disp()- Display the driver Name and Version
1250 * @dev: ptr to device not used.
1251 * @attr: device attribute, not used.
1252 * @buf: contains formatted text driver name and version
1253 *
1254 * return
1255 * size of the formatted string
1256 **/
1257 ssize_t
1258 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr,
1259 char *buf)
1260 {
1261 return snprintf(buf, PAGE_SIZE, BE_NAME "\n");
1262 }
1263
1264 /**
1265 * beiscsi_fw_ver_disp()- Display Firmware Version
1266 * @dev: ptr to device not used.
1267 * @attr: device attribute, not used.
1268 * @buf: contains formatted text Firmware version
1269 *
1270 * return
1271 * size of the formatted string
1272 **/
1273 ssize_t
1274 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr,
1275 char *buf)
1276 {
1277 struct Scsi_Host *shost = class_to_shost(dev);
1278 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1279
1280 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str);
1281 }
1282
1283 /**
1284 * beiscsi_active_cid_disp()- Display Sessions Active
1285 * @dev: ptr to device not used.
1286 * @attr: device attribute, not used.
1287 * @buf: contains formatted text Session Count
1288 *
1289 * return
1290 * size of the formatted string
1291 **/
1292 ssize_t
1293 beiscsi_active_cid_disp(struct device *dev, struct device_attribute *attr,
1294 char *buf)
1295 {
1296 struct Scsi_Host *shost = class_to_shost(dev);
1297 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1298
1299 return snprintf(buf, PAGE_SIZE, "%d\n",
1300 (phba->params.cxns_per_ctrl - phba->avlbl_cids));
1301 }
1302
1303 /**
1304 * beiscsi_adap_family_disp()- Display adapter family.
1305 * @dev: ptr to device to get priv structure
1306 * @attr: device attribute, not used.
1307 * @buf: contains formatted text driver name and version
1308 *
1309 * return
1310 * size of the formatted string
1311 **/
1312 ssize_t
1313 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr,
1314 char *buf)
1315 {
1316 uint16_t dev_id = 0;
1317 struct Scsi_Host *shost = class_to_shost(dev);
1318 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1319
1320 dev_id = phba->pcidev->device;
1321 switch (dev_id) {
1322 case BE_DEVICE_ID1:
1323 case OC_DEVICE_ID1:
1324 case OC_DEVICE_ID2:
1325 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n");
1326 break;
1327 case BE_DEVICE_ID2:
1328 case OC_DEVICE_ID3:
1329 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n");
1330 break;
1331 case OC_SKH_ID1:
1332 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n");
1333 break;
1334 default:
1335 return snprintf(buf, PAGE_SIZE,
1336 "Unknown Adapter Family: 0x%x\n", dev_id);
1337 break;
1338 }
1339 }
1340
1341
1342 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params,
1343 struct wrb_handle *pwrb_handle,
1344 struct be_mem_descriptor *mem_descr)
1345 {
1346 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1347
1348 memset(pwrb, 0, sizeof(*pwrb));
1349 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1350 max_send_data_segment_length, pwrb,
1351 params->dw[offsetof(struct amap_beiscsi_offload_params,
1352 max_send_data_segment_length) / 32]);
1353 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb,
1354 BE_TGT_CTX_UPDT_CMD);
1355 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1356 first_burst_length,
1357 pwrb,
1358 params->dw[offsetof(struct amap_beiscsi_offload_params,
1359 first_burst_length) / 32]);
1360 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb,
1361 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1362 erl) / 32] & OFFLD_PARAMS_ERL));
1363 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb,
1364 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1365 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1366 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb,
1367 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1368 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1369 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb,
1370 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1371 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1372 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb,
1373 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1374 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1375 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn,
1376 pwrb,
1377 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1378 exp_statsn) / 32] + 1));
1379 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx,
1380 pwrb, pwrb_handle->wrb_index);
1381
1382 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1383 max_burst_length, pwrb, params->dw[offsetof
1384 (struct amap_beiscsi_offload_params,
1385 max_burst_length) / 32]);
1386
1387 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb,
1388 pwrb, pwrb_handle->nxt_wrb_index);
1389 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1390 session_state, pwrb, 0);
1391 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack,
1392 pwrb, 1);
1393 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq,
1394 pwrb, 0);
1395 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb,
1396 0);
1397
1398 mem_descr += ISCSI_MEM_GLOBAL_HEADER;
1399 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1400 pad_buffer_addr_hi, pwrb,
1401 mem_descr->mem_array[0].bus_address.u.a32.address_hi);
1402 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1403 pad_buffer_addr_lo, pwrb,
1404 mem_descr->mem_array[0].bus_address.u.a32.address_lo);
1405 }
1406
1407 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params,
1408 struct wrb_handle *pwrb_handle)
1409 {
1410 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1411
1412 memset(pwrb, 0, sizeof(*pwrb));
1413
1414 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1415 max_burst_length, pwrb, params->dw[offsetof
1416 (struct amap_beiscsi_offload_params,
1417 max_burst_length) / 32]);
1418 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1419 max_burst_length, pwrb, params->dw[offsetof
1420 (struct amap_beiscsi_offload_params,
1421 max_burst_length) / 32]);
1422 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1423 type, pwrb,
1424 BE_TGT_CTX_UPDT_CMD);
1425 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1426 ptr2nextwrb,
1427 pwrb, pwrb_handle->nxt_wrb_index);
1428 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx,
1429 pwrb, pwrb_handle->wrb_index);
1430 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1431 max_send_data_segment_length, pwrb,
1432 params->dw[offsetof(struct amap_beiscsi_offload_params,
1433 max_send_data_segment_length) / 32]);
1434 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1435 first_burst_length, pwrb,
1436 params->dw[offsetof(struct amap_beiscsi_offload_params,
1437 first_burst_length) / 32]);
1438 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1439 max_recv_dataseg_len, pwrb, BEISCSI_MAX_RECV_DATASEG_LEN);
1440 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1441 max_cxns, pwrb, BEISCSI_MAX_CXNS);
1442 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb,
1443 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1444 erl) / 32] & OFFLD_PARAMS_ERL));
1445 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb,
1446 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1447 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1448 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb,
1449 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1450 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1451 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1452 ir2t, pwrb,
1453 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1454 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1455 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb,
1456 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1457 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1458 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1459 data_seq_inorder,
1460 pwrb,
1461 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1462 data_seq_inorder) / 32] &
1463 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6);
1464 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1465 pdu_seq_inorder,
1466 pwrb,
1467 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1468 pdu_seq_inorder) / 32] &
1469 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7);
1470 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t,
1471 pwrb,
1472 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1473 max_r2t) / 32] &
1474 OFFLD_PARAMS_MAX_R2T) >> 8);
1475 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn,
1476 pwrb,
1477 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1478 exp_statsn) / 32] + 1));
1479 }
Linux with added FPC-III support