← Back to branch summary

~ubuntu-branches/ubuntu/precise/vice/precise

« back to all changes in this revision

Viewing changes to src/arch/unix/parsid.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-02-11 18:30:16 UTC
  • mfrom: (1.1.8 upstream) (9.2.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100211183016-f6n8usn3tzp0u6dp
Tags: 2.2.dfsg-1
* New upstream release, C64 DTV is included so update package description
  and add it to the menu.
* Drop patch fixing build failure with gcc-4.4 , applied upstream.
* Fix some lintian problems and clean up debian/rules .

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/arch/unix/parsid.c
65
65
#include "types.h"
66
66
 
67
67
/* control register bits */
68
 
#define parsid_STROBE           0x01
69
 
#define parsid_AUTOFEED         0x02
70
 
#define parsid_nINIT            0x04
71
 
#define parsid_SELECTIN         0x08
72
 
#define parsid_PCD              0x20
 
68
#define parsid_STROBE   0x01
 
69
#define parsid_AUTOFEED 0x02
 
70
#define parsid_nINIT    0x04
 
71
#define parsid_SELECTIN 0x08
 
72
#define parsid_PCD      0x20
73
73
 
74
74
static unsigned char parsid_ctrport;
75
75
 
76
76
static int parsid_port_address[4];
77
77
 
78
78
static int ports;
79
 
static int old_parsid_port=0;
80
 
static int parsid_open_status=0;
 
79
static int old_parsid_port = 0;
 
80
static int parsid_open_status = 0;
81
81
 
82
82
#ifdef HAVE_LIBIEEE1284
83
 
  struct parport_list parlist;
 
83
    struct parport_list parlist;
84
84
 
85
85
void parsid_ieee1284_outb(struct parport_list *pl, int addr, BYTE value)
86
86
{
87
 
  if (addr==parsid_port_address[old_parsid_port])
88
 
    ieee1284_write_data(pl->portv[old_parsid_port-1],value);
89
 
  else
90
 
    ieee1284_write_control(pl->portv[old_parsid_port-1],value);
 
87
    if (addr == parsid_port_address[old_parsid_port]) {
 
88
        ieee1284_write_data(pl->portv[old_parsid_port - 1], value);
 
89
    } else {
 
90
        ieee1284_write_control(pl->portv[old_parsid_port - 1], value);
 
91
    }
91
92
}
92
93
 
93
94
int parsid_ieee1284_inb(struct parport_list *pl, int addr)
94
95
{
95
 
  if (addr==parsid_port_address[old_parsid_port])
96
 
    return ieee1284_read_data(pl->portv[old_parsid_port-1]);
97
 
  else
98
 
    return ieee1284_read_control(pl->portv[old_parsid_port-1]);
 
96
    if (addr == parsid_port_address[old_parsid_port]) {
 
97
        return ieee1284_read_data(pl->portv[old_parsid_port - 1]);
 
98
    } else {
 
99
        return ieee1284_read_control(pl->portv[old_parsid_port - 1]);
 
100
    }
99
101
}
100
102
 
101
103
int parsid_ieee1284_open(struct parport_list *pl, int portnr)
102
104
{
103
 
  int ret_value;
104
 
  int cap;
105
 
 
106
 
  ret_value=ieee1284_open(pl->portv[portnr],F1284_EXCL,&cap);
107
 
 
108
 
  if (ret_value==E1284_OK)
109
 
  {
110
 
    ret_value=ieee1284_claim(pl->portv[portnr]);
111
 
    if (ret_value!=E1284_OK)
112
 
      ieee1284_close(pl->portv[portnr]);
113
 
  }
114
 
  if (ret_value==E1284_OK && (cap&CAP1284_RAW)==CAP1284_RAW)
115
 
    return 1;
116
 
  else
117
 
    return 0;
 
105
    int ret_value;
 
106
    int cap;
 
107
 
 
108
    ret_value = ieee1284_open(pl->portv[portnr], F1284_EXCL, &cap);
 
109
 
 
110
    if (ret_value == E1284_OK) {
 
111
        ret_value = ieee1284_claim(pl->portv[portnr]);
 
112
        if (ret_value != E1284_OK) {
 
113
            ieee1284_close(pl->portv[portnr]);
 
114
        }
 
115
    }
 
116
    if (ret_value == E1284_OK && (cap & CAP1284_RAW) == CAP1284_RAW) {
 
117
        return 1;
 
118
    } else {
 
119
        return 0;
 
120
    }
118
121
}
119
122
 
120
123
void parsid_ieee1284_close(struct parport_list *pl, int portnr)
121
124
{
122
 
  ieee1284_release(pl->portv[portnr]);
123
 
  ieee1284_close(pl->portv[portnr]);
 
125
    ieee1284_release(pl->portv[portnr]);
 
126
    ieee1284_close(pl->portv[portnr]);
124
127
}
125
128
#endif
126
129
 
128
131
#ifndef __FreeBSD__
129
132
static void setaccess(u_long * map, u_int bit, int allow)
130
133
{
131
 
  u_int word;
132
 
  u_int shift;
133
 
  u_long mask;
134
 
 
135
 
  word=bit/32;
136
 
  shift=bit-(word*32);
137
 
 
138
 
  mask=0x000000001<<shift;
139
 
  if (allow)
140
 
    map[word]&=~mask;
141
 
  else
142
 
    map[word]|=mask;
 
134
    u_int word;
 
135
    u_int shift;
 
136
    u_long mask;
 
137
 
 
138
    word = bit / 32;
 
139
    shift = bit - (word * 32);
 
140
 
 
141
    mask = 0x000000001 << shift;
 
142
    if (allow) {
 
143
        map[word] &= ~mask;
 
144
    } else {
 
145
        map[word] |= mask;
 
146
    }
143
147
}
144
148
#endif
145
149
#endif
147
151
void parsid_outb(int addr, BYTE value)
148
152
{
149
153
#ifdef HAVE_LIBIEEE1284
150
 
  parsid_ieee1284_outb(&parlist,addr,value);
 
154
    parsid_ieee1284_outb(&parlist, addr, value);
151
155
#endif
152
156
#ifdef HAVE_MMAP_DEVICE_IO
153
 
  out8(addr,value);
 
157
    out8(addr, value);
154
158
#endif
155
159
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
156
 
  outb(addr,value);
 
160
    outb(addr, value);
157
161
#endif
158
162
#ifdef HAVE_IOPERM
159
 
  outb_p(value,addr);
 
163
    outb_p(value, addr);
160
164
#endif
161
165
}
162
166
 
163
167
BYTE parsid_inb(int addr)
164
168
{
165
169
#ifdef HAVE_LIBIEEE1284
166
 
  return parsid_ieee1284_inb(&parlist,addr);
 
170
    return parsid_ieee1284_inb(&parlist, addr);
167
171
#endif
168
172
#ifdef HAVE_MMAP_DEVICE_IO
169
 
  return in8(addr);
 
173
    return in8(addr);
170
174
#endif
171
175
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
172
 
  return inb((unsigned short)addr);
 
176
    return inb((unsigned short)addr);
173
177
#endif
174
178
#ifdef HAVE_IOPERM
175
 
  return inb_p((unsigned short)addr);
 
179
    return inb_p((unsigned short)addr);
176
180
#endif
177
181
}
178
182
 
179
183
/* chip control pin assignments */
180
184
static void parsid_chip_select(void)
181
185
{
182
 
  parsid_ctrport|=parsid_STROBE;
183
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
186
    parsid_ctrport |= parsid_STROBE;
 
187
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
184
188
}
185
189
 
186
190
static void parsid_chip_deselect(void)
187
191
{
188
 
  parsid_ctrport&=~parsid_STROBE;
189
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
192
    parsid_ctrport &= ~parsid_STROBE;
 
193
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
190
194
}
191
195
 
192
196
static void parsid_reset_start(void)
193
197
{
194
 
  parsid_ctrport|=parsid_SELECTIN;
195
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
198
    parsid_ctrport |= parsid_SELECTIN;
 
199
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
196
200
}
197
201
 
198
202
static void parsid_reset_end(void)
199
203
{
200
 
  parsid_ctrport&=~parsid_SELECTIN;
201
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
204
    parsid_ctrport &= ~parsid_SELECTIN;
 
205
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
202
206
}
203
207
 
204
208
static void parsid_latch_open(void)
205
209
{
206
 
  parsid_ctrport&=~parsid_AUTOFEED;
207
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
210
    parsid_ctrport &= ~parsid_AUTOFEED;
 
211
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
208
212
}
209
213
 
210
214
static void parsid_latch_lock(void)
211
215
{
212
 
  parsid_ctrport|=parsid_AUTOFEED;
213
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
216
    parsid_ctrport |= parsid_AUTOFEED;
 
217
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
214
218
}
215
219
 
216
220
static void parsid_RW_write(void)
217
221
{
218
 
  parsid_ctrport&=~parsid_nINIT;
219
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
222
    parsid_ctrport &= ~parsid_nINIT;
 
223
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
220
224
}
221
225
 
222
226
static void parsid_RW_read(void)
223
227
{
224
 
  parsid_ctrport|=parsid_nINIT;
225
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
228
    parsid_ctrport |= parsid_nINIT;
 
229
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
226
230
}
227
231
 
228
232
/* parallel port direction control */
229
233
static void parsid_port_write(void)
230
234
{
231
 
  parsid_ctrport&=~parsid_PCD;
232
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
235
    parsid_ctrport &= ~parsid_PCD;
 
236
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
233
237
}
234
238
 
235
239
static void parsid_port_read(void)
236
240
{
237
 
  parsid_ctrport|=parsid_PCD;
238
 
  parsid_outb(parsid_port_address[old_parsid_port]+2, parsid_ctrport);
 
241
    parsid_ctrport |= parsid_PCD;
 
242
    parsid_outb(parsid_port_address[old_parsid_port] + 2, parsid_ctrport);
239
243
}
240
244
 
241
245
static void parsid_sidwait(void)
244
248
 
245
249
int parsid_check_port(int port)
246
250
{
247
 
  int real_port=0;
248
 
  int count_port=0;
 
251
    int real_port = 0;
 
252
    int count_port = 0;
249
253
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
250
 
  int old_port_addr=0;
251
 
  int port_addr=0;
 
254
    int old_port_addr = 0;
 
255
    int port_addr = 0;
252
256
#endif
253
257
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
254
258
#ifndef __FreeBSD__
255
 
  u_long iomap[32];
256
 
#endif
257
 
#endif
258
 
 
259
 
  if (port<0 || port>3)
260
 
    return -1;
261
 
 
262
 
  if (port>ports)
263
 
    return -1;
264
 
 
265
 
  while (count_port!=port)
266
 
  {
267
 
    if (parsid_port_address[port-1]!=0)
268
 
      count_port++;
269
 
    real_port++;
270
 
  }
 
259
    u_long iomap[32];
 
260
#endif
 
261
#endif
 
262
 
 
263
    if (port < 0 || port > 3) {
 
264
        return -1;
 
265
    }
 
266
 
 
267
    if (port > ports) {
 
268
        return -1;
 
269
    }
 
270
 
 
271
    while (count_port != port) {
 
272
        if (parsid_port_address[port - 1] != 0) {
 
273
            count_port++;
 
274
        }
 
275
        real_port++;
 
276
    }
271
277
 
272
278
#ifdef HAVE_LIBIEEE1284
273
 
  if (parsid_ieee1284_open(&parlist,real_port-1)==0)
274
 
    return -1;
275
 
  else
276
 
  {
277
 
    if (old_parsid_port!=0)
278
 
      parsid_ieee1284_close(&parlist,old_parsid_port-1);
279
 
    old_parsid_port=real_port;
280
 
  }
 
279
    if (parsid_ieee1284_open(&parlist, real_port - 1) == 0) {
 
280
        return -1;
 
281
    } else {
 
282
        if (old_parsid_port != 0) {
 
283
            parsid_ieee1284_close(&parlist, old_parsid_port - 1);
 
284
        }
 
285
        old_parsid_port=real_port;
 
286
    }
281
287
#endif
282
288
 
283
289
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
284
 
    if (real_port==1)
285
 
      port_addr=0x3bc;
286
 
    if (real_port==2)
287
 
      port_addr=0x378;
288
 
    if (real_port==3)
289
 
      port_addr=0x278;
 
290
    if (real_port == 1) {
 
291
        port_addr = 0x3bc;
 
292
    }
 
293
    if (real_port == 2) {
 
294
        port_addr = 0x378;
 
295
    }
 
296
    if (real_port == 3) {
 
297
        port_addr = 0x278;
 
298
    }
290
299
 
291
 
    if (old_parsid_port==1)
292
 
      old_port_addr=0x3bc;
293
 
    if (old_parsid_port==2)
294
 
      old_port_addr=0x378;
295
 
    if (old_parsid_port==3)
296
 
      old_port_addr=0x278;
 
300
    if (old_parsid_port == 1) {
 
301
        old_port_addr=0x3bc;
 
302
    }
 
303
    if (old_parsid_port == 2) {
 
304
        old_port_addr = 0x378;
 
305
    }
 
306
    if (old_parsid_port == 3) {
 
307
        old_port_addr = 0x278;
 
308
    }
297
309
#endif
298
310
 
299
311
#ifdef HAVE_MMAP_DEVICE_IO
300
 
  if (mmap_device_io(4, port_addr)==MAP_FAILED)
301
 
    return -1;
302
 
  else
303
 
  {
304
 
    if (old_parsid_port!=0)
305
 
      mmunmap_device_io(4, old_port_addr);
306
 
  }
307
 
  old_parsid_port=real_port;
 
312
    if (mmap_device_io(4, port_addr) == MAP_FAILED) {
 
313
        return -1;
 
314
    } else {
 
315
        if (old_parsid_port != 0) {
 
316
            mmunmap_device_io(4, old_port_addr);
 
317
        }
 
318
    }
 
319
    old_parsid_port = real_port;
308
320
#endif
309
321
 
310
322
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
311
323
#ifndef __FreeBSD__
312
324
#ifdef HAVE_LIBAMD64
313
 
    if (amd64_get_ioperm(iomap)!=-1)
314
 
#else
315
 
    if (i386_get_ioperm(iomap)!=-1)
316
 
#endif
317
 
    {
318
 
      setaccess(iomap,port_addr,1);
319
 
      setaccess(iomap,port_addr+2,1);
320
 
#ifdef HAVE_LIBAMD64
321
 
      if (amd64_set_ioperm(iomap)!=-1)
322
 
#else
323
 
      if (i386_set_ioperm(iomap)!=-1)
324
 
#endif
325
 
      {
326
 
        if (old_parsid_port!=0)
327
 
        {
328
 
          setaccess(iomap,old_port_addr,0);
329
 
          setaccess(iomap,old_port_addr+2,0);
330
 
#ifdef HAVE_LIBAMD64
331
 
          amd64_set_ioperm(iomap);
332
 
#else
333
 
          i386_set_ioperm(iomap);
334
 
#endif
 
325
    if (amd64_get_ioperm(iomap) != -1) {
 
326
#else
 
327
    if (i386_get_ioperm(iomap) != -1) {
 
328
#endif
 
329
        setaccess(iomap, port_addr, 1);
 
330
        setaccess(iomap, port_addr + 2, 1);
 
331
#ifdef HAVE_LIBAMD64
 
332
        if (amd64_set_ioperm(iomap) != -1) {
 
333
#else
 
334
        if (i386_set_ioperm(iomap) != -1) {
 
335
#endif
 
336
            if (old_parsid_port != 0) {
 
337
                setaccess(iomap, old_port_addr, 0);
 
338
                setaccess(iomap, old_port_addr + 2, 0);
 
339
#ifdef HAVE_LIBAMD64
 
340
                amd64_set_ioperm(iomap);
 
341
#else
 
342
                i386_set_ioperm(iomap);
 
343
#endif
 
344
            }
 
345
        } else {
 
346
            return -1;
335
347
        }
336
 
      }
337
 
      else
 
348
    } else {
338
349
        return -1;
339
350
    }
340
 
    else
341
 
      return -1;
342
 
    old_parsid_port=real_port;
 
351
    old_parsid_port = real_port;
343
352
#else
344
 
    if (i386_set_ioperm(port_addr,3,1)!=0)
345
 
      return -1;
346
 
    if (old_parsid_port!=0)
347
 
      i386_set_ioperm(old_port_addr,3,0);
348
 
    old_parsid_port=real_port;
 
353
    if (i386_set_ioperm(port_addr, 3, 1) != 0) {
 
354
        return -1;
 
355
    }
 
356
    if (old_parsid_port != 0) {
 
357
        i386_set_ioperm(old_port_addr, 3, 0);
 
358
    }
 
359
    old_parsid_port = real_port;
349
360
#endif
350
361
#endif
351
362
 
352
363
#ifdef HAVE_IOPERM
353
 
    if (ioperm(0x80,1,1)!=0)
354
 
      return -1;
355
 
    if (ioperm(port_addr,3,1)!=0)
356
 
      return -1;
357
 
    if (old_parsid_port!=0)
358
 
      ioperm(old_port_addr,3,0);
359
 
    old_parsid_port=real_port;
 
364
    if (ioperm(0x80, 1, 1) != 0) {
 
365
        return -1;
 
366
    }
 
367
    if (ioperm(port_addr, 3, 1) != 0) {
 
368
        return -1;
 
369
    }
 
370
    if (old_parsid_port != 0) {
 
371
        ioperm(old_port_addr, 3, 0);
 
372
    }
 
373
    old_parsid_port = real_port;
360
374
#endif
361
375
 
362
 
  parsid_ctrport = parsid_inb(parsid_port_address[old_parsid_port]+2);
363
 
  return 0;
 
376
    parsid_ctrport = parsid_inb(parsid_port_address[old_parsid_port] + 2);
 
377
    return 0;
364
378
}
365
379
 
366
380
static int parsid_init(void)
367
381
{
368
 
  int j;
 
382
    int j;
369
383
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
370
 
  int port_addr=0;
 
384
    int port_addr = 0;
371
385
#endif
372
386
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
373
387
#ifndef __FreeBSD__
374
 
  u_long iomap[32];
375
 
#endif
376
 
#endif
377
 
 
378
 
  ports=0;
379
 
 
380
 
#ifdef HAVE_LIBIEEE1284
381
 
  ieee1284_find_ports(&parlist, 0);
382
 
#endif
383
 
 
384
 
  for (j = 0; j < 3; j++)
385
 
  {
386
 
#ifdef HAVE_LIBIEEE1284
387
 
    parsid_port_address[j]=parsid_ieee1284_open(&parlist,j);
 
388
    u_long iomap[32];
 
389
#endif
 
390
#endif
 
391
 
 
392
    ports = 0;
 
393
 
 
394
#ifdef HAVE_LIBIEEE1284
 
395
    ieee1284_find_ports(&parlist, 0);
 
396
#endif
 
397
 
 
398
    for (j = 0; j < 3; j++) {
 
399
#ifdef HAVE_LIBIEEE1284
 
400
        parsid_port_address[j] = parsid_ieee1284_open(&parlist, j);
388
401
#endif
389
402
 
390
403
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
391
 
    if (j==0)
392
 
      port_addr=0x3bc;
393
 
    if (j==1)
394
 
      port_addr=0x378;
395
 
    if (j==2)
396
 
      port_addr=0x278;
 
404
        if (j == 0) {
 
405
            port_addr = 0x3bc;
 
406
        }
 
407
        if (j == 1) {
 
408
            port_addr = 0x378;
 
409
        }
 
410
        if (j == 2) {
 
411
            port_addr = 0x278;
 
412
        }
397
413
#endif
398
414
 
399
415
#ifdef HAVE_MMAP_DEVICE_IO
400
 
    parsid_port_address[j]=mmap_device_io(4, port_addr);
401
 
    if (parsid_port_address[j]!=MAP_FAILED)
402
 
    {
403
 
      mmunmap_device_io(4, port_addr);
404
 
      parsid_port_address[j]=port_addr;
405
 
    }
406
 
    else
407
 
      parsid_port_address[j]=0;
 
416
        parsid_port_address[j] = mmap_device_io(4, port_addr);
 
417
        if (parsid_port_address[j] != MAP_FAILED) {
 
418
            mmunmap_device_io(4, port_addr);
 
419
            parsid_port_address[j] = port_addr;
 
420
        } else {
 
421
            parsid_port_address[j] = 0;
 
422
        }
408
423
#endif
409
424
 
410
425
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
411
426
#ifndef __FreeBSD__
412
427
#ifdef HAVE_LIBAMD64
413
 
    if (amd64_get_ioperm(iomap)!=-1)
414
 
#else
415
 
    if (i386_get_ioperm(iomap)!=-1)
416
 
#endif
417
 
    {
418
 
      setaccess(iomap,port_addr,1);
419
 
      setaccess(iomap,port_addr+2,1);
420
 
#ifdef HAVE_LIBAMD64
421
 
      if (amd64_set_ioperm(iomap)!=-1)
422
 
#else
423
 
      if (i386_set_ioperm(iomap)!=-1)
424
 
#endif
425
 
      {
426
 
        parsid_port_address[j]=port_addr;
427
 
        setaccess(iomap,port_addr,0);
428
 
        setaccess(iomap,port_addr+2,0);
429
 
#ifdef HAVE_LIBAMD64
430
 
        amd64_set_ioperm(iomap);
431
 
#else
432
 
        i386_set_ioperm(iomap);
433
 
#endif
434
 
      }
435
 
      else
436
 
        parsid_port_address[j]=0;
437
 
    }
438
 
    else
439
 
      parsid_port_address[j]=0;
440
 
#else
441
 
    parsid_port_address[j]=i386_set_ioperm(port_addr,3,1);
442
 
    if (parsid_port_address[j]==0)
443
 
    {
444
 
      i386_set_ioperm(port_addr,3,0);
445
 
      parsid_port_address[j]=port_addr;
446
 
    }
447
 
    else
448
 
      parsid_port_address[j]=0;
 
428
        if (amd64_get_ioperm(iomap) != -1)
 
429
#else
 
430
        if (i386_get_ioperm(iomap) != -1)
 
431
#endif
 
432
        {
 
433
            setaccess(iomap, port_addr, 1);
 
434
            setaccess(iomap, port_addr + 2, 1);
 
435
#ifdef HAVE_LIBAMD64
 
436
            if (amd64_set_ioperm(iomap) != -1)
 
437
#else
 
438
            if (i386_set_ioperm(iomap) != -1)
 
439
#endif
 
440
            {
 
441
                parsid_port_address[j] = port_addr;
 
442
                setaccess(iomap, port_addr, 0);
 
443
                setaccess(iomap, port_addr + 2, 0);
 
444
#ifdef HAVE_LIBAMD64
 
445
                amd64_set_ioperm(iomap);
 
446
#else
 
447
                i386_set_ioperm(iomap);
 
448
#endif
 
449
            } else {
 
450
                parsid_port_address[j] = 0;
 
451
            }
 
452
        } else
 
453
            parsid_port_address[j] = 0;
 
454
        }
 
455
#else
 
456
        parsid_port_address[j] = i386_set_ioperm(port_addr, 3, 1);
 
457
        if (parsid_port_address[j] == 0) {
 
458
            i386_set_ioperm(port_addr, 3, 0);
 
459
            parsid_port_address[j] = port_addr;
 
460
        } else {
 
461
            parsid_port_address[j] = 0;
 
462
        }
449
463
#endif
450
464
#endif
451
465
 
452
466
#ifdef HAVE_IOPERM
453
 
    parsid_port_address[j]=ioperm(port_addr,3,1);
454
 
    if (parsid_port_address[j]==0)
455
 
    {
456
 
      ioperm(port_addr,3,0);
457
 
      parsid_port_address[j]=port_addr;
458
 
    }
459
 
    else
460
 
      parsid_port_address[j]=0;
 
467
        parsid_port_address[j] = ioperm(port_addr, 3, 1);
 
468
        if (parsid_port_address[j] == 0) {
 
469
            ioperm(port_addr, 3, 0);
 
470
            parsid_port_address[j] = port_addr;
 
471
        } else {
 
472
            parsid_port_address[j] = 0;
 
473
        }
461
474
#endif
462
 
    if (parsid_port_address[j]!=0)
463
 
      ports++;
464
 
  }
 
475
        if (parsid_port_address[j] != 0) {
 
476
            ports++;
 
477
        }
 
478
    }
465
479
 
466
 
  if (ports==0)
467
 
    return -1;
468
 
  else
469
 
    return 0;
 
480
    if (ports == 0) {
 
481
        return -1;
 
482
    } else {
 
483
        return 0;
 
484
    }
470
485
}
471
486
 
472
487
void parsid_reset(void)
473
488
{
474
 
  if (parsid_open_status==1)
475
 
  {
476
 
    parsid_RW_write();
477
 
    parsid_port_write();
478
 
    parsid_chip_select();
479
 
    parsid_latch_open();
480
 
    parsid_outb(parsid_port_address[old_parsid_port],0);
481
 
    parsid_reset_start();
482
 
    sleep(1);
483
 
    parsid_reset_end();
484
 
    parsid_latch_lock();
485
 
    parsid_chip_deselect();
486
 
  }
 
489
    if (parsid_open_status == 1) {
 
490
        parsid_RW_write();
 
491
        parsid_port_write();
 
492
        parsid_chip_select();
 
493
        parsid_latch_open();
 
494
        parsid_outb(parsid_port_address[old_parsid_port], 0);
 
495
        parsid_reset_start();
 
496
        sleep(1);
 
497
        parsid_reset_end();
 
498
        parsid_latch_lock();
 
499
        parsid_chip_deselect();
 
500
    }
487
501
}
488
502
 
489
503
int parsid_open(int port)
490
504
{
491
 
  if (parsid_open_status==0)
492
 
  {
493
 
    if (parsid_init()<0)
494
 
      return -1;
495
 
    if (parsid_check_port(port)<0)
496
 
      return -1;
497
 
    parsid_reset();
498
 
    parsid_open_status=1;
499
 
  }
500
 
  return 0;
 
505
    if (parsid_open_status == 0) {
 
506
        if (parsid_init() < 0) {
 
507
            return -1;
 
508
        }
 
509
        if (parsid_check_port(port) < 0) {
 
510
            return -1;
 
511
        }
 
512
        parsid_reset();
 
513
        parsid_open_status = 1;
 
514
    }
 
515
    return 0;
501
516
}
502
517
 
503
518
int parsid_close(void)
504
519
{
505
520
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
506
 
  int old_port_addr=0;
 
521
    int old_port_addr = 0;
507
522
#endif
508
523
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
509
524
#ifndef __FreeBSD__
510
 
  u_long iomap[32];
511
 
#endif
512
 
#endif
513
 
  if (parsid_open_status==1)
514
 
  {
515
 
    parsid_reset();
 
525
    u_long iomap[32];
 
526
#endif
 
527
#endif
 
528
    if (parsid_open_status == 1) {
 
529
        parsid_reset();
516
530
#ifdef HAVE_LIBIEEE1284
517
 
    if (old_parsid_port!=0)
518
 
    {
519
 
      parsid_ieee1284_close(&parlist,old_parsid_port-1);
520
 
      old_parsid_port=0;
521
 
    }
 
531
        if (old_parsid_port != 0) {
 
532
            parsid_ieee1284_close(&parlist, old_parsid_port - 1);
 
533
            old_parsid_port = 0;
 
534
        }
522
535
#endif
523
536
 
524
537
#if defined(HAVE_MMAP_DEVICE_IO) || defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM) || defined(HAVE_IOPERM)
525
 
    if (old_parsid_port==1)
526
 
      old_port_addr=0x3bc;
527
 
    if (old_parsid_port==2)
528
 
      old_port_addr=0x378;
529
 
    if (old_parsid_port==3)
530
 
      old_port_addr=0x278;
 
538
        if (old_parsid_port == 1) {
 
539
            old_port_addr = 0x3bc;
 
540
        }
 
541
        if (old_parsid_port == 2) {
 
542
            old_port_addr = 0x378;
 
543
        }
 
544
        if (old_parsid_port == 3) {
 
545
            old_port_addr = 0x278;
 
546
        }
531
547
#endif
532
548
 
533
549
#ifdef HAVE_MMAP_DEVICE_IO
534
 
    if (old_parsid_port!=0)
535
 
    {
536
 
      mmunmap_device_io(4, old_port_addr);
537
 
      old_parsid_port=0;
538
 
    }
 
550
        if (old_parsid_port != 0) {
 
551
            mmunmap_device_io(4, old_port_addr);
 
552
            old_parsid_port = 0;
 
553
        }
539
554
#endif
540
555
 
541
556
#if defined(HAVE_LIBAMD64) || defined(HAVE_I386_SET_IOPERM)
542
557
#ifndef __FreeBSD__
543
558
#ifdef HAVE_LIBAMD64
544
 
    if (amd64_get_ioperm(iomap)!=-1)
 
559
        if (amd64_get_ioperm(iomap) != -1)
545
560
#else
546
 
    if (i386_get_ioperm(iomap)!=-1)
 
561
        if (i386_get_ioperm(iomap) != -1)
547
562
#endif
548
 
    {
549
 
      if (old_parsid_port!=0)
550
 
      {
551
 
        setaccess(iomap,old_port_addr,0);
552
 
        setaccess(iomap,old_port_addr+2,0);
 
563
        {
 
564
            if (old_parsid_port != 0) {
 
565
                setaccess(iomap, old_port_addr, 0);
 
566
                setaccess(iomap, old_port_addr + 2, 0);
553
567
#ifdef HAVE_LIBAMD64
554
 
        amd64_set_ioperm(iomap);
 
568
                amd64_set_ioperm(iomap);
555
569
#else
556
 
        i386_set_ioperm(iomap);
 
570
                i386_set_ioperm(iomap);
557
571
#endif
558
 
      }
559
 
    }
560
 
    old_parsid_port=0;
 
572
            }
 
573
        }
 
574
        old_parsid_port = 0;
561
575
#else
562
 
    if (old_parsid_port!=0)
563
 
    {
564
 
      i386_set_ioperm(old_port_addr,3,0);
565
 
      old_parsid_port=0;
566
 
    }
 
576
        if (old_parsid_port != 0) {
 
577
            i386_set_ioperm(old_port_addr, 3, 0);
 
578
            old_parsid_port = 0;
 
579
        }
567
580
#endif
568
581
#endif
569
582
 
570
583
#ifdef HAVE_IOPERM
571
 
    if (old_parsid_port!=0)
572
 
    {
573
 
      ioperm(0x80,1,0);
574
 
      ioperm(old_port_addr,3,0);
575
 
      old_parsid_port=0;
 
584
        if (old_parsid_port != 0) {
 
585
            ioperm(0x80, 1, 0);
 
586
            ioperm(old_port_addr, 3, 0);
 
587
            old_parsid_port = 0;
 
588
        }
 
589
#endif
576
590
    }
577
 
#endif
578
 
  }
579
 
  parsid_open_status=0;
580
 
  return 0;
 
591
    parsid_open_status = 0;
 
592
    return 0;
581
593
}
582
594
 
583
595
int parsid_read(WORD addr, int chipno)
584
596
{
585
 
  int value;
 
597
    int value;
586
598
 
587
 
  parsid_outb(parsid_port_address[old_parsid_port],addr);
588
 
  parsid_latch_open();
589
 
  parsid_sidwait();
590
 
  parsid_latch_lock();
591
 
  parsid_port_read();
592
 
  parsid_RW_read();
593
 
  parsid_chip_select();
594
 
  parsid_sidwait();
595
 
  value=parsid_inb(parsid_port_address[old_parsid_port]);
596
 
  parsid_chip_deselect();
597
 
  return value;
 
599
    parsid_outb(parsid_port_address[old_parsid_port], addr);
 
600
    parsid_latch_open();
 
601
    parsid_sidwait();
 
602
    parsid_latch_lock();
 
603
    parsid_port_read();
 
604
    parsid_RW_read();
 
605
    parsid_chip_select();
 
606
    parsid_sidwait();
 
607
    value = parsid_inb(parsid_port_address[old_parsid_port]);
 
608
    parsid_chip_deselect();
 
609
    return value;
598
610
}
599
611
 
600
612
void parsid_store(WORD addr, BYTE outval, int chipno)
601
613
{
602
 
  parsid_outb(parsid_port_address[old_parsid_port],addr);
603
 
  parsid_latch_open();
604
 
  parsid_sidwait();
605
 
  parsid_latch_lock();
606
 
  parsid_outb(parsid_port_address[old_parsid_port],outval);
607
 
  parsid_chip_select();
608
 
  parsid_sidwait();
609
 
  parsid_chip_deselect();
 
614
    parsid_outb(parsid_port_address[old_parsid_port], addr);
 
615
    parsid_latch_open();
 
616
    parsid_sidwait();
 
617
    parsid_latch_lock();
 
618
    parsid_outb(parsid_port_address[old_parsid_port], outval);
 
619
    parsid_chip_select();
 
620
    parsid_sidwait();
 
621
    parsid_chip_deselect();
610
622
}
611
623
#endif