rom/isapnp/controller.c

   1 /* $Id$ */
   2
   3 /*
   4      ISA-PnP -- A Plug And Play ISA software layer for AmigaOS.
   5      Copyright (C) 2001 Martin Blom <martin@blom.org>
   6
   7      This library is free software; you can redistribute it and/or
   8      modify it under the terms of the GNU Library General Public
   9      License as published by the Free Software Foundation; either
  10      version 2 of the License, or (at your option) any later version.
  11
  12      This library is distributed in the hope that it will be useful,
  13      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15      Library General Public License for more details.
  16
  17      You should have received a copy of the GNU Library General Public
  18      License along with this library; if not, write to the
  19      Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
  20      MA 02139, USA.
  21 */
  22
  23 #include <asm/io.h>
  24 #include <libraries/configvars.h>
  25 #include <libraries/expansion.h>
  26
  27 #include <proto/expansion.h>
  28
  29 #include "controller.h"
  30 #include "isapnp_private.h"
  31
  32 /******************************************************************************
  33 *** Controller functions ******************************************************
  34 ******************************************************************************/
  35
  36 void ASMCALL
  37 ISAC_SetMasterInt( REG( d0, BOOL               on ),
  38                    REG( a6, struct ISAPNPBase* res ) )
  39 {
  40     /* On a PC we have no interrupt mapping so we don't have a 'master interrupt' */
  41 }
  42
  43
  44 BOOL ASMCALL
  45 ISAC_GetMasterInt( REG( a6, struct ISAPNPBase* res ) )
  46 {
  47     return TRUE;
  48 }
  49
  50
  51 void ASMCALL
  52 ISAC_SetWaitState( REG( d0, BOOL               on ),
  53                    REG( a6, struct ISAPNPBase* res ) )
  54 {
  55     /* On a PC we can't control it */
  56 }
  57
  58
  59 BOOL ASMCALL
  60 ISAC_GetWaitState( REG( a6, struct ISAPNPBase* res ) )
  61 {
  62     return TRUE;
  63 }
  64
  65
  66 BOOL ASMCALL
  67 ISAC_GetInterruptStatus( REG( d0, UBYTE              interrupt ),
  68                          REG( a6, struct ISAPNPBase* res ) )
  69 {
  70     bug("[ISAPNP] ISAC_GetInterruptStatus() is not implemented\n");
  71 /*UWORD* reg1 = (UWORD*)( res->m_Base + 0x18000 );
  72
  73   switch( interrupt )
  74   {
  75     case 3:
  76       return ( ReadWord( reg1 ) & 4 ) != 0;
  77
  78     case 4:
  79       return ( ReadWord( reg1 ) & 8 ) != 0;
  80
  81     case 5:
  82       return ( ReadWord( reg1 ) & 16 ) != 0;
  83
  84     case 6:
  85       return ( ReadWord( reg1 ) & 32 ) != 0;
  86
  87     case 7:
  88       return ( ReadWord( reg1 ) & 64 ) != 0;
  89
  90     case 9:
  91       return ( ReadWord( reg1 ) & 128 ) != 0;
  92
  93     case 10:
  94       return ( ReadWord( reg1 ) & 256 ) != 0;
  95
  96     case 11:
  97       return ( ReadWord( reg1 ) & 512 ) != 0;
  98
  99     case 12:
 100       return ( ReadWord( reg1 ) & 1024 ) != 0;
 101
 102     case 14:
 103       return ( ReadWord( reg1 ) & 2048 ) != 0;
 104
 105     case 15:
 106       return ( ReadWord( reg1 ) & 4096 ) != 0;
 107   }
 108 */
 109   return FALSE;
 110 }
 111
 112
 113 UBYTE ASMCALL
 114 ISAC_GetRegByte( REG( d0, UWORD              reg ),
 115                  REG( a6, struct ISAPNPBase* res ) )
 116 {
 117     return inb(reg);
 118 }
 119
 120
 121 void ASMCALL
 122 ISAC_SetRegByte( REG( d0, UWORD              reg ),
 123                  REG( d1, UBYTE              value ),
 124                  REG( a6, struct ISAPNPBase* res ) )
 125 {
 126     outb(value, reg);
 127 }
 128
 129
 130 UWORD ASMCALL
 131 ISAC_GetRegWord( REG( d0, UWORD              reg ),
 132                  REG( a6, struct ISAPNPBase* res ) )
 133 {
 134     return inw(reg);
 135 }
 136
 137
 138 void ASMCALL
 139 ISAC_SetRegWord( REG( d0, UWORD              reg ),
 140                  REG( d1, UWORD              value ),
 141                  REG( a6, struct ISAPNPBase* res ) )
 142 {
 143     outw(value, reg);
 144 }
 145
 146
 147 ULONG ASMCALL
 148 ISAC_GetRegLong( REG( d0, UWORD              reg ),
 149                  REG( a6, struct ISAPNPBase* res ) )
 150 {
 151     return inl(reg);
 152 }
 153
 154
 155 void ASMCALL
 156 ISAC_SetRegLong( REG( d0, UWORD              reg ),
 157                  REG( d1, ULONG              value ),
 158                  REG( a6, struct ISAPNPBase* res ) )
 159 {
 160     outl(value, reg);
 161 }
 162
 163
 164 UBYTE ASMCALL
 165 ISAC_ReadByte( REG( d0, ULONG              address ),
 166                REG( a6, struct ISAPNPBase* res ) )
 167 {
 168     return *(UBYTE *)address;
 169 }
 170
 171
 172 void ASMCALL
 173 ISAC_WriteByte( REG( d0, ULONG              address ),
 174                 REG( d1, UBYTE              value ),
 175                 REG( a6, struct ISAPNPBase* res ) )
 176 {
 177     *(UBYTE *)address = value;
 178 }
 179
 180
 181 UWORD ASMCALL
 182 ISAC_ReadWord( REG( d0, ULONG              address ),
 183                REG( a6, struct ISAPNPBase* res ) )
 184 {
 185     return *(UWORD *)address;
 186 }
 187
 188
 189 void ASMCALL
 190 ISAC_WriteWord( REG( d0, ULONG              address ),
 191                 REG( d1, UWORD              value ),
 192                 REG( a6, struct ISAPNPBase* res ) )
 193 {
 194     *(UWORD *)address = value;
 195 }
 196
 197
 198 ULONG ASMCALL
 199 ISAC_ReadLong( REG( d0, ULONG              address ),
 200                REG( a6, struct ISAPNPBase* res ) )
 201 {
 202     return *(ULONG *)address;
 203 }
 204
 205
 206 void ASMCALL
 207 ISAC_WriteLong( REG( d0, ULONG              address ),
 208                 REG( d1, ULONG              value ),
 209                 REG( a6, struct ISAPNPBase* res ) )
 210 {
 211     *(ULONG *)address = value;
 212 }