?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / drivers / scsi / be2iscsi / be_mgmt.c
blobef0a78b0d730a7ecd0c9f0071d510bf7dadb16a0
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 sizeof(req->ip_params.ip_record.ip_addr.addr));
816
817 if (subnet_param)
818 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
819 subnet_param->value,
820 sizeof(req->ip_params.ip_record.ip_addr.subnet_mask));
821 } else {
822 memcpy(req->ip_params.ip_record.ip_addr.addr,
823 if_info->ip_addr.addr,
824 sizeof(req->ip_params.ip_record.ip_addr.addr));
825
826 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
827 if_info->ip_addr.subnet_mask,
828 sizeof(req->ip_params.ip_record.ip_addr.subnet_mask));
829 }
830
831 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
832 if (rc < 0)
833 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
834 "BG_%d : Failed to Modify existing IP Address\n");
835 return rc;
836 }
837
838 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr,
839 uint32_t gtway_action, uint32_t param_len)
840 {
841 struct be_cmd_set_def_gateway_req *req;
842 struct be_dma_mem nonemb_cmd;
843 int rt_val;
844
845
846 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
847 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY,
848 sizeof(*req));
849 if (rt_val)
850 return rt_val;
851
852 req = nonemb_cmd.va;
853 req->action = gtway_action;
854 req->ip_addr.ip_type = BE2_IPV4;
855
856 memcpy(req->ip_addr.addr, gt_addr, sizeof(req->ip_addr.addr));
857
858 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
859 }
860
861 int mgmt_set_ip(struct beiscsi_hba *phba,
862 struct iscsi_iface_param_info *ip_param,
863 struct iscsi_iface_param_info *subnet_param,
864 uint32_t boot_proto)
865 {
866 struct be_cmd_get_def_gateway_resp gtway_addr_set;
867 struct be_cmd_get_if_info_resp if_info;
868 struct be_cmd_set_dhcp_req *dhcpreq;
869 struct be_cmd_rel_dhcp_req *reldhcp;
870 struct be_dma_mem nonemb_cmd;
871 uint8_t *gtway_addr;
872 uint32_t ip_type;
873 int rc;
874
875 if (mgmt_get_all_if_id(phba))
876 return -EIO;
877
878 memset(&if_info, 0, sizeof(if_info));
879 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
880 BE2_IPV6 : BE2_IPV4 ;
881
882 rc = mgmt_get_if_info(phba, ip_type, &if_info);
883 if (rc)
884 return rc;
885
886 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
887 if (if_info.dhcp_state) {
888 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
889 "BG_%d : DHCP Already Enabled\n");
890 return 0;
891 }
892 /* The ip_param->len is 1 in DHCP case. Setting
893 proper IP len as this it is used while
894 freeing the Static IP.
895 */
896 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
897 IP_V6_LEN : IP_V4_LEN;
898
899 } else {
900 if (if_info.dhcp_state) {
901
902 memset(&if_info, 0, sizeof(if_info));
903 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
904 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR,
905 sizeof(*reldhcp));
906
907 if (rc)
908 return rc;
909
910 reldhcp = nonemb_cmd.va;
911 reldhcp->interface_hndl = phba->interface_handle;
912 reldhcp->ip_type = ip_type;
913
914 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
915 if (rc < 0) {
916 beiscsi_log(phba, KERN_WARNING,
917 BEISCSI_LOG_CONFIG,
918 "BG_%d : Failed to Delete existing dhcp\n");
919 return rc;
920 }
921 }
922 }
923
924 /* Delete the Static IP Set */
925 if (if_info.ip_addr.addr[0]) {
926 rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL,
927 IP_ACTION_DEL);
928 if (rc)
929 return rc;
930 }
931
932 /* Delete the Gateway settings if mode change is to DHCP */
933 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
934 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
935 rc = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
936 if (rc) {
937 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
938 "BG_%d : Failed to Get Gateway Addr\n");
939 return rc;
940 }
941
942 if (gtway_addr_set.ip_addr.addr[0]) {
943 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
944 rc = mgmt_modify_gateway(phba, gtway_addr,
945 IP_ACTION_DEL, IP_V4_LEN);
946
947 if (rc) {
948 beiscsi_log(phba, KERN_WARNING,
949 BEISCSI_LOG_CONFIG,
950 "BG_%d : Failed to clear Gateway Addr Set\n");
951 return rc;
952 }
953 }
954 }
955
956 /* Set Adapter to DHCP/Static Mode */
957 if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
958 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
959 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR,
960 sizeof(*dhcpreq));
961 if (rc)
962 return rc;
963
964 dhcpreq = nonemb_cmd.va;
965 dhcpreq->flags = BLOCKING;
966 dhcpreq->retry_count = 1;
967 dhcpreq->interface_hndl = phba->interface_handle;
968 dhcpreq->ip_type = BE2_DHCP_V4;
969
970 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
971 } else {
972 return mgmt_static_ip_modify(phba, &if_info, ip_param,
973 subnet_param, IP_ACTION_ADD);
974 }
975
976 return rc;
977 }
978
979 int mgmt_set_gateway(struct beiscsi_hba *phba,
980 struct iscsi_iface_param_info *gateway_param)
981 {
982 struct be_cmd_get_def_gateway_resp gtway_addr_set;
983 uint8_t *gtway_addr;
984 int rt_val;
985
986 memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
987 rt_val = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
988 if (rt_val) {
989 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
990 "BG_%d : Failed to Get Gateway Addr\n");
991 return rt_val;
992 }
993
994 if (gtway_addr_set.ip_addr.addr[0]) {
995 gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
996 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL,
997 gateway_param->len);
998 if (rt_val) {
999 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1000 "BG_%d : Failed to clear Gateway Addr Set\n");
1001 return rt_val;
1002 }
1003 }
1004
1005 gtway_addr = (uint8_t *)&gateway_param->value;
1006 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD,
1007 gateway_param->len);
1008
1009 if (rt_val)
1010 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1011 "BG_%d : Failed to Set Gateway Addr\n");
1012
1013 return rt_val;
1014 }
1015
1016 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
1017 struct be_cmd_get_def_gateway_resp *gateway)
1018 {
1019 struct be_cmd_get_def_gateway_req *req;
1020 struct be_dma_mem nonemb_cmd;
1021 int rc;
1022
1023 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1024 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY,
1025 sizeof(*gateway));
1026 if (rc)
1027 return rc;
1028
1029 req = nonemb_cmd.va;
1030 req->ip_type = ip_type;
1031
1032 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway,
1033 sizeof(*gateway));
1034 }
1035
1036 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
1037 struct be_cmd_get_if_info_resp *if_info)
1038 {
1039 struct be_cmd_get_if_info_req *req;
1040 struct be_dma_mem nonemb_cmd;
1041 int rc;
1042
1043 if (mgmt_get_all_if_id(phba))
1044 return -EIO;
1045
1046 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1047 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO,
1048 sizeof(*if_info));
1049 if (rc)
1050 return rc;
1051
1052 req = nonemb_cmd.va;
1053 req->interface_hndl = phba->interface_handle;
1054 req->ip_type = ip_type;
1055
1056 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info,
1057 sizeof(*if_info));
1058 }
1059
1060 int mgmt_get_nic_conf(struct beiscsi_hba *phba,
1061 struct be_cmd_get_nic_conf_resp *nic)
1062 {
1063 struct be_dma_mem nonemb_cmd;
1064 int rc;
1065
1066 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
1067 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
1068 sizeof(*nic));
1069 if (rc)
1070 return rc;
1071
1072 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic));
1073 }
1074
1075
1076
1077 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
1078 {
1079 unsigned int tag = 0;
1080 struct be_mcc_wrb *wrb;
1081 struct be_cmd_hba_name *req;
1082 struct be_ctrl_info *ctrl = &phba->ctrl;
1083
1084 spin_lock(&ctrl->mbox_lock);
1085 tag = alloc_mcc_tag(phba);
1086 if (!tag) {
1087 spin_unlock(&ctrl->mbox_lock);
1088 return tag;
1089 }
1090
1091 wrb = wrb_from_mccq(phba);
1092 req = embedded_payload(wrb);
1093 wrb->tag0 |= tag;
1094 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1095 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
1096 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
1097 sizeof(*req));
1098
1099 be_mcc_notify(phba);
1100 spin_unlock(&ctrl->mbox_lock);
1101 return tag;
1102 }
1103
1104 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
1105 {
1106 unsigned int tag = 0;
1107 struct be_mcc_wrb *wrb;
1108 struct be_cmd_ntwk_link_status_req *req;
1109 struct be_ctrl_info *ctrl = &phba->ctrl;
1110
1111 spin_lock(&ctrl->mbox_lock);
1112 tag = alloc_mcc_tag(phba);
1113 if (!tag) {
1114 spin_unlock(&ctrl->mbox_lock);
1115 return tag;
1116 }
1117
1118 wrb = wrb_from_mccq(phba);
1119 req = embedded_payload(wrb);
1120 wrb->tag0 |= tag;
1121 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1122 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1123 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
1124 sizeof(*req));
1125
1126 be_mcc_notify(phba);
1127 spin_unlock(&ctrl->mbox_lock);
1128 return tag;
1129 }
1130
1131 /**
1132 * be_mgmt_get_boot_shandle()- Get the session handle
1133 * @phba: device priv structure instance
1134 * @s_handle: session handle returned for boot session.
1135 *
1136 * Get the boot target session handle. In case of
1137 * crashdump mode driver has to issue and MBX Cmd
1138 * for FW to login to boot target
1139 *
1140 * return
1141 * Success: 0
1142 * Failure: Non-Zero value
1143 *
1144 **/
1145 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba,
1146 unsigned int *s_handle)
1147 {
1148 struct be_cmd_get_boot_target_resp *boot_resp;
1149 struct be_mcc_wrb *wrb;
1150 unsigned int tag;
1151 uint8_t boot_retry = 3;
1152 int rc;
1153
1154 do {
1155 /* Get the Boot Target Session Handle and Count*/
1156 tag = mgmt_get_boot_target(phba);
1157 if (!tag) {
1158 beiscsi_log(phba, KERN_ERR,
1159 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
1160 "BG_%d : Getting Boot Target Info Failed\n");
1161 return -EAGAIN;
1162 }
1163
1164 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1165 if (rc) {
1166 beiscsi_log(phba, KERN_ERR,
1167 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1168 "BG_%d : MBX CMD get_boot_target Failed\n");
1169 return -EBUSY;
1170 }
1171
1172 boot_resp = embedded_payload(wrb);
1173
1174 /* Check if the there are any Boot targets configured */
1175 if (!boot_resp->boot_session_count) {
1176 beiscsi_log(phba, KERN_INFO,
1177 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1178 "BG_%d ;No boot targets configured\n");
1179 return -ENXIO;
1180 }
1181
1182 /* FW returns the session handle of the boot session */
1183 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) {
1184 *s_handle = boot_resp->boot_session_handle;
1185 return 0;
1186 }
1187
1188 /* Issue MBX Cmd to FW to login to the boot target */
1189 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS,
1190 INVALID_SESS_HANDLE);
1191 if (!tag) {
1192 beiscsi_log(phba, KERN_ERR,
1193 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1194 "BG_%d : mgmt_reopen_session Failed\n");
1195 return -EAGAIN;
1196 }
1197
1198 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL);
1199 if (rc) {
1200 beiscsi_log(phba, KERN_ERR,
1201 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1202 "BG_%d : mgmt_reopen_session Failed");
1203 return rc;
1204 }
1205 } while (--boot_retry);
1206
1207 /* Couldn't log into the boot target */
1208 beiscsi_log(phba, KERN_ERR,
1209 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
1210 "BG_%d : Login to Boot Target Failed\n");
1211 return -ENXIO;
1212 }
1213
1214 /**
1215 * mgmt_set_vlan()- Issue and wait for CMD completion
1216 * @phba: device private structure instance
1217 * @vlan_tag: VLAN tag
1218 *
1219 * Issue the MBX Cmd and wait for the completion of the
1220 * command.
1221 *
1222 * returns
1223 * Success: 0
1224 * Failure: Non-Xero Value
1225 **/
1226 int mgmt_set_vlan(struct beiscsi_hba *phba,
1227 uint16_t vlan_tag)
1228 {
1229 int rc;
1230 unsigned int tag;
1231 struct be_mcc_wrb *wrb = NULL;
1232
1233 tag = be_cmd_set_vlan(phba, vlan_tag);
1234 if (!tag) {
1235 beiscsi_log(phba, KERN_ERR,
1236 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1237 "BG_%d : VLAN Setting Failed\n");
1238 return -EBUSY;
1239 }
1240
1241 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
1242 if (rc) {
1243 beiscsi_log(phba, KERN_ERR,
1244 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),
1245 "BS_%d : VLAN MBX Cmd Failed\n");
1246 return rc;
1247 }
1248 return rc;
1249 }
1250
1251 /**
1252 * beiscsi_drvr_ver_disp()- Display the driver Name and Version
1253 * @dev: ptr to device not used.
1254 * @attr: device attribute, not used.
1255 * @buf: contains formatted text driver name and version
1256 *
1257 * return
1258 * size of the formatted string
1259 **/
1260 ssize_t
1261 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr,
1262 char *buf)
1263 {
1264 return snprintf(buf, PAGE_SIZE, BE_NAME "\n");
1265 }
1266
1267 /**
1268 * beiscsi_fw_ver_disp()- Display Firmware Version
1269 * @dev: ptr to device not used.
1270 * @attr: device attribute, not used.
1271 * @buf: contains formatted text Firmware version
1272 *
1273 * return
1274 * size of the formatted string
1275 **/
1276 ssize_t
1277 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr,
1278 char *buf)
1279 {
1280 struct Scsi_Host *shost = class_to_shost(dev);
1281 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1282
1283 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str);
1284 }
1285
1286 /**
1287 * beiscsi_active_cid_disp()- Display Sessions Active
1288 * @dev: ptr to device not used.
1289 * @attr: device attribute, not used.
1290 * @buf: contains formatted text Session Count
1291 *
1292 * return
1293 * size of the formatted string
1294 **/
1295 ssize_t
1296 beiscsi_active_cid_disp(struct device *dev, struct device_attribute *attr,
1297 char *buf)
1298 {
1299 struct Scsi_Host *shost = class_to_shost(dev);
1300 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1301
1302 return snprintf(buf, PAGE_SIZE, "%d\n",
1303 (phba->params.cxns_per_ctrl - phba->avlbl_cids));
1304 }
1305
1306 /**
1307 * beiscsi_adap_family_disp()- Display adapter family.
1308 * @dev: ptr to device to get priv structure
1309 * @attr: device attribute, not used.
1310 * @buf: contains formatted text driver name and version
1311 *
1312 * return
1313 * size of the formatted string
1314 **/
1315 ssize_t
1316 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr,
1317 char *buf)
1318 {
1319 uint16_t dev_id = 0;
1320 struct Scsi_Host *shost = class_to_shost(dev);
1321 struct beiscsi_hba *phba = iscsi_host_priv(shost);
1322
1323 dev_id = phba->pcidev->device;
1324 switch (dev_id) {
1325 case BE_DEVICE_ID1:
1326 case OC_DEVICE_ID1:
1327 case OC_DEVICE_ID2:
1328 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n");
1329 break;
1330 case BE_DEVICE_ID2:
1331 case OC_DEVICE_ID3:
1332 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n");
1333 break;
1334 case OC_SKH_ID1:
1335 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n");
1336 break;
1337 default:
1338 return snprintf(buf, PAGE_SIZE,
1339 "Unknown Adapter Family: 0x%x\n", dev_id);
1340 break;
1341 }
1342 }
1343
1344
1345 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params,
1346 struct wrb_handle *pwrb_handle,
1347 struct be_mem_descriptor *mem_descr)
1348 {
1349 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1350
1351 memset(pwrb, 0, sizeof(*pwrb));
1352 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1353 max_send_data_segment_length, pwrb,
1354 params->dw[offsetof(struct amap_beiscsi_offload_params,
1355 max_send_data_segment_length) / 32]);
1356 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb,
1357 BE_TGT_CTX_UPDT_CMD);
1358 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1359 first_burst_length,
1360 pwrb,
1361 params->dw[offsetof(struct amap_beiscsi_offload_params,
1362 first_burst_length) / 32]);
1363 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb,
1364 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1365 erl) / 32] & OFFLD_PARAMS_ERL));
1366 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb,
1367 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1368 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1369 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb,
1370 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1371 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1372 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb,
1373 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1374 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1375 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb,
1376 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1377 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1378 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn,
1379 pwrb,
1380 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1381 exp_statsn) / 32] + 1));
1382 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx,
1383 pwrb, pwrb_handle->wrb_index);
1384
1385 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1386 max_burst_length, pwrb, params->dw[offsetof
1387 (struct amap_beiscsi_offload_params,
1388 max_burst_length) / 32]);
1389
1390 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb,
1391 pwrb, pwrb_handle->nxt_wrb_index);
1392 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1393 session_state, pwrb, 0);
1394 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack,
1395 pwrb, 1);
1396 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq,
1397 pwrb, 0);
1398 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb,
1399 0);
1400
1401 mem_descr += ISCSI_MEM_GLOBAL_HEADER;
1402 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1403 pad_buffer_addr_hi, pwrb,
1404 mem_descr->mem_array[0].bus_address.u.a32.address_hi);
1405 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1406 pad_buffer_addr_lo, pwrb,
1407 mem_descr->mem_array[0].bus_address.u.a32.address_lo);
1408 }
1409
1410 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params,
1411 struct wrb_handle *pwrb_handle)
1412 {
1413 struct iscsi_wrb *pwrb = pwrb_handle->pwrb;
1414
1415 memset(pwrb, 0, sizeof(*pwrb));
1416
1417 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
1418 max_burst_length, pwrb, params->dw[offsetof
1419 (struct amap_beiscsi_offload_params,
1420 max_burst_length) / 32]);
1421 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1422 max_burst_length, pwrb, params->dw[offsetof
1423 (struct amap_beiscsi_offload_params,
1424 max_burst_length) / 32]);
1425 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1426 type, pwrb,
1427 BE_TGT_CTX_UPDT_CMD);
1428 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1429 ptr2nextwrb,
1430 pwrb, pwrb_handle->nxt_wrb_index);
1431 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx,
1432 pwrb, pwrb_handle->wrb_index);
1433 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1434 max_send_data_segment_length, pwrb,
1435 params->dw[offsetof(struct amap_beiscsi_offload_params,
1436 max_send_data_segment_length) / 32]);
1437 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1438 first_burst_length, pwrb,
1439 params->dw[offsetof(struct amap_beiscsi_offload_params,
1440 first_burst_length) / 32]);
1441 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1442 max_recv_dataseg_len, pwrb, BEISCSI_MAX_RECV_DATASEG_LEN);
1443 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1444 max_cxns, pwrb, BEISCSI_MAX_CXNS);
1445 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb,
1446 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1447 erl) / 32] & OFFLD_PARAMS_ERL));
1448 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb,
1449 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1450 dde) / 32] & OFFLD_PARAMS_DDE) >> 2);
1451 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb,
1452 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1453 hde) / 32] & OFFLD_PARAMS_HDE) >> 3);
1454 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1455 ir2t, pwrb,
1456 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1457 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4);
1458 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb,
1459 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1460 imd) / 32] & OFFLD_PARAMS_IMD) >> 5);
1461 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1462 data_seq_inorder,
1463 pwrb,
1464 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1465 data_seq_inorder) / 32] &
1466 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6);
1467 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2,
1468 pdu_seq_inorder,
1469 pwrb,
1470 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1471 pdu_seq_inorder) / 32] &
1472 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7);
1473 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t,
1474 pwrb,
1475 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1476 max_r2t) / 32] &
1477 OFFLD_PARAMS_MAX_R2T) >> 8);
1478 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn,
1479 pwrb,
1480 (params->dw[offsetof(struct amap_beiscsi_offload_params,
1481 exp_statsn) / 32] + 1));
1482 }
Linux with added FPC-III support