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