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

   1 /*
   2 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
   3 http://www.aros.org/license.html
   4
   5 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   6 ANY KIND, either express or implied. See the License for the specific language governing rights and
   7 limitations under the License.
   8
   9 (C) Copyright xxxx-2009 Davy Wentzler.
  10 (C) Copyright 2009-2010 Stephen Jones.
  11
  12 The Initial Developer of the Original Code is Davy Wentzler.
  13
  14 All Rights Reserved.
  15 */
  16
  17 #include <exec/memory.h>
  18
  19 #include <proto/expansion.h>
  20 #include <proto/dos.h>
  21 #include <proto/exec.h>
  22 #include <clib/alib_protos.h>
  23 #ifdef __AROS__
  24 #include <aros/debug.h>
  25 struct DosLibrary* DOSBase;
  26 struct Library *StdCBase = NULL;
  27 #endif
  28 #include <stdlib.h>
  29
  30 #include "library.h"
  31 #include "version.h"
  32 #include "pci_wrapper.h"
  33 #include "misc.h"
  34
  35
  36
  37 struct DriverBase* AHIsubBase;
  38
  39
  40 struct VendorDevice
  41 {
  42     UWORD vendor;
  43     UWORD device;
  44 };
  45
  46
  47 struct VendorDevice *vendor_device_list = NULL;
  48 static int vendor_device_list_size = 0;
  49
  50 static void parse_config_file(void);
  51 static int hex_char_to_int(char c);
  52 #define MAX_DEVICE_VENDORS 512
  53
  54
  55 /******************************************************************************
  56 ** Custom driver init *********************************************************
  57 ******************************************************************************/
  58
  59 BOOL DriverInit(struct DriverBase* ahisubbase)
  60 {
  61     struct HDAudioBase* card_base = (struct HDAudioBase*) ahisubbase;
  62     struct PCIDevice *dev;
  63     int card_no;
  64     int i;
  65
  66     D(bug("[HDAudio] %s()\n", __PRETTY_FUNCTION__));
  67     AHIsubBase = ahisubbase;
  68
  69     DOSBase = (struct DosLibrary *) OpenLibrary(DOSNAME, 37);
  70
  71     if (DOSBase == NULL)
  72     {
  73         Req("Unable to open 'dos.library' version 37.\n");
  74         return FALSE;
  75     }
  76
  77 #ifdef __AROS__
  78     StdCBase = OpenLibrary("stdc.library", 0);
  79     if (StdCBase == NULL)
  80     {
  81         Req("Unable to open 'stdc.library'.\n");
  82         return FALSE;
  83     }
  84 #endif
  85
  86     if (!ahi_pci_init(ahisubbase))
  87     {
  88         return FALSE;
  89     }
  90
  91     InitSemaphore(&card_base->semaphore);
  92
  93     /*** Count cards ***********************************************************/
  94
  95     vendor_device_list = (struct VendorDevice *) AllocVec(sizeof(struct VendorDevice) * MAX_DEVICE_VENDORS, MEMF_PUBLIC | MEMF_CLEAR);
  96
  97     // Add Intel ICH7 (used in iMica)
  98     vendor_device_list[0].vendor = 0x8086;
  99     vendor_device_list[0].device = 0x27D8;
 100     vendor_device_list_size++;
 101
 102     // Then parse the hdaudio.config file, if available in ENV:
 103     parse_config_file();
 104
 105     D(bug("[HDAudio] vendor_device_list_size = %ld\n", vendor_device_list_size));
 106
 107     card_base->cards_found = 0;
 108     dev = NULL;
 109
 110     for (i = 0; i < vendor_device_list_size; i++)
 111     {
 112         dev = ahi_pci_find_device(vendor_device_list[i].vendor, vendor_device_list[i].device, dev);
 113
 114         if (dev != NULL)
 115         {
 116             D(bug("[HDAudio] Found device with vendor ID = %x, device ID = %x!(i = %d)\n", vendor_device_list[i].vendor, vendor_device_list[i].device, i));
 117             ++card_base->cards_found;
 118             break; // stop at first found controller
 119         }
 120     }
 121
 122
 123     FreeVec(vendor_device_list);
 124
 125     // Fail if no hardware (prevents the audio modes from being added to
 126     // the database if the driver cannot be used).
 127
 128     if (card_base->cards_found == 0)
 129     {
 130         D(bug("[HDAudio] No HDaudio controller found! :-(\n"));
 131         return FALSE;
 132     }
 133
 134
 135     /*** Allocate and init all cards *******************************************/
 136
 137     card_base->driverdatas = (struct HDAudioChip **) AllocVec(
 138         sizeof(*card_base->driverdatas) * card_base->cards_found,
 139         MEMF_PUBLIC | MEMF_CLEAR);
 140
 141     if (card_base->driverdatas == NULL)
 142     {
 143         D(bug("[HDAudio] Out of memory.\n"));
 144         return FALSE;
 145     }
 146
 147     card_no = 0;
 148
 149     if (dev)
 150     {
 151         card_base->driverdatas[card_no] = AllocDriverData(dev, AHIsubBase);
 152         if (card_base->driverdatas[card_no] == NULL)
 153         {
 154             FreeVec(card_base->driverdatas);
 155             return FALSE;
 156         }
 157
 158         ++card_no;
 159     }
 160
 161     D(bug("[HDAudio] exit init\n"));
 162     return TRUE;
 163 }
 164
 165
 166 /******************************************************************************
 167 ** Custom driver clean-up *****************************************************
 168 ******************************************************************************/
 169
 170 VOID DriverCleanup(struct DriverBase* AHIsubBase)
 171 {
 172     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 173     int i;
 174
 175     for(i = 0; i < card_base->cards_found; ++i)
 176     {
 177         FreeDriverData(card_base->driverdatas[i], AHIsubBase);
 178     }
 179
 180     FreeVec(card_base->driverdatas);
 181
 182     ahi_pci_exit();
 183
 184 #ifdef __AROS__
 185     if (StdCBase)
 186     {
 187         CloseLibrary(StdCBase);
 188     }
 189 #endif
 190
 191     if (DOSBase)
 192     {
 193         CloseLibrary((struct Library*) DOSBase);
 194     }
 195 }
 196
 197
 198 static void parse_config_file(void)
 199 {
 200     BPTR config_file;
 201     BPTR handle;
 202
 203     handle = Lock("ENV:hdaudio.config", SHARED_LOCK);
 204
 205     if (handle == 0)
 206     {
 207         bug("No handle found\n");
 208         return;
 209     }
 210
 211     UnLock(handle);
 212
 213     config_file = Open("ENV:hdaudio.config", MODE_OLDFILE);
 214
 215     if (config_file)
 216     {
 217         BOOL Continue = TRUE;
 218         bug("Opened config file\n");
 219
 220         while (Continue)
 221         {
 222             char *line = (char *) AllocVec(512, MEMF_CLEAR);
 223             char *ret;
 224
 225             ret = FGets(config_file, line, 512);
 226
 227             if (ret == NULL)
 228             {
 229                 FreeVec(line);
 230                 break;
 231             }
 232
 233             if (ret[0] == '0' &&
 234                 ret[1] == 'x' &&
 235                 ret[6] == ',' &&
 236                 ret[7] == ' ' &&
 237                 ret[8] == '0' &&
 238                 ret[9] == 'x' &&
 239                 ret[15] == '\0')
 240             {
 241                 int value;
 242                 UWORD vendor, device;
 243                 char *tmp = (char *) AllocVec(16, MEMF_CLEAR);
 244                 char *tmp2 = (char *) AllocVec(4, MEMF_CLEAR);
 245
 246                 CopyMem(line + 2, tmp, 4);
 247                 tmp[4] = '\0';
 248
 249                 // convert hex to decimal
 250                 value = hex_char_to_int(tmp[0]) * 16 * 16 * 16 + hex_char_to_int(tmp[1]) * 16 * 16 + hex_char_to_int(tmp[2]) * 16 + hex_char_to_int(tmp[3]);
 251                 vendor = (UWORD) value;
 252
 253                 CopyMem(line + 10, tmp, 4);
 254                 value = hex_char_to_int(tmp[0]) * 16 * 16 * 16 + hex_char_to_int(tmp[1]) * 16 * 16 + hex_char_to_int(tmp[2]) * 16 + hex_char_to_int(tmp[3]);
 255                 device = (UWORD) value;
 256                 //bug("Adding vendor = %x, device = %x to list, size = %ld\n", vendor, device, vendor_device_list_size);
 257
 258                 vendor_device_list[vendor_device_list_size].vendor = vendor;
 259                 vendor_device_list[vendor_device_list_size].device = device;
 260                 vendor_device_list_size++;
 261
 262                 if (vendor_device_list_size >= MAX_DEVICE_VENDORS)
 263                 {
 264                     bug("Exceeded MAX_DEVICE_VENDORS\n");
 265                     break;
 266                 }
 267
 268                 FreeVec(tmp);
 269                 FreeVec(tmp2);
 270             }
 271             else if (ret[0] == 'Q' && ret[1] == 'U' && ret[2] == 'E' && ret[3] == 'R' && ret[4] == 'Y')
 272             {
 273                 bug("QUERY found!\n");
 274                 setForceQuery();
 275
 276                 if (ret[5] == 'D') // debug
 277                 {
 278                     setDumpAll();
 279                 }
 280             }
 281             else if (Strnicmp(ret, "speaker=0x", 10) == 0)
 282             {
 283                 int speaker = 0;
 284                 char *tmp = (char *) AllocVec(16, MEMF_CLEAR);
 285
 286                 CopyMem(line + 10, tmp, 2);
 287                 tmp[2] = '\0';
 288
 289                 // convert hex to decimal
 290                 speaker = hex_char_to_int(tmp[0]) * 16 + hex_char_to_int(tmp[1]);
 291
 292                 bug("Speaker in config = %x!\n", speaker);
 293
 294                 setForceSpeaker(speaker);
 295             }
 296
 297             FreeVec(line);
 298         }
 299
 300         Close(config_file);
 301     }
 302     else
 303     {
 304         bug("Couldn't open config file!\n");
 305     }
 306 }
 307
 308
 309 static int hex_char_to_int(char c)
 310 {
 311     if (c >= '0' && c <= '9')
 312     {
 313         return (c - '0');
 314     }
 315     else if (c >= 'A' && c <= 'F')
 316     {
 317         return 10 + (c - 'A');
 318     }
 319     else if (c >= 'a' && c <= 'f')
 320     {
 321         return 10 + (c - 'a');
 322     }
 323     else
 324     {
 325         bug("Error in hex_char_to_int: char was %c\n", c);
 326         return 0;
 327     }
 328 }