]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/scsi/be2iscsi/be_iscsi.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] be2iscsi: Fix session update context with V2 version.
[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / be2iscsi / be_iscsi.c
CommitLineData
6733b39a 1/**
255fa9a3 2 * Copyright (C) 2005 - 2011 Emulex
6733b39a
JK		 3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
9 *
255fa9a3 10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
6733b39a
JK		 11 *
12 * Contact Information:
255fa9a3 13 * linux-drivers@emulex.com
6733b39a 14 *
255fa9a3
JK		 15 * Emulex
16 * 3333 Susan Street
17 * Costa Mesa, CA 92626
6733b39a
JK		 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>
0e43895e
MC		 26#include <scsi/scsi_netlink.h>
27#include <net/netlink.h>
6733b39a
JK		 28#include <scsi/scsi.h>
29
30#include "be_iscsi.h"
31
32extern struct iscsi_transport beiscsi_iscsi_transport;
33
34/**
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
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;
6733b39a 48 struct beiscsi_hba *phba;
b8b9e1b8
JK		 49 struct iscsi_session *sess;
50 struct beiscsi_session *beiscsi_sess;
6733b39a 51 struct beiscsi_io_task *io_task;
6733b39a 52
6733b39a
JK		 53
54 if (!ep) {
99bc5d55
JSJ		 55 printk(KERN_ERR
56 "beiscsi_session_create: invalid ep\n");
6733b39a
JK		 57 return NULL;
58 }
59 beiscsi_ep = ep->dd_data;
60 phba = beiscsi_ep->phba;
61 shost = phba->shost;
99bc5d55
JSJ		 62
63 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
64 "BS_%d : In beiscsi_session_create\n");
65
6733b39a 66 if (cmds_max > beiscsi_ep->phba->params.wrbs_per_cxn) {
99bc5d55
JSJ		 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."
70 "\n", cmds_max,
71 beiscsi_ep->phba->params.wrbs_per_cxn,
72 beiscsi_ep->phba->params.wrbs_per_cxn);
73
6733b39a
JK		 74 cmds_max = beiscsi_ep->phba->params.wrbs_per_cxn;
75 }
76
bfead3b2
JK		 77 cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
78 shost, cmds_max,
79 sizeof(*beiscsi_sess),
80 sizeof(*io_task),
81 initial_cmdsn, ISCSI_MAX_TARGET);
6733b39a
JK		 82 if (!cls_session)
83 return NULL;
84 sess = cls_session->dd_data;
2afc95bf
JK		 85 beiscsi_sess = sess->dd_data;
86 beiscsi_sess->bhs_pool = pci_pool_create("beiscsi_bhs_pool",
87 phba->pcidev,
88 sizeof(struct be_cmd_bhs),
89 64, 0);
90 if (!beiscsi_sess->bhs_pool)
91 goto destroy_sess;
6733b39a 92
6733b39a 93 return cls_session;
2afc95bf
JK		 94destroy_sess:
95 iscsi_session_teardown(cls_session);
96 return NULL;
6733b39a
JK		 97}
98
99/**
100 * beiscsi_session_destroy - destroys iscsi session
101 * @cls_session: pointer to iscsi cls session
102 *
103 * Destroys iSCSI session instance and releases
104 * resources allocated for it.
105 */
106void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
107{
6733b39a 108 struct iscsi_session *sess = cls_session->dd_data;
2afc95bf 109 struct beiscsi_session *beiscsi_sess = sess->dd_data;
6733b39a 110
99bc5d55 111 printk(KERN_INFO "In beiscsi_session_destroy\n");
2afc95bf 112 pci_pool_destroy(beiscsi_sess->bhs_pool);
6733b39a
JK		 113 iscsi_session_teardown(cls_session);
114}
115
116/**
117 * beiscsi_conn_create - create an instance of iscsi connection
118 * @cls_session: ptr to iscsi_cls_session
119 * @cid: iscsi cid
120 */
121struct iscsi_cls_conn *
122beiscsi_conn_create(struct iscsi_cls_session *cls_session, u32 cid)
123{
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;
2afc95bf
JK		 129 struct iscsi_session *sess;
130 struct beiscsi_session *beiscsi_sess;
6733b39a 131
6733b39a
JK		 132 shost = iscsi_session_to_shost(cls_session);
133 phba = iscsi_host_priv(shost);
134
99bc5d55
JSJ		 135 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
136 "BS_%d : In beiscsi_conn_create ,cid"
137 "from iscsi layer=%d\n", cid);
138
6733b39a
JK		 139 cls_conn = iscsi_conn_setup(cls_session, sizeof(*beiscsi_conn), cid);
140 if (!cls_conn)
141 return NULL;
142
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;
2afc95bf
JK		 148 sess = cls_session->dd_data;
149 beiscsi_sess = sess->dd_data;
150 beiscsi_conn->beiscsi_sess = beiscsi_sess;
6733b39a
JK		 151 return cls_conn;
152}
153
154/**
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
159 */
160static int beiscsi_bindconn_cid(struct beiscsi_hba *phba,
161 struct beiscsi_conn *beiscsi_conn,
162 unsigned int cid)
163{
164 if (phba->conn_table[cid]) {
99bc5d55
JSJ		 165 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
166 "BS_%d : Connection table already occupied. Detected clash\n");
167
6733b39a
JK		 168 return -EINVAL;
169 } else {
99bc5d55
JSJ		 170 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
171 "BS_%d : phba->conn_table[%d]=%p(beiscsi_conn)\n",
172 cid, beiscsi_conn);
173
6733b39a
JK		 174 phba->conn_table[cid] = beiscsi_conn;
175 }
176 return 0;
177}
178
179/**
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)
184 *
185 * This function binds the TCP Conn with iSCSI Connection and Session.
186 */
187int beiscsi_conn_bind(struct iscsi_cls_session *cls_session,
188 struct iscsi_cls_conn *cls_conn,
189 u64 transport_fd, int is_leading)
190{
191 struct iscsi_conn *conn = cls_conn->dd_data;
192 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
3093b048
MC		 193 struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
194 struct beiscsi_hba *phba = iscsi_host_priv(shost);
6733b39a
JK		 195 struct beiscsi_endpoint *beiscsi_ep;
196 struct iscsi_endpoint *ep;
197
6733b39a
JK		 198 ep = iscsi_lookup_endpoint(transport_fd);
199 if (!ep)
200 return -EINVAL;
201
202 beiscsi_ep = ep->dd_data;
203
204 if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
205 return -EINVAL;
206
207 if (beiscsi_ep->phba != phba) {
99bc5d55
JSJ		 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);
211
6733b39a
JK		 212 return -EEXIST;
213 }
214
215 beiscsi_conn->beiscsi_conn_cid = beiscsi_ep->ep_cid;
216 beiscsi_conn->ep = beiscsi_ep;
217 beiscsi_ep->conn = beiscsi_conn;
99bc5d55
JSJ		 218
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);
222
6733b39a
JK		 223 return beiscsi_bindconn_cid(phba, beiscsi_conn, beiscsi_ep->ep_cid);
224}
225
0e43895e
MC		 226static int beiscsi_create_ipv4_iface(struct beiscsi_hba *phba)
227{
228 if (phba->ipv4_iface)
229 return 0;
230
231 phba->ipv4_iface = iscsi_create_iface(phba->shost,
232 &beiscsi_iscsi_transport,
233 ISCSI_IFACE_TYPE_IPV4,
234 0, 0);
235 if (!phba->ipv4_iface) {
99bc5d55
JSJ		 236 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
237 "BS_%d : Could not "
238 "create default IPv4 address.\n");
0e43895e
MC		 239 return -ENODEV;
240 }
241
242 return 0;
243}
244
245static int beiscsi_create_ipv6_iface(struct beiscsi_hba *phba)
246{
247 if (phba->ipv6_iface)
248 return 0;
249
250 phba->ipv6_iface = iscsi_create_iface(phba->shost,
251 &beiscsi_iscsi_transport,
252 ISCSI_IFACE_TYPE_IPV6,
253 0, 0);
254 if (!phba->ipv6_iface) {
99bc5d55
JSJ		 255 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
256 "BS_%d : Could not "
257 "create default IPv6 address.\n");
0e43895e
MC		 258 return -ENODEV;
259 }
260
261 return 0;
262}
263
264void beiscsi_create_def_ifaces(struct beiscsi_hba *phba)
265{
266 struct be_cmd_get_if_info_resp if_info;
267
268 if (!mgmt_get_if_info(phba, BE2_IPV4, &if_info))
269 beiscsi_create_ipv4_iface(phba);
270
271 if (!mgmt_get_if_info(phba, BE2_IPV6, &if_info))
272 beiscsi_create_ipv6_iface(phba);
273}
274
275void beiscsi_destroy_def_ifaces(struct beiscsi_hba *phba)
276{
277 if (phba->ipv6_iface)
278 iscsi_destroy_iface(phba->ipv6_iface);
279 if (phba->ipv4_iface)
280 iscsi_destroy_iface(phba->ipv4_iface);
281}
282
283static int
284beiscsi_set_static_ip(struct Scsi_Host *shost,
285 struct iscsi_iface_param_info *iface_param,
286 void *data, uint32_t dt_len)
287{
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;
291 struct nlattr *nla;
292 int ret;
293
294
295 switch (iface_param->param) {
296 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
297 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
298 if (nla)
299 iface_ip = nla_data(nla);
300
301 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
302 if (nla)
303 iface_subnet = nla_data(nla);
304 break;
305 case ISCSI_NET_PARAM_IPV4_ADDR:
306 iface_ip = iface_param;
307 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
308 if (nla)
309 iface_subnet = nla_data(nla);
310 break;
311 case ISCSI_NET_PARAM_IPV4_SUBNET:
312 iface_subnet = iface_param;
313 nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
314 if (nla)
315 iface_ip = nla_data(nla);
316 break;
317 default:
99bc5d55
JSJ		 318 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
319 "BS_%d : Unsupported param %d\n",
320 iface_param->param);
0e43895e
MC		 321 }
322
323 if (!iface_ip || !iface_subnet) {
99bc5d55
JSJ		 324 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
325 "BS_%d : IP and Subnet Mask required\n");
0e43895e
MC		 326 return -EINVAL;
327 }
328
329 ret = mgmt_set_ip(phba, iface_ip, iface_subnet,
330 ISCSI_BOOTPROTO_STATIC);
331
332 return ret;
333}
334
6f72238e
JSJ		 335/**
336 * beiscsi_set_vlan_tag()- Set the VLAN TAG
337 * @shost: Scsi Host for the driver instance
338 * @iface_param: Interface paramters
339 *
340 * Set the VLAN TAG for the adapter or disable
341 * the VLAN config
342 *
343 * returns
344 * Success: 0
345 * Failure: Non-Zero Value
346 **/
347static int
348beiscsi_set_vlan_tag(struct Scsi_Host *shost,
349 struct iscsi_iface_param_info *iface_param)
350{
351 struct beiscsi_hba *phba = iscsi_host_priv(shost);
352 int ret = 0;
353
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");
358 return -EIO;
359 }
360
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);
365 break;
366 case ISCSI_NET_PARAM_VLAN_TAG:
367 ret = mgmt_set_vlan(phba,
368 *((uint16_t *)iface_param->value));
369 break;
370 default:
371 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
372 "BS_%d : Unkown Param Type : %d\n",
373 iface_param->param);
374 return -ENOSYS;
375 }
376 return ret;
377}
378
379
0e43895e
MC		 380static int
381beiscsi_set_ipv4(struct Scsi_Host *shost,
382 struct iscsi_iface_param_info *iface_param,
383 void *data, uint32_t dt_len)
384{
385 struct beiscsi_hba *phba = iscsi_host_priv(shost);
386 int ret = 0;
387
388 /* Check the param */
389 switch (iface_param->param) {
390 case ISCSI_NET_PARAM_IPV4_GW:
391 ret = mgmt_set_gateway(phba, iface_param);
392 break;
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,
399 data, dt_len);
400 else
99bc5d55
JSJ		 401 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
402 "BS_%d : Invalid BOOTPROTO: %d\n",
403 iface_param->value[0]);
0e43895e
MC		 404 break;
405 case ISCSI_NET_PARAM_IFACE_ENABLE:
406 if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
407 ret = beiscsi_create_ipv4_iface(phba);
408 else
409 iscsi_destroy_iface(phba->ipv4_iface);
410 break;
411 case ISCSI_NET_PARAM_IPV4_SUBNET:
412 case ISCSI_NET_PARAM_IPV4_ADDR:
413 ret = beiscsi_set_static_ip(shost, iface_param,
414 data, dt_len);
415 break;
6f72238e
JSJ		 416 case ISCSI_NET_PARAM_VLAN_ENABLED:
417 case ISCSI_NET_PARAM_VLAN_TAG:
418 ret = beiscsi_set_vlan_tag(shost, iface_param);
419 break;
0e43895e 420 default:
99bc5d55
JSJ		 421 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
422 "BS_%d : Param %d not supported\n",
423 iface_param->param);
0e43895e
MC		 424 }
425
426 return ret;
427}
428
429static int
430beiscsi_set_ipv6(struct Scsi_Host *shost,
431 struct iscsi_iface_param_info *iface_param,
432 void *data, uint32_t dt_len)
433{
434 struct beiscsi_hba *phba = iscsi_host_priv(shost);
435 int ret = 0;
436
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);
441 else {
442 iscsi_destroy_iface(phba->ipv6_iface);
443 ret = 0;
444 }
445 break;
446 case ISCSI_NET_PARAM_IPV6_ADDR:
447 ret = mgmt_set_ip(phba, iface_param, NULL,
448 ISCSI_BOOTPROTO_STATIC);
449 break;
450 default:
99bc5d55
JSJ		 451 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
452 "BS_%d : Param %d not supported\n",
453 iface_param->param);
0e43895e
MC		 454 }
455
456 return ret;
457}
458
459int be2iscsi_iface_set_param(struct Scsi_Host *shost,
460 void *data, uint32_t dt_len)
461{
462 struct iscsi_iface_param_info *iface_param = NULL;
99bc5d55 463 struct beiscsi_hba *phba = iscsi_host_priv(shost);
0e43895e
MC		 464 struct nlattr *attrib;
465 uint32_t rm_len = dt_len;
466 int ret = 0 ;
467
468 nla_for_each_attr(attrib, data, dt_len, rm_len) {
469 iface_param = nla_data(attrib);
470
471 if (iface_param->param_type != ISCSI_NET_PARAM)
472 continue;
473
474 /*
475 * BE2ISCSI only supports 1 interface
476 */
477 if (iface_param->iface_num) {
99bc5d55
JSJ		 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);
482
0e43895e
MC		 483 return -EINVAL;
484 }
485
486 switch (iface_param->iface_type) {
487 case ISCSI_IFACE_TYPE_IPV4:
488 ret = beiscsi_set_ipv4(shost, iface_param,
489 data, dt_len);
490 break;
491 case ISCSI_IFACE_TYPE_IPV6:
492 ret = beiscsi_set_ipv6(shost, iface_param,
493 data, dt_len);
494 break;
495 default:
99bc5d55
JSJ		 496 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
497 "BS_%d : Invalid iface type :%d passed\n",
498 iface_param->iface_type);
0e43895e
MC		 499 break;
500 }
501
502 if (ret)
503 return ret;
504 }
505
506 return ret;
507}
508
509static int be2iscsi_get_if_param(struct beiscsi_hba *phba,
510 struct iscsi_iface *iface, int param,
511 char *buf)
512{
513 struct be_cmd_get_if_info_resp if_info;
514 int len, ip_type = BE2_IPV4;
515
516 memset(&if_info, 0, sizeof(if_info));
517
518 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
519 ip_type = BE2_IPV6;
520
521 len = mgmt_get_if_info(phba, ip_type, &if_info);
522 if (len)
523 return len;
524
525 switch (param) {
526 case ISCSI_NET_PARAM_IPV4_ADDR:
527 len = sprintf(buf, "%pI4\n", &if_info.ip_addr.addr);
528 break;
529 case ISCSI_NET_PARAM_IPV6_ADDR:
530 len = sprintf(buf, "%pI6\n", &if_info.ip_addr.addr);
531 break;
532 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
533 if (!if_info.dhcp_state)
8359c79b 534 len = sprintf(buf, "static\n");
0e43895e 535 else
8359c79b 536 len = sprintf(buf, "dhcp\n");
0e43895e
MC		 537 break;
538 case ISCSI_NET_PARAM_IPV4_SUBNET:
539 len = sprintf(buf, "%pI4\n", &if_info.ip_addr.subnet_mask);
540 break;
6f72238e
JSJ		 541 case ISCSI_NET_PARAM_VLAN_ENABLED:
542 len = sprintf(buf, "%s\n",
543 (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
8359c79b 544 ? "Disabled\n" : "Enabled\n");
6f72238e
JSJ		 545 break;
546 case ISCSI_NET_PARAM_VLAN_ID:
547 if (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
548 return -EINVAL;
549 else
550 len = sprintf(buf, "%d\n",
551 (if_info.vlan_priority &
552 ISCSI_MAX_VLAN_ID));
553 break;
554 case ISCSI_NET_PARAM_VLAN_PRIORITY:
555 if (if_info.vlan_priority == BEISCSI_VLAN_DISABLE)
556 return -EINVAL;
557 else
558 len = sprintf(buf, "%d\n",
559 ((if_info.vlan_priority >> 13) &
560 ISCSI_MAX_VLAN_PRIORITY));
561 break;
0e43895e
MC		 562 default:
563 WARN_ON(1);
564 }
565
566 return len;
567}
568
569int be2iscsi_iface_get_param(struct iscsi_iface *iface,
570 enum iscsi_param_type param_type,
571 int param, char *buf)
572{
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;
576 int len = -ENOSYS;
577
578 switch (param) {
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:
6f72238e
JSJ		 583 case ISCSI_NET_PARAM_VLAN_ENABLED:
584 case ISCSI_NET_PARAM_VLAN_ID:
585 case ISCSI_NET_PARAM_VLAN_PRIORITY:
0e43895e
MC		 586 len = be2iscsi_get_if_param(phba, iface, param, buf);
587 break;
588 case ISCSI_NET_PARAM_IFACE_ENABLE:
8359c79b 589 len = sprintf(buf, "enabled\n");
0e43895e
MC		 590 break;
591 case ISCSI_NET_PARAM_IPV4_GW:
592 memset(&gateway, 0, sizeof(gateway));
593 len = mgmt_get_gateway(phba, BE2_IPV4, &gateway);
594 if (!len)
595 len = sprintf(buf, "%pI4\n", &gateway.ip_addr.addr);
596 break;
597 default:
598 len = -ENOSYS;
599 }
600
601 return len;
602}
603
6733b39a 604/**
c7f7fd5b
MC		 605 * beiscsi_ep_get_param - get the iscsi parameter
606 * @ep: pointer to iscsi ep
6733b39a
JK		 607 * @param: parameter type identifier
608 * @buf: buffer pointer
609 *
610 * returns iscsi parameter
611 */
c7f7fd5b 612int beiscsi_ep_get_param(struct iscsi_endpoint *ep,
6733b39a
JK		 613 enum iscsi_param param, char *buf)
614{
c7f7fd5b 615 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
6733b39a
JK		 616 int len = 0;
617
99bc5d55
JSJ		 618 beiscsi_log(beiscsi_ep->phba, KERN_INFO,
619 BEISCSI_LOG_CONFIG,
620 "BS_%d : In beiscsi_ep_get_param,"
621 " param= %d\n", param);
6733b39a
JK		 622
623 switch (param) {
624 case ISCSI_PARAM_CONN_PORT:
625 len = sprintf(buf, "%hu\n", beiscsi_ep->dst_tcpport);
626 break;
627 case ISCSI_PARAM_CONN_ADDRESS:
628 if (beiscsi_ep->ip_type == BE2_IPV4)
629 len = sprintf(buf, "%pI4\n", &beiscsi_ep->dst_addr);
630 else
631 len = sprintf(buf, "%pI6\n", &beiscsi_ep->dst6_addr);
632 break;
633 default:
c7f7fd5b 634 return -ENOSYS;
6733b39a
JK		 635 }
636 return len;
637}
638
639int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
640 enum iscsi_param param, char *buf, int buflen)
641{
642 struct iscsi_conn *conn = cls_conn->dd_data;
643 struct iscsi_session *session = conn->session;
99bc5d55 644 struct beiscsi_hba *phba = NULL;
6733b39a
JK		 645 int ret;
646
99bc5d55
JSJ		 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);
651
6733b39a
JK		 652 ret = iscsi_set_param(cls_conn, param, buf, buflen);
653 if (ret)
654 return ret;
655 /*
656 * If userspace tried to set the value to higher than we can
657 * support override here.
658 */
659 switch (param) {
660 case ISCSI_PARAM_FIRST_BURST:
661 if (session->first_burst > 8192)
662 session->first_burst = 8192;
663 break;
664 case ISCSI_PARAM_MAX_RECV_DLENGTH:
665 if (conn->max_recv_dlength > 65536)
666 conn->max_recv_dlength = 65536;
667 break;
668 case ISCSI_PARAM_MAX_BURST:
230dceb4
JK		 669 if (session->max_burst > 262144)
670 session->max_burst = 262144;
6733b39a 671 break;
42f43c41
JK		 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;
6733b39a
JK		 676 default:
677 return 0;
678 }
679
680 return 0;
681}
682
2177199d
JSJ		 683/**
684 * beiscsi_get_initname - Read Initiator Name from flash
685 * @buf: buffer bointer
686 * @phba: The device priv structure instance
687 *
688 * returns number of bytes
689 */
690static int beiscsi_get_initname(char *buf, struct beiscsi_hba *phba)
691{
692 int rc;
693 unsigned int tag, wrb_num;
694 unsigned short status, extd_status;
695 struct be_mcc_wrb *wrb;
696 struct be_cmd_hba_name *resp;
697 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
698
699 tag = be_cmd_get_initname(phba);
700 if (!tag) {
99bc5d55
JSJ		 701 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
702 "BS_%d : Getting Initiator Name Failed\n");
703
2177199d
JSJ		 704 return -EBUSY;
705 } else
706 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
707 phba->ctrl.mcc_numtag[tag]);
708
709 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
710 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
711 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
712
713 if (status || extd_status) {
99bc5d55
JSJ		 714 beiscsi_log(phba, KERN_ERR,
715 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
716 "BS_%d : MailBox Command Failed with "
717 "status = %d extd_status = %d\n",
718 status, extd_status);
719
2177199d
JSJ		 720 free_mcc_tag(&phba->ctrl, tag);
721 return -EAGAIN;
722 }
723 wrb = queue_get_wrb(mccq, wrb_num);
724 free_mcc_tag(&phba->ctrl, tag);
725 resp = embedded_payload(wrb);
726 rc = sprintf(buf, "%s\n", resp->initiator_name);
727 return rc;
728}
729
c62eef0d
JSJ		 730/**
731 * beiscsi_get_port_state - Get the Port State
732 * @shost : pointer to scsi_host structure
733 *
c62eef0d
JSJ		 734 */
735static void beiscsi_get_port_state(struct Scsi_Host *shost)
736{
737 struct beiscsi_hba *phba = iscsi_host_priv(shost);
738 struct iscsi_cls_host *ihost = shost->shost_data;
739
740 ihost->port_state = (phba->state == BE_ADAPTER_UP) ?
741 ISCSI_PORT_STATE_UP : ISCSI_PORT_STATE_DOWN;
742}
743
744/**
745 * beiscsi_get_port_speed - Get the Port Speed from Adapter
746 * @shost : pointer to scsi_host structure
747 *
748 * returns Success/Failure
749 */
750static int beiscsi_get_port_speed(struct Scsi_Host *shost)
751{
752 unsigned int tag, wrb_num;
753 unsigned short status, extd_status;
754 struct be_mcc_wrb *wrb;
755 struct be_cmd_ntwk_link_status_resp *resp;
756 struct beiscsi_hba *phba = iscsi_host_priv(shost);
757 struct iscsi_cls_host *ihost = shost->shost_data;
758 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
759
760 tag = be_cmd_get_port_speed(phba);
761 if (!tag) {
99bc5d55
JSJ		 762 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
763 "BS_%d : Getting Port Speed Failed\n");
764
c62eef0d
JSJ		 765 return -EBUSY;
766 } else
767 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
768 phba->ctrl.mcc_numtag[tag]);
769
770 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
771 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
772 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
773
774 if (status || extd_status) {
99bc5d55
JSJ		 775 beiscsi_log(phba, KERN_ERR,
776 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
777 "BS_%d : MailBox Command Failed with "
778 "status = %d extd_status = %d\n",
779 status, extd_status);
780
c62eef0d
JSJ		 781 free_mcc_tag(&phba->ctrl, tag);
782 return -EAGAIN;
783 }
784 wrb = queue_get_wrb(mccq, wrb_num);
785 free_mcc_tag(&phba->ctrl, tag);
786 resp = embedded_payload(wrb);
787
788 switch (resp->mac_speed) {
789 case BE2ISCSI_LINK_SPEED_10MBPS:
790 ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
791 break;
792 case BE2ISCSI_LINK_SPEED_100MBPS:
793 ihost->port_speed = BE2ISCSI_LINK_SPEED_100MBPS;
794 break;
795 case BE2ISCSI_LINK_SPEED_1GBPS:
796 ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
797 break;
798 case BE2ISCSI_LINK_SPEED_10GBPS:
799 ihost->port_speed = ISCSI_PORT_SPEED_10GBPS;
800 break;
801 default:
802 ihost->port_speed = ISCSI_PORT_SPEED_UNKNOWN;
803 }
804 return 0;
805}
806
6733b39a
JK		 807/**
808 * beiscsi_get_host_param - get the iscsi parameter
809 * @shost: pointer to scsi_host structure
810 * @param: parameter type identifier
811 * @buf: buffer pointer
812 *
813 * returns host parameter
814 */
815int beiscsi_get_host_param(struct Scsi_Host *shost,
816 enum iscsi_host_param param, char *buf)
817{
3093b048 818 struct beiscsi_hba *phba = iscsi_host_priv(shost);
b15d05b0 819 int status = 0;
6733b39a 820
99bc5d55
JSJ		 821 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
822 "BS_%d : In beiscsi_get_host_param,"
823 " param= %d\n", param);
824
6733b39a
JK		 825 switch (param) {
826 case ISCSI_HOST_PARAM_HWADDRESS:
c7acc5b8
JK		 827 status = beiscsi_get_macaddr(buf, phba);
828 if (status < 0) {
99bc5d55
JSJ		 829 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
830 "BS_%d : beiscsi_get_macaddr Failed\n");
c7acc5b8 831 return status;
756d29c8 832 }
6733b39a 833 break;
2177199d
JSJ		 834 case ISCSI_HOST_PARAM_INITIATOR_NAME:
835 status = beiscsi_get_initname(buf, phba);
836 if (status < 0) {
99bc5d55
JSJ		 837 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
838 "BS_%d : Retreiving Initiator Name Failed\n");
2177199d
JSJ		 839 return status;
840 }
841 break;
c62eef0d
JSJ		 842 case ISCSI_HOST_PARAM_PORT_STATE:
843 beiscsi_get_port_state(shost);
844 status = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
845 break;
846 case ISCSI_HOST_PARAM_PORT_SPEED:
847 status = beiscsi_get_port_speed(shost);
848 if (status) {
99bc5d55
JSJ		 849 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
850 "BS_%d : Retreiving Port Speed Failed\n");
c62eef0d
JSJ		 851 return status;
852 }
853 status = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
854 break;
6733b39a
JK		 855 default:
856 return iscsi_host_get_param(shost, param, buf);
857 }
b15d05b0 858 return status;
6733b39a
JK		 859}
860
c7acc5b8
JK		 861int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
862{
0e43895e 863 struct be_cmd_get_nic_conf_resp resp;
c7acc5b8
JK		 864 int rc;
865
0e43895e 866 if (strlen(phba->mac_address))
df5d0e6e 867 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
c7acc5b8 868
0e43895e
MC		 869 memset(&resp, 0, sizeof(resp));
870 rc = mgmt_get_nic_conf(phba, &resp);
871 if (rc)
872 return rc;
c7acc5b8 873
0e43895e
MC		 874 memcpy(phba->mac_address, resp.mac_address, ETH_ALEN);
875 return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
c7acc5b8
JK		 876}
877
6733b39a
JK		 878/**
879 * beiscsi_conn_get_stats - get the iscsi stats
880 * @cls_conn: pointer to iscsi cls conn
881 * @stats: pointer to iscsi_stats structure
882 *
883 * returns iscsi stats
884 */
885void beiscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn,
886 struct iscsi_stats *stats)
887{
888 struct iscsi_conn *conn = cls_conn->dd_data;
99bc5d55
JSJ		 889 struct beiscsi_hba *phba = NULL;
890
891 phba = ((struct beiscsi_conn *)conn->dd_data)->phba;
892 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
893 "BS_%d : In beiscsi_conn_get_stats\n");
6733b39a 894
6733b39a
JK		 895 stats->txdata_octets = conn->txdata_octets;
896 stats->rxdata_octets = conn->rxdata_octets;
897 stats->dataout_pdus = conn->dataout_pdus_cnt;
898 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
899 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
900 stats->datain_pdus = conn->datain_pdus_cnt;
901 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
902 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
903 stats->r2t_pdus = conn->r2t_pdus_cnt;
904 stats->digest_err = 0;
905 stats->timeout_err = 0;
906 stats->custom_length = 0;
907 strcpy(stats->custom[0].desc, "eh_abort_cnt");
908 stats->custom[0].value = conn->eh_abort_cnt;
909}
910
911/**
912 * beiscsi_set_params_for_offld - get the parameters for offload
913 * @beiscsi_conn: pointer to beiscsi_conn
914 * @params: pointer to offload_params structure
915 */
916static void beiscsi_set_params_for_offld(struct beiscsi_conn *beiscsi_conn,
917 struct beiscsi_offload_params *params)
918{
919 struct iscsi_conn *conn = beiscsi_conn->conn;
920 struct iscsi_session *session = conn->session;
921
922 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_burst_length,
923 params, session->max_burst);
924 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
925 max_send_data_segment_length, params,
926 conn->max_xmit_dlength);
927 AMAP_SET_BITS(struct amap_beiscsi_offload_params, first_burst_length,
928 params, session->first_burst);
929 AMAP_SET_BITS(struct amap_beiscsi_offload_params, erl, params,
930 session->erl);
931 AMAP_SET_BITS(struct amap_beiscsi_offload_params, dde, params,
932 conn->datadgst_en);
933 AMAP_SET_BITS(struct amap_beiscsi_offload_params, hde, params,
934 conn->hdrdgst_en);
935 AMAP_SET_BITS(struct amap_beiscsi_offload_params, ir2t, params,
936 session->initial_r2t_en);
937 AMAP_SET_BITS(struct amap_beiscsi_offload_params, imd, params,
938 session->imm_data_en);
acb9693c
JSJ		 939 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
940 data_seq_inorder, params,
941 session->dataseq_inorder_en);
942 AMAP_SET_BITS(struct amap_beiscsi_offload_params,
943 pdu_seq_inorder, params,
944 session->pdu_inorder_en);
945 AMAP_SET_BITS(struct amap_beiscsi_offload_params, max_r2t, params,
946 session->max_r2t);
6733b39a
JK		 947 AMAP_SET_BITS(struct amap_beiscsi_offload_params, exp_statsn, params,
948 (conn->exp_statsn - 1));
949}
950
951/**
952 * beiscsi_conn_start - offload of session to chip
953 * @cls_conn: pointer to beiscsi_conn
954 */
955int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
956{
957 struct iscsi_conn *conn = cls_conn->dd_data;
958 struct beiscsi_conn *beiscsi_conn = conn->dd_data;
959 struct beiscsi_endpoint *beiscsi_ep;
960 struct beiscsi_offload_params params;
6733b39a 961
99bc5d55
JSJ		 962 beiscsi_log(beiscsi_conn->phba, KERN_INFO,
963 BEISCSI_LOG_CONFIG,
964 "BS_%d : In beiscsi_conn_start\n");
965
6733b39a
JK		 966 memset(&params, 0, sizeof(struct beiscsi_offload_params));
967 beiscsi_ep = beiscsi_conn->ep;
968 if (!beiscsi_ep)
99bc5d55
JSJ		 969 beiscsi_log(beiscsi_conn->phba, KERN_ERR,
970 BEISCSI_LOG_CONFIG,
971 "BS_%d : In beiscsi_conn_start , no beiscsi_ep\n");
6733b39a 972
6733b39a
JK		 973 beiscsi_conn->login_in_progress = 0;
974 beiscsi_set_params_for_offld(beiscsi_conn, &params);
975 beiscsi_offload_connection(beiscsi_conn, &params);
976 iscsi_conn_start(cls_conn);
977 return 0;
978}
979
980/**
981 * beiscsi_get_cid - Allocate a cid
982 * @phba: The phba instance
983 */
984static int beiscsi_get_cid(struct beiscsi_hba *phba)
985{
986 unsigned short cid = 0xFFFF;
987
988 if (!phba->avlbl_cids)
989 return cid;
990
991 cid = phba->cid_array[phba->cid_alloc++];
992 if (phba->cid_alloc == phba->params.cxns_per_ctrl)
993 phba->cid_alloc = 0;
994 phba->avlbl_cids--;
995 return cid;
996}
997
fa95d206
MC		 998/**
999 * beiscsi_put_cid - Free the cid
1000 * @phba: The phba for which the cid is being freed
1001 * @cid: The cid to free
1002 */
1003static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
1004{
1005 phba->avlbl_cids++;
1006 phba->cid_array[phba->cid_free++] = cid;
1007 if (phba->cid_free == phba->params.cxns_per_ctrl)
1008 phba->cid_free = 0;
1009}
1010
1011/**
1012 * beiscsi_free_ep - free endpoint
1013 * @ep: pointer to iscsi endpoint structure
1014 */
1015static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
1016{
1017 struct beiscsi_hba *phba = beiscsi_ep->phba;
1018
1019 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1020 beiscsi_ep->phba = NULL;
1021}
1022
6733b39a
JK		 1023/**
1024 * beiscsi_open_conn - Ask FW to open a TCP connection
1025 * @ep: endpoint to be used
1026 * @src_addr: The source IP address
1027 * @dst_addr: The Destination IP address
1028 *
1029 * Asks the FW to open a TCP connection
1030 */
1031static int beiscsi_open_conn(struct iscsi_endpoint *ep,
1032 struct sockaddr *src_addr,
1033 struct sockaddr *dst_addr, int non_blocking)
1034{
1035 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1036 struct beiscsi_hba *phba = beiscsi_ep->phba;
756d29c8
JK		 1037 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
1038 struct be_mcc_wrb *wrb;
1039 struct tcp_connect_and_offload_out *ptcpcnct_out;
1040 unsigned short status, extd_status;
3cbb7a74 1041 struct be_dma_mem nonemb_cmd;
756d29c8 1042 unsigned int tag, wrb_num;
d3ad2bb3 1043 int ret = -ENOMEM;
6733b39a 1044
99bc5d55
JSJ		 1045 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1046 "BS_%d : In beiscsi_open_conn\n");
1047
6733b39a
JK		 1048 beiscsi_ep->ep_cid = beiscsi_get_cid(phba);
1049 if (beiscsi_ep->ep_cid == 0xFFFF) {
99bc5d55
JSJ		 1050 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1051 "BS_%d : No free cid available\n");
6733b39a
JK		 1052 return ret;
1053 }
99bc5d55
JSJ		 1054
1055 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1056 "BS_%d : In beiscsi_open_conn, ep_cid=%d\n",
1057 beiscsi_ep->ep_cid);
1058
7da50879
JK		 1059 phba->ep_array[beiscsi_ep->ep_cid -
1060 phba->fw_config.iscsi_cid_start] = ep;
1061 if (beiscsi_ep->ep_cid > (phba->fw_config.iscsi_cid_start +
1062 phba->params.cxns_per_ctrl * 2)) {
99bc5d55
JSJ		 1063
1064 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1065 "BS_%d : Failed in allocate iscsi cid\n");
fa95d206 1066 goto free_ep;
6733b39a
JK		 1067 }
1068
1069 beiscsi_ep->cid_vld = 0;
3cbb7a74
JK		 1070 nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
1071 sizeof(struct tcp_connect_and_offload_in),
1072 &nonemb_cmd.dma);
1073 if (nonemb_cmd.va == NULL) {
99bc5d55
JSJ		 1074
1075 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1076 "BS_%d : Failed to allocate memory for"
1077 " mgmt_open_connection\n");
1078
3cbb7a74
JK		 1079 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
1080 return -ENOMEM;
1081 }
1082 nonemb_cmd.size = sizeof(struct tcp_connect_and_offload_in);
1083 memset(nonemb_cmd.va, 0, nonemb_cmd.size);
1084 tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep, &nonemb_cmd);
756d29c8 1085 if (!tag) {
99bc5d55
JSJ		 1086 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1087 "BS_%d : mgmt_open_connection Failed for cid=%d\n",
1088 beiscsi_ep->ep_cid);
1089
1f92638f 1090 beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
3cbb7a74
JK		 1091 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1092 nonemb_cmd.va, nonemb_cmd.dma);
1f92638f 1093 return -EAGAIN;
756d29c8
JK		 1094 } else {
1095 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1096 phba->ctrl.mcc_numtag[tag]);
1097 }
1098 wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
1099 extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
1100 status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
1101 if (status || extd_status) {
99bc5d55
JSJ		 1102 beiscsi_log(phba, KERN_ERR,
1103 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
1104 "BS_%d : mgmt_open_connection Failed"
1105 " status = %d extd_status = %d\n",
1106 status, extd_status);
1107
756d29c8 1108 free_mcc_tag(&phba->ctrl, tag);
3cbb7a74
JK		 1109 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1110 nonemb_cmd.va, nonemb_cmd.dma);
fa95d206 1111 goto free_ep;
756d29c8
JK		 1112 } else {
1113 wrb = queue_get_wrb(mccq, wrb_num);
1114 free_mcc_tag(&phba->ctrl, tag);
1115
457ff3b7 1116 ptcpcnct_out = embedded_payload(wrb);
756d29c8
JK		 1117 beiscsi_ep = ep->dd_data;
1118 beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
1119 beiscsi_ep->cid_vld = 1;
99bc5d55
JSJ		 1120 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1121 "BS_%d : mgmt_open_connection Success\n");
756d29c8 1122 }
3cbb7a74
JK		 1123 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
1124 nonemb_cmd.va, nonemb_cmd.dma);
756d29c8 1125 return 0;
6733b39a 1126
fa95d206
MC		 1127free_ep:
1128 beiscsi_free_ep(beiscsi_ep);
d3ad2bb3 1129 return -EBUSY;
6733b39a
JK		 1130}
1131
1132/**
1133 * beiscsi_ep_connect - Ask chip to create TCP Conn
1134 * @scsi_host: Pointer to scsi_host structure
1135 * @dst_addr: The IP address of Target
1136 * @non_blocking: blocking or non-blocking call
1137 *
1138 * This routines first asks chip to create a connection and then allocates an EP
1139 */
1140struct iscsi_endpoint *
1141beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1142 int non_blocking)
1143{
1144 struct beiscsi_hba *phba;
1145 struct beiscsi_endpoint *beiscsi_ep;
1146 struct iscsi_endpoint *ep;
1147 int ret;
1148
6733b39a
JK		 1149 if (shost)
1150 phba = iscsi_host_priv(shost);
1151 else {
1152 ret = -ENXIO;
99bc5d55
JSJ		 1153 printk(KERN_ERR
1154 "beiscsi_ep_connect shost is NULL\n");
6733b39a
JK		 1155 return ERR_PTR(ret);
1156 }
bfead3b2 1157
5dc1c416 1158 if (phba->state != BE_ADAPTER_UP) {
bfead3b2 1159 ret = -EBUSY;
8359c79b
JSJ		 1160 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
1161 "BS_%d : The Adapter Port state is Down!!!\n");
bfead3b2
JK		 1162 return ERR_PTR(ret);
1163 }
1164
6733b39a
JK		 1165 ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
1166 if (!ep) {
1167 ret = -ENOMEM;
1168 return ERR_PTR(ret);
1169 }
1170
1171 beiscsi_ep = ep->dd_data;
1172 beiscsi_ep->phba = phba;
c2462288 1173 beiscsi_ep->openiscsi_ep = ep;
f5ed7bd4
JK		 1174 ret = beiscsi_open_conn(ep, NULL, dst_addr, non_blocking);
1175 if (ret) {
99bc5d55
JSJ		 1176 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
1177 "BS_%d : Failed in beiscsi_open_conn\n");
6733b39a
JK		 1178 goto free_ep;
1179 }
1180
1181 return ep;
1182
1183free_ep:
fa95d206 1184 iscsi_destroy_endpoint(ep);
6733b39a
JK		 1185 return ERR_PTR(ret);
1186}
1187
1188/**
1189 * beiscsi_ep_poll - Poll to see if connection is established
1190 * @ep: endpoint to be used
1191 * @timeout_ms: timeout specified in millisecs
1192 *
1193 * Poll to see if TCP connection established
1194 */
1195int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1196{
1197 struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
1198
99bc5d55
JSJ		 1199 beiscsi_log(beiscsi_ep->phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1200 "BS_%d : In beiscsi_ep_poll\n");
1201
6733b39a
JK		 1202 if (beiscsi_ep->cid_vld == 1)
1203 return 1;
1204 else
1205 return 0;
1206}
1207
1208/**
1209 * beiscsi_close_conn - Upload the connection
1210 * @ep: The iscsi endpoint
1211 * @flag: The type of connection closure
1212 */
c2462288 1213static int beiscsi_close_conn(struct beiscsi_endpoint *beiscsi_ep, int flag)
6733b39a
JK		 1214{
1215 int ret = 0;
756d29c8 1216 unsigned int tag;
6733b39a
JK		 1217 struct beiscsi_hba *phba = beiscsi_ep->phba;
1218
756d29c8
JK		 1219 tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
1220 if (!tag) {
99bc5d55
JSJ		 1221 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1222 "BS_%d : upload failed for cid 0x%x\n",
1223 beiscsi_ep->ep_cid);
1224
d3ad2bb3 1225 ret = -EAGAIN;
756d29c8
JK		 1226 } else {
1227 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1228 phba->ctrl.mcc_numtag[tag]);
1229 free_mcc_tag(&phba->ctrl, tag);
6733b39a 1230 }
6733b39a
JK		 1231 return ret;
1232}
1233
6733b39a
JK		 1234/**
1235 * beiscsi_unbind_conn_to_cid - Unbind the beiscsi_conn from phba conn table
1236 * @phba: The phba instance
1237 * @cid: The cid to free
1238 */
1239static int beiscsi_unbind_conn_to_cid(struct beiscsi_hba *phba,
1240 unsigned int cid)
1241{
1242 if (phba->conn_table[cid])
1243 phba->conn_table[cid] = NULL;
1244 else {
99bc5d55
JSJ		 1245 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1246 "BS_%d : Connection table Not occupied.\n");
6733b39a
JK		 1247 return -EINVAL;
1248 }
1249 return 0;
1250}
1251
1252/**
fa95d206
MC		 1253 * beiscsi_ep_disconnect - Tears down the TCP connection
1254 * @ep: endpoint to be used
1255 *
1256 * Tears down the TCP connection
6733b39a 1257 */
fa95d206 1258void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
6733b39a 1259{
fa95d206 1260 struct beiscsi_conn *beiscsi_conn;
6733b39a 1261 struct beiscsi_endpoint *beiscsi_ep;
fa95d206 1262 struct beiscsi_hba *phba;
756d29c8 1263 unsigned int tag;
0a513dd8 1264 uint8_t mgmt_invalidate_flag, tcp_upload_flag;
6733b39a
JK		 1265 unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
1266
fa95d206
MC		 1267 beiscsi_ep = ep->dd_data;
1268 phba = beiscsi_ep->phba;
99bc5d55
JSJ		 1269 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
1270 "BS_%d : In beiscsi_ep_disconnect for ep_cid = %d\n",
1271 beiscsi_ep->ep_cid);
fa95d206 1272
0a513dd8
JSJ		 1273 if (beiscsi_ep->conn) {
1274 beiscsi_conn = beiscsi_ep->conn;
1275 iscsi_suspend_queue(beiscsi_conn->conn);
1276 mgmt_invalidate_flag = ~BEISCSI_NO_RST_ISSUE;
1277 tcp_upload_flag = CONNECTION_UPLOAD_GRACEFUL;
1278 } else {
1279 mgmt_invalidate_flag = BEISCSI_NO_RST_ISSUE;
1280 tcp_upload_flag = CONNECTION_UPLOAD_ABORT;
6733b39a 1281 }
fa95d206 1282
756d29c8 1283 tag = mgmt_invalidate_connection(phba, beiscsi_ep,
0a513dd8
JSJ		 1284 beiscsi_ep->ep_cid,
1285 mgmt_invalidate_flag,
1286 savecfg_flag);
756d29c8 1287 if (!tag) {
99bc5d55 1288 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
0a513dd8 1289 "BS_%d : mgmt_invalidate_connection Failed for cid=%d\n",
99bc5d55 1290 beiscsi_ep->ep_cid);
756d29c8
JK		 1291 } else {
1292 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
1293 phba->ctrl.mcc_numtag[tag]);
1294 free_mcc_tag(&phba->ctrl, tag);
6733b39a 1295 }
fa95d206 1296
0a513dd8 1297 beiscsi_close_conn(beiscsi_ep, tcp_upload_flag);
c2462288 1298 beiscsi_free_ep(beiscsi_ep);
6733b39a 1299 beiscsi_unbind_conn_to_cid(phba, beiscsi_ep->ep_cid);
fa95d206 1300 iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
6733b39a 1301}
3128c6c7 1302
587a1f16 1303umode_t be2iscsi_attr_is_visible(int param_type, int param)
3128c6c7
MC		 1304{
1305 switch (param_type) {
0e43895e
MC		 1306 case ISCSI_NET_PARAM:
1307 switch (param) {
1308 case ISCSI_NET_PARAM_IFACE_ENABLE:
1309 case ISCSI_NET_PARAM_IPV4_ADDR:
1310 case ISCSI_NET_PARAM_IPV4_SUBNET:
1311 case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
1312 case ISCSI_NET_PARAM_IPV4_GW:
1313 case ISCSI_NET_PARAM_IPV6_ADDR:
6f72238e
JSJ		 1314 case ISCSI_NET_PARAM_VLAN_ID:
1315 case ISCSI_NET_PARAM_VLAN_PRIORITY:
1316 case ISCSI_NET_PARAM_VLAN_ENABLED:
0e43895e
MC		 1317 return S_IRUGO;
1318 default:
1319 return 0;
1320 }
f27fb2ef
MC		 1321 case ISCSI_HOST_PARAM:
1322 switch (param) {
1323 case ISCSI_HOST_PARAM_HWADDRESS:
c62eef0d
JSJ		 1324 case ISCSI_HOST_PARAM_INITIATOR_NAME:
1325 case ISCSI_HOST_PARAM_PORT_STATE:
1326 case ISCSI_HOST_PARAM_PORT_SPEED:
f27fb2ef
MC		 1327 return S_IRUGO;
1328 default:
1329 return 0;
1330 }
3128c6c7
MC		 1331 case ISCSI_PARAM:
1332 switch (param) {
1333 case ISCSI_PARAM_MAX_RECV_DLENGTH:
1334 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
1335 case ISCSI_PARAM_HDRDGST_EN:
1336 case ISCSI_PARAM_DATADGST_EN:
1337 case ISCSI_PARAM_CONN_ADDRESS:
1338 case ISCSI_PARAM_CONN_PORT:
1339 case ISCSI_PARAM_EXP_STATSN:
1340 case ISCSI_PARAM_PERSISTENT_ADDRESS:
1341 case ISCSI_PARAM_PERSISTENT_PORT:
1342 case ISCSI_PARAM_PING_TMO:
1343 case ISCSI_PARAM_RECV_TMO:
1d063c17
MC		 1344 case ISCSI_PARAM_INITIAL_R2T_EN:
1345 case ISCSI_PARAM_MAX_R2T:
1346 case ISCSI_PARAM_IMM_DATA_EN:
1347 case ISCSI_PARAM_FIRST_BURST:
1348 case ISCSI_PARAM_MAX_BURST:
1349 case ISCSI_PARAM_PDU_INORDER_EN:
1350 case ISCSI_PARAM_DATASEQ_INORDER_EN:
1351 case ISCSI_PARAM_ERL:
1352 case ISCSI_PARAM_TARGET_NAME:
1353 case ISCSI_PARAM_TPGT:
1354 case ISCSI_PARAM_USERNAME:
1355 case ISCSI_PARAM_PASSWORD:
1356 case ISCSI_PARAM_USERNAME_IN:
1357 case ISCSI_PARAM_PASSWORD_IN:
1358 case ISCSI_PARAM_FAST_ABORT:
1359 case ISCSI_PARAM_ABORT_TMO:
1360 case ISCSI_PARAM_LU_RESET_TMO:
1361 case ISCSI_PARAM_IFACE_NAME:
1362 case ISCSI_PARAM_INITIATOR_NAME:
3128c6c7
MC		 1363 return S_IRUGO;
1364 default:
1365 return 0;
1366 }
1367 }
1368
1369 return 0;
1370}
ubuntu-bionic-kernel mirror