1 /* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2010 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 22 /* 23 * Driver version 24 */ 25 static char qla4xxx_version_str[40]; 26 27 /* 28 * SRB allocation cache 29 */ 30 static struct kmem_cache *srb_cachep; 31 32 /* 33 * Module parameter information and variables 34 */ 35 static int ql4xdisablesysfsboot = 1; 36 module_param(ql4xdisablesysfsboot, int, S_IRUGO | S_IWUSR); 37 MODULE_PARM_DESC(ql4xdisablesysfsboot, 38 " Set to disable exporting boot targets to sysfs.\n" 39 "\t\t 0 - Export boot targets\n" 40 "\t\t 1 - Do not export boot targets (Default)"); 41 42 int ql4xdontresethba; 43 module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR); 44 MODULE_PARM_DESC(ql4xdontresethba, 45 " Don't reset the HBA for driver recovery.\n" 46 "\t\t 0 - It will reset HBA (Default)\n" 47 "\t\t 1 - It will NOT reset HBA"); 48 49 int ql4xextended_error_logging; 50 module_param(ql4xextended_error_logging, int, S_IRUGO | S_IWUSR); 51 MODULE_PARM_DESC(ql4xextended_error_logging, 52 " Option to enable extended error logging.\n" 53 "\t\t 0 - no logging (Default)\n" 54 "\t\t 2 - debug logging"); 55 56 int ql4xenablemsix = 1; 57 module_param(ql4xenablemsix, int, S_IRUGO|S_IWUSR); 58 MODULE_PARM_DESC(ql4xenablemsix, 59 " Set to enable MSI or MSI-X interrupt mechanism.\n" 60 "\t\t 0 = enable INTx interrupt mechanism.\n" 61 "\t\t 1 = enable MSI-X interrupt mechanism (Default).\n" 62 "\t\t 2 = enable MSI interrupt mechanism."); 63 64 #define QL4_DEF_QDEPTH 32 65 static int ql4xmaxqdepth = QL4_DEF_QDEPTH; 66 module_param(ql4xmaxqdepth, int, S_IRUGO | S_IWUSR); 67 MODULE_PARM_DESC(ql4xmaxqdepth, 68 " Maximum queue depth to report for target devices.\n" 69 "\t\t Default: 32."); 70 71 static int ql4xqfulltracking = 1; 72 module_param(ql4xqfulltracking, int, S_IRUGO | S_IWUSR); 73 MODULE_PARM_DESC(ql4xqfulltracking, 74 " Enable or disable dynamic tracking and adjustment of\n" 75 "\t\t scsi device queue depth.\n" 76 "\t\t 0 - Disable.\n" 77 "\t\t 1 - Enable. (Default)"); 78 79 static int ql4xsess_recovery_tmo = QL4_SESS_RECOVERY_TMO; 80 module_param(ql4xsess_recovery_tmo, int, S_IRUGO); 81 MODULE_PARM_DESC(ql4xsess_recovery_tmo, 82 " Target Session Recovery Timeout.\n" 83 "\t\t Default: 120 sec."); 84 85 int ql4xmdcapmask = 0x1F; 86 module_param(ql4xmdcapmask, int, S_IRUGO); 87 MODULE_PARM_DESC(ql4xmdcapmask, 88 " Set the Minidump driver capture mask level.\n" 89 "\t\t Default is 0x1F.\n" 90 "\t\t Can be set to 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F"); 91 92 int ql4xenablemd = 1; 93 module_param(ql4xenablemd, int, S_IRUGO | S_IWUSR); 94 MODULE_PARM_DESC(ql4xenablemd, 95 " Set to enable minidump.\n" 96 "\t\t 0 - disable minidump\n" 97 "\t\t 1 - enable minidump (Default)"); 98 99 static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha); 100 /* 101 * SCSI host template entry points 102 */ 103 static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha); 104 105 /* 106 * iSCSI template entry points 107 */ 108 static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess, 109 enum iscsi_param param, char *buf); 110 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn, 111 enum iscsi_param param, char *buf); 112 static int qla4xxx_host_get_param(struct Scsi_Host *shost, 113 enum iscsi_host_param param, char *buf); 114 static int qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, 115 uint32_t len); 116 static int qla4xxx_get_iface_param(struct iscsi_iface *iface, 117 enum iscsi_param_type param_type, 118 int param, char *buf); 119 static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc); 120 static struct iscsi_endpoint *qla4xxx_ep_connect(struct Scsi_Host *shost, 121 struct sockaddr *dst_addr, 122 int non_blocking); 123 static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms); 124 static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep); 125 static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep, 126 enum iscsi_param param, char *buf); 127 static int qla4xxx_conn_start(struct iscsi_cls_conn *conn); 128 static struct iscsi_cls_conn * 129 qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx); 130 static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session, 131 struct iscsi_cls_conn *cls_conn, 132 uint64_t transport_fd, int is_leading); 133 static void qla4xxx_conn_destroy(struct iscsi_cls_conn *conn); 134 static struct iscsi_cls_session * 135 qla4xxx_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max, 136 uint16_t qdepth, uint32_t initial_cmdsn); 137 static void qla4xxx_session_destroy(struct iscsi_cls_session *sess); 138 static void qla4xxx_task_work(struct work_struct *wdata); 139 static int qla4xxx_alloc_pdu(struct iscsi_task *, uint8_t); 140 static int qla4xxx_task_xmit(struct iscsi_task *); 141 static void qla4xxx_task_cleanup(struct iscsi_task *); 142 static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session); 143 static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn, 144 struct iscsi_stats *stats); 145 static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num, 146 uint32_t iface_type, uint32_t payload_size, 147 uint32_t pid, struct sockaddr *dst_addr); 148 static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx, 149 uint32_t *num_entries, char *buf); 150 static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx); 151 152 /* 153 * SCSI host template entry points 154 */ 155 static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd); 156 static int qla4xxx_eh_abort(struct scsi_cmnd *cmd); 157 static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd); 158 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd); 159 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd); 160 static int qla4xxx_slave_alloc(struct scsi_device *device); 161 static int qla4xxx_slave_configure(struct scsi_device *device); 162 static void qla4xxx_slave_destroy(struct scsi_device *sdev); 163 static umode_t ql4_attr_is_visible(int param_type, int param); 164 static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type); 165 static int qla4xxx_change_queue_depth(struct scsi_device *sdev, int qdepth, 166 int reason); 167 168 static struct qla4_8xxx_legacy_intr_set legacy_intr[] = 169 QLA82XX_LEGACY_INTR_CONFIG; 170 171 static struct scsi_host_template qla4xxx_driver_template = { 172 .module = THIS_MODULE, 173 .name = DRIVER_NAME, 174 .proc_name = DRIVER_NAME, 175 .queuecommand = qla4xxx_queuecommand, 176 177 .eh_abort_handler = qla4xxx_eh_abort, 178 .eh_device_reset_handler = qla4xxx_eh_device_reset, 179 .eh_target_reset_handler = qla4xxx_eh_target_reset, 180 .eh_host_reset_handler = qla4xxx_eh_host_reset, 181 .eh_timed_out = qla4xxx_eh_cmd_timed_out, 182 183 .slave_configure = qla4xxx_slave_configure, 184 .slave_alloc = qla4xxx_slave_alloc, 185 .slave_destroy = qla4xxx_slave_destroy, 186 .change_queue_depth = qla4xxx_change_queue_depth, 187 188 .this_id = -1, 189 .cmd_per_lun = 3, 190 .use_clustering = ENABLE_CLUSTERING, 191 .sg_tablesize = SG_ALL, 192 193 .max_sectors = 0xFFFF, 194 .shost_attrs = qla4xxx_host_attrs, 195 .host_reset = qla4xxx_host_reset, 196 .vendor_id = SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC, 197 }; 198 199 static struct iscsi_transport qla4xxx_iscsi_transport = { 200 .owner = THIS_MODULE, 201 .name = DRIVER_NAME, 202 .caps = CAP_TEXT_NEGO | 203 CAP_DATA_PATH_OFFLOAD | CAP_HDRDGST | 204 CAP_DATADGST | CAP_LOGIN_OFFLOAD | 205 CAP_MULTI_R2T, 206 .attr_is_visible = ql4_attr_is_visible, 207 .create_session = qla4xxx_session_create, 208 .destroy_session = qla4xxx_session_destroy, 209 .start_conn = qla4xxx_conn_start, 210 .create_conn = qla4xxx_conn_create, 211 .bind_conn = qla4xxx_conn_bind, 212 .stop_conn = iscsi_conn_stop, 213 .destroy_conn = qla4xxx_conn_destroy, 214 .set_param = iscsi_set_param, 215 .get_conn_param = qla4xxx_conn_get_param, 216 .get_session_param = qla4xxx_session_get_param, 217 .get_ep_param = qla4xxx_get_ep_param, 218 .ep_connect = qla4xxx_ep_connect, 219 .ep_poll = qla4xxx_ep_poll, 220 .ep_disconnect = qla4xxx_ep_disconnect, 221 .get_stats = qla4xxx_conn_get_stats, 222 .send_pdu = iscsi_conn_send_pdu, 223 .xmit_task = qla4xxx_task_xmit, 224 .cleanup_task = qla4xxx_task_cleanup, 225 .alloc_pdu = qla4xxx_alloc_pdu, 226 227 .get_host_param = qla4xxx_host_get_param, 228 .set_iface_param = qla4xxx_iface_set_param, 229 .get_iface_param = qla4xxx_get_iface_param, 230 .bsg_request = qla4xxx_bsg_request, 231 .send_ping = qla4xxx_send_ping, 232 .get_chap = qla4xxx_get_chap_list, 233 .delete_chap = qla4xxx_delete_chap, 234 }; 235 236 static struct scsi_transport_template *qla4xxx_scsi_transport; 237 238 static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num, 239 uint32_t iface_type, uint32_t payload_size, 240 uint32_t pid, struct sockaddr *dst_addr) 241 { 242 struct scsi_qla_host *ha = to_qla_host(shost); 243 struct sockaddr_in *addr; 244 struct sockaddr_in6 *addr6; 245 uint32_t options = 0; 246 uint8_t ipaddr[IPv6_ADDR_LEN]; 247 int rval; 248 249 memset(ipaddr, 0, IPv6_ADDR_LEN); 250 /* IPv4 to IPv4 */ 251 if ((iface_type == ISCSI_IFACE_TYPE_IPV4) && 252 (dst_addr->sa_family == AF_INET)) { 253 addr = (struct sockaddr_in *)dst_addr; 254 memcpy(ipaddr, &addr->sin_addr.s_addr, IP_ADDR_LEN); 255 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv4 Ping src: %pI4 " 256 "dest: %pI4\n", __func__, 257 &ha->ip_config.ip_address, ipaddr)); 258 rval = qla4xxx_ping_iocb(ha, options, payload_size, pid, 259 ipaddr); 260 if (rval) 261 rval = -EINVAL; 262 } else if ((iface_type == ISCSI_IFACE_TYPE_IPV6) && 263 (dst_addr->sa_family == AF_INET6)) { 264 /* IPv6 to IPv6 */ 265 addr6 = (struct sockaddr_in6 *)dst_addr; 266 memcpy(ipaddr, &addr6->sin6_addr.in6_u.u6_addr8, IPv6_ADDR_LEN); 267 268 options |= PING_IPV6_PROTOCOL_ENABLE; 269 270 /* Ping using LinkLocal address */ 271 if ((iface_num == 0) || (iface_num == 1)) { 272 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: LinkLocal Ping " 273 "src: %pI6 dest: %pI6\n", __func__, 274 &ha->ip_config.ipv6_link_local_addr, 275 ipaddr)); 276 options |= PING_IPV6_LINKLOCAL_ADDR; 277 rval = qla4xxx_ping_iocb(ha, options, payload_size, 278 pid, ipaddr); 279 } else { 280 ql4_printk(KERN_WARNING, ha, "%s: iface num = %d " 281 "not supported\n", __func__, iface_num); 282 rval = -ENOSYS; 283 goto exit_send_ping; 284 } 285 286 /* 287 * If ping using LinkLocal address fails, try ping using 288 * IPv6 address 289 */ 290 if (rval != QLA_SUCCESS) { 291 options &= ~PING_IPV6_LINKLOCAL_ADDR; 292 if (iface_num == 0) { 293 options |= PING_IPV6_ADDR0; 294 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 " 295 "Ping src: %pI6 " 296 "dest: %pI6\n", __func__, 297 &ha->ip_config.ipv6_addr0, 298 ipaddr)); 299 } else if (iface_num == 1) { 300 options |= PING_IPV6_ADDR1; 301 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 " 302 "Ping src: %pI6 " 303 "dest: %pI6\n", __func__, 304 &ha->ip_config.ipv6_addr1, 305 ipaddr)); 306 } 307 rval = qla4xxx_ping_iocb(ha, options, payload_size, 308 pid, ipaddr); 309 if (rval) 310 rval = -EINVAL; 311 } 312 } else 313 rval = -ENOSYS; 314 exit_send_ping: 315 return rval; 316 } 317 318 static umode_t ql4_attr_is_visible(int param_type, int param) 319 { 320 switch (param_type) { 321 case ISCSI_HOST_PARAM: 322 switch (param) { 323 case ISCSI_HOST_PARAM_HWADDRESS: 324 case ISCSI_HOST_PARAM_IPADDRESS: 325 case ISCSI_HOST_PARAM_INITIATOR_NAME: 326 case ISCSI_HOST_PARAM_PORT_STATE: 327 case ISCSI_HOST_PARAM_PORT_SPEED: 328 return S_IRUGO; 329 default: 330 return 0; 331 } 332 case ISCSI_PARAM: 333 switch (param) { 334 case ISCSI_PARAM_PERSISTENT_ADDRESS: 335 case ISCSI_PARAM_PERSISTENT_PORT: 336 case ISCSI_PARAM_CONN_ADDRESS: 337 case ISCSI_PARAM_CONN_PORT: 338 case ISCSI_PARAM_TARGET_NAME: 339 case ISCSI_PARAM_TPGT: 340 case ISCSI_PARAM_TARGET_ALIAS: 341 case ISCSI_PARAM_MAX_BURST: 342 case ISCSI_PARAM_MAX_R2T: 343 case ISCSI_PARAM_FIRST_BURST: 344 case ISCSI_PARAM_MAX_RECV_DLENGTH: 345 case ISCSI_PARAM_MAX_XMIT_DLENGTH: 346 case ISCSI_PARAM_IFACE_NAME: 347 case ISCSI_PARAM_CHAP_OUT_IDX: 348 case ISCSI_PARAM_CHAP_IN_IDX: 349 case ISCSI_PARAM_USERNAME: 350 case ISCSI_PARAM_PASSWORD: 351 case ISCSI_PARAM_USERNAME_IN: 352 case ISCSI_PARAM_PASSWORD_IN: 353 return S_IRUGO; 354 default: 355 return 0; 356 } 357 case ISCSI_NET_PARAM: 358 switch (param) { 359 case ISCSI_NET_PARAM_IPV4_ADDR: 360 case ISCSI_NET_PARAM_IPV4_SUBNET: 361 case ISCSI_NET_PARAM_IPV4_GW: 362 case ISCSI_NET_PARAM_IPV4_BOOTPROTO: 363 case ISCSI_NET_PARAM_IFACE_ENABLE: 364 case ISCSI_NET_PARAM_IPV6_LINKLOCAL: 365 case ISCSI_NET_PARAM_IPV6_ADDR: 366 case ISCSI_NET_PARAM_IPV6_ROUTER: 367 case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG: 368 case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG: 369 case ISCSI_NET_PARAM_VLAN_ID: 370 case ISCSI_NET_PARAM_VLAN_PRIORITY: 371 case ISCSI_NET_PARAM_VLAN_ENABLED: 372 case ISCSI_NET_PARAM_MTU: 373 case ISCSI_NET_PARAM_PORT: 374 return S_IRUGO; 375 default: 376 return 0; 377 } 378 } 379 380 return 0; 381 } 382 383 static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx, 384 uint32_t *num_entries, char *buf) 385 { 386 struct scsi_qla_host *ha = to_qla_host(shost); 387 struct ql4_chap_table *chap_table; 388 struct iscsi_chap_rec *chap_rec; 389 int max_chap_entries = 0; 390 int valid_chap_entries = 0; 391 int ret = 0, i; 392 393 if (is_qla8022(ha)) 394 max_chap_entries = (ha->hw.flt_chap_size / 2) / 395 sizeof(struct ql4_chap_table); 396 else 397 max_chap_entries = MAX_CHAP_ENTRIES_40XX; 398 399 ql4_printk(KERN_INFO, ha, "%s: num_entries = %d, CHAP idx = %d\n", 400 __func__, *num_entries, chap_tbl_idx); 401 402 if (!buf) { 403 ret = -ENOMEM; 404 goto exit_get_chap_list; 405 } 406 407 chap_rec = (struct iscsi_chap_rec *) buf; 408 mutex_lock(&ha->chap_sem); 409 for (i = chap_tbl_idx; i < max_chap_entries; i++) { 410 chap_table = (struct ql4_chap_table *)ha->chap_list + i; 411 if (chap_table->cookie != 412 __constant_cpu_to_le16(CHAP_VALID_COOKIE)) 413 continue; 414 415 chap_rec->chap_tbl_idx = i; 416 strncpy(chap_rec->username, chap_table->name, 417 ISCSI_CHAP_AUTH_NAME_MAX_LEN); 418 strncpy(chap_rec->password, chap_table->secret, 419 QL4_CHAP_MAX_SECRET_LEN); 420 chap_rec->password_length = chap_table->secret_len; 421 422 if (chap_table->flags & BIT_7) /* local */ 423 chap_rec->chap_type = CHAP_TYPE_OUT; 424 425 if (chap_table->flags & BIT_6) /* peer */ 426 chap_rec->chap_type = CHAP_TYPE_IN; 427 428 chap_rec++; 429 430 valid_chap_entries++; 431 if (valid_chap_entries == *num_entries) 432 break; 433 else 434 continue; 435 } 436 mutex_unlock(&ha->chap_sem); 437 438 exit_get_chap_list: 439 ql4_printk(KERN_INFO, ha, "%s: Valid CHAP Entries = %d\n", 440 __func__, valid_chap_entries); 441 *num_entries = valid_chap_entries; 442 return ret; 443 } 444 445 static int __qla4xxx_is_chap_active(struct device *dev, void *data) 446 { 447 int ret = 0; 448 uint16_t *chap_tbl_idx = (uint16_t *) data; 449 struct iscsi_cls_session *cls_session; 450 struct iscsi_session *sess; 451 struct ddb_entry *ddb_entry; 452 453 if (!iscsi_is_session_dev(dev)) 454 goto exit_is_chap_active; 455 456 cls_session = iscsi_dev_to_session(dev); 457 sess = cls_session->dd_data; 458 ddb_entry = sess->dd_data; 459 460 if (iscsi_session_chkready(cls_session)) 461 goto exit_is_chap_active; 462 463 if (ddb_entry->chap_tbl_idx == *chap_tbl_idx) 464 ret = 1; 465 466 exit_is_chap_active: 467 return ret; 468 } 469 470 static int qla4xxx_is_chap_active(struct Scsi_Host *shost, 471 uint16_t chap_tbl_idx) 472 { 473 int ret = 0; 474 475 ret = device_for_each_child(&shost->shost_gendev, &chap_tbl_idx, 476 __qla4xxx_is_chap_active); 477 478 return ret; 479 } 480 481 static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx) 482 { 483 struct scsi_qla_host *ha = to_qla_host(shost); 484 struct ql4_chap_table *chap_table; 485 dma_addr_t chap_dma; 486 int max_chap_entries = 0; 487 uint32_t offset = 0; 488 uint32_t chap_size; 489 int ret = 0; 490 491 chap_table = dma_pool_alloc(ha->chap_dma_pool, GFP_KERNEL, &chap_dma); 492 if (chap_table == NULL) 493 return -ENOMEM; 494 495 memset(chap_table, 0, sizeof(struct ql4_chap_table)); 496 497 if (is_qla8022(ha)) 498 max_chap_entries = (ha->hw.flt_chap_size / 2) / 499 sizeof(struct ql4_chap_table); 500 else 501 max_chap_entries = MAX_CHAP_ENTRIES_40XX; 502 503 if (chap_tbl_idx > max_chap_entries) { 504 ret = -EINVAL; 505 goto exit_delete_chap; 506 } 507 508 /* Check if chap index is in use. 509 * If chap is in use don't delet chap entry */ 510 ret = qla4xxx_is_chap_active(shost, chap_tbl_idx); 511 if (ret) { 512 ql4_printk(KERN_INFO, ha, "CHAP entry %d is in use, cannot " 513 "delete from flash\n", chap_tbl_idx); 514 ret = -EBUSY; 515 goto exit_delete_chap; 516 } 517 518 chap_size = sizeof(struct ql4_chap_table); 519 if (is_qla40XX(ha)) 520 offset = FLASH_CHAP_OFFSET | (chap_tbl_idx * chap_size); 521 else { 522 offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2); 523 /* flt_chap_size is CHAP table size for both ports 524 * so divide it by 2 to calculate the offset for second port 525 */ 526 if (ha->port_num == 1) 527 offset += (ha->hw.flt_chap_size / 2); 528 offset += (chap_tbl_idx * chap_size); 529 } 530 531 ret = qla4xxx_get_flash(ha, chap_dma, offset, chap_size); 532 if (ret != QLA_SUCCESS) { 533 ret = -EINVAL; 534 goto exit_delete_chap; 535 } 536 537 DEBUG2(ql4_printk(KERN_INFO, ha, "Chap Cookie: x%x\n", 538 __le16_to_cpu(chap_table->cookie))); 539 540 if (__le16_to_cpu(chap_table->cookie) != CHAP_VALID_COOKIE) { 541 ql4_printk(KERN_ERR, ha, "No valid chap entry found\n"); 542 goto exit_delete_chap; 543 } 544 545 chap_table->cookie = __constant_cpu_to_le16(0xFFFF); 546 547 offset = FLASH_CHAP_OFFSET | 548 (chap_tbl_idx * sizeof(struct ql4_chap_table)); 549 ret = qla4xxx_set_flash(ha, chap_dma, offset, chap_size, 550 FLASH_OPT_RMW_COMMIT); 551 if (ret == QLA_SUCCESS && ha->chap_list) { 552 mutex_lock(&ha->chap_sem); 553 /* Update ha chap_list cache */ 554 memcpy((struct ql4_chap_table *)ha->chap_list + chap_tbl_idx, 555 chap_table, sizeof(struct ql4_chap_table)); 556 mutex_unlock(&ha->chap_sem); 557 } 558 if (ret != QLA_SUCCESS) 559 ret = -EINVAL; 560 561 exit_delete_chap: 562 dma_pool_free(ha->chap_dma_pool, chap_table, chap_dma); 563 return ret; 564 } 565 566 static int qla4xxx_get_iface_param(struct iscsi_iface *iface, 567 enum iscsi_param_type param_type, 568 int param, char *buf) 569 { 570 struct Scsi_Host *shost = iscsi_iface_to_shost(iface); 571 struct scsi_qla_host *ha = to_qla_host(shost); 572 int len = -ENOSYS; 573 574 if (param_type != ISCSI_NET_PARAM) 575 return -ENOSYS; 576 577 switch (param) { 578 case ISCSI_NET_PARAM_IPV4_ADDR: 579 len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address); 580 break; 581 case ISCSI_NET_PARAM_IPV4_SUBNET: 582 len = sprintf(buf, "%pI4\n", &ha->ip_config.subnet_mask); 583 break; 584 case ISCSI_NET_PARAM_IPV4_GW: 585 len = sprintf(buf, "%pI4\n", &ha->ip_config.gateway); 586 break; 587 case ISCSI_NET_PARAM_IFACE_ENABLE: 588 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) 589 len = sprintf(buf, "%s\n", 590 (ha->ip_config.ipv4_options & 591 IPOPT_IPV4_PROTOCOL_ENABLE) ? 592 "enabled" : "disabled"); 593 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) 594 len = sprintf(buf, "%s\n", 595 (ha->ip_config.ipv6_options & 596 IPV6_OPT_IPV6_PROTOCOL_ENABLE) ? 597 "enabled" : "disabled"); 598 break; 599 case ISCSI_NET_PARAM_IPV4_BOOTPROTO: 600 len = sprintf(buf, "%s\n", 601 (ha->ip_config.tcp_options & TCPOPT_DHCP_ENABLE) ? 602 "dhcp" : "static"); 603 break; 604 case ISCSI_NET_PARAM_IPV6_ADDR: 605 if (iface->iface_num == 0) 606 len = sprintf(buf, "%pI6\n", &ha->ip_config.ipv6_addr0); 607 if (iface->iface_num == 1) 608 len = sprintf(buf, "%pI6\n", &ha->ip_config.ipv6_addr1); 609 break; 610 case ISCSI_NET_PARAM_IPV6_LINKLOCAL: 611 len = sprintf(buf, "%pI6\n", 612 &ha->ip_config.ipv6_link_local_addr); 613 break; 614 case ISCSI_NET_PARAM_IPV6_ROUTER: 615 len = sprintf(buf, "%pI6\n", 616 &ha->ip_config.ipv6_default_router_addr); 617 break; 618 case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG: 619 len = sprintf(buf, "%s\n", 620 (ha->ip_config.ipv6_addl_options & 621 IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) ? 622 "nd" : "static"); 623 break; 624 case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG: 625 len = sprintf(buf, "%s\n", 626 (ha->ip_config.ipv6_addl_options & 627 IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR) ? 628 "auto" : "static"); 629 break; 630 case ISCSI_NET_PARAM_VLAN_ID: 631 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) 632 len = sprintf(buf, "%d\n", 633 (ha->ip_config.ipv4_vlan_tag & 634 ISCSI_MAX_VLAN_ID)); 635 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) 636 len = sprintf(buf, "%d\n", 637 (ha->ip_config.ipv6_vlan_tag & 638 ISCSI_MAX_VLAN_ID)); 639 break; 640 case ISCSI_NET_PARAM_VLAN_PRIORITY: 641 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) 642 len = sprintf(buf, "%d\n", 643 ((ha->ip_config.ipv4_vlan_tag >> 13) & 644 ISCSI_MAX_VLAN_PRIORITY)); 645 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) 646 len = sprintf(buf, "%d\n", 647 ((ha->ip_config.ipv6_vlan_tag >> 13) & 648 ISCSI_MAX_VLAN_PRIORITY)); 649 break; 650 case ISCSI_NET_PARAM_VLAN_ENABLED: 651 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) 652 len = sprintf(buf, "%s\n", 653 (ha->ip_config.ipv4_options & 654 IPOPT_VLAN_TAGGING_ENABLE) ? 655 "enabled" : "disabled"); 656 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) 657 len = sprintf(buf, "%s\n", 658 (ha->ip_config.ipv6_options & 659 IPV6_OPT_VLAN_TAGGING_ENABLE) ? 660 "enabled" : "disabled"); 661 break; 662 case ISCSI_NET_PARAM_MTU: 663 len = sprintf(buf, "%d\n", ha->ip_config.eth_mtu_size); 664 break; 665 case ISCSI_NET_PARAM_PORT: 666 if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) 667 len = sprintf(buf, "%d\n", ha->ip_config.ipv4_port); 668 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) 669 len = sprintf(buf, "%d\n", ha->ip_config.ipv6_port); 670 break; 671 default: 672 len = -ENOSYS; 673 } 674 675 return len; 676 } 677 678 static struct iscsi_endpoint * 679 qla4xxx_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr, 680 int non_blocking) 681 { 682 int ret; 683 struct iscsi_endpoint *ep; 684 struct qla_endpoint *qla_ep; 685 struct scsi_qla_host *ha; 686 struct sockaddr_in *addr; 687 struct sockaddr_in6 *addr6; 688 689 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 690 if (!shost) { 691 ret = -ENXIO; 692 printk(KERN_ERR "%s: shost is NULL\n", 693 __func__); 694 return ERR_PTR(ret); 695 } 696 697 ha = iscsi_host_priv(shost); 698 699 ep = iscsi_create_endpoint(sizeof(struct qla_endpoint)); 700 if (!ep) { 701 ret = -ENOMEM; 702 return ERR_PTR(ret); 703 } 704 705 qla_ep = ep->dd_data; 706 memset(qla_ep, 0, sizeof(struct qla_endpoint)); 707 if (dst_addr->sa_family == AF_INET) { 708 memcpy(&qla_ep->dst_addr, dst_addr, sizeof(struct sockaddr_in)); 709 addr = (struct sockaddr_in *)&qla_ep->dst_addr; 710 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI4\n", __func__, 711 (char *)&addr->sin_addr)); 712 } else if (dst_addr->sa_family == AF_INET6) { 713 memcpy(&qla_ep->dst_addr, dst_addr, 714 sizeof(struct sockaddr_in6)); 715 addr6 = (struct sockaddr_in6 *)&qla_ep->dst_addr; 716 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI6\n", __func__, 717 (char *)&addr6->sin6_addr)); 718 } 719 720 qla_ep->host = shost; 721 722 return ep; 723 } 724 725 static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms) 726 { 727 struct qla_endpoint *qla_ep; 728 struct scsi_qla_host *ha; 729 int ret = 0; 730 731 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 732 qla_ep = ep->dd_data; 733 ha = to_qla_host(qla_ep->host); 734 735 if (adapter_up(ha) && !test_bit(AF_BUILD_DDB_LIST, &ha->flags)) 736 ret = 1; 737 738 return ret; 739 } 740 741 static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep) 742 { 743 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 744 iscsi_destroy_endpoint(ep); 745 } 746 747 static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep, 748 enum iscsi_param param, 749 char *buf) 750 { 751 struct qla_endpoint *qla_ep = ep->dd_data; 752 struct sockaddr *dst_addr; 753 754 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 755 756 switch (param) { 757 case ISCSI_PARAM_CONN_PORT: 758 case ISCSI_PARAM_CONN_ADDRESS: 759 if (!qla_ep) 760 return -ENOTCONN; 761 762 dst_addr = (struct sockaddr *)&qla_ep->dst_addr; 763 if (!dst_addr) 764 return -ENOTCONN; 765 766 return iscsi_conn_get_addr_param((struct sockaddr_storage *) 767 &qla_ep->dst_addr, param, buf); 768 default: 769 return -ENOSYS; 770 } 771 } 772 773 static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn, 774 struct iscsi_stats *stats) 775 { 776 struct iscsi_session *sess; 777 struct iscsi_cls_session *cls_sess; 778 struct ddb_entry *ddb_entry; 779 struct scsi_qla_host *ha; 780 struct ql_iscsi_stats *ql_iscsi_stats; 781 int stats_size; 782 int ret; 783 dma_addr_t iscsi_stats_dma; 784 785 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 786 787 cls_sess = iscsi_conn_to_session(cls_conn); 788 sess = cls_sess->dd_data; 789 ddb_entry = sess->dd_data; 790 ha = ddb_entry->ha; 791 792 stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats)); 793 /* Allocate memory */ 794 ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size, 795 &iscsi_stats_dma, GFP_KERNEL); 796 if (!ql_iscsi_stats) { 797 ql4_printk(KERN_ERR, ha, 798 "Unable to allocate memory for iscsi stats\n"); 799 goto exit_get_stats; 800 } 801 802 ret = qla4xxx_get_mgmt_data(ha, ddb_entry->fw_ddb_index, stats_size, 803 iscsi_stats_dma); 804 if (ret != QLA_SUCCESS) { 805 ql4_printk(KERN_ERR, ha, 806 "Unable to retreive iscsi stats\n"); 807 goto free_stats; 808 } 809 810 /* octets */ 811 stats->txdata_octets = le64_to_cpu(ql_iscsi_stats->tx_data_octets); 812 stats->rxdata_octets = le64_to_cpu(ql_iscsi_stats->rx_data_octets); 813 /* xmit pdus */ 814 stats->noptx_pdus = le32_to_cpu(ql_iscsi_stats->tx_nopout_pdus); 815 stats->scsicmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_cmd_pdus); 816 stats->tmfcmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_tmf_cmd_pdus); 817 stats->login_pdus = le32_to_cpu(ql_iscsi_stats->tx_login_cmd_pdus); 818 stats->text_pdus = le32_to_cpu(ql_iscsi_stats->tx_text_cmd_pdus); 819 stats->dataout_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_write_pdus); 820 stats->logout_pdus = le32_to_cpu(ql_iscsi_stats->tx_logout_cmd_pdus); 821 stats->snack_pdus = le32_to_cpu(ql_iscsi_stats->tx_snack_req_pdus); 822 /* recv pdus */ 823 stats->noprx_pdus = le32_to_cpu(ql_iscsi_stats->rx_nopin_pdus); 824 stats->scsirsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_resp_pdus); 825 stats->tmfrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_tmf_resp_pdus); 826 stats->textrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_text_resp_pdus); 827 stats->datain_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_read_pdus); 828 stats->logoutrsp_pdus = 829 le32_to_cpu(ql_iscsi_stats->rx_logout_resp_pdus); 830 stats->r2t_pdus = le32_to_cpu(ql_iscsi_stats->rx_r2t_pdus); 831 stats->async_pdus = le32_to_cpu(ql_iscsi_stats->rx_async_pdus); 832 stats->rjt_pdus = le32_to_cpu(ql_iscsi_stats->rx_reject_pdus); 833 834 free_stats: 835 dma_free_coherent(&ha->pdev->dev, stats_size, ql_iscsi_stats, 836 iscsi_stats_dma); 837 exit_get_stats: 838 return; 839 } 840 841 static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc) 842 { 843 struct iscsi_cls_session *session; 844 struct iscsi_session *sess; 845 unsigned long flags; 846 enum blk_eh_timer_return ret = BLK_EH_NOT_HANDLED; 847 848 session = starget_to_session(scsi_target(sc->device)); 849 sess = session->dd_data; 850 851 spin_lock_irqsave(&session->lock, flags); 852 if (session->state == ISCSI_SESSION_FAILED) 853 ret = BLK_EH_RESET_TIMER; 854 spin_unlock_irqrestore(&session->lock, flags); 855 856 return ret; 857 } 858 859 static void qla4xxx_set_port_speed(struct Scsi_Host *shost) 860 { 861 struct scsi_qla_host *ha = to_qla_host(shost); 862 struct iscsi_cls_host *ihost = shost->shost_data; 863 uint32_t speed = ISCSI_PORT_SPEED_UNKNOWN; 864 865 qla4xxx_get_firmware_state(ha); 866 867 switch (ha->addl_fw_state & 0x0F00) { 868 case FW_ADDSTATE_LINK_SPEED_10MBPS: 869 speed = ISCSI_PORT_SPEED_10MBPS; 870 break; 871 case FW_ADDSTATE_LINK_SPEED_100MBPS: 872 speed = ISCSI_PORT_SPEED_100MBPS; 873 break; 874 case FW_ADDSTATE_LINK_SPEED_1GBPS: 875 speed = ISCSI_PORT_SPEED_1GBPS; 876 break; 877 case FW_ADDSTATE_LINK_SPEED_10GBPS: 878 speed = ISCSI_PORT_SPEED_10GBPS; 879 break; 880 } 881 ihost->port_speed = speed; 882 } 883 884 static void qla4xxx_set_port_state(struct Scsi_Host *shost) 885 { 886 struct scsi_qla_host *ha = to_qla_host(shost); 887 struct iscsi_cls_host *ihost = shost->shost_data; 888 uint32_t state = ISCSI_PORT_STATE_DOWN; 889 890 if (test_bit(AF_LINK_UP, &ha->flags)) 891 state = ISCSI_PORT_STATE_UP; 892 893 ihost->port_state = state; 894 } 895 896 static int qla4xxx_host_get_param(struct Scsi_Host *shost, 897 enum iscsi_host_param param, char *buf) 898 { 899 struct scsi_qla_host *ha = to_qla_host(shost); 900 int len; 901 902 switch (param) { 903 case ISCSI_HOST_PARAM_HWADDRESS: 904 len = sysfs_format_mac(buf, ha->my_mac, MAC_ADDR_LEN); 905 break; 906 case ISCSI_HOST_PARAM_IPADDRESS: 907 len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address); 908 break; 909 case ISCSI_HOST_PARAM_INITIATOR_NAME: 910 len = sprintf(buf, "%s\n", ha->name_string); 911 break; 912 case ISCSI_HOST_PARAM_PORT_STATE: 913 qla4xxx_set_port_state(shost); 914 len = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost)); 915 break; 916 case ISCSI_HOST_PARAM_PORT_SPEED: 917 qla4xxx_set_port_speed(shost); 918 len = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost)); 919 break; 920 default: 921 return -ENOSYS; 922 } 923 924 return len; 925 } 926 927 static void qla4xxx_create_ipv4_iface(struct scsi_qla_host *ha) 928 { 929 if (ha->iface_ipv4) 930 return; 931 932 /* IPv4 */ 933 ha->iface_ipv4 = iscsi_create_iface(ha->host, 934 &qla4xxx_iscsi_transport, 935 ISCSI_IFACE_TYPE_IPV4, 0, 0); 936 if (!ha->iface_ipv4) 937 ql4_printk(KERN_ERR, ha, "Could not create IPv4 iSCSI " 938 "iface0.\n"); 939 } 940 941 static void qla4xxx_create_ipv6_iface(struct scsi_qla_host *ha) 942 { 943 if (!ha->iface_ipv6_0) 944 /* IPv6 iface-0 */ 945 ha->iface_ipv6_0 = iscsi_create_iface(ha->host, 946 &qla4xxx_iscsi_transport, 947 ISCSI_IFACE_TYPE_IPV6, 0, 948 0); 949 if (!ha->iface_ipv6_0) 950 ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI " 951 "iface0.\n"); 952 953 if (!ha->iface_ipv6_1) 954 /* IPv6 iface-1 */ 955 ha->iface_ipv6_1 = iscsi_create_iface(ha->host, 956 &qla4xxx_iscsi_transport, 957 ISCSI_IFACE_TYPE_IPV6, 1, 958 0); 959 if (!ha->iface_ipv6_1) 960 ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI " 961 "iface1.\n"); 962 } 963 964 static void qla4xxx_create_ifaces(struct scsi_qla_host *ha) 965 { 966 if (ha->ip_config.ipv4_options & IPOPT_IPV4_PROTOCOL_ENABLE) 967 qla4xxx_create_ipv4_iface(ha); 968 969 if (ha->ip_config.ipv6_options & IPV6_OPT_IPV6_PROTOCOL_ENABLE) 970 qla4xxx_create_ipv6_iface(ha); 971 } 972 973 static void qla4xxx_destroy_ipv4_iface(struct scsi_qla_host *ha) 974 { 975 if (ha->iface_ipv4) { 976 iscsi_destroy_iface(ha->iface_ipv4); 977 ha->iface_ipv4 = NULL; 978 } 979 } 980 981 static void qla4xxx_destroy_ipv6_iface(struct scsi_qla_host *ha) 982 { 983 if (ha->iface_ipv6_0) { 984 iscsi_destroy_iface(ha->iface_ipv6_0); 985 ha->iface_ipv6_0 = NULL; 986 } 987 if (ha->iface_ipv6_1) { 988 iscsi_destroy_iface(ha->iface_ipv6_1); 989 ha->iface_ipv6_1 = NULL; 990 } 991 } 992 993 static void qla4xxx_destroy_ifaces(struct scsi_qla_host *ha) 994 { 995 qla4xxx_destroy_ipv4_iface(ha); 996 qla4xxx_destroy_ipv6_iface(ha); 997 } 998 999 static void qla4xxx_set_ipv6(struct scsi_qla_host *ha, 1000 struct iscsi_iface_param_info *iface_param, 1001 struct addr_ctrl_blk *init_fw_cb) 1002 { 1003 /* 1004 * iface_num 0 is valid for IPv6 Addr, linklocal, router, autocfg. 1005 * iface_num 1 is valid only for IPv6 Addr. 1006 */ 1007 switch (iface_param->param) { 1008 case ISCSI_NET_PARAM_IPV6_ADDR: 1009 if (iface_param->iface_num & 0x1) 1010 /* IPv6 Addr 1 */ 1011 memcpy(init_fw_cb->ipv6_addr1, iface_param->value, 1012 sizeof(init_fw_cb->ipv6_addr1)); 1013 else 1014 /* IPv6 Addr 0 */ 1015 memcpy(init_fw_cb->ipv6_addr0, iface_param->value, 1016 sizeof(init_fw_cb->ipv6_addr0)); 1017 break; 1018 case ISCSI_NET_PARAM_IPV6_LINKLOCAL: 1019 if (iface_param->iface_num & 0x1) 1020 break; 1021 memcpy(init_fw_cb->ipv6_if_id, &iface_param->value[8], 1022 sizeof(init_fw_cb->ipv6_if_id)); 1023 break; 1024 case ISCSI_NET_PARAM_IPV6_ROUTER: 1025 if (iface_param->iface_num & 0x1) 1026 break; 1027 memcpy(init_fw_cb->ipv6_dflt_rtr_addr, iface_param->value, 1028 sizeof(init_fw_cb->ipv6_dflt_rtr_addr)); 1029 break; 1030 case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG: 1031 /* Autocfg applies to even interface */ 1032 if (iface_param->iface_num & 0x1) 1033 break; 1034 1035 if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_DISABLE) 1036 init_fw_cb->ipv6_addtl_opts &= 1037 cpu_to_le16( 1038 ~IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE); 1039 else if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_ND_ENABLE) 1040 init_fw_cb->ipv6_addtl_opts |= 1041 cpu_to_le16( 1042 IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE); 1043 else 1044 ql4_printk(KERN_ERR, ha, "Invalid autocfg setting for " 1045 "IPv6 addr\n"); 1046 break; 1047 case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG: 1048 /* Autocfg applies to even interface */ 1049 if (iface_param->iface_num & 0x1) 1050 break; 1051 1052 if (iface_param->value[0] == 1053 ISCSI_IPV6_LINKLOCAL_AUTOCFG_ENABLE) 1054 init_fw_cb->ipv6_addtl_opts |= cpu_to_le16( 1055 IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR); 1056 else if (iface_param->value[0] == 1057 ISCSI_IPV6_LINKLOCAL_AUTOCFG_DISABLE) 1058 init_fw_cb->ipv6_addtl_opts &= cpu_to_le16( 1059 ~IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR); 1060 else 1061 ql4_printk(KERN_ERR, ha, "Invalid autocfg setting for " 1062 "IPv6 linklocal addr\n"); 1063 break; 1064 case ISCSI_NET_PARAM_IPV6_ROUTER_AUTOCFG: 1065 /* Autocfg applies to even interface */ 1066 if (iface_param->iface_num & 0x1) 1067 break; 1068 1069 if (iface_param->value[0] == ISCSI_IPV6_ROUTER_AUTOCFG_ENABLE) 1070 memset(init_fw_cb->ipv6_dflt_rtr_addr, 0, 1071 sizeof(init_fw_cb->ipv6_dflt_rtr_addr)); 1072 break; 1073 case ISCSI_NET_PARAM_IFACE_ENABLE: 1074 if (iface_param->value[0] == ISCSI_IFACE_ENABLE) { 1075 init_fw_cb->ipv6_opts |= 1076 cpu_to_le16(IPV6_OPT_IPV6_PROTOCOL_ENABLE); 1077 qla4xxx_create_ipv6_iface(ha); 1078 } else { 1079 init_fw_cb->ipv6_opts &= 1080 cpu_to_le16(~IPV6_OPT_IPV6_PROTOCOL_ENABLE & 1081 0xFFFF); 1082 qla4xxx_destroy_ipv6_iface(ha); 1083 } 1084 break; 1085 case ISCSI_NET_PARAM_VLAN_TAG: 1086 if (iface_param->len != sizeof(init_fw_cb->ipv6_vlan_tag)) 1087 break; 1088 init_fw_cb->ipv6_vlan_tag = 1089 cpu_to_be16(*(uint16_t *)iface_param->value); 1090 break; 1091 case ISCSI_NET_PARAM_VLAN_ENABLED: 1092 if (iface_param->value[0] == ISCSI_VLAN_ENABLE) 1093 init_fw_cb->ipv6_opts |= 1094 cpu_to_le16(IPV6_OPT_VLAN_TAGGING_ENABLE); 1095 else 1096 init_fw_cb->ipv6_opts &= 1097 cpu_to_le16(~IPV6_OPT_VLAN_TAGGING_ENABLE); 1098 break; 1099 case ISCSI_NET_PARAM_MTU: 1100 init_fw_cb->eth_mtu_size = 1101 cpu_to_le16(*(uint16_t *)iface_param->value); 1102 break; 1103 case ISCSI_NET_PARAM_PORT: 1104 /* Autocfg applies to even interface */ 1105 if (iface_param->iface_num & 0x1) 1106 break; 1107 1108 init_fw_cb->ipv6_port = 1109 cpu_to_le16(*(uint16_t *)iface_param->value); 1110 break; 1111 default: 1112 ql4_printk(KERN_ERR, ha, "Unknown IPv6 param = %d\n", 1113 iface_param->param); 1114 break; 1115 } 1116 } 1117 1118 static void qla4xxx_set_ipv4(struct scsi_qla_host *ha, 1119 struct iscsi_iface_param_info *iface_param, 1120 struct addr_ctrl_blk *init_fw_cb) 1121 { 1122 switch (iface_param->param) { 1123 case ISCSI_NET_PARAM_IPV4_ADDR: 1124 memcpy(init_fw_cb->ipv4_addr, iface_param->value, 1125 sizeof(init_fw_cb->ipv4_addr)); 1126 break; 1127 case ISCSI_NET_PARAM_IPV4_SUBNET: 1128 memcpy(init_fw_cb->ipv4_subnet, iface_param->value, 1129 sizeof(init_fw_cb->ipv4_subnet)); 1130 break; 1131 case ISCSI_NET_PARAM_IPV4_GW: 1132 memcpy(init_fw_cb->ipv4_gw_addr, iface_param->value, 1133 sizeof(init_fw_cb->ipv4_gw_addr)); 1134 break; 1135 case ISCSI_NET_PARAM_IPV4_BOOTPROTO: 1136 if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP) 1137 init_fw_cb->ipv4_tcp_opts |= 1138 cpu_to_le16(TCPOPT_DHCP_ENABLE); 1139 else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC) 1140 init_fw_cb->ipv4_tcp_opts &= 1141 cpu_to_le16(~TCPOPT_DHCP_ENABLE); 1142 else 1143 ql4_printk(KERN_ERR, ha, "Invalid IPv4 bootproto\n"); 1144 break; 1145 case ISCSI_NET_PARAM_IFACE_ENABLE: 1146 if (iface_param->value[0] == ISCSI_IFACE_ENABLE) { 1147 init_fw_cb->ipv4_ip_opts |= 1148 cpu_to_le16(IPOPT_IPV4_PROTOCOL_ENABLE); 1149 qla4xxx_create_ipv4_iface(ha); 1150 } else { 1151 init_fw_cb->ipv4_ip_opts &= 1152 cpu_to_le16(~IPOPT_IPV4_PROTOCOL_ENABLE & 1153 0xFFFF); 1154 qla4xxx_destroy_ipv4_iface(ha); 1155 } 1156 break; 1157 case ISCSI_NET_PARAM_VLAN_TAG: 1158 if (iface_param->len != sizeof(init_fw_cb->ipv4_vlan_tag)) 1159 break; 1160 init_fw_cb->ipv4_vlan_tag = 1161 cpu_to_be16(*(uint16_t *)iface_param->value); 1162 break; 1163 case ISCSI_NET_PARAM_VLAN_ENABLED: 1164 if (iface_param->value[0] == ISCSI_VLAN_ENABLE) 1165 init_fw_cb->ipv4_ip_opts |= 1166 cpu_to_le16(IPOPT_VLAN_TAGGING_ENABLE); 1167 else 1168 init_fw_cb->ipv4_ip_opts &= 1169 cpu_to_le16(~IPOPT_VLAN_TAGGING_ENABLE); 1170 break; 1171 case ISCSI_NET_PARAM_MTU: 1172 init_fw_cb->eth_mtu_size = 1173 cpu_to_le16(*(uint16_t *)iface_param->value); 1174 break; 1175 case ISCSI_NET_PARAM_PORT: 1176 init_fw_cb->ipv4_port = 1177 cpu_to_le16(*(uint16_t *)iface_param->value); 1178 break; 1179 default: 1180 ql4_printk(KERN_ERR, ha, "Unknown IPv4 param = %d\n", 1181 iface_param->param); 1182 break; 1183 } 1184 } 1185 1186 static void 1187 qla4xxx_initcb_to_acb(struct addr_ctrl_blk *init_fw_cb) 1188 { 1189 struct addr_ctrl_blk_def *acb; 1190 acb = (struct addr_ctrl_blk_def *)init_fw_cb; 1191 memset(acb->reserved1, 0, sizeof(acb->reserved1)); 1192 memset(acb->reserved2, 0, sizeof(acb->reserved2)); 1193 memset(acb->reserved3, 0, sizeof(acb->reserved3)); 1194 memset(acb->reserved4, 0, sizeof(acb->reserved4)); 1195 memset(acb->reserved5, 0, sizeof(acb->reserved5)); 1196 memset(acb->reserved6, 0, sizeof(acb->reserved6)); 1197 memset(acb->reserved7, 0, sizeof(acb->reserved7)); 1198 memset(acb->reserved8, 0, sizeof(acb->reserved8)); 1199 memset(acb->reserved9, 0, sizeof(acb->reserved9)); 1200 memset(acb->reserved10, 0, sizeof(acb->reserved10)); 1201 memset(acb->reserved11, 0, sizeof(acb->reserved11)); 1202 memset(acb->reserved12, 0, sizeof(acb->reserved12)); 1203 memset(acb->reserved13, 0, sizeof(acb->reserved13)); 1204 memset(acb->reserved14, 0, sizeof(acb->reserved14)); 1205 memset(acb->reserved15, 0, sizeof(acb->reserved15)); 1206 } 1207 1208 static int 1209 qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len) 1210 { 1211 struct scsi_qla_host *ha = to_qla_host(shost); 1212 int rval = 0; 1213 struct iscsi_iface_param_info *iface_param = NULL; 1214 struct addr_ctrl_blk *init_fw_cb = NULL; 1215 dma_addr_t init_fw_cb_dma; 1216 uint32_t mbox_cmd[MBOX_REG_COUNT]; 1217 uint32_t mbox_sts[MBOX_REG_COUNT]; 1218 uint32_t rem = len; 1219 struct nlattr *attr; 1220 1221 init_fw_cb = dma_alloc_coherent(&ha->pdev->dev, 1222 sizeof(struct addr_ctrl_blk), 1223 &init_fw_cb_dma, GFP_KERNEL); 1224 if (!init_fw_cb) { 1225 ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb\n", 1226 __func__); 1227 return -ENOMEM; 1228 } 1229 1230 memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk)); 1231 memset(&mbox_cmd, 0, sizeof(mbox_cmd)); 1232 memset(&mbox_sts, 0, sizeof(mbox_sts)); 1233 1234 if (qla4xxx_get_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma)) { 1235 ql4_printk(KERN_ERR, ha, "%s: get ifcb failed\n", __func__); 1236 rval = -EIO; 1237 goto exit_init_fw_cb; 1238 } 1239 1240 nla_for_each_attr(attr, data, len, rem) { 1241 iface_param = nla_data(attr); 1242 1243 if (iface_param->param_type != ISCSI_NET_PARAM) 1244 continue; 1245 1246 switch (iface_param->iface_type) { 1247 case ISCSI_IFACE_TYPE_IPV4: 1248 switch (iface_param->iface_num) { 1249 case 0: 1250 qla4xxx_set_ipv4(ha, iface_param, init_fw_cb); 1251 break; 1252 default: 1253 /* Cannot have more than one IPv4 interface */ 1254 ql4_printk(KERN_ERR, ha, "Invalid IPv4 iface " 1255 "number = %d\n", 1256 iface_param->iface_num); 1257 break; 1258 } 1259 break; 1260 case ISCSI_IFACE_TYPE_IPV6: 1261 switch (iface_param->iface_num) { 1262 case 0: 1263 case 1: 1264 qla4xxx_set_ipv6(ha, iface_param, init_fw_cb); 1265 break; 1266 default: 1267 /* Cannot have more than two IPv6 interface */ 1268 ql4_printk(KERN_ERR, ha, "Invalid IPv6 iface " 1269 "number = %d\n", 1270 iface_param->iface_num); 1271 break; 1272 } 1273 break; 1274 default: 1275 ql4_printk(KERN_ERR, ha, "Invalid iface type\n"); 1276 break; 1277 } 1278 } 1279 1280 init_fw_cb->cookie = cpu_to_le32(0x11BEAD5A); 1281 1282 rval = qla4xxx_set_flash(ha, init_fw_cb_dma, FLASH_SEGMENT_IFCB, 1283 sizeof(struct addr_ctrl_blk), 1284 FLASH_OPT_RMW_COMMIT); 1285 if (rval != QLA_SUCCESS) { 1286 ql4_printk(KERN_ERR, ha, "%s: set flash mbx failed\n", 1287 __func__); 1288 rval = -EIO; 1289 goto exit_init_fw_cb; 1290 } 1291 1292 rval = qla4xxx_disable_acb(ha); 1293 if (rval != QLA_SUCCESS) { 1294 ql4_printk(KERN_ERR, ha, "%s: disable acb mbx failed\n", 1295 __func__); 1296 rval = -EIO; 1297 goto exit_init_fw_cb; 1298 } 1299 1300 wait_for_completion_timeout(&ha->disable_acb_comp, 1301 DISABLE_ACB_TOV * HZ); 1302 1303 qla4xxx_initcb_to_acb(init_fw_cb); 1304 1305 rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma); 1306 if (rval != QLA_SUCCESS) { 1307 ql4_printk(KERN_ERR, ha, "%s: set acb mbx failed\n", 1308 __func__); 1309 rval = -EIO; 1310 goto exit_init_fw_cb; 1311 } 1312 1313 memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk)); 1314 qla4xxx_update_local_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb, 1315 init_fw_cb_dma); 1316 1317 exit_init_fw_cb: 1318 dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk), 1319 init_fw_cb, init_fw_cb_dma); 1320 1321 return rval; 1322 } 1323 1324 static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess, 1325 enum iscsi_param param, char *buf) 1326 { 1327 struct iscsi_session *sess = cls_sess->dd_data; 1328 struct ddb_entry *ddb_entry = sess->dd_data; 1329 struct scsi_qla_host *ha = ddb_entry->ha; 1330 int rval, len; 1331 uint16_t idx; 1332 1333 switch (param) { 1334 case ISCSI_PARAM_CHAP_IN_IDX: 1335 rval = qla4xxx_get_chap_index(ha, sess->username_in, 1336 sess->password_in, BIDI_CHAP, 1337 &idx); 1338 if (rval) 1339 return -EINVAL; 1340 1341 len = sprintf(buf, "%hu\n", idx); 1342 break; 1343 case ISCSI_PARAM_CHAP_OUT_IDX: 1344 rval = qla4xxx_get_chap_index(ha, sess->username, 1345 sess->password, LOCAL_CHAP, 1346 &idx); 1347 if (rval) 1348 return -EINVAL; 1349 1350 len = sprintf(buf, "%hu\n", idx); 1351 break; 1352 default: 1353 return iscsi_session_get_param(cls_sess, param, buf); 1354 } 1355 1356 return len; 1357 } 1358 1359 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *cls_conn, 1360 enum iscsi_param param, char *buf) 1361 { 1362 struct iscsi_conn *conn; 1363 struct qla_conn *qla_conn; 1364 struct sockaddr *dst_addr; 1365 int len = 0; 1366 1367 conn = cls_conn->dd_data; 1368 qla_conn = conn->dd_data; 1369 dst_addr = &qla_conn->qla_ep->dst_addr; 1370 1371 switch (param) { 1372 case ISCSI_PARAM_CONN_PORT: 1373 case ISCSI_PARAM_CONN_ADDRESS: 1374 return iscsi_conn_get_addr_param((struct sockaddr_storage *) 1375 dst_addr, param, buf); 1376 default: 1377 return iscsi_conn_get_param(cls_conn, param, buf); 1378 } 1379 1380 return len; 1381 1382 } 1383 1384 int qla4xxx_get_ddb_index(struct scsi_qla_host *ha, uint16_t *ddb_index) 1385 { 1386 uint32_t mbx_sts = 0; 1387 uint16_t tmp_ddb_index; 1388 int ret; 1389 1390 get_ddb_index: 1391 tmp_ddb_index = find_first_zero_bit(ha->ddb_idx_map, MAX_DDB_ENTRIES); 1392 1393 if (tmp_ddb_index >= MAX_DDB_ENTRIES) { 1394 DEBUG2(ql4_printk(KERN_INFO, ha, 1395 "Free DDB index not available\n")); 1396 ret = QLA_ERROR; 1397 goto exit_get_ddb_index; 1398 } 1399 1400 if (test_and_set_bit(tmp_ddb_index, ha->ddb_idx_map)) 1401 goto get_ddb_index; 1402 1403 DEBUG2(ql4_printk(KERN_INFO, ha, 1404 "Found a free DDB index at %d\n", tmp_ddb_index)); 1405 ret = qla4xxx_req_ddb_entry(ha, tmp_ddb_index, &mbx_sts); 1406 if (ret == QLA_ERROR) { 1407 if (mbx_sts == MBOX_STS_COMMAND_ERROR) { 1408 ql4_printk(KERN_INFO, ha, 1409 "DDB index = %d not available trying next\n", 1410 tmp_ddb_index); 1411 goto get_ddb_index; 1412 } 1413 DEBUG2(ql4_printk(KERN_INFO, ha, 1414 "Free FW DDB not available\n")); 1415 } 1416 1417 *ddb_index = tmp_ddb_index; 1418 1419 exit_get_ddb_index: 1420 return ret; 1421 } 1422 1423 static int qla4xxx_match_ipaddress(struct scsi_qla_host *ha, 1424 struct ddb_entry *ddb_entry, 1425 char *existing_ipaddr, 1426 char *user_ipaddr) 1427 { 1428 uint8_t dst_ipaddr[IPv6_ADDR_LEN]; 1429 char formatted_ipaddr[DDB_IPADDR_LEN]; 1430 int status = QLA_SUCCESS, ret = 0; 1431 1432 if (ddb_entry->fw_ddb_entry.options & DDB_OPT_IPV6_DEVICE) { 1433 ret = in6_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr, 1434 '\0', NULL); 1435 if (ret == 0) { 1436 status = QLA_ERROR; 1437 goto out_match; 1438 } 1439 ret = sprintf(formatted_ipaddr, "%pI6", dst_ipaddr); 1440 } else { 1441 ret = in4_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr, 1442 '\0', NULL); 1443 if (ret == 0) { 1444 status = QLA_ERROR; 1445 goto out_match; 1446 } 1447 ret = sprintf(formatted_ipaddr, "%pI4", dst_ipaddr); 1448 } 1449 1450 if (strcmp(existing_ipaddr, formatted_ipaddr)) 1451 status = QLA_ERROR; 1452 1453 out_match: 1454 return status; 1455 } 1456 1457 static int qla4xxx_match_fwdb_session(struct scsi_qla_host *ha, 1458 struct iscsi_cls_conn *cls_conn) 1459 { 1460 int idx = 0, max_ddbs, rval; 1461 struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn); 1462 struct iscsi_session *sess, *existing_sess; 1463 struct iscsi_conn *conn, *existing_conn; 1464 struct ddb_entry *ddb_entry; 1465 1466 sess = cls_sess->dd_data; 1467 conn = cls_conn->dd_data; 1468 1469 if (sess->targetname == NULL || 1470 conn->persistent_address == NULL || 1471 conn->persistent_port == 0) 1472 return QLA_ERROR; 1473 1474 max_ddbs = is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX : 1475 MAX_DEV_DB_ENTRIES; 1476 1477 for (idx = 0; idx < max_ddbs; idx++) { 1478 ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx); 1479 if (ddb_entry == NULL) 1480 continue; 1481 1482 if (ddb_entry->ddb_type != FLASH_DDB) 1483 continue; 1484 1485 existing_sess = ddb_entry->sess->dd_data; 1486 existing_conn = ddb_entry->conn->dd_data; 1487 1488 if (existing_sess->targetname == NULL || 1489 existing_conn->persistent_address == NULL || 1490 existing_conn->persistent_port == 0) 1491 continue; 1492 1493 DEBUG2(ql4_printk(KERN_INFO, ha, 1494 "IQN = %s User IQN = %s\n", 1495 existing_sess->targetname, 1496 sess->targetname)); 1497 1498 DEBUG2(ql4_printk(KERN_INFO, ha, 1499 "IP = %s User IP = %s\n", 1500 existing_conn->persistent_address, 1501 conn->persistent_address)); 1502 1503 DEBUG2(ql4_printk(KERN_INFO, ha, 1504 "Port = %d User Port = %d\n", 1505 existing_conn->persistent_port, 1506 conn->persistent_port)); 1507 1508 if (strcmp(existing_sess->targetname, sess->targetname)) 1509 continue; 1510 rval = qla4xxx_match_ipaddress(ha, ddb_entry, 1511 existing_conn->persistent_address, 1512 conn->persistent_address); 1513 if (rval == QLA_ERROR) 1514 continue; 1515 if (existing_conn->persistent_port != conn->persistent_port) 1516 continue; 1517 break; 1518 } 1519 1520 if (idx == max_ddbs) 1521 return QLA_ERROR; 1522 1523 DEBUG2(ql4_printk(KERN_INFO, ha, 1524 "Match found in fwdb sessions\n")); 1525 return QLA_SUCCESS; 1526 } 1527 1528 static struct iscsi_cls_session * 1529 qla4xxx_session_create(struct iscsi_endpoint *ep, 1530 uint16_t cmds_max, uint16_t qdepth, 1531 uint32_t initial_cmdsn) 1532 { 1533 struct iscsi_cls_session *cls_sess; 1534 struct scsi_qla_host *ha; 1535 struct qla_endpoint *qla_ep; 1536 struct ddb_entry *ddb_entry; 1537 uint16_t ddb_index; 1538 struct iscsi_session *sess; 1539 struct sockaddr *dst_addr; 1540 int ret; 1541 1542 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1543 if (!ep) { 1544 printk(KERN_ERR "qla4xxx: missing ep.\n"); 1545 return NULL; 1546 } 1547 1548 qla_ep = ep->dd_data; 1549 dst_addr = (struct sockaddr *)&qla_ep->dst_addr; 1550 ha = to_qla_host(qla_ep->host); 1551 1552 ret = qla4xxx_get_ddb_index(ha, &ddb_index); 1553 if (ret == QLA_ERROR) 1554 return NULL; 1555 1556 cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, qla_ep->host, 1557 cmds_max, sizeof(struct ddb_entry), 1558 sizeof(struct ql4_task_data), 1559 initial_cmdsn, ddb_index); 1560 if (!cls_sess) 1561 return NULL; 1562 1563 sess = cls_sess->dd_data; 1564 ddb_entry = sess->dd_data; 1565 ddb_entry->fw_ddb_index = ddb_index; 1566 ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE; 1567 ddb_entry->ha = ha; 1568 ddb_entry->sess = cls_sess; 1569 ddb_entry->unblock_sess = qla4xxx_unblock_ddb; 1570 ddb_entry->ddb_change = qla4xxx_ddb_change; 1571 cls_sess->recovery_tmo = ql4xsess_recovery_tmo; 1572 ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry; 1573 ha->tot_ddbs++; 1574 1575 return cls_sess; 1576 } 1577 1578 static void qla4xxx_session_destroy(struct iscsi_cls_session *cls_sess) 1579 { 1580 struct iscsi_session *sess; 1581 struct ddb_entry *ddb_entry; 1582 struct scsi_qla_host *ha; 1583 unsigned long flags, wtime; 1584 struct dev_db_entry *fw_ddb_entry = NULL; 1585 dma_addr_t fw_ddb_entry_dma; 1586 uint32_t ddb_state; 1587 int ret; 1588 1589 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1590 sess = cls_sess->dd_data; 1591 ddb_entry = sess->dd_data; 1592 ha = ddb_entry->ha; 1593 1594 fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 1595 &fw_ddb_entry_dma, GFP_KERNEL); 1596 if (!fw_ddb_entry) { 1597 ql4_printk(KERN_ERR, ha, 1598 "%s: Unable to allocate dma buffer\n", __func__); 1599 goto destroy_session; 1600 } 1601 1602 wtime = jiffies + (HZ * LOGOUT_TOV); 1603 do { 1604 ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, 1605 fw_ddb_entry, fw_ddb_entry_dma, 1606 NULL, NULL, &ddb_state, NULL, 1607 NULL, NULL); 1608 if (ret == QLA_ERROR) 1609 goto destroy_session; 1610 1611 if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) || 1612 (ddb_state == DDB_DS_SESSION_FAILED)) 1613 goto destroy_session; 1614 1615 schedule_timeout_uninterruptible(HZ); 1616 } while ((time_after(wtime, jiffies))); 1617 1618 destroy_session: 1619 qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index); 1620 1621 spin_lock_irqsave(&ha->hardware_lock, flags); 1622 qla4xxx_free_ddb(ha, ddb_entry); 1623 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1624 1625 iscsi_session_teardown(cls_sess); 1626 1627 if (fw_ddb_entry) 1628 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 1629 fw_ddb_entry, fw_ddb_entry_dma); 1630 } 1631 1632 static struct iscsi_cls_conn * 1633 qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx) 1634 { 1635 struct iscsi_cls_conn *cls_conn; 1636 struct iscsi_session *sess; 1637 struct ddb_entry *ddb_entry; 1638 1639 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1640 cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn), 1641 conn_idx); 1642 if (!cls_conn) 1643 return NULL; 1644 1645 sess = cls_sess->dd_data; 1646 ddb_entry = sess->dd_data; 1647 ddb_entry->conn = cls_conn; 1648 1649 return cls_conn; 1650 } 1651 1652 static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session, 1653 struct iscsi_cls_conn *cls_conn, 1654 uint64_t transport_fd, int is_leading) 1655 { 1656 struct iscsi_conn *conn; 1657 struct qla_conn *qla_conn; 1658 struct iscsi_endpoint *ep; 1659 1660 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1661 1662 if (iscsi_conn_bind(cls_session, cls_conn, is_leading)) 1663 return -EINVAL; 1664 ep = iscsi_lookup_endpoint(transport_fd); 1665 conn = cls_conn->dd_data; 1666 qla_conn = conn->dd_data; 1667 qla_conn->qla_ep = ep->dd_data; 1668 return 0; 1669 } 1670 1671 static int qla4xxx_conn_start(struct iscsi_cls_conn *cls_conn) 1672 { 1673 struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn); 1674 struct iscsi_session *sess; 1675 struct ddb_entry *ddb_entry; 1676 struct scsi_qla_host *ha; 1677 struct dev_db_entry *fw_ddb_entry = NULL; 1678 dma_addr_t fw_ddb_entry_dma; 1679 uint32_t mbx_sts = 0; 1680 int ret = 0; 1681 int status = QLA_SUCCESS; 1682 1683 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1684 sess = cls_sess->dd_data; 1685 ddb_entry = sess->dd_data; 1686 ha = ddb_entry->ha; 1687 1688 /* Check if we have matching FW DDB, if yes then do not 1689 * login to this target. This could cause target to logout previous 1690 * connection 1691 */ 1692 ret = qla4xxx_match_fwdb_session(ha, cls_conn); 1693 if (ret == QLA_SUCCESS) { 1694 ql4_printk(KERN_INFO, ha, 1695 "Session already exist in FW.\n"); 1696 ret = -EEXIST; 1697 goto exit_conn_start; 1698 } 1699 1700 fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 1701 &fw_ddb_entry_dma, GFP_KERNEL); 1702 if (!fw_ddb_entry) { 1703 ql4_printk(KERN_ERR, ha, 1704 "%s: Unable to allocate dma buffer\n", __func__); 1705 ret = -ENOMEM; 1706 goto exit_conn_start; 1707 } 1708 1709 ret = qla4xxx_set_param_ddbentry(ha, ddb_entry, cls_conn, &mbx_sts); 1710 if (ret) { 1711 /* If iscsid is stopped and started then no need to do 1712 * set param again since ddb state will be already 1713 * active and FW does not allow set ddb to an 1714 * active session. 1715 */ 1716 if (mbx_sts) 1717 if (ddb_entry->fw_ddb_device_state == 1718 DDB_DS_SESSION_ACTIVE) { 1719 ddb_entry->unblock_sess(ddb_entry->sess); 1720 goto exit_set_param; 1721 } 1722 1723 ql4_printk(KERN_ERR, ha, "%s: Failed set param for index[%d]\n", 1724 __func__, ddb_entry->fw_ddb_index); 1725 goto exit_conn_start; 1726 } 1727 1728 status = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index); 1729 if (status == QLA_ERROR) { 1730 ql4_printk(KERN_ERR, ha, "%s: Login failed: %s\n", __func__, 1731 sess->targetname); 1732 ret = -EINVAL; 1733 goto exit_conn_start; 1734 } 1735 1736 if (ddb_entry->fw_ddb_device_state == DDB_DS_NO_CONNECTION_ACTIVE) 1737 ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS; 1738 1739 DEBUG2(printk(KERN_INFO "%s: DDB state [%d]\n", __func__, 1740 ddb_entry->fw_ddb_device_state)); 1741 1742 exit_set_param: 1743 ret = 0; 1744 1745 exit_conn_start: 1746 if (fw_ddb_entry) 1747 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 1748 fw_ddb_entry, fw_ddb_entry_dma); 1749 return ret; 1750 } 1751 1752 static void qla4xxx_conn_destroy(struct iscsi_cls_conn *cls_conn) 1753 { 1754 struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn); 1755 struct iscsi_session *sess; 1756 struct scsi_qla_host *ha; 1757 struct ddb_entry *ddb_entry; 1758 int options; 1759 1760 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 1761 sess = cls_sess->dd_data; 1762 ddb_entry = sess->dd_data; 1763 ha = ddb_entry->ha; 1764 1765 options = LOGOUT_OPTION_CLOSE_SESSION; 1766 if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR) 1767 ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", __func__); 1768 } 1769 1770 static void qla4xxx_task_work(struct work_struct *wdata) 1771 { 1772 struct ql4_task_data *task_data; 1773 struct scsi_qla_host *ha; 1774 struct passthru_status *sts; 1775 struct iscsi_task *task; 1776 struct iscsi_hdr *hdr; 1777 uint8_t *data; 1778 uint32_t data_len; 1779 struct iscsi_conn *conn; 1780 int hdr_len; 1781 itt_t itt; 1782 1783 task_data = container_of(wdata, struct ql4_task_data, task_work); 1784 ha = task_data->ha; 1785 task = task_data->task; 1786 sts = &task_data->sts; 1787 hdr_len = sizeof(struct iscsi_hdr); 1788 1789 DEBUG3(printk(KERN_INFO "Status returned\n")); 1790 DEBUG3(qla4xxx_dump_buffer(sts, 64)); 1791 DEBUG3(printk(KERN_INFO "Response buffer")); 1792 DEBUG3(qla4xxx_dump_buffer(task_data->resp_buffer, 64)); 1793 1794 conn = task->conn; 1795 1796 switch (sts->completionStatus) { 1797 case PASSTHRU_STATUS_COMPLETE: 1798 hdr = (struct iscsi_hdr *)task_data->resp_buffer; 1799 /* Assign back the itt in hdr, until we use the PREASSIGN_TAG */ 1800 itt = sts->handle; 1801 hdr->itt = itt; 1802 data = task_data->resp_buffer + hdr_len; 1803 data_len = task_data->resp_len - hdr_len; 1804 iscsi_complete_pdu(conn, hdr, data, data_len); 1805 break; 1806 default: 1807 ql4_printk(KERN_ERR, ha, "Passthru failed status = 0x%x\n", 1808 sts->completionStatus); 1809 break; 1810 } 1811 return; 1812 } 1813 1814 static int qla4xxx_alloc_pdu(struct iscsi_task *task, uint8_t opcode) 1815 { 1816 struct ql4_task_data *task_data; 1817 struct iscsi_session *sess; 1818 struct ddb_entry *ddb_entry; 1819 struct scsi_qla_host *ha; 1820 int hdr_len; 1821 1822 sess = task->conn->session; 1823 ddb_entry = sess->dd_data; 1824 ha = ddb_entry->ha; 1825 task_data = task->dd_data; 1826 memset(task_data, 0, sizeof(struct ql4_task_data)); 1827 1828 if (task->sc) { 1829 ql4_printk(KERN_INFO, ha, 1830 "%s: SCSI Commands not implemented\n", __func__); 1831 return -EINVAL; 1832 } 1833 1834 hdr_len = sizeof(struct iscsi_hdr); 1835 task_data->ha = ha; 1836 task_data->task = task; 1837 1838 if (task->data_count) { 1839 task_data->data_dma = dma_map_single(&ha->pdev->dev, task->data, 1840 task->data_count, 1841 PCI_DMA_TODEVICE); 1842 } 1843 1844 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n", 1845 __func__, task->conn->max_recv_dlength, hdr_len)); 1846 1847 task_data->resp_len = task->conn->max_recv_dlength + hdr_len; 1848 task_data->resp_buffer = dma_alloc_coherent(&ha->pdev->dev, 1849 task_data->resp_len, 1850 &task_data->resp_dma, 1851 GFP_ATOMIC); 1852 if (!task_data->resp_buffer) 1853 goto exit_alloc_pdu; 1854 1855 task_data->req_len = task->data_count + hdr_len; 1856 task_data->req_buffer = dma_alloc_coherent(&ha->pdev->dev, 1857 task_data->req_len, 1858 &task_data->req_dma, 1859 GFP_ATOMIC); 1860 if (!task_data->req_buffer) 1861 goto exit_alloc_pdu; 1862 1863 task->hdr = task_data->req_buffer; 1864 1865 INIT_WORK(&task_data->task_work, qla4xxx_task_work); 1866 1867 return 0; 1868 1869 exit_alloc_pdu: 1870 if (task_data->resp_buffer) 1871 dma_free_coherent(&ha->pdev->dev, task_data->resp_len, 1872 task_data->resp_buffer, task_data->resp_dma); 1873 1874 if (task_data->req_buffer) 1875 dma_free_coherent(&ha->pdev->dev, task_data->req_len, 1876 task_data->req_buffer, task_data->req_dma); 1877 return -ENOMEM; 1878 } 1879 1880 static void qla4xxx_task_cleanup(struct iscsi_task *task) 1881 { 1882 struct ql4_task_data *task_data; 1883 struct iscsi_session *sess; 1884 struct ddb_entry *ddb_entry; 1885 struct scsi_qla_host *ha; 1886 int hdr_len; 1887 1888 hdr_len = sizeof(struct iscsi_hdr); 1889 sess = task->conn->session; 1890 ddb_entry = sess->dd_data; 1891 ha = ddb_entry->ha; 1892 task_data = task->dd_data; 1893 1894 if (task->data_count) { 1895 dma_unmap_single(&ha->pdev->dev, task_data->data_dma, 1896 task->data_count, PCI_DMA_TODEVICE); 1897 } 1898 1899 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n", 1900 __func__, task->conn->max_recv_dlength, hdr_len)); 1901 1902 dma_free_coherent(&ha->pdev->dev, task_data->resp_len, 1903 task_data->resp_buffer, task_data->resp_dma); 1904 dma_free_coherent(&ha->pdev->dev, task_data->req_len, 1905 task_data->req_buffer, task_data->req_dma); 1906 return; 1907 } 1908 1909 static int qla4xxx_task_xmit(struct iscsi_task *task) 1910 { 1911 struct scsi_cmnd *sc = task->sc; 1912 struct iscsi_session *sess = task->conn->session; 1913 struct ddb_entry *ddb_entry = sess->dd_data; 1914 struct scsi_qla_host *ha = ddb_entry->ha; 1915 1916 if (!sc) 1917 return qla4xxx_send_passthru0(task); 1918 1919 ql4_printk(KERN_INFO, ha, "%s: scsi cmd xmit not implemented\n", 1920 __func__); 1921 return -ENOSYS; 1922 } 1923 1924 static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha, 1925 struct dev_db_entry *fw_ddb_entry, 1926 struct iscsi_cls_session *cls_sess, 1927 struct iscsi_cls_conn *cls_conn) 1928 { 1929 int buflen = 0; 1930 struct iscsi_session *sess; 1931 struct ddb_entry *ddb_entry; 1932 struct iscsi_conn *conn; 1933 char ip_addr[DDB_IPADDR_LEN]; 1934 uint16_t options = 0; 1935 1936 sess = cls_sess->dd_data; 1937 ddb_entry = sess->dd_data; 1938 conn = cls_conn->dd_data; 1939 1940 ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx); 1941 1942 conn->max_recv_dlength = BYTE_UNITS * 1943 le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len); 1944 1945 conn->max_xmit_dlength = BYTE_UNITS * 1946 le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len); 1947 1948 sess->initial_r2t_en = 1949 (BIT_10 & le16_to_cpu(fw_ddb_entry->iscsi_options)); 1950 1951 sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t); 1952 1953 sess->imm_data_en = (BIT_11 & le16_to_cpu(fw_ddb_entry->iscsi_options)); 1954 1955 sess->first_burst = BYTE_UNITS * 1956 le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len); 1957 1958 sess->max_burst = BYTE_UNITS * 1959 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len); 1960 1961 sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait); 1962 1963 sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain); 1964 1965 conn->persistent_port = le16_to_cpu(fw_ddb_entry->port); 1966 1967 sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp); 1968 1969 options = le16_to_cpu(fw_ddb_entry->options); 1970 if (options & DDB_OPT_IPV6_DEVICE) 1971 sprintf(ip_addr, "%pI6", fw_ddb_entry->ip_addr); 1972 else 1973 sprintf(ip_addr, "%pI4", fw_ddb_entry->ip_addr); 1974 1975 iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_NAME, 1976 (char *)fw_ddb_entry->iscsi_name, buflen); 1977 iscsi_set_param(cls_conn, ISCSI_PARAM_INITIATOR_NAME, 1978 (char *)ha->name_string, buflen); 1979 iscsi_set_param(cls_conn, ISCSI_PARAM_PERSISTENT_ADDRESS, 1980 (char *)ip_addr, buflen); 1981 iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_ALIAS, 1982 (char *)fw_ddb_entry->iscsi_alias, buflen); 1983 } 1984 1985 void qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host *ha, 1986 struct ddb_entry *ddb_entry) 1987 { 1988 struct iscsi_cls_session *cls_sess; 1989 struct iscsi_cls_conn *cls_conn; 1990 uint32_t ddb_state; 1991 dma_addr_t fw_ddb_entry_dma; 1992 struct dev_db_entry *fw_ddb_entry; 1993 1994 fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 1995 &fw_ddb_entry_dma, GFP_KERNEL); 1996 if (!fw_ddb_entry) { 1997 ql4_printk(KERN_ERR, ha, 1998 "%s: Unable to allocate dma buffer\n", __func__); 1999 goto exit_session_conn_fwddb_param; 2000 } 2001 2002 if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry, 2003 fw_ddb_entry_dma, NULL, NULL, &ddb_state, 2004 NULL, NULL, NULL) == QLA_ERROR) { 2005 DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed " 2006 "get_ddb_entry for fw_ddb_index %d\n", 2007 ha->host_no, __func__, 2008 ddb_entry->fw_ddb_index)); 2009 goto exit_session_conn_fwddb_param; 2010 } 2011 2012 cls_sess = ddb_entry->sess; 2013 2014 cls_conn = ddb_entry->conn; 2015 2016 /* Update params */ 2017 qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn); 2018 2019 exit_session_conn_fwddb_param: 2020 if (fw_ddb_entry) 2021 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 2022 fw_ddb_entry, fw_ddb_entry_dma); 2023 } 2024 2025 void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha, 2026 struct ddb_entry *ddb_entry) 2027 { 2028 struct iscsi_cls_session *cls_sess; 2029 struct iscsi_cls_conn *cls_conn; 2030 struct iscsi_session *sess; 2031 struct iscsi_conn *conn; 2032 uint32_t ddb_state; 2033 dma_addr_t fw_ddb_entry_dma; 2034 struct dev_db_entry *fw_ddb_entry; 2035 2036 fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 2037 &fw_ddb_entry_dma, GFP_KERNEL); 2038 if (!fw_ddb_entry) { 2039 ql4_printk(KERN_ERR, ha, 2040 "%s: Unable to allocate dma buffer\n", __func__); 2041 goto exit_session_conn_param; 2042 } 2043 2044 if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry, 2045 fw_ddb_entry_dma, NULL, NULL, &ddb_state, 2046 NULL, NULL, NULL) == QLA_ERROR) { 2047 DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed " 2048 "get_ddb_entry for fw_ddb_index %d\n", 2049 ha->host_no, __func__, 2050 ddb_entry->fw_ddb_index)); 2051 goto exit_session_conn_param; 2052 } 2053 2054 cls_sess = ddb_entry->sess; 2055 sess = cls_sess->dd_data; 2056 2057 cls_conn = ddb_entry->conn; 2058 conn = cls_conn->dd_data; 2059 2060 /* Update timers after login */ 2061 ddb_entry->default_relogin_timeout = 2062 (le16_to_cpu(fw_ddb_entry->def_timeout) > LOGIN_TOV) && 2063 (le16_to_cpu(fw_ddb_entry->def_timeout) < LOGIN_TOV * 10) ? 2064 le16_to_cpu(fw_ddb_entry->def_timeout) : LOGIN_TOV; 2065 ddb_entry->default_time2wait = 2066 le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait); 2067 2068 /* Update params */ 2069 ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx); 2070 conn->max_recv_dlength = BYTE_UNITS * 2071 le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len); 2072 2073 conn->max_xmit_dlength = BYTE_UNITS * 2074 le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len); 2075 2076 sess->initial_r2t_en = 2077 (BIT_10 & le16_to_cpu(fw_ddb_entry->iscsi_options)); 2078 2079 sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t); 2080 2081 sess->imm_data_en = (BIT_11 & le16_to_cpu(fw_ddb_entry->iscsi_options)); 2082 2083 sess->first_burst = BYTE_UNITS * 2084 le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len); 2085 2086 sess->max_burst = BYTE_UNITS * 2087 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len); 2088 2089 sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait); 2090 2091 sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain); 2092 2093 sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp); 2094 2095 memcpy(sess->initiatorname, ha->name_string, 2096 min(sizeof(ha->name_string), sizeof(sess->initiatorname))); 2097 2098 iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_ALIAS, 2099 (char *)fw_ddb_entry->iscsi_alias, 0); 2100 2101 exit_session_conn_param: 2102 if (fw_ddb_entry) 2103 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 2104 fw_ddb_entry, fw_ddb_entry_dma); 2105 } 2106 2107 /* 2108 * Timer routines 2109 */ 2110 2111 static void qla4xxx_start_timer(struct scsi_qla_host *ha, void *func, 2112 unsigned long interval) 2113 { 2114 DEBUG(printk("scsi: %s: Starting timer thread for adapter %d\n", 2115 __func__, ha->host->host_no)); 2116 init_timer(&ha->timer); 2117 ha->timer.expires = jiffies + interval * HZ; 2118 ha->timer.data = (unsigned long)ha; 2119 ha->timer.function = (void (*)(unsigned long))func; 2120 add_timer(&ha->timer); 2121 ha->timer_active = 1; 2122 } 2123 2124 static void qla4xxx_stop_timer(struct scsi_qla_host *ha) 2125 { 2126 del_timer_sync(&ha->timer); 2127 ha->timer_active = 0; 2128 } 2129 2130 /*** 2131 * qla4xxx_mark_device_missing - blocks the session 2132 * @cls_session: Pointer to the session to be blocked 2133 * @ddb_entry: Pointer to device database entry 2134 * 2135 * This routine marks a device missing and close connection. 2136 **/ 2137 void qla4xxx_mark_device_missing(struct iscsi_cls_session *cls_session) 2138 { 2139 iscsi_block_session(cls_session); 2140 } 2141 2142 /** 2143 * qla4xxx_mark_all_devices_missing - mark all devices as missing. 2144 * @ha: Pointer to host adapter structure. 2145 * 2146 * This routine marks a device missing and resets the relogin retry count. 2147 **/ 2148 void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha) 2149 { 2150 iscsi_host_for_each_session(ha->host, qla4xxx_mark_device_missing); 2151 } 2152 2153 static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha, 2154 struct ddb_entry *ddb_entry, 2155 struct scsi_cmnd *cmd) 2156 { 2157 struct srb *srb; 2158 2159 srb = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); 2160 if (!srb) 2161 return srb; 2162 2163 kref_init(&srb->srb_ref); 2164 srb->ha = ha; 2165 srb->ddb = ddb_entry; 2166 srb->cmd = cmd; 2167 srb->flags = 0; 2168 CMD_SP(cmd) = (void *)srb; 2169 2170 return srb; 2171 } 2172 2173 static void qla4xxx_srb_free_dma(struct scsi_qla_host *ha, struct srb *srb) 2174 { 2175 struct scsi_cmnd *cmd = srb->cmd; 2176 2177 if (srb->flags & SRB_DMA_VALID) { 2178 scsi_dma_unmap(cmd); 2179 srb->flags &= ~SRB_DMA_VALID; 2180 } 2181 CMD_SP(cmd) = NULL; 2182 } 2183 2184 void qla4xxx_srb_compl(struct kref *ref) 2185 { 2186 struct srb *srb = container_of(ref, struct srb, srb_ref); 2187 struct scsi_cmnd *cmd = srb->cmd; 2188 struct scsi_qla_host *ha = srb->ha; 2189 2190 qla4xxx_srb_free_dma(ha, srb); 2191 2192 mempool_free(srb, ha->srb_mempool); 2193 2194 cmd->scsi_done(cmd); 2195 } 2196 2197 /** 2198 * qla4xxx_queuecommand - scsi layer issues scsi command to driver. 2199 * @host: scsi host 2200 * @cmd: Pointer to Linux's SCSI command structure 2201 * 2202 * Remarks: 2203 * This routine is invoked by Linux to send a SCSI command to the driver. 2204 * The mid-level driver tries to ensure that queuecommand never gets 2205 * invoked concurrently with itself or the interrupt handler (although 2206 * the interrupt handler may call this routine as part of request- 2207 * completion handling). Unfortunely, it sometimes calls the scheduler 2208 * in interrupt context which is a big NO! NO!. 2209 **/ 2210 static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) 2211 { 2212 struct scsi_qla_host *ha = to_qla_host(host); 2213 struct ddb_entry *ddb_entry = cmd->device->hostdata; 2214 struct iscsi_cls_session *sess = ddb_entry->sess; 2215 struct srb *srb; 2216 int rval; 2217 2218 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 2219 if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags)) 2220 cmd->result = DID_NO_CONNECT << 16; 2221 else 2222 cmd->result = DID_REQUEUE << 16; 2223 goto qc_fail_command; 2224 } 2225 2226 if (!sess) { 2227 cmd->result = DID_IMM_RETRY << 16; 2228 goto qc_fail_command; 2229 } 2230 2231 rval = iscsi_session_chkready(sess); 2232 if (rval) { 2233 cmd->result = rval; 2234 goto qc_fail_command; 2235 } 2236 2237 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 2238 test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) || 2239 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 2240 test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) || 2241 test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) || 2242 !test_bit(AF_ONLINE, &ha->flags) || 2243 !test_bit(AF_LINK_UP, &ha->flags) || 2244 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) 2245 goto qc_host_busy; 2246 2247 srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd); 2248 if (!srb) 2249 goto qc_host_busy; 2250 2251 rval = qla4xxx_send_command_to_isp(ha, srb); 2252 if (rval != QLA_SUCCESS) 2253 goto qc_host_busy_free_sp; 2254 2255 return 0; 2256 2257 qc_host_busy_free_sp: 2258 qla4xxx_srb_free_dma(ha, srb); 2259 mempool_free(srb, ha->srb_mempool); 2260 2261 qc_host_busy: 2262 return SCSI_MLQUEUE_HOST_BUSY; 2263 2264 qc_fail_command: 2265 cmd->scsi_done(cmd); 2266 2267 return 0; 2268 } 2269 2270 /** 2271 * qla4xxx_mem_free - frees memory allocated to adapter 2272 * @ha: Pointer to host adapter structure. 2273 * 2274 * Frees memory previously allocated by qla4xxx_mem_alloc 2275 **/ 2276 static void qla4xxx_mem_free(struct scsi_qla_host *ha) 2277 { 2278 if (ha->queues) 2279 dma_free_coherent(&ha->pdev->dev, ha->queues_len, ha->queues, 2280 ha->queues_dma); 2281 2282 if (ha->fw_dump) 2283 vfree(ha->fw_dump); 2284 2285 ha->queues_len = 0; 2286 ha->queues = NULL; 2287 ha->queues_dma = 0; 2288 ha->request_ring = NULL; 2289 ha->request_dma = 0; 2290 ha->response_ring = NULL; 2291 ha->response_dma = 0; 2292 ha->shadow_regs = NULL; 2293 ha->shadow_regs_dma = 0; 2294 ha->fw_dump = NULL; 2295 ha->fw_dump_size = 0; 2296 2297 /* Free srb pool. */ 2298 if (ha->srb_mempool) 2299 mempool_destroy(ha->srb_mempool); 2300 2301 ha->srb_mempool = NULL; 2302 2303 if (ha->chap_dma_pool) 2304 dma_pool_destroy(ha->chap_dma_pool); 2305 2306 if (ha->chap_list) 2307 vfree(ha->chap_list); 2308 ha->chap_list = NULL; 2309 2310 if (ha->fw_ddb_dma_pool) 2311 dma_pool_destroy(ha->fw_ddb_dma_pool); 2312 2313 /* release io space registers */ 2314 if (is_qla8022(ha)) { 2315 if (ha->nx_pcibase) 2316 iounmap( 2317 (struct device_reg_82xx __iomem *)ha->nx_pcibase); 2318 } else if (ha->reg) 2319 iounmap(ha->reg); 2320 pci_release_regions(ha->pdev); 2321 } 2322 2323 /** 2324 * qla4xxx_mem_alloc - allocates memory for use by adapter. 2325 * @ha: Pointer to host adapter structure 2326 * 2327 * Allocates DMA memory for request and response queues. Also allocates memory 2328 * for srbs. 2329 **/ 2330 static int qla4xxx_mem_alloc(struct scsi_qla_host *ha) 2331 { 2332 unsigned long align; 2333 2334 /* Allocate contiguous block of DMA memory for queues. */ 2335 ha->queues_len = ((REQUEST_QUEUE_DEPTH * QUEUE_SIZE) + 2336 (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE) + 2337 sizeof(struct shadow_regs) + 2338 MEM_ALIGN_VALUE + 2339 (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1); 2340 ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len, 2341 &ha->queues_dma, GFP_KERNEL); 2342 if (ha->queues == NULL) { 2343 ql4_printk(KERN_WARNING, ha, 2344 "Memory Allocation failed - queues.\n"); 2345 2346 goto mem_alloc_error_exit; 2347 } 2348 memset(ha->queues, 0, ha->queues_len); 2349 2350 /* 2351 * As per RISC alignment requirements -- the bus-address must be a 2352 * multiple of the request-ring size (in bytes). 2353 */ 2354 align = 0; 2355 if ((unsigned long)ha->queues_dma & (MEM_ALIGN_VALUE - 1)) 2356 align = MEM_ALIGN_VALUE - ((unsigned long)ha->queues_dma & 2357 (MEM_ALIGN_VALUE - 1)); 2358 2359 /* Update request and response queue pointers. */ 2360 ha->request_dma = ha->queues_dma + align; 2361 ha->request_ring = (struct queue_entry *) (ha->queues + align); 2362 ha->response_dma = ha->queues_dma + align + 2363 (REQUEST_QUEUE_DEPTH * QUEUE_SIZE); 2364 ha->response_ring = (struct queue_entry *) (ha->queues + align + 2365 (REQUEST_QUEUE_DEPTH * 2366 QUEUE_SIZE)); 2367 ha->shadow_regs_dma = ha->queues_dma + align + 2368 (REQUEST_QUEUE_DEPTH * QUEUE_SIZE) + 2369 (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE); 2370 ha->shadow_regs = (struct shadow_regs *) (ha->queues + align + 2371 (REQUEST_QUEUE_DEPTH * 2372 QUEUE_SIZE) + 2373 (RESPONSE_QUEUE_DEPTH * 2374 QUEUE_SIZE)); 2375 2376 /* Allocate memory for srb pool. */ 2377 ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab, 2378 mempool_free_slab, srb_cachep); 2379 if (ha->srb_mempool == NULL) { 2380 ql4_printk(KERN_WARNING, ha, 2381 "Memory Allocation failed - SRB Pool.\n"); 2382 2383 goto mem_alloc_error_exit; 2384 } 2385 2386 ha->chap_dma_pool = dma_pool_create("ql4_chap", &ha->pdev->dev, 2387 CHAP_DMA_BLOCK_SIZE, 8, 0); 2388 2389 if (ha->chap_dma_pool == NULL) { 2390 ql4_printk(KERN_WARNING, ha, 2391 "%s: chap_dma_pool allocation failed..\n", __func__); 2392 goto mem_alloc_error_exit; 2393 } 2394 2395 ha->fw_ddb_dma_pool = dma_pool_create("ql4_fw_ddb", &ha->pdev->dev, 2396 DDB_DMA_BLOCK_SIZE, 8, 0); 2397 2398 if (ha->fw_ddb_dma_pool == NULL) { 2399 ql4_printk(KERN_WARNING, ha, 2400 "%s: fw_ddb_dma_pool allocation failed..\n", 2401 __func__); 2402 goto mem_alloc_error_exit; 2403 } 2404 2405 return QLA_SUCCESS; 2406 2407 mem_alloc_error_exit: 2408 qla4xxx_mem_free(ha); 2409 return QLA_ERROR; 2410 } 2411 2412 /** 2413 * qla4_8xxx_check_temp - Check the ISP82XX temperature. 2414 * @ha: adapter block pointer. 2415 * 2416 * Note: The caller should not hold the idc lock. 2417 **/ 2418 static int qla4_8xxx_check_temp(struct scsi_qla_host *ha) 2419 { 2420 uint32_t temp, temp_state, temp_val; 2421 int status = QLA_SUCCESS; 2422 2423 temp = qla4_8xxx_rd_32(ha, CRB_TEMP_STATE); 2424 2425 temp_state = qla82xx_get_temp_state(temp); 2426 temp_val = qla82xx_get_temp_val(temp); 2427 2428 if (temp_state == QLA82XX_TEMP_PANIC) { 2429 ql4_printk(KERN_WARNING, ha, "Device temperature %d degrees C" 2430 " exceeds maximum allowed. Hardware has been shut" 2431 " down.\n", temp_val); 2432 status = QLA_ERROR; 2433 } else if (temp_state == QLA82XX_TEMP_WARN) { 2434 if (ha->temperature == QLA82XX_TEMP_NORMAL) 2435 ql4_printk(KERN_WARNING, ha, "Device temperature %d" 2436 " degrees C exceeds operating range." 2437 " Immediate action needed.\n", temp_val); 2438 } else { 2439 if (ha->temperature == QLA82XX_TEMP_WARN) 2440 ql4_printk(KERN_INFO, ha, "Device temperature is" 2441 " now %d degrees C in normal range.\n", 2442 temp_val); 2443 } 2444 ha->temperature = temp_state; 2445 return status; 2446 } 2447 2448 /** 2449 * qla4_8xxx_check_fw_alive - Check firmware health 2450 * @ha: Pointer to host adapter structure. 2451 * 2452 * Context: Interrupt 2453 **/ 2454 static int qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha) 2455 { 2456 uint32_t fw_heartbeat_counter; 2457 int status = QLA_SUCCESS; 2458 2459 fw_heartbeat_counter = qla4_8xxx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER); 2460 /* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */ 2461 if (fw_heartbeat_counter == 0xffffffff) { 2462 DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen " 2463 "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff\n", 2464 ha->host_no, __func__)); 2465 return status; 2466 } 2467 2468 if (ha->fw_heartbeat_counter == fw_heartbeat_counter) { 2469 ha->seconds_since_last_heartbeat++; 2470 /* FW not alive after 2 seconds */ 2471 if (ha->seconds_since_last_heartbeat == 2) { 2472 ha->seconds_since_last_heartbeat = 0; 2473 2474 ql4_printk(KERN_INFO, ha, 2475 "scsi(%ld): %s, Dumping hw/fw registers:\n " 2476 " PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2:" 2477 " 0x%x,\n PEG_NET_0_PC: 0x%x, PEG_NET_1_PC:" 2478 " 0x%x,\n PEG_NET_2_PC: 0x%x, PEG_NET_3_PC:" 2479 " 0x%x,\n PEG_NET_4_PC: 0x%x\n", 2480 ha->host_no, __func__, 2481 qla4_8xxx_rd_32(ha, 2482 QLA82XX_PEG_HALT_STATUS1), 2483 qla4_8xxx_rd_32(ha, 2484 QLA82XX_PEG_HALT_STATUS2), 2485 qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_0 + 2486 0x3c), 2487 qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_1 + 2488 0x3c), 2489 qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_2 + 2490 0x3c), 2491 qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_3 + 2492 0x3c), 2493 qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_4 + 2494 0x3c)); 2495 status = QLA_ERROR; 2496 } 2497 } else 2498 ha->seconds_since_last_heartbeat = 0; 2499 2500 ha->fw_heartbeat_counter = fw_heartbeat_counter; 2501 return status; 2502 } 2503 2504 /** 2505 * qla4_8xxx_watchdog - Poll dev state 2506 * @ha: Pointer to host adapter structure. 2507 * 2508 * Context: Interrupt 2509 **/ 2510 void qla4_8xxx_watchdog(struct scsi_qla_host *ha) 2511 { 2512 uint32_t dev_state, halt_status; 2513 2514 /* don't poll if reset is going on */ 2515 if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) || 2516 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 2517 test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags))) { 2518 dev_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE); 2519 2520 if (qla4_8xxx_check_temp(ha)) { 2521 ql4_printk(KERN_INFO, ha, "disabling pause" 2522 " transmit on port 0 & 1.\n"); 2523 qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x98, 2524 CRB_NIU_XG_PAUSE_CTL_P0 | 2525 CRB_NIU_XG_PAUSE_CTL_P1); 2526 set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags); 2527 qla4xxx_wake_dpc(ha); 2528 } else if (dev_state == QLA82XX_DEV_NEED_RESET && 2529 !test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 2530 if (!ql4xdontresethba) { 2531 ql4_printk(KERN_INFO, ha, "%s: HW State: " 2532 "NEED RESET!\n", __func__); 2533 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2534 qla4xxx_wake_dpc(ha); 2535 } 2536 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT && 2537 !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 2538 ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!\n", 2539 __func__); 2540 set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags); 2541 qla4xxx_wake_dpc(ha); 2542 } else { 2543 /* Check firmware health */ 2544 if (qla4_8xxx_check_fw_alive(ha)) { 2545 ql4_printk(KERN_INFO, ha, "disabling pause" 2546 " transmit on port 0 & 1.\n"); 2547 qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x98, 2548 CRB_NIU_XG_PAUSE_CTL_P0 | 2549 CRB_NIU_XG_PAUSE_CTL_P1); 2550 halt_status = qla4_8xxx_rd_32(ha, 2551 QLA82XX_PEG_HALT_STATUS1); 2552 2553 if (QLA82XX_FWERROR_CODE(halt_status) == 0x67) 2554 ql4_printk(KERN_ERR, ha, "%s:" 2555 " Firmware aborted with" 2556 " error code 0x00006700." 2557 " Device is being reset\n", 2558 __func__); 2559 2560 /* Since we cannot change dev_state in interrupt 2561 * context, set appropriate DPC flag then wakeup 2562 * DPC */ 2563 if (halt_status & HALT_STATUS_UNRECOVERABLE) 2564 set_bit(DPC_HA_UNRECOVERABLE, 2565 &ha->dpc_flags); 2566 else { 2567 ql4_printk(KERN_INFO, ha, "%s: detect " 2568 "abort needed!\n", __func__); 2569 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2570 } 2571 qla4xxx_mailbox_premature_completion(ha); 2572 qla4xxx_wake_dpc(ha); 2573 } 2574 } 2575 } 2576 } 2577 2578 static void qla4xxx_check_relogin_flash_ddb(struct iscsi_cls_session *cls_sess) 2579 { 2580 struct iscsi_session *sess; 2581 struct ddb_entry *ddb_entry; 2582 struct scsi_qla_host *ha; 2583 2584 sess = cls_sess->dd_data; 2585 ddb_entry = sess->dd_data; 2586 ha = ddb_entry->ha; 2587 2588 if (!(ddb_entry->ddb_type == FLASH_DDB)) 2589 return; 2590 2591 if (adapter_up(ha) && !test_bit(DF_RELOGIN, &ddb_entry->flags) && 2592 !iscsi_is_session_online(cls_sess)) { 2593 if (atomic_read(&ddb_entry->retry_relogin_timer) != 2594 INVALID_ENTRY) { 2595 if (atomic_read(&ddb_entry->retry_relogin_timer) == 2596 0) { 2597 atomic_set(&ddb_entry->retry_relogin_timer, 2598 INVALID_ENTRY); 2599 set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags); 2600 set_bit(DF_RELOGIN, &ddb_entry->flags); 2601 DEBUG2(ql4_printk(KERN_INFO, ha, 2602 "%s: index [%d] login device\n", 2603 __func__, ddb_entry->fw_ddb_index)); 2604 } else 2605 atomic_dec(&ddb_entry->retry_relogin_timer); 2606 } 2607 } 2608 2609 /* Wait for relogin to timeout */ 2610 if (atomic_read(&ddb_entry->relogin_timer) && 2611 (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) { 2612 /* 2613 * If the relogin times out and the device is 2614 * still NOT ONLINE then try and relogin again. 2615 */ 2616 if (!iscsi_is_session_online(cls_sess)) { 2617 /* Reset retry relogin timer */ 2618 atomic_inc(&ddb_entry->relogin_retry_count); 2619 DEBUG2(ql4_printk(KERN_INFO, ha, 2620 "%s: index[%d] relogin timed out-retrying" 2621 " relogin (%d), retry (%d)\n", __func__, 2622 ddb_entry->fw_ddb_index, 2623 atomic_read(&ddb_entry->relogin_retry_count), 2624 ddb_entry->default_time2wait + 4)); 2625 set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags); 2626 atomic_set(&ddb_entry->retry_relogin_timer, 2627 ddb_entry->default_time2wait + 4); 2628 } 2629 } 2630 } 2631 2632 /** 2633 * qla4xxx_timer - checks every second for work to do. 2634 * @ha: Pointer to host adapter structure. 2635 **/ 2636 static void qla4xxx_timer(struct scsi_qla_host *ha) 2637 { 2638 int start_dpc = 0; 2639 uint16_t w; 2640 2641 iscsi_host_for_each_session(ha->host, qla4xxx_check_relogin_flash_ddb); 2642 2643 /* If we are in the middle of AER/EEH processing 2644 * skip any processing and reschedule the timer 2645 */ 2646 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 2647 mod_timer(&ha->timer, jiffies + HZ); 2648 return; 2649 } 2650 2651 /* Hardware read to trigger an EEH error during mailbox waits. */ 2652 if (!pci_channel_offline(ha->pdev)) 2653 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w); 2654 2655 if (is_qla8022(ha)) { 2656 qla4_8xxx_watchdog(ha); 2657 } 2658 2659 if (!is_qla8022(ha)) { 2660 /* Check for heartbeat interval. */ 2661 if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE && 2662 ha->heartbeat_interval != 0) { 2663 ha->seconds_since_last_heartbeat++; 2664 if (ha->seconds_since_last_heartbeat > 2665 ha->heartbeat_interval + 2) 2666 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2667 } 2668 } 2669 2670 /* Process any deferred work. */ 2671 if (!list_empty(&ha->work_list)) 2672 start_dpc++; 2673 2674 /* Wakeup the dpc routine for this adapter, if needed. */ 2675 if (start_dpc || 2676 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 2677 test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) || 2678 test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) || 2679 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 2680 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 2681 test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) || 2682 test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) || 2683 test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) || 2684 test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) || 2685 test_bit(DPC_AEN, &ha->dpc_flags)) { 2686 DEBUG2(printk("scsi%ld: %s: scheduling dpc routine" 2687 " - dpc flags = 0x%lx\n", 2688 ha->host_no, __func__, ha->dpc_flags)); 2689 qla4xxx_wake_dpc(ha); 2690 } 2691 2692 /* Reschedule timer thread to call us back in one second */ 2693 mod_timer(&ha->timer, jiffies + HZ); 2694 2695 DEBUG2(ha->seconds_since_last_intr++); 2696 } 2697 2698 /** 2699 * qla4xxx_cmd_wait - waits for all outstanding commands to complete 2700 * @ha: Pointer to host adapter structure. 2701 * 2702 * This routine stalls the driver until all outstanding commands are returned. 2703 * Caller must release the Hardware Lock prior to calling this routine. 2704 **/ 2705 static int qla4xxx_cmd_wait(struct scsi_qla_host *ha) 2706 { 2707 uint32_t index = 0; 2708 unsigned long flags; 2709 struct scsi_cmnd *cmd; 2710 2711 unsigned long wtime = jiffies + (WAIT_CMD_TOV * HZ); 2712 2713 DEBUG2(ql4_printk(KERN_INFO, ha, "Wait up to %d seconds for cmds to " 2714 "complete\n", WAIT_CMD_TOV)); 2715 2716 while (!time_after_eq(jiffies, wtime)) { 2717 spin_lock_irqsave(&ha->hardware_lock, flags); 2718 /* Find a command that hasn't completed. */ 2719 for (index = 0; index < ha->host->can_queue; index++) { 2720 cmd = scsi_host_find_tag(ha->host, index); 2721 /* 2722 * We cannot just check if the index is valid, 2723 * becase if we are run from the scsi eh, then 2724 * the scsi/block layer is going to prevent 2725 * the tag from being released. 2726 */ 2727 if (cmd != NULL && CMD_SP(cmd)) 2728 break; 2729 } 2730 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2731 2732 /* If No Commands are pending, wait is complete */ 2733 if (index == ha->host->can_queue) 2734 return QLA_SUCCESS; 2735 2736 msleep(1000); 2737 } 2738 /* If we timed out on waiting for commands to come back 2739 * return ERROR. */ 2740 return QLA_ERROR; 2741 } 2742 2743 int qla4xxx_hw_reset(struct scsi_qla_host *ha) 2744 { 2745 uint32_t ctrl_status; 2746 unsigned long flags = 0; 2747 2748 DEBUG2(printk(KERN_ERR "scsi%ld: %s\n", ha->host_no, __func__)); 2749 2750 if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS) 2751 return QLA_ERROR; 2752 2753 spin_lock_irqsave(&ha->hardware_lock, flags); 2754 2755 /* 2756 * If the SCSI Reset Interrupt bit is set, clear it. 2757 * Otherwise, the Soft Reset won't work. 2758 */ 2759 ctrl_status = readw(&ha->reg->ctrl_status); 2760 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) 2761 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 2762 2763 /* Issue Soft Reset */ 2764 writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status); 2765 readl(&ha->reg->ctrl_status); 2766 2767 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2768 return QLA_SUCCESS; 2769 } 2770 2771 /** 2772 * qla4xxx_soft_reset - performs soft reset. 2773 * @ha: Pointer to host adapter structure. 2774 **/ 2775 int qla4xxx_soft_reset(struct scsi_qla_host *ha) 2776 { 2777 uint32_t max_wait_time; 2778 unsigned long flags = 0; 2779 int status; 2780 uint32_t ctrl_status; 2781 2782 status = qla4xxx_hw_reset(ha); 2783 if (status != QLA_SUCCESS) 2784 return status; 2785 2786 status = QLA_ERROR; 2787 /* Wait until the Network Reset Intr bit is cleared */ 2788 max_wait_time = RESET_INTR_TOV; 2789 do { 2790 spin_lock_irqsave(&ha->hardware_lock, flags); 2791 ctrl_status = readw(&ha->reg->ctrl_status); 2792 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2793 2794 if ((ctrl_status & CSR_NET_RESET_INTR) == 0) 2795 break; 2796 2797 msleep(1000); 2798 } while ((--max_wait_time)); 2799 2800 if ((ctrl_status & CSR_NET_RESET_INTR) != 0) { 2801 DEBUG2(printk(KERN_WARNING 2802 "scsi%ld: Network Reset Intr not cleared by " 2803 "Network function, clearing it now!\n", 2804 ha->host_no)); 2805 spin_lock_irqsave(&ha->hardware_lock, flags); 2806 writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status); 2807 readl(&ha->reg->ctrl_status); 2808 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2809 } 2810 2811 /* Wait until the firmware tells us the Soft Reset is done */ 2812 max_wait_time = SOFT_RESET_TOV; 2813 do { 2814 spin_lock_irqsave(&ha->hardware_lock, flags); 2815 ctrl_status = readw(&ha->reg->ctrl_status); 2816 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2817 2818 if ((ctrl_status & CSR_SOFT_RESET) == 0) { 2819 status = QLA_SUCCESS; 2820 break; 2821 } 2822 2823 msleep(1000); 2824 } while ((--max_wait_time)); 2825 2826 /* 2827 * Also, make sure that the SCSI Reset Interrupt bit has been cleared 2828 * after the soft reset has taken place. 2829 */ 2830 spin_lock_irqsave(&ha->hardware_lock, flags); 2831 ctrl_status = readw(&ha->reg->ctrl_status); 2832 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) { 2833 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 2834 readl(&ha->reg->ctrl_status); 2835 } 2836 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2837 2838 /* If soft reset fails then most probably the bios on other 2839 * function is also enabled. 2840 * Since the initialization is sequential the other fn 2841 * wont be able to acknowledge the soft reset. 2842 * Issue a force soft reset to workaround this scenario. 2843 */ 2844 if (max_wait_time == 0) { 2845 /* Issue Force Soft Reset */ 2846 spin_lock_irqsave(&ha->hardware_lock, flags); 2847 writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status); 2848 readl(&ha->reg->ctrl_status); 2849 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2850 /* Wait until the firmware tells us the Soft Reset is done */ 2851 max_wait_time = SOFT_RESET_TOV; 2852 do { 2853 spin_lock_irqsave(&ha->hardware_lock, flags); 2854 ctrl_status = readw(&ha->reg->ctrl_status); 2855 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2856 2857 if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) { 2858 status = QLA_SUCCESS; 2859 break; 2860 } 2861 2862 msleep(1000); 2863 } while ((--max_wait_time)); 2864 } 2865 2866 return status; 2867 } 2868 2869 /** 2870 * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S. 2871 * @ha: Pointer to host adapter structure. 2872 * @res: returned scsi status 2873 * 2874 * This routine is called just prior to a HARD RESET to return all 2875 * outstanding commands back to the Operating System. 2876 * Caller should make sure that the following locks are released 2877 * before this calling routine: Hardware lock, and io_request_lock. 2878 **/ 2879 static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res) 2880 { 2881 struct srb *srb; 2882 int i; 2883 unsigned long flags; 2884 2885 spin_lock_irqsave(&ha->hardware_lock, flags); 2886 for (i = 0; i < ha->host->can_queue; i++) { 2887 srb = qla4xxx_del_from_active_array(ha, i); 2888 if (srb != NULL) { 2889 srb->cmd->result = res; 2890 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 2891 } 2892 } 2893 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2894 } 2895 2896 void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha) 2897 { 2898 clear_bit(AF_ONLINE, &ha->flags); 2899 2900 /* Disable the board */ 2901 ql4_printk(KERN_INFO, ha, "Disabling the board\n"); 2902 2903 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 2904 qla4xxx_mark_all_devices_missing(ha); 2905 clear_bit(AF_INIT_DONE, &ha->flags); 2906 } 2907 2908 static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session) 2909 { 2910 struct iscsi_session *sess; 2911 struct ddb_entry *ddb_entry; 2912 2913 sess = cls_session->dd_data; 2914 ddb_entry = sess->dd_data; 2915 ddb_entry->fw_ddb_device_state = DDB_DS_SESSION_FAILED; 2916 2917 if (ddb_entry->ddb_type == FLASH_DDB) 2918 iscsi_block_session(ddb_entry->sess); 2919 else 2920 iscsi_session_failure(cls_session->dd_data, 2921 ISCSI_ERR_CONN_FAILED); 2922 } 2923 2924 /** 2925 * qla4xxx_recover_adapter - recovers adapter after a fatal error 2926 * @ha: Pointer to host adapter structure. 2927 **/ 2928 static int qla4xxx_recover_adapter(struct scsi_qla_host *ha) 2929 { 2930 int status = QLA_ERROR; 2931 uint8_t reset_chip = 0; 2932 uint32_t dev_state; 2933 unsigned long wait; 2934 2935 /* Stall incoming I/O until we are done */ 2936 scsi_block_requests(ha->host); 2937 clear_bit(AF_ONLINE, &ha->flags); 2938 clear_bit(AF_LINK_UP, &ha->flags); 2939 2940 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE\n", __func__)); 2941 2942 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 2943 2944 iscsi_host_for_each_session(ha->host, qla4xxx_fail_session); 2945 2946 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) 2947 reset_chip = 1; 2948 2949 /* For the DPC_RESET_HA_INTR case (ISP-4xxx specific) 2950 * do not reset adapter, jump to initialize_adapter */ 2951 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 2952 status = QLA_SUCCESS; 2953 goto recover_ha_init_adapter; 2954 } 2955 2956 /* For the ISP-82xx adapter, issue a stop_firmware if invoked 2957 * from eh_host_reset or ioctl module */ 2958 if (is_qla8022(ha) && !reset_chip && 2959 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) { 2960 2961 DEBUG2(ql4_printk(KERN_INFO, ha, 2962 "scsi%ld: %s - Performing stop_firmware...\n", 2963 ha->host_no, __func__)); 2964 status = ha->isp_ops->reset_firmware(ha); 2965 if (status == QLA_SUCCESS) { 2966 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 2967 qla4xxx_cmd_wait(ha); 2968 ha->isp_ops->disable_intrs(ha); 2969 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 2970 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 2971 } else { 2972 /* If the stop_firmware fails then 2973 * reset the entire chip */ 2974 reset_chip = 1; 2975 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 2976 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2977 } 2978 } 2979 2980 /* Issue full chip reset if recovering from a catastrophic error, 2981 * or if stop_firmware fails for ISP-82xx. 2982 * This is the default case for ISP-4xxx */ 2983 if (!is_qla8022(ha) || reset_chip) { 2984 if (!is_qla8022(ha)) 2985 goto chip_reset; 2986 2987 /* Check if 82XX firmware is alive or not 2988 * We may have arrived here from NEED_RESET 2989 * detection only */ 2990 if (test_bit(AF_FW_RECOVERY, &ha->flags)) 2991 goto chip_reset; 2992 2993 wait = jiffies + (FW_ALIVE_WAIT_TOV * HZ); 2994 while (time_before(jiffies, wait)) { 2995 if (qla4_8xxx_check_fw_alive(ha)) { 2996 qla4xxx_mailbox_premature_completion(ha); 2997 break; 2998 } 2999 3000 set_current_state(TASK_UNINTERRUPTIBLE); 3001 schedule_timeout(HZ); 3002 } 3003 3004 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 3005 qla4xxx_cmd_wait(ha); 3006 chip_reset: 3007 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 3008 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 3009 DEBUG2(ql4_printk(KERN_INFO, ha, 3010 "scsi%ld: %s - Performing chip reset..\n", 3011 ha->host_no, __func__)); 3012 status = ha->isp_ops->reset_chip(ha); 3013 } 3014 3015 /* Flush any pending ddb changed AENs */ 3016 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 3017 3018 recover_ha_init_adapter: 3019 /* Upon successful firmware/chip reset, re-initialize the adapter */ 3020 if (status == QLA_SUCCESS) { 3021 /* For ISP-4xxx, force function 1 to always initialize 3022 * before function 3 to prevent both funcions from 3023 * stepping on top of the other */ 3024 if (!is_qla8022(ha) && (ha->mac_index == 3)) 3025 ssleep(6); 3026 3027 /* NOTE: AF_ONLINE flag set upon successful completion of 3028 * qla4xxx_initialize_adapter */ 3029 status = qla4xxx_initialize_adapter(ha, RESET_ADAPTER); 3030 } 3031 3032 /* Retry failed adapter initialization, if necessary 3033 * Do not retry initialize_adapter for RESET_HA_INTR (ISP-4xxx specific) 3034 * case to prevent ping-pong resets between functions */ 3035 if (!test_bit(AF_ONLINE, &ha->flags) && 3036 !test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 3037 /* Adapter initialization failed, see if we can retry 3038 * resetting the ha. 3039 * Since we don't want to block the DPC for too long 3040 * with multiple resets in the same thread, 3041 * utilize DPC to retry */ 3042 if (is_qla8022(ha)) { 3043 qla4_8xxx_idc_lock(ha); 3044 dev_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE); 3045 qla4_8xxx_idc_unlock(ha); 3046 if (dev_state == QLA82XX_DEV_FAILED) { 3047 ql4_printk(KERN_INFO, ha, "%s: don't retry " 3048 "recover adapter. H/W is in Failed " 3049 "state\n", __func__); 3050 qla4xxx_dead_adapter_cleanup(ha); 3051 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 3052 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 3053 clear_bit(DPC_RESET_HA_FW_CONTEXT, 3054 &ha->dpc_flags); 3055 status = QLA_ERROR; 3056 3057 goto exit_recover; 3058 } 3059 } 3060 3061 if (!test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags)) { 3062 ha->retry_reset_ha_cnt = MAX_RESET_HA_RETRIES; 3063 DEBUG2(printk("scsi%ld: recover adapter - retrying " 3064 "(%d) more times\n", ha->host_no, 3065 ha->retry_reset_ha_cnt)); 3066 set_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 3067 status = QLA_ERROR; 3068 } else { 3069 if (ha->retry_reset_ha_cnt > 0) { 3070 /* Schedule another Reset HA--DPC will retry */ 3071 ha->retry_reset_ha_cnt--; 3072 DEBUG2(printk("scsi%ld: recover adapter - " 3073 "retry remaining %d\n", 3074 ha->host_no, 3075 ha->retry_reset_ha_cnt)); 3076 status = QLA_ERROR; 3077 } 3078 3079 if (ha->retry_reset_ha_cnt == 0) { 3080 /* Recover adapter retries have been exhausted. 3081 * Adapter DEAD */ 3082 DEBUG2(printk("scsi%ld: recover adapter " 3083 "failed - board disabled\n", 3084 ha->host_no)); 3085 qla4xxx_dead_adapter_cleanup(ha); 3086 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 3087 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 3088 clear_bit(DPC_RESET_HA_FW_CONTEXT, 3089 &ha->dpc_flags); 3090 status = QLA_ERROR; 3091 } 3092 } 3093 } else { 3094 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 3095 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 3096 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 3097 } 3098 3099 exit_recover: 3100 ha->adapter_error_count++; 3101 3102 if (test_bit(AF_ONLINE, &ha->flags)) 3103 ha->isp_ops->enable_intrs(ha); 3104 3105 scsi_unblock_requests(ha->host); 3106 3107 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 3108 DEBUG2(printk("scsi%ld: recover adapter: %s\n", ha->host_no, 3109 status == QLA_ERROR ? "FAILED" : "SUCCEEDED")); 3110 3111 return status; 3112 } 3113 3114 static void qla4xxx_relogin_devices(struct iscsi_cls_session *cls_session) 3115 { 3116 struct iscsi_session *sess; 3117 struct ddb_entry *ddb_entry; 3118 struct scsi_qla_host *ha; 3119 3120 sess = cls_session->dd_data; 3121 ddb_entry = sess->dd_data; 3122 ha = ddb_entry->ha; 3123 if (!iscsi_is_session_online(cls_session)) { 3124 if (ddb_entry->fw_ddb_device_state == DDB_DS_SESSION_ACTIVE) { 3125 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]" 3126 " unblock session\n", ha->host_no, __func__, 3127 ddb_entry->fw_ddb_index); 3128 iscsi_unblock_session(ddb_entry->sess); 3129 } else { 3130 /* Trigger relogin */ 3131 if (ddb_entry->ddb_type == FLASH_DDB) { 3132 if (!test_bit(DF_RELOGIN, &ddb_entry->flags)) 3133 qla4xxx_arm_relogin_timer(ddb_entry); 3134 } else 3135 iscsi_session_failure(cls_session->dd_data, 3136 ISCSI_ERR_CONN_FAILED); 3137 } 3138 } 3139 } 3140 3141 int qla4xxx_unblock_flash_ddb(struct iscsi_cls_session *cls_session) 3142 { 3143 struct iscsi_session *sess; 3144 struct ddb_entry *ddb_entry; 3145 struct scsi_qla_host *ha; 3146 3147 sess = cls_session->dd_data; 3148 ddb_entry = sess->dd_data; 3149 ha = ddb_entry->ha; 3150 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]" 3151 " unblock session\n", ha->host_no, __func__, 3152 ddb_entry->fw_ddb_index); 3153 3154 iscsi_unblock_session(ddb_entry->sess); 3155 3156 /* Start scan target */ 3157 if (test_bit(AF_ONLINE, &ha->flags)) { 3158 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]" 3159 " start scan\n", ha->host_no, __func__, 3160 ddb_entry->fw_ddb_index); 3161 scsi_queue_work(ha->host, &ddb_entry->sess->scan_work); 3162 } 3163 return QLA_SUCCESS; 3164 } 3165 3166 int qla4xxx_unblock_ddb(struct iscsi_cls_session *cls_session) 3167 { 3168 struct iscsi_session *sess; 3169 struct ddb_entry *ddb_entry; 3170 struct scsi_qla_host *ha; 3171 3172 sess = cls_session->dd_data; 3173 ddb_entry = sess->dd_data; 3174 ha = ddb_entry->ha; 3175 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]" 3176 " unblock user space session\n", ha->host_no, __func__, 3177 ddb_entry->fw_ddb_index); 3178 iscsi_conn_start(ddb_entry->conn); 3179 iscsi_conn_login_event(ddb_entry->conn, 3180 ISCSI_CONN_STATE_LOGGED_IN); 3181 3182 return QLA_SUCCESS; 3183 } 3184 3185 static void qla4xxx_relogin_all_devices(struct scsi_qla_host *ha) 3186 { 3187 iscsi_host_for_each_session(ha->host, qla4xxx_relogin_devices); 3188 } 3189 3190 static void qla4xxx_relogin_flash_ddb(struct iscsi_cls_session *cls_sess) 3191 { 3192 uint16_t relogin_timer; 3193 struct iscsi_session *sess; 3194 struct ddb_entry *ddb_entry; 3195 struct scsi_qla_host *ha; 3196 3197 sess = cls_sess->dd_data; 3198 ddb_entry = sess->dd_data; 3199 ha = ddb_entry->ha; 3200 3201 relogin_timer = max(ddb_entry->default_relogin_timeout, 3202 (uint16_t)RELOGIN_TOV); 3203 atomic_set(&ddb_entry->relogin_timer, relogin_timer); 3204 3205 DEBUG2(ql4_printk(KERN_INFO, ha, 3206 "scsi%ld: Relogin index [%d]. TOV=%d\n", ha->host_no, 3207 ddb_entry->fw_ddb_index, relogin_timer)); 3208 3209 qla4xxx_login_flash_ddb(cls_sess); 3210 } 3211 3212 static void qla4xxx_dpc_relogin(struct iscsi_cls_session *cls_sess) 3213 { 3214 struct iscsi_session *sess; 3215 struct ddb_entry *ddb_entry; 3216 struct scsi_qla_host *ha; 3217 3218 sess = cls_sess->dd_data; 3219 ddb_entry = sess->dd_data; 3220 ha = ddb_entry->ha; 3221 3222 if (!(ddb_entry->ddb_type == FLASH_DDB)) 3223 return; 3224 3225 if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags) && 3226 !iscsi_is_session_online(cls_sess)) { 3227 DEBUG2(ql4_printk(KERN_INFO, ha, 3228 "relogin issued\n")); 3229 qla4xxx_relogin_flash_ddb(cls_sess); 3230 } 3231 } 3232 3233 void qla4xxx_wake_dpc(struct scsi_qla_host *ha) 3234 { 3235 if (ha->dpc_thread) 3236 queue_work(ha->dpc_thread, &ha->dpc_work); 3237 } 3238 3239 static struct qla4_work_evt * 3240 qla4xxx_alloc_work(struct scsi_qla_host *ha, uint32_t data_size, 3241 enum qla4_work_type type) 3242 { 3243 struct qla4_work_evt *e; 3244 uint32_t size = sizeof(struct qla4_work_evt) + data_size; 3245 3246 e = kzalloc(size, GFP_ATOMIC); 3247 if (!e) 3248 return NULL; 3249 3250 INIT_LIST_HEAD(&e->list); 3251 e->type = type; 3252 return e; 3253 } 3254 3255 static void qla4xxx_post_work(struct scsi_qla_host *ha, 3256 struct qla4_work_evt *e) 3257 { 3258 unsigned long flags; 3259 3260 spin_lock_irqsave(&ha->work_lock, flags); 3261 list_add_tail(&e->list, &ha->work_list); 3262 spin_unlock_irqrestore(&ha->work_lock, flags); 3263 qla4xxx_wake_dpc(ha); 3264 } 3265 3266 int qla4xxx_post_aen_work(struct scsi_qla_host *ha, 3267 enum iscsi_host_event_code aen_code, 3268 uint32_t data_size, uint8_t *data) 3269 { 3270 struct qla4_work_evt *e; 3271 3272 e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_AEN); 3273 if (!e) 3274 return QLA_ERROR; 3275 3276 e->u.aen.code = aen_code; 3277 e->u.aen.data_size = data_size; 3278 memcpy(e->u.aen.data, data, data_size); 3279 3280 qla4xxx_post_work(ha, e); 3281 3282 return QLA_SUCCESS; 3283 } 3284 3285 int qla4xxx_post_ping_evt_work(struct scsi_qla_host *ha, 3286 uint32_t status, uint32_t pid, 3287 uint32_t data_size, uint8_t *data) 3288 { 3289 struct qla4_work_evt *e; 3290 3291 e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_PING_STATUS); 3292 if (!e) 3293 return QLA_ERROR; 3294 3295 e->u.ping.status = status; 3296 e->u.ping.pid = pid; 3297 e->u.ping.data_size = data_size; 3298 memcpy(e->u.ping.data, data, data_size); 3299 3300 qla4xxx_post_work(ha, e); 3301 3302 return QLA_SUCCESS; 3303 } 3304 3305 static void qla4xxx_do_work(struct scsi_qla_host *ha) 3306 { 3307 struct qla4_work_evt *e, *tmp; 3308 unsigned long flags; 3309 LIST_HEAD(work); 3310 3311 spin_lock_irqsave(&ha->work_lock, flags); 3312 list_splice_init(&ha->work_list, &work); 3313 spin_unlock_irqrestore(&ha->work_lock, flags); 3314 3315 list_for_each_entry_safe(e, tmp, &work, list) { 3316 list_del_init(&e->list); 3317 3318 switch (e->type) { 3319 case QLA4_EVENT_AEN: 3320 iscsi_post_host_event(ha->host_no, 3321 &qla4xxx_iscsi_transport, 3322 e->u.aen.code, 3323 e->u.aen.data_size, 3324 e->u.aen.data); 3325 break; 3326 case QLA4_EVENT_PING_STATUS: 3327 iscsi_ping_comp_event(ha->host_no, 3328 &qla4xxx_iscsi_transport, 3329 e->u.ping.status, 3330 e->u.ping.pid, 3331 e->u.ping.data_size, 3332 e->u.ping.data); 3333 break; 3334 default: 3335 ql4_printk(KERN_WARNING, ha, "event type: 0x%x not " 3336 "supported", e->type); 3337 } 3338 kfree(e); 3339 } 3340 } 3341 3342 /** 3343 * qla4xxx_do_dpc - dpc routine 3344 * @data: in our case pointer to adapter structure 3345 * 3346 * This routine is a task that is schedule by the interrupt handler 3347 * to perform the background processing for interrupts. We put it 3348 * on a task queue that is consumed whenever the scheduler runs; that's 3349 * so you can do anything (i.e. put the process to sleep etc). In fact, 3350 * the mid-level tries to sleep when it reaches the driver threshold 3351 * "host->can_queue". This can cause a panic if we were in our interrupt code. 3352 **/ 3353 static void qla4xxx_do_dpc(struct work_struct *work) 3354 { 3355 struct scsi_qla_host *ha = 3356 container_of(work, struct scsi_qla_host, dpc_work); 3357 int status = QLA_ERROR; 3358 3359 DEBUG2(printk("scsi%ld: %s: DPC handler waking up." 3360 "flags = 0x%08lx, dpc_flags = 0x%08lx\n", 3361 ha->host_no, __func__, ha->flags, ha->dpc_flags)) 3362 3363 /* Initialization not yet finished. Don't do anything yet. */ 3364 if (!test_bit(AF_INIT_DONE, &ha->flags)) 3365 return; 3366 3367 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 3368 DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n", 3369 ha->host_no, __func__, ha->flags)); 3370 return; 3371 } 3372 3373 /* post events to application */ 3374 qla4xxx_do_work(ha); 3375 3376 if (is_qla8022(ha)) { 3377 if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) { 3378 qla4_8xxx_idc_lock(ha); 3379 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 3380 QLA82XX_DEV_FAILED); 3381 qla4_8xxx_idc_unlock(ha); 3382 ql4_printk(KERN_INFO, ha, "HW State: FAILED\n"); 3383 qla4_8xxx_device_state_handler(ha); 3384 } 3385 if (test_and_clear_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 3386 qla4_8xxx_need_qsnt_handler(ha); 3387 } 3388 } 3389 3390 if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) && 3391 (test_bit(DPC_RESET_HA, &ha->dpc_flags) || 3392 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 3393 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))) { 3394 if (ql4xdontresethba) { 3395 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 3396 ha->host_no, __func__)); 3397 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 3398 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 3399 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 3400 goto dpc_post_reset_ha; 3401 } 3402 if (test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 3403 test_bit(DPC_RESET_HA, &ha->dpc_flags)) 3404 qla4xxx_recover_adapter(ha); 3405 3406 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 3407 uint8_t wait_time = RESET_INTR_TOV; 3408 3409 while ((readw(&ha->reg->ctrl_status) & 3410 (CSR_SOFT_RESET | CSR_FORCE_SOFT_RESET)) != 0) { 3411 if (--wait_time == 0) 3412 break; 3413 msleep(1000); 3414 } 3415 if (wait_time == 0) 3416 DEBUG2(printk("scsi%ld: %s: SR|FSR " 3417 "bit not cleared-- resetting\n", 3418 ha->host_no, __func__)); 3419 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 3420 if (ql4xxx_lock_drvr_wait(ha) == QLA_SUCCESS) { 3421 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 3422 status = qla4xxx_recover_adapter(ha); 3423 } 3424 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 3425 if (status == QLA_SUCCESS) 3426 ha->isp_ops->enable_intrs(ha); 3427 } 3428 } 3429 3430 dpc_post_reset_ha: 3431 /* ---- process AEN? --- */ 3432 if (test_and_clear_bit(DPC_AEN, &ha->dpc_flags)) 3433 qla4xxx_process_aen(ha, PROCESS_ALL_AENS); 3434 3435 /* ---- Get DHCP IP Address? --- */ 3436 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags)) 3437 qla4xxx_get_dhcp_ip_address(ha); 3438 3439 /* ---- relogin device? --- */ 3440 if (adapter_up(ha) && 3441 test_and_clear_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags)) { 3442 iscsi_host_for_each_session(ha->host, qla4xxx_dpc_relogin); 3443 } 3444 3445 /* ---- link change? --- */ 3446 if (test_and_clear_bit(DPC_LINK_CHANGED, &ha->dpc_flags)) { 3447 if (!test_bit(AF_LINK_UP, &ha->flags)) { 3448 /* ---- link down? --- */ 3449 qla4xxx_mark_all_devices_missing(ha); 3450 } else { 3451 /* ---- link up? --- * 3452 * F/W will auto login to all devices ONLY ONCE after 3453 * link up during driver initialization and runtime 3454 * fatal error recovery. Therefore, the driver must 3455 * manually relogin to devices when recovering from 3456 * connection failures, logouts, expired KATO, etc. */ 3457 if (test_and_clear_bit(AF_BUILD_DDB_LIST, &ha->flags)) { 3458 qla4xxx_build_ddb_list(ha, ha->is_reset); 3459 iscsi_host_for_each_session(ha->host, 3460 qla4xxx_login_flash_ddb); 3461 } else 3462 qla4xxx_relogin_all_devices(ha); 3463 } 3464 } 3465 } 3466 3467 /** 3468 * qla4xxx_free_adapter - release the adapter 3469 * @ha: pointer to adapter structure 3470 **/ 3471 static void qla4xxx_free_adapter(struct scsi_qla_host *ha) 3472 { 3473 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 3474 3475 if (test_bit(AF_INTERRUPTS_ON, &ha->flags)) { 3476 /* Turn-off interrupts on the card. */ 3477 ha->isp_ops->disable_intrs(ha); 3478 } 3479 3480 /* Remove timer thread, if present */ 3481 if (ha->timer_active) 3482 qla4xxx_stop_timer(ha); 3483 3484 /* Kill the kernel thread for this host */ 3485 if (ha->dpc_thread) 3486 destroy_workqueue(ha->dpc_thread); 3487 3488 /* Kill the kernel thread for this host */ 3489 if (ha->task_wq) 3490 destroy_workqueue(ha->task_wq); 3491 3492 /* Put firmware in known state */ 3493 ha->isp_ops->reset_firmware(ha); 3494 3495 if (is_qla8022(ha)) { 3496 qla4_8xxx_idc_lock(ha); 3497 qla4_8xxx_clear_drv_active(ha); 3498 qla4_8xxx_idc_unlock(ha); 3499 } 3500 3501 /* Detach interrupts */ 3502 if (test_and_clear_bit(AF_IRQ_ATTACHED, &ha->flags)) 3503 qla4xxx_free_irqs(ha); 3504 3505 /* free extra memory */ 3506 qla4xxx_mem_free(ha); 3507 } 3508 3509 int qla4_8xxx_iospace_config(struct scsi_qla_host *ha) 3510 { 3511 int status = 0; 3512 unsigned long mem_base, mem_len, db_base, db_len; 3513 struct pci_dev *pdev = ha->pdev; 3514 3515 status = pci_request_regions(pdev, DRIVER_NAME); 3516 if (status) { 3517 printk(KERN_WARNING 3518 "scsi(%ld) Failed to reserve PIO regions (%s) " 3519 "status=%d\n", ha->host_no, pci_name(pdev), status); 3520 goto iospace_error_exit; 3521 } 3522 3523 DEBUG2(printk(KERN_INFO "%s: revision-id=%d\n", 3524 __func__, pdev->revision)); 3525 ha->revision_id = pdev->revision; 3526 3527 /* remap phys address */ 3528 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */ 3529 mem_len = pci_resource_len(pdev, 0); 3530 DEBUG2(printk(KERN_INFO "%s: ioremap from %lx a size of %lx\n", 3531 __func__, mem_base, mem_len)); 3532 3533 /* mapping of pcibase pointer */ 3534 ha->nx_pcibase = (unsigned long)ioremap(mem_base, mem_len); 3535 if (!ha->nx_pcibase) { 3536 printk(KERN_ERR 3537 "cannot remap MMIO (%s), aborting\n", pci_name(pdev)); 3538 pci_release_regions(ha->pdev); 3539 goto iospace_error_exit; 3540 } 3541 3542 /* Mapping of IO base pointer, door bell read and write pointer */ 3543 3544 /* mapping of IO base pointer */ 3545 ha->qla4_8xxx_reg = 3546 (struct device_reg_82xx __iomem *)((uint8_t *)ha->nx_pcibase + 3547 0xbc000 + (ha->pdev->devfn << 11)); 3548 3549 db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */ 3550 db_len = pci_resource_len(pdev, 4); 3551 3552 ha->nx_db_wr_ptr = (ha->pdev->devfn == 4 ? QLA82XX_CAM_RAM_DB1 : 3553 QLA82XX_CAM_RAM_DB2); 3554 3555 return 0; 3556 iospace_error_exit: 3557 return -ENOMEM; 3558 } 3559 3560 /*** 3561 * qla4xxx_iospace_config - maps registers 3562 * @ha: pointer to adapter structure 3563 * 3564 * This routines maps HBA's registers from the pci address space 3565 * into the kernel virtual address space for memory mapped i/o. 3566 **/ 3567 int qla4xxx_iospace_config(struct scsi_qla_host *ha) 3568 { 3569 unsigned long pio, pio_len, pio_flags; 3570 unsigned long mmio, mmio_len, mmio_flags; 3571 3572 pio = pci_resource_start(ha->pdev, 0); 3573 pio_len = pci_resource_len(ha->pdev, 0); 3574 pio_flags = pci_resource_flags(ha->pdev, 0); 3575 if (pio_flags & IORESOURCE_IO) { 3576 if (pio_len < MIN_IOBASE_LEN) { 3577 ql4_printk(KERN_WARNING, ha, 3578 "Invalid PCI I/O region size\n"); 3579 pio = 0; 3580 } 3581 } else { 3582 ql4_printk(KERN_WARNING, ha, "region #0 not a PIO resource\n"); 3583 pio = 0; 3584 } 3585 3586 /* Use MMIO operations for all accesses. */ 3587 mmio = pci_resource_start(ha->pdev, 1); 3588 mmio_len = pci_resource_len(ha->pdev, 1); 3589 mmio_flags = pci_resource_flags(ha->pdev, 1); 3590 3591 if (!(mmio_flags & IORESOURCE_MEM)) { 3592 ql4_printk(KERN_ERR, ha, 3593 "region #0 not an MMIO resource, aborting\n"); 3594 3595 goto iospace_error_exit; 3596 } 3597 3598 if (mmio_len < MIN_IOBASE_LEN) { 3599 ql4_printk(KERN_ERR, ha, 3600 "Invalid PCI mem region size, aborting\n"); 3601 goto iospace_error_exit; 3602 } 3603 3604 if (pci_request_regions(ha->pdev, DRIVER_NAME)) { 3605 ql4_printk(KERN_WARNING, ha, 3606 "Failed to reserve PIO/MMIO regions\n"); 3607 3608 goto iospace_error_exit; 3609 } 3610 3611 ha->pio_address = pio; 3612 ha->pio_length = pio_len; 3613 ha->reg = ioremap(mmio, MIN_IOBASE_LEN); 3614 if (!ha->reg) { 3615 ql4_printk(KERN_ERR, ha, 3616 "cannot remap MMIO, aborting\n"); 3617 3618 goto iospace_error_exit; 3619 } 3620 3621 return 0; 3622 3623 iospace_error_exit: 3624 return -ENOMEM; 3625 } 3626 3627 static struct isp_operations qla4xxx_isp_ops = { 3628 .iospace_config = qla4xxx_iospace_config, 3629 .pci_config = qla4xxx_pci_config, 3630 .disable_intrs = qla4xxx_disable_intrs, 3631 .enable_intrs = qla4xxx_enable_intrs, 3632 .start_firmware = qla4xxx_start_firmware, 3633 .intr_handler = qla4xxx_intr_handler, 3634 .interrupt_service_routine = qla4xxx_interrupt_service_routine, 3635 .reset_chip = qla4xxx_soft_reset, 3636 .reset_firmware = qla4xxx_hw_reset, 3637 .queue_iocb = qla4xxx_queue_iocb, 3638 .complete_iocb = qla4xxx_complete_iocb, 3639 .rd_shdw_req_q_out = qla4xxx_rd_shdw_req_q_out, 3640 .rd_shdw_rsp_q_in = qla4xxx_rd_shdw_rsp_q_in, 3641 .get_sys_info = qla4xxx_get_sys_info, 3642 }; 3643 3644 static struct isp_operations qla4_8xxx_isp_ops = { 3645 .iospace_config = qla4_8xxx_iospace_config, 3646 .pci_config = qla4_8xxx_pci_config, 3647 .disable_intrs = qla4_8xxx_disable_intrs, 3648 .enable_intrs = qla4_8xxx_enable_intrs, 3649 .start_firmware = qla4_8xxx_load_risc, 3650 .intr_handler = qla4_8xxx_intr_handler, 3651 .interrupt_service_routine = qla4_8xxx_interrupt_service_routine, 3652 .reset_chip = qla4_8xxx_isp_reset, 3653 .reset_firmware = qla4_8xxx_stop_firmware, 3654 .queue_iocb = qla4_8xxx_queue_iocb, 3655 .complete_iocb = qla4_8xxx_complete_iocb, 3656 .rd_shdw_req_q_out = qla4_8xxx_rd_shdw_req_q_out, 3657 .rd_shdw_rsp_q_in = qla4_8xxx_rd_shdw_rsp_q_in, 3658 .get_sys_info = qla4_8xxx_get_sys_info, 3659 }; 3660 3661 uint16_t qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 3662 { 3663 return (uint16_t)le32_to_cpu(ha->shadow_regs->req_q_out); 3664 } 3665 3666 uint16_t qla4_8xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 3667 { 3668 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->req_q_out)); 3669 } 3670 3671 uint16_t qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 3672 { 3673 return (uint16_t)le32_to_cpu(ha->shadow_regs->rsp_q_in); 3674 } 3675 3676 uint16_t qla4_8xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 3677 { 3678 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->rsp_q_in)); 3679 } 3680 3681 static ssize_t qla4xxx_show_boot_eth_info(void *data, int type, char *buf) 3682 { 3683 struct scsi_qla_host *ha = data; 3684 char *str = buf; 3685 int rc; 3686 3687 switch (type) { 3688 case ISCSI_BOOT_ETH_FLAGS: 3689 rc = sprintf(str, "%d\n", SYSFS_FLAG_FW_SEL_BOOT); 3690 break; 3691 case ISCSI_BOOT_ETH_INDEX: 3692 rc = sprintf(str, "0\n"); 3693 break; 3694 case ISCSI_BOOT_ETH_MAC: 3695 rc = sysfs_format_mac(str, ha->my_mac, 3696 MAC_ADDR_LEN); 3697 break; 3698 default: 3699 rc = -ENOSYS; 3700 break; 3701 } 3702 return rc; 3703 } 3704 3705 static umode_t qla4xxx_eth_get_attr_visibility(void *data, int type) 3706 { 3707 int rc; 3708 3709 switch (type) { 3710 case ISCSI_BOOT_ETH_FLAGS: 3711 case ISCSI_BOOT_ETH_MAC: 3712 case ISCSI_BOOT_ETH_INDEX: 3713 rc = S_IRUGO; 3714 break; 3715 default: 3716 rc = 0; 3717 break; 3718 } 3719 return rc; 3720 } 3721 3722 static ssize_t qla4xxx_show_boot_ini_info(void *data, int type, char *buf) 3723 { 3724 struct scsi_qla_host *ha = data; 3725 char *str = buf; 3726 int rc; 3727 3728 switch (type) { 3729 case ISCSI_BOOT_INI_INITIATOR_NAME: 3730 rc = sprintf(str, "%s\n", ha->name_string); 3731 break; 3732 default: 3733 rc = -ENOSYS; 3734 break; 3735 } 3736 return rc; 3737 } 3738 3739 static umode_t qla4xxx_ini_get_attr_visibility(void *data, int type) 3740 { 3741 int rc; 3742 3743 switch (type) { 3744 case ISCSI_BOOT_INI_INITIATOR_NAME: 3745 rc = S_IRUGO; 3746 break; 3747 default: 3748 rc = 0; 3749 break; 3750 } 3751 return rc; 3752 } 3753 3754 static ssize_t 3755 qla4xxx_show_boot_tgt_info(struct ql4_boot_session_info *boot_sess, int type, 3756 char *buf) 3757 { 3758 struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0]; 3759 char *str = buf; 3760 int rc; 3761 3762 switch (type) { 3763 case ISCSI_BOOT_TGT_NAME: 3764 rc = sprintf(buf, "%s\n", (char *)&boot_sess->target_name); 3765 break; 3766 case ISCSI_BOOT_TGT_IP_ADDR: 3767 if (boot_sess->conn_list[0].dest_ipaddr.ip_type == 0x1) 3768 rc = sprintf(buf, "%pI4\n", 3769 &boot_conn->dest_ipaddr.ip_address); 3770 else 3771 rc = sprintf(str, "%pI6\n", 3772 &boot_conn->dest_ipaddr.ip_address); 3773 break; 3774 case ISCSI_BOOT_TGT_PORT: 3775 rc = sprintf(str, "%d\n", boot_conn->dest_port); 3776 break; 3777 case ISCSI_BOOT_TGT_CHAP_NAME: 3778 rc = sprintf(str, "%.*s\n", 3779 boot_conn->chap.target_chap_name_length, 3780 (char *)&boot_conn->chap.target_chap_name); 3781 break; 3782 case ISCSI_BOOT_TGT_CHAP_SECRET: 3783 rc = sprintf(str, "%.*s\n", 3784 boot_conn->chap.target_secret_length, 3785 (char *)&boot_conn->chap.target_secret); 3786 break; 3787 case ISCSI_BOOT_TGT_REV_CHAP_NAME: 3788 rc = sprintf(str, "%.*s\n", 3789 boot_conn->chap.intr_chap_name_length, 3790 (char *)&boot_conn->chap.intr_chap_name); 3791 break; 3792 case ISCSI_BOOT_TGT_REV_CHAP_SECRET: 3793 rc = sprintf(str, "%.*s\n", 3794 boot_conn->chap.intr_secret_length, 3795 (char *)&boot_conn->chap.intr_secret); 3796 break; 3797 case ISCSI_BOOT_TGT_FLAGS: 3798 rc = sprintf(str, "%d\n", SYSFS_FLAG_FW_SEL_BOOT); 3799 break; 3800 case ISCSI_BOOT_TGT_NIC_ASSOC: 3801 rc = sprintf(str, "0\n"); 3802 break; 3803 default: 3804 rc = -ENOSYS; 3805 break; 3806 } 3807 return rc; 3808 } 3809 3810 static ssize_t qla4xxx_show_boot_tgt_pri_info(void *data, int type, char *buf) 3811 { 3812 struct scsi_qla_host *ha = data; 3813 struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_pri_sess); 3814 3815 return qla4xxx_show_boot_tgt_info(boot_sess, type, buf); 3816 } 3817 3818 static ssize_t qla4xxx_show_boot_tgt_sec_info(void *data, int type, char *buf) 3819 { 3820 struct scsi_qla_host *ha = data; 3821 struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_sec_sess); 3822 3823 return qla4xxx_show_boot_tgt_info(boot_sess, type, buf); 3824 } 3825 3826 static umode_t qla4xxx_tgt_get_attr_visibility(void *data, int type) 3827 { 3828 int rc; 3829 3830 switch (type) { 3831 case ISCSI_BOOT_TGT_NAME: 3832 case ISCSI_BOOT_TGT_IP_ADDR: 3833 case ISCSI_BOOT_TGT_PORT: 3834 case ISCSI_BOOT_TGT_CHAP_NAME: 3835 case ISCSI_BOOT_TGT_CHAP_SECRET: 3836 case ISCSI_BOOT_TGT_REV_CHAP_NAME: 3837 case ISCSI_BOOT_TGT_REV_CHAP_SECRET: 3838 case ISCSI_BOOT_TGT_NIC_ASSOC: 3839 case ISCSI_BOOT_TGT_FLAGS: 3840 rc = S_IRUGO; 3841 break; 3842 default: 3843 rc = 0; 3844 break; 3845 } 3846 return rc; 3847 } 3848 3849 static void qla4xxx_boot_release(void *data) 3850 { 3851 struct scsi_qla_host *ha = data; 3852 3853 scsi_host_put(ha->host); 3854 } 3855 3856 static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[]) 3857 { 3858 dma_addr_t buf_dma; 3859 uint32_t addr, pri_addr, sec_addr; 3860 uint32_t offset; 3861 uint16_t func_num; 3862 uint8_t val; 3863 uint8_t *buf = NULL; 3864 size_t size = 13 * sizeof(uint8_t); 3865 int ret = QLA_SUCCESS; 3866 3867 func_num = PCI_FUNC(ha->pdev->devfn); 3868 3869 ql4_printk(KERN_INFO, ha, "%s: Get FW boot info for 0x%x func %d\n", 3870 __func__, ha->pdev->device, func_num); 3871 3872 if (is_qla40XX(ha)) { 3873 if (func_num == 1) { 3874 addr = NVRAM_PORT0_BOOT_MODE; 3875 pri_addr = NVRAM_PORT0_BOOT_PRI_TGT; 3876 sec_addr = NVRAM_PORT0_BOOT_SEC_TGT; 3877 } else if (func_num == 3) { 3878 addr = NVRAM_PORT1_BOOT_MODE; 3879 pri_addr = NVRAM_PORT1_BOOT_PRI_TGT; 3880 sec_addr = NVRAM_PORT1_BOOT_SEC_TGT; 3881 } else { 3882 ret = QLA_ERROR; 3883 goto exit_boot_info; 3884 } 3885 3886 /* Check Boot Mode */ 3887 val = rd_nvram_byte(ha, addr); 3888 if (!(val & 0x07)) { 3889 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Adapter boot " 3890 "options : 0x%x\n", __func__, val)); 3891 ret = QLA_ERROR; 3892 goto exit_boot_info; 3893 } 3894 3895 /* get primary valid target index */ 3896 val = rd_nvram_byte(ha, pri_addr); 3897 if (val & BIT_7) 3898 ddb_index[0] = (val & 0x7f); 3899 3900 /* get secondary valid target index */ 3901 val = rd_nvram_byte(ha, sec_addr); 3902 if (val & BIT_7) 3903 ddb_index[1] = (val & 0x7f); 3904 3905 } else if (is_qla8022(ha)) { 3906 buf = dma_alloc_coherent(&ha->pdev->dev, size, 3907 &buf_dma, GFP_KERNEL); 3908 if (!buf) { 3909 DEBUG2(ql4_printk(KERN_ERR, ha, 3910 "%s: Unable to allocate dma buffer\n", 3911 __func__)); 3912 ret = QLA_ERROR; 3913 goto exit_boot_info; 3914 } 3915 3916 if (ha->port_num == 0) 3917 offset = BOOT_PARAM_OFFSET_PORT0; 3918 else if (ha->port_num == 1) 3919 offset = BOOT_PARAM_OFFSET_PORT1; 3920 else { 3921 ret = QLA_ERROR; 3922 goto exit_boot_info_free; 3923 } 3924 addr = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_iscsi_param * 4) + 3925 offset; 3926 if (qla4xxx_get_flash(ha, buf_dma, addr, 3927 13 * sizeof(uint8_t)) != QLA_SUCCESS) { 3928 DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: Get Flash" 3929 " failed\n", ha->host_no, __func__)); 3930 ret = QLA_ERROR; 3931 goto exit_boot_info_free; 3932 } 3933 /* Check Boot Mode */ 3934 if (!(buf[1] & 0x07)) { 3935 DEBUG2(ql4_printk(KERN_INFO, ha, "Firmware boot options" 3936 " : 0x%x\n", buf[1])); 3937 ret = QLA_ERROR; 3938 goto exit_boot_info_free; 3939 } 3940 3941 /* get primary valid target index */ 3942 if (buf[2] & BIT_7) 3943 ddb_index[0] = buf[2] & 0x7f; 3944 3945 /* get secondary valid target index */ 3946 if (buf[11] & BIT_7) 3947 ddb_index[1] = buf[11] & 0x7f; 3948 } else { 3949 ret = QLA_ERROR; 3950 goto exit_boot_info; 3951 } 3952 3953 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary target ID %d, Secondary" 3954 " target ID %d\n", __func__, ddb_index[0], 3955 ddb_index[1])); 3956 3957 exit_boot_info_free: 3958 dma_free_coherent(&ha->pdev->dev, size, buf, buf_dma); 3959 exit_boot_info: 3960 ha->pri_ddb_idx = ddb_index[0]; 3961 ha->sec_ddb_idx = ddb_index[1]; 3962 return ret; 3963 } 3964 3965 /** 3966 * qla4xxx_get_bidi_chap - Get a BIDI CHAP user and password 3967 * @ha: pointer to adapter structure 3968 * @username: CHAP username to be returned 3969 * @password: CHAP password to be returned 3970 * 3971 * If a boot entry has BIDI CHAP enabled then we need to set the BIDI CHAP 3972 * user and password in the sysfs entry in /sys/firmware/iscsi_boot#/. 3973 * So from the CHAP cache find the first BIDI CHAP entry and set it 3974 * to the boot record in sysfs. 3975 **/ 3976 static int qla4xxx_get_bidi_chap(struct scsi_qla_host *ha, char *username, 3977 char *password) 3978 { 3979 int i, ret = -EINVAL; 3980 int max_chap_entries = 0; 3981 struct ql4_chap_table *chap_table; 3982 3983 if (is_qla8022(ha)) 3984 max_chap_entries = (ha->hw.flt_chap_size / 2) / 3985 sizeof(struct ql4_chap_table); 3986 else 3987 max_chap_entries = MAX_CHAP_ENTRIES_40XX; 3988 3989 if (!ha->chap_list) { 3990 ql4_printk(KERN_ERR, ha, "Do not have CHAP table cache\n"); 3991 return ret; 3992 } 3993 3994 mutex_lock(&ha->chap_sem); 3995 for (i = 0; i < max_chap_entries; i++) { 3996 chap_table = (struct ql4_chap_table *)ha->chap_list + i; 3997 if (chap_table->cookie != 3998 __constant_cpu_to_le16(CHAP_VALID_COOKIE)) { 3999 continue; 4000 } 4001 4002 if (chap_table->flags & BIT_7) /* local */ 4003 continue; 4004 4005 if (!(chap_table->flags & BIT_6)) /* Not BIDI */ 4006 continue; 4007 4008 strncpy(password, chap_table->secret, QL4_CHAP_MAX_SECRET_LEN); 4009 strncpy(username, chap_table->name, QL4_CHAP_MAX_NAME_LEN); 4010 ret = 0; 4011 break; 4012 } 4013 mutex_unlock(&ha->chap_sem); 4014 4015 return ret; 4016 } 4017 4018 4019 static int qla4xxx_get_boot_target(struct scsi_qla_host *ha, 4020 struct ql4_boot_session_info *boot_sess, 4021 uint16_t ddb_index) 4022 { 4023 struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0]; 4024 struct dev_db_entry *fw_ddb_entry; 4025 dma_addr_t fw_ddb_entry_dma; 4026 uint16_t idx; 4027 uint16_t options; 4028 int ret = QLA_SUCCESS; 4029 4030 fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 4031 &fw_ddb_entry_dma, GFP_KERNEL); 4032 if (!fw_ddb_entry) { 4033 DEBUG2(ql4_printk(KERN_ERR, ha, 4034 "%s: Unable to allocate dma buffer.\n", 4035 __func__)); 4036 ret = QLA_ERROR; 4037 return ret; 4038 } 4039 4040 if (qla4xxx_bootdb_by_index(ha, fw_ddb_entry, 4041 fw_ddb_entry_dma, ddb_index)) { 4042 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: No Flash DDB found at " 4043 "index [%d]\n", __func__, ddb_index)); 4044 ret = QLA_ERROR; 4045 goto exit_boot_target; 4046 } 4047 4048 /* Update target name and IP from DDB */ 4049 memcpy(boot_sess->target_name, fw_ddb_entry->iscsi_name, 4050 min(sizeof(boot_sess->target_name), 4051 sizeof(fw_ddb_entry->iscsi_name))); 4052 4053 options = le16_to_cpu(fw_ddb_entry->options); 4054 if (options & DDB_OPT_IPV6_DEVICE) { 4055 memcpy(&boot_conn->dest_ipaddr.ip_address, 4056 &fw_ddb_entry->ip_addr[0], IPv6_ADDR_LEN); 4057 } else { 4058 boot_conn->dest_ipaddr.ip_type = 0x1; 4059 memcpy(&boot_conn->dest_ipaddr.ip_address, 4060 &fw_ddb_entry->ip_addr[0], IP_ADDR_LEN); 4061 } 4062 4063 boot_conn->dest_port = le16_to_cpu(fw_ddb_entry->port); 4064 4065 /* update chap information */ 4066 idx = __le16_to_cpu(fw_ddb_entry->chap_tbl_idx); 4067 4068 if (BIT_7 & le16_to_cpu(fw_ddb_entry->iscsi_options)) { 4069 4070 DEBUG2(ql4_printk(KERN_INFO, ha, "Setting chap\n")); 4071 4072 ret = qla4xxx_get_chap(ha, (char *)&boot_conn->chap. 4073 target_chap_name, 4074 (char *)&boot_conn->chap.target_secret, 4075 idx); 4076 if (ret) { 4077 ql4_printk(KERN_ERR, ha, "Failed to set chap\n"); 4078 ret = QLA_ERROR; 4079 goto exit_boot_target; 4080 } 4081 4082 boot_conn->chap.target_chap_name_length = QL4_CHAP_MAX_NAME_LEN; 4083 boot_conn->chap.target_secret_length = QL4_CHAP_MAX_SECRET_LEN; 4084 } 4085 4086 if (BIT_4 & le16_to_cpu(fw_ddb_entry->iscsi_options)) { 4087 4088 DEBUG2(ql4_printk(KERN_INFO, ha, "Setting BIDI chap\n")); 4089 4090 ret = qla4xxx_get_bidi_chap(ha, 4091 (char *)&boot_conn->chap.intr_chap_name, 4092 (char *)&boot_conn->chap.intr_secret); 4093 4094 if (ret) { 4095 ql4_printk(KERN_ERR, ha, "Failed to set BIDI chap\n"); 4096 ret = QLA_ERROR; 4097 goto exit_boot_target; 4098 } 4099 4100 boot_conn->chap.intr_chap_name_length = QL4_CHAP_MAX_NAME_LEN; 4101 boot_conn->chap.intr_secret_length = QL4_CHAP_MAX_SECRET_LEN; 4102 } 4103 4104 exit_boot_target: 4105 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), 4106 fw_ddb_entry, fw_ddb_entry_dma); 4107 return ret; 4108 } 4109 4110 static int qla4xxx_get_boot_info(struct scsi_qla_host *ha) 4111 { 4112 uint16_t ddb_index[2]; 4113 int ret = QLA_ERROR; 4114 int rval; 4115 4116 memset(ddb_index, 0, sizeof(ddb_index)); 4117 ddb_index[0] = 0xffff; 4118 ddb_index[1] = 0xffff; 4119 ret = get_fw_boot_info(ha, ddb_index); 4120 if (ret != QLA_SUCCESS) { 4121 DEBUG2(ql4_printk(KERN_INFO, ha, 4122 "%s: No boot target configured.\n", __func__)); 4123 return ret; 4124 } 4125 4126 if (ql4xdisablesysfsboot) 4127 return QLA_SUCCESS; 4128 4129 if (ddb_index[0] == 0xffff) 4130 goto sec_target; 4131 4132 rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_pri_sess), 4133 ddb_index[0]); 4134 if (rval != QLA_SUCCESS) { 4135 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary boot target not " 4136 "configured\n", __func__)); 4137 } else 4138 ret = QLA_SUCCESS; 4139 4140 sec_target: 4141 if (ddb_index[1] == 0xffff) 4142 goto exit_get_boot_info; 4143 4144 rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_sec_sess), 4145 ddb_index[1]); 4146 if (rval != QLA_SUCCESS) { 4147 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Secondary boot target not" 4148 " configured\n", __func__)); 4149 } else 4150 ret = QLA_SUCCESS; 4151 4152 exit_get_boot_info: 4153 return ret; 4154 } 4155 4156 static int qla4xxx_setup_boot_info(struct scsi_qla_host *ha) 4157 { 4158 struct iscsi_boot_kobj *boot_kobj; 4159 4160 if (qla4xxx_get_boot_info(ha) != QLA_SUCCESS) 4161 return QLA_ERROR; 4162 4163 if (ql4xdisablesysfsboot) { 4164 ql4_printk(KERN_INFO, ha, 4165 "%s: syfsboot disabled - driver will trigger login " 4166 "and publish session for discovery .\n", __func__); 4167 return QLA_SUCCESS; 4168 } 4169 4170 4171 ha->boot_kset = iscsi_boot_create_host_kset(ha->host->host_no); 4172 if (!ha->boot_kset) 4173 goto kset_free; 4174 4175 if (!scsi_host_get(ha->host)) 4176 goto kset_free; 4177 boot_kobj = iscsi_boot_create_target(ha->boot_kset, 0, ha, 4178 qla4xxx_show_boot_tgt_pri_info, 4179 qla4xxx_tgt_get_attr_visibility, 4180 qla4xxx_boot_release); 4181 if (!boot_kobj) 4182 goto put_host; 4183 4184 if (!scsi_host_get(ha->host)) 4185 goto kset_free; 4186 boot_kobj = iscsi_boot_create_target(ha->boot_kset, 1, ha, 4187 qla4xxx_show_boot_tgt_sec_info, 4188 qla4xxx_tgt_get_attr_visibility, 4189 qla4xxx_boot_release); 4190 if (!boot_kobj) 4191 goto put_host; 4192 4193 if (!scsi_host_get(ha->host)) 4194 goto kset_free; 4195 boot_kobj = iscsi_boot_create_initiator(ha->boot_kset, 0, ha, 4196 qla4xxx_show_boot_ini_info, 4197 qla4xxx_ini_get_attr_visibility, 4198 qla4xxx_boot_release); 4199 if (!boot_kobj) 4200 goto put_host; 4201 4202 if (!scsi_host_get(ha->host)) 4203 goto kset_free; 4204 boot_kobj = iscsi_boot_create_ethernet(ha->boot_kset, 0, ha, 4205 qla4xxx_show_boot_eth_info, 4206 qla4xxx_eth_get_attr_visibility, 4207 qla4xxx_boot_release); 4208 if (!boot_kobj) 4209 goto put_host; 4210 4211 return QLA_SUCCESS; 4212 4213 put_host: 4214 scsi_host_put(ha->host); 4215 kset_free: 4216 iscsi_boot_destroy_kset(ha->boot_kset); 4217 return -ENOMEM; 4218 } 4219 4220 4221 /** 4222 * qla4xxx_create chap_list - Create CHAP list from FLASH 4223 * @ha: pointer to adapter structure 4224 * 4225 * Read flash and make a list of CHAP entries, during login when a CHAP entry 4226 * is received, it will be checked in this list. If entry exist then the CHAP 4227 * entry index is set in the DDB. If CHAP entry does not exist in this list 4228 * then a new entry is added in FLASH in CHAP table and the index obtained is 4229 * used in the DDB. 4230 **/ 4231 static void qla4xxx_create_chap_list(struct scsi_qla_host *ha) 4232 { 4233 int rval = 0; 4234 uint8_t *chap_flash_data = NULL; 4235 uint32_t offset; 4236 dma_addr_t chap_dma; 4237 uint32_t chap_size = 0; 4238 4239 if (is_qla40XX(ha)) 4240 chap_size = MAX_CHAP_ENTRIES_40XX * 4241 sizeof(struct ql4_chap_table); 4242 else /* Single region contains CHAP info for both 4243 * ports which is divided into half for each port. 4244 */ 4245 chap_size = ha->hw.flt_chap_size / 2; 4246 4247 chap_flash_data = dma_alloc_coherent(&ha->pdev->dev, chap_size, 4248 &chap_dma, GFP_KERNEL); 4249 if (!chap_flash_data) { 4250 ql4_printk(KERN_ERR, ha, "No memory for chap_flash_data\n"); 4251 return; 4252 } 4253 if (is_qla40XX(ha)) 4254 offset = FLASH_CHAP_OFFSET; 4255 else { 4256 offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2); 4257 if (ha->port_num == 1) 4258 offset += chap_size; 4259 } 4260 4261 rval = qla4xxx_get_flash(ha, chap_dma, offset, chap_size); 4262 if (rval != QLA_SUCCESS) 4263 goto exit_chap_list; 4264 4265 if (ha->chap_list == NULL) 4266 ha->chap_list = vmalloc(chap_size); 4267 if (ha->chap_list == NULL) { 4268 ql4_printk(KERN_ERR, ha, "No memory for ha->chap_list\n"); 4269 goto exit_chap_list; 4270 } 4271 4272 memcpy(ha->chap_list, chap_flash_data, chap_size); 4273 4274 exit_chap_list: 4275 dma_free_coherent(&ha->pdev->dev, chap_size, 4276 chap_flash_data, chap_dma); 4277 } 4278 4279 static void qla4xxx_get_param_ddb(struct ddb_entry *ddb_entry, 4280 struct ql4_tuple_ddb *tddb) 4281 { 4282 struct scsi_qla_host *ha; 4283 struct iscsi_cls_session *cls_sess; 4284 struct iscsi_cls_conn *cls_conn; 4285 struct iscsi_session *sess; 4286 struct iscsi_conn *conn; 4287 4288 DEBUG2(printk(KERN_INFO "Func: %s\n", __func__)); 4289 ha = ddb_entry->ha; 4290 cls_sess = ddb_entry->sess; 4291 sess = cls_sess->dd_data; 4292 cls_conn = ddb_entry->conn; 4293 conn = cls_conn->dd_data; 4294 4295 tddb->tpgt = sess->tpgt; 4296 tddb->port = conn->persistent_port; 4297 strncpy(tddb->iscsi_name, sess->targetname, ISCSI_NAME_SIZE); 4298 strncpy(tddb->ip_addr, conn->persistent_address, DDB_IPADDR_LEN); 4299 } 4300 4301 static void qla4xxx_convert_param_ddb(struct dev_db_entry *fw_ddb_entry, 4302 struct ql4_tuple_ddb *tddb, 4303 uint8_t *flash_isid) 4304 { 4305 uint16_t options = 0; 4306 4307 tddb->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp); 4308 memcpy(&tddb->iscsi_name[0], &fw_ddb_entry->iscsi_name[0], 4309 min(sizeof(tddb->iscsi_name), sizeof(fw_ddb_entry->iscsi_name))); 4310 4311 options = le16_to_cpu(fw_ddb_entry->options); 4312 if (options & DDB_OPT_IPV6_DEVICE) 4313 sprintf(tddb->ip_addr, "%pI6", fw_ddb_entry->ip_addr); 4314 else 4315 sprintf(tddb->ip_addr, "%pI4", fw_ddb_entry->ip_addr); 4316 4317 tddb->port = le16_to_cpu(fw_ddb_entry->port); 4318 4319 if (flash_isid == NULL) 4320 memcpy(&tddb->isid[0], &fw_ddb_entry->isid[0], 4321 sizeof(tddb->isid)); 4322 else 4323 memcpy(&tddb->isid[0], &flash_isid[0], sizeof(tddb->isid)); 4324 } 4325 4326 static int qla4xxx_compare_tuple_ddb(struct scsi_qla_host *ha, 4327 struct ql4_tuple_ddb *old_tddb, 4328 struct ql4_tuple_ddb *new_tddb, 4329 uint8_t is_isid_compare) 4330 { 4331 if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name)) 4332 return QLA_ERROR; 4333 4334 if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr)) 4335 return QLA_ERROR; 4336 4337 if (old_tddb->port != new_tddb->port) 4338 return QLA_ERROR; 4339 4340 /* For multi sessions, driver generates the ISID, so do not compare 4341 * ISID in reset path since it would be a comparision between the 4342 * driver generated ISID and firmware generated ISID. This could 4343 * lead to adding duplicated DDBs in the list as driver generated 4344 * ISID would not match firmware generated ISID. 4345 */ 4346 if (is_isid_compare) { 4347 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: old ISID [%02x%02x%02x" 4348 "%02x%02x%02x] New ISID [%02x%02x%02x%02x%02x%02x]\n", 4349 __func__, old_tddb->isid[5], old_tddb->isid[4], 4350 old_tddb->isid[3], old_tddb->isid[2], old_tddb->isid[1], 4351 old_tddb->isid[0], new_tddb->isid[5], new_tddb->isid[4], 4352 new_tddb->isid[3], new_tddb->isid[2], new_tddb->isid[1], 4353 new_tddb->isid[0])); 4354 4355 if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0], 4356 sizeof(old_tddb->isid))) 4357 return QLA_ERROR; 4358 } 4359 4360 DEBUG2(ql4_printk(KERN_INFO, ha, 4361 "Match Found, fw[%d,%d,%s,%s], [%d,%d,%s,%s]", 4362 old_tddb->port, old_tddb->tpgt, old_tddb->ip_addr, 4363 old_tddb->iscsi_name, new_tddb->port, new_tddb->tpgt, 4364 new_tddb->ip_addr, new_tddb->iscsi_name)); 4365 4366 return QLA_SUCCESS; 4367 } 4368 4369 static int qla4xxx_is_session_exists(struct scsi_qla_host *ha, 4370 struct dev_db_entry *fw_ddb_entry) 4371 { 4372 struct ddb_entry *ddb_entry; 4373 struct ql4_tuple_ddb *fw_tddb = NULL; 4374 struct ql4_tuple_ddb *tmp_tddb = NULL; 4375 int idx; 4376 int ret = QLA_ERROR; 4377 4378 fw_tddb = vzalloc(sizeof(*fw_tddb)); 4379 if (!fw_tddb) { 4380 DEBUG2(ql4_printk(KERN_WARNING, ha, 4381 "Memory Allocation failed.\n")); 4382 ret = QLA_SUCCESS; 4383 goto exit_check; 4384 } 4385 4386 tmp_tddb = vzalloc(sizeof(*tmp_tddb)); 4387 if (!tmp_tddb) { 4388 DEBUG2(ql4_printk(KERN_WARNING, ha, 4389 "Memory Allocation failed.\n")); 4390 ret = QLA_SUCCESS; 4391 goto exit_check; 4392 } 4393 4394 qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL); 4395 4396 for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) { 4397 ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx); 4398 if (ddb_entry == NULL) 4399 continue; 4400 4401 qla4xxx_get_param_ddb(ddb_entry, tmp_tddb); 4402 if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, false)) { 4403 ret = QLA_SUCCESS; /* found */ 4404 goto exit_check; 4405 } 4406 } 4407 4408 exit_check: 4409 if (fw_tddb) 4410 vfree(fw_tddb); 4411 if (tmp_tddb) 4412 vfree(tmp_tddb); 4413 return ret; 4414 } 4415 4416 /** 4417 * qla4xxx_check_existing_isid - check if target with same isid exist 4418 * in target list 4419 * @list_nt: list of target 4420 * @isid: isid to check 4421 * 4422 * This routine return QLA_SUCCESS if target with same isid exist 4423 **/ 4424 static int qla4xxx_check_existing_isid(struct list_head *list_nt, uint8_t *isid) 4425 { 4426 struct qla_ddb_index *nt_ddb_idx, *nt_ddb_idx_tmp; 4427 struct dev_db_entry *fw_ddb_entry; 4428 4429 list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) { 4430 fw_ddb_entry = &nt_ddb_idx->fw_ddb; 4431 4432 if (memcmp(&fw_ddb_entry->isid[0], &isid[0], 4433 sizeof(nt_ddb_idx->fw_ddb.isid)) == 0) { 4434 return QLA_SUCCESS; 4435 } 4436 } 4437 return QLA_ERROR; 4438 } 4439 4440 /** 4441 * qla4xxx_update_isid - compare ddbs and updated isid 4442 * @ha: Pointer to host adapter structure. 4443 * @list_nt: list of nt target 4444 * @fw_ddb_entry: firmware ddb entry 4445 * 4446 * This routine update isid if ddbs have same iqn, same isid and 4447 * different IP addr. 4448 * Return QLA_SUCCESS if isid is updated. 4449 **/ 4450 static int qla4xxx_update_isid(struct scsi_qla_host *ha, 4451 struct list_head *list_nt, 4452 struct dev_db_entry *fw_ddb_entry) 4453 { 4454 uint8_t base_value, i; 4455 4456 base_value = fw_ddb_entry->isid[1] & 0x1f; 4457 for (i = 0; i < 8; i++) { 4458 fw_ddb_entry->isid[1] = (base_value | (i << 5)); 4459 if (qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid)) 4460 break; 4461 } 4462 4463 if (!qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid)) 4464 return QLA_ERROR; 4465 4466 return QLA_SUCCESS; 4467 } 4468 4469 /** 4470 * qla4xxx_should_update_isid - check if isid need to update 4471 * @ha: Pointer to host adapter structure. 4472 * @old_tddb: ddb tuple 4473 * @new_tddb: ddb tuple 4474 * 4475 * Return QLA_SUCCESS if different IP, different PORT, same iqn, 4476 * same isid 4477 **/ 4478 static int qla4xxx_should_update_isid(struct scsi_qla_host *ha, 4479 struct ql4_tuple_ddb *old_tddb, 4480 struct ql4_tuple_ddb *new_tddb) 4481 { 4482 if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr) == 0) { 4483 /* Same ip */ 4484 if (old_tddb->port == new_tddb->port) 4485 return QLA_ERROR; 4486 } 4487 4488 if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name)) 4489 /* different iqn */ 4490 return QLA_ERROR; 4491 4492 if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0], 4493 sizeof(old_tddb->isid))) 4494 /* different isid */ 4495 return QLA_ERROR; 4496 4497 return QLA_SUCCESS; 4498 } 4499 4500 /** 4501 * qla4xxx_is_flash_ddb_exists - check if fw_ddb_entry already exists in list_nt 4502 * @ha: Pointer to host adapter structure. 4503 * @list_nt: list of nt target. 4504 * @fw_ddb_entry: firmware ddb entry. 4505 * 4506 * This routine check if fw_ddb_entry already exists in list_nt to avoid 4507 * duplicate ddb in list_nt. 4508 * Return QLA_SUCCESS if duplicate ddb exit in list_nl. 4509 * Note: This function also update isid of DDB if required. 4510 **/ 4511 4512 static int qla4xxx_is_flash_ddb_exists(struct scsi_qla_host *ha, 4513 struct list_head *list_nt, 4514 struct dev_db_entry *fw_ddb_entry) 4515 { 4516 struct qla_ddb_index *nt_ddb_idx, *nt_ddb_idx_tmp; 4517 struct ql4_tuple_ddb *fw_tddb = NULL; 4518 struct ql4_tuple_ddb *tmp_tddb = NULL; 4519 int rval, ret = QLA_ERROR; 4520 4521 fw_tddb = vzalloc(sizeof(*fw_tddb)); 4522 if (!fw_tddb) { 4523 DEBUG2(ql4_printk(KERN_WARNING, ha, 4524 "Memory Allocation failed.\n")); 4525 ret = QLA_SUCCESS; 4526 goto exit_check; 4527 } 4528 4529 tmp_tddb = vzalloc(sizeof(*tmp_tddb)); 4530 if (!tmp_tddb) { 4531 DEBUG2(ql4_printk(KERN_WARNING, ha, 4532 "Memory Allocation failed.\n")); 4533 ret = QLA_SUCCESS; 4534 goto exit_check; 4535 } 4536 4537 qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL); 4538 4539 list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) { 4540 qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb, 4541 nt_ddb_idx->flash_isid); 4542 ret = qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, true); 4543 /* found duplicate ddb */ 4544 if (ret == QLA_SUCCESS) 4545 goto exit_check; 4546 } 4547 4548 list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) { 4549 qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb, NULL); 4550 4551 ret = qla4xxx_should_update_isid(ha, tmp_tddb, fw_tddb); 4552 if (ret == QLA_SUCCESS) { 4553 rval = qla4xxx_update_isid(ha, list_nt, fw_ddb_entry); 4554 if (rval == QLA_SUCCESS) 4555 ret = QLA_ERROR; 4556 else 4557 ret = QLA_SUCCESS; 4558 4559 goto exit_check; 4560 } 4561 } 4562 4563 exit_check: 4564 if (fw_tddb) 4565 vfree(fw_tddb); 4566 if (tmp_tddb) 4567 vfree(tmp_tddb); 4568 return ret; 4569 } 4570 4571 static void qla4xxx_free_ddb_list(struct list_head *list_ddb) 4572 { 4573 struct qla_ddb_index *ddb_idx, *ddb_idx_tmp; 4574 4575 list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) { 4576 list_del_init(&ddb_idx->list); 4577 vfree(ddb_idx); 4578 } 4579 } 4580 4581 static struct iscsi_endpoint *qla4xxx_get_ep_fwdb(struct scsi_qla_host *ha, 4582 struct dev_db_entry *fw_ddb_entry) 4583 { 4584 struct iscsi_endpoint *ep; 4585 struct sockaddr_in *addr; 4586 struct sockaddr_in6 *addr6; 4587 struct sockaddr *dst_addr; 4588 char *ip; 4589 4590 /* TODO: need to destroy on unload iscsi_endpoint*/ 4591 dst_addr = vmalloc(sizeof(*dst_addr)); 4592 if (!dst_addr) 4593 return NULL; 4594 4595 if (fw_ddb_entry->options & DDB_OPT_IPV6_DEVICE) { 4596 dst_addr->sa_family = AF_INET6; 4597 addr6 = (struct sockaddr_in6 *)dst_addr; 4598 ip = (char *)&addr6->sin6_addr; 4599 memcpy(ip, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN); 4600 addr6->sin6_port = htons(le16_to_cpu(fw_ddb_entry->port)); 4601 4602 } else { 4603 dst_addr->sa_family = AF_INET; 4604 addr = (struct sockaddr_in *)dst_addr; 4605 ip = (char *)&addr->sin_addr; 4606 memcpy(ip, fw_ddb_entry->ip_addr, IP_ADDR_LEN); 4607 addr->sin_port = htons(le16_to_cpu(fw_ddb_entry->port)); 4608 } 4609 4610 ep = qla4xxx_ep_connect(ha->host, dst_addr, 0); 4611 vfree(dst_addr); 4612 return ep; 4613 } 4614 4615 static int qla4xxx_verify_boot_idx(struct scsi_qla_host *ha, uint16_t idx) 4616 { 4617 if (ql4xdisablesysfsboot) 4618 return QLA_SUCCESS; 4619 if (idx == ha->pri_ddb_idx || idx == ha->sec_ddb_idx) 4620 return QLA_ERROR; 4621 return QLA_SUCCESS; 4622 } 4623 4624 static void qla4xxx_setup_flash_ddb_entry(struct scsi_qla_host *ha, 4625 struct ddb_entry *ddb_entry) 4626 { 4627 uint16_t def_timeout; 4628 4629 ddb_entry->ddb_type = FLASH_DDB; 4630 ddb_entry->fw_ddb_index = INVALID_ENTRY; 4631 ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE; 4632 ddb_entry->ha = ha; 4633 ddb_entry->unblock_sess = qla4xxx_unblock_flash_ddb; 4634 ddb_entry->ddb_change = qla4xxx_flash_ddb_change; 4635 4636 atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY); 4637 atomic_set(&ddb_entry->relogin_timer, 0); 4638 atomic_set(&ddb_entry->relogin_retry_count, 0); 4639 def_timeout = le16_to_cpu(ddb_entry->fw_ddb_entry.def_timeout); 4640 ddb_entry->default_relogin_timeout = 4641 (def_timeout > LOGIN_TOV) && (def_timeout < LOGIN_TOV * 10) ? 4642 def_timeout : LOGIN_TOV; 4643 ddb_entry->default_time2wait = 4644 le16_to_cpu(ddb_entry->fw_ddb_entry.iscsi_def_time2wait); 4645 } 4646 4647 static void qla4xxx_wait_for_ip_configuration(struct scsi_qla_host *ha) 4648 { 4649 uint32_t idx = 0; 4650 uint32_t ip_idx[IP_ADDR_COUNT] = {0, 1, 2, 3}; /* 4 IP interfaces */ 4651 uint32_t sts[MBOX_REG_COUNT]; 4652 uint32_t ip_state; 4653 unsigned long wtime; 4654 int ret; 4655 4656 wtime = jiffies + (HZ * IP_CONFIG_TOV); 4657 do { 4658 for (idx = 0; idx < IP_ADDR_COUNT; idx++) { 4659 if (ip_idx[idx] == -1) 4660 continue; 4661 4662 ret = qla4xxx_get_ip_state(ha, 0, ip_idx[idx], sts); 4663 4664 if (ret == QLA_ERROR) { 4665 ip_idx[idx] = -1; 4666 continue; 4667 } 4668 4669 ip_state = (sts[1] & IP_STATE_MASK) >> IP_STATE_SHIFT; 4670 4671 DEBUG2(ql4_printk(KERN_INFO, ha, 4672 "Waiting for IP state for idx = %d, state = 0x%x\n", 4673 ip_idx[idx], ip_state)); 4674 if (ip_state == IP_ADDRSTATE_UNCONFIGURED || 4675 ip_state == IP_ADDRSTATE_INVALID || 4676 ip_state == IP_ADDRSTATE_PREFERRED || 4677 ip_state == IP_ADDRSTATE_DEPRICATED || 4678 ip_state == IP_ADDRSTATE_DISABLING) 4679 ip_idx[idx] = -1; 4680 } 4681 4682 /* Break if all IP states checked */ 4683 if ((ip_idx[0] == -1) && 4684 (ip_idx[1] == -1) && 4685 (ip_idx[2] == -1) && 4686 (ip_idx[3] == -1)) 4687 break; 4688 schedule_timeout_uninterruptible(HZ); 4689 } while (time_after(wtime, jiffies)); 4690 } 4691 4692 static void qla4xxx_build_st_list(struct scsi_qla_host *ha, 4693 struct list_head *list_st) 4694 { 4695 struct qla_ddb_index *st_ddb_idx; 4696 int max_ddbs; 4697 int fw_idx_size; 4698 struct dev_db_entry *fw_ddb_entry; 4699 dma_addr_t fw_ddb_dma; 4700 int ret; 4701 uint32_t idx = 0, next_idx = 0; 4702 uint32_t state = 0, conn_err = 0; 4703 uint16_t conn_id = 0; 4704 4705 fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL, 4706 &fw_ddb_dma); 4707 if (fw_ddb_entry == NULL) { 4708 DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n")); 4709 goto exit_st_list; 4710 } 4711 4712 max_ddbs = is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX : 4713 MAX_DEV_DB_ENTRIES; 4714 fw_idx_size = sizeof(struct qla_ddb_index); 4715 4716 for (idx = 0; idx < max_ddbs; idx = next_idx) { 4717 ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma, 4718 NULL, &next_idx, &state, 4719 &conn_err, NULL, &conn_id); 4720 if (ret == QLA_ERROR) 4721 break; 4722 4723 /* Ignore DDB if invalid state (unassigned) */ 4724 if (state == DDB_DS_UNASSIGNED) 4725 goto continue_next_st; 4726 4727 /* Check if ST, add to the list_st */ 4728 if (strlen((char *) fw_ddb_entry->iscsi_name) != 0) 4729 goto continue_next_st; 4730 4731 st_ddb_idx = vzalloc(fw_idx_size); 4732 if (!st_ddb_idx) 4733 break; 4734 4735 st_ddb_idx->fw_ddb_idx = idx; 4736 4737 list_add_tail(&st_ddb_idx->list, list_st); 4738 continue_next_st: 4739 if (next_idx == 0) 4740 break; 4741 } 4742 4743 exit_st_list: 4744 if (fw_ddb_entry) 4745 dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma); 4746 } 4747 4748 /** 4749 * qla4xxx_remove_failed_ddb - Remove inactive or failed ddb from list 4750 * @ha: pointer to adapter structure 4751 * @list_ddb: List from which failed ddb to be removed 4752 * 4753 * Iterate over the list of DDBs and find and remove DDBs that are either in 4754 * no connection active state or failed state 4755 **/ 4756 static void qla4xxx_remove_failed_ddb(struct scsi_qla_host *ha, 4757 struct list_head *list_ddb) 4758 { 4759 struct qla_ddb_index *ddb_idx, *ddb_idx_tmp; 4760 uint32_t next_idx = 0; 4761 uint32_t state = 0, conn_err = 0; 4762 int ret; 4763 4764 list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) { 4765 ret = qla4xxx_get_fwddb_entry(ha, ddb_idx->fw_ddb_idx, 4766 NULL, 0, NULL, &next_idx, &state, 4767 &conn_err, NULL, NULL); 4768 if (ret == QLA_ERROR) 4769 continue; 4770 4771 if (state == DDB_DS_NO_CONNECTION_ACTIVE || 4772 state == DDB_DS_SESSION_FAILED) { 4773 list_del_init(&ddb_idx->list); 4774 vfree(ddb_idx); 4775 } 4776 } 4777 } 4778 4779 static int qla4xxx_sess_conn_setup(struct scsi_qla_host *ha, 4780 struct dev_db_entry *fw_ddb_entry, 4781 int is_reset) 4782 { 4783 struct iscsi_cls_session *cls_sess; 4784 struct iscsi_session *sess; 4785 struct iscsi_cls_conn *cls_conn; 4786 struct iscsi_endpoint *ep; 4787 uint16_t cmds_max = 32; 4788 uint16_t conn_id = 0; 4789 uint32_t initial_cmdsn = 0; 4790 int ret = QLA_SUCCESS; 4791 4792 struct ddb_entry *ddb_entry = NULL; 4793 4794 /* Create session object, with INVALID_ENTRY, 4795 * the targer_id would get set when we issue the login 4796 */ 4797 cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, ha->host, 4798 cmds_max, sizeof(struct ddb_entry), 4799 sizeof(struct ql4_task_data), 4800 initial_cmdsn, INVALID_ENTRY); 4801 if (!cls_sess) { 4802 ret = QLA_ERROR; 4803 goto exit_setup; 4804 } 4805 4806 /* 4807 * so calling module_put function to decrement the 4808 * reference count. 4809 **/ 4810 module_put(qla4xxx_iscsi_transport.owner); 4811 sess = cls_sess->dd_data; 4812 ddb_entry = sess->dd_data; 4813 ddb_entry->sess = cls_sess; 4814 4815 cls_sess->recovery_tmo = ql4xsess_recovery_tmo; 4816 memcpy(&ddb_entry->fw_ddb_entry, fw_ddb_entry, 4817 sizeof(struct dev_db_entry)); 4818 4819 qla4xxx_setup_flash_ddb_entry(ha, ddb_entry); 4820 4821 cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn), conn_id); 4822 4823 if (!cls_conn) { 4824 ret = QLA_ERROR; 4825 goto exit_setup; 4826 } 4827 4828 ddb_entry->conn = cls_conn; 4829 4830 /* Setup ep, for displaying attributes in sysfs */ 4831 ep = qla4xxx_get_ep_fwdb(ha, fw_ddb_entry); 4832 if (ep) { 4833 ep->conn = cls_conn; 4834 cls_conn->ep = ep; 4835 } else { 4836 DEBUG2(ql4_printk(KERN_ERR, ha, "Unable to get ep\n")); 4837 ret = QLA_ERROR; 4838 goto exit_setup; 4839 } 4840 4841 /* Update sess/conn params */ 4842 qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn); 4843 4844 if (is_reset == RESET_ADAPTER) { 4845 iscsi_block_session(cls_sess); 4846 /* Use the relogin path to discover new devices 4847 * by short-circuting the logic of setting 4848 * timer to relogin - instead set the flags 4849 * to initiate login right away. 4850 */ 4851 set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags); 4852 set_bit(DF_RELOGIN, &ddb_entry->flags); 4853 } 4854 4855 exit_setup: 4856 return ret; 4857 } 4858 4859 static void qla4xxx_build_nt_list(struct scsi_qla_host *ha, 4860 struct list_head *list_nt, int is_reset) 4861 { 4862 struct dev_db_entry *fw_ddb_entry; 4863 dma_addr_t fw_ddb_dma; 4864 int max_ddbs; 4865 int fw_idx_size; 4866 int ret; 4867 uint32_t idx = 0, next_idx = 0; 4868 uint32_t state = 0, conn_err = 0; 4869 uint16_t conn_id = 0; 4870 struct qla_ddb_index *nt_ddb_idx; 4871 4872 fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL, 4873 &fw_ddb_dma); 4874 if (fw_ddb_entry == NULL) { 4875 DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n")); 4876 goto exit_nt_list; 4877 } 4878 max_ddbs = is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX : 4879 MAX_DEV_DB_ENTRIES; 4880 fw_idx_size = sizeof(struct qla_ddb_index); 4881 4882 for (idx = 0; idx < max_ddbs; idx = next_idx) { 4883 ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma, 4884 NULL, &next_idx, &state, 4885 &conn_err, NULL, &conn_id); 4886 if (ret == QLA_ERROR) 4887 break; 4888 4889 if (qla4xxx_verify_boot_idx(ha, idx) != QLA_SUCCESS) 4890 goto continue_next_nt; 4891 4892 /* Check if NT, then add to list it */ 4893 if (strlen((char *) fw_ddb_entry->iscsi_name) == 0) 4894 goto continue_next_nt; 4895 4896 if (!(state == DDB_DS_NO_CONNECTION_ACTIVE || 4897 state == DDB_DS_SESSION_FAILED)) 4898 goto continue_next_nt; 4899 4900 DEBUG2(ql4_printk(KERN_INFO, ha, 4901 "Adding DDB to session = 0x%x\n", idx)); 4902 if (is_reset == INIT_ADAPTER) { 4903 nt_ddb_idx = vmalloc(fw_idx_size); 4904 if (!nt_ddb_idx) 4905 break; 4906 4907 nt_ddb_idx->fw_ddb_idx = idx; 4908 4909 /* Copy original isid as it may get updated in function 4910 * qla4xxx_update_isid(). We need original isid in 4911 * function qla4xxx_compare_tuple_ddb to find duplicate 4912 * target */ 4913 memcpy(&nt_ddb_idx->flash_isid[0], 4914 &fw_ddb_entry->isid[0], 4915 sizeof(nt_ddb_idx->flash_isid)); 4916 4917 ret = qla4xxx_is_flash_ddb_exists(ha, list_nt, 4918 fw_ddb_entry); 4919 if (ret == QLA_SUCCESS) { 4920 /* free nt_ddb_idx and do not add to list_nt */ 4921 vfree(nt_ddb_idx); 4922 goto continue_next_nt; 4923 } 4924 4925 /* Copy updated isid */ 4926 memcpy(&nt_ddb_idx->fw_ddb, fw_ddb_entry, 4927 sizeof(struct dev_db_entry)); 4928 4929 list_add_tail(&nt_ddb_idx->list, list_nt); 4930 } else if (is_reset == RESET_ADAPTER) { 4931 if (qla4xxx_is_session_exists(ha, fw_ddb_entry) == 4932 QLA_SUCCESS) 4933 goto continue_next_nt; 4934 } 4935 4936 ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, is_reset); 4937 if (ret == QLA_ERROR) 4938 goto exit_nt_list; 4939 4940 continue_next_nt: 4941 if (next_idx == 0) 4942 break; 4943 } 4944 4945 exit_nt_list: 4946 if (fw_ddb_entry) 4947 dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma); 4948 } 4949 4950 /** 4951 * qla4xxx_build_ddb_list - Build ddb list and setup sessions 4952 * @ha: pointer to adapter structure 4953 * @is_reset: Is this init path or reset path 4954 * 4955 * Create a list of sendtargets (st) from firmware DDBs, issue send targets 4956 * using connection open, then create the list of normal targets (nt) 4957 * from firmware DDBs. Based on the list of nt setup session and connection 4958 * objects. 4959 **/ 4960 void qla4xxx_build_ddb_list(struct scsi_qla_host *ha, int is_reset) 4961 { 4962 uint16_t tmo = 0; 4963 struct list_head list_st, list_nt; 4964 struct qla_ddb_index *st_ddb_idx, *st_ddb_idx_tmp; 4965 unsigned long wtime; 4966 4967 if (!test_bit(AF_LINK_UP, &ha->flags)) { 4968 set_bit(AF_BUILD_DDB_LIST, &ha->flags); 4969 ha->is_reset = is_reset; 4970 return; 4971 } 4972 4973 INIT_LIST_HEAD(&list_st); 4974 INIT_LIST_HEAD(&list_nt); 4975 4976 qla4xxx_build_st_list(ha, &list_st); 4977 4978 /* Before issuing conn open mbox, ensure all IPs states are configured 4979 * Note, conn open fails if IPs are not configured 4980 */ 4981 qla4xxx_wait_for_ip_configuration(ha); 4982 4983 /* Go thru the STs and fire the sendtargets by issuing conn open mbx */ 4984 list_for_each_entry_safe(st_ddb_idx, st_ddb_idx_tmp, &list_st, list) { 4985 qla4xxx_conn_open(ha, st_ddb_idx->fw_ddb_idx); 4986 } 4987 4988 /* Wait to ensure all sendtargets are done for min 12 sec wait */ 4989 tmo = ((ha->def_timeout > LOGIN_TOV) && 4990 (ha->def_timeout < LOGIN_TOV * 10) ? 4991 ha->def_timeout : LOGIN_TOV); 4992 4993 DEBUG2(ql4_printk(KERN_INFO, ha, 4994 "Default time to wait for build ddb %d\n", tmo)); 4995 4996 wtime = jiffies + (HZ * tmo); 4997 do { 4998 if (list_empty(&list_st)) 4999 break; 5000 5001 qla4xxx_remove_failed_ddb(ha, &list_st); 5002 schedule_timeout_uninterruptible(HZ / 10); 5003 } while (time_after(wtime, jiffies)); 5004 5005 /* Free up the sendtargets list */ 5006 qla4xxx_free_ddb_list(&list_st); 5007 5008 qla4xxx_build_nt_list(ha, &list_nt, is_reset); 5009 5010 qla4xxx_free_ddb_list(&list_nt); 5011 5012 qla4xxx_free_ddb_index(ha); 5013 } 5014 5015 /** 5016 * qla4xxx_probe_adapter - callback function to probe HBA 5017 * @pdev: pointer to pci_dev structure 5018 * @pci_device_id: pointer to pci_device entry 5019 * 5020 * This routine will probe for Qlogic 4xxx iSCSI host adapters. 5021 * It returns zero if successful. It also initializes all data necessary for 5022 * the driver. 5023 **/ 5024 static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev, 5025 const struct pci_device_id *ent) 5026 { 5027 int ret = -ENODEV, status; 5028 struct Scsi_Host *host; 5029 struct scsi_qla_host *ha; 5030 uint8_t init_retry_count = 0; 5031 char buf[34]; 5032 struct qla4_8xxx_legacy_intr_set *nx_legacy_intr; 5033 uint32_t dev_state; 5034 5035 if (pci_enable_device(pdev)) 5036 return -1; 5037 5038 host = iscsi_host_alloc(&qla4xxx_driver_template, sizeof(*ha), 0); 5039 if (host == NULL) { 5040 printk(KERN_WARNING 5041 "qla4xxx: Couldn't allocate host from scsi layer!\n"); 5042 goto probe_disable_device; 5043 } 5044 5045 /* Clear our data area */ 5046 ha = to_qla_host(host); 5047 memset(ha, 0, sizeof(*ha)); 5048 5049 /* Save the information from PCI BIOS. */ 5050 ha->pdev = pdev; 5051 ha->host = host; 5052 ha->host_no = host->host_no; 5053 5054 pci_enable_pcie_error_reporting(pdev); 5055 5056 /* Setup Runtime configurable options */ 5057 if (is_qla8022(ha)) { 5058 ha->isp_ops = &qla4_8xxx_isp_ops; 5059 rwlock_init(&ha->hw_lock); 5060 ha->qdr_sn_window = -1; 5061 ha->ddr_mn_window = -1; 5062 ha->curr_window = 255; 5063 ha->func_num = PCI_FUNC(ha->pdev->devfn); 5064 nx_legacy_intr = &legacy_intr[ha->func_num]; 5065 ha->nx_legacy_intr.int_vec_bit = nx_legacy_intr->int_vec_bit; 5066 ha->nx_legacy_intr.tgt_status_reg = 5067 nx_legacy_intr->tgt_status_reg; 5068 ha->nx_legacy_intr.tgt_mask_reg = nx_legacy_intr->tgt_mask_reg; 5069 ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg; 5070 } else { 5071 ha->isp_ops = &qla4xxx_isp_ops; 5072 } 5073 5074 /* Set EEH reset type to fundamental if required by hba */ 5075 if (is_qla8022(ha)) 5076 pdev->needs_freset = 1; 5077 5078 /* Configure PCI I/O space. */ 5079 ret = ha->isp_ops->iospace_config(ha); 5080 if (ret) 5081 goto probe_failed_ioconfig; 5082 5083 ql4_printk(KERN_INFO, ha, "Found an ISP%04x, irq %d, iobase 0x%p\n", 5084 pdev->device, pdev->irq, ha->reg); 5085 5086 qla4xxx_config_dma_addressing(ha); 5087 5088 /* Initialize lists and spinlocks. */ 5089 INIT_LIST_HEAD(&ha->free_srb_q); 5090 5091 mutex_init(&ha->mbox_sem); 5092 mutex_init(&ha->chap_sem); 5093 init_completion(&ha->mbx_intr_comp); 5094 init_completion(&ha->disable_acb_comp); 5095 5096 spin_lock_init(&ha->hardware_lock); 5097 5098 /* Initialize work list */ 5099 INIT_LIST_HEAD(&ha->work_list); 5100 5101 /* Allocate dma buffers */ 5102 if (qla4xxx_mem_alloc(ha)) { 5103 ql4_printk(KERN_WARNING, ha, 5104 "[ERROR] Failed to allocate memory for adapter\n"); 5105 5106 ret = -ENOMEM; 5107 goto probe_failed; 5108 } 5109 5110 host->cmd_per_lun = 3; 5111 host->max_channel = 0; 5112 host->max_lun = MAX_LUNS - 1; 5113 host->max_id = MAX_TARGETS; 5114 host->max_cmd_len = IOCB_MAX_CDB_LEN; 5115 host->can_queue = MAX_SRBS ; 5116 host->transportt = qla4xxx_scsi_transport; 5117 5118 ret = scsi_init_shared_tag_map(host, MAX_SRBS); 5119 if (ret) { 5120 ql4_printk(KERN_WARNING, ha, 5121 "%s: scsi_init_shared_tag_map failed\n", __func__); 5122 goto probe_failed; 5123 } 5124 5125 pci_set_drvdata(pdev, ha); 5126 5127 ret = scsi_add_host(host, &pdev->dev); 5128 if (ret) 5129 goto probe_failed; 5130 5131 if (is_qla8022(ha)) 5132 (void) qla4_8xxx_get_flash_info(ha); 5133 5134 /* 5135 * Initialize the Host adapter request/response queues and 5136 * firmware 5137 * NOTE: interrupts enabled upon successful completion 5138 */ 5139 status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER); 5140 while ((!test_bit(AF_ONLINE, &ha->flags)) && 5141 init_retry_count++ < MAX_INIT_RETRIES) { 5142 5143 if (is_qla8022(ha)) { 5144 qla4_8xxx_idc_lock(ha); 5145 dev_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE); 5146 qla4_8xxx_idc_unlock(ha); 5147 if (dev_state == QLA82XX_DEV_FAILED) { 5148 ql4_printk(KERN_WARNING, ha, "%s: don't retry " 5149 "initialize adapter. H/W is in failed state\n", 5150 __func__); 5151 break; 5152 } 5153 } 5154 DEBUG2(printk("scsi: %s: retrying adapter initialization " 5155 "(%d)\n", __func__, init_retry_count)); 5156 5157 if (ha->isp_ops->reset_chip(ha) == QLA_ERROR) 5158 continue; 5159 5160 status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER); 5161 } 5162 5163 if (!test_bit(AF_ONLINE, &ha->flags)) { 5164 ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n"); 5165 5166 if (is_qla8022(ha) && ql4xdontresethba) { 5167 /* Put the device in failed state. */ 5168 DEBUG2(printk(KERN_ERR "HW STATE: FAILED\n")); 5169 qla4_8xxx_idc_lock(ha); 5170 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 5171 QLA82XX_DEV_FAILED); 5172 qla4_8xxx_idc_unlock(ha); 5173 } 5174 ret = -ENODEV; 5175 goto remove_host; 5176 } 5177 5178 /* Startup the kernel thread for this host adapter. */ 5179 DEBUG2(printk("scsi: %s: Starting kernel thread for " 5180 "qla4xxx_dpc\n", __func__)); 5181 sprintf(buf, "qla4xxx_%lu_dpc", ha->host_no); 5182 ha->dpc_thread = create_singlethread_workqueue(buf); 5183 if (!ha->dpc_thread) { 5184 ql4_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n"); 5185 ret = -ENODEV; 5186 goto remove_host; 5187 } 5188 INIT_WORK(&ha->dpc_work, qla4xxx_do_dpc); 5189 5190 sprintf(buf, "qla4xxx_%lu_task", ha->host_no); 5191 ha->task_wq = alloc_workqueue(buf, WQ_MEM_RECLAIM, 1); 5192 if (!ha->task_wq) { 5193 ql4_printk(KERN_WARNING, ha, "Unable to start task thread!\n"); 5194 ret = -ENODEV; 5195 goto remove_host; 5196 } 5197 5198 /* For ISP-82XX, request_irqs is called in qla4_8xxx_load_risc 5199 * (which is called indirectly by qla4xxx_initialize_adapter), 5200 * so that irqs will be registered after crbinit but before 5201 * mbx_intr_enable. 5202 */ 5203 if (!is_qla8022(ha)) { 5204 ret = qla4xxx_request_irqs(ha); 5205 if (ret) { 5206 ql4_printk(KERN_WARNING, ha, "Failed to reserve " 5207 "interrupt %d already in use.\n", pdev->irq); 5208 goto remove_host; 5209 } 5210 } 5211 5212 pci_save_state(ha->pdev); 5213 ha->isp_ops->enable_intrs(ha); 5214 5215 /* Start timer thread. */ 5216 qla4xxx_start_timer(ha, qla4xxx_timer, 1); 5217 5218 set_bit(AF_INIT_DONE, &ha->flags); 5219 5220 qla4_8xxx_alloc_sysfs_attr(ha); 5221 5222 printk(KERN_INFO 5223 " QLogic iSCSI HBA Driver version: %s\n" 5224 " QLogic ISP%04x @ %s, host#=%ld, fw=%02d.%02d.%02d.%02d\n", 5225 qla4xxx_version_str, ha->pdev->device, pci_name(ha->pdev), 5226 ha->host_no, ha->firmware_version[0], ha->firmware_version[1], 5227 ha->patch_number, ha->build_number); 5228 5229 if (qla4xxx_setup_boot_info(ha)) 5230 ql4_printk(KERN_ERR, ha, 5231 "%s: No iSCSI boot target configured\n", __func__); 5232 5233 /* Perform the build ddb list and login to each */ 5234 qla4xxx_build_ddb_list(ha, INIT_ADAPTER); 5235 iscsi_host_for_each_session(ha->host, qla4xxx_login_flash_ddb); 5236 5237 qla4xxx_create_chap_list(ha); 5238 5239 qla4xxx_create_ifaces(ha); 5240 return 0; 5241 5242 remove_host: 5243 scsi_remove_host(ha->host); 5244 5245 probe_failed: 5246 qla4xxx_free_adapter(ha); 5247 5248 probe_failed_ioconfig: 5249 pci_disable_pcie_error_reporting(pdev); 5250 scsi_host_put(ha->host); 5251 5252 probe_disable_device: 5253 pci_disable_device(pdev); 5254 5255 return ret; 5256 } 5257 5258 /** 5259 * qla4xxx_prevent_other_port_reinit - prevent other port from re-initialize 5260 * @ha: pointer to adapter structure 5261 * 5262 * Mark the other ISP-4xxx port to indicate that the driver is being removed, 5263 * so that the other port will not re-initialize while in the process of 5264 * removing the ha due to driver unload or hba hotplug. 5265 **/ 5266 static void qla4xxx_prevent_other_port_reinit(struct scsi_qla_host *ha) 5267 { 5268 struct scsi_qla_host *other_ha = NULL; 5269 struct pci_dev *other_pdev = NULL; 5270 int fn = ISP4XXX_PCI_FN_2; 5271 5272 /*iscsi function numbers for ISP4xxx is 1 and 3*/ 5273 if (PCI_FUNC(ha->pdev->devfn) & BIT_1) 5274 fn = ISP4XXX_PCI_FN_1; 5275 5276 other_pdev = 5277 pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus), 5278 ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn), 5279 fn)); 5280 5281 /* Get other_ha if other_pdev is valid and state is enable*/ 5282 if (other_pdev) { 5283 if (atomic_read(&other_pdev->enable_cnt)) { 5284 other_ha = pci_get_drvdata(other_pdev); 5285 if (other_ha) { 5286 set_bit(AF_HA_REMOVAL, &other_ha->flags); 5287 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: " 5288 "Prevent %s reinit\n", __func__, 5289 dev_name(&other_ha->pdev->dev))); 5290 } 5291 } 5292 pci_dev_put(other_pdev); 5293 } 5294 } 5295 5296 static void qla4xxx_destroy_fw_ddb_session(struct scsi_qla_host *ha) 5297 { 5298 struct ddb_entry *ddb_entry; 5299 int options; 5300 int idx; 5301 5302 for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) { 5303 5304 ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx); 5305 if ((ddb_entry != NULL) && 5306 (ddb_entry->ddb_type == FLASH_DDB)) { 5307 5308 options = LOGOUT_OPTION_CLOSE_SESSION; 5309 if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) 5310 == QLA_ERROR) 5311 ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", 5312 __func__); 5313 5314 qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index); 5315 /* 5316 * we have decremented the reference count of the driver 5317 * when we setup the session to have the driver unload 5318 * to be seamless without actually destroying the 5319 * session 5320 **/ 5321 try_module_get(qla4xxx_iscsi_transport.owner); 5322 iscsi_destroy_endpoint(ddb_entry->conn->ep); 5323 qla4xxx_free_ddb(ha, ddb_entry); 5324 iscsi_session_teardown(ddb_entry->sess); 5325 } 5326 } 5327 } 5328 /** 5329 * qla4xxx_remove_adapter - calback function to remove adapter. 5330 * @pci_dev: PCI device pointer 5331 **/ 5332 static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev) 5333 { 5334 struct scsi_qla_host *ha; 5335 5336 ha = pci_get_drvdata(pdev); 5337 5338 if (!is_qla8022(ha)) 5339 qla4xxx_prevent_other_port_reinit(ha); 5340 5341 /* destroy iface from sysfs */ 5342 qla4xxx_destroy_ifaces(ha); 5343 5344 if ((!ql4xdisablesysfsboot) && ha->boot_kset) 5345 iscsi_boot_destroy_kset(ha->boot_kset); 5346 5347 qla4xxx_destroy_fw_ddb_session(ha); 5348 qla4_8xxx_free_sysfs_attr(ha); 5349 5350 scsi_remove_host(ha->host); 5351 5352 qla4xxx_free_adapter(ha); 5353 5354 scsi_host_put(ha->host); 5355 5356 pci_disable_pcie_error_reporting(pdev); 5357 pci_disable_device(pdev); 5358 pci_set_drvdata(pdev, NULL); 5359 } 5360 5361 /** 5362 * qla4xxx_config_dma_addressing() - Configure OS DMA addressing method. 5363 * @ha: HA context 5364 * 5365 * At exit, the @ha's flags.enable_64bit_addressing set to indicated 5366 * supported addressing method. 5367 */ 5368 static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha) 5369 { 5370 int retval; 5371 5372 /* Update our PCI device dma_mask for full 64 bit mask */ 5373 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64)) == 0) { 5374 if (pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) { 5375 dev_dbg(&ha->pdev->dev, 5376 "Failed to set 64 bit PCI consistent mask; " 5377 "using 32 bit.\n"); 5378 retval = pci_set_consistent_dma_mask(ha->pdev, 5379 DMA_BIT_MASK(32)); 5380 } 5381 } else 5382 retval = pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)); 5383 } 5384 5385 static int qla4xxx_slave_alloc(struct scsi_device *sdev) 5386 { 5387 struct iscsi_cls_session *cls_sess; 5388 struct iscsi_session *sess; 5389 struct ddb_entry *ddb; 5390 int queue_depth = QL4_DEF_QDEPTH; 5391 5392 cls_sess = starget_to_session(sdev->sdev_target); 5393 sess = cls_sess->dd_data; 5394 ddb = sess->dd_data; 5395 5396 sdev->hostdata = ddb; 5397 sdev->tagged_supported = 1; 5398 5399 if (ql4xmaxqdepth != 0 && ql4xmaxqdepth <= 0xffffU) 5400 queue_depth = ql4xmaxqdepth; 5401 5402 scsi_activate_tcq(sdev, queue_depth); 5403 return 0; 5404 } 5405 5406 static int qla4xxx_slave_configure(struct scsi_device *sdev) 5407 { 5408 sdev->tagged_supported = 1; 5409 return 0; 5410 } 5411 5412 static void qla4xxx_slave_destroy(struct scsi_device *sdev) 5413 { 5414 scsi_deactivate_tcq(sdev, 1); 5415 } 5416 5417 static int qla4xxx_change_queue_depth(struct scsi_device *sdev, int qdepth, 5418 int reason) 5419 { 5420 if (!ql4xqfulltracking) 5421 return -EOPNOTSUPP; 5422 5423 return iscsi_change_queue_depth(sdev, qdepth, reason); 5424 } 5425 5426 /** 5427 * qla4xxx_del_from_active_array - returns an active srb 5428 * @ha: Pointer to host adapter structure. 5429 * @index: index into the active_array 5430 * 5431 * This routine removes and returns the srb at the specified index 5432 **/ 5433 struct srb *qla4xxx_del_from_active_array(struct scsi_qla_host *ha, 5434 uint32_t index) 5435 { 5436 struct srb *srb = NULL; 5437 struct scsi_cmnd *cmd = NULL; 5438 5439 cmd = scsi_host_find_tag(ha->host, index); 5440 if (!cmd) 5441 return srb; 5442 5443 srb = (struct srb *)CMD_SP(cmd); 5444 if (!srb) 5445 return srb; 5446 5447 /* update counters */ 5448 if (srb->flags & SRB_DMA_VALID) { 5449 ha->req_q_count += srb->iocb_cnt; 5450 ha->iocb_cnt -= srb->iocb_cnt; 5451 if (srb->cmd) 5452 srb->cmd->host_scribble = 5453 (unsigned char *)(unsigned long) MAX_SRBS; 5454 } 5455 return srb; 5456 } 5457 5458 /** 5459 * qla4xxx_eh_wait_on_command - waits for command to be returned by firmware 5460 * @ha: Pointer to host adapter structure. 5461 * @cmd: Scsi Command to wait on. 5462 * 5463 * This routine waits for the command to be returned by the Firmware 5464 * for some max time. 5465 **/ 5466 static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha, 5467 struct scsi_cmnd *cmd) 5468 { 5469 int done = 0; 5470 struct srb *rp; 5471 uint32_t max_wait_time = EH_WAIT_CMD_TOV; 5472 int ret = SUCCESS; 5473 5474 /* Dont wait on command if PCI error is being handled 5475 * by PCI AER driver 5476 */ 5477 if (unlikely(pci_channel_offline(ha->pdev)) || 5478 (test_bit(AF_EEH_BUSY, &ha->flags))) { 5479 ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n", 5480 ha->host_no, __func__); 5481 return ret; 5482 } 5483 5484 do { 5485 /* Checking to see if its returned to OS */ 5486 rp = (struct srb *) CMD_SP(cmd); 5487 if (rp == NULL) { 5488 done++; 5489 break; 5490 } 5491 5492 msleep(2000); 5493 } while (max_wait_time--); 5494 5495 return done; 5496 } 5497 5498 /** 5499 * qla4xxx_wait_for_hba_online - waits for HBA to come online 5500 * @ha: Pointer to host adapter structure 5501 **/ 5502 static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha) 5503 { 5504 unsigned long wait_online; 5505 5506 wait_online = jiffies + (HBA_ONLINE_TOV * HZ); 5507 while (time_before(jiffies, wait_online)) { 5508 5509 if (adapter_up(ha)) 5510 return QLA_SUCCESS; 5511 5512 msleep(2000); 5513 } 5514 5515 return QLA_ERROR; 5516 } 5517 5518 /** 5519 * qla4xxx_eh_wait_for_commands - wait for active cmds to finish. 5520 * @ha: pointer to HBA 5521 * @t: target id 5522 * @l: lun id 5523 * 5524 * This function waits for all outstanding commands to a lun to complete. It 5525 * returns 0 if all pending commands are returned and 1 otherwise. 5526 **/ 5527 static int qla4xxx_eh_wait_for_commands(struct scsi_qla_host *ha, 5528 struct scsi_target *stgt, 5529 struct scsi_device *sdev) 5530 { 5531 int cnt; 5532 int status = 0; 5533 struct scsi_cmnd *cmd; 5534 5535 /* 5536 * Waiting for all commands for the designated target or dev 5537 * in the active array 5538 */ 5539 for (cnt = 0; cnt < ha->host->can_queue; cnt++) { 5540 cmd = scsi_host_find_tag(ha->host, cnt); 5541 if (cmd && stgt == scsi_target(cmd->device) && 5542 (!sdev || sdev == cmd->device)) { 5543 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 5544 status++; 5545 break; 5546 } 5547 } 5548 } 5549 return status; 5550 } 5551 5552 /** 5553 * qla4xxx_eh_abort - callback for abort task. 5554 * @cmd: Pointer to Linux's SCSI command structure 5555 * 5556 * This routine is called by the Linux OS to abort the specified 5557 * command. 5558 **/ 5559 static int qla4xxx_eh_abort(struct scsi_cmnd *cmd) 5560 { 5561 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 5562 unsigned int id = cmd->device->id; 5563 unsigned int lun = cmd->device->lun; 5564 unsigned long flags; 5565 struct srb *srb = NULL; 5566 int ret = SUCCESS; 5567 int wait = 0; 5568 5569 ql4_printk(KERN_INFO, ha, 5570 "scsi%ld:%d:%d: Abort command issued cmd=%p\n", 5571 ha->host_no, id, lun, cmd); 5572 5573 spin_lock_irqsave(&ha->hardware_lock, flags); 5574 srb = (struct srb *) CMD_SP(cmd); 5575 if (!srb) { 5576 spin_unlock_irqrestore(&ha->hardware_lock, flags); 5577 return SUCCESS; 5578 } 5579 kref_get(&srb->srb_ref); 5580 spin_unlock_irqrestore(&ha->hardware_lock, flags); 5581 5582 if (qla4xxx_abort_task(ha, srb) != QLA_SUCCESS) { 5583 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx failed.\n", 5584 ha->host_no, id, lun)); 5585 ret = FAILED; 5586 } else { 5587 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx success.\n", 5588 ha->host_no, id, lun)); 5589 wait = 1; 5590 } 5591 5592 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 5593 5594 /* Wait for command to complete */ 5595 if (wait) { 5596 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 5597 DEBUG2(printk("scsi%ld:%d:%d: Abort handler timed out\n", 5598 ha->host_no, id, lun)); 5599 ret = FAILED; 5600 } 5601 } 5602 5603 ql4_printk(KERN_INFO, ha, 5604 "scsi%ld:%d:%d: Abort command - %s\n", 5605 ha->host_no, id, lun, (ret == SUCCESS) ? "succeeded" : "failed"); 5606 5607 return ret; 5608 } 5609 5610 /** 5611 * qla4xxx_eh_device_reset - callback for target reset. 5612 * @cmd: Pointer to Linux's SCSI command structure 5613 * 5614 * This routine is called by the Linux OS to reset all luns on the 5615 * specified target. 5616 **/ 5617 static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd) 5618 { 5619 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 5620 struct ddb_entry *ddb_entry = cmd->device->hostdata; 5621 int ret = FAILED, stat; 5622 5623 if (!ddb_entry) 5624 return ret; 5625 5626 ret = iscsi_block_scsi_eh(cmd); 5627 if (ret) 5628 return ret; 5629 ret = FAILED; 5630 5631 ql4_printk(KERN_INFO, ha, 5632 "scsi%ld:%d:%d:%d: DEVICE RESET ISSUED.\n", ha->host_no, 5633 cmd->device->channel, cmd->device->id, cmd->device->lun); 5634 5635 DEBUG2(printk(KERN_INFO 5636 "scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x," 5637 "dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no, 5638 cmd, jiffies, cmd->request->timeout / HZ, 5639 ha->dpc_flags, cmd->result, cmd->allowed)); 5640 5641 /* FIXME: wait for hba to go online */ 5642 stat = qla4xxx_reset_lun(ha, ddb_entry, cmd->device->lun); 5643 if (stat != QLA_SUCCESS) { 5644 ql4_printk(KERN_INFO, ha, "DEVICE RESET FAILED. %d\n", stat); 5645 goto eh_dev_reset_done; 5646 } 5647 5648 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 5649 cmd->device)) { 5650 ql4_printk(KERN_INFO, ha, 5651 "DEVICE RESET FAILED - waiting for " 5652 "commands.\n"); 5653 goto eh_dev_reset_done; 5654 } 5655 5656 /* Send marker. */ 5657 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 5658 MM_LUN_RESET) != QLA_SUCCESS) 5659 goto eh_dev_reset_done; 5660 5661 ql4_printk(KERN_INFO, ha, 5662 "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n", 5663 ha->host_no, cmd->device->channel, cmd->device->id, 5664 cmd->device->lun); 5665 5666 ret = SUCCESS; 5667 5668 eh_dev_reset_done: 5669 5670 return ret; 5671 } 5672 5673 /** 5674 * qla4xxx_eh_target_reset - callback for target reset. 5675 * @cmd: Pointer to Linux's SCSI command structure 5676 * 5677 * This routine is called by the Linux OS to reset the target. 5678 **/ 5679 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd) 5680 { 5681 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 5682 struct ddb_entry *ddb_entry = cmd->device->hostdata; 5683 int stat, ret; 5684 5685 if (!ddb_entry) 5686 return FAILED; 5687 5688 ret = iscsi_block_scsi_eh(cmd); 5689 if (ret) 5690 return ret; 5691 5692 starget_printk(KERN_INFO, scsi_target(cmd->device), 5693 "WARM TARGET RESET ISSUED.\n"); 5694 5695 DEBUG2(printk(KERN_INFO 5696 "scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, " 5697 "to=%x,dpc_flags=%lx, status=%x allowed=%d\n", 5698 ha->host_no, cmd, jiffies, cmd->request->timeout / HZ, 5699 ha->dpc_flags, cmd->result, cmd->allowed)); 5700 5701 stat = qla4xxx_reset_target(ha, ddb_entry); 5702 if (stat != QLA_SUCCESS) { 5703 starget_printk(KERN_INFO, scsi_target(cmd->device), 5704 "WARM TARGET RESET FAILED.\n"); 5705 return FAILED; 5706 } 5707 5708 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 5709 NULL)) { 5710 starget_printk(KERN_INFO, scsi_target(cmd->device), 5711 "WARM TARGET DEVICE RESET FAILED - " 5712 "waiting for commands.\n"); 5713 return FAILED; 5714 } 5715 5716 /* Send marker. */ 5717 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 5718 MM_TGT_WARM_RESET) != QLA_SUCCESS) { 5719 starget_printk(KERN_INFO, scsi_target(cmd->device), 5720 "WARM TARGET DEVICE RESET FAILED - " 5721 "marker iocb failed.\n"); 5722 return FAILED; 5723 } 5724 5725 starget_printk(KERN_INFO, scsi_target(cmd->device), 5726 "WARM TARGET RESET SUCCEEDED.\n"); 5727 return SUCCESS; 5728 } 5729 5730 /** 5731 * qla4xxx_is_eh_active - check if error handler is running 5732 * @shost: Pointer to SCSI Host struct 5733 * 5734 * This routine finds that if reset host is called in EH 5735 * scenario or from some application like sg_reset 5736 **/ 5737 static int qla4xxx_is_eh_active(struct Scsi_Host *shost) 5738 { 5739 if (shost->shost_state == SHOST_RECOVERY) 5740 return 1; 5741 return 0; 5742 } 5743 5744 /** 5745 * qla4xxx_eh_host_reset - kernel callback 5746 * @cmd: Pointer to Linux's SCSI command structure 5747 * 5748 * This routine is invoked by the Linux kernel to perform fatal error 5749 * recovery on the specified adapter. 5750 **/ 5751 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd) 5752 { 5753 int return_status = FAILED; 5754 struct scsi_qla_host *ha; 5755 5756 ha = to_qla_host(cmd->device->host); 5757 5758 if (ql4xdontresethba) { 5759 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 5760 ha->host_no, __func__)); 5761 5762 /* Clear outstanding srb in queues */ 5763 if (qla4xxx_is_eh_active(cmd->device->host)) 5764 qla4xxx_abort_active_cmds(ha, DID_ABORT << 16); 5765 5766 return FAILED; 5767 } 5768 5769 ql4_printk(KERN_INFO, ha, 5770 "scsi(%ld:%d:%d:%d): HOST RESET ISSUED.\n", ha->host_no, 5771 cmd->device->channel, cmd->device->id, cmd->device->lun); 5772 5773 if (qla4xxx_wait_for_hba_online(ha) != QLA_SUCCESS) { 5774 DEBUG2(printk("scsi%ld:%d: %s: Unable to reset host. Adapter " 5775 "DEAD.\n", ha->host_no, cmd->device->channel, 5776 __func__)); 5777 5778 return FAILED; 5779 } 5780 5781 if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 5782 if (is_qla8022(ha)) 5783 set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 5784 else 5785 set_bit(DPC_RESET_HA, &ha->dpc_flags); 5786 } 5787 5788 if (qla4xxx_recover_adapter(ha) == QLA_SUCCESS) 5789 return_status = SUCCESS; 5790 5791 ql4_printk(KERN_INFO, ha, "HOST RESET %s.\n", 5792 return_status == FAILED ? "FAILED" : "SUCCEEDED"); 5793 5794 return return_status; 5795 } 5796 5797 static int qla4xxx_context_reset(struct scsi_qla_host *ha) 5798 { 5799 uint32_t mbox_cmd[MBOX_REG_COUNT]; 5800 uint32_t mbox_sts[MBOX_REG_COUNT]; 5801 struct addr_ctrl_blk_def *acb = NULL; 5802 uint32_t acb_len = sizeof(struct addr_ctrl_blk_def); 5803 int rval = QLA_SUCCESS; 5804 dma_addr_t acb_dma; 5805 5806 acb = dma_alloc_coherent(&ha->pdev->dev, 5807 sizeof(struct addr_ctrl_blk_def), 5808 &acb_dma, GFP_KERNEL); 5809 if (!acb) { 5810 ql4_printk(KERN_ERR, ha, "%s: Unable to alloc acb\n", 5811 __func__); 5812 rval = -ENOMEM; 5813 goto exit_port_reset; 5814 } 5815 5816 memset(acb, 0, acb_len); 5817 5818 rval = qla4xxx_get_acb(ha, acb_dma, PRIMARI_ACB, acb_len); 5819 if (rval != QLA_SUCCESS) { 5820 rval = -EIO; 5821 goto exit_free_acb; 5822 } 5823 5824 rval = qla4xxx_disable_acb(ha); 5825 if (rval != QLA_SUCCESS) { 5826 rval = -EIO; 5827 goto exit_free_acb; 5828 } 5829 5830 wait_for_completion_timeout(&ha->disable_acb_comp, 5831 DISABLE_ACB_TOV * HZ); 5832 5833 rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], acb_dma); 5834 if (rval != QLA_SUCCESS) { 5835 rval = -EIO; 5836 goto exit_free_acb; 5837 } 5838 5839 exit_free_acb: 5840 dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk_def), 5841 acb, acb_dma); 5842 exit_port_reset: 5843 DEBUG2(ql4_printk(KERN_INFO, ha, "%s %s\n", __func__, 5844 rval == QLA_SUCCESS ? "SUCCEEDED" : "FAILED")); 5845 return rval; 5846 } 5847 5848 static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type) 5849 { 5850 struct scsi_qla_host *ha = to_qla_host(shost); 5851 int rval = QLA_SUCCESS; 5852 5853 if (ql4xdontresethba) { 5854 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Don't Reset HBA\n", 5855 __func__)); 5856 rval = -EPERM; 5857 goto exit_host_reset; 5858 } 5859 5860 rval = qla4xxx_wait_for_hba_online(ha); 5861 if (rval != QLA_SUCCESS) { 5862 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Unable to reset host " 5863 "adapter\n", __func__)); 5864 rval = -EIO; 5865 goto exit_host_reset; 5866 } 5867 5868 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) 5869 goto recover_adapter; 5870 5871 switch (reset_type) { 5872 case SCSI_ADAPTER_RESET: 5873 set_bit(DPC_RESET_HA, &ha->dpc_flags); 5874 break; 5875 case SCSI_FIRMWARE_RESET: 5876 if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 5877 if (is_qla8022(ha)) 5878 /* set firmware context reset */ 5879 set_bit(DPC_RESET_HA_FW_CONTEXT, 5880 &ha->dpc_flags); 5881 else { 5882 rval = qla4xxx_context_reset(ha); 5883 goto exit_host_reset; 5884 } 5885 } 5886 break; 5887 } 5888 5889 recover_adapter: 5890 rval = qla4xxx_recover_adapter(ha); 5891 if (rval != QLA_SUCCESS) { 5892 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: recover adapter fail\n", 5893 __func__)); 5894 rval = -EIO; 5895 } 5896 5897 exit_host_reset: 5898 return rval; 5899 } 5900 5901 /* PCI AER driver recovers from all correctable errors w/o 5902 * driver intervention. For uncorrectable errors PCI AER 5903 * driver calls the following device driver's callbacks 5904 * 5905 * - Fatal Errors - link_reset 5906 * - Non-Fatal Errors - driver's pci_error_detected() which 5907 * returns CAN_RECOVER, NEED_RESET or DISCONNECT. 5908 * 5909 * PCI AER driver calls 5910 * CAN_RECOVER - driver's pci_mmio_enabled(), mmio_enabled 5911 * returns RECOVERED or NEED_RESET if fw_hung 5912 * NEED_RESET - driver's slot_reset() 5913 * DISCONNECT - device is dead & cannot recover 5914 * RECOVERED - driver's pci_resume() 5915 */ 5916 static pci_ers_result_t 5917 qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 5918 { 5919 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 5920 5921 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n", 5922 ha->host_no, __func__, state); 5923 5924 if (!is_aer_supported(ha)) 5925 return PCI_ERS_RESULT_NONE; 5926 5927 switch (state) { 5928 case pci_channel_io_normal: 5929 clear_bit(AF_EEH_BUSY, &ha->flags); 5930 return PCI_ERS_RESULT_CAN_RECOVER; 5931 case pci_channel_io_frozen: 5932 set_bit(AF_EEH_BUSY, &ha->flags); 5933 qla4xxx_mailbox_premature_completion(ha); 5934 qla4xxx_free_irqs(ha); 5935 pci_disable_device(pdev); 5936 /* Return back all IOs */ 5937 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 5938 return PCI_ERS_RESULT_NEED_RESET; 5939 case pci_channel_io_perm_failure: 5940 set_bit(AF_EEH_BUSY, &ha->flags); 5941 set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags); 5942 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 5943 return PCI_ERS_RESULT_DISCONNECT; 5944 } 5945 return PCI_ERS_RESULT_NEED_RESET; 5946 } 5947 5948 /** 5949 * qla4xxx_pci_mmio_enabled() gets called if 5950 * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER 5951 * and read/write to the device still works. 5952 **/ 5953 static pci_ers_result_t 5954 qla4xxx_pci_mmio_enabled(struct pci_dev *pdev) 5955 { 5956 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 5957 5958 if (!is_aer_supported(ha)) 5959 return PCI_ERS_RESULT_NONE; 5960 5961 return PCI_ERS_RESULT_RECOVERED; 5962 } 5963 5964 static uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha) 5965 { 5966 uint32_t rval = QLA_ERROR; 5967 uint32_t ret = 0; 5968 int fn; 5969 struct pci_dev *other_pdev = NULL; 5970 5971 ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__); 5972 5973 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 5974 5975 if (test_bit(AF_ONLINE, &ha->flags)) { 5976 clear_bit(AF_ONLINE, &ha->flags); 5977 clear_bit(AF_LINK_UP, &ha->flags); 5978 iscsi_host_for_each_session(ha->host, qla4xxx_fail_session); 5979 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 5980 } 5981 5982 fn = PCI_FUNC(ha->pdev->devfn); 5983 while (fn > 0) { 5984 fn--; 5985 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at " 5986 "func %x\n", ha->host_no, __func__, fn); 5987 /* Get the pci device given the domain, bus, 5988 * slot/function number */ 5989 other_pdev = 5990 pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus), 5991 ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn), 5992 fn)); 5993 5994 if (!other_pdev) 5995 continue; 5996 5997 if (atomic_read(&other_pdev->enable_cnt)) { 5998 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI " 5999 "func in enabled state%x\n", ha->host_no, 6000 __func__, fn); 6001 pci_dev_put(other_pdev); 6002 break; 6003 } 6004 pci_dev_put(other_pdev); 6005 } 6006 6007 /* The first function on the card, the reset owner will 6008 * start & initialize the firmware. The other functions 6009 * on the card will reset the firmware context 6010 */ 6011 if (!fn) { 6012 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset " 6013 "0x%x is the owner\n", ha->host_no, __func__, 6014 ha->pdev->devfn); 6015 6016 qla4_8xxx_idc_lock(ha); 6017 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 6018 QLA82XX_DEV_COLD); 6019 6020 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION, 6021 QLA82XX_IDC_VERSION); 6022 6023 qla4_8xxx_idc_unlock(ha); 6024 clear_bit(AF_FW_RECOVERY, &ha->flags); 6025 rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER); 6026 qla4_8xxx_idc_lock(ha); 6027 6028 if (rval != QLA_SUCCESS) { 6029 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 6030 "FAILED\n", ha->host_no, __func__); 6031 qla4_8xxx_clear_drv_active(ha); 6032 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 6033 QLA82XX_DEV_FAILED); 6034 } else { 6035 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 6036 "READY\n", ha->host_no, __func__); 6037 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 6038 QLA82XX_DEV_READY); 6039 /* Clear driver state register */ 6040 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0); 6041 qla4_8xxx_set_drv_active(ha); 6042 ret = qla4xxx_request_irqs(ha); 6043 if (ret) { 6044 ql4_printk(KERN_WARNING, ha, "Failed to " 6045 "reserve interrupt %d already in use.\n", 6046 ha->pdev->irq); 6047 rval = QLA_ERROR; 6048 } else { 6049 ha->isp_ops->enable_intrs(ha); 6050 rval = QLA_SUCCESS; 6051 } 6052 } 6053 qla4_8xxx_idc_unlock(ha); 6054 } else { 6055 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not " 6056 "the reset owner\n", ha->host_no, __func__, 6057 ha->pdev->devfn); 6058 if ((qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE) == 6059 QLA82XX_DEV_READY)) { 6060 clear_bit(AF_FW_RECOVERY, &ha->flags); 6061 rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER); 6062 if (rval == QLA_SUCCESS) { 6063 ret = qla4xxx_request_irqs(ha); 6064 if (ret) { 6065 ql4_printk(KERN_WARNING, ha, "Failed to" 6066 " reserve interrupt %d already in" 6067 " use.\n", ha->pdev->irq); 6068 rval = QLA_ERROR; 6069 } else { 6070 ha->isp_ops->enable_intrs(ha); 6071 rval = QLA_SUCCESS; 6072 } 6073 } 6074 qla4_8xxx_idc_lock(ha); 6075 qla4_8xxx_set_drv_active(ha); 6076 qla4_8xxx_idc_unlock(ha); 6077 } 6078 } 6079 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 6080 return rval; 6081 } 6082 6083 static pci_ers_result_t 6084 qla4xxx_pci_slot_reset(struct pci_dev *pdev) 6085 { 6086 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; 6087 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 6088 int rc; 6089 6090 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n", 6091 ha->host_no, __func__); 6092 6093 if (!is_aer_supported(ha)) 6094 return PCI_ERS_RESULT_NONE; 6095 6096 /* Restore the saved state of PCIe device - 6097 * BAR registers, PCI Config space, PCIX, MSI, 6098 * IOV states 6099 */ 6100 pci_restore_state(pdev); 6101 6102 /* pci_restore_state() clears the saved_state flag of the device 6103 * save restored state which resets saved_state flag 6104 */ 6105 pci_save_state(pdev); 6106 6107 /* Initialize device or resume if in suspended state */ 6108 rc = pci_enable_device(pdev); 6109 if (rc) { 6110 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Can't re-enable " 6111 "device after reset\n", ha->host_no, __func__); 6112 goto exit_slot_reset; 6113 } 6114 6115 ha->isp_ops->disable_intrs(ha); 6116 6117 if (is_qla8022(ha)) { 6118 if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) { 6119 ret = PCI_ERS_RESULT_RECOVERED; 6120 goto exit_slot_reset; 6121 } else 6122 goto exit_slot_reset; 6123 } 6124 6125 exit_slot_reset: 6126 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n" 6127 "device after reset\n", ha->host_no, __func__, ret); 6128 return ret; 6129 } 6130 6131 static void 6132 qla4xxx_pci_resume(struct pci_dev *pdev) 6133 { 6134 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 6135 int ret; 6136 6137 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n", 6138 ha->host_no, __func__); 6139 6140 ret = qla4xxx_wait_for_hba_online(ha); 6141 if (ret != QLA_SUCCESS) { 6142 ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to " 6143 "resume I/O from slot/link_reset\n", ha->host_no, 6144 __func__); 6145 } 6146 6147 pci_cleanup_aer_uncorrect_error_status(pdev); 6148 clear_bit(AF_EEH_BUSY, &ha->flags); 6149 } 6150 6151 static const struct pci_error_handlers qla4xxx_err_handler = { 6152 .error_detected = qla4xxx_pci_error_detected, 6153 .mmio_enabled = qla4xxx_pci_mmio_enabled, 6154 .slot_reset = qla4xxx_pci_slot_reset, 6155 .resume = qla4xxx_pci_resume, 6156 }; 6157 6158 static struct pci_device_id qla4xxx_pci_tbl[] = { 6159 { 6160 .vendor = PCI_VENDOR_ID_QLOGIC, 6161 .device = PCI_DEVICE_ID_QLOGIC_ISP4010, 6162 .subvendor = PCI_ANY_ID, 6163 .subdevice = PCI_ANY_ID, 6164 }, 6165 { 6166 .vendor = PCI_VENDOR_ID_QLOGIC, 6167 .device = PCI_DEVICE_ID_QLOGIC_ISP4022, 6168 .subvendor = PCI_ANY_ID, 6169 .subdevice = PCI_ANY_ID, 6170 }, 6171 { 6172 .vendor = PCI_VENDOR_ID_QLOGIC, 6173 .device = PCI_DEVICE_ID_QLOGIC_ISP4032, 6174 .subvendor = PCI_ANY_ID, 6175 .subdevice = PCI_ANY_ID, 6176 }, 6177 { 6178 .vendor = PCI_VENDOR_ID_QLOGIC, 6179 .device = PCI_DEVICE_ID_QLOGIC_ISP8022, 6180 .subvendor = PCI_ANY_ID, 6181 .subdevice = PCI_ANY_ID, 6182 }, 6183 {0, 0}, 6184 }; 6185 MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl); 6186 6187 static struct pci_driver qla4xxx_pci_driver = { 6188 .name = DRIVER_NAME, 6189 .id_table = qla4xxx_pci_tbl, 6190 .probe = qla4xxx_probe_adapter, 6191 .remove = qla4xxx_remove_adapter, 6192 .err_handler = &qla4xxx_err_handler, 6193 }; 6194 6195 static int __init qla4xxx_module_init(void) 6196 { 6197 int ret; 6198 6199 /* Allocate cache for SRBs. */ 6200 srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0, 6201 SLAB_HWCACHE_ALIGN, NULL); 6202 if (srb_cachep == NULL) { 6203 printk(KERN_ERR 6204 "%s: Unable to allocate SRB cache..." 6205 "Failing load!\n", DRIVER_NAME); 6206 ret = -ENOMEM; 6207 goto no_srp_cache; 6208 } 6209 6210 /* Derive version string. */ 6211 strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION); 6212 if (ql4xextended_error_logging) 6213 strcat(qla4xxx_version_str, "-debug"); 6214 6215 qla4xxx_scsi_transport = 6216 iscsi_register_transport(&qla4xxx_iscsi_transport); 6217 if (!qla4xxx_scsi_transport){ 6218 ret = -ENODEV; 6219 goto release_srb_cache; 6220 } 6221 6222 ret = pci_register_driver(&qla4xxx_pci_driver); 6223 if (ret) 6224 goto unregister_transport; 6225 6226 printk(KERN_INFO "QLogic iSCSI HBA Driver\n"); 6227 return 0; 6228 6229 unregister_transport: 6230 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 6231 release_srb_cache: 6232 kmem_cache_destroy(srb_cachep); 6233 no_srp_cache: 6234 return ret; 6235 } 6236 6237 static void __exit qla4xxx_module_exit(void) 6238 { 6239 pci_unregister_driver(&qla4xxx_pci_driver); 6240 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 6241 kmem_cache_destroy(srb_cachep); 6242 } 6243 6244 module_init(qla4xxx_module_init); 6245 module_exit(qla4xxx_module_exit); 6246 6247 MODULE_AUTHOR("QLogic Corporation"); 6248 MODULE_DESCRIPTION("QLogic iSCSI HBA Driver"); 6249 MODULE_LICENSE("GPL"); 6250 MODULE_VERSION(QLA4XXX_DRIVER_VERSION); 6251