xref: /illumos-gate/usr/src/uts/common/io/dma_engine.c (revision 7c478bd9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
30 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
31 /*	  All Rights Reserved  	*/
32 
33 /*
34  * This is the implementation of the kernel DMA interface for the
35  * AT Class machines using Intel 8237A DMAC.
36  *
37  * The following routines in the interface are implemented:
38  *	i_dmae_init()
39  *	_dmae_nxcookie()
40  *	i_dmae_acquire()
41  *	i_dmae_free()
42  *	i_dmae_prog()
43  *	i_dmae_swsetup()
44  *	i_dmae_swstart()
45  *	i_dmae_stop()
46  *	i_dmae_enable()
47  *	i_dmae_disable()
48  *	i_dmae_get_best_mode()
49  *	i_dmae_get_chan_stat()
50  *
51  */
52 
53 #include <sys/types.h>
54 #include <sys/param.h>
55 #include <sys/buf.h>
56 #include <sys/kmem.h>
57 #include <sys/sunddi.h>
58 #include <sys/cmn_err.h>
59 #include <sys/dma_engine.h>
60 #include <sys/dma_i8237A.h>
61 
62 #ifdef DEBUG
63 #include <sys/promif.h>
64 static int dmaedebug = 0;
65 #define	dprintf(x)	if (dmaedebug) prom_printf x
66 #else
67 #define	dprintf(x)
68 #endif
69 
70 
71 static struct dmae_chnl dmae_stat[NCHANS];
72 static uintptr_t dmae_call_list[NCHANS] = {0, 0, 0, 0, 0, 0, 0, 0};
73 
74 /*
75  *  routine: i_dmae_init()
76  *  purpose: called to initialize the dma interface, the DMAC, and any
77  *           dma data structures. Called during system initialization.
78  *  caller:  main()
79  *  calls:   d37A_init()
80  */
81 
82 int
i_dmae_init(dev_info_t * dip)83 i_dmae_init(dev_info_t *dip)
84 {
85 	int chnl;
86 
87 	dprintf(("i_dmae_init: initializing dma.\n"));
88 
89 	/* initialize semaphore map */
90 	for (chnl = 0; chnl < NCHANS; chnl++) {
91 		sema_init(&dmae_stat[chnl].dch_lock, 1, NULL, SEMA_DRIVER,
92 		    (void *)NULL);
93 	}
94 	return (d37A_init(dip));
95 }
96 
97 
98 /*
99  *  routine: i_dmae_acquire()
100  *  purpose: Request the semaphore for the indicated channel.
101  *           A call_back function can be passed if caller does/cannot
102  *           wait for the semaphore.
103  *  caller:  drivers
104  *  calls:   sema_p(), sema_tryp(), ddi_set_callback()
105  */
106 int
i_dmae_acquire(dev_info_t * dip,int chnl,int (* dmae_waitfp)(),caddr_t arg)107 i_dmae_acquire(dev_info_t *dip, int chnl, int (*dmae_waitfp)(), caddr_t arg)
108 {
109 #if defined(lint)
110 	dip = dip;
111 #endif
112 	dprintf(("i_dmae_acquire: channel %d, waitfp %p\n",
113 	    chnl, (void *)dmae_waitfp));
114 
115 	if (!d37A_dma_valid(chnl))
116 		return (DDI_FAILURE);
117 
118 	if (dmae_waitfp == DDI_DMA_SLEEP) {
119 		sema_p(&dmae_stat[chnl].dch_lock);
120 	} else if (sema_tryp(&dmae_stat[chnl].dch_lock) == 0) {
121 		if (dmae_waitfp == DDI_DMA_DONTWAIT) {
122 			dprintf(("_dma_acquire: channel %d is busy.\n", chnl));
123 		} else {
124 			ddi_set_callback(dmae_waitfp, arg,
125 			    &dmae_call_list[chnl]);
126 		}
127 		return (DDI_DMA_NORESOURCES);
128 	}
129 
130 	/*
131 	 * XXX -  save dip for authentication later ??
132 	 */
133 	dprintf(("_dma_acquire: channel %d now allocated.\n", chnl));
134 	return (DDI_SUCCESS);
135 }
136 
137 
138 /*
139  *  routine: i_dmae_free()
140  *  purpose: Release the channel semaphore on chnl. Assumes caller actually
141  *           owns the semaphore (no check made for this).
142  *  caller:  drivers
143  *  calls:   none
144  */
145 
146 int
i_dmae_free(dev_info_t * dip,int chnl)147 i_dmae_free(dev_info_t *dip, int chnl)
148 {
149 #if defined(lint)
150 	dip = dip;
151 #endif
152 	dprintf(("i_dmae_free: channel %d\n", chnl));
153 
154 	d37A_dma_release(chnl);
155 	/*
156 	 * XXX - should dip be authenticated as the one that did acquire?
157 	 */
158 	sema_v(&dmae_stat[chnl].dch_lock);
159 
160 	if (dmae_call_list[chnl])
161 		ddi_run_callback(&dmae_call_list[chnl]);
162 	return (DDI_SUCCESS);
163 }
164 
165 /*
166  *  routine: i_dmae_get_best_mode()
167  *  purpose: confirm that data is aligned for efficient flyby mode
168  *  caller:  driver routines.
169  *  calls:   d37A_get_best_mode.
170  */
171 
172 uchar_t
i_dmae_get_best_mode(dev_info_t * dip,struct ddi_dmae_req * dmaereqp)173 i_dmae_get_best_mode(dev_info_t *dip, struct ddi_dmae_req *dmaereqp)
174 {
175 #if defined(lint)
176 	dip = dip;
177 #endif
178 	return (d37A_get_best_mode(dmaereqp));
179 }
180 
181 /*
182  *  routine: _dmae_nxcookie()
183  *  purpose: service the interrupt by calling device driver routine for next
184  *		DMA cookie.
185  *  caller:  d37A_intr()
186  *  calls:   routine provided in request structure
187  */
188 
189 ddi_dma_cookie_t *
_dmae_nxcookie(int chnl)190 _dmae_nxcookie(int chnl)
191 {
192 	ddi_dma_cookie_t *cookiep = NULL;
193 
194 	dprintf(("_dmae_nxcookie: chnl %d\n", chnl));
195 
196 	if (dmae_stat[chnl].proc) {
197 
198 		cookiep = dmae_stat[chnl].proc(dmae_stat[chnl].procparms);
199 		/*
200 		 * expect a cookie pointer from user's routine;
201 		 * null cookie pointer will terminate chaining
202 		 */
203 	}
204 	return (cookiep);
205 }
206 
207 
208 /*
209  *  routine: i_dmae_prog()
210  *  purpose: Program channel for the to_be_initiated_by_hardware operation.
211  *           _dma_acquire is called to request the channel semaphore and
212  *	     mode is passed as the sleep parameter.
213  *	     The channel is enabled after it is setup.
214  *	     Note that the ddi_dmae_req pointer can be to NULL if the mode
215  *	     registers have already been setup by a prior call; this implements
216  *	     a prog_next() to update the address and count registers.
217  *  caller:  driver routines
218  *  calls:   d37A_prog_chan()
219  */
220 
221 int
i_dmae_prog(dev_info_t * dip,struct ddi_dmae_req * dmaereqp,ddi_dma_cookie_t * cp,int chnl)222 i_dmae_prog(dev_info_t *dip, struct ddi_dmae_req *dmaereqp,
223     ddi_dma_cookie_t *cp, int chnl)
224 {
225 	struct dmae_chnl *dcp;
226 	int rval;
227 
228 #if defined(lint)
229 	dip = dip;
230 #endif
231 	rval = d37A_prog_chan(dmaereqp, cp, chnl);
232 	if (rval != DDI_SUCCESS) {
233 		dprintf(("i_dmae_prog: failure on channel %d dmaereq=%p\n",
234 		    chnl, (void *)dmaereqp));
235 	} else {
236 		dprintf(("i_dmae_prog: channel %d dmaereq=%p\n",
237 		    chnl, (void *)dmaereqp));
238 		dcp = &dmae_stat[chnl];
239 		dcp->dch_cookiep = cp;
240 		if (dmaereqp) {
241 			dcp->proc = dmaereqp->proc;
242 			dcp->procparms = dmaereqp->procparms;
243 		}
244 		d37A_dma_enable(chnl);
245 	}
246 	return (rval);
247 }
248 
249 
250 /*
251  *  routine: i_dmae_swsetup()
252  *  purpose: Setup chan for the operation given in dmacbptr.
253  *           _dma_acquire is first called
254  *           to request the channel semaphore for chnl; mode is
255  *           passed to _dma_acquire().
256  *  caller:  driver routines
257  *  calls:   d37A_dma_swsetup()
258  */
259 
260 int
i_dmae_swsetup(dev_info_t * dip,struct ddi_dmae_req * dmaereqp,ddi_dma_cookie_t * cp,int chnl)261 i_dmae_swsetup(dev_info_t *dip, struct ddi_dmae_req *dmaereqp,
262     ddi_dma_cookie_t *cp, int chnl)
263 {
264 	struct dmae_chnl *dcp;
265 	int rval;
266 
267 #if defined(lint)
268 	dip = dip;
269 #endif
270 	rval = d37A_dma_swsetup(dmaereqp, cp, chnl);
271 	if (rval != DDI_SUCCESS) {
272 		dprintf(("i_dmae_swsetup: failure on channel %d dmaereq=%p\n",
273 		    chnl, (void *)dmaereqp));
274 	} else {
275 		dprintf(("i_dmae_swsetup: channel %d: dmaereq=%p\n",
276 		    chnl, (void *)dmaereqp));
277 		dcp = &dmae_stat[chnl];
278 		dcp->dch_cookiep = cp;
279 		dcp->proc = dmaereqp->proc;
280 		dcp->procparms = dmaereqp->procparms;
281 	}
282 	return (rval);
283 }
284 
285 
286 /*
287  *  routine: i_dmae_swstart()
288  *  purpose: Start the operation setup by i_dmae_swsetup().
289  *  caller:  driver routines
290  *  calls:   d37A_dma_swstart().
291  */
292 
293 void
i_dmae_swstart(dev_info_t * dip,int chnl)294 i_dmae_swstart(dev_info_t *dip, int chnl)
295 {
296 #if defined(lint)
297 	dip = dip;
298 #endif
299 	dprintf(("i_dmae_swstart: channel %d.\n", chnl));
300 
301 	d37A_dma_swstart(chnl);
302 }
303 
304 
305 /*
306  *  routine: i_dmae_stop()
307  *  purpose: stop DMA activity on chnl.
308  *  caller:  driver routines
309  *  calls:   splhi(), _dma_relse(), splx(),
310  *           d37A_dma_stop().
311  */
312 
313 void
i_dmae_stop(dev_info_t * dip,int chnl)314 i_dmae_stop(dev_info_t *dip, int chnl)
315 {
316 #if defined(lint)
317 	dip = dip;
318 #endif
319 	dprintf(("i_dmae_stop: channel %d\n", chnl));
320 
321 	/* call d37A the stop the channel */
322 	d37A_dma_stop(chnl);
323 
324 	dmae_stat[chnl].dch_cookiep = NULL;
325 }
326 
327 
328 /*
329  *  routine: i_dmae_enable()
330  *  purpose: Allow the hardware tied to channel chnl to request service
331  *           from the DMAC. i_dmae_prog() should have been called prior
332  *           to this.
333  *  caller:  driver routines.
334  *  calls:   d37A_dma_enable()
335  */
336 
337 void
i_dmae_enable(dev_info_t * dip,int chnl)338 i_dmae_enable(dev_info_t *dip, int chnl)
339 {
340 #if defined(lint)
341 	dip = dip;
342 #endif
343 	dprintf(("i_dmae_enable: channel %d\n", chnl));
344 
345 	d37A_dma_enable(chnl);
346 }
347 
348 
349 /*
350  *  routine: i_dmae_disable()
351  *  purpose: Called to mask off hardware requests on channel chnl. Assumes
352  *           the caller owns the channel.
353  *  caller:  driver routines.
354  *  calls:   d37A_dma_disable()
355  */
356 
357 void
i_dmae_disable(dev_info_t * dip,int chnl)358 i_dmae_disable(dev_info_t *dip, int chnl)
359 {
360 #if defined(lint)
361 	dip = dip;
362 #endif
363 	/* dprintf(("i_dmae_disable: disable channel %d.\n", chnl)); */
364 
365 	d37A_dma_disable(chnl);
366 
367 	dmae_stat[chnl].dch_cookiep = NULL;
368 }
369 
370 
371 /*
372  *  routine: i_dmae_get_chan_stat()
373  *  purpose: Obtain the current channel status from the DMAC
374  *  caller:  driver routines.
375  *  calls:   d37A_get_chan_stat()
376  */
377 
378 void
i_dmae_get_chan_stat(dev_info_t * dip,int chnl,ulong_t * addressp,int * countp)379 i_dmae_get_chan_stat(dev_info_t *dip, int chnl, ulong_t *addressp, int *countp)
380 {
381 #if defined(lint)
382 	dip = dip;
383 #endif
384 	dprintf(("i_dmae_get_chan_stat: channel %d", chnl));
385 
386 	d37A_get_chan_stat(chnl, addressp, countp);
387 }
388