2 * Copyright (C) 2005 - 2012 Emulex
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@emulex.com)
12 * Contact Information:
13 * linux-drivers@emulex.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;
56 "beiscsi_session_create: invalid ep\n");
59 beiscsi_ep = ep->dd_data;
60 phba = beiscsi_ep->phba;
63 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
64 "BS_%d : In beiscsi_session_create\n");
66 if (cmds_max > beiscsi_ep->phba->params.wrbs_per_cxn) {
67 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
68 "BS_%d : Cannot handle %d cmds."
69 "Max cmds per session supported is %d. Using %d."
71 beiscsi_ep->phba->params.wrbs_per_cxn,
72 beiscsi_ep->phba->params.wrbs_per_cxn);
74 cmds_max = beiscsi_ep->phba->params.wrbs_per_cxn;
77 cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
79 sizeof(*beiscsi_sess),
81 initial_cmdsn, ISCSI_MAX_TARGET);
84 sess = cls_session->dd_data;
85 beiscsi_sess = sess->dd_data;
86 beiscsi_sess->bhs_pool = pci_pool_create("beiscsi_bhs_pool",
88 sizeof(struct be_cmd_bhs),
90 if (!beiscsi_sess->bhs_pool)
95 iscsi_session_teardown(cls_session);
100 * beiscsi_session_destroy - destroys iscsi session
101 * @cls_session: pointer to iscsi cls session
103 * Destroys iSCSI session instance and releases
104 * resources allocated for it.
106 void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
108 struct iscsi_session *sess = cls_session->dd_data;
109 struct beiscsi_session *beiscsi_sess = sess->dd_data;
111 printk(KERN_INFO "In beiscsi_session_destroy\n");
112 pci_pool_destroy(beiscsi_sess->bhs_pool);
113 iscsi_session_teardown(cls_session);
117 * beiscsi_conn_create - create an instance of iscsi connection
118 * @cls_session: ptr to iscsi_cls_session
121 struct iscsi_cls_conn *
122 beiscsi_conn_create(struct iscsi_cls_session *cls_session, u32 cid)
124 struct beiscsi_hba *phba;
125 struct Scsi_Host *shost;
126 struct iscsi_cls_conn *cls_conn;
127 struct beiscsi_conn *beiscsi_conn;
128 struct iscsi_conn *conn;
129 struct iscsi_session *sess;
130 struct beiscsi_session *beiscsi_sess;
132 shost = iscsi_session_to_shost(cls_session);
133 phba = iscsi_host_priv(shost);
135 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
136 "BS_%d : In beiscsi_conn_create ,cid"
137 "from iscsi layer=%d\n", cid);
139 cls_conn = iscsi_conn_setup(cls_session, sizeof(*beiscsi_conn), cid);
143 conn = cls_conn->dd_data;
144 beiscsi_conn = conn->dd_data;
145 beiscsi_conn->ep = NULL;
146 beiscsi_conn->phba = phba;
147 beiscsi_conn->conn = conn;
148 sess = cls_session->dd_data;
149 beiscsi_sess = sess->dd_data;
150 beiscsi_conn->beiscsi_sess = beiscsi_sess;
155 * beiscsi_bindconn_cid - Bind the beiscsi_conn with phba connection table
156 * @beiscsi_conn: The pointer to beiscsi_conn structure
157 * @phba: The phba instance
158 * @cid: The cid to free
160 static int beiscsi_bindconn_cid(struct beiscsi_hba *phba,
161 struct beiscsi_conn *beiscsi_conn,
164 if (phba->conn_table[cid]) {
165 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
166 "BS_%d : Connection table already occupied. Detected clash\n");
170 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
171 "BS_%d : phba->conn_table[%d]=%p(beiscsi_conn)\n",
174 phba->conn_table[cid] = beiscsi_conn;
180 * beiscsi_conn_bind - Binds iscsi session/connection with TCP connection
181 * @cls_session: pointer to iscsi cls session
182 * @cls_conn: pointer to iscsi cls conn
183 * @transport_fd: EP handle(64 bit)
185 * This function binds the TCP Conn with iSCSI Connection and Session.
187 int beiscsi_conn_bind(struct iscsi_cls_session *cls_session,
188 struct iscsi_cls_conn *cls_conn,
189 u64 transport_fd, int is_leading)
191 struct iscsi_conn *conn = cls_conn->dd_data;
192 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
193 struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
194 struct beiscsi_hba *phba = iscsi_host_priv(shost);
195 struct beiscsi_endpoint *beiscsi_ep;
196 struct iscsi_endpoint *ep;
198 ep = iscsi_lookup_endpoint(transport_fd);
202 beiscsi_ep = ep->dd_data;
204 if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
207 if (beiscsi_ep->phba != phba) {
208 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
209 "BS_%d : beiscsi_ep->hba=%p not equal to phba=%p\n",
210 beiscsi_ep->phba, phba);
215 beiscsi_conn->beiscsi_conn_cid = beiscsi_ep->ep_cid;
216 beiscsi_conn->ep = beiscsi_ep;
217 beiscsi_ep->conn = beiscsi_conn;
219 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
220 "BS_%d : beiscsi_conn=%p conn=%p ep_cid=%d\n",
221 beiscsi_conn, conn, beiscsi_ep->ep_cid);
223 return beiscsi_bindconn_cid(phba, beiscsi_conn, beiscsi_ep->ep_cid);
226 static int beiscsi_create_ipv4_iface(struct beiscsi_hba *phba)
228 if (phba->ipv4_iface)
231 phba->ipv4_iface = iscsi_create_iface(phba->shost,
232 &beiscsi_iscsi_transport,
233 ISCSI_IFACE_TYPE_IPV4,
235 if (!phba->ipv4_iface) {
236 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
238 "create default IPv4 address.\n");
245 static int beiscsi_create_ipv6_iface(struct beiscsi_hba *phba)
247 if (phba->ipv6_iface)
250 phba->ipv6_iface = iscsi_create_iface(phba->shost,
251 &beiscsi_iscsi_transport,
252 ISCSI_IFACE_TYPE_IPV6,
254 if (!phba->ipv6_iface) {
255 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
257 "create default IPv6 address.\n");
264 void beiscsi_create_def_ifaces(struct beiscsi_hba *phba)
266 struct be_cmd_get_if_info_resp if_info;
268 if (!mgmt_get_if_info(phba, BE2_IPV4, &if_info))
269 beiscsi_create_ipv4_iface(phba);
271 if (!mgmt_get_if_info(phba, BE2_IPV6, &if_info))
272 beiscsi_create_ipv6_iface(phba);
275 void beiscsi_destroy_def_ifaces(struct beiscsi_hba *phba)
277 if (phba->ipv6_iface)
278 iscsi_destroy_iface(phba->ipv6_iface);
279 if (phba->ipv4_iface)
280 iscsi_destroy_iface(phba->ipv4_iface);
284 beiscsi_set_static_ip(struct Scsi_Host *shost,
285 struct iscsi_iface_param_info *iface_param,
286 void *data, uint32_t dt_len)
288 struct beiscsi_hba *phba = iscsi_host_priv(shost);
289 struct iscsi_iface_param_info *iface_ip = NULL;
290 struct iscsi_iface_param_info *iface_subnet = NULL;
295 switch (iface_param->param) {
296 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
297 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
299 iface_ip = nla_data(nla);
301 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
303 iface_subnet = nla_data(nla);
305 case ISCSI_NET_PARAM_IPV4_ADDR:
306 iface_ip = iface_param;
307 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
309 iface_subnet = nla_data(nla);
311 case ISCSI_NET_PARAM_IPV4_SUBNET:
312 iface_subnet = iface_param;
313 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
315 iface_ip = nla_data(nla);
318 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
319 "BS_%d : Unsupported param %d\n",
323 if (!iface_ip || !iface_subnet) {
324 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
325 "BS_%d : IP and Subnet Mask required\n");
329 ret = mgmt_set_ip(phba, iface_ip, iface_subnet,
330 ISCSI_BOOTPROTO_STATIC);
336 * beiscsi_set_vlan_tag()- Set the VLAN TAG
337 * @shost: Scsi Host for the driver instance
338 * @iface_param: Interface paramters
340 * Set the VLAN TAG for the adapter or disable
345 * Failure: Non-Zero Value
348 beiscsi_set_vlan_tag(struct Scsi_Host *shost,
349 struct iscsi_iface_param_info *iface_param)
351 struct beiscsi_hba *phba = iscsi_host_priv(shost);
354 /* Get the Interface Handle */
355 if (mgmt_get_all_if_id(phba)) {
356 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
357 "BS_%d : Getting Interface Handle Failed\n");
361 switch (iface_param->param) {
362 case ISCSI_NET_PARAM_VLAN_ENABLED:
363 if (iface_param->value[0] != ISCSI_VLAN_ENABLE)
364 ret = mgmt_set_vlan(phba, BEISCSI_VLAN_DISABLE);
366 case ISCSI_NET_PARAM_VLAN_TAG:
367 ret = mgmt_set_vlan(phba,
368 *((uint16_t *)iface_param->value));
371 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
372 "BS_%d : Unknown Param Type : %d\n",
381 beiscsi_set_ipv4(struct Scsi_Host *shost,
382 struct iscsi_iface_param_info *iface_param,
383 void *data, uint32_t dt_len)
385 struct beiscsi_hba *phba = iscsi_host_priv(shost);
388 /* Check the param */
389 switch (iface_param->param) {
390 case ISCSI_NET_PARAM_IPV4_GW:
391 ret = mgmt_set_gateway(phba, iface_param);
393 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
394 if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP)
395 ret = mgmt_set_ip(phba, iface_param,
396 NULL, ISCSI_BOOTPROTO_DHCP);
397 else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC)
398 ret = beiscsi_set_static_ip(shost, iface_param,
401 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
402 "BS_%d : Invalid BOOTPROTO: %d\n",
403 iface_param->value[0]);
405 case ISCSI_NET_PARAM_IFACE_ENABLE:
406 if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
407 ret = beiscsi_create_ipv4_iface(phba);
409 iscsi_destroy_iface(phba->ipv4_iface);
411 case ISCSI_NET_PARAM_IPV4_SUBNET:
412 case ISCSI_NET_PARAM_IPV4_ADDR:
413 ret = beiscsi_set_static_ip(shost, iface_param,
416 case ISCSI_NET_PARAM_VLAN_ENABLED:
417 case ISCSI_NET_PARAM_VLAN_TAG:
418 ret = beiscsi_set_vlan_tag(shost, iface_param);
421 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
422 "BS_%d : Param %d not supported\n",
430 beiscsi_set_ipv6(struct Scsi_Host *shost,
431 struct iscsi_iface_param_info *iface_param,
432 void *data, uint32_t dt_len)
434 struct beiscsi_hba *phba = iscsi_host_priv(shost);
437 switch (iface_param->param) {
438 case ISCSI_NET_PARAM_IFACE_ENABLE:
439 if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
440 ret = beiscsi_create_ipv6_iface(phba);
442 iscsi_destroy_iface(phba->ipv6_iface);
446 case ISCSI_NET_PARAM_IPV6_ADDR:
447 ret = mgmt_set_ip(phba, iface_param, NULL,
448 ISCSI_BOOTPROTO_STATIC);
451 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
452 "BS_%d : Param %d not supported\n",
459 int be2iscsi_iface_set_param(struct Scsi_Host *shost,
460 void *data, uint32_t dt_len)
462 struct iscsi_iface_param_info *iface_param = NULL;
463 struct beiscsi_hba *phba = iscsi_host_priv(shost);
464 struct nlattr *attrib;
465 uint32_t rm_len = dt_len;
468 nla_for_each_attr(attrib, data, dt_len, rm_len) {
469 iface_param = nla_data(attrib);
471 if (iface_param->param_type != ISCSI_NET_PARAM)
475 * BE2ISCSI only supports 1 interface
477 if (iface_param->iface_num) {
478 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
479 "BS_%d : Invalid iface_num %d."
480 "Only iface_num 0 is supported.\n",
481 iface_param->iface_num);
486 switch (iface_param->iface_type) {
487 case ISCSI_IFACE_TYPE_IPV4:
488 ret = beiscsi_set_ipv4(shost, iface_param,
491 case ISCSI_IFACE_TYPE_IPV6:
492 ret = beiscsi_set_ipv6(shost, iface_param,
496 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
497 "BS_%d : Invalid iface type :%d passed\n",
498 iface_param->iface_type);
509 static int be2iscsi_get_if_param(struct beiscsi_hba *phba,
510 struct iscsi_iface *iface, int param,
513 struct be_cmd_get_if_info_resp if_info;
514 int len, ip_type = BE2_IPV4;
516 memset(&if_info, 0, sizeof(if_info));
518 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
521 len = mgmt_get_if_info(phba, ip_type, &if_info);
526 case ISCSI_NET_PARAM_IPV4_ADDR:
527 len = sprintf(buf, "%pI4\n", &if_info.ip_addr.addr);
529 case ISCSI_NET_PARAM_IPV6_ADDR:
530 len = sprintf(buf, "%pI6\n", &if_info.ip_addr.addr);
532 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
533 if (!if_info.dhcp_state)
534 len = sprintf(buf, "static\n");
536 len = sprintf(buf, "dhcp\n");
538 case ISCSI_NET_PARAM_IPV4_SUBNET:
539 len = sprintf(buf, "%pI4\n", &if_info.ip_addr.subnet_mask);
541 case ISCSI_NET_PARAM_VLAN_ENABLED:
542 len = sprintf(buf, "%s\n",
543 (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
544 ? "Disabled\n" : "Enabled\n");
546 case ISCSI_NET_PARAM_VLAN_ID:
547 if (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
550 len = sprintf(buf, "%d\n",
551 (if_info.vlan_priority &
554 case ISCSI_NET_PARAM_VLAN_PRIORITY:
555 if (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
558 len = sprintf(buf, "%d\n",
559 ((if_info.vlan_priority >> 13) &
560 ISCSI_MAX_VLAN_PRIORITY));
569 int be2iscsi_iface_get_param(struct iscsi_iface *iface,
570 enum iscsi_param_type param_type,
571 int param, char *buf)
573 struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
574 struct beiscsi_hba *phba = iscsi_host_priv(shost);
575 struct be_cmd_get_def_gateway_resp gateway;
579 case ISCSI_NET_PARAM_IPV4_ADDR:
580 case ISCSI_NET_PARAM_IPV4_SUBNET:
581 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
582 case ISCSI_NET_PARAM_IPV6_ADDR:
583 case ISCSI_NET_PARAM_VLAN_ENABLED:
584 case ISCSI_NET_PARAM_VLAN_ID:
585 case ISCSI_NET_PARAM_VLAN_PRIORITY:
586 len = be2iscsi_get_if_param(phba, iface, param, buf);
588 case ISCSI_NET_PARAM_IFACE_ENABLE:
589 len = sprintf(buf, "enabled\n");
591 case ISCSI_NET_PARAM_IPV4_GW:
592 memset(&gateway, 0, sizeof(gateway));
593 len = mgmt_get_gateway(phba, BE2_IPV4, &gateway);
595 len = sprintf(buf, "%pI4\n", &gateway.ip_addr.addr);
605 * beiscsi_ep_get_param - get the iscsi parameter
606 * @ep: pointer to iscsi ep
607 * @param: parameter type identifier
608 * @buf: buffer pointer
610 * returns iscsi parameter
612 int beiscsi_ep_get_param(struct iscsi_endpoint *ep,
613 enum iscsi_param param, char *buf)
615 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
618 beiscsi_log(beiscsi_ep->phba, KERN_INFO,
620 "BS_%d : In beiscsi_ep_get_param,"
621 " param= %d\n", param);
624 case ISCSI_PARAM_CONN_PORT:
625 len = sprintf(buf, "%hu\n", beiscsi_ep->dst_tcpport);
627 case ISCSI_PARAM_CONN_ADDRESS:
628 if (beiscsi_ep->ip_type == BE2_IPV4)
629 len = sprintf(buf, "%pI4\n", &beiscsi_ep->dst_addr);
631 len = sprintf(buf, "%pI6\n", &beiscsi_ep->dst6_addr);
639 int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
640 enum iscsi_param param, char *buf, int buflen)
642 struct iscsi_conn *conn = cls_conn->dd_data;
643 struct iscsi_session *session = conn->session;
644 struct beiscsi_hba *phba = NULL;
647 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
648 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
649 "BS_%d : In beiscsi_conn_set_param,"
650 " param= %d\n", param);
652 ret = iscsi_set_param(cls_conn, param, buf, buflen);
656 * If userspace tried to set the value to higher than we can
657 * support override here.
660 case ISCSI_PARAM_FIRST_BURST:
661 if (session->first_burst > 8192)
662 session->first_burst = 8192;
664 case ISCSI_PARAM_MAX_RECV_DLENGTH:
665 if (conn->max_recv_dlength > 65536)
666 conn->max_recv_dlength = 65536;
668 case ISCSI_PARAM_MAX_BURST:
669 if (session->max_burst > 262144)
670 session->max_burst = 262144;
672 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
673 if ((conn->max_xmit_dlength > 65536) ||
674 (conn->max_xmit_dlength == 0))
675 conn->max_xmit_dlength = 65536;
684 * beiscsi_get_initname - Read Initiator Name from flash
685 * @buf: buffer bointer
686 * @phba: The device priv structure instance
688 * returns number of bytes
690 static int beiscsi_get_initname(char *buf, struct beiscsi_hba *phba)
694 struct be_mcc_wrb *wrb;
695 struct be_cmd_hba_name *resp;
697 tag = be_cmd_get_initname(phba);
699 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
700 "BS_%d : Getting Initiator Name Failed\n");
705 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
707 beiscsi_log(phba, KERN_ERR,
708 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
709 "BS_%d : Initiator Name MBX Failed\n");
713 resp = embedded_payload(wrb);
714 rc = sprintf(buf, "%s\n", resp->initiator_name);
719 * beiscsi_get_port_state - Get the Port State
720 * @shost : pointer to scsi_host structure
723 static void beiscsi_get_port_state(struct Scsi_Host *shost)
725 struct beiscsi_hba *phba = iscsi_host_priv(shost);
726 struct iscsi_cls_host *ihost = shost->shost_data;
728 ihost->port_state = (phba->state == BE_ADAPTER_UP) ?
729 ISCSI_PORT_STATE_UP : ISCSI_PORT_STATE_DOWN;
733 * beiscsi_get_port_speed - Get the Port Speed from Adapter
734 * @shost : pointer to scsi_host structure
736 * returns Success/Failure
738 static int beiscsi_get_port_speed(struct Scsi_Host *shost)
742 struct be_mcc_wrb *wrb;
743 struct be_cmd_ntwk_link_status_resp *resp;
744 struct beiscsi_hba *phba = iscsi_host_priv(shost);
745 struct iscsi_cls_host *ihost = shost->shost_data;
747 tag = be_cmd_get_port_speed(phba);
749 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
750 "BS_%d : Getting Port Speed Failed\n");
754 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
756 beiscsi_log(phba, KERN_ERR,
757 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
758 "BS_%d : Port Speed MBX Failed\n");
761 resp = embedded_payload(wrb);
763 switch (resp->mac_speed) {
764 case BE2ISCSI_LINK_SPEED_10MBPS:
765 ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
767 case BE2ISCSI_LINK_SPEED_100MBPS:
768 ihost->port_speed = BE2ISCSI_LINK_SPEED_100MBPS;
770 case BE2ISCSI_LINK_SPEED_1GBPS:
771 ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
773 case BE2ISCSI_LINK_SPEED_10GBPS:
774 ihost->port_speed = ISCSI_PORT_SPEED_10GBPS;
777 ihost->port_speed = ISCSI_PORT_SPEED_UNKNOWN;
783 * beiscsi_get_host_param - get the iscsi parameter
784 * @shost: pointer to scsi_host structure
785 * @param: parameter type identifier
786 * @buf: buffer pointer
788 * returns host parameter
790 int beiscsi_get_host_param(struct Scsi_Host *shost,
791 enum iscsi_host_param param, char *buf)
793 struct beiscsi_hba *phba = iscsi_host_priv(shost);
796 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
797 "BS_%d : In beiscsi_get_host_param,"
798 " param= %d\n", param);
801 case ISCSI_HOST_PARAM_HWADDRESS:
802 status = beiscsi_get_macaddr(buf, phba);
804 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
805 "BS_%d : beiscsi_get_macaddr Failed\n");
809 case ISCSI_HOST_PARAM_INITIATOR_NAME:
810 status = beiscsi_get_initname(buf, phba);
812 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
813 "BS_%d : Retreiving Initiator Name Failed\n");
817 case ISCSI_HOST_PARAM_PORT_STATE:
818 beiscsi_get_port_state(shost);
819 status = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
821 case ISCSI_HOST_PARAM_PORT_SPEED:
822 status = beiscsi_get_port_speed(shost);
824 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
825 "BS_%d : Retreiving Port Speed Failed\n");
828 status = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
831 return iscsi_host_get_param(shost, param, buf);
836 int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
838 struct be_cmd_get_nic_conf_resp resp;
841 if (strlen(phba->mac_address))
842 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
844 memset(&resp, 0, sizeof(resp));
845 rc = mgmt_get_nic_conf(phba, &resp);
849 memcpy(phba->mac_address, resp.mac_address, ETH_ALEN);
850 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
854 * beiscsi_conn_get_stats - get the iscsi stats
855 * @cls_conn: pointer to iscsi cls conn
856 * @stats: pointer to iscsi_stats structure
858 * returns iscsi stats
860 void beiscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn,
861 struct iscsi_stats *stats)
863 struct iscsi_conn *conn = cls_conn->dd_data;
864 struct beiscsi_hba *phba = NULL;
866 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
867 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
868 "BS_%d : In beiscsi_conn_get_stats\n");
870 stats->txdata_octets = conn->txdata_octets;
871 stats->rxdata_octets = conn->rxdata_octets;
872 stats->dataout_pdus = conn->dataout_pdus_cnt;
873 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
874 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
875 stats->datain_pdus = conn->datain_pdus_cnt;
876 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
877 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
878 stats->r2t_pdus = conn->r2t_pdus_cnt;
879 stats->digest_err = 0;
880 stats->timeout_err = 0;
881 stats->custom_length = 0;
882 strcpy(stats->custom[0].desc, "eh_abort_cnt");
883 stats->custom[0].value = conn->eh_abort_cnt;
887 * beiscsi_set_params_for_offld - get the parameters for offload
888 * @beiscsi_conn: pointer to beiscsi_conn
889 * @params: pointer to offload_params structure
891 static void beiscsi_set_params_for_offld(struct beiscsi_conn *beiscsi_conn,
892 struct beiscsi_offload_params *params)
894 struct iscsi_conn *conn = beiscsi_conn->conn;
895 struct iscsi_session *session = conn->session;
897 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_burst_length,
898 params, session->max_burst);
899 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
900 max_send_data_segment_length, params,
901 conn->max_xmit_dlength);
902 AMAP_SET_BITS(struct amap_beiscsi_offload_params, first_burst_length,
903 params, session->first_burst);
904 AMAP_SET_BITS(struct amap_beiscsi_offload_params, erl, params,
906 AMAP_SET_BITS(struct amap_beiscsi_offload_params, dde, params,
908 AMAP_SET_BITS(struct amap_beiscsi_offload_params, hde, params,
910 AMAP_SET_BITS(struct amap_beiscsi_offload_params, ir2t, params,
911 session->initial_r2t_en);
912 AMAP_SET_BITS(struct amap_beiscsi_offload_params, imd, params,
913 session->imm_data_en);
914 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
915 data_seq_inorder, params,
916 session->dataseq_inorder_en);
917 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
918 pdu_seq_inorder, params,
919 session->pdu_inorder_en);
920 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_r2t, params,
922 AMAP_SET_BITS(struct amap_beiscsi_offload_params, exp_statsn, params,
923 (conn->exp_statsn - 1));
927 * beiscsi_conn_start - offload of session to chip
928 * @cls_conn: pointer to beiscsi_conn
930 int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
932 struct iscsi_conn *conn = cls_conn->dd_data;
933 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
934 struct beiscsi_endpoint *beiscsi_ep;
935 struct beiscsi_offload_params params;
937 beiscsi_log(beiscsi_conn->phba, KERN_INFO,
939 "BS_%d : In beiscsi_conn_start\n");
941 memset(¶ms, 0, sizeof(struct beiscsi_offload_params));
942 beiscsi_ep = beiscsi_conn->ep;
944 beiscsi_log(beiscsi_conn->phba, KERN_ERR,
946 "BS_%d : In beiscsi_conn_start , no beiscsi_ep\n");
948 beiscsi_conn->login_in_progress = 0;
949 beiscsi_set_params_for_offld(beiscsi_conn, ¶ms);
950 beiscsi_offload_connection(beiscsi_conn, ¶ms);
951 iscsi_conn_start(cls_conn);
956 * beiscsi_get_cid - Allocate a cid
957 * @phba: The phba instance
959 static int beiscsi_get_cid(struct beiscsi_hba *phba)
961 unsigned short cid = 0xFFFF;
963 if (!phba->avlbl_cids)
966 cid = phba->cid_array[phba->cid_alloc++];
967 if (phba->cid_alloc == phba->params.cxns_per_ctrl)
974 * beiscsi_put_cid - Free the cid
975 * @phba: The phba for which the cid is being freed
976 * @cid: The cid to free
978 static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
981 phba->cid_array[phba->cid_free++] = cid;
982 if (phba->cid_free == phba->params.cxns_per_ctrl)
987 * beiscsi_free_ep - free endpoint
988 * @ep: pointer to iscsi endpoint structure
990 static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
992 struct beiscsi_hba *phba = beiscsi_ep->phba;
993 struct beiscsi_conn *beiscsi_conn;
995 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
996 beiscsi_ep->phba = NULL;
999 * Check if any connection resource allocated by driver
1000 * is to be freed.This case occurs when target redirection
1001 * or connection retry is done.
1003 if (!beiscsi_ep->conn)
1006 beiscsi_conn = beiscsi_ep->conn;
1007 if (beiscsi_conn->login_in_progress) {
1008 beiscsi_free_mgmt_task_handles(beiscsi_conn);
1009 beiscsi_conn->login_in_progress = 0;
1014 * beiscsi_open_conn - Ask FW to open a TCP connection
1015 * @ep: endpoint to be used
1016 * @src_addr: The source IP address
1017 * @dst_addr: The Destination IP address
1019 * Asks the FW to open a TCP connection
1021 static int beiscsi_open_conn(struct iscsi_endpoint *ep,
1022 struct sockaddr *src_addr,
1023 struct sockaddr *dst_addr, int non_blocking)
1025 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1026 struct beiscsi_hba *phba = beiscsi_ep->phba;
1027 struct tcp_connect_and_offload_out *ptcpcnct_out;
1028 struct be_dma_mem nonemb_cmd;
1032 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1033 "BS_%d : In beiscsi_open_conn\n");
1035 beiscsi_ep->ep_cid = beiscsi_get_cid(phba);
1036 if (beiscsi_ep->ep_cid == 0xFFFF) {
1037 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1038 "BS_%d : No free cid available\n");
1042 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1043 "BS_%d : In beiscsi_open_conn, ep_cid=%d\n",
1044 beiscsi_ep->ep_cid);
1046 phba->ep_array[beiscsi_ep->ep_cid -
1047 phba->fw_config.iscsi_cid_start] = ep;
1048 if (beiscsi_ep->ep_cid > (phba->fw_config.iscsi_cid_start +
1049 phba->params.cxns_per_ctrl * 2)) {
1051 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1052 "BS_%d : Failed in allocate iscsi cid\n");
1056 beiscsi_ep->cid_vld = 0;
1057 nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
1058 sizeof(struct tcp_connect_and_offload_in),
1060 if (nonemb_cmd.va == NULL) {
1062 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1063 "BS_%d : Failed to allocate memory for"
1064 " mgmt_open_connection\n");
1066 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1069 nonemb_cmd.size = sizeof(struct tcp_connect_and_offload_in);
1070 memset(nonemb_cmd.va, 0, nonemb_cmd.size);
1071 tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep, &nonemb_cmd);
1073 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1074 "BS_%d : mgmt_open_connection Failed for cid=%d\n",
1075 beiscsi_ep->ep_cid);
1077 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1078 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1079 nonemb_cmd.va, nonemb_cmd.dma);
1083 ret = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
1085 beiscsi_log(phba, KERN_ERR,
1086 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
1087 "BS_%d : mgmt_open_connection Failed");
1089 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1090 nonemb_cmd.va, nonemb_cmd.dma);
1094 ptcpcnct_out = (struct tcp_connect_and_offload_out *)nonemb_cmd.va;
1095 beiscsi_ep = ep->dd_data;
1096 beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
1097 beiscsi_ep->cid_vld = 1;
1098 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1099 "BS_%d : mgmt_open_connection Success\n");
1101 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1102 nonemb_cmd.va, nonemb_cmd.dma);
1106 beiscsi_free_ep(beiscsi_ep);
1111 * beiscsi_ep_connect - Ask chip to create TCP Conn
1112 * @scsi_host: Pointer to scsi_host structure
1113 * @dst_addr: The IP address of Target
1114 * @non_blocking: blocking or non-blocking call
1116 * This routines first asks chip to create a connection and then allocates an EP
1118 struct iscsi_endpoint *
1119 beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1122 struct beiscsi_hba *phba;
1123 struct beiscsi_endpoint *beiscsi_ep;
1124 struct iscsi_endpoint *ep;
1128 phba = iscsi_host_priv(shost);
1132 "beiscsi_ep_connect shost is NULL\n");
1133 return ERR_PTR(ret);
1136 if (phba->state != BE_ADAPTER_UP) {
1138 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1139 "BS_%d : The Adapter Port state is Down!!!\n");
1140 return ERR_PTR(ret);
1143 ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
1146 return ERR_PTR(ret);
1149 beiscsi_ep = ep->dd_data;
1150 beiscsi_ep->phba = phba;
1151 beiscsi_ep->openiscsi_ep = ep;
1152 ret = beiscsi_open_conn(ep, NULL, dst_addr, non_blocking);
1154 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1155 "BS_%d : Failed in beiscsi_open_conn\n");
1162 iscsi_destroy_endpoint(ep);
1163 return ERR_PTR(ret);
1167 * beiscsi_ep_poll - Poll to see if connection is established
1168 * @ep: endpoint to be used
1169 * @timeout_ms: timeout specified in millisecs
1171 * Poll to see if TCP connection established
1173 int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1175 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1177 beiscsi_log(beiscsi_ep->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1178 "BS_%d : In beiscsi_ep_poll\n");
1180 if (beiscsi_ep->cid_vld == 1)
1187 * beiscsi_close_conn - Upload the connection
1188 * @ep: The iscsi endpoint
1189 * @flag: The type of connection closure
1191 static int beiscsi_close_conn(struct beiscsi_endpoint *beiscsi_ep, int flag)
1195 struct beiscsi_hba *phba = beiscsi_ep->phba;
1197 tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
1199 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1200 "BS_%d : upload failed for cid 0x%x\n",
1201 beiscsi_ep->ep_cid);
1206 ret = beiscsi_mccq_compl(phba, tag, NULL, NULL);
1211 * beiscsi_unbind_conn_to_cid - Unbind the beiscsi_conn from phba conn table
1212 * @phba: The phba instance
1213 * @cid: The cid to free
1215 static int beiscsi_unbind_conn_to_cid(struct beiscsi_hba *phba,
1218 if (phba->conn_table[cid])
1219 phba->conn_table[cid] = NULL;
1221 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1222 "BS_%d : Connection table Not occupied.\n");
1229 * beiscsi_ep_disconnect - Tears down the TCP connection
1230 * @ep: endpoint to be used
1232 * Tears down the TCP connection
1234 void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
1236 struct beiscsi_conn *beiscsi_conn;
1237 struct beiscsi_endpoint *beiscsi_ep;
1238 struct beiscsi_hba *phba;
1240 uint8_t mgmt_invalidate_flag, tcp_upload_flag;
1241 unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
1243 beiscsi_ep = ep->dd_data;
1244 phba = beiscsi_ep->phba;
1245 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1246 "BS_%d : In beiscsi_ep_disconnect for ep_cid = %d\n",
1247 beiscsi_ep->ep_cid);
1249 if (beiscsi_ep->conn) {
1250 beiscsi_conn = beiscsi_ep->conn;
1251 iscsi_suspend_queue(beiscsi_conn->conn);
1252 mgmt_invalidate_flag = ~BEISCSI_NO_RST_ISSUE;
1253 tcp_upload_flag = CONNECTION_UPLOAD_GRACEFUL;
1255 mgmt_invalidate_flag = BEISCSI_NO_RST_ISSUE;
1256 tcp_upload_flag = CONNECTION_UPLOAD_ABORT;
1259 tag = mgmt_invalidate_connection(phba, beiscsi_ep,
1261 mgmt_invalidate_flag,
1264 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1265 "BS_%d : mgmt_invalidate_connection Failed for cid=%d\n",
1266 beiscsi_ep->ep_cid);
1269 beiscsi_mccq_compl(phba, tag, NULL, NULL);
1270 beiscsi_close_conn(beiscsi_ep, tcp_upload_flag);
1271 beiscsi_free_ep(beiscsi_ep);
1272 beiscsi_unbind_conn_to_cid(phba, beiscsi_ep->ep_cid);
1273 iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
1276 umode_t be2iscsi_attr_is_visible(int param_type, int param)
1278 switch (param_type) {
1279 case ISCSI_NET_PARAM:
1281 case ISCSI_NET_PARAM_IFACE_ENABLE:
1282 case ISCSI_NET_PARAM_IPV4_ADDR:
1283 case ISCSI_NET_PARAM_IPV4_SUBNET:
1284 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
1285 case ISCSI_NET_PARAM_IPV4_GW:
1286 case ISCSI_NET_PARAM_IPV6_ADDR:
1287 case ISCSI_NET_PARAM_VLAN_ID:
1288 case ISCSI_NET_PARAM_VLAN_PRIORITY:
1289 case ISCSI_NET_PARAM_VLAN_ENABLED:
1294 case ISCSI_HOST_PARAM:
1296 case ISCSI_HOST_PARAM_HWADDRESS:
1297 case ISCSI_HOST_PARAM_INITIATOR_NAME:
1298 case ISCSI_HOST_PARAM_PORT_STATE:
1299 case ISCSI_HOST_PARAM_PORT_SPEED:
1306 case ISCSI_PARAM_MAX_RECV_DLENGTH:
1307 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
1308 case ISCSI_PARAM_HDRDGST_EN:
1309 case ISCSI_PARAM_DATADGST_EN:
1310 case ISCSI_PARAM_CONN_ADDRESS:
1311 case ISCSI_PARAM_CONN_PORT:
1312 case ISCSI_PARAM_EXP_STATSN:
1313 case ISCSI_PARAM_PERSISTENT_ADDRESS:
1314 case ISCSI_PARAM_PERSISTENT_PORT:
1315 case ISCSI_PARAM_PING_TMO:
1316 case ISCSI_PARAM_RECV_TMO:
1317 case ISCSI_PARAM_INITIAL_R2T_EN:
1318 case ISCSI_PARAM_MAX_R2T:
1319 case ISCSI_PARAM_IMM_DATA_EN:
1320 case ISCSI_PARAM_FIRST_BURST:
1321 case ISCSI_PARAM_MAX_BURST:
1322 case ISCSI_PARAM_PDU_INORDER_EN:
1323 case ISCSI_PARAM_DATASEQ_INORDER_EN:
1324 case ISCSI_PARAM_ERL:
1325 case ISCSI_PARAM_TARGET_NAME:
1326 case ISCSI_PARAM_TPGT:
1327 case ISCSI_PARAM_USERNAME:
1328 case ISCSI_PARAM_PASSWORD:
1329 case ISCSI_PARAM_USERNAME_IN:
1330 case ISCSI_PARAM_PASSWORD_IN:
1331 case ISCSI_PARAM_FAST_ABORT:
1332 case ISCSI_PARAM_ABORT_TMO:
1333 case ISCSI_PARAM_LU_RESET_TMO:
1334 case ISCSI_PARAM_IFACE_NAME:
1335 case ISCSI_PARAM_INITIATOR_NAME: