2 * Copyright (C) 2005 - 2016 Broadcom
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@broadcom.com)
12 * Contact Information:
13 * linux-drivers@broadcom.com
17 * Costa Mesa, CA 92626
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>
32 extern struct iscsi_transport beiscsi_iscsi_transport;
35 * beiscsi_session_create - creates a new iscsi session
36 * @cmds_max: max commands supported
37 * @qdepth: max queue depth supported
38 * @initial_cmdsn: initial iscsi CMDSN
40 struct iscsi_cls_session *beiscsi_session_create(struct iscsi_endpoint *ep,
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;
55 pr_err("beiscsi_session_create: invalid ep\n");
58 beiscsi_ep = ep->dd_data;
59 phba = beiscsi_ep->phba;
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);
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."
74 beiscsi_ep->phba->params.wrbs_per_cxn,
75 beiscsi_ep->phba->params.wrbs_per_cxn);
77 cmds_max = beiscsi_ep->phba->params.wrbs_per_cxn;
81 cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
83 sizeof(*beiscsi_sess),
85 initial_cmdsn, ISCSI_MAX_TARGET);
88 sess = cls_session->dd_data;
89 beiscsi_sess = sess->dd_data;
90 beiscsi_sess->bhs_pool = pci_pool_create("beiscsi_bhs_pool",
92 sizeof(struct be_cmd_bhs),
94 if (!beiscsi_sess->bhs_pool)
99 iscsi_session_teardown(cls_session);
104 * beiscsi_session_destroy - destroys iscsi session
105 * @cls_session: pointer to iscsi cls session
107 * Destroys iSCSI session instance and releases
108 * resources allocated for it.
110 void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
112 struct iscsi_session *sess = cls_session->dd_data;
113 struct beiscsi_session *beiscsi_sess = sess->dd_data;
115 printk(KERN_INFO "In beiscsi_session_destroy\n");
116 pci_pool_destroy(beiscsi_sess->bhs_pool);
117 iscsi_session_teardown(cls_session);
121 * beiscsi_session_fail(): Closing session with appropriate error
122 * @cls_session: ptr to session
124 void beiscsi_session_fail(struct iscsi_cls_session *cls_session)
126 iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
131 * beiscsi_conn_create - create an instance of iscsi connection
132 * @cls_session: ptr to iscsi_cls_session
135 struct iscsi_cls_conn *
136 beiscsi_conn_create(struct iscsi_cls_session *cls_session, u32 cid)
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;
146 shost = iscsi_session_to_shost(cls_session);
147 phba = iscsi_host_priv(shost);
149 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
150 "BS_%d : In beiscsi_conn_create ,cid"
151 "from iscsi layer=%d\n", cid);
153 cls_conn = iscsi_conn_setup(cls_session, sizeof(*beiscsi_conn), cid);
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;
169 * beiscsi_conn_bind - Binds iscsi session/connection with TCP connection
170 * @cls_session: pointer to iscsi cls session
171 * @cls_conn: pointer to iscsi cls conn
172 * @transport_fd: EP handle(64 bit)
174 * This function binds the TCP Conn with iSCSI Connection and Session.
176 int beiscsi_conn_bind(struct iscsi_cls_session *cls_session,
177 struct iscsi_cls_conn *cls_conn,
178 u64 transport_fd, int is_leading)
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;
190 ep = iscsi_lookup_endpoint(transport_fd);
194 beiscsi_ep = ep->dd_data;
196 if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
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);
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",
215 phba->conn_table[cri_index]);
220 beiscsi_conn->beiscsi_conn_cid = beiscsi_ep->ep_cid;
221 beiscsi_conn->ep = beiscsi_ep;
222 beiscsi_ep->conn = beiscsi_conn;
224 * Each connection is associated with a WRBQ kept in wrb_context.
225 * Store doorbell offset for transmit path.
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;
236 static int beiscsi_iface_create_ipv4(struct beiscsi_hba *phba)
238 if (phba->ipv4_iface)
241 phba->ipv4_iface = iscsi_create_iface(phba->shost,
242 &beiscsi_iscsi_transport,
243 ISCSI_IFACE_TYPE_IPV4,
245 if (!phba->ipv4_iface) {
246 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
248 "create default IPv4 address.\n");
255 static int beiscsi_iface_create_ipv6(struct beiscsi_hba *phba)
257 if (phba->ipv6_iface)
260 phba->ipv6_iface = iscsi_create_iface(phba->shost,
261 &beiscsi_iscsi_transport,
262 ISCSI_IFACE_TYPE_IPV6,
264 if (!phba->ipv6_iface) {
265 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
267 "create default IPv6 address.\n");
274 void beiscsi_iface_create_default(struct beiscsi_hba *phba)
276 struct be_cmd_get_if_info_resp *if_info;
278 if (!beiscsi_if_get_info(phba, BEISCSI_IP_TYPE_V4, &if_info)) {
279 beiscsi_iface_create_ipv4(phba);
283 if (!beiscsi_if_get_info(phba, BEISCSI_IP_TYPE_V6, &if_info)) {
284 beiscsi_iface_create_ipv6(phba);
289 void beiscsi_iface_destroy_default(struct beiscsi_hba *phba)
291 if (phba->ipv6_iface) {
292 iscsi_destroy_iface(phba->ipv6_iface);
293 phba->ipv6_iface = NULL;
295 if (phba->ipv4_iface) {
296 iscsi_destroy_iface(phba->ipv4_iface);
297 phba->ipv4_iface = NULL;
302 * beiscsi_set_vlan_tag()- Set the VLAN TAG
303 * @shost: Scsi Host for the driver instance
304 * @iface_param: Interface paramters
306 * Set the VLAN TAG for the adapter or disable
311 * Failure: Non-Zero Value
314 beiscsi_iface_config_vlan(struct Scsi_Host *shost,
315 struct iscsi_iface_param_info *iface_param)
317 struct beiscsi_hba *phba = iscsi_host_priv(shost);
320 switch (iface_param->param) {
321 case ISCSI_NET_PARAM_VLAN_ENABLED:
323 if (iface_param->value[0] != ISCSI_VLAN_ENABLE)
324 ret = beiscsi_if_set_vlan(phba, BEISCSI_VLAN_DISABLE);
326 case ISCSI_NET_PARAM_VLAN_TAG:
327 ret = beiscsi_if_set_vlan(phba,
328 *((uint16_t *)iface_param->value));
336 beiscsi_iface_config_ipv4(struct Scsi_Host *shost,
337 struct iscsi_iface_param_info *info,
338 void *data, uint32_t dt_len)
340 struct beiscsi_hba *phba = iscsi_host_priv(shost);
341 u8 *ip = NULL, *subnet = NULL, *gw;
345 /* Check the param */
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);
351 iscsi_destroy_iface(phba->ipv4_iface);
352 phba->ipv4_iface = NULL;
355 case ISCSI_NET_PARAM_IPV4_GW:
357 ret = beiscsi_if_set_gw(phba, BEISCSI_IP_TYPE_V4, gw);
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 /* release DHCP IP address */
364 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
367 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
368 "BS_%d : Invalid BOOTPROTO: %d\n",
371 case ISCSI_NET_PARAM_IPV4_ADDR:
373 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
375 info = nla_data(nla);
376 subnet = info->value;
378 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
381 case ISCSI_NET_PARAM_IPV4_SUBNET:
383 * OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR ioctl needs IP
384 * and subnet both. Find IP to be applied for this subnet.
386 subnet = info->value;
387 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
389 info = nla_data(nla);
392 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V4,
401 beiscsi_iface_config_ipv6(struct Scsi_Host *shost,
402 struct iscsi_iface_param_info *iface_param,
403 void *data, uint32_t dt_len)
405 struct beiscsi_hba *phba = iscsi_host_priv(shost);
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);
413 iscsi_destroy_iface(phba->ipv6_iface);
414 phba->ipv6_iface = NULL;
417 case ISCSI_NET_PARAM_IPV6_ADDR:
418 ret = beiscsi_if_en_static(phba, BEISCSI_IP_TYPE_V6,
419 iface_param->value, NULL);
426 int beiscsi_iface_set_param(struct Scsi_Host *shost,
427 void *data, uint32_t dt_len)
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;
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);
441 /* update interface_handle */
442 ret = beiscsi_if_get_handle(phba);
444 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
445 "BS_%d : Getting Interface Handle Failed\n");
449 nla_for_each_attr(attrib, data, dt_len, rm_len) {
450 iface_param = nla_data(attrib);
452 if (iface_param->param_type != ISCSI_NET_PARAM)
456 * BE2ISCSI only supports 1 interface
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);
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);
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);
479 switch (iface_param->iface_type) {
480 case ISCSI_IFACE_TYPE_IPV4:
481 ret = beiscsi_iface_config_ipv4(shost,
485 case ISCSI_IFACE_TYPE_IPV6:
486 ret = beiscsi_iface_config_ipv6(shost,
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",
508 static int __beiscsi_iface_get_param(struct beiscsi_hba *phba,
509 struct iscsi_iface *iface,
510 int param, char *buf)
512 struct be_cmd_get_if_info_resp *if_info;
513 int len, ip_type = BEISCSI_IP_TYPE_V4;
515 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
516 ip_type = BEISCSI_IP_TYPE_V6;
518 len = beiscsi_if_get_info(phba, ip_type, &if_info);
523 case ISCSI_NET_PARAM_IPV4_ADDR:
524 len = sprintf(buf, "%pI4\n", if_info->ip_addr.addr);
526 case ISCSI_NET_PARAM_IPV6_ADDR:
527 len = sprintf(buf, "%pI6\n", if_info->ip_addr.addr);
529 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
530 if (!if_info->dhcp_state)
531 len = sprintf(buf, "static\n");
533 len = sprintf(buf, "dhcp\n");
535 case ISCSI_NET_PARAM_IPV4_SUBNET:
536 len = sprintf(buf, "%pI4\n", if_info->ip_addr.subnet_mask);
538 case ISCSI_NET_PARAM_VLAN_ENABLED:
539 len = sprintf(buf, "%s\n",
540 (if_info->vlan_priority == BEISCSI_VLAN_DISABLE) ?
541 "disable" : "enable");
543 case ISCSI_NET_PARAM_VLAN_ID:
544 if (if_info->vlan_priority == BEISCSI_VLAN_DISABLE)
547 len = sprintf(buf, "%d\n",
548 (if_info->vlan_priority &
551 case ISCSI_NET_PARAM_VLAN_PRIORITY:
552 if (if_info->vlan_priority == BEISCSI_VLAN_DISABLE)
555 len = sprintf(buf, "%d\n",
556 ((if_info->vlan_priority >> 13) &
557 ISCSI_MAX_VLAN_PRIORITY));
567 int beiscsi_iface_get_param(struct iscsi_iface *iface,
568 enum iscsi_param_type param_type,
569 int param, char *buf)
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;
576 if (param_type != ISCSI_NET_PARAM)
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);
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);
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");
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);
606 len = sprintf(buf, "%pI4\n", &gateway.ip_addr.addr);
614 * beiscsi_ep_get_param - get the iscsi parameter
615 * @ep: pointer to iscsi ep
616 * @param: parameter type identifier
617 * @buf: buffer pointer
619 * returns iscsi parameter
621 int beiscsi_ep_get_param(struct iscsi_endpoint *ep,
622 enum iscsi_param param, char *buf)
624 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
627 beiscsi_log(beiscsi_ep->phba, KERN_INFO,
629 "BS_%d : In beiscsi_ep_get_param,"
630 " param= %d\n", param);
633 case ISCSI_PARAM_CONN_PORT:
634 len = sprintf(buf, "%hu\n", beiscsi_ep->dst_tcpport);
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);
640 len = sprintf(buf, "%pI6\n", &beiscsi_ep->dst6_addr);
648 int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
649 enum iscsi_param param, char *buf, int buflen)
651 struct iscsi_conn *conn = cls_conn->dd_data;
652 struct iscsi_session *session = conn->session;
653 struct beiscsi_hba *phba = NULL;
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);
661 ret = iscsi_set_param(cls_conn, param, buf, buflen);
665 * If userspace tried to set the value to higher than we can
666 * support override here.
669 case ISCSI_PARAM_FIRST_BURST:
670 if (session->first_burst > 8192)
671 session->first_burst = 8192;
673 case ISCSI_PARAM_MAX_RECV_DLENGTH:
674 if (conn->max_recv_dlength > 65536)
675 conn->max_recv_dlength = 65536;
677 case ISCSI_PARAM_MAX_BURST:
678 if (session->max_burst > 262144)
679 session->max_burst = 262144;
681 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
682 if (conn->max_xmit_dlength > 65536)
683 conn->max_xmit_dlength = 65536;
692 * beiscsi_get_initname - Read Initiator Name from flash
693 * @buf: buffer bointer
694 * @phba: The device priv structure instance
696 * returns number of bytes
698 static int beiscsi_get_initname(char *buf, struct beiscsi_hba *phba)
702 struct be_mcc_wrb *wrb;
703 struct be_cmd_hba_name *resp;
705 tag = be_cmd_get_initname(phba);
707 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
708 "BS_%d : Getting Initiator Name Failed\n");
713 rc = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL);
715 beiscsi_log(phba, KERN_ERR,
716 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
717 "BS_%d : Initiator Name MBX Failed\n");
721 resp = embedded_payload(wrb);
722 rc = sprintf(buf, "%s\n", resp->initiator_name);
727 * beiscsi_get_port_state - Get the Port State
728 * @shost : pointer to scsi_host structure
731 static void beiscsi_get_port_state(struct Scsi_Host *shost)
733 struct beiscsi_hba *phba = iscsi_host_priv(shost);
734 struct iscsi_cls_host *ihost = shost->shost_data;
736 ihost->port_state = test_bit(BEISCSI_HBA_LINK_UP, &phba->state) ?
737 ISCSI_PORT_STATE_UP : ISCSI_PORT_STATE_DOWN;
741 * beiscsi_get_port_speed - Get the Port Speed from Adapter
742 * @shost : pointer to scsi_host structure
745 static void beiscsi_get_port_speed(struct Scsi_Host *shost)
747 struct beiscsi_hba *phba = iscsi_host_priv(shost);
748 struct iscsi_cls_host *ihost = shost->shost_data;
750 switch (phba->port_speed) {
751 case BE2ISCSI_LINK_SPEED_10MBPS:
752 ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
754 case BE2ISCSI_LINK_SPEED_100MBPS:
755 ihost->port_speed = ISCSI_PORT_SPEED_100MBPS;
757 case BE2ISCSI_LINK_SPEED_1GBPS:
758 ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
760 case BE2ISCSI_LINK_SPEED_10GBPS:
761 ihost->port_speed = ISCSI_PORT_SPEED_10GBPS;
763 case BE2ISCSI_LINK_SPEED_25GBPS:
764 ihost->port_speed = ISCSI_PORT_SPEED_25GBPS;
766 case BE2ISCSI_LINK_SPEED_40GBPS:
767 ihost->port_speed = ISCSI_PORT_SPEED_40GBPS;
770 ihost->port_speed = ISCSI_PORT_SPEED_UNKNOWN;
775 * beiscsi_get_host_param - get the iscsi parameter
776 * @shost: pointer to scsi_host structure
777 * @param: parameter type identifier
778 * @buf: buffer pointer
780 * returns host parameter
782 int beiscsi_get_host_param(struct Scsi_Host *shost,
783 enum iscsi_host_param param, char *buf)
785 struct beiscsi_hba *phba = iscsi_host_priv(shost);
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);
793 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
794 "BS_%d : In beiscsi_get_host_param, param = %d\n", param);
797 case ISCSI_HOST_PARAM_HWADDRESS:
798 status = beiscsi_get_macaddr(buf, phba);
800 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
801 "BS_%d : beiscsi_get_macaddr Failed\n");
805 case ISCSI_HOST_PARAM_INITIATOR_NAME:
806 status = beiscsi_get_initname(buf, phba);
808 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
809 "BS_%d : Retreiving Initiator Name Failed\n");
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));
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));
822 return iscsi_host_get_param(shost, param, buf);
827 int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
829 struct be_cmd_get_nic_conf_resp resp;
832 if (phba->mac_addr_set)
833 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
835 memset(&resp, 0, sizeof(resp));
836 rc = mgmt_get_nic_conf(phba, &resp);
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);
846 * beiscsi_conn_get_stats - get the iscsi stats
847 * @cls_conn: pointer to iscsi cls conn
848 * @stats: pointer to iscsi_stats structure
850 * returns iscsi stats
852 void beiscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn,
853 struct iscsi_stats *stats)
855 struct iscsi_conn *conn = cls_conn->dd_data;
856 struct beiscsi_hba *phba = NULL;
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");
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;
879 * beiscsi_set_params_for_offld - get the parameters for offload
880 * @beiscsi_conn: pointer to beiscsi_conn
881 * @params: pointer to offload_params structure
883 static void beiscsi_set_params_for_offld(struct beiscsi_conn *beiscsi_conn,
884 struct beiscsi_offload_params *params)
886 struct iscsi_conn *conn = beiscsi_conn->conn;
887 struct iscsi_session *session = conn->session;
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,
898 AMAP_SET_BITS(struct amap_beiscsi_offload_params, dde, params,
900 AMAP_SET_BITS(struct amap_beiscsi_offload_params, hde, params,
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,
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);
923 * beiscsi_conn_start - offload of session to chip
924 * @cls_conn: pointer to beiscsi_conn
926 int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
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;
934 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
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);
941 beiscsi_log(beiscsi_conn->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
942 "BS_%d : In beiscsi_conn_start\n");
944 memset(¶ms, 0, sizeof(struct beiscsi_offload_params));
945 beiscsi_ep = beiscsi_conn->ep;
947 beiscsi_log(beiscsi_conn->phba, KERN_ERR,
949 "BS_%d : In beiscsi_conn_start , no beiscsi_ep\n");
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);
959 * beiscsi_get_cid - Allocate a cid
960 * @phba: The phba instance
962 static int beiscsi_get_cid(struct beiscsi_hba *phba)
964 uint16_t cid_avlbl_ulp0, cid_avlbl_ulp1;
965 unsigned short cid, cid_from_ulp;
966 struct ulp_cid_info *cid_info;
968 /* Find the ULP which has more CID available */
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;
976 * If iSCSI protocol is loaded only on ULP 0, and when cid_avlbl_ulp
977 * is ZERO for both, ULP 1 is returned.
978 * Check if ULP is loaded before getting new CID.
980 if (!test_bit(cid_from_ulp, (void *)&phba->fw_config.ulp_supported))
981 return BE_INVALID_CID;
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;
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--;
1000 * beiscsi_put_cid - Free the cid
1001 * @phba: The phba for which the cid is being freed
1002 * @cid: The cid to free
1004 static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
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;
1012 phwi_ctrlr = phba->phwi_ctrlr;
1013 pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
1014 cid_post_ulp = pwrb_context->ulp_num;
1016 cid_info = phba->cid_array_info[cid_post_ulp];
1017 /* fill only in empty slot */
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);
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++;
1031 * beiscsi_free_ep - free endpoint
1032 * @ep: pointer to iscsi endpoint structure
1034 static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
1036 struct beiscsi_hba *phba = beiscsi_ep->phba;
1037 struct beiscsi_conn *beiscsi_conn;
1039 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1040 beiscsi_ep->phba = NULL;
1041 /* clear this to track freeing in beiscsi_ep_disconnect */
1042 phba->ep_array[BE_GET_CRI_FROM_CID(beiscsi_ep->ep_cid)] = NULL;
1045 * Check if any connection resource allocated by driver
1046 * is to be freed.This case occurs when target redirection
1047 * or connection retry is done.
1049 if (!beiscsi_ep->conn)
1052 beiscsi_conn = beiscsi_ep->conn;
1054 * Break ep->conn link here so that completions after
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;
1066 * beiscsi_open_conn - Ask FW to open a TCP connection
1067 * @ep: endpoint to be used
1068 * @src_addr: The source IP address
1069 * @dst_addr: The Destination IP address
1071 * Asks the FW to open a TCP connection
1073 static int beiscsi_open_conn(struct iscsi_endpoint *ep,
1074 struct sockaddr *src_addr,
1075 struct sockaddr *dst_addr, int non_blocking)
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;
1084 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1085 "BS_%d : In beiscsi_open_conn\n");
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");
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);
1098 phba->ep_array[BE_GET_CRI_FROM_CID
1099 (beiscsi_ep->ep_cid)] = ep;
1101 beiscsi_ep->cid_vld = 0;
1103 if (is_chip_be2_be3r(phba))
1104 req_memsize = sizeof(struct tcp_connect_and_offload_in);
1106 req_memsize = sizeof(struct tcp_connect_and_offload_in_v1);
1108 nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
1111 if (nonemb_cmd.va == NULL) {
1113 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1114 "BS_%d : Failed to allocate memory for"
1115 " mgmt_open_connection\n");
1117 beiscsi_free_ep(beiscsi_ep);
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);
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);
1128 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1129 nonemb_cmd.va, nonemb_cmd.dma);
1130 beiscsi_free_ep(beiscsi_ep);
1134 ret = beiscsi_mccq_compl_wait(phba, tag, NULL, &nonemb_cmd);
1136 beiscsi_log(phba, KERN_ERR,
1137 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
1138 "BS_%d : mgmt_open_connection Failed");
1141 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1142 nonemb_cmd.va, nonemb_cmd.dma);
1144 beiscsi_free_ep(beiscsi_ep);
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");
1155 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1156 nonemb_cmd.va, nonemb_cmd.dma);
1161 * beiscsi_ep_connect - Ask chip to create TCP Conn
1162 * @scsi_host: Pointer to scsi_host structure
1163 * @dst_addr: The IP address of Target
1164 * @non_blocking: blocking or non-blocking call
1166 * This routines first asks chip to create a connection and then allocates an EP
1168 struct iscsi_endpoint *
1169 beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1172 struct beiscsi_hba *phba;
1173 struct beiscsi_endpoint *beiscsi_ep;
1174 struct iscsi_endpoint *ep;
1179 pr_err("beiscsi_ep_connect shost is NULL\n");
1180 return ERR_PTR(ret);
1183 phba = iscsi_host_priv(shost);
1184 if (!beiscsi_hba_is_online(phba)) {
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);
1190 if (!test_bit(BEISCSI_HBA_LINK_UP, &phba->state)) {
1192 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1193 "BS_%d : The Adapter Port state is Down!!!\n");
1194 return ERR_PTR(ret);
1197 ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
1200 return ERR_PTR(ret);
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);
1208 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1209 "BS_%d : Failed in beiscsi_open_conn\n");
1216 iscsi_destroy_endpoint(ep);
1217 return ERR_PTR(ret);
1221 * beiscsi_ep_poll - Poll to see if connection is established
1222 * @ep: endpoint to be used
1223 * @timeout_ms: timeout specified in millisecs
1225 * Poll to see if TCP connection established
1227 int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1229 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1231 beiscsi_log(beiscsi_ep->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1232 "BS_%d : In beiscsi_ep_poll\n");
1234 if (beiscsi_ep->cid_vld == 1)
1241 * beiscsi_flush_cq()- Flush the CQ created.
1242 * @phba: ptr device priv structure.
1244 * Before the connection resource are freed flush
1245 * all the CQ enteries
1247 static void beiscsi_flush_cq(struct beiscsi_hba *phba)
1250 struct be_eq_obj *pbe_eq;
1251 struct hwi_controller *phwi_ctrlr;
1252 struct hwi_context_memory *phwi_context;
1254 phwi_ctrlr = phba->phwi_ctrlr;
1255 phwi_context = phwi_ctrlr->phwi_ctxt;
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);
1266 * beiscsi_close_conn - Upload the connection
1267 * @ep: The iscsi endpoint
1268 * @flag: The type of connection closure
1270 static int beiscsi_close_conn(struct beiscsi_endpoint *beiscsi_ep, int flag)
1274 struct beiscsi_hba *phba = beiscsi_ep->phba;
1276 tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
1278 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1279 "BS_%d : upload failed for cid 0x%x\n",
1280 beiscsi_ep->ep_cid);
1285 ret = beiscsi_mccq_compl_wait(phba, tag, NULL, NULL);
1287 /* Flush the CQ entries */
1288 beiscsi_flush_cq(phba);
1294 * beiscsi_ep_disconnect - Tears down the TCP connection
1295 * @ep: endpoint to be used
1297 * Tears down the TCP connection
1299 void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
1301 struct beiscsi_conn *beiscsi_conn;
1302 struct beiscsi_endpoint *beiscsi_ep;
1303 struct beiscsi_hba *phba;
1305 uint8_t mgmt_invalidate_flag, tcp_upload_flag;
1306 unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
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);
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",
1320 beiscsi_ep->ep_cid);
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;
1330 mgmt_invalidate_flag = BEISCSI_NO_RST_ISSUE;
1331 tcp_upload_flag = CONNECTION_UPLOAD_ABORT;
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);
1340 tag = mgmt_invalidate_connection(phba, beiscsi_ep,
1342 mgmt_invalidate_flag,
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);
1350 beiscsi_mccq_compl_wait(phba, tag, NULL, NULL);
1351 beiscsi_close_conn(beiscsi_ep, tcp_upload_flag);
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",
1359 beiscsi_ep->ep_cid);
1360 phba->conn_table[cri_index] = NULL;
1361 iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
1364 umode_t beiscsi_attr_is_visible(int param_type, int param)
1366 switch (param_type) {
1367 case ISCSI_NET_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:
1382 case ISCSI_HOST_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:
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: