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

Last change on this file since 333 was 65, checked in by vladest, 20 years ago

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