int ghd_reset_notify(ccc_t *cccp,
gtgt_t *gtgtp,
int flag,
void (*callback)(caddr_t),
caddr_t arg)
{
ghd_reset_notify_list_t *rnp;
int rc = FALSE;
switch (flag) {
case SCSI_RESET_NOTIFY:
rnp = (ghd_reset_notify_list_t *)kmem_zalloc(sizeof (*rnp),
KM_SLEEP);
rnp->gtgtp = gtgtp;
rnp->callback = callback;
rnp->arg = arg;
mutex_enter(&cccp->ccc_reset_notify_mutex);
L2_add(&cccp->ccc_reset_notify_list, &rnp->l2_link,
(void *)rnp);
mutex_exit(&cccp->ccc_reset_notify_mutex);
rc = TRUE;
break;
case SCSI_RESET_CANCEL:
mutex_enter(&cccp->ccc_reset_notify_mutex);
for (rnp = (ghd_reset_notify_list_t *)
L2_next(&cccp->ccc_reset_notify_list);
rnp != NULL;
rnp = (ghd_reset_notify_list_t *)L2_next(&rnp->l2_link)) {
if (rnp->gtgtp == gtgtp &&
rnp->callback == callback &&
rnp->arg == arg) {
L2_delete(&rnp->l2_link);
kmem_free(rnp, sizeof (*rnp));
rc = TRUE;
}
}
mutex_exit(&cccp->ccc_reset_notify_mutex);
break;
default:
rc = FALSE;
break;
}
return (rc);
}
static gcmd_t *
ghd_doneq_get(ccc_t *cccp)
{
kmutex_t *doneq_mutexp = &cccp->ccc_doneq_mutex;
gcmd_t *gcmdp;
mutex_enter(doneq_mutexp);
if ((gcmdp = L2_next(&cccp->ccc_doneq)) != NULL)
L2_delete(&gcmdp->cmd_q);
mutex_exit(doneq_mutexp);
return (gcmdp);
}
static uint_t
ghd_doneq_process(caddr_t arg)
{
ccc_t *cccp = (ccc_t *)arg;
kmutex_t *doneq_mutexp;
gcmd_t *gcmdp;
int rc = DDI_INTR_UNCLAIMED;
doneq_mutexp = &cccp->ccc_doneq_mutex;
for (;;) {
mutex_enter(doneq_mutexp);
/* skip if FLAG_NOINTR request in progress */
if (cccp->ccc_hba_pollmode)
break;
/* pop the first one from the done Q */
if ((gcmdp = L2_next(&cccp->ccc_doneq)) == NULL)
break;
L2_delete(&gcmdp->cmd_q);
if (gcmdp->cmd_flags & GCMDFLG_RESET_NOTIFY) {
/* special request; processed here and discarded */
ghd_do_reset_notify_callbacks(cccp);
ghd_gcmd_free(gcmdp);
mutex_exit(doneq_mutexp);
continue;
}
/*
* drop the mutex since completion
* function can re-enter the top half via
* ghd_transport()
*/
mutex_exit(doneq_mutexp);
gcmdp->cmd_state = GCMD_STATE_IDLE;
(*cccp->ccc_hba_complete)(cccp->ccc_hba_handle, gcmdp, TRUE);
#ifdef notyet
/* I don't think this is ever necessary */
rc = DDI_INTR_CLAIMED;
#endif
}
mutex_exit(doneq_mutexp);
return (rc);
}
static int
ghd_poll(ccc_t *cccp,
gpoll_t polltype,
ulong_t polltime,
gcmd_t *poll_gcmdp,
gtgt_t *gtgtp,
void *intr_status)
{
gcmd_t *gcmdp;
L2el_t gcmd_hold_queue;
int got_it = FALSE;
clock_t poll_lbolt;
clock_t start_lbolt;
clock_t current_lbolt;
ASSERT(mutex_owned(&cccp->ccc_hba_mutex));
L2_INIT(&gcmd_hold_queue);
/* Que hora es? */
poll_lbolt = drv_usectohz((clock_t)polltime);
start_lbolt = ddi_get_lbolt();
/* unqueue and save all CMD/CCBs until I find the right one */
while (!got_it) {
/* Give up yet? */
current_lbolt = ddi_get_lbolt();
if (poll_lbolt && (current_lbolt - start_lbolt >= poll_lbolt))
break;
/*
* delay 1 msec each time around the loop (this is an
* arbitrary delay value, any value should work) except
* zero because some devices don't like being polled too
* fast and it saturates the bus on an MP system.
*/
drv_usecwait(1000);
/*
* check for any new device status
*/
if ((*cccp->ccc_get_status)(cccp->ccc_hba_handle, intr_status))
(*cccp->ccc_process_intr)(cccp->ccc_hba_handle,
intr_status);
/*
* If something completed then try to start the
* next request from the wait queue. Don't release
* the HBA mutex because I don't know whether my
* request(s) is/are on the done queue yet.
*/
mutex_enter(&cccp->ccc_waitq_mutex);
(void) ghd_waitq_process_and_mutex_hold(cccp);
mutex_exit(&cccp->ccc_waitq_mutex);
/*
* Process the first of any timed-out requests.
*/
ghd_timer_poll(cccp, GHD_TIMER_POLL_ONE);
/*
* Unqueue all the completed requests, look for mine
*/
while (gcmdp = ghd_doneq_get(cccp)) {
/*
* If we got one and it's my request, then
* we're done.
*/
if (gcmdp == poll_gcmdp) {
poll_gcmdp->cmd_state = GCMD_STATE_IDLE;
got_it = TRUE;
continue;
}
/* fifo queue the other cmds on my local list */
L2_add(&gcmd_hold_queue, &gcmdp->cmd_q, gcmdp);
}
/*
* Check whether we're done yet.
*/
switch (polltype) {
case GHD_POLL_DEVICE:
/*
* wait for everything queued on a specific device
*/
if (GDEV_NACTIVE(gtgtp->gt_gdevp) == 0)
got_it = TRUE;
break;
case GHD_POLL_ALL:
/*
* if waiting for all outstanding requests and
* if active list is now empty then exit
*/
if (GHBA_NACTIVE(cccp) == 0)
got_it = TRUE;
break;
case GHD_POLL_REQUEST:
break;
}
}
if (L2_EMPTY(&gcmd_hold_queue)) {
ASSERT(!mutex_owned(&cccp->ccc_waitq_mutex));
ASSERT(mutex_owned(&cccp->ccc_hba_mutex));
return (got_it);
}
/*
* copy the local gcmd_hold_queue back to the doneq so
* that the order of completion callbacks is preserved
*/
while (gcmdp = L2_next(&gcmd_hold_queue)) {
L2_delete(&gcmdp->cmd_q);
GHD_DONEQ_PUT_TAIL(cccp, gcmdp);
}
ASSERT(!mutex_owned(&cccp->ccc_waitq_mutex));
ASSERT(mutex_owned(&cccp->ccc_hba_mutex));
return (got_it);
}
void
ghd_waitq_delete(ccc_t *cccp, gcmd_t *gcmdp)
{
gtgt_t *gtgtp = GCMDP2GTGTP(gcmdp);
gdev_t *gdevp = gtgtp->gt_gdevp;
#if defined(GHD_DEBUG) || defined(__lint)
Q_t *qp = &gdevp->gd_waitq;
#endif
ASSERT(mutex_owned(&cccp->ccc_hba_mutex));
mutex_enter(&cccp->ccc_waitq_mutex);
/*
* Adjust all queue counters. If this request is being aborted
* it might only have made it to the target queue. Otherwise,
* both the target and hba queue have to be adjusted when a
* request is completed normally. The cmd_waitq_level value
* indicates which queue counters need to be adjusted. It's
* incremented as the request progresses up the queues.
*/
switch (gcmdp->cmd_waitq_level) {
case 0:
break;
case 1:
/*
* If this is an early-timeout, or early-abort, the request
* is still linked onto a waitq. Remove it now. If it's
* an active request and no longer on the waitq then calling
* L2_delete a second time does no harm.
*/
L2_delete(&gcmdp->cmd_q);
break;
case 2:
L2_delete(&gcmdp->cmd_q);
#if defined(GHD_DEBUG) || defined(__lint)
if (GDEV_NACTIVE(gdevp) == 0)
debug_enter("\n\nGHD WAITQ DELETE\n\n");
#endif
GDEV_NACTIVE(gdevp)--;
break;
case 3:
/* it's an active or completed command */
#if defined(GHD_DEBUG) || defined(__lint)
if (GDEV_NACTIVE(gdevp) == 0 || GHBA_NACTIVE(cccp) == 0)
debug_enter("\n\nGHD WAITQ DELETE\n\n");
#endif
GDEV_NACTIVE(gdevp)--;
GHBA_NACTIVE(cccp)--;
break;
default:
/* this shouldn't happen */
#if defined(GHD_DEBUG) || defined(__lint)
debug_enter("\n\nGHD WAITQ LEVEL > 3\n\n");
#endif
break;
}
GDBG_WAITQ(("ghd_waitq_delete: gcmdp 0x%p qp 0x%p level %ld\n",
gcmdp, qp, gcmdp->cmd_waitq_level));
/*
* There's probably now more room in the HBA queue. Move
* up as many requests as possible.
*/
ghd_waitq_shuffle_up(cccp, gdevp);
mutex_exit(&cccp->ccc_waitq_mutex);
}
