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