Changeset 6f4d6bd in multiio


Ignore:
Timestamp:
Jun 10, 2009, 4:23:01 PM (10 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
master
Children:
2fc4157
Parents:
c99627b
Message:

2009-06-10 Joel Sherrill <joel.sherrill@…>

  • mio_io_rtems.c: Add checking for interrupt status.
Location:
pcmmio/original
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • pcmmio/original/ChangeLog

    rc99627b r6f4d6bd  
     12009-06-10      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * mio_io_rtems.c: Add checking for interrupt status.
     4
    152009-06-08      Joel Sherrill <joel.sherrill@oarcorp.com>
    26
  • pcmmio/original/mio_io_rtems.c

    rc99627b r6f4d6bd  
    1 /* mio_io.c WinSystems support module file for the  PCM-MIO Linux driver */
     1/* mio_io.c WinSystems support module file for the  PCM-MIO RTEMS driver */
    22/*
    3 *  $Header$
    4 *
    5 *  $Id$
    6 *
    7 *  $Log$
    8 *  Revision 1.1  2009/06/08 18:40:06  joel
    9 *  2009-06-08   Joel Sherrill <joel.sherrill@oarcorp.com>
    10 *
    11 *       * Makefile, mio_io.c, mio_io.h: Linux code split to porting file.
    12 *       * mio_io_linux.c: New file.
    13 *
    14 *  Revision 1.2  2009/06/08 18:21:56  joel
    15 *  2009-06-08   Joel Sherrill <joel.sherrill@oarcorp.com>
    16 *
    17 *       * Makefile, kbhit.c, mio_io.c, mio_io.h: First successful compilation
    18 *       under RTEMS. Added some Linux ifdef's.
    19 *       * rtems_config.c: New file.
    20 *
    21 *  Revision 1.1.1.1  2009/06/08 14:52:43  joel
    22 *  Initial import.
    23 *
    24 *
    25 *  This file implements all of the supported 'C' language functions. Where necessary
    26 *  ioctl call are made into the kernel driver to access the actual hardware.
    27 */
     3 *  $Id$
     4 *
     5 *  This file implements the hardware access routines as implemented for RTEMS.
     6 *  This is very likely close to what is required with no OS.
     7 */
    288
    299/* #define DEBUG 1 */
     
    3616#include <sys/ioctl.h>  /* ioctl */
    3717
    38 /**************************************************************************
    39 *
    40 *               USER LIBRARY FUNCTIONS
    41 *
    42 ***************************************************************************
     18#include <i386_io.h>
     19
     20/*
     21 *  These have to be configured SOMEHOW
     22 */
     23
     24/* IRQ source or 0 ==> polled */
     25static unsigned short irq = 0;
     26/* This holds the base addresses of the board */
     27static unsigned short base_port = 0;
     28
     29/* for RTEMS */
     30void pcmmio_initialize(
     31  unsigned short _base_port,
     32  unsigned short _irq
     33)
     34{
     35  base_port = _base_port;
     36  irq       = _irq;
     37}
     38
     39/* Function prototypes for local functions */
     40int get_buffered_int(void);
     41void init_io(unsigned short io_address);
     42void clr_int(int bit_number);
     43int get_int(void);
     44
     45///////////////////////////////////////////////////////////////////////////////
     46//
     47//    MIO_READ_IRQ_ASSIGNED
     48//
     49//////////////////////////////////////////////////////////////////////////////
     50
     51int mio_read_irq_assigned(void)
     52{
     53  mio_error_code = MIO_SUCCESS;
     54
     55  if (check_handle())   /* Check for chip available */
     56    return -1;
     57
     58
     59  /* All of our programming of the hardware is handled at this level so that
     60     all of the routines that need to shove and IRQ value into hardware will
     61     use this call.
     62  */
     63
     64  return (irq & 0xff);
     65}
     66
     67///////////////////////////////////////////////////////////////////////////////
     68//
     69//    READ_DIO_BYTE
     70//
     71//////////////////////////////////////////////////////////////////////////////
     72
     73unsigned char read_dio_byte(int offset)
     74{
     75  unsigned char byte_val;
     76  unsigned char offset_val;
     77
     78  mio_error_code = MIO_SUCCESS;
     79
     80  if (check_handle())   /* Check for chip available */
     81    return -1;
     82
     83  /* All bit operations are handled at this level so we need only
     84     read and write bytes from the actual hardware.
     85  */
     86
     87  offset_val = offset & 0xff;
     88  byte_val = inb(base_port + 0x10 + offset_val);
     89  return (byte_val & 0xff);
     90}
     91
     92///////////////////////////////////////////////////////////////////////////////
     93//
     94//    MIO_READ_REG
     95//
     96//////////////////////////////////////////////////////////////////////////////
     97
     98unsigned char mio_read_reg(int offset)
     99{
     100  unsigned char byte_val;
     101  unsigned char offset_val;
     102
     103  mio_error_code = MIO_SUCCESS;
     104
     105  if (check_handle())   /* Check for chip available */
     106    return -1;
     107
     108
     109  /* This is a catchall register read routine that allows reading of
     110     ANY of the registers on the PCM-MIO. It is used primarily for
     111     retreiving control and access values in the hardware.
     112   */
     113
     114  offset_val = offset & 0xff;
     115  byte_val = inb(base_port + offset_val);
     116  return (byte_val & 0xff);
     117}
     118
     119///////////////////////////////////////////////////////////////////////////////
     120//
     121//    MIO_WRITE_REG
     122//
     123//////////////////////////////////////////////////////////////////////////////
     124
     125int mio_write_reg(int offset, unsigned char value)
     126{
     127  unsigned char byte_val;
     128  unsigned char offset_val;
     129
     130  mio_error_code = MIO_SUCCESS;
     131
     132  if (check_handle())   /* Check for chip available */
     133    return -1;
     134
     135  /* This function like the previous allow unlimited
     136     write access to ALL of the registers on the PCM-MIO
     137   */
     138
     139  offset_val = offset & 0xff;
     140  byte_val = value;
     141  outb(byte_val, base_port + offset_val);
     142 
     143  return 0;
     144}
     145
     146
     147///////////////////////////////////////////////////////////////////////////////
     148//
     149//    WRITE_DIO_BYTE
     150//
     151//////////////////////////////////////////////////////////////////////////////
     152
     153int write_dio_byte(int offset, unsigned char value)
     154{
     155  unsigned char byte_val;
     156  unsigned char offset_val;
     157
     158  mio_error_code = MIO_SUCCESS;
     159
     160  if (check_handle())   /* Check for chip available */
     161    return -1;
     162
     163  /* All bit operations for the DIO are handled at this level
     164     and we need the driver to allow access to the actual
     165     DIO registers to update the value.
     166  */
     167
     168  offset_val = offset & 0xff;
     169  byte_val = value;
     170  outb(byte_val, base_port + 0x10 + offset_val);
     171
     172  return 0;
     173}
     174
     175
     176///////////////////////////////////////////////////////////////////////////////
     177//
     178//    WRITE_DAC_COMMAND
     179//
     180//////////////////////////////////////////////////////////////////////////////
     181
     182int write_dac_command(int dac_num,unsigned char value)
     183{
     184  unsigned char  byte_val;
     185  unsigned char  offset_val;
     186
     187  mio_error_code = MIO_SUCCESS;
     188
     189  if (check_handle())   /* Check for chip available */
     190    return -1;
     191
     192  byte_val = dac_num & 0xff;            /* This is the DAC number */
     193  offset_val = value;                   /* This is the data value */
     194  if (byte_val)
     195    outb(offset_val,base_port + 0x0e);
     196  else
     197    outb(offset_val,base_port + 0x0a);
     198
     199  return 0;
     200}
     201
     202///////////////////////////////////////////////////////////////////////////////
     203//
     204//    WRITE_ADC_COMMAND
     205//
     206//////////////////////////////////////////////////////////////////////////////
     207
     208int write_adc_command(int adc_num,unsigned char value)
     209{
     210  unsigned char byte_val;
     211  unsigned char offset_val;
     212
     213  mio_error_code = MIO_SUCCESS;
     214
     215  if (check_handle())   /* Check for chip available */
     216    return -1;
     217
     218  byte_val = adc_num & 0xff;            /* This is the ADC number */
     219  offset_val = value;                   /* This is the data value */
     220
     221  if(byte_val)
     222    outb(offset_val,base_port + 0x06);
     223  else
     224    outb(offset_val,base_port + 0x02);
     225  return 0;
     226}
     227
     228///////////////////////////////////////////////////////////////////////////////
     229//
     230//    WRITE_DAC_DATA
     231//
     232//////////////////////////////////////////////////////////////////////////////
     233
     234int write_dac_data(int dac_num, unsigned short value)
     235{
     236  unsigned short word_val;
     237  unsigned char byte_val;
     238
     239  mio_error_code = MIO_SUCCESS;
     240
     241  if (check_handle())   /* Check for chip available */
     242    return -1;
     243
     244  byte_val = dac_num;
     245  word_val = value;
     246
     247  if(byte_val)          /* DAC 1 */
     248    outw(word_val,base_port+0x0c);
     249  else
     250    outw(word_val,base_port+8);
     251 
     252  return 0;
     253}
     254
     255///////////////////////////////////////////////////////////////////////////////
     256//
     257//    DAC_READ_STATUS
     258//
     259//////////////////////////////////////////////////////////////////////////////
     260
     261unsigned char dac_read_status(int dac_num)
     262{
     263  mio_error_code = MIO_SUCCESS;
     264
     265  if (check_handle())   /* Check for chip available */
     266    return -1;
     267
     268  if (dac_num)
     269    return inb(base_port + 0x0f);
     270
     271  return inb(base_port + 0x0b);
     272}
     273
     274///////////////////////////////////////////////////////////////////////////////
     275//
     276//    ADC_READ_STATUS
     277//
     278//////////////////////////////////////////////////////////////////////////////
     279
     280unsigned char adc_read_status(int adc_num)
     281{
     282  mio_error_code = MIO_SUCCESS;
     283
     284  if (check_handle())   /* Check for chip available */
     285    return -1;
     286
     287  if (adc_num)
     288    return inb(base_port + 7);
     289  return inb(base_port + 3);
     290}
     291
     292///////////////////////////////////////////////////////////////////////////////
     293//
     294//    ADC_READ_CONVERSION_DATA
     295//
     296//////////////////////////////////////////////////////////////////////////////
     297
     298unsigned short adc_read_conversion_data(int channel)
     299{
     300int adc_num;
     301
     302  mio_error_code = MIO_SUCCESS;
     303
     304  if (check_handle())   /* Check for chip available */
     305    return -1;
     306
     307  if (channel > 7)
     308    adc_num = 1;
     309  else
     310    adc_num = 0;
     311
     312  if (adc_num)
     313    return inw(base_port + 4);
     314
     315  return inw(base_port);
     316}
     317
     318
     319int dio_get_int(void)
     320{
     321  if (check_handle())   /* Check for chip available */
     322    return -1;
     323
     324  return get_buffered_int() & 0xff;
     325
     326}
     327
     328static int handle = 0; /* XXX move to lower */
     329
     330
     331int wait_adc_int(int adc_num)
     332{
     333  int c;
     334
     335  if (check_handle())   /* Check for chip available */
     336    return -1;
     337
     338  if (adc_num)
     339      c=ioctl(handle,WAIT_A2D_INT_1,NULL);
     340  else
     341      c=ioctl(handle,WAIT_A2D_INT_2,NULL);
     342
     343
     344  return (c & 0xff);
     345
     346}
     347
     348
     349int wait_dac_int(int dac_num)
     350{
     351  int c;
     352
     353  if (check_handle())   /* Check for chip available */
     354    return -1;
     355
     356  if (dac_num)
     357      c=ioctl(handle,WAIT_DAC_INT_1,NULL);
     358  else
     359      c=ioctl(handle,WAIT_DAC_INT_2,NULL);
     360
     361  return (c & 0xff);
     362
     363}
     364
     365
     366int wait_dio_int(void)
     367{
     368  int c;
     369
     370  if (check_handle())   /* Check for chip available */
     371    return -1;
     372
     373  c=ioctl(handle,WAIT_DIO_INT,NULL);
     374
     375  return (c & 0xff);
     376
     377}
     378
     379
     380int check_handle(void)
     381{
     382  if (handle > 0)  /* If it's already a valid handle */
     383    return 0;
     384
     385  if (handle == -1)  /* If it's already been tried */
     386  {
     387    mio_error_code = MIO_OPEN_ERROR;
     388    sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
     389    return -1;
     390  }
     391
     392  /*
     393   * 0  ==> not initialized
     394   * 1+ ==> valid file handle, thus initialized
     395   * -1 ==> already attempted to open
     396   */
     397  handle = 1;
     398  return 0;
     399
     400  /* if an error happens, go here */
     401  mio_error_code = MIO_OPEN_ERROR;
     402  sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
     403  handle = -1;
     404  return -1;
     405}
     406
     407
     408/*
     409 *  From this point down, we should be able to share easily with the Linux
     410 *  driver but I haven't gone to the trouble to do surgery on it.  I have
     411 *  no way to test it.
     412 */
     413
     414/* We will buffer up the transition interrupts and will pass them on
     415   to waiting applications
    43416*/
    44417
    45 int handle = 0;
    46 char *device_id ="pcmmio";
    47 char *dev_id    = "/dev/pcmmio";
    48 
    49 ///////////////////////////////////////////////////////////////////////////////
    50 //
    51 //              MIO_READ_IRQ_ASSIGNED
    52 //
    53 //////////////////////////////////////////////////////////////////////////////
    54 
    55 int mio_read_irq_assigned(void)
    56 {
    57 unsigned char val;
    58 
    59         mio_error_code = MIO_SUCCESS;
    60 
    61         if(check_handle())   /* Check for chip available */
    62                 return -1;
    63 
    64 
    65         /* All of our programming of the hardware is handled at this level so that
    66            all of the routines that need to shove and IRQ value into hardware will
    67            use this call.
    68         */
    69 
    70         val = ioctl(handle,READ_IRQ_ASSIGNED,NULL);
    71 
    72         return val & 0xff;
    73 }
    74 
    75 ///////////////////////////////////////////////////////////////////////////////
    76 //
    77 //              READ_DIO_BYTE
    78 //
    79 //////////////////////////////////////////////////////////////////////////////
    80 
    81 unsigned char read_dio_byte(int offset)
    82 {
    83 int val;
    84 
    85         mio_error_code = MIO_SUCCESS;
    86 
    87         if(check_handle())   /* Check for chip available */
    88                 return -1;
    89 
    90         /* All bit operations are handled at this level so we need only
    91         read and write bytes from the actual hardware using the driver
    92         to handle our ioctl call for it.
    93         */
    94 
    95     val = ioctl(handle,READ_DIO_BYTE,offset);
    96 
    97         return (unsigned char) (val & 0xff);;
    98 }
    99 
    100 ///////////////////////////////////////////////////////////////////////////////
    101 //
    102 //              MIO_READ_REG
    103 //
    104 //////////////////////////////////////////////////////////////////////////////
    105 
    106 unsigned char mio_read_reg(int offset)
    107 {
    108 int val;
    109 
    110         mio_error_code = MIO_SUCCESS;
    111 
    112         if(check_handle())   /* Check for chip available */
    113                 return -1;
    114 
    115 
    116         /* This is a catchall register read routine that allows reading of
    117            ANY of the registers on the PCM-MIO. It is used primarily for
    118            retreiving control and access values in the hardware.
    119    */
    120 
    121      val = ioctl(handle,MIO_READ_REG,offset);
    122 
    123         return (unsigned char) (val & 0xff);
    124 }
    125 
    126 ///////////////////////////////////////////////////////////////////////////////
    127 //
    128 //              MIO_WRITE_REG
    129 //
    130 //////////////////////////////////////////////////////////////////////////////
    131 
    132 int mio_write_reg(int offset, unsigned char value)
    133 {
    134 unsigned short param;
    135 int val;
    136 
    137         mio_error_code = MIO_SUCCESS;
    138 
    139         if(check_handle())   /* Check for chip available */
    140                 return -1;
    141 
    142         param = offset & 0xff;
    143 
    144         param = param | (value << 8);
    145    
    146         /* This function like the previous allow unlimited
    147            write access to ALL of the registers on the PCM-MIO
    148    */
    149 
    150         val = ioctl(handle,MIO_WRITE_REG,param);
    151        
    152         return 0;
    153 }
    154 
    155 
    156 ///////////////////////////////////////////////////////////////////////////////
    157 //
    158 //              WRITE_DIO_BYTE
    159 //
    160 //////////////////////////////////////////////////////////////////////////////
    161 
    162 int write_dio_byte(int offset, unsigned char value)
    163 {
    164 unsigned short param;
    165 int val;
    166 
    167         mio_error_code = MIO_SUCCESS;
    168 
    169         if(check_handle())   /* Check for chip available */
    170                 return -1;
    171 
    172         param = offset & 0xff;
    173 
    174         param = param | (value << 8);
    175    
    176         /* All bit operations for the DIO are handled at this level
    177            and we need the driver to allow access to the actual
    178            DIO registers to update the value.
    179     */
    180 
    181         val = ioctl(handle,WRITE_DIO_BYTE,param);
    182        
    183         return 0;
    184 }
    185 
    186 
    187 ///////////////////////////////////////////////////////////////////////////////
    188 //
    189 //              WRITE_DAC_COMMAND
    190 //
    191 //////////////////////////////////////////////////////////////////////////////
    192 
    193 int write_dac_command(int dac_num,unsigned char value)
    194 {
    195 unsigned short param;
    196 int val;
    197 
    198         mio_error_code = MIO_SUCCESS;
    199 
    200         if(check_handle())   /* Check for chip available */
    201                 return -1;
    202 
    203         param = dac_num & 0xff;
    204 
    205         param = param | (value << 8);
    206 
    207         val = ioctl(handle,WRITE_DAC_COMMAND,param);
    208 
    209         return 0;
    210 }
    211 
    212 ///////////////////////////////////////////////////////////////////////////////
    213 //
    214 //              WRITE_ADC_COMMAND
    215 //
    216 //////////////////////////////////////////////////////////////////////////////
    217 
    218 int write_adc_command(int adc_num,unsigned char value)
    219 {
    220 unsigned short param;
    221 int ret_val;
    222 
    223         mio_error_code = MIO_SUCCESS;
    224 
    225         if(check_handle())   /* Check for chip available */
    226                 return -1;
    227 
    228         param = adc_num & 0xff;
    229 
    230         param = param | (value << 8);
    231 
    232     ret_val = ioctl(handle,WRITE_ADC_COMMAND,param);
    233 
    234         return 0;
    235 }
    236 
    237 ///////////////////////////////////////////////////////////////////////////////
    238 //
    239 //              WRITE_DAC_DATA
    240 //
    241 //////////////////////////////////////////////////////////////////////////////
    242 
    243 int write_dac_data(int dac_num, unsigned short value)
    244 {
    245 int ret_val;
    246 unsigned char buffer[3];
    247 
    248         mio_error_code = MIO_SUCCESS;
    249 
    250         if(check_handle())   /* Check for chip available */
    251                 return -1;
    252 
    253         buffer[0] = dac_num;
    254         buffer[1] = value & 0xff;
    255         buffer[2] = value >> 8;
    256 
    257     ret_val = ioctl(handle,WRITE_DAC_DATA,buffer);
    258        
    259         return 0;
    260 }
    261 
    262 ///////////////////////////////////////////////////////////////////////////////
    263 //
    264 //              DAC_READ_STATUS
    265 //
    266 //////////////////////////////////////////////////////////////////////////////
    267 
    268 unsigned char dac_read_status(int dac_num)
    269 {
    270 int ret_val;
    271 
    272         mio_error_code = MIO_SUCCESS;
    273 
    274         if(check_handle())   /* Check for chip available */
    275                 return -1;
    276 
    277     ret_val = ioctl(handle,READ_DAC_STATUS,dac_num);
    278 
    279         return ret_val & 0xff;
    280 }
    281 
    282 ///////////////////////////////////////////////////////////////////////////////
    283 //
    284 //              ADC_READ_STATUS
    285 //
    286 //////////////////////////////////////////////////////////////////////////////
    287 
    288 unsigned char adc_read_status(int adc_num)
    289 {
    290 int ret_val;
    291 
    292         mio_error_code = MIO_SUCCESS;
    293 
    294         if(check_handle())   /* Check for chip available */
    295                 return -1;
    296 
    297     ret_val = ioctl(handle,READ_ADC_STATUS,adc_num);
    298 
    299         return (ret_val & 0xff);
    300 }
    301 
    302 ///////////////////////////////////////////////////////////////////////////////
    303 //
    304 //              ADC_READ_CONVERSION_DATA
    305 //
    306 //////////////////////////////////////////////////////////////////////////////
    307 
    308 unsigned short adc_read_conversion_data(int channel)
    309 {
    310 int ret_val;
    311 int adc_num;
    312 
    313         mio_error_code = MIO_SUCCESS;
    314 
    315         if(check_handle())   /* Check for chip available */
    316                 return -1;
    317 
    318         if(channel > 7)
    319                 adc_num = 1;
    320         else
    321                 adc_num = 0;
    322 
    323     ret_val = ioctl(handle,READ_ADC_DATA,adc_num);
    324        
    325         return (ret_val & 0xffff);
    326 }
    327 
    328 
    329 int dio_get_int(void)
    330 {
    331 int c;
    332 
    333     c=ioctl(handle,DIO_GET_INT,NULL);
    334 
    335     return (c & 0xff);
    336 
    337 }
    338 
    339 
    340 int wait_adc_int(int adc_num)
    341 {
    342 int c;
    343 
    344 
    345     if(check_handle())   /* Check for chip available */
    346                 return -1;
    347 
    348         if(adc_num)
    349             c=ioctl(handle,WAIT_A2D_INT_1,NULL);
    350         else
    351             c=ioctl(handle,WAIT_A2D_INT_2,NULL);
    352 
    353 
    354     return (c & 0xff);
    355 
    356 }
    357 
    358 
    359 int wait_dac_int(int dac_num)
    360 {
    361 int c;
    362 
    363     if(check_handle())   /* Check for chip available */
    364                 return -1;
    365 
    366         if(dac_num)
    367             c=ioctl(handle,WAIT_DAC_INT_1,NULL);
    368         else
    369             c=ioctl(handle,WAIT_DAC_INT_2,NULL);
    370 
    371     return (c & 0xff);
    372 
    373 }
    374 
    375 
    376 int wait_dio_int(void)
    377 {
    378 int c;
    379 
    380 
    381     if(check_handle())   /* Check for chip available */
    382                 return -1;
    383 
    384     c=ioctl(handle,WAIT_DIO_INT,NULL);
    385 
    386     return (c & 0xff);
    387 
    388 }
    389 
    390 
    391 
    392 int check_handle(void)
    393 {
    394     if(handle > 0)      /* If it's already a valid handle */
    395                 return 0;
    396 
    397     if(handle == -1)    /* If it's already been tried */
    398         {
    399                 mio_error_code = MIO_OPEN_ERROR;
    400                 sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
    401                 return -1;
    402         }
    403 
    404     /* Try opening the device file, in case it hasn't been opened yet */
    405 
    406     handle = open(device_id,0);
    407 
    408         /* Try an alternate open at /dev */
    409 
    410         if(handle < 0)
    411                 handle = open(dev_id,0);
    412 
    413     if(handle > 0)      /* If it's now a valid handle */
    414                 return 0;
    415 
    416         mio_error_code = MIO_OPEN_ERROR;
    417         sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
    418     handle = -1;
    419         return -1;
    420 }
    421 
     418#define MAX_INTS 1024
     419
     420static unsigned char int_buffer[MAX_INTS];
     421static int inptr = 0;
     422static int outptr = 0;
     423
     424void clr_int(int bit_number)
     425{
     426  unsigned short port;
     427  unsigned short temp;
     428  unsigned short mask;
     429  unsigned short dio_port;
     430
     431  dio_port = base_port + 0x10;
     432
     433  /* Also adjust bit number */
     434  --bit_number;
     435
     436  /* Calculate the I/O address based upon bit number */
     437  port = (bit_number / 8) + dio_port + 8;
     438
     439  /* Calculate a bit mask based upon the specified bit number */
     440  mask = (1 << (bit_number % 8));
     441
     442  /* Turn on page 2 access */
     443  outb(0x80,dio_port+7);
     444
     445  /* Get the current state of the interrupt enable register */
     446  temp = inb(port);
     447
     448  /* Temporarily clear only our enable. This clears the interrupt */
     449  temp = temp & ~mask;    /* Clear the enable for this bit */
     450
     451  /* Now update the interrupt enable register */
     452  outb(temp,port);
     453
     454  /* Re-enable our interrupt bit */
     455  temp = temp | mask;
     456  outb(temp,port);
     457
     458  /* Set access back to page 0 */
     459  outb(0x00,dio_port+7);
     460}
     461
     462int get_int(void)
     463{
     464  int temp;
     465  int x;
     466  unsigned short dio_port;
     467
     468  dio_port = base_port + 0x10;
     469
     470  /* Read the master interrupt pending register,
     471           mask off undefined bits */
     472  temp = inb(dio_port+6) & 0x07;
     473
     474  /* If there are no pending interrupts, return 0 */
     475  if ((temp & 7) == 0)
     476    return 0;
     477
     478  /* There is something pending, now we need to identify it */
     479
     480  /* Set access to page 3 for interrupt id register */
     481  outb(0xc0, dio_port + 7);
     482
     483  /* Read the interrupt ID register for port 0 */
     484  temp = inb(dio_port+8);
     485
     486  /* See if any bit set, if so return the bit number */
     487  if (temp != 0) {
     488    for (x=0; x<=7; x++) {
     489      if (temp & (1 << x)) {
     490        outb(0,dio_port+7);
     491        return(x+1);
     492       }
     493    }
     494  }
     495
     496  /* None in port 0, read port 1 interrupt ID register */
     497  temp = inb(dio_port+9);
     498
     499  /* See if any bit set, if so return the bit number */
     500  if (temp != 0) {
     501    for (x=0; x<=7; x++) {
     502      if (temp & (1 << x)) {
     503        outb(0,dio_port+7);
     504        return(x+9);
     505      }
     506    }
     507  }
     508
     509  /* Lastly, read the statur of port 2 interrupt ID register */
     510  temp = inb(dio_port+0x0a);
     511
     512  /* If any pending, return the appropriate bit number */
     513  if (temp != 0) {
     514    for (x=0; x<=7; x++) {
     515      if (temp & (1 << x)) {
     516         outb(0,dio_port+7);
     517         return(x+17);
     518      }
     519    }
     520  }
     521
     522  /* We should never get here unless the hardware is seriously
     523     misbehaving, but just to be sure, we'll turn the page access
     524     back to 0 and return a 0 for no interrupt found
     525  */
     526  outb(0,dio_port+7);
     527  return 0;
     528}
     529
     530
     531int get_buffered_int(void)
     532{
     533  int temp;
     534
     535  if (irq == 0) {
     536    temp = get_int();
     537    if (temp)
     538      clr_int(temp);
     539    return temp;
     540  }
     541
     542  if (outptr != inptr) {
     543    temp = int_buffer[outptr++];
     544    if (outptr == MAX_INTS)
     545      outptr = 0;
     546    return temp;
     547  }
     548
     549  return 0;
     550}
     551
     552
     553
     554
     555
Note: See TracChangeset for help on using the changeset viewer.