linux/drivers/scsi/qla4xxx/ql4_os.c
<<
>>
Prefs
   1/*
   2 * QLogic iSCSI HBA Driver
   3 * Copyright (c)  2003-2013 QLogic Corporation
   4 *
   5 * See LICENSE.qla4xxx for copyright and licensing details.
   6 */
   7#include <linux/moduleparam.h>
   8#include <linux/slab.h>
   9#include <linux/blkdev.h>
  10#include <linux/iscsi_boot_sysfs.h>
  11#include <linux/inet.h>
  12
  13#include <scsi/scsi_tcq.h>
  14#include <scsi/scsicam.h>
  15
  16#include "ql4_def.h"
  17#include "ql4_version.h"
  18#include "ql4_glbl.h"
  19#include "ql4_dbg.h"
  20#include "ql4_inline.h"
  21#include "ql4_83xx.h"
  22
  23/*
  24 * Driver version
  25 */
  26static char qla4xxx_version_str[40];
  27
  28/*
  29 * SRB allocation cache
  30 */
  31static struct kmem_cache *srb_cachep;
  32
  33/*
  34 * Module parameter information and variables
  35 */
  36static int ql4xdisablesysfsboot = 1;
  37module_param(ql4xdisablesysfsboot, int, S_IRUGO | S_IWUSR);
  38MODULE_PARM_DESC(ql4xdisablesysfsboot,
  39                 " Set to disable exporting boot targets to sysfs.\n"
  40                 "\t\t  0 - Export boot targets\n"
  41                 "\t\t  1 - Do not export boot targets (Default)");
  42
  43int ql4xdontresethba;
  44module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR);
  45MODULE_PARM_DESC(ql4xdontresethba,
  46                 " Don't reset the HBA for driver recovery.\n"
  47                 "\t\t  0 - It will reset HBA (Default)\n"
  48                 "\t\t  1 - It will NOT reset HBA");
  49
  50int ql4xextended_error_logging;
  51module_param(ql4xextended_error_logging, int, S_IRUGO | S_IWUSR);
  52MODULE_PARM_DESC(ql4xextended_error_logging,
  53                 " Option to enable extended error logging.\n"
  54                 "\t\t  0 - no logging (Default)\n"
  55                 "\t\t  2 - debug logging");
  56
  57int ql4xenablemsix = 1;
  58module_param(ql4xenablemsix, int, S_IRUGO|S_IWUSR);
  59MODULE_PARM_DESC(ql4xenablemsix,
  60                 " Set to enable MSI or MSI-X interrupt mechanism.\n"
  61                 "\t\t  0 = enable INTx interrupt mechanism.\n"
  62                 "\t\t  1 = enable MSI-X interrupt mechanism (Default).\n"
  63                 "\t\t  2 = enable MSI interrupt mechanism.");
  64
  65#define QL4_DEF_QDEPTH 32
  66static int ql4xmaxqdepth = QL4_DEF_QDEPTH;
  67module_param(ql4xmaxqdepth, int, S_IRUGO | S_IWUSR);
  68MODULE_PARM_DESC(ql4xmaxqdepth,
  69                 " Maximum queue depth to report for target devices.\n"
  70                 "\t\t  Default: 32.");
  71
  72static int ql4xqfulltracking = 1;
  73module_param(ql4xqfulltracking, int, S_IRUGO | S_IWUSR);
  74MODULE_PARM_DESC(ql4xqfulltracking,
  75                 " Enable or disable dynamic tracking and adjustment of\n"
  76                 "\t\t scsi device queue depth.\n"
  77                 "\t\t  0 - Disable.\n"
  78                 "\t\t  1 - Enable. (Default)");
  79
  80static int ql4xsess_recovery_tmo = QL4_SESS_RECOVERY_TMO;
  81module_param(ql4xsess_recovery_tmo, int, S_IRUGO);
  82MODULE_PARM_DESC(ql4xsess_recovery_tmo,
  83                " Target Session Recovery Timeout.\n"
  84                "\t\t  Default: 120 sec.");
  85
  86int ql4xmdcapmask = 0;
  87module_param(ql4xmdcapmask, int, S_IRUGO);
  88MODULE_PARM_DESC(ql4xmdcapmask,
  89                 " Set the Minidump driver capture mask level.\n"
  90                 "\t\t  Default is 0 (firmware default capture mask)\n"
  91                 "\t\t  Can be set to 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF");
  92
  93int ql4xenablemd = 1;
  94module_param(ql4xenablemd, int, S_IRUGO | S_IWUSR);
  95MODULE_PARM_DESC(ql4xenablemd,
  96                 " Set to enable minidump.\n"
  97                 "\t\t  0 - disable minidump\n"
  98                 "\t\t  1 - enable minidump (Default)");
  99
 100static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha);
 101/*
 102 * SCSI host template entry points
 103 */
 104static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);
 105
 106/*
 107 * iSCSI template entry points
 108 */
 109static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
 110                                     enum iscsi_param param, char *buf);
 111static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn,
 112                                  enum iscsi_param param, char *buf);
 113static int qla4xxx_host_get_param(struct Scsi_Host *shost,
 114                                  enum iscsi_host_param param, char *buf);
 115static int qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data,
 116                                   uint32_t len);
 117static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
 118                                   enum iscsi_param_type param_type,
 119                                   int param, char *buf);
 120static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc);
 121static struct iscsi_endpoint *qla4xxx_ep_connect(struct Scsi_Host *shost,
 122                                                 struct sockaddr *dst_addr,
 123                                                 int non_blocking);
 124static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms);
 125static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep);
 126static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
 127                                enum iscsi_param param, char *buf);
 128static int qla4xxx_conn_start(struct iscsi_cls_conn *conn);
 129static struct iscsi_cls_conn *
 130qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx);
 131static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
 132                             struct iscsi_cls_conn *cls_conn,
 133                             uint64_t transport_fd, int is_leading);
 134static void qla4xxx_conn_destroy(struct iscsi_cls_conn *conn);
 135static struct iscsi_cls_session *
 136qla4xxx_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max,
 137                        uint16_t qdepth, uint32_t initial_cmdsn);
 138static void qla4xxx_session_destroy(struct iscsi_cls_session *sess);
 139static void qla4xxx_task_work(struct work_struct *wdata);
 140static int qla4xxx_alloc_pdu(struct iscsi_task *, uint8_t);
 141static int qla4xxx_task_xmit(struct iscsi_task *);
 142static void qla4xxx_task_cleanup(struct iscsi_task *);
 143static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session);
 144static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
 145                                   struct iscsi_stats *stats);
 146static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
 147                             uint32_t iface_type, uint32_t payload_size,
 148                             uint32_t pid, struct sockaddr *dst_addr);
 149static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
 150                                 uint32_t *num_entries, char *buf);
 151static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx);
 152static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void  *data,
 153                                  int len);
 154static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len);
 155
 156/*
 157 * SCSI host template entry points
 158 */
 159static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
 160static int qla4xxx_eh_abort(struct scsi_cmnd *cmd);
 161static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);
 162static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);
 163static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd);
 164static int qla4xxx_slave_alloc(struct scsi_device *device);
 165static umode_t qla4_attr_is_visible(int param_type, int param);
 166static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type);
 167
 168/*
 169 * iSCSI Flash DDB sysfs entry points
 170 */
 171static int
 172qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
 173                            struct iscsi_bus_flash_conn *fnode_conn,
 174                            void *data, int len);
 175static int
 176qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
 177                            int param, char *buf);
 178static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
 179                                 int len);
 180static int
 181qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess);
 182static int qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session *fnode_sess,
 183                                   struct iscsi_bus_flash_conn *fnode_conn);
 184static int qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session *fnode_sess,
 185                                    struct iscsi_bus_flash_conn *fnode_conn);
 186static int qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session *cls_sess);
 187
 188static struct qla4_8xxx_legacy_intr_set legacy_intr[] =
 189    QLA82XX_LEGACY_INTR_CONFIG;
 190
 191static struct scsi_host_template qla4xxx_driver_template = {
 192        .module                 = THIS_MODULE,
 193        .name                   = DRIVER_NAME,
 194        .proc_name              = DRIVER_NAME,
 195        .queuecommand           = qla4xxx_queuecommand,
 196
 197        .eh_abort_handler       = qla4xxx_eh_abort,
 198        .eh_device_reset_handler = qla4xxx_eh_device_reset,
 199        .eh_target_reset_handler = qla4xxx_eh_target_reset,
 200        .eh_host_reset_handler  = qla4xxx_eh_host_reset,
 201        .eh_timed_out           = qla4xxx_eh_cmd_timed_out,
 202
 203        .slave_alloc            = qla4xxx_slave_alloc,
 204        .change_queue_depth     = scsi_change_queue_depth,
 205
 206        .this_id                = -1,
 207        .cmd_per_lun            = 3,
 208        .sg_tablesize           = SG_ALL,
 209
 210        .max_sectors            = 0xFFFF,
 211        .shost_attrs            = qla4xxx_host_attrs,
 212        .host_reset             = qla4xxx_host_reset,
 213        .vendor_id              = SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC,
 214};
 215
 216static struct iscsi_transport qla4xxx_iscsi_transport = {
 217        .owner                  = THIS_MODULE,
 218        .name                   = DRIVER_NAME,
 219        .caps                   = CAP_TEXT_NEGO |
 220                                  CAP_DATA_PATH_OFFLOAD | CAP_HDRDGST |
 221                                  CAP_DATADGST | CAP_LOGIN_OFFLOAD |
 222                                  CAP_MULTI_R2T,
 223        .attr_is_visible        = qla4_attr_is_visible,
 224        .create_session         = qla4xxx_session_create,
 225        .destroy_session        = qla4xxx_session_destroy,
 226        .start_conn             = qla4xxx_conn_start,
 227        .create_conn            = qla4xxx_conn_create,
 228        .bind_conn              = qla4xxx_conn_bind,
 229        .stop_conn              = iscsi_conn_stop,
 230        .destroy_conn           = qla4xxx_conn_destroy,
 231        .set_param              = iscsi_set_param,
 232        .get_conn_param         = qla4xxx_conn_get_param,
 233        .get_session_param      = qla4xxx_session_get_param,
 234        .get_ep_param           = qla4xxx_get_ep_param,
 235        .ep_connect             = qla4xxx_ep_connect,
 236        .ep_poll                = qla4xxx_ep_poll,
 237        .ep_disconnect          = qla4xxx_ep_disconnect,
 238        .get_stats              = qla4xxx_conn_get_stats,
 239        .send_pdu               = iscsi_conn_send_pdu,
 240        .xmit_task              = qla4xxx_task_xmit,
 241        .cleanup_task           = qla4xxx_task_cleanup,
 242        .alloc_pdu              = qla4xxx_alloc_pdu,
 243
 244        .get_host_param         = qla4xxx_host_get_param,
 245        .set_iface_param        = qla4xxx_iface_set_param,
 246        .get_iface_param        = qla4xxx_get_iface_param,
 247        .bsg_request            = qla4xxx_bsg_request,
 248        .send_ping              = qla4xxx_send_ping,
 249        .get_chap               = qla4xxx_get_chap_list,
 250        .delete_chap            = qla4xxx_delete_chap,
 251        .set_chap               = qla4xxx_set_chap_entry,
 252        .get_flashnode_param    = qla4xxx_sysfs_ddb_get_param,
 253        .set_flashnode_param    = qla4xxx_sysfs_ddb_set_param,
 254        .new_flashnode          = qla4xxx_sysfs_ddb_add,
 255        .del_flashnode          = qla4xxx_sysfs_ddb_delete,
 256        .login_flashnode        = qla4xxx_sysfs_ddb_login,
 257        .logout_flashnode       = qla4xxx_sysfs_ddb_logout,
 258        .logout_flashnode_sid   = qla4xxx_sysfs_ddb_logout_sid,
 259        .get_host_stats         = qla4xxx_get_host_stats,
 260};
 261
 262static struct scsi_transport_template *qla4xxx_scsi_transport;
 263
 264static int qla4xxx_isp_check_reg(struct scsi_qla_host *ha)
 265{
 266        u32 reg_val = 0;
 267        int rval = QLA_SUCCESS;
 268
 269        if (is_qla8022(ha))
 270                reg_val = readl(&ha->qla4_82xx_reg->host_status);
 271        else if (is_qla8032(ha) || is_qla8042(ha))
 272                reg_val = qla4_8xxx_rd_direct(ha, QLA8XXX_PEG_ALIVE_COUNTER);
 273        else
 274                reg_val = readw(&ha->reg->ctrl_status);
 275
 276        if (reg_val == QL4_ISP_REG_DISCONNECT)
 277                rval = QLA_ERROR;
 278
 279        return rval;
 280}
 281
 282static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
 283                             uint32_t iface_type, uint32_t payload_size,
 284                             uint32_t pid, struct sockaddr *dst_addr)
 285{
 286        struct scsi_qla_host *ha = to_qla_host(shost);
 287        struct sockaddr_in *addr;
 288        struct sockaddr_in6 *addr6;
 289        uint32_t options = 0;
 290        uint8_t ipaddr[IPv6_ADDR_LEN];
 291        int rval;
 292
 293        memset(ipaddr, 0, IPv6_ADDR_LEN);
 294        /* IPv4 to IPv4 */
 295        if ((iface_type == ISCSI_IFACE_TYPE_IPV4) &&
 296            (dst_addr->sa_family == AF_INET)) {
 297                addr = (struct sockaddr_in *)dst_addr;
 298                memcpy(ipaddr, &addr->sin_addr.s_addr, IP_ADDR_LEN);
 299                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv4 Ping src: %pI4 "
 300                                  "dest: %pI4\n", __func__,
 301                                  &ha->ip_config.ip_address, ipaddr));
 302                rval = qla4xxx_ping_iocb(ha, options, payload_size, pid,
 303                                         ipaddr);
 304                if (rval)
 305                        rval = -EINVAL;
 306        } else if ((iface_type == ISCSI_IFACE_TYPE_IPV6) &&
 307                   (dst_addr->sa_family == AF_INET6)) {
 308                /* IPv6 to IPv6 */
 309                addr6 = (struct sockaddr_in6 *)dst_addr;
 310                memcpy(ipaddr, &addr6->sin6_addr.in6_u.u6_addr8, IPv6_ADDR_LEN);
 311
 312                options |= PING_IPV6_PROTOCOL_ENABLE;
 313
 314                /* Ping using LinkLocal address */
 315                if ((iface_num == 0) || (iface_num == 1)) {
 316                        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: LinkLocal Ping "
 317                                          "src: %pI6 dest: %pI6\n", __func__,
 318                                          &ha->ip_config.ipv6_link_local_addr,
 319                                          ipaddr));
 320                        options |= PING_IPV6_LINKLOCAL_ADDR;
 321                        rval = qla4xxx_ping_iocb(ha, options, payload_size,
 322                                                 pid, ipaddr);
 323                } else {
 324                        ql4_printk(KERN_WARNING, ha, "%s: iface num = %d "
 325                                   "not supported\n", __func__, iface_num);
 326                        rval = -ENOSYS;
 327                        goto exit_send_ping;
 328                }
 329
 330                /*
 331                 * If ping using LinkLocal address fails, try ping using
 332                 * IPv6 address
 333                 */
 334                if (rval != QLA_SUCCESS) {
 335                        options &= ~PING_IPV6_LINKLOCAL_ADDR;
 336                        if (iface_num == 0) {
 337                                options |= PING_IPV6_ADDR0;
 338                                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
 339                                                  "Ping src: %pI6 "
 340                                                  "dest: %pI6\n", __func__,
 341                                                  &ha->ip_config.ipv6_addr0,
 342                                                  ipaddr));
 343                        } else if (iface_num == 1) {
 344                                options |= PING_IPV6_ADDR1;
 345                                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
 346                                                  "Ping src: %pI6 "
 347                                                  "dest: %pI6\n", __func__,
 348                                                  &ha->ip_config.ipv6_addr1,
 349                                                  ipaddr));
 350                        }
 351                        rval = qla4xxx_ping_iocb(ha, options, payload_size,
 352                                                 pid, ipaddr);
 353                        if (rval)
 354                                rval = -EINVAL;
 355                }
 356        } else
 357                rval = -ENOSYS;
 358exit_send_ping:
 359        return rval;
 360}
 361
 362static umode_t qla4_attr_is_visible(int param_type, int param)
 363{
 364        switch (param_type) {
 365        case ISCSI_HOST_PARAM:
 366                switch (param) {
 367                case ISCSI_HOST_PARAM_HWADDRESS:
 368                case ISCSI_HOST_PARAM_IPADDRESS:
 369                case ISCSI_HOST_PARAM_INITIATOR_NAME:
 370                case ISCSI_HOST_PARAM_PORT_STATE:
 371                case ISCSI_HOST_PARAM_PORT_SPEED:
 372                        return S_IRUGO;
 373                default:
 374                        return 0;
 375                }
 376        case ISCSI_PARAM:
 377                switch (param) {
 378                case ISCSI_PARAM_PERSISTENT_ADDRESS:
 379                case ISCSI_PARAM_PERSISTENT_PORT:
 380                case ISCSI_PARAM_CONN_ADDRESS:
 381                case ISCSI_PARAM_CONN_PORT:
 382                case ISCSI_PARAM_TARGET_NAME:
 383                case ISCSI_PARAM_TPGT:
 384                case ISCSI_PARAM_TARGET_ALIAS:
 385                case ISCSI_PARAM_MAX_BURST:
 386                case ISCSI_PARAM_MAX_R2T:
 387                case ISCSI_PARAM_FIRST_BURST:
 388                case ISCSI_PARAM_MAX_RECV_DLENGTH:
 389                case ISCSI_PARAM_MAX_XMIT_DLENGTH:
 390                case ISCSI_PARAM_IFACE_NAME:
 391                case ISCSI_PARAM_CHAP_OUT_IDX:
 392                case ISCSI_PARAM_CHAP_IN_IDX:
 393                case ISCSI_PARAM_USERNAME:
 394                case ISCSI_PARAM_PASSWORD:
 395                case ISCSI_PARAM_USERNAME_IN:
 396                case ISCSI_PARAM_PASSWORD_IN:
 397                case ISCSI_PARAM_AUTO_SND_TGT_DISABLE:
 398                case ISCSI_PARAM_DISCOVERY_SESS:
 399                case ISCSI_PARAM_PORTAL_TYPE:
 400                case ISCSI_PARAM_CHAP_AUTH_EN:
 401                case ISCSI_PARAM_DISCOVERY_LOGOUT_EN:
 402                case ISCSI_PARAM_BIDI_CHAP_EN:
 403                case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL:
 404                case ISCSI_PARAM_DEF_TIME2WAIT:
 405                case ISCSI_PARAM_DEF_TIME2RETAIN:
 406                case ISCSI_PARAM_HDRDGST_EN:
 407                case ISCSI_PARAM_DATADGST_EN:
 408                case ISCSI_PARAM_INITIAL_R2T_EN:
 409                case ISCSI_PARAM_IMM_DATA_EN:
 410                case ISCSI_PARAM_PDU_INORDER_EN:
 411                case ISCSI_PARAM_DATASEQ_INORDER_EN:
 412                case ISCSI_PARAM_MAX_SEGMENT_SIZE:
 413                case ISCSI_PARAM_TCP_TIMESTAMP_STAT:
 414                case ISCSI_PARAM_TCP_WSF_DISABLE:
 415                case ISCSI_PARAM_TCP_NAGLE_DISABLE:
 416                case ISCSI_PARAM_TCP_TIMER_SCALE:
 417                case ISCSI_PARAM_TCP_TIMESTAMP_EN:
 418                case ISCSI_PARAM_TCP_XMIT_WSF:
 419                case ISCSI_PARAM_TCP_RECV_WSF:
 420                case ISCSI_PARAM_IP_FRAGMENT_DISABLE:
 421                case ISCSI_PARAM_IPV4_TOS:
 422                case ISCSI_PARAM_IPV6_TC:
 423                case ISCSI_PARAM_IPV6_FLOW_LABEL:
 424                case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6:
 425                case ISCSI_PARAM_KEEPALIVE_TMO:
 426                case ISCSI_PARAM_LOCAL_PORT:
 427                case ISCSI_PARAM_ISID:
 428                case ISCSI_PARAM_TSID:
 429                case ISCSI_PARAM_DEF_TASKMGMT_TMO:
 430                case ISCSI_PARAM_ERL:
 431                case ISCSI_PARAM_STATSN:
 432                case ISCSI_PARAM_EXP_STATSN:
 433                case ISCSI_PARAM_DISCOVERY_PARENT_IDX:
 434                case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
 435                case ISCSI_PARAM_LOCAL_IPADDR:
 436                        return S_IRUGO;
 437                default:
 438                        return 0;
 439                }
 440        case ISCSI_NET_PARAM:
 441                switch (param) {
 442                case ISCSI_NET_PARAM_IPV4_ADDR:
 443                case ISCSI_NET_PARAM_IPV4_SUBNET:
 444                case ISCSI_NET_PARAM_IPV4_GW:
 445                case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
 446                case ISCSI_NET_PARAM_IFACE_ENABLE:
 447                case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
 448                case ISCSI_NET_PARAM_IPV6_ADDR:
 449                case ISCSI_NET_PARAM_IPV6_ROUTER:
 450                case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
 451                case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
 452                case ISCSI_NET_PARAM_VLAN_ID:
 453                case ISCSI_NET_PARAM_VLAN_PRIORITY:
 454                case ISCSI_NET_PARAM_VLAN_ENABLED:
 455                case ISCSI_NET_PARAM_MTU:
 456                case ISCSI_NET_PARAM_PORT:
 457                case ISCSI_NET_PARAM_IPADDR_STATE:
 458                case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
 459                case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
 460                case ISCSI_NET_PARAM_DELAYED_ACK_EN:
 461                case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
 462                case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
 463                case ISCSI_NET_PARAM_TCP_WSF:
 464                case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
 465                case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
 466                case ISCSI_NET_PARAM_CACHE_ID:
 467                case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
 468                case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
 469                case ISCSI_NET_PARAM_IPV4_TOS_EN:
 470                case ISCSI_NET_PARAM_IPV4_TOS:
 471                case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
 472                case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
 473                case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
 474                case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
 475                case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
 476                case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
 477                case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
 478                case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
 479                case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
 480                case ISCSI_NET_PARAM_REDIRECT_EN:
 481                case ISCSI_NET_PARAM_IPV4_TTL:
 482                case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
 483                case ISCSI_NET_PARAM_IPV6_MLD_EN:
 484                case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
 485                case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
 486                case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
 487                case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
 488                case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
 489                case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
 490                case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
 491                case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
 492                        return S_IRUGO;
 493                default:
 494                        return 0;
 495                }
 496        case ISCSI_IFACE_PARAM:
 497                switch (param) {
 498                case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
 499                case ISCSI_IFACE_PARAM_HDRDGST_EN:
 500                case ISCSI_IFACE_PARAM_DATADGST_EN:
 501                case ISCSI_IFACE_PARAM_IMM_DATA_EN:
 502                case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
 503                case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
 504                case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
 505                case ISCSI_IFACE_PARAM_ERL:
 506                case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
 507                case ISCSI_IFACE_PARAM_FIRST_BURST:
 508                case ISCSI_IFACE_PARAM_MAX_R2T:
 509                case ISCSI_IFACE_PARAM_MAX_BURST:
 510                case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
 511                case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
 512                case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
 513                case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
 514                case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
 515                case ISCSI_IFACE_PARAM_INITIATOR_NAME:
 516                        return S_IRUGO;
 517                default:
 518                        return 0;
 519                }
 520        case ISCSI_FLASHNODE_PARAM:
 521                switch (param) {
 522                case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
 523                case ISCSI_FLASHNODE_PORTAL_TYPE:
 524                case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
 525                case ISCSI_FLASHNODE_DISCOVERY_SESS:
 526                case ISCSI_FLASHNODE_ENTRY_EN:
 527                case ISCSI_FLASHNODE_HDR_DGST_EN:
 528                case ISCSI_FLASHNODE_DATA_DGST_EN:
 529                case ISCSI_FLASHNODE_IMM_DATA_EN:
 530                case ISCSI_FLASHNODE_INITIAL_R2T_EN:
 531                case ISCSI_FLASHNODE_DATASEQ_INORDER:
 532                case ISCSI_FLASHNODE_PDU_INORDER:
 533                case ISCSI_FLASHNODE_CHAP_AUTH_EN:
 534                case ISCSI_FLASHNODE_SNACK_REQ_EN:
 535                case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
 536                case ISCSI_FLASHNODE_BIDI_CHAP_EN:
 537                case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
 538                case ISCSI_FLASHNODE_ERL:
 539                case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
 540                case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
 541                case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
 542                case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
 543                case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
 544                case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
 545                case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
 546                case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
 547                case ISCSI_FLASHNODE_FIRST_BURST:
 548                case ISCSI_FLASHNODE_DEF_TIME2WAIT:
 549                case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
 550                case ISCSI_FLASHNODE_MAX_R2T:
 551                case ISCSI_FLASHNODE_KEEPALIVE_TMO:
 552                case ISCSI_FLASHNODE_ISID:
 553                case ISCSI_FLASHNODE_TSID:
 554                case ISCSI_FLASHNODE_PORT:
 555                case ISCSI_FLASHNODE_MAX_BURST:
 556                case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
 557                case ISCSI_FLASHNODE_IPADDR:
 558                case ISCSI_FLASHNODE_ALIAS:
 559                case ISCSI_FLASHNODE_REDIRECT_IPADDR:
 560                case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
 561                case ISCSI_FLASHNODE_LOCAL_PORT:
 562                case ISCSI_FLASHNODE_IPV4_TOS:
 563                case ISCSI_FLASHNODE_IPV6_TC:
 564                case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
 565                case ISCSI_FLASHNODE_NAME:
 566                case ISCSI_FLASHNODE_TPGT:
 567                case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
 568                case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
 569                case ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE:
 570                case ISCSI_FLASHNODE_TCP_XMIT_WSF:
 571                case ISCSI_FLASHNODE_TCP_RECV_WSF:
 572                case ISCSI_FLASHNODE_CHAP_OUT_IDX:
 573                case ISCSI_FLASHNODE_USERNAME:
 574                case ISCSI_FLASHNODE_PASSWORD:
 575                case ISCSI_FLASHNODE_STATSN:
 576                case ISCSI_FLASHNODE_EXP_STATSN:
 577                case ISCSI_FLASHNODE_IS_BOOT_TGT:
 578                        return S_IRUGO;
 579                default:
 580                        return 0;
 581                }
 582        }
 583
 584        return 0;
 585}
 586
 587/**
 588 * qla4xxx_create chap_list - Create CHAP list from FLASH
 589 * @ha: pointer to adapter structure
 590 *
 591 * Read flash and make a list of CHAP entries, during login when a CHAP entry
 592 * is received, it will be checked in this list. If entry exist then the CHAP
 593 * entry index is set in the DDB. If CHAP entry does not exist in this list
 594 * then a new entry is added in FLASH in CHAP table and the index obtained is
 595 * used in the DDB.
 596 **/
 597static void qla4xxx_create_chap_list(struct scsi_qla_host *ha)
 598{
 599        int rval = 0;
 600        uint8_t *chap_flash_data = NULL;
 601        uint32_t offset;
 602        dma_addr_t chap_dma;
 603        uint32_t chap_size = 0;
 604
 605        if (is_qla40XX(ha))
 606                chap_size = MAX_CHAP_ENTRIES_40XX *
 607                            sizeof(struct ql4_chap_table);
 608        else    /* Single region contains CHAP info for both
 609                 * ports which is divided into half for each port.
 610                 */
 611                chap_size = ha->hw.flt_chap_size / 2;
 612
 613        chap_flash_data = dma_alloc_coherent(&ha->pdev->dev, chap_size,
 614                                             &chap_dma, GFP_KERNEL);
 615        if (!chap_flash_data) {
 616                ql4_printk(KERN_ERR, ha, "No memory for chap_flash_data\n");
 617                return;
 618        }
 619
 620        if (is_qla40XX(ha)) {
 621                offset = FLASH_CHAP_OFFSET;
 622        } else {
 623                offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
 624                if (ha->port_num == 1)
 625                        offset += chap_size;
 626        }
 627
 628        rval = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
 629        if (rval != QLA_SUCCESS)
 630                goto exit_chap_list;
 631
 632        if (ha->chap_list == NULL)
 633                ha->chap_list = vmalloc(chap_size);
 634        if (ha->chap_list == NULL) {
 635                ql4_printk(KERN_ERR, ha, "No memory for ha->chap_list\n");
 636                goto exit_chap_list;
 637        }
 638
 639        memset(ha->chap_list, 0, chap_size);
 640        memcpy(ha->chap_list, chap_flash_data, chap_size);
 641
 642exit_chap_list:
 643        dma_free_coherent(&ha->pdev->dev, chap_size, chap_flash_data, chap_dma);
 644}
 645
 646static int qla4xxx_get_chap_by_index(struct scsi_qla_host *ha,
 647                                     int16_t chap_index,
 648                                     struct ql4_chap_table **chap_entry)
 649{
 650        int rval = QLA_ERROR;
 651        int max_chap_entries;
 652
 653        if (!ha->chap_list) {
 654                ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!\n");
 655                rval = QLA_ERROR;
 656                goto exit_get_chap;
 657        }
 658
 659        if (is_qla80XX(ha))
 660                max_chap_entries = (ha->hw.flt_chap_size / 2) /
 661                                   sizeof(struct ql4_chap_table);
 662        else
 663                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
 664
 665        if (chap_index > max_chap_entries) {
 666                ql4_printk(KERN_ERR, ha, "Invalid Chap index\n");
 667                rval = QLA_ERROR;
 668                goto exit_get_chap;
 669        }
 670
 671        *chap_entry = (struct ql4_chap_table *)ha->chap_list + chap_index;
 672        if ((*chap_entry)->cookie !=
 673             __constant_cpu_to_le16(CHAP_VALID_COOKIE)) {
 674                rval = QLA_ERROR;
 675                *chap_entry = NULL;
 676        } else {
 677                rval = QLA_SUCCESS;
 678        }
 679
 680exit_get_chap:
 681        return rval;
 682}
 683
 684/**
 685 * qla4xxx_find_free_chap_index - Find the first free chap index
 686 * @ha: pointer to adapter structure
 687 * @chap_index: CHAP index to be returned
 688 *
 689 * Find the first free chap index available in the chap table
 690 *
 691 * Note: Caller should acquire the chap lock before getting here.
 692 **/
 693static int qla4xxx_find_free_chap_index(struct scsi_qla_host *ha,
 694                                        uint16_t *chap_index)
 695{
 696        int i, rval;
 697        int free_index = -1;
 698        int max_chap_entries = 0;
 699        struct ql4_chap_table *chap_table;
 700
 701        if (is_qla80XX(ha))
 702                max_chap_entries = (ha->hw.flt_chap_size / 2) /
 703                                                sizeof(struct ql4_chap_table);
 704        else
 705                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
 706
 707        if (!ha->chap_list) {
 708                ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!\n");
 709                rval = QLA_ERROR;
 710                goto exit_find_chap;
 711        }
 712
 713        for (i = 0; i < max_chap_entries; i++) {
 714                chap_table = (struct ql4_chap_table *)ha->chap_list + i;
 715
 716                if ((chap_table->cookie !=
 717                    __constant_cpu_to_le16(CHAP_VALID_COOKIE)) &&
 718                   (i > MAX_RESRV_CHAP_IDX)) {
 719                                free_index = i;
 720                                break;
 721                }
 722        }
 723
 724        if (free_index != -1) {
 725                *chap_index = free_index;
 726                rval = QLA_SUCCESS;
 727        } else {
 728                rval = QLA_ERROR;
 729        }
 730
 731exit_find_chap:
 732        return rval;
 733}
 734
 735static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
 736                                  uint32_t *num_entries, char *buf)
 737{
 738        struct scsi_qla_host *ha = to_qla_host(shost);
 739        struct ql4_chap_table *chap_table;
 740        struct iscsi_chap_rec *chap_rec;
 741        int max_chap_entries = 0;
 742        int valid_chap_entries = 0;
 743        int ret = 0, i;
 744
 745        if (is_qla80XX(ha))
 746                max_chap_entries = (ha->hw.flt_chap_size / 2) /
 747                                        sizeof(struct ql4_chap_table);
 748        else
 749                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
 750
 751        ql4_printk(KERN_INFO, ha, "%s: num_entries = %d, CHAP idx = %d\n",
 752                        __func__, *num_entries, chap_tbl_idx);
 753
 754        if (!buf) {
 755                ret = -ENOMEM;
 756                goto exit_get_chap_list;
 757        }
 758
 759        qla4xxx_create_chap_list(ha);
 760
 761        chap_rec = (struct iscsi_chap_rec *) buf;
 762        mutex_lock(&ha->chap_sem);
 763        for (i = chap_tbl_idx; i < max_chap_entries; i++) {
 764                chap_table = (struct ql4_chap_table *)ha->chap_list + i;
 765                if (chap_table->cookie !=
 766                    __constant_cpu_to_le16(CHAP_VALID_COOKIE))
 767                        continue;
 768
 769                chap_rec->chap_tbl_idx = i;
 770                strlcpy(chap_rec->username, chap_table->name,
 771                        ISCSI_CHAP_AUTH_NAME_MAX_LEN);
 772                strlcpy(chap_rec->password, chap_table->secret,
 773                        QL4_CHAP_MAX_SECRET_LEN);
 774                chap_rec->password_length = chap_table->secret_len;
 775
 776                if (chap_table->flags & BIT_7) /* local */
 777                        chap_rec->chap_type = CHAP_TYPE_OUT;
 778
 779                if (chap_table->flags & BIT_6) /* peer */
 780                        chap_rec->chap_type = CHAP_TYPE_IN;
 781
 782                chap_rec++;
 783
 784                valid_chap_entries++;
 785                if (valid_chap_entries == *num_entries)
 786                        break;
 787                else
 788                        continue;
 789        }
 790        mutex_unlock(&ha->chap_sem);
 791
 792exit_get_chap_list:
 793        ql4_printk(KERN_INFO, ha, "%s: Valid CHAP Entries = %d\n",
 794                        __func__,  valid_chap_entries);
 795        *num_entries = valid_chap_entries;
 796        return ret;
 797}
 798
 799static int __qla4xxx_is_chap_active(struct device *dev, void *data)
 800{
 801        int ret = 0;
 802        uint16_t *chap_tbl_idx = (uint16_t *) data;
 803        struct iscsi_cls_session *cls_session;
 804        struct iscsi_session *sess;
 805        struct ddb_entry *ddb_entry;
 806
 807        if (!iscsi_is_session_dev(dev))
 808                goto exit_is_chap_active;
 809
 810        cls_session = iscsi_dev_to_session(dev);
 811        sess = cls_session->dd_data;
 812        ddb_entry = sess->dd_data;
 813
 814        if (iscsi_session_chkready(cls_session))
 815                goto exit_is_chap_active;
 816
 817        if (ddb_entry->chap_tbl_idx == *chap_tbl_idx)
 818                ret = 1;
 819
 820exit_is_chap_active:
 821        return ret;
 822}
 823
 824static int qla4xxx_is_chap_active(struct Scsi_Host *shost,
 825                                  uint16_t chap_tbl_idx)
 826{
 827        int ret = 0;
 828
 829        ret = device_for_each_child(&shost->shost_gendev, &chap_tbl_idx,
 830                                    __qla4xxx_is_chap_active);
 831
 832        return ret;
 833}
 834
 835static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx)
 836{
 837        struct scsi_qla_host *ha = to_qla_host(shost);
 838        struct ql4_chap_table *chap_table;
 839        dma_addr_t chap_dma;
 840        int max_chap_entries = 0;
 841        uint32_t offset = 0;
 842        uint32_t chap_size;
 843        int ret = 0;
 844
 845        chap_table = dma_pool_zalloc(ha->chap_dma_pool, GFP_KERNEL, &chap_dma);
 846        if (chap_table == NULL)
 847                return -ENOMEM;
 848
 849        if (is_qla80XX(ha))
 850                max_chap_entries = (ha->hw.flt_chap_size / 2) /
 851                                   sizeof(struct ql4_chap_table);
 852        else
 853                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
 854
 855        if (chap_tbl_idx > max_chap_entries) {
 856                ret = -EINVAL;
 857                goto exit_delete_chap;
 858        }
 859
 860        /* Check if chap index is in use.
 861         * If chap is in use don't delet chap entry */
 862        ret = qla4xxx_is_chap_active(shost, chap_tbl_idx);
 863        if (ret) {
 864                ql4_printk(KERN_INFO, ha, "CHAP entry %d is in use, cannot "
 865                           "delete from flash\n", chap_tbl_idx);
 866                ret = -EBUSY;
 867                goto exit_delete_chap;
 868        }
 869
 870        chap_size = sizeof(struct ql4_chap_table);
 871        if (is_qla40XX(ha))
 872                offset = FLASH_CHAP_OFFSET | (chap_tbl_idx * chap_size);
 873        else {
 874                offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
 875                /* flt_chap_size is CHAP table size for both ports
 876                 * so divide it by 2 to calculate the offset for second port
 877                 */
 878                if (ha->port_num == 1)
 879                        offset += (ha->hw.flt_chap_size / 2);
 880                offset += (chap_tbl_idx * chap_size);
 881        }
 882
 883        ret = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
 884        if (ret != QLA_SUCCESS) {
 885                ret = -EINVAL;
 886                goto exit_delete_chap;
 887        }
 888
 889        DEBUG2(ql4_printk(KERN_INFO, ha, "Chap Cookie: x%x\n",
 890                          __le16_to_cpu(chap_table->cookie)));
 891
 892        if (__le16_to_cpu(chap_table->cookie) != CHAP_VALID_COOKIE) {
 893                ql4_printk(KERN_ERR, ha, "No valid chap entry found\n");
 894                goto exit_delete_chap;
 895        }
 896
 897        chap_table->cookie = __constant_cpu_to_le16(0xFFFF);
 898
 899        offset = FLASH_CHAP_OFFSET |
 900                        (chap_tbl_idx * sizeof(struct ql4_chap_table));
 901        ret = qla4xxx_set_flash(ha, chap_dma, offset, chap_size,
 902                                FLASH_OPT_RMW_COMMIT);
 903        if (ret == QLA_SUCCESS && ha->chap_list) {
 904                mutex_lock(&ha->chap_sem);
 905                /* Update ha chap_list cache */
 906                memcpy((struct ql4_chap_table *)ha->chap_list + chap_tbl_idx,
 907                        chap_table, sizeof(struct ql4_chap_table));
 908                mutex_unlock(&ha->chap_sem);
 909        }
 910        if (ret != QLA_SUCCESS)
 911                ret =  -EINVAL;
 912
 913exit_delete_chap:
 914        dma_pool_free(ha->chap_dma_pool, chap_table, chap_dma);
 915        return ret;
 916}
 917
 918/**
 919 * qla4xxx_set_chap_entry - Make chap entry with given information
 920 * @shost: pointer to host
 921 * @data: chap info - credentials, index and type to make chap entry
 922 * @len: length of data
 923 *
 924 * Add or update chap entry with the given information
 925 **/
 926static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void *data, int len)
 927{
 928        struct scsi_qla_host *ha = to_qla_host(shost);
 929        struct iscsi_chap_rec chap_rec;
 930        struct ql4_chap_table *chap_entry = NULL;
 931        struct iscsi_param_info *param_info;
 932        struct nlattr *attr;
 933        int max_chap_entries = 0;
 934        int type;
 935        int rem = len;
 936        int rc = 0;
 937        int size;
 938
 939        memset(&chap_rec, 0, sizeof(chap_rec));
 940
 941        nla_for_each_attr(attr, data, len, rem) {
 942                param_info = nla_data(attr);
 943
 944                switch (param_info->param) {
 945                case ISCSI_CHAP_PARAM_INDEX:
 946                        chap_rec.chap_tbl_idx = *(uint16_t *)param_info->value;
 947                        break;
 948                case ISCSI_CHAP_PARAM_CHAP_TYPE:
 949                        chap_rec.chap_type = param_info->value[0];
 950                        break;
 951                case ISCSI_CHAP_PARAM_USERNAME:
 952                        size = min_t(size_t, sizeof(chap_rec.username),
 953                                     param_info->len);
 954                        memcpy(chap_rec.username, param_info->value, size);
 955                        break;
 956                case ISCSI_CHAP_PARAM_PASSWORD:
 957                        size = min_t(size_t, sizeof(chap_rec.password),
 958                                     param_info->len);
 959                        memcpy(chap_rec.password, param_info->value, size);
 960                        break;
 961                case ISCSI_CHAP_PARAM_PASSWORD_LEN:
 962                        chap_rec.password_length = param_info->value[0];
 963                        break;
 964                default:
 965                        ql4_printk(KERN_ERR, ha,
 966                                   "%s: No such sysfs attribute\n", __func__);
 967                        rc = -ENOSYS;
 968                        goto exit_set_chap;
 969                };
 970        }
 971
 972        if (chap_rec.chap_type == CHAP_TYPE_IN)
 973                type = BIDI_CHAP;
 974        else
 975                type = LOCAL_CHAP;
 976
 977        if (is_qla80XX(ha))
 978                max_chap_entries = (ha->hw.flt_chap_size / 2) /
 979                                   sizeof(struct ql4_chap_table);
 980        else
 981                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
 982
 983        mutex_lock(&ha->chap_sem);
 984        if (chap_rec.chap_tbl_idx < max_chap_entries) {
 985                rc = qla4xxx_get_chap_by_index(ha, chap_rec.chap_tbl_idx,
 986                                               &chap_entry);
 987                if (!rc) {
 988                        if (!(type == qla4xxx_get_chap_type(chap_entry))) {
 989                                ql4_printk(KERN_INFO, ha,
 990                                           "Type mismatch for CHAP entry %d\n",
 991                                           chap_rec.chap_tbl_idx);
 992                                rc = -EINVAL;
 993                                goto exit_unlock_chap;
 994                        }
 995
 996                        /* If chap index is in use then don't modify it */
 997                        rc = qla4xxx_is_chap_active(shost,
 998                                                    chap_rec.chap_tbl_idx);
 999                        if (rc) {
1000                                ql4_printk(KERN_INFO, ha,
1001                                           "CHAP entry %d is in use\n",
1002                                           chap_rec.chap_tbl_idx);
1003                                rc = -EBUSY;
1004                                goto exit_unlock_chap;
1005                        }
1006                }
1007        } else {
1008                rc = qla4xxx_find_free_chap_index(ha, &chap_rec.chap_tbl_idx);
1009                if (rc) {
1010                        ql4_printk(KERN_INFO, ha, "CHAP entry not available\n");
1011                        rc = -EBUSY;
1012                        goto exit_unlock_chap;
1013                }
1014        }
1015
1016        rc = qla4xxx_set_chap(ha, chap_rec.username, chap_rec.password,
1017                              chap_rec.chap_tbl_idx, type);
1018
1019exit_unlock_chap:
1020        mutex_unlock(&ha->chap_sem);
1021
1022exit_set_chap:
1023        return rc;
1024}
1025
1026
1027static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len)
1028{
1029        struct scsi_qla_host *ha = to_qla_host(shost);
1030        struct iscsi_offload_host_stats *host_stats = NULL;
1031        int host_stats_size;
1032        int ret = 0;
1033        int ddb_idx = 0;
1034        struct ql_iscsi_stats *ql_iscsi_stats = NULL;
1035        int stats_size;
1036        dma_addr_t iscsi_stats_dma;
1037
1038        DEBUG2(ql4_printk(KERN_INFO, ha, "Func: %s\n", __func__));
1039
1040        host_stats_size = sizeof(struct iscsi_offload_host_stats);
1041
1042        if (host_stats_size != len) {
1043                ql4_printk(KERN_INFO, ha, "%s: host_stats size mismatch expected = %d, is = %d\n",
1044                           __func__, len, host_stats_size);
1045                ret = -EINVAL;
1046                goto exit_host_stats;
1047        }
1048        host_stats = (struct iscsi_offload_host_stats *)buf;
1049
1050        if (!buf) {
1051                ret = -ENOMEM;
1052                goto exit_host_stats;
1053        }
1054
1055        stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
1056
1057        ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
1058                                            &iscsi_stats_dma, GFP_KERNEL);
1059        if (!ql_iscsi_stats) {
1060                ql4_printk(KERN_ERR, ha,
1061                           "Unable to allocate memory for iscsi stats\n");
1062                ret = -ENOMEM;
1063                goto exit_host_stats;
1064        }
1065
1066        ret =  qla4xxx_get_mgmt_data(ha, ddb_idx, stats_size,
1067                                     iscsi_stats_dma);
1068        if (ret != QLA_SUCCESS) {
1069                ql4_printk(KERN_ERR, ha,
1070                           "Unable to retrieve iscsi stats\n");
1071                ret = -EIO;
1072                goto exit_host_stats;
1073        }
1074        host_stats->mactx_frames = le64_to_cpu(ql_iscsi_stats->mac_tx_frames);
1075        host_stats->mactx_bytes = le64_to_cpu(ql_iscsi_stats->mac_tx_bytes);
1076        host_stats->mactx_multicast_frames =
1077                        le64_to_cpu(ql_iscsi_stats->mac_tx_multicast_frames);
1078        host_stats->mactx_broadcast_frames =
1079                        le64_to_cpu(ql_iscsi_stats->mac_tx_broadcast_frames);
1080        host_stats->mactx_pause_frames =
1081                        le64_to_cpu(ql_iscsi_stats->mac_tx_pause_frames);
1082        host_stats->mactx_control_frames =
1083                        le64_to_cpu(ql_iscsi_stats->mac_tx_control_frames);
1084        host_stats->mactx_deferral =
1085                        le64_to_cpu(ql_iscsi_stats->mac_tx_deferral);
1086        host_stats->mactx_excess_deferral =
1087                        le64_to_cpu(ql_iscsi_stats->mac_tx_excess_deferral);
1088        host_stats->mactx_late_collision =
1089                        le64_to_cpu(ql_iscsi_stats->mac_tx_late_collision);
1090        host_stats->mactx_abort = le64_to_cpu(ql_iscsi_stats->mac_tx_abort);
1091        host_stats->mactx_single_collision =
1092                        le64_to_cpu(ql_iscsi_stats->mac_tx_single_collision);
1093        host_stats->mactx_multiple_collision =
1094                        le64_to_cpu(ql_iscsi_stats->mac_tx_multiple_collision);
1095        host_stats->mactx_collision =
1096                        le64_to_cpu(ql_iscsi_stats->mac_tx_collision);
1097        host_stats->mactx_frames_dropped =
1098                        le64_to_cpu(ql_iscsi_stats->mac_tx_frames_dropped);
1099        host_stats->mactx_jumbo_frames =
1100                        le64_to_cpu(ql_iscsi_stats->mac_tx_jumbo_frames);
1101        host_stats->macrx_frames = le64_to_cpu(ql_iscsi_stats->mac_rx_frames);
1102        host_stats->macrx_bytes = le64_to_cpu(ql_iscsi_stats->mac_rx_bytes);
1103        host_stats->macrx_unknown_control_frames =
1104                le64_to_cpu(ql_iscsi_stats->mac_rx_unknown_control_frames);
1105        host_stats->macrx_pause_frames =
1106                        le64_to_cpu(ql_iscsi_stats->mac_rx_pause_frames);
1107        host_stats->macrx_control_frames =
1108                        le64_to_cpu(ql_iscsi_stats->mac_rx_control_frames);
1109        host_stats->macrx_dribble =
1110                        le64_to_cpu(ql_iscsi_stats->mac_rx_dribble);
1111        host_stats->macrx_frame_length_error =
1112                        le64_to_cpu(ql_iscsi_stats->mac_rx_frame_length_error);
1113        host_stats->macrx_jabber = le64_to_cpu(ql_iscsi_stats->mac_rx_jabber);
1114        host_stats->macrx_carrier_sense_error =
1115                le64_to_cpu(ql_iscsi_stats->mac_rx_carrier_sense_error);
1116        host_stats->macrx_frame_discarded =
1117                        le64_to_cpu(ql_iscsi_stats->mac_rx_frame_discarded);
1118        host_stats->macrx_frames_dropped =
1119                        le64_to_cpu(ql_iscsi_stats->mac_rx_frames_dropped);
1120        host_stats->mac_crc_error = le64_to_cpu(ql_iscsi_stats->mac_crc_error);
1121        host_stats->mac_encoding_error =
1122                        le64_to_cpu(ql_iscsi_stats->mac_encoding_error);
1123        host_stats->macrx_length_error_large =
1124                        le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_large);
1125        host_stats->macrx_length_error_small =
1126                        le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_small);
1127        host_stats->macrx_multicast_frames =
1128                        le64_to_cpu(ql_iscsi_stats->mac_rx_multicast_frames);
1129        host_stats->macrx_broadcast_frames =
1130                        le64_to_cpu(ql_iscsi_stats->mac_rx_broadcast_frames);
1131        host_stats->iptx_packets = le64_to_cpu(ql_iscsi_stats->ip_tx_packets);
1132        host_stats->iptx_bytes = le64_to_cpu(ql_iscsi_stats->ip_tx_bytes);
1133        host_stats->iptx_fragments =
1134                        le64_to_cpu(ql_iscsi_stats->ip_tx_fragments);
1135        host_stats->iprx_packets = le64_to_cpu(ql_iscsi_stats->ip_rx_packets);
1136        host_stats->iprx_bytes = le64_to_cpu(ql_iscsi_stats->ip_rx_bytes);
1137        host_stats->iprx_fragments =
1138                        le64_to_cpu(ql_iscsi_stats->ip_rx_fragments);
1139        host_stats->ip_datagram_reassembly =
1140                        le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly);
1141        host_stats->ip_invalid_address_error =
1142                        le64_to_cpu(ql_iscsi_stats->ip_invalid_address_error);
1143        host_stats->ip_error_packets =
1144                        le64_to_cpu(ql_iscsi_stats->ip_error_packets);
1145        host_stats->ip_fragrx_overlap =
1146                        le64_to_cpu(ql_iscsi_stats->ip_fragrx_overlap);
1147        host_stats->ip_fragrx_outoforder =
1148                        le64_to_cpu(ql_iscsi_stats->ip_fragrx_outoforder);
1149        host_stats->ip_datagram_reassembly_timeout =
1150                le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly_timeout);
1151        host_stats->ipv6tx_packets =
1152                        le64_to_cpu(ql_iscsi_stats->ipv6_tx_packets);
1153        host_stats->ipv6tx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_tx_bytes);
1154        host_stats->ipv6tx_fragments =
1155                        le64_to_cpu(ql_iscsi_stats->ipv6_tx_fragments);
1156        host_stats->ipv6rx_packets =
1157                        le64_to_cpu(ql_iscsi_stats->ipv6_rx_packets);
1158        host_stats->ipv6rx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_rx_bytes);
1159        host_stats->ipv6rx_fragments =
1160                        le64_to_cpu(ql_iscsi_stats->ipv6_rx_fragments);
1161        host_stats->ipv6_datagram_reassembly =
1162                        le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly);
1163        host_stats->ipv6_invalid_address_error =
1164                le64_to_cpu(ql_iscsi_stats->ipv6_invalid_address_error);
1165        host_stats->ipv6_error_packets =
1166                        le64_to_cpu(ql_iscsi_stats->ipv6_error_packets);
1167        host_stats->ipv6_fragrx_overlap =
1168                        le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_overlap);
1169        host_stats->ipv6_fragrx_outoforder =
1170                        le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_outoforder);
1171        host_stats->ipv6_datagram_reassembly_timeout =
1172                le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly_timeout);
1173        host_stats->tcptx_segments =
1174                        le64_to_cpu(ql_iscsi_stats->tcp_tx_segments);
1175        host_stats->tcptx_bytes = le64_to_cpu(ql_iscsi_stats->tcp_tx_bytes);
1176        host_stats->tcprx_segments =
1177                        le64_to_cpu(ql_iscsi_stats->tcp_rx_segments);
1178        host_stats->tcprx_byte = le64_to_cpu(ql_iscsi_stats->tcp_rx_byte);
1179        host_stats->tcp_duplicate_ack_retx =
1180                        le64_to_cpu(ql_iscsi_stats->tcp_duplicate_ack_retx);
1181        host_stats->tcp_retx_timer_expired =
1182                        le64_to_cpu(ql_iscsi_stats->tcp_retx_timer_expired);
1183        host_stats->tcprx_duplicate_ack =
1184                        le64_to_cpu(ql_iscsi_stats->tcp_rx_duplicate_ack);
1185        host_stats->tcprx_pure_ackr =
1186                        le64_to_cpu(ql_iscsi_stats->tcp_rx_pure_ackr);
1187        host_stats->tcptx_delayed_ack =
1188                        le64_to_cpu(ql_iscsi_stats->tcp_tx_delayed_ack);
1189        host_stats->tcptx_pure_ack =
1190                        le64_to_cpu(ql_iscsi_stats->tcp_tx_pure_ack);
1191        host_stats->tcprx_segment_error =
1192                        le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_error);
1193        host_stats->tcprx_segment_outoforder =
1194                        le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_outoforder);
1195        host_stats->tcprx_window_probe =
1196                        le64_to_cpu(ql_iscsi_stats->tcp_rx_window_probe);
1197        host_stats->tcprx_window_update =
1198                        le64_to_cpu(ql_iscsi_stats->tcp_rx_window_update);
1199        host_stats->tcptx_window_probe_persist =
1200                le64_to_cpu(ql_iscsi_stats->tcp_tx_window_probe_persist);
1201        host_stats->ecc_error_correction =
1202                        le64_to_cpu(ql_iscsi_stats->ecc_error_correction);
1203        host_stats->iscsi_pdu_tx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_tx);
1204        host_stats->iscsi_data_bytes_tx =
1205                        le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_tx);
1206        host_stats->iscsi_pdu_rx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_rx);
1207        host_stats->iscsi_data_bytes_rx =
1208                        le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_rx);
1209        host_stats->iscsi_io_completed =
1210                        le64_to_cpu(ql_iscsi_stats->iscsi_io_completed);
1211        host_stats->iscsi_unexpected_io_rx =
1212                        le64_to_cpu(ql_iscsi_stats->iscsi_unexpected_io_rx);
1213        host_stats->iscsi_format_error =
1214                        le64_to_cpu(ql_iscsi_stats->iscsi_format_error);
1215        host_stats->iscsi_hdr_digest_error =
1216                        le64_to_cpu(ql_iscsi_stats->iscsi_hdr_digest_error);
1217        host_stats->iscsi_data_digest_error =
1218                        le64_to_cpu(ql_iscsi_stats->iscsi_data_digest_error);
1219        host_stats->iscsi_sequence_error =
1220                        le64_to_cpu(ql_iscsi_stats->iscsi_sequence_error);
1221exit_host_stats:
1222        if (ql_iscsi_stats)
1223                dma_free_coherent(&ha->pdev->dev, host_stats_size,
1224                                  ql_iscsi_stats, iscsi_stats_dma);
1225
1226        ql4_printk(KERN_INFO, ha, "%s: Get host stats done\n",
1227                   __func__);
1228        return ret;
1229}
1230
1231static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
1232                                   enum iscsi_param_type param_type,
1233                                   int param, char *buf)
1234{
1235        struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
1236        struct scsi_qla_host *ha = to_qla_host(shost);
1237        int ival;
1238        char *pval = NULL;
1239        int len = -ENOSYS;
1240
1241        if (param_type == ISCSI_NET_PARAM) {
1242                switch (param) {
1243                case ISCSI_NET_PARAM_IPV4_ADDR:
1244                        len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address);
1245                        break;
1246                case ISCSI_NET_PARAM_IPV4_SUBNET:
1247                        len = sprintf(buf, "%pI4\n",
1248                                      &ha->ip_config.subnet_mask);
1249                        break;
1250                case ISCSI_NET_PARAM_IPV4_GW:
1251                        len = sprintf(buf, "%pI4\n", &ha->ip_config.gateway);
1252                        break;
1253                case ISCSI_NET_PARAM_IFACE_ENABLE:
1254                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1255                                OP_STATE(ha->ip_config.ipv4_options,
1256                                         IPOPT_IPV4_PROTOCOL_ENABLE, pval);
1257                        } else {
1258                                OP_STATE(ha->ip_config.ipv6_options,
1259                                         IPV6_OPT_IPV6_PROTOCOL_ENABLE, pval);
1260                        }
1261
1262                        len = sprintf(buf, "%s\n", pval);
1263                        break;
1264                case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
1265                        len = sprintf(buf, "%s\n",
1266                                      (ha->ip_config.tcp_options &
1267                                       TCPOPT_DHCP_ENABLE) ?
1268                                      "dhcp" : "static");
1269                        break;
1270                case ISCSI_NET_PARAM_IPV6_ADDR:
1271                        if (iface->iface_num == 0)
1272                                len = sprintf(buf, "%pI6\n",
1273                                              &ha->ip_config.ipv6_addr0);
1274                        if (iface->iface_num == 1)
1275                                len = sprintf(buf, "%pI6\n",
1276                                              &ha->ip_config.ipv6_addr1);
1277                        break;
1278                case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
1279                        len = sprintf(buf, "%pI6\n",
1280                                      &ha->ip_config.ipv6_link_local_addr);
1281                        break;
1282                case ISCSI_NET_PARAM_IPV6_ROUTER:
1283                        len = sprintf(buf, "%pI6\n",
1284                                      &ha->ip_config.ipv6_default_router_addr);
1285                        break;
1286                case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
1287                        pval = (ha->ip_config.ipv6_addl_options &
1288                                IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) ?
1289                                "nd" : "static";
1290
1291                        len = sprintf(buf, "%s\n", pval);
1292                        break;
1293                case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
1294                        pval = (ha->ip_config.ipv6_addl_options &
1295                                IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR) ?
1296                                "auto" : "static";
1297
1298                        len = sprintf(buf, "%s\n", pval);
1299                        break;
1300                case ISCSI_NET_PARAM_VLAN_ID:
1301                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1302                                ival = ha->ip_config.ipv4_vlan_tag &
1303                                       ISCSI_MAX_VLAN_ID;
1304                        else
1305                                ival = ha->ip_config.ipv6_vlan_tag &
1306                                       ISCSI_MAX_VLAN_ID;
1307
1308                        len = sprintf(buf, "%d\n", ival);
1309                        break;
1310                case ISCSI_NET_PARAM_VLAN_PRIORITY:
1311                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1312                                ival = (ha->ip_config.ipv4_vlan_tag >> 13) &
1313                                       ISCSI_MAX_VLAN_PRIORITY;
1314                        else
1315                                ival = (ha->ip_config.ipv6_vlan_tag >> 13) &
1316                                       ISCSI_MAX_VLAN_PRIORITY;
1317
1318                        len = sprintf(buf, "%d\n", ival);
1319                        break;
1320                case ISCSI_NET_PARAM_VLAN_ENABLED:
1321                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1322                                OP_STATE(ha->ip_config.ipv4_options,
1323                                         IPOPT_VLAN_TAGGING_ENABLE, pval);
1324                        } else {
1325                                OP_STATE(ha->ip_config.ipv6_options,
1326                                         IPV6_OPT_VLAN_TAGGING_ENABLE, pval);
1327                        }
1328                        len = sprintf(buf, "%s\n", pval);
1329                        break;
1330                case ISCSI_NET_PARAM_MTU:
1331                        len = sprintf(buf, "%d\n", ha->ip_config.eth_mtu_size);
1332                        break;
1333                case ISCSI_NET_PARAM_PORT:
1334                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1335                                len = sprintf(buf, "%d\n",
1336                                              ha->ip_config.ipv4_port);
1337                        else
1338                                len = sprintf(buf, "%d\n",
1339                                              ha->ip_config.ipv6_port);
1340                        break;
1341                case ISCSI_NET_PARAM_IPADDR_STATE:
1342                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1343                                pval = iscsi_get_ipaddress_state_name(
1344                                                ha->ip_config.ipv4_addr_state);
1345                        } else {
1346                                if (iface->iface_num == 0)
1347                                        pval = iscsi_get_ipaddress_state_name(
1348                                                ha->ip_config.ipv6_addr0_state);
1349                                else if (iface->iface_num == 1)
1350                                        pval = iscsi_get_ipaddress_state_name(
1351                                                ha->ip_config.ipv6_addr1_state);
1352                        }
1353
1354                        len = sprintf(buf, "%s\n", pval);
1355                        break;
1356                case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
1357                        pval = iscsi_get_ipaddress_state_name(
1358                                        ha->ip_config.ipv6_link_local_state);
1359                        len = sprintf(buf, "%s\n", pval);
1360                        break;
1361                case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
1362                        pval = iscsi_get_router_state_name(
1363                                      ha->ip_config.ipv6_default_router_state);
1364                        len = sprintf(buf, "%s\n", pval);
1365                        break;
1366                case ISCSI_NET_PARAM_DELAYED_ACK_EN:
1367                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1368                                OP_STATE(~ha->ip_config.tcp_options,
1369                                         TCPOPT_DELAYED_ACK_DISABLE, pval);
1370                        } else {
1371                                OP_STATE(~ha->ip_config.ipv6_tcp_options,
1372                                         IPV6_TCPOPT_DELAYED_ACK_DISABLE, pval);
1373                        }
1374                        len = sprintf(buf, "%s\n", pval);
1375                        break;
1376                case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
1377                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1378                                OP_STATE(~ha->ip_config.tcp_options,
1379                                         TCPOPT_NAGLE_ALGO_DISABLE, pval);
1380                        } else {
1381                                OP_STATE(~ha->ip_config.ipv6_tcp_options,
1382                                         IPV6_TCPOPT_NAGLE_ALGO_DISABLE, pval);
1383                        }
1384                        len = sprintf(buf, "%s\n", pval);
1385                        break;
1386                case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
1387                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1388                                OP_STATE(~ha->ip_config.tcp_options,
1389                                         TCPOPT_WINDOW_SCALE_DISABLE, pval);
1390                        } else {
1391                                OP_STATE(~ha->ip_config.ipv6_tcp_options,
1392                                         IPV6_TCPOPT_WINDOW_SCALE_DISABLE,
1393                                         pval);
1394                        }
1395                        len = sprintf(buf, "%s\n", pval);
1396                        break;
1397                case ISCSI_NET_PARAM_TCP_WSF:
1398                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1399                                len = sprintf(buf, "%d\n",
1400                                              ha->ip_config.tcp_wsf);
1401                        else
1402                                len = sprintf(buf, "%d\n",
1403                                              ha->ip_config.ipv6_tcp_wsf);
1404                        break;
1405                case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
1406                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1407                                ival = (ha->ip_config.tcp_options &
1408                                        TCPOPT_TIMER_SCALE) >> 1;
1409                        else
1410                                ival = (ha->ip_config.ipv6_tcp_options &
1411                                        IPV6_TCPOPT_TIMER_SCALE) >> 1;
1412
1413                        len = sprintf(buf, "%d\n", ival);
1414                        break;
1415                case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
1416                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1417                                OP_STATE(ha->ip_config.tcp_options,
1418                                         TCPOPT_TIMESTAMP_ENABLE, pval);
1419                        } else {
1420                                OP_STATE(ha->ip_config.ipv6_tcp_options,
1421                                         IPV6_TCPOPT_TIMESTAMP_EN, pval);
1422                        }
1423                        len = sprintf(buf, "%s\n", pval);
1424                        break;
1425                case ISCSI_NET_PARAM_CACHE_ID:
1426                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1427                                len = sprintf(buf, "%d\n",
1428                                              ha->ip_config.ipv4_cache_id);
1429                        else
1430                                len = sprintf(buf, "%d\n",
1431                                              ha->ip_config.ipv6_cache_id);
1432                        break;
1433                case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
1434                        OP_STATE(ha->ip_config.tcp_options,
1435                                 TCPOPT_DNS_SERVER_IP_EN, pval);
1436
1437                        len = sprintf(buf, "%s\n", pval);
1438                        break;
1439                case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
1440                        OP_STATE(ha->ip_config.tcp_options,
1441                                 TCPOPT_SLP_DA_INFO_EN, pval);
1442
1443                        len = sprintf(buf, "%s\n", pval);
1444                        break;
1445                case ISCSI_NET_PARAM_IPV4_TOS_EN:
1446                        OP_STATE(ha->ip_config.ipv4_options,
1447                                 IPOPT_IPV4_TOS_EN, pval);
1448
1449                        len = sprintf(buf, "%s\n", pval);
1450                        break;
1451                case ISCSI_NET_PARAM_IPV4_TOS:
1452                        len = sprintf(buf, "%d\n", ha->ip_config.ipv4_tos);
1453                        break;
1454                case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
1455                        OP_STATE(ha->ip_config.ipv4_options,
1456                                 IPOPT_GRAT_ARP_EN, pval);
1457
1458                        len = sprintf(buf, "%s\n", pval);
1459                        break;
1460                case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
1461                        OP_STATE(ha->ip_config.ipv4_options, IPOPT_ALT_CID_EN,
1462                                 pval);
1463
1464                        len = sprintf(buf, "%s\n", pval);
1465                        break;
1466                case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
1467                        pval = (ha->ip_config.ipv4_alt_cid_len) ?
1468                               (char *)ha->ip_config.ipv4_alt_cid : "";
1469
1470                        len = sprintf(buf, "%s\n", pval);
1471                        break;
1472                case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
1473                        OP_STATE(ha->ip_config.ipv4_options,
1474                                 IPOPT_REQ_VID_EN, pval);
1475
1476                        len = sprintf(buf, "%s\n", pval);
1477                        break;
1478                case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
1479                        OP_STATE(ha->ip_config.ipv4_options,
1480                                 IPOPT_USE_VID_EN, pval);
1481
1482                        len = sprintf(buf, "%s\n", pval);
1483                        break;
1484                case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
1485                        pval = (ha->ip_config.ipv4_vid_len) ?
1486                               (char *)ha->ip_config.ipv4_vid : "";
1487
1488                        len = sprintf(buf, "%s\n", pval);
1489                        break;
1490                case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
1491                        OP_STATE(ha->ip_config.ipv4_options,
1492                                 IPOPT_LEARN_IQN_EN, pval);
1493
1494                        len = sprintf(buf, "%s\n", pval);
1495                        break;
1496                case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
1497                        OP_STATE(~ha->ip_config.ipv4_options,
1498                                 IPOPT_FRAGMENTATION_DISABLE, pval);
1499
1500                        len = sprintf(buf, "%s\n", pval);
1501                        break;
1502                case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
1503                        OP_STATE(ha->ip_config.ipv4_options,
1504                                 IPOPT_IN_FORWARD_EN, pval);
1505
1506                        len = sprintf(buf, "%s\n", pval);
1507                        break;
1508                case ISCSI_NET_PARAM_REDIRECT_EN:
1509                        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1510                                OP_STATE(ha->ip_config.ipv4_options,
1511                                         IPOPT_ARP_REDIRECT_EN, pval);
1512                        } else {
1513                                OP_STATE(ha->ip_config.ipv6_options,
1514                                         IPV6_OPT_REDIRECT_EN, pval);
1515                        }
1516                        len = sprintf(buf, "%s\n", pval);
1517                        break;
1518                case ISCSI_NET_PARAM_IPV4_TTL:
1519                        len = sprintf(buf, "%d\n", ha->ip_config.ipv4_ttl);
1520                        break;
1521                case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
1522                        OP_STATE(ha->ip_config.ipv6_options,
1523                                 IPV6_OPT_GRAT_NEIGHBOR_ADV_EN, pval);
1524
1525                        len = sprintf(buf, "%s\n", pval);
1526                        break;
1527                case ISCSI_NET_PARAM_IPV6_MLD_EN:
1528                        OP_STATE(ha->ip_config.ipv6_addl_options,
1529                                 IPV6_ADDOPT_MLD_EN, pval);
1530
1531                        len = sprintf(buf, "%s\n", pval);
1532                        break;
1533                case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
1534                        len = sprintf(buf, "%u\n", ha->ip_config.ipv6_flow_lbl);
1535                        break;
1536                case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
1537                        len = sprintf(buf, "%d\n",
1538                                      ha->ip_config.ipv6_traffic_class);
1539                        break;
1540                case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
1541                        len = sprintf(buf, "%d\n",
1542                                      ha->ip_config.ipv6_hop_limit);
1543                        break;
1544                case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
1545                        len = sprintf(buf, "%d\n",
1546                                      ha->ip_config.ipv6_nd_reach_time);
1547                        break;
1548                case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
1549                        len = sprintf(buf, "%d\n",
1550                                      ha->ip_config.ipv6_nd_rexmit_timer);
1551                        break;
1552                case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
1553                        len = sprintf(buf, "%d\n",
1554                                      ha->ip_config.ipv6_nd_stale_timeout);
1555                        break;
1556                case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
1557                        len = sprintf(buf, "%d\n",
1558                                      ha->ip_config.ipv6_dup_addr_detect_count);
1559                        break;
1560                case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
1561                        len = sprintf(buf, "%d\n",
1562                                      ha->ip_config.ipv6_gw_advrt_mtu);
1563                        break;
1564                default:
1565                        len = -ENOSYS;
1566                }
1567        } else if (param_type == ISCSI_IFACE_PARAM) {
1568                switch (param) {
1569                case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
1570                        len = sprintf(buf, "%d\n", ha->ip_config.def_timeout);
1571                        break;
1572                case ISCSI_IFACE_PARAM_HDRDGST_EN:
1573                        OP_STATE(ha->ip_config.iscsi_options,
1574                                 ISCSIOPTS_HEADER_DIGEST_EN, pval);
1575
1576                        len = sprintf(buf, "%s\n", pval);
1577                        break;
1578                case ISCSI_IFACE_PARAM_DATADGST_EN:
1579                        OP_STATE(ha->ip_config.iscsi_options,
1580                                 ISCSIOPTS_DATA_DIGEST_EN, pval);
1581
1582                        len = sprintf(buf, "%s\n", pval);
1583                        break;
1584                case ISCSI_IFACE_PARAM_IMM_DATA_EN:
1585                        OP_STATE(ha->ip_config.iscsi_options,
1586                                 ISCSIOPTS_IMMEDIATE_DATA_EN, pval);
1587
1588                        len = sprintf(buf, "%s\n", pval);
1589                        break;
1590                case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
1591                        OP_STATE(ha->ip_config.iscsi_options,
1592                                 ISCSIOPTS_INITIAL_R2T_EN, pval);
1593
1594                        len = sprintf(buf, "%s\n", pval);
1595                        break;
1596                case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
1597                        OP_STATE(ha->ip_config.iscsi_options,
1598                                 ISCSIOPTS_DATA_SEQ_INORDER_EN, pval);
1599
1600                        len = sprintf(buf, "%s\n", pval);
1601                        break;
1602                case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
1603                        OP_STATE(ha->ip_config.iscsi_options,
1604                                 ISCSIOPTS_DATA_PDU_INORDER_EN, pval);
1605
1606                        len = sprintf(buf, "%s\n", pval);
1607                        break;
1608                case ISCSI_IFACE_PARAM_ERL:
1609                        len = sprintf(buf, "%d\n",
1610                                      (ha->ip_config.iscsi_options &
1611                                       ISCSIOPTS_ERL));
1612                        break;
1613                case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
1614                        len = sprintf(buf, "%u\n",
1615                                      ha->ip_config.iscsi_max_pdu_size *
1616                                      BYTE_UNITS);
1617                        break;
1618                case ISCSI_IFACE_PARAM_FIRST_BURST:
1619                        len = sprintf(buf, "%u\n",
1620                                      ha->ip_config.iscsi_first_burst_len *
1621                                      BYTE_UNITS);
1622                        break;
1623                case ISCSI_IFACE_PARAM_MAX_R2T:
1624                        len = sprintf(buf, "%d\n",
1625                                      ha->ip_config.iscsi_max_outstnd_r2t);
1626                        break;
1627                case ISCSI_IFACE_PARAM_MAX_BURST:
1628                        len = sprintf(buf, "%u\n",
1629                                      ha->ip_config.iscsi_max_burst_len *
1630                                      BYTE_UNITS);
1631                        break;
1632                case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
1633                        OP_STATE(ha->ip_config.iscsi_options,
1634                                 ISCSIOPTS_CHAP_AUTH_EN, pval);
1635
1636                        len = sprintf(buf, "%s\n", pval);
1637                        break;
1638                case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
1639                        OP_STATE(ha->ip_config.iscsi_options,
1640                                 ISCSIOPTS_BIDI_CHAP_EN, pval);
1641
1642                        len = sprintf(buf, "%s\n", pval);
1643                        break;
1644                case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
1645                        OP_STATE(ha->ip_config.iscsi_options,
1646                                 ISCSIOPTS_DISCOVERY_AUTH_EN, pval);
1647
1648                        len = sprintf(buf, "%s\n", pval);
1649                        break;
1650                case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
1651                        OP_STATE(ha->ip_config.iscsi_options,
1652                                 ISCSIOPTS_DISCOVERY_LOGOUT_EN, pval);
1653
1654                        len = sprintf(buf, "%s\n", pval);
1655                        break;
1656                case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
1657                        OP_STATE(ha->ip_config.iscsi_options,
1658                                 ISCSIOPTS_STRICT_LOGIN_COMP_EN, pval);
1659
1660                        len = sprintf(buf, "%s\n", pval);
1661                        break;
1662                case ISCSI_IFACE_PARAM_INITIATOR_NAME:
1663                        len = sprintf(buf, "%s\n", ha->ip_config.iscsi_name);
1664                        break;
1665                default:
1666                        len = -ENOSYS;
1667                }
1668        }
1669
1670        return len;
1671}
1672
1673static struct iscsi_endpoint *
1674qla4xxx_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1675                   int non_blocking)
1676{
1677        int ret;
1678        struct iscsi_endpoint *ep;
1679        struct qla_endpoint *qla_ep;
1680        struct scsi_qla_host *ha;
1681        struct sockaddr_in *addr;
1682        struct sockaddr_in6 *addr6;
1683
1684        if (!shost) {
1685                ret = -ENXIO;
1686                pr_err("%s: shost is NULL\n", __func__);
1687                return ERR_PTR(ret);
1688        }
1689
1690        ha = iscsi_host_priv(shost);
1691        ep = iscsi_create_endpoint(sizeof(struct qla_endpoint));
1692        if (!ep) {
1693                ret = -ENOMEM;
1694                return ERR_PTR(ret);
1695        }
1696
1697        qla_ep = ep->dd_data;
1698        memset(qla_ep, 0, sizeof(struct qla_endpoint));
1699        if (dst_addr->sa_family == AF_INET) {
1700                memcpy(&qla_ep->dst_addr, dst_addr, sizeof(struct sockaddr_in));
1701                addr = (struct sockaddr_in *)&qla_ep->dst_addr;
1702                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI4\n", __func__,
1703                                  (char *)&addr->sin_addr));
1704        } else if (dst_addr->sa_family == AF_INET6) {
1705                memcpy(&qla_ep->dst_addr, dst_addr,
1706                       sizeof(struct sockaddr_in6));
1707                addr6 = (struct sockaddr_in6 *)&qla_ep->dst_addr;
1708                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI6\n", __func__,
1709                                  (char *)&addr6->sin6_addr));
1710        } else {
1711                ql4_printk(KERN_WARNING, ha, "%s: Invalid endpoint\n",
1712                           __func__);
1713        }
1714
1715        qla_ep->host = shost;
1716
1717        return ep;
1718}
1719
1720static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1721{
1722        struct qla_endpoint *qla_ep;
1723        struct scsi_qla_host *ha;
1724        int ret = 0;
1725
1726        qla_ep = ep->dd_data;
1727        ha = to_qla_host(qla_ep->host);
1728        DEBUG2(pr_info_ratelimited("%s: host: %ld\n", __func__, ha->host_no));
1729
1730        if (adapter_up(ha) && !test_bit(AF_BUILD_DDB_LIST, &ha->flags))
1731                ret = 1;
1732
1733        return ret;
1734}
1735
1736static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep)
1737{
1738        struct qla_endpoint *qla_ep;
1739        struct scsi_qla_host *ha;
1740
1741        qla_ep = ep->dd_data;
1742        ha = to_qla_host(qla_ep->host);
1743        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1744                          ha->host_no));
1745        iscsi_destroy_endpoint(ep);
1746}
1747
1748static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
1749                                enum iscsi_param param,
1750                                char *buf)
1751{
1752        struct qla_endpoint *qla_ep = ep->dd_data;
1753        struct sockaddr *dst_addr;
1754        struct scsi_qla_host *ha;
1755
1756        if (!qla_ep)
1757                return -ENOTCONN;
1758
1759        ha = to_qla_host(qla_ep->host);
1760        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1761                          ha->host_no));
1762
1763        switch (param) {
1764        case ISCSI_PARAM_CONN_PORT:
1765        case ISCSI_PARAM_CONN_ADDRESS:
1766                dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
1767                if (!dst_addr)
1768                        return -ENOTCONN;
1769
1770                return iscsi_conn_get_addr_param((struct sockaddr_storage *)
1771                                                 &qla_ep->dst_addr, param, buf);
1772        default:
1773                return -ENOSYS;
1774        }
1775}
1776
1777static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
1778                                   struct iscsi_stats *stats)
1779{
1780        struct iscsi_session *sess;
1781        struct iscsi_cls_session *cls_sess;
1782        struct ddb_entry *ddb_entry;
1783        struct scsi_qla_host *ha;
1784        struct ql_iscsi_stats *ql_iscsi_stats;
1785        int stats_size;
1786        int ret;
1787        dma_addr_t iscsi_stats_dma;
1788
1789        cls_sess = iscsi_conn_to_session(cls_conn);
1790        sess = cls_sess->dd_data;
1791        ddb_entry = sess->dd_data;
1792        ha = ddb_entry->ha;
1793
1794        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1795                          ha->host_no));
1796        stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
1797        /* Allocate memory */
1798        ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
1799                                            &iscsi_stats_dma, GFP_KERNEL);
1800        if (!ql_iscsi_stats) {
1801                ql4_printk(KERN_ERR, ha,
1802                           "Unable to allocate memory for iscsi stats\n");
1803                goto exit_get_stats;
1804        }
1805
1806        ret =  qla4xxx_get_mgmt_data(ha, ddb_entry->fw_ddb_index, stats_size,
1807                                     iscsi_stats_dma);
1808        if (ret != QLA_SUCCESS) {
1809                ql4_printk(KERN_ERR, ha,
1810                           "Unable to retrieve iscsi stats\n");
1811                goto free_stats;
1812        }
1813
1814        /* octets */
1815        stats->txdata_octets = le64_to_cpu(ql_iscsi_stats->tx_data_octets);
1816        stats->rxdata_octets = le64_to_cpu(ql_iscsi_stats->rx_data_octets);
1817        /* xmit pdus */
1818        stats->noptx_pdus = le32_to_cpu(ql_iscsi_stats->tx_nopout_pdus);
1819        stats->scsicmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_cmd_pdus);
1820        stats->tmfcmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_tmf_cmd_pdus);
1821        stats->login_pdus = le32_to_cpu(ql_iscsi_stats->tx_login_cmd_pdus);
1822        stats->text_pdus = le32_to_cpu(ql_iscsi_stats->tx_text_cmd_pdus);
1823        stats->dataout_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_write_pdus);
1824        stats->logout_pdus = le32_to_cpu(ql_iscsi_stats->tx_logout_cmd_pdus);
1825        stats->snack_pdus = le32_to_cpu(ql_iscsi_stats->tx_snack_req_pdus);
1826        /* recv pdus */
1827        stats->noprx_pdus = le32_to_cpu(ql_iscsi_stats->rx_nopin_pdus);
1828        stats->scsirsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_resp_pdus);
1829        stats->tmfrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_tmf_resp_pdus);
1830        stats->textrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_text_resp_pdus);
1831        stats->datain_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_read_pdus);
1832        stats->logoutrsp_pdus =
1833                        le32_to_cpu(ql_iscsi_stats->rx_logout_resp_pdus);
1834        stats->r2t_pdus = le32_to_cpu(ql_iscsi_stats->rx_r2t_pdus);
1835        stats->async_pdus = le32_to_cpu(ql_iscsi_stats->rx_async_pdus);
1836        stats->rjt_pdus = le32_to_cpu(ql_iscsi_stats->rx_reject_pdus);
1837
1838free_stats:
1839        dma_free_coherent(&ha->pdev->dev, stats_size, ql_iscsi_stats,
1840                          iscsi_stats_dma);
1841exit_get_stats:
1842        return;
1843}
1844
1845static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc)
1846{
1847        struct iscsi_cls_session *session;
1848        struct iscsi_session *sess;
1849        unsigned long flags;
1850        enum blk_eh_timer_return ret = BLK_EH_DONE;
1851
1852        session = starget_to_session(scsi_target(sc->device));
1853        sess = session->dd_data;
1854
1855        spin_lock_irqsave(&session->lock, flags);
1856        if (session->state == ISCSI_SESSION_FAILED)
1857                ret = BLK_EH_RESET_TIMER;
1858        spin_unlock_irqrestore(&session->lock, flags);
1859
1860        return ret;
1861}
1862
1863static void qla4xxx_set_port_speed(struct Scsi_Host *shost)
1864{
1865        struct scsi_qla_host *ha = to_qla_host(shost);
1866        struct iscsi_cls_host *ihost = shost->shost_data;
1867        uint32_t speed = ISCSI_PORT_SPEED_UNKNOWN;
1868
1869        qla4xxx_get_firmware_state(ha);
1870
1871        switch (ha->addl_fw_state & 0x0F00) {
1872        case FW_ADDSTATE_LINK_SPEED_10MBPS:
1873                speed = ISCSI_PORT_SPEED_10MBPS;
1874                break;
1875        case FW_ADDSTATE_LINK_SPEED_100MBPS:
1876                speed = ISCSI_PORT_SPEED_100MBPS;
1877                break;
1878        case FW_ADDSTATE_LINK_SPEED_1GBPS:
1879                speed = ISCSI_PORT_SPEED_1GBPS;
1880                break;
1881        case FW_ADDSTATE_LINK_SPEED_10GBPS:
1882                speed = ISCSI_PORT_SPEED_10GBPS;
1883                break;
1884        }
1885        ihost->port_speed = speed;
1886}
1887
1888static void qla4xxx_set_port_state(struct Scsi_Host *shost)
1889{
1890        struct scsi_qla_host *ha = to_qla_host(shost);
1891        struct iscsi_cls_host *ihost = shost->shost_data;
1892        uint32_t state = ISCSI_PORT_STATE_DOWN;
1893
1894        if (test_bit(AF_LINK_UP, &ha->flags))
1895                state = ISCSI_PORT_STATE_UP;
1896
1897        ihost->port_state = state;
1898}
1899
1900static int qla4xxx_host_get_param(struct Scsi_Host *shost,
1901                                  enum iscsi_host_param param, char *buf)
1902{
1903        struct scsi_qla_host *ha = to_qla_host(shost);
1904        int len;
1905
1906        switch (param) {
1907        case ISCSI_HOST_PARAM_HWADDRESS:
1908                len = sysfs_format_mac(buf, ha->my_mac, MAC_ADDR_LEN);
1909                break;
1910        case ISCSI_HOST_PARAM_IPADDRESS:
1911                len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address);
1912                break;
1913        case ISCSI_HOST_PARAM_INITIATOR_NAME:
1914                len = sprintf(buf, "%s\n", ha->name_string);
1915                break;
1916        case ISCSI_HOST_PARAM_PORT_STATE:
1917                qla4xxx_set_port_state(shost);
1918                len = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
1919                break;
1920        case ISCSI_HOST_PARAM_PORT_SPEED:
1921                qla4xxx_set_port_speed(shost);
1922                len = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
1923                break;
1924        default:
1925                return -ENOSYS;
1926        }
1927
1928        return len;
1929}
1930
1931static void qla4xxx_create_ipv4_iface(struct scsi_qla_host *ha)
1932{
1933        if (ha->iface_ipv4)
1934                return;
1935
1936        /* IPv4 */
1937        ha->iface_ipv4 = iscsi_create_iface(ha->host,
1938                                            &qla4xxx_iscsi_transport,
1939                                            ISCSI_IFACE_TYPE_IPV4, 0, 0);
1940        if (!ha->iface_ipv4)
1941                ql4_printk(KERN_ERR, ha, "Could not create IPv4 iSCSI "
1942                           "iface0.\n");
1943}
1944
1945static void qla4xxx_create_ipv6_iface(struct scsi_qla_host *ha)
1946{
1947        if (!ha->iface_ipv6_0)
1948                /* IPv6 iface-0 */
1949                ha->iface_ipv6_0 = iscsi_create_iface(ha->host,
1950                                                      &qla4xxx_iscsi_transport,
1951                                                      ISCSI_IFACE_TYPE_IPV6, 0,
1952                                                      0);
1953        if (!ha->iface_ipv6_0)
1954                ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
1955                           "iface0.\n");
1956
1957        if (!ha->iface_ipv6_1)
1958                /* IPv6 iface-1 */
1959                ha->iface_ipv6_1 = iscsi_create_iface(ha->host,
1960                                                      &qla4xxx_iscsi_transport,
1961                                                      ISCSI_IFACE_TYPE_IPV6, 1,
1962                                                      0);
1963        if (!ha->iface_ipv6_1)
1964                ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
1965                           "iface1.\n");
1966}
1967
1968static void qla4xxx_create_ifaces(struct scsi_qla_host *ha)
1969{
1970        if (ha->ip_config.ipv4_options & IPOPT_IPV4_PROTOCOL_ENABLE)
1971                qla4xxx_create_ipv4_iface(ha);
1972
1973        if (ha->ip_config.ipv6_options & IPV6_OPT_IPV6_PROTOCOL_ENABLE)
1974                qla4xxx_create_ipv6_iface(ha);
1975}
1976
1977static void qla4xxx_destroy_ipv4_iface(struct scsi_qla_host *ha)
1978{
1979        if (ha->iface_ipv4) {
1980                iscsi_destroy_iface(ha->iface_ipv4);
1981                ha->iface_ipv4 = NULL;
1982        }
1983}
1984
1985static void qla4xxx_destroy_ipv6_iface(struct scsi_qla_host *ha)
1986{
1987        if (ha->iface_ipv6_0) {
1988                iscsi_destroy_iface(ha->iface_ipv6_0);
1989                ha->iface_ipv6_0 = NULL;
1990        }
1991        if (ha->iface_ipv6_1) {
1992                iscsi_destroy_iface(ha->iface_ipv6_1);
1993                ha->iface_ipv6_1 = NULL;
1994        }
1995}
1996
1997static void qla4xxx_destroy_ifaces(struct scsi_qla_host *ha)
1998{
1999        qla4xxx_destroy_ipv4_iface(ha);
2000        qla4xxx_destroy_ipv6_iface(ha);
2001}
2002
2003static void qla4xxx_set_ipv6(struct scsi_qla_host *ha,
2004                             struct iscsi_iface_param_info *iface_param,
2005                             struct addr_ctrl_blk *init_fw_cb)
2006{
2007        /*
2008         * iface_num 0 is valid for IPv6 Addr, linklocal, router, autocfg.
2009         * iface_num 1 is valid only for IPv6 Addr.
2010         */
2011        switch (iface_param->param) {
2012        case ISCSI_NET_PARAM_IPV6_ADDR:
2013                if (iface_param->iface_num & 0x1)
2014                        /* IPv6 Addr 1 */
2015                        memcpy(init_fw_cb->ipv6_addr1, iface_param->value,
2016                               sizeof(init_fw_cb->ipv6_addr1));
2017                else
2018                        /* IPv6 Addr 0 */
2019                        memcpy(init_fw_cb->ipv6_addr0, iface_param->value,
2020                               sizeof(init_fw_cb->ipv6_addr0));
2021                break;
2022        case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
2023                if (iface_param->iface_num & 0x1)
2024                        break;
2025                memcpy(init_fw_cb->ipv6_if_id, &iface_param->value[8],
2026                       sizeof(init_fw_cb->ipv6_if_id));
2027                break;
2028        case ISCSI_NET_PARAM_IPV6_ROUTER:
2029                if (iface_param->iface_num & 0x1)
2030                        break;
2031                memcpy(init_fw_cb->ipv6_dflt_rtr_addr, iface_param->value,
2032                       sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
2033                break;
2034        case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
2035                /* Autocfg applies to even interface */
2036                if (iface_param->iface_num & 0x1)
2037                        break;
2038
2039                if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_DISABLE)
2040                        init_fw_cb->ipv6_addtl_opts &=
2041                                cpu_to_le16(
2042                                  ~IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
2043                else if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_ND_ENABLE)
2044                        init_fw_cb->ipv6_addtl_opts |=
2045                                cpu_to_le16(
2046                                  IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
2047                else
2048                        ql4_printk(KERN_ERR, ha,
2049                                   "Invalid autocfg setting for IPv6 addr\n");
2050                break;
2051        case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
2052                /* Autocfg applies to even interface */
2053                if (iface_param->iface_num & 0x1)
2054                        break;
2055
2056                if (iface_param->value[0] ==
2057                    ISCSI_IPV6_LINKLOCAL_AUTOCFG_ENABLE)
2058                        init_fw_cb->ipv6_addtl_opts |= cpu_to_le16(
2059                                        IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
2060                else if (iface_param->value[0] ==
2061                         ISCSI_IPV6_LINKLOCAL_AUTOCFG_DISABLE)
2062                        init_fw_cb->ipv6_addtl_opts &= cpu_to_le16(
2063                                       ~IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
2064                else
2065                        ql4_printk(KERN_ERR, ha,
2066                                   "Invalid autocfg setting for IPv6 linklocal addr\n");
2067                break;
2068        case ISCSI_NET_PARAM_IPV6_ROUTER_AUTOCFG:
2069                /* Autocfg applies to even interface */
2070                if (iface_param->iface_num & 0x1)
2071                        break;
2072
2073                if (iface_param->value[0] == ISCSI_IPV6_ROUTER_AUTOCFG_ENABLE)
2074                        memset(init_fw_cb->ipv6_dflt_rtr_addr, 0,
2075                               sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
2076                break;
2077        case ISCSI_NET_PARAM_IFACE_ENABLE:
2078                if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {
2079                        init_fw_cb->ipv6_opts |=
2080                                cpu_to_le16(IPV6_OPT_IPV6_PROTOCOL_ENABLE);
2081                        qla4xxx_create_ipv6_iface(ha);
2082                } else {
2083                        init_fw_cb->ipv6_opts &=
2084                                cpu_to_le16(~IPV6_OPT_IPV6_PROTOCOL_ENABLE &
2085                                            0xFFFF);
2086                        qla4xxx_destroy_ipv6_iface(ha);
2087                }
2088                break;
2089        case ISCSI_NET_PARAM_VLAN_TAG:
2090                if (iface_param->len != sizeof(init_fw_cb->ipv6_vlan_tag))
2091                        break;
2092                init_fw_cb->ipv6_vlan_tag =
2093                                cpu_to_be16(*(uint16_t *)iface_param->value);
2094                break;
2095        case ISCSI_NET_PARAM_VLAN_ENABLED:
2096                if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
2097                        init_fw_cb->ipv6_opts |=
2098                                cpu_to_le16(IPV6_OPT_VLAN_TAGGING_ENABLE);
2099                else
2100                        init_fw_cb->ipv6_opts &=
2101                                cpu_to_le16(~IPV6_OPT_VLAN_TAGGING_ENABLE);
2102                break;
2103        case ISCSI_NET_PARAM_MTU:
2104                init_fw_cb->eth_mtu_size =
2105                                cpu_to_le16(*(uint16_t *)iface_param->value);
2106                break;
2107        case ISCSI_NET_PARAM_PORT:
2108                /* Autocfg applies to even interface */
2109                if (iface_param->iface_num & 0x1)
2110                        break;
2111
2112                init_fw_cb->ipv6_port =
2113                                cpu_to_le16(*(uint16_t *)iface_param->value);
2114                break;
2115        case ISCSI_NET_PARAM_DELAYED_ACK_EN:
2116                if (iface_param->iface_num & 0x1)
2117                        break;
2118                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2119                        init_fw_cb->ipv6_tcp_opts |=
2120                                cpu_to_le16(IPV6_TCPOPT_DELAYED_ACK_DISABLE);
2121                else
2122                        init_fw_cb->ipv6_tcp_opts &=
2123                                cpu_to_le16(~IPV6_TCPOPT_DELAYED_ACK_DISABLE &
2124                                            0xFFFF);
2125                break;
2126        case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
2127                if (iface_param->iface_num & 0x1)
2128                        break;
2129                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2130                        init_fw_cb->ipv6_tcp_opts |=
2131                                cpu_to_le16(IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
2132                else
2133                        init_fw_cb->ipv6_tcp_opts &=
2134                                cpu_to_le16(~IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
2135                break;
2136        case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
2137                if (iface_param->iface_num & 0x1)
2138                        break;
2139                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2140                        init_fw_cb->ipv6_tcp_opts |=
2141                                cpu_to_le16(IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
2142                else
2143                        init_fw_cb->ipv6_tcp_opts &=
2144                                cpu_to_le16(~IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
2145                break;
2146        case ISCSI_NET_PARAM_TCP_WSF:
2147                if (iface_param->iface_num & 0x1)
2148                        break;
2149                init_fw_cb->ipv6_tcp_wsf = iface_param->value[0];
2150                break;
2151        case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
2152                if (iface_param->iface_num & 0x1)
2153                        break;
2154                init_fw_cb->ipv6_tcp_opts &=
2155                                        cpu_to_le16(~IPV6_TCPOPT_TIMER_SCALE);
2156                init_fw_cb->ipv6_tcp_opts |=
2157                                cpu_to_le16((iface_param->value[0] << 1) &
2158                                            IPV6_TCPOPT_TIMER_SCALE);
2159                break;
2160        case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
2161                if (iface_param->iface_num & 0x1)
2162                        break;
2163                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2164                        init_fw_cb->ipv6_tcp_opts |=
2165                                cpu_to_le16(IPV6_TCPOPT_TIMESTAMP_EN);
2166                else
2167                        init_fw_cb->ipv6_tcp_opts &=
2168                                cpu_to_le16(~IPV6_TCPOPT_TIMESTAMP_EN);
2169                break;
2170        case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
2171                if (iface_param->iface_num & 0x1)
2172                        break;
2173                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2174                        init_fw_cb->ipv6_opts |=
2175                                cpu_to_le16(IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
2176                else
2177                        init_fw_cb->ipv6_opts &=
2178                                cpu_to_le16(~IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
2179                break;
2180        case ISCSI_NET_PARAM_REDIRECT_EN:
2181                if (iface_param->iface_num & 0x1)
2182                        break;
2183                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2184                        init_fw_cb->ipv6_opts |=
2185                                cpu_to_le16(IPV6_OPT_REDIRECT_EN);
2186                else
2187                        init_fw_cb->ipv6_opts &=
2188                                cpu_to_le16(~IPV6_OPT_REDIRECT_EN);
2189                break;
2190        case ISCSI_NET_PARAM_IPV6_MLD_EN:
2191                if (iface_param->iface_num & 0x1)
2192                        break;
2193                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2194                        init_fw_cb->ipv6_addtl_opts |=
2195                                cpu_to_le16(IPV6_ADDOPT_MLD_EN);
2196                else
2197                        init_fw_cb->ipv6_addtl_opts &=
2198                                cpu_to_le16(~IPV6_ADDOPT_MLD_EN);
2199                break;
2200        case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
2201                if (iface_param->iface_num & 0x1)
2202                        break;
2203                init_fw_cb->ipv6_flow_lbl =
2204                                cpu_to_le16(*(uint16_t *)iface_param->value);
2205                break;
2206        case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
2207                if (iface_param->iface_num & 0x1)
2208                        break;
2209                init_fw_cb->ipv6_traffic_class = iface_param->value[0];
2210                break;
2211        case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
2212                if (iface_param->iface_num & 0x1)
2213                        break;
2214                init_fw_cb->ipv6_hop_limit = iface_param->value[0];
2215                break;
2216        case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
2217                if (iface_param->iface_num & 0x1)
2218                        break;
2219                init_fw_cb->ipv6_nd_reach_time =
2220                                cpu_to_le32(*(uint32_t *)iface_param->value);
2221                break;
2222        case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
2223                if (iface_param->iface_num & 0x1)
2224                        break;
2225                init_fw_cb->ipv6_nd_rexmit_timer =
2226                                cpu_to_le32(*(uint32_t *)iface_param->value);
2227                break;
2228        case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
2229                if (iface_param->iface_num & 0x1)
2230                        break;
2231                init_fw_cb->ipv6_nd_stale_timeout =
2232                                cpu_to_le32(*(uint32_t *)iface_param->value);
2233                break;
2234        case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
2235                if (iface_param->iface_num & 0x1)
2236                        break;
2237                init_fw_cb->ipv6_dup_addr_detect_count = iface_param->value[0];
2238                break;
2239        case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
2240                if (iface_param->iface_num & 0x1)
2241                        break;
2242                init_fw_cb->ipv6_gw_advrt_mtu =
2243                                cpu_to_le32(*(uint32_t *)iface_param->value);
2244                break;
2245        default:
2246                ql4_printk(KERN_ERR, ha, "Unknown IPv6 param = %d\n",
2247                           iface_param->param);
2248                break;
2249        }
2250}
2251
2252static void qla4xxx_set_ipv4(struct scsi_qla_host *ha,
2253                             struct iscsi_iface_param_info *iface_param,
2254                             struct addr_ctrl_blk *init_fw_cb)
2255{
2256        switch (iface_param->param) {
2257        case ISCSI_NET_PARAM_IPV4_ADDR:
2258                memcpy(init_fw_cb->ipv4_addr, iface_param->value,
2259                       sizeof(init_fw_cb->ipv4_addr));
2260                break;
2261        case ISCSI_NET_PARAM_IPV4_SUBNET:
2262                memcpy(init_fw_cb->ipv4_subnet, iface_param->value,
2263                       sizeof(init_fw_cb->ipv4_subnet));
2264                break;
2265        case ISCSI_NET_PARAM_IPV4_GW:
2266                memcpy(init_fw_cb->ipv4_gw_addr, iface_param->value,
2267                       sizeof(init_fw_cb->ipv4_gw_addr));
2268                break;
2269        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
2270                if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP)
2271                        init_fw_cb->ipv4_tcp_opts |=
2272                                        cpu_to_le16(TCPOPT_DHCP_ENABLE);
2273                else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC)
2274                        init_fw_cb->ipv4_tcp_opts &=
2275                                        cpu_to_le16(~TCPOPT_DHCP_ENABLE);
2276                else
2277                        ql4_printk(KERN_ERR, ha, "Invalid IPv4 bootproto\n");
2278                break;
2279        case ISCSI_NET_PARAM_IFACE_ENABLE:
2280                if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {
2281                        init_fw_cb->ipv4_ip_opts |=
2282                                cpu_to_le16(IPOPT_IPV4_PROTOCOL_ENABLE);
2283                        qla4xxx_create_ipv4_iface(ha);
2284                } else {
2285                        init_fw_cb->ipv4_ip_opts &=
2286                                cpu_to_le16(~IPOPT_IPV4_PROTOCOL_ENABLE &
2287                                            0xFFFF);
2288                        qla4xxx_destroy_ipv4_iface(ha);
2289                }
2290                break;
2291        case ISCSI_NET_PARAM_VLAN_TAG:
2292                if (iface_param->len != sizeof(init_fw_cb->ipv4_vlan_tag))
2293                        break;
2294                init_fw_cb->ipv4_vlan_tag =
2295                                cpu_to_be16(*(uint16_t *)iface_param->value);
2296                break;
2297        case ISCSI_NET_PARAM_VLAN_ENABLED:
2298                if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
2299                        init_fw_cb->ipv4_ip_opts |=
2300                                        cpu_to_le16(IPOPT_VLAN_TAGGING_ENABLE);
2301                else
2302                        init_fw_cb->ipv4_ip_opts &=
2303                                        cpu_to_le16(~IPOPT_VLAN_TAGGING_ENABLE);
2304                break;
2305        case ISCSI_NET_PARAM_MTU:
2306                init_fw_cb->eth_mtu_size =
2307                                cpu_to_le16(*(uint16_t *)iface_param->value);
2308                break;
2309        case ISCSI_NET_PARAM_PORT:
2310                init_fw_cb->ipv4_port =
2311                                cpu_to_le16(*(uint16_t *)iface_param->value);
2312                break;
2313        case ISCSI_NET_PARAM_DELAYED_ACK_EN:
2314                if (iface_param->iface_num & 0x1)
2315                        break;
2316                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2317                        init_fw_cb->ipv4_tcp_opts |=
2318                                cpu_to_le16(TCPOPT_DELAYED_ACK_DISABLE);
2319                else
2320                        init_fw_cb->ipv4_tcp_opts &=
2321                                cpu_to_le16(~TCPOPT_DELAYED_ACK_DISABLE &
2322                                            0xFFFF);
2323                break;
2324        case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
2325                if (iface_param->iface_num & 0x1)
2326                        break;
2327                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2328                        init_fw_cb->ipv4_tcp_opts |=
2329                                cpu_to_le16(TCPOPT_NAGLE_ALGO_DISABLE);
2330                else
2331                        init_fw_cb->ipv4_tcp_opts &=
2332                                cpu_to_le16(~TCPOPT_NAGLE_ALGO_DISABLE);
2333                break;
2334        case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
2335                if (iface_param->iface_num & 0x1)
2336                        break;
2337                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2338                        init_fw_cb->ipv4_tcp_opts |=
2339                                cpu_to_le16(TCPOPT_WINDOW_SCALE_DISABLE);
2340                else
2341                        init_fw_cb->ipv4_tcp_opts &=
2342                                cpu_to_le16(~TCPOPT_WINDOW_SCALE_DISABLE);
2343                break;
2344        case ISCSI_NET_PARAM_TCP_WSF:
2345                if (iface_param->iface_num & 0x1)
2346                        break;
2347                init_fw_cb->ipv4_tcp_wsf = iface_param->value[0];
2348                break;
2349        case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
2350                if (iface_param->iface_num & 0x1)
2351                        break;
2352                init_fw_cb->ipv4_tcp_opts &= cpu_to_le16(~TCPOPT_TIMER_SCALE);
2353                init_fw_cb->ipv4_tcp_opts |=
2354                                cpu_to_le16((iface_param->value[0] << 1) &
2355                                            TCPOPT_TIMER_SCALE);
2356                break;
2357        case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
2358                if (iface_param->iface_num & 0x1)
2359                        break;
2360                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2361                        init_fw_cb->ipv4_tcp_opts |=
2362                                cpu_to_le16(TCPOPT_TIMESTAMP_ENABLE);
2363                else
2364                        init_fw_cb->ipv4_tcp_opts &=
2365                                cpu_to_le16(~TCPOPT_TIMESTAMP_ENABLE);
2366                break;
2367        case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
2368                if (iface_param->iface_num & 0x1)
2369                        break;
2370                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2371                        init_fw_cb->ipv4_tcp_opts |=
2372                                cpu_to_le16(TCPOPT_DNS_SERVER_IP_EN);
2373                else
2374                        init_fw_cb->ipv4_tcp_opts &=
2375                                cpu_to_le16(~TCPOPT_DNS_SERVER_IP_EN);
2376                break;
2377        case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
2378                if (iface_param->iface_num & 0x1)
2379                        break;
2380                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2381                        init_fw_cb->ipv4_tcp_opts |=
2382                                cpu_to_le16(TCPOPT_SLP_DA_INFO_EN);
2383                else
2384                        init_fw_cb->ipv4_tcp_opts &=
2385                                cpu_to_le16(~TCPOPT_SLP_DA_INFO_EN);
2386                break;
2387        case ISCSI_NET_PARAM_IPV4_TOS_EN:
2388                if (iface_param->iface_num & 0x1)
2389                        break;
2390                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2391                        init_fw_cb->ipv4_ip_opts |=
2392                                cpu_to_le16(IPOPT_IPV4_TOS_EN);
2393                else
2394                        init_fw_cb->ipv4_ip_opts &=
2395                                cpu_to_le16(~IPOPT_IPV4_TOS_EN);
2396                break;
2397        case ISCSI_NET_PARAM_IPV4_TOS:
2398                if (iface_param->iface_num & 0x1)
2399                        break;
2400                init_fw_cb->ipv4_tos = iface_param->value[0];
2401                break;
2402        case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
2403                if (iface_param->iface_num & 0x1)
2404                        break;
2405                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2406                        init_fw_cb->ipv4_ip_opts |=
2407                                        cpu_to_le16(IPOPT_GRAT_ARP_EN);
2408                else
2409                        init_fw_cb->ipv4_ip_opts &=
2410                                        cpu_to_le16(~IPOPT_GRAT_ARP_EN);
2411                break;
2412        case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
2413                if (iface_param->iface_num & 0x1)
2414                        break;
2415                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2416                        init_fw_cb->ipv4_ip_opts |=
2417                                cpu_to_le16(IPOPT_ALT_CID_EN);
2418                else
2419                        init_fw_cb->ipv4_ip_opts &=
2420                                cpu_to_le16(~IPOPT_ALT_CID_EN);
2421                break;
2422        case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
2423                if (iface_param->iface_num & 0x1)
2424                        break;
2425                memcpy(init_fw_cb->ipv4_dhcp_alt_cid, iface_param->value,
2426                       (sizeof(init_fw_cb->ipv4_dhcp_alt_cid) - 1));
2427                init_fw_cb->ipv4_dhcp_alt_cid_len =
2428                                        strlen(init_fw_cb->ipv4_dhcp_alt_cid);
2429                break;
2430        case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
2431                if (iface_param->iface_num & 0x1)
2432                        break;
2433                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2434                        init_fw_cb->ipv4_ip_opts |=
2435                                        cpu_to_le16(IPOPT_REQ_VID_EN);
2436                else
2437                        init_fw_cb->ipv4_ip_opts &=
2438                                        cpu_to_le16(~IPOPT_REQ_VID_EN);
2439                break;
2440        case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
2441                if (iface_param->iface_num & 0x1)
2442                        break;
2443                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2444                        init_fw_cb->ipv4_ip_opts |=
2445                                        cpu_to_le16(IPOPT_USE_VID_EN);
2446                else
2447                        init_fw_cb->ipv4_ip_opts &=
2448                                        cpu_to_le16(~IPOPT_USE_VID_EN);
2449                break;
2450        case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
2451                if (iface_param->iface_num & 0x1)
2452                        break;
2453                memcpy(init_fw_cb->ipv4_dhcp_vid, iface_param->value,
2454                       (sizeof(init_fw_cb->ipv4_dhcp_vid) - 1));
2455                init_fw_cb->ipv4_dhcp_vid_len =
2456                                        strlen(init_fw_cb->ipv4_dhcp_vid);
2457                break;
2458        case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
2459                if (iface_param->iface_num & 0x1)
2460                        break;
2461                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2462                        init_fw_cb->ipv4_ip_opts |=
2463                                        cpu_to_le16(IPOPT_LEARN_IQN_EN);
2464                else
2465                        init_fw_cb->ipv4_ip_opts &=
2466                                        cpu_to_le16(~IPOPT_LEARN_IQN_EN);
2467                break;
2468        case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
2469                if (iface_param->iface_num & 0x1)
2470                        break;
2471                if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2472                        init_fw_cb->ipv4_ip_opts |=
2473                                cpu_to_le16(IPOPT_FRAGMENTATION_DISABLE);
2474                else
2475                        init_fw_cb->ipv4_ip_opts &=
2476                                cpu_to_le16(~IPOPT_FRAGMENTATION_DISABLE);
2477                break;
2478        case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
2479                if (iface_param->iface_num & 0x1)
2480                        break;
2481                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2482                        init_fw_cb->ipv4_ip_opts |=
2483                                cpu_to_le16(IPOPT_IN_FORWARD_EN);
2484                else
2485                        init_fw_cb->ipv4_ip_opts &=
2486                                cpu_to_le16(~IPOPT_IN_FORWARD_EN);
2487                break;
2488        case ISCSI_NET_PARAM_REDIRECT_EN:
2489                if (iface_param->iface_num & 0x1)
2490                        break;
2491                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2492                        init_fw_cb->ipv4_ip_opts |=
2493                                cpu_to_le16(IPOPT_ARP_REDIRECT_EN);
2494                else
2495                        init_fw_cb->ipv4_ip_opts &=
2496                                cpu_to_le16(~IPOPT_ARP_REDIRECT_EN);
2497                break;
2498        case ISCSI_NET_PARAM_IPV4_TTL:
2499                if (iface_param->iface_num & 0x1)
2500                        break;
2501                init_fw_cb->ipv4_ttl = iface_param->value[0];
2502                break;
2503        default:
2504                ql4_printk(KERN_ERR, ha, "Unknown IPv4 param = %d\n",
2505                           iface_param->param);
2506                break;
2507        }
2508}
2509
2510static void qla4xxx_set_iscsi_param(struct scsi_qla_host *ha,
2511                                    struct iscsi_iface_param_info *iface_param,
2512                                    struct addr_ctrl_blk *init_fw_cb)
2513{
2514        switch (iface_param->param) {
2515        case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
2516                if (iface_param->iface_num & 0x1)
2517                        break;
2518                init_fw_cb->def_timeout =
2519                                cpu_to_le16(*(uint16_t *)iface_param->value);
2520                break;
2521        case ISCSI_IFACE_PARAM_HDRDGST_EN:
2522                if (iface_param->iface_num & 0x1)
2523                        break;
2524                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2525                        init_fw_cb->iscsi_opts |=
2526                                cpu_to_le16(ISCSIOPTS_HEADER_DIGEST_EN);
2527                else
2528                        init_fw_cb->iscsi_opts &=
2529                                cpu_to_le16(~ISCSIOPTS_HEADER_DIGEST_EN);
2530                break;
2531        case ISCSI_IFACE_PARAM_DATADGST_EN:
2532                if (iface_param->iface_num & 0x1)
2533                        break;
2534                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2535                        init_fw_cb->iscsi_opts |=
2536                                cpu_to_le16(ISCSIOPTS_DATA_DIGEST_EN);
2537                else
2538                        init_fw_cb->iscsi_opts &=
2539                                cpu_to_le16(~ISCSIOPTS_DATA_DIGEST_EN);
2540                break;
2541        case ISCSI_IFACE_PARAM_IMM_DATA_EN:
2542                if (iface_param->iface_num & 0x1)
2543                        break;
2544                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2545                        init_fw_cb->iscsi_opts |=
2546                                cpu_to_le16(ISCSIOPTS_IMMEDIATE_DATA_EN);
2547                else
2548                        init_fw_cb->iscsi_opts &=
2549                                cpu_to_le16(~ISCSIOPTS_IMMEDIATE_DATA_EN);
2550                break;
2551        case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
2552                if (iface_param->iface_num & 0x1)
2553                        break;
2554                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2555                        init_fw_cb->iscsi_opts |=
2556                                cpu_to_le16(ISCSIOPTS_INITIAL_R2T_EN);
2557                else
2558                        init_fw_cb->iscsi_opts &=
2559                                cpu_to_le16(~ISCSIOPTS_INITIAL_R2T_EN);
2560                break;
2561        case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
2562                if (iface_param->iface_num & 0x1)
2563                        break;
2564                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2565                        init_fw_cb->iscsi_opts |=
2566                                cpu_to_le16(ISCSIOPTS_DATA_SEQ_INORDER_EN);
2567                else
2568                        init_fw_cb->iscsi_opts &=
2569                                cpu_to_le16(~ISCSIOPTS_DATA_SEQ_INORDER_EN);
2570                break;
2571        case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
2572                if (iface_param->iface_num & 0x1)
2573                        break;
2574                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2575                        init_fw_cb->iscsi_opts |=
2576                                cpu_to_le16(ISCSIOPTS_DATA_PDU_INORDER_EN);
2577                else
2578                        init_fw_cb->iscsi_opts &=
2579                                cpu_to_le16(~ISCSIOPTS_DATA_PDU_INORDER_EN);
2580                break;
2581        case ISCSI_IFACE_PARAM_ERL:
2582                if (iface_param->iface_num & 0x1)
2583                        break;
2584                init_fw_cb->iscsi_opts &= cpu_to_le16(~ISCSIOPTS_ERL);
2585                init_fw_cb->iscsi_opts |= cpu_to_le16(iface_param->value[0] &
2586                                                      ISCSIOPTS_ERL);
2587                break;
2588        case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
2589                if (iface_param->iface_num & 0x1)
2590                        break;
2591                init_fw_cb->iscsi_max_pdu_size =
2592                                cpu_to_le32(*(uint32_t *)iface_param->value) /
2593                                BYTE_UNITS;
2594                break;
2595        case ISCSI_IFACE_PARAM_FIRST_BURST:
2596                if (iface_param->iface_num & 0x1)
2597                        break;
2598                init_fw_cb->iscsi_fburst_len =
2599                                cpu_to_le32(*(uint32_t *)iface_param->value) /
2600                                BYTE_UNITS;
2601                break;
2602        case ISCSI_IFACE_PARAM_MAX_R2T:
2603                if (iface_param->iface_num & 0x1)
2604                        break;
2605                init_fw_cb->iscsi_max_outstnd_r2t =
2606                                cpu_to_le16(*(uint16_t *)iface_param->value);
2607                break;
2608        case ISCSI_IFACE_PARAM_MAX_BURST:
2609                if (iface_param->iface_num & 0x1)
2610                        break;
2611                init_fw_cb->iscsi_max_burst_len =
2612                                cpu_to_le32(*(uint32_t *)iface_param->value) /
2613                                BYTE_UNITS;
2614                break;
2615        case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
2616                if (iface_param->iface_num & 0x1)
2617                        break;
2618                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2619                        init_fw_cb->iscsi_opts |=
2620                                cpu_to_le16(ISCSIOPTS_CHAP_AUTH_EN);
2621                else
2622                        init_fw_cb->iscsi_opts &=
2623                                cpu_to_le16(~ISCSIOPTS_CHAP_AUTH_EN);
2624                break;
2625        case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
2626                if (iface_param->iface_num & 0x1)
2627                        break;
2628                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2629                        init_fw_cb->iscsi_opts |=
2630                                cpu_to_le16(ISCSIOPTS_BIDI_CHAP_EN);
2631                else
2632                        init_fw_cb->iscsi_opts &=
2633                                cpu_to_le16(~ISCSIOPTS_BIDI_CHAP_EN);
2634                break;
2635        case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
2636                if (iface_param->iface_num & 0x1)
2637                        break;
2638                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2639                        init_fw_cb->iscsi_opts |=
2640                                cpu_to_le16(ISCSIOPTS_DISCOVERY_AUTH_EN);
2641                else
2642                        init_fw_cb->iscsi_opts &=
2643                                cpu_to_le16(~ISCSIOPTS_DISCOVERY_AUTH_EN);
2644                break;
2645        case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
2646                if (iface_param->iface_num & 0x1)
2647                        break;
2648                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2649                        init_fw_cb->iscsi_opts |=
2650                                cpu_to_le16(ISCSIOPTS_DISCOVERY_LOGOUT_EN);
2651                else
2652                        init_fw_cb->iscsi_opts &=
2653                                cpu_to_le16(~ISCSIOPTS_DISCOVERY_LOGOUT_EN);
2654                break;
2655        case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
2656                if (iface_param->iface_num & 0x1)
2657                        break;
2658                if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2659                        init_fw_cb->iscsi_opts |=
2660                                cpu_to_le16(ISCSIOPTS_STRICT_LOGIN_COMP_EN);
2661                else
2662                        init_fw_cb->iscsi_opts &=
2663                                cpu_to_le16(~ISCSIOPTS_STRICT_LOGIN_COMP_EN);
2664                break;
2665        default:
2666                ql4_printk(KERN_ERR, ha, "Unknown iscsi param = %d\n",
2667                           iface_param->param);
2668                break;
2669        }
2670}
2671
2672static void
2673qla4xxx_initcb_to_acb(struct addr_ctrl_blk *init_fw_cb)
2674{
2675        struct addr_ctrl_blk_def *acb;
2676        acb = (struct addr_ctrl_blk_def *)init_fw_cb;
2677        memset(acb->reserved1, 0, sizeof(acb->reserved1));
2678        memset(acb->reserved2, 0, sizeof(acb->reserved2));
2679        memset(acb->reserved3, 0, sizeof(acb->reserved3));
2680        memset(acb->reserved4, 0, sizeof(acb->reserved4));
2681        memset(acb->reserved5, 0, sizeof(acb->reserved5));
2682        memset(acb->reserved6, 0, sizeof(acb->reserved6));
2683        memset(acb->reserved7, 0, sizeof(acb->reserved7));
2684        memset(acb->reserved8, 0, sizeof(acb->reserved8));
2685        memset(acb->reserved9, 0, sizeof(acb->reserved9));
2686        memset(acb->reserved10, 0, sizeof(acb->reserved10));
2687        memset(acb->reserved11, 0, sizeof(acb->reserved11));
2688        memset(acb->reserved12, 0, sizeof(acb->reserved12));
2689        memset(acb->reserved13, 0, sizeof(acb->reserved13));
2690        memset(acb->reserved14, 0, sizeof(acb->reserved14));
2691        memset(acb->reserved15, 0, sizeof(acb->reserved15));
2692}
2693
2694static int
2695qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len)
2696{
2697        struct scsi_qla_host *ha = to_qla_host(shost);
2698        int rval = 0;
2699        struct iscsi_iface_param_info *iface_param = NULL;
2700        struct addr_ctrl_blk *init_fw_cb = NULL;
2701        dma_addr_t init_fw_cb_dma;
2702        uint32_t mbox_cmd[MBOX_REG_COUNT];
2703        uint32_t mbox_sts[MBOX_REG_COUNT];
2704        uint32_t rem = len;
2705        struct nlattr *attr;
2706
2707        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
2708                                        sizeof(struct addr_ctrl_blk),
2709                                        &init_fw_cb_dma, GFP_KERNEL);
2710        if (!init_fw_cb) {
2711                ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb\n",
2712                           __func__);
2713                return -ENOMEM;
2714        }
2715
2716        memset(&mbox_cmd, 0, sizeof(mbox_cmd));
2717        memset(&mbox_sts, 0, sizeof(mbox_sts));
2718
2719        if (qla4xxx_get_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma)) {
2720                ql4_printk(KERN_ERR, ha, "%s: get ifcb failed\n", __func__);
2721                rval = -EIO;
2722                goto exit_init_fw_cb;
2723        }
2724
2725        nla_for_each_attr(attr, data, len, rem) {
2726                iface_param = nla_data(attr);
2727
2728                if (iface_param->param_type == ISCSI_NET_PARAM) {
2729                        switch (iface_param->iface_type) {
2730                        case ISCSI_IFACE_TYPE_IPV4:
2731                                switch (iface_param->iface_num) {
2732                                case 0:
2733                                        qla4xxx_set_ipv4(ha, iface_param,
2734                                                         init_fw_cb);
2735                                        break;
2736                                default:
2737                                /* Cannot have more than one IPv4 interface */
2738                                        ql4_printk(KERN_ERR, ha,
2739                                                   "Invalid IPv4 iface number = %d\n",
2740                                                   iface_param->iface_num);
2741                                        break;
2742                                }
2743                                break;
2744                        case ISCSI_IFACE_TYPE_IPV6:
2745                                switch (iface_param->iface_num) {
2746                                case 0:
2747                                case 1:
2748                                        qla4xxx_set_ipv6(ha, iface_param,
2749                                                         init_fw_cb);
2750                                        break;
2751                                default:
2752                                /* Cannot have more than two IPv6 interface */
2753                                        ql4_printk(KERN_ERR, ha,
2754                                                   "Invalid IPv6 iface number = %d\n",
2755                                                   iface_param->iface_num);
2756                                        break;
2757                                }
2758                                break;
2759                        default:
2760                                ql4_printk(KERN_ERR, ha,
2761                                           "Invalid iface type\n");
2762                                break;
2763                        }
2764                } else if (iface_param->param_type == ISCSI_IFACE_PARAM) {
2765                                qla4xxx_set_iscsi_param(ha, iface_param,
2766                                                        init_fw_cb);
2767                } else {
2768                        continue;
2769                }
2770        }
2771
2772        init_fw_cb->cookie = cpu_to_le32(0x11BEAD5A);
2773
2774        rval = qla4xxx_set_flash(ha, init_fw_cb_dma, FLASH_SEGMENT_IFCB,
2775                                 sizeof(struct addr_ctrl_blk),
2776                                 FLASH_OPT_RMW_COMMIT);
2777        if (rval != QLA_SUCCESS) {
2778                ql4_printk(KERN_ERR, ha, "%s: set flash mbx failed\n",
2779                           __func__);
2780                rval = -EIO;
2781                goto exit_init_fw_cb;
2782        }
2783
2784        rval = qla4xxx_disable_acb(ha);
2785        if (rval != QLA_SUCCESS) {
2786                ql4_printk(KERN_ERR, ha, "%s: disable acb mbx failed\n",
2787                           __func__);
2788                rval = -EIO;
2789                goto exit_init_fw_cb;
2790        }
2791
2792        wait_for_completion_timeout(&ha->disable_acb_comp,
2793                                    DISABLE_ACB_TOV * HZ);
2794
2795        qla4xxx_initcb_to_acb(init_fw_cb);
2796
2797        rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma);
2798        if (rval != QLA_SUCCESS) {
2799                ql4_printk(KERN_ERR, ha, "%s: set acb mbx failed\n",
2800                           __func__);
2801                rval = -EIO;
2802                goto exit_init_fw_cb;
2803        }
2804
2805        memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk));
2806        qla4xxx_update_local_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb,
2807                                  init_fw_cb_dma);
2808
2809exit_init_fw_cb:
2810        dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk),
2811                          init_fw_cb, init_fw_cb_dma);
2812
2813        return rval;
2814}
2815
2816static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
2817                                     enum iscsi_param param, char *buf)
2818{
2819        struct iscsi_session *sess = cls_sess->dd_data;
2820        struct ddb_entry *ddb_entry = sess->dd_data;
2821        struct scsi_qla_host *ha = ddb_entry->ha;
2822        struct iscsi_cls_conn *cls_conn = ddb_entry->conn;
2823        struct ql4_chap_table chap_tbl;
2824        int rval, len;
2825        uint16_t idx;
2826
2827        memset(&chap_tbl, 0, sizeof(chap_tbl));
2828        switch (param) {
2829        case ISCSI_PARAM_CHAP_IN_IDX:
2830                rval = qla4xxx_get_chap_index(ha, sess->username_in,
2831                                              sess->password_in, BIDI_CHAP,
2832                                              &idx);
2833                if (rval)
2834                        len = sprintf(buf, "\n");
2835                else
2836                        len = sprintf(buf, "%hu\n", idx);
2837                break;
2838        case ISCSI_PARAM_CHAP_OUT_IDX:
2839                if (ddb_entry->ddb_type == FLASH_DDB) {
2840                        if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
2841                                idx = ddb_entry->chap_tbl_idx;
2842                                rval = QLA_SUCCESS;
2843                        } else {
2844                                rval = QLA_ERROR;
2845                        }
2846                } else {
2847                        rval = qla4xxx_get_chap_index(ha, sess->username,
2848                                                      sess->password,
2849                                                      LOCAL_CHAP, &idx);
2850                }
2851                if (rval)
2852                        len = sprintf(buf, "\n");
2853                else
2854                        len = sprintf(buf, "%hu\n", idx);
2855                break;
2856        case ISCSI_PARAM_USERNAME:
2857        case ISCSI_PARAM_PASSWORD:
2858                /* First, populate session username and password for FLASH DDB,
2859                 * if not already done. This happens when session login fails
2860                 * for a FLASH DDB.
2861                 */
2862                if (ddb_entry->ddb_type == FLASH_DDB &&
2863                    ddb_entry->chap_tbl_idx != INVALID_ENTRY &&
2864                    !sess->username && !sess->password) {
2865                        idx = ddb_entry->chap_tbl_idx;
2866                        rval = qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
2867                                                            chap_tbl.secret,
2868                                                            idx);
2869                        if (!rval) {
2870                                iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
2871                                                (char *)chap_tbl.name,
2872                                                strlen((char *)chap_tbl.name));
2873                                iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
2874                                                (char *)chap_tbl.secret,
2875                                                chap_tbl.secret_len);
2876                        }
2877                }
2878                /* fall through */
2879        default:
2880                return iscsi_session_get_param(cls_sess, param, buf);
2881        }
2882
2883        return len;
2884}
2885
2886static int qla4xxx_conn_get_param(struct iscsi_cls_conn *cls_conn,
2887                                  enum iscsi_param param, char *buf)
2888{
2889        struct iscsi_conn *conn;
2890        struct qla_conn *qla_conn;
2891        struct sockaddr *dst_addr;
2892
2893        conn = cls_conn->dd_data;
2894        qla_conn = conn->dd_data;
2895        dst_addr = (struct sockaddr *)&qla_conn->qla_ep->dst_addr;
2896
2897        switch (param) {
2898        case ISCSI_PARAM_CONN_PORT:
2899        case ISCSI_PARAM_CONN_ADDRESS:
2900                return iscsi_conn_get_addr_param((struct sockaddr_storage *)
2901                                                 dst_addr, param, buf);
2902        default:
2903                return iscsi_conn_get_param(cls_conn, param, buf);
2904        }
2905}
2906
2907int qla4xxx_get_ddb_index(struct scsi_qla_host *ha, uint16_t *ddb_index)
2908{
2909        uint32_t mbx_sts = 0;
2910        uint16_t tmp_ddb_index;
2911        int ret;
2912
2913get_ddb_index:
2914        tmp_ddb_index = find_first_zero_bit(ha->ddb_idx_map, MAX_DDB_ENTRIES);
2915
2916        if (tmp_ddb_index >= MAX_DDB_ENTRIES) {
2917                DEBUG2(ql4_printk(KERN_INFO, ha,
2918                                  "Free DDB index not available\n"));
2919                ret = QLA_ERROR;
2920                goto exit_get_ddb_index;
2921        }
2922
2923        if (test_and_set_bit(tmp_ddb_index, ha->ddb_idx_map))
2924                goto get_ddb_index;
2925
2926        DEBUG2(ql4_printk(KERN_INFO, ha,
2927                          "Found a free DDB index at %d\n", tmp_ddb_index));
2928        ret = qla4xxx_req_ddb_entry(ha, tmp_ddb_index, &mbx_sts);
2929        if (ret == QLA_ERROR) {
2930                if (mbx_sts == MBOX_STS_COMMAND_ERROR) {
2931                        ql4_printk(KERN_INFO, ha,
2932                                   "DDB index = %d not available trying next\n",
2933                                   tmp_ddb_index);
2934                        goto get_ddb_index;
2935                }
2936                DEBUG2(ql4_printk(KERN_INFO, ha,
2937                                  "Free FW DDB not available\n"));
2938        }
2939
2940        *ddb_index = tmp_ddb_index;
2941
2942exit_get_ddb_index:
2943        return ret;
2944}
2945
2946static int qla4xxx_match_ipaddress(struct scsi_qla_host *ha,
2947                                   struct ddb_entry *ddb_entry,
2948                                   char *existing_ipaddr,
2949                                   char *user_ipaddr)
2950{
2951        uint8_t dst_ipaddr[IPv6_ADDR_LEN];
2952        char formatted_ipaddr[DDB_IPADDR_LEN];
2953        int status = QLA_SUCCESS, ret = 0;
2954
2955        if (ddb_entry->fw_ddb_entry.options & DDB_OPT_IPV6_DEVICE) {
2956                ret = in6_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
2957                               '\0', NULL);
2958                if (ret == 0) {
2959                        status = QLA_ERROR;
2960                        goto out_match;
2961                }
2962                ret = sprintf(formatted_ipaddr, "%pI6", dst_ipaddr);
2963        } else {
2964                ret = in4_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
2965                               '\0', NULL);
2966                if (ret == 0) {
2967                        status = QLA_ERROR;
2968                        goto out_match;
2969                }
2970                ret = sprintf(formatted_ipaddr, "%pI4", dst_ipaddr);
2971        }
2972
2973        if (strcmp(existing_ipaddr, formatted_ipaddr))
2974                status = QLA_ERROR;
2975
2976out_match:
2977        return status;
2978}
2979
2980static int qla4xxx_match_fwdb_session(struct scsi_qla_host *ha,
2981                                      struct iscsi_cls_conn *cls_conn)
2982{
2983        int idx = 0, max_ddbs, rval;
2984        struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
2985        struct iscsi_session *sess, *existing_sess;
2986        struct iscsi_conn *conn, *existing_conn;
2987        struct ddb_entry *ddb_entry;
2988
2989        sess = cls_sess->dd_data;
2990        conn = cls_conn->dd_data;
2991
2992        if (sess->targetname == NULL ||
2993            conn->persistent_address == NULL ||
2994            conn->persistent_port == 0)
2995                return QLA_ERROR;
2996
2997        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
2998                                     MAX_DEV_DB_ENTRIES;
2999
3000        for (idx = 0; idx < max_ddbs; idx++) {
3001                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
3002                if (ddb_entry == NULL)
3003                        continue;
3004
3005                if (ddb_entry->ddb_type != FLASH_DDB)
3006                        continue;
3007
3008                existing_sess = ddb_entry->sess->dd_data;
3009                existing_conn = ddb_entry->conn->dd_data;
3010
3011                if (existing_sess->targetname == NULL ||
3012                    existing_conn->persistent_address == NULL ||
3013                    existing_conn->persistent_port == 0)
3014                        continue;
3015
3016                DEBUG2(ql4_printk(KERN_INFO, ha,
3017                                  "IQN = %s User IQN = %s\n",
3018                                  existing_sess->targetname,
3019                                  sess->targetname));
3020
3021                DEBUG2(ql4_printk(KERN_INFO, ha,
3022                                  "IP = %s User IP = %s\n",
3023                                  existing_conn->persistent_address,
3024                                  conn->persistent_address));
3025
3026                DEBUG2(ql4_printk(KERN_INFO, ha,
3027                                  "Port = %d User Port = %d\n",
3028                                  existing_conn->persistent_port,
3029                                  conn->persistent_port));
3030
3031                if (strcmp(existing_sess->targetname, sess->targetname))
3032                        continue;
3033                rval = qla4xxx_match_ipaddress(ha, ddb_entry,
3034                                        existing_conn->persistent_address,
3035                                        conn->persistent_address);
3036                if (rval == QLA_ERROR)
3037                        continue;
3038                if (existing_conn->persistent_port != conn->persistent_port)
3039                        continue;
3040                break;
3041        }
3042
3043        if (idx == max_ddbs)
3044                return QLA_ERROR;
3045
3046        DEBUG2(ql4_printk(KERN_INFO, ha,
3047                          "Match found in fwdb sessions\n"));
3048        return QLA_SUCCESS;
3049}
3050
3051static struct iscsi_cls_session *
3052qla4xxx_session_create(struct iscsi_endpoint *ep,
3053                        uint16_t cmds_max, uint16_t qdepth,
3054                        uint32_t initial_cmdsn)
3055{
3056        struct iscsi_cls_session *cls_sess;
3057        struct scsi_qla_host *ha;
3058        struct qla_endpoint *qla_ep;
3059        struct ddb_entry *ddb_entry;
3060        uint16_t ddb_index;
3061        struct iscsi_session *sess;
3062        struct sockaddr *dst_addr;
3063        int ret;
3064
3065        if (!ep) {
3066                printk(KERN_ERR "qla4xxx: missing ep.\n");
3067                return NULL;
3068        }
3069
3070        qla_ep = ep->dd_data;
3071        dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
3072        ha = to_qla_host(qla_ep->host);
3073        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
3074                          ha->host_no));
3075
3076        ret = qla4xxx_get_ddb_index(ha, &ddb_index);
3077        if (ret == QLA_ERROR)
3078                return NULL;
3079
3080        cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, qla_ep->host,
3081                                       cmds_max, sizeof(struct ddb_entry),
3082                                       sizeof(struct ql4_task_data),
3083                                       initial_cmdsn, ddb_index);
3084        if (!cls_sess)
3085                return NULL;
3086
3087        sess = cls_sess->dd_data;
3088        ddb_entry = sess->dd_data;
3089        ddb_entry->fw_ddb_index = ddb_index;
3090        ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE;
3091        ddb_entry->ha = ha;
3092        ddb_entry->sess = cls_sess;
3093        ddb_entry->unblock_sess = qla4xxx_unblock_ddb;
3094        ddb_entry->ddb_change = qla4xxx_ddb_change;
3095        clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags);
3096        cls_sess->recovery_tmo = ql4xsess_recovery_tmo;
3097        ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry;
3098        ha->tot_ddbs++;
3099
3100        return cls_sess;
3101}
3102
3103static void qla4xxx_session_destroy(struct iscsi_cls_session *cls_sess)
3104{
3105        struct iscsi_session *sess;
3106        struct ddb_entry *ddb_entry;
3107        struct scsi_qla_host *ha;
3108        unsigned long flags, wtime;
3109        struct dev_db_entry *fw_ddb_entry = NULL;
3110        dma_addr_t fw_ddb_entry_dma;
3111        uint32_t ddb_state;
3112        int ret;
3113
3114        sess = cls_sess->dd_data;
3115        ddb_entry = sess->dd_data;
3116        ha = ddb_entry->ha;
3117        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
3118                          ha->host_no));
3119
3120        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3121                                          &fw_ddb_entry_dma, GFP_KERNEL);
3122        if (!fw_ddb_entry) {
3123                ql4_printk(KERN_ERR, ha,
3124                           "%s: Unable to allocate dma buffer\n", __func__);
3125                goto destroy_session;
3126        }
3127
3128        wtime = jiffies + (HZ * LOGOUT_TOV);
3129        do {
3130                ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
3131                                              fw_ddb_entry, fw_ddb_entry_dma,
3132                                              NULL, NULL, &ddb_state, NULL,
3133                                              NULL, NULL);
3134                if (ret == QLA_ERROR)
3135                        goto destroy_session;
3136
3137                if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
3138                    (ddb_state == DDB_DS_SESSION_FAILED))
3139                        goto destroy_session;
3140
3141                schedule_timeout_uninterruptible(HZ);
3142        } while ((time_after(wtime, jiffies)));
3143
3144destroy_session:
3145        qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
3146        if (test_and_clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags))
3147                clear_bit(ddb_entry->fw_ddb_index, ha->ddb_idx_map);
3148        spin_lock_irqsave(&ha->hardware_lock, flags);
3149        qla4xxx_free_ddb(ha, ddb_entry);
3150        spin_unlock_irqrestore(&ha->hardware_lock, flags);
3151
3152        iscsi_session_teardown(cls_sess);
3153
3154        if (fw_ddb_entry)
3155                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3156                                  fw_ddb_entry, fw_ddb_entry_dma);
3157}
3158
3159static struct iscsi_cls_conn *
3160qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx)
3161{
3162        struct iscsi_cls_conn *cls_conn;
3163        struct iscsi_session *sess;
3164        struct ddb_entry *ddb_entry;
3165        struct scsi_qla_host *ha;
3166
3167        cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn),
3168                                    conn_idx);
3169        if (!cls_conn) {
3170                pr_info("%s: Can not create connection for conn_idx = %u\n",
3171                        __func__, conn_idx);
3172                return NULL;
3173        }
3174
3175        sess = cls_sess->dd_data;
3176        ddb_entry = sess->dd_data;
3177        ddb_entry->conn = cls_conn;
3178
3179        ha = ddb_entry->ha;
3180        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: conn_idx = %u\n", __func__,
3181                          conn_idx));
3182        return cls_conn;
3183}
3184
3185static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
3186                             struct iscsi_cls_conn *cls_conn,
3187                             uint64_t transport_fd, int is_leading)
3188{
3189        struct iscsi_conn *conn;
3190        struct qla_conn *qla_conn;
3191        struct iscsi_endpoint *ep;
3192        struct ddb_entry *ddb_entry;
3193        struct scsi_qla_host *ha;
3194        struct iscsi_session *sess;
3195
3196        sess = cls_session->dd_data;
3197        ddb_entry = sess->dd_data;
3198        ha = ddb_entry->ha;
3199
3200        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d\n", __func__,
3201                          cls_session->sid, cls_conn->cid));
3202
3203        if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
3204                return -EINVAL;
3205        ep = iscsi_lookup_endpoint(transport_fd);
3206        if (!ep)
3207                return -EINVAL;
3208        conn = cls_conn->dd_data;
3209        qla_conn = conn->dd_data;
3210        qla_conn->qla_ep = ep->dd_data;
3211        return 0;
3212}
3213
3214static int qla4xxx_conn_start(struct iscsi_cls_conn *cls_conn)
3215{
3216        struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
3217        struct iscsi_session *sess;
3218        struct ddb_entry *ddb_entry;
3219        struct scsi_qla_host *ha;
3220        struct dev_db_entry *fw_ddb_entry = NULL;
3221        dma_addr_t fw_ddb_entry_dma;
3222        uint32_t mbx_sts = 0;
3223        int ret = 0;
3224        int status = QLA_SUCCESS;
3225
3226        sess = cls_sess->dd_data;
3227        ddb_entry = sess->dd_data;
3228        ha = ddb_entry->ha;
3229        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d\n", __func__,
3230                          cls_sess->sid, cls_conn->cid));
3231
3232        /* Check if we have  matching FW DDB, if yes then do not
3233         * login to this target. This could cause target to logout previous
3234         * connection
3235         */
3236        ret = qla4xxx_match_fwdb_session(ha, cls_conn);
3237        if (ret == QLA_SUCCESS) {
3238                ql4_printk(KERN_INFO, ha,
3239                           "Session already exist in FW.\n");
3240                ret = -EEXIST;
3241                goto exit_conn_start;
3242        }
3243
3244        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3245                                          &fw_ddb_entry_dma, GFP_KERNEL);
3246        if (!fw_ddb_entry) {
3247                ql4_printk(KERN_ERR, ha,
3248                           "%s: Unable to allocate dma buffer\n", __func__);
3249                ret = -ENOMEM;
3250                goto exit_conn_start;
3251        }
3252
3253        ret = qla4xxx_set_param_ddbentry(ha, ddb_entry, cls_conn, &mbx_sts);
3254        if (ret) {
3255                /* If iscsid is stopped and started then no need to do
3256                * set param again since ddb state will be already
3257                * active and FW does not allow set ddb to an
3258                * active session.
3259                */
3260                if (mbx_sts)
3261                        if (ddb_entry->fw_ddb_device_state ==
3262                                                DDB_DS_SESSION_ACTIVE) {
3263                                ddb_entry->unblock_sess(ddb_entry->sess);
3264                                goto exit_set_param;
3265                        }
3266
3267                ql4_printk(KERN_ERR, ha, "%s: Failed set param for index[%d]\n",
3268                           __func__, ddb_entry->fw_ddb_index);
3269                goto exit_conn_start;
3270        }
3271
3272        status = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index);
3273        if (status == QLA_ERROR) {
3274                ql4_printk(KERN_ERR, ha, "%s: Login failed: %s\n", __func__,
3275                           sess->targetname);
3276                ret = -EINVAL;
3277                goto exit_conn_start;
3278        }
3279
3280        if (ddb_entry->fw_ddb_device_state == DDB_DS_NO_CONNECTION_ACTIVE)
3281                ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS;
3282
3283        DEBUG2(printk(KERN_INFO "%s: DDB state [%d]\n", __func__,
3284                      ddb_entry->fw_ddb_device_state));
3285
3286exit_set_param:
3287        ret = 0;
3288
3289exit_conn_start:
3290        if (fw_ddb_entry)
3291                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3292                                  fw_ddb_entry, fw_ddb_entry_dma);
3293        return ret;
3294}
3295
3296static void qla4xxx_conn_destroy(struct iscsi_cls_conn *cls_conn)
3297{
3298        struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
3299        struct iscsi_session *sess;
3300        struct scsi_qla_host *ha;
3301        struct ddb_entry *ddb_entry;
3302        int options;
3303
3304        sess = cls_sess->dd_data;
3305        ddb_entry = sess->dd_data;
3306        ha = ddb_entry->ha;
3307        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: cid = %d\n", __func__,
3308                          cls_conn->cid));
3309
3310        options = LOGOUT_OPTION_CLOSE_SESSION;
3311        if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR)
3312                ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", __func__);
3313}
3314
3315static void qla4xxx_task_work(struct work_struct *wdata)
3316{
3317        struct ql4_task_data *task_data;
3318        struct scsi_qla_host *ha;
3319        struct passthru_status *sts;
3320        struct iscsi_task *task;
3321        struct iscsi_hdr *hdr;
3322        uint8_t *data;
3323        uint32_t data_len;
3324        struct iscsi_conn *conn;
3325        int hdr_len;
3326        itt_t itt;
3327
3328        task_data = container_of(wdata, struct ql4_task_data, task_work);
3329        ha = task_data->ha;
3330        task = task_data->task;
3331        sts = &task_data->sts;
3332        hdr_len = sizeof(struct iscsi_hdr);
3333
3334        DEBUG3(printk(KERN_INFO "Status returned\n"));
3335        DEBUG3(qla4xxx_dump_buffer(sts, 64));
3336        DEBUG3(printk(KERN_INFO "Response buffer"));
3337        DEBUG3(qla4xxx_dump_buffer(task_data->resp_buffer, 64));
3338
3339        conn = task->conn;
3340
3341        switch (sts->completionStatus) {
3342        case PASSTHRU_STATUS_COMPLETE:
3343                hdr = (struct iscsi_hdr *)task_data->resp_buffer;
3344                /* Assign back the itt in hdr, until we use the PREASSIGN_TAG */
3345                itt = sts->handle;
3346                hdr->itt = itt;
3347                data = task_data->resp_buffer + hdr_len;
3348                data_len = task_data->resp_len - hdr_len;
3349                iscsi_complete_pdu(conn, hdr, data, data_len);
3350                break;
3351        default:
3352                ql4_printk(KERN_ERR, ha, "Passthru failed status = 0x%x\n",
3353                           sts->completionStatus);
3354                break;
3355        }
3356        return;
3357}
3358
3359static int qla4xxx_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
3360{
3361        struct ql4_task_data *task_data;
3362        struct iscsi_session *sess;
3363        struct ddb_entry *ddb_entry;
3364        struct scsi_qla_host *ha;
3365        int hdr_len;
3366
3367        sess = task->conn->session;
3368        ddb_entry = sess->dd_data;
3369        ha = ddb_entry->ha;
3370        task_data = task->dd_data;
3371        memset(task_data, 0, sizeof(struct ql4_task_data));
3372
3373        if (task->sc) {
3374                ql4_printk(KERN_INFO, ha,
3375                           "%s: SCSI Commands not implemented\n", __func__);
3376                return -EINVAL;
3377        }
3378
3379        hdr_len = sizeof(struct iscsi_hdr);
3380        task_data->ha = ha;
3381        task_data->task = task;
3382
3383        if (task->data_count) {
3384                task_data->data_dma = dma_map_single(&ha->pdev->dev, task->data,
3385                                                     task->data_count,
3386                                                     DMA_TO_DEVICE);
3387        }
3388
3389        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n",
3390                      __func__, task->conn->max_recv_dlength, hdr_len));
3391
3392        task_data->resp_len = task->conn->max_recv_dlength + hdr_len;
3393        task_data->resp_buffer = dma_alloc_coherent(&ha->pdev->dev,
3394                                                    task_data->resp_len,
3395                                                    &task_data->resp_dma,
3396                                                    GFP_ATOMIC);
3397        if (!task_data->resp_buffer)
3398                goto exit_alloc_pdu;
3399
3400        task_data->req_len = task->data_count + hdr_len;
3401        task_data->req_buffer = dma_alloc_coherent(&ha->pdev->dev,
3402                                                   task_data->req_len,
3403                                                   &task_data->req_dma,
3404                                                   GFP_ATOMIC);
3405        if (!task_data->req_buffer)
3406                goto exit_alloc_pdu;
3407
3408        task->hdr = task_data->req_buffer;
3409
3410        INIT_WORK(&task_data->task_work, qla4xxx_task_work);
3411
3412        return 0;
3413
3414exit_alloc_pdu:
3415        if (task_data->resp_buffer)
3416                dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
3417                                  task_data->resp_buffer, task_data->resp_dma);
3418
3419        if (task_data->req_buffer)
3420                dma_free_coherent(&ha->pdev->dev, task_data->req_len,
3421                                  task_data->req_buffer, task_data->req_dma);
3422        return -ENOMEM;
3423}
3424
3425static void qla4xxx_task_cleanup(struct iscsi_task *task)
3426{
3427        struct ql4_task_data *task_data;
3428        struct iscsi_session *sess;
3429        struct ddb_entry *ddb_entry;
3430        struct scsi_qla_host *ha;
3431        int hdr_len;
3432
3433        hdr_len = sizeof(struct iscsi_hdr);
3434        sess = task->conn->session;
3435        ddb_entry = sess->dd_data;
3436        ha = ddb_entry->ha;
3437        task_data = task->dd_data;
3438
3439        if (task->data_count) {
3440                dma_unmap_single(&ha->pdev->dev, task_data->data_dma,
3441                                 task->data_count, DMA_TO_DEVICE);
3442        }
3443
3444        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n",
3445                      __func__, task->conn->max_recv_dlength, hdr_len));
3446
3447        dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
3448                          task_data->resp_buffer, task_data->resp_dma);
3449        dma_free_coherent(&ha->pdev->dev, task_data->req_len,
3450                          task_data->req_buffer, task_data->req_dma);
3451        return;
3452}
3453
3454static int qla4xxx_task_xmit(struct iscsi_task *task)
3455{
3456        struct scsi_cmnd *sc = task->sc;
3457        struct iscsi_session *sess = task->conn->session;
3458        struct ddb_entry *ddb_entry = sess->dd_data;
3459        struct scsi_qla_host *ha = ddb_entry->ha;
3460
3461        if (!sc)
3462                return qla4xxx_send_passthru0(task);
3463
3464        ql4_printk(KERN_INFO, ha, "%s: scsi cmd xmit not implemented\n",
3465                   __func__);
3466        return -ENOSYS;
3467}
3468
3469static int qla4xxx_copy_from_fwddb_param(struct iscsi_bus_flash_session *sess,
3470                                         struct iscsi_bus_flash_conn *conn,
3471                                         struct dev_db_entry *fw_ddb_entry)
3472{
3473        unsigned long options = 0;
3474        int rc = 0;
3475
3476        options = le16_to_cpu(fw_ddb_entry->options);
3477        conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
3478        if (test_bit(OPT_IPV6_DEVICE, &options)) {
3479                rc = iscsi_switch_str_param(&sess->portal_type,
3480                                            PORTAL_TYPE_IPV6);
3481                if (rc)
3482                        goto exit_copy;
3483        } else {
3484                rc = iscsi_switch_str_param(&sess->portal_type,
3485                                            PORTAL_TYPE_IPV4);
3486                if (rc)
3487                        goto exit_copy;
3488        }
3489
3490        sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
3491                                              &options);
3492        sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
3493        sess->entry_state = test_bit(OPT_ENTRY_STATE, &options);
3494
3495        options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3496        conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
3497        conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
3498        sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
3499        sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
3500        sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
3501                                            &options);
3502        sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
3503        sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
3504        conn->snack_req_en = test_bit(ISCSIOPT_SNACK_REQ_EN, &options);
3505        sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
3506                                             &options);
3507        sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
3508        sess->discovery_auth_optional =
3509                        test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
3510        if (test_bit(ISCSIOPT_ERL1, &options))
3511                sess->erl |= BIT_1;
3512        if (test_bit(ISCSIOPT_ERL0, &options))
3513                sess->erl |= BIT_0;
3514
3515        options = le16_to_cpu(fw_ddb_entry->tcp_options);
3516        conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
3517        conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
3518        conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
3519        if (test_bit(TCPOPT_TIMER_SCALE3, &options))
3520                conn->tcp_timer_scale |= BIT_3;
3521        if (test_bit(TCPOPT_TIMER_SCALE2, &options))
3522                conn->tcp_timer_scale |= BIT_2;
3523        if (test_bit(TCPOPT_TIMER_SCALE1, &options))
3524                conn->tcp_timer_scale |= BIT_1;
3525
3526        conn->tcp_timer_scale >>= 1;
3527        conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
3528
3529        options = le16_to_cpu(fw_ddb_entry->ip_options);
3530        conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
3531
3532        conn->max_recv_dlength = BYTE_UNITS *
3533                          le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
3534        conn->max_xmit_dlength = BYTE_UNITS *
3535                          le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
3536        sess->first_burst = BYTE_UNITS *
3537                               le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
3538        sess->max_burst = BYTE_UNITS *
3539                                 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
3540        sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
3541        sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3542        sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
3543        sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
3544        conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
3545        conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
3546        conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
3547        conn->ipv6_flow_label = le16_to_cpu(fw_ddb_entry->ipv6_flow_lbl);
3548        conn->keepalive_timeout = le16_to_cpu(fw_ddb_entry->ka_timeout);
3549        conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
3550        conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
3551        conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
3552        sess->discovery_parent_idx = le16_to_cpu(fw_ddb_entry->ddb_link);
3553        sess->discovery_parent_type = le16_to_cpu(fw_ddb_entry->ddb_link);
3554        sess->chap_out_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3555        sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
3556
3557        sess->default_taskmgmt_timeout =
3558                                le16_to_cpu(fw_ddb_entry->def_timeout);
3559        conn->port = le16_to_cpu(fw_ddb_entry->port);
3560
3561        options = le16_to_cpu(fw_ddb_entry->options);
3562        conn->ipaddress = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
3563        if (!conn->ipaddress) {
3564                rc = -ENOMEM;
3565                goto exit_copy;
3566        }
3567
3568        conn->redirect_ipaddr = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
3569        if (!conn->redirect_ipaddr) {
3570                rc = -ENOMEM;
3571                goto exit_copy;
3572        }
3573
3574        memcpy(conn->ipaddress, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN);
3575        memcpy(conn->redirect_ipaddr, fw_ddb_entry->tgt_addr, IPv6_ADDR_LEN);
3576
3577        if (test_bit(OPT_IPV6_DEVICE, &options)) {
3578                conn->ipv6_traffic_class = fw_ddb_entry->ipv4_tos;
3579
3580                conn->link_local_ipv6_addr = kmemdup(
3581                                        fw_ddb_entry->link_local_ipv6_addr,
3582                                        IPv6_ADDR_LEN, GFP_KERNEL);
3583                if (!conn->link_local_ipv6_addr) {
3584                        rc = -ENOMEM;
3585                        goto exit_copy;
3586                }
3587        } else {
3588                conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
3589        }
3590
3591        if (fw_ddb_entry->iscsi_name[0]) {
3592                rc = iscsi_switch_str_param(&sess->targetname,
3593                                            (char *)fw_ddb_entry->iscsi_name);
3594                if (rc)
3595                        goto exit_copy;
3596        }
3597
3598        if (fw_ddb_entry->iscsi_alias[0]) {
3599                rc = iscsi_switch_str_param(&sess->targetalias,
3600                                            (char *)fw_ddb_entry->iscsi_alias);
3601                if (rc)
3602                        goto exit_copy;
3603        }
3604
3605        COPY_ISID(sess->isid, fw_ddb_entry->isid);
3606
3607exit_copy:
3608        return rc;
3609}
3610
3611static int qla4xxx_copy_to_fwddb_param(struct iscsi_bus_flash_session *sess,
3612                                       struct iscsi_bus_flash_conn *conn,
3613                                       struct dev_db_entry *fw_ddb_entry)
3614{
3615        uint16_t options;
3616        int rc = 0;
3617
3618        options = le16_to_cpu(fw_ddb_entry->options);
3619        SET_BITVAL(conn->is_fw_assigned_ipv6,  options, BIT_11);
3620        if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))
3621                options |= BIT_8;
3622        else
3623                options &= ~BIT_8;
3624
3625        SET_BITVAL(sess->auto_snd_tgt_disable, options, BIT_6);
3626        SET_BITVAL(sess->discovery_sess, options, BIT_4);
3627        SET_BITVAL(sess->entry_state, options, BIT_3);
3628        fw_ddb_entry->options = cpu_to_le16(options);
3629
3630        options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3631        SET_BITVAL(conn->hdrdgst_en, options, BIT_13);
3632        SET_BITVAL(conn->datadgst_en, options, BIT_12);
3633        SET_BITVAL(sess->imm_data_en, options, BIT_11);
3634        SET_BITVAL(sess->initial_r2t_en, options, BIT_10);
3635        SET_BITVAL(sess->dataseq_inorder_en, options, BIT_9);
3636        SET_BITVAL(sess->pdu_inorder_en, options, BIT_8);
3637        SET_BITVAL(sess->chap_auth_en, options, BIT_7);
3638        SET_BITVAL(conn->snack_req_en, options, BIT_6);
3639        SET_BITVAL(sess->discovery_logout_en, options, BIT_5);
3640        SET_BITVAL(sess->bidi_chap_en, options, BIT_4);
3641        SET_BITVAL(sess->discovery_auth_optional, options, BIT_3);
3642        SET_BITVAL(sess->erl & BIT_1, options, BIT_1);
3643        SET_BITVAL(sess->erl & BIT_0, options, BIT_0);
3644        fw_ddb_entry->iscsi_options = cpu_to_le16(options);
3645
3646        options = le16_to_cpu(fw_ddb_entry->tcp_options);
3647        SET_BITVAL(conn->tcp_timestamp_stat, options, BIT_6);
3648        SET_BITVAL(conn->tcp_nagle_disable, options, BIT_5);
3649        SET_BITVAL(conn->tcp_wsf_disable, options, BIT_4);
3650        SET_BITVAL(conn->tcp_timer_scale & BIT_2, options, BIT_3);
3651        SET_BITVAL(conn->tcp_timer_scale & BIT_1, options, BIT_2);
3652        SET_BITVAL(conn->tcp_timer_scale & BIT_0, options, BIT_1);
3653        SET_BITVAL(conn->tcp_timestamp_en, options, BIT_0);
3654        fw_ddb_entry->tcp_options = cpu_to_le16(options);
3655
3656        options = le16_to_cpu(fw_ddb_entry->ip_options);
3657        SET_BITVAL(conn->fragment_disable, options, BIT_4);
3658        fw_ddb_entry->ip_options = cpu_to_le16(options);
3659
3660        fw_ddb_entry->iscsi_max_outsnd_r2t = cpu_to_le16(sess->max_r2t);
3661        fw_ddb_entry->iscsi_max_rcv_data_seg_len =
3662                               cpu_to_le16(conn->max_recv_dlength / BYTE_UNITS);
3663        fw_ddb_entry->iscsi_max_snd_data_seg_len =
3664                               cpu_to_le16(conn->max_xmit_dlength / BYTE_UNITS);
3665        fw_ddb_entry->iscsi_first_burst_len =
3666                                cpu_to_le16(sess->first_burst / BYTE_UNITS);
3667        fw_ddb_entry->iscsi_max_burst_len = cpu_to_le16(sess->max_burst /
3668                                            BYTE_UNITS);
3669        fw_ddb_entry->iscsi_def_time2wait = cpu_to_le16(sess->time2wait);
3670        fw_ddb_entry->iscsi_def_time2retain = cpu_to_le16(sess->time2retain);
3671        fw_ddb_entry->tgt_portal_grp = cpu_to_le16(sess->tpgt);
3672        fw_ddb_entry->mss = cpu_to_le16(conn->max_segment_size);
3673        fw_ddb_entry->tcp_xmt_wsf = (uint8_t) cpu_to_le32(conn->tcp_xmit_wsf);
3674        fw_ddb_entry->tcp_rcv_wsf = (uint8_t) cpu_to_le32(conn->tcp_recv_wsf);
3675        fw_ddb_entry->ipv6_flow_lbl = cpu_to_le16(conn->ipv6_flow_label);
3676        fw_ddb_entry->ka_timeout = cpu_to_le16(conn->keepalive_timeout);
3677        fw_ddb_entry->lcl_port = cpu_to_le16(conn->local_port);
3678        fw_ddb_entry->stat_sn = cpu_to_le32(conn->statsn);
3679        fw_ddb_entry->exp_stat_sn = cpu_to_le32(conn->exp_statsn);
3680        fw_ddb_entry->ddb_link = cpu_to_le16(sess->discovery_parent_idx);
3681        fw_ddb_entry->chap_tbl_idx = cpu_to_le16(sess->chap_out_idx);
3682        fw_ddb_entry->tsid = cpu_to_le16(sess->tsid);
3683        fw_ddb_entry->port = cpu_to_le16(conn->port);
3684        fw_ddb_entry->def_timeout =
3685                                cpu_to_le16(sess->default_taskmgmt_timeout);
3686
3687        if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))
3688                fw_ddb_entry->ipv4_tos = conn->ipv6_traffic_class;
3689        else
3690                fw_ddb_entry->ipv4_tos = conn->ipv4_tos;
3691
3692        if (conn->ipaddress)
3693                memcpy(fw_ddb_entry->ip_addr, conn->ipaddress,
3694                       sizeof(fw_ddb_entry->ip_addr));
3695
3696        if (conn->redirect_ipaddr)
3697                memcpy(fw_ddb_entry->tgt_addr, conn->redirect_ipaddr,
3698                       sizeof(fw_ddb_entry->tgt_addr));
3699
3700        if (conn->link_local_ipv6_addr)
3701                memcpy(fw_ddb_entry->link_local_ipv6_addr,
3702                       conn->link_local_ipv6_addr,
3703                       sizeof(fw_ddb_entry->link_local_ipv6_addr));
3704
3705        if (sess->targetname)
3706                memcpy(fw_ddb_entry->iscsi_name, sess->targetname,
3707                       sizeof(fw_ddb_entry->iscsi_name));
3708
3709        if (sess->targetalias)
3710                memcpy(fw_ddb_entry->iscsi_alias, sess->targetalias,
3711                       sizeof(fw_ddb_entry->iscsi_alias));
3712
3713        COPY_ISID(fw_ddb_entry->isid, sess->isid);
3714
3715        return rc;
3716}
3717
3718static void qla4xxx_copy_to_sess_conn_params(struct iscsi_conn *conn,
3719                                             struct iscsi_session *sess,
3720                                             struct dev_db_entry *fw_ddb_entry)
3721{
3722        unsigned long options = 0;
3723        uint16_t ddb_link;
3724        uint16_t disc_parent;
3725        char ip_addr[DDB_IPADDR_LEN];
3726
3727        options = le16_to_cpu(fw_ddb_entry->options);
3728        conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
3729        sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
3730                                              &options);
3731        sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
3732
3733        options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3734        conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
3735        conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
3736        sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
3737        sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
3738        sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
3739                                            &options);
3740        sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
3741        sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
3742        sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
3743                                             &options);
3744        sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
3745        sess->discovery_auth_optional =
3746                        test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
3747        if (test_bit(ISCSIOPT_ERL1, &options))
3748                sess->erl |= BIT_1;
3749        if (test_bit(ISCSIOPT_ERL0, &options))
3750                sess->erl |= BIT_0;
3751
3752        options = le16_to_cpu(fw_ddb_entry->tcp_options);
3753        conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
3754        conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
3755        conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
3756        if (test_bit(TCPOPT_TIMER_SCALE3, &options))
3757                conn->tcp_timer_scale |= BIT_3;
3758        if (test_bit(TCPOPT_TIMER_SCALE2, &options))
3759                conn->tcp_timer_scale |= BIT_2;
3760        if (test_bit(TCPOPT_TIMER_SCALE1, &options))
3761                conn->tcp_timer_scale |= BIT_1;
3762
3763        conn->tcp_timer_scale >>= 1;
3764        conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
3765
3766        options = le16_to_cpu(fw_ddb_entry->ip_options);
3767        conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
3768
3769        conn->max_recv_dlength = BYTE_UNITS *
3770                          le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
3771        conn->max_xmit_dlength = BYTE_UNITS *
3772                          le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
3773        sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
3774        sess->first_burst = BYTE_UNITS *
3775                               le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
3776        sess->max_burst = BYTE_UNITS *
3777                                 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
3778        sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3779        sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
3780        sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
3781        conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
3782        conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
3783        conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
3784        conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
3785        conn->keepalive_tmo = le16_to_cpu(fw_ddb_entry->ka_timeout);
3786        conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
3787        conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
3788        conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
3789        sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
3790        COPY_ISID(sess->isid, fw_ddb_entry->isid);
3791
3792        ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
3793        if (ddb_link == DDB_ISNS)
3794                disc_parent = ISCSI_DISC_PARENT_ISNS;
3795        else if (ddb_link == DDB_NO_LINK)
3796                disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
3797        else if (ddb_link < MAX_DDB_ENTRIES)
3798                disc_parent = ISCSI_DISC_PARENT_SENDTGT;
3799        else
3800                disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
3801
3802        iscsi_set_param(conn->cls_conn, ISCSI_PARAM_DISCOVERY_PARENT_TYPE,
3803                        iscsi_get_discovery_parent_name(disc_parent), 0);
3804
3805        iscsi_set_param(conn->cls_conn, ISCSI_PARAM_TARGET_ALIAS,
3806                        (char *)fw_ddb_entry->iscsi_alias, 0);
3807
3808        options = le16_to_cpu(fw_ddb_entry->options);
3809        if (options & DDB_OPT_IPV6_DEVICE) {
3810                memset(ip_addr, 0, sizeof(ip_addr));
3811                sprintf(ip_addr, "%pI6", fw_ddb_entry->link_local_ipv6_addr);
3812                iscsi_set_param(conn->cls_conn, ISCSI_PARAM_LOCAL_IPADDR,
3813                                (char *)ip_addr, 0);
3814        }
3815}
3816
3817static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha,
3818                                     struct dev_db_entry *fw_ddb_entry,
3819                                     struct iscsi_cls_session *cls_sess,
3820                                     struct iscsi_cls_conn *cls_conn)
3821{
3822        int buflen = 0;
3823        struct iscsi_session *sess;
3824        struct ddb_entry *ddb_entry;
3825        struct ql4_chap_table chap_tbl;
3826        struct iscsi_conn *conn;
3827        char ip_addr[DDB_IPADDR_LEN];
3828        uint16_t options = 0;
3829
3830        sess = cls_sess->dd_data;
3831        ddb_entry = sess->dd_data;
3832        conn = cls_conn->dd_data;
3833        memset(&chap_tbl, 0, sizeof(chap_tbl));
3834
3835        ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3836
3837        qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);
3838
3839        sess->def_taskmgmt_tmo = le16_to_cpu(fw_ddb_entry->def_timeout);
3840        conn->persistent_port = le16_to_cpu(fw_ddb_entry->port);
3841
3842        memset(ip_addr, 0, sizeof(ip_addr));
3843        options = le16_to_cpu(fw_ddb_entry->options);
3844        if (options & DDB_OPT_IPV6_DEVICE) {
3845                iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv6", 4);
3846
3847                memset(ip_addr, 0, sizeof(ip_addr));
3848                sprintf(ip_addr, "%pI6", fw_ddb_entry->ip_addr);
3849        } else {
3850                iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv4", 4);
3851                sprintf(ip_addr, "%pI4", fw_ddb_entry->ip_addr);
3852        }
3853
3854        iscsi_set_param(cls_conn, ISCSI_PARAM_PERSISTENT_ADDRESS,
3855                        (char *)ip_addr, buflen);
3856        iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_NAME,
3857                        (char *)fw_ddb_entry->iscsi_name, buflen);
3858        iscsi_set_param(cls_conn, ISCSI_PARAM_INITIATOR_NAME,
3859                        (char *)ha->name_string, buflen);
3860
3861        if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
3862                if (!qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
3863                                                   chap_tbl.secret,
3864                                                   ddb_entry->chap_tbl_idx)) {
3865                        iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
3866                                        (char *)chap_tbl.name,
3867                                        strlen((char *)chap_tbl.name));
3868                        iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
3869                                        (char *)chap_tbl.secret,
3870                                        chap_tbl.secret_len);
3871                }
3872        }
3873}
3874
3875void qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host *ha,
3876                                             struct ddb_entry *ddb_entry)
3877{
3878        struct iscsi_cls_session *cls_sess;
3879        struct iscsi_cls_conn *cls_conn;
3880        uint32_t ddb_state;
3881        dma_addr_t fw_ddb_entry_dma;
3882        struct dev_db_entry *fw_ddb_entry;
3883
3884        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3885                                          &fw_ddb_entry_dma, GFP_KERNEL);
3886        if (!fw_ddb_entry) {
3887                ql4_printk(KERN_ERR, ha,
3888                           "%s: Unable to allocate dma buffer\n", __func__);
3889                goto exit_session_conn_fwddb_param;
3890        }
3891
3892        if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
3893                                    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
3894                                    NULL, NULL, NULL) == QLA_ERROR) {
3895                DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
3896                                  "get_ddb_entry for fw_ddb_index %d\n",
3897                                  ha->host_no, __func__,
3898                                  ddb_entry->fw_ddb_index));
3899                goto exit_session_conn_fwddb_param;
3900        }
3901
3902        cls_sess = ddb_entry->sess;
3903
3904        cls_conn = ddb_entry->conn;
3905
3906        /* Update params */
3907        qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn);
3908
3909exit_session_conn_fwddb_param:
3910        if (fw_ddb_entry)
3911                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3912                                  fw_ddb_entry, fw_ddb_entry_dma);
3913}
3914
3915void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha,
3916                                       struct ddb_entry *ddb_entry)
3917{
3918        struct iscsi_cls_session *cls_sess;
3919        struct iscsi_cls_conn *cls_conn;
3920        struct iscsi_session *sess;
3921        struct iscsi_conn *conn;
3922        uint32_t ddb_state;
3923        dma_addr_t fw_ddb_entry_dma;
3924        struct dev_db_entry *fw_ddb_entry;
3925
3926        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3927                                          &fw_ddb_entry_dma, GFP_KERNEL);
3928        if (!fw_ddb_entry) {
3929                ql4_printk(KERN_ERR, ha,
3930                           "%s: Unable to allocate dma buffer\n", __func__);
3931                goto exit_session_conn_param;
3932        }
3933
3934        if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
3935                                    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
3936                                    NULL, NULL, NULL) == QLA_ERROR) {
3937                DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
3938                                  "get_ddb_entry for fw_ddb_index %d\n",
3939                                  ha->host_no, __func__,
3940                                  ddb_entry->fw_ddb_index));
3941                goto exit_session_conn_param;
3942        }
3943
3944        cls_sess = ddb_entry->sess;
3945        sess = cls_sess->dd_data;
3946
3947        cls_conn = ddb_entry->conn;
3948        conn = cls_conn->dd_data;
3949
3950        /* Update timers after login */
3951        ddb_entry->default_relogin_timeout =
3952                (le16_to_cpu(fw_ddb_entry->def_timeout) > LOGIN_TOV) &&
3953                 (le16_to_cpu(fw_ddb_entry->def_timeout) < LOGIN_TOV * 10) ?
3954                 le16_to_cpu(fw_ddb_entry->def_timeout) : LOGIN_TOV;
3955        ddb_entry->default_time2wait =
3956                                le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3957
3958        /* Update params */
3959        ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3960        qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);
3961
3962        memcpy(sess->initiatorname, ha->name_string,
3963               min(sizeof(ha->name_string), sizeof(sess->initiatorname)));
3964
3965exit_session_conn_param:
3966        if (fw_ddb_entry)
3967                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3968                                  fw_ddb_entry, fw_ddb_entry_dma);
3969}
3970
3971/*
3972 * Timer routines
3973 */
3974static void qla4xxx_timer(struct timer_list *t);
3975
3976static void qla4xxx_start_timer(struct scsi_qla_host *ha,
3977                                unsigned long interval)
3978{
3979        DEBUG(printk("scsi: %s: Starting timer thread for adapter %d\n",
3980                     __func__, ha->host->host_no));
3981        timer_setup(&ha->timer, qla4xxx_timer, 0);
3982        ha->timer.expires = jiffies + interval * HZ;
3983        add_timer(&ha->timer);
3984        ha->timer_active = 1;
3985}
3986
3987static void qla4xxx_stop_timer(struct scsi_qla_host *ha)
3988{
3989        del_timer_sync(&ha->timer);
3990        ha->timer_active = 0;
3991}
3992
3993/***
3994 * qla4xxx_mark_device_missing - blocks the session
3995 * @cls_session: Pointer to the session to be blocked
3996 * @ddb_entry: Pointer to device database entry
3997 *
3998 * This routine marks a device missing and close connection.
3999 **/
4000void qla4xxx_mark_device_missing(struct iscsi_cls_session *cls_session)
4001{
4002        iscsi_block_session(cls_session);
4003}
4004
4005/**
4006 * qla4xxx_mark_all_devices_missing - mark all devices as missing.
4007 * @ha: Pointer to host adapter structure.
4008 *
4009 * This routine marks a device missing and resets the relogin retry count.
4010 **/
4011void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha)
4012{
4013        iscsi_host_for_each_session(ha->host, qla4xxx_mark_device_missing);
4014}
4015
4016static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha,
4017                                       struct ddb_entry *ddb_entry,
4018                                       struct scsi_cmnd *cmd)
4019{
4020        struct srb *srb;
4021
4022        srb = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
4023        if (!srb)
4024                return srb;
4025
4026        kref_init(&srb->srb_ref);
4027        srb->ha = ha;
4028        srb->ddb = ddb_entry;
4029        srb->cmd = cmd;
4030        srb->flags = 0;
4031        CMD_SP(cmd) = (void *)srb;
4032
4033        return srb;
4034}
4035
4036static void qla4xxx_srb_free_dma(struct scsi_qla_host *ha, struct srb *srb)
4037{
4038        struct scsi_cmnd *cmd = srb->cmd;
4039
4040        if (srb->flags & SRB_DMA_VALID) {
4041                scsi_dma_unmap(cmd);
4042                srb->flags &= ~SRB_DMA_VALID;
4043        }
4044        CMD_SP(cmd) = NULL;
4045}
4046
4047void qla4xxx_srb_compl(struct kref *ref)
4048{
4049        struct srb *srb = container_of(ref, struct srb, srb_ref);
4050        struct scsi_cmnd *cmd = srb->cmd;
4051        struct scsi_qla_host *ha = srb->ha;
4052
4053        qla4xxx_srb_free_dma(ha, srb);
4054
4055        mempool_free(srb, ha->srb_mempool);
4056
4057        cmd->scsi_done(cmd);
4058}
4059
4060/**
4061 * qla4xxx_queuecommand - scsi layer issues scsi command to driver.
4062 * @host: scsi host
4063 * @cmd: Pointer to Linux's SCSI command structure
4064 *
4065 * Remarks:
4066 * This routine is invoked by Linux to send a SCSI command to the driver.
4067 * The mid-level driver tries to ensure that queuecommand never gets
4068 * invoked concurrently with itself or the interrupt handler (although
4069 * the interrupt handler may call this routine as part of request-
4070 * completion handling).   Unfortunely, it sometimes calls the scheduler
4071 * in interrupt context which is a big NO! NO!.
4072 **/
4073static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
4074{
4075        struct scsi_qla_host *ha = to_qla_host(host);
4076        struct ddb_entry *ddb_entry = cmd->device->hostdata;
4077        struct iscsi_cls_session *sess = ddb_entry->sess;
4078        struct srb *srb;
4079        int rval;
4080
4081        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
4082                if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
4083                        cmd->result = DID_NO_CONNECT << 16;
4084                else
4085                        cmd->result = DID_REQUEUE << 16;
4086                goto qc_fail_command;
4087        }
4088
4089        if (!sess) {
4090                cmd->result = DID_IMM_RETRY << 16;
4091                goto qc_fail_command;
4092        }
4093
4094        rval = iscsi_session_chkready(sess);
4095        if (rval) {
4096                cmd->result = rval;
4097                goto qc_fail_command;
4098        }
4099
4100        if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
4101            test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
4102            test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4103            test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
4104            test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
4105            !test_bit(AF_ONLINE, &ha->flags) ||
4106            !test_bit(AF_LINK_UP, &ha->flags) ||
4107            test_bit(AF_LOOPBACK, &ha->flags) ||
4108            test_bit(DPC_POST_IDC_ACK, &ha->dpc_flags) ||
4109            test_bit(DPC_RESTORE_ACB, &ha->dpc_flags) ||
4110            test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))
4111                goto qc_host_busy;
4112
4113        srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd);
4114        if (!srb)
4115                goto qc_host_busy;
4116
4117        rval = qla4xxx_send_command_to_isp(ha, srb);
4118        if (rval != QLA_SUCCESS)
4119                goto qc_host_busy_free_sp;
4120
4121        return 0;
4122
4123qc_host_busy_free_sp:
4124        qla4xxx_srb_free_dma(ha, srb);
4125        mempool_free(srb, ha->srb_mempool);
4126
4127qc_host_busy:
4128        return SCSI_MLQUEUE_HOST_BUSY;
4129
4130qc_fail_command:
4131        cmd->scsi_done(cmd);
4132
4133        return 0;
4134}
4135
4136/**
4137 * qla4xxx_mem_free - frees memory allocated to adapter
4138 * @ha: Pointer to host adapter structure.
4139 *
4140 * Frees memory previously allocated by qla4xxx_mem_alloc
4141 **/
4142static void qla4xxx_mem_free(struct scsi_qla_host *ha)
4143{
4144        if (ha->queues)
4145                dma_free_coherent(&ha->pdev->dev, ha->queues_len, ha->queues,
4146                                  ha->queues_dma);
4147
4148         if (ha->fw_dump)
4149                vfree(ha->fw_dump);
4150
4151        ha->queues_len = 0;
4152        ha->queues = NULL;
4153        ha->queues_dma = 0;
4154        ha->request_ring = NULL;
4155        ha->request_dma = 0;
4156        ha->response_ring = NULL;
4157        ha->response_dma = 0;
4158        ha->shadow_regs = NULL;
4159        ha->shadow_regs_dma = 0;
4160        ha->fw_dump = NULL;
4161        ha->fw_dump_size = 0;
4162
4163        /* Free srb pool. */
4164        mempool_destroy(ha->srb_mempool);
4165        ha->srb_mempool = NULL;
4166
4167        dma_pool_destroy(ha->chap_dma_pool);
4168
4169        if (ha->chap_list)
4170                vfree(ha->chap_list);
4171        ha->chap_list = NULL;
4172
4173        dma_pool_destroy(ha->fw_ddb_dma_pool);
4174
4175        /* release io space registers  */
4176        if (is_qla8022(ha)) {
4177                if (ha->nx_pcibase)
4178                        iounmap(
4179                            (struct device_reg_82xx __iomem *)ha->nx_pcibase);
4180        } else if (is_qla8032(ha) || is_qla8042(ha)) {
4181                if (ha->nx_pcibase)
4182                        iounmap(
4183                            (struct device_reg_83xx __iomem *)ha->nx_pcibase);
4184        } else if (ha->reg) {
4185                iounmap(ha->reg);
4186        }
4187
4188        if (ha->reset_tmplt.buff)
4189                vfree(ha->reset_tmplt.buff);
4190
4191        pci_release_regions(ha->pdev);
4192}
4193
4194/**
4195 * qla4xxx_mem_alloc - allocates memory for use by adapter.
4196 * @ha: Pointer to host adapter structure
4197 *
4198 * Allocates DMA memory for request and response queues. Also allocates memory
4199 * for srbs.
4200 **/
4201static int qla4xxx_mem_alloc(struct scsi_qla_host *ha)
4202{
4203        unsigned long align;
4204
4205        /* Allocate contiguous block of DMA memory for queues. */
4206        ha->queues_len = ((REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
4207                          (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE) +
4208                          sizeof(struct shadow_regs) +
4209                          MEM_ALIGN_VALUE +
4210                          (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
4211        ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len,
4212                                        &ha->queues_dma, GFP_KERNEL);
4213        if (ha->queues == NULL) {
4214                ql4_printk(KERN_WARNING, ha,
4215                    "Memory Allocation failed - queues.\n");
4216
4217                goto mem_alloc_error_exit;
4218        }
4219
4220        /*
4221         * As per RISC alignment requirements -- the bus-address must be a
4222         * multiple of the request-ring size (in bytes).
4223         */
4224        align = 0;
4225        if ((unsigned long)ha->queues_dma & (MEM_ALIGN_VALUE - 1))
4226                align = MEM_ALIGN_VALUE - ((unsigned long)ha->queues_dma &
4227                                           (MEM_ALIGN_VALUE - 1));
4228
4229        /* Update request and response queue pointers. */
4230        ha->request_dma = ha->queues_dma + align;
4231        ha->request_ring = (struct queue_entry *) (ha->queues + align);
4232        ha->response_dma = ha->queues_dma + align +
4233                (REQUEST_QUEUE_DEPTH * QUEUE_SIZE);
4234        ha->response_ring = (struct queue_entry *) (ha->queues + align +
4235                                                    (REQUEST_QUEUE_DEPTH *
4236                                                     QUEUE_SIZE));
4237        ha->shadow_regs_dma = ha->queues_dma + align +
4238                (REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
4239                (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE);
4240        ha->shadow_regs = (struct shadow_regs *) (ha->queues + align +
4241                                                  (REQUEST_QUEUE_DEPTH *
4242                                                   QUEUE_SIZE) +
4243                                                  (RESPONSE_QUEUE_DEPTH *
4244                                                   QUEUE_SIZE));
4245
4246        /* Allocate memory for srb pool. */
4247        ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
4248                                         mempool_free_slab, srb_cachep);
4249        if (ha->srb_mempool == NULL) {
4250                ql4_printk(KERN_WARNING, ha,
4251                    "Memory Allocation failed - SRB Pool.\n");
4252
4253                goto mem_alloc_error_exit;
4254        }
4255
4256        ha->chap_dma_pool = dma_pool_create("ql4_chap", &ha->pdev->dev,
4257                                            CHAP_DMA_BLOCK_SIZE, 8, 0);
4258
4259        if (ha->chap_dma_pool == NULL) {
4260                ql4_printk(KERN_WARNING, ha,
4261                    "%s: chap_dma_pool allocation failed..\n", __func__);
4262                goto mem_alloc_error_exit;
4263        }
4264
4265        ha->fw_ddb_dma_pool = dma_pool_create("ql4_fw_ddb", &ha->pdev->dev,
4266                                              DDB_DMA_BLOCK_SIZE, 8, 0);
4267
4268        if (ha->fw_ddb_dma_pool == NULL) {
4269                ql4_printk(KERN_WARNING, ha,
4270                           "%s: fw_ddb_dma_pool allocation failed..\n",
4271                           __func__);
4272                goto mem_alloc_error_exit;
4273        }
4274
4275        return QLA_SUCCESS;
4276
4277mem_alloc_error_exit:
4278        qla4xxx_mem_free(ha);
4279        return QLA_ERROR;
4280}
4281
4282/**
4283 * qla4_8xxx_check_temp - Check the ISP82XX temperature.
4284 * @ha: adapter block pointer.
4285 *
4286 * Note: The caller should not hold the idc lock.
4287 **/
4288static int qla4_8xxx_check_temp(struct scsi_qla_host *ha)
4289{
4290        uint32_t temp, temp_state, temp_val;
4291        int status = QLA_SUCCESS;
4292
4293        temp = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_TEMP_STATE);
4294
4295        temp_state = qla82xx_get_temp_state(temp);
4296        temp_val = qla82xx_get_temp_val(temp);
4297
4298        if (temp_state == QLA82XX_TEMP_PANIC) {
4299                ql4_printk(KERN_WARNING, ha, "Device temperature %d degrees C"
4300                           " exceeds maximum allowed. Hardware has been shut"
4301                           " down.\n", temp_val);
4302                status = QLA_ERROR;
4303        } else if (temp_state == QLA82XX_TEMP_WARN) {
4304                if (ha->temperature == QLA82XX_TEMP_NORMAL)
4305                        ql4_printk(KERN_WARNING, ha, "Device temperature %d"
4306                                   " degrees C exceeds operating range."
4307                                   " Immediate action needed.\n", temp_val);
4308        } else {
4309                if (ha->temperature == QLA82XX_TEMP_WARN)
4310                        ql4_printk(KERN_INFO, ha, "Device temperature is"
4311                                   " now %d degrees C in normal range.\n",
4312                                   temp_val);
4313        }
4314        ha->temperature = temp_state;
4315        return status;
4316}
4317
4318/**
4319 * qla4_8xxx_check_fw_alive  - Check firmware health
4320 * @ha: Pointer to host adapter structure.
4321 *
4322 * Context: Interrupt
4323 **/
4324static int qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
4325{
4326        uint32_t fw_heartbeat_counter;
4327        int status = QLA_SUCCESS;
4328
4329        fw_heartbeat_counter = qla4_8xxx_rd_direct(ha,
4330                                                   QLA8XXX_PEG_ALIVE_COUNTER);
4331        /* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */
4332        if (fw_heartbeat_counter == 0xffffffff) {
4333                DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen "
4334                    "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff\n",
4335                    ha->host_no, __func__));
4336                return status;
4337        }
4338
4339        if (ha->fw_heartbeat_counter == fw_heartbeat_counter) {
4340                ha->seconds_since_last_heartbeat++;
4341                /* FW not alive after 2 seconds */
4342                if (ha->seconds_since_last_heartbeat == 2) {
4343                        ha->seconds_since_last_heartbeat = 0;
4344                        qla4_8xxx_dump_peg_reg(ha);
4345                        status = QLA_ERROR;
4346                }
4347        } else
4348                ha->seconds_since_last_heartbeat = 0;
4349
4350        ha->fw_heartbeat_counter = fw_heartbeat_counter;
4351        return status;
4352}
4353
4354static void qla4_8xxx_process_fw_error(struct scsi_qla_host *ha)
4355{
4356        uint32_t halt_status;
4357        int halt_status_unrecoverable = 0;
4358
4359        halt_status = qla4_8xxx_rd_direct(ha, QLA8XXX_PEG_HALT_STATUS1);
4360
4361        if (is_qla8022(ha)) {
4362                ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
4363                           __func__);
4364                qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
4365                                CRB_NIU_XG_PAUSE_CTL_P0 |
4366                                CRB_NIU_XG_PAUSE_CTL_P1);
4367
4368                if (QLA82XX_FWERROR_CODE(halt_status) == 0x67)
4369                        ql4_printk(KERN_ERR, ha, "%s: Firmware aborted with error code 0x00006700. Device is being reset\n",
4370                                   __func__);
4371                if (halt_status & HALT_STATUS_UNRECOVERABLE)
4372                        halt_status_unrecoverable = 1;
4373        } else if (is_qla8032(ha) || is_qla8042(ha)) {
4374                if (halt_status & QLA83XX_HALT_STATUS_FW_RESET)
4375                        ql4_printk(KERN_ERR, ha, "%s: Firmware error detected device is being reset\n",
4376                                   __func__);
4377                else if (halt_status & QLA83XX_HALT_STATUS_UNRECOVERABLE)
4378                        halt_status_unrecoverable = 1;
4379        }
4380
4381        /*
4382         * Since we cannot change dev_state in interrupt context,
4383         * set appropriate DPC flag then wakeup DPC
4384         */
4385        if (halt_status_unrecoverable) {
4386                set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
4387        } else {
4388                ql4_printk(KERN_INFO, ha, "%s: detect abort needed!\n",
4389                           __func__);
4390                set_bit(DPC_RESET_HA, &ha->dpc_flags);
4391        }
4392        qla4xxx_mailbox_premature_completion(ha);
4393        qla4xxx_wake_dpc(ha);
4394}
4395
4396/**
4397 * qla4_8xxx_watchdog - Poll dev state
4398 * @ha: Pointer to host adapter structure.
4399 *
4400 * Context: Interrupt
4401 **/
4402void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
4403{
4404        uint32_t dev_state;
4405        uint32_t idc_ctrl;
4406
4407        if (is_qla8032(ha) &&
4408            (qla4_83xx_is_detached(ha) == QLA_SUCCESS))
4409                WARN_ONCE(1, "%s: iSCSI function %d marked invisible\n",
4410                          __func__, ha->func_num);
4411
4412        /* don't poll if reset is going on */
4413        if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
4414            test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4415            test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags))) {
4416                dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
4417
4418                if (qla4_8xxx_check_temp(ha)) {
4419                        if (is_qla8022(ha)) {
4420                                ql4_printk(KERN_INFO, ha, "disabling pause transmit on port 0 & 1.\n");
4421                                qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
4422                                                CRB_NIU_XG_PAUSE_CTL_P0 |
4423                                                CRB_NIU_XG_PAUSE_CTL_P1);
4424                        }
4425                        set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
4426                        qla4xxx_wake_dpc(ha);
4427                } else if (dev_state == QLA8XXX_DEV_NEED_RESET &&
4428                           !test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
4429
4430                        ql4_printk(KERN_INFO, ha, "%s: HW State: NEED RESET!\n",
4431                                   __func__);
4432
4433                        if (is_qla8032(ha) || is_qla8042(ha)) {
4434                                idc_ctrl = qla4_83xx_rd_reg(ha,
4435                                                        QLA83XX_IDC_DRV_CTRL);
4436                                if (!(idc_ctrl & GRACEFUL_RESET_BIT1)) {
4437                                        ql4_printk(KERN_INFO, ha, "%s: Graceful reset bit is not set\n",
4438                                                   __func__);
4439                                        qla4xxx_mailbox_premature_completion(
4440                                                                            ha);
4441                                }
4442                        }
4443
4444                        if ((is_qla8032(ha) || is_qla8042(ha)) ||
4445                            (is_qla8022(ha) && !ql4xdontresethba)) {
4446                                set_bit(DPC_RESET_HA, &ha->dpc_flags);
4447                                qla4xxx_wake_dpc(ha);
4448                        }
4449                } else if (dev_state == QLA8XXX_DEV_NEED_QUIESCENT &&
4450                    !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
4451                        ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!\n",
4452                            __func__);
4453                        set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags);
4454                        qla4xxx_wake_dpc(ha);
4455                } else  {
4456                        /* Check firmware health */
4457                        if (qla4_8xxx_check_fw_alive(ha))
4458                                qla4_8xxx_process_fw_error(ha);
4459                }
4460        }
4461}
4462
4463static void qla4xxx_check_relogin_flash_ddb(struct iscsi_cls_session *cls_sess)
4464{
4465        struct iscsi_session *sess;
4466        struct ddb_entry *ddb_entry;
4467        struct scsi_qla_host *ha;
4468
4469        sess = cls_sess->dd_data;
4470        ddb_entry = sess->dd_data;
4471        ha = ddb_entry->ha;
4472
4473        if (!(ddb_entry->ddb_type == FLASH_DDB))
4474                return;
4475
4476        if (adapter_up(ha) && !test_bit(DF_RELOGIN, &ddb_entry->flags) &&
4477            !iscsi_is_session_online(cls_sess)) {
4478                if (atomic_read(&ddb_entry->retry_relogin_timer) !=
4479                    INVALID_ENTRY) {
4480                        if (atomic_read(&ddb_entry->retry_relogin_timer) ==
4481                                        0) {
4482                                atomic_set(&ddb_entry->retry_relogin_timer,
4483                                           INVALID_ENTRY);
4484                                set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
4485                                set_bit(DF_RELOGIN, &ddb_entry->flags);
4486                                DEBUG2(ql4_printk(KERN_INFO, ha,
4487                                       "%s: index [%d] login device\n",
4488                                        __func__, ddb_entry->fw_ddb_index));
4489                        } else
4490                                atomic_dec(&ddb_entry->retry_relogin_timer);
4491                }
4492        }
4493
4494        /* Wait for relogin to timeout */
4495        if (atomic_read(&ddb_entry->relogin_timer) &&
4496            (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) {
4497                /*
4498                 * If the relogin times out and the device is
4499                 * still NOT ONLINE then try and relogin again.
4500                 */
4501                if (!iscsi_is_session_online(cls_sess)) {
4502                        /* Reset retry relogin timer */
4503                        atomic_inc(&ddb_entry->relogin_retry_count);
4504                        DEBUG2(ql4_printk(KERN_INFO, ha,
4505                                "%s: index[%d] relogin timed out-retrying"
4506                                " relogin (%d), retry (%d)\n", __func__,
4507                                ddb_entry->fw_ddb_index,
4508                                atomic_read(&ddb_entry->relogin_retry_count),
4509                                ddb_entry->default_time2wait + 4));
4510                        set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
4511                        atomic_set(&ddb_entry->retry_relogin_timer,
4512                                   ddb_entry->default_time2wait + 4);
4513                }
4514        }
4515}
4516
4517/**
4518 * qla4xxx_timer - checks every second for work to do.
4519 * @ha: Pointer to host adapter structure.
4520 **/
4521static void qla4xxx_timer(struct timer_list *t)
4522{
4523        struct scsi_qla_host *ha = from_timer(ha, t, timer);
4524        int start_dpc = 0;
4525        uint16_t w;
4526
4527        iscsi_host_for_each_session(ha->host, qla4xxx_check_relogin_flash_ddb);
4528
4529        /* If we are in the middle of AER/EEH processing
4530         * skip any processing and reschedule the timer
4531         */
4532        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
4533                mod_timer(&ha->timer, jiffies + HZ);
4534                return;
4535        }
4536
4537        /* Hardware read to trigger an EEH error during mailbox waits. */
4538        if (!pci_channel_offline(ha->pdev))
4539                pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
4540
4541        if (is_qla80XX(ha))
4542                qla4_8xxx_watchdog(ha);
4543
4544        if (is_qla40XX(ha)) {
4545                /* Check for heartbeat interval. */
4546                if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE &&
4547                    ha->heartbeat_interval != 0) {
4548                        ha->seconds_since_last_heartbeat++;
4549                        if (ha->seconds_since_last_heartbeat >
4550                            ha->heartbeat_interval + 2)
4551                                set_bit(DPC_RESET_HA, &ha->dpc_flags);
4552                }
4553        }
4554
4555        /* Process any deferred work. */
4556        if (!list_empty(&ha->work_list))
4557                start_dpc++;
4558
4559        /* Wakeup the dpc routine for this adapter, if needed. */
4560        if (start_dpc ||
4561             test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4562             test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) ||
4563             test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) ||
4564             test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) ||
4565             test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
4566             test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) ||
4567             test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) ||
4568             test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
4569             test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
4570             test_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags) ||
4571             test_bit(DPC_AEN, &ha->dpc_flags)) {
4572                DEBUG2(printk("scsi%ld: %s: scheduling dpc routine"
4573                              " - dpc flags = 0x%lx\n",
4574                              ha->host_no, __func__, ha->dpc_flags));
4575                qla4xxx_wake_dpc(ha);
4576        }
4577
4578        /* Reschedule timer thread to call us back in one second */
4579        mod_timer(&ha->timer, jiffies + HZ);
4580
4581        DEBUG2(ha->seconds_since_last_intr++);
4582}
4583
4584/**
4585 * qla4xxx_cmd_wait - waits for all outstanding commands to complete
4586 * @ha: Pointer to host adapter structure.
4587 *
4588 * This routine stalls the driver until all outstanding commands are returned.
4589 * Caller must release the Hardware Lock prior to calling this routine.
4590 **/
4591static int qla4xxx_cmd_wait(struct scsi_qla_host *ha)
4592{
4593        uint32_t index = 0;
4594        unsigned long flags;
4595        struct scsi_cmnd *cmd;
4596        unsigned long wtime;
4597        uint32_t wtmo;
4598
4599        if (is_qla40XX(ha))
4600                wtmo = WAIT_CMD_TOV;
4601        else
4602                wtmo = ha->nx_reset_timeout / 2;
4603
4604        wtime = jiffies + (wtmo * HZ);
4605
4606        DEBUG2(ql4_printk(KERN_INFO, ha,
4607                          "Wait up to %u seconds for cmds to complete\n",
4608                          wtmo));
4609
4610        while (!time_after_eq(jiffies, wtime)) {
4611                spin_lock_irqsave(&ha->hardware_lock, flags);
4612                /* Find a command that hasn't completed. */
4613                for (index = 0; index < ha->host->can_queue; index++) {
4614                        cmd = scsi_host_find_tag(ha->host, index);
4615                        /*
4616                         * We cannot just check if the index is valid,
4617                         * becase if we are run from the scsi eh, then
4618                         * the scsi/block layer is going to prevent
4619                         * the tag from being released.
4620                         */
4621                        if (cmd != NULL && CMD_SP(cmd))
4622                                break;
4623                }
4624                spin_unlock_irqrestore(&ha->hardware_lock, flags);
4625
4626                /* If No Commands are pending, wait is complete */
4627                if (index == ha->host->can_queue)
4628                        return QLA_SUCCESS;
4629
4630                msleep(1000);
4631        }
4632        /* If we timed out on waiting for commands to come back
4633         * return ERROR. */
4634        return QLA_ERROR;
4635}
4636
4637int qla4xxx_hw_reset(struct scsi_qla_host *ha)
4638{
4639        uint32_t ctrl_status;
4640        unsigned long flags = 0;
4641
4642        DEBUG2(printk(KERN_ERR "scsi%ld: %s\n", ha->host_no, __func__));
4643
4644        if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS)
4645                return QLA_ERROR;
4646
4647        spin_lock_irqsave(&ha->hardware_lock, flags);
4648
4649        /*
4650         * If the SCSI Reset Interrupt bit is set, clear it.
4651         * Otherwise, the Soft Reset won't work.
4652         */
4653        ctrl_status = readw(&ha->reg->ctrl_status);
4654        if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0)
4655                writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
4656
4657        /* Issue Soft Reset */
4658        writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status);
4659        readl(&ha->reg->ctrl_status);
4660
4661        spin_unlock_irqrestore(&ha->hardware_lock, flags);
4662        return QLA_SUCCESS;
4663}
4664
4665/**
4666 * qla4xxx_soft_reset - performs soft reset.
4667 * @ha: Pointer to host adapter structure.
4668 **/
4669int qla4xxx_soft_reset(struct scsi_qla_host *ha)
4670{
4671        uint32_t max_wait_time;
4672        unsigned long flags = 0;
4673        int status;
4674        uint32_t ctrl_status;
4675
4676        status = qla4xxx_hw_reset(ha);
4677        if (status != QLA_SUCCESS)
4678                return status;
4679
4680        status = QLA_ERROR;
4681        /* Wait until the Network Reset Intr bit is cleared */
4682        max_wait_time = RESET_INTR_TOV;
4683        do {
4684                spin_lock_irqsave(&ha->hardware_lock, flags);
4685                ctrl_status = readw(&ha->reg->ctrl_status);
4686                spin_unlock_irqrestore(&ha->hardware_lock, flags);
4687
4688                if ((ctrl_status & CSR_NET_RESET_INTR) == 0)
4689                        break;
4690
4691                msleep(1000);
4692        } while ((--max_wait_time));
4693
4694        if ((ctrl_status & CSR_NET_RESET_INTR) != 0) {
4695                DEBUG2(printk(KERN_WARNING
4696                              "scsi%ld: Network Reset Intr not cleared by "
4697                              "Network function, clearing it now!\n",
4698                              ha->host_no));
4699                spin_lock_irqsave(&ha->hardware_lock, flags);
4700                writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status);
4701                readl(&ha->reg->ctrl_status);
4702                spin_unlock_irqrestore(&ha->hardware_lock, flags);
4703        }
4704
4705        /* Wait until the firmware tells us the Soft Reset is done */
4706        max_wait_time = SOFT_RESET_TOV;
4707        do {
4708                spin_lock_irqsave(&ha->hardware_lock, flags);
4709                ctrl_status = readw(&ha->reg->ctrl_status);
4710                spin_unlock_irqrestore(&ha->hardware_lock, flags);
4711
4712                if ((ctrl_status & CSR_SOFT_RESET) == 0) {
4713                        status = QLA_SUCCESS;
4714                        break;
4715                }
4716
4717                msleep(1000);
4718        } while ((--max_wait_time));
4719
4720        /*
4721         * Also, make sure that the SCSI Reset Interrupt bit has been cleared
4722         * after the soft reset has taken place.
4723         */
4724        spin_lock_irqsave(&ha->hardware_lock, flags);
4725        ctrl_status = readw(&ha->reg->ctrl_status);
4726        if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) {
4727                writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
4728                readl(&ha->reg->ctrl_status);
4729        }
4730        spin_unlock_irqrestore(&ha->hardware_lock, flags);
4731
4732        /* If soft reset fails then most probably the bios on other
4733         * function is also enabled.
4734         * Since the initialization is sequential the other fn
4735         * wont be able to acknowledge the soft reset.
4736         * Issue a force soft reset to workaround this scenario.
4737         */
4738        if (max_wait_time == 0) {
4739                /* Issue Force Soft Reset */
4740                spin_lock_irqsave(&ha->hardware_lock, flags);
4741                writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status);
4742                readl(&ha->reg->ctrl_status);
4743                spin_unlock_irqrestore(&ha->hardware_lock, flags);
4744                /* Wait until the firmware tells us the Soft Reset is done */
4745                max_wait_time = SOFT_RESET_TOV;
4746                do {
4747                        spin_lock_irqsave(&ha->hardware_lock, flags);
4748                        ctrl_status = readw(&ha->reg->ctrl_status);
4749                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
4750
4751                        if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) {
4752                                status = QLA_SUCCESS;
4753                                break;
4754                        }
4755
4756                        msleep(1000);
4757                } while ((--max_wait_time));
4758        }
4759
4760        return status;
4761}
4762
4763/**
4764 * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S.
4765 * @ha: Pointer to host adapter structure.
4766 * @res: returned scsi status
4767 *
4768 * This routine is called just prior to a HARD RESET to return all
4769 * outstanding commands back to the Operating System.
4770 * Caller should make sure that the following locks are released
4771 * before this calling routine: Hardware lock, and io_request_lock.
4772 **/
4773static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res)
4774{
4775        struct srb *srb;
4776        int i;
4777        unsigned long flags;
4778
4779        spin_lock_irqsave(&ha->hardware_lock, flags);
4780        for (i = 0; i < ha->host->can_queue; i++) {
4781                srb = qla4xxx_del_from_active_array(ha, i);
4782                if (srb != NULL) {
4783                        srb->cmd->result = res;
4784                        kref_put(&srb->srb_ref, qla4xxx_srb_compl);
4785                }
4786        }
4787        spin_unlock_irqrestore(&ha->hardware_lock, flags);
4788}
4789
4790void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha)
4791{
4792        clear_bit(AF_ONLINE, &ha->flags);
4793
4794        /* Disable the board */
4795        ql4_printk(KERN_INFO, ha, "Disabling the board\n");
4796
4797        qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
4798        qla4xxx_mark_all_devices_missing(ha);
4799        clear_bit(AF_INIT_DONE, &ha->flags);
4800}
4801
4802static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session)
4803{
4804        struct iscsi_session *sess;
4805        struct ddb_entry *ddb_entry;
4806
4807        sess = cls_session->dd_data;
4808        ddb_entry = sess->dd_data;
4809        ddb_entry->fw_ddb_device_state = DDB_DS_SESSION_FAILED;
4810
4811        if (ddb_entry->ddb_type == FLASH_DDB)
4812                iscsi_block_session(ddb_entry->sess);
4813        else
4814                iscsi_session_failure(cls_session->dd_data,
4815                                      ISCSI_ERR_CONN_FAILED);
4816}
4817
4818/**
4819 * qla4xxx_recover_adapter - recovers adapter after a fatal error
4820 * @ha: Pointer to host adapter structure.
4821 **/
4822static int qla4xxx_recover_adapter(struct scsi_qla_host *ha)
4823{
4824        int status = QLA_ERROR;
4825        uint8_t reset_chip = 0;
4826        uint32_t dev_state;
4827        unsigned long wait;
4828
4829        /* Stall incoming I/O until we are done */
4830        scsi_block_requests(ha->host);
4831        clear_bit(AF_ONLINE, &ha->flags);
4832        clear_bit(AF_LINK_UP, &ha->flags);
4833
4834        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE\n", __func__));
4835
4836        set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
4837
4838        if ((is_qla8032(ha) || is_qla8042(ha)) &&
4839            !test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) {
4840                ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
4841                           __func__);
4842                /* disable pause frame for ISP83xx */
4843                qla4_83xx_disable_pause(ha);
4844        }
4845
4846        iscsi_host_for_each_session(ha->host, qla4xxx_fail_session);
4847
4848        if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
4849                reset_chip = 1;
4850
4851        /* For the DPC_RESET_HA_INTR case (ISP-4xxx specific)
4852         * do not reset adapter, jump to initialize_adapter */
4853        if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
4854                status = QLA_SUCCESS;
4855                goto recover_ha_init_adapter;
4856        }
4857
4858        /* For the ISP-8xxx adapter, issue a stop_firmware if invoked
4859         * from eh_host_reset or ioctl module */
4860        if (is_qla80XX(ha) && !reset_chip &&
4861            test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) {
4862
4863                DEBUG2(ql4_printk(KERN_INFO, ha,
4864                    "scsi%ld: %s - Performing stop_firmware...\n",
4865                    ha->host_no, __func__));
4866                status = ha->isp_ops->reset_firmware(ha);
4867                if (status == QLA_SUCCESS) {
4868                        ha->isp_ops->disable_intrs(ha);
4869                        qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4870                        qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
4871                } else {
4872                        /* If the stop_firmware fails then
4873                         * reset the entire chip */
4874                        reset_chip = 1;
4875                        clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
4876                        set_bit(DPC_RESET_HA, &ha->dpc_flags);
4877                }
4878        }
4879
4880        /* Issue full chip reset if recovering from a catastrophic error,
4881         * or if stop_firmware fails for ISP-8xxx.
4882         * This is the default case for ISP-4xxx */
4883        if (is_qla40XX(ha) || reset_chip) {
4884                if (is_qla40XX(ha))
4885                        goto chip_reset;
4886
4887                /* Check if 8XXX firmware is alive or not
4888                 * We may have arrived here from NEED_RESET
4889                 * detection only */
4890                if (test_bit(AF_FW_RECOVERY, &ha->flags))
4891                        goto chip_reset;
4892
4893                wait = jiffies + (FW_ALIVE_WAIT_TOV * HZ);
4894                while (time_before(jiffies, wait)) {
4895                        if (qla4_8xxx_check_fw_alive(ha)) {
4896                                qla4xxx_mailbox_premature_completion(ha);
4897                                break;
4898                        }
4899
4900                        set_current_state(TASK_UNINTERRUPTIBLE);
4901                        schedule_timeout(HZ);
4902                }
4903chip_reset:
4904                if (!test_bit(AF_FW_RECOVERY, &ha->flags))
4905                        qla4xxx_cmd_wait(ha);
4906
4907                qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4908                DEBUG2(ql4_printk(KERN_INFO, ha,
4909                    "scsi%ld: %s - Performing chip reset..\n",
4910                    ha->host_no, __func__));
4911                status = ha->isp_ops->reset_chip(ha);
4912                qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
4913        }
4914
4915        /* Flush any pending ddb changed AENs */
4916        qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4917
4918recover_ha_init_adapter:
4919        /* Upon successful firmware/chip reset, re-initialize the adapter */
4920        if (status == QLA_SUCCESS) {
4921                /* For ISP-4xxx, force function 1 to always initialize
4922                 * before function 3 to prevent both funcions from
4923                 * stepping on top of the other */
4924                if (is_qla40XX(ha) && (ha->mac_index == 3))
4925                        ssleep(6);
4926
4927                /* NOTE: AF_ONLINE flag set upon successful completion of
4928                 * qla4xxx_initialize_adapter */
4929                status = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
4930                if (is_qla80XX(ha) && (status == QLA_ERROR)) {
4931                        status = qla4_8xxx_check_init_adapter_retry(ha);
4932                        if (status == QLA_ERROR) {
4933                                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Don't retry recover adapter\n",
4934                                           ha->host_no, __func__);
4935                                qla4xxx_dead_adapter_cleanup(ha);
4936                                clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
4937                                clear_bit(DPC_RESET_HA, &ha->dpc_flags);
4938                                clear_bit(DPC_RESET_HA_FW_CONTEXT,
4939                                          &ha->dpc_flags);
4940                                goto exit_recover;
4941                        }
4942                }
4943        }
4944
4945        /* Retry failed adapter initialization, if necessary
4946         * Do not retry initialize_adapter for RESET_HA_INTR (ISP-4xxx specific)
4947         * case to prevent ping-pong resets between functions */
4948        if (!test_bit(AF_ONLINE, &ha->flags) &&
4949            !test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
4950                /* Adapter initialization failed, see if we can retry
4951                 * resetting the ha.
4952                 * Since we don't want to block the DPC for too long
4953                 * with multiple resets in the same thread,
4954                 * utilize DPC to retry */
4955                if (is_qla80XX(ha)) {
4956                        ha->isp_ops->idc_lock(ha);
4957                        dev_state = qla4_8xxx_rd_direct(ha,
4958                                                        QLA8XXX_CRB_DEV_STATE);
4959                        ha->isp_ops->idc_unlock(ha);
4960                        if (dev_state == QLA8XXX_DEV_FAILED) {
4961                                ql4_printk(KERN_INFO, ha, "%s: don't retry "
4962                                           "recover adapter. H/W is in Failed "
4963                                           "state\n", __func__);
4964                                qla4xxx_dead_adapter_cleanup(ha);
4965                                clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
4966                                clear_bit(DPC_RESET_HA, &ha->dpc_flags);
4967                                clear_bit(DPC_RESET_HA_FW_CONTEXT,
4968                                                &ha->dpc_flags);
4969                                status = QLA_ERROR;
4970
4971                                goto exit_recover;
4972                        }
4973                }
4974
4975                if (!test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags)) {
4976                        ha->retry_reset_ha_cnt = MAX_RESET_HA_RETRIES;
4977                        DEBUG2(printk("scsi%ld: recover adapter - retrying "
4978                                      "(%d) more times\n", ha->host_no,
4979                                      ha->retry_reset_ha_cnt));
4980                        set_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
4981                        status = QLA_ERROR;
4982                } else {
4983                        if (ha->retry_reset_ha_cnt > 0) {
4984                                /* Schedule another Reset HA--DPC will retry */
4985                                ha->retry_reset_ha_cnt--;
4986                                DEBUG2(printk("scsi%ld: recover adapter - "
4987                                              "retry remaining %d\n",
4988                                              ha->host_no,
4989                                              ha->retry_reset_ha_cnt));
4990                                status = QLA_ERROR;
4991                        }
4992
4993                        if (ha->retry_reset_ha_cnt == 0) {
4994                                /* Recover adapter retries have been exhausted.
4995                                 * Adapter DEAD */
4996                                DEBUG2(printk("scsi%ld: recover adapter "
4997                                              "failed - board disabled\n",
4998                                              ha->host_no));
4999                                qla4xxx_dead_adapter_cleanup(ha);
5000                                clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
5001                                clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5002                                clear_bit(DPC_RESET_HA_FW_CONTEXT,
5003                                          &ha->dpc_flags);
5004                                status = QLA_ERROR;
5005                        }
5006                }
5007        } else {
5008                clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5009                clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
5010                clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
5011        }
5012
5013exit_recover:
5014        ha->adapter_error_count++;
5015
5016        if (test_bit(AF_ONLINE, &ha->flags))
5017                ha->isp_ops->enable_intrs(ha);
5018
5019        scsi_unblock_requests(ha->host);
5020
5021        clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
5022        DEBUG2(printk("scsi%ld: recover adapter: %s\n", ha->host_no,
5023            status == QLA_ERROR ? "FAILED" : "SUCCEEDED"));
5024
5025        return status;
5026}
5027
5028static void qla4xxx_relogin_devices(struct iscsi_cls_session *cls_session)
5029{
5030        struct iscsi_session *sess;
5031        struct ddb_entry *ddb_entry;
5032        struct scsi_qla_host *ha;
5033
5034        sess = cls_session->dd_data;
5035        ddb_entry = sess->dd_data;
5036        ha = ddb_entry->ha;
5037        if (!iscsi_is_session_online(cls_session)) {
5038                if (ddb_entry->fw_ddb_device_state == DDB_DS_SESSION_ACTIVE) {
5039                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5040                                   " unblock session\n", ha->host_no, __func__,
5041                                   ddb_entry->fw_ddb_index);
5042                        iscsi_unblock_session(ddb_entry->sess);
5043                } else {
5044                        /* Trigger relogin */
5045                        if (ddb_entry->ddb_type == FLASH_DDB) {
5046                                if (!(test_bit(DF_RELOGIN, &ddb_entry->flags) ||
5047                                      test_bit(DF_DISABLE_RELOGIN,
5048                                               &ddb_entry->flags)))
5049                                        qla4xxx_arm_relogin_timer(ddb_entry);
5050                        } else
5051                                iscsi_session_failure(cls_session->dd_data,
5052                                                      ISCSI_ERR_CONN_FAILED);
5053                }
5054        }
5055}
5056
5057int qla4xxx_unblock_flash_ddb(struct iscsi_cls_session *cls_session)
5058{
5059        struct iscsi_session *sess;
5060        struct ddb_entry *ddb_entry;
5061        struct scsi_qla_host *ha;
5062
5063        sess = cls_session->dd_data;
5064        ddb_entry = sess->dd_data;
5065        ha = ddb_entry->ha;
5066        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5067                   " unblock session\n", ha->host_no, __func__,
5068                   ddb_entry->fw_ddb_index);
5069
5070        iscsi_unblock_session(ddb_entry->sess);
5071
5072        /* Start scan target */
5073        if (test_bit(AF_ONLINE, &ha->flags)) {
5074                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5075                           " start scan\n", ha->host_no, __func__,
5076                           ddb_entry->fw_ddb_index);
5077                scsi_queue_work(ha->host, &ddb_entry->sess->scan_work);
5078        }
5079        return QLA_SUCCESS;
5080}
5081
5082int qla4xxx_unblock_ddb(struct iscsi_cls_session *cls_session)
5083{
5084        struct iscsi_session *sess;
5085        struct ddb_entry *ddb_entry;
5086        struct scsi_qla_host *ha;
5087        int status = QLA_SUCCESS;
5088
5089        sess = cls_session->dd_data;
5090        ddb_entry = sess->dd_data;
5091        ha = ddb_entry->ha;
5092        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5093                   " unblock user space session\n", ha->host_no, __func__,
5094                   ddb_entry->fw_ddb_index);
5095
5096        if (!iscsi_is_session_online(cls_session)) {
5097                iscsi_conn_start(ddb_entry->conn);
5098                iscsi_conn_login_event(ddb_entry->conn,
5099                                       ISCSI_CONN_STATE_LOGGED_IN);
5100        } else {
5101                ql4_printk(KERN_INFO, ha,
5102                           "scsi%ld: %s: ddb[%d] session [%d] already logged in\n",
5103                           ha->host_no, __func__, ddb_entry->fw_ddb_index,
5104                           cls_session->sid);
5105                status = QLA_ERROR;
5106        }
5107
5108        return status;
5109}
5110
5111static void qla4xxx_relogin_all_devices(struct scsi_qla_host *ha)
5112{
5113        iscsi_host_for_each_session(ha->host, qla4xxx_relogin_devices);
5114}
5115
5116static void qla4xxx_relogin_flash_ddb(struct iscsi_cls_session *cls_sess)
5117{
5118        uint16_t relogin_timer;
5119        struct iscsi_session *sess;
5120        struct ddb_entry *ddb_entry;
5121        struct scsi_qla_host *ha;
5122
5123        sess = cls_sess->dd_data;
5124        ddb_entry = sess->dd_data;
5125        ha = ddb_entry->ha;
5126
5127        relogin_timer = max(ddb_entry->default_relogin_timeout,
5128                            (uint16_t)RELOGIN_TOV);
5129        atomic_set(&ddb_entry->relogin_timer, relogin_timer);
5130
5131        DEBUG2(ql4_printk(KERN_INFO, ha,
5132                          "scsi%ld: Relogin index [%d]. TOV=%d\n", ha->host_no,
5133                          ddb_entry->fw_ddb_index, relogin_timer));
5134
5135        qla4xxx_login_flash_ddb(cls_sess);
5136}
5137
5138static void qla4xxx_dpc_relogin(struct iscsi_cls_session *cls_sess)
5139{
5140        struct iscsi_session *sess;
5141        struct ddb_entry *ddb_entry;
5142        struct scsi_qla_host *ha;
5143
5144        sess = cls_sess->dd_data;
5145        ddb_entry = sess->dd_data;
5146        ha = ddb_entry->ha;
5147
5148        if (!(ddb_entry->ddb_type == FLASH_DDB))
5149                return;
5150
5151        if (test_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags))
5152                return;
5153
5154        if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags) &&
5155            !iscsi_is_session_online(cls_sess)) {
5156                DEBUG2(ql4_printk(KERN_INFO, ha,
5157                                  "relogin issued\n"));
5158                qla4xxx_relogin_flash_ddb(cls_sess);
5159        }
5160}
5161
5162void qla4xxx_wake_dpc(struct scsi_qla_host *ha)
5163{
5164        if (ha->dpc_thread)
5165                queue_work(ha->dpc_thread, &ha->dpc_work);
5166}
5167
5168static struct qla4_work_evt *
5169qla4xxx_alloc_work(struct scsi_qla_host *ha, uint32_t data_size,
5170                   enum qla4_work_type type)
5171{
5172        struct qla4_work_evt *e;
5173        uint32_t size = sizeof(struct qla4_work_evt) + data_size;
5174
5175        e = kzalloc(size, GFP_ATOMIC);
5176        if (!e)
5177                return NULL;
5178
5179        INIT_LIST_HEAD(&e->list);
5180        e->type = type;
5181        return e;
5182}
5183
5184static void qla4xxx_post_work(struct scsi_qla_host *ha,
5185                             struct qla4_work_evt *e)
5186{
5187        unsigned long flags;
5188
5189        spin_lock_irqsave(&ha->work_lock, flags);
5190        list_add_tail(&e->list, &ha->work_list);
5191        spin_unlock_irqrestore(&ha->work_lock, flags);
5192        qla4xxx_wake_dpc(ha);
5193}
5194
5195int qla4xxx_post_aen_work(struct scsi_qla_host *ha,
5196                          enum iscsi_host_event_code aen_code,
5197                          uint32_t data_size, uint8_t *data)
5198{
5199        struct qla4_work_evt *e;
5200
5201        e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_AEN);
5202        if (!e)
5203                return QLA_ERROR;
5204
5205        e->u.aen.code = aen_code;
5206        e->u.aen.data_size = data_size;
5207        memcpy(e->u.aen.data, data, data_size);
5208
5209        qla4xxx_post_work(ha, e);
5210
5211        return QLA_SUCCESS;
5212}
5213
5214int qla4xxx_post_ping_evt_work(struct scsi_qla_host *ha,
5215                               uint32_t status, uint32_t pid,
5216                               uint32_t data_size, uint8_t *data)
5217{
5218        struct qla4_work_evt *e;
5219
5220        e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_PING_STATUS);
5221        if (!e)
5222                return QLA_ERROR;
5223
5224        e->u.ping.status = status;
5225        e->u.ping.pid = pid;
5226        e->u.ping.data_size = data_size;
5227        memcpy(e->u.ping.data, data, data_size);
5228
5229        qla4xxx_post_work(ha, e);
5230
5231        return QLA_SUCCESS;
5232}
5233
5234static void qla4xxx_do_work(struct scsi_qla_host *ha)
5235{
5236        struct qla4_work_evt *e, *tmp;
5237        unsigned long flags;
5238        LIST_HEAD(work);
5239
5240        spin_lock_irqsave(&ha->work_lock, flags);
5241        list_splice_init(&ha->work_list, &work);
5242        spin_unlock_irqrestore(&ha->work_lock, flags);
5243
5244        list_for_each_entry_safe(e, tmp, &work, list) {
5245                list_del_init(&e->list);
5246
5247                switch (e->type) {
5248                case QLA4_EVENT_AEN:
5249                        iscsi_post_host_event(ha->host_no,
5250                                              &qla4xxx_iscsi_transport,
5251                                              e->u.aen.code,
5252                                              e->u.aen.data_size,
5253                                              e->u.aen.data);
5254                        break;
5255                case QLA4_EVENT_PING_STATUS:
5256                        iscsi_ping_comp_event(ha->host_no,
5257                                              &qla4xxx_iscsi_transport,
5258                                              e->u.ping.status,
5259                                              e->u.ping.pid,
5260                                              e->u.ping.data_size,
5261                                              e->u.ping.data);
5262                        break;
5263                default:
5264                        ql4_printk(KERN_WARNING, ha, "event type: 0x%x not "
5265                                   "supported", e->type);
5266                }
5267                kfree(e);
5268        }
5269}
5270
5271/**
5272 * qla4xxx_do_dpc - dpc routine
5273 * @data: in our case pointer to adapter structure
5274 *
5275 * This routine is a task that is schedule by the interrupt handler
5276 * to perform the background processing for interrupts.  We put it
5277 * on a task queue that is consumed whenever the scheduler runs; that's
5278 * so you can do anything (i.e. put the process to sleep etc).  In fact,
5279 * the mid-level tries to sleep when it reaches the driver threshold
5280 * "host->can_queue". This can cause a panic if we were in our interrupt code.
5281 **/
5282static void qla4xxx_do_dpc(struct work_struct *work)
5283{
5284        struct scsi_qla_host *ha =
5285                container_of(work, struct scsi_qla_host, dpc_work);
5286        int status = QLA_ERROR;
5287
5288        DEBUG2(ql4_printk(KERN_INFO, ha,
5289                          "scsi%ld: %s: DPC handler waking up. flags = 0x%08lx, dpc_flags = 0x%08lx\n",
5290                          ha->host_no, __func__, ha->flags, ha->dpc_flags));
5291
5292        /* Initialization not yet finished. Don't do anything yet. */
5293        if (!test_bit(AF_INIT_DONE, &ha->flags))
5294                return;
5295
5296        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
5297                DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n",
5298                    ha->host_no, __func__, ha->flags));
5299                return;
5300        }
5301
5302        /* post events to application */
5303        qla4xxx_do_work(ha);
5304
5305        if (is_qla80XX(ha)) {
5306                if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) {
5307                        if (is_qla8032(ha) || is_qla8042(ha)) {
5308                                ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
5309                                           __func__);
5310                                /* disable pause frame for ISP83xx */
5311                                qla4_83xx_disable_pause(ha);
5312                        }
5313
5314                        ha->isp_ops->idc_lock(ha);
5315                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
5316                                            QLA8XXX_DEV_FAILED);
5317                        ha->isp_ops->idc_unlock(ha);
5318                        ql4_printk(KERN_INFO, ha, "HW State: FAILED\n");
5319                        qla4_8xxx_device_state_handler(ha);
5320                }
5321
5322                if (test_bit(DPC_POST_IDC_ACK, &ha->dpc_flags)) {
5323                        if (is_qla8042(ha)) {
5324                                if (ha->idc_info.info2 &
5325                                    ENABLE_INTERNAL_LOOPBACK) {
5326                                        ql4_printk(KERN_INFO, ha, "%s: Disabling ACB\n",
5327                                                   __func__);
5328                                        status = qla4_84xx_config_acb(ha,
5329                                                            ACB_CONFIG_DISABLE);
5330                                        if (status != QLA_SUCCESS) {
5331                                                ql4_printk(KERN_INFO, ha, "%s: ACB config failed\n",
5332                                                           __func__);
5333                                        }
5334                                }
5335                        }
5336                        qla4_83xx_post_idc_ack(ha);
5337                        clear_bit(DPC_POST_IDC_ACK, &ha->dpc_flags);
5338                }
5339
5340                if (is_qla8042(ha) &&
5341                    test_bit(DPC_RESTORE_ACB, &ha->dpc_flags)) {
5342                        ql4_printk(KERN_INFO, ha, "%s: Restoring ACB\n",
5343                                   __func__);
5344                        if (qla4_84xx_config_acb(ha, ACB_CONFIG_SET) !=
5345                            QLA_SUCCESS) {
5346                                ql4_printk(KERN_INFO, ha, "%s: ACB config failed ",
5347                                           __func__);
5348                        }
5349                        clear_bit(DPC_RESTORE_ACB, &ha->dpc_flags);
5350                }
5351
5352                if (test_and_clear_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
5353                        qla4_8xxx_need_qsnt_handler(ha);
5354                }
5355        }
5356
5357        if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) &&
5358            (test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
5359            test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
5360            test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))) {
5361                if ((is_qla8022(ha) && ql4xdontresethba) ||
5362                    ((is_qla8032(ha) || is_qla8042(ha)) &&
5363                     qla4_83xx_idc_dontreset(ha))) {
5364                        DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n",
5365                            ha->host_no, __func__));
5366                        clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5367                        clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags);
5368                        clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
5369                        goto dpc_post_reset_ha;
5370                }
5371                if (test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) ||
5372                    test_bit(DPC_RESET_HA, &ha->dpc_flags))
5373                        qla4xxx_recover_adapter(ha);
5374
5375                if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
5376                        uint8_t wait_time = RESET_INTR_TOV;
5377
5378                        while ((readw(&ha->reg->ctrl_status) &
5379                                (CSR_SOFT_RESET | CSR_FORCE_SOFT_RESET)) != 0) {
5380                                if (--wait_time == 0)
5381                                        break;
5382                                msleep(1000);
5383                        }
5384                        if (wait_time == 0)
5385                                DEBUG2(printk("scsi%ld: %s: SR|FSR "
5386                                              "bit not cleared-- resetting\n",
5387                                              ha->host_no, __func__));
5388                        qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
5389                        if (ql4xxx_lock_drvr_wait(ha) == QLA_SUCCESS) {
5390                                qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
5391                                status = qla4xxx_recover_adapter(ha);
5392                        }
5393                        clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags);
5394                        if (status == QLA_SUCCESS)
5395                                ha->isp_ops->enable_intrs(ha);
5396                }
5397        }
5398
5399dpc_post_reset_ha:
5400        /* ---- process AEN? --- */
5401        if (test_and_clear_bit(DPC_AEN, &ha->dpc_flags))
5402                qla4xxx_process_aen(ha, PROCESS_ALL_AENS);
5403
5404        /* ---- Get DHCP IP Address? --- */
5405        if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags))
5406                qla4xxx_get_dhcp_ip_address(ha);
5407
5408        /* ---- relogin device? --- */
5409        if (adapter_up(ha) &&
5410            test_and_clear_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags)) {
5411                iscsi_host_for_each_session(ha->host, qla4xxx_dpc_relogin);
5412        }
5413
5414        /* ---- link change? --- */
5415        if (!test_bit(AF_LOOPBACK, &ha->flags) &&
5416            test_and_clear_bit(DPC_LINK_CHANGED, &ha->dpc_flags)) {
5417                if (!test_bit(AF_LINK_UP, &ha->flags)) {
5418                        /* ---- link down? --- */
5419                        qla4xxx_mark_all_devices_missing(ha);
5420                } else {
5421                        /* ---- link up? --- *
5422                         * F/W will auto login to all devices ONLY ONCE after
5423                         * link up during driver initialization and runtime
5424                         * fatal error recovery.  Therefore, the driver must
5425                         * manually relogin to devices when recovering from
5426                         * connection failures, logouts, expired KATO, etc. */
5427                        if (test_and_clear_bit(AF_BUILD_DDB_LIST, &ha->flags)) {
5428                                qla4xxx_build_ddb_list(ha, ha->is_reset);
5429                                iscsi_host_for_each_session(ha->host,
5430                                                qla4xxx_login_flash_ddb);
5431                        } else
5432                                qla4xxx_relogin_all_devices(ha);
5433                }
5434        }
5435        if (test_and_clear_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags)) {
5436                if (qla4xxx_sysfs_ddb_export(ha))
5437                        ql4_printk(KERN_ERR, ha, "%s: Error exporting ddb to sysfs\n",
5438                                   __func__);
5439        }
5440}
5441
5442/**
5443 * qla4xxx_free_adapter - release the adapter
5444 * @ha: pointer to adapter structure
5445 **/
5446static void qla4xxx_free_adapter(struct scsi_qla_host *ha)
5447{
5448        qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
5449
5450        /* Turn-off interrupts on the card. */
5451        ha->isp_ops->disable_intrs(ha);
5452
5453        if (is_qla40XX(ha)) {
5454                writel(set_rmask(CSR_SCSI_PROCESSOR_INTR),
5455                       &ha->reg->ctrl_status);
5456                readl(&ha->reg->ctrl_status);
5457        } else if (is_qla8022(ha)) {
5458                writel(0, &ha->qla4_82xx_reg->host_int);
5459                readl(&ha->qla4_82xx_reg->host_int);
5460        } else if (is_qla8032(ha) || is_qla8042(ha)) {
5461                writel(0, &ha->qla4_83xx_reg->risc_intr);
5462                readl(&ha->qla4_83xx_reg->risc_intr);
5463        }
5464
5465        /* Remove timer thread, if present */
5466        if (ha->timer_active)
5467                qla4xxx_stop_timer(ha);
5468
5469        /* Kill the kernel thread for this host */
5470        if (ha->dpc_thread)
5471                destroy_workqueue(ha->dpc_thread);
5472
5473        /* Kill the kernel thread for this host */
5474        if (ha->task_wq)
5475                destroy_workqueue(ha->task_wq);
5476
5477        /* Put firmware in known state */
5478        ha->isp_ops->reset_firmware(ha);
5479
5480        if (is_qla80XX(ha)) {
5481                ha->isp_ops->idc_lock(ha);
5482                qla4_8xxx_clear_drv_active(ha);
5483                ha->isp_ops->idc_unlock(ha);
5484        }
5485
5486        /* Detach interrupts */
5487        qla4xxx_free_irqs(ha);
5488
5489        /* free extra memory */
5490        qla4xxx_mem_free(ha);
5491}
5492
5493int qla4_8xxx_iospace_config(struct scsi_qla_host *ha)
5494{
5495        int status = 0;
5496        unsigned long mem_base, mem_len, db_base, db_len;
5497        struct pci_dev *pdev = ha->pdev;
5498
5499        status = pci_request_regions(pdev, DRIVER_NAME);
5500        if (status) {
5501                printk(KERN_WARNING
5502                    "scsi(%ld) Failed to reserve PIO regions (%s) "
5503                    "status=%d\n", ha->host_no, pci_name(pdev), status);
5504                goto iospace_error_exit;
5505        }
5506
5507        DEBUG2(printk(KERN_INFO "%s: revision-id=%d\n",
5508            __func__, pdev->revision));
5509        ha->revision_id = pdev->revision;
5510
5511        /* remap phys address */
5512        mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
5513        mem_len = pci_resource_len(pdev, 0);
5514        DEBUG2(printk(KERN_INFO "%s: ioremap from %lx a size of %lx\n",
5515            __func__, mem_base, mem_len));
5516
5517        /* mapping of pcibase pointer */
5518        ha->nx_pcibase = (unsigned long)ioremap(mem_base, mem_len);
5519        if (!ha->nx_pcibase) {
5520                printk(KERN_ERR
5521                    "cannot remap MMIO (%s), aborting\n", pci_name(pdev));
5522                pci_release_regions(ha->pdev);
5523                goto iospace_error_exit;
5524        }
5525
5526        /* Mapping of IO base pointer, door bell read and write pointer */
5527
5528        /* mapping of IO base pointer */
5529        if (is_qla8022(ha)) {
5530                ha->qla4_82xx_reg = (struct device_reg_82xx  __iomem *)
5531                                    ((uint8_t *)ha->nx_pcibase + 0xbc000 +
5532                                     (ha->pdev->devfn << 11));
5533                ha->nx_db_wr_ptr = (ha->pdev->devfn == 4 ? QLA82XX_CAM_RAM_DB1 :
5534                                    QLA82XX_CAM_RAM_DB2);
5535        } else if (is_qla8032(ha) || is_qla8042(ha)) {
5536                ha->qla4_83xx_reg = (struct device_reg_83xx __iomem *)
5537                                    ((uint8_t *)ha->nx_pcibase);
5538        }
5539
5540        db_base = pci_resource_start(pdev, 4);  /* doorbell is on bar 4 */
5541        db_len = pci_resource_len(pdev, 4);
5542
5543        return 0;
5544iospace_error_exit:
5545        return -ENOMEM;
5546}
5547
5548/***
5549 * qla4xxx_iospace_config - maps registers
5550 * @ha: pointer to adapter structure
5551 *
5552 * This routines maps HBA's registers from the pci address space
5553 * into the kernel virtual address space for memory mapped i/o.
5554 **/
5555int qla4xxx_iospace_config(struct scsi_qla_host *ha)
5556{
5557        unsigned long pio, pio_len, pio_flags;
5558        unsigned long mmio, mmio_len, mmio_flags;
5559
5560        pio = pci_resource_start(ha->pdev, 0);
5561        pio_len = pci_resource_len(ha->pdev, 0);
5562        pio_flags = pci_resource_flags(ha->pdev, 0);
5563        if (pio_flags & IORESOURCE_IO) {
5564                if (pio_len < MIN_IOBASE_LEN) {
5565                        ql4_printk(KERN_WARNING, ha,
5566                                "Invalid PCI I/O region size\n");
5567                        pio = 0;
5568                }
5569        } else {
5570                ql4_printk(KERN_WARNING, ha, "region #0 not a PIO resource\n");
5571                pio = 0;
5572        }
5573
5574        /* Use MMIO operations for all accesses. */
5575        mmio = pci_resource_start(ha->pdev, 1);
5576        mmio_len = pci_resource_len(ha->pdev, 1);
5577        mmio_flags = pci_resource_flags(ha->pdev, 1);
5578
5579        if (!(mmio_flags & IORESOURCE_MEM)) {
5580                ql4_printk(KERN_ERR, ha,
5581                    "region #0 not an MMIO resource, aborting\n");
5582
5583                goto iospace_error_exit;
5584        }
5585
5586        if (mmio_len < MIN_IOBASE_LEN) {
5587                ql4_printk(KERN_ERR, ha,
5588                    "Invalid PCI mem region size, aborting\n");
5589                goto iospace_error_exit;
5590        }
5591
5592        if (pci_request_regions(ha->pdev, DRIVER_NAME)) {
5593                ql4_printk(KERN_WARNING, ha,
5594                    "Failed to reserve PIO/MMIO regions\n");
5595
5596                goto iospace_error_exit;
5597        }
5598
5599        ha->pio_address = pio;
5600        ha->pio_length = pio_len;
5601        ha->reg = ioremap(mmio, MIN_IOBASE_LEN);
5602        if (!ha->reg) {
5603                ql4_printk(KERN_ERR, ha,
5604                    "cannot remap MMIO, aborting\n");
5605
5606                goto iospace_error_exit;
5607        }
5608
5609        return 0;
5610
5611iospace_error_exit:
5612        return -ENOMEM;
5613}
5614
5615static struct isp_operations qla4xxx_isp_ops = {
5616        .iospace_config         = qla4xxx_iospace_config,
5617        .pci_config             = qla4xxx_pci_config,
5618        .disable_intrs          = qla4xxx_disable_intrs,
5619        .enable_intrs           = qla4xxx_enable_intrs,
5620        .start_firmware         = qla4xxx_start_firmware,
5621        .intr_handler           = qla4xxx_intr_handler,
5622        .interrupt_service_routine = qla4xxx_interrupt_service_routine,
5623        .reset_chip             = qla4xxx_soft_reset,
5624        .reset_firmware         = qla4xxx_hw_reset,
5625        .queue_iocb             = qla4xxx_queue_iocb,
5626        .complete_iocb          = qla4xxx_complete_iocb,
5627        .rd_shdw_req_q_out      = qla4xxx_rd_shdw_req_q_out,
5628        .rd_shdw_rsp_q_in       = qla4xxx_rd_shdw_rsp_q_in,
5629        .get_sys_info           = qla4xxx_get_sys_info,
5630        .queue_mailbox_command  = qla4xxx_queue_mbox_cmd,
5631        .process_mailbox_interrupt = qla4xxx_process_mbox_intr,
5632};
5633
5634static struct isp_operations qla4_82xx_isp_ops = {
5635        .iospace_config         = qla4_8xxx_iospace_config,
5636        .pci_config             = qla4_8xxx_pci_config,
5637        .disable_intrs          = qla4_82xx_disable_intrs,
5638        .enable_intrs           = qla4_82xx_enable_intrs,
5639        .start_firmware         = qla4_8xxx_load_risc,
5640        .restart_firmware       = qla4_82xx_try_start_fw,
5641        .intr_handler           = qla4_82xx_intr_handler,
5642        .interrupt_service_routine = qla4_82xx_interrupt_service_routine,
5643        .need_reset             = qla4_8xxx_need_reset,
5644        .reset_chip             = qla4_82xx_isp_reset,
5645        .reset_firmware         = qla4_8xxx_stop_firmware,
5646        .queue_iocb             = qla4_82xx_queue_iocb,
5647        .complete_iocb          = qla4_82xx_complete_iocb,
5648        .rd_shdw_req_q_out      = qla4_82xx_rd_shdw_req_q_out,
5649        .rd_shdw_rsp_q_in       = qla4_82xx_rd_shdw_rsp_q_in,
5650        .get_sys_info           = qla4_8xxx_get_sys_info,
5651        .rd_reg_direct          = qla4_82xx_rd_32,
5652        .wr_reg_direct          = qla4_82xx_wr_32,
5653        .rd_reg_indirect        = qla4_82xx_md_rd_32,
5654        .wr_reg_indirect        = qla4_82xx_md_wr_32,
5655        .idc_lock               = qla4_82xx_idc_lock,
5656        .idc_unlock             = qla4_82xx_idc_unlock,
5657        .rom_lock_recovery      = qla4_82xx_rom_lock_recovery,
5658        .queue_mailbox_command  = qla4_82xx_queue_mbox_cmd,
5659        .process_mailbox_interrupt = qla4_82xx_process_mbox_intr,
5660};
5661
5662static struct isp_operations qla4_83xx_isp_ops = {
5663        .iospace_config         = qla4_8xxx_iospace_config,
5664        .pci_config             = qla4_8xxx_pci_config,
5665        .disable_intrs          = qla4_83xx_disable_intrs,
5666        .enable_intrs           = qla4_83xx_enable_intrs,
5667        .start_firmware         = qla4_8xxx_load_risc,
5668        .restart_firmware       = qla4_83xx_start_firmware,
5669        .intr_handler           = qla4_83xx_intr_handler,
5670        .interrupt_service_routine = qla4_83xx_interrupt_service_routine,
5671        .need_reset             = qla4_8xxx_need_reset,
5672        .reset_chip             = qla4_83xx_isp_reset,
5673        .reset_firmware         = qla4_8xxx_stop_firmware,
5674        .queue_iocb             = qla4_83xx_queue_iocb,
5675        .complete_iocb          = qla4_83xx_complete_iocb,
5676        .rd_shdw_req_q_out      = qla4xxx_rd_shdw_req_q_out,
5677        .rd_shdw_rsp_q_in       = qla4xxx_rd_shdw_rsp_q_in,
5678        .get_sys_info           = qla4_8xxx_get_sys_info,
5679        .rd_reg_direct          = qla4_83xx_rd_reg,
5680        .wr_reg_direct          = qla4_83xx_wr_reg,
5681        .rd_reg_indirect        = qla4_83xx_rd_reg_indirect,
5682        .wr_reg_indirect        = qla4_83xx_wr_reg_indirect,
5683        .idc_lock               = qla4_83xx_drv_lock,
5684        .idc_unlock             = qla4_83xx_drv_unlock,
5685        .rom_lock_recovery      = qla4_83xx_rom_lock_recovery,
5686        .queue_mailbox_command  = qla4_83xx_queue_mbox_cmd,
5687        .process_mailbox_interrupt = qla4_83xx_process_mbox_intr,
5688};
5689
5690uint16_t qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha)
5691{
5692        return (uint16_t)le32_to_cpu(ha->shadow_regs->req_q_out);
5693}
5694
5695uint16_t qla4_82xx_rd_shdw_req_q_out(struct scsi_qla_host *ha)
5696{
5697        return (uint16_t)le32_to_cpu(readl(&ha->qla4_82xx_reg->req_q_out));
5698}
5699
5700uint16_t qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha)
5701{
5702        return (uint16_t)le32_to_cpu(ha->shadow_regs->rsp_q_in);
5703}
5704
5705uint16_t qla4_82xx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha)
5706{
5707        return (uint16_t)le32_to_cpu(readl(&ha->qla4_82xx_reg->rsp_q_in));
5708}
5709
5710static ssize_t qla4xxx_show_boot_eth_info(void *data, int type, char *buf)
5711{
5712        struct scsi_qla_host *ha = data;
5713        char *str = buf;
5714        int rc;
5715
5716        switch (type) {
5717        case ISCSI_BOOT_ETH_FLAGS:
5718                rc = sprintf(str, "%d\n", SYSFS_FLAG_FW_SEL_BOOT);
5719                break;
5720        case ISCSI_BOOT_ETH_INDEX:
5721                rc = sprintf(str, "0\n");
5722                break;
5723        case ISCSI_BOOT_ETH_MAC:
5724                rc = sysfs_format_mac(str, ha->my_mac,
5725                                      MAC_ADDR_LEN);
5726                break;
5727        default:
5728                rc = -ENOSYS;
5729                break;
5730        }
5731        return rc;
5732}
5733
5734static umode_t qla4xxx_eth_get_attr_visibility(void *data, int type)
5735{
5736        int rc;
5737
5738        switch (type) {
5739        case ISCSI_BOOT_ETH_FLAGS:
5740        case ISCSI_BOOT_ETH_MAC:
5741        case ISCSI_BOOT_ETH_INDEX:
5742                rc = S_IRUGO;
5743                break;
5744        default:
5745                rc = 0;
5746                break;
5747        }
5748        return rc;
5749}
5750
5751static ssize_t qla4xxx_show_boot_ini_info(void *data, int type, char *buf)
5752{
5753        struct scsi_qla_host *ha = data;
5754        char *str = buf;
5755        int rc;
5756
5757        switch (type) {
5758        case ISCSI_BOOT_INI_INITIATOR_NAME:
5759                rc = sprintf(str, "%s\n", ha->name_string);
5760                break;
5761        default:
5762                rc = -ENOSYS;
5763                break;
5764        }
5765        return rc;
5766}
5767
5768static umode_t qla4xxx_ini_get_attr_visibility(void *data, int type)
5769{
5770        int rc;
5771
5772        switch (type) {
5773        case ISCSI_BOOT_INI_INITIATOR_NAME:
5774                rc = S_IRUGO;
5775                break;
5776        default:
5777                rc = 0;
5778                break;
5779        }
5780        return rc;
5781}
5782
5783static ssize_t
5784qla4xxx_show_boot_tgt_info(struct ql4_boot_session_info *boot_sess, int type,
5785                           char *buf)
5786{
5787        struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0];
5788        char *str = buf;
5789        int rc;
5790
5791        switch (type) {
5792        case ISCSI_BOOT_TGT_NAME:
5793                rc = sprintf(buf, "%s\n", (char *)&boot_sess->target_name);
5794                break;
5795        case ISCSI_BOOT_TGT_IP_ADDR:
5796                if (boot_sess->conn_list[0].dest_ipaddr.ip_type == 0x1)
5797                        rc = sprintf(buf, "%pI4\n",
5798                                     &boot_conn->dest_ipaddr.ip_address);
5799                else
5800                        rc = sprintf(str, "%pI6\n",
5801                                     &boot_conn->dest_ipaddr.ip_address);
5802                break;
5803        case ISCSI_BOOT_TGT_PORT:
5804                        rc = sprintf(str, "%d\n", boot_conn->dest_port);
5805                break;
5806        case ISCSI_BOOT_TGT_CHAP_NAME:
5807                rc = sprintf(str,  "%.*s\n",
5808                             boot_conn->chap.target_chap_name_length,
5809                             (char *)&boot_conn->chap.target_chap_name);
5810                break;
5811        case ISCSI_BOOT_TGT_CHAP_SECRET:
5812                rc = sprintf(str,  "%.*s\n",
5813                             boot_conn->chap.target_secret_length,
5814                             (char *)&boot_conn->chap.target_secret);
5815                break;
5816        case ISCSI_BOOT_TGT_REV_CHAP_NAME:
5817                rc = sprintf(str,  "%.*s\n",
5818                             boot_conn->chap.intr_chap_name_length,
5819                             (char *)&boot_conn->chap.intr_chap_name);
5820                break;
5821        case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
5822                rc = sprintf(str,  "%.*s\n",
5823                             boot_conn->chap.intr_secret_length,
5824                             (char *)&boot_conn->chap.intr_secret);
5825                break;
5826        case ISCSI_BOOT_TGT_FLAGS:
5827                rc = sprintf(str, "%d\n", SYSFS_FLAG_FW_SEL_BOOT);
5828                break;
5829        case ISCSI_BOOT_TGT_NIC_ASSOC:
5830                rc = sprintf(str, "0\n");
5831                break;
5832        default:
5833                rc = -ENOSYS;
5834                break;
5835        }
5836        return rc;
5837}
5838
5839static ssize_t qla4xxx_show_boot_tgt_pri_info(void *data, int type, char *buf)
5840{
5841        struct scsi_qla_host *ha = data;
5842        struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_pri_sess);
5843
5844        return qla4xxx_show_boot_tgt_info(boot_sess, type, buf);
5845}
5846
5847static ssize_t qla4xxx_show_boot_tgt_sec_info(void *data, int type, char *buf)
5848{
5849        struct scsi_qla_host *ha = data;
5850        struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_sec_sess);
5851
5852        return qla4xxx_show_boot_tgt_info(boot_sess, type, buf);
5853}
5854
5855static umode_t qla4xxx_tgt_get_attr_visibility(void *data, int type)
5856{
5857        int rc;
5858
5859        switch (type) {
5860        case ISCSI_BOOT_TGT_NAME:
5861        case ISCSI_BOOT_TGT_IP_ADDR:
5862        case ISCSI_BOOT_TGT_PORT:
5863        case ISCSI_BOOT_TGT_CHAP_NAME:
5864        case ISCSI_BOOT_TGT_CHAP_SECRET:
5865        case ISCSI_BOOT_TGT_REV_CHAP_NAME:
5866        case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
5867        case ISCSI_BOOT_TGT_NIC_ASSOC:
5868        case ISCSI_BOOT_TGT_FLAGS:
5869                rc = S_IRUGO;
5870                break;
5871        default:
5872                rc = 0;
5873                break;
5874        }
5875        return rc;
5876}
5877
5878static void qla4xxx_boot_release(void *data)
5879{
5880        struct scsi_qla_host *ha = data;
5881
5882        scsi_host_put(ha->host);
5883}
5884
5885static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[])
5886{
5887        dma_addr_t buf_dma;
5888        uint32_t addr, pri_addr, sec_addr;
5889        uint32_t offset;
5890        uint16_t func_num;
5891        uint8_t val;
5892        uint8_t *buf = NULL;
5893        size_t size = 13 * sizeof(uint8_t);
5894        int ret = QLA_SUCCESS;
5895
5896        func_num = PCI_FUNC(ha->pdev->devfn);
5897
5898        ql4_printk(KERN_INFO, ha, "%s: Get FW boot info for 0x%x func %d\n",
5899                   __func__, ha->pdev->device, func_num);
5900
5901        if (is_qla40XX(ha)) {
5902                if (func_num == 1) {
5903                        addr = NVRAM_PORT0_BOOT_MODE;
5904                        pri_addr = NVRAM_PORT0_BOOT_PRI_TGT;
5905                        sec_addr = NVRAM_PORT0_BOOT_SEC_TGT;
5906                } else if (func_num == 3) {
5907                        addr = NVRAM_PORT1_BOOT_MODE;
5908                        pri_addr = NVRAM_PORT1_BOOT_PRI_TGT;
5909                        sec_addr = NVRAM_PORT1_BOOT_SEC_TGT;
5910                } else {
5911                        ret = QLA_ERROR;
5912                        goto exit_boot_info;
5913                }
5914
5915                /* Check Boot Mode */
5916                val = rd_nvram_byte(ha, addr);
5917                if (!(val & 0x07)) {
5918                        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Adapter boot "
5919                                          "options : 0x%x\n", __func__, val));
5920                        ret = QLA_ERROR;
5921                        goto exit_boot_info;
5922                }
5923
5924                /* get primary valid target index */
5925                val = rd_nvram_byte(ha, pri_addr);
5926                if (val & BIT_7)
5927                        ddb_index[0] = (val & 0x7f);
5928
5929                /* get secondary valid target index */
5930                val = rd_nvram_byte(ha, sec_addr);
5931                if (val & BIT_7)
5932                        ddb_index[1] = (val & 0x7f);
5933
5934        } else if (is_qla80XX(ha)) {
5935                buf = dma_alloc_coherent(&ha->pdev->dev, size,
5936                                         &buf_dma, GFP_KERNEL);
5937                if (!buf) {
5938                        DEBUG2(ql4_printk(KERN_ERR, ha,
5939                                          "%s: Unable to allocate dma buffer\n",
5940                                           __func__));
5941                        ret = QLA_ERROR;
5942                        goto exit_boot_info;
5943                }
5944
5945                if (ha->port_num == 0)
5946                        offset = BOOT_PARAM_OFFSET_PORT0;
5947                else if (ha->port_num == 1)
5948                        offset = BOOT_PARAM_OFFSET_PORT1;
5949                else {
5950                        ret = QLA_ERROR;
5951                        goto exit_boot_info_free;
5952                }
5953                addr = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_iscsi_param * 4) +
5954                       offset;
5955                if (qla4xxx_get_flash(ha, buf_dma, addr,
5956                                      13 * sizeof(uint8_t)) != QLA_SUCCESS) {
5957                        DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: Get Flash"
5958                                          " failed\n", ha->host_no, __func__));
5959                        ret = QLA_ERROR;
5960                        goto exit_boot_info_free;
5961                }
5962                /* Check Boot Mode */
5963                if (!(buf[1] & 0x07)) {
5964                        DEBUG2(ql4_printk(KERN_INFO, ha, "Firmware boot options"
5965                                          " : 0x%x\n", buf[1]));
5966                        ret = QLA_ERROR;
5967                        goto exit_boot_info_free;
5968                }
5969
5970                /* get primary valid target index */
5971                if (buf[2] & BIT_7)
5972                        ddb_index[0] = buf[2] & 0x7f;
5973
5974                /* get secondary valid target index */
5975                if (buf[11] & BIT_7)
5976                        ddb_index[1] = buf[11] & 0x7f;
5977        } else {
5978                ret = QLA_ERROR;
5979                goto exit_boot_info;
5980        }
5981
5982        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary target ID %d, Secondary"
5983                          " target ID %d\n", __func__, ddb_index[0],
5984                          ddb_index[1]));
5985
5986exit_boot_info_free:
5987        dma_free_coherent(&ha->pdev->dev, size, buf, buf_dma);
5988exit_boot_info:
5989        ha->pri_ddb_idx = ddb_index[0];
5990        ha->sec_ddb_idx = ddb_index[1];
5991        return ret;
5992}
5993
5994/**
5995 * qla4xxx_get_bidi_chap - Get a BIDI CHAP user and password
5996 * @ha: pointer to adapter structure
5997 * @username: CHAP username to be returned
5998 * @password: CHAP password to be returned
5999 *
6000 * If a boot entry has BIDI CHAP enabled then we need to set the BIDI CHAP
6001 * user and password in the sysfs entry in /sys/firmware/iscsi_boot#/.
6002 * So from the CHAP cache find the first BIDI CHAP entry and set it
6003 * to the boot record in sysfs.
6004 **/
6005static int qla4xxx_get_bidi_chap(struct scsi_qla_host *ha, char *username,
6006                            char *password)
6007{
6008        int i, ret = -EINVAL;
6009        int max_chap_entries = 0;
6010        struct ql4_chap_table *chap_table;
6011
6012        if (is_qla80XX(ha))
6013                max_chap_entries = (ha->hw.flt_chap_size / 2) /
6014                                                sizeof(struct ql4_chap_table);
6015        else
6016                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
6017
6018        if (!ha->chap_list) {
6019                ql4_printk(KERN_ERR, ha, "Do not have CHAP table cache\n");
6020                return ret;
6021        }
6022
6023        mutex_lock(&ha->chap_sem);
6024        for (i = 0; i < max_chap_entries; i++) {
6025                chap_table = (struct ql4_chap_table *)ha->chap_list + i;
6026                if (chap_table->cookie !=
6027                    __constant_cpu_to_le16(CHAP_VALID_COOKIE)) {
6028                        continue;
6029                }
6030
6031                if (chap_table->flags & BIT_7) /* local */
6032                        continue;
6033
6034                if (!(chap_table->flags & BIT_6)) /* Not BIDI */
6035                        continue;
6036
6037                strlcpy(password, chap_table->secret, QL4_CHAP_MAX_SECRET_LEN);
6038                strlcpy(username, chap_table->name, QL4_CHAP_MAX_NAME_LEN);
6039                ret = 0;
6040                break;
6041        }
6042        mutex_unlock(&ha->chap_sem);
6043
6044        return ret;
6045}
6046
6047
6048static int qla4xxx_get_boot_target(struct scsi_qla_host *ha,
6049                                   struct ql4_boot_session_info *boot_sess,
6050                                   uint16_t ddb_index)
6051{
6052        struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0];
6053        struct dev_db_entry *fw_ddb_entry;
6054        dma_addr_t fw_ddb_entry_dma;
6055        uint16_t idx;
6056        uint16_t options;
6057        int ret = QLA_SUCCESS;
6058
6059        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
6060                                          &fw_ddb_entry_dma, GFP_KERNEL);
6061        if (!fw_ddb_entry) {
6062                DEBUG2(ql4_printk(KERN_ERR, ha,
6063                                  "%s: Unable to allocate dma buffer.\n",
6064                                  __func__));
6065                ret = QLA_ERROR;
6066                return ret;
6067        }
6068
6069        if (qla4xxx_bootdb_by_index(ha, fw_ddb_entry,
6070                                   fw_ddb_entry_dma, ddb_index)) {
6071                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: No Flash DDB found at "
6072                                  "index [%d]\n", __func__, ddb_index));
6073                ret = QLA_ERROR;
6074                goto exit_boot_target;
6075        }
6076
6077        /* Update target name and IP from DDB */
6078        memcpy(boot_sess->target_name, fw_ddb_entry->iscsi_name,
6079               min(sizeof(boot_sess->target_name),
6080                   sizeof(fw_ddb_entry->iscsi_name)));
6081
6082        options = le16_to_cpu(fw_ddb_entry->options);
6083        if (options & DDB_OPT_IPV6_DEVICE) {
6084                memcpy(&boot_conn->dest_ipaddr.ip_address,
6085                       &fw_ddb_entry->ip_addr[0], IPv6_ADDR_LEN);
6086        } else {
6087                boot_conn->dest_ipaddr.ip_type = 0x1;
6088                memcpy(&boot_conn->dest_ipaddr.ip_address,
6089                       &fw_ddb_entry->ip_addr[0], IP_ADDR_LEN);
6090        }
6091
6092        boot_conn->dest_port = le16_to_cpu(fw_ddb_entry->port);
6093
6094        /* update chap information */
6095        idx = __le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
6096
6097        if (BIT_7 & le16_to_cpu(fw_ddb_entry->iscsi_options))   {
6098
6099                DEBUG2(ql4_printk(KERN_INFO, ha, "Setting chap\n"));
6100
6101                ret = qla4xxx_get_chap(ha, (char *)&boot_conn->chap.
6102                                       target_chap_name,
6103                                       (char *)&boot_conn->chap.target_secret,
6104                                       idx);
6105                if (ret) {
6106                        ql4_printk(KERN_ERR, ha, "Failed to set chap\n");
6107                        ret = QLA_ERROR;
6108                        goto exit_boot_target;
6109                }
6110
6111                boot_conn->chap.target_chap_name_length = QL4_CHAP_MAX_NAME_LEN;
6112                boot_conn->chap.target_secret_length = QL4_CHAP_MAX_SECRET_LEN;
6113        }
6114
6115        if (BIT_4 & le16_to_cpu(fw_ddb_entry->iscsi_options)) {
6116
6117                DEBUG2(ql4_printk(KERN_INFO, ha, "Setting BIDI chap\n"));
6118
6119                ret = qla4xxx_get_bidi_chap(ha,
6120                                    (char *)&boot_conn->chap.intr_chap_name,
6121                                    (char *)&boot_conn->chap.intr_secret);
6122
6123                if (ret) {
6124                        ql4_printk(KERN_ERR, ha, "Failed to set BIDI chap\n");
6125                        ret = QLA_ERROR;
6126                        goto exit_boot_target;
6127                }
6128
6129                boot_conn->chap.intr_chap_name_length = QL4_CHAP_MAX_NAME_LEN;
6130                boot_conn->chap.intr_secret_length = QL4_CHAP_MAX_SECRET_LEN;
6131        }
6132
6133exit_boot_target:
6134        dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
6135                          fw_ddb_entry, fw_ddb_entry_dma);
6136        return ret;
6137}
6138
6139static int qla4xxx_get_boot_info(struct scsi_qla_host *ha)
6140{
6141        uint16_t ddb_index[2];
6142        int ret = QLA_ERROR;
6143        int rval;
6144
6145        memset(ddb_index, 0, sizeof(ddb_index));
6146        ddb_index[0] = 0xffff;
6147        ddb_index[1] = 0xffff;
6148        ret = get_fw_boot_info(ha, ddb_index);
6149        if (ret != QLA_SUCCESS) {
6150                DEBUG2(ql4_printk(KERN_INFO, ha,
6151                                "%s: No boot target configured.\n", __func__));
6152                return ret;
6153        }
6154
6155        if (ql4xdisablesysfsboot)
6156                return QLA_SUCCESS;
6157
6158        if (ddb_index[0] == 0xffff)
6159                goto sec_target;
6160
6161        rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_pri_sess),
6162                                      ddb_index[0]);
6163        if (rval != QLA_SUCCESS) {
6164                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary boot target not "
6165                                  "configured\n", __func__));
6166        } else
6167                ret = QLA_SUCCESS;
6168
6169sec_target:
6170        if (ddb_index[1] == 0xffff)
6171                goto exit_get_boot_info;
6172
6173        rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_sec_sess),
6174                                      ddb_index[1]);
6175        if (rval != QLA_SUCCESS) {
6176                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Secondary boot target not"
6177                                  " configured\n", __func__));
6178        } else
6179                ret = QLA_SUCCESS;
6180
6181exit_get_boot_info:
6182        return ret;
6183}
6184
6185static int qla4xxx_setup_boot_info(struct scsi_qla_host *ha)
6186{
6187        struct iscsi_boot_kobj *boot_kobj;
6188
6189        if (qla4xxx_get_boot_info(ha) != QLA_SUCCESS)
6190                return QLA_ERROR;
6191
6192        if (ql4xdisablesysfsboot) {
6193                ql4_printk(KERN_INFO, ha,
6194                           "%s: syfsboot disabled - driver will trigger login "
6195                           "and publish session for discovery .\n", __func__);
6196                return QLA_SUCCESS;
6197        }
6198
6199
6200        ha->boot_kset = iscsi_boot_create_host_kset(ha->host->host_no);
6201        if (!ha->boot_kset)
6202                goto kset_free;
6203
6204        if (!scsi_host_get(ha->host))
6205                goto kset_free;
6206        boot_kobj = iscsi_boot_create_target(ha->boot_kset, 0, ha,
6207                                             qla4xxx_show_boot_tgt_pri_info,
6208                                             qla4xxx_tgt_get_attr_visibility,
6209                                             qla4xxx_boot_release);
6210        if (!boot_kobj)
6211                goto put_host;
6212
6213        if (!scsi_host_get(ha->host))
6214                goto kset_free;
6215        boot_kobj = iscsi_boot_create_target(ha->boot_kset, 1, ha,
6216                                             qla4xxx_show_boot_tgt_sec_info,
6217                                             qla4xxx_tgt_get_attr_visibility,
6218                                             qla4xxx_boot_release);
6219        if (!boot_kobj)
6220                goto put_host;
6221
6222        if (!scsi_host_get(ha->host))
6223                goto kset_free;
6224        boot_kobj = iscsi_boot_create_initiator(ha->boot_kset, 0, ha,
6225                                               qla4xxx_show_boot_ini_info,
6226                                               qla4xxx_ini_get_attr_visibility,
6227                                               qla4xxx_boot_release);
6228        if (!boot_kobj)
6229                goto put_host;
6230
6231        if (!scsi_host_get(ha->host))
6232                goto kset_free;
6233        boot_kobj = iscsi_boot_create_ethernet(ha->boot_kset, 0, ha,
6234                                               qla4xxx_show_boot_eth_info,
6235                                               qla4xxx_eth_get_attr_visibility,
6236                                               qla4xxx_boot_release);
6237        if (!boot_kobj)
6238                goto put_host;
6239
6240        return QLA_SUCCESS;
6241
6242put_host:
6243        scsi_host_put(ha->host);
6244kset_free:
6245        iscsi_boot_destroy_kset(ha->boot_kset);
6246        return -ENOMEM;
6247}
6248
6249
6250static void qla4xxx_get_param_ddb(struct ddb_entry *ddb_entry,
6251                                  struct ql4_tuple_ddb *tddb)
6252{
6253        struct scsi_qla_host *ha;
6254        struct iscsi_cls_session *cls_sess;
6255        struct iscsi_cls_conn *cls_conn;
6256        struct iscsi_session *sess;
6257        struct iscsi_conn *conn;
6258
6259        DEBUG2(printk(KERN_INFO "Func: %s\n", __func__));
6260        ha = ddb_entry->ha;
6261        cls_sess = ddb_entry->sess;
6262        sess = cls_sess->dd_data;
6263        cls_conn = ddb_entry->conn;
6264        conn = cls_conn->dd_data;
6265
6266        tddb->tpgt = sess->tpgt;
6267        tddb->port = conn->persistent_port;
6268        strlcpy(tddb->iscsi_name, sess->targetname, ISCSI_NAME_SIZE);
6269        strlcpy(tddb->ip_addr, conn->persistent_address, DDB_IPADDR_LEN);
6270}
6271
6272static void qla4xxx_convert_param_ddb(struct dev_db_entry *fw_ddb_entry,
6273                                      struct ql4_tuple_ddb *tddb,
6274                                      uint8_t *flash_isid)
6275{
6276        uint16_t options = 0;
6277
6278        tddb->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
6279        memcpy(&tddb->iscsi_name[0], &fw_ddb_entry->iscsi_name[0],
6280               min(sizeof(tddb->iscsi_name), sizeof(fw_ddb_entry->iscsi_name)));
6281
6282        options = le16_to_cpu(fw_ddb_entry->options);
6283        if (options & DDB_OPT_IPV6_DEVICE)
6284                sprintf(tddb->ip_addr, "%pI6", fw_ddb_entry->ip_addr);
6285        else
6286                sprintf(tddb->ip_addr, "%pI4", fw_ddb_entry->ip_addr);
6287
6288        tddb->port = le16_to_cpu(fw_ddb_entry->port);
6289
6290        if (flash_isid == NULL)
6291                memcpy(&tddb->isid[0], &fw_ddb_entry->isid[0],
6292                       sizeof(tddb->isid));
6293        else
6294                memcpy(&tddb->isid[0], &flash_isid[0], sizeof(tddb->isid));
6295}
6296
6297static int qla4xxx_compare_tuple_ddb(struct scsi_qla_host *ha,
6298                                     struct ql4_tuple_ddb *old_tddb,
6299                                     struct ql4_tuple_ddb *new_tddb,
6300                                     uint8_t is_isid_compare)
6301{
6302        if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name))
6303                return QLA_ERROR;
6304
6305        if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr))
6306                return QLA_ERROR;
6307
6308        if (old_tddb->port != new_tddb->port)
6309                return QLA_ERROR;
6310
6311        /* For multi sessions, driver generates the ISID, so do not compare
6312         * ISID in reset path since it would be a comparison between the
6313         * driver generated ISID and firmware generated ISID. This could
6314         * lead to adding duplicated DDBs in the list as driver generated
6315         * ISID would not match firmware generated ISID.
6316         */
6317        if (is_isid_compare) {
6318                DEBUG2(ql4_printk(KERN_INFO, ha,
6319                        "%s: old ISID [%pmR] New ISID [%pmR]\n",
6320                        __func__, old_tddb->isid, new_tddb->isid));
6321
6322                if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0],
6323                           sizeof(old_tddb->isid)))
6324                        return QLA_ERROR;
6325        }
6326
6327        DEBUG2(ql4_printk(KERN_INFO, ha,
6328                          "Match Found, fw[%d,%d,%s,%s], [%d,%d,%s,%s]",
6329                          old_tddb->port, old_tddb->tpgt, old_tddb->ip_addr,
6330                          old_tddb->iscsi_name, new_tddb->port, new_tddb->tpgt,
6331                          new_tddb->ip_addr, new_tddb->iscsi_name));
6332
6333        return QLA_SUCCESS;
6334}
6335
6336static int qla4xxx_is_session_exists(struct scsi_qla_host *ha,
6337                                     struct dev_db_entry *fw_ddb_entry,
6338                                     uint32_t *index)
6339{
6340        struct ddb_entry *ddb_entry;
6341        struct ql4_tuple_ddb *fw_tddb = NULL;
6342        struct ql4_tuple_ddb *tmp_tddb = NULL;
6343        int idx;
6344        int ret = QLA_ERROR;
6345
6346        fw_tddb = vzalloc(sizeof(*fw_tddb));
6347        if (!fw_tddb) {
6348                DEBUG2(ql4_printk(KERN_WARNING, ha,
6349                                  "Memory Allocation failed.\n"));
6350                ret = QLA_SUCCESS;
6351                goto exit_check;
6352        }
6353
6354        tmp_tddb = vzalloc(sizeof(*tmp_tddb));
6355        if (!tmp_tddb) {
6356                DEBUG2(ql4_printk(KERN_WARNING, ha,
6357                                  "Memory Allocation failed.\n"));
6358                ret = QLA_SUCCESS;
6359                goto exit_check;
6360        }
6361
6362        qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL);
6363
6364        for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
6365                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
6366                if (ddb_entry == NULL)
6367                        continue;
6368
6369                qla4xxx_get_param_ddb(ddb_entry, tmp_tddb);
6370                if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, false)) {
6371                        ret = QLA_SUCCESS; /* found */
6372                        if (index != NULL)
6373                                *index = idx;
6374                        goto exit_check;
6375                }
6376        }
6377
6378exit_check:
6379        if (fw_tddb)
6380                vfree(fw_tddb);
6381        if (tmp_tddb)
6382                vfree(tmp_tddb);
6383        return ret;
6384}
6385
6386/**
6387 * qla4xxx_check_existing_isid - check if target with same isid exist
6388 *                               in target list
6389 * @list_nt: list of target
6390 * @isid: isid to check
6391 *
6392 * This routine return QLA_SUCCESS if target with same isid exist
6393 **/
6394static int qla4xxx_check_existing_isid(struct list_head *list_nt, uint8_t *isid)
6395{
6396        struct qla_ddb_index *nt_ddb_idx, *nt_ddb_idx_tmp;
6397        struct dev_db_entry *fw_ddb_entry;
6398
6399        list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6400                fw_ddb_entry = &nt_ddb_idx->fw_ddb;
6401
6402                if (memcmp(&fw_ddb_entry->isid[0], &isid[0],
6403                           sizeof(nt_ddb_idx->fw_ddb.isid)) == 0) {
6404                        return QLA_SUCCESS;
6405                }
6406        }
6407        return QLA_ERROR;
6408}
6409
6410/**
6411 * qla4xxx_update_isid - compare ddbs and updated isid
6412 * @ha: Pointer to host adapter structure.
6413 * @list_nt: list of nt target
6414 * @fw_ddb_entry: firmware ddb entry
6415 *
6416 * This routine update isid if ddbs have same iqn, same isid and
6417 * different IP addr.
6418 * Return QLA_SUCCESS if isid is updated.
6419 **/
6420static int qla4xxx_update_isid(struct scsi_qla_host *ha,
6421                               struct list_head *list_nt,
6422                               struct dev_db_entry *fw_ddb_entry)
6423{
6424        uint8_t base_value, i;
6425
6426        base_value = fw_ddb_entry->isid[1] & 0x1f;
6427        for (i = 0; i < 8; i++) {
6428                fw_ddb_entry->isid[1] = (base_value | (i << 5));
6429                if (qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid))
6430                        break;
6431        }
6432
6433        if (!qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid))
6434                return QLA_ERROR;
6435
6436        return QLA_SUCCESS;
6437}
6438
6439/**
6440 * qla4xxx_should_update_isid - check if isid need to update
6441 * @ha: Pointer to host adapter structure.
6442 * @old_tddb: ddb tuple
6443 * @new_tddb: ddb tuple
6444 *
6445 * Return QLA_SUCCESS if different IP, different PORT, same iqn,
6446 * same isid
6447 **/
6448static int qla4xxx_should_update_isid(struct scsi_qla_host *ha,
6449                                      struct ql4_tuple_ddb *old_tddb,
6450                                      struct ql4_tuple_ddb *new_tddb)
6451{
6452        if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr) == 0) {
6453                /* Same ip */
6454                if (old_tddb->port == new_tddb->port)
6455                        return QLA_ERROR;
6456        }
6457
6458        if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name))
6459                /* different iqn */
6460                return QLA_ERROR;
6461
6462        if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0],
6463                   sizeof(old_tddb->isid)))
6464                /* different isid */
6465                return QLA_ERROR;
6466
6467        return QLA_SUCCESS;
6468}
6469
6470/**
6471 * qla4xxx_is_flash_ddb_exists - check if fw_ddb_entry already exists in list_nt
6472 * @ha: Pointer to host adapter structure.
6473 * @list_nt: list of nt target.
6474 * @fw_ddb_entry: firmware ddb entry.
6475 *
6476 * This routine check if fw_ddb_entry already exists in list_nt to avoid
6477 * duplicate ddb in list_nt.
6478 * Return QLA_SUCCESS if duplicate ddb exit in list_nl.
6479 * Note: This function also update isid of DDB if required.
6480 **/
6481
6482static int qla4xxx_is_flash_ddb_exists(struct scsi_qla_host *ha,
6483                                       struct list_head *list_nt,
6484                                       struct dev_db_entry *fw_ddb_entry)
6485{
6486        struct qla_ddb_index  *nt_ddb_idx, *nt_ddb_idx_tmp;
6487        struct ql4_tuple_ddb *fw_tddb = NULL;
6488        struct ql4_tuple_ddb *tmp_tddb = NULL;
6489        int rval, ret = QLA_ERROR;
6490
6491        fw_tddb = vzalloc(sizeof(*fw_tddb));
6492        if (!fw_tddb) {
6493                DEBUG2(ql4_printk(KERN_WARNING, ha,
6494                                  "Memory Allocation failed.\n"));
6495                ret = QLA_SUCCESS;
6496                goto exit_check;
6497        }
6498
6499        tmp_tddb = vzalloc(sizeof(*tmp_tddb));
6500        if (!tmp_tddb) {
6501                DEBUG2(ql4_printk(KERN_WARNING, ha,
6502                                  "Memory Allocation failed.\n"));
6503                ret = QLA_SUCCESS;
6504                goto exit_check;
6505        }
6506
6507        qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL);
6508
6509        list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6510                qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb,
6511                                          nt_ddb_idx->flash_isid);
6512                ret = qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, true);
6513                /* found duplicate ddb */
6514                if (ret == QLA_SUCCESS)
6515                        goto exit_check;
6516        }
6517
6518        list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6519                qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb, NULL);
6520
6521                ret = qla4xxx_should_update_isid(ha, tmp_tddb, fw_tddb);
6522                if (ret == QLA_SUCCESS) {
6523                        rval = qla4xxx_update_isid(ha, list_nt, fw_ddb_entry);
6524                        if (rval == QLA_SUCCESS)
6525                                ret = QLA_ERROR;
6526                        else
6527                                ret = QLA_SUCCESS;
6528
6529                        goto exit_check;
6530                }
6531        }
6532
6533exit_check:
6534        if (fw_tddb)
6535                vfree(fw_tddb);
6536        if (tmp_tddb)
6537                vfree(tmp_tddb);
6538        return ret;
6539}
6540
6541static void qla4xxx_free_ddb_list(struct list_head *list_ddb)
6542{
6543        struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6544
6545        list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6546                list_del_init(&ddb_idx->list);
6547                vfree(ddb_idx);
6548        }
6549}
6550
6551static struct iscsi_endpoint *qla4xxx_get_ep_fwdb(struct scsi_qla_host *ha,
6552                                        struct dev_db_entry *fw_ddb_entry)
6553{
6554        struct iscsi_endpoint *ep;
6555        struct sockaddr_in *addr;
6556        struct sockaddr_in6 *addr6;
6557        struct sockaddr *t_addr;
6558        struct sockaddr_storage *dst_addr;
6559        char *ip;
6560
6561        /* TODO: need to destroy on unload iscsi_endpoint*/
6562        dst_addr = vmalloc(sizeof(*dst_addr));
6563        if (!dst_addr)
6564                return NULL;
6565
6566        if (fw_ddb_entry->options & DDB_OPT_IPV6_DEVICE) {
6567                t_addr = (struct sockaddr *)dst_addr;
6568                t_addr->sa_family = AF_INET6;
6569                addr6 = (struct sockaddr_in6 *)dst_addr;
6570                ip = (char *)&addr6->sin6_addr;
6571                memcpy(ip, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN);
6572                addr6->sin6_port = htons(le16_to_cpu(fw_ddb_entry->port));
6573
6574        } else {
6575                t_addr = (struct sockaddr *)dst_addr;
6576                t_addr->sa_family = AF_INET;
6577                addr = (struct sockaddr_in *)dst_addr;
6578                ip = (char *)&addr->sin_addr;
6579                memcpy(ip, fw_ddb_entry->ip_addr, IP_ADDR_LEN);
6580                addr->sin_port = htons(le16_to_cpu(fw_ddb_entry->port));
6581        }
6582
6583        ep = qla4xxx_ep_connect(ha->host, (struct sockaddr *)dst_addr, 0);
6584        vfree(dst_addr);
6585        return ep;
6586}
6587
6588static int qla4xxx_verify_boot_idx(struct scsi_qla_host *ha, uint16_t idx)
6589{
6590        if (ql4xdisablesysfsboot)
6591                return QLA_SUCCESS;
6592        if (idx == ha->pri_ddb_idx || idx == ha->sec_ddb_idx)
6593                return QLA_ERROR;
6594        return QLA_SUCCESS;
6595}
6596
6597static void qla4xxx_setup_flash_ddb_entry(struct scsi_qla_host *ha,
6598                                          struct ddb_entry *ddb_entry,
6599                                          uint16_t idx)
6600{
6601        uint16_t def_timeout;
6602
6603        ddb_entry->ddb_type = FLASH_DDB;
6604        ddb_entry->fw_ddb_index = INVALID_ENTRY;
6605        ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE;
6606        ddb_entry->ha = ha;
6607        ddb_entry->unblock_sess = qla4xxx_unblock_flash_ddb;
6608        ddb_entry->ddb_change = qla4xxx_flash_ddb_change;
6609        ddb_entry->chap_tbl_idx = INVALID_ENTRY;
6610
6611        atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY);
6612        atomic_set(&ddb_entry->relogin_timer, 0);
6613        atomic_set(&ddb_entry->relogin_retry_count, 0);
6614        def_timeout = le16_to_cpu(ddb_entry->fw_ddb_entry.def_timeout);
6615        ddb_entry->default_relogin_timeout =
6616                (def_timeout > LOGIN_TOV) && (def_timeout < LOGIN_TOV * 10) ?
6617                def_timeout : LOGIN_TOV;
6618        ddb_entry->default_time2wait =
6619                le16_to_cpu(ddb_entry->fw_ddb_entry.iscsi_def_time2wait);
6620
6621        if (ql4xdisablesysfsboot &&
6622            (idx == ha->pri_ddb_idx || idx == ha->sec_ddb_idx))
6623                set_bit(DF_BOOT_TGT, &ddb_entry->flags);
6624}
6625
6626static void qla4xxx_wait_for_ip_configuration(struct scsi_qla_host *ha)
6627{
6628        uint32_t idx = 0;
6629        uint32_t ip_idx[IP_ADDR_COUNT] = {0, 1, 2, 3}; /* 4 IP interfaces */
6630        uint32_t sts[MBOX_REG_COUNT];
6631        uint32_t ip_state;
6632        unsigned long wtime;
6633        int ret;
6634
6635        wtime = jiffies + (HZ * IP_CONFIG_TOV);
6636        do {
6637                for (idx = 0; idx < IP_ADDR_COUNT; idx++) {
6638                        if (ip_idx[idx] == -1)
6639                                continue;
6640
6641                        ret = qla4xxx_get_ip_state(ha, 0, ip_idx[idx], sts);
6642
6643                        if (ret == QLA_ERROR) {
6644                                ip_idx[idx] = -1;
6645                                continue;
6646                        }
6647
6648                        ip_state = (sts[1] & IP_STATE_MASK) >> IP_STATE_SHIFT;
6649
6650                        DEBUG2(ql4_printk(KERN_INFO, ha,
6651                                          "Waiting for IP state for idx = %d, state = 0x%x\n",
6652                                          ip_idx[idx], ip_state));
6653                        if (ip_state == IP_ADDRSTATE_UNCONFIGURED ||
6654                            ip_state == IP_ADDRSTATE_INVALID ||
6655                            ip_state == IP_ADDRSTATE_PREFERRED ||
6656                            ip_state == IP_ADDRSTATE_DEPRICATED ||
6657                            ip_state == IP_ADDRSTATE_DISABLING)
6658                                ip_idx[idx] = -1;
6659                }
6660
6661                /* Break if all IP states checked */
6662                if ((ip_idx[0] == -1) &&
6663                    (ip_idx[1] == -1) &&
6664                    (ip_idx[2] == -1) &&
6665                    (ip_idx[3] == -1))
6666                        break;
6667                schedule_timeout_uninterruptible(HZ);
6668        } while (time_after(wtime, jiffies));
6669}
6670
6671static int qla4xxx_cmp_fw_stentry(struct dev_db_entry *fw_ddb_entry,
6672                                  struct dev_db_entry *flash_ddb_entry)
6673{
6674        uint16_t options = 0;
6675        size_t ip_len = IP_ADDR_LEN;
6676
6677        options = le16_to_cpu(fw_ddb_entry->options);
6678        if (options & DDB_OPT_IPV6_DEVICE)
6679                ip_len = IPv6_ADDR_LEN;
6680
6681        if (memcmp(fw_ddb_entry->ip_addr, flash_ddb_entry->ip_addr, ip_len))
6682                return QLA_ERROR;
6683
6684        if (memcmp(&fw_ddb_entry->isid[0], &flash_ddb_entry->isid[0],
6685                   sizeof(fw_ddb_entry->isid)))
6686                return QLA_ERROR;
6687
6688        if (memcmp(&fw_ddb_entry->port, &flash_ddb_entry->port,
6689                   sizeof(fw_ddb_entry->port)))
6690                return QLA_ERROR;
6691
6692        return QLA_SUCCESS;
6693}
6694
6695static int qla4xxx_find_flash_st_idx(struct scsi_qla_host *ha,
6696                                     struct dev_db_entry *fw_ddb_entry,
6697                                     uint32_t fw_idx, uint32_t *flash_index)
6698{
6699        struct dev_db_entry *flash_ddb_entry;
6700        dma_addr_t flash_ddb_entry_dma;
6701        uint32_t idx = 0;
6702        int max_ddbs;
6703        int ret = QLA_ERROR, status;
6704
6705        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6706                                     MAX_DEV_DB_ENTRIES;
6707
6708        flash_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
6709                                         &flash_ddb_entry_dma);
6710        if (flash_ddb_entry == NULL || fw_ddb_entry == NULL) {
6711                ql4_printk(KERN_ERR, ha, "Out of memory\n");
6712                goto exit_find_st_idx;
6713        }
6714
6715        status = qla4xxx_flashdb_by_index(ha, flash_ddb_entry,
6716                                          flash_ddb_entry_dma, fw_idx);
6717        if (status == QLA_SUCCESS) {
6718                status = qla4xxx_cmp_fw_stentry(fw_ddb_entry, flash_ddb_entry);
6719                if (status == QLA_SUCCESS) {
6720                        *flash_index = fw_idx;
6721                        ret = QLA_SUCCESS;
6722                        goto exit_find_st_idx;
6723                }
6724        }
6725
6726        for (idx = 0; idx < max_ddbs; idx++) {
6727                status = qla4xxx_flashdb_by_index(ha, flash_ddb_entry,
6728                                                  flash_ddb_entry_dma, idx);
6729                if (status == QLA_ERROR)
6730                        continue;
6731
6732                status = qla4xxx_cmp_fw_stentry(fw_ddb_entry, flash_ddb_entry);
6733                if (status == QLA_SUCCESS) {
6734                        *flash_index = idx;
6735                        ret = QLA_SUCCESS;
6736                        goto exit_find_st_idx;
6737                }
6738        }
6739
6740        if (idx == max_ddbs)
6741                ql4_printk(KERN_ERR, ha, "Failed to find ST [%d] in flash\n",
6742                           fw_idx);
6743
6744exit_find_st_idx:
6745        if (flash_ddb_entry)
6746                dma_pool_free(ha->fw_ddb_dma_pool, flash_ddb_entry,
6747                              flash_ddb_entry_dma);
6748
6749        return ret;
6750}
6751
6752static void qla4xxx_build_st_list(struct scsi_qla_host *ha,
6753                                  struct list_head *list_st)
6754{
6755        struct qla_ddb_index  *st_ddb_idx;
6756        int max_ddbs;
6757        int fw_idx_size;
6758        struct dev_db_entry *fw_ddb_entry;
6759        dma_addr_t fw_ddb_dma;
6760        int ret;
6761        uint32_t idx = 0, next_idx = 0;
6762        uint32_t state = 0, conn_err = 0;
6763        uint32_t flash_index = -1;
6764        uint16_t conn_id = 0;
6765
6766        fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
6767                                      &fw_ddb_dma);
6768        if (fw_ddb_entry == NULL) {
6769                DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
6770                goto exit_st_list;
6771        }
6772
6773        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6774                                     MAX_DEV_DB_ENTRIES;
6775        fw_idx_size = sizeof(struct qla_ddb_index);
6776
6777        for (idx = 0; idx < max_ddbs; idx = next_idx) {
6778                ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
6779                                              NULL, &next_idx, &state,
6780                                              &conn_err, NULL, &conn_id);
6781                if (ret == QLA_ERROR)
6782                        break;
6783
6784                /* Ignore DDB if invalid state (unassigned) */
6785                if (state == DDB_DS_UNASSIGNED)
6786                        goto continue_next_st;
6787
6788                /* Check if ST, add to the list_st */
6789                if (strlen((char *) fw_ddb_entry->iscsi_name) != 0)
6790                        goto continue_next_st;
6791
6792                st_ddb_idx = vzalloc(fw_idx_size);
6793                if (!st_ddb_idx)
6794                        break;
6795
6796                ret = qla4xxx_find_flash_st_idx(ha, fw_ddb_entry, idx,
6797                                                &flash_index);
6798                if (ret == QLA_ERROR) {
6799                        ql4_printk(KERN_ERR, ha,
6800                                   "No flash entry for ST at idx [%d]\n", idx);
6801                        st_ddb_idx->flash_ddb_idx = idx;
6802                } else {
6803                        ql4_printk(KERN_INFO, ha,
6804                                   "ST at idx [%d] is stored at flash [%d]\n",
6805                                   idx, flash_index);
6806                        st_ddb_idx->flash_ddb_idx = flash_index;
6807                }
6808
6809                st_ddb_idx->fw_ddb_idx = idx;
6810
6811                list_add_tail(&st_ddb_idx->list, list_st);
6812continue_next_st:
6813                if (next_idx == 0)
6814                        break;
6815        }
6816
6817exit_st_list:
6818        if (fw_ddb_entry)
6819                dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
6820}
6821
6822/**
6823 * qla4xxx_remove_failed_ddb - Remove inactive or failed ddb from list
6824 * @ha: pointer to adapter structure
6825 * @list_ddb: List from which failed ddb to be removed
6826 *
6827 * Iterate over the list of DDBs and find and remove DDBs that are either in
6828 * no connection active state or failed state
6829 **/
6830static void qla4xxx_remove_failed_ddb(struct scsi_qla_host *ha,
6831                                      struct list_head *list_ddb)
6832{
6833        struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6834        uint32_t next_idx = 0;
6835        uint32_t state = 0, conn_err = 0;
6836        int ret;
6837
6838        list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6839                ret = qla4xxx_get_fwddb_entry(ha, ddb_idx->fw_ddb_idx,
6840                                              NULL, 0, NULL, &next_idx, &state,
6841                                              &conn_err, NULL, NULL);
6842                if (ret == QLA_ERROR)
6843                        continue;
6844
6845                if (state == DDB_DS_NO_CONNECTION_ACTIVE ||
6846                    state == DDB_DS_SESSION_FAILED) {
6847                        list_del_init(&ddb_idx->list);
6848                        vfree(ddb_idx);
6849                }
6850        }
6851}
6852
6853static void qla4xxx_update_sess_disc_idx(struct scsi_qla_host *ha,
6854                                         struct ddb_entry *ddb_entry,
6855                                         struct dev_db_entry *fw_ddb_entry)
6856{
6857        struct iscsi_cls_session *cls_sess;
6858        struct iscsi_session *sess;
6859        uint32_t max_ddbs = 0;
6860        uint16_t ddb_link = -1;
6861
6862        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6863                                     MAX_DEV_DB_ENTRIES;
6864
6865        cls_sess = ddb_entry->sess;
6866        sess = cls_sess->dd_data;
6867
6868        ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
6869        if (ddb_link < max_ddbs)
6870                sess->discovery_parent_idx = ddb_link;
6871        else
6872                sess->discovery_parent_idx = DDB_NO_LINK;
6873}
6874
6875static int qla4xxx_sess_conn_setup(struct scsi_qla_host *ha,
6876                                   struct dev_db_entry *fw_ddb_entry,
6877                                   int is_reset, uint16_t idx)
6878{
6879        struct iscsi_cls_session *cls_sess;
6880        struct iscsi_session *sess;
6881        struct iscsi_cls_conn *cls_conn;
6882        struct iscsi_endpoint *ep;
6883        uint16_t cmds_max = 32;
6884        uint16_t conn_id = 0;
6885        uint32_t initial_cmdsn = 0;
6886        int ret = QLA_SUCCESS;
6887
6888        struct ddb_entry *ddb_entry = NULL;
6889
6890        /* Create session object, with INVALID_ENTRY,
6891         * the targer_id would get set when we issue the login
6892         */
6893        cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, ha->host,
6894                                       cmds_max, sizeof(struct ddb_entry),
6895                                       sizeof(struct ql4_task_data),
6896                                       initial_cmdsn, INVALID_ENTRY);
6897        if (!cls_sess) {
6898                ret = QLA_ERROR;
6899                goto exit_setup;
6900        }
6901
6902        /*
6903         * so calling module_put function to decrement the
6904         * reference count.
6905         **/
6906        module_put(qla4xxx_iscsi_transport.owner);
6907        sess = cls_sess->dd_data;
6908        ddb_entry = sess->dd_data;
6909        ddb_entry->sess = cls_sess;
6910
6911        cls_sess->recovery_tmo = ql4xsess_recovery_tmo;
6912        memcpy(&ddb_entry->fw_ddb_entry, fw_ddb_entry,
6913               sizeof(struct dev_db_entry));
6914
6915        qla4xxx_setup_flash_ddb_entry(ha, ddb_entry, idx);
6916
6917        cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn), conn_id);
6918
6919        if (!cls_conn) {
6920                ret = QLA_ERROR;
6921                goto exit_setup;
6922        }
6923
6924        ddb_entry->conn = cls_conn;
6925
6926        /* Setup ep, for displaying attributes in sysfs */
6927        ep = qla4xxx_get_ep_fwdb(ha, fw_ddb_entry);
6928        if (ep) {
6929                ep->conn = cls_conn;
6930                cls_conn->ep = ep;
6931        } else {
6932                DEBUG2(ql4_printk(KERN_ERR, ha, "Unable to get ep\n"));
6933                ret = QLA_ERROR;
6934                goto exit_setup;
6935        }
6936
6937        /* Update sess/conn params */
6938        qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn);
6939        qla4xxx_update_sess_disc_idx(ha, ddb_entry, fw_ddb_entry);
6940
6941        if (is_reset == RESET_ADAPTER) {
6942                iscsi_block_session(cls_sess);
6943                /* Use the relogin path to discover new devices
6944                 *  by short-circuting the logic of setting
6945                 *  timer to relogin - instead set the flags
6946                 *  to initiate login right away.
6947                 */
6948                set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
6949                set_bit(DF_RELOGIN, &ddb_entry->flags);
6950        }
6951
6952exit_setup:
6953        return ret;
6954}
6955
6956static void qla4xxx_update_fw_ddb_link(struct scsi_qla_host *ha,
6957                                       struct list_head *list_ddb,
6958                                       struct dev_db_entry *fw_ddb_entry)
6959{
6960        struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6961        uint16_t ddb_link;
6962
6963        ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
6964
6965        list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6966                if (ddb_idx->fw_ddb_idx == ddb_link) {
6967                        DEBUG2(ql4_printk(KERN_INFO, ha,
6968                                          "Updating NT parent idx from [%d] to [%d]\n",
6969                                          ddb_link, ddb_idx->flash_ddb_idx));
6970                        fw_ddb_entry->ddb_link =
6971                                            cpu_to_le16(ddb_idx->flash_ddb_idx);
6972                        return;
6973                }
6974        }
6975}
6976
6977static void qla4xxx_build_nt_list(struct scsi_qla_host *ha,
6978                                  struct list_head *list_nt,
6979                                  struct list_head *list_st,
6980                                  int is_reset)
6981{
6982        struct dev_db_entry *fw_ddb_entry;
6983        struct ddb_entry *ddb_entry = NULL;
6984        dma_addr_t fw_ddb_dma;
6985        int max_ddbs;
6986        int fw_idx_size;
6987        int ret;
6988        uint32_t idx = 0, next_idx = 0;
6989        uint32_t state = 0, conn_err = 0;
6990        uint32_t ddb_idx = -1;
6991        uint16_t conn_id = 0;
6992        uint16_t ddb_link = -1;
6993        struct qla_ddb_index  *nt_ddb_idx;
6994
6995        fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
6996                                      &fw_ddb_dma);
6997        if (fw_ddb_entry == NULL) {
6998                DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
6999                goto exit_nt_list;
7000        }
7001        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
7002                                     MAX_DEV_DB_ENTRIES;
7003        fw_idx_size = sizeof(struct qla_ddb_index);
7004
7005        for (idx = 0; idx < max_ddbs; idx = next_idx) {
7006                ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
7007                                              NULL, &next_idx, &state,
7008                                              &conn_err, NULL, &conn_id);
7009                if (ret == QLA_ERROR)
7010                        break;
7011
7012                if (qla4xxx_verify_boot_idx(ha, idx) != QLA_SUCCESS)
7013                        goto continue_next_nt;
7014
7015                /* Check if NT, then add to list it */
7016                if (strlen((char *) fw_ddb_entry->iscsi_name) == 0)
7017                        goto continue_next_nt;
7018
7019                ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
7020                if (ddb_link < max_ddbs)
7021                        qla4xxx_update_fw_ddb_link(ha, list_st, fw_ddb_entry);
7022
7023                if (!(state == DDB_DS_NO_CONNECTION_ACTIVE ||
7024                    state == DDB_DS_SESSION_FAILED) &&
7025                    (is_reset == INIT_ADAPTER))
7026                        goto continue_next_nt;
7027
7028                DEBUG2(ql4_printk(KERN_INFO, ha,
7029                                  "Adding  DDB to session = 0x%x\n", idx));
7030
7031                if (is_reset == INIT_ADAPTER) {
7032                        nt_ddb_idx = vmalloc(fw_idx_size);
7033                        if (!nt_ddb_idx)
7034                                break;
7035
7036                        nt_ddb_idx->fw_ddb_idx = idx;
7037
7038                        /* Copy original isid as it may get updated in function
7039                         * qla4xxx_update_isid(). We need original isid in
7040                         * function qla4xxx_compare_tuple_ddb to find duplicate
7041                         * target */
7042                        memcpy(&nt_ddb_idx->flash_isid[0],
7043                               &fw_ddb_entry->isid[0],
7044                               sizeof(nt_ddb_idx->flash_isid));
7045
7046                        ret = qla4xxx_is_flash_ddb_exists(ha, list_nt,
7047                                                          fw_ddb_entry);
7048                        if (ret == QLA_SUCCESS) {
7049                                /* free nt_ddb_idx and do not add to list_nt */
7050                                vfree(nt_ddb_idx);
7051                                goto continue_next_nt;
7052                        }
7053
7054                        /* Copy updated isid */
7055                        memcpy(&nt_ddb_idx->fw_ddb, fw_ddb_entry,
7056                               sizeof(struct dev_db_entry));
7057
7058                        list_add_tail(&nt_ddb_idx->list, list_nt);
7059                } else if (is_reset == RESET_ADAPTER) {
7060                        ret = qla4xxx_is_session_exists(ha, fw_ddb_entry,
7061                                                        &ddb_idx);
7062                        if (ret == QLA_SUCCESS) {
7063                                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha,
7064                                                                       ddb_idx);
7065                                if (ddb_entry != NULL)
7066                                        qla4xxx_update_sess_disc_idx(ha,
7067                                                                     ddb_entry,
7068                                                                  fw_ddb_entry);
7069                                goto continue_next_nt;
7070                        }
7071                }
7072
7073                ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, is_reset, idx);
7074                if (ret == QLA_ERROR)
7075                        goto exit_nt_list;
7076
7077continue_next_nt:
7078                if (next_idx == 0)
7079                        break;
7080        }
7081
7082exit_nt_list:
7083        if (fw_ddb_entry)
7084                dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7085}
7086
7087static void qla4xxx_build_new_nt_list(struct scsi_qla_host *ha,
7088                                      struct list_head *list_nt,
7089                                      uint16_t target_id)
7090{
7091        struct dev_db_entry *fw_ddb_entry;
7092        dma_addr_t fw_ddb_dma;
7093        int max_ddbs;
7094        int fw_idx_size;
7095        int ret;
7096        uint32_t idx = 0, next_idx = 0;
7097        uint32_t state = 0, conn_err = 0;
7098        uint16_t conn_id = 0;
7099        struct qla_ddb_index  *nt_ddb_idx;
7100
7101        fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
7102                                      &fw_ddb_dma);
7103        if (fw_ddb_entry == NULL) {
7104                DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
7105                goto exit_new_nt_list;
7106        }
7107        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
7108                                     MAX_DEV_DB_ENTRIES;
7109        fw_idx_size = sizeof(struct qla_ddb_index);
7110
7111        for (idx = 0; idx < max_ddbs; idx = next_idx) {
7112                ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
7113                                              NULL, &next_idx, &state,
7114                                              &conn_err, NULL, &conn_id);
7115                if (ret == QLA_ERROR)
7116                        break;
7117
7118                /* Check if NT, then add it to list */
7119                if (strlen((char *)fw_ddb_entry->iscsi_name) == 0)
7120                        goto continue_next_new_nt;
7121
7122                if (!(state == DDB_DS_NO_CONNECTION_ACTIVE))
7123                        goto continue_next_new_nt;
7124
7125                DEBUG2(ql4_printk(KERN_INFO, ha,
7126                                  "Adding  DDB to session = 0x%x\n", idx));
7127
7128                nt_ddb_idx = vmalloc(fw_idx_size);
7129                if (!nt_ddb_idx)
7130                        break;
7131
7132                nt_ddb_idx->fw_ddb_idx = idx;
7133
7134                ret = qla4xxx_is_session_exists(ha, fw_ddb_entry, NULL);
7135                if (ret == QLA_SUCCESS) {
7136                        /* free nt_ddb_idx and do not add to list_nt */
7137                        vfree(nt_ddb_idx);
7138                        goto continue_next_new_nt;
7139                }
7140
7141                if (target_id < max_ddbs)
7142                        fw_ddb_entry->ddb_link = cpu_to_le16(target_id);
7143
7144                list_add_tail(&nt_ddb_idx->list, list_nt);
7145
7146                ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, RESET_ADAPTER,
7147                                              idx);
7148                if (ret == QLA_ERROR)
7149                        goto exit_new_nt_list;
7150
7151continue_next_new_nt:
7152                if (next_idx == 0)
7153                        break;
7154        }
7155
7156exit_new_nt_list:
7157        if (fw_ddb_entry)
7158                dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7159}
7160
7161/**
7162 * qla4xxx_sysfs_ddb_is_non_persistent - check for non-persistence of ddb entry
7163 * @dev: dev associated with the sysfs entry
7164 * @data: pointer to flashnode session object
7165 *
7166 * Returns:
7167 *      1: if flashnode entry is non-persistent
7168 *      0: if flashnode entry is persistent
7169 **/
7170static int qla4xxx_sysfs_ddb_is_non_persistent(struct device *dev, void *data)
7171{
7172        struct iscsi_bus_flash_session *fnode_sess;
7173
7174        if (!iscsi_flashnode_bus_match(dev, NULL))
7175                return 0;
7176
7177        fnode_sess = iscsi_dev_to_flash_session(dev);
7178
7179        return (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT);
7180}
7181
7182/**
7183 * qla4xxx_sysfs_ddb_tgt_create - Create sysfs entry for target
7184 * @ha: pointer to host
7185 * @fw_ddb_entry: flash ddb data
7186 * @idx: target index
7187 * @user: if set then this call is made from userland else from kernel
7188 *
7189 * Returns:
7190 * On sucess: QLA_SUCCESS
7191 * On failure: QLA_ERROR
7192 *
7193 * This create separate sysfs entries for session and connection attributes of
7194 * the given fw ddb entry.
7195 * If this is invoked as a result of a userspace call then the entry is marked
7196 * as nonpersistent using flash_state field.
7197 **/
7198static int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
7199                                        struct dev_db_entry *fw_ddb_entry,
7200                                        uint16_t *idx, int user)
7201{
7202        struct iscsi_bus_flash_session *fnode_sess = NULL;
7203        struct iscsi_bus_flash_conn *fnode_conn = NULL;
7204        int rc = QLA_ERROR;
7205
7206        fnode_sess = iscsi_create_flashnode_sess(ha->host, *idx,
7207                                                 &qla4xxx_iscsi_transport, 0);
7208        if (!fnode_sess) {
7209                ql4_printk(KERN_ERR, ha,
7210                           "%s: Unable to create session sysfs entry for flashnode %d of host%lu\n",
7211                           __func__, *idx, ha->host_no);
7212                goto exit_tgt_create;
7213        }
7214
7215        fnode_conn = iscsi_create_flashnode_conn(ha->host, fnode_sess,
7216                                                 &qla4xxx_iscsi_transport, 0);
7217        if (!fnode_conn) {
7218                ql4_printk(KERN_ERR, ha,
7219                           "%s: Unable to create conn sysfs entry for flashnode %d of host%lu\n",
7220                           __func__, *idx, ha->host_no);
7221                goto free_sess;
7222        }
7223
7224        if (user) {
7225                fnode_sess->flash_state = DEV_DB_NON_PERSISTENT;
7226        } else {
7227                fnode_sess->flash_state = DEV_DB_PERSISTENT;
7228
7229                if (*idx == ha->pri_ddb_idx || *idx == ha->sec_ddb_idx)
7230                        fnode_sess->is_boot_target = 1;
7231                else
7232                        fnode_sess->is_boot_target = 0;
7233        }
7234
7235        rc = qla4xxx_copy_from_fwddb_param(fnode_sess, fnode_conn,
7236                                           fw_ddb_entry);
7237        if (rc)
7238                goto free_sess;
7239
7240        ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
7241                   __func__, fnode_sess->dev.kobj.name);
7242
7243        ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
7244                   __func__, fnode_conn->dev.kobj.name);
7245
7246        return QLA_SUCCESS;
7247
7248free_sess:
7249        iscsi_destroy_flashnode_sess(fnode_sess);
7250
7251exit_tgt_create:
7252        return QLA_ERROR;
7253}
7254
7255/**
7256 * qla4xxx_sysfs_ddb_add - Add new ddb entry in flash
7257 * @shost: pointer to host
7258 * @buf: type of ddb entry (ipv4/ipv6)
7259 * @len: length of buf
7260 *
7261 * This creates new ddb entry in the flash by finding first free index and
7262 * storing default ddb there. And then create sysfs entry for the new ddb entry.
7263 **/
7264static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
7265                                 int len)
7266{
7267        struct scsi_qla_host *ha = to_qla_host(shost);
7268        struct dev_db_entry *fw_ddb_entry = NULL;
7269        dma_addr_t fw_ddb_entry_dma;
7270        struct device *dev;
7271        uint16_t idx = 0;
7272        uint16_t max_ddbs = 0;
7273        uint32_t options = 0;
7274        uint32_t rval = QLA_ERROR;
7275
7276        if (strncasecmp(PORTAL_TYPE_IPV4, buf, 4) &&
7277            strncasecmp(PORTAL_TYPE_IPV6, buf, 4)) {
7278                DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Invalid portal type\n",
7279                                  __func__));
7280                goto exit_ddb_add;
7281        }
7282
7283        max_ddbs =  is_qla40XX(ha) ? MAX_PRST_DEV_DB_ENTRIES :
7284                                     MAX_DEV_DB_ENTRIES;
7285
7286        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7287                                          &fw_ddb_entry_dma, GFP_KERNEL);
7288        if (!fw_ddb_entry) {
7289                DEBUG2(ql4_printk(KERN_ERR, ha,
7290                                  "%s: Unable to allocate dma buffer\n",
7291                                  __func__));
7292                goto exit_ddb_add;
7293        }
7294
7295        dev = iscsi_find_flashnode_sess(ha->host, NULL,
7296                                        qla4xxx_sysfs_ddb_is_non_persistent);
7297        if (dev) {
7298                ql4_printk(KERN_ERR, ha,
7299                           "%s: A non-persistent entry %s found\n",
7300                           __func__, dev->kobj.name);
7301                put_device(dev);
7302                goto exit_ddb_add;
7303        }
7304
7305        /* Index 0 and 1 are reserved for boot target entries */
7306        for (idx = 2; idx < max_ddbs; idx++) {
7307                if (qla4xxx_flashdb_by_index(ha, fw_ddb_entry,
7308                                             fw_ddb_entry_dma, idx))
7309                        break;
7310        }
7311
7312        if (idx == max_ddbs)
7313                goto exit_ddb_add;
7314
7315        if (!strncasecmp("ipv6", buf, 4))
7316                options |= IPV6_DEFAULT_DDB_ENTRY;
7317
7318        rval = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7319        if (rval == QLA_ERROR)
7320                goto exit_ddb_add;
7321
7322        rval = qla4xxx_sysfs_ddb_tgt_create(ha, fw_ddb_entry, &idx, 1);
7323
7324exit_ddb_add:
7325        if (fw_ddb_entry)
7326                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7327                                  fw_ddb_entry, fw_ddb_entry_dma);
7328        if (rval == QLA_SUCCESS)
7329                return idx;
7330        else
7331                return -EIO;
7332}
7333
7334/**
7335 * qla4xxx_sysfs_ddb_apply - write the target ddb contents to Flash
7336 * @fnode_sess: pointer to session attrs of flash ddb entry
7337 * @fnode_conn: pointer to connection attrs of flash ddb entry
7338 *
7339 * This writes the contents of target ddb buffer to Flash with a valid cookie
7340 * value in order to make the ddb entry persistent.
7341 **/
7342static int  qla4xxx_sysfs_ddb_apply(struct iscsi_bus_flash_session *fnode_sess,
7343                                    struct iscsi_bus_flash_conn *fnode_conn)
7344{
7345        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7346        struct scsi_qla_host *ha = to_qla_host(shost);
7347        uint32_t dev_db_start_offset = FLASH_OFFSET_DB_INFO;
7348        struct dev_db_entry *fw_ddb_entry = NULL;
7349        dma_addr_t fw_ddb_entry_dma;
7350        uint32_t options = 0;
7351        int rval = 0;
7352
7353        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7354                                          &fw_ddb_entry_dma, GFP_KERNEL);
7355        if (!fw_ddb_entry) {
7356                DEBUG2(ql4_printk(KERN_ERR, ha,
7357                                  "%s: Unable to allocate dma buffer\n",
7358                                  __func__));
7359                rval = -ENOMEM;
7360                goto exit_ddb_apply;
7361        }
7362
7363        if (!strncasecmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7364                options |= IPV6_DEFAULT_DDB_ENTRY;
7365
7366        rval = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7367        if (rval == QLA_ERROR)
7368                goto exit_ddb_apply;
7369
7370        dev_db_start_offset += (fnode_sess->target_id *
7371                                sizeof(*fw_ddb_entry));
7372
7373        qla4xxx_copy_to_fwddb_param(fnode_sess, fnode_conn, fw_ddb_entry);
7374        fw_ddb_entry->cookie = DDB_VALID_COOKIE;
7375
7376        rval = qla4xxx_set_flash(ha, fw_ddb_entry_dma, dev_db_start_offset,
7377                                 sizeof(*fw_ddb_entry), FLASH_OPT_RMW_COMMIT);
7378
7379        if (rval == QLA_SUCCESS) {
7380                fnode_sess->flash_state = DEV_DB_PERSISTENT;
7381                ql4_printk(KERN_INFO, ha,
7382                           "%s: flash node %u of host %lu written to flash\n",
7383                           __func__, fnode_sess->target_id, ha->host_no);
7384        } else {
7385                rval = -EIO;
7386                ql4_printk(KERN_ERR, ha,
7387                           "%s: Error while writing flash node %u of host %lu to flash\n",
7388                           __func__, fnode_sess->target_id, ha->host_no);
7389        }
7390
7391exit_ddb_apply:
7392        if (fw_ddb_entry)
7393                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7394                                  fw_ddb_entry, fw_ddb_entry_dma);
7395        return rval;
7396}
7397
7398static ssize_t qla4xxx_sysfs_ddb_conn_open(struct scsi_qla_host *ha,
7399                                           struct dev_db_entry *fw_ddb_entry,
7400                                           uint16_t idx)
7401{
7402        struct dev_db_entry *ddb_entry = NULL;
7403        dma_addr_t ddb_entry_dma;
7404        unsigned long wtime;
7405        uint32_t mbx_sts = 0;
7406        uint32_t state = 0, conn_err = 0;
7407        uint16_t tmo = 0;
7408        int ret = 0;
7409
7410        ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*ddb_entry),
7411                                       &ddb_entry_dma, GFP_KERNEL);
7412        if (!ddb_entry) {
7413                DEBUG2(ql4_printk(KERN_ERR, ha,
7414                                  "%s: Unable to allocate dma buffer\n",
7415                                  __func__));
7416                return QLA_ERROR;
7417        }
7418
7419        memcpy(ddb_entry, fw_ddb_entry, sizeof(*ddb_entry));
7420
7421        ret = qla4xxx_set_ddb_entry(ha, idx, ddb_entry_dma, &mbx_sts);
7422        if (ret != QLA_SUCCESS) {
7423                DEBUG2(ql4_printk(KERN_ERR, ha,
7424                                  "%s: Unable to set ddb entry for index %d\n",
7425                                  __func__, idx));
7426                goto exit_ddb_conn_open;
7427        }
7428
7429        qla4xxx_conn_open(ha, idx);
7430
7431        /* To ensure that sendtargets is done, wait for at least 12 secs */
7432        tmo = ((ha->def_timeout > LOGIN_TOV) &&
7433               (ha->def_timeout < LOGIN_TOV * 10) ?
7434               ha->def_timeout : LOGIN_TOV);
7435
7436        DEBUG2(ql4_printk(KERN_INFO, ha,
7437                          "Default time to wait for login to ddb %d\n", tmo));
7438
7439        wtime = jiffies + (HZ * tmo);
7440        do {
7441                ret = qla4xxx_get_fwddb_entry(ha, idx, NULL, 0, NULL,
7442                                              NULL, &state, &conn_err, NULL,
7443                                              NULL);
7444                if (ret == QLA_ERROR)
7445                        continue;
7446
7447                if (state == DDB_DS_NO_CONNECTION_ACTIVE ||
7448                    state == DDB_DS_SESSION_FAILED)
7449                        break;
7450
7451                schedule_timeout_uninterruptible(HZ / 10);
7452        } while (time_after(wtime, jiffies));
7453
7454exit_ddb_conn_open:
7455        if (ddb_entry)
7456                dma_free_coherent(&ha->pdev->dev, sizeof(*ddb_entry),
7457                                  ddb_entry, ddb_entry_dma);
7458        return ret;
7459}
7460
7461static int qla4xxx_ddb_login_st(struct scsi_qla_host *ha,
7462                                struct dev_db_entry *fw_ddb_entry,
7463                                uint16_t target_id)
7464{
7465        struct qla_ddb_index *ddb_idx, *ddb_idx_tmp;
7466        struct list_head list_nt;
7467        uint16_t ddb_index;
7468        int ret = 0;
7469
7470        if (test_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags)) {
7471                ql4_printk(KERN_WARNING, ha,
7472                           "%s: A discovery already in progress!\n", __func__);
7473                return QLA_ERROR;
7474        }
7475
7476        INIT_LIST_HEAD(&list_nt);
7477
7478        set_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags);
7479
7480        ret = qla4xxx_get_ddb_index(ha, &ddb_index);
7481        if (ret == QLA_ERROR)
7482                goto exit_login_st_clr_bit;
7483
7484        ret = qla4xxx_sysfs_ddb_conn_open(ha, fw_ddb_entry, ddb_index);
7485        if (ret == QLA_ERROR)
7486                goto exit_login_st;
7487
7488        qla4xxx_build_new_nt_list(ha, &list_nt, target_id);
7489
7490        list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, &list_nt, list) {
7491                list_del_init(&ddb_idx->list);
7492                qla4xxx_clear_ddb_entry(ha, ddb_idx->fw_ddb_idx);
7493                vfree(ddb_idx);
7494        }
7495
7496exit_login_st:
7497        if (qla4xxx_clear_ddb_entry(ha, ddb_index) == QLA_ERROR) {
7498                ql4_printk(KERN_ERR, ha,
7499                           "Unable to clear DDB index = 0x%x\n", ddb_index);
7500        }
7501
7502        clear_bit(ddb_index, ha->ddb_idx_map);
7503
7504exit_login_st_clr_bit:
7505        clear_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags);
7506        return ret;
7507}
7508
7509static int qla4xxx_ddb_login_nt(struct scsi_qla_host *ha,
7510                                struct dev_db_entry *fw_ddb_entry,
7511                                uint16_t idx)
7512{
7513        int ret = QLA_ERROR;
7514
7515        ret = qla4xxx_is_session_exists(ha, fw_ddb_entry, NULL);
7516        if (ret != QLA_SUCCESS)
7517                ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, RESET_ADAPTER,
7518                                              idx);
7519        else
7520                ret = -EPERM;
7521
7522        return ret;
7523}
7524
7525/**
7526 * qla4xxx_sysfs_ddb_login - Login to the specified target
7527 * @fnode_sess: pointer to session attrs of flash ddb entry
7528 * @fnode_conn: pointer to connection attrs of flash ddb entry
7529 *
7530 * This logs in to the specified target
7531 **/
7532static int qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session *fnode_sess,
7533                                   struct iscsi_bus_flash_conn *fnode_conn)
7534{
7535        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7536        struct scsi_qla_host *ha = to_qla_host(shost);
7537        struct dev_db_entry *fw_ddb_entry = NULL;
7538        dma_addr_t fw_ddb_entry_dma;
7539        uint32_t options = 0;
7540        int ret = 0;
7541
7542        if (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT) {
7543                ql4_printk(KERN_ERR, ha,
7544                           "%s: Target info is not persistent\n", __func__);
7545                ret = -EIO;
7546                goto exit_ddb_login;
7547        }
7548
7549        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7550                                          &fw_ddb_entry_dma, GFP_KERNEL);
7551        if (!fw_ddb_entry) {
7552                DEBUG2(ql4_printk(KERN_ERR, ha,
7553                                  "%s: Unable to allocate dma buffer\n",
7554                                  __func__));
7555                ret = -ENOMEM;
7556                goto exit_ddb_login;
7557        }
7558
7559        if (!strncasecmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7560                options |= IPV6_DEFAULT_DDB_ENTRY;
7561
7562        ret = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7563        if (ret == QLA_ERROR)
7564                goto exit_ddb_login;
7565
7566        qla4xxx_copy_to_fwddb_param(fnode_sess, fnode_conn, fw_ddb_entry);
7567        fw_ddb_entry->cookie = DDB_VALID_COOKIE;
7568
7569        if (strlen((char *)fw_ddb_entry->iscsi_name) == 0)
7570                ret = qla4xxx_ddb_login_st(ha, fw_ddb_entry,
7571                                           fnode_sess->target_id);
7572        else
7573                ret = qla4xxx_ddb_login_nt(ha, fw_ddb_entry,
7574                                           fnode_sess->target_id);
7575
7576        if (ret > 0)
7577                ret = -EIO;
7578
7579exit_ddb_login:
7580        if (fw_ddb_entry)
7581                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7582                                  fw_ddb_entry, fw_ddb_entry_dma);
7583        return ret;
7584}
7585
7586/**
7587 * qla4xxx_sysfs_ddb_logout_sid - Logout session for the specified target
7588 * @cls_sess: pointer to session to be logged out
7589 *
7590 * This performs session log out from the specified target
7591 **/
7592static int qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session *cls_sess)
7593{
7594        struct iscsi_session *sess;
7595        struct ddb_entry *ddb_entry = NULL;
7596        struct scsi_qla_host *ha;
7597        struct dev_db_entry *fw_ddb_entry = NULL;
7598        dma_addr_t fw_ddb_entry_dma;
7599        unsigned long flags;
7600        unsigned long wtime;
7601        uint32_t ddb_state;
7602        int options;
7603        int ret = 0;
7604
7605        sess = cls_sess->dd_data;
7606        ddb_entry = sess->dd_data;
7607        ha = ddb_entry->ha;
7608
7609        if (ddb_entry->ddb_type != FLASH_DDB) {
7610                ql4_printk(KERN_ERR, ha, "%s: Not a flash node session\n",
7611                           __func__);
7612                ret = -ENXIO;
7613                goto exit_ddb_logout;
7614        }
7615
7616        if (test_bit(DF_BOOT_TGT, &ddb_entry->flags)) {
7617                ql4_printk(KERN_ERR, ha,
7618                           "%s: Logout from boot target entry is not permitted.\n",
7619                           __func__);
7620                ret = -EPERM;
7621                goto exit_ddb_logout;
7622        }
7623
7624        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7625                                          &fw_ddb_entry_dma, GFP_KERNEL);
7626        if (!fw_ddb_entry) {
7627                ql4_printk(KERN_ERR, ha,
7628                           "%s: Unable to allocate dma buffer\n", __func__);
7629                ret = -ENOMEM;
7630                goto exit_ddb_logout;
7631        }
7632
7633        if (test_and_set_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags))
7634                goto ddb_logout_init;
7635
7636        ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
7637                                      fw_ddb_entry, fw_ddb_entry_dma,
7638                                      NULL, NULL, &ddb_state, NULL,
7639                                      NULL, NULL);
7640        if (ret == QLA_ERROR)
7641                goto ddb_logout_init;
7642
7643        if (ddb_state == DDB_DS_SESSION_ACTIVE)
7644                goto ddb_logout_init;
7645
7646        /* wait until next relogin is triggered using DF_RELOGIN and
7647         * clear DF_RELOGIN to avoid invocation of further relogin
7648         */
7649        wtime = jiffies + (HZ * RELOGIN_TOV);
7650        do {
7651                if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags))
7652                        goto ddb_logout_init;
7653
7654                schedule_timeout_uninterruptible(HZ);
7655        } while ((time_after(wtime, jiffies)));
7656
7657ddb_logout_init:
7658        atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY);
7659        atomic_set(&ddb_entry->relogin_timer, 0);
7660
7661        options = LOGOUT_OPTION_CLOSE_SESSION;
7662        qla4xxx_session_logout_ddb(ha, ddb_entry, options);
7663
7664        memset(fw_ddb_entry, 0, sizeof(*fw_ddb_entry));
7665        wtime = jiffies + (HZ * LOGOUT_TOV);
7666        do {
7667                ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
7668                                              fw_ddb_entry, fw_ddb_entry_dma,
7669                                              NULL, NULL, &ddb_state, NULL,
7670                                              NULL, NULL);
7671                if (ret == QLA_ERROR)
7672                        goto ddb_logout_clr_sess;
7673
7674                if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
7675                    (ddb_state == DDB_DS_SESSION_FAILED))
7676                        goto ddb_logout_clr_sess;
7677
7678                schedule_timeout_uninterruptible(HZ);
7679        } while ((time_after(wtime, jiffies)));
7680
7681ddb_logout_clr_sess:
7682        qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
7683        /*
7684         * we have decremented the reference count of the driver
7685         * when we setup the session to have the driver unload
7686         * to be seamless without actually destroying the
7687         * session
7688         **/
7689        try_module_get(qla4xxx_iscsi_transport.owner);
7690        iscsi_destroy_endpoint(ddb_entry->conn->ep);
7691
7692        spin_lock_irqsave(&ha->hardware_lock, flags);
7693        qla4xxx_free_ddb(ha, ddb_entry);
7694        clear_bit(ddb_entry->fw_ddb_index, ha->ddb_idx_map);
7695        spin_unlock_irqrestore(&ha->hardware_lock, flags);
7696
7697        iscsi_session_teardown(ddb_entry->sess);
7698
7699        clear_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags);
7700        ret = QLA_SUCCESS;
7701
7702exit_ddb_logout:
7703        if (fw_ddb_entry)
7704                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7705                                  fw_ddb_entry, fw_ddb_entry_dma);
7706        return ret;
7707}
7708
7709/**
7710 * qla4xxx_sysfs_ddb_logout - Logout from the specified target
7711 * @fnode_sess: pointer to session attrs of flash ddb entry
7712 * @fnode_conn: pointer to connection attrs of flash ddb entry
7713 *
7714 * This performs log out from the specified target
7715 **/
7716static int qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session *fnode_sess,
7717                                    struct iscsi_bus_flash_conn *fnode_conn)
7718{
7719        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7720        struct scsi_qla_host *ha = to_qla_host(shost);
7721        struct ql4_tuple_ddb *flash_tddb = NULL;
7722        struct ql4_tuple_ddb *tmp_tddb = NULL;
7723        struct dev_db_entry *fw_ddb_entry = NULL;
7724        struct ddb_entry *ddb_entry = NULL;
7725        dma_addr_t fw_ddb_dma;
7726        uint32_t next_idx = 0;
7727        uint32_t state = 0, conn_err = 0;
7728        uint16_t conn_id = 0;
7729        int idx, index;
7730        int status, ret = 0;
7731
7732        fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
7733                                      &fw_ddb_dma);
7734        if (fw_ddb_entry == NULL) {
7735                ql4_printk(KERN_ERR, ha, "%s:Out of memory\n", __func__);
7736                ret = -ENOMEM;
7737                goto exit_ddb_logout;
7738        }
7739
7740        flash_tddb = vzalloc(sizeof(*flash_tddb));
7741        if (!flash_tddb) {
7742                ql4_printk(KERN_WARNING, ha,
7743                           "%s:Memory Allocation failed.\n", __func__);
7744                ret = -ENOMEM;
7745                goto exit_ddb_logout;
7746        }
7747
7748        tmp_tddb = vzalloc(sizeof(*tmp_tddb));
7749        if (!tmp_tddb) {
7750                ql4_printk(KERN_WARNING, ha,
7751                           "%s:Memory Allocation failed.\n", __func__);
7752                ret = -ENOMEM;
7753                goto exit_ddb_logout;
7754        }
7755
7756        if (!fnode_sess->targetname) {
7757                ql4_printk(KERN_ERR, ha,
7758                           "%s:Cannot logout from SendTarget entry\n",
7759                           __func__);
7760                ret = -EPERM;
7761                goto exit_ddb_logout;
7762        }
7763
7764        if (fnode_sess->is_boot_target) {
7765                ql4_printk(KERN_ERR, ha,
7766                           "%s: Logout from boot target entry is not permitted.\n",
7767                           __func__);
7768                ret = -EPERM;
7769                goto exit_ddb_logout;
7770        }
7771
7772        strlcpy(flash_tddb->iscsi_name, fnode_sess->targetname,
7773                ISCSI_NAME_SIZE);
7774
7775        if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7776                sprintf(flash_tddb->ip_addr, "%pI6", fnode_conn->ipaddress);
7777        else
7778                sprintf(flash_tddb->ip_addr, "%pI4", fnode_conn->ipaddress);
7779
7780        flash_tddb->tpgt = fnode_sess->tpgt;
7781        flash_tddb->port = fnode_conn->port;
7782
7783        COPY_ISID(flash_tddb->isid, fnode_sess->isid);
7784
7785        for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
7786                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
7787                if (ddb_entry == NULL)
7788                        continue;
7789
7790                if (ddb_entry->ddb_type != FLASH_DDB)
7791                        continue;
7792
7793                index = ddb_entry->sess->target_id;
7794                status = qla4xxx_get_fwddb_entry(ha, index, fw_ddb_entry,
7795                                                 fw_ddb_dma, NULL, &next_idx,
7796                                                 &state, &conn_err, NULL,
7797                                                 &conn_id);
7798                if (status == QLA_ERROR) {
7799                        ret = -ENOMEM;
7800                        break;
7801                }
7802
7803                qla4xxx_convert_param_ddb(fw_ddb_entry, tmp_tddb, NULL);
7804
7805                status = qla4xxx_compare_tuple_ddb(ha, flash_tddb, tmp_tddb,
7806                                                   true);
7807                if (status == QLA_SUCCESS) {
7808                        ret = qla4xxx_sysfs_ddb_logout_sid(ddb_entry->sess);
7809                        break;
7810                }
7811        }
7812
7813        if (idx == MAX_DDB_ENTRIES)
7814                ret = -ESRCH;
7815
7816exit_ddb_logout:
7817        if (flash_tddb)
7818                vfree(flash_tddb);
7819        if (tmp_tddb)
7820                vfree(tmp_tddb);
7821        if (fw_ddb_entry)
7822                dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7823
7824        return ret;
7825}
7826
7827static int
7828qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
7829                            int param, char *buf)
7830{
7831        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7832        struct scsi_qla_host *ha = to_qla_host(shost);
7833        struct iscsi_bus_flash_conn *fnode_conn;
7834        struct ql4_chap_table chap_tbl;
7835        struct device *dev;
7836        int parent_type;
7837        int rc = 0;
7838
7839        dev = iscsi_find_flashnode_conn(fnode_sess);
7840        if (!dev)
7841                return -EIO;
7842
7843        fnode_conn = iscsi_dev_to_flash_conn(dev);
7844
7845        switch (param) {
7846        case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
7847                rc = sprintf(buf, "%u\n", fnode_conn->is_fw_assigned_ipv6);
7848                break;
7849        case ISCSI_FLASHNODE_PORTAL_TYPE:
7850                rc = sprintf(buf, "%s\n", fnode_sess->portal_type);
7851                break;
7852        case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
7853                rc = sprintf(buf, "%u\n", fnode_sess->auto_snd_tgt_disable);
7854                break;
7855        case ISCSI_FLASHNODE_DISCOVERY_SESS:
7856                rc = sprintf(buf, "%u\n", fnode_sess->discovery_sess);
7857                break;
7858        case ISCSI_FLASHNODE_ENTRY_EN:
7859                rc = sprintf(buf, "%u\n", fnode_sess->entry_state);
7860                break;
7861        case ISCSI_FLASHNODE_HDR_DGST_EN:
7862                rc = sprintf(buf, "%u\n", fnode_conn->hdrdgst_en);
7863                break;
7864        case ISCSI_FLASHNODE_DATA_DGST_EN:
7865                rc = sprintf(buf, "%u\n", fnode_conn->datadgst_en);
7866                break;
7867        case ISCSI_FLASHNODE_IMM_DATA_EN:
7868                rc = sprintf(buf, "%u\n", fnode_sess->imm_data_en);
7869                break;
7870        case ISCSI_FLASHNODE_INITIAL_R2T_EN:
7871                rc = sprintf(buf, "%u\n", fnode_sess->initial_r2t_en);
7872                break;
7873        case ISCSI_FLASHNODE_DATASEQ_INORDER:
7874                rc = sprintf(buf, "%u\n", fnode_sess->dataseq_inorder_en);
7875                break;
7876        case ISCSI_FLASHNODE_PDU_INORDER:
7877                rc = sprintf(buf, "%u\n", fnode_sess->pdu_inorder_en);
7878                break;
7879        case ISCSI_FLASHNODE_CHAP_AUTH_EN:
7880                rc = sprintf(buf, "%u\n", fnode_sess->chap_auth_en);
7881                break;
7882        case ISCSI_FLASHNODE_SNACK_REQ_EN:
7883                rc = sprintf(buf, "%u\n", fnode_conn->snack_req_en);
7884                break;
7885        case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
7886                rc = sprintf(buf, "%u\n", fnode_sess->discovery_logout_en);
7887                break;
7888        case ISCSI_FLASHNODE_BIDI_CHAP_EN:
7889                rc = sprintf(buf, "%u\n", fnode_sess->bidi_chap_en);
7890                break;
7891        case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
7892                rc = sprintf(buf, "%u\n", fnode_sess->discovery_auth_optional);
7893                break;
7894        case ISCSI_FLASHNODE_ERL:
7895                rc = sprintf(buf, "%u\n", fnode_sess->erl);
7896                break;
7897        case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
7898                rc = sprintf(buf, "%u\n", fnode_conn->tcp_timestamp_stat);
7899                break;
7900        case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
7901                rc = sprintf(buf, "%u\n", fnode_conn->tcp_nagle_disable);
7902                break;
7903        case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
7904                rc = sprintf(buf, "%u\n", fnode_conn->tcp_wsf_disable);
7905                break;
7906        case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
7907                rc = sprintf(buf, "%u\n", fnode_conn->tcp_timer_scale);
7908                break;
7909        case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
7910                rc = sprintf(buf, "%u\n", fnode_conn->tcp_timestamp_en);
7911                break;
7912        case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
7913                rc = sprintf(buf, "%u\n", fnode_conn->fragment_disable);
7914                break;
7915        case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
7916                rc = sprintf(buf, "%u\n", fnode_conn->max_recv_dlength);
7917                break;
7918        case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
7919                rc = sprintf(buf, "%u\n", fnode_conn->max_xmit_dlength);
7920                break;
7921        case ISCSI_FLASHNODE_FIRST_BURST:
7922                rc = sprintf(buf, "%u\n", fnode_sess->first_burst);
7923                break;
7924        case ISCSI_FLASHNODE_DEF_TIME2WAIT:
7925                rc = sprintf(buf, "%u\n", fnode_sess->time2wait);
7926                break;
7927        case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
7928                rc = sprintf(buf, "%u\n", fnode_sess->time2retain);
7929                break;
7930        case ISCSI_FLASHNODE_MAX_R2T:
7931                rc = sprintf(buf, "%u\n", fnode_sess->max_r2t);
7932                break;
7933        case ISCSI_FLASHNODE_KEEPALIVE_TMO:
7934                rc = sprintf(buf, "%u\n", fnode_conn->keepalive_timeout);
7935                break;
7936        case ISCSI_FLASHNODE_ISID:
7937                rc = sprintf(buf, "%pm\n", fnode_sess->isid);
7938                break;
7939        case ISCSI_FLASHNODE_TSID:
7940                rc = sprintf(buf, "%u\n", fnode_sess->tsid);
7941                break;
7942        case ISCSI_FLASHNODE_PORT:
7943                rc = sprintf(buf, "%d\n", fnode_conn->port);
7944                break;
7945        case ISCSI_FLASHNODE_MAX_BURST:
7946                rc = sprintf(buf, "%u\n", fnode_sess->max_burst);
7947                break;
7948        case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
7949                rc = sprintf(buf, "%u\n",
7950                             fnode_sess->default_taskmgmt_timeout);
7951                break;
7952        case ISCSI_FLASHNODE_IPADDR:
7953                if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7954                        rc = sprintf(buf, "%pI6\n", fnode_conn->ipaddress);
7955                else
7956                        rc = sprintf(buf, "%pI4\n", fnode_conn->ipaddress);
7957                break;
7958        case ISCSI_FLASHNODE_ALIAS:
7959                if (fnode_sess->targetalias)
7960                        rc = sprintf(buf, "%s\n", fnode_sess->targetalias);
7961                else
7962                        rc = sprintf(buf, "\n");
7963                break;
7964        case ISCSI_FLASHNODE_REDIRECT_IPADDR:
7965                if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7966                        rc = sprintf(buf, "%pI6\n",
7967                                     fnode_conn->redirect_ipaddr);
7968                else
7969                        rc = sprintf(buf, "%pI4\n",
7970                                     fnode_conn->redirect_ipaddr);
7971                break;
7972        case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
7973                rc = sprintf(buf, "%u\n", fnode_conn->max_segment_size);
7974                break;
7975        case ISCSI_FLASHNODE_LOCAL_PORT:
7976                rc = sprintf(buf, "%u\n", fnode_conn->local_port);
7977                break;
7978        case ISCSI_FLASHNODE_IPV4_TOS:
7979                rc = sprintf(buf, "%u\n", fnode_conn->ipv4_tos);
7980                break;
7981        case ISCSI_FLASHNODE_IPV6_TC:
7982                if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7983                        rc = sprintf(buf, "%u\n",
7984                                     fnode_conn->ipv6_traffic_class);
7985                else
7986                        rc = sprintf(buf, "\n");
7987                break;
7988        case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
7989                rc = sprintf(buf, "%u\n", fnode_conn->ipv6_flow_label);
7990                break;
7991        case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
7992                if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7993                        rc = sprintf(buf, "%pI6\n",
7994                                     fnode_conn->link_local_ipv6_addr);
7995                else
7996                        rc = sprintf(buf, "\n");
7997                break;
7998        case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
7999                rc = sprintf(buf, "%u\n", fnode_sess->discovery_parent_idx);
8000                break;
8001        case ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE:
8002                if (fnode_sess->discovery_parent_type == DDB_ISNS)
8003                        parent_type = ISCSI_DISC_PARENT_ISNS;
8004                else if (fnode_sess->discovery_parent_type == DDB_NO_LINK)
8005                        parent_type = ISCSI_DISC_PARENT_UNKNOWN;
8006                else if (fnode_sess->discovery_parent_type < MAX_DDB_ENTRIES)
8007                        parent_type = ISCSI_DISC_PARENT_SENDTGT;
8008                else
8009                        parent_type = ISCSI_DISC_PARENT_UNKNOWN;
8010
8011                rc = sprintf(buf, "%s\n",
8012                             iscsi_get_discovery_parent_name(parent_type));
8013                break;
8014        case ISCSI_FLASHNODE_NAME:
8015                if (fnode_sess->targetname)
8016                        rc = sprintf(buf, "%s\n", fnode_sess->targetname);
8017                else
8018                        rc = sprintf(buf, "\n");
8019                break;
8020        case ISCSI_FLASHNODE_TPGT:
8021                rc = sprintf(buf, "%u\n", fnode_sess->tpgt);
8022                break;
8023        case ISCSI_FLASHNODE_TCP_XMIT_WSF:
8024                rc = sprintf(buf, "%u\n", fnode_conn->tcp_xmit_wsf);
8025                break;
8026        case ISCSI_FLASHNODE_TCP_RECV_WSF:
8027                rc = sprintf(buf, "%u\n", fnode_conn->tcp_recv_wsf);
8028                break;
8029        case ISCSI_FLASHNODE_CHAP_OUT_IDX:
8030                rc = sprintf(buf, "%u\n", fnode_sess->chap_out_idx);
8031                break;
8032        case ISCSI_FLASHNODE_USERNAME:
8033                if (fnode_sess->chap_auth_en) {
8034                        qla4xxx_get_uni_chap_at_index(ha,
8035                                                      chap_tbl.name,
8036                                                      chap_tbl.secret,
8037                                                      fnode_sess->chap_out_idx);
8038                        rc = sprintf(buf, "%s\n", chap_tbl.name);
8039                } else {
8040                        rc = sprintf(buf, "\n");
8041                }
8042                break;
8043        case ISCSI_FLASHNODE_PASSWORD:
8044                if (fnode_sess->chap_auth_en) {
8045                        qla4xxx_get_uni_chap_at_index(ha,
8046                                                      chap_tbl.name,
8047                                                      chap_tbl.secret,
8048                                                      fnode_sess->chap_out_idx);
8049                        rc = sprintf(buf, "%s\n", chap_tbl.secret);
8050                } else {
8051                        rc = sprintf(buf, "\n");
8052                }
8053                break;
8054        case ISCSI_FLASHNODE_STATSN:
8055                rc = sprintf(buf, "%u\n", fnode_conn->statsn);
8056                break;
8057        case ISCSI_FLASHNODE_EXP_STATSN:
8058                rc = sprintf(buf, "%u\n", fnode_conn->exp_statsn);
8059                break;
8060        case ISCSI_FLASHNODE_IS_BOOT_TGT:
8061                rc = sprintf(buf, "%u\n", fnode_sess->is_boot_target);
8062                break;
8063        default:
8064                rc = -ENOSYS;
8065                break;
8066        }
8067
8068        put_device(dev);
8069        return rc;
8070}
8071
8072/**
8073 * qla4xxx_sysfs_ddb_set_param - Set parameter for firmware DDB entry
8074 * @fnode_sess: pointer to session attrs of flash ddb entry
8075 * @fnode_conn: pointer to connection attrs of flash ddb entry
8076 * @data: Parameters and their values to update
8077 * @len: len of data
8078 *
8079 * This sets the parameter of flash ddb entry and writes them to flash
8080 **/
8081static int
8082qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
8083                            struct iscsi_bus_flash_conn *fnode_conn,
8084                            void *data, int len)
8085{
8086        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
8087        struct scsi_qla_host *ha = to_qla_host(shost);
8088        struct iscsi_flashnode_param_info *fnode_param;
8089        struct ql4_chap_table chap_tbl;
8090        struct nlattr *attr;
8091        uint16_t chap_out_idx = INVALID_ENTRY;
8092        int rc = QLA_ERROR;
8093        uint32_t rem = len;
8094
8095        memset((void *)&chap_tbl, 0, sizeof(chap_tbl));
8096        nla_for_each_attr(attr, data, len, rem) {
8097                fnode_param = nla_data(attr);
8098
8099                switch (fnode_param->param) {
8100                case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
8101                        fnode_conn->is_fw_assigned_ipv6 = fnode_param->value[0];
8102                        break;
8103                case ISCSI_FLASHNODE_PORTAL_TYPE:
8104                        memcpy(fnode_sess->portal_type, fnode_param->value,
8105                               strlen(fnode_sess->portal_type));
8106                        break;
8107                case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
8108                        fnode_sess->auto_snd_tgt_disable =
8109                                                        fnode_param->value[0];
8110                        break;
8111                case ISCSI_FLASHNODE_DISCOVERY_SESS:
8112                        fnode_sess->discovery_sess = fnode_param->value[0];
8113                        break;
8114                case ISCSI_FLASHNODE_ENTRY_EN:
8115                        fnode_sess->entry_state = fnode_param->value[0];
8116                        break;
8117                case ISCSI_FLASHNODE_HDR_DGST_EN:
8118                        fnode_conn->hdrdgst_en = fnode_param->value[0];
8119                        break;
8120                case ISCSI_FLASHNODE_DATA_DGST_EN:
8121                        fnode_conn->datadgst_en = fnode_param->value[0];
8122                        break;
8123                case ISCSI_FLASHNODE_IMM_DATA_EN:
8124                        fnode_sess->imm_data_en = fnode_param->value[0];
8125                        break;
8126                case ISCSI_FLASHNODE_INITIAL_R2T_EN:
8127                        fnode_sess->initial_r2t_en = fnode_param->value[0];
8128                        break;
8129                case ISCSI_FLASHNODE_DATASEQ_INORDER:
8130                        fnode_sess->dataseq_inorder_en = fnode_param->value[0];
8131                        break;
8132                case ISCSI_FLASHNODE_PDU_INORDER:
8133                        fnode_sess->pdu_inorder_en = fnode_param->value[0];
8134                        break;
8135                case ISCSI_FLASHNODE_CHAP_AUTH_EN:
8136                        fnode_sess->chap_auth_en = fnode_param->value[0];
8137                        /* Invalidate chap index if chap auth is disabled */
8138                        if (!fnode_sess->chap_auth_en)
8139                                fnode_sess->chap_out_idx = INVALID_ENTRY;
8140
8141                        break;
8142                case ISCSI_FLASHNODE_SNACK_REQ_EN:
8143                        fnode_conn->snack_req_en = fnode_param->value[0];
8144                        break;
8145                case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
8146                        fnode_sess->discovery_logout_en = fnode_param->value[0];
8147                        break;
8148                case ISCSI_FLASHNODE_BIDI_CHAP_EN:
8149                        fnode_sess->bidi_chap_en = fnode_param->value[0];
8150                        break;
8151                case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
8152                        fnode_sess->discovery_auth_optional =
8153                                                        fnode_param->value[0];
8154                        break;
8155                case ISCSI_FLASHNODE_ERL:
8156                        fnode_sess->erl = fnode_param->value[0];
8157                        break;
8158                case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
8159                        fnode_conn->tcp_timestamp_stat = fnode_param->value[0];
8160                        break;
8161                case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
8162                        fnode_conn->tcp_nagle_disable = fnode_param->value[0];
8163                        break;
8164                case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
8165                        fnode_conn->tcp_wsf_disable = fnode_param->value[0];
8166                        break;
8167                case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
8168                        fnode_conn->tcp_timer_scale = fnode_param->value[0];
8169                        break;
8170                case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
8171                        fnode_conn->tcp_timestamp_en = fnode_param->value[0];
8172                        break;
8173                case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
8174                        fnode_conn->fragment_disable = fnode_param->value[0];
8175                        break;
8176                case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
8177                        fnode_conn->max_recv_dlength =
8178                                        *(unsigned *)fnode_param->value;
8179                        break;
8180                case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
8181                        fnode_conn->max_xmit_dlength =
8182                                        *(unsigned *)fnode_param->value;
8183                        break;
8184                case ISCSI_FLASHNODE_FIRST_BURST:
8185                        fnode_sess->first_burst =
8186                                        *(unsigned *)fnode_param->value;
8187                        break;
8188                case ISCSI_FLASHNODE_DEF_TIME2WAIT:
8189                        fnode_sess->time2wait = *(uint16_t *)fnode_param->value;
8190                        break;
8191                case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
8192                        fnode_sess->time2retain =
8193                                                *(uint16_t *)fnode_param->value;
8194                        break;
8195                case ISCSI_FLASHNODE_MAX_R2T:
8196                        fnode_sess->max_r2t =
8197                                        *(uint16_t *)fnode_param->value;
8198                        break;
8199                case ISCSI_FLASHNODE_KEEPALIVE_TMO:
8200                        fnode_conn->keepalive_timeout =
8201                                *(uint16_t *)fnode_param->value;
8202                        break;
8203                case ISCSI_FLASHNODE_ISID:
8204                        memcpy(fnode_sess->isid, fnode_param->value,
8205                               sizeof(fnode_sess->isid));
8206                        break;
8207                case ISCSI_FLASHNODE_TSID:
8208                        fnode_sess->tsid = *(uint16_t *)fnode_param->value;
8209                        break;
8210                case ISCSI_FLASHNODE_PORT:
8211                        fnode_conn->port = *(uint16_t *)fnode_param->value;
8212                        break;
8213                case ISCSI_FLASHNODE_MAX_BURST:
8214                        fnode_sess->max_burst = *(unsigned *)fnode_param->value;
8215                        break;
8216                case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
8217                        fnode_sess->default_taskmgmt_timeout =
8218                                                *(uint16_t *)fnode_param->value;
8219                        break;
8220                case ISCSI_FLASHNODE_IPADDR:
8221                        memcpy(fnode_conn->ipaddress, fnode_param->value,
8222                               IPv6_ADDR_LEN);
8223                        break;
8224                case ISCSI_FLASHNODE_ALIAS:
8225                        rc = iscsi_switch_str_param(&fnode_sess->targetalias,
8226                                                    (char *)fnode_param->value);
8227                        break;
8228                case ISCSI_FLASHNODE_REDIRECT_IPADDR:
8229                        memcpy(fnode_conn->redirect_ipaddr, fnode_param->value,
8230                               IPv6_ADDR_LEN);
8231                        break;
8232                case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
8233                        fnode_conn->max_segment_size =
8234                                        *(unsigned *)fnode_param->value;
8235                        break;
8236                case ISCSI_FLASHNODE_LOCAL_PORT:
8237                        fnode_conn->local_port =
8238                                                *(uint16_t *)fnode_param->value;
8239                        break;
8240                case ISCSI_FLASHNODE_IPV4_TOS:
8241                        fnode_conn->ipv4_tos = fnode_param->value[0];
8242                        break;
8243                case ISCSI_FLASHNODE_IPV6_TC:
8244                        fnode_conn->ipv6_traffic_class = fnode_param->value[0];
8245                        break;
8246                case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
8247                        fnode_conn->ipv6_flow_label = fnode_param->value[0];
8248                        break;
8249                case ISCSI_FLASHNODE_NAME:
8250                        rc = iscsi_switch_str_param(&fnode_sess->targetname,
8251                                                    (char *)fnode_param->value);
8252                        break;
8253                case ISCSI_FLASHNODE_TPGT:
8254                        fnode_sess->tpgt = *(uint16_t *)fnode_param->value;
8255                        break;
8256                case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
8257                        memcpy(fnode_conn->link_local_ipv6_addr,
8258                               fnode_param->value, IPv6_ADDR_LEN);
8259                        break;
8260                case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
8261                        fnode_sess->discovery_parent_idx =
8262                                                *(uint16_t *)fnode_param->value;
8263                        break;
8264                case ISCSI_FLASHNODE_TCP_XMIT_WSF:
8265                        fnode_conn->tcp_xmit_wsf =
8266                                                *(uint8_t *)fnode_param->value;
8267                        break;
8268                case ISCSI_FLASHNODE_TCP_RECV_WSF:
8269                        fnode_conn->tcp_recv_wsf =
8270                                                *(uint8_t *)fnode_param->value;
8271                        break;
8272                case ISCSI_FLASHNODE_STATSN:
8273                        fnode_conn->statsn = *(uint32_t *)fnode_param->value;
8274                        break;
8275                case ISCSI_FLASHNODE_EXP_STATSN:
8276                        fnode_conn->exp_statsn =
8277                                                *(uint32_t *)fnode_param->value;
8278                        break;
8279                case ISCSI_FLASHNODE_CHAP_OUT_IDX:
8280                        chap_out_idx = *(uint16_t *)fnode_param->value;
8281                        if (!qla4xxx_get_uni_chap_at_index(ha,
8282                                                           chap_tbl.name,
8283                                                           chap_tbl.secret,
8284                                                           chap_out_idx)) {
8285                                fnode_sess->chap_out_idx = chap_out_idx;
8286                                /* Enable chap auth if chap index is valid */
8287                                fnode_sess->chap_auth_en = QL4_PARAM_ENABLE;
8288                        }
8289                        break;
8290                default:
8291                        ql4_printk(KERN_ERR, ha,
8292                                   "%s: No such sysfs attribute\n", __func__);
8293                        rc = -ENOSYS;
8294                        goto exit_set_param;
8295                }
8296        }
8297
8298        rc = qla4xxx_sysfs_ddb_apply(fnode_sess, fnode_conn);
8299
8300exit_set_param:
8301        return rc;
8302}
8303
8304/**
8305 * qla4xxx_sysfs_ddb_delete - Delete firmware DDB entry
8306 * @fnode_sess: pointer to session attrs of flash ddb entry
8307 *
8308 * This invalidates the flash ddb entry at the given index
8309 **/
8310static int qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess)
8311{
8312        struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
8313        struct scsi_qla_host *ha = to_qla_host(shost);
8314        uint32_t dev_db_start_offset;
8315        uint32_t dev_db_end_offset;
8316        struct dev_db_entry *fw_ddb_entry = NULL;
8317        dma_addr_t fw_ddb_entry_dma;
8318        uint16_t *ddb_cookie = NULL;
8319        size_t ddb_size = 0;
8320        void *pddb = NULL;
8321        int target_id;
8322        int rc = 0;
8323
8324        if (fnode_sess->is_boot_target) {
8325                rc = -EPERM;
8326                DEBUG2(ql4_printk(KERN_ERR, ha,
8327                                  "%s: Deletion of boot target entry is not permitted.\n",
8328                                  __func__));
8329                goto exit_ddb_del;
8330        }
8331
8332        if (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT)
8333                goto sysfs_ddb_del;
8334
8335        if (is_qla40XX(ha)) {
8336                dev_db_start_offset = FLASH_OFFSET_DB_INFO;
8337                dev_db_end_offset = FLASH_OFFSET_DB_END;
8338                dev_db_start_offset += (fnode_sess->target_id *
8339                                       sizeof(*fw_ddb_entry));
8340                ddb_size = sizeof(*fw_ddb_entry);
8341        } else {
8342                dev_db_start_offset = FLASH_RAW_ACCESS_ADDR +
8343                                      (ha->hw.flt_region_ddb << 2);
8344                /* flt_ddb_size is DDB table size for both ports
8345                 * so divide it by 2 to calculate the offset for second port
8346                 */
8347                if (ha->port_num == 1)
8348                        dev_db_start_offset += (ha->hw.flt_ddb_size / 2);
8349
8350                dev_db_end_offset = dev_db_start_offset +
8351                                    (ha->hw.flt_ddb_size / 2);
8352
8353                dev_db_start_offset += (fnode_sess->target_id *
8354                                       sizeof(*fw_ddb_entry));
8355                dev_db_start_offset += offsetof(struct dev_db_entry, cookie);
8356
8357                ddb_size = sizeof(*ddb_cookie);
8358        }
8359
8360        DEBUG2(ql4_printk(KERN_ERR, ha, "%s: start offset=%u, end offset=%u\n",
8361                          __func__, dev_db_start_offset, dev_db_end_offset));
8362
8363        if (dev_db_start_offset > dev_db_end_offset) {
8364                rc = -EIO;
8365                DEBUG2(ql4_printk(KERN_ERR, ha, "%s:Invalid DDB index %u\n",
8366                                  __func__, fnode_sess->target_id));
8367                goto exit_ddb_del;
8368        }
8369
8370        pddb = dma_alloc_coherent(&ha->pdev->dev, ddb_size,
8371                                  &fw_ddb_entry_dma, GFP_KERNEL);
8372        if (!pddb) {
8373                rc = -ENOMEM;
8374                DEBUG2(ql4_printk(KERN_ERR, ha,
8375                                  "%s: Unable to allocate dma buffer\n",
8376                                  __func__));
8377                goto exit_ddb_del;
8378        }
8379
8380        if (is_qla40XX(ha)) {
8381                fw_ddb_entry = pddb;
8382                memset(fw_ddb_entry, 0, ddb_size);
8383                ddb_cookie = &fw_ddb_entry->cookie;
8384        } else {
8385                ddb_cookie = pddb;
8386        }
8387
8388        /* invalidate the cookie */
8389        *ddb_cookie = 0xFFEE;
8390        qla4xxx_set_flash(ha, fw_ddb_entry_dma, dev_db_start_offset,
8391                          ddb_size, FLASH_OPT_RMW_COMMIT);
8392
8393sysfs_ddb_del:
8394        target_id = fnode_sess->target_id;
8395        iscsi_destroy_flashnode_sess(fnode_sess);
8396        ql4_printk(KERN_INFO, ha,
8397                   "%s: session and conn entries for flashnode %u of host %lu deleted\n",
8398                   __func__, target_id, ha->host_no);
8399exit_ddb_del:
8400        if (pddb)
8401                dma_free_coherent(&ha->pdev->dev, ddb_size, pddb,
8402                                  fw_ddb_entry_dma);
8403        return rc;
8404}
8405
8406/**
8407 * qla4xxx_sysfs_ddb_export - Create sysfs entries for firmware DDBs
8408 * @ha: pointer to adapter structure
8409 *
8410 * Export the firmware DDB for all send targets and normal targets to sysfs.
8411 **/
8412int qla4xxx_sysfs_ddb_export(struct scsi_qla_host *ha)
8413{
8414        struct dev_db_entry *fw_ddb_entry = NULL;
8415        dma_addr_t fw_ddb_entry_dma;
8416        uint16_t max_ddbs;
8417        uint16_t idx = 0;
8418        int ret = QLA_SUCCESS;
8419
8420        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev,
8421                                          sizeof(*fw_ddb_entry),
8422                                          &fw_ddb_entry_dma, GFP_KERNEL);
8423        if (!fw_ddb_entry) {
8424                DEBUG2(ql4_printk(KERN_ERR, ha,
8425                                  "%s: Unable to allocate dma buffer\n",
8426                                  __func__));
8427                return -ENOMEM;
8428        }
8429
8430        max_ddbs =  is_qla40XX(ha) ? MAX_PRST_DEV_DB_ENTRIES :
8431                                     MAX_DEV_DB_ENTRIES;
8432
8433        for (idx = 0; idx < max_ddbs; idx++) {
8434                if (qla4xxx_flashdb_by_index(ha, fw_ddb_entry, fw_ddb_entry_dma,
8435                                             idx))
8436                        continue;
8437
8438                ret = qla4xxx_sysfs_ddb_tgt_create(ha, fw_ddb_entry, &idx, 0);
8439                if (ret) {
8440                        ret = -EIO;
8441                        break;
8442                }
8443        }
8444
8445        dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), fw_ddb_entry,
8446                          fw_ddb_entry_dma);
8447
8448        return ret;
8449}
8450
8451static void qla4xxx_sysfs_ddb_remove(struct scsi_qla_host *ha)
8452{
8453        iscsi_destroy_all_flashnode(ha->host);
8454}
8455
8456/**
8457 * qla4xxx_build_ddb_list - Build ddb list and setup sessions
8458 * @ha: pointer to adapter structure
8459 * @is_reset: Is this init path or reset path
8460 *
8461 * Create a list of sendtargets (st) from firmware DDBs, issue send targets
8462 * using connection open, then create the list of normal targets (nt)
8463 * from firmware DDBs. Based on the list of nt setup session and connection
8464 * objects.
8465 **/
8466void qla4xxx_build_ddb_list(struct scsi_qla_host *ha, int is_reset)
8467{
8468        uint16_t tmo = 0;
8469        struct list_head list_st, list_nt;
8470        struct qla_ddb_index  *st_ddb_idx, *st_ddb_idx_tmp;
8471        unsigned long wtime;
8472
8473        if (!test_bit(AF_LINK_UP, &ha->flags)) {
8474                set_bit(AF_BUILD_DDB_LIST, &ha->flags);
8475                ha->is_reset = is_reset;
8476                return;
8477        }
8478
8479        INIT_LIST_HEAD(&list_st);
8480        INIT_LIST_HEAD(&list_nt);
8481
8482        qla4xxx_build_st_list(ha, &list_st);
8483
8484        /* Before issuing conn open mbox, ensure all IPs states are configured
8485         * Note, conn open fails if IPs are not configured
8486         */
8487        qla4xxx_wait_for_ip_configuration(ha);
8488
8489        /* Go thru the STs and fire the sendtargets by issuing conn open mbx */
8490        list_for_each_entry_safe(st_ddb_idx, st_ddb_idx_tmp, &list_st, list) {
8491                qla4xxx_conn_open(ha, st_ddb_idx->fw_ddb_idx);
8492        }
8493
8494        /* Wait to ensure all sendtargets are done for min 12 sec wait */
8495        tmo = ((ha->def_timeout > LOGIN_TOV) &&
8496               (ha->def_timeout < LOGIN_TOV * 10) ?
8497               ha->def_timeout : LOGIN_TOV);
8498
8499        DEBUG2(ql4_printk(KERN_INFO, ha,
8500                          "Default time to wait for build ddb %d\n", tmo));
8501
8502        wtime = jiffies + (HZ * tmo);
8503        do {
8504                if (list_empty(&list_st))
8505                        break;
8506
8507                qla4xxx_remove_failed_ddb(ha, &list_st);
8508                schedule_timeout_uninterruptible(HZ / 10);
8509        } while (time_after(wtime, jiffies));
8510
8511
8512        qla4xxx_build_nt_list(ha, &list_nt, &list_st, is_reset);
8513
8514        qla4xxx_free_ddb_list(&list_st);
8515        qla4xxx_free_ddb_list(&list_nt);
8516
8517        qla4xxx_free_ddb_index(ha);
8518}
8519
8520/**
8521 * qla4xxx_wait_login_resp_boot_tgt -  Wait for iSCSI boot target login
8522 * response.
8523 * @ha: pointer to adapter structure
8524 *
8525 * When the boot entry is normal iSCSI target then DF_BOOT_TGT flag will be
8526 * set in DDB and we will wait for login response of boot targets during
8527 * probe.
8528 **/
8529static void qla4xxx_wait_login_resp_boot_tgt(struct scsi_qla_host *ha)
8530{
8531        struct ddb_entry *ddb_entry;
8532        struct dev_db_entry *fw_ddb_entry = NULL;
8533        dma_addr_t fw_ddb_entry_dma;
8534        unsigned long wtime;
8535        uint32_t ddb_state;
8536        int max_ddbs, idx, ret;
8537
8538        max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
8539                                     MAX_DEV_DB_ENTRIES;
8540
8541        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8542                                          &fw_ddb_entry_dma, GFP_KERNEL);
8543        if (!fw_ddb_entry) {
8544                ql4_printk(KERN_ERR, ha,
8545                           "%s: Unable to allocate dma buffer\n", __func__);
8546                goto exit_login_resp;
8547        }
8548
8549        wtime = jiffies + (HZ * BOOT_LOGIN_RESP_TOV);
8550
8551        for (idx = 0; idx < max_ddbs; idx++) {
8552                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
8553                if (ddb_entry == NULL)
8554                        continue;
8555
8556                if (test_bit(DF_BOOT_TGT, &ddb_entry->flags)) {
8557                        DEBUG2(ql4_printk(KERN_INFO, ha,
8558                                          "%s: DDB index [%d]\n", __func__,
8559                                          ddb_entry->fw_ddb_index));
8560                        do {
8561                                ret = qla4xxx_get_fwddb_entry(ha,
8562                                                ddb_entry->fw_ddb_index,
8563                                                fw_ddb_entry, fw_ddb_entry_dma,
8564                                                NULL, NULL, &ddb_state, NULL,
8565                                                NULL, NULL);
8566                                if (ret == QLA_ERROR)
8567                                        goto exit_login_resp;
8568
8569                                if ((ddb_state == DDB_DS_SESSION_ACTIVE) ||
8570                                    (ddb_state == DDB_DS_SESSION_FAILED))
8571                                        break;
8572
8573                                schedule_timeout_uninterruptible(HZ);
8574
8575                        } while ((time_after(wtime, jiffies)));
8576
8577                        if (!time_after(wtime, jiffies)) {
8578                                DEBUG2(ql4_printk(KERN_INFO, ha,
8579                                                  "%s: Login response wait timer expired\n",
8580                                                  __func__));
8581                                 goto exit_login_resp;
8582                        }
8583                }
8584        }
8585
8586exit_login_resp:
8587        if (fw_ddb_entry)
8588                dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8589                                  fw_ddb_entry, fw_ddb_entry_dma);
8590}
8591
8592/**
8593 * qla4xxx_probe_adapter - callback function to probe HBA
8594 * @pdev: pointer to pci_dev structure
8595 * @pci_device_id: pointer to pci_device entry
8596 *
8597 * This routine will probe for Qlogic 4xxx iSCSI host adapters.
8598 * It returns zero if successful. It also initializes all data necessary for
8599 * the driver.
8600 **/
8601static int qla4xxx_probe_adapter(struct pci_dev *pdev,
8602                                 const struct pci_device_id *ent)
8603{
8604        int ret = -ENODEV, status;
8605        struct Scsi_Host *host;
8606        struct scsi_qla_host *ha;
8607        uint8_t init_retry_count = 0;
8608        char buf[34];
8609        struct qla4_8xxx_legacy_intr_set *nx_legacy_intr;
8610        uint32_t dev_state;
8611
8612        if (pci_enable_device(pdev))
8613                return -1;
8614
8615        host = iscsi_host_alloc(&qla4xxx_driver_template, sizeof(*ha), 0);
8616        if (host == NULL) {
8617                printk(KERN_WARNING
8618                       "qla4xxx: Couldn't allocate host from scsi layer!\n");
8619                goto probe_disable_device;
8620        }
8621
8622        /* Clear our data area */
8623        ha = to_qla_host(host);
8624        memset(ha, 0, sizeof(*ha));
8625
8626        /* Save the information from PCI BIOS.  */
8627        ha->pdev = pdev;
8628        ha->host = host;
8629        ha->host_no = host->host_no;
8630        ha->func_num = PCI_FUNC(ha->pdev->devfn);
8631
8632        pci_enable_pcie_error_reporting(pdev);
8633
8634        /* Setup Runtime configurable options */
8635        if (is_qla8022(ha)) {
8636                ha->isp_ops = &qla4_82xx_isp_ops;
8637                ha->reg_tbl = (uint32_t *) qla4_82xx_reg_tbl;
8638                ha->qdr_sn_window = -1;
8639                ha->ddr_mn_window = -1;
8640                ha->curr_window = 255;
8641                nx_legacy_intr = &legacy_intr[ha->func_num];
8642                ha->nx_legacy_intr.int_vec_bit = nx_legacy_intr->int_vec_bit;
8643                ha->nx_legacy_intr.tgt_status_reg =
8644                        nx_legacy_intr->tgt_status_reg;
8645                ha->nx_legacy_intr.tgt_mask_reg = nx_legacy_intr->tgt_mask_reg;
8646                ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg;
8647        } else if (is_qla8032(ha) || is_qla8042(ha)) {
8648                ha->isp_ops = &qla4_83xx_isp_ops;
8649                ha->reg_tbl = (uint32_t *)qla4_83xx_reg_tbl;
8650        } else {
8651                ha->isp_ops = &qla4xxx_isp_ops;
8652        }
8653
8654        if (is_qla80XX(ha)) {
8655                rwlock_init(&ha->hw_lock);
8656                ha->pf_bit = ha->func_num << 16;
8657                /* Set EEH reset type to fundamental if required by hba */
8658                pdev->needs_freset = 1;
8659        }
8660
8661        /* Configure PCI I/O space. */
8662        ret = ha->isp_ops->iospace_config(ha);
8663        if (ret)
8664                goto probe_failed_ioconfig;
8665
8666        ql4_printk(KERN_INFO, ha, "Found an ISP%04x, irq %d, iobase 0x%p\n",
8667                   pdev->device, pdev->irq, ha->reg);
8668
8669        qla4xxx_config_dma_addressing(ha);
8670
8671        /* Initialize lists and spinlocks. */
8672        INIT_LIST_HEAD(&ha->free_srb_q);
8673
8674        mutex_init(&ha->mbox_sem);
8675        mutex_init(&ha->chap_sem);
8676        init_completion(&ha->mbx_intr_comp);
8677        init_completion(&ha->disable_acb_comp);
8678        init_completion(&ha->idc_comp);
8679        init_completion(&ha->link_up_comp);
8680
8681        spin_lock_init(&ha->hardware_lock);
8682        spin_lock_init(&ha->work_lock);
8683
8684        /* Initialize work list */
8685        INIT_LIST_HEAD(&ha->work_list);
8686
8687        /* Allocate dma buffers */
8688        if (qla4xxx_mem_alloc(ha)) {
8689                ql4_printk(KERN_WARNING, ha,
8690                    "[ERROR] Failed to allocate memory for adapter\n");
8691
8692                ret = -ENOMEM;
8693                goto probe_failed;
8694        }
8695
8696        host->cmd_per_lun = 3;
8697        host->max_channel = 0;
8698        host->max_lun = MAX_LUNS - 1;
8699        host->max_id = MAX_TARGETS;
8700        host->max_cmd_len = IOCB_MAX_CDB_LEN;
8701        host->can_queue = MAX_SRBS ;
8702        host->transportt = qla4xxx_scsi_transport;
8703
8704        pci_set_drvdata(pdev, ha);
8705
8706        ret = scsi_add_host(host, &pdev->dev);
8707        if (ret)
8708                goto probe_failed;
8709
8710        if (is_qla80XX(ha))
8711                qla4_8xxx_get_flash_info(ha);
8712
8713        if (is_qla8032(ha) || is_qla8042(ha)) {
8714                qla4_83xx_read_reset_template(ha);
8715                /*
8716                 * NOTE: If ql4dontresethba==1, set IDC_CTRL DONTRESET_BIT0.
8717                 * If DONRESET_BIT0 is set, drivers should not set dev_state
8718                 * to NEED_RESET. But if NEED_RESET is set, drivers should
8719                 * should honor the reset.
8720                 */
8721                if (ql4xdontresethba == 1)
8722                        qla4_83xx_set_idc_dontreset(ha);
8723        }
8724
8725        /*
8726         * Initialize the Host adapter request/response queues and
8727         * firmware
8728         * NOTE: interrupts enabled upon successful completion
8729         */
8730        status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER);
8731
8732        /* Dont retry adapter initialization if IRQ allocation failed */
8733        if (is_qla80XX(ha) && (status == QLA_ERROR))
8734                goto skip_retry_init;
8735
8736        while ((!test_bit(AF_ONLINE, &ha->flags)) &&
8737            init_retry_count++ < MAX_INIT_RETRIES) {
8738
8739                if (is_qla80XX(ha)) {
8740                        ha->isp_ops->idc_lock(ha);
8741                        dev_state = qla4_8xxx_rd_direct(ha,
8742                                                        QLA8XXX_CRB_DEV_STATE);
8743                        ha->isp_ops->idc_unlock(ha);
8744                        if (dev_state == QLA8XXX_DEV_FAILED) {
8745                                ql4_printk(KERN_WARNING, ha, "%s: don't retry "
8746                                    "initialize adapter. H/W is in failed state\n",
8747                                    __func__);
8748                                break;
8749                        }
8750                }
8751                DEBUG2(printk("scsi: %s: retrying adapter initialization "
8752                              "(%d)\n", __func__, init_retry_count));
8753
8754                if (ha->isp_ops->reset_chip(ha) == QLA_ERROR)
8755                        continue;
8756
8757                status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER);
8758                if (is_qla80XX(ha) && (status == QLA_ERROR)) {
8759                        if (qla4_8xxx_check_init_adapter_retry(ha) == QLA_ERROR)
8760                                goto skip_retry_init;
8761                }
8762        }
8763
8764skip_retry_init:
8765        if (!test_bit(AF_ONLINE, &ha->flags)) {
8766                ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n");
8767
8768                if ((is_qla8022(ha) && ql4xdontresethba) ||
8769                    ((is_qla8032(ha) || is_qla8042(ha)) &&
8770                     qla4_83xx_idc_dontreset(ha))) {
8771                        /* Put the device in failed state. */
8772                        DEBUG2(printk(KERN_ERR "HW STATE: FAILED\n"));
8773                        ha->isp_ops->idc_lock(ha);
8774                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
8775                                            QLA8XXX_DEV_FAILED);
8776                        ha->isp_ops->idc_unlock(ha);
8777                }
8778                ret = -ENODEV;
8779                goto remove_host;
8780        }
8781
8782        /* Startup the kernel thread for this host adapter. */
8783        DEBUG2(printk("scsi: %s: Starting kernel thread for "
8784                      "qla4xxx_dpc\n", __func__));
8785        sprintf(buf, "qla4xxx_%lu_dpc", ha->host_no);
8786        ha->dpc_thread = create_singlethread_workqueue(buf);
8787        if (!ha->dpc_thread) {
8788                ql4_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n");
8789                ret = -ENODEV;
8790                goto remove_host;
8791        }
8792        INIT_WORK(&ha->dpc_work, qla4xxx_do_dpc);
8793
8794        ha->task_wq = alloc_workqueue("qla4xxx_%lu_task", WQ_MEM_RECLAIM, 1,
8795                                      ha->host_no);
8796        if (!ha->task_wq) {
8797                ql4_printk(KERN_WARNING, ha, "Unable to start task thread!\n");
8798                ret = -ENODEV;
8799                goto remove_host;
8800        }
8801
8802        /*
8803         * For ISP-8XXX, request_irqs is called in qla4_8xxx_load_risc
8804         * (which is called indirectly by qla4xxx_initialize_adapter),
8805         * so that irqs will be registered after crbinit but before
8806         * mbx_intr_enable.
8807         */
8808        if (is_qla40XX(ha)) {
8809                ret = qla4xxx_request_irqs(ha);
8810                if (ret) {
8811                        ql4_printk(KERN_WARNING, ha, "Failed to reserve "
8812                            "interrupt %d already in use.\n", pdev->irq);
8813                        goto remove_host;
8814                }
8815        }
8816
8817        pci_save_state(ha->pdev);
8818        ha->isp_ops->enable_intrs(ha);
8819
8820        /* Start timer thread. */
8821        qla4xxx_start_timer(ha, 1);
8822
8823        set_bit(AF_INIT_DONE, &ha->flags);
8824
8825        qla4_8xxx_alloc_sysfs_attr(ha);
8826
8827        printk(KERN_INFO
8828               " QLogic iSCSI HBA Driver version: %s\n"
8829               "  QLogic ISP%04x @ %s, host#=%ld, fw=%02d.%02d.%02d.%02d\n",
8830               qla4xxx_version_str, ha->pdev->device, pci_name(ha->pdev),
8831               ha->host_no, ha->fw_info.fw_major, ha->fw_info.fw_minor,
8832               ha->fw_info.fw_patch, ha->fw_info.fw_build);
8833
8834        /* Set the driver version */
8835        if (is_qla80XX(ha))
8836                qla4_8xxx_set_param(ha, SET_DRVR_VERSION);
8837
8838        if (qla4xxx_setup_boot_info(ha))
8839                ql4_printk(KERN_ERR, ha,
8840                           "%s: No iSCSI boot target configured\n", __func__);
8841
8842        set_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags);
8843        /* Perform the build ddb list and login to each */
8844        qla4xxx_build_ddb_list(ha, INIT_ADAPTER);
8845        iscsi_host_for_each_session(ha->host, qla4xxx_login_flash_ddb);
8846        qla4xxx_wait_login_resp_boot_tgt(ha);
8847
8848        qla4xxx_create_chap_list(ha);
8849
8850        qla4xxx_create_ifaces(ha);
8851        return 0;
8852
8853remove_host:
8854        scsi_remove_host(ha->host);
8855
8856probe_failed:
8857        qla4xxx_free_adapter(ha);
8858
8859probe_failed_ioconfig:
8860        pci_disable_pcie_error_reporting(pdev);
8861        scsi_host_put(ha->host);
8862
8863probe_disable_device:
8864        pci_disable_device(pdev);
8865
8866        return ret;
8867}
8868
8869/**
8870 * qla4xxx_prevent_other_port_reinit - prevent other port from re-initialize
8871 * @ha: pointer to adapter structure
8872 *
8873 * Mark the other ISP-4xxx port to indicate that the driver is being removed,
8874 * so that the other port will not re-initialize while in the process of
8875 * removing the ha due to driver unload or hba hotplug.
8876 **/
8877static void qla4xxx_prevent_other_port_reinit(struct scsi_qla_host *ha)
8878{
8879        struct scsi_qla_host *other_ha = NULL;
8880        struct pci_dev *other_pdev = NULL;
8881        int fn = ISP4XXX_PCI_FN_2;
8882
8883        /*iscsi function numbers for ISP4xxx is 1 and 3*/
8884        if (PCI_FUNC(ha->pdev->devfn) & BIT_1)
8885                fn = ISP4XXX_PCI_FN_1;
8886
8887        other_pdev =
8888                pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
8889                ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
8890                fn));
8891
8892        /* Get other_ha if other_pdev is valid and state is enable*/
8893        if (other_pdev) {
8894                if (atomic_read(&other_pdev->enable_cnt)) {
8895                        other_ha = pci_get_drvdata(other_pdev);
8896                        if (other_ha) {
8897                                set_bit(AF_HA_REMOVAL, &other_ha->flags);
8898                                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: "
8899                                    "Prevent %s reinit\n", __func__,
8900                                    dev_name(&other_ha->pdev->dev)));
8901                        }
8902                }
8903                pci_dev_put(other_pdev);
8904        }
8905}
8906
8907static void qla4xxx_destroy_ddb(struct scsi_qla_host *ha,
8908                struct ddb_entry *ddb_entry)
8909{
8910        struct dev_db_entry *fw_ddb_entry = NULL;
8911        dma_addr_t fw_ddb_entry_dma;
8912        unsigned long wtime;
8913        uint32_t ddb_state;
8914        int options;
8915        int status;
8916
8917        options = LOGOUT_OPTION_CLOSE_SESSION;
8918        if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR) {
8919                ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", __func__);
8920                goto clear_ddb;
8921        }
8922
8923        fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8924                                          &fw_ddb_entry_dma, GFP_KERNEL);
8925        if (!fw_ddb_entry) {
8926                ql4_printk(KERN_ERR, ha,
8927                           "%s: Unable to allocate dma buffer\n", __func__);
8928                goto clear_ddb;
8929        }
8930
8931        wtime = jiffies + (HZ * LOGOUT_TOV);
8932        do {
8933                status = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
8934                                                 fw_ddb_entry, fw_ddb_entry_dma,
8935                                                 NULL, NULL, &ddb_state, NULL,
8936                                                 NULL, NULL);
8937                if (status == QLA_ERROR)
8938                        goto free_ddb;
8939
8940                if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
8941                    (ddb_state == DDB_DS_SESSION_FAILED))
8942                        goto free_ddb;
8943
8944                schedule_timeout_uninterruptible(HZ);
8945        } while ((time_after(wtime, jiffies)));
8946
8947free_ddb:
8948        dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8949                          fw_ddb_entry, fw_ddb_entry_dma);
8950clear_ddb:
8951        qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
8952}
8953
8954static void qla4xxx_destroy_fw_ddb_session(struct scsi_qla_host *ha)
8955{
8956        struct ddb_entry *ddb_entry;
8957        int idx;
8958
8959        for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
8960
8961                ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
8962                if ((ddb_entry != NULL) &&
8963                    (ddb_entry->ddb_type == FLASH_DDB)) {
8964
8965                        qla4xxx_destroy_ddb(ha, ddb_entry);
8966                        /*
8967                         * we have decremented the reference count of the driver
8968                         * when we setup the session to have the driver unload
8969                         * to be seamless without actually destroying the
8970                         * session
8971                         **/
8972                        try_module_get(qla4xxx_iscsi_transport.owner);
8973                        iscsi_destroy_endpoint(ddb_entry->conn->ep);
8974                        qla4xxx_free_ddb(ha, ddb_entry);
8975                        iscsi_session_teardown(ddb_entry->sess);
8976                }
8977        }
8978}
8979/**
8980 * qla4xxx_remove_adapter - callback function to remove adapter.
8981 * @pci_dev: PCI device pointer
8982 **/
8983static void qla4xxx_remove_adapter(struct pci_dev *pdev)
8984{
8985        struct scsi_qla_host *ha;
8986
8987        /*
8988         * If the PCI device is disabled then it means probe_adapter had
8989         * failed and resources already cleaned up on probe_adapter exit.
8990         */
8991        if (!pci_is_enabled(pdev))
8992                return;
8993
8994        ha = pci_get_drvdata(pdev);
8995
8996        if (is_qla40XX(ha))
8997                qla4xxx_prevent_other_port_reinit(ha);
8998
8999        /* destroy iface from sysfs */
9000        qla4xxx_destroy_ifaces(ha);
9001
9002        if ((!ql4xdisablesysfsboot) && ha->boot_kset)
9003                iscsi_boot_destroy_kset(ha->boot_kset);
9004
9005        qla4xxx_destroy_fw_ddb_session(ha);
9006        qla4_8xxx_free_sysfs_attr(ha);
9007
9008        qla4xxx_sysfs_ddb_remove(ha);
9009        scsi_remove_host(ha->host);
9010
9011        qla4xxx_free_adapter(ha);
9012
9013        scsi_host_put(ha->host);
9014
9015        pci_disable_pcie_error_reporting(pdev);
9016        pci_disable_device(pdev);
9017}
9018
9019/**
9020 * qla4xxx_config_dma_addressing() - Configure OS DMA addressing method.
9021 * @ha: HA context
9022 */
9023static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
9024{
9025        /* Update our PCI device dma_mask for full 64 bit mask */
9026        if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
9027                dev_dbg(&ha->pdev->dev,
9028                          "Failed to set 64 bit PCI consistent mask; "
9029                           "using 32 bit.\n");
9030                dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(32));
9031        }
9032}
9033
9034static int qla4xxx_slave_alloc(struct scsi_device *sdev)
9035{
9036        struct iscsi_cls_session *cls_sess;
9037        struct iscsi_session *sess;
9038        struct ddb_entry *ddb;
9039        int queue_depth = QL4_DEF_QDEPTH;
9040
9041        cls_sess = starget_to_session(sdev->sdev_target);
9042        sess = cls_sess->dd_data;
9043        ddb = sess->dd_data;
9044
9045        sdev->hostdata = ddb;
9046
9047        if (ql4xmaxqdepth != 0 && ql4xmaxqdepth <= 0xffffU)
9048                queue_depth = ql4xmaxqdepth;
9049
9050        scsi_change_queue_depth(sdev, queue_depth);
9051        return 0;
9052}
9053
9054/**
9055 * qla4xxx_del_from_active_array - returns an active srb
9056 * @ha: Pointer to host adapter structure.
9057 * @index: index into the active_array
9058 *
9059 * This routine removes and returns the srb at the specified index
9060 **/
9061struct srb *qla4xxx_del_from_active_array(struct scsi_qla_host *ha,
9062    uint32_t index)
9063{
9064        struct srb *srb = NULL;
9065        struct scsi_cmnd *cmd = NULL;
9066
9067        cmd = scsi_host_find_tag(ha->host, index);
9068        if (!cmd)
9069                return srb;
9070
9071        srb = (struct srb *)CMD_SP(cmd);
9072        if (!srb)
9073                return srb;
9074
9075        /* update counters */
9076        if (srb->flags & SRB_DMA_VALID) {
9077                ha->iocb_cnt -= srb->iocb_cnt;
9078                if (srb->cmd)
9079                        srb->cmd->host_scribble =
9080                                (unsigned char *)(unsigned long) MAX_SRBS;
9081        }
9082        return srb;
9083}
9084
9085/**
9086 * qla4xxx_eh_wait_on_command - waits for command to be returned by firmware
9087 * @ha: Pointer to host adapter structure.
9088 * @cmd: Scsi Command to wait on.
9089 *
9090 * This routine waits for the command to be returned by the Firmware
9091 * for some max time.
9092 **/
9093static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha,
9094                                      struct scsi_cmnd *cmd)
9095{
9096        int done = 0;
9097        struct srb *rp;
9098        uint32_t max_wait_time = EH_WAIT_CMD_TOV;
9099        int ret = SUCCESS;
9100
9101        /* Dont wait on command if PCI error is being handled
9102         * by PCI AER driver
9103         */
9104        if (unlikely(pci_channel_offline(ha->pdev)) ||
9105            (test_bit(AF_EEH_BUSY, &ha->flags))) {
9106                ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n",
9107                    ha->host_no, __func__);
9108                return ret;
9109        }
9110
9111        do {
9112                /* Checking to see if its returned to OS */
9113                rp = (struct srb *) CMD_SP(cmd);
9114                if (rp == NULL) {
9115                        done++;
9116                        break;
9117                }
9118
9119                msleep(2000);
9120        } while (max_wait_time--);
9121
9122        return done;
9123}
9124
9125/**
9126 * qla4xxx_wait_for_hba_online - waits for HBA to come online
9127 * @ha: Pointer to host adapter structure
9128 **/
9129static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha)
9130{
9131        unsigned long wait_online;
9132
9133        wait_online = jiffies + (HBA_ONLINE_TOV * HZ);
9134        while (time_before(jiffies, wait_online)) {
9135
9136                if (adapter_up(ha))
9137                        return QLA_SUCCESS;
9138
9139                msleep(2000);
9140        }
9141
9142        return QLA_ERROR;
9143}
9144
9145/**
9146 * qla4xxx_eh_wait_for_commands - wait for active cmds to finish.
9147 * @ha: pointer to HBA
9148 * @t: target id
9149 * @l: lun id
9150 *
9151 * This function waits for all outstanding commands to a lun to complete. It
9152 * returns 0 if all pending commands are returned and 1 otherwise.
9153 **/
9154static int qla4xxx_eh_wait_for_commands(struct scsi_qla_host *ha,
9155                                        struct scsi_target *stgt,
9156                                        struct scsi_device *sdev)
9157{
9158        int cnt;
9159        int status = 0;
9160        struct scsi_cmnd *cmd;
9161
9162        /*
9163         * Waiting for all commands for the designated target or dev
9164         * in the active array
9165         */
9166        for (cnt = 0; cnt < ha->host->can_queue; cnt++) {
9167                cmd = scsi_host_find_tag(ha->host, cnt);
9168                if (cmd && stgt == scsi_target(cmd->device) &&
9169                    (!sdev || sdev == cmd->device)) {
9170                        if (!qla4xxx_eh_wait_on_command(ha, cmd)) {
9171                                status++;
9172                                break;
9173                        }
9174                }
9175        }
9176        return status;
9177}
9178
9179/**
9180 * qla4xxx_eh_abort - callback for abort task.
9181 * @cmd: Pointer to Linux's SCSI command structure
9182 *
9183 * This routine is called by the Linux OS to abort the specified
9184 * command.
9185 **/
9186static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
9187{
9188        struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9189        unsigned int id = cmd->device->id;
9190        uint64_t lun = cmd->device->lun;
9191        unsigned long flags;
9192        struct srb *srb = NULL;
9193        int ret = SUCCESS;
9194        int wait = 0;
9195        int rval;
9196
9197        ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%llu: Abort command issued cmd=%p, cdb=0x%x\n",
9198                   ha->host_no, id, lun, cmd, cmd->cmnd[0]);
9199
9200        rval = qla4xxx_isp_check_reg(ha);
9201        if (rval != QLA_SUCCESS) {
9202                ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9203                return FAILED;
9204        }
9205
9206        spin_lock_irqsave(&ha->hardware_lock, flags);
9207        srb = (struct srb *) CMD_SP(cmd);
9208        if (!srb) {
9209                spin_unlock_irqrestore(&ha->hardware_lock, flags);
9210                ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%llu: Specified command has already completed.\n",
9211                           ha->host_no, id, lun);
9212                return SUCCESS;
9213        }
9214        kref_get(&srb->srb_ref);
9215        spin_unlock_irqrestore(&ha->hardware_lock, flags);
9216
9217        if (qla4xxx_abort_task(ha, srb) != QLA_SUCCESS) {
9218                DEBUG3(printk("scsi%ld:%d:%llu: Abort_task mbx failed.\n",
9219                    ha->host_no, id, lun));
9220                ret = FAILED;
9221        } else {
9222                DEBUG3(printk("scsi%ld:%d:%llu: Abort_task mbx success.\n",
9223                    ha->host_no, id, lun));
9224                wait = 1;
9225        }
9226
9227        kref_put(&srb->srb_ref, qla4xxx_srb_compl);
9228
9229        /* Wait for command to complete */
9230        if (wait) {
9231                if (!qla4xxx_eh_wait_on_command(ha, cmd)) {
9232                        DEBUG2(printk("scsi%ld:%d:%llu: Abort handler timed out\n",
9233                            ha->host_no, id, lun));
9234                        ret = FAILED;
9235                }
9236        }
9237
9238        ql4_printk(KERN_INFO, ha,
9239            "scsi%ld:%d:%llu: Abort command - %s\n",
9240            ha->host_no, id, lun, (ret == SUCCESS) ? "succeeded" : "failed");
9241
9242        return ret;
9243}
9244
9245/**
9246 * qla4xxx_eh_device_reset - callback for target reset.
9247 * @cmd: Pointer to Linux's SCSI command structure
9248 *
9249 * This routine is called by the Linux OS to reset all luns on the
9250 * specified target.
9251 **/
9252static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd)
9253{
9254        struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9255        struct ddb_entry *ddb_entry = cmd->device->hostdata;
9256        int ret = FAILED, stat;
9257        int rval;
9258
9259        if (!ddb_entry)
9260                return ret;
9261
9262        ret = iscsi_block_scsi_eh(cmd);
9263        if (ret)
9264                return ret;
9265        ret = FAILED;
9266
9267        ql4_printk(KERN_INFO, ha,
9268                   "scsi%ld:%d:%d:%llu: DEVICE RESET ISSUED.\n", ha->host_no,
9269                   cmd->device->channel, cmd->device->id, cmd->device->lun);
9270
9271        DEBUG2(printk(KERN_INFO
9272                      "scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x,"
9273                      "dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no,
9274                      cmd, jiffies, cmd->request->timeout / HZ,
9275                      ha->dpc_flags, cmd->result, cmd->allowed));
9276
9277        rval = qla4xxx_isp_check_reg(ha);
9278        if (rval != QLA_SUCCESS) {
9279                ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9280                return FAILED;
9281        }
9282
9283        /* FIXME: wait for hba to go online */
9284        stat = qla4xxx_reset_lun(ha, ddb_entry, cmd->device->lun);
9285        if (stat != QLA_SUCCESS) {
9286                ql4_printk(KERN_INFO, ha, "DEVICE RESET FAILED. %d\n", stat);
9287                goto eh_dev_reset_done;
9288        }
9289
9290        if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device),
9291                                         cmd->device)) {
9292                ql4_printk(KERN_INFO, ha,
9293                           "DEVICE RESET FAILED - waiting for "
9294                           "commands.\n");
9295                goto eh_dev_reset_done;
9296        }
9297
9298        /* Send marker. */
9299        if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun,
9300                MM_LUN_RESET) != QLA_SUCCESS)
9301                goto eh_dev_reset_done;
9302
9303        ql4_printk(KERN_INFO, ha,
9304                   "scsi(%ld:%d:%d:%llu): DEVICE RESET SUCCEEDED.\n",
9305                   ha->host_no, cmd->device->channel, cmd->device->id,
9306                   cmd->device->lun);
9307
9308        ret = SUCCESS;
9309
9310eh_dev_reset_done:
9311
9312        return ret;
9313}
9314
9315/**
9316 * qla4xxx_eh_target_reset - callback for target reset.
9317 * @cmd: Pointer to Linux's SCSI command structure
9318 *
9319 * This routine is called by the Linux OS to reset the target.
9320 **/
9321static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd)
9322{
9323        struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9324        struct ddb_entry *ddb_entry = cmd->device->hostdata;
9325        int stat, ret;
9326        int rval;
9327
9328        if (!ddb_entry)
9329                return FAILED;
9330
9331        ret = iscsi_block_scsi_eh(cmd);
9332        if (ret)
9333                return ret;
9334
9335        starget_printk(KERN_INFO, scsi_target(cmd->device),
9336                       "WARM TARGET RESET ISSUED.\n");
9337
9338        DEBUG2(printk(KERN_INFO
9339                      "scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, "
9340                      "to=%x,dpc_flags=%lx, status=%x allowed=%d\n",
9341                      ha->host_no, cmd, jiffies, cmd->request->timeout / HZ,
9342                      ha->dpc_flags, cmd->result, cmd->allowed));
9343
9344        rval = qla4xxx_isp_check_reg(ha);
9345        if (rval != QLA_SUCCESS) {
9346                ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9347                return FAILED;
9348        }
9349
9350        stat = qla4xxx_reset_target(ha, ddb_entry);
9351        if (stat != QLA_SUCCESS) {
9352                starget_printk(KERN_INFO, scsi_target(cmd->device),
9353                               "WARM TARGET RESET FAILED.\n");
9354                return FAILED;
9355        }
9356
9357        if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device),
9358                                         NULL)) {
9359                starget_printk(KERN_INFO, scsi_target(cmd->device),
9360                               "WARM TARGET DEVICE RESET FAILED - "
9361                               "waiting for commands.\n");
9362                return FAILED;
9363        }
9364
9365        /* Send marker. */
9366        if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun,
9367                MM_TGT_WARM_RESET) != QLA_SUCCESS) {
9368                starget_printk(KERN_INFO, scsi_target(cmd->device),
9369                               "WARM TARGET DEVICE RESET FAILED - "
9370                               "marker iocb failed.\n");
9371                return FAILED;
9372        }
9373
9374        starget_printk(KERN_INFO, scsi_target(cmd->device),
9375                       "WARM TARGET RESET SUCCEEDED.\n");
9376        return SUCCESS;
9377}
9378
9379/**
9380 * qla4xxx_is_eh_active - check if error handler is running
9381 * @shost: Pointer to SCSI Host struct
9382 *
9383 * This routine finds that if reset host is called in EH
9384 * scenario or from some application like sg_reset
9385 **/
9386static int qla4xxx_is_eh_active(struct Scsi_Host *shost)
9387{
9388        if (shost->shost_state == SHOST_RECOVERY)
9389                return 1;
9390        return 0;
9391}
9392
9393/**
9394 * qla4xxx_eh_host_reset - kernel callback
9395 * @cmd: Pointer to Linux's SCSI command structure
9396 *
9397 * This routine is invoked by the Linux kernel to perform fatal error
9398 * recovery on the specified adapter.
9399 **/
9400static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd)
9401{
9402        int return_status = FAILED;
9403        struct scsi_qla_host *ha;
9404        int rval;
9405
9406        ha = to_qla_host(cmd->device->host);
9407
9408        rval = qla4xxx_isp_check_reg(ha);
9409        if (rval != QLA_SUCCESS) {
9410                ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9411                return FAILED;
9412        }
9413
9414        if ((is_qla8032(ha) || is_qla8042(ha)) && ql4xdontresethba)
9415                qla4_83xx_set_idc_dontreset(ha);
9416
9417        /*
9418         * For ISP8324 and ISP8042, if IDC_CTRL DONTRESET_BIT0 is set by other
9419         * protocol drivers, we should not set device_state to NEED_RESET
9420         */
9421        if (ql4xdontresethba ||
9422            ((is_qla8032(ha) || is_qla8042(ha)) &&
9423             qla4_83xx_idc_dontreset(ha))) {
9424                DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n",
9425                     ha->host_no, __func__));
9426
9427                /* Clear outstanding srb in queues */
9428                if (qla4xxx_is_eh_active(cmd->device->host))
9429                        qla4xxx_abort_active_cmds(ha, DID_ABORT << 16);
9430
9431                return FAILED;
9432        }
9433
9434        ql4_printk(KERN_INFO, ha,
9435                   "scsi(%ld:%d:%d:%llu): HOST RESET ISSUED.\n", ha->host_no,
9436                   cmd->device->channel, cmd->device->id, cmd->device->lun);
9437
9438        if (qla4xxx_wait_for_hba_online(ha) != QLA_SUCCESS) {
9439                DEBUG2(printk("scsi%ld:%d: %s: Unable to reset host.  Adapter "
9440                              "DEAD.\n", ha->host_no, cmd->device->channel,
9441                              __func__));
9442
9443                return FAILED;
9444        }
9445
9446        if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9447                if (is_qla80XX(ha))
9448                        set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
9449                else
9450                        set_bit(DPC_RESET_HA, &ha->dpc_flags);
9451        }
9452
9453        if (qla4xxx_recover_adapter(ha) == QLA_SUCCESS)
9454                return_status = SUCCESS;
9455
9456        ql4_printk(KERN_INFO, ha, "HOST RESET %s.\n",
9457                   return_status == FAILED ? "FAILED" : "SUCCEEDED");
9458
9459        return return_status;
9460}
9461
9462static int qla4xxx_context_reset(struct scsi_qla_host *ha)
9463{
9464        uint32_t mbox_cmd[MBOX_REG_COUNT];
9465        uint32_t mbox_sts[MBOX_REG_COUNT];
9466        struct addr_ctrl_blk_def *acb = NULL;
9467        uint32_t acb_len = sizeof(struct addr_ctrl_blk_def);
9468        int rval = QLA_SUCCESS;
9469        dma_addr_t acb_dma;
9470
9471        acb = dma_alloc_coherent(&ha->pdev->dev,
9472                                 sizeof(struct addr_ctrl_blk_def),
9473                                 &acb_dma, GFP_KERNEL);
9474        if (!acb) {
9475                ql4_printk(KERN_ERR, ha, "%s: Unable to alloc acb\n",
9476                           __func__);
9477                rval = -ENOMEM;
9478                goto exit_port_reset;
9479        }
9480
9481        memset(acb, 0, acb_len);
9482
9483        rval = qla4xxx_get_acb(ha, acb_dma, PRIMARI_ACB, acb_len);
9484        if (rval != QLA_SUCCESS) {
9485                rval = -EIO;
9486                goto exit_free_acb;
9487        }
9488
9489        rval = qla4xxx_disable_acb(ha);
9490        if (rval != QLA_SUCCESS) {
9491                rval = -EIO;
9492                goto exit_free_acb;
9493        }
9494
9495        wait_for_completion_timeout(&ha->disable_acb_comp,
9496                                    DISABLE_ACB_TOV * HZ);
9497
9498        rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], acb_dma);
9499        if (rval != QLA_SUCCESS) {
9500                rval = -EIO;
9501                goto exit_free_acb;
9502        }
9503
9504exit_free_acb:
9505        dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk_def),
9506                          acb, acb_dma);
9507exit_port_reset:
9508        DEBUG2(ql4_printk(KERN_INFO, ha, "%s %s\n", __func__,
9509                          rval == QLA_SUCCESS ? "SUCCEEDED" : "FAILED"));
9510        return rval;
9511}
9512
9513static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type)
9514{
9515        struct scsi_qla_host *ha = to_qla_host(shost);
9516        int rval = QLA_SUCCESS;
9517        uint32_t idc_ctrl;
9518
9519        if (ql4xdontresethba) {
9520                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Don't Reset HBA\n",
9521                                  __func__));
9522                rval = -EPERM;
9523                goto exit_host_reset;
9524        }
9525
9526        if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
9527                goto recover_adapter;
9528
9529        switch (reset_type) {
9530        case SCSI_ADAPTER_RESET:
9531                set_bit(DPC_RESET_HA, &ha->dpc_flags);
9532                break;
9533        case SCSI_FIRMWARE_RESET:
9534                if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9535                        if (is_qla80XX(ha))
9536                                /* set firmware context reset */
9537                                set_bit(DPC_RESET_HA_FW_CONTEXT,
9538                                        &ha->dpc_flags);
9539                        else {
9540                                rval = qla4xxx_context_reset(ha);
9541                                goto exit_host_reset;
9542                        }
9543                }
9544                break;
9545        }
9546
9547recover_adapter:
9548        /* For ISP8324 and ISP8042 set graceful reset bit in IDC_DRV_CTRL if
9549         * reset is issued by application */
9550        if ((is_qla8032(ha) || is_qla8042(ha)) &&
9551            test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9552                idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
9553                qla4_83xx_wr_reg(ha, QLA83XX_IDC_DRV_CTRL,
9554                                 (idc_ctrl | GRACEFUL_RESET_BIT1));
9555        }
9556
9557        rval = qla4xxx_recover_adapter(ha);
9558        if (rval != QLA_SUCCESS) {
9559                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: recover adapter fail\n",
9560                                  __func__));
9561                rval = -EIO;
9562        }
9563
9564exit_host_reset:
9565        return rval;
9566}
9567
9568/* PCI AER driver recovers from all correctable errors w/o
9569 * driver intervention. For uncorrectable errors PCI AER
9570 * driver calls the following device driver's callbacks
9571 *
9572 * - Fatal Errors - link_reset
9573 * - Non-Fatal Errors - driver's error_detected() which
9574 * returns CAN_RECOVER, NEED_RESET or DISCONNECT.
9575 *
9576 * PCI AER driver calls
9577 * CAN_RECOVER - driver's mmio_enabled(), mmio_enabled()
9578 *               returns RECOVERED or NEED_RESET if fw_hung
9579 * NEED_RESET - driver's slot_reset()
9580 * DISCONNECT - device is dead & cannot recover
9581 * RECOVERED - driver's resume()
9582 */
9583static pci_ers_result_t
9584qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
9585{
9586        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9587
9588        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n",
9589            ha->host_no, __func__, state);
9590
9591        if (!is_aer_supported(ha))
9592                return PCI_ERS_RESULT_NONE;
9593
9594        switch (state) {
9595        case pci_channel_io_normal:
9596                clear_bit(AF_EEH_BUSY, &ha->flags);
9597                return PCI_ERS_RESULT_CAN_RECOVER;
9598        case pci_channel_io_frozen:
9599                set_bit(AF_EEH_BUSY, &ha->flags);
9600                qla4xxx_mailbox_premature_completion(ha);
9601                qla4xxx_free_irqs(ha);
9602                pci_disable_device(pdev);
9603                /* Return back all IOs */
9604                qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
9605                return PCI_ERS_RESULT_NEED_RESET;
9606        case pci_channel_io_perm_failure:
9607                set_bit(AF_EEH_BUSY, &ha->flags);
9608                set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags);
9609                qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
9610                return PCI_ERS_RESULT_DISCONNECT;
9611        }
9612        return PCI_ERS_RESULT_NEED_RESET;
9613}
9614
9615/**
9616 * qla4xxx_pci_mmio_enabled() gets called if
9617 * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER
9618 * and read/write to the device still works.
9619 **/
9620static pci_ers_result_t
9621qla4xxx_pci_mmio_enabled(struct pci_dev *pdev)
9622{
9623        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9624
9625        if (!is_aer_supported(ha))
9626                return PCI_ERS_RESULT_NONE;
9627
9628        return PCI_ERS_RESULT_RECOVERED;
9629}
9630
9631static uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha)
9632{
9633        uint32_t rval = QLA_ERROR;
9634        int fn;
9635        struct pci_dev *other_pdev = NULL;
9636
9637        ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__);
9638
9639        set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
9640
9641        if (test_bit(AF_ONLINE, &ha->flags)) {
9642                clear_bit(AF_ONLINE, &ha->flags);
9643                clear_bit(AF_LINK_UP, &ha->flags);
9644                iscsi_host_for_each_session(ha->host, qla4xxx_fail_session);
9645                qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
9646        }
9647
9648        fn = PCI_FUNC(ha->pdev->devfn);
9649        if (is_qla8022(ha)) {
9650                while (fn > 0) {
9651                        fn--;
9652                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at func %x\n",
9653                                   ha->host_no, __func__, fn);
9654                        /* Get the pci device given the domain, bus,
9655                         * slot/function number */
9656                        other_pdev = pci_get_domain_bus_and_slot(
9657                                           pci_domain_nr(ha->pdev->bus),
9658                                           ha->pdev->bus->number,
9659                                           PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
9660                                           fn));
9661
9662                        if (!other_pdev)
9663                                continue;
9664
9665                        if (atomic_read(&other_pdev->enable_cnt)) {
9666                                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI func in enabled state%x\n",
9667                                           ha->host_no, __func__, fn);
9668                                pci_dev_put(other_pdev);
9669                                break;
9670                        }
9671                        pci_dev_put(other_pdev);
9672                }
9673        } else {
9674                /* this case is meant for ISP83xx/ISP84xx only */
9675                if (qla4_83xx_can_perform_reset(ha)) {
9676                        /* reset fn as iSCSI is going to perform the reset */
9677                        fn = 0;
9678                }
9679        }
9680
9681        /* The first function on the card, the reset owner will
9682         * start & initialize the firmware. The other functions
9683         * on the card will reset the firmware context
9684         */
9685        if (!fn) {
9686                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset "
9687                    "0x%x is the owner\n", ha->host_no, __func__,
9688                    ha->pdev->devfn);
9689
9690                ha->isp_ops->idc_lock(ha);
9691                qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9692                                    QLA8XXX_DEV_COLD);
9693                ha->isp_ops->idc_unlock(ha);
9694
9695                rval = qla4_8xxx_update_idc_reg(ha);
9696                if (rval == QLA_ERROR) {
9697                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: FAILED\n",
9698                                   ha->host_no, __func__);
9699                        ha->isp_ops->idc_lock(ha);
9700                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9701                                            QLA8XXX_DEV_FAILED);
9702                        ha->isp_ops->idc_unlock(ha);
9703                        goto exit_error_recovery;
9704                }
9705
9706                clear_bit(AF_FW_RECOVERY, &ha->flags);
9707                rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
9708
9709                if (rval != QLA_SUCCESS) {
9710                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
9711                            "FAILED\n", ha->host_no, __func__);
9712                        qla4xxx_free_irqs(ha);
9713                        ha->isp_ops->idc_lock(ha);
9714                        qla4_8xxx_clear_drv_active(ha);
9715                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9716                                            QLA8XXX_DEV_FAILED);
9717                        ha->isp_ops->idc_unlock(ha);
9718                } else {
9719                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
9720                            "READY\n", ha->host_no, __func__);
9721                        ha->isp_ops->idc_lock(ha);
9722                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9723                                            QLA8XXX_DEV_READY);
9724                        /* Clear driver state register */
9725                        qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_STATE, 0);
9726                        qla4_8xxx_set_drv_active(ha);
9727                        ha->isp_ops->idc_unlock(ha);
9728                        ha->isp_ops->enable_intrs(ha);
9729                }
9730        } else {
9731                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not "
9732                    "the reset owner\n", ha->host_no, __func__,
9733                    ha->pdev->devfn);
9734                if ((qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE) ==
9735                     QLA8XXX_DEV_READY)) {
9736                        clear_bit(AF_FW_RECOVERY, &ha->flags);
9737                        rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
9738                        if (rval == QLA_SUCCESS)
9739                                ha->isp_ops->enable_intrs(ha);
9740                        else
9741                                qla4xxx_free_irqs(ha);
9742
9743                        ha->isp_ops->idc_lock(ha);
9744                        qla4_8xxx_set_drv_active(ha);
9745                        ha->isp_ops->idc_unlock(ha);
9746                }
9747        }
9748exit_error_recovery:
9749        clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
9750        return rval;
9751}
9752
9753static pci_ers_result_t
9754qla4xxx_pci_slot_reset(struct pci_dev *pdev)
9755{
9756        pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
9757        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9758        int rc;
9759
9760        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n",
9761            ha->host_no, __func__);
9762
9763        if (!is_aer_supported(ha))
9764                return PCI_ERS_RESULT_NONE;
9765
9766        /* Restore the saved state of PCIe device -
9767         * BAR registers, PCI Config space, PCIX, MSI,
9768         * IOV states
9769         */
9770        pci_restore_state(pdev);
9771
9772        /* pci_restore_state() clears the saved_state flag of the device
9773         * save restored state which resets saved_state flag
9774         */
9775        pci_save_state(pdev);
9776
9777        /* Initialize device or resume if in suspended state */
9778        rc = pci_enable_device(pdev);
9779        if (rc) {
9780                ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Can't re-enable "
9781                    "device after reset\n", ha->host_no, __func__);
9782                goto exit_slot_reset;
9783        }
9784
9785        ha->isp_ops->disable_intrs(ha);
9786
9787        if (is_qla80XX(ha)) {
9788                if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) {
9789                        ret = PCI_ERS_RESULT_RECOVERED;
9790                        goto exit_slot_reset;
9791                } else
9792                        goto exit_slot_reset;
9793        }
9794
9795exit_slot_reset:
9796        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n"
9797            "device after reset\n", ha->host_no, __func__, ret);
9798        return ret;
9799}
9800
9801static void
9802qla4xxx_pci_resume(struct pci_dev *pdev)
9803{
9804        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9805        int ret;
9806
9807        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n",
9808            ha->host_no, __func__);
9809
9810        ret = qla4xxx_wait_for_hba_online(ha);
9811        if (ret != QLA_SUCCESS) {
9812                ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to "
9813                    "resume I/O from slot/link_reset\n", ha->host_no,
9814                     __func__);
9815        }
9816
9817        clear_bit(AF_EEH_BUSY, &ha->flags);
9818}
9819
9820static const struct pci_error_handlers qla4xxx_err_handler = {
9821        .error_detected = qla4xxx_pci_error_detected,
9822        .mmio_enabled = qla4xxx_pci_mmio_enabled,
9823        .slot_reset = qla4xxx_pci_slot_reset,
9824        .resume = qla4xxx_pci_resume,
9825};
9826
9827static struct pci_device_id qla4xxx_pci_tbl[] = {
9828        {
9829                .vendor         = PCI_VENDOR_ID_QLOGIC,
9830                .device         = PCI_DEVICE_ID_QLOGIC_ISP4010,
9831                .subvendor      = PCI_ANY_ID,
9832                .subdevice      = PCI_ANY_ID,
9833        },
9834        {
9835                .vendor         = PCI_VENDOR_ID_QLOGIC,
9836                .device         = PCI_DEVICE_ID_QLOGIC_ISP4022,
9837                .subvendor      = PCI_ANY_ID,
9838                .subdevice      = PCI_ANY_ID,
9839        },
9840        {
9841                .vendor         = PCI_VENDOR_ID_QLOGIC,
9842                .device         = PCI_DEVICE_ID_QLOGIC_ISP4032,
9843                .subvendor      = PCI_ANY_ID,
9844                .subdevice      = PCI_ANY_ID,
9845        },
9846        {
9847                .vendor         = PCI_VENDOR_ID_QLOGIC,
9848                .device         = PCI_DEVICE_ID_QLOGIC_ISP8022,
9849                .subvendor      = PCI_ANY_ID,
9850                .subdevice      = PCI_ANY_ID,
9851        },
9852        {
9853                .vendor         = PCI_VENDOR_ID_QLOGIC,
9854                .device         = PCI_DEVICE_ID_QLOGIC_ISP8324,
9855                .subvendor      = PCI_ANY_ID,
9856                .subdevice      = PCI_ANY_ID,
9857        },
9858        {
9859                .vendor         = PCI_VENDOR_ID_QLOGIC,
9860                .device         = PCI_DEVICE_ID_QLOGIC_ISP8042,
9861                .subvendor      = PCI_ANY_ID,
9862                .subdevice      = PCI_ANY_ID,
9863        },
9864        {0, 0},
9865};
9866MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl);
9867
9868static struct pci_driver qla4xxx_pci_driver = {
9869        .name           = DRIVER_NAME,
9870        .id_table       = qla4xxx_pci_tbl,
9871        .probe          = qla4xxx_probe_adapter,
9872        .remove         = qla4xxx_remove_adapter,
9873        .err_handler = &qla4xxx_err_handler,
9874};
9875
9876static int __init qla4xxx_module_init(void)
9877{
9878        int ret;
9879
9880        if (ql4xqfulltracking)
9881                qla4xxx_driver_template.track_queue_depth = 1;
9882
9883        /* Allocate cache for SRBs. */
9884        srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0,
9885                                       SLAB_HWCACHE_ALIGN, NULL);
9886        if (srb_cachep == NULL) {
9887                printk(KERN_ERR
9888                       "%s: Unable to allocate SRB cache..."
9889                       "Failing load!\n", DRIVER_NAME);
9890                ret = -ENOMEM;
9891                goto no_srp_cache;
9892        }
9893
9894        /* Derive version string. */
9895        strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION);
9896        if (ql4xextended_error_logging)
9897                strcat(qla4xxx_version_str, "-debug");
9898
9899        qla4xxx_scsi_transport =
9900                iscsi_register_transport(&qla4xxx_iscsi_transport);
9901        if (!qla4xxx_scsi_transport){
9902                ret = -ENODEV;
9903                goto release_srb_cache;
9904        }
9905
9906        ret = pci_register_driver(&qla4xxx_pci_driver);
9907        if (ret)
9908                goto unregister_transport;
9909
9910        printk(KERN_INFO "QLogic iSCSI HBA Driver\n");
9911        return 0;
9912
9913unregister_transport:
9914        iscsi_unregister_transport(&qla4xxx_iscsi_transport);
9915release_srb_cache:
9916        kmem_cache_destroy(srb_cachep);
9917no_srp_cache:
9918        return ret;
9919}
9920
9921static void __exit qla4xxx_module_exit(void)
9922{
9923        pci_unregister_driver(&qla4xxx_pci_driver);
9924        iscsi_unregister_transport(&qla4xxx_iscsi_transport);
9925        kmem_cache_destroy(srb_cachep);
9926}
9927
9928module_init(qla4xxx_module_init);
9929module_exit(qla4xxx_module_exit);
9930
9931MODULE_AUTHOR("QLogic Corporation");
9932MODULE_DESCRIPTION("QLogic iSCSI HBA Driver");
9933MODULE_LICENSE("GPL");
9934MODULE_VERSION(QLA4XXX_DRIVER_VERSION);
9935