xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/emlxs/emlxs_clock.c (revision 8f23e9fa)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at
 * http://www.opensource.org/licenses/cddl1.txt.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004-2012 Emulex. All rights reserved.
 * Use is subject to license terms.
 */

#include <emlxs.h>

/* Timer period in seconds */
#define	EMLXS_TIMER_PERIOD		1	/* secs */
#define	EMLXS_PKT_PERIOD		5	/* secs */
#define	EMLXS_UB_PERIOD			60	/* secs */

EMLXS_MSG_DEF(EMLXS_CLOCK_C);


static void emlxs_timer_check_loopback(emlxs_hba_t *hba);

#ifdef DHCHAP_SUPPORT
static void emlxs_timer_check_dhchap(emlxs_port_t *port);
#endif /* DHCHAP_SUPPORT */

static void	emlxs_timer_check_pools(emlxs_hba_t *hba);
static void	emlxs_timer(void *arg);
static void	emlxs_timer_check_fw_update(emlxs_hba_t *hba);
static void	emlxs_timer_check_heartbeat(emlxs_hba_t *hba);
static uint32_t	emlxs_timer_check_pkts(emlxs_hba_t *hba, uint8_t *flag);
static void	emlxs_timer_check_nodes(emlxs_port_t *port, uint8_t *flag);
static void	emlxs_timer_check_linkup(emlxs_hba_t *hba);
static void	emlxs_timer_check_discovery(emlxs_port_t *port);
static void	emlxs_timer_check_clean_address(emlxs_port_t *port);
static void	emlxs_timer_check_ub(emlxs_port_t *port);
static void	emlxs_timer_check_channels(emlxs_hba_t *hba, uint8_t *flag);
static uint32_t	emlxs_pkt_chip_timeout(emlxs_port_t *port, emlxs_buf_t *sbp,
			Q *abortq, uint8_t *flag);

#ifdef TX_WATCHDOG
static void	emlxs_tx_watchdog(emlxs_hba_t *hba);
#endif /* TX_WATCHDOG */

extern clock_t
emlxs_timeout(emlxs_hba_t *hba, uint32_t timeout)
{
	emlxs_config_t *cfg = &CFG;
	clock_t time;

	/* Set thread timeout */
	if (cfg[CFG_TIMEOUT_ENABLE].current) {
		(void) drv_getparm(LBOLT, &time);
		time += (timeout * drv_usectohz(1000000));
	} else {
		time = -1;
	}

	return (time);

} /* emlxs_timeout() */


static void
emlxs_timer(void *arg)
{
	emlxs_hba_t *hba = (emlxs_hba_t *)arg;
	emlxs_port_t *port = &PPORT;

	if (!hba->timer_id) {
		return;
	}

	mutex_enter(&EMLXS_TIMER_LOCK);

	/* Only one timer thread is allowed */
	if (hba->timer_flags & EMLXS_TIMER_BUSY) {
		mutex_exit(&EMLXS_TIMER_LOCK);
		return;
	}

	/* Check if a kill request has been made */
	if (hba->timer_flags & EMLXS_TIMER_KILL) {
		hba->timer_id = 0;
		hba->timer_tics = 0;
		hba->timer_flags |= EMLXS_TIMER_ENDED;

		mutex_exit(&EMLXS_TIMER_LOCK);
		return;
	}

	hba->timer_flags |= (EMLXS_TIMER_BUSY | EMLXS_TIMER_STARTED);
	hba->timer_tics = DRV_TIME;

	/* Check io_active count (Safety net) */
	if (hba->io_active & 0x80000000) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
		    "Timer: io_active=0x%x. Reset to zero.", hba->io_active);
		hba->io_active = 0;
	}

	mutex_exit(&EMLXS_TIMER_LOCK);

	EMLXS_SLI_POLL_ERRATT(hba);

	/* Perform standard checks */
	emlxs_timer_checks(hba);

	/* Restart the timer */
	mutex_enter(&EMLXS_TIMER_LOCK);

	hba->timer_flags &= ~EMLXS_TIMER_BUSY;

	/* If timer is still enabled, restart it */
	if (!(hba->timer_flags & EMLXS_TIMER_KILL)) {
		hba->timer_id =
		    timeout(emlxs_timer, (void *)hba,
		    (EMLXS_TIMER_PERIOD * drv_usectohz(1000000)));
	} else {
		hba->timer_id = 0;
		hba->timer_flags |= EMLXS_TIMER_ENDED;
	}

	mutex_exit(&EMLXS_TIMER_LOCK);

	return;

} /* emlxs_timer() */


extern void
emlxs_timer_checks(emlxs_hba_t *hba)
{
	emlxs_port_t *port = &PPORT;
	uint8_t flag[MAX_CHANNEL];
	uint32_t i;
	uint32_t rc;

	/* Exit if we are still initializing */
	if (hba->state < FC_LINK_DOWN) {
		return;
	}

	bzero((void *)flag, sizeof (flag));

	/* Check SLI level timeouts */
	EMLXS_SLI_TIMER(hba);

	/* Check event queue */
	emlxs_timer_check_events(hba);

	/* Check heartbeat timer */
	emlxs_timer_check_heartbeat(hba);

	/* Check fw update timer */
	emlxs_timer_check_fw_update(hba);

#ifdef IDLE_TIMER
	emlxs_pm_idle_timer(hba);
#endif /* IDLE_TIMER */

	/* Check for loopback timeouts */
	emlxs_timer_check_loopback(hba);

	/* Check for packet timeouts */
	rc = emlxs_timer_check_pkts(hba, flag);

	if (rc) {
		/* Link or adapter is being reset */
		return;
	}

	/* Check for linkup timeout */
	emlxs_timer_check_linkup(hba);

	/* Check the ports */
	for (i = 0; i < MAX_VPORTS; i++) {
		port = &VPORT(i);

		if (!(port->flag & EMLXS_PORT_BOUND)) {
			continue;
		}

		/* Check for node gate timeouts */
		emlxs_timer_check_nodes(port, flag);

		/* Check for clean address bit delay timeout */
		emlxs_timer_check_clean_address(port);

		/* Check for tape discovery timeout */
		emlxs_timer_check_discovery(port);

		/* Check for UB timeouts */
		emlxs_timer_check_ub(port);

#ifdef DHCHAP_SUPPORT
		/* Check for DHCHAP authentication timeouts */
		emlxs_timer_check_dhchap(port);
#endif /* DHCHAP_SUPPORT */

	}

	/* Check memory pools */
	emlxs_timer_check_pools(hba);

	/* Check for IO channel service timeouts */
	/* Always do this last */
	emlxs_timer_check_channels(hba, flag);

	return;

} /* emlxs_timer_checks() */


extern void
emlxs_timer_start(emlxs_hba_t *hba)
{
	if (hba->timer_id) {
		return;
	}

	/* Restart the timer */
	mutex_enter(&EMLXS_TIMER_LOCK);
	if (!hba->timer_id) {
		hba->timer_flags = 0;
		hba->timer_id =
		    timeout(emlxs_timer, (void *)hba, drv_usectohz(1000000));
	}
	mutex_exit(&EMLXS_TIMER_LOCK);

} /* emlxs_timer_start() */


extern void
emlxs_timer_stop(emlxs_hba_t *hba)
{
	if (!hba->timer_id) {
		return;
	}

	mutex_enter(&EMLXS_TIMER_LOCK);
	hba->timer_flags |= EMLXS_TIMER_KILL;

	while (hba->timer_id) {
		mutex_exit(&EMLXS_TIMER_LOCK);
		delay(drv_usectohz(500000));
		mutex_enter(&EMLXS_TIMER_LOCK);
	}
	mutex_exit(&EMLXS_TIMER_LOCK);

	return;

} /* emlxs_timer_stop() */


static uint32_t
emlxs_timer_check_pkts(emlxs_hba_t *hba, uint8_t *flag)
{
	emlxs_port_t *port = &PPORT;
	emlxs_config_t *cfg = &CFG;
	Q tmo;
	int32_t channelno;
	CHANNEL *cp;
	NODELIST *nlp;
	IOCBQ *prev;
	IOCBQ *next;
	IOCB *iocb;
	IOCBQ *iocbq;
	emlxs_buf_t *sbp;
	fc_packet_t *pkt;
	Q abort;
	uint32_t iotag;
	uint32_t rc;

	if (!cfg[CFG_TIMEOUT_ENABLE].current) {
		return (0);
	}

	if (hba->pkt_timer > hba->timer_tics) {
		return (0);
	}

	hba->pkt_timer = hba->timer_tics + EMLXS_PKT_PERIOD;


	bzero((void *)&tmo, sizeof (Q));

	/*
	 * We must hold the locks here because we never know when an iocb
	 * will be removed out from under us
	 */

	mutex_enter(&EMLXS_TX_CHANNEL_LOCK);

	for (channelno = 0; channelno < hba->chan_count; channelno++) {
		cp = &hba->chan[channelno];

		/* Scan the tx queues for each active node on the channel */

		/* Get the first node */
		nlp = (NODELIST *)cp->nodeq.q_first;

		while (nlp) {
			/* Scan the node's priority tx queue */
			prev = NULL;
			iocbq = (IOCBQ *)nlp->nlp_ptx[channelno].q_first;

			while (iocbq) {
				next = (IOCBQ *)iocbq->next;
				iocb = &iocbq->iocb;
				sbp = (emlxs_buf_t *)iocbq->sbp;

				/* Check if iocb has timed out */
				if (sbp && hba->timer_tics >= sbp->ticks) {
					/* iocb timed out, now deque it */
					if (next == NULL) {
						nlp->nlp_ptx[channelno].q_last =
						    (uint8_t *)prev;
					}

					if (prev == NULL) {
						nlp->nlp_ptx[channelno].
						    q_first = (uint8_t *)next;
					} else {
						prev->next = next;
					}

					iocbq->next = NULL;
					nlp->nlp_ptx[channelno].q_cnt--;

					/* Add this iocb to our local */
					/* timout queue */

					/*
					 * This way we don't hold the TX_CHANNEL
					 * lock too long
					 */

					if (tmo.q_first) {
						((IOCBQ *)tmo.q_last)->next =
						    iocbq;
						tmo.q_last =
						    (uint8_t *)iocbq;
						tmo.q_cnt++;
					} else {
						tmo.q_first =
						    (uint8_t *)iocbq;
						tmo.q_last =
						    (uint8_t *)iocbq;
						tmo.q_cnt = 1;
					}
					iocbq->next = NULL;

				} else {
					prev = iocbq;
				}

				iocbq = next;

			}	/* while (iocbq) */


			/* Scan the node's tx queue */
			prev = NULL;
			iocbq = (IOCBQ *)nlp->nlp_tx[channelno].q_first;

			while (iocbq) {
				next = (IOCBQ *)iocbq->next;
				iocb = &iocbq->iocb;
				sbp = (emlxs_buf_t *)iocbq->sbp;

				/* Check if iocb has timed out */
				if (sbp && hba->timer_tics >= sbp->ticks) {
					/* iocb timed out, now deque it */
					if (next == NULL) {
						nlp->nlp_tx[channelno].q_last =
						    (uint8_t *)prev;
					}

					if (prev == NULL) {
						nlp->nlp_tx[channelno].q_first =
						    (uint8_t *)next;
					} else {
						prev->next = next;
					}

					iocbq->next = NULL;
					nlp->nlp_tx[channelno].q_cnt--;

					/* Add this iocb to our local */
					/* timout queue */

					/*
					 * This way we don't hold the TX_CHANNEL
					 * lock too long
					 */

					if (tmo.q_first) {
						((IOCBQ *)tmo.q_last)->next =
						    iocbq;
						tmo.q_last =
						    (uint8_t *)iocbq;
						tmo.q_cnt++;
					} else {
						tmo.q_first =
						    (uint8_t *)iocbq;
						tmo.q_last =
						    (uint8_t *)iocbq;
						tmo.q_cnt = 1;
					}
					iocbq->next = NULL;

				} else {
					prev = iocbq;
				}

				iocbq = next;

			}	/* while (iocbq) */

			if (nlp == (NODELIST *)cp->nodeq.q_last) {
				nlp = NULL;
			} else {
				nlp = nlp->nlp_next[channelno];
			}

		}	/* while (nlp) */

	}	/* end of for */

	/* Now cleanup the iocb's */
	iocbq = (IOCBQ *)tmo.q_first;
	while (iocbq) {
		/* Free the IoTag and the bmp */
		iocb = &iocbq->iocb;
		channelno = ((CHANNEL *)iocbq->channel)->channelno;
		sbp = iocbq->sbp;
		if (sbp && (sbp != STALE_PACKET)) {
			if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
				emlxs_sli4_free_xri(port, sbp, sbp->xrip, 1);
			} else {
				(void) emlxs_unregister_pkt(
				    (CHANNEL *)iocbq->channel,
				    iocb->ULPIOTAG, 0);
			}

			mutex_enter(&sbp->mtx);
			sbp->pkt_flags |= PACKET_IN_TIMEOUT;
			mutex_exit(&sbp->mtx);
		}

		iocbq = (IOCBQ *)iocbq->next;

	}	/* end of while */

	mutex_exit(&EMLXS_TX_CHANNEL_LOCK);

	/* Now complete the transmit timeouts outside the locks */
	iocbq = (IOCBQ *)tmo.q_first;
	while (iocbq) {
		/* Save the next iocbq for now */
		next = (IOCBQ *)iocbq->next;

		/* Unlink this iocbq */
		iocbq->next = NULL;

		/* Get the pkt */
		sbp = (emlxs_buf_t *)iocbq->sbp;

		if (sbp) {
			/* Warning: Some FCT sbp's don't have */
			/* fc_packet objects */
			pkt = PRIV2PKT(sbp);

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_timeout_msg,
			    "TXQ abort: sbp=%p iotag=%d tmo=%d", sbp,
			    sbp->iotag, (pkt) ? pkt->pkt_timeout : 0);

			if (hba->state >= FC_LINK_UP) {
				emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
				    IOERR_ABORT_TIMEOUT, 1);
			} else {
				emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
				    IOERR_LINK_DOWN, 1);
			}

		}

		iocbq = next;

	}	/* end of while */



	/* Now check the chip */
	bzero((void *)&abort, sizeof (Q));

	/* Check the HBA for outstanding IOs */
	rc = 0;
	mutex_enter(&EMLXS_FCTAB_LOCK);
	for (iotag = 1; iotag < hba->max_iotag; iotag++) {
		sbp = hba->fc_table[iotag];

		if (!sbp || sbp == STALE_PACKET) {
			continue;
		}

		/* Check if IO is valid */
		if (!(sbp->pkt_flags & PACKET_VALID) ||
		    (sbp->pkt_flags & (PACKET_ULP_OWNED|
		    PACKET_COMPLETED|PACKET_IN_COMPLETION))) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg,
			    "timer_check_pkts: Invalid IO found. iotag=%d",
			    iotag);

			hba->fc_table[iotag] = STALE_PACKET;
			hba->io_count--;
			continue;
		}

		if ((sbp->pkt_flags & PACKET_IN_CHIPQ) &&
		    (hba->timer_tics >= sbp->ticks)) {
			rc = emlxs_pkt_chip_timeout(sbp->iocbq.port,
			    sbp, &abort, flag);

			if (rc) {
				break;
			}
		}
	}
	mutex_exit(&EMLXS_FCTAB_LOCK);

	/* Now put the iocb's on the tx queue */
	iocbq = (IOCBQ *)abort.q_first;
	while (iocbq) {
		/* Save the next iocbq for now */
		next = (IOCBQ *)iocbq->next;

		/* Unlink this iocbq */
		iocbq->next = NULL;

		/* Send this iocbq */
		emlxs_tx_put(iocbq, 1);

		iocbq = next;
	}

	/* Now trigger IO channel service to send these abort iocbq */
	for (channelno = 0; channelno < hba->chan_count; channelno++) {
		if (!flag[channelno]) {
			continue;
		}
		cp = &hba->chan[channelno];

		EMLXS_SLI_ISSUE_IOCB_CMD(hba, cp, 0);
	}

	if (rc == 1) {
		mutex_enter(&EMLXS_PORT_LOCK);
		/* If a link reset or port reset is already requested, exit */
		if (!(hba->reset_request & (FC_LINK_RESET | FC_PORT_RESET))) {
			hba->reset_request |= FC_LINK_RESET;
			mutex_exit(&EMLXS_PORT_LOCK);
			/* Spawn a thread to reset the link */
			emlxs_thread_spawn(hba, emlxs_reset_link_thread, NULL,
			    NULL);
			goto exit;
		}
		mutex_exit(&EMLXS_PORT_LOCK);
	} else if (rc == 2) {
		mutex_enter(&EMLXS_PORT_LOCK);
		/* If a port reset is already requested, exit */
		if (!(hba->reset_request & FC_PORT_RESET)) {
			hba->reset_request |= FC_PORT_RESET;
			mutex_exit(&EMLXS_PORT_LOCK);
			/* Spawn a thread to reset the adapter */
			emlxs_thread_spawn(hba, emlxs_restart_thread, NULL,
			    NULL);
			goto exit;
		}
		mutex_exit(&EMLXS_PORT_LOCK);
	}

exit:
	return (rc);

} /* emlxs_timer_check_pkts() */


static void
emlxs_timer_check_channels(emlxs_hba_t *hba, uint8_t *flag)
{
	emlxs_port_t *port = &PPORT;
	emlxs_config_t *cfg = &CFG;
	int32_t channelno;
	CHANNEL *cp;
	uint32_t logit;

	if (!cfg[CFG_TIMEOUT_ENABLE].current) {
		return;
	}

	for (channelno = 0; channelno < hba->chan_count; channelno++) {
		cp = &hba->chan[channelno];

		logit = 0;

		/* Check for channel timeout now */
		mutex_enter(&EMLXS_TX_CHANNEL_LOCK);
		if (cp->timeout && (hba->timer_tics >= cp->timeout)) {
			/* Check if there is work to do on channel and */
			/* the link is still up */
			if (cp->nodeq.q_first) {
				flag[channelno] = 1;
				cp->timeout = hba->timer_tics + 10;

				if (hba->state >= FC_LINK_UP) {
					logit = 1;
				}
			} else {
				cp->timeout = 0;
			}
		}
		mutex_exit(&EMLXS_TX_CHANNEL_LOCK);

		if (logit) {
			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_chan_watchdog_msg,
			    "IO Channel %d cnt=%d,%d",
			    channelno,
			    hba->channel_tx_count,
			    hba->io_count);
		}

		/*
		 * If IO channel flag is set, request iocb servicing
		 * here to send any iocb's that may still be queued
		 */
		if (flag[channelno]) {
			EMLXS_SLI_ISSUE_IOCB_CMD(hba, cp, 0);
		}
	}

	return;

} /* emlxs_timer_check_channels() */


static void
emlxs_timer_check_nodes(emlxs_port_t *port, uint8_t *flag)
{
	emlxs_hba_t *hba = HBA;
	uint32_t found;
	uint32_t i;
	NODELIST *nlp;
	int32_t channelno;

	for (;;) {
		/* Check node gate flag for expiration */
		found = 0;

		/*
		 * We need to lock, scan, and unlock because we can't hold the
		 * lock while we call node_open
		 */
		rw_enter(&port->node_rwlock, RW_READER);
		for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) {
			nlp = port->node_table[i];