![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bwtwo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to bwtwo.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)bwtwo.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1986 by Sun Microsystems, Inc.
7: */
8:
9: /*
10: * Sun Two Black & White Board(s) Driver
11: */
12:
13: #include "bwtwo.h"
14:
15: #include "../h/param.h"
16: #include "../h/systm.h"
17: #include "../h/dir.h"
18: #include "../h/user.h"
19: #include "../h/proc.h"
20: #include "../h/buf.h"
21: #include "../h/conf.h"
22: #include "../h/file.h"
23: #include "../h/map.h"
24: #include "../h/vmmac.h"
25:
26: #include "../sun/fbio.h"
27:
28: #include "../machine/pte.h"
29: #include "../machine/mmu.h"
30: #include "../machine/cpu.h"
31:
32: #include "../sundev/mbvar.h"
33: #include "../sundev/bw2reg.h"
34:
35: #ifdef sun3
36: #include "../sun3/eeprom.h"
37: #endif sun3
38:
39: extern char CADDR1[];
40:
41: int copyenpfnum; /* pfnum before shadow memory mapped in */
42: caddr_t copyenvirt = 0; /* virtual address mapped to shadow memory */
43:
44: struct bw2_softc {
45: caddr_t image;
46: } bw2_softc[NBWTWO];
47:
48: #define BW2SIZEX 1152
49: #define BW2SIZEY 900
50: #define BW2SQUARESIZEX 1024
51: #define BW2SQUARESIZEY 1024
52:
53: /*
54: * Driver information for auto-configuration stuff.
55: */
56: int bwtwoprobe(), bwtwoattach(), bwtwointr();
57: struct mb_device *bwtwoinfo[NBWTWO];
58: struct mb_driver bwtwodriver = {
59: bwtwoprobe, 0, bwtwoattach, 0, 0, bwtwointr,
60: sizeof (struct bw2dev) + CLBYTES /* XXX */, "bwtwo", bwtwoinfo, 0, 0, 0,
61: };
62:
63: /*
64: * Only allow opens for writing or reading and writing
65: * because reading is nonsensical.
66: */
67: bwtwoopen(dev, flag)
68: dev_t dev;
69: {
70:
71: fbopen(dev, flag, NBWTWO, bwtwoinfo);
72: }
73:
74: bwtwoclose(dev, flag)
75: dev_t dev;
76: {
77: }
78:
79: /*ARGSUSED*/
80: bwtwommap(dev, off, prot)
81: dev_t dev;
82: off_t off;
83: int prot;
84: {
85: register caddr_t hold;
86: register int unit = minor(dev);
87: int page;
88:
89: hold = bwtwoinfo[unit]->md_addr;
90: bwtwoinfo[unit]->md_addr = bw2_softc[unit].image;
91: page = fbmmap(dev, off, prot, NBWTWO, bwtwoinfo, BW2_FBSIZE);
92: bwtwoinfo[unit]->md_addr = hold;
93: return (page);
94: }
95:
96: /*
97: * Determine if a bwtwo exists at the given address.
98: */
99: /*ARGSUSED*/
100: bwtwoprobe(reg, unit)
101: caddr_t reg;
102: int unit;
103: {
104: #ifdef sun3
105: /*
106: * For the sun3 we have to rely on the machine type since the bits
107: * in the enable register may not be reliable.
108: */
109: int result;
110:
111: /*
112: * XXX - kludge used to get around current mem_rop bug.
113: * We need to have the page before the frame buffer to not have
114: * have any "holes" in them as the mem_rop code will sometimes
115: * access this page. We kludge here to avoid this problem by
116: * increasing the size of area to be mapped by adding CLBYTES
117: * to the device size mapped by the autoconfig code. Here
118: * we remap all but the first page so that the first page map
119: * entry is duplicated and then we bump the virtual address
120: * up by CLBYTES in bwtwoattach().
121: */
122: mapin(&Sysmap[btoc(reg + CLBYTES - KERNELBASE)],
123: (u_int)btoc(reg + CLBYTES),
124: ((*(u_int *)&Sysmap[btoc(reg - KERNELBASE)]) & PG_PFNUM),
125: btoc(BW2_FBSIZE), PG_V | PG_KW);
126:
127: switch (cpu) {
128: case CPU_SUN3_160:
129: result = BW2_FBSIZE;
130: break;
131: case CPU_SUN3_50:
132: result = BW2_FBSIZE;
133: break;
134: case CPU_SUN3_260:
135: result = 0;
136: break;
137: default:
138: result = 0;
139: break;
140: }
141: return (result);
142: #endif sun3
143: #ifdef sun2
144: struct bw2dev *bw2dev = (struct bw2dev *)(reg + CLBYTES); /* XXX */
145: register struct bw2cr *alias1;
146: register struct bw2cr *alias2;
147: short w1;
148: register short w2, wrestore;
149: int result = 0;
150:
151: /*
152: * XXX - kludge used to get around current mem_rop bug.
153: * We need to have the page before the frame buffer to not have
154: * have any "holes" in them as the mem_rop code will sometimes
155: * access this page. We kludge here to avoid this problem by
156: * increasing the size of area to be mapped by adding CLBYTES
157: * to the device size mapped by the autoconfig code. Here
158: * we remap all but the first page so that the first page map
159: * entry is duplicated and then we bump the virtual address
160: * up by CLBYTES above for bw2dev and in bwtwoattach().
161: */
162: mapin(&Sysmap[btoc(reg + CLBYTES - KERNELBASE)],
163: (u_int)btoc(reg + CLBYTES),
164: ((*(u_int *)&Sysmap[btoc(reg - KERNELBASE)]) & PG_PFNUM),
165: btoc(BW2_FBSIZE), PG_V | PG_KW);
166:
167: bw2crmapin(bw2dev);
168: alias1 = &bw2dev->bw2cr;
169: alias2 = alias1 + 1;
170:
171: /*
172: * Two adjacent shorts should be the same because
173: * the control register is replicated every 2 bytes
174: * throughout the control page.
175: */
176: if ((w1 = peek((short *)alias1)) == -1)
177: return (0);
178: wrestore = w1;
179: ((struct bw2cr *)&w1)->vc_copybase = 0xAA & BW2_COPYBASEMASK;
180: if (poke((short *)alias1, w1))
181: return (0);
182: if ((w2 = peek((short *)alias2)) == -1)
183: goto restore;
184: if (w1 != w2)
185: goto restore;
186: ((struct bw2cr *)&w1)->vc_copybase = ~0xAA & BW2_COPYBASEMASK;
187: if (poke((short *)alias1, w1))
188: goto restore;
189: if ((w2 = peek((short *)alias2)) == -1)
190: goto restore;
191: if (w1 != w2)
192: goto restore;
193: result = BW2_FBSIZE;
194: restore:
195: if (poke((short *)alias1, wrestore))
196: panic("bwtwoprobe");
197: return (result);
198: #endif sun2
199: }
200:
201: /*
202: * Set up the softc structure
203: */
204: bwtwoattach(md)
205: register struct mb_device *md;
206: {
207: #ifdef sun2
208: register struct bw2dev *bw2dev;
209: #endif
210: int pfnum;
211: caddr_t fbvirtaddr;
212: caddr_t v;
213: int i;
214:
215: /*
216: * XXX - Last part of mem_rop bug kludge, increase the virtual
217: * address set up by autoconfig by CLBYTES as we have remapped
218: * the first page to be a duplicate in bwtwoprobe().
219: */
220: md->md_addr += CLBYTES;
221:
222: pfnum = getkpgmap(md->md_addr) & PG_PFNUM;
223: #ifdef sun3
224: /*
225: * If we are on a SUN3_50 (Model 25), then we must
226: * reserve the on board memory for the frame buffer.
227: */
228: if (cpu == CPU_SUN3_50) {
229: if (fbobmemavail == 0)
230: panic("No video memory");
231: else
232: fbobmemavail = 0;
233: }
234: #endif sun3
235:
236: /*
237: * Have we passed this way before?
238: */
239: if (fbobmemavail == 0) {
240: if (copyenvirt == 0) {
241: copyenvirt = (caddr_t)(*romp->v_fbaddr);
242: if (pfnum == copyenpfnum)
243: bw2_softc[md->md_unit].image = copyenvirt;
244: else
245: bw2_softc[md->md_unit].image = md->md_addr;
246: }
247: return;
248: }
249:
250: /*
251: * We know that the copy memory can be used. Use the
252: * shadow memory if the config flags say to use it.
253: */
254: if ((md->md_flags & BW2_USECOPYMEM) == 0) {
255: /* don't bother using reserved shadow memory */
256: copyenvirt = md->md_addr;
257: bw2_softc[md->md_unit].image = md->md_addr;
258: return;
259: }
260:
261: /*
262: * Mark the onboard frame buffer memory as not available
263: * anymore as we are going to use it for copy memory.
264: */
265: fbobmemavail = 0;
266:
267: if (*romp->v_outsink != OUTSCREEN || *romp->v_fbtype != FBTYPE_SUN2BW)
268: fbvirtaddr = (caddr_t)md->md_addr;
269: else {
270: rmfree(kernelmap, (long)btoc(BW2_FBSIZE),
271: btokmx((struct pte *)(md->md_addr)));
272: mapout(&Usrptmap[btokmx((struct pte *)(md->md_addr))],
273: btoc(BW2_FBSIZE));
274: fbvirtaddr = (caddr_t)(*romp->v_fbaddr);
275: }
276: copyenvirt = fbvirtaddr;
277: copyenpfnum = getkpgmap(fbvirtaddr) & PG_PFNUM;
278:
279: /*
280: * Copy the current frame buffer memory
281: * to the copy memory as we map it in.
282: */
283: for (v = (caddr_t)fbvirtaddr, i = btop(OBFBADDR);
284: i < btop(OBFBADDR + BW2_FBSIZE); v += NBPG, i++) {
285: mapin(CMAP1, btop(CADDR1),
286: (u_int)(i | PGT_OBMEM), 1, PG_V | PG_KW);
287: bcopy(v, CADDR1, NBPG);
288: setpgmap(v, (long)(PG_V|PG_KW|PGT_OBMEM|i));
289: }
290:
291: #ifdef sun2
292: bw2dev = (struct bw2dev *)md->md_addr;
293: i = (OBFBADDR>>BW2_COPYSHIFT) | BW2_COPYENABLEMASK;
294: (void) bwtwosetcr(&bw2dev->bw2cr, i, 1);
295: #endif sun2
296: #ifdef sun3
297: setcopyenable();
298: #endif
299: if (pfnum == copyenpfnum)
300: bw2_softc[md->md_unit].image = copyenvirt;
301: else
302: bw2_softc[md->md_unit].image = md->md_addr;
303: }
304:
305: /*ARGSUSED*/
306: bwtwoioctl(dev, cmd, data, flag)
307: dev_t dev;
308: caddr_t data;
309: {
310: register int unit = minor(dev);
311:
312: switch (cmd) {
313:
314: case FBIOGTYPE: {
315: register struct fbtype *fb = (struct fbtype *)data;
316: #ifdef sun2
317: register struct bw2dev *bw2dev =
318: (struct bw2dev *)bwtwoinfo[unit]->md_addr;
319: #endif
320: fb->fb_type = FBTYPE_SUN2BW;
321: fb->fb_depth = 1;
322: fb->fb_cmsize = 2;
323: fb->fb_size = BW2_FBSIZE;
324: #ifdef sun3
325: /*
326: * Look at the eeprom for screen configuration,
327: * if unknown default to standard sizes.
328: */
329: switch (EEPROM->ee_diag.eed_scrsize) {
330: case EED_SCR_1024X1024:
331: fb->fb_height = BW2SQUARESIZEY;
332: fb->fb_width = BW2SQUARESIZEX;
333: break;
334:
335: case EED_SCR_1152X900:
336: default:
337: fb->fb_height = BW2SIZEY;
338: fb->fb_width = BW2SIZEX;
339: break;
340: }
341: #endif sun3
342: #ifdef sun2
343: /*
344: * Check for "square screen" jumper
345: */
346: if (cpu != CPU_SUN2_120 && bwtwoinfo[unit]->md_unit == 0 &&
347: bw2dev->bw2cr.vc_1024_jumper) {
348: fb->fb_height = BW2SQUARESIZEY;
349: fb->fb_width = BW2SQUARESIZEX;
350: } else {
351: fb->fb_height = BW2SIZEY;
352: fb->fb_width = BW2SIZEX;
353: }
354: #endif sun2
355: break;
356: }
357:
358: default:
359: u.u_error = ENOTTY;
360: }
361: }
362:
363: bwtwointr()
364: {
365: int bwtwointclear();
366:
367: return (fbintr(NBWTWO, bwtwoinfo, bwtwointclear));
368: }
369:
370: /*
371: * Turn off interrupts on bwtwo board.
372: */
373: #ifdef sun3
374: /*ARGSUSED*/
375: bwtwointclear(bw2dev)
376: struct bw2dev *bw2dev;
377: {
378:
379: (void) setintrenable(0);
380: return (0);
381: }
382: #endif sun3
383:
384: #ifdef sun2
385: bwtwointclear(bw2dev)
386: struct bw2dev *bw2dev;
387: {
388: int int_active;
389:
390: int_active = bw2dev->bw2cr.vc_int;
391: (void) setintrenable(&bw2dev->bw2cr);
392: return (int_active);
393: }
394:
395: setvideoenable(bw2cr)
396: struct bw2cr *bw2cr;
397: {
398:
399: bwtwosetcr(bw2cr, BW2_VIDEOENABLEMASK, 1);
400: }
401:
402: setintrenable(bw2cr)
403: struct bw2cr *bw2cr;
404: {
405:
406: bwtwosetcr(bw2cr, BW2_INTENABLEMASK, 0);
407: }
408:
409: /*
410: * Special access approach to video ctrl register needed because byte writes,
411: * generated when do bit writes, replicates itself on the subsequent byte as
412: * well (this is a hardware bug). Thus, we need to access the register as a
413: * word. Also these routines assume that only one bit changes at a time.
414: */
415: bwtwosetcr(bw2cr, mask, value)
416: struct bw2cr *bw2cr;
417: short mask;
418: int value;
419: {
420: register short w;
421:
422: /*
423: * Read word from video control register.
424: */
425: w = *((short *)bw2cr);
426: /*
427: * Modify bit as requested.
428: */
429: if (value)
430: w |= mask;
431: else
432: w &= ~mask;
433: /*
434: * Write word back to video control register.
435: */
436: *((short *)bw2cr) = w;
437: return;
438: }
439: #endif sun2
440:
441: #ifndef sun3
442: /*
443: * Given the video base virtual address,
444: * map in the control register address.
445: * This lets us handle minor implementation differences.
446: */
447: bw2crmapin(bw2dev)
448: struct bw2dev *bw2dev;
449: {
450: struct bw2cr *bw2cr = &bw2dev->bw2cr;
451: int pte = getkpgmap((caddr_t)bw2dev);
452: int page, delta;
453:
454: page = pte & PGT_MASK;
455:
456: if (page == PGT_OBMEM)
457: delta = (int)BW2MB_CR - (int)BW2MB_FB;
458: else if (page == PGT_OBIO)
459: delta = (int)BW2VME_CR - (int)BW2VME_FB;
460: else
461: panic("bwtwocraddr");
462:
463: mapin(&Sysmap[btoc((u_int)bw2cr - KERNELBASE)], btoc(bw2cr),
464: pte + btoc(delta), 1, PG_V | (pte & PG_PROT));
465: }
466: #endif !sun3
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.