![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun-cgtwo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / machine / sun|
Return to sun-cgtwo.c CVS log | Up to [The Machine Emulator] / tme / machine / sun |
1.1 root 1: /* $Id: sun-cgtwo.c,v 1.2 2005/05/09 02:01:02 fredette Exp $ */
2:
3: /* machine/sun/sun-cgtwo.c - Sun cgtwo emulation: */
4:
5: /*
6: * Copyright (c) 2003, 2004, 2005 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: sun-cgtwo.c,v 1.2 2005/05/09 02:01:02 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/machine/sun.h>
41: #include <tme/generic/bus-device.h>
42: #include <tme/generic/fb.h>
43: #include "sun-fb.h"
44:
45: /* macros: */
46:
47: /* cgtwo types: */
48: #define TME_SUNCG2_TYPE_NULL (0)
49: #define TME_SUNCG2_TYPE_SUN3 (1)
50:
51: /* a cgtwo has eight planes: */
52: #define TME_SUNCG2_PLANE_MAX (8)
53:
54: /* every rasterop unit has its alternate, prime registers: */
55: #define TME_SUNCG2_ROPC_PRIME (9)
56:
57: /* every so many CSR reads, we fake a retrace: */
58: #define TME_SUNCG2_CYCLE_RETRACE (10)
59:
60: /* this gives the index into the entire colormap of a pixel's
61: intensity for a given primary: */
62: #define TME_SUNCG2_CMAP_INDEX(pixel, primary) ((((primary) - TME_SUNCG2_REG_CMAP_R) / sizeof(tme_uint16_t)) + (pixel))
63:
64: /* this gives a pixel's intensity for a given primary: */
65: #define TME_SUNCG2_CMAP_VALUE(suncg2, pixel, primary) \
66: (tme_betoh_u16((suncg2)->tme_suncg2_cmap_raw[TME_SUNCG2_CMAP_INDEX(pixel, primary)]) & 0xff)
67:
68: /* a plane bitmap has one bit per pixel: */
69: #define TME_SUNCG2_REG_BITMAP(x) (0x000000 + (TME_SUNCG2_SIZ_BITMAP * (x)))
70: #define TME_SUNCG2_SIZ_BITMAP ((1024 * 1024) / 8)
71:
72: /* the pixmap has one byte per pixel: */
73: #define TME_SUNCG2_REG_PIXMAP (0x100000)
74: #define TME_SUNCG2_SIZ_PIXMAP (1024 * 1024)
75:
76: /* the raster op data: */
77: #define TME_SUNCG2_REG_ROP_DATA (0x200000)
78:
79: /* register offsets and sizes. many registers are decoded at all
80: size-aligned addresses within a 4KB page: */
81: #define TME_SUNCG2_SIZ_REG_PAGE (0x001000)
82: #define TME_SUNCG2_REG_ROPC_UNIT(x) (0x300000 + ((x) * TME_SUNCG2_SIZ_REG_PAGE))
83: #define TME_SUNCG2_REG_ROPC_UNIT_PRIME(x) (TME_SUNCG2_REG_ROPC_UNIT(x) + 0x000800)
84: #define TME_SUNCG2_REG_CSR (0x309000)
85: #define TME_SUNCG2_REG_PLANE_MASK (0x30a000)
86: #define TME_SUNCG2_REG_SUN2_PAN_HI (0x30b000)
87: #define TME_SUNCG2_REG_SUN3_DOUBLE_BUF (0x30b000)
88: #define TME_SUNCG2_REG_SUN2_ZOOM (0x30c000)
89: #define TME_SUNCG2_REG_SUN3_DMA_BASE (0x30c000)
90: #define TME_SUNCG2_REG_SUN2_PAN_LO (0x30d000)
91: #define TME_SUNCG2_REG_SUN3_DMA_WIDTH (0x30d000)
92: #define TME_SUNCG2_REG_SUN2_ZOOM_VAR (0x30e000)
93: #define TME_SUNCG2_REG_SUN3_FRAME_COUNT (0x30e000)
94: #define TME_SUNCG2_REG_INTVEC (0x30f000)
95: #define TME_SUNCG2_REG_CMAP_R (0x310000)
96: #define TME_SUNCG2_REG_CMAP_G (0x310200)
97: #define TME_SUNCG2_REG_CMAP_B (0x310400)
98: #define TME_SUNCG2_SIZ_REGS (0x310600)
99:
100: /* the bits in the Control/Status register: */
101: #define TME_SUNCG2_CSR_ENABLE_VIDEO (0x0001)
102: #define TME_SUNCG2_CSR_CMAP_UPDATE (0x0002)
103: #define TME_SUNCG2_CSR_INT_ENABLE (0x0004)
104: #define TME_SUNCG2_CSR_ROP_MODE_MASK (0x0038)
105: #define TME_SUNCG2_CSR_ROP_MODE_PRWWRD (0x0000)
106: #define TME_SUNCG2_CSR_ROP_MODE_SRWPIX (0x0008)
107: #define TME_SUNCG2_CSR_ROP_MODE_PWWWRD (0x0010)
108: #define TME_SUNCG2_CSR_ROP_MODE_SWWPIX (0x0018)
109: #define TME_SUNCG2_CSR_ROP_MODE_PRRWRD (0x0020)
110: #define TME_SUNCG2_CSR_ROP_MODE_PRWPIX (0x0028)
111: #define TME_SUNCG2_CSR_ROP_MODE_PWRWRD (0x0030)
112: #define TME_SUNCG2_CSR_ROP_MODE_PWWPIX (0x0038)
113: #define TME_SUNCG2_CSR_INT_ACTIVE (0x0040)
114: #define TME_SUNCG2_CSR_RETRACE (0x0080)
115: #define TME_SUNCG2_CSR_SIZE_MASK_SUN2 (0x0f00)
116: #define TME_SUNCG2_CSR_SIZE_MASK_SUN3 (0x0100)
117: #define TME_SUNCG2_CSR_SIZE_1152_900 (0x0000)
118: #define TME_SUNCG2_CSR_SIZE_1024_1024 (0x0100)
119:
120: /* the raster ops: */
121: #define TME_SUNCG2_ROP_SRC (0xcc)
122: #define TME_SUNCG2_ROP_DST (0xaa)
123: #define TME_SUNCG2_ROP_NOT(x) ((x) ^ 0xff)
124:
125: /* the callout flags: */
126: #define TME_SUNCG2_CALLOUT_CHECK (0)
127: #define TME_SUNCG2_CALLOUT_RUNNING TME_BIT(0)
128: #define TME_SUNCG2_CALLOUTS_MASK (-2)
129: #define TME_SUNCG2_CALLOUT_MODE_CHANGE TME_BIT(1)
130: #define TME_SUNCG2_CALLOUT_INT TME_BIT(2)
131:
132: /* state flags: */
133: #define TME_SUNCG2_FLAG_INVALID_DISPLAYED TME_BIT(0)
134: #define TME_SUNCG2_FLAG_INVALID_PIXMAP TME_BIT(1)
135: #define TME_SUNCG2_FLAG_INVALID_BITMAPS TME_BIT(2)
136: #define TME_SUNCG2_FLAG_CALLOUT_THREAD_RUNNING TME_BIT(3)
137:
138: /* structures: */
139:
140: /* the card: */
141: struct tme_suncg2 {
142:
143: /* our simple bus device header: */
144: struct tme_bus_device tme_suncg2_device;
145: #define tme_suncg2_element tme_suncg2_device.tme_bus_device_element
146:
147: /* the mutex protecting the card: */
148: tme_mutex_t tme_suncg2_mutex;
149:
150: /* the rwlock protecting the card: */
151: tme_rwlock_t tme_suncg2_rwlock;
152:
153: /* the framebuffer connection: */
154: struct tme_fb_connection *tme_suncg2_fb_connection;
155:
156: /* the callout flags: */
157: int tme_suncg2_callout_flags;
158:
159: /* the type of the cgtwo: */
160: tme_uint32_t tme_suncg2_type;
161:
162: /* the size of the bwtwo: */
163: tme_uint32_t tme_suncg2_size;
164:
165: /* the number of displayed pixels: */
166: tme_uint32_t tme_suncg2_pixel_count;
167:
168: /* the raw memory: */
169: tme_uint8_t *tme_suncg2_raw_memory;
170:
171: /* the displayed memory: */
172: tme_uint8_t *tme_suncg2_displayed_memory;
173:
174: /* the rasterop registers: */
175: struct {
176: tme_uint16_t tme_suncg2_ropc_dest;
177: tme_uint16_t tme_suncg2_ropc_source1;
178: tme_uint16_t tme_suncg2_ropc_source2;
179: tme_uint16_t tme_suncg2_ropc_pattern;
180: tme_uint16_t tme_suncg2_ropc_mask1;
181: tme_uint16_t tme_suncg2_ropc_mask2;
182: tme_uint16_t tme_suncg2_ropc_ena_shift;
183: tme_uint16_t tme_suncg2_ropc_op;
184: tme_uint16_t tme_suncg2_ropc_width;
185: tme_uint16_t tme_suncg2_ropc_opcount;
186: tme_uint16_t tme_suncg2_ropc_decoderout;
187: tme_uint16_t tme_suncg2_ropc_x11;
188: tme_uint16_t tme_suncg2_ropc_x12;
189: tme_uint16_t tme_suncg2_ropc_x13;
190: tme_uint16_t tme_suncg2_ropc_x14;
191: tme_uint16_t tme_suncg2_ropc_x15;
192: } tme_suncg2_ropc[TME_SUNCG2_ROPC_PRIME * 2];
193:
194: /* our csr: */
195: tme_uint16_t tme_suncg2_csr;
196:
197: /* our interrupt vector: */
198: tme_uint16_t tme_suncg2_intvec;
199:
200: /* our plane mask: */
201: tme_uint16_t tme_suncg2_plane_mask;
202:
203: /* the raw colormap: */
204: tme_uint16_t tme_suncg2_cmap_raw[(1 << TME_SUNCG2_PLANE_MAX) * 3];
205:
206: /* the cooked colormap: */
207: tme_uint8_t tme_suncg2_cmap[(1 << TME_SUNCG2_PLANE_MAX) * 3];
208:
209: /* if this is zero, the next CSR read will have the retrace bit set: */
210: unsigned int tme_suncg2_cycle_retrace;
211:
212: /* if this is TME_SUNCG2_PLANE_MAX, we are displaying the pixmap,
213: else we are displaying this plane's bitmap: */
214: unsigned int tme_suncg2_bitmap_mode_plane;
215:
216: /* state flags: */
217: unsigned int tme_suncg2_flags;
218:
219: /* any outstanding TLBs: */
220: struct tme_bus_tlb *tme_suncg2_tlbs[4];
221: unsigned int tme_suncg2_tlb_head;
222:
223: /* a rasterop buffered SRC value: */
224: tme_uint16_t tme_suncg2_rop_src_buffer;
225: };
226:
227: /* globals: */
228:
229: #ifndef TME_NO_LOG
230: static const char *_tme_suncg2_ropc_regs[] =
231: { "dest",
232: "source1",
233: "source2",
234: "pattern",
235: "mask1",
236: "mask2",
237: "ena_shift",
238: "op",
239: "width",
240: "opcount",
241: "decoderout",
242: "x11",
243: "x12",
244: "x13",
245: "x14",
246: "x15",
247: };
248: #endif /* !TME_NO_LOG */
249:
250: /* this invalidates any outstanding TLBs: */
251: static void
252: _tme_suncg2_tlb_invalidate(struct tme_suncg2 *suncg2, struct tme_bus_tlb *tlb_valid)
253: {
254: unsigned int tlb_i;
255: struct tme_bus_tlb *tlb;
256:
257: if (tlb_valid != NULL) {
258: tlb_valid = TME_ATOMIC_READ(struct tme_bus_tlb *,
259: tlb_valid->tme_bus_tlb_backing_reservation);
260: }
261:
262: for (tlb_i = 0; tlb_i < TME_ARRAY_ELS(suncg2->tme_suncg2_tlbs); tlb_i++) {
263: tlb = suncg2->tme_suncg2_tlbs[tlb_i];
264: suncg2->tme_suncg2_tlbs[tlb_i] = NULL;
265: if (tlb != NULL
266: && tlb != tlb_valid) {
267: tme_bus_tlb_invalidate(tlb);
268: }
269: }
270: }
271:
272: /* this adds an outstanding TLB: */
273: static void
274: _tme_suncg2_tlb_add(struct tme_suncg2 *suncg2, struct tme_bus_tlb *tlb_valid)
275: {
276: struct tme_bus_tlb *tlb;
277:
278: tlb_valid = TME_ATOMIC_READ(struct tme_bus_tlb *,
279: tlb_valid->tme_bus_tlb_backing_reservation);
280:
281: tlb = suncg2->tme_suncg2_tlbs[suncg2->tme_suncg2_tlb_head % TME_ARRAY_ELS(suncg2->tme_suncg2_tlbs)];
282: if (tlb != NULL
283: && tlb != tlb_valid) {
284: tme_bus_tlb_invalidate(tlb);
285: }
286: suncg2->tme_suncg2_tlbs[suncg2->tme_suncg2_tlb_head % TME_ARRAY_ELS(suncg2->tme_suncg2_tlbs)] = tlb_valid;
287: suncg2->tme_suncg2_tlb_head++;
288: }
289:
290: /* this validates the bitmaps: */
291: static void
292: _tme_suncg2_validate_bitmaps(struct tme_suncg2 *suncg2, struct tme_bus_tlb *tlb)
293: {
294: #if SIZEOF_LONG > 4
295: const unsigned long *pixmap_pointer;
296: unsigned long pixmap;
297: #else /* SIZEOF_LONG <= 4 */
298: const tme_uint32_t *pixmap_pointer;
299: tme_uint32_t pixmap;
300: #endif /* SIZEOF_LONG <= 4 */
301: tme_uint32_t pixmap_resid;
302: tme_uint32_t bitmaps_lo;
303: tme_uint32_t bitmaps_hi;
304: tme_uint8_t *bitmap_pointer;
305:
306: /* if the bitmaps are invalid: */
307: if (suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_BITMAPS) {
308:
309: /* the pixmap must not be invalid: */
310: assert (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_PIXMAP));
311:
312: /* invalidate any outstanding TLBs: */
313: _tme_suncg2_tlb_invalidate(suncg2, tlb);
314:
315: /* if we are displaying the pixmap: */
316: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
317:
318: /* if the displayed memory is not invalid: */
319: if (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED)) {
320:
321: /* copy the displayed memory back into the pixmap: */
322: memcpy((suncg2->tme_suncg2_raw_memory
323: + TME_SUNCG2_REG_PIXMAP),
324: suncg2->tme_suncg2_displayed_memory,
325: TME_SUNCG2_SIZ_PIXMAP);
326: }
327: }
328:
329: /* otherwise, we're displaying a bitmap: */
330: else {
331:
332: /* the displayed memory must be invalid: */
333: assert (suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED);
334: }
335:
336: /* start in the pixmap: */
337: pixmap_pointer = (tme_uint32_t *) (suncg2->tme_suncg2_raw_memory + TME_SUNCG2_REG_PIXMAP);
338: pixmap_resid = TME_SUNCG2_SIZ_PIXMAP;
339: pixmap = 0;
340:
341: /* start in the bitmaps: */
342: bitmap_pointer = suncg2->tme_suncg2_raw_memory + TME_SUNCG2_REG_BITMAP(0);
343: bitmaps_lo = 0;
344: bitmaps_hi = 0;
345:
346: /* do the translation: */
347: do {
348:
349: /* if the pixmap data is empty, reload it: */
350: if (__tme_predict_false((pixmap_resid % sizeof(pixmap)) == 0)) {
351: pixmap = *(pixmap_pointer++);
352: pixmap = tme_betoh_u32(pixmap);
353: }
354:
355: /* translate another pixel's bits into the bitmaps: */
356: bitmaps_lo >>= 1;
357: if (pixmap & TME_BIT(0)) bitmaps_lo |= 0x00000080;
358: if (pixmap & TME_BIT(1)) bitmaps_lo |= 0x00008000;
359: if (pixmap & TME_BIT(2)) bitmaps_lo |= 0x00800000;
360: if (pixmap & TME_BIT(3)) bitmaps_lo |= 0x80000000;
361: bitmaps_hi >>= 1;
362: if (pixmap & TME_BIT(4)) bitmaps_hi |= 0x00000080;
363: if (pixmap & TME_BIT(5)) bitmaps_hi |= 0x00008000;
364: if (pixmap & TME_BIT(6)) bitmaps_hi |= 0x00800000;
365: if (pixmap & TME_BIT(7)) bitmaps_hi |= 0x80000000;
366:
367: /* we have translated another pixel: */
368: pixmap >>= 8;
369: pixmap_resid--;
370:
371: /* after every eight pixels, we have another eight bytes of bitmap
372: data to write out: */
373: if (__tme_predict_false((pixmap_resid % 8) == 0)) {
374: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 0] = TME_FIELD_MASK_EXTRACTU(bitmaps_lo, 0x000000ff);
375: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 1] = TME_FIELD_MASK_EXTRACTU(bitmaps_lo, 0x0000ff00);
376: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 2] = TME_FIELD_MASK_EXTRACTU(bitmaps_lo, 0x00ff0000);
377: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 3] = TME_FIELD_MASK_EXTRACTU(bitmaps_lo, 0xff000000);
378: bitmaps_lo = 0;
379: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 4] = TME_FIELD_MASK_EXTRACTU(bitmaps_hi, 0x000000ff);
380: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 5] = TME_FIELD_MASK_EXTRACTU(bitmaps_hi, 0x0000ff00);
381: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 6] = TME_FIELD_MASK_EXTRACTU(bitmaps_hi, 0x00ff0000);
382: bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 7] = TME_FIELD_MASK_EXTRACTU(bitmaps_hi, 0xff000000);
383: bitmaps_hi = 0;
384: bitmap_pointer++;
385: }
386:
387: /* loop while we have pixmap bytes remaining: */
388: } while (pixmap_resid > 0);
389:
390: /* the bitmaps are no longer invalid: */
391: suncg2->tme_suncg2_flags &= ~TME_SUNCG2_FLAG_INVALID_BITMAPS;
392: }
393:
394: /* otherwise, the bitmaps are valid: */
395: else {
396:
397: /* if our caller needs the actual raw bitmap memory valid
398: (indicated by tlb == NULL): */
399: if (tlb == NULL) {
400:
401: /* invalidate any outstanding TLBs: */
402: _tme_suncg2_tlb_invalidate(suncg2, NULL);
403:
404: /* if we're displaying a bitmap: */
405: if (suncg2->tme_suncg2_bitmap_mode_plane != TME_SUNCG2_PLANE_MAX) {
406:
407: /* if the displayed memory is not invalid: */
408: if (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED)) {
409:
410: /* copy the displayed memory back into the bitmap: */
411: memcpy((suncg2->tme_suncg2_raw_memory
412: + TME_SUNCG2_REG_BITMAP(suncg2->tme_suncg2_bitmap_mode_plane)),
413: suncg2->tme_suncg2_displayed_memory,
414: TME_SUNCG2_SIZ_BITMAP);
415: }
416: }
417: }
418: }
419: }
420:
421: /* this validates the pixmap: */
422: static void
423: _tme_suncg2_validate_pixmap(struct tme_suncg2 *suncg2, struct tme_bus_tlb *tlb)
424: {
425: #if SIZEOF_LONG > 4
426: unsigned long *pixmap_pointer;
427: unsigned long pixmap;
428: #else /* SIZEOF_LONG <= 4 */
429: tme_uint32_t *pixmap_pointer;
430: tme_uint32_t pixmap;
431: #endif /* SIZEOF_LONG <= 4 */
432: tme_uint32_t pixmap_resid;
433: tme_uint32_t bitmaps_lo;
434: tme_uint32_t bitmaps_hi;
435: const tme_uint8_t *bitmap_pointer;
436:
437: /* if the pixmap is invalid: */
438: if (suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_PIXMAP) {
439:
440: /* the bitmaps must not be invalid: */
441: assert (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_BITMAPS));
442:
443: /* invalidate any outstanding TLBs: */
444: _tme_suncg2_tlb_invalidate(suncg2, tlb);
445:
446: /* if we are displaying a bitmap: */
447: if (suncg2->tme_suncg2_bitmap_mode_plane != TME_SUNCG2_PLANE_MAX) {
448:
449: /* if the displayed memory is not invalid: */
450: if (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED)) {
451:
452: /* copy the displayed memory back into the bitmap: */
453: memcpy((suncg2->tme_suncg2_raw_memory
454: + TME_SUNCG2_REG_BITMAP(suncg2->tme_suncg2_bitmap_mode_plane)),
455: suncg2->tme_suncg2_displayed_memory,
456: TME_SUNCG2_SIZ_BITMAP);
457: }
458: }
459:
460: /* otherwise, we're displaying the pixmap: */
461: else {
462:
463: /* the displayed memory must be invalid: */
464: assert (suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED);
465: }
466:
467: /* start in the pixmap: */
468: pixmap_pointer = (tme_uint32_t *) (suncg2->tme_suncg2_raw_memory + TME_SUNCG2_REG_PIXMAP);
469: pixmap_resid = TME_SUNCG2_SIZ_PIXMAP;
470: pixmap = 0;
471:
472: /* start in the bitmaps: */
473: bitmap_pointer = suncg2->tme_suncg2_raw_memory + TME_SUNCG2_REG_BITMAP(0);
474: bitmaps_lo = 0;
475: bitmaps_hi = 0;
476:
477: /* do the translation: */
478: do {
479:
480: /* if the bitmap data is empty, reload it: */
481: if (__tme_predict_false((pixmap_resid % 8) == 0)) {
482: bitmaps_lo
483: = ((((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 0]) << 0)
484: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 1]) << 8)
485: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 2]) << 16)
486: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 3]) << 24));
487: bitmaps_hi
488: = ((((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 4]) << 0)
489: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 5]) << 8)
490: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 6]) << 16)
491: | (((tme_uint32_t) bitmap_pointer[TME_SUNCG2_SIZ_BITMAP * 7]) << 24));
492: bitmap_pointer++;
493: }
494:
495: /* we are about to translate another pixel: */
496: pixmap <<= 8;
497: pixmap_resid--;
498:
499: /* translate another pixel's bits from the bitmaps: */
500: if (bitmaps_lo & 0x00000080) pixmap |= TME_BIT(0);
501: if (bitmaps_lo & 0x00008000) pixmap |= TME_BIT(1);
502: if (bitmaps_lo & 0x00800000) pixmap |= TME_BIT(2);
503: if (bitmaps_lo & 0x80000000) pixmap |= TME_BIT(3);
504: bitmaps_lo <<= 1;
505: if (bitmaps_hi & 0x00000080) pixmap |= TME_BIT(4);
506: if (bitmaps_hi & 0x00008000) pixmap |= TME_BIT(5);
507: if (bitmaps_hi & 0x00800000) pixmap |= TME_BIT(6);
508: if (bitmaps_hi & 0x80000000) pixmap |= TME_BIT(7);
509: bitmaps_hi <<= 1;
510:
511: /* if the pixmap data is full, write it: */
512: if (__tme_predict_false((pixmap_resid % sizeof(pixmap)) == 0)) {
513: *(pixmap_pointer++) = tme_htobe_u32(pixmap);
514: pixmap = 0;
515: }
516:
517: /* loop while we have pixmap bytes remaining: */
518: } while (pixmap_resid > 0);
519:
520: /* the pixmap is no longer invalid, but the bitmaps are: */
521: suncg2->tme_suncg2_flags &= ~TME_SUNCG2_FLAG_INVALID_PIXMAP;
522: }
523:
524: /* otherwise, the pixmap is valid: */
525: else {
526:
527: /* if our caller needs the actual raw pixmap memory valid
528: (indicated by tlb == NULL): */
529: if (tlb == NULL) {
530:
531: /* invalidate any outstanding TLBs: */
532: _tme_suncg2_tlb_invalidate(suncg2, NULL);
533:
534: /* if we're displaying the pixmap: */
535: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
536:
537: /* if the displayed memory is not invalid: */
538: if (!(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED)) {
539:
540: /* copy the displayed memory back into the pixmap: */
541: memcpy((suncg2->tme_suncg2_raw_memory
542: + TME_SUNCG2_REG_PIXMAP),
543: suncg2->tme_suncg2_displayed_memory,
544: TME_SUNCG2_SIZ_PIXMAP);
545: }
546: }
547: }
548: }
549: }
550:
551: /* this validates the displayed memory: */
552: static void
553: _tme_suncg2_validate_displayed(struct tme_suncg2 *suncg2, struct tme_bus_tlb *tlb)
554: {
555:
556: /* if the displayed memory is invalid: */
557: if (suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_INVALID_DISPLAYED) {
558:
559: /* if we're displaying the pixmap: */
560: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
561:
562: /* validate the pixmap: */
563: _tme_suncg2_validate_pixmap(suncg2, tlb);
564:
565: /* copy the pixmap into the displayed memory: */
566: memcpy(suncg2->tme_suncg2_displayed_memory,
567: (suncg2->tme_suncg2_raw_memory
568: + TME_SUNCG2_REG_PIXMAP),
569: TME_SUNCG2_SIZ_PIXMAP);
570: }
571:
572: /* otherwise, we're displaying a bitmap: */
573: else {
574:
575: /* validate the bitmaps: */
576: _tme_suncg2_validate_bitmaps(suncg2, tlb);
577:
578: /* copy the bitmap into the displayed memory: */
579: memcpy(suncg2->tme_suncg2_displayed_memory,
580: (suncg2->tme_suncg2_raw_memory
581: + TME_SUNCG2_REG_BITMAP(suncg2->tme_suncg2_bitmap_mode_plane)),
582: TME_SUNCG2_SIZ_BITMAP);
583: }
584:
585: /* the displayed memory is no longer invalid: */
586: suncg2->tme_suncg2_flags &= ~TME_SUNCG2_FLAG_INVALID_DISPLAYED;
587: }
588: }
589:
590: /* this handles a mode change callout: */
591: static int
592: _tme_suncg2_mode_change(struct tme_suncg2 *suncg2)
593: {
594: struct tme_fb_connection *conn_fb_other;
595: struct tme_fb_connection *conn_fb;
596: unsigned int pixel_i;
597: unsigned int mono_mask;
598: tme_uint32_t color0;
599: tme_uint32_t color1;
600: tme_uint32_t color;
601: unsigned int bitmap_mode_plane;
602: unsigned int color_i;
603: int rc;
604:
605: /* this makes a color for a pixel: */
606: #define _TME_SUNCG2_PIXEL_COLOR(pixel) \
607: ((TME_SUNCG2_CMAP_VALUE(suncg2, pixel, TME_SUNCG2_REG_CMAP_G) << 0) \
608: | (TME_SUNCG2_CMAP_VALUE(suncg2, pixel, TME_SUNCG2_REG_CMAP_R) << 8) \
609: | (TME_SUNCG2_CMAP_VALUE(suncg2, pixel, TME_SUNCG2_REG_CMAP_B) << 16))
610:
611: /* if we are to display a bitmap, the color for pixmap pixel zero
612: must be the color for bitmap pixel zero, and the color for pixmap
613: pixel 255 must be the color for bitmap pixel one: */
614: color0 = _TME_SUNCG2_PIXEL_COLOR(0);
615: color1 = _TME_SUNCG2_PIXEL_COLOR(255);
616:
617: /* we don't know what the monochrome mask is yet: */
618: mono_mask = 0xff;
619:
620: /* loop over the other pixels: */
621: for (pixel_i = 1; pixel_i < 255; pixel_i++) {
622:
623: /* get the color for this pixel: */
624: color = _TME_SUNCG2_PIXEL_COLOR(pixel_i);
625:
626: /* if this matches color0: */
627: if (color == color0) {
628:
629: /* any set bits in this pixel number can't be in the monochrome
630: mask: */
631: mono_mask &= ~pixel_i;
632: }
633:
634: /* else, if this matches color1: */
635: else if (color == color1) {
636:
637: /* any clear bits in this pixel number can't be in the
638: monochrome mask: */
639: mono_mask &= pixel_i;
640: }
641:
642: /* otherwise, this is some other color: */
643: else {
644:
645: /* we can't be in bitmap mode: */
646: mono_mask = 0;
647: break;
648: }
649: }
650:
651: /* if we completed the above loop, but our monochrome mask is zero,
652: the colors for all pixel values must be the same. while strange,
653: we tolerate this, and take the least significant bit as the
654: monochrome mask: */
655: if (pixel_i == 255
656: && mono_mask == 0) {
657: assert (color0 == color1);
658: mono_mask = 1;
659: }
660:
661: /* if the monochrome mask is zero, we must display the pixmap, else
662: we display the bitmap corresponding to the least significant set
663: bit in the monochrome mask: */
664: if (mono_mask == 0) {
665: bitmap_mode_plane = TME_SUNCG2_PLANE_MAX;
666: }
667: else {
668: for (bitmap_mode_plane = 0;
669: (mono_mask & 1) == 0;
670: bitmap_mode_plane++, mono_mask >>= 1);
671: }
672:
673: #undef _TME_SUNCG2_PIXEL_COLOR
674:
675: /* get both sides of the framebuffer connection: */
676: conn_fb_other = suncg2->tme_suncg2_fb_connection;
677: conn_fb = (struct tme_fb_connection *) conn_fb_other->tme_fb_connection.tme_connection_other;
678:
679: /* if we are displaying the pixmap: */
680: if (bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
681:
682: /* the pixmap is eight bits deep: */
683: conn_fb->tme_fb_connection_depth = TME_SUNCG2_PLANE_MAX;
684: conn_fb->tme_fb_connection_bits_per_pixel = TME_SUNCG2_PLANE_MAX;
685:
686: /* recook the colormap: */
687: for (color_i = 0;
688: color_i < TME_ARRAY_ELS(suncg2->tme_suncg2_cmap_raw);
689: color_i++) {
690: suncg2->tme_suncg2_cmap[color_i] = tme_betoh_u16(suncg2->tme_suncg2_cmap_raw[color_i]);
691: }
692: }
693:
694: /* otherwise, we can display a bitmap: */
695: else {
696:
697: /* a bitmap is one bit deep: */
698: conn_fb->tme_fb_connection_depth = 1;
699: conn_fb->tme_fb_connection_bits_per_pixel = 1;
700:
701: /* cook the monochrome colormap: */
702: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_G)] = TME_SUNCG2_CMAP_VALUE(suncg2, 0, TME_SUNCG2_REG_CMAP_G);
703: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_R)] = TME_SUNCG2_CMAP_VALUE(suncg2, 0, TME_SUNCG2_REG_CMAP_R);
704: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_B)] = TME_SUNCG2_CMAP_VALUE(suncg2, 0, TME_SUNCG2_REG_CMAP_B);
705: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(1, TME_SUNCG2_REG_CMAP_G)] = TME_SUNCG2_CMAP_VALUE(suncg2, 255, TME_SUNCG2_REG_CMAP_G);
706: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(1, TME_SUNCG2_REG_CMAP_R)] = TME_SUNCG2_CMAP_VALUE(suncg2, 255, TME_SUNCG2_REG_CMAP_R);
707: suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(1, TME_SUNCG2_REG_CMAP_B)] = TME_SUNCG2_CMAP_VALUE(suncg2, 255, TME_SUNCG2_REG_CMAP_B);
708: }
709:
710: /* if the display is changing: */
711: if (bitmap_mode_plane != suncg2->tme_suncg2_bitmap_mode_plane) {
712:
713: /* log the change: */
714: tme_log(&suncg2->tme_suncg2_element->tme_element_log_handle,
715: 100, TME_OK,
716: (&suncg2->tme_suncg2_element->tme_element_log_handle,
717: "display changing from plane %u to plane %u",
718: suncg2->tme_suncg2_bitmap_mode_plane,
719: bitmap_mode_plane));
720:
721: /* if we were displaying the pixmap, validate the pixmap, else
722: validate the bitmaps, to copy the current displayed memory back
723: into the raw memory: */
724: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
725: _tme_suncg2_validate_pixmap(suncg2, NULL);
726: }
727: else {
728: _tme_suncg2_validate_bitmaps(suncg2, NULL);
729: }
730:
731: /* invalidate any outstanding TLBs: */
732: _tme_suncg2_tlb_invalidate(suncg2, NULL);
733:
734: /* set the display: */
735: suncg2->tme_suncg2_bitmap_mode_plane = bitmap_mode_plane;
736:
737: /* free any previously allocated memory: */
738: if (suncg2->tme_suncg2_displayed_memory != NULL) {
739: tme_free(suncg2->tme_suncg2_displayed_memory);
740: }
741:
742: /* allocate memory for our framebuffer connection: */
743: rc = tme_fb_xlat_alloc_src(conn_fb);
744: assert (rc == TME_OK);
745: suncg2->tme_suncg2_displayed_memory = conn_fb->tme_fb_connection_buffer;
746:
747: /* the displayed memory is now invalid: */
748: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_DISPLAYED;
749: }
750:
751: /* unlock the mutex: */
752: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
753:
754: /* do the callout: */
755: rc = (conn_fb_other != NULL
756: ? ((*conn_fb_other->tme_fb_connection_mode_change)
757: (conn_fb_other))
758: : TME_OK);
759:
760: /* lock the mutex: */
761: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
762:
763: return (rc);
764: }
765:
766: /* the suncg2 callout function. it must be called with the mutex locked: */
767: static void
768: _tme_suncg2_callout(struct tme_suncg2 *suncg2, int new_callouts)
769: {
770: int callouts, later_callouts;
771: int rc;
772:
773: /* add in any new callouts: */
774: suncg2->tme_suncg2_callout_flags |= new_callouts;
775:
776: /* if this function is already running in another thread, simply
777: return now. the other thread will do our work: */
778: if (suncg2->tme_suncg2_callout_flags
779: & TME_SUNCG2_CALLOUT_RUNNING) {
780: return;
781: }
782:
783: /* callouts are now running: */
784: suncg2->tme_suncg2_callout_flags
785: |= TME_SUNCG2_CALLOUT_RUNNING;
786:
787: /* assume that we won't need any later callouts: */
788: later_callouts = 0;
789:
790: /* loop while callouts are needed: */
791: for (; ((callouts
792: = suncg2->tme_suncg2_callout_flags)
793: & TME_SUNCG2_CALLOUTS_MASK); ) {
794:
795: /* clear the needed callouts: */
796: suncg2->tme_suncg2_callout_flags
797: = (callouts
798: & ~TME_SUNCG2_CALLOUTS_MASK);
799: callouts
800: &= TME_SUNCG2_CALLOUTS_MASK;
801:
802: /* if we need a mode change: */
803: if (new_callouts & TME_SUNCG2_CALLOUT_MODE_CHANGE) {
804:
805: /* call out the mode change: */
806: rc = _tme_suncg2_mode_change(suncg2);
807:
808: /* if the callout failed: */
809: if (rc != TME_OK) {
810:
811: /* remember that this callout should be attempted again at
812: some later time: */
813: later_callouts |= TME_SUNCG2_CALLOUT_MODE_CHANGE;
814: }
815: }
816: }
817:
818: /* put in any later callouts, and clear that callouts are running: */
819: suncg2->tme_suncg2_callout_flags = later_callouts;
820: }
821:
822: /* the callout thread: */
823: static void
824: _tme_suncg2_callout_thread(void *_suncg2)
825: {
826: struct tme_suncg2 *suncg2;
827:
828: /* recover our data structure: */
829: suncg2 = _suncg2;
830:
831: /* lock the mutex: */
832: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
833:
834: /* the callout thread is no longer running: */
835: suncg2->tme_suncg2_flags &= ~TME_SUNCG2_FLAG_CALLOUT_THREAD_RUNNING;
836:
837: /* make any callouts: */
838: _tme_suncg2_callout(suncg2, 0);
839:
840: /* unlock the mutex: */
841: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
842: }
843:
844: /* this is called before the framebuffer's display is updated: */
845: static int
846: _tme_suncg2_update(struct tme_fb_connection *conn_fb)
847: {
848: struct tme_suncg2 *suncg2;
849:
850: /* recover our data structure: */
851: suncg2 = conn_fb->tme_fb_connection.tme_connection_element->tme_element_private;
852:
853: /* lock the mutex: */
854: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
855:
856: /* validate the displayed memory: */
857: _tme_suncg2_validate_displayed(suncg2, NULL);
858:
859: /* if we still need callouts, and the callout thread isn't running,
860: start it: */
861: if ((suncg2->tme_suncg2_callout_flags & TME_SUNCG2_CALLOUTS_MASK) != 0
862: && !(suncg2->tme_suncg2_flags & TME_SUNCG2_FLAG_CALLOUT_THREAD_RUNNING)) {
863: tme_thread_create(_tme_suncg2_callout_thread, suncg2);
864: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_CALLOUT_THREAD_RUNNING;
865: }
866:
867: /* unlock the mutex: */
868: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
869:
870: return (TME_OK);
871: }
872:
873: /* the suncg2 displayed memory bus cycle handler: */
874: static int
875: _tme_suncg2_bus_cycle_displayed(void *_suncg2, struct tme_bus_cycle *cycle_init)
876: {
877: struct tme_suncg2 *suncg2;
878: unsigned int plane_i;
879: tme_bus_addr_t address_first;
880: tme_bus_addr_t address_last;
881:
882: /* recover our data structure: */
883: suncg2 = (struct tme_suncg2 *) _suncg2;
884:
885: /* lock the mutex: */
886: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
887:
888: /* if we're displaying the pixmap: */
889: plane_i = suncg2->tme_suncg2_bitmap_mode_plane;
890: if (plane_i == TME_SUNCG2_PLANE_MAX) {
891:
892: /* the displayed memory is the pixmap memory: */
893: address_first = TME_SUNCG2_REG_PIXMAP;
894: address_last = TME_SUNCG2_REG_PIXMAP + suncg2->tme_suncg2_pixel_count - 1;
895: }
896:
897: /* otherwise, we're in bitmap mode: */
898: else {
899:
900: /* the displayed memory is the displayed bitmap memory: */
901: address_first = TME_SUNCG2_REG_BITMAP(plane_i);
902: address_last = address_first + (suncg2->tme_suncg2_pixel_count / 8) - 1;
903: }
904:
905: /* run the cycle: */
906: tme_bus_cycle_xfer_memory(cycle_init,
907: (suncg2->tme_suncg2_displayed_memory
908: - address_first),
909: address_last);
910:
911: /* unlock the mutex: */
912: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
913:
914: /* no faults: */
915: return (TME_OK);
916: }
917:
918: /* the suncg2 raw memory bus cycle handler: */
919: static int
920: _tme_suncg2_bus_cycle_raw(void *_suncg2, struct tme_bus_cycle *cycle_init)
921: {
922: struct tme_suncg2 *suncg2;
923:
924: /* recover our data structure: */
925: suncg2 = (struct tme_suncg2 *) _suncg2;
926:
927: /* lock the mutex: */
928: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
929:
930: /* run the cycle: */
931: tme_bus_cycle_xfer_memory(cycle_init,
932: (suncg2->tme_suncg2_raw_memory
933: - TME_SUNCG2_REG_BITMAP(0)),
934: (TME_SUNCG2_REG_PIXMAP
935: + TME_SUNCG2_SIZ_PIXMAP
936: - 1));
937:
938: /* unlock the mutex: */
939: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
940:
941: /* no faults: */
942: return (TME_OK);
943: }
944:
945: /* this catches unsupported rasterop configurations: */
946: static void
947: _tme_suncg2_rop_unsupported(struct tme_suncg2 *suncg2)
948: {
949: /* nothing */
950: }
951:
952: /* this does a raster op: */
953: static tme_uint16_t
954: _tme_suncg2_rop_op(struct tme_suncg2 *suncg2,
955: unsigned int ropc_unit,
956: tme_uint16_t src,
957: tme_uint16_t dst)
958: {
959: switch ((tme_uint8_t) suncg2->tme_suncg2_ropc[ropc_unit].tme_suncg2_ropc_op) {
960: default:
961: _tme_suncg2_rop_unsupported(suncg2);
962: /* FALLTHROUGH */
963: case (TME_SUNCG2_ROP_SRC): return (src);
964: case (TME_SUNCG2_ROP_NOT(TME_SUNCG2_ROP_DST)): return (~dst);
965: }
966: }
967:
968: /* the bus cycle handler for the rasterop data: */
969: static int
970: _tme_suncg2_bus_cycle_rop_data(void *_suncg2, struct tme_bus_cycle *cycle_init)
971: {
972: struct tme_suncg2 *suncg2;
973: tme_uint32_t address;
974: tme_uint32_t address_aligned;
975: tme_uint16_t data;
976: tme_uint8_t src;
977: tme_uint8_t dst;
978: tme_uint8_t pixel;
979: int supported;
980:
981: /* recover our data structure: */
982: suncg2 = (struct tme_suncg2 *) _suncg2;
983:
984: /* decode the address: */
985: address
986: = (cycle_init->tme_bus_cycle_address
987: - TME_SUNCG2_REG_ROP_DATA);
988: address_aligned
989: = (address & (((tme_uint32_t) 0) - sizeof(tme_uint16_t)));
990:
991: /* assume that this access is unsupported: */
992: supported = FALSE;
993:
994: /* lock the mutex: */
995: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
996:
997: /* if this is a read: */
998: if (cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_READ) {
999:
1000: /* dispatch on the rop mode: */
1001: switch (suncg2->tme_suncg2_csr & TME_SUNCG2_CSR_ROP_MODE_MASK) {
1002:
1003: default:
1004: _tme_suncg2_rop_unsupported(suncg2);
1005: data = 0;
1006: break;
1007:
1008: /* the single pixel, LD_SRC write, LD_DST write, mode: */
1009: case TME_SUNCG2_CSR_ROP_MODE_SWWPIX:
1010:
1011: /* this mode has partial support: */
1012: supported = TRUE;
1013:
1014: /* XXX FIXME does a load reset the state? */
1015:
1016: /* just load two pixels from the pixmap: */
1017: _tme_suncg2_validate_pixmap(suncg2, NULL);
1018: data = (suncg2->tme_suncg2_raw_memory[TME_SUNCG2_REG_PIXMAP + address_aligned]
1019: & ((tme_uint8_t) suncg2->tme_suncg2_plane_mask));
1020: data = ((data << 8)
1021: | (suncg2->tme_suncg2_raw_memory[TME_SUNCG2_REG_PIXMAP + address_aligned + 1]
1022: & ((tme_uint8_t) suncg2->tme_suncg2_plane_mask)));
1023: break;
1024: }
1025: }
1026:
1027: /* do the bus cycle: */
1028: tme_bus_cycle_xfer_reg(cycle_init,
1029: &data,
1030: TME_BUS16_LOG2);
1031:
1032: /* get the data: */
1033: data = (((cycle_init->tme_bus_cycle_size == sizeof(tme_uint16_t)
1034: || (address % sizeof(tme_uint16_t)) == 1)
1035: ? data
1036: : (data >> 8))
1037: & (0xffff >> (sizeof(tme_uint16_t) - cycle_init->tme_bus_cycle_size)));
1038:
1039: /* log the cycle: */
1040: tme_log(&suncg2->tme_suncg2_element->tme_element_log_handle,
1041: 100, TME_OK,
1042: (&suncg2->tme_suncg2_element->tme_element_log_handle,
1043: ((cycle_init->tme_bus_cycle_size == sizeof(tme_uint16_t))
1044: ? "rop data offset 0x%05x size 16bits %s 0x%04x"
1045: : "rop data offset 0x%05x size 8bits %s 0x%02x"),
1046: address,
1047: ((cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE)
1048: ? "<-"
1049: : "->"),
1050: data));
1051:
1052: /* if this is a write: */
1053: if (cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE) {
1054:
1055: /* dispatch on the rop mode: */
1056: switch (suncg2->tme_suncg2_csr & TME_SUNCG2_CSR_ROP_MODE_MASK) {
1057:
1058: default:
1059: _tme_suncg2_rop_unsupported(suncg2);
1060: break;
1061:
1062: /* the single pixel, LD_SRC write, LD_DST write, mode: */
1063: case TME_SUNCG2_CSR_ROP_MODE_SWWPIX:
1064:
1065: /* this mode has partial support: */
1066: supported = TRUE;
1067:
1068: /* validate the pixmap: */
1069: _tme_suncg2_validate_pixmap(suncg2, NULL);
1070:
1071: /* the current pixel value is DST: */
1072: dst = suncg2->tme_suncg2_raw_memory[TME_SUNCG2_REG_PIXMAP + address];
1073:
1074: /* the current source buffer is SRC: */
1075: src = suncg2->tme_suncg2_rop_src_buffer;
1076:
1077: /* make the new pixel value: */
1078: pixel = _tme_suncg2_rop_op(suncg2,
1079: 8,
1080: src,
1081: dst);
1082:
1083: /* store the pixel: */
1084: suncg2->tme_suncg2_raw_memory[TME_SUNCG2_REG_PIXMAP + address]
1085: = ((dst & ((tme_uint8_t) (~suncg2->tme_suncg2_plane_mask)))
1086: | (pixel & ((tme_uint8_t) suncg2->tme_suncg2_plane_mask)));
1087:
1088: /* the displayed memory is now invalid: */
1089: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_DISPLAYED;
1090:
1091: /* load the source buffer: */
1092: suncg2->tme_suncg2_rop_src_buffer = data;
1093: break;
1094: }
1095: }
1096:
1097: /* if this cycle was unsupported, abort: */
1098: if (__tme_predict_false(!supported)) {
1099: _tme_suncg2_rop_unsupported(suncg2);
1100: }
1101:
1102: /* unlock the mutex: */
1103: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
1104:
1105: /* no faults: */
1106: return (TME_OK);
1107: }
1108:
1109: /* the bus cycle handler for the registers: */
1110: static int
1111: _tme_suncg2_bus_cycle_regs(void *_suncg2, struct tme_bus_cycle *cycle_init)
1112: {
1113: struct tme_suncg2 *suncg2;
1114: tme_bus_addr_t address;
1115: tme_uint16_t *reg;
1116: tme_uint16_t reg_old, reg_new;
1117: tme_uint16_t junk;
1118: unsigned int ropc_unit;
1119: unsigned int ropc_unit_prime;
1120: unsigned int ropc_reg;
1121: int new_callouts;
1122:
1123: /* assume we won't need any new callouts: */
1124: new_callouts = 0;
1125:
1126: /* recover our data structure: */
1127: suncg2 = (struct tme_suncg2 *) _suncg2;
1128:
1129: /* coarsely decode the address: */
1130: address
1131: = (cycle_init->tme_bus_cycle_address
1132: & (((tme_bus_addr_t) 0)
1133: - TME_SUNCG2_SIZ_REG_PAGE));
1134:
1135: /* lock the mutex: */
1136: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
1137:
1138: /* the rasterop registers go from [TME_SUNCG2_REG_ROPC_UNIT(0)..TME_SUNCG2_REG_CSR): */
1139: assert (address >= TME_SUNCG2_REG_ROPC_UNIT(0));
1140: if (address < TME_SUNCG2_REG_CSR) {
1141:
1142: /* get the rasterop unit number: */
1143: ropc_unit = (address - TME_SUNCG2_REG_ROPC_UNIT(0)) / TME_SUNCG2_SIZ_REG_PAGE;
1144:
1145: /* see if this is the prime registers: */
1146: ropc_unit_prime
1147: = ((cycle_init->tme_bus_cycle_address & (TME_SUNCG2_SIZ_REG_PAGE / 2))
1148: ? TME_SUNCG2_ROPC_PRIME
1149: : 0);
1150:
1151: /* get the register number: */
1152: ropc_reg
1153: = ((cycle_init->tme_bus_cycle_address
1154: % sizeof(suncg2->tme_suncg2_ropc[ropc_unit_prime + ropc_unit]))
1155: / sizeof(tme_uint16_t));
1156:
1157: /* get a pointer to the single register: */
1158: reg = (((tme_uint16_t *) &suncg2->tme_suncg2_ropc[ropc_unit_prime + ropc_unit]) + ropc_reg);
1159:
1160: /* do the bus cycle: */
1161: tme_bus_cycle_xfer_reg(cycle_init,
1162: reg,
1163: TME_BUS16_LOG2);
1164:
1165: #ifndef TME_NO_LOG
1166: /* log the transfer: */
1167: tme_log(&suncg2->tme_suncg2_element->tme_element_log_handle,
1168: 100, TME_OK,
1169: (&suncg2->tme_suncg2_element->tme_element_log_handle,
1170: "ropc unit %u%s reg %s %s 0x%04x",
1171: ropc_unit,
1172: (ropc_unit_prime
1173: ? " PRIME"
1174: : ""),
1175: _tme_suncg2_ropc_regs[ropc_reg],
1176: ((cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE)
1177: ? "<-"
1178: : "->"),
1179: *reg));
1180: #endif /* !TME_NO_LOG */
1181: }
1182:
1183: /* the CSR is the entire page at TME_SUNCG2_REG_CSR: */
1184: else if (address == TME_SUNCG2_REG_CSR) {
1185:
1186: /* if this is a read: */
1187: if ((cycle_init->tme_bus_cycle_type & TME_BUS_CYCLE_READ) != 0) {
1188:
1189: /* if it's time to set the retrace bit, set it: */
1190: if (suncg2->tme_suncg2_cycle_retrace-- == 0) {
1191: suncg2->tme_suncg2_csr |= TME_SUNCG2_CSR_RETRACE;
1192: suncg2->tme_suncg2_cycle_retrace = TME_SUNCG2_CYCLE_RETRACE;
1193: }
1194:
1195: /* otherwise, clear it: */
1196: else {
1197: suncg2->tme_suncg2_csr &= ~TME_SUNCG2_CSR_RETRACE;
1198: }
1199: }
1200:
1201: /* do the bus cycle: */
1202: reg_old = suncg2->tme_suncg2_csr;
1203: tme_bus_cycle_xfer_reg(cycle_init,
1204: &suncg2->tme_suncg2_csr,
1205: TME_BUS16_LOG2);
1206: reg_new = suncg2->tme_suncg2_csr;
1207:
1208: /* put back the unchanging bits: */
1209: reg_new
1210: = ((reg_new
1211: & ~(TME_SUNCG2_CSR_INT_ACTIVE
1212: | TME_SUNCG2_CSR_RETRACE
1213: | 0xff00))
1214: | (reg_old
1215: & (TME_SUNCG2_CSR_INT_ACTIVE
1216: | TME_SUNCG2_CSR_RETRACE
1217: | 0xff00)));
1218: suncg2->tme_suncg2_csr = reg_new;
1219:
1220: /* log the transfer: */
1221: tme_log(&suncg2->tme_suncg2_element->tme_element_log_handle,
1222: 100, TME_OK,
1223: (&suncg2->tme_suncg2_element->tme_element_log_handle,
1224: "csr %s 0x%04x",
1225: ((cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE)
1226: ? "<-"
1227: : "->"),
1228: reg_new));
1229:
1230: /* we do not support these bits: */
1231: if ((reg_new
1232: ^ reg_old)
1233: & TME_SUNCG2_CSR_INT_ENABLE) {
1234: abort();
1235: }
1236:
1237: /* if the cmap update bit is transitioning from a zero to a one,
1238: we need a mode change: */
1239: if ((reg_old & TME_SUNCG2_CSR_CMAP_UPDATE) == 0
1240: && (reg_new & TME_SUNCG2_CSR_CMAP_UPDATE) != 0) {
1241: new_callouts |= TME_SUNCG2_CALLOUT_MODE_CHANGE;
1242: }
1243: }
1244:
1245: /* if this is the interrupt vector: */
1246: else if (address == TME_SUNCG2_REG_INTVEC) {
1247: tme_bus_cycle_xfer_reg(cycle_init,
1248: &suncg2->tme_suncg2_intvec,
1249: TME_BUS16_LOG2);
1250: }
1251:
1252: /* if this is the plane mask: */
1253: else if (address == TME_SUNCG2_REG_PLANE_MASK) {
1254:
1255: /* do the bus cycle: */
1256: tme_bus_cycle_xfer_reg(cycle_init,
1257: &suncg2->tme_suncg2_plane_mask,
1258: TME_BUS16_LOG2);
1259:
1260: /* log the transfer: */
1261: tme_log(&suncg2->tme_suncg2_element->tme_element_log_handle,
1262: 100, TME_OK,
1263: (&suncg2->tme_suncg2_element->tme_element_log_handle,
1264: "plane mask %s 0x%04x",
1265: ((cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE)
1266: ? "<-"
1267: : "->"),
1268: suncg2->tme_suncg2_plane_mask));
1269: }
1270:
1271: /* XXX FIXME - the sun3 PROM zeroes the cg3 DMA base register,
1272: the cg3 double buffer register, the cg3 DMA width register,
1273: and the cg3 frame count registers: */
1274: else if (address == TME_SUNCG2_REG_SUN3_DMA_BASE
1275: || address == TME_SUNCG2_REG_SUN3_DOUBLE_BUF
1276: || address == TME_SUNCG2_REG_SUN3_DMA_WIDTH
1277: || address == TME_SUNCG2_REG_SUN3_FRAME_COUNT) {
1278: tme_bus_cycle_xfer_reg(cycle_init,
1279: &junk,
1280: TME_BUS16_LOG2);
1281: }
1282:
1283: /* XXX FIXME - this is a partial implementation: */
1284: else {
1285: abort();
1286: }
1287:
1288: /* make any new callouts: */
1289: _tme_suncg2_callout(suncg2, new_callouts);
1290:
1291: /* unlock the mutex: */
1292: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
1293:
1294: /* no faults: */
1295: return (TME_OK);
1296: }
1297:
1298: /* the bus cycle handler for the suncg2 colormap registers: */
1299: static int
1300: _tme_suncg2_bus_cycle_cmap(void *_suncg2, struct tme_bus_cycle *cycle_init)
1301: {
1302: struct tme_suncg2 *suncg2;
1303:
1304: /* recover our data structure: */
1305: suncg2 = (struct tme_suncg2 *) _suncg2;
1306:
1307: /* lock the mutex: */
1308: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
1309:
1310: /* run the cycle: */
1311: tme_bus_cycle_xfer_memory(cycle_init,
1312: (((tme_uint8_t *) suncg2->tme_suncg2_cmap_raw)
1313: - TME_SUNCG2_REG_CMAP_R),
1314: TME_SUNCG2_SIZ_REGS - 1);
1315:
1316: /* if this is a write and colormap updates are enabled, we need to
1317: call out a mode change. we don't make the callout now, assuming
1318: that more writes to the colormap are coming soon. we will
1319: eventually make the callout when the framebuffer updates: */
1320: if ((cycle_init->tme_bus_cycle_type & TME_BUS_CYCLE_WRITE)
1321: && (suncg2->tme_suncg2_csr
1322: & TME_SUNCG2_CSR_CMAP_UPDATE)) {
1323: suncg2->tme_suncg2_callout_flags |= TME_SUNCG2_CALLOUT_MODE_CHANGE;
1324: }
1325:
1326: /* unlock the mutex: */
1327: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
1328:
1329: /* no faults: */
1330: return (TME_OK);
1331: }
1332:
1333: /* the suncg2 TLB filler: */
1334: static int
1335: _tme_suncg2_tlb_fill(void *_suncg2, struct tme_bus_tlb *tlb,
1336: tme_bus_addr_t address, unsigned int cycles)
1337: {
1338: struct tme_suncg2 *suncg2;
1339: tme_uint8_t *memory;
1340: tme_bus_addr_t address_first;
1341: tme_bus_addr_t address_last;
1342:
1343: /* recover our data structure: */
1344: suncg2 = (struct tme_suncg2 *) _suncg2;
1345:
1346: /* initialize the TLB entry: */
1347: tme_bus_tlb_initialize(tlb);
1348:
1349: /* the fast reading and writing rwlock: */
1350: tlb->tme_bus_tlb_rwlock = &suncg2->tme_suncg2_rwlock;
1351:
1352: /* allow reading and writing: */
1353: tlb->tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE;
1354:
1355: /* our bus cycle handler private data: */
1356: tlb->tme_bus_tlb_cycle_private = _suncg2;
1357:
1358: /* lock the mutex: */
1359: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
1360:
1361: /* we require a connection: */
1362: assert (suncg2->tme_suncg2_fb_connection != NULL);
1363: assert (suncg2->tme_suncg2_displayed_memory != NULL);
1364:
1365: /* if this address falls in a bitmap: */
1366: if ((TME_SUNCG2_REG_BITMAP(0)
1367: <= address)
1368: && (address
1369: < TME_SUNCG2_REG_BITMAP(TME_SUNCG2_PLANE_MAX))) {
1370:
1371: /* the cycle handler: */
1372: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_raw;
1373:
1374: /* if we're displaying the pixmap: */
1375: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
1376:
1377: /* validate the bitmaps: */
1378: _tme_suncg2_validate_bitmaps(suncg2, tlb);
1379:
1380: /* this TLB entry covers all of the bitmap memory: */
1381: address_first = TME_SUNCG2_REG_BITMAP(0);
1382: address_last = TME_SUNCG2_REG_PIXMAP - 1;
1383: memory = suncg2->tme_suncg2_raw_memory + address_first;
1384:
1385: /* the displayed memory is now invalid: */
1386: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_DISPLAYED;
1387: }
1388:
1389: /* otherwise, we're displaying a bitmap: */
1390: else {
1391:
1392: /* calculate the first and last addresses of the displayed
1393: memory: */
1394: address_first = TME_SUNCG2_REG_BITMAP(suncg2->tme_suncg2_bitmap_mode_plane);
1395: address_last = address_first + (suncg2->tme_suncg2_pixel_count / 8) - 1;
1396:
1397: /* if this address is before the displayed memory, this TLB
1398: entry covers from the beginning of the bitmap memory up to
1399: the displayed memory: */
1400: if (address < address_first) {
1401: address_last = address_first - 1;
1402: address_first = TME_SUNCG2_REG_BITMAP(0);
1403: memory = suncg2->tme_suncg2_raw_memory + address_first;
1404:
1405: /* validate the bitmaps: */
1406: _tme_suncg2_validate_bitmaps(suncg2, tlb);
1407: }
1408:
1409: /* otherwise, if this address is after the displayed memory,
1410: this TLB entry covers from right after the displayed memory
1411: to the end of the bitmap memory: */
1412: else if (address > address_last) {
1413: address_first = address_last + 1;
1414: address_last = TME_SUNCG2_REG_PIXMAP - 1;
1415: memory = suncg2->tme_suncg2_raw_memory + address_first;
1416:
1417: /* validate the bitmaps: */
1418: _tme_suncg2_validate_bitmaps(suncg2, tlb);
1419: }
1420:
1421: /* otherwise, this address is in the displayed memory: */
1422: else {
1423: memory = suncg2->tme_suncg2_displayed_memory;
1424: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_displayed;
1425:
1426: /* validate the displayed memory: */
1427: _tme_suncg2_validate_displayed(suncg2, tlb);
1428: }
1429: }
1430:
1431: /* the address range: */
1432: TME_ATOMIC_WRITE(tme_bus_addr_t,
1433: tlb->tme_bus_tlb_addr_first,
1434: address_first);
1435: TME_ATOMIC_WRITE(tme_bus_addr_t,
1436: tlb->tme_bus_tlb_addr_last,
1437: address_last);
1438:
1439: /* this TLB entry allows fast reading and fast writing: */
1440: tlb->tme_bus_tlb_emulator_off_read = memory - address_first;
1441: tlb->tme_bus_tlb_emulator_off_write = memory - address_first;
1442:
1443: /* add this TLB entry: */
1444: _tme_suncg2_tlb_add(suncg2, tlb);
1445:
1446: /* the pixmap is now invalid: */
1447: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_PIXMAP;
1448: }
1449:
1450: /* if this address falls in the pixmap: */
1451: else if ((TME_SUNCG2_REG_PIXMAP
1452: <= address)
1453: && (address
1454: < (TME_SUNCG2_REG_PIXMAP + TME_SUNCG2_SIZ_PIXMAP))) {
1455:
1456: /* the cycle handler: */
1457: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_raw;
1458:
1459: /* if we're displaying the pixmap: */
1460: if (suncg2->tme_suncg2_bitmap_mode_plane == TME_SUNCG2_PLANE_MAX) {
1461:
1462: /* calculate the first and last addresses of the displayed memory: */
1463: address_first = TME_SUNCG2_REG_PIXMAP;
1464: address_last = TME_SUNCG2_REG_PIXMAP + suncg2->tme_suncg2_pixel_count - 1;
1465:
1466: /* if this address is after the displayed memory, we're in the pad: */
1467: if (address > address_last) {
1468: address_first = address_last + 1;
1469: address_last = TME_SUNCG2_REG_PIXMAP + TME_SUNCG2_SIZ_PIXMAP - 1;
1470: memory = suncg2->tme_suncg2_raw_memory + address_first;
1471:
1472: /* validate the pixmap: */
1473: _tme_suncg2_validate_pixmap(suncg2, tlb);
1474: }
1475:
1476: /* otherwise, this address is in the displayed memory: */
1477: else {
1478: memory = suncg2->tme_suncg2_displayed_memory;
1479: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_displayed;
1480:
1481: /* validate the displayed memory: */
1482: _tme_suncg2_validate_displayed(suncg2, tlb);
1483: }
1484: }
1485:
1486: /* otherwise, we're displaying a bitmap: */
1487: else {
1488:
1489: /* validate the pixmap: */
1490: _tme_suncg2_validate_pixmap(suncg2, tlb);
1491:
1492: /* this TLB covers all of pixmap memory: */
1493: address_first = TME_SUNCG2_REG_PIXMAP;
1494: address_last = TME_SUNCG2_REG_PIXMAP + TME_SUNCG2_SIZ_PIXMAP - 1;
1495: memory = suncg2->tme_suncg2_raw_memory + address_first;
1496:
1497: /* the displayed memory is now invalid: */
1498: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_DISPLAYED;
1499: }
1500:
1501: /* the address range: */
1502: TME_ATOMIC_WRITE(tme_bus_addr_t,
1503: tlb->tme_bus_tlb_addr_first,
1504: address_first);
1505: TME_ATOMIC_WRITE(tme_bus_addr_t,
1506: tlb->tme_bus_tlb_addr_last,
1507: address_last);
1508:
1509: /* this TLB entry allows fast reading and fast writing: */
1510: tlb->tme_bus_tlb_emulator_off_read = memory - address_first;
1511: tlb->tme_bus_tlb_emulator_off_write = memory - address_first;
1512:
1513: /* add this TLB entry: */
1514: _tme_suncg2_tlb_add(suncg2, tlb);
1515:
1516: /* the bitmaps are now invalid: */
1517: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_BITMAPS;
1518: }
1519:
1520: /* if this address falls in the rasterop data: */
1521: else if ((TME_SUNCG2_REG_ROP_DATA
1522: <= address)
1523: && (address
1524: < TME_SUNCG2_REG_ROPC_UNIT(0))) {
1525:
1526: /* the cycle handler: */
1527: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_rop_data;
1528:
1529: /* this TLB entry covers this range: */
1530: TME_ATOMIC_WRITE(tme_bus_addr_t,
1531: tlb->tme_bus_tlb_addr_first,
1532: TME_SUNCG2_REG_ROP_DATA);
1533: TME_ATOMIC_WRITE(tme_bus_addr_t,
1534: tlb->tme_bus_tlb_addr_last,
1535: (TME_SUNCG2_REG_ROPC_UNIT(0)
1536: - 1));
1537:
1538: /* this TLB entry cannot allow fast reading or fast writing, since
1539: this is the rasterop data: */
1540: }
1541:
1542: /* if this address falls in the registers: */
1543: else if ((TME_SUNCG2_REG_ROPC_UNIT(0)
1544: <= address)
1545: && (address
1546: < TME_SUNCG2_REG_CMAP_R)) {
1547:
1548: /* the cycle handler: */
1549: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_regs;
1550:
1551: /* this TLB entry covers this range: */
1552: TME_ATOMIC_WRITE(tme_bus_addr_t,
1553: tlb->tme_bus_tlb_addr_first,
1554: TME_SUNCG2_REG_ROPC_UNIT(0));
1555: TME_ATOMIC_WRITE(tme_bus_addr_t,
1556: tlb->tme_bus_tlb_addr_last,
1557: (TME_SUNCG2_REG_CMAP_R
1558: - 1));
1559:
1560: /* this TLB entry cannot allow fast reading or fast writing, since
1561: these are registers: */
1562: }
1563:
1564: /* if this address falls in the colormap registers: */
1565: else if ((TME_SUNCG2_REG_CMAP_R
1566: <= address)
1567: && (address
1568: <= (TME_SUNCG2_SIZ_REGS
1569: - 1))) {
1570:
1571: /* the cycle handler: */
1572: tlb->tme_bus_tlb_cycle = _tme_suncg2_bus_cycle_cmap;
1573:
1574: /* this TLB entry covers this range: */
1575: TME_ATOMIC_WRITE(tme_bus_addr_t,
1576: tlb->tme_bus_tlb_addr_first,
1577: TME_SUNCG2_REG_CMAP_R);
1578: TME_ATOMIC_WRITE(tme_bus_addr_t,
1579: tlb->tme_bus_tlb_addr_last,
1580: TME_SUNCG2_SIZ_REGS - 1);
1581:
1582: /* this TLB entry allows fast reading: */
1583: tlb->tme_bus_tlb_emulator_off_read
1584: = (((tme_uint8_t *) suncg2->tme_suncg2_cmap_raw)
1585: - TME_SUNCG2_REG_CMAP_R);
1586: }
1587:
1588: /* XXX FIXME - this is a partial implementation: */
1589: else {
1590: abort();
1591: }
1592:
1593: /* unlock the mutex: */
1594: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
1595:
1596: return (TME_OK);
1597: }
1598:
1599: /* this makes a new framebuffer connection: */
1600: static int
1601: _tme_suncg2_connection_make(struct tme_connection *conn, unsigned int state)
1602: {
1603: struct tme_suncg2 *suncg2;
1604: struct tme_fb_connection *conn_fb;
1605: struct tme_fb_connection *conn_fb_other;
1606: int rc;
1607:
1608: /* recover our data structures: */
1609: suncg2 = conn->tme_connection_element->tme_element_private;
1610: conn_fb = (struct tme_fb_connection *) conn;
1611: conn_fb_other = (struct tme_fb_connection *) conn->tme_connection_other;
1612:
1613: /* both sides must be framebuffer connections: */
1614: assert(conn->tme_connection_type == TME_CONNECTION_FRAMEBUFFER);
1615: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_FRAMEBUFFER);
1616:
1617: /* lock our mutex: */
1618: tme_mutex_lock(&suncg2->tme_suncg2_mutex);
1619:
1620: /* once the connection is made, we know whether or not the other
1621: side of the connection is supplying specific memory that it wants
1622: us to use, or if we should allocate memory ourselves: */
1623: if (conn_fb->tme_fb_connection_buffer == NULL) {
1624: rc = tme_fb_xlat_alloc_src(conn_fb);
1625: assert (rc == TME_OK);
1626: }
1627: suncg2->tme_suncg2_displayed_memory = conn_fb->tme_fb_connection_buffer;
1628:
1629: /* invalidate any outstanding TLBs: */
1630: _tme_suncg2_tlb_invalidate(suncg2, NULL);
1631:
1632: /* the displayed memory is now invalid: */
1633: suncg2->tme_suncg2_flags |= TME_SUNCG2_FLAG_INVALID_DISPLAYED;
1634:
1635: /* we're always set up to answer calls across the connection, so we
1636: only have to do work when the connection has gone full, namely
1637: taking the other side of the connection: */
1638: if (state == TME_CONNECTION_FULL) {
1639:
1640: /* save our connection: */
1641: suncg2->tme_suncg2_fb_connection = conn_fb_other;
1642: }
1643:
1644: /* unlock our mutex: */
1645: tme_mutex_unlock(&suncg2->tme_suncg2_mutex);
1646:
1647: return (TME_OK);
1648: }
1649:
1650: /* this breaks a connection: */
1651: static int
1652: _tme_suncg2_connection_break(struct tme_connection *conn, unsigned int state)
1653: {
1654: abort();
1655: }
1656:
1657: /* this makes a new connection side for a suncg2: */
1658: static int
1659: _tme_suncg2_connections_new(struct tme_element *element,
1660: const char * const *args,
1661: struct tme_connection **_conns,
1662: char **_output)
1663: {
1664: struct tme_suncg2 *suncg2;
1665: struct tme_fb_connection *conn_fb;
1666: struct tme_connection *conn;
1667: int rc;
1668:
1669: /* recover our data structure: */
1670: suncg2 = (struct tme_suncg2 *) element->tme_element_private;
1671:
1672: /* make the generic bus device connection side: */
1673: rc = tme_bus_device_connections_new(element, args, _conns, _output);
1674: if (rc != TME_OK) {
1675: return (rc);
1676: }
1677:
1678: /* if we don't have a framebuffer connection, make one: */
1679: if (suncg2->tme_suncg2_fb_connection == NULL) {
1680:
1681: /* allocate the new framebuffer connection: */
1682: conn_fb = tme_new0(struct tme_fb_connection, 1);
1683: conn = &conn_fb->tme_fb_connection;
1684:
1685: /* fill in the generic connection: */
1686: conn->tme_connection_next = *_conns;
1687: conn->tme_connection_type = TME_CONNECTION_FRAMEBUFFER;
1688: conn->tme_connection_score = tme_fb_connection_score;
1689: conn->tme_connection_make = _tme_suncg2_connection_make;
1690: conn->tme_connection_break = _tme_suncg2_connection_break;
1691:
1692: /* fill in the framebuffer connection: */
1693: conn_fb->tme_fb_connection_mode_change = NULL;
1694: conn_fb->tme_fb_connection_update = _tme_suncg2_update;
1695:
1696: /* height and width: */
1697: conn_fb->tme_fb_connection_width = tme_sun_fb_p4_size_width(suncg2->tme_suncg2_size);
1698: conn_fb->tme_fb_connection_height = tme_sun_fb_p4_size_height(suncg2->tme_suncg2_size);
1699:
1700: /* we are color: */
1701: conn_fb->tme_fb_connection_class = TME_FB_XLAT_CLASS_COLOR;
1702: conn_fb->tme_fb_connection_depth = TME_SUNCG2_PLANE_MAX;
1703: conn_fb->tme_fb_connection_bits_per_pixel = TME_SUNCG2_PLANE_MAX;
1704:
1705: /* we skip no pixels at the start of the scanline: */
1706: conn_fb->tme_fb_connection_skipx = 0;
1707:
1708: /* we pad to 32-bit boundaries: */
1709: conn_fb->tme_fb_connection_scanline_pad = 32;
1710:
1711: /* we are big-endian: */
1712: conn_fb->tme_fb_connection_order = TME_ENDIAN_BIG;
1713:
1714: /* we don't allocate memory until the connection is made, in case
1715: the other side of the connection wants to provide us with a
1716: specific memory region to use (maybe we're on a system with a
1717: real cgtwo and we can write directly to its buffer): */
1718: conn_fb->tme_fb_connection_buffer = NULL;
1719:
1720: /* our pixels don't have subfields: */
1721: conn_fb->tme_fb_connection_mask_g = 0;
1722: conn_fb->tme_fb_connection_mask_r = 0;
1723: conn_fb->tme_fb_connection_mask_b = 0;
1724:
1725: /* intensities are eight bits and index mapped: */
1726: conn_fb->tme_fb_connection_map_bits = (8 * sizeof(suncg2->tme_suncg2_cmap[0]));
1727: conn_fb->tme_fb_connection_map_g = &suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_G)];
1728: conn_fb->tme_fb_connection_map_r = &suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_R)];
1729: conn_fb->tme_fb_connection_map_b = &suncg2->tme_suncg2_cmap[TME_SUNCG2_CMAP_INDEX(0, TME_SUNCG2_REG_CMAP_B)];
1730:
1731: /* return the connection side possibility: */
1732: *_conns = conn;
1733: }
1734:
1735: /* done: */
1736: return (TME_OK);
1737: }
1738:
1739: /* the new sun cgtwo function: */
1740: int
1741: tme_sun_cgtwo(struct tme_element *element, const char * const *args, char **_output)
1742: {
1743: struct tme_suncg2 *suncg2;
1744: tme_uint32_t cg2_type;
1745: tme_uint32_t cg2_size;
1746: int arg_i;
1747: int usage;
1748:
1749: /* check our arguments: */
1750: usage = 0;
1751: cg2_type = TME_SUNCG2_TYPE_NULL;
1752: cg2_size = TME_SUN_P4_SIZE_1152_900;
1753: arg_i = 1;
1754: for (;;) {
1755:
1756: /* the framebuffer type: */
1757: if (TME_ARG_IS(args[arg_i + 0], "type")) {
1758: if (TME_ARG_IS(args[arg_i + 1], "sun3")) {
1759: cg2_type = TME_SUNCG2_TYPE_SUN3;
1760: }
1761: else {
1762: usage = TRUE;
1763: break;
1764: }
1765: arg_i += 2;
1766: }
1767:
1768: /* the framebuffer size: */
1769: else if (TME_ARG_IS(args[arg_i + 0], "size")) {
1770: cg2_size = tme_sun_fb_p4_size(args[arg_i + 1]);
1771: if (cg2_size != TME_SUN_P4_SIZE_1152_900
1772: && cg2_size != TME_SUN_P4_SIZE_1024_1024) {
1773: usage = TRUE;
1774: break;
1775: }
1776: arg_i += 2;
1777: }
1778:
1779: /* if we ran out of arguments: */
1780: else if (args[arg_i] == NULL) {
1781: break;
1782: }
1783:
1784: /* otherwise this is a bad argument: */
1785: else {
1786: tme_output_append_error(_output,
1787: "%s %s, ",
1788: args[arg_i],
1789: _("unexpected"));
1790: usage = TRUE;
1791: break;
1792: }
1793: }
1794:
1795: /* a cgtwo type must have been given: */
1796: if (cg2_type == TME_SUNCG2_TYPE_NULL) {
1797: usage = TRUE;
1798: }
1799:
1800: if (usage) {
1801: tme_output_append_error(_output,
1802: "%s %s type sun3 [ size { 1152x900 | 1024x1024 } ]",
1803: _("usage:"),
1804: args[0]);
1805: return (EINVAL);
1806: }
1807:
1808: /* start the suncg2 structure: */
1809: suncg2 = tme_new0(struct tme_suncg2, 1);
1810: suncg2->tme_suncg2_element = element;
1811: tme_mutex_init(&suncg2->tme_suncg2_mutex);
1812: tme_rwlock_init(&suncg2->tme_suncg2_rwlock);
1813:
1814: /* set the cgtwo type: */
1815: suncg2->tme_suncg2_type = cg2_type;
1816:
1817: /* set the cgtwo size: */
1818: suncg2->tme_suncg2_size = cg2_size;
1819:
1820: /* start displaying the pixmap: */
1821: suncg2->tme_suncg2_bitmap_mode_plane = TME_SUNCG2_PLANE_MAX;
1822:
1823: /* set our initial CSR: */
1824: suncg2->tme_suncg2_csr
1825: = (TME_SUNCG2_CSR_ENABLE_VIDEO
1826: | (cg2_size == TME_SUN_P4_SIZE_1024_1024
1827: ? TME_SUNCG2_CSR_SIZE_1024_1024
1828: : TME_SUNCG2_CSR_SIZE_1152_900));
1829:
1830: /* if this is a sun3 cgtwo: */
1831: if (cg2_type == TME_SUNCG2_TYPE_SUN3) {
1832: /* nothing to do */
1833: }
1834:
1835: /* calculate the pixel count: */
1836: suncg2->tme_suncg2_pixel_count
1837: = (tme_sun_fb_p4_size_width(cg2_size)
1838: * tme_sun_fb_p4_size_height(cg2_size));
1839:
1840: /* allocate the raw memory: */
1841: suncg2->tme_suncg2_raw_memory
1842: = tme_new0(tme_uint8_t, TME_SUNCG2_REG_PIXMAP + TME_SUNCG2_SIZ_PIXMAP);
1843:
1844: /* initialize our simple bus device descriptor: */
1845: suncg2->tme_suncg2_device.tme_bus_device_element = element;
1846: suncg2->tme_suncg2_device.tme_bus_device_tlb_fill = _tme_suncg2_tlb_fill;
1847: suncg2->tme_suncg2_device.tme_bus_device_address_last = TME_SUNCG2_SIZ_REGS - 1;
1848:
1849: /* fill the element: */
1850: element->tme_element_private = suncg2;
1851: element->tme_element_connections_new = _tme_suncg2_connections_new;
1852:
1853: return (TME_OK);
1854: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.