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