source: GPL/branches/uniaud32-2.1.x/drv32/rmhelp.cpp@ 546

Last change on this file since 546 was 546, checked in by David Azarewicz, 14 years ago

interrupt fixes
File size: 11.5 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//******************************************************************************
151BOOL RMRequestIRQ(ULONG ulIrq, BOOL fShared, PHRESOURCE phRes)
152{
153 RESOURCESTRUCT Resource;
154 HRESOURCE hres;
155 APIRET rc;
156
157 Resource.ResourceType = RS_TYPE_IRQ;
158 Resource.IRQResource.IRQLevel = (USHORT)ulIrq & 0xff;
159 Resource.IRQResource.PCIIrqPin = 0;
160 Resource.IRQResource.IRQFlags = ( fShared ) ? RS_IRQ_SHARED : RS_IRQ_EXCLUSIVE;
161
162 rc = RMAllocResource(DriverHandle, // Handle to driver.
163 FlatToSel((ULONG)&hres), // OUT: "allocated" resource node handle
164 FlatToSel((ULONG)&Resource)); // Resource to allocate.
165
166 if (rc == 0) {
167 if (ctResHandles < MAX_RESHANDLES ) arResHandles[ctResHandles++] = hres;
168 *phRes = hres;
169 }
170
171 dprintf(("RMAllocResource[%d] IRQ rc = %d\n", ctResHandles, rc));
172
173 return rc == 0;
174}
175
176//******************************************************************************
177//******************************************************************************
178BOOL RMDeallocateIRQ(HRESOURCE hRes)
179{
180 ULONG ulI;
181
182 RMDeallocResource(DriverHandle, hRes);
183
184 for (ulI=0; ulI<ctResHandles; ulI++) {
185 if (arResHandles[ulI] == hRes) {
186 arResHandles[ulI] = 0;
187 break;
188 }
189 }
190
191 return 0;
192}
193
194
195//******************************************************************************
196//******************************************************************************
197VOID RMDone(ULONG DevID)
198{
199 APIRET rc;
200 HDEVICE hDevice;
201 HADAPTER hAdapter;
202 ADAPTERSTRUCT AdapterStruct;
203 DEVICESTRUCT DeviceStruct;
204 char AdapterName[sizeof(RM_ADAPTER_NAME)];
205 char szDeviceName[128];
206 char szMixerName[64];
207 struct
208 {
209 ULONG NumResource;
210 HRESOURCE hResource[MAX_RESHANDLES];
211 } ahResource;
212
213 szDeviceName[0] = szMixerName[0] = '\0';
214
215 if( DevID && OSS32_QueryNames(OSS32_DEFAULT_DEVICE,
216 szDeviceName, sizeof(szDeviceName),
217 szMixerName, sizeof(szMixerName), FALSE) == OSSERR_SUCCESS )
218 {
219 switch(DevID) {
220 case PCIID_VIA_686A:
221 case PCIID_VIA_8233:
222 case PCIID_SI_7012:
223 case PCIID_INTEL_82801:
224 case PCIID_INTEL_82901:
225 case PCIID_INTEL_92801BA:
226 case PCIID_INTEL_440MX:
227 case PCIID_INTEL_ICH3:
228 case PCIID_INTEL_ICH4:
229 case PCIID_INTEL_ICH5:
230 case PCIID_INTEL_ICH6:
231 case PCIID_INTEL_ICH7:
232 case PCIID_NVIDIA_MCP_AUDIO:
233 case PCIID_NVIDIA_MCP2_AUDIO:
234 case PCIID_NVIDIA_MCP3_AUDIO:
235 case PCIID_NVIDIA_CK8S_AUDIO:
236 case PCIID_NVIDIA_CK8_AUDIO:
237 strcat(szDeviceName, " with ");
238 strcat(szDeviceName, szMixerName);
239 break;
240/*
241 case PCIID_CREATIVELABS_SBLIVE:
242 case PCIID_ALS4000:
243 case PCIID_CMEDIA_CM8338A:
244 case PCIID_CMEDIA_CM8338B:
245 case PCIID_CMEDIA_CM8738:
246 case PCIID_CMEDIA_CM8738B:
247 case PCIID_CIRRUS_4281:
248 case PCIID_CIRRUS_4280:
249 case PCIID_CIRRUS_4612:
250 case PCIID_CIRRUS_4615:
251 case PCIID_ESS_ALLEGRO_1:
252 case PCIID_ESS_ALLEGRO:
253 case PCIID_ESS_MAESTRO3:
254 case PCIID_ESS_MAESTRO3_1:
255 case PCIID_ESS_MAESTRO3_HW:
256 case PCIID_ESS_MAESTRO3_2:
257 case PCIID_ESS_CANYON3D_2LE:
258 case PCIID_ESS_CANYON3D_2:
259 case PCIID_ESS_ES1938:
260 case PCIID_AUREAL_VORTEX:
261 case PCIID_AUREAL_VORTEX2:
262 case PCIID_AUREAL_ADVANTAGE:
263 case PCIID_ENSONIQ_CT5880:
264 case PCIID_ENSONIQ_ES1371:
265 case PCIID_YAMAHA_YMF724:
266 case PCIID_YAMAHA_YMF724F:
267 case PCIID_YAMAHA_YMF740:
268 case PCIID_YAMAHA_YMF740C:
269 case PCIID_YAMAHA_YMF744:
270 case PCIID_YAMAHA_YMF754:
271 case PCIID_ESS_M2E:
272 case PCIID_ESS_M2:
273 case PCIID_ESS_M1:
274 case PCIID_ALI_5451:
275 case PCIID_TRIDENT_4DWAVE_DX:
276 case PCIID_TRIDENT_4DWAVE_NX:
277 case PCIID_SI_7018:
278 case PCIID_FM801:
279 case PCIID_ATIIXP_SB200:
280 case PCIID_ATIIXP_SB300:
281 case PCIID_ATIIXP_SB400:
282 case PCIID_AUDIGYLS:
283 case PCIID_AUDIGYLS1:
284 case PCIID_AUDIGYLS2:
285 break;
286*/
287 }
288
289
290 if( ctResHandles )
291 {
292 ahResource.NumResource = ctResHandles;
293 memcpy(ahResource.hResource,
294 arResHandles, ctResHandles * sizeof(arResHandles[0]));
295
296 //copy string to stack, because we need to give RM 16:16 pointers
297 //(which can only be (easily) generated from 32 bits stack addresses)
298 strcpy(AdapterName, RM_ADAPTER_NAME);
299
300 memset( (PVOID) &AdapterStruct, 0, sizeof(AdapterStruct) );
301 AdapterStruct.AdaptDescriptName = FlatToSel((ULONG)AdapterName); /* ### IHV */
302 AdapterStruct.AdaptFlags = AS_16MB_ADDRESS_LIMIT; // AdaptFlags /* ### IHV */
303 AdapterStruct.BaseType = AS_BASE_MMEDIA; // BaseType
304 AdapterStruct.SubType = AS_SUB_MM_AUDIO; // SubType
305 AdapterStruct.InterfaceType = AS_INTF_GENERIC; // InterfaceType
306 AdapterStruct.HostBusType = AS_HOSTBUS_PCI; // HostBusType /* ### IHV */
307 AdapterStruct.HostBusWidth = AS_BUSWIDTH_32BIT; // HostBusWidth /* ### IHV */
308 AdapterStruct.pAdjunctList = NULL; // pAdjunctList /* ### IHV */
309
310 //--- Register adapter. We'll record any error code, but won't fail
311 // the driver initialization and won't return resources.
312 //NOTE: hAdapter must be used as FlatToSel only works for stack variables
313 rc = RMCreateAdapter(DriverHandle, // Handle to driver
314 FlatToSel((ULONG)&hAdapter), // (OUT) Handle to adapter
315 FlatToSel((ULONG)&AdapterStruct), // Adapter structure
316 NULL, // Parent device (defaults OK)
317 NULL); // Allocated resources.
318
319 dprintf(("RMCreateAdapter rc = %d\n", rc));
320
321 if( rc == 0 )
322 {
323 if( !szDeviceName[0] ) strcpy(szDeviceName, "Unknown");
324
325 //NOTE: Assumes szDeviceName is a stack pointer!!
326 memset( (PVOID) &DeviceStruct, 0, sizeof(DeviceStruct) );
327 DeviceStruct.DevDescriptName = FlatToSel((ULONG)szDeviceName);
328 DeviceStruct.DevFlags = DS_FIXED_LOGICALNAME;
329 DeviceStruct.DevType = DS_TYPE_AUDIO;
330 DeviceStruct.pAdjunctList = NULL;
331
332 rc = RMCreateDevice(DriverHandle, // Handle to driver
333 FlatToSel((ULONG)&hDevice), // (OUT) Handle to device, unused.
334 FlatToSel((ULONG)&DeviceStruct), // Device structure
335 hAdapter, // Parent adapter
336 FlatToSel((ULONG)&ahResource)); // Allocated resources
337
338 dprintf(("RMCreateDevice rc = %d\n", rc));
339
340 if( rc == 0 )
341 {
342 // no resource handles to be freed
343 ctResHandles = 0; return;
344 }
345
346// !!! Not implemented in startup.asm
347// RMDestroyAdapter(DriverHandle, hAdapter);
348 }
349 }
350 else dprintf(("No resources allocated !!!\n"));
351 }
352
353
354 // free resource handles
355 while( ctResHandles )
356 RMDeallocResource(DriverHandle, arResHandles[--ctResHandles]);
357}
358
359
360
Note: See TracBrowser for help on using the repository browser.