BPicture: Fix archive constructor.

[haiku.git] / src / add-ons / kernel / bus_managers / ide / sync.c

/*
 * Copyright 2002/03, Thomas Kurschel. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

/*
        Part of Open IDE bus manager

        Handling of passive waiting and synchronized procedure calls.
        The latter are calls that get delayed until the bus is idle.
*/


#include "ide_internal.h"
#include "ide_sim.h"

#include <string.h>


//#define TRACE_SYNC
#ifdef TRACE_SYNC
#       define TRACE(x) { dprintf("%s(): ", __FUNCTION__); dprintf x ; }
#else
#       define TRACE(x) ;
#endif


/** DPC handler for IRQs */

void
ide_dpc(void *arg)
{
        ide_bus_info *bus = (ide_bus_info *)arg;
        ide_qrequest *qrequest;
        ide_device_info *device;

        TRACE(("\n"));

        //snooze(500000);

        // IRQ handler doesn't tell us whether this bus was in async_wait or
        // in idle state, so we just check whether there is an active request,
        // which means that we were async_waiting
        if (bus->active_qrequest != NULL) {
                TRACE(("continue command\n"));

                // cancel timeout
                cancel_timer(&bus->timer.te);

                qrequest = bus->active_qrequest;
                device = qrequest->device;

                // not perfect but simple: we simply know who is waiting why
                if (device->is_atapi)
                        packet_dpc(qrequest);
                else {
                        if (qrequest->uses_dma)
                                ata_dpc_DMA(qrequest);
                        else
                                ata_dpc_PIO(qrequest);
                }
        } else {
                // no request active, so this must be a service request or
                // a spurious IRQ; access_finished will take care of testing
                // for service requests
                TRACE(("irq in idle mode - possible service request\n"));

                device = get_current_device(bus);
                if (device == NULL) {
                        // got an interrupt from a non-existing device
                        // either this is a spurious interrupt or there *is* a device
                        // but we haven't detected it - we better ignore it silently
                        access_finished(bus, bus->first_device);
                } else {
                        // access_finished always checks the other device first, but as
                        // we do have a service request, we negate the negation
                        access_finished(bus, device->other_device);
                }

                // let XPT resend commands that got blocked
                scsi->cont_send_bus(bus->scsi_cookie);
        }

        return;

/*err:
        xpt->cont_send( bus->xpt_cookie );*/
}


/** handler for IDE IRQs */

status_t
ide_irq_handler(ide_bus_info *bus, uint8 status)
{
        ide_device_info *device;

        // we need to lock bus to have a solid bus state
        // (side effect: we lock out the timeout handler and get
        //  delayed if the IRQ happens at the same time as a command is
        //  issued; in the latter case, we have no official way to determine
        //  whether the command was issued before or afterwards; if it was
        //  afterwards, the device must not be busy; if it was before,
        //  the device is either busy because of the sent command, or it's
        //  not busy as the command has already been finished, i.e. there
        //  was a second IRQ which we've overlooked as we didn't acknowledge
        //  the first IRQ)
        IDE_LOCK(bus);

        device = bus->active_device;

        if (device == NULL) {
                IDE_UNLOCK(bus);

                TRACE(("IRQ though there is no active device\n"));
                return B_UNHANDLED_INTERRUPT;
        }

        if ((status & ide_status_bsy) != 0) {
                // the IRQ seems to be fired before the last command was sent,
                // i.e. it's not the one that signals finishing of command
                IDE_UNLOCK(bus);

                TRACE(("IRQ though device is busy\n"));
                return B_UNHANDLED_INTERRUPT;
        }

        switch (bus->state) {
                case ide_state_async_waiting:
                        TRACE(("state: async waiting\n"));

                        bus->state = ide_state_accessing;

                        IDE_UNLOCK(bus);

                        scsi->schedule_dpc(bus->scsi_cookie, bus->irq_dpc, ide_dpc, bus);
                        return B_INVOKE_SCHEDULER;

                case ide_state_idle:
                        TRACE(("state: idle, num_running_reqs %d\n", bus->num_running_reqs));

                        // this must be a service request;
                        // if no request is pending, the IRQ was fired wrongly
                        if (bus->num_running_reqs == 0) {
                                IDE_UNLOCK(bus);
                                return B_UNHANDLED_INTERRUPT;
                        }

                        bus->state = ide_state_accessing;

                        IDE_UNLOCK(bus);

                        scsi->schedule_dpc(bus->scsi_cookie, bus->irq_dpc, ide_dpc, bus);
                        return B_INVOKE_SCHEDULER;

                case ide_state_sync_waiting:
                        TRACE(("state: sync waiting\n"));

                        bus->state = ide_state_accessing;
                        bus->sync_wait_timeout = false;

                        IDE_UNLOCK(bus);

                        release_sem_etc(bus->sync_wait_sem, 1, B_DO_NOT_RESCHEDULE);
                        return B_INVOKE_SCHEDULER;

                case ide_state_accessing:
                        TRACE(("state: spurious IRQ - there is a command being executed\n"));

                        IDE_UNLOCK(bus);
                        return B_UNHANDLED_INTERRUPT;

                default:
                        dprintf("BUG: unknown state (%d)\n", bus->state);

                        IDE_UNLOCK(bus);

                        return B_UNHANDLED_INTERRUPT;
        }
}


/**     cancel IRQ timeout
 *      it doesn't matter whether there really was a timout running;
 *      on return, bus state is set to _accessing_
 */

void
cancel_irq_timeout(ide_bus_info *bus)
{
        IDE_LOCK(bus);
        bus->state = ide_state_accessing;
        IDE_UNLOCK(bus);

        cancel_timer(&bus->timer.te);
}


/** start waiting for IRQ with bus lock hold
 *      new_state must be either sync_wait or async_wait
 */

void
start_waiting(ide_bus_info *bus, uint32 timeout, int new_state)
{
        int res;

        TRACE(("timeout = %u\n", (uint)timeout));

        bus->state = new_state;

        res = add_timer(&bus->timer.te, ide_timeout,
                (bigtime_t)timeout * 1000000, B_ONE_SHOT_RELATIVE_TIMER);

        if (res != B_OK)
                panic("Error setting timeout (%s)", strerror(res));

        IDE_UNLOCK(bus);
}


/** start waiting for IRQ with bus lock not hold */

void
start_waiting_nolock(ide_bus_info *bus, uint32 timeout, int new_state)
{
        IDE_LOCK(bus);
        start_waiting(bus, timeout, new_state);
}


/** wait for sync IRQ */

void
wait_for_sync(ide_bus_info *bus)
{
        acquire_sem(bus->sync_wait_sem);
        cancel_timer(&bus->timer.te);
}


/** timeout dpc handler */

static void
ide_timeout_dpc(void *arg)
{
        ide_bus_info *bus = (ide_bus_info *)arg;
        ide_qrequest *qrequest;
        ide_device_info *device;

        qrequest = bus->active_qrequest;
        device = qrequest->device;

        dprintf("ide: ide_timeout_dpc() bus %p, device %p\n", bus, device);

        // this also resets overlapped commands
        reset_device(device, qrequest);

        device->subsys_status = SCSI_CMD_TIMEOUT;

        if (qrequest->uses_dma) {
                if (++device->DMA_failures >= MAX_DMA_FAILURES) {
                        dprintf("Disabling DMA because of too many errors\n");

                        device->DMA_enabled = false;
                }
        }

        // let upper layer do the retry
        finish_checksense(qrequest);
}


/** timeout handler, called by system timer */

status_t
ide_timeout(timer *arg)
{
        ide_bus_info *bus = ((ide_bus_timer_info *)arg)->bus;

        TRACE(("ide_timeout(): %p\n", bus));

        dprintf("ide: ide_timeout() bus %p\n", bus);

        // we need to lock bus to have a solid bus state
        // (side effect: we lock out the IRQ handler)
        IDE_LOCK(bus);

        switch (bus->state) {
                case ide_state_async_waiting:
                        TRACE(("async waiting\n"));

                        bus->state = ide_state_accessing;

                        IDE_UNLOCK(bus);

                        scsi->schedule_dpc(bus->scsi_cookie, bus->irq_dpc, ide_timeout_dpc, bus);
                        return B_INVOKE_SCHEDULER;

                case ide_state_sync_waiting:
                        TRACE(("sync waiting\n"));

                        bus->state = ide_state_accessing;
                        bus->sync_wait_timeout = true;

                        IDE_UNLOCK(bus);

                        release_sem_etc(bus->sync_wait_sem, 1, B_DO_NOT_RESCHEDULE);
                        return B_INVOKE_SCHEDULER;

                case ide_state_accessing:
                        TRACE(("came too late - IRQ occured already\n"));

                        IDE_UNLOCK(bus);
                        return B_DO_NOT_RESCHEDULE;

                default:
                        // this case also happens if a timeout fires too late;
                        // unless there is a bug, the timeout should always be canceled
                        // before declaring bus as being idle
                        dprintf("BUG: unknown state (%d)\n", (int)bus->state);

                        IDE_UNLOCK(bus);
                        return B_DO_NOT_RESCHEDULE;
        }
}


void
init_synced_pc(ide_synced_pc *pc, ide_synced_pc_func func)
{
        pc->func = func;
        pc->registered = false;
}


void
uninit_synced_pc(ide_synced_pc *pc)
{
        if (pc->registered)
                panic("Tried to clean up pending synced PC\n");
}


/**     schedule a synced pc
 *      a synced pc gets executed as soon as the bus becomes idle
 */

status_t
schedule_synced_pc(ide_bus_info *bus, ide_synced_pc *pc, void *arg)
{
        //TRACE(());

        IDE_LOCK(bus);

        if (pc->registered) {
                // spc cannot be registered twice
                TRACE(("already registered\n"));
                return B_ERROR;
        } else if( bus->state != ide_state_idle ) {
                // bus isn't idle - spc must be added to pending list
                TRACE(("adding to pending list\n"));

                pc->next = bus->synced_pc_list;
                bus->synced_pc_list = pc;
                pc->arg = arg;
                pc->registered = true;

                IDE_UNLOCK(bus);
                return B_OK;
        }

        // we have luck - bus is idle, so grab it before
        // releasing the lock

        TRACE(("exec immediately\n"));

        bus->state = ide_state_accessing;
        IDE_UNLOCK(bus);

        TRACE(("go\n"));
        pc->func(bus, arg);

        TRACE(("finished\n"));
        access_finished(bus, bus->first_device);

        // meanwhile, we may have rejected SCSI commands;
        // usually, the XPT resends them once a command
        // has finished, but in this case XPT doesn't know
        // about our "private" command, so we have to tell about
        // idle bus manually
        TRACE(("tell SCSI bus manager about idle bus\n"));
        scsi->cont_send_bus(bus->scsi_cookie);
        return B_OK;
}


/** execute list of synced pcs */

static void
exec_synced_pcs(ide_bus_info *bus, ide_synced_pc *pc_list)
{
        ide_synced_pc *pc;

        // noone removes items from pc_list, so we don't need lock
        // to access entries
        for (pc = pc_list; pc; pc = pc->next) {
                pc->func(bus, pc->arg);
        }

        // need lock now as items can be added to pc_list again as soon
        // as <registered> is reset
        IDE_LOCK(bus);

        for (pc = pc_list; pc; pc = pc->next) {
                pc->registered = false;
        }

        IDE_UNLOCK(bus);
}


/**     finish bus access;
 *      check if any device wants to service pending commands + execute synced_pc
 */

void
access_finished(ide_bus_info *bus, ide_device_info *device)
{
        TRACE(("bus = %p, device = %p\n", bus, device));

        while (true) {
                ide_synced_pc *synced_pc_list;

                IDE_LOCK(bus);

                // normally, there is always an device; only exception is a
                // bus without devices, not sure whether this can really happen though
                if (device) {
                        if (try_service(device))
                                return;
                }

                // noone wants it, so execute pending synced_pc
                if (bus->synced_pc_list == NULL) {
                        bus->state = ide_state_idle;
                        IDE_UNLOCK(bus);
                        return;
                }

                synced_pc_list = bus->synced_pc_list;
                bus->synced_pc_list = NULL;

                IDE_UNLOCK(bus);

                exec_synced_pcs(bus, synced_pc_list);

                // executed synced_pc may have generated other sync_pc,
                // thus the loop
        }
}