1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <scsi/libiscsi.h>
21#include <scsi/scsi_transport_iscsi.h>
22#include <scsi/scsi_transport.h>
23#include <scsi/scsi_cmnd.h>
24#include <scsi/scsi_device.h>
25#include <scsi/scsi_host.h>
26#include <scsi/scsi_netlink.h>
27#include <net/netlink.h>
28#include <scsi/scsi.h>
29
30#include "be_iscsi.h"
31
32extern struct iscsi_transport beiscsi_iscsi_transport;
33
34
35
36
37
38
39
40struct iscsi_cls_session *beiscsi_session_create(struct iscsi_endpoint *ep,
41 u16 cmds_max,
42 u16 qdepth,
43 u32 initial_cmdsn)
44{
45 struct Scsi_Host *shost;
46 struct beiscsi_endpoint *beiscsi_ep;
47 struct iscsi_cls_session *cls_session;
48 struct beiscsi_hba *phba;
49 struct iscsi_session *sess;
50 struct beiscsi_session *beiscsi_sess;
51 struct beiscsi_io_task *io_task;
52
53
54 if (!ep) {
55 pr_err("beiscsi_session_create: invalid ep\n");
56 return NULL;
57 }
58 beiscsi_ep = ep->dd_data;
59 phba = beiscsi_ep->phba;
60
61 if (!beiscsi_hba_is_online(phba)) {
62 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
63 "BS_%d : HBA in error 0x%lx\n", phba->state);
64 return NULL;
65 }
66
67 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
68 "BS_%d : In beiscsi_session_create\n");
69 if (cmds_max > beiscsi_ep->phba->params.wrbs_per_cxn) {
70 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
71 "BS_%d : Cannot handle %d cmds."
72 "Max cmds per session supported is %d. Using %d."
73 "\n", cmds_max,
74 beiscsi_ep->phba->params.wrbs_per_cxn,
75 beiscsi_ep->phba->params.wrbs_per_cxn);
76
77 cmds_max = beiscsi_ep->phba->params.wrbs_per_cxn;
78 }
79
80 shost = phba->shost;
81 cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
82 shost, cmds_max,
83 sizeof(*beiscsi_sess),
84 sizeof(*io_task),
85 initial_cmdsn, ISCSI_MAX_TARGET);
86 if (!cls_session)
87 return NULL;
88 sess = cls_session->dd_data;
89 beiscsi_sess = sess->dd_data;
90 beiscsi_sess->bhs_pool = pci_pool_create("beiscsi_bhs_pool",
91 phba->pcidev,
92 sizeof(struct be_cmd_bhs),
93 64, 0);
94 if (!beiscsi_sess->bhs_pool)
95 goto destroy_sess;
96
97 return cls_session;
98destroy_sess:
99 iscsi_session_teardown(cls_session);
100 return NULL;
101}
102
103
104
105
106
107
108
109
110void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
111{
112 struct iscsi_session *sess = cls_session->dd_data;
113 struct beiscsi_session *beiscsi_sess = sess->dd_data;
114
115 printk(KERN_INFO "In beiscsi_session_destroy\n");
116 pci_pool_destroy(beiscsi_sess->bhs_pool);
117 iscsi_session_teardown(cls_session);
118}
119
120
121
122
123
124void beiscsi_session_fail(struct iscsi_cls_session *cls_session)
125{
126 iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
127}
128
129
130
131
132
133
134
135struct iscsi_cls_conn *
136beiscsi_conn_create(struct iscsi_cls_session *cls_session, u32 cid)
137{
138 struct beiscsi_hba *phba;
139 struct Scsi_Host *shost;
140 struct iscsi_cls_conn *cls_conn;
141 struct beiscsi_conn *beiscsi_conn;
142 struct iscsi_conn *conn;
143 struct iscsi_session *sess;
144 struct beiscsi_session *beiscsi_sess;
145
146 shost = iscsi_session_to_shost(cls_session);
147 phba = iscsi_host_priv(shost);
148
149 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
150 "BS_%d : In beiscsi_conn_create ,cid"
151 "from iscsi layer=%d\n", cid);
152
153 cls_conn = iscsi_conn_setup(cls_session, sizeof(*beiscsi_conn), cid);
154 if (!cls_conn)
155 return NULL;
156
157 conn = cls_conn->dd_data;
158 beiscsi_conn = conn->dd_data;
159 beiscsi_conn->ep = NULL;
160 beiscsi_conn->phba = phba;
161 beiscsi_conn->conn = conn;
162 sess = cls_session->dd_data;
163 beiscsi_sess = sess->dd_data;
164 beiscsi_conn->beiscsi_sess = beiscsi_sess;
165 return cls_conn;
166}
167
168
169
170
171
172
173
174
175
176int beiscsi_conn_bind(struct iscsi_cls_session *cls_session,
177 struct iscsi_cls_conn *cls_conn,
178 u64 transport_fd, int is_leading)
179{
180 struct iscsi_conn *conn = cls_conn->dd_data;
181 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
182 struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
183 struct beiscsi_hba *phba = iscsi_host_priv(shost);
184 struct hwi_controller *phwi_ctrlr = phba->phwi_ctrlr;
185 struct hwi_wrb_context *pwrb_context;
186 struct beiscsi_endpoint *beiscsi_ep;
187 struct iscsi_endpoint *ep;
188 uint16_t cri_index;
189
190 ep = iscsi_lookup_endpoint(transport_fd);
191 if (!ep)
192 return -EINVAL;
193
194 beiscsi_ep = ep->dd_data;
195
196 if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
197 return -EINVAL;
198
199 if (beiscsi_ep->phba != phba) {
200 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
201 "BS_%d : beiscsi_ep->hba=%p not equal to phba=%p\n",
202 beiscsi_ep->phba, phba);
203
204 return -EEXIST;
205 }
206 cri_index = BE_GET_CRI_FROM_CID(beiscsi_ep->ep_cid);
207 if (phba->conn_table[cri_index]) {
208 if (beiscsi_conn != phba->conn_table[cri_index] ||
209 beiscsi_ep != phba->conn_table[cri_index]->ep) {
210 __beiscsi_log(phba, KERN_ERR,
211 "BS_%d : conn_table not empty at %u: cid %u conn %p:%p\n",
212 cri_index,
213 beiscsi_ep->ep_cid,
214 beiscsi_conn,
215 phba->conn_table[cri_index]);
216 return -EINVAL;
217 }
218 }
219
220 beiscsi_conn->beiscsi_conn_cid = beiscsi_ep->ep_cid;
221 beiscsi_conn->ep = beiscsi_ep;
222 beiscsi_ep->conn = beiscsi_conn;
223
224
225
226
227 pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
228 beiscsi_conn->doorbell_offset = pwrb_context->doorbell_offset;
229 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
230 "BS_%d : cid %d phba->conn_table[%u]=%p\n",
231 beiscsi_ep->ep_cid, cri_index, beiscsi_conn);
232 phba->conn_table[cri_index] = beiscsi_conn;
233 return 0;
234}
235
236static int beiscsi_iface_create_ipv4(struct beiscsi_hba *phba)
237{
238 if (phba->ipv4_iface)
239 return 0;
240
241 phba->ipv4_iface = iscsi_create_iface(phba->shost,
242 &beiscsi_iscsi_transport,
243 ISCSI_IFACE_TYPE_IPV4,
244 0, 0);
245 if (!phba->ipv4_iface) {
246 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
247 "BS_%d : Could not "
248 "create default IPv4 address.\n");
249 return -ENODEV;
250 }
251
252 return 0;
253}
254
255static int beiscsi_iface_create_ipv6(struct beiscsi_hba *phba)
256{
257 if (phba->ipv6_iface)
258 return 0;
259
260 phba->ipv6_iface = iscsi_create_iface(phba->shost,
261 &beiscsi_iscsi_transport,
262 ISCSI_IFACE_TYPE_IPV6,
263 0, 0);
264 if (!phba->ipv6_iface) {
265 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
266 "BS_%d : Could not "
267 "create default IPv6 address.\n");
268 return -ENODEV;
269 }
270
271 return 0;
272}
273
274void beiscsi_iface_create_default(struct beiscsi_hba *phba)
275{
276 struct be_cmd_get_if_info_resp *if_info;
277
278 if (!beiscsi_if_get_info(phba, BEISCSI_IP_TYPE_V4, &if_info)) {
279 beiscsi_iface_create_ipv4(phba);
280 kfree(if_info);
281 }
282
283 if (!beiscsi_if_get_info(phba, BEISCSI_IP_TYPE_V6, &if_info)) {
284 beiscsi_iface_create_ipv6(phba);
285 kfree(if_info);
286 }
287}
288
289void beiscsi_iface_destroy_default(struct beiscsi_hba *phba)
290{
291 if (phba->ipv6_iface) {
292 iscsi_destroy_iface(phba->ipv6_iface);
293 phba->ipv6_iface = NULL;
294 }
295 if (phba->ipv4_iface) {
296 iscsi_destroy_iface(phba->ipv4_iface);
297 phba->ipv4_iface = NULL;
298 }
299}
300
301
302
303
304
305
306
307
308
309
310
311
312
313static int
314beiscsi_iface_config_vlan(struct Scsi_Host *shost,
315 struct iscsi_iface_param_info *iface_param)
316{
317 struct beiscsi_hba *phba = iscsi_host_priv(shost);
318 int ret = -EPERM;
319
320 switch (iface_param->param) {
321 case ISCSI_NET_PARAM_VLAN_ENABLED:
322 ret = 0;
323 if (iface_param->value[0] != ISCSI_VLAN_ENABLE)
324 ret = beiscsi_if_set_vlan(phba, BEISCSI_VLAN_DISABLE);
325 break;
326 case ISCSI_NET_PARAM_VLAN_TAG:
327 ret = beiscsi_if_set_vlan(phba,
328 *((uint16_t *)iface_param->value));
329 break;
330 }
331 return ret;
332}
333
334
335static int
336beiscsi_iface_config_ipv4(struct Scsi_Host *shost,
337 struct iscsi_iface_param_info *info,
338 void *data, uint32_t dt_len)
339{
340 struct beiscsi_hba *phba = iscsi_host_priv(shost);
341 u8 *ip = NULL, *subnet = NULL, *gw;
342 struct nlattr *nla;
343 int ret = -EPERM;
344
345
346 switch (info->param) {
347 case ISCSI_NET_PARAM_IFACE_ENABLE:
348 if (info->value[0] == ISCSI_IFACE_ENABLE)
349 ret = beiscsi_iface_create_ipv4(phba);
350 else {
351 iscsi_destroy_iface(phba->ipv4_iface);
352 phba->ipv4_iface = NULL;
353 }
354 break;
355 case ISCSI_NET_PARAM_IPV4_GW:
356 gw = info->value;
357 ret = beiscsi_if_set_gw(phba, BEISCSI_IP_TYPE_V4, gw);
358 break;
359 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
360 if (info->value[0] == ISCSI_BOOTPROTO_DHCP)
361 ret = beiscsi_if_en_dhcp(phba, BEISCSI_IP_TYPE_V4);
362 else if (info->value[0] == ISCSI_BOOTPROTO_STATIC)
363
364 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
365 NULL, NULL);
366 else
367 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
368 "BS_%d : Invalid BOOTPROTO: %d\n",
369 info->value[0]);
370 break;
371 case ISCSI_NET_PARAM_IPV4_ADDR:
372 ip = info->value;
373 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
374 if (nla) {
375 info = nla_data(nla);
376 subnet = info->value;
377 }
378 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
379 ip, subnet);
380 break;
381 case ISCSI_NET_PARAM_IPV4_SUBNET:
382
383
384
385
386 subnet = info->value;
387 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
388 if (nla) {
389 info = nla_data(nla);
390 ip = info->value;
391 }
392 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
393 ip, subnet);
394 break;
395 }
396
397 return ret;
398}
399
400static int
401beiscsi_iface_config_ipv6(struct Scsi_Host *shost,
402 struct iscsi_iface_param_info *iface_param,
403 void *data, uint32_t dt_len)
404{
405 struct beiscsi_hba *phba = iscsi_host_priv(shost);
406 int ret = -EPERM;
407
408 switch (iface_param->param) {
409 case ISCSI_NET_PARAM_IFACE_ENABLE:
410 if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
411 ret = beiscsi_iface_create_ipv6(phba);
412 else {
413 iscsi_destroy_iface(phba->ipv6_iface);
414 phba->ipv6_iface = NULL;
415 }
416 break;
417 case ISCSI_NET_PARAM_IPV6_ADDR:
418 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V6,
419 iface_param->value, NULL);
420 break;
421 }
422
423 return ret;
424}
425
426int beiscsi_iface_set_param(struct Scsi_Host *shost,
427 void *data, uint32_t dt_len)
428{
429 struct iscsi_iface_param_info *iface_param = NULL;
430 struct beiscsi_hba *phba = iscsi_host_priv(shost);
431 struct nlattr *attrib;
432 uint32_t rm_len = dt_len;
433 int ret;
434
435 if (!beiscsi_hba_is_online(phba)) {
436 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
437 "BS_%d : HBA in error 0x%lx\n", phba->state);
438 return -EBUSY;
439 }
440
441
442 ret = beiscsi_if_get_handle(phba);
443 if (ret) {
444 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
445 "BS_%d : Getting Interface Handle Failed\n");
446 return ret;
447 }
448
449 nla_for_each_attr(attrib, data, dt_len, rm_len) {
450 iface_param = nla_data(attrib);
451
452 if (iface_param->param_type != ISCSI_NET_PARAM)
453 continue;
454
455
456
457
458 if (iface_param->iface_num) {
459 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
460 "BS_%d : Invalid iface_num %d."
461 "Only iface_num 0 is supported.\n",
462 iface_param->iface_num);
463
464 return -EINVAL;
465 }
466
467 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
468 "BS_%d : %s.0 set param %d",
469 (iface_param->iface_type == ISCSI_IFACE_TYPE_IPV4) ?
470 "ipv4" : "ipv6", iface_param->param);
471
472 ret = -EPERM;
473 switch (iface_param->param) {
474 case ISCSI_NET_PARAM_VLAN_ENABLED:
475 case ISCSI_NET_PARAM_VLAN_TAG:
476 ret = beiscsi_iface_config_vlan(shost, iface_param);
477 break;
478 default:
479 switch (iface_param->iface_type) {
480 case ISCSI_IFACE_TYPE_IPV4:
481 ret = beiscsi_iface_config_ipv4(shost,
482 iface_param,
483 data, dt_len);
484 break;
485 case ISCSI_IFACE_TYPE_IPV6:
486 ret = beiscsi_iface_config_ipv6(shost,
487 iface_param,
488 data, dt_len);
489 break;
490 }
491 }
492
493 if (ret == -EPERM) {
494 __beiscsi_log(phba, KERN_ERR,
495 "BS_%d : %s.0 set param %d not permitted",
496 (iface_param->iface_type ==
497 ISCSI_IFACE_TYPE_IPV4) ? "ipv4" : "ipv6",
498 iface_param->param);
499 ret = 0;
500 }
501 if (ret)
502 break;
503 }
504
505 return ret;
506}
507
508static int __beiscsi_iface_get_param(struct beiscsi_hba *phba,
509 struct iscsi_iface *iface,
510 int param, char *buf)
511{
512 struct be_cmd_get_if_info_resp *if_info;
513 int len, ip_type = BEISCSI_IP_TYPE_V4;
514
515 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
516 ip_type = BEISCSI_IP_TYPE_V6;
517
518 len = beiscsi_if_get_info(phba, ip_type, &if_info);
519 if (len)
520 return len;
521
522 switch (param) {
523 case ISCSI_NET_PARAM_IPV4_ADDR:
524 len = sprintf(buf, "%pI4\n", if_info->ip_addr.addr);
525 break;
526 case ISCSI_NET_PARAM_IPV6_ADDR:
527 len = sprintf(buf, "%pI6\n", if_info->ip_addr.addr);
528 break;
529 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
530 if (!if_info->dhcp_state)
531 len = sprintf(buf, "static\n");
532 else
533 len = sprintf(buf, "dhcp\n");
534 break;
535 case ISCSI_NET_PARAM_IPV4_SUBNET:
536 len = sprintf(buf, "%pI4\n", if_info->ip_addr.subnet_mask);
537 break;
538 case ISCSI_NET_PARAM_VLAN_ENABLED:
539 len = sprintf(buf, "%s\n",
540 (if_info->vlan_priority == BEISCSI_VLAN_DISABLE) ?
541 "disable" : "enable");
542 break;
543 case ISCSI_NET_PARAM_VLAN_ID:
544 if (if_info->vlan_priority == BEISCSI_VLAN_DISABLE)
545 len = -EINVAL;
546 else
547 len = sprintf(buf, "%d\n",
548 (if_info->vlan_priority &
549 ISCSI_MAX_VLAN_ID));
550 break;
551 case ISCSI_NET_PARAM_VLAN_PRIORITY:
552 if (if_info->vlan_priority == BEISCSI_VLAN_DISABLE)
553 len = -EINVAL;
554 else
555 len = sprintf(buf, "%d\n",
556 ((if_info->vlan_priority >> 13) &
557 ISCSI_MAX_VLAN_PRIORITY));
558 break;
559 default:
560 WARN_ON(1);
561 }
562
563 kfree(if_info);
564 return len;
565}
566
567int beiscsi_iface_get_param(struct iscsi_iface *iface,
568 enum iscsi_param_type param_type,
569 int param, char *buf)
570{
571 struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
572 struct beiscsi_hba *phba = iscsi_host_priv(shost);
573 struct be_cmd_get_def_gateway_resp gateway;
574 int len = -EPERM;
575
576 if (param_type != ISCSI_NET_PARAM)
577 return 0;
578 if (!beiscsi_hba_is_online(phba)) {
579 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
580 "BS_%d : HBA in error 0x%lx\n", phba->state);
581 return -EBUSY;
582 }
583
584 switch (param) {
585 case ISCSI_NET_PARAM_IPV4_ADDR:
586 case ISCSI_NET_PARAM_IPV4_SUBNET:
587 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
588 case ISCSI_NET_PARAM_IPV6_ADDR:
589 case ISCSI_NET_PARAM_VLAN_ENABLED:
590 case ISCSI_NET_PARAM_VLAN_ID:
591 case ISCSI_NET_PARAM_VLAN_PRIORITY:
592 len = __beiscsi_iface_get_param(phba, iface, param, buf);
593 break;
594 case ISCSI_NET_PARAM_IFACE_ENABLE:
595 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
596 len = sprintf(buf, "%s\n",
597 phba->ipv4_iface ? "enable" : "disable");
598 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
599 len = sprintf(buf, "%s\n",
600 phba->ipv6_iface ? "enable" : "disable");
601 break;
602 case ISCSI_NET_PARAM_IPV4_GW:
603 memset(&gateway, 0, sizeof(gateway));
604 len = beiscsi_if_get_gw(phba, BEISCSI_IP_TYPE_V4, &gateway);
605 if (!len)
606 len = sprintf(buf, "%pI4\n", &gateway.ip_addr.addr);
607 break;
608 }
609
610 return len;
611}
612
613
614
615
616
617
618
619
620
621int beiscsi_ep_get_param(struct iscsi_endpoint *ep,
622 enum iscsi_param param, char *buf)
623{
624 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
625 int len;
626
627 beiscsi_log(beiscsi_ep->phba, KERN_INFO,
628 BEISCSI_LOG_CONFIG,
629 "BS_%d : In beiscsi_ep_get_param,"
630 " param= %d\n", param);
631
632 switch (param) {
633 case ISCSI_PARAM_CONN_PORT:
634 len = sprintf(buf, "%hu\n", beiscsi_ep->dst_tcpport);
635 break;
636 case ISCSI_PARAM_CONN_ADDRESS:
637 if (beiscsi_ep->ip_type == BEISCSI_IP_TYPE_V4)
638 len = sprintf(buf, "%pI4\n", &beiscsi_ep->dst_addr);
639 else
640 len = sprintf(buf, "%pI6\n", &beiscsi_ep->dst6_addr);
641 break;
642 default:
643 len = -EPERM;
644 }
645 return len;
646}
647
648int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
649 enum iscsi_param param, char *buf, int buflen)
650{
651 struct iscsi_conn *conn = cls_conn->dd_data;
652 struct iscsi_session *session = conn->session;
653 struct beiscsi_hba *phba = NULL;
654 int ret;
655
656 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
657 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
658 "BS_%d : In beiscsi_conn_set_param,"
659 " param= %d\n", param);
660
661 ret = iscsi_set_param(cls_conn, param, buf, buflen);
662 if (ret)
663 return ret;
664
665
666
667
668 switch (param) {
669 case ISCSI_PARAM_FIRST_BURST:
670 if (session->first_burst > 8192)
671 session->first_burst = 8192;
672 break;
673 case ISCSI_PARAM_MAX_RECV_DLENGTH:
674 if (conn->max_recv_dlength > 65536)
675 conn->max_recv_dlength = 65536;
676 break;
677 case ISCSI_PARAM_MAX_BURST:
678 if (session->max_burst > 262144)
679 session->max_burst = 262144;
680 break;
681 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
682 if (conn->max_xmit_dlength > 65536)
683 conn->max_xmit_dlength = 65536;
684 default:
685 return 0;
686 }
687
688 return 0;
689}
690
691
692
693
694
695
696
697
698static int beiscsi_get_initname(char *buf, struct beiscsi_hba *phba)
699{
700 int rc;
701 unsigned int tag;
702 struct be_mcc_wrb *wrb;
703 struct be_cmd_hba_name *resp;
704
705 tag = be_cmd_get_initname(phba);
706 if (!tag) {
707 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
708 "BS_%d : Getting Initiator Name Failed\n");
709
710 return -EBUSY;
711 }
712
713 rc = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL);
714 if (rc) {
715 beiscsi_log(phba, KERN_ERR,
716 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
717 "BS_%d : Initiator Name MBX Failed\n");
718 return rc;
719 }
720
721 resp = embedded_payload(wrb);
722 rc = sprintf(buf, "%s\n", resp->initiator_name);
723 return rc;
724}
725
726
727
728
729
730
731static void beiscsi_get_port_state(struct Scsi_Host *shost)
732{
733 struct beiscsi_hba *phba = iscsi_host_priv(shost);
734 struct iscsi_cls_host *ihost = shost->shost_data;
735
736 ihost->port_state = test_bit(BEISCSI_HBA_LINK_UP, &phba->state) ?
737 ISCSI_PORT_STATE_UP : ISCSI_PORT_STATE_DOWN;
738}
739
740
741
742
743
744
745static void beiscsi_get_port_speed(struct Scsi_Host *shost)
746{
747 struct beiscsi_hba *phba = iscsi_host_priv(shost);
748 struct iscsi_cls_host *ihost = shost->shost_data;
749
750 switch (phba->port_speed) {
751 case BE2ISCSI_LINK_SPEED_10MBPS:
752 ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
753 break;
754 case BE2ISCSI_LINK_SPEED_100MBPS:
755 ihost->port_speed = ISCSI_PORT_SPEED_100MBPS;
756 break;
757 case BE2ISCSI_LINK_SPEED_1GBPS:
758 ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
759 break;
760 case BE2ISCSI_LINK_SPEED_10GBPS:
761 ihost->port_speed = ISCSI_PORT_SPEED_10GBPS;
762 break;
763 case BE2ISCSI_LINK_SPEED_25GBPS:
764 ihost->port_speed = ISCSI_PORT_SPEED_25GBPS;
765 break;
766 case BE2ISCSI_LINK_SPEED_40GBPS:
767 ihost->port_speed = ISCSI_PORT_SPEED_40GBPS;
768 break;
769 default:
770 ihost->port_speed = ISCSI_PORT_SPEED_UNKNOWN;
771 }
772}
773
774
775
776
777
778
779
780
781
782int beiscsi_get_host_param(struct Scsi_Host *shost,
783 enum iscsi_host_param param, char *buf)
784{
785 struct beiscsi_hba *phba = iscsi_host_priv(shost);
786 int status = 0;
787
788 if (!beiscsi_hba_is_online(phba)) {
789 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
790 "BS_%d : HBA in error 0x%lx\n", phba->state);
791 return -EBUSY;
792 }
793 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
794 "BS_%d : In beiscsi_get_host_param, param = %d\n", param);
795
796 switch (param) {
797 case ISCSI_HOST_PARAM_HWADDRESS:
798 status = beiscsi_get_macaddr(buf, phba);
799 if (status < 0) {
800 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
801 "BS_%d : beiscsi_get_macaddr Failed\n");
802 return status;
803 }
804 break;
805 case ISCSI_HOST_PARAM_INITIATOR_NAME:
806 status = beiscsi_get_initname(buf, phba);
807 if (status < 0) {
808 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
809 "BS_%d : Retreiving Initiator Name Failed\n");
810 return status;
811 }
812 break;
813 case ISCSI_HOST_PARAM_PORT_STATE:
814 beiscsi_get_port_state(shost);
815 status = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
816 break;
817 case ISCSI_HOST_PARAM_PORT_SPEED:
818 beiscsi_get_port_speed(shost);
819 status = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
820 break;
821 default:
822 return iscsi_host_get_param(shost, param, buf);
823 }
824 return status;
825}
826
827int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
828{
829 struct be_cmd_get_nic_conf_resp resp;
830 int rc;
831
832 if (phba->mac_addr_set)
833 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
834
835 memset(&resp, 0, sizeof(resp));
836 rc = mgmt_get_nic_conf(phba, &resp);
837 if (rc)
838 return rc;
839
840 phba->mac_addr_set = true;
841 memcpy(phba->mac_address, resp.mac_address, ETH_ALEN);
842 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
843}
844
845
846
847
848
849
850
851
852void beiscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn,
853 struct iscsi_stats *stats)
854{
855 struct iscsi_conn *conn = cls_conn->dd_data;
856 struct beiscsi_hba *phba = NULL;
857
858 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
859 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
860 "BS_%d : In beiscsi_conn_get_stats\n");
861
862 stats->txdata_octets = conn->txdata_octets;
863 stats->rxdata_octets = conn->rxdata_octets;
864 stats->dataout_pdus = conn->dataout_pdus_cnt;
865 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
866 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
867 stats->datain_pdus = conn->datain_pdus_cnt;
868 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
869 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
870 stats->r2t_pdus = conn->r2t_pdus_cnt;
871 stats->digest_err = 0;
872 stats->timeout_err = 0;
873 stats->custom_length = 1;
874 strcpy(stats->custom[0].desc, "eh_abort_cnt");
875 stats->custom[0].value = conn->eh_abort_cnt;
876}
877
878
879
880
881
882
883static void beiscsi_set_params_for_offld(struct beiscsi_conn *beiscsi_conn,
884 struct beiscsi_offload_params *params)
885{
886 struct iscsi_conn *conn = beiscsi_conn->conn;
887 struct iscsi_session *session = conn->session;
888
889 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_burst_length,
890 params, session->max_burst);
891 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
892 max_send_data_segment_length, params,
893 conn->max_xmit_dlength);
894 AMAP_SET_BITS(struct amap_beiscsi_offload_params, first_burst_length,
895 params, session->first_burst);
896 AMAP_SET_BITS(struct amap_beiscsi_offload_params, erl, params,
897 session->erl);
898 AMAP_SET_BITS(struct amap_beiscsi_offload_params, dde, params,
899 conn->datadgst_en);
900 AMAP_SET_BITS(struct amap_beiscsi_offload_params, hde, params,
901 conn->hdrdgst_en);
902 AMAP_SET_BITS(struct amap_beiscsi_offload_params, ir2t, params,
903 session->initial_r2t_en);
904 AMAP_SET_BITS(struct amap_beiscsi_offload_params, imd, params,
905 session->imm_data_en);
906 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
907 data_seq_inorder, params,
908 session->dataseq_inorder_en);
909 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
910 pdu_seq_inorder, params,
911 session->pdu_inorder_en);
912 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_r2t, params,
913 session->max_r2t);
914 AMAP_SET_BITS(struct amap_beiscsi_offload_params, exp_statsn, params,
915 (conn->exp_statsn - 1));
916 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
917 max_recv_data_segment_length, params,
918 conn->max_recv_dlength);
919
920}
921
922
923
924
925
926int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
927{
928 struct iscsi_conn *conn = cls_conn->dd_data;
929 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
930 struct beiscsi_endpoint *beiscsi_ep;
931 struct beiscsi_offload_params params;
932 struct beiscsi_hba *phba;
933
934 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
935
936 if (!beiscsi_hba_is_online(phba)) {
937 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
938 "BS_%d : HBA in error 0x%lx\n", phba->state);
939 return -EBUSY;
940 }
941 beiscsi_log(beiscsi_conn->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
942 "BS_%d : In beiscsi_conn_start\n");
943
944 memset(¶ms, 0, sizeof(struct beiscsi_offload_params));
945 beiscsi_ep = beiscsi_conn->ep;
946 if (!beiscsi_ep)
947 beiscsi_log(beiscsi_conn->phba, KERN_ERR,
948 BEISCSI_LOG_CONFIG,
949 "BS_%d : In beiscsi_conn_start , no beiscsi_ep\n");
950
951 beiscsi_conn->login_in_progress = 0;
952 beiscsi_set_params_for_offld(beiscsi_conn, ¶ms);
953 beiscsi_offload_connection(beiscsi_conn, ¶ms);
954 iscsi_conn_start(cls_conn);
955 return 0;
956}
957
958
959
960
961
962static int beiscsi_get_cid(struct beiscsi_hba *phba)
963{
964 uint16_t cid_avlbl_ulp0, cid_avlbl_ulp1;
965 unsigned short cid, cid_from_ulp;
966 struct ulp_cid_info *cid_info;
967
968
969 cid_avlbl_ulp0 = (phba->cid_array_info[BEISCSI_ULP0]) ?
970 BEISCSI_ULP0_AVLBL_CID(phba) : 0;
971 cid_avlbl_ulp1 = (phba->cid_array_info[BEISCSI_ULP1]) ?
972 BEISCSI_ULP1_AVLBL_CID(phba) : 0;
973 cid_from_ulp = (cid_avlbl_ulp0 > cid_avlbl_ulp1) ?
974 BEISCSI_ULP0 : BEISCSI_ULP1;
975
976
977
978
979
980 if (!test_bit(cid_from_ulp, (void *)&phba->fw_config.ulp_supported))
981 return BE_INVALID_CID;
982
983 cid_info = phba->cid_array_info[cid_from_ulp];
984 cid = cid_info->cid_array[cid_info->cid_alloc];
985 if (!cid_info->avlbl_cids || cid == BE_INVALID_CID) {
986 __beiscsi_log(phba, KERN_ERR,
987 "BS_%d : failed to get cid: available %u:%u\n",
988 cid_info->avlbl_cids, cid_info->cid_free);
989 return BE_INVALID_CID;
990 }
991
992 cid_info->cid_array[cid_info->cid_alloc++] = BE_INVALID_CID;
993 if (cid_info->cid_alloc == BEISCSI_GET_CID_COUNT(phba, cid_from_ulp))
994 cid_info->cid_alloc = 0;
995 cid_info->avlbl_cids--;
996 return cid;
997}
998
999
1000
1001
1002
1003
1004static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
1005{
1006 uint16_t cri_index = BE_GET_CRI_FROM_CID(cid);
1007 struct hwi_wrb_context *pwrb_context;
1008 struct hwi_controller *phwi_ctrlr;
1009 struct ulp_cid_info *cid_info;
1010 uint16_t cid_post_ulp;
1011
1012 phwi_ctrlr = phba->phwi_ctrlr;
1013 pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
1014 cid_post_ulp = pwrb_context->ulp_num;
1015
1016 cid_info = phba->cid_array_info[cid_post_ulp];
1017
1018 if (cid_info->cid_array[cid_info->cid_free] != BE_INVALID_CID) {
1019 __beiscsi_log(phba, KERN_ERR,
1020 "BS_%d : failed to put cid %u: available %u:%u\n",
1021 cid, cid_info->avlbl_cids, cid_info->cid_free);
1022 return;
1023 }
1024 cid_info->cid_array[cid_info->cid_free++] = cid;
1025 if (cid_info->cid_free == BEISCSI_GET_CID_COUNT(phba, cid_post_ulp))
1026 cid_info->cid_free = 0;
1027 cid_info->avlbl_cids++;
1028}
1029
1030
1031
1032
1033
1034static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
1035{
1036 struct beiscsi_hba *phba = beiscsi_ep->phba;
1037 struct beiscsi_conn *beiscsi_conn;
1038
1039 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1040 beiscsi_ep->phba = NULL;
1041
1042 phba->ep_array[BE_GET_CRI_FROM_CID(beiscsi_ep->ep_cid)] = NULL;
1043
1044
1045
1046
1047
1048
1049 if (!beiscsi_ep->conn)
1050 return;
1051
1052 beiscsi_conn = beiscsi_ep->conn;
1053
1054
1055
1056
1057 beiscsi_ep->conn = NULL;
1058 if (beiscsi_conn->login_in_progress) {
1059 beiscsi_free_mgmt_task_handles(beiscsi_conn,
1060 beiscsi_conn->task);
1061 beiscsi_conn->login_in_progress = 0;
1062 }
1063}
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073static int beiscsi_open_conn(struct iscsi_endpoint *ep,
1074 struct sockaddr *src_addr,
1075 struct sockaddr *dst_addr, int non_blocking)
1076{
1077 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1078 struct beiscsi_hba *phba = beiscsi_ep->phba;
1079 struct tcp_connect_and_offload_out *ptcpcnct_out;
1080 struct be_dma_mem nonemb_cmd;
1081 unsigned int tag, req_memsize;
1082 int ret = -ENOMEM;
1083
1084 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1085 "BS_%d : In beiscsi_open_conn\n");
1086
1087 beiscsi_ep->ep_cid = beiscsi_get_cid(phba);
1088 if (beiscsi_ep->ep_cid == BE_INVALID_CID) {
1089 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1090 "BS_%d : No free cid available\n");
1091 return ret;
1092 }
1093
1094 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1095 "BS_%d : In beiscsi_open_conn, ep_cid=%d\n",
1096 beiscsi_ep->ep_cid);
1097
1098 phba->ep_array[BE_GET_CRI_FROM_CID
1099 (beiscsi_ep->ep_cid)] = ep;
1100
1101 beiscsi_ep->cid_vld = 0;
1102
1103 if (is_chip_be2_be3r(phba))
1104 req_memsize = sizeof(struct tcp_connect_and_offload_in);
1105 else
1106 req_memsize = sizeof(struct tcp_connect_and_offload_in_v1);
1107
1108 nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
1109 req_memsize,
1110 &nonemb_cmd.dma);
1111 if (nonemb_cmd.va == NULL) {
1112
1113 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1114 "BS_%d : Failed to allocate memory for"
1115 " mgmt_open_connection\n");
1116
1117 beiscsi_free_ep(beiscsi_ep);
1118 return -ENOMEM;
1119 }
1120 nonemb_cmd.size = req_memsize;
1121 memset(nonemb_cmd.va, 0, nonemb_cmd.size);
1122 tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep, &nonemb_cmd);
1123 if (!tag) {
1124 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1125 "BS_%d : mgmt_open_connection Failed for cid=%d\n",
1126 beiscsi_ep->ep_cid);
1127
1128 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1129 nonemb_cmd.va, nonemb_cmd.dma);
1130 beiscsi_free_ep(beiscsi_ep);
1131 return -EAGAIN;
1132 }
1133
1134 ret = beiscsi_mccq_compl_wait(phba, tag, NULL, &nonemb_cmd);
1135 if (ret) {
1136 beiscsi_log(phba, KERN_ERR,
1137 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
1138 "BS_%d : mgmt_open_connection Failed");
1139
1140 if (ret != -EBUSY)
1141 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1142 nonemb_cmd.va, nonemb_cmd.dma);
1143
1144 beiscsi_free_ep(beiscsi_ep);
1145 return ret;
1146 }
1147
1148 ptcpcnct_out = (struct tcp_connect_and_offload_out *)nonemb_cmd.va;
1149 beiscsi_ep = ep->dd_data;
1150 beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
1151 beiscsi_ep->cid_vld = 1;
1152 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1153 "BS_%d : mgmt_open_connection Success\n");
1154
1155 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1156 nonemb_cmd.va, nonemb_cmd.dma);
1157 return 0;
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168struct iscsi_endpoint *
1169beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1170 int non_blocking)
1171{
1172 struct beiscsi_hba *phba;
1173 struct beiscsi_endpoint *beiscsi_ep;
1174 struct iscsi_endpoint *ep;
1175 int ret;
1176
1177 if (!shost) {
1178 ret = -ENXIO;
1179 pr_err("beiscsi_ep_connect shost is NULL\n");
1180 return ERR_PTR(ret);
1181 }
1182
1183 phba = iscsi_host_priv(shost);
1184 if (!beiscsi_hba_is_online(phba)) {
1185 ret = -EIO;
1186 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1187 "BS_%d : HBA in error 0x%lx\n", phba->state);
1188 return ERR_PTR(ret);
1189 }
1190 if (!test_bit(BEISCSI_HBA_LINK_UP, &phba->state)) {
1191 ret = -EBUSY;
1192 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1193 "BS_%d : The Adapter Port state is Down!!!\n");
1194 return ERR_PTR(ret);
1195 }
1196
1197 ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
1198 if (!ep) {
1199 ret = -ENOMEM;
1200 return ERR_PTR(ret);
1201 }
1202
1203 beiscsi_ep = ep->dd_data;
1204 beiscsi_ep->phba = phba;
1205 beiscsi_ep->openiscsi_ep = ep;
1206 ret = beiscsi_open_conn(ep, NULL, dst_addr, non_blocking);
1207 if (ret) {
1208 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1209 "BS_%d : Failed in beiscsi_open_conn\n");
1210 goto free_ep;
1211 }
1212
1213 return ep;
1214
1215free_ep:
1216 iscsi_destroy_endpoint(ep);
1217 return ERR_PTR(ret);
1218}
1219
1220
1221
1222
1223
1224
1225
1226
1227int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1228{
1229 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1230
1231 beiscsi_log(beiscsi_ep->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1232 "BS_%d : In beiscsi_ep_poll\n");
1233
1234 if (beiscsi_ep->cid_vld == 1)
1235 return 1;
1236 else
1237 return 0;
1238}
1239
1240
1241
1242
1243
1244
1245
1246
1247static void beiscsi_flush_cq(struct beiscsi_hba *phba)
1248{
1249 uint16_t i;
1250 struct be_eq_obj *pbe_eq;
1251 struct hwi_controller *phwi_ctrlr;
1252 struct hwi_context_memory *phwi_context;
1253
1254 phwi_ctrlr = phba->phwi_ctrlr;
1255 phwi_context = phwi_ctrlr->phwi_ctxt;
1256
1257 for (i = 0; i < phba->num_cpus; i++) {
1258 pbe_eq = &phwi_context->be_eq[i];
1259 irq_poll_disable(&pbe_eq->iopoll);
1260 beiscsi_process_cq(pbe_eq, BE2_MAX_NUM_CQ_PROC);
1261 irq_poll_enable(&pbe_eq->iopoll);
1262 }
1263}
1264
1265
1266
1267
1268
1269
1270static int beiscsi_close_conn(struct beiscsi_endpoint *beiscsi_ep, int flag)
1271{
1272 int ret = 0;
1273 unsigned int tag;
1274 struct beiscsi_hba *phba = beiscsi_ep->phba;
1275
1276 tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
1277 if (!tag) {
1278 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1279 "BS_%d : upload failed for cid 0x%x\n",
1280 beiscsi_ep->ep_cid);
1281
1282 ret = -EAGAIN;
1283 }
1284
1285 ret = beiscsi_mccq_compl_wait(phba, tag, NULL, NULL);
1286
1287
1288 beiscsi_flush_cq(phba);
1289
1290 return ret;
1291}
1292
1293
1294
1295
1296
1297
1298
1299void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
1300{
1301 struct beiscsi_conn *beiscsi_conn;
1302 struct beiscsi_endpoint *beiscsi_ep;
1303 struct beiscsi_hba *phba;
1304 unsigned int tag;
1305 uint8_t mgmt_invalidate_flag, tcp_upload_flag;
1306 unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
1307 uint16_t cri_index;
1308
1309 beiscsi_ep = ep->dd_data;
1310 phba = beiscsi_ep->phba;
1311 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1312 "BS_%d : In beiscsi_ep_disconnect for ep_cid = %u\n",
1313 beiscsi_ep->ep_cid);
1314
1315 cri_index = BE_GET_CRI_FROM_CID(beiscsi_ep->ep_cid);
1316 if (!phba->ep_array[cri_index]) {
1317 __beiscsi_log(phba, KERN_ERR,
1318 "BS_%d : ep_array at %u cid %u empty\n",
1319 cri_index,
1320 beiscsi_ep->ep_cid);
1321 return;
1322 }
1323
1324 if (beiscsi_ep->conn) {
1325 beiscsi_conn = beiscsi_ep->conn;
1326 iscsi_suspend_queue(beiscsi_conn->conn);
1327 mgmt_invalidate_flag = ~BEISCSI_NO_RST_ISSUE;
1328 tcp_upload_flag = CONNECTION_UPLOAD_GRACEFUL;
1329 } else {
1330 mgmt_invalidate_flag = BEISCSI_NO_RST_ISSUE;
1331 tcp_upload_flag = CONNECTION_UPLOAD_ABORT;
1332 }
1333
1334 if (!beiscsi_hba_is_online(phba)) {
1335 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1336 "BS_%d : HBA in error 0x%lx\n", phba->state);
1337 goto free_ep;
1338 }
1339
1340 tag = mgmt_invalidate_connection(phba, beiscsi_ep,
1341 beiscsi_ep->ep_cid,
1342 mgmt_invalidate_flag,
1343 savecfg_flag);
1344 if (!tag) {
1345 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1346 "BS_%d : mgmt_invalidate_connection Failed for cid=%d\n",
1347 beiscsi_ep->ep_cid);
1348 }
1349
1350 beiscsi_mccq_compl_wait(phba, tag, NULL, NULL);
1351 beiscsi_close_conn(beiscsi_ep, tcp_upload_flag);
1352free_ep:
1353 msleep(BEISCSI_LOGOUT_SYNC_DELAY);
1354 beiscsi_free_ep(beiscsi_ep);
1355 if (!phba->conn_table[cri_index])
1356 __beiscsi_log(phba, KERN_ERR,
1357 "BS_%d : conn_table empty at %u: cid %u\n",
1358 cri_index,
1359 beiscsi_ep->ep_cid);
1360 phba->conn_table[cri_index] = NULL;
1361 iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
1362}
1363
1364umode_t beiscsi_attr_is_visible(int param_type, int param)
1365{
1366 switch (param_type) {
1367 case ISCSI_NET_PARAM:
1368 switch (param) {
1369 case ISCSI_NET_PARAM_IFACE_ENABLE:
1370 case ISCSI_NET_PARAM_IPV4_ADDR:
1371 case ISCSI_NET_PARAM_IPV4_SUBNET:
1372 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
1373 case ISCSI_NET_PARAM_IPV4_GW:
1374 case ISCSI_NET_PARAM_IPV6_ADDR:
1375 case ISCSI_NET_PARAM_VLAN_ID:
1376 case ISCSI_NET_PARAM_VLAN_PRIORITY:
1377 case ISCSI_NET_PARAM_VLAN_ENABLED:
1378 return S_IRUGO;
1379 default:
1380 return 0;
1381 }
1382 case ISCSI_HOST_PARAM:
1383 switch (param) {
1384 case ISCSI_HOST_PARAM_HWADDRESS:
1385 case ISCSI_HOST_PARAM_INITIATOR_NAME:
1386 case ISCSI_HOST_PARAM_PORT_STATE:
1387 case ISCSI_HOST_PARAM_PORT_SPEED:
1388 return S_IRUGO;
1389 default:
1390 return 0;
1391 }
1392 case ISCSI_PARAM:
1393 switch (param) {
1394 case ISCSI_PARAM_MAX_RECV_DLENGTH:
1395 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
1396 case ISCSI_PARAM_HDRDGST_EN:
1397 case ISCSI_PARAM_DATADGST_EN:
1398 case ISCSI_PARAM_CONN_ADDRESS:
1399 case ISCSI_PARAM_CONN_PORT:
1400 case ISCSI_PARAM_EXP_STATSN:
1401 case ISCSI_PARAM_PERSISTENT_ADDRESS:
1402 case ISCSI_PARAM_PERSISTENT_PORT:
1403 case ISCSI_PARAM_PING_TMO:
1404 case ISCSI_PARAM_RECV_TMO:
1405 case ISCSI_PARAM_INITIAL_R2T_EN:
1406 case ISCSI_PARAM_MAX_R2T:
1407 case ISCSI_PARAM_IMM_DATA_EN:
1408 case ISCSI_PARAM_FIRST_BURST:
1409 case ISCSI_PARAM_MAX_BURST:
1410 case ISCSI_PARAM_PDU_INORDER_EN:
1411 case ISCSI_PARAM_DATASEQ_INORDER_EN:
1412 case ISCSI_PARAM_ERL:
1413 case ISCSI_PARAM_TARGET_NAME:
1414 case ISCSI_PARAM_TPGT:
1415 case ISCSI_PARAM_USERNAME:
1416 case ISCSI_PARAM_PASSWORD:
1417 case ISCSI_PARAM_USERNAME_IN:
1418 case ISCSI_PARAM_PASSWORD_IN:
1419 case ISCSI_PARAM_FAST_ABORT:
1420 case ISCSI_PARAM_ABORT_TMO:
1421 case ISCSI_PARAM_LU_RESET_TMO:
1422 case ISCSI_PARAM_IFACE_NAME:
1423 case ISCSI_PARAM_INITIATOR_NAME:
1424 return S_IRUGO;
1425 default:
1426 return 0;
1427 }
1428 }
1429
1430 return 0;
1431}
1432
