Lines Matching defs:vhost
161 struct ibmvfc_host *vhost = evt->vhost;
166 entry = &vhost->trace[vhost->trace_index++];
195 struct ibmvfc_host *vhost = evt->vhost;
198 struct ibmvfc_trace_entry *entry = &vhost->trace[vhost->trace_index++];
450 * @vhost: ibmvfc host struct
456 static int ibmvfc_set_host_state(struct ibmvfc_host *vhost,
461 switch (vhost->state) {
466 vhost->state = state;
475 * @vhost: ibmvfc host struct
479 static void ibmvfc_set_host_action(struct ibmvfc_host *vhost,
484 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT)
485 vhost->action = action;
488 if (vhost->action == IBMVFC_HOST_ACTION_LOGO)
489 vhost->action = action;
492 if (vhost->action == IBMVFC_HOST_ACTION_INIT)
493 vhost->action = action;
496 switch (vhost->action) {
500 vhost->action = action;
507 if (vhost->action == IBMVFC_HOST_ACTION_ALLOC_TGTS)
508 vhost->action = action;
512 switch (vhost->action) {
517 vhost->action = action;
528 vhost->action = action;
535 * @vhost: ibmvfc host struct
540 static void ibmvfc_reinit_host(struct ibmvfc_host *vhost)
542 if (vhost->action == IBMVFC_HOST_ACTION_NONE) {
543 if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
544 scsi_block_requests(vhost->host);
545 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
548 vhost->reinit = 1;
550 wake_up(&vhost->work_wait_q);
555 * @vhost: ibmvfc host struct
559 static void ibmvfc_link_down(struct ibmvfc_host *vhost,
565 scsi_block_requests(vhost->host);
566 list_for_each_entry(tgt, &vhost->targets, queue)
568 ibmvfc_set_host_state(vhost, state);
569 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
570 vhost->events_to_log |= IBMVFC_AE_LINKDOWN;
571 wake_up(&vhost->work_wait_q);
577 * @vhost: ibmvfc host struct
582 static void ibmvfc_init_host(struct ibmvfc_host *vhost)
586 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
587 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
588 dev_err(vhost->dev,
590 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
595 if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
596 memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
597 vhost->async_crq.cur = 0;
599 list_for_each_entry(tgt, &vhost->targets, queue)
601 scsi_block_requests(vhost->host);
602 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
603 vhost->job_step = ibmvfc_npiv_login;
604 wake_up(&vhost->work_wait_q);
610 * @vhost: ibmvfc host struct
617 static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)
619 struct vio_dev *vdev = to_vio_dev(vhost->dev);
625 * @vhost: ibmvfc host struct
630 static int ibmvfc_send_crq_init(struct ibmvfc_host *vhost)
632 ibmvfc_dbg(vhost, "Sending CRQ init\n");
633 return ibmvfc_send_crq(vhost, 0xC001000000000000LL, 0);
638 * @vhost: ibmvfc host struct
643 static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)
645 ibmvfc_dbg(vhost, "Sending CRQ init complete\n");
646 return ibmvfc_send_crq(vhost, 0xC002000000000000LL, 0);
651 * @vhost: ibmvfc host struct
656 static void ibmvfc_release_crq_queue(struct ibmvfc_host *vhost)
659 struct vio_dev *vdev = to_vio_dev(vhost->dev);
660 struct ibmvfc_crq_queue *crq = &vhost->crq;
662 ibmvfc_dbg(vhost, "Releasing CRQ\n");
663 free_irq(vdev->irq, vhost);
664 tasklet_kill(&vhost->tasklet);
671 vhost->state = IBMVFC_NO_CRQ;
672 vhost->logged_in = 0;
673 dma_unmap_single(vhost->dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
679 * @vhost: ibmvfc host struct
684 static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
687 struct vio_dev *vdev = to_vio_dev(vhost->dev);
697 dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
704 * @vhost: ibmvfc host struct
709 static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
713 struct vio_dev *vdev = to_vio_dev(vhost->dev);
714 struct ibmvfc_crq_queue *crq = &vhost->crq;
723 spin_lock_irqsave(vhost->host->host_lock, flags);
724 vhost->state = IBMVFC_NO_CRQ;
725 vhost->logged_in = 0;
726 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
738 dev_warn(vhost->dev, "Partner adapter not ready\n");
740 dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
741 spin_unlock_irqrestore(vhost->host->host_lock, flags);
772 struct ibmvfc_host *vhost = evt->vhost;
773 struct ibmvfc_event_pool *pool = &vhost->pool;
777 list_add_tail(&evt->queue, &vhost->free);
826 * @vhost: ibmvfc host struct
832 static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)
836 ibmvfc_dbg(vhost, "Purging all requests\n");
837 list_for_each_entry_safe(evt, pos, &vhost->sent, queue)
843 * @vhost: struct ibmvfc host to reset
845 static void ibmvfc_hard_reset_host(struct ibmvfc_host *vhost)
847 ibmvfc_purge_requests(vhost, DID_ERROR);
848 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
849 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
854 * @vhost: struct ibmvfc host to reset
856 static void __ibmvfc_reset_host(struct ibmvfc_host *vhost)
858 if (vhost->logged_in && vhost->action != IBMVFC_HOST_ACTION_LOGO_WAIT &&
859 !ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
860 scsi_block_requests(vhost->host);
861 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO);
862 vhost->job_step = ibmvfc_npiv_logout;
863 wake_up(&vhost->work_wait_q);
865 ibmvfc_hard_reset_host(vhost);
870 * @vhost: ibmvfc host struct
872 static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
876 spin_lock_irqsave(vhost->host->host_lock, flags);
877 __ibmvfc_reset_host(vhost);
878 spin_unlock_irqrestore(vhost->host->host_lock, flags);
883 * @vhost: ibmvfc host struct
888 static int ibmvfc_retry_host_init(struct ibmvfc_host *vhost)
892 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
893 vhost->delay_init = 1;
894 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
895 dev_err(vhost->dev,
897 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
898 } else if (vhost->init_retries == IBMVFC_MAX_HOST_INIT_RETRIES)
899 __ibmvfc_reset_host(vhost);
901 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
906 wake_up(&vhost->work_wait_q);
920 struct ibmvfc_host *vhost = shost_priv(shost);
923 list_for_each_entry(tgt, &vhost->targets, queue)
959 struct ibmvfc_host *vhost = shost_priv(shost);
963 if (vhost->state == IBMVFC_ACTIVE) {
964 switch (vhost->login_buf->resp.link_speed / 100) {
984 ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
985 vhost->login_buf->resp.link_speed / 100);
1003 struct ibmvfc_host *vhost = shost_priv(shost);
1007 switch (vhost->state) {
1026 ibmvfc_log(vhost, 3, "Unknown port state: %d\n", vhost->state);
1107 * @vhost: ibmvfc host struct
1112 static int ibmvfc_wait_while_resetting(struct ibmvfc_host *vhost)
1114 long timeout = wait_event_timeout(vhost->init_wait_q,
1115 ((vhost->state == IBMVFC_ACTIVE ||
1116 vhost->state == IBMVFC_HOST_OFFLINE ||
1117 vhost->state == IBMVFC_LINK_DEAD) &&
1118 vhost->action == IBMVFC_HOST_ACTION_NONE),
1133 struct ibmvfc_host *vhost = shost_priv(shost);
1135 dev_err(vhost->dev, "Initiating host LIP. Resetting connection\n");
1136 ibmvfc_reset_host(vhost);
1137 return ibmvfc_wait_while_resetting(vhost);
1146 static void ibmvfc_gather_partition_info(struct ibmvfc_host *vhost)
1158 strncpy(vhost->partition_name, name, sizeof(vhost->partition_name));
1161 vhost->partition_number = *num;
1167 * @vhost: ibmvfc host struct
1172 static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
1174 struct ibmvfc_npiv_login *login_info = &vhost->login_info;
1175 struct device_node *of_node = vhost->dev->of_node;
1184 login_info->partition_num = vhost->partition_number;
1188 if (vhost->client_migrated)
1193 login_info->async.va = vhost->async_crq.msg_token;
1194 login_info->async.len = vhost->async_crq.size * sizeof(*vhost->async_crq.msgs);
1195 strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
1197 dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
1200 location = location ? location : dev_name(vhost->dev);
1206 * @vhost: ibmvfc host who owns the event pool
1210 static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
1213 struct ibmvfc_event_pool *pool = &vhost->pool;
1221 pool->iu_storage = dma_alloc_coherent(vhost->dev,
1236 evt->vhost = vhost;
1238 list_add_tail(&evt->queue, &vhost->free);
1247 * @vhost: ibmvfc host who owns the event pool
1250 static void ibmvfc_free_event_pool(struct ibmvfc_host *vhost)
1253 struct ibmvfc_event_pool *pool = &vhost->pool;
1260 dma_pool_free(vhost->sg_pool,
1266 dma_free_coherent(vhost->dev,
1274 * @vhost: ibmvfc host struct
1278 static struct ibmvfc_event *ibmvfc_get_event(struct ibmvfc_host *vhost)
1282 BUG_ON(list_empty(&vhost->free));
1283 evt = list_entry(vhost->free.next, struct ibmvfc_event, queue);
1342 struct ibmvfc_host *vhost = dev_get_drvdata(dev);
1349 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1370 evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
1375 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1397 struct ibmvfc_host *vhost = evt->vhost;
1398 dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt);
1399 ibmvfc_reset_host(vhost);
1405 * @vhost: ibmvfc host struct
1411 struct ibmvfc_host *vhost, unsigned long timeout)
1425 list_add_tail(&evt->queue, &vhost->sent);
1437 if ((rc = ibmvfc_send_crq(vhost, crq_as_u64[0], crq_as_u64[1]))) {
1448 dev_warn(vhost->dev, "Send warning. Receive queue closed, will retry.\n");
1455 dev_err(vhost->dev, "Send error (rc=%d)\n", rc);
1477 struct ibmvfc_host *vhost = evt->vhost;
1490 if (!logerr && (vhost->log_level <= (IBMVFC_DEFAULT_LOG_LEVEL + 1)))
1509 struct ibmvfc_host *vhost = shost_priv(sdev->host);
1513 list_for_each_entry(tgt, &vhost->targets, queue) {
1520 ibmvfc_reinit_host(vhost);
1579 * @vhost: struct ibmvfc host
1584 static inline int ibmvfc_host_chkready(struct ibmvfc_host *vhost)
1588 switch (vhost->state) {
1618 struct ibmvfc_host *vhost = shost_priv(cmnd->device->host);
1626 unlikely((rc = ibmvfc_host_chkready(vhost)))) {
1633 evt = ibmvfc_get_event(vhost);
1665 if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
1666 return ibmvfc_send_event(evt, vhost, 0);
1672 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1702 struct ibmvfc_host *vhost = evt->vhost;
1705 vhost->aborting_passthru = 0;
1706 dev_info(vhost->dev, "Passthru command cancelled\n");
1718 struct ibmvfc_host *vhost = shost_priv(job->shost);
1726 spin_lock_irqsave(vhost->host->host_lock, flags);
1727 if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
1728 __ibmvfc_reset_host(vhost);
1729 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1733 vhost->aborting_passthru = 1;
1734 evt = ibmvfc_get_event(vhost);
1745 rc = ibmvfc_send_event(evt, vhost, default_timeout);
1748 vhost->aborting_passthru = 0;
1749 dev_err(vhost->dev, "Failed to send cancel event. rc=%d\n", rc);
1752 dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
1755 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1763 * @vhost: struct ibmvfc_host to send command
1769 static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
1779 spin_lock_irqsave(vhost->host->host_lock, flags);
1780 list_for_each_entry(tgt, &vhost->targets, queue) {
1789 if (unlikely((rc = ibmvfc_host_chkready(vhost))))
1792 evt = ibmvfc_get_event(vhost);
1803 rc = ibmvfc_send_event(evt, vhost, default_timeout);
1804 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1814 spin_lock_irqsave(vhost->host->host_lock, flags);
1817 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1831 struct ibmvfc_host *vhost = shost_priv(job->shost);
1868 if (!mutex_trylock(&vhost->passthru_mutex))
1872 req_seg = dma_map_sg(vhost->dev, job->request_payload.sg_list,
1876 mutex_unlock(&vhost->passthru_mutex);
1880 rsp_seg = dma_map_sg(vhost->dev, job->reply_payload.sg_list,
1884 dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
1886 mutex_unlock(&vhost->passthru_mutex);
1896 rc = ibmvfc_bsg_plogi(vhost, port_id);
1898 spin_lock_irqsave(vhost->host->host_lock, flags);
1901 unlikely((rc = ibmvfc_host_chkready(vhost)))) {
1902 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1906 evt = ibmvfc_get_event(vhost);
1934 rc = ibmvfc_send_event(evt, vhost, 0);
1935 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1949 spin_lock_irqsave(vhost->host->host_lock, flags);
1951 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1956 dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
1958 dma_unmap_sg(vhost->dev, job->reply_payload.sg_list,
1960 mutex_unlock(&vhost->passthru_mutex);
1976 struct ibmvfc_host *vhost = shost_priv(sdev->host);
1986 spin_lock_irqsave(vhost->host->host_lock, flags);
1987 if (vhost->state == IBMVFC_ACTIVE) {
1988 evt = ibmvfc_get_event(vhost);
2006 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2008 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2035 spin_lock_irqsave(vhost->host->host_lock, flags);
2037 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2093 * @vhost: ibmvfc host struct
2100 static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
2112 spin_lock_irqsave(vhost->host->host_lock, flags);
2113 list_for_each_entry(evt, &vhost->sent, queue) {
2119 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2126 spin_lock_irqsave(vhost->host->host_lock, flags);
2127 list_for_each_entry(evt, &vhost->sent, queue) {
2133 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2135 dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
2159 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2170 spin_lock_irqsave(vhost->host->host_lock, flags);
2172 list_for_each_entry(evt, &vhost->sent, queue) {
2180 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
2182 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2186 if (vhost->state == IBMVFC_ACTIVE) {
2187 evt = ibmvfc_get_event(vhost);
2203 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2206 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2217 spin_lock_irqsave(vhost->host->host_lock, flags);
2219 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2260 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2270 spin_lock_irqsave(vhost->host->host_lock, flags);
2272 list_for_each_entry(evt, &vhost->sent, queue) {
2280 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
2282 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2286 if (vhost->state == IBMVFC_ACTIVE) {
2287 evt = ibmvfc_get_event(vhost);
2305 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2308 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2321 rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
2328 ibmvfc_reset_host(vhost);
2351 spin_lock_irqsave(vhost->host->host_lock, flags);
2353 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2367 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2373 ibmvfc_wait_while_resetting(vhost);
2378 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
2394 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2400 ibmvfc_wait_while_resetting(vhost);
2405 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
2433 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2441 ibmvfc_wait_while_resetting(vhost);
2446 rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
2460 struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
2463 dev_err(vhost->dev, "Resetting connection due to error recovery\n");
2464 rc = ibmvfc_issue_fc_host_lip(vhost->host);
2478 struct ibmvfc_host *vhost = shost_priv(shost);
2492 rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
2539 * @vhost: ibmvfc host struct
2543 struct ibmvfc_host *vhost)
2548 ibmvfc_log(vhost, 3, "%s event received. scsi_id: %llx, wwpn: %llx,"
2555 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2558 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2563 vhost->events_to_log |= IBMVFC_AE_LINKUP;
2564 vhost->delay_init = 1;
2565 __ibmvfc_reset_host(vhost);
2571 vhost->events_to_log |= IBMVFC_AE_LINKUP;
2572 vhost->delay_init = 1;
2573 __ibmvfc_reset_host(vhost);
2577 vhost->events_to_log |= IBMVFC_AE_RSCN;
2578 vhost->delay_init = 1;
2579 __ibmvfc_reset_host(vhost);
2583 vhost->events_to_log |= IBMVFC_AE_RSCN;
2584 ibmvfc_reinit_host(vhost);
2589 list_for_each_entry(tgt, &vhost->targets, queue) {
2602 ibmvfc_reinit_host(vhost);
2608 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2611 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2614 ibmvfc_link_down(vhost, IBMVFC_HALTED);
2617 dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
2625 * @vhost: ibmvfc host struct
2628 static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
2637 dev_info(vhost->dev, "Partner initialized\n");
2639 rc = ibmvfc_send_crq_init_complete(vhost);
2641 ibmvfc_init_host(vhost);
2643 dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
2646 dev_info(vhost->dev, "Partner initialization complete\n");
2647 ibmvfc_init_host(vhost);
2650 dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
2654 vhost->state = IBMVFC_NO_CRQ;
2655 vhost->logged_in = 0;
2656 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
2659 dev_info(vhost->dev, "Re-enabling adapter\n");
2660 vhost->client_migrated = 1;
2661 ibmvfc_purge_requests(vhost, DID_REQUEUE);
2662 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2663 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_REENABLE);
2665 dev_err(vhost->dev, "Virtual adapter failed (rc=%d)\n", crq->format);
2666 ibmvfc_purge_requests(vhost, DID_ERROR);
2667 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2668 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
2674 dev_err(vhost->dev, "Got an invalid message type 0x%02x\n", crq->valid);
2685 if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
2686 dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
2692 dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
2714 struct ibmvfc_host *vhost = shost_priv(shost);
2719 dev_info(vhost->dev, "Scan taking longer than %d seconds, "
2724 if (vhost->scan_complete)
2744 struct ibmvfc_host *vhost = shost_priv(shost);
2751 sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
2769 struct ibmvfc_host *vhost = shost_priv(shost);
2773 starget->hostdata = (void *)(unsigned long)vhost->task_set++;
2858 struct ibmvfc_host *vhost = shost_priv(shost);
2861 vhost->login_buf->resp.partition_name);
2868 struct ibmvfc_host *vhost = shost_priv(shost);
2871 vhost->login_buf->resp.device_name);
2878 struct ibmvfc_host *vhost = shost_priv(shost);
2881 vhost->login_buf->resp.port_loc_code);
2888 struct ibmvfc_host *vhost = shost_priv(shost);
2891 vhost->login_buf->resp.drc_name);
2898 struct ibmvfc_host *vhost = shost_priv(shost);
2899 return snprintf(buf, PAGE_SIZE, "%d\n", vhost->login_buf->resp.version);
2906 struct ibmvfc_host *vhost = shost_priv(shost);
2907 return snprintf(buf, PAGE_SIZE, "%llx\n", vhost->login_buf->resp.capabilities);
2922 struct ibmvfc_host *vhost = shost_priv(shost);
2927 len = snprintf(buf, PAGE_SIZE, "%d\n", vhost->log_level);
2945 struct ibmvfc_host *vhost = shost_priv(shost);
2949 vhost->log_level = simple_strtoul(buf, NULL, 10);
2982 struct ibmvfc_host *vhost = shost_priv(shost);
2985 char *src = (char *)vhost->trace;
3047 * @vhost: ibmvfc host struct
3052 static struct ibmvfc_async_crq *ibmvfc_next_async_crq(struct ibmvfc_host *vhost)
3054 struct ibmvfc_async_crq_queue *async_crq = &vhost->async_crq;
3070 * @vhost: ibmvfc host struct
3075 static struct ibmvfc_crq *ibmvfc_next_crq(struct ibmvfc_host *vhost)
3077 struct ibmvfc_crq_queue *queue = &vhost->crq;
3101 struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
3104 spin_lock_irqsave(vhost->host->host_lock, flags);
3105 vio_disable_interrupts(to_vio_dev(vhost->dev));
3106 tasklet_schedule(&vhost->tasklet);
3107 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3120 struct ibmvfc_host *vhost = data;
3121 struct vio_dev *vdev = to_vio_dev(vhost->dev);
3127 spin_lock_irqsave(vhost->host->host_lock, flags);
3130 while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
3131 ibmvfc_handle_async(async, vhost);
3137 while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
3138 ibmvfc_handle_crq(crq, vhost);
3144 if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
3146 ibmvfc_handle_async(async, vhost);
3149 } else if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
3151 ibmvfc_handle_crq(crq, vhost);
3158 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3172 wake_up(&tgt->vhost->work_wait_q);
3188 wake_up(&tgt->vhost->work_wait_q);
3237 struct ibmvfc_host *vhost = evt->vhost;
3243 vhost->discovery_threads--;
3294 wake_up(&vhost->work_wait_q);
3305 struct ibmvfc_host *vhost = tgt->vhost;
3308 if (vhost->discovery_threads >= disc_threads)
3312 evt = ibmvfc_get_event(vhost);
3313 vhost->discovery_threads++;
3328 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3329 vhost->discovery_threads--;
3344 struct ibmvfc_host *vhost = evt->vhost;
3349 vhost->discovery_threads--;
3356 vhost->reinit = 1;
3390 wake_up(&vhost->work_wait_q);
3401 struct ibmvfc_host *vhost = tgt->vhost;
3404 if (vhost->discovery_threads >= disc_threads)
3409 evt = ibmvfc_get_event(vhost);
3410 vhost->discovery_threads++;
3421 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3422 vhost->discovery_threads--;
3437 struct ibmvfc_host *vhost = evt->vhost;
3441 vhost->discovery_threads--;
3451 wake_up(&vhost->work_wait_q);
3459 if (vhost->action == IBMVFC_HOST_ACTION_TGT_INIT)
3461 else if (vhost->action == IBMVFC_HOST_ACTION_QUERY_TGTS &&
3465 wake_up(&vhost->work_wait_q);
3476 struct ibmvfc_host *vhost = tgt->vhost;
3479 if (vhost->discovery_threads >= disc_threads)
3483 evt = ibmvfc_get_event(vhost);
3484 vhost->discovery_threads++;
3495 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3496 vhost->discovery_threads--;
3533 struct ibmvfc_host *vhost = evt->vhost;
3538 vhost->discovery_threads--;
3565 wake_up(&vhost->work_wait_q);
3608 struct ibmvfc_host *vhost = evt->vhost;
3612 vhost->abort_threads--;
3615 wake_up(&vhost->work_wait_q);
3628 struct ibmvfc_host *vhost = tgt->vhost;
3635 spin_lock_irqsave(vhost->host->host_lock, flags);
3636 if (vhost->abort_threads >= disc_threads ||
3638 vhost->state != IBMVFC_INITIALIZING ||
3639 vhost->action != IBMVFC_HOST_ACTION_QUERY_TGTS) {
3640 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3644 vhost->abort_threads++;
3646 evt = ibmvfc_get_event(vhost);
3658 rc = ibmvfc_send_event(evt, vhost, default_timeout);
3662 vhost->abort_threads--;
3664 __ibmvfc_reset_host(vhost);
3667 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3684 struct ibmvfc_host *vhost = tgt->vhost;
3687 if (vhost->discovery_threads >= disc_threads)
3691 evt = ibmvfc_get_event(vhost);
3692 vhost->discovery_threads++;
3703 memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
3704 sizeof(vhost->login_buf->resp.port_name));
3705 memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
3706 sizeof(vhost->login_buf->resp.node_name));
3707 mad->fc_iu.payload[6] = vhost->login_buf->resp.scsi_id & 0x00ffffff;
3719 if (ibmvfc_send_event(evt, vhost, IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT)) {
3720 vhost->discovery_threads--;
3736 struct ibmvfc_host *vhost = evt->vhost;
3741 vhost->discovery_threads--;
3777 wake_up(&vhost->work_wait_q);
3788 struct ibmvfc_host *vhost = tgt->vhost;
3791 if (vhost->discovery_threads >= disc_threads)
3795 evt = ibmvfc_get_event(vhost);
3796 vhost->discovery_threads++;
3807 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3808 vhost->discovery_threads--;
3817 * @vhost: ibmvfc host struct
3823 static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
3828 spin_lock_irqsave(vhost->host->host_lock, flags);
3829 list_for_each_entry(tgt, &vhost->targets, queue) {
3836 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3838 tgt = mempool_alloc(vhost->tgt_pool, GFP_NOIO);
3840 dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
3848 tgt->vhost = vhost;
3850 tgt->cancel_key = vhost->task_set++;
3854 spin_lock_irqsave(vhost->host->host_lock, flags);
3855 list_add_tail(&tgt->queue, &vhost->targets);
3858 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3864 * @vhost: ibmvfc host struct
3869 static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
3873 for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
3874 rc = ibmvfc_alloc_target(vhost,
3875 vhost->disc_buf->scsi_id[i] & IBMVFC_DISC_TGT_SCSI_ID_MASK);
3887 struct ibmvfc_host *vhost = evt->vhost;
3894 ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
3895 vhost->num_targets = rsp->num_written;
3896 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
3899 level += ibmvfc_retry_host_init(vhost);
3900 ibmvfc_log(vhost, level, "Discover Targets failed: %s (%x:%x)\n",
3906 dev_err(vhost->dev, "Invalid Discover Targets response: 0x%x\n", mad_status);
3907 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3912 wake_up(&vhost->work_wait_q);
3917 * @vhost: ibmvfc host struct
3920 static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
3923 struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
3931 mad->bufflen = vhost->disc_buf_sz;
3932 mad->buffer.va = vhost->disc_buf_dma;
3933 mad->buffer.len = vhost->disc_buf_sz;
3934 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
3936 if (!ibmvfc_send_event(evt, vhost, default_timeout))
3937 ibmvfc_dbg(vhost, "Sent discover targets\n");
3939 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3949 struct ibmvfc_host *vhost = evt->vhost;
3951 struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
3961 level += ibmvfc_retry_host_init(vhost);
3963 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3964 ibmvfc_log(vhost, level, "NPIV Login failed: %s (%x:%x)\n",
3969 ibmvfc_retry_host_init(vhost);
3974 dev_err(vhost->dev, "Invalid NPIV Login response: 0x%x\n", mad_status);
3975 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3980 vhost->client_migrated = 0;
3983 dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
3985 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3986 wake_up(&vhost->work_wait_q);
3991 dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
3993 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3994 wake_up(&vhost->work_wait_q);
3998 vhost->logged_in = 1;
4000 dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
4004 fc_host_fabric_name(vhost->host) = rsp->node_name;
4005 fc_host_node_name(vhost->host) = rsp->node_name;
4006 fc_host_port_name(vhost->host) = rsp->port_name;
4007 fc_host_port_id(vhost->host) = rsp->scsi_id;
4008 fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
4009 fc_host_supported_classes(vhost->host) = 0;
4011 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
4013 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
4015 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
4016 fc_host_maxframe_size(vhost->host) =
4019 vhost->host->can_queue = rsp->max_cmds - IBMVFC_NUM_INTERNAL_REQ;
4020 vhost->host->max_sectors = npiv_max_sectors;
4021 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
4022 wake_up(&vhost->work_wait_q);
4027 * @vhost: ibmvfc host struct
4030 static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
4033 struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
4035 ibmvfc_gather_partition_info(vhost);
4036 ibmvfc_set_login_info(vhost);
4039 memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
4045 mad->buffer.va = vhost->login_buf_dma;
4046 mad->buffer.len = sizeof(*vhost->login_buf);
4048 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
4050 if (!ibmvfc_send_event(evt, vhost, default_timeout))
4051 ibmvfc_dbg(vhost, "Sent NPIV login\n");
4053 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4058 * @vhost: ibmvfc host struct
4063 struct ibmvfc_host *vhost = evt->vhost;
4070 if (list_empty(&vhost->sent) &&
4071 vhost->action == IBMVFC_HOST_ACTION_LOGO_WAIT) {
4072 ibmvfc_init_host(vhost);
4081 ibmvfc_dbg(vhost, "NPIV Logout failed. 0x%X\n", mad_status);
4085 ibmvfc_hard_reset_host(vhost);
4090 * @vhost: ibmvfc host struct
4093 static void ibmvfc_npiv_logout(struct ibmvfc_host *vhost)
4098 evt = ibmvfc_get_event(vhost);
4107 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO_WAIT);
4109 if (!ibmvfc_send_event(evt, vhost, default_timeout))
4110 ibmvfc_dbg(vhost, "Sent NPIV logout\n");
4112 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4117 * @vhost: ibmvfc host struct
4122 static int ibmvfc_dev_init_to_do(struct ibmvfc_host *vhost)
4126 list_for_each_entry(tgt, &vhost->targets, queue) {
4137 * @vhost: ibmvfc host struct
4142 static int __ibmvfc_work_to_do(struct ibmvfc_host *vhost)
4148 switch (vhost->action) {
4155 if (vhost->discovery_threads == disc_threads)
4157 list_for_each_entry(tgt, &vhost->targets, queue)
4160 list_for_each_entry(tgt, &vhost->targets, queue)
4181 * @vhost: ibmvfc host struct
4186 static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
4191 spin_lock_irqsave(vhost->host->host_lock, flags);
4192 rc = __ibmvfc_work_to_do(vhost);
4193 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4199 * @vhost: ibmvfc host struct
4203 static void ibmvfc_log_ae(struct ibmvfc_host *vhost, int events)
4206 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_RSCN, 0);
4208 vhost->state >= IBMVFC_HALTED)
4209 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
4211 vhost->state == IBMVFC_INITIALIZING)
4212 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKUP, 0);
4222 struct ibmvfc_host *vhost = tgt->vhost;
4227 rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
4228 spin_lock_irqsave(vhost->host->host_lock, flags);
4234 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4240 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4260 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4265 * @vhost: ibmvfc host struct
4268 static void ibmvfc_do_work(struct ibmvfc_host *vhost)
4275 ibmvfc_log_ae(vhost, vhost->events_to_log);
4276 spin_lock_irqsave(vhost->host->host_lock, flags);
4277 vhost->events_to_log = 0;
4278 switch (vhost->action) {
4284 vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
4285 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4286 rc = ibmvfc_reset_crq(vhost);
4287 spin_lock_irqsave(vhost->host->host_lock, flags);
4288 if (rc || (rc = ibmvfc_send_crq_init(vhost)) ||
4289 (rc = vio_enable_interrupts(to_vio_dev(vhost->dev)))) {
4290 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4291 dev_err(vhost->dev, "Error after reset (rc=%d)\n", rc);
4295 vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
4296 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4297 rc = ibmvfc_reenable_crq_queue(vhost);
4298 spin_lock_irqsave(vhost->host->host_lock, flags);
4299 if (rc || (rc = ibmvfc_send_crq_init(vhost))) {
4300 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4301 dev_err(vhost->dev, "Error after enable (rc=%d)\n", rc);
4305 vhost->job_step(vhost);
4308 BUG_ON(vhost->state != IBMVFC_INITIALIZING);
4309 if (vhost->delay_init) {
4310 vhost->delay_init = 0;
4311 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4315 vhost->job_step(vhost);
4318 list_for_each_entry(tgt, &vhost->targets, queue)
4320 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY_TGTS);
4323 list_for_each_entry(tgt, &vhost->targets, queue) {
4330 if (!ibmvfc_dev_init_to_do(vhost))
4331 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
4335 list_for_each_entry(tgt, &vhost->targets, queue) {
4342 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4351 if (vhost->state == IBMVFC_INITIALIZING) {
4352 if (vhost->action == IBMVFC_HOST_ACTION_TGT_DEL_FAILED) {
4353 if (vhost->reinit) {
4354 vhost->reinit = 0;
4355 scsi_block_requests(vhost->host);
4356 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
4357 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4359 ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
4360 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
4361 wake_up(&vhost->init_wait_q);
4362 schedule_work(&vhost->rport_add_work_q);
4363 vhost->init_retries = 0;
4364 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4365 scsi_unblock_requests(vhost->host);
4370 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
4371 vhost->job_step = ibmvfc_discover_targets;
4374 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
4375 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4376 scsi_unblock_requests(vhost->host);
4377 wake_up(&vhost->init_wait_q);
4382 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
4383 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4384 ibmvfc_alloc_targets(vhost);
4385 spin_lock_irqsave(vhost->host->host_lock, flags);
4388 list_for_each_entry(tgt, &vhost->targets, queue) {
4395 if (!ibmvfc_dev_init_to_do(vhost))
4396 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL_FAILED);
4402 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4414 struct ibmvfc_host *vhost = data;
4420 rc = wait_event_interruptible(vhost->work_wait_q,
4421 ibmvfc_work_to_do(vhost));
4428 ibmvfc_do_work(vhost);
4431 ibmvfc_dbg(vhost, "ibmvfc kthread exiting...\n");
4437 * @vhost: ibmvfc host struct
4445 static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
4448 struct device *dev = vhost->dev;
4450 struct ibmvfc_crq_queue *crq = &vhost->crq;
4470 retrc = rc = ibmvfc_reset_crq(vhost);
4481 tasklet_init(&vhost->tasklet, (void *)ibmvfc_tasklet, (unsigned long)vhost);
4483 if ((rc = request_irq(vdev->irq, ibmvfc_interrupt, 0, IBMVFC_NAME, vhost))) {
4498 tasklet_kill(&vhost->tasklet);
4510 * ibmvfc_free_mem - Free memory for vhost
4511 * @vhost: ibmvfc host struct
4516 static void ibmvfc_free_mem(struct ibmvfc_host *vhost)
4518 struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
4521 mempool_destroy(vhost->tgt_pool);
4522 kfree(vhost->trace);
4523 dma_free_coherent(vhost->dev, vhost->disc_buf_sz, vhost->disc_buf,
4524 vhost->disc_buf_dma);
4525 dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
4526 vhost->login_buf, vhost->login_buf_dma);
4527 dma_pool_destroy(vhost->sg_pool);
4528 dma_unmap_single(vhost->dev, async_q->msg_token,
4535 * ibmvfc_alloc_mem - Allocate memory for vhost
4536 * @vhost: ibmvfc host struct
4541 static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
4543 struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
4544 struct device *dev = vhost->dev;
4563 vhost->sg_pool = dma_pool_create(IBMVFC_NAME, dev,
4567 if (!vhost->sg_pool) {
4572 vhost->login_buf = dma_alloc_coherent(dev, sizeof(*vhost->login_buf),
4573 &vhost->login_buf_dma, GFP_KERNEL);
4575 if (!vhost->login_buf) {
4580 vhost->disc_buf_sz = sizeof(vhost->disc_buf->scsi_id[0]) * max_targets;
4581 vhost->disc_buf = dma_alloc_coherent(dev, vhost->disc_buf_sz,
4582 &vhost->disc_buf_dma, GFP_KERNEL);
4584 if (!vhost->disc_buf) {
4589 vhost->trace = kcalloc(IBMVFC_NUM_TRACE_ENTRIES,
4592 if (!vhost->trace)
4595 vhost->tgt_pool = mempool_create_kmalloc_pool(IBMVFC_TGT_MEMPOOL_SZ,
4598 if (!vhost->tgt_pool) {
4607 kfree(vhost->trace);
4609 dma_free_coherent(dev, vhost->disc_buf_sz, vhost->disc_buf,
4610 vhost->disc_buf_dma);
4612 dma_free_coherent(dev, sizeof(*vhost->login_buf),
4613 vhost->login_buf, vhost->login_buf_dma);
4615 dma_pool_destroy(vhost->sg_pool);
4633 struct ibmvfc_host *vhost = container_of(work, struct ibmvfc_host,
4641 spin_lock_irqsave(vhost->host->host_lock, flags);
4644 if (vhost->state != IBMVFC_ACTIVE)
4647 list_for_each_entry(tgt, &vhost->targets, queue) {
4654 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4657 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4664 spin_lock_irqsave(vhost->host->host_lock, flags);
4670 if (vhost->state == IBMVFC_ACTIVE)
4671 vhost->scan_complete = 1;
4672 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4686 struct ibmvfc_host *vhost;
4692 shost = scsi_host_alloc(&driver_template, sizeof(*vhost));
4706 vhost = shost_priv(shost);
4707 INIT_LIST_HEAD(&vhost->sent);
4708 INIT_LIST_HEAD(&vhost->free);
4709 INIT_LIST_HEAD(&vhost->targets);
4710 sprintf(vhost->name, IBMVFC_NAME);
4711 vhost->host = shost;
4712 vhost->dev = dev;
4713 vhost->partition_number = -1;
4714 vhost->log_level = log_level;
4715 vhost->task_set = 1;
4716 strcpy(vhost->partition_name, "UNKNOWN");
4717 init_waitqueue_head(&vhost->work_wait_q);
4718 init_waitqueue_head(&vhost->init_wait_q);
4719 INIT_WORK(&vhost->rport_add_work_q, ibmvfc_rport_add_thread);
4720 mutex_init(&vhost->passthru_mutex);
4722 if ((rc = ibmvfc_alloc_mem(vhost)))
4725 vhost->work_thread = kthread_run(ibmvfc_work, vhost, "%s_%d", IBMVFC_NAME,
4728 if (IS_ERR(vhost->work_thread)) {
4730 PTR_ERR(vhost->work_thread));
4734 if ((rc = ibmvfc_init_crq(vhost))) {
4739 if ((rc = ibmvfc_init_event_pool(vhost))) {
4755 dev_set_drvdata(dev, vhost);
4757 list_add_tail(&vhost->queue, &ibmvfc_head);
4760 ibmvfc_send_crq_init(vhost);
4767 ibmvfc_free_event_pool(vhost);
4769 ibmvfc_release_crq_queue(vhost);
4771 kthread_stop(vhost->work_thread);
4773 ibmvfc_free_mem(vhost);
4790 struct ibmvfc_host *vhost = dev_get_drvdata(&vdev->dev);
4794 ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
4796 spin_lock_irqsave(vhost->host->host_lock, flags);
4797 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
4798 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4800 ibmvfc_wait_while_resetting(vhost);
4801 ibmvfc_release_crq_queue(vhost);
4802 kthread_stop(vhost->work_thread);
4803 fc_remove_host(vhost->host);
4804 scsi_remove_host(vhost->host);
4806 spin_lock_irqsave(vhost->host->host_lock, flags);
4807 ibmvfc_purge_requests(vhost, DID_ERROR);
4808 ibmvfc_free_event_pool(vhost);
4809 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4811 ibmvfc_free_mem(vhost);
4813 list_del(&vhost->queue);
4815 scsi_host_put(vhost->host);
4831 struct ibmvfc_host *vhost = dev_get_drvdata(dev);
4834 spin_lock_irqsave(vhost->host->host_lock, flags);
4836 tasklet_schedule(&vhost->tasklet);
4837 spin_unlock_irqrestore(vhost->host->host_lock, flags);