![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun-bwtwo.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-bwtwo.c CVS log | Up to [The Machine Emulator] / tme / machine / sun |
1.1 root 1: /* $Id: sun-bwtwo.c,v 1.2 2005/04/30 15:12:56 fredette Exp $ */
2:
3: /* machine/sun/sun-bwtwo.c - Sun bwtwo emulation: */
4:
5: /*
6: * Copyright (c) 2003, 2004 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-bwtwo.c,v 1.2 2005/04/30 15:12:56 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: /* bwtwo types: */
48: #define TME_SUNBW2_TYPE_NULL (0)
49: #define TME_SUNBW2_TYPE_MULTIBUS (1)
50: #define TME_SUNBW2_TYPE_OLD_ONBOARD (2)
51: #define TME_SUNBW2_TYPE_ONBOARD (3)
52: #define TME_SUNBW2_TYPE_P4 (4)
53:
54: /* register offsets and sizes: */
55: #define TME_SUNBW2_REG_CSR_MULTIBUS (0x81800)
56: #define TME_SUNBW2_REG_CSR_OLD_ONBOARD (0x20000)
57: #define TME_SUNBW2_SIZ_CSR (0x00002)
58: #define TME_SUNBW2_SIZ_CSR_PAGE (0x00800)
59: #define TME_SUNBW2_REG_P4 (0x00000)
60: #define TME_SUNBW2_SIZ_P4_PAGE (sizeof(tme_uint32_t))
61:
62: /* the bits in the Multibus and old-onboard Control/Status register: */
63: #define TME_SUNBW2_CSR_ENABLE_VIDEO (0x8000) /* enable video */
64: #define TME_SUNBW2_CSR_ENABLE_COPY (0x4000) /* enable copy mode */
65: #define TME_SUNBW2_CSR_ENABLE_INT (0x2000) /* interrupt enable */
66: #define TME_SUNBW2_CSR_INT_ACTIVE (0x1000) /* interrupt is active */
67: #define TME_SUNBW2_CSR_JUMPER_B (0x0800) /* jumper B */
68: #define TME_SUNBW2_CSR_JUMPER_A (0x0400) /* jumper A */
69: #define TME_SUNBW2_CSR_JUMPER_COLOR (0x0200) /* jumper color */
70: #define TME_SUNBW2_CSR_JUMPER_HIRES (0x0100) /* jumper hires */
71: #define TME_SUNBW2_CSR_COPYBASE_MASK (0x007E) /* copybase mask */
72:
73: #if 0
74: #define TME_SUNBW2_DEBUG
75: #endif
76:
77: /* structures: */
78:
79: /* the card: */
80: struct tme_sunbw2 {
81:
82: /* our simple bus device header: */
83: struct tme_bus_device tme_sunbw2_device;
84: #define tme_sunbw2_element tme_sunbw2_device.tme_bus_device_element
85:
86: /* the mutex protecting the card: */
87: tme_mutex_t tme_sunbw2_mutex;
88:
89: /* the rwlock protecting the card: */
90: tme_rwlock_t tme_sunbw2_rwlock;
91:
92: /* the framebuffer connection: */
93: struct tme_fb_connection *tme_sunbw2_fb_connection;
94:
95: /* the type of the bwtwo: */
96: tme_uint32_t tme_sunbw2_type;
97:
98: /* the size of the bwtwo: */
99: tme_uint32_t tme_sunbw2_size;
100:
101: /* the (relative) bus address of our csr register: */
102: tme_bus_addr_t tme_sunbw2_csr_address;
103:
104: /* the (relative) bus addresses of the first byte of framebuffer
105: memory, the last byte of displayed framebuffer memory, and the
106: last byte of framebuffer memory: */
107: tme_bus_addr_t tme_sunbw2_fb_address_first;
108: tme_bus_addr_t tme_sunbw2_fb_address_last_displayed;
109: tme_bus_addr_t tme_sunbw2_fb_address_last;
110:
111: /* the framebuffer memory: */
112: tme_uint8_t *tme_sunbw2_fb_memory;
113:
114: /* any pad memory: */
115: tme_uint8_t *tme_sunbw2_pad_memory;
116:
117: /* our csr: */
118: tme_uint16_t tme_sunbw2_csr;
119:
120: /* our P4 register: */
121: tme_uint32_t tme_sunbw2_p4;
122:
123: /* our second bus subregion: */
124: struct tme_bus_subregion tme_sunbw2_subregion1;
125: };
126:
127: #ifdef TME_SUNBW2_DEBUG
128: #define TME_SUNBW2_LO_WIDTH (1152)
129: #define TME_SUNBW2_LO_HEIGHT (900)
130: static int
131: _tme_sunbw2_update_debug(struct tme_fb_connection *conn_fb)
132: {
133: struct tme_sunbw2 *sunbw2;
134: static int y = -1;
135: static int x;
136: unsigned long pixel;
137: unsigned int pixel_byte;
138: tme_uint8_t pixel_bit;
139: int box, box_y, box_x;
140:
141: sunbw2 = conn_fb->tme_fb_connection.tme_connection_element->tme_element_private;
142:
143: for (box = 0; box < 2; box++) {
144: if (y < 0) {
145: y = 16;
146: x = 0;
147: continue;
148: }
149: for (box_y = 0; box_y < 2; box_y++) {
150: for (box_x = 0; box_x < 2; box_x++) {
151: pixel = (((y + box_y)
152: * TME_SUNBW2_LO_WIDTH)
153: + x
154: + box_x);
155: pixel_byte = (pixel / 8);
156: pixel_bit = (0x80 >> (pixel % 8));
157: sunbw2->tme_sunbw2_fb_memory[pixel_byte] ^= pixel_bit;
158: }
159: }
160: if (box == 0) {
161: x += 2;
162: if (x == TME_SUNBW2_LO_WIDTH) {
163: x = 0;
164: y += 2;
165: if (y == TME_SUNBW2_LO_HEIGHT) {
166: y = 0;
167: }
168: }
169: }
170: }
171:
172: return (TME_OK);
173: }
174: #undef TME_SUNBW2_LO_WIDTH
175: #undef TME_SUNBW2_LO_HEIGHT
176: #endif /* TME_SUNBW2_DEBUG */
177:
178: /* the sunbw2 framebuffer bus cycle handler: */
179: static int
180: _tme_sunbw2_bus_cycle_fb(void *_sunbw2, struct tme_bus_cycle *cycle_init)
181: {
182: struct tme_sunbw2 *sunbw2;
183:
184: /* recover our data structure: */
185: sunbw2 = (struct tme_sunbw2 *) _sunbw2;
186:
187: /* lock the mutex: */
188: tme_mutex_lock(&sunbw2->tme_sunbw2_mutex);
189:
190: /* run the cycle: */
191: assert (cycle_init->tme_bus_cycle_address
192: >= sunbw2->tme_sunbw2_fb_address_first);
193: tme_bus_cycle_xfer_memory(cycle_init,
194: (sunbw2->tme_sunbw2_fb_memory
195: - sunbw2->tme_sunbw2_fb_address_first),
196: sunbw2->tme_sunbw2_fb_address_last_displayed);
197:
198: /* unlock the mutex: */
199: tme_mutex_unlock(&sunbw2->tme_sunbw2_mutex);
200:
201: /* no faults: */
202: return (TME_OK);
203: }
204:
205: /* the sunbw2 pad bus cycle handler: */
206: static int
207: _tme_sunbw2_bus_cycle_pad(void *_sunbw2, struct tme_bus_cycle *cycle_init)
208: {
209: struct tme_sunbw2 *sunbw2;
210:
211: /* recover our data structure: */
212: sunbw2 = (struct tme_sunbw2 *) _sunbw2;
213:
214: /* lock the mutex: */
215: tme_mutex_lock(&sunbw2->tme_sunbw2_mutex);
216:
217: /* run the cycle: */
218: assert (cycle_init->tme_bus_cycle_address
219: > sunbw2->tme_sunbw2_fb_address_last_displayed);
220: tme_bus_cycle_xfer_memory(cycle_init,
221: (sunbw2->tme_sunbw2_pad_memory
222: - (sunbw2->tme_sunbw2_fb_address_last_displayed
223: + 1)),
224: sunbw2->tme_sunbw2_fb_address_last);
225:
226: /* unlock the mutex: */
227: tme_mutex_unlock(&sunbw2->tme_sunbw2_mutex);
228:
229: /* no faults: */
230: return (TME_OK);
231: }
232:
233: /* the sunbw2 CSR bus cycle handler: */
234: static int
235: _tme_sunbw2_bus_cycle_csr(void *_sunbw2, struct tme_bus_cycle *cycle_init)
236: {
237: struct tme_sunbw2 *sunbw2;
238: tme_uint16_t csr_old, csr_new;
239: tme_bus_addr_t undecoded;
240:
241: /* recover our data structure: */
242: sunbw2 = (struct tme_sunbw2 *) _sunbw2;
243:
244: /* lock the mutex: */
245: tme_mutex_lock(&sunbw2->tme_sunbw2_mutex);
246:
247: /* get the old CSR value: */
248: csr_old = tme_betoh_u16(sunbw2->tme_sunbw2_csr);
249:
250: /* the entire 2KB (one page's) worth of addresses at
251: tme_sunbw2_csr_address are all decoded (or, rather, not decoded)
252: as the CSR: */
253: undecoded
254: = (cycle_init->tme_bus_cycle_address
255: & (TME_SUNBW2_SIZ_CSR_PAGE - sizeof(sunbw2->tme_sunbw2_csr)));
256: cycle_init->tme_bus_cycle_address
257: -= undecoded;
258:
259: /* run the cycle: */
260: assert (cycle_init->tme_bus_cycle_address
261: >= sunbw2->tme_sunbw2_csr_address);
262: tme_bus_cycle_xfer_memory(cycle_init,
263: (((tme_uint8_t *) &sunbw2->tme_sunbw2_csr)
264: - sunbw2->tme_sunbw2_csr_address),
265: (sunbw2->tme_sunbw2_csr_address
266: + sizeof(sunbw2->tme_sunbw2_csr)
267: - 1));
268: cycle_init->tme_bus_cycle_address
269: += undecoded;
270:
271: /* get the new CSR value: */
272: csr_new = tme_betoh_u16(sunbw2->tme_sunbw2_csr);
273:
274: /* put back the unchanging bits: */
275: csr_new
276: = ((csr_new
277: & ~(TME_SUNBW2_CSR_INT_ACTIVE
278: | TME_SUNBW2_CSR_JUMPER_B
279: | TME_SUNBW2_CSR_JUMPER_A
280: | TME_SUNBW2_CSR_JUMPER_COLOR
281: | TME_SUNBW2_CSR_JUMPER_HIRES))
282: | (csr_old
283: & (TME_SUNBW2_CSR_INT_ACTIVE
284: | TME_SUNBW2_CSR_JUMPER_B
285: | TME_SUNBW2_CSR_JUMPER_A
286: | TME_SUNBW2_CSR_JUMPER_COLOR
287: | TME_SUNBW2_CSR_JUMPER_HIRES)));
288:
289: /* we do not support these bits: */
290: if (csr_new
291: & (TME_SUNBW2_CSR_ENABLE_COPY
292: | TME_SUNBW2_CSR_ENABLE_INT)) {
293: abort();
294: }
295:
296: /* set the new CSR value: */
297: sunbw2->tme_sunbw2_csr = tme_htobe_u16(csr_new);
298:
299: /* unlock the mutex: */
300: tme_mutex_unlock(&sunbw2->tme_sunbw2_mutex);
301:
302: /* no faults: */
303: return (TME_OK);
304: }
305:
306: /* the sunbw2 P4 bus cycle handler: */
307: static int
308: _tme_sunbw2_bus_cycle_p4(void *_sunbw2, struct tme_bus_cycle *cycle_init)
309: {
310: struct tme_sunbw2 *sunbw2;
311: tme_uint32_t p4_old, p4_new;
312: tme_bus_addr_t undecoded;
313:
314: /* recover our data structure: */
315: sunbw2 = (struct tme_sunbw2 *) _sunbw2;
316:
317: /* lock the mutex: */
318: tme_mutex_lock(&sunbw2->tme_sunbw2_mutex);
319:
320: /* get the old P4 value: */
321: p4_old = tme_betoh_u32(sunbw2->tme_sunbw2_p4);
322:
323: /* the entire ?KB (one page's) worth of addresses at
324: TME_SUNBW2_REG_P4 are all decoded (or, rather, not decoded)
325: as the P4: */
326: undecoded
327: = (cycle_init->tme_bus_cycle_address
328: & (TME_SUNBW2_SIZ_P4_PAGE - sizeof(sunbw2->tme_sunbw2_p4)));
329: cycle_init->tme_bus_cycle_address
330: -= undecoded;
331:
332: /* run the cycle: */
333: assert (cycle_init->tme_bus_cycle_address
334: >= TME_SUNBW2_REG_P4);
335: tme_bus_cycle_xfer_memory(cycle_init,
336: (((tme_uint8_t *) &sunbw2->tme_sunbw2_p4)
337: - TME_SUNBW2_REG_P4),
338: (TME_SUNBW2_REG_P4
339: + sizeof(sunbw2->tme_sunbw2_p4)
340: - 1));
341: cycle_init->tme_bus_cycle_address
342: += undecoded;
343:
344: /* get the new P4 value: */
345: p4_new = tme_betoh_u32(sunbw2->tme_sunbw2_p4);
346:
347: /* put back the unchanging bits: */
348: p4_new
349: = ((p4_new
350: & ~TME_SUN_P4_RO_MASK)
351: | (p4_old
352: & TME_SUN_P4_RO_MASK));
353:
354: /* we do not support these bits: */
355: if (p4_new
356: & (TME_SUN_P4_REG_SYNC_RAMDAC
357: | TME_SUN_P4_REG_ENABLE_INT)) {
358: abort();
359: }
360:
361: /* set the new P4 value: */
362: sunbw2->tme_sunbw2_p4 = tme_htobe_u32(p4_new);
363:
364: /* unlock the mutex: */
365: tme_mutex_unlock(&sunbw2->tme_sunbw2_mutex);
366:
367: /* no faults: */
368: return (TME_OK);
369: }
370:
371: /* the sunbw2 TLB filler: */
372: static int
373: _tme_sunbw2_tlb_fill(void *_sunbw2, struct tme_bus_tlb *tlb,
374: tme_bus_addr_t address, unsigned int cycles)
375: {
376: struct tme_sunbw2 *sunbw2;
377:
378: /* recover our data structure: */
379: sunbw2 = (struct tme_sunbw2 *) _sunbw2;
380:
381: /* initialize the TLB entry: */
382: tme_bus_tlb_initialize(tlb);
383:
384: /* if this is a Multibus or old-onboard bwtwo, and the address falls in the CSR: */
385: if (((sunbw2->tme_sunbw2_type
386: == TME_SUNBW2_TYPE_MULTIBUS)
387: || (sunbw2->tme_sunbw2_type
388: == TME_SUNBW2_TYPE_OLD_ONBOARD))
389: && (sunbw2->tme_sunbw2_csr_address
390: <= address)
391: && (address
392: < (sunbw2->tme_sunbw2_csr_address
393: + TME_SUNBW2_SIZ_CSR_PAGE))) {
394:
395: tlb->tme_bus_tlb_cycle = _tme_sunbw2_bus_cycle_csr;
396:
397: /* this TLB entry covers this range: */
398: TME_ATOMIC_WRITE(tme_bus_addr_t,
399: tlb->tme_bus_tlb_addr_first,
400: sunbw2->tme_sunbw2_csr_address);
401: TME_ATOMIC_WRITE(tme_bus_addr_t,
402: tlb->tme_bus_tlb_addr_last,
403: (sunbw2->tme_sunbw2_csr_address
404: + TME_SUNBW2_SIZ_CSR
405: - 1));
406:
407: /* this TLB entry cannot allow fast reading, since the page the
408: CSR is on isn't fully decoded - all words on the 2KB page are
409: the CSR: */
410: }
411:
412: /* if this is a P4 bwtwo, and the address falls in the P4 register: */
413: else if ((sunbw2->tme_sunbw2_type
414: == TME_SUNBW2_TYPE_P4)
415: && (address
416: < (TME_SUNBW2_REG_P4
417: + TME_SUNBW2_SIZ_P4_PAGE))) {
418:
419: tlb->tme_bus_tlb_cycle = _tme_sunbw2_bus_cycle_p4;
420:
421: /* this TLB entry covers this range: */
422: TME_ATOMIC_WRITE(tme_bus_addr_t,
423: tlb->tme_bus_tlb_addr_first,
424: TME_SUNBW2_REG_P4);
425: TME_ATOMIC_WRITE(tme_bus_addr_t,
426: tlb->tme_bus_tlb_addr_last,
427: (TME_SUNBW2_REG_P4
428: + TME_SUNBW2_SIZ_P4_PAGE
429: - 1));
430:
431: /* this TLB entry cannot allow fast reading, since the page the
432: P4 register is on isn't fully decoded - all words on the ?KB page are
433: the P4 register: */
434: }
435:
436: /* if this address falls in the displayed framebuffer memory: */
437: else if ((sunbw2->tme_sunbw2_fb_address_first
438: <= address)
439: && (address
440: <= sunbw2->tme_sunbw2_fb_address_last_displayed)) {
441:
442: assert (sunbw2->tme_sunbw2_fb_connection != NULL);
443:
444: tlb->tme_bus_tlb_cycle = _tme_sunbw2_bus_cycle_fb;
445:
446: /* this TLB entry covers this range: */
447: TME_ATOMIC_WRITE(tme_bus_addr_t,
448: tlb->tme_bus_tlb_addr_first,
449: sunbw2->tme_sunbw2_fb_address_first);
450: TME_ATOMIC_WRITE(tme_bus_addr_t,
451: tlb->tme_bus_tlb_addr_last,
452: sunbw2->tme_sunbw2_fb_address_last_displayed);
453:
454: /* this TLB entry allows fast reading and writing: */
455: tlb->tme_bus_tlb_emulator_off_read
456: = (sunbw2->tme_sunbw2_fb_memory
457: - sunbw2->tme_sunbw2_fb_address_first);
458: tlb->tme_bus_tlb_emulator_off_write
459: = (sunbw2->tme_sunbw2_fb_memory
460: - sunbw2->tme_sunbw2_fb_address_first);
461: }
462:
463: /* if this address falls in the pad memory: */
464: else if ((sunbw2->tme_sunbw2_fb_address_last_displayed
465: < address)
466: && (address
467: <= sunbw2->tme_sunbw2_fb_address_last)) {
468:
469: tlb->tme_bus_tlb_cycle = _tme_sunbw2_bus_cycle_pad;
470:
471: /* this TLB entry covers this range: */
472: TME_ATOMIC_WRITE(tme_bus_addr_t,
473: tlb->tme_bus_tlb_addr_first,
474: (sunbw2->tme_sunbw2_fb_address_last_displayed
475: + 1));
476: TME_ATOMIC_WRITE(tme_bus_addr_t,
477: tlb->tme_bus_tlb_addr_last,
478: sunbw2->tme_sunbw2_fb_address_last);
479:
480: /* this TLB entry allows fast reading and writing: */
481: tlb->tme_bus_tlb_emulator_off_read
482: = (sunbw2->tme_sunbw2_pad_memory
483: - (sunbw2->tme_sunbw2_fb_address_last_displayed
484: + 1));
485: tlb->tme_bus_tlb_emulator_off_write
486: = (sunbw2->tme_sunbw2_pad_memory
487: - (sunbw2->tme_sunbw2_fb_address_last_displayed
488: + 1));
489: }
490:
491: /* the fast reading and writing rwlock: */
492: tlb->tme_bus_tlb_rwlock = &sunbw2->tme_sunbw2_rwlock;
493:
494: /* allow reading and writing: */
495: tlb->tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE;
496:
497: /* our bus cycle handler private data: */
498: tlb->tme_bus_tlb_cycle_private = _sunbw2;
499:
500: return (TME_OK);
501: }
502:
503: /* this makes a new framebuffer connection: */
504: static int
505: _tme_sunbw2_connection_make(struct tme_connection *conn, unsigned int state)
506: {
507: struct tme_sunbw2 *sunbw2;
508: struct tme_fb_connection *conn_fb;
509: struct tme_fb_connection *conn_fb_other;
510: int rc;
511:
512: /* recover our data structures: */
513: sunbw2 = conn->tme_connection_element->tme_element_private;
514: conn_fb = (struct tme_fb_connection *) conn;
515: conn_fb_other = (struct tme_fb_connection *) conn->tme_connection_other;
516:
517: /* both sides must be framebuffer connections: */
518: assert(conn->tme_connection_type == TME_CONNECTION_FRAMEBUFFER);
519: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_FRAMEBUFFER);
520:
521: /* lock our mutex: */
522: tme_mutex_lock(&sunbw2->tme_sunbw2_mutex);
523:
524: /* once the connection is made, we know whether or not the other
525: side of the connection is supplying specific memory that it wants
526: us to use, or if we should allocate memory ourselves: */
527: if (conn_fb->tme_fb_connection_buffer == NULL) {
528: rc = tme_fb_xlat_alloc_src(conn_fb);
529: assert (rc == TME_OK);
530: }
531: sunbw2->tme_sunbw2_fb_memory = conn_fb->tme_fb_connection_buffer;
532:
533: /* we're always set up to answer calls across the connection, so we
534: only have to do work when the connection has gone full, namely
535: taking the other side of the connection: */
536: if (state == TME_CONNECTION_FULL) {
537:
538: /* save our connection: */
539: sunbw2->tme_sunbw2_fb_connection = conn_fb_other;
540: }
541:
542: /* unlock our mutex: */
543: tme_mutex_unlock(&sunbw2->tme_sunbw2_mutex);
544:
545: return (TME_OK);
546: }
547:
548: /* this breaks a connection: */
549: static int
550: _tme_sunbw2_connection_break(struct tme_connection *conn, unsigned int state)
551: {
552: abort();
553: }
554:
555: /* this makes a new connection side for a sunbw2: */
556: static int
557: _tme_sunbw2_connections_new(struct tme_element *element,
558: const char * const *args,
559: struct tme_connection **_conns,
560: char **_output)
561: {
562: struct tme_sunbw2 *sunbw2;
563: struct tme_fb_connection *conn_fb;
564: struct tme_connection *conn;
565: int rc;
566:
567: /* recover our data structure: */
568: sunbw2 = (struct tme_sunbw2 *) element->tme_element_private;
569:
570: /* make the generic bus device connection side: */
571: rc = tme_bus_device_connections_new(element, args, _conns, _output);
572: if (rc != TME_OK) {
573: return (rc);
574: }
575:
576: /* if we don't have a framebuffer connection, make one: */
577: if (sunbw2->tme_sunbw2_fb_connection == NULL) {
578:
579: /* allocate the new framebuffer connection: */
580: conn_fb = tme_new0(struct tme_fb_connection, 1);
581: conn = &conn_fb->tme_fb_connection;
582:
583: /* fill in the generic connection: */
584: conn->tme_connection_next = *_conns;
585: conn->tme_connection_type = TME_CONNECTION_FRAMEBUFFER;
586: conn->tme_connection_score = tme_fb_connection_score;
587: conn->tme_connection_make = _tme_sunbw2_connection_make;
588: conn->tme_connection_break = _tme_sunbw2_connection_break;
589:
590: /* fill in the framebuffer connection: */
591: conn_fb->tme_fb_connection_mode_change = NULL;
592: #ifdef TME_SUNBW2_DEBUG
593: conn_fb->tme_fb_connection_update = _tme_sunbw2_update_debug;
594: #else /* !TME_SUNBW2_DEBUG */
595: conn_fb->tme_fb_connection_update = NULL;
596: #endif /* !TME_SUNBW2_DEBUG */
597:
598: /* height and width: */
599: conn_fb->tme_fb_connection_width = tme_sun_fb_p4_size_width(sunbw2->tme_sunbw2_size);
600: conn_fb->tme_fb_connection_height = tme_sun_fb_p4_size_height(sunbw2->tme_sunbw2_size);
601:
602: /* we are monochrome: */
603: conn_fb->tme_fb_connection_class = TME_FB_XLAT_CLASS_MONOCHROME;
604: conn_fb->tme_fb_connection_depth = 1;
605: conn_fb->tme_fb_connection_bits_per_pixel = 1;
606:
607: /* we skip no pixels at the start of the scanline: */
608: conn_fb->tme_fb_connection_skipx = 0;
609:
610: /* we pad to 32-bit boundaries: */
611: conn_fb->tme_fb_connection_scanline_pad = 32;
612:
613: /* we are big-endian: */
614: conn_fb->tme_fb_connection_order = TME_ENDIAN_BIG;
615:
616: /* we don't allocate memory until the connection is made, in case
617: the other side of the connection wants to provide us with a
618: specific memory region to use (maybe we're on a system with a
619: real bwtwo and we can write directly to its buffer): */
620: conn_fb->tme_fb_connection_buffer = NULL;
621:
622: /* our pixels don't have subfields: */
623: conn_fb->tme_fb_connection_mask_g = 0;
624: conn_fb->tme_fb_connection_mask_r = 0;
625: conn_fb->tme_fb_connection_mask_b = 0;
626:
627: /* intensities are a single bit, linearly mapped, but inverted: */
628: conn_fb->tme_fb_connection_map_bits = 1;
629: conn_fb->tme_fb_connection_map_g = NULL;
630: conn_fb->tme_fb_connection_map_r = NULL;
631: conn_fb->tme_fb_connection_map_b = NULL;
632: conn_fb->tme_fb_connection_inverted = TRUE;
633:
634: /* return the connection side possibility: */
635: *_conns = conn;
636: }
637:
638: /* done: */
639: return (TME_OK);
640: }
641:
642: /* the new sun bwtwo function: */
643: int
644: tme_sun_bwtwo(struct tme_element *element, const char * const *args, char **_output)
645: {
646: struct tme_sunbw2 *sunbw2;
647: struct tme_bus_subregion *fb_subregion;
648: struct tme_bus_subregion *reg_subregion;
649: tme_uint32_t bw2_type;
650: tme_uint32_t bw2_size;
651: tme_bus_addr_t fb_size;
652: int arg_i;
653: int usage;
654:
655: /* check our arguments: */
656: usage = 0;
657: bw2_type = TME_SUNBW2_TYPE_NULL;
658: bw2_size = TME_SUN_P4_SIZE_1152_900;
659: arg_i = 1;
660: for (;;) {
661:
662: /* the framebuffer type: */
663: if (TME_ARG_IS(args[arg_i + 0], "type")) {
664: if (TME_ARG_IS(args[arg_i + 1], "multibus")) {
665: bw2_type = TME_SUNBW2_TYPE_MULTIBUS;
666: }
667: else if (TME_ARG_IS(args[arg_i + 1], "old-onboard")) {
668: bw2_type = TME_SUNBW2_TYPE_OLD_ONBOARD;
669: }
670: else if (TME_ARG_IS(args[arg_i + 1], "onboard")) {
671: bw2_type = TME_SUNBW2_TYPE_ONBOARD;
672: }
673: else if (TME_ARG_IS(args[arg_i + 1], "P4")) {
674: bw2_type = TME_SUNBW2_TYPE_P4;
675: }
676: else {
677: usage = TRUE;
678: break;
679: }
680: arg_i += 2;
681: }
682:
683: /* the framebuffer size: */
684: else if (TME_ARG_IS(args[arg_i + 0], "size")) {
685: bw2_size = tme_sun_fb_p4_size(args[arg_i + 1]);
686: if (bw2_size == TME_SUN_P4_SIZE_NULL) {
687: usage = TRUE;
688: break;
689: }
690: arg_i += 2;
691: }
692:
693: /* if we ran out of arguments: */
694: else if (args[arg_i] == NULL) {
695:
696: break;
697: }
698:
699: /* otherwise this is a bad argument: */
700: else {
701: tme_output_append_error(_output,
702: "%s %s, ",
703: args[arg_i],
704: _("unexpected"));
705: usage = TRUE;
706: break;
707: }
708: }
709:
710: /* dispatch on the bwtwo type to check that it and the size are
711: valid: */
712: switch (bw2_type) {
713:
714: /* no bwtwo type was specified: */
715: case TME_SUNBW2_TYPE_NULL:
716: /* XXX TBD */
717: usage = TRUE;
718: break;
719:
720: /* the original Multibus bwtwo and onboard bwtwo only support
721: 1152x900 and 1024x1024: */
722: case TME_SUNBW2_TYPE_MULTIBUS:
723: case TME_SUNBW2_TYPE_OLD_ONBOARD:
724: if (bw2_size != TME_SUN_P4_SIZE_1152_900
725: && bw2_size != TME_SUN_P4_SIZE_1024_1024) {
726: /* XXX TBD */
727: usage = TRUE;
728: }
729: break;
730:
731: /* the sizes supported by a CSR-less bwtwo appear to depend on the
732: actual model; we assume the user knows what he is doing: */
733: case TME_SUNBW2_TYPE_ONBOARD:
734: break;
735:
736: /* we allow creating a P4 bwtwo with any of the P4 sizes, again
737: assuming that the user knows what he is doing: */
738: case TME_SUNBW2_TYPE_P4:
739: break;
740:
741: default:
742: assert(FALSE);
743: break;
744: }
745:
746: if (usage) {
747: tme_output_append_error(_output,
748: "%s %s type { multibus | old-onboard | onboard | P4 } [ size { 1600x1280 | 1152x900 | 1024x1024 | 1280x1024 | 1440x1440 | 640x480 } ]",
749: _("usage:"),
750: args[0]);
751: return (EINVAL);
752: }
753:
754: /* start the sunbw2 structure: */
755: sunbw2 = tme_new0(struct tme_sunbw2, 1);
756: sunbw2->tme_sunbw2_element = element;
757: tme_mutex_init(&sunbw2->tme_sunbw2_mutex);
758: tme_rwlock_init(&sunbw2->tme_sunbw2_rwlock);
759:
760: /* set the bwtwo type: */
761: sunbw2->tme_sunbw2_type = bw2_type;
762:
763: /* set the bwtwo size: */
764: sunbw2->tme_sunbw2_size = bw2_size;
765:
766: /* assume the (relative) bus address of the first byte of displayed
767: framebuffer memory: */
768: sunbw2->tme_sunbw2_fb_address_first = 0;
769:
770: /* assume that the number of bytes of framebuffer memory is the
771: minimum number of bytes required, rounded up to the nearest power
772: of two: */
773: fb_size = ((tme_sun_fb_p4_size_width(bw2_size)
774: * tme_sun_fb_p4_size_height(bw2_size))
775: / 8);
776: if ((fb_size & (fb_size - 1)) != 0) {
777: for (; (fb_size & (fb_size - 1)) != 0; fb_size &= (fb_size - 1));
778: fb_size <<= 1;
779: }
780:
781: /* assume that we will attach to two bus subregions, and that the
782: framebuffer memory will be first: */
783: fb_subregion = &sunbw2->tme_sunbw2_device.tme_bus_device_subregions;
784: fb_subregion->tme_bus_subregion_next = &sunbw2->tme_sunbw2_subregion1;
785: sunbw2->tme_sunbw2_subregion1.tme_bus_subregion_next = NULL;
786:
787: /* dispatch on the bwtwo type: */
788: switch (bw2_type) {
789: case TME_SUNBW2_TYPE_MULTIBUS:
790: case TME_SUNBW2_TYPE_OLD_ONBOARD:
791:
792: /* set our initial CSR: */
793: sunbw2->tme_sunbw2_csr
794: = tme_htobe_u16(TME_SUNBW2_CSR_ENABLE_VIDEO
795: | (bw2_size == TME_SUN_P4_SIZE_1024_1024
796: ? TME_SUNBW2_CSR_JUMPER_HIRES
797: : 0));
798:
799: /* set our CSR address: */
800: sunbw2->tme_sunbw2_csr_address
801: = (bw2_type == TME_SUNBW2_TYPE_MULTIBUS
802: ? TME_SUNBW2_REG_CSR_MULTIBUS
803: : TME_SUNBW2_REG_CSR_OLD_ONBOARD);
804:
805: /* our second bus subregion is for the CSR: */
806: reg_subregion = &sunbw2->tme_sunbw2_subregion1;
807: reg_subregion->tme_bus_subregion_address_first
808: = sunbw2->tme_sunbw2_csr_address;
809: reg_subregion->tme_bus_subregion_address_last
810: = (reg_subregion->tme_bus_subregion_address_first
811: + TME_SUNBW2_SIZ_CSR_PAGE
812: - 1);
813: break;
814:
815: case TME_SUNBW2_TYPE_ONBOARD:
816:
817: /* we attach to only one bus subregion: */
818: fb_subregion->tme_bus_subregion_next = NULL;
819: break;
820:
821: case TME_SUNBW2_TYPE_P4:
822:
823: /* set our initial P4 register: */
824: sunbw2->tme_sunbw2_p4
825: = tme_htobe_u16(TME_SUN_P4_ID_BWTWO
826: | bw2_size
827: | TME_SUN_P4_REG_ENABLE_VIDEO);
828:
829: /* the framebuffer memory begins at a fixed offset after the P4 register: */
830: sunbw2->tme_sunbw2_fb_address_first = TME_SUN_P4_OFFSET_BWTWO;
831:
832: /* we attach the P4 register first, and the framebuffer memory second: */
833: reg_subregion = &sunbw2->tme_sunbw2_device.tme_bus_device_subregions;
834: fb_subregion = &sunbw2->tme_sunbw2_subregion1;
835: reg_subregion->tme_bus_subregion_address_first = 0;
836: reg_subregion->tme_bus_subregion_address_last
837: = (reg_subregion->tme_bus_subregion_address_first
838: + sizeof(sunbw2->tme_sunbw2_p4)
839: - 1);
840: break;
841: }
842:
843: /* set the (relative) bus address of the last byte of displayed
844: framebuffer memory: */
845: sunbw2->tme_sunbw2_fb_address_last_displayed
846: = (sunbw2->tme_sunbw2_fb_address_first
847: + ((tme_sun_fb_p4_size_width(bw2_size)
848: * tme_sun_fb_p4_size_height(bw2_size))
849: / 8)
850: - 1);
851:
852: /* set the (relative) bus address of the last byte of framebuffer
853: memory: */
854: sunbw2->tme_sunbw2_fb_address_last
855: = (sunbw2->tme_sunbw2_fb_address_first
856: + fb_size
857: - 1);
858:
859: /* finish the framebuffer memory subregion: */
860: fb_subregion->tme_bus_subregion_address_first
861: = sunbw2->tme_sunbw2_fb_address_first;
862: fb_subregion->tme_bus_subregion_address_last
863: = sunbw2->tme_sunbw2_fb_address_last;
864:
865: /* assume that we don't need any pad (undisplayed) framebuffer memory: */
866: sunbw2->tme_sunbw2_pad_memory = NULL;
867: assert (sunbw2->tme_sunbw2_fb_address_last
868: >= sunbw2->tme_sunbw2_fb_address_last_displayed);
869:
870: /* if we need to, allocate pad (undisplayed) framebuffer memory: */
871: if (sunbw2->tme_sunbw2_fb_address_last
872: > sunbw2->tme_sunbw2_fb_address_last_displayed) {
873:
874: /* allocate the pad memory: */
875: sunbw2->tme_sunbw2_pad_memory
876: = tme_new0(tme_uint8_t,
877: (sunbw2->tme_sunbw2_fb_address_last
878: - sunbw2->tme_sunbw2_fb_address_last_displayed));
879: }
880:
881: /* initialize our simple bus device descriptor: */
882: sunbw2->tme_sunbw2_device.tme_bus_device_element = element;
883: sunbw2->tme_sunbw2_device.tme_bus_device_tlb_fill = _tme_sunbw2_tlb_fill;
884:
885: /* fill the element: */
886: element->tme_element_private = sunbw2;
887: element->tme_element_connections_new = _tme_sunbw2_connections_new;
888:
889: return (TME_OK);
890: }
891:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.