← Back to branch summary

~ubuntu-branches/ubuntu/raring/vice/raring

« back to all changes in this revision

Viewing changes to src/vic20/vic20iec.c

  • Committer: Bazaar Package Importer
  • Author(s): Zed Pobre
  • Date: 2005-02-01 11:30:26 UTC
  • mto: (9.1.1 lenny) (1.1.6 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20050201113026-6gy97mcqlg2ykg4z
Tags: upstream-1.16
Import upstream version 1.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/vic20/vic20iec.c
47
47
 
48
48
 
49
49
static BYTE cpu_data, cpu_clock, cpu_atn;
50
 
static BYTE drive_data, drive_clock, drive_atna, drive_data_modifier;
51
 
static BYTE drive2_data, drive2_clock, drive2_atna, drive2_data_modifier;
 
50
static BYTE drive_data[DRIVE_NUM], drive_clock[DRIVE_NUM];
 
51
static BYTE drive_atna[DRIVE_NUM], drive_data_modifier[DRIVE_NUM];
52
52
static BYTE bus_data, bus_clock, bus_atn;
53
53
static BYTE cpu_bus_val;
54
 
static BYTE drive_bus_val, drive2_bus_val;
55
54
 
56
55
static inline void resolve_bus_signals(void)
57
56
{
58
 
    drive_t *drive0, *drive1;
59
 
 
60
 
    drive0 = drive_context[0]->drive;
61
 
    drive1 = drive_context[1]->drive;
 
57
    drive_t *drive;
 
58
    unsigned int i;
62
59
 
63
60
    bus_atn = NOT(cpu_atn);
64
 
    bus_clock = NOT(cpu_clock) & (drive0->enable ? NOT(drive_clock) : 0x01)
65
 
                               & (drive1->enable ? NOT(drive2_clock) : 0x01);
66
 
    bus_data = (drive0->enable
67
 
                     ? NOT(drive_data) & NOT(drive_data_modifier) : 0x01)
68
 
                 & (drive1->enable
69
 
                     ? NOT(drive2_data) & NOT(drive2_data_modifier) : 0x01)
70
 
                 & NOT(cpu_data);
71
 
#ifdef BUS_DBG
72
 
    fprintf(logfile, "SB: [%ld]  data:%d clock:%d atn:%d\n",
73
 
           drive_clk[0], bus_data, bus_clock, bus_atn);
74
 
#endif
 
61
    bus_clock = NOT(cpu_clock);
 
62
    bus_data = NOT(cpu_data);
 
63
 
 
64
    for (i = 0; i < DRIVE_NUM; i++) {
 
65
        drive = drive_context[i]->drive;
 
66
 
 
67
        bus_clock &= drive->enable ? NOT(drive_clock[i]) : 0x01;
 
68
        bus_data &= drive->enable ? NOT(drive_data[i])
 
69
                    & NOT(drive_data_modifier[i]) : 0x01;
 
70
    }
75
71
}
76
72
 
77
73
void iec_update_ports(void)
95
91
    iec_update_ports();
96
92
}
97
93
 
98
 
static void iec_calculate_data_modifier(void)
99
 
{
100
 
    if (drive_context[0]->drive->type != DRIVE_TYPE_1581)
101
 
        drive_data_modifier = (NOT(cpu_atn) ^ NOT(drive_atna));
102
 
    else
103
 
        drive_data_modifier = (cpu_atn & drive_atna);
104
 
}
105
 
 
106
 
static void iec_calculate_data_modifier2(void)
107
 
{
108
 
    if (drive_context[1]->drive->type != DRIVE_TYPE_1581)
109
 
        drive2_data_modifier = (NOT(cpu_atn) ^ NOT(drive2_atna));
110
 
    else
111
 
        drive2_data_modifier = (cpu_atn & drive2_atna);
112
 
}
113
 
 
114
 
void iec_drive0_write(BYTE data)
115
 
{
116
 
    static int last_write = 0;
117
 
 
118
 
    data = ~data;
119
 
    drive_data = ((data & 2) >> 1);
120
 
    drive_clock = ((data & 8) >> 3);
121
 
    drive_atna = ((data & 16) >> 4);
122
 
    iec_calculate_data_modifier();
123
 
    resolve_bus_signals();
124
 
    last_write = data & 26;
125
 
}
126
 
 
127
 
void iec_drive1_write(BYTE data)
128
 
{
129
 
    static int last_write = 0;
130
 
 
131
 
    data = ~data;
132
 
    drive2_data = ((data & 2) >> 1);
133
 
    drive2_clock = ((data & 8) >> 3);
134
 
    drive2_atna = ((data & 16) >> 4);
135
 
    iec_calculate_data_modifier2();
136
 
    resolve_bus_signals();
137
 
    last_write = data & 26;
138
 
}
139
 
 
140
 
BYTE iec_drive0_read(void)
141
 
{
 
94
static void iec_calculate_data_modifier(unsigned int dnr)
 
95
{
 
96
    if (drive_context[dnr]->drive->type != DRIVE_TYPE_1581)
 
97
        drive_data_modifier[dnr] = (NOT(cpu_atn) ^ NOT(drive_atna[dnr]));
 
98
    else
 
99
        drive_data_modifier[dnr] = (cpu_atn & drive_atna[dnr]);
 
100
}
 
101
 
 
102
void iec_drive_write(BYTE data, unsigned int dnr)
 
103
{
 
104
    static int last_write = 0;
 
105
 
 
106
    data = ~data;
 
107
    drive_data[dnr] = ((data & 2) >> 1);
 
108
    drive_clock[dnr] = ((data & 8) >> 3);
 
109
    drive_atna[dnr] = ((data & 16) >> 4);
 
110
    iec_calculate_data_modifier(dnr);
 
111
    resolve_bus_signals();
 
112
    last_write = data & 26;
 
113
}
 
114
 
 
115
BYTE iec_drive_read(unsigned int dnr)
 
116
{
 
117
    BYTE drive_bus_val;
 
118
 
142
119
    drive_bus_val = bus_data | (bus_clock << 2) | (bus_atn << 7);
 
120
 
143
121
    return drive_bus_val;
144
122
}
145
123
 
146
 
BYTE iec_drive1_read(void)
147
 
{
148
 
    drive2_bus_val = bus_data | (bus_clock << 2) | (bus_atn << 7);
149
 
    return drive2_bus_val;
150
 
}
151
 
 
152
124
/*
153
125
   The VIC20 has a strange bus layout for the serial IEC bus.
154
126
 
175
147
void iec_pa_write(BYTE data)
176
148
{
177
149
    static int last_write = 0;
178
 
    drive_t *drive0, *drive1;
179
 
 
180
 
    drive0 = drive_context[0]->drive;
181
 
    drive1 = drive_context[1]->drive;
 
150
    drive_t *drive;
 
151
    unsigned int i;
182
152
 
183
153
    drivecpu_execute_all(maincpu_clk);
184
154
 
185
155
    /* Signal ATN interrupt to the drives.  */
186
156
    if ((cpu_atn == 0) && (data & 128)) {
187
 
        if (drive0->enable) {
188
 
            if (drive0->type != DRIVE_TYPE_1581)
189
 
                viacore_signal(drive_context[0]->via1d1541, VIA_SIG_CA1,
190
 
                               VIA_SIG_RISE);
191
 
            else
192
 
                ciacore_set_flag(drive_context[0]->cia1581);
193
 
        }
194
 
        if (drive1->enable) {
195
 
            if (drive1->type != DRIVE_TYPE_1581)
196
 
                viacore_signal(drive_context[1]->via1d1541, VIA_SIG_CA1,
197
 
                               VIA_SIG_RISE);
198
 
            else
199
 
                ciacore_set_flag(drive_context[1]->cia1581);
 
157
        for (i = 0; i < DRIVE_NUM; i++) {
 
158
            drive = drive_context[i]->drive;
 
159
 
 
160
            if (drive->enable) {
 
161
                if (drive->type != DRIVE_TYPE_1581)
 
162
                    viacore_signal(drive_context[i]->via1d1541, VIA_SIG_CA1,
 
163
                                   VIA_SIG_RISE);
 
164
                else
 
165
                    ciacore_set_flag(drive_context[i]->cia1581);
 
166
            }
200
167
        }
201
168
    }
202
169
 
203
170
    /* Release ATN signal.  */
204
171
    if (!(data & 128)) {
205
 
        if (drive0->enable) {
206
 
            if (drive0->type != DRIVE_TYPE_1581)
207
 
                viacore_signal(drive_context[0]->via1d1541, VIA_SIG_CA1, 0);
208
 
        }
209
 
        if (drive1->enable) {
210
 
            if (drive1->type != DRIVE_TYPE_1581)
211
 
                viacore_signal(drive_context[1]->via1d1541, VIA_SIG_CA1, 0);
 
172
        for (i = 0; i < DRIVE_NUM; i++) {
 
173
            drive = drive_context[i]->drive;
 
174
 
 
175
            if (drive->enable) {
 
176
                if (drive->type != DRIVE_TYPE_1581)
 
177
                    viacore_signal(drive_context[i]->via1d1541, VIA_SIG_CA1, 0);
 
178
 
 
179
            }
212
180
        }
213
181
    }
214
182
 
215
183
    cpu_atn = ((data & 128) >> 7);
216
184
 
217
 
    iec_calculate_data_modifier();
218
 
    iec_calculate_data_modifier2();
 
185
    for (i = 0; i < DRIVE_NUM; i++)
 
186
        iec_calculate_data_modifier(i);
219
187
 
220
188
    resolve_bus_signals();
221
189
    last_write = data & 128;
230
198
void iec_pcr_write(BYTE data)
231
199
{
232
200
    static int last_write = 0;
233
 
 
234
 
    if (!(drive_context[0]->drive->enable)
235
 
        && !(drive_context[1]->drive->enable))
236
 
        return;
 
201
    unsigned int i;
237
202
 
238
203
    drivecpu_execute_all(maincpu_clk);
239
204
 
240
205
    cpu_data = ((data & 32) >> 5);
241
206
    cpu_clock = ((data & 2) >> 1);
242
207
 
243
 
    iec_calculate_data_modifier();
244
 
    iec_calculate_data_modifier2();
 
208
    for (i = 0; i < DRIVE_NUM; i++)
 
209
        iec_calculate_data_modifier(i);
245
210
 
246
211
    resolve_bus_signals();
247
212
    last_write = data & 34;
261
226
    return NULL;
262
227
}
263
228
 
264
 
void parallel_cable_drive0_write(BYTE data, int handshake)
265
 
{
266
 
}
267
 
 
268
 
void parallel_cable_drive1_write(BYTE data, int handshake)
 
229
void parallel_cable_drive_write(BYTE data, int handshake, unsigned int dnr)
269
230
{
270
231
}
271
232