pspan_diag.c

adlink master board 6760 pci driver for control powerspan slave pci driver

   // prepare datas of the buffer for dma transfer
   if(direction ==1 )// PCI to PB
   {
        printf("Enter the initial data in PCI Address:\n");
        fgets(line, sizeof(line), stdin);
        //sscanf (line, "%d",(unsigned char *)ulPcAddr);         
        memcpy((unsigned char *)ulPcAddr,line,size);
   }
   else // PB to PCI
   {
        printf("Please prepare the initial data in PB Address then press enter:\n");
        fgets(line, sizeof(line), stdin);
   }

   // Setup DMA transfer and launch the DMA 
   if(direction == 0)   // PB to PCI
   {
        if (PSPAN_directModeDMA(hPlx,
                            ulLocAddr,  /* src : local address ulLocAddr */
                            ulPcAddr,   /* dest : PCI address ulPcAddr */
                            PB,         /* src port = local bus PB*/
                            PCI1,       /* dest port = PCI bus PCI1 */
                            size,       /* byte count */
                           channel      /* DMA channel */
                          ) == ERROR )
        {
              printf("direction == 0 Error!\n"); 
              return;
        }   
   
    }
    else    // PCI to PB
    {
        if (PSPAN_directModeDMA(hPlx,
                                ulPcAddr,       /* src : local address ulLocAddr    */
                                ulLocAddr,      /* dest : PCI address ulPcAddr      */
                                PCI1,           /* src port = local bus PB          */
                                PB,             /* dest port = PCI bus PCI1         */
                                size,           /* byte count                       */
                                channel         /* DMA channel                      */
                               ) == ERROR  )
        {
              printf("direction == 1 Error!\n"); 
              return;
        } 
        
    }
   
}


/******************************************************************************
* NAME:  PSPAN_testLinkedListDMA
*
* DESCRIPTION: linked list (2 command packets) DMA test on channel 0
*
* INPUT PARAMETERS:
*
* RETURN VALUES: none
*
*******************************************************************************/

void PSPAN_testLinkedListDMA(PSPAN_HANDLE hPlx)
{
   unsigned short size;
   unsigned long i, ulPcAddr, ulLocAddr, ulBaseAddr;
   unsigned long cmdPaktphysAdr1, cmdPaktphysAdr2, cmdPaktphysAdr3;
   unsigned char *pucAlignAddr;
   unsigned long *pulPcPtr, *pulLocPtr;

   printf("Linked list test (2 command packets) : \n");    // DMA 
   printf("  First command packet :  PCI   -> local \n");
   printf("  Second command packet : local -> PCI \n");
   
   printf("  PCI Address(0x200000-0x200800) initial data is like 0,1,2...\n");
   printf("  Please prepare the initial data in PB Address(0x300800) and then press enter:\n");
   fgets(line, sizeof(line), stdin);
   
   size = 0x2000/2; // transfer bytes count 

   // get 4k aligned address 
   pucAlignAddr = (unsigned char *)((0x200000 + 0xFFF) & ~0x00000FFF);
   ulPcAddr = pucAlignAddr;
   
   // define the pointer to the local address 
   // the last 3 bits of SRC and DEST addr must be the same for powerspan DMA transfer 
   ulLocAddr = (0x300000 & 0xFFFFFFF8) | (ulPcAddr & 0x7);    

   // disable DMA interrupts : STOP_EN, HALT_EN, DONE_EN 
   //PSPAN_WriteReg(hPlx, T_DMA0_GCSR, PSPAN_ReadReg(hPlx, T_DMA0_GCSR) & 0xFFFFFF00 ); // debug use
   PSPAN_WriteReg(hPlx, T_DMA0_GCSR, (PSPAN_ReadReg(hPlx, T_DMA0_GCSR) & 0xFFFFFF01) | 1 ); // debug use
      
   // disable all interrupts in IER0 and IER1 registers 
   //PSPAN_WriteReg(hPlx,T_IER0, 0);
   //PSPAN_WriteReg(hPlx,T_IER1, 0);
   
   // Initialize local memory area with 0,1,2,3,.... 
   for(i = 0; i < size/4; i++)
   {
     // DramWrite32(Hdl, ulLocAddr + i*sizeof(unsigned long) , i);
   }

     // Initialize PCI memory area 
   for(i = 0; i < size/2; i++)
   {
      pucAlignAddr[i] = i;
   }
   
   // get 32bytes aligned address 
   cmdPaktphysAdr1 = 0x400000;
   cmdPaktphysAdr1 = (cmdPaktphysAdr1 + 0x1F) & ~0x0000001F;
   cmdPaktphysAdr2 = cmdPaktphysAdr1 + sizeof(struct PowerSpanCmdPktDef);
   cmdPaktphysAdr3 = cmdPaktphysAdr2 + sizeof(struct PowerSpanCmdPktDef);

   // create command packet 
   if (PSPAN_createCommandPacket( (struct PowerSpanCmdPktDef *)cmdPaktphysAdr1, 
                        ulPcAddr,   // src : local address 
                        ulLocAddr,  // dest : PCI address 
                        PCI1,       // src port = local bus 
                        PB,         // dest port = PCI bus 
                        size/2,     // byte count 
                        (struct PowerSpanCmdPktDef *)cmdPaktphysAdr2, // next command packet 
                        FALSE       // not last command packet 
                       ) == ERROR )
   {
        printf("PSPAN_createCommandPacket1() error\n");
        return;
   }
   

   if (PSPAN_createCommandPacket( (struct PowerSpanCmdPktDef *)cmdPaktphysAdr2, 
                        ulLocAddr + size/2, // src : PCI address 
                        ulPcAddr + size/2,  // dest : local address 
                        PB,                 // src port = PCI bus 
                        PCI1,               // dest port = local bus 
                        size/2,             // byte count 
                        (struct PowerSpanCmdPktDef *)cmdPaktphysAdr3, // next command packet 
                        TRUE                // last command packet 
                       ) == ERROR )
   {
        printf("PSPAN_createCommandPacket2() error\n");
        return;
   }
   

   // set up and launch DMA 
   if (PSPAN_linkedListDMA(hPlx, (struct PowerSpanCmdPktDef *)cmdPaktphysAdr1,
                         PCI1,
                         0
                       ) == ERROR )
   {
      printf("PSPAN_linkedListDMA() error\n");
      return;
   }

   
   // poll the end of DMA transfer 
   for( i = 0; (i < 4000000) && (PSPAN_isDMADone(hPlx, 0) == ERROR) ; i++)
   {
   }

   if (i == 4000000)
   {
      printf("Timeout error\n");
   }

   // check DMA status register
   if (PSPAN_checkDMAStatus(hPlx, 0) == ERROR)
   {
      printf("PSPAN_checkDMAStatus() error\n");
      return;
   }
   
}


////////////////////////////////////////////////////////////////////////////////////////

int pspan_test(int argc, char *argv[])
{
    int cmd;
    PSPAN_HANDLE hPlx = NULL;
    HANDLE hWD;
    
    int la;
    DWORD dwIntStatus;
    BYTE in;
    DWORD ll;
    
    printf ("Pspan II diagnostic utility.\n");
    printf ("Application accesses hardware using my own driver Pspan.o .\n");

    // make sure DriverBuilder is loaded
    
    if (!PCI_Get_WD_handle(&hWD)) return 0;
    WD_Close (hWD);
    

    hPlx = PSPAN_LocateAndOpenBoard(0x107e, 0x9060);	

    do
    {
        printf ("\n");
        printf ("Pspan II main menu\n");
        printf ("-------------------\n");
        printf ("1.  Scan PCI bus\n");
        printf ("2.  Locate/Choose Pspan board\n");
        if (hPlx)
        {
            printf ("3.  PCI configuration registers\n");
            printf ("4.  Pspan II local registers\n");
            printf ("5.  Access address spaces on the board\n");
            printf ("6.  Access local address ranges on the board\n");
            printf ("7.  Enable / Disable interrupts\n");
            printf ("8.  Access serial EEPROM on the board\n");
            printf ("9.  Get board parameter\n");
            printf ("10. Test DMA(Direct Mode: PB -to- PCI) \n");
            printf ("11. Test DMA(Direct Mode: PCI -to- PB) \n");
            printf ("12. Test DMA(LinkedList Mode) \n");
            
        }
        printf ("99. Exit\n");
        printf ("Enter option: ");
        
        cmd = 0;
        fgets(line, sizeof(line), stdin);
        sscanf (line, "%d",&cmd);
        switch (cmd)
        {
        case 1: // Scan PCI bus
            PCI_Print_all_cards_info();
            break;
            
        case 2: // Locate PSPAN board
            if (hPlx) PSPAN_Close(hPlx);
            hPlx = PSPAN_LocateAndOpenBoard(0, 0);
            if (!hPlx) printf ("Pspan II card open failed!\n");
            break;
            
        case 3: // PCI configuration registers
            if (hPlx) 
            {
                WD_PCI_SLOT pciSlot;
                PSPAN_GetPciSlot(hPlx, &pciSlot);
                PCI_EditConfigReg(pciSlot);
            }
            break;
            
        case 4: // PSPAN local registers
            if (hPlx) PSPAN_EditReg(hPlx); 
            break;
            
        case 5: // Access address spaces on the board
            if (hPlx) PSPAN_BoardAccess(hPlx, FALSE);
            break;
            
        case 6: // Access local address ranges on the board
            if (hPlx) PSPAN_BoardAccess(hPlx, TRUE);
            break;
            
        case 7: // Enable / Disable interrupts
            if (hPlx) PSPAN_EnableDisableInterrupts(hPlx);
            break;
            
        case 8: // Access serial EEPROM on the board
            if (hPlx) PSPAN_EEPROMAccess(hPlx);
            break;
            
        case 9:
            PSPAN_test();
            break;
        
        case 10:
            printf (" Test DMA (Direct Mode: PB -to- PCI) \n");
            PSPAN_SimpleDMA( hPlx, 0,0 );
            break;

        case 11:
            printf (" Test DMA (Direct Mode: PCI -to- PB) \n");
            PSPAN_SimpleDMA( hPlx, 0,1 );
            break;

        case 12:
            printf (" Test DMA (LinkedList Mode) \n");
            PSPAN_testLinkedListDMA( hPlx );
            break;
        
        default:
            break;
            
        }// switch clause end
        
    } 
    while (cmd!=99);

    if (hPlx) PSPAN_Close(hPlx);

    return 0;
}