rom/isapnp/controller.c

   1 /* $Id: controller.c,v 1.7 2001/05/29 10:53:44 lcs Exp $ */
   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     bug("[ISAPNP] ISAC_SetMasterInt() is not implemented\n");
  41 /*UWORD* reg2 = (UWORD*)( res->m_Base + 0x18002 );
  42
  43   if( on )
  44   {
  45     WriteWord( reg2, 0 );
  46   }
  47   else
  48   {
  49     ReadWord( reg2 );
  50   }*/
  51 }
  52
  53
  54 BOOL ASMCALL
  55 ISAC_GetMasterInt( REG( a6, struct ISAPNPBase* res ) )
  56 {
  57     bug("[ISAPNP] ISAC_GetMasterInt() is not implemented\n");
  58 /*UWORD* reg1 = (UWORD*)( res->m_Base + 0x18000 );
  59
  60   return ( ReadWord( reg1 ) & 1 ) != 0;*/
  61 }
  62
  63
  64 void ASMCALL
  65 ISAC_SetWaitState( REG( d0, BOOL               on ),
  66                    REG( a6, struct ISAPNPBase* res ) )
  67 {
  68     bug("[ISAPNP] ISAC_SetWaitState() is not implemented\n");
  69 #if 0
  70   UBYTE* reg3 = (UBYTE*) ( isa_Base + 0x18007 );
  71
  72   if( (  on && !WaitState() ) ||
  73       ( !on &&  WaitState() ) )
  74   {
  75     *reg3 = 0;             // Toggle
  76   }
  77 #endif
  78 }
  79
  80
  81 BOOL ASMCALL
  82 ISAC_GetWaitState( REG( a6, struct ISAPNPBase* res ) )
  83 {
  84     bug("[ISAPNP] ISAC_GetWaitState() is not implemented\n");
  85 /*UWORD* reg1 = (UWORD*)( res->m_Base + 0x18000 );
  86
  87   return ( ReadWord( reg1 ) & 2 ) != 0;*/
  88 }
  89
  90
  91 BOOL ASMCALL
  92 ISAC_GetInterruptStatus( REG( d0, UBYTE              interrupt ),
  93                          REG( a6, struct ISAPNPBase* res ) )
  94 {
  95     bug("[ISAPNP] ISAC_GetInterruptStatus() is not implemented\n");
  96 /*UWORD* reg1 = (UWORD*)( res->m_Base + 0x18000 );
  97
  98   switch( interrupt )
  99   {
 100     case 3:
 101       return ( ReadWord( reg1 ) & 4 ) != 0;
 102
 103     case 4:
 104       return ( ReadWord( reg1 ) & 8 ) != 0;
 105
 106     case 5:
 107       return ( ReadWord( reg1 ) & 16 ) != 0;
 108
 109     case 6:
 110       return ( ReadWord( reg1 ) & 32 ) != 0;
 111
 112     case 7:
 113       return ( ReadWord( reg1 ) & 64 ) != 0;
 114
 115     case 9:
 116       return ( ReadWord( reg1 ) & 128 ) != 0;
 117
 118     case 10:
 119       return ( ReadWord( reg1 ) & 256 ) != 0;
 120
 121     case 11:
 122       return ( ReadWord( reg1 ) & 512 ) != 0;
 123
 124     case 12:
 125       return ( ReadWord( reg1 ) & 1024 ) != 0;
 126
 127     case 14:
 128       return ( ReadWord( reg1 ) & 2048 ) != 0;
 129
 130     case 15:
 131       return ( ReadWord( reg1 ) & 4096 ) != 0;
 132   }
 133 */
 134   return FALSE;
 135 }
 136
 137
 138 UBYTE ASMCALL
 139 ISAC_GetRegByte( REG( d0, UWORD              reg ),
 140                  REG( a6, struct ISAPNPBase* res ) )
 141 {
 142     return inb(reg);
 143 }
 144
 145
 146 void ASMCALL
 147 ISAC_SetRegByte( REG( d0, UWORD              reg ),
 148                  REG( d1, UBYTE              value ),
 149                  REG( a6, struct ISAPNPBase* res ) )
 150 {
 151     outb(value, reg);
 152 }
 153
 154
 155 UWORD ASMCALL
 156 ISAC_GetRegWord( REG( d0, UWORD              reg ),
 157                  REG( a6, struct ISAPNPBase* res ) )
 158 {
 159     return inw(reg);
 160 }
 161
 162
 163 void ASMCALL
 164 ISAC_SetRegWord( REG( d0, UWORD              reg ),
 165                  REG( d1, UWORD              value ),
 166                  REG( a6, struct ISAPNPBase* res ) )
 167 {
 168     outw(value, reg);
 169 }
 170
 171
 172 ULONG ASMCALL
 173 ISAC_GetRegLong( REG( d0, UWORD              reg ),
 174                  REG( a6, struct ISAPNPBase* res ) )
 175 {
 176     return inl(reg);
 177 }
 178
 179
 180 void ASMCALL
 181 ISAC_SetRegLong( REG( d0, UWORD              reg ),
 182                  REG( d1, ULONG              value ),
 183                  REG( a6, struct ISAPNPBase* res ) )
 184 {
 185     outl(value, reg);
 186 }
 187
 188
 189 UBYTE ASMCALL
 190 ISAC_ReadByte( REG( d0, ULONG              address ),
 191                REG( a6, struct ISAPNPBase* res ) )
 192 {
 193     return *(UBYTE *)address;
 194 }
 195
 196
 197 void ASMCALL
 198 ISAC_WriteByte( REG( d0, ULONG              address ),
 199                 REG( d1, UBYTE              value ),
 200                 REG( a6, struct ISAPNPBase* res ) )
 201 {
 202     *(UBYTE *)address = value;
 203 }
 204
 205
 206 UWORD ASMCALL
 207 ISAC_ReadWord( REG( d0, ULONG              address ),
 208                REG( a6, struct ISAPNPBase* res ) )
 209 {
 210     return *(UWORD *)address;
 211 }
 212
 213
 214 void ASMCALL
 215 ISAC_WriteWord( REG( d0, ULONG              address ),
 216                 REG( d1, UWORD              value ),
 217                 REG( a6, struct ISAPNPBase* res ) )
 218 {
 219     *(UWORD *)address = value;
 220 }
 221
 222
 223 ULONG ASMCALL
 224 ISAC_ReadLong( REG( d0, ULONG              address ),
 225                REG( a6, struct ISAPNPBase* res ) )
 226 {
 227     return *(ULONG *)address;
 228 }
 229
 230
 231 void ASMCALL
 232 ISAC_WriteLong( REG( d0, ULONG              address ),
 233                 REG( d1, ULONG              value ),
 234                 REG( a6, struct ISAPNPBase* res ) )
 235 {
 236     *(ULONG *)address = value;
 237 }