Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / dma_engine.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*      Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
/*      Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T   */
/*        All Rights Reserved   */

/*
 * This is the implementation of the kernel DMA interface for the
 * AT Class machines using Intel 8237A DMAC.
 *
 * The following routines in the interface are implemented:
 *      i_dmae_init()
 *      _dmae_nxcookie()
 *      i_dmae_acquire()
 *      i_dmae_free()
 *      i_dmae_prog()
 *      i_dmae_swsetup()
 *      i_dmae_swstart()
 *      i_dmae_stop()
 *      i_dmae_enable()
 *      i_dmae_disable()
 *      i_dmae_get_best_mode()
 *      i_dmae_get_chan_stat()
 *
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/kmem.h>
#include <sys/sunddi.h>
#include <sys/cmn_err.h>
#include <sys/dma_engine.h>
#include <sys/dma_i8237A.h>

#ifdef DEBUG
#include <sys/promif.h>
static int dmaedebug = 0;
#define dprintf(x)      if (dmaedebug) prom_printf x
#else
#define dprintf(x)
#endif


static struct dmae_chnl dmae_stat[NCHANS];
static uintptr_t dmae_call_list[NCHANS] = {0, 0, 0, 0, 0, 0, 0, 0};

/*
 *  routine: i_dmae_init()
 *  purpose: called to initialize the dma interface, the DMAC, and any
 *           dma data structures. Called during system initialization.
 *  caller:  main()
 *  calls:   d37A_init()
 */

int
i_dmae_init(dev_info_t *dip)
{
        int chnl;

        dprintf(("i_dmae_init: initializing dma.\n"));

        /* initialize semaphore map */
        for (chnl = 0; chnl < NCHANS; chnl++) {
                sema_init(&dmae_stat[chnl].dch_lock, 1, NULL, SEMA_DRIVER,
                    NULL);
        }
        return (d37A_init(dip));
}


/*
 *  routine: i_dmae_acquire()
 *  purpose: Request the semaphore for the indicated channel.
 *           A call_back function can be passed if caller does/cannot
 *           wait for the semaphore.
 *  caller:  drivers
 *  calls:   sema_p(), sema_tryp(), ddi_set_callback()
 */
int
i_dmae_acquire(dev_info_t *dip, int chnl, int (*dmae_waitfp)(), caddr_t arg)
{
        dprintf(("i_dmae_acquire: channel %d, waitfp %p\n",
            chnl, (void *)dmae_waitfp));

        if (!d37A_dma_valid(chnl))
                return (DDI_FAILURE);

        if (dmae_waitfp == DDI_DMA_SLEEP) {
                sema_p(&dmae_stat[chnl].dch_lock);
        } else if (sema_tryp(&dmae_stat[chnl].dch_lock) == 0) {
                if (dmae_waitfp == DDI_DMA_DONTWAIT) {
                        dprintf(("_dma_acquire: channel %d is busy.\n", chnl));
                } else {
                        ddi_set_callback(dmae_waitfp, arg,
                            &dmae_call_list[chnl]);
                }
                return (DDI_DMA_NORESOURCES);
        }

        /*
         * XXX -  save dip for authentication later ??
         */
        dprintf(("_dma_acquire: channel %d now allocated.\n", chnl));
        return (DDI_SUCCESS);
}


/*
 *  routine: i_dmae_free()
 *  purpose: Release the channel semaphore on chnl. Assumes caller actually
 *           owns the semaphore (no check made for this).
 *  caller:  drivers
 *  calls:   none
 */

int
i_dmae_free(dev_info_t *dip, int chnl)
{
        dprintf(("i_dmae_free: channel %d\n", chnl));

        d37A_dma_release(chnl);
        /*
         * XXX - should dip be authenticated as the one that did acquire?
         */
        sema_v(&dmae_stat[chnl].dch_lock);

        if (dmae_call_list[chnl])
                ddi_run_callback(&dmae_call_list[chnl]);
        return (DDI_SUCCESS);
}

/*
 *  routine: i_dmae_get_best_mode()
 *  purpose: confirm that data is aligned for efficient flyby mode
 *  caller:  driver routines.
 *  calls:   d37A_get_best_mode.
 */

uchar_t
i_dmae_get_best_mode(dev_info_t *dip, struct ddi_dmae_req *dmaereqp)
{
        return (d37A_get_best_mode(dmaereqp));
}

/*
 *  routine: _dmae_nxcookie()
 *  purpose: service the interrupt by calling device driver routine for next
 *              DMA cookie.
 *  caller:  d37A_intr()
 *  calls:   routine provided in request structure
 */

ddi_dma_cookie_t *
_dmae_nxcookie(int chnl)
{
        ddi_dma_cookie_t *cookiep = NULL;

        dprintf(("_dmae_nxcookie: chnl %d\n", chnl));

        if (dmae_stat[chnl].proc) {

                cookiep = dmae_stat[chnl].proc(dmae_stat[chnl].procparms);
                /*
                 * expect a cookie pointer from user's routine;
                 * null cookie pointer will terminate chaining
                 */
        }
        return (cookiep);
}


/*
 *  routine: i_dmae_prog()
 *  purpose: Program channel for the to_be_initiated_by_hardware operation.
 *           _dma_acquire is called to request the channel semaphore and
 *           mode is passed as the sleep parameter.
 *           The channel is enabled after it is setup.
 *           Note that the ddi_dmae_req pointer can be to NULL if the mode
 *           registers have already been setup by a prior call; this implements
 *           a prog_next() to update the address and count registers.
 *  caller:  driver routines
 *  calls:   d37A_prog_chan()
 */

int
i_dmae_prog(dev_info_t *dip, struct ddi_dmae_req *dmaereqp,
    ddi_dma_cookie_t *cp, int chnl)
{
        struct dmae_chnl *dcp;
        int rval;

        rval = d37A_prog_chan(dmaereqp, cp, chnl);
        if (rval != DDI_SUCCESS) {
                dprintf(("i_dmae_prog: failure on channel %d dmaereq=%p\n",
                    chnl, (void *)dmaereqp));
        } else {
                dprintf(("i_dmae_prog: channel %d dmaereq=%p\n",
                    chnl, (void *)dmaereqp));
                dcp = &dmae_stat[chnl];
                dcp->dch_cookiep = cp;
                if (dmaereqp) {
                        dcp->proc = dmaereqp->proc;
                        dcp->procparms = dmaereqp->procparms;
                }
                d37A_dma_enable(chnl);
        }
        return (rval);
}


/*
 *  routine: i_dmae_swsetup()
 *  purpose: Setup chan for the operation given in dmacbptr.
 *           _dma_acquire is first called
 *           to request the channel semaphore for chnl; mode is
 *           passed to _dma_acquire().
 *  caller:  driver routines
 *  calls:   d37A_dma_swsetup()
 */

int
i_dmae_swsetup(dev_info_t *dip, struct ddi_dmae_req *dmaereqp,
    ddi_dma_cookie_t *cp, int chnl)
{
        struct dmae_chnl *dcp;
        int rval;

        rval = d37A_dma_swsetup(dmaereqp, cp, chnl);
        if (rval != DDI_SUCCESS) {
                dprintf(("i_dmae_swsetup: failure on channel %d dmaereq=%p\n",
                    chnl, (void *)dmaereqp));
        } else {
                dprintf(("i_dmae_swsetup: channel %d: dmaereq=%p\n",
                    chnl, (void *)dmaereqp));
                dcp = &dmae_stat[chnl];
                dcp->dch_cookiep = cp;
                dcp->proc = dmaereqp->proc;
                dcp->procparms = dmaereqp->procparms;
        }
        return (rval);
}


/*
 *  routine: i_dmae_swstart()
 *  purpose: Start the operation setup by i_dmae_swsetup().
 *  caller:  driver routines
 *  calls:   d37A_dma_swstart().
 */

void
i_dmae_swstart(dev_info_t *dip, int chnl)
{
        dprintf(("i_dmae_swstart: channel %d.\n", chnl));

        d37A_dma_swstart(chnl);
}


/*
 *  routine: i_dmae_stop()
 *  purpose: stop DMA activity on chnl.
 *  caller:  driver routines
 *  calls:   splhi(), _dma_relse(), splx(),
 *           d37A_dma_stop().
 */

void
i_dmae_stop(dev_info_t *dip, int chnl)
{
        dprintf(("i_dmae_stop: channel %d\n", chnl));

        /* call d37A the stop the channel */
        d37A_dma_stop(chnl);

        dmae_stat[chnl].dch_cookiep = NULL;
}


/*
 *  routine: i_dmae_enable()
 *  purpose: Allow the hardware tied to channel chnl to request service
 *           from the DMAC. i_dmae_prog() should have been called prior
 *           to this.
 *  caller:  driver routines.
 *  calls:   d37A_dma_enable()
 */

void
i_dmae_enable(dev_info_t *dip, int chnl)
{
        dprintf(("i_dmae_enable: channel %d\n", chnl));

        d37A_dma_enable(chnl);
}


/*
 *  routine: i_dmae_disable()
 *  purpose: Called to mask off hardware requests on channel chnl. Assumes
 *           the caller owns the channel.
 *  caller:  driver routines.
 *  calls:   d37A_dma_disable()
 */

void
i_dmae_disable(dev_info_t *dip, int chnl)
{
        /* dprintf(("i_dmae_disable: disable channel %d.\n", chnl)); */

        d37A_dma_disable(chnl);

        dmae_stat[chnl].dch_cookiep = NULL;
}


/*
 *  routine: i_dmae_get_chan_stat()
 *  purpose: Obtain the current channel status from the DMAC
 *  caller:  driver routines.
 *  calls:   d37A_get_chan_stat()
 */

void
i_dmae_get_chan_stat(dev_info_t *dip, int chnl, ulong_t *addressp, int *countp)
{
        dprintf(("i_dmae_get_chan_stat: channel %d", chnl));

        d37A_get_chan_stat(chnl, addressp, countp);
}