xref: /netbsd-src/sys/arch/mac68k/dev/grf_compat.c (revision d47bcd296c8b39243dd81e9cc75ea86330d4eeaf)
1 /*	$NetBSD: grf_compat.c,v 1.29 2019/11/10 21:16:29 chs Exp $	*/
2 
3 /*
4  * Copyright (C) 1999 Scott Reynolds
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. The name of the author may not be used to endorse or promote products
16  *    derived from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 /*
31  * macfb compatibility with legacy grf devices
32  */
33 
34 #include "opt_grf_compat.h"
35 
36 #include <sys/cdefs.h>
37 __KERNEL_RCSID(0, "$NetBSD: grf_compat.c,v 1.29 2019/11/10 21:16:29 chs Exp $");
38 
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/conf.h>
42 #include <sys/device.h>
43 #include <sys/errno.h>
44 #include <sys/ioctl.h>
45 #include <sys/malloc.h>
46 #include <sys/proc.h>
47 #include <sys/resourcevar.h>
48 
49 #include <machine/bus.h>
50 #include <machine/grfioctl.h>
51 
52 #include <mac68k/nubus/nubus.h>
53 #include <mac68k/dev/grfvar.h>
54 #include <mac68k/dev/macfbvar.h>
55 
56 #include <miscfs/specfs/specdev.h>
57 
58 #include <uvm/uvm_extern.h>
59 
60 #include "ioconf.h"
61 
62 dev_type_open(grfopen);
63 dev_type_close(grfclose);
64 dev_type_ioctl(grfioctl);
65 dev_type_mmap(grfmmap);
66 
67 const struct cdevsw grf_cdevsw = {
68 	.d_open = grfopen,
69 	.d_close = grfclose,
70 	.d_read = noread,
71 	.d_write = nowrite,
72 	.d_ioctl = grfioctl,
73 	.d_stop = nostop,
74 	.d_tty = notty,
75 	.d_poll = nopoll,
76 	.d_mmap = grfmmap,
77 	.d_kqfilter = nokqfilter,
78 	.d_discard = nodiscard,
79 	.d_flag = 0
80 };
81 
82 void	grf_scinit(struct grf_softc *, const char *, int);
83 void	grf_init(int);
84 int	grfmap(dev_t, struct macfb_softc *, void **, struct proc *);
85 int	grfunmap(dev_t, struct macfb_softc *, void *, struct proc *);
86 
87 /* Non-private for the benefit of libkvm. */
88 struct	grf_softc *grf_softc;
89 int	numgrf = 0;
90 
91 /*
92  * Initialize a softc to sane defaults.
93  */
94 void
grf_scinit(struct grf_softc * sc,const char * name,int unit)95 grf_scinit(struct grf_softc *sc, const char *name, int unit)
96 {
97 	memset(sc, 0, sizeof(struct grf_softc));
98 	snprintf(sc->sc_xname, sizeof(sc->sc_xname), "%s%d", name, unit);
99 	sc->mfb_sc = NULL;
100 }
101 
102 /*
103  * (Re-)initialize the grf_softc block so that at least the requested
104  * number of elements has been allocated.  If this results in more
105  * elements than we had prior to getting here, we initialize each of
106  * them to avoid problems down the road.
107  */
108 void
grf_init(int n)109 grf_init(int n)
110 {
111 	struct grf_softc *sc;
112 	int i;
113 
114 	if (n >= numgrf) {
115 		i = numgrf;
116 		numgrf = n + 1;
117 
118 		if (grf_softc == NULL)
119 			sc = (struct grf_softc *)
120 			    malloc(numgrf * sizeof(*sc),
121 			    M_DEVBUF, M_WAITOK);
122 		else
123 			sc = (struct grf_softc *)
124 			    realloc(grf_softc, numgrf * sizeof(*sc),
125 			    M_DEVBUF, M_WAITOK);
126 		grf_softc = sc;
127 
128 		/* Initialize per-softc structures. */
129 		while (i < numgrf) {
130 			grf_scinit(&grf_softc[i], "grf", i);
131 			i++;
132 		}
133 	}
134 }
135 
136 /*
137  * Called by main() during pseudo-device attachment.  If we had a
138  * way to configure additional grf devices later, this would actually
139  * allocate enough space for them.  As it stands, it's nonsensical,
140  * so other than a basic sanity check we do nothing.
141  */
142 void
grfattach(int n)143 grfattach(int n)
144 {
145 	if (n <= 0) {
146 #ifdef DIAGNOSTIC
147 		panic("grfattach: count <= 0");
148 #endif
149 		return;
150 	}
151 
152 #if 0 /* XXX someday, if we implement a way to attach after autoconfig */
153 	grf_init(n);
154 #endif
155 }
156 
157 /*
158  * Called from macfb_attach() after setting up the frame buffer.  Since
159  * there is a 1:1 correspondence between the macfb device and the grf
160  * device, the only bit of information we really need is the macfb_softc.
161  */
162 void
grf_attach(struct macfb_softc * sc,int unit)163 grf_attach(struct macfb_softc *sc, int unit)
164 {
165 
166 	grf_init(unit);
167 	if (unit < numgrf)
168 		grf_softc[unit].mfb_sc = sc;
169 }
170 
171 /*
172  * Standard device ops
173  */
174 int
grfopen(dev_t dev,int flag,int mode,struct lwp * l)175 grfopen(dev_t dev, int flag, int mode, struct lwp *l)
176 {
177 	struct grf_softc *sc;
178 	int unit = GRFUNIT(dev);
179 	int rv = 0;
180 
181 	if (grf_softc == NULL || unit >= numgrf)
182 		return ENXIO;
183 
184 	sc = &grf_softc[unit];
185 	if (sc->mfb_sc == NULL)
186 		rv = ENXIO;
187 
188 	return rv;
189 }
190 
191 int
grfclose(dev_t dev,int flag,int mode,struct lwp * l)192 grfclose(dev_t dev, int flag, int mode, struct lwp *l)
193 {
194 	struct grf_softc *sc;
195 	int unit = GRFUNIT(dev);
196 	int rv = 0;
197 
198 	if (grf_softc == NULL || unit >= numgrf)
199 		return ENXIO;
200 
201 	sc = &grf_softc[unit];
202 	if (sc->mfb_sc != NULL)
203 		macfb_clear(sc->mfb_sc->sc_dc);	/* clear the display */
204 	else
205 		rv = ENXIO;
206 
207 	return rv;
208 }
209 
210 int
grfioctl(dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)211 grfioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
212 {
213 	struct grf_softc *sc;
214 	struct macfb_devconfig *dc;
215 #if defined(GRF_COMPAT) || (NGRF > 0)
216 	struct grfinfo *gd;
217 #endif /* GRF_COMPAT || (NGRF > 0) */
218 	struct grfmode *gm;
219 	int unit = GRFUNIT(dev);
220 	int rv;
221 
222 	if (grf_softc == NULL || unit >= numgrf)
223 		return ENXIO;
224 
225 	sc = &grf_softc[unit];
226 	if (sc->mfb_sc == NULL)
227 		return ENXIO;
228 
229 	dc = sc->mfb_sc->sc_dc;
230 
231 	switch (cmd) {
232 #if defined(GRF_COMPAT) || (NGRF > 0)
233 	case GRFIOCGINFO:
234 		gd = (struct grfinfo *)data;
235 		memset(gd, 0, sizeof(struct grfinfo));
236 		gd->gd_fbaddr     = (void *)dc->dc_paddr;
237 		gd->gd_fbsize     = dc->dc_size;
238 		gd->gd_colors     = (short)(1 << dc->dc_depth);
239 		gd->gd_planes     = (short)dc->dc_depth;
240 		gd->gd_fbwidth    = dc->dc_wid;
241 		gd->gd_fbheight   = dc->dc_ht;
242 		gd->gd_fbrowbytes = dc->dc_rowbytes;
243 		gd->gd_dwidth     = dc->dc_raster.width;
244 		gd->gd_dheight    = dc->dc_raster.height;
245 		rv = 0;
246 		break;
247 #endif /* GRF_COMPAT || (NGRF > 0) */
248 
249 	case GRFIOCON:
250 	case GRFIOCOFF:
251 		/* Nothing to do */
252 		rv = 0;
253 		break;
254 
255 #if defined(GRF_COMPAT) || (NGRF > 0)
256 	case GRFIOCMAP:
257 		rv = grfmap(dev, sc->mfb_sc, (void **)data, l->l_proc);
258 		break;
259 
260 	case GRFIOCUNMAP:
261 		rv = grfunmap(dev, sc->mfb_sc, *(void **)data, l->l_proc);
262 		break;
263 #endif /* GRF_COMPAT || (NGRF > 0) */
264 
265 	case GRFIOCGMODE:
266 		gm = (struct grfmode *)data;
267 		memset(gm, 0, sizeof(struct grfmode));
268 		gm->fbbase   = (char *)dc->dc_vaddr;
269 		gm->fbsize   = dc->dc_size;
270 		gm->fboff    = dc->dc_offset;
271 		gm->rowbytes = dc->dc_rowbytes;
272 		gm->width    = dc->dc_wid;
273 		gm->height   = dc->dc_ht;
274 		gm->psize    = dc->dc_depth;
275 		rv = 0;
276 		break;
277 
278 	case GRFIOCLISTMODES:
279 	case GRFIOCGETMODE:
280 	case GRFIOCSETMODE:
281 		/* NONE of these operations are (officially) supported. */
282 	default:
283 		rv = EINVAL;
284 		break;
285 	}
286 	return rv;
287 }
288 
289 paddr_t
grfmmap(dev_t dev,off_t off,int prot)290 grfmmap(dev_t dev, off_t off, int prot)
291 {
292 	struct grf_softc *sc;
293 	struct macfb_devconfig *dc;
294 	int unit = GRFUNIT(dev);
295 
296 	if (grf_softc == NULL || unit >= numgrf)
297 		return ENXIO;
298 
299 	sc = &grf_softc[unit];
300 	if (sc->mfb_sc == NULL)
301 		return ENXIO;
302 
303 	dc = sc->mfb_sc->sc_dc;
304 
305 	if ((u_int)off < m68k_round_page(dc->dc_offset + dc->dc_size))
306 		return m68k_btop(dc->dc_paddr + off);
307 
308 	return (-1);
309 }
310 
311 int
grfmap(dev_t dev,struct macfb_softc * sc,void ** addrp,struct proc * p)312 grfmap(dev_t dev, struct macfb_softc *sc, void **addrp, struct proc *p)
313 {
314 	size_t len;
315 	int error;
316 
317 	len = m68k_round_page(sc->sc_dc->dc_offset + sc->sc_dc->dc_size);
318 	error = uvm_mmap_dev(p, addrp, len, dev, 0);
319 
320 	/* Offset into page: */
321 	*addrp = (char *)*addrp + sc->sc_dc->dc_offset;
322 
323 	return (error);
324 }
325 
326 int
grfunmap(dev_t dev,struct macfb_softc * sc,void * addr,struct proc * p)327 grfunmap(dev_t dev, struct macfb_softc *sc, void *addr, struct proc *p)
328 {
329 	size_t size;
330 
331 	addr = (char *)addr - sc->sc_dc->dc_offset;
332 
333 	if (addr <= 0)
334 		return (-1);
335 
336 	size = m68k_round_page(sc->sc_dc->dc_offset + sc->sc_dc->dc_size);
337 	uvm_unmap(&p->p_vmspace->vm_map, (vaddr_t)addr, (vaddr_t)addr + size);
338 	return 0;
339 }
340