← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vice/maverick

« 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
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050201113026-3eyakzsmmheclvjg
Tags: 1.16-1
http://bugs.debian.org/287640
http://bugs.debian.org/286767
http://bugs.debian.org/152952
http://bugs.debian.org/207942
* New upstream version
* Fixes crash on 64-bit architectures (closes: #287640)
* x128 working again (closes: #286767)
* Works fine with /dev/dsp in use (not in the main changelog, but tested
  on my local machine as working).  Presumably, this also takes care of
  the issue with dsp being held.  I'm not sure if this is because I'm
  testing it on a 2.6 kernel now -- if you are still having problems
  with /dev/dsp, please reopen the bugs. (closes: #152952, #207942)
* Don't kill Makefile.in on clean

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