source: GPL/branches/uniaud32-2.0/drv32/rmhelp.cpp@ 421

Last change on this file since 421 was 421, checked in by Paul Smedley, 16 years ago

Updates from Pasha to improve IRQ handling and resolve long delays at startup in APIC mode when using ACPI
File size: 11.7 KB
Line 
1/*
2 * Resource manager helper functions
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of
7 * the License, or (at your option) any later version.
8 *
9 */
10
11#define INCL_NOPMAPI
12#define INCL_DOSINFOSEG
13#include <os2.h>
14
15#include <devhelp.h>
16#include <devinfo.h>
17
18#include <rmbase.h> // Resource manager definitions.
19#include "rmcalls.h"
20#include <rmioctl.h>
21
22#include <version.h>
23#include <dbgos2.h>
24#include <unicard.h>
25#include <osspci.h>
26#include <ossidc32.h>
27#include "pciids.h"
28
29#include <string.h>
30
31
32#define MAX_RESHANDLES 16
33
34//******************************************************************************
35//******************************************************************************
36
37PFN RM_Help;
38PFN RM_Help0;
39PFN RM_Help3;
40ULONG RMFlags;
41
42static HDRIVER DriverHandle = (HDRIVER)-1;
43static ULONG ctResHandles = 0;
44static HRESOURCE arResHandles[MAX_RESHANDLES];
45
46
47//******************************************************************************
48//******************************************************************************
49VOID RMInit(VOID)
50{
51 APIRET rc;
52 HDRIVER hDriver;
53 DRIVERSTRUCT DriverStruct;
54 char DriverName[sizeof(RM_DRIVER_NAME)];
55 char VendorName[sizeof(RM_DRIVER_VENDORNAME)];
56 char DriverDesc[sizeof(RM_DRIVER_DESCRIPTION)];
57
58 if( DriverHandle == (HDRIVER)-1 )
59 {
60 memset( (PVOID) &DriverStruct, 0, sizeof(DriverStruct) );
61
62 //copy strings to stack, because we need to give RM 16:16 pointers
63 //(which can only be (easily) generated from 32 bits stack addresses)
64 strcpy(DriverName, RM_DRIVER_NAME);
65 strcpy(VendorName, RM_DRIVER_VENDORNAME);
66 strcpy(DriverDesc, RM_DRIVER_DESCRIPTION);
67
68 DriverStruct.DrvrName = FlatToSel((ULONG)DriverName); /* ### IHV */
69 DriverStruct.DrvrDescript = FlatToSel((ULONG)DriverDesc); /* ### IHV */
70 DriverStruct.VendorName = FlatToSel((ULONG)VendorName); /* ### IHV */
71 DriverStruct.MajorVer = CMVERSION_MAJOR; //rmbase.h /* ### IHV */
72 DriverStruct.MinorVer = CMVERSION_MINOR; //rmbase.h /* ### IHV */
73 DriverStruct.Date.Year = RM_DRIVER_BUILDYEAR; /* ### IHV */
74 DriverStruct.Date.Month = RM_DRIVER_BUILDMONTH; /* ### IHV */
75 DriverStruct.Date.Day = RM_DRIVER_BUILDDAY; /* ### IHV */
76 DriverStruct.DrvrType = DRT_AUDIO;
77 DriverStruct.DrvrSubType = 0;
78 DriverStruct.DrvrCallback = NULL;
79
80 rc = RMCreateDriver( FlatToSel((ULONG)&DriverStruct), FlatToSel((ULONG)&hDriver) );
81
82 dprintf(("RMCreateDriver rc = %d\n", rc));
83
84 if( rc == RMRC_SUCCESS ) DriverHandle = hDriver;
85 }
86
87 while( ctResHandles )
88 RMDeallocResource(DriverHandle, arResHandles[--ctResHandles]);
89}
90
91
92//******************************************************************************
93//******************************************************************************
94BOOL RMRequestIO(ULONG ulIOBase, ULONG ulIOLength)
95{
96 RESOURCESTRUCT Resource;
97 HRESOURCE hres;
98 APIRET rc;
99
100 Resource.ResourceType = RS_TYPE_IO;
101 Resource.IOResource.BaseIOPort = (USHORT)ulIOBase;
102 Resource.IOResource.NumIOPorts = (USHORT)ulIOLength;
103 Resource.IOResource.IOFlags = RS_IO_EXCLUSIVE;
104 Resource.IOResource.IOAddressLines = ( ulIOBase > 0x3ff ) ? 16 : 10;
105
106 rc = RMAllocResource(DriverHandle, // Handle to driver.
107 FlatToSel((ULONG)&hres), // OUT: "allocated" resource node handle
108 FlatToSel((ULONG)&Resource)); // Resource to allocate.
109
110 if( rc == 0 && ctResHandles < MAX_RESHANDLES )
111 {
112 arResHandles[ctResHandles++] = hres; return TRUE;
113 }
114
115 dprintf(("RMAllocResource[%d] IO rc = %d\n", ctResHandles, rc));
116
117 return FALSE;
118}
119
120
121//******************************************************************************
122//******************************************************************************
123BOOL RMRequestMem(ULONG ulMemBase, ULONG ulMemLength)
124{
125 RESOURCESTRUCT Resource;
126 HRESOURCE hres;
127 APIRET rc;
128
129 Resource.ResourceType = RS_TYPE_MEM;
130 Resource.MEMResource.MemBase = ulMemBase;
131 Resource.MEMResource.MemSize = ulMemLength;
132 Resource.MEMResource.MemFlags = RS_MEM_EXCLUSIVE;
133
134 rc = RMAllocResource(DriverHandle, // Handle to driver.
135 FlatToSel((ULONG)&hres), // OUT: "allocated" resource node handle
136 FlatToSel((ULONG)&Resource)); // Resource to allocate.
137
138 if( rc == 0 && ctResHandles < MAX_RESHANDLES )
139 {
140 arResHandles[ctResHandles++] = hres; return TRUE;
141 }
142
143 dprintf(("RMAllocResource[%d] MEM rc = %d\n", ctResHandles, rc));
144
145 return rc == 0;
146}
147
148
149//******************************************************************************
150//******************************************************************************
151//PS+++ see to irq.cpp
152#ifdef ACPI
153#ifdef __cplusplus
154extern "C" {
155#endif
156struct SaveIRQForSlot
157{
158 ULONG ulSlotNo;
159 BYTE LowIRQ;
160 BYTE HighIRQ;
161 BYTE Pin;
162};
163extern struct SaveIRQForSlot sISRHigh[];
164extern int SaveIRQCounter;
165#ifdef __cplusplus
166}
167#endif
168#endif
169BOOL RMRequestIRQ(ULONG ulIrq, BOOL fShared)
170{
171 RESOURCESTRUCT Resource;
172 HRESOURCE hres;
173 APIRET rc;
174
175 Resource.ResourceType = RS_TYPE_IRQ;
176#ifdef ACPI //PS+++
177 Resource.IRQResource.PCIIrqPin = (USHORT)(sISRHigh[SaveIRQCounter].Pin & 0xf);
178 if (sISRHigh[SaveIRQCounter].HighIRQ)
179 Resource.IRQResource.IRQLevel = (USHORT)sISRHigh[SaveIRQCounter].HighIRQ & 0xff;
180 else
181 Resource.IRQResource.IRQLevel = (USHORT)ulIrq & 0xff;
182#else
183 Resource.IRQResource.IRQLevel = (USHORT)ulIrq & 0xff;
184 Resource.IRQResource.PCIIrqPin = 0;
185#endif
186 Resource.IRQResource.IRQFlags = ( fShared ) ? RS_IRQ_SHARED : RS_IRQ_EXCLUSIVE;
187
188 rc = RMAllocResource(DriverHandle, // Handle to driver.
189 FlatToSel((ULONG)&hres), // OUT: "allocated" resource node handle
190 FlatToSel((ULONG)&Resource)); // Resource to allocate.
191
192 if( rc == 0 && ctResHandles < MAX_RESHANDLES )
193 {
194 arResHandles[ctResHandles++] = hres; return TRUE;
195 }
196
197 dprintf(("RMAllocResource[%d] IRQ rc = %d\n", ctResHandles, rc));
198
199 return rc == 0;
200}
201
202
203//******************************************************************************
204//******************************************************************************
205VOID RMDone(ULONG DevID)
206{
207 APIRET rc;
208 HDEVICE hDevice;
209 HADAPTER hAdapter;
210 ADAPTERSTRUCT AdapterStruct;
211 DEVICESTRUCT DeviceStruct;
212 char AdapterName[sizeof(RM_ADAPTER_NAME)];
213 char szDeviceName[128];
214 char szMixerName[64];
215 struct
216 {
217 ULONG NumResource;
218 HRESOURCE hResource[MAX_RESHANDLES];
219 } ahResource;
220
221 szDeviceName[0] = szMixerName[0] = '\0';
222
223 if( DevID && OSS32_QueryNames(OSS32_DEFAULT_DEVICE,
224 szDeviceName, sizeof(szDeviceName),
225 szMixerName, sizeof(szMixerName), FALSE) == OSSERR_SUCCESS )
226 {
227 switch(DevID) {
228 case PCIID_VIA_686A:
229 case PCIID_VIA_8233:
230 case PCIID_SI_7012:
231 case PCIID_INTEL_82801:
232 case PCIID_INTEL_82901:
233 case PCIID_INTEL_92801BA:
234 case PCIID_INTEL_440MX:
235 case PCIID_INTEL_ICH3:
236 case PCIID_INTEL_ICH4:
237 case PCIID_INTEL_ICH5:
238 case PCIID_INTEL_ICH6:
239 case PCIID_INTEL_ICH7:
240 case PCIID_NVIDIA_MCP_AUDIO:
241 case PCIID_NVIDIA_MCP2_AUDIO:
242 case PCIID_NVIDIA_MCP3_AUDIO:
243 case PCIID_NVIDIA_CK8S_AUDIO:
244 case PCIID_NVIDIA_CK8_AUDIO:
245 strcat(szDeviceName, " with ");
246 strcat(szDeviceName, szMixerName);
247 break;
248/*
249 case PCIID_CREATIVELABS_SBLIVE:
250 case PCIID_ALS4000:
251 case PCIID_CMEDIA_CM8338A:
252 case PCIID_CMEDIA_CM8338B:
253 case PCIID_CMEDIA_CM8738:
254 case PCIID_CMEDIA_CM8738B:
255 case PCIID_CIRRUS_4281:
256 case PCIID_CIRRUS_4280:
257 case PCIID_CIRRUS_4612:
258 case PCIID_CIRRUS_4615:
259 case PCIID_ESS_ALLEGRO_1:
260 case PCIID_ESS_ALLEGRO:
261 case PCIID_ESS_MAESTRO3:
262 case PCIID_ESS_MAESTRO3_1:
263 case PCIID_ESS_MAESTRO3_HW:
264 case PCIID_ESS_MAESTRO3_2:
265 case PCIID_ESS_CANYON3D_2LE:
266 case PCIID_ESS_CANYON3D_2:
267 case PCIID_ESS_ES1938:
268 case PCIID_AUREAL_VORTEX:
269 case PCIID_AUREAL_VORTEX2:
270 case PCIID_AUREAL_ADVANTAGE:
271 case PCIID_ENSONIQ_CT5880:
272 case PCIID_ENSONIQ_ES1371:
273 case PCIID_YAMAHA_YMF724:
274 case PCIID_YAMAHA_YMF724F:
275 case PCIID_YAMAHA_YMF740:
276 case PCIID_YAMAHA_YMF740C:
277 case PCIID_YAMAHA_YMF744:
278 case PCIID_YAMAHA_YMF754:
279 case PCIID_ESS_M2E:
280 case PCIID_ESS_M2:
281 case PCIID_ESS_M1:
282 case PCIID_ALI_5451:
283 case PCIID_TRIDENT_4DWAVE_DX:
284 case PCIID_TRIDENT_4DWAVE_NX:
285 case PCIID_SI_7018:
286 case PCIID_FM801:
287 case PCIID_ATIIXP_SB200:
288 case PCIID_ATIIXP_SB300:
289 case PCIID_ATIIXP_SB400:
290 case PCIID_AUDIGYLS:
291 case PCIID_AUDIGYLS1:
292 case PCIID_AUDIGYLS2:
293 break;
294*/
295 }
296
297
298 if( ctResHandles )
299 {
300 ahResource.NumResource = ctResHandles;
301 memcpy(ahResource.hResource,
302 arResHandles, ctResHandles * sizeof(arResHandles[0]));
303
304 //copy string to stack, because we need to give RM 16:16 pointers
305 //(which can only be (easily) generated from 32 bits stack addresses)
306 strcpy(AdapterName, RM_ADAPTER_NAME);
307
308 memset( (PVOID) &AdapterStruct, 0, sizeof(AdapterStruct) );
309 AdapterStruct.AdaptDescriptName = FlatToSel((ULONG)AdapterName); /* ### IHV */
310 AdapterStruct.AdaptFlags = AS_16MB_ADDRESS_LIMIT; // AdaptFlags /* ### IHV */
311 AdapterStruct.BaseType = AS_BASE_MMEDIA; // BaseType
312 AdapterStruct.SubType = AS_SUB_MM_AUDIO; // SubType
313 AdapterStruct.InterfaceType = AS_INTF_GENERIC; // InterfaceType
314 AdapterStruct.HostBusType = AS_HOSTBUS_PCI; // HostBusType /* ### IHV */
315 AdapterStruct.HostBusWidth = AS_BUSWIDTH_32BIT; // HostBusWidth /* ### IHV */
316 AdapterStruct.pAdjunctList = NULL; // pAdjunctList /* ### IHV */
317
318 //--- Register adapter. We'll record any error code, but won't fail
319 // the driver initialization and won't return resources.
320 //NOTE: hAdapter must be used as FlatToSel only works for stack variables
321 rc = RMCreateAdapter(DriverHandle, // Handle to driver
322 FlatToSel((ULONG)&hAdapter), // (OUT) Handle to adapter
323 FlatToSel((ULONG)&AdapterStruct), // Adapter structure
324 NULL, // Parent device (defaults OK)
325 NULL); // Allocated resources.
326
327 dprintf(("RMCreateAdapter rc = %d\n", rc));
328
329 if( rc == 0 )
330 {
331 if( !szDeviceName[0] ) strcpy(szDeviceName, "Unknown");
332
333 //NOTE: Assumes szDeviceName is a stack pointer!!
334 memset( (PVOID) &DeviceStruct, 0, sizeof(DeviceStruct) );
335 DeviceStruct.DevDescriptName = FlatToSel((ULONG)szDeviceName);
336 DeviceStruct.DevFlags = DS_FIXED_LOGICALNAME;
337 DeviceStruct.DevType = DS_TYPE_AUDIO;
338 DeviceStruct.pAdjunctList = NULL;
339
340 rc = RMCreateDevice(DriverHandle, // Handle to driver
341 FlatToSel((ULONG)&hDevice), // (OUT) Handle to device, unused.
342 FlatToSel((ULONG)&DeviceStruct), // Device structure
343 hAdapter, // Parent adapter
344 FlatToSel((ULONG)&ahResource)); // Allocated resources
345
346 dprintf(("RMCreateDevice rc = %d\n", rc));
347
348 if( rc == 0 )
349 {
350 // no resource handles to be freed
351 ctResHandles = 0; return;
352 }
353
354// !!! Not implemented in startup.asm
355// RMDestroyAdapter(DriverHandle, hAdapter);
356 }
357 }
358 else dprintf(("No resources allocated !!!\n"));
359 }
360
361
362 // free resource handles
363 while( ctResHandles )
364 RMDeallocResource(DriverHandle, arResHandles[--ctResHandles]);
365}
366
367
368
Note: See TracBrowser for help on using the repository browser.