Subversion Repositories f9daq

Rev

Rev 23 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
23 f9daq 1
//-------------------------------------------------------------------------
2
// WINNT driver for PCICC32 (CAMAC) interface of ARW Elektronik, Germany --
3
// the main body of the driver
4
//
5
// (c) 2000-2002 ARW Elektronik
6
//
7
// this source code is published under GPL (Open Source). You can use, redistribute and 
8
// modify it unless this header   is not modified or deleted. No warranty is given that 
9
// this software will work like expected.
10
// This product is not authorized for use as critical component in life support systems
11
// wihout the express written approval of ARW Elektronik Germany.
12
//
13
// Please announce changes and hints to ARW Elektronik
14
//
15
// what                                            who          when
16
// started out of pcivme sources                   AR           25.03.2000
17
// added IRQ handling                              AR           24.02.2001
18
// Added AUTOREAD functionality                    AR           17.03.2001
19
// Added LCR_READ                                  AR           31.03.2001
20
// resource allocation registers idle entries too  AR           25.11.2001
21
// changed making procedure (only VCC > 6.0)       AR           30.05.2002
22
// totally rearanged resource alloc for WIN2000    AR           01.06.2002
23
// version 2.14 eleminates PLXBUG in WIN2000       AR           05.06.2002
24
// added KeSynchronizeExecution for interrupt sync AR           16.06.2002
25
//
26
 
27
//------------------------------------------------------------------------
28
// DEFINES
29
//
30
#ifndef DWORD
31
#define DWORD ULONG
32
#endif
33
 
34
#ifndef WORD
35
#define WORD USHORT
36
#endif
37
 
38
#define CTL_INDEX(x) ((x >> 2) & 0xFF)  // get user control code as index
39
#define RESOURCE_ENTRY_COUNT 6          // WIN2000 forces to claim all entries
40
 
41
#define DOS_DEVICE_NAME L"\\DosDevices\\PCICC32:"
42
 
43
//-------------------------------------------------------------------------
44
// INCLUDES
45
//
46
 
47
#include <ntddk.h>
48
#include <devioctl.h>
49
// #include <wdm.h>
50
 
51
#include <pcicc32_drv.h>
52
#include <pcicc32.h>
53
#include <pcicc32_v.h>
54
#include <pcicc32_i.h>
55
#include <pcicc32_io.h>
56
 
57
 
58
//------------------------------------------------------------------------
59
// TYPEDEFS
60
//
61
typedef struct
62
{
63
        FILE_OBJ  *file_obj;
64
        PCIADA    *pciada;
65
        PVOID     pOutputBuffer;
66
        PVOID     pInputBuffer;
67
        ULONG     Address;
68
        DWORD     Length;
69
} SYNC_CONTEXT;
70
 
71
//------------------------------------------------------------------------
72
// GLOBALS
73
//
74
 
75
//------------------------------------------------------------------------
76
// FUNCTIONS
77
//
78
 
79
//------------------------------------------------------------------------
80
// for debug only - print interrupt line
81
//
82
#if DBG
83
void PrintInterruptLine(int Bus, int Slot)
84
{
85
  PCI_COMMON_CONFIG pci_config;
86
 
87
  HalGetBusData( PCIConfiguration,                      // Bustype 
88
                                 Bus,                                   // PCI-Busnumber
89
                         Slot,                                          // Slotnumber
90
                                 (PVOID) &(pci_config),     // Pointer for the PCI-Information
91
                                 sizeof(PCI_COMMON_CONFIG));
92
 
93
  KdPrint(("Irql: %d\n", pci_config.u.type0.InterruptLine));
94
}
95
#endif
96
 
97
//------------------------------------------------------------------------
98
// get the cc32 number out of the filename
99
//
100
NTSTATUS InterpreteFileName(PCHAR name, int *nCC32)
101
{
102
        char *ptr = name;
103
    char *n   = "cc32_";
104
        int  h = -1;  // high part
105
        int  l = -1;  // low part
106
 
107
        if (*ptr == '\\') ptr++; // jump over leading ...
108
 
109
    while (*n)                           // compare the basename
110
          if (*n == tolower(*ptr))     
111
          {
112
                  n++;
113
                  ptr++;
114
          }
115
          else
116
                  return STATUS_NO_SUCH_FILE;
117
 
118
        h = *ptr - '0';                  // get the number
119
        ptr++;
120
        l = *ptr - '0';
121
 
122
        if (*ptr == 0)                   // still over the end ??
123
        {
124
                l = h;
125
                h = 0;
126
        }
127
        else
128
          ptr++;
129
 
130
        if ((h < 0) || (l < 0) || (*ptr != 0))  // anything wrong ??
131
                  return STATUS_NO_SUCH_FILE;
132
 
133
        *nCC32 = (h * 10) + l;  // calculate number
134
 
135
        if (*nCC32 >= PCICC32_MAX_CC32) // out of range ??
136
                  return STATUS_NO_SUCH_FILE;
137
 
138
        return STATUS_SUCCESS;
139
}
140
 
141
//------------------------------------------------------------------------
142
// the ultimate driver unload
143
VOID PCICC32Unload(PDRIVER_OBJECT driverObj)
144
{
145
        int              i;
146
        UNICODE_STRING symbol_name;
147
        DEVICE_EXT *ext = (DEVICE_EXT*)(driverObj->DeviceObject->DeviceExtension);
148
        int         nPCIADAs = ext->nPCIADAs;
149
        PCIADA      *pciada;
150
 
151
    KdPrint(("PCICC32Unload()\n"));
152
 
153
        switch (ext->nInitState)
154
        {
155
                case 8:
156
                case 7:
157
                case 6:
158
                        // stop interrupts and shut off
159
                        PCICC32DeInitPCIADAs(driverObj->DeviceObject);
160
                        PCICC32DisConnectInterrupt(driverObj->DeviceObject);
161
                case 5:
162
                        // KeInitializeDpc has no counterpart
163
                case 4:
164
                        for (i = 0; i < nPCIADAs; i++)
165
                        {
166
                                pciada = &ext->pciada[i];
167
                                if (pciada->pvVirtLcr != NULL)
168
                                        MmUnmapIoSpace(pciada->pvVirtLcr, LCR_SPACE);
169
                                if (pciada->pvVirtIfr != NULL)
170
                                        MmUnmapIoSpace(pciada->pvVirtIfr, IFR_SPACE);
171
                        }
172
                case 3:
173
                        // HalGetInterruptVector has no counterpart
174
                case 2:
175
                        // HalTranslateBusAddress has no counterpart
176
                case 1:
177
                        PCICC32FreeResources(driverObj->DeviceObject);
178
                default:
179
                case 0:
180
                        RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
181
 
182
                        // delete the symbolicLink in the registry 
183
                        IoDeleteSymbolicLink( &symbol_name);
184
 
185
                        // delete the deviceObject 
186
                        IoDeleteDevice(driverObj->DeviceObject);
187
        }
188
 
189
        KdPrint(("PCICC32Unload() OK.\n"));
190
}
191
 
192
 
193
//------------------------------------------------------------------------
194
// called at CreateFile()
195
NTSTATUS PCICC32Open(PDEVICE_OBJECT deviceObj, PIRP Irp)
196
{
197
        NTSTATUS result = STATUS_SUCCESS;
198
    ANSI_STRING name;
199
    int nCC32;
200
        int i;
201
        DEVICE_EXT      *pDevExt = (DEVICE_EXT *)(deviceObj->DeviceExtension);
202
        PCIADA      *pciada;
203
        FILE_OBJ        *file_obj;
204
 
205
        name.Buffer = NULL;
206
    name.MaximumLength = 80;
207
 
208
        result = RtlUnicodeStringToAnsiString(&name, &(Irp->Tail.Overlay.OriginalFileObject->FileName), TRUE);
209
        if (result != STATUS_SUCCESS) goto fin;
210
 
211
        KdPrint(("PCICC32Open(%s)\n", name.Buffer));
212
 
213
        result = InterpreteFileName(name.Buffer, &nCC32);
214
    if (result != STATUS_SUCCESS) goto fin;
215
 
216
    KdPrint(("PCICC32Open(%d)\n", nCC32));
217
        RtlFreeAnsiString(&name);
218
 
219
    file_obj = (FILE_OBJ *)ExAllocatePool(NonPagedPool, sizeof(FILE_OBJ));
220
        if (file_obj == (FILE_OBJ *)NULL)
221
        {
222
                result = STATUS_NO_MEMORY;
223
                goto fin;
224
        }
225
 
226
        file_obj->uwAssociatedCC32  = (USHORT) nCC32;
227
 
228
    Irp->Tail.Overlay.OriginalFileObject->FsContext = (PVOID)file_obj;
229
 
230
        result = PCICC32ScanCC32(deviceObj);
231
        if (result != STATUS_SUCCESS) goto fin;
232
 
233
        for (i = 0; i < pDevExt->nPCIADAs; i++)
234
        {
235
          pciada = &pDevExt->pciada[i];
236
 
237
          if (pciada->wModuleNumber == nCC32)
238
          {
239
                  pDevExt->cc32[nCC32] = pciada; // create association
240
                  pciada->dwLinkCount++;
241
 
242
                  enableCC32(pciada);
243
                  break;
244
          }
245
        }
246
 
247
        if (i >= pDevExt->nPCIADAs)
248
        {
249
                result = STATUS_NO_SUCH_FILE;
250
                goto fin;
251
        }
252
 
253
        fin:
254
        Irp->IoStatus.Status = result;
255
        Irp->IoStatus.Information = 0;
256
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
257
 
258
        return result;
259
}
260
 
261
//------------------------------------------------------------------------
262
// called at close()
263
NTSTATUS PCICC32Close(PDEVICE_OBJECT deviceObj, PIRP Irp)
264
{
265
        DEVICE_EXT      *pDevExt  = (DEVICE_EXT *)(deviceObj->DeviceExtension);
266
        FILE_OBJ    *file_obj = (FILE_OBJ *)NULL;
267
        PCIADA      *pciada;                   
268
 
269
        file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
270
 
271
    KdPrint(("PCICC32Close(%d)\n", file_obj->uwAssociatedCC32));
272
 
273
        if (file_obj != (FILE_OBJ *)NULL)
274
        {
275
                pciada = pDevExt->cc32[file_obj->uwAssociatedCC32];
276
                pciada->dwLinkCount--;
277
 
278
                // disable interrupts when closing
279
                if (pciada->pIrqControlFile == file_obj)
280
                {
281
                        pciada->pIrqControlFile = (FILE_OBJ *)NULL;
282
                        globalInterruptDisable(pciada);
283
                }
284
 
285
                // cancel any blocking Irp origin from this file
286
                if (file_obj->blockingIrp != (PIRP)NULL)
287
                        file_obj->blockingIrp = (PIRP)NULL;
288
 
289
                if (pciada->pBlockingIrp == &file_obj->blockingIrp)
290
                        pciada->pBlockingIrp = (PIRP *)NULL;
291
 
292
                if (!pciada->dwLinkCount)
293
                          disableCC32(pciada);
294
 
295
                ExFreePool(file_obj);
296
                Irp->Tail.Overlay.OriginalFileObject->FsContext = (FILE_OBJ *)NULL;
297
        }
298
 
299
        KdPrint(("PCICC32Close OK\n"));
300
 
301
    Irp->IoStatus.Status = STATUS_SUCCESS;
302
        Irp->IoStatus.Information = 0;
303
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
304
 
305
        return STATUS_SUCCESS;
306
}
307
 
308
//------------------------------------------------------------------------
309
// called at 
310
NTSTATUS PCICC32Shutdown(PDEVICE_OBJECT deviceObj, PIRP irp)
311
{
312
        UNREFERENCED_PARAMETER(irp);
313
        KdPrint(("PCICC32Shutdown()\n"));
314
 
315
        // deinit interfaces and interrupts
316
        PCICC32DeInitPCIADAs(deviceObj);
317
 
318
    KdPrint(("PCICC32Shutdown() OK\n"));
319
 
320
        return STATUS_SUCCESS;
321
}
322
 
323
//------------------------------------------------------------------------
324
// called at ioctl()
325
NTSTATUS PCICC32DeviceControl(PDEVICE_OBJECT deviceObj, PIRP Irp)
326
{
327
        PIO_STACK_LOCATION IrpStack;
328
        int   nIndex;
329
 
330
        IrpStack  = IoGetCurrentIrpStackLocation(Irp);
331
        nIndex    = CTL_INDEX(IrpStack->Parameters.DeviceIoControl.IoControlCode);
332
 
333
    KdPrint(("PCICC32DeviceControl(%d / 0x%08x)\n", nIndex, Irp->Tail.Overlay.OriginalFileObject));
334
 
335
        if (nIndex > CTL_INDEX(PCICC32_LAST_CTL_CODE))
336
        {
337
                KdPrint(("LastIndex(%d)\n", CTL_INDEX(PCICC32_LAST_CTL_CODE)));
338
                Irp->IoStatus.Status      = STATUS_UNSUCCESSFUL;
339
                Irp->IoStatus.Information = 0;
340
                IoCompleteRequest(Irp,IO_NO_INCREMENT);
341
 
342
        KdPrint(("PCICC32DeviceControl() FAIL.\n"));
343
 
344
                return STATUS_UNSUCCESSFUL;
345
        }
346
 
347
        return ioctl[nIndex](deviceObj, Irp, IrpStack);
348
}
349
 
350
 
351
//------------------------------------------------------------------------
352
// called at read()
353
static BOOLEAN PCICC32Read_kernel(PVOID pvContext)
354
{
355
        register SYNC_CONTEXT *context = (SYNC_CONTEXT *)pvContext;
356
        register ULONG i = 0;
357
        USHORT   wCntrl;
358
 
359
        wCntrl = READ_REGISTER_USHORT(context->pciada->pwCntrl);
360
        if (context->file_obj->wBlockTransfer & AUTOREAD)
361
        {
362
                wCntrl &= ~0x0004;  // enable autoread - set bit to 0
363
                WRITE_REGISTER_USHORT(context->pciada->pwCntrl, wCntrl);                               
364
        }
365
 
366
        // do the read ---
367
        if (context->file_obj->wBlockTransfer & UNTIL_NOT_Q)
368
        {
369
                // read first time to get Q information
370
                register ULONG tempBuffer = READ_REGISTER_ULONG((ULONG *)context->Address);
371
 
372
                if (context->file_obj->wAccessType == WORD_ACCESS)
373
                {
374
                        PUSHORT pwBuffer = (PUSHORT)context->pOutputBuffer;
375
                        PUSHORT pwBufEnd = (PUSHORT)((PUCHAR)context->pOutputBuffer + context->Length);
376
 
377
                        while ((tempBuffer & 0x80000000) && (pwBuffer < pwBufEnd))
378
                        {
379
                                *pwBuffer++ = (USHORT)tempBuffer;
380
                                tempBuffer = READ_REGISTER_ULONG((ULONG *)context->Address);  // read the same address multiple times as long to get Q
381
                                i++;
382
                        }
383
                }
384
                else
385
                {
386
                        // LONG_ACCESS
387
                        PULONG pdwBuffer = (PULONG)context->pOutputBuffer;
388
                        PULONG pdwBufEnd = (PULONG)((PUCHAR)context->pOutputBuffer + context->Length);
389
 
390
                        while ((tempBuffer & 0x80000000) && (pdwBuffer < pdwBufEnd))
391
                        {
392
                                *pdwBuffer++ = tempBuffer;
393
                                tempBuffer   = READ_REGISTER_ULONG((ULONG *)context->Address);  // read the same address multiple times as long to get Q
394
                                i++;
395
                        }
396
                }
397
 
398
                i *= context->file_obj->wAccessType;
399
 
400
                KdPrint(("UNTIL_NOT_Q, 0x%08x bytes read\n", i));
401
        }
402
        else // no UNTIL_NOT_Q
403
        {
404
                while (i < context->Length)
405
                {
406
                        context->file_obj->fRead((void *)((PUCHAR)context->pOutputBuffer + i), (void *)context->Address);  // read the same address multiple times
407
                        i += context->file_obj->wAccessType;
408
                }
409
        }
410
 
411
        // disable autoread unconditionally - set bit to 1
412
        wCntrl |= 0x0004;  
413
        WRITE_REGISTER_USHORT(context->pciada->pwCntrl, wCntrl);
414
 
415
    context->Length = i;       
416
 
417
        return TRUE;
418
}
419
 
420
NTSTATUS PCICC32Read(PDEVICE_OBJECT device_Obj, PIRP Irp)
421
{
422
        NTSTATUS        Status        = STATUS_SUCCESS;
423
        PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
424
        DEVICE_EXT      *pDevExt          = (DEVICE_EXT *)(device_Obj->DeviceExtension);
425
        SYNC_CONTEXT context;
426
 
427
        context.file_obj              = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
428
        context.pciada                = pDevExt->cc32[context.file_obj->uwAssociatedCC32];
429
        context.pOutputBuffer = ((void *)(MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority)));
430
        context.Address           = IrpStack->Parameters.Read.ByteOffset.LowPart;  
431
        context.Length            = 0;
432
 
433
        KdPrint(("PCICC32Read(%d)\n", context.file_obj->uwAssociatedCC32));
434
 
435
        if (context.Address > IFR_SPACE)
436
                Status = STATUS_ACCESS_VIOLATION;
437
        else
438
        {
439
                // do here in between what has to be done -----------------
440
                context.Length = IrpStack->Parameters.Read.Length;
441
                KdPrint(("Address = 0x%08x, Length = 0x%08x\n", context.Address, context.Length));
442
                context.Address = (ULONG)context.pciada->pvVirtIfr + context.Address;
443
 
444
                KeSynchronizeExecution(context.pciada->InterruptObject, PCICC32Read_kernel, &context);
445
                // do here in between what has to be done end -------------
446
        }
447
 
448
        Irp->IoStatus.Status      = Status;  
449
        Irp->IoStatus.Information = context.Length;  
450
        IoCompleteRequest(Irp,IO_NO_INCREMENT);  
451
 
452
    KdPrint(("PCICC32Read(), Status = 0x%08x\n", Status));
453
 
454
        return Status;
455
}
456
 
457
 
458
//------------------------------------------------------------------------
459
// called at write()
460
static BOOLEAN PCICC32Write_kernel(PVOID pvContext)
461
{
462
        register SYNC_CONTEXT *context = (SYNC_CONTEXT *)pvContext;
463
        register ULONG i = 0;
464
 
465
        // do the write ---
466
        while (i < context->Length)
467
        {
468
                context->file_obj->fWrite((void *)context->Address, (void *)((PUCHAR)context->pInputBuffer + i));  // write the same address multiple times
469
                i += context->file_obj->wAccessType;
470
        }
471
 
472
        context->Length = i;
473
 
474
        return TRUE;
475
}
476
 
477
NTSTATUS PCICC32Write(PDEVICE_OBJECT device_Obj, PIRP Irp)
478
{
479
        NTSTATUS        Status        = STATUS_SUCCESS;
480
        PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
481
        DEVICE_EXT      *pDevExt          = (DEVICE_EXT *)(device_Obj->DeviceExtension);
482
        SYNC_CONTEXT context;
483
 
484
        context.file_obj              = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
485
        context.pciada                = pDevExt->cc32[context.file_obj->uwAssociatedCC32];
486
        context.pInputBuffer = ((void *)(MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority)));
487
        context.Address           = IrpStack->Parameters.Read.ByteOffset.LowPart;  
488
        context.Length            = 0;
489
 
490
        KdPrint(("PCICC32Write(%d)\n", context.file_obj->uwAssociatedCC32));
491
 
492
        if (context.Address > IFR_SPACE)
493
                Status = STATUS_ACCESS_VIOLATION;
494
        else
495
        {
496
//              register ULONG i = 0;
497
 
498
                // do here in between what has to be done -----------------
499
                context.Length    = IrpStack->Parameters.Read.Length;
500
                KdPrint(("Address = 0x%08x, Length = 0x%08x\n", context.Address, context.Length));
501
                context.Address   = (ULONG)context.pciada->pvVirtIfr + context.Address;
502
 
503
                KeSynchronizeExecution(context.pciada->InterruptObject, PCICC32Write_kernel, &context);
504
                // do here in between what has to be done end -------------
505
        }
506
 
507
 
508
        Irp->IoStatus.Status      = Status;  
509
        Irp->IoStatus.Information = context.Length;  
510
        IoCompleteRequest(Irp,IO_NO_INCREMENT);  
511
 
512
    KdPrint(("PCICC32Write(), Status = 0x%08x\n", Status));
513
 
514
        return Status;
515
}
516
 
517
//------------------------------------------------------------------------
518
// search for pciada's
519
//
520
NTSTATUS SearchDevices(PDEVICE_OBJECT device_Obj)
521
{
522
  PCI_SLOT_NUMBER   SlotNumber;
523
  PCI_COMMON_CONFIG pci_config;
524
  PCIADA            *pciada;
525
  ULONG             length;
526
  int               *found;
527
  int               i,j,k;
528
 
529
  KdPrint(("SearchDevices()\n"));
530
 
531
  // prepare structures ----------------------------------------
532
  found  = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
533
  *found = 0;
534
  for (i = 0; i < PCICC32_MAX_PCIADA; i++)
535
  {
536
        pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
537
 
538
        pciada->Bus                = -1;
539
    pciada->Slot.u.AsULONG     = 0xFFFFFFFF;
540
  }
541
 
542
  // search for pciada's ---------------------------------------
543
  SlotNumber.u.bits.Reserved = 0;
544
 
545
  for (j = 0; j < PCI_MAX_BUSES; j++)
546
  {
547
    for (i = 0; i < PCI_MAX_DEVICES; i++)
548
        {
549
          SlotNumber.u.bits.DeviceNumber = i;
550
          for (k = 0; k < PCI_MAX_FUNCTION; k++)
551
          {
552
                SlotNumber.u.bits.FunctionNumber = k;
553
            length = HalGetBusData( PCIConfiguration,         // Bustype 
554
                                                            j,                                    // PCI-Busnumber
555
                                                            SlotNumber.u.AsULONG,     // Slotnumber
556
                                                            (PVOID) &(pci_config),    // Pointer for the PCI-Information
557
                                                            sizeof(PCI_COMMON_CONFIG) );
558
 
559
                if ((pci_config.VendorID    == PCICC32_VENDOR_ID) &&
560
                        (pci_config.DeviceID    == PCICC32_DEVICE_ID) &&
561
                        (pci_config.u.type0.SubSystemID == PCICC32_SUBSYS_ID) &&
562
                        (pci_config.u.type0.SubVendorID == PCICC32_SUBVEN_ID) &&
563
                        (pci_config.u.type0.BaseAddresses[3]))
564
                {
565
               pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[*found];
566
 
567
               memcpy(&pciada->PCIDevice, &pci_config, sizeof(pci_config));
568
                   pciada->Slot = SlotNumber;
569
                   pciada->Bus  = j;
570
 
571
                   KdPrint(("PCIADA found @ Bus/Slot %d/%d.\n", pciada->Bus, pciada->Slot.u.AsULONG));
572
 
573
                   (*found)++;
574
                   if (*found >= PCICC32_MAX_PCIADA) return STATUS_SUCCESS;
575
                }
576
          }
577
        }              
578
  }
579
 
580
  return STATUS_SUCCESS;
581
}
582
 
583
//---------------------------------------------------------------
584
// function to call for bug fix of PLX9050 build in bug
585
//
586
NTSTATUS PLX9050BugFix(PDEVICE_OBJECT device_Obj)
587
{
588
        DEVICE_EXT *DeviceExtension = (DEVICE_EXT*)device_Obj->DeviceExtension;
589
        int i;
590
        ULONG dwData;
591
        PCIADA *pciada;
592
 
593
        KdPrint(("PLX9050BugFix()\n"));
594
 
595
        for (i = 0; i < DeviceExtension->nPCIADAs; i++)
596
        {
597
                pciada = &DeviceExtension->pciada[i];
598
 
599
                if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[0]) & 0x80)
600
                {      
601
                        KdPrint(("Changing address 0:0x%p with 4:0x%p\n",
602
                                pciada->PCIDevice.u.type0.BaseAddresses[0],
603
                                pciada->PCIDevice.u.type0.BaseAddresses[4]));
604
 
605
                        pciada->PCIDevice.u.type0.BaseAddresses[0] =           // exchange
606
                                pciada->PCIDevice.u.type0.BaseAddresses[4];
607
                        pciada->PCIDevice.u.type0.BaseAddresses[4] = dwData;
608
 
609
                        if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
610
                                  pciada->Slot.u.AsULONG,
611
                                        (PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[0],
612
                                                0x10, 4) != 4)
613
                        return STATUS_UNSUCCESSFUL;
614
 
615
                        if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
616
                                  pciada->Slot.u.AsULONG,
617
                                        (PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[4],
618
                                                0x20, 4) != 4)
619
                        return STATUS_UNSUCCESSFUL;
620
                }
621
 
622
                if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[1]) & 0x80)
623
                {
624
                        KdPrint(("Changing address 1:0x%p with 5:0x%p\n",
625
                                pciada->PCIDevice.u.type0.BaseAddresses[1],
626
                                pciada->PCIDevice.u.type0.BaseAddresses[5]));
627
 
628
                  pciada->PCIDevice.u.type0.BaseAddresses[1] =           // exchange
629
                                pciada->PCIDevice.u.type0.BaseAddresses[5];
630
                  pciada->PCIDevice.u.type0.BaseAddresses[5] = dwData;
631
 
632
                  if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
633
                                  pciada->Slot.u.AsULONG,
634
                                        (PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[1],
635
                                                0x14, 4) != 4)
636
                        return STATUS_UNSUCCESSFUL;
637
 
638
                  if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
639
                                  pciada->Slot.u.AsULONG,
640
                                        (PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[5],
641
                                                0x24, 4) != 4)
642
                        return STATUS_UNSUCCESSFUL;
643
                }
644
        }
645
 
646
        return STATUS_SUCCESS;
647
}
648
 
649
 
650
//------------------------------------------------------------------------
651
//  reserve resources for PCIADAs 
652
//
653
NTSTATUS PCICC32ExtractResources(PCIADA *pciada, PCM_RESOURCE_LIST pList)
654
{
655
        PCM_RESOURCE_LIST pResourceList;
656
        PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
657
        PCM_PARTIAL_RESOURCE_LIST pPartialList;
658
        PCM_PARTIAL_RESOURCE_DESCRIPTOR pPartialDescriptor;
659
        int i;
660
        int bug = 0;
661
 
662
        KdPrint(("PCICC32ExtractResources()\n"));
663
 
664
        pResourceList   = pList;
665
        pFullDescriptor = pResourceList->List;
666
        pPartialList    = &pFullDescriptor->PartialResourceList;
667
 
668
        for (i=0; i<(int)pPartialList->Count; i++)
669
        {
670
                pPartialDescriptor = &pPartialList->PartialDescriptors[i];
671
                switch (pPartialDescriptor->Type)
672
                {
673
                        case CmResourceTypeInterrupt:
674
                                pciada->Irql     = (KIRQL)pPartialDescriptor->u.Interrupt.Level;
675
                                pciada->Vector   = pPartialDescriptor->u.Interrupt.Vector;
676
                                pciada->Affinity = pPartialDescriptor->u.Interrupt.Affinity;
677
 
678
                                KdPrint(("Irq    : Irql: %d, Vector: %d, Affinity: %d\n",
679
                                        pciada->Irql, pciada->Vector, pciada->Affinity));
680
                                break;
681
                        case CmResourceTypeDma:
682
                                KdPrint(("Dma    : \n"));
683
                                break;
684
                        case CmResourceTypePort:
685
 
686
                                KdPrint(("Port   : 0x%p\n", pPartialDescriptor->u.Port.Start));
687
                                break;
688
                        case CmResourceTypeMemory:
689
                                // special handling of PLXBUG here because of WIN2000
690
                                // WIN2000 doesn't recognize late address changes
691
                                if (!bug)
692
                                {
693
                                        if (i == 0)
694
                                        {
695
                                                pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
696
 
697
                                                if (pciada->pvPhysLcr.LowPart & 0x80)
698
                                                        bug = 1;
699
                                        }
700
                                }
701
                                else
702
                                {
703
                                        if (i == 3)
704
                                                pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
705
                                }
706
 
707
                                if (i == 2)
708
                                        pciada->pvPhysIfr = pPartialDescriptor->u.Memory.Start;
709
 
710
                                KdPrint(("Memory : 0x%p\n", (PUCHAR)pPartialDescriptor->u.Memory.Start.LowPart));
711
                                break;
712
                }
713
        }
714
 
715
        if (pciada->Irql == 0)
716
                return STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT;
717
 
718
        KdPrint(("PCICC32ExtractResources() OK.\n"));
719
 
720
        return STATUS_SUCCESS;
721
}
722
 
723
NTSTATUS PCICC32ReserveResources(PDEVICE_OBJECT device_Obj)
724
{
725
        PCM_RESOURCE_LIST pList = NULL;
726
        NTSTATUS result = STATUS_SUCCESS;
727
        int i;
728
        DEVICE_EXT *pDevExt = (DEVICE_EXT*)(device_Obj->DeviceExtension);
729
        int nPCIADAs = pDevExt->nPCIADAs;
730
        PCIADA *pciada;
731
    UNICODE_STRING DriverClassName;
732
 
733
        KdPrint(("PCICC32ReserveResources()\n"));
734
 
735
        // prepare resource claiming
736
        RtlInitUnicodeString(&DriverClassName, L"PCICC32");
737
 
738
        // cycle through all busses and slots assigned to PCIADAs
739
        for (i = 0; i < nPCIADAs; i++)
740
    {
741
                pciada = &pDevExt->pciada[i];
742
 
743
                result = HalAssignSlotResources(NULL, &DriverClassName, device_Obj->DriverObject, device_Obj,
744
                        PCIBus, pciada->Bus, pciada->Slot.u.AsULONG, &pList);
745
 
746
                if (result != STATUS_SUCCESS)
747
                        break;
748
 
749
                result = PCICC32ExtractResources(pciada, pList);
750
 
751
                if (result != STATUS_SUCCESS)
752
                        break;
753
        }
754
 
755
        // its my part to free allocated resources
756
        ExFreePool(pList);
757
 
758
        KdPrint(("PCICC32ReserveResources(0x%08x)\n", result));
759
 
760
        return result;
761
};
762
 
763
//------------------------------------------------------------------------
764
//  free resources from PCIADAs 
765
//
766
NTSTATUS PCICC32FreeResources(PDEVICE_OBJECT device_Obj)
767
{
768
        CM_RESOURCE_LIST ResList;
769
        BOOLEAN          bConflict;
770
    UNICODE_STRING   DriverClassName;
771
 
772
    KdPrint(("PCICC32FreeResources()\n"));
773
 
774
        RtlInitUnicodeString(&DriverClassName, L"PCICC32");
775
 
776
        ResList.Count = 0;
777
 
778
        IoReportResourceUsage(&DriverClassName, device_Obj->DriverObject,
779
                                         &ResList, sizeof(ResList), device_Obj,
780
                                                                         NULL, 0, FALSE, &bConflict);
781
        return STATUS_SUCCESS;
782
};
783
 
784
 
785
//------------------------------------------------------------------------
786
//  translate memory resources to neutral for PCIADAs 
787
//
788
NTSTATUS PCICC32TranslateBusAddresses(PDEVICE_OBJECT device_Obj)
789
{
790
        int              i;
791
        NTSTATUS         result = STATUS_SUCCESS;
792
        int nPCIADAs = ((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
793
        ULONG            memType0, memType2;
794
        PCIADA           *pciada;
795
 
796
    KdPrint(("TranslateBusAddresseses()\n"));
797
        for (i = 0; i < nPCIADAs; i++)
798
        {
799
      pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
800
 
801
          memType0 = memType2 = 0;
802
 
803
          if (!(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysLcr, &memType0,
804
                                                               &pciada->pvPhysLcr)) ||
805
              !(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysIfr, &memType2,
806
                                                               &pciada->pvPhysIfr)))
807
          {
808
                  result = STATUS_UNSUCCESSFUL;
809
                  break;
810
          }
811
 
812
          if ((memType0) || (memType2))
813
          {
814
                  result = STATUS_UNSUCCESSFUL;
815
                  break;
816
          }
817
        }
818
        return result;
819
}
820
 
821
//------------------------------------------------------------------------
822
//  map address spaces to virtual addresses
823
//
824
NTSTATUS PCICC32MapIOspaces(PDEVICE_OBJECT device_Obj)
825
{
826
        int              i;
827
        DEVICE_EXT       *pDevExt = (DEVICE_EXT*)device_Obj->DeviceExtension;
828
        int                              nPCIADAs = pDevExt->nPCIADAs;
829
        PCIADA           *pciada;
830
 
831
        KdPrint(("PCICC32MapIOspaces()\n"));
832
 
833
        for (i = 0; i < nPCIADAs; i++)
834
        {
835
       pciada = &pDevExt->pciada[i];
836
 
837
       if ((pciada->pvVirtLcr = MmMapIoSpace(pciada->pvPhysLcr, LCR_SPACE, FALSE)) == NULL)
838
          return STATUS_UNSUCCESSFUL;
839
       if ((pciada->pvVirtIfr = MmMapIoSpace(pciada->pvPhysIfr, IFR_SPACE, FALSE)) == NULL)
840
          return STATUS_UNSUCCESSFUL;
841
 
842
           KdPrint(("PCIADA %d: LCR 0x%08x IFR 0x%08x\n", i, pciada->pvVirtLcr, pciada->pvVirtIfr));
843
 
844
           pciada->pwIntCSR = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x4C);
845
           pciada->pwCntrl  = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x50);
846
        }
847
 
848
        return STATUS_SUCCESS;
849
}
850
 
851
 
852
//------------------------------------------------------------------------
853
//  initializes and registers a DPC routine for each pciada
854
//
855
NTSTATUS InitializeCustomDPCObjects(PDEVICE_OBJECT device_object)
856
{
857
        int              i;
858
        DEVICE_EXT       *pDevExt = (DEVICE_EXT*)(device_object->DeviceExtension);
859
        int              nPCIADAs = pDevExt->nPCIADAs;
860
        PCIADA           *pciada;
861
 
862
        KdPrint(("InitializeCustomDPCObject()\n"));
863
 
864
        for (i = 0; i < nPCIADAs; i++)
865
        {
866
                pciada = &pDevExt->pciada[i];
867
                KeInitializeDpc(&pciada->kDPCobj, fMyDefferedRoutine, (PVOID)device_object);
868
        }
869
 
870
        return STATUS_SUCCESS;
871
}
872
 
873
//------------------------------------------------------------------------
874
// init structures a.s.o.
875
//
876
VOID PCICC32SoftInit(PDEVICE_OBJECT device_Obj)
877
{
878
        int i;
879
        PCIADA *pciada;
880
 
881
        for (i = 0; i < PCICC32_MAX_PCIADA; i++)
882
        {
883
                pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
884
 
885
                pciada->pvPhysLcr.QuadPart = pciada->pvPhysIfr.QuadPart = 0;
886
                pciada->pvVirtLcr = pciada->pvVirtIfr = NULL;
887
 
888
                pciada->bConnected     = FALSE;   // connection still not verified
889
                pciada->wModuleNumber  = 0xFFFF;
890
                pciada->wFPGAVersion   = 0xFFFF;
891
                pciada->wModuleType    = 1;       // always CC32
892
 
893
                pciada->InterruptObject = NULL;
894
                pciada->Irql                    = 0;
895
                pciada->Vector          = 0;
896
                pciada->Affinity                = 0;
897
 
898
                pciada->dwLinkCount     = 0;
899
 
900
                pciada->dwIrqStatus     = 0;
901
                pciada->pBlockingIrp    = (PIRP *)NULL;
902
 
903
                pciada->pIrqControlFile = (FILE_OBJ *)NULL;
904
        }
905
 
906
        // no CC32 associated to any PCIADA
907
        for (i = 0; i < PCICC32_MAX_CC32; i++)
908
          ((DEVICE_EXT*)(device_Obj->DeviceExtension))->cc32[i] = NULL;
909
}
910
 
911
//------------------------------------------------------------------------
912
// the ultimate starting point of a driver
913
NTSTATUS DriverEntry(PDRIVER_OBJECT driverObj, PUNICODE_STRING regPath)
914
{
915
        int            i;
916
        PDEVICE_OBJECT device_object;                   // pointer to the device object
917
        UNICODE_STRING device_name;
918
        UNICODE_STRING symbol_name;
919
        NTSTATUS result = STATUS_SUCCESS;
920
        PCIADA         *pciada;                                 // pointer to a PCIADA
921
        int            nPCIADAs;                                // count of PCIADAs
922
        DEVICE_EXT     *DeviceExtension = NULL;
923
        UNREFERENCED_PARAMETER(regPath);
924
    KdPrint(("DriverEntry() ----%d.%d-------------------------\n", (DRIVER_VERSION >> 16) & 0xFFFF, DRIVER_VERSION & 0xFFFF));
925
 
926
        driverObj->DriverUnload = PCICC32Unload;
927
        driverObj->MajorFunction[IRP_MJ_CREATE]            = PCICC32Open;
928
        driverObj->MajorFunction[IRP_MJ_CLOSE]             = PCICC32Close;
929
        driverObj->MajorFunction[IRP_MJ_READ]              = PCICC32Read;
930
    driverObj->MajorFunction[IRP_MJ_WRITE]             = PCICC32Write;
931
        driverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]    = PCICC32DeviceControl;
932
    driverObj->MajorFunction[IRP_MJ_SHUTDOWN]          = PCICC32Shutdown;
933
 
934
        RtlInitUnicodeString(&device_name, L"\\Device\\CC32");
935
 
936
        /* DeviceObject durch IO-Manager erzeugen */
937
        result = IoCreateDevice( driverObj,           // DriverObject received by the DriverEntry Call
938
                                                         sizeof(DEVICE_EXT),  // required Memory for the DeviceExtension
939
                                                         &device_name,        // Name of the device in the device-Directory
940
                                                         FILE_DEVICE_UNKNOWN, // Device-ID              
941
                                                         0,                   // Device-Characteristics normal 0
942
                                                         FALSE,               // TRUE : one Thread can open the driver
943
                                                         &device_object);     // DeviceObject returned from the IO-Manager
944
 
945
        // defines how the data are handled between user / kernel Adress-Space  
946
        device_object->Flags |= DO_DIRECT_IO;
947
 
948
        // anounce driver as symbolic device ---------------------------------
949
        if (result == STATUS_SUCCESS)
950
        {
951
                /* now the symbolic Link is created. If there is no S.L. a program cannot connect to the driver */
952
                RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
953
                result = IoCreateSymbolicLink(&symbol_name,&device_name);
954
                if (result != STATUS_SUCCESS)
955
                {
956
                        IoDeleteDevice(device_object);
957
                        return result;
958
                }
959
        }
960
        else
961
                return result;
962
 
963
        DeviceExtension = (DEVICE_EXT*)device_object->DeviceExtension;
964
 
965
        DeviceExtension->actualIrp  = NULL;
966
        DeviceExtension->nInitState = 0;
967
 
968
        // init pciada structures ------------------------------------
969
        PCICC32SoftInit(device_object);
970
 
971
        // search for PCIADAs ----------------------------------------
972
        result   = SearchDevices(device_object);
973
        nPCIADAs = DeviceExtension->nPCIADAs;
974
 
975
        if ((result != STATUS_SUCCESS) || !(nPCIADAs))
976
        {
977
                PCICC32Unload(driverObj);    
978
                return STATUS_DEVICE_DOES_NOT_EXIST;
979
        }
980
 
981
        // request exclusive ownership of .. ---------------------------------
982
        if ((result = PCICC32ReserveResources(device_object)) != STATUS_SUCCESS)
983
        {
984
                PCICC32Unload(driverObj);    
985
                return result;
986
        }
987
        else
988
                DeviceExtension->nInitState++;
989
 
990
        // fix PLX9050 Bug -------------------------------------------
991
        if ((result = PLX9050BugFix(device_object)) != STATUS_SUCCESS)
992
        {
993
                PCICC32Unload(driverObj);    
994
                return result;
995
        }
996
 
997
        // translate BUS relative addresses ----------------------------------
998
        if ((result = PCICC32TranslateBusAddresses(device_object)) != STATUS_SUCCESS)
999
        {
1000
                PCICC32Unload(driverObj);    
1001
                return STATUS_DEVICE_DOES_NOT_EXIST;
1002
        }
1003
        else
1004
                DeviceExtension->nInitState++;
1005
 
1006
        // translate Interrupt Resources used --------------------------------
1007
        if ((result = PCICC32TranslateInterrupt(device_object)) != STATUS_SUCCESS)
1008
        {
1009
                PCICC32Unload(driverObj);    
1010
                return STATUS_DEVICE_DOES_NOT_EXIST;
1011
        }
1012
        else
1013
                DeviceExtension->nInitState++;
1014
 
1015
        // map address spaces to virtual addresses ---------------------------
1016
        if ((result = PCICC32MapIOspaces(device_object)) != STATUS_SUCCESS)
1017
        {
1018
                PCICC32Unload(driverObj);    
1019
                return STATUS_DEVICE_DOES_NOT_EXIST;
1020
        }
1021
        else
1022
                DeviceExtension->nInitState++;
1023
 
1024
        // initialze my custom DPC objects -----------------------------------
1025
        if ((result = InitializeCustomDPCObjects(device_object)) != STATUS_SUCCESS)
1026
        {
1027
                PCICC32Unload(driverObj);    
1028
                return result;
1029
        }
1030
        else
1031
                DeviceExtension->nInitState++;
1032
 
1033
        // disable all interrupts --------------------------------------------
1034
        for (i = 0; i < nPCIADAs; i++)
1035
        {
1036
                pciada = &DeviceExtension->pciada[i];
1037
 
1038
                globalInterruptDisable(pciada);
1039
        }
1040
 
1041
        // connect interrupts to service routines ----------------------------
1042
        if ((result = PCICC32ConnectInterrupt(device_object)) != STATUS_SUCCESS)
1043
        {
1044
                PCICC32Unload(driverObj);    
1045
                return STATUS_DEVICE_DOES_NOT_EXIST;
1046
        }
1047
        else
1048
                DeviceExtension->nInitState++;
1049
 
1050
        // scan all connected CC32 for info and later use -------------------
1051
        if ((result = PCICC32ScanCC32(device_object)) != STATUS_SUCCESS)
1052
        {
1053
                PCICC32Unload(driverObj);    
1054
                return STATUS_DEVICE_DOES_NOT_EXIST;
1055
        }
1056
 
1057
        device_object->Flags &= ~DO_DEVICE_INITIALIZING;
1058
 
1059
    KdPrint(("DriverEntry() OK.\n"));
1060
 
1061
        return result;
1062
}
1063