Return to nd_vio.c CVS log

Up to [Previous NeXT emulator] / previous / src / dimension

Annotation of previous/src/dimension/nd_vio.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <limits.h>
                      3: #include <stdlib.h>
                      4: 
                      5: #include "main.h"
                      6: #include "configuration.h"
                      7: #include "m68000.h"
                      8: #include "sysdeps.h"
                      9: #include "dimension.h"
                     10: #include "nd_vio.h"
                     11: #include "i860cfg.h"
                     12: #include "nd_sdl.h"
                     13: #include "host.h"
                     14: 
                     15: 
                     16: #define LOG_VID_LEVEL   LOG_WARN
                     17: 
                     18: /* --------- NEXTDIMENSION VIDEO I/O ---------- *
                     19:  *                                              *
                     20:  * Code for NeXTdimension video I/O. For now    *
                     21:  * only some dummy devices.                     */
                     22: 
                     23: 
                     24: #define ND_VID_DMCD     0x8A
                     25: #define ND_VID_DCSC0    0xE0
                     26: #define ND_VID_DCSC1    0xE2
                     27: 
                     28: 
                     29: /* SAA7191 (Digital Multistandard Colour Decoder - Square Pixel) */
                     30: 
                     31: #define ND_DMCD_NUM_REG 25
                     32: 
                     33: struct {
                     34:     uae_u8 addr;
                     35:     uae_u8 reg[ND_DMCD_NUM_REG];
                     36: } dmcd;
                     37: 
                     38: 
                     39: void dmcd_write(uae_u32 step, uae_u8 data) {
                     40:     if (step == 0) {
                     41:         dmcd.addr = data;
                     42:     } else {
                     43:         Log_Printf(LOG_VID_LEVEL, "[ND] DMCD: Writing register %i (%02X)", dmcd.addr, data);
                     44:         
                     45:         if (dmcd.addr < ND_DMCD_NUM_REG) {
                     46:             dmcd.reg[dmcd.addr] = data;
                     47:             dmcd.addr++;
                     48:         } else {
                     49:             Log_Printf(LOG_WARN, "[ND] DMCD: Illegal register (%i)", dmcd.addr);
                     50:         }
                     51:     }
                     52: }
                     53: 
                     54: 
                     55: /* SAA7192 (Digital Colour Space Converter) */
                     56: 
                     57: #define ND_DCSC_CTRL    0x00
                     58: #define ND_DCSC_CLUT    0x01
                     59: 
                     60: struct {
                     61:     uae_u8 addr;
                     62:     uae_u8 ctrl;
                     63:     uae_u8 lut_r[256];
                     64:     uae_u8 lut_g[256];
                     65:     uae_u8 lut_b[256];
                     66: } dcsc[2];
                     67: 
                     68: 
                     69: void dcsc_write(uae_u8 dev, uae_u32 step, uae_u8 data) {
                     70:     switch (step) {
                     71:         case 0:
                     72:             dcsc[dev].addr = data;
                     73:             break;
                     74:         case 1:
                     75:             if (dcsc[dev].addr == ND_DCSC_CTRL) {
                     76:                 Log_Printf(LOG_VID_LEVEL, "[ND] DCSC%i: Writing control (%02X)", dev, data);
                     77:                 
                     78:                 dcsc[dev].ctrl = data;
                     79:                 break;
                     80:             }
                     81:             /* else fall through */
                     82: 
                     83:         default:
                     84:             if (dcsc[dev].addr == ND_DCSC_CLUT) {
                     85:                 Log_Printf(LOG_VID_LEVEL, "[ND] DCSC%i: Writing LUT at %i (%02X)", dev, step-1, data);
                     86: 
                     87:                 dcsc[dev].lut_r[(step-1)&0xFF] = data;
                     88:                 dcsc[dev].lut_g[(step-1)&0xFF] = data;
                     89:                 dcsc[dev].lut_b[(step-1)&0xFF] = data;
                     90:             } else {
                     91:                 Log_Printf(LOG_WARN, "[ND] DCSC%i: Unknown address (%02X)", dev, dcsc[dev].addr);
                     92:             }
                     93:             break;
                     94:     }
                     95: }
                     96: 
                     97: 
                     98: /* Receiver function (from IIC bus) */
                     99: 
                    100: void nd_video_dev_write(uae_u8 addr, uae_u32 step, uae_u8 data) {
                    101:     
                    102:     if (addr&0x01) {
                    103:         Log_Printf(LOG_WARN, "[ND] IIC bus: Unimplemented read from video device at %02X", addr);
                    104:     }
                    105:     
                    106:     if (step == 0) {
                    107:         Log_Printf(LOG_VID_LEVEL, "[ND] IIC bus: selecting device at %02X (subaddress: %02X)", addr, data);
                    108:     }
                    109:     
                    110:     switch (addr&0xFE) {
                    111:         case ND_VID_DMCD:
                    112:             dmcd_write(step, data);
                    113:             break;
                    114:         case ND_VID_DCSC0:
                    115:             dcsc_write(0, step, data);
                    116:             break;
                    117:         case ND_VID_DCSC1:
                    118:             dcsc_write(1, step, data);
                    119:             break;
                    120:             
                    121:         default:
                    122:             Log_Printf(LOG_WARN, "[ND] IIC bus: Unknown device (%02X)", addr);
                    123:             break;
                    124:     }
                    125: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.