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