OpenSolaris_b135/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,
(void *)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)
{
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
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;
#if defined(lint)
dip = dip;
#endif
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;
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
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)
{
#if defined(lint)
dip = dip;
#endif
/* 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)
{
#if defined(lint)
dip = dip;
#endif
dprintf(("i_dmae_get_chan_stat: channel %d", chnl));
d37A_get_chan_stat(chnl, addressp, countp);
}