workbench/devs/AHI/Drivers/SB128/driver-init.c

   1 /*
   2
   3 The contents of this file are subject to the AROS Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
   4 http://www.aros.org/license.html
   5
   6 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   7 ANY KIND, either express or implied. See the License for the specific language governing rights and
   8 limitations under the License.
   9
  10 The Original Code is (C) Copyright 2004-2011 Ross Vumbaca.
  11
  12 The Initial Developer of the Original Code is Ross Vumbaca.
  13
  14 All Rights Reserved.
  15
  16 */
  17
  18 #include <exec/memory.h>
  19
  20 #include <proto/exec.h>
  21 #include <proto/dos.h>
  22
  23 #include <devices/timer.h>
  24
  25 #define DEBUG 1
  26 #include <aros/debug.h>
  27 #define DebugPrintF bug
  28
  29 #include "library.h"
  30 #include "version.h"
  31 #include "misc.h"
  32 #include "regs.h"
  33
  34 #include "pci_wrapper.h"
  35
  36 struct DosLibrary* DOSBase;
  37 struct DriverBase* AHIsubBase;
  38 struct Library*             ExpansionBase = NULL;
  39
  40 struct VendorDevice
  41 {
  42     UWORD vendor;
  43     UWORD device;
  44 };
  45
  46 #define CARD_STRING "SB128"
  47 #define MAX_DEVICE_VENDORS 512
  48
  49 struct VendorDevice *vendor_device_list = NULL;
  50 static int vendor_device_list_size = 0;
  51
  52 /******************************************************************************
  53 ** Custom driver init *********************************************************
  54 ******************************************************************************/
  55
  56 BOOL
  57 DriverInit( struct DriverBase* ahisubbase )
  58 {
  59   struct SB128Base* SB128Base = (struct SB128Base*) ahisubbase;
  60   struct PCIDevice   *dev;
  61     int                 card_no, i;
  62     struct List         foundCards;
  63     struct Node         *devTmp;
  64
  65     bug("[SB128]: %s()\n", __PRETTY_FUNCTION__);
  66
  67   SB128Base->cards_found = 0;
  68   SB128Base->driverdatas = 0;
  69   AHIsubBase = ahisubbase;
  70
  71   DOSBase  = OpenLibrary( DOSNAME, 37 );
  72
  73   if( DOSBase == NULL )
  74   {
  75     Req( "Unable to open 'dos.library' version 37.\n" );
  76     return FALSE;
  77   }
  78
  79   ExpansionBase = OpenLibrary( "expansion.library", 50 );
  80   if( ExpansionBase == NULL )
  81   {
  82     Req( "Unable to open 'expansion.library' version 50.\n" );
  83     return FALSE;
  84   }
  85
  86     if (!ahi_pci_init(ahisubbase))
  87     {
  88         return FALSE;
  89     }
  90
  91   /* Timer Device */
  92
  93 /*  replymp = (struct MsgPort *) CreatePort(NULL, 0);
  94   if (!replymp)
  95   {
  96     DebugPrintF("SB128: Couldn't create ReplyPort!\n");
  97     return FALSE;
  98   }*/
  99
 100   /*TimerIO = (struct timerequest *)CreateIORequest(replymp, sizeof(struct timerequest));
 101
 102   if (TimerIO == NULL)
 103   {
 104     DebugPrintF("Out of memory.\n");
 105     return FALSE;
 106   }
 107
 108   if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *)TimerIO, 0) != 0)
 109   {
 110     DebugPrintF("Unable to open 'timer.device'.\n");
 111     return FALSE;
 112   }
 113   else
 114     TimerBase = (struct Device *)TimerIO->tr_node.io_Device;*/
 115
 116   InitSemaphore( &SB128Base->semaphore );
 117
 118     /*** Count cards ***********************************************************/
 119
 120     vendor_device_list = (struct VendorDevice *) AllocVec(sizeof(struct VendorDevice) * MAX_DEVICE_VENDORS, MEMF_PUBLIC | MEMF_CLEAR);
 121
 122     vendor_device_list[0].vendor = 0x1274;
 123     vendor_device_list[0].device = 0x5000;
 124     vendor_device_list_size++;
 125
 126     vendor_device_list[0].vendor = 0x1274;
 127     vendor_device_list[0].device = 0x1371;
 128     vendor_device_list_size++;
 129
 130     vendor_device_list[0].vendor = 0x1274;
 131     vendor_device_list[0].device = 0x5880;
 132     vendor_device_list_size++;
 133
 134     vendor_device_list[0].vendor = 0x1102;
 135     vendor_device_list[0].device = 0x8938;
 136     vendor_device_list_size++;
 137
 138     bug("vendor_device_list_size = %ld\n", vendor_device_list_size);
 139
 140     SB128Base->cards_found = 0;
 141     dev = NULL;
 142
 143     for (i = 0; i < vendor_device_list_size; i++)
 144     {
 145         dev = ahi_pci_find_device(vendor_device_list[i].vendor, vendor_device_list[i].device, dev);
 146
 147         if (dev != NULL)
 148         {
 149             bug("[SB128] %s: Found SB128 #%d [%4x:%4x] pci obj @ 0x%p\n", __PRETTY_FUNCTION__, i, vendor_device_list[i].vendor, vendor_device_list[i].device, dev);
 150             ++SB128Base->cards_found;
 151
 152             devTmp = AllocVec(sizeof(struct Node), MEMF_CLEAR);
 153             devTmp->ln_Name = dev;
 154             AddTail(&foundCards, devTmp);
 155         }
 156     }
 157
 158     // Fail if no hardware is present (prevents the audio modes from being added to
 159     // the database if the driver cannot be used).
 160
 161     if(SB128Base->cards_found == 0 )
 162     {
 163         DebugPrintF("No SB128 found! :-(\n");
 164         Req( "No card present.\n" );
 165         return FALSE;
 166     }
 167
 168   /*** CAMD ******************************************************************/
 169 #if 0
 170   InitSemaphore( &SB128Base->camd.Semaphore );
 171   SB128Base->camd.Semaphore.ss_Link.ln_Pri  = 0;
 172
 173   SB128Base->camd.Semaphore.ss_Link.ln_Name = Card_CAMD_SEMAPHORE;
 174   AddSemaphore( &SB128Base->camd.Semaphore );
 175
 176   SB128Base->camd.Cards    = SB128Base->cards_found;
 177   SB128Base->camd.Version  = VERSION;
 178   SB128Base->camd.Revision = REVISION;
 179
 180
 181   SB128Base->camd.OpenPortFunc.h_Entry    = OpenCAMDPort;
 182   SB128Base->camd.OpenPortFunc.h_SubEntry = NULL;
 183   SB128Base->camd.OpenPortFunc.h_Data     = NULL;
 184
 185   SB128Base->camd.ClosePortFunc.h_Entry    = (HOOKFUNC) CloseCAMDPort;
 186   SB128Base->camd.ClosePortFunc.h_SubEntry = NULL;
 187   SB128Base->camd.ClosePortFunc.h_Data     = NULL;
 188
 189   SB128Base->camd.ActivateXmitFunc.h_Entry    = (HOOKFUNC) ActivateCAMDXmit;
 190   SB128Base->camd.ActivateXmitFunc.h_SubEntry = NULL;
 191   SB128Base->camd.ActivateXmitFunc.h_Data     = NULL;
 192 #endif
 193
 194
 195   /*** Allocate and init all cards *******************************************/
 196
 197   SB128Base->driverdatas = AllocVec( sizeof( *SB128Base->driverdatas ) *
 198                                        SB128Base->cards_found,
 199                                        MEMF_PUBLIC );
 200
 201   if( SB128Base->driverdatas == NULL )
 202   {
 203     Req( "Out of memory." );
 204     return FALSE;
 205   }
 206
 207   card_no = 0;
 208
 209     struct Node *scratchNode;
 210     ForeachNodeSafe(&foundCards, devTmp, scratchNode)
 211     {
 212         Remove(devTmp);
 213
 214         dev = devTmp->ln_Name;
 215         bug("[SB128] %s: Prepairing card #%d pci obj @ 0x%p\n", __PRETTY_FUNCTION__, card_no, dev);
 216         SB128Base->driverdatas[ card_no ] = AllocDriverData( dev, AHIsubBase );
 217
 218         FreeVec(devTmp);
 219         ++card_no;
 220     }
 221
 222     bug("[SB128] %s: Done.\n", __PRETTY_FUNCTION__);
 223
 224
 225   return TRUE;
 226 }
 227
 228
 229 /******************************************************************************
 230 ** Custom driver clean-up *****************************************************
 231 ******************************************************************************/
 232
 233 VOID
 234 DriverCleanup( struct DriverBase* AHIsubBase )
 235 {
 236   struct SB128Base* SB128Base = (struct SB128Base*) AHIsubBase;
 237   int i;
 238 #if 0
 239   if( SB128Base->camd.Semaphore.ss_Link.ln_Name != NULL )
 240   {
 241     ObtainSemaphore( &SB128Base->camd.Semaphore );
 242     RemSemaphore( &SB128Base->camd.Semaphore );
 243     ReleaseSemaphore( &SB128Base->camd.Semaphore );
 244   }
 245 #endif
 246
 247   for( i = 0; i < SB128Base->cards_found; ++i )
 248   {
 249     if (SB128Base->driverdatas)
 250     {
 251       pci_outl( 0, SB128_SCON, SB128Base->driverdatas[i] );
 252       FreeDriverData( SB128Base->driverdatas[ i ], AHIsubBase );
 253     }
 254   }
 255
 256   if (SB128Base->driverdatas)
 257     FreeVec( SB128Base->driverdatas );
 258
 259   /*if (TimerIO)
 260   {
 261     CloseDevice((struct IORequest *)TimerIO);
 262     DeleteIORequest((struct IORequest *)TimerIO);
 263   }*/
 264
 265   /*if (replymp)
 266     DeletePort(replymp);*/
 267
 268   ahi_pci_exit();
 269
 270   if (ExpansionBase)
 271     CloseLibrary( (struct Library*) ExpansionBase );
 272
 273   if (UtilityBase)
 274     CloseLibrary( (struct Library*) UtilityBase );
 275
 276   if (DOSBase)
 277     CloseLibrary( (struct Library*) DOSBase );
 278 }