source: GPL/trunk/drv32/rmhelp.cpp@ 536

Last change on this file since 536 was 518, checked in by David Azarewicz, 15 years ago

Some of my updates from the 2.1.x branch
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.