int OpenLan(/* out */ ADI_DEV_DEVICE_HANDLE *pRes) // return bool { ADI_DEV_DEVICE_HANDLE lan_handle; unsigned int result; /* Initialize interrupt manager and device manager */ // adi_ssl_Init(); // ?? -- already done in VDK startup code /* Initialize the kernel */ ker_init((void*)0); /* set thread type for the stack threads */ ker_set_auxdata((void*)kADI_TOOLS_IOEThreadType); /* open lan-device */ result = adi_dev_Open( adi_dev_ManagerHandle, &ADI_ETHER_BF537_Entrypoint, 0, NULL, &lan_handle, ADI_DEV_DIRECTION_BIDIRECTIONAL, NULL, NULL, (ADI_DCB_CALLBACK_FN)stack_callback_handler); *pRes = lan_handle; return (result == ADI_DEV_RESULT_SUCCESS); }
int ReadMACAddress(char * cMacAddress) { u32 Result = ADI_DEV_RESULT_SUCCESS; u32 access_mode = ADI_OTP_ACCESS_READ; u64 macaddress; u16 i=0; char *ptr=cMacAddress; char MACaddr[6] = { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd }; // open the OTP driver Result = adi_dev_Open( adi_dev_ManagerHandle, // DevMgr handle &ADIOTPEntryPoint, // pdd entry point 0, // device instance NULL, // client handle callback identifier &DevHandleOTP, // DevMgr handle for this device ADI_DEV_DIRECTION_BIDIRECTIONAL,// data direction for this device NULL, // handle to DmaMgr for this device NULL, // handle to deferred callback service OTP_Callback); // client's callback function if (Result != ADI_DEV_RESULT_SUCCESS) return 0; access_mode = ADI_OTP_ACCESS_READWRITE; Result = adi_dev_Control(DevHandleOTP, ADI_OTP_CMD_SET_ACCESS_MODE, &access_mode ); if (Result != ADI_DEV_RESULT_SUCCESS) { adi_dev_Close( DevHandleOTP ); return 0; } // Set Dataflow method Result = adi_dev_Control(DevHandleOTP, ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void *)ADI_DEV_MODE_CHAINED ); if(Result != ADI_DEV_RESULT_SUCCESS) { adi_dev_Close( DevHandleOTP ); return 0; } Result = otp_read_page(OTP_MAC_ADDRESS_PAGE, ADI_OTP_LOWER_HALF, (u64*)&MACaddr); if( Result != ADI_DEV_RESULT_SUCCESS ) return 0; // The MAC address is in reverse order // do byte swape for(i=0; i<6; i++) { *ptr++ = MACaddr[5-i]; } adi_dev_Close( DevHandleOTP ); return 1; }
AdiDeviceResult AdiDevice::Open() { ESS_ASSERT(!IsOpened()); AdiDeviceResult result = adi_dev_Open(m_deviceManager.Handle(), m_settings.m_pEntryPoint, m_deviceNumber, m_settings.m_clientHandle, &m_deviceHandle, m_settings.m_direction, m_settings.m_DMAHandle, m_settings.m_DCBHandle, m_settings.m_clientCallback); if (result.isSuccess()) m_isOpen = true; return result; }
void UARTinit( u32 baudrate ) { ADI_DCB_HANDLE DCBManagerHandle = 0; // handle to the callback service u32 cclk, sclk, vco; // frequencies (note these are in MHz) u32 i; //loop variable ADI_DEV_CMD_VALUE_PAIR ConfigurationTable [] = { // configuration table for the UART driver { ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void *)ADI_DEV_MODE_CHAINED }, { ADI_UART_CMD_SET_DATA_BITS, (void *)8 }, { ADI_UART_CMD_ENABLE_PARITY, (void *)FALSE }, { ADI_UART_CMD_SET_STOP_BITS, (void *)1 }, { ADI_UART_CMD_SET_BAUD_RATE, (void *)baudrate }, { ADI_UART_CMD_SET_LINE_STATUS_EVENTS, (void *)TRUE }, { ADI_DEV_CMD_END, NULL }, }; InputBufferhead = 0; InputBuffertail = 0; // create two buffers that will be initially be placed on the inbound queue // only the inbound buffer will have a callback InboundBuffer.Data = &InboundData; InboundBuffer.ElementCount = 1; InboundBuffer.ElementWidth = 1; InboundBuffer.CallbackParameter = (void*)&InboundBuffer; InboundBuffer.ProcessedFlag = FALSE; InboundBuffer.pNext = NULL; sending_done = 1; OutboundBuffer.Data = OutboundData; OutboundBuffer.ElementCount = 1; OutboundBuffer.ElementWidth = 1; OutboundBuffer.CallbackParameter = (void*)&OutboundBuffer; OutboundBuffer.ProcessedFlag = TRUE; OutboundBuffer.pNext = NULL; // open the UART driver for bidirectional data flow ezErrorCheck(adi_dev_Open(DeviceManagerHandle, &ADIUARTEntryPoint, 0, NULL, &DriverHandle, ADI_DEV_DIRECTION_BIDIRECTIONAL, NULL, DCBManagerHandle, Callback)); // configure the UART driver with the values from the configuration table ezErrorCheck(adi_dev_Control(DriverHandle, ADI_DEV_CMD_TABLE, ConfigurationTable)); // give the device the inbound buffer ezErrorCheck(adi_dev_Read(DriverHandle, ADI_DEV_1D, (ADI_DEV_BUFFER *)&InboundBuffer)); // enable data flow ezErrorCheck(adi_dev_Control(DriverHandle, ADI_DEV_CMD_SET_DATAFLOW, (void *)TRUE)); }
/********************************************************************* * * Function: SPORT_Open * * Description: Opens the SPORT device for ADAV801 audio dataflow * *********************************************************************/ static u32 SPORT_Open( ADI_DEV_PDD_HANDLE PDDHandle // Physical Device Driver Handle ) { // Pointer to ADAV801 device driver instance ADI_ADAV801 *pADAV801 = (ADI_ADAV801 *)PDDHandle; // default return code u32 Result = ADI_DEV_RESULT_SUCCESS; // Open the SPORT driver Result = adi_dev_Open( pADAV801->ManagerHandle, // device manager handle &ADISPORTEntryPoint, // SPORT Entry point pADAV801->sportDeviceNumber, // SPORT device number pADAV801, // client handle - passed to internal callback function &pADAV801->sportHandle, // pointer to DM handle (for SPORT driver) location pADAV801->sportDirection, // SPORT data direcion pADAV801->DMAHandle, // handle to the DMA manager pADAV801->DCBHandle, // handle to the callback manager sportCallbackFunction // internal callback function ); // return with appropriate code if SPORT driver fails to open #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // SPORT Configuration (by default) // Active Low, External Frame sync, MSB first, External CLK // Stereo frame sync enable, Secondary side enabled, 24-bit data ADI_DEV_CMD_VALUE_PAIR SPORT_Config[] = { { ADI_SPORT_CMD_SET_TCR1, (void *)(TFSR | LTFS | TCKFE) }, { ADI_SPORT_CMD_SET_TCR2, (void *)(pADAV801->sport_txlen| TXSE| TSFSE ) }, { ADI_SPORT_CMD_SET_RCR1, (void *)(RFSR | LRFS | RCKFE) }, { ADI_SPORT_CMD_SET_RCR2, (void *)(pADAV801->sport_rxlen| RXSE | RSFSE) }, { ADI_DEV_CMD_END, (void *)NULL }, }; // Configure SPORT device Result = adi_dev_Control( pADAV801->sportHandle, ADI_DEV_CMD_TABLE, (void*)SPORT_Config ); return (Result); }
static u32 adi_pdd_Open( ADI_DEV_MANAGER_HANDLE ManagerHandle, // device manager handle u32 DeviceNumber, // device number ADI_DEV_DEVICE_HANDLE DMHandle, // device handle ADI_DEV_PDD_HANDLE *pPDDHandle, // pointer to PDD handle location ADI_DEV_DIRECTION Direction, // data direction void *pEnterCriticalArg, // enter critical region parameter ADI_DMA_MANAGER_HANDLE DMAHandle, // handle to the DMA manager ADI_DCB_HANDLE DCBHandle, // callback handle ADI_DCB_CALLBACK_FN DMCallback // client callback function ) { // default return code u32 Result = ADI_DEV_RESULT_SUCCESS; ADI_AD7477A *pAD7477A; // pointer to the AD7477A device we're working on void *pExitCriticalArg; // exit critical region parameter // Check for a valid device number and that we're only doing input #ifdef ADI_DEV_DEBUG if (DeviceNumber >= ADI_AD7477A_NUM_DEVICES) return (ADI_DEV_RESULT_BAD_DEVICE_NUMBER); if (Direction != ADI_DEV_DIRECTION_INBOUND) return (ADI_DEV_RESULT_DIRECTION_NOT_SUPPORTED); #endif // assign the pointer to the device instance pAD7477A = &Device[DeviceNumber]; // and store the Device Manager handle pAD7477A->DMHandle = DMHandle; // and callback function pAD7477A->DMCallback = DMCallback; // Assign the quiet period factor, to enable us to more accurately // modify the requested sample rate to what is achievable. This value is the // (1+e)*1000, where e = (tsample - tconvert)/tconvert. // (see description under case ADI_AD7477A_CMD_SET_QUIET_PERIOD_FACTOR in the // adi_pdd_Control function for more details). // The default value is based on experimental evidence using two ADSP-BF537 // EZ-Kits. pAD7477A->tquiet_factor = 1062; // Check that this device instance is not already in use. If not, // assign flag to indicate that it is now. // the device starts in powerup mode //pAD7477A->CurMode = ADI_AD7477A_MODE_NORMAL; pExitCriticalArg = adi_int_EnterCriticalRegion(pEnterCriticalArg); if (pAD7477A->InUseFlag == FALSE) { pAD7477A->InUseFlag = TRUE; Result = ADI_DEV_RESULT_SUCCESS; } adi_int_ExitCriticalRegion(pExitCriticalArg); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // Open the SPI driver Result = adi_dev_Open( ManagerHandle, // device manager handle &ADISPIDMAEntryPoint, // dma-driven SPI driver entry point 0, // device number pAD7477A, // client handle - passed to internal callback function &pAD7477A->spiHandle, // pointer to DM handle (for SPI driver) location Direction, // data direction as input DMAHandle, // handle to the DMA manager DCBHandle, // handle to the callback manager spiCallbackFunction // internal callback function ); // return with appropriate code if SPI driver fails to open #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // Configure the SPI Control register (SPI_CTL) for the // appropriate values for the AD7477A device ADI_DEV_CMD_VALUE_PAIR SPI_config[] = { { ADI_SPI_CMD_SET_TRANSFER_INIT_MODE, (void*)2 }, // DMA read { ADI_SPI_CMD_SET_GET_MORE_DATA, (void*)0 }, // discard incoming data if SPI_RDBR register is full { ADI_SPI_CMD_SET_PSSE, (void*)0 }, // free up PF0 { ADI_SPI_CMD_SET_MISO, (void*)1 }, // allow data in { ADI_SPI_CMD_SET_WORD_SIZE, (void*)16 }, // Data word size 16 Bit (we need 16bits // since the AD7477A device generates 10 bits data with 4 leading // and 2 trailing zeros) { ADI_SPI_CMD_SET_LSB_FIRST, (void*)0 }, // Most Significant Bit transmitted first { ADI_SPI_CMD_SET_CLOCK_PHASE, (void*)0 }, // Clock phase field = 0 is required for DMA { ADI_SPI_CMD_SET_CLOCK_POLARITY, (void*)1 }, // Clock polarity - sample on falling edge of serial clock { ADI_SPI_CMD_SET_MASTER, (void*)1 }, // The SPI port is the master { ADI_SPI_CMD_SET_EXCLUSIVE_ACCESS, (void*) TRUE}, // get us exclusive access to the SPI driver { ADI_DEV_CMD_END, (void*)0 } }; Result = adi_dev_Control( pAD7477A->spiHandle, ADI_DEV_CMD_TABLE, (void*)SPI_config ); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // save the physical device handle in the client supplied location *pPDDHandle = (ADI_DEV_PDD_HANDLE *)pAD7477A; // return after successful completion return(Result); }
/********************************************************************* Function: adi_ad1980_SportConfig Opens and Configures SPORT device allocated to AD1980 Audio Codec Parameters: poDevice - Pointer to AD1980 device instance to work on Returns: ADI_DEV_RESULT_SUCCESS - Successfully opened and configured SPORT device Error code returned from SPORT driver *********************************************************************/ static u32 adi_ad1980_SportConfig( ADI_AD1980_DEF *poDevice ) { /* default return code */ u32 nResult = ADI_DEV_RESULT_SUCCESS; /* SPORT Configuration Table */ ADI_DEV_CMD_VALUE_PAIR aoSportConfigTable[] = { /* clear any previous Tx errors */ { ADI_SPORT_CMD_CLEAR_TX_ERRORS, (void *)NULL }, /* clear any previous Rx errors */ { ADI_SPORT_CMD_CLEAR_RX_ERRORS, (void *)NULL }, /* SPORT in Circular mode */ { ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void *)ADI_DEV_MODE_CIRCULAR }, /* Enable Streaming mode */ { ADI_DEV_CMD_SET_STREAMING, (void *)true }, /* External Frame sync, MSB first, No TFS required */ { ADI_SPORT_CMD_SET_TCR1, (void *)0 }, /* Secondary disabled */ { ADI_SPORT_CMD_SET_TCR2, (void *)0 }, /* Tx Wordlength = 16 bits */ { ADI_SPORT_CMD_SET_TX_WORD_LENGTH, (void *)15 }, /* Internal RFS, Require RFS for every data */ { ADI_SPORT_CMD_SET_RCR1, (void *)0x0600 }, /* Secondary disabled */ { ADI_SPORT_CMD_SET_RCR2, (void *)0 }, /* Rx Wordlength = 16 bits */ { ADI_SPORT_CMD_SET_RX_WORD_LENGTH, (void *)15 }, /* sets RFS to 48kHz (BIT_CLK for AC'97 = 12.288MHz) */ { ADI_SPORT_CMD_SET_RFSDIV, (void *)0xFF }, /* MFD = 1, Enable Multi Channel, Enable Tx/Rx DMA packing */ { ADI_SPORT_CMD_SET_MCMC2, (void *)0x101C }, /* 16 Channels */ { ADI_SPORT_CMD_SET_MTCS0, (void *)0xFFFF }, /* 16 Channels */ { ADI_SPORT_CMD_SET_MRCS0, (void *)0xFFFF }, /* Window Size = ((16 Channels/8) - 1) = 1 */ { ADI_SPORT_CMD_SET_MCMC1, (void *)0x1000 }, /* Enable error reporting */ { ADI_DEV_CMD_SET_ERROR_REPORTING, (void *)true }, /* End of Configuration table */ { ADI_DEV_CMD_END, (void *)NULL }, }; /* IF (Reset Flag ID is valid) */ if (poDevice->eResetFlag != ADI_FLAG_UNDEFINED) { /* Issue a Hardware reset to AD1980 */ nResult = adi_ac97_HwReset(poDevice->pAC97, poDevice->eResetFlag); } /* ELSE (Invalid reset flag) */ else { /* Report failure (Invalid Reset Flag) */ nResult = ADI_AD1980_RESULT_RESET_FLAG_ID_INVALID; } /* IF (Successfully Reset AD1980) */ if (nResult == ADI_DEV_RESULT_SUCCESS) { /* Open SPORT Device connected to AD1980 */ nResult = adi_dev_Open(poDevice->hDeviceManager, &ADISPORTEntryPoint, poDevice->nSportDevNumber, poDevice, &poDevice->hSport, ADI_DEV_DIRECTION_BIDIRECTIONAL, poDevice->hDmaManager, NULL, adi_ad1980_SportCallback); } /* IF (Successfully opened SPORT device) */ if (nResult == ADI_DEV_RESULT_SUCCESS) { /* Configure SPORT Device */ nResult = adi_dev_Control(poDevice->hSport, ADI_DEV_CMD_TABLE, (void *)&aoSportConfigTable[0]); } /* IF (Successfully Configured the SPORT driver) */ if (nResult == ADI_DEV_RESULT_SUCCESS) { /* Submit outbound buffer */ nResult = adi_dev_Write (poDevice->hSport, ADI_DEV_CIRC, (ADI_DEV_BUFFER *)(&poDevice->pAC97->DacCircBuf)); } /* IF (Successfully Submitted outbound buffer) */ if (nResult == ADI_DEV_RESULT_SUCCESS) { /* Submit inbound buffer */ nResult = adi_dev_Read (poDevice->hSport, ADI_DEV_CIRC, (ADI_DEV_BUFFER *)(&poDevice->pAC97->AdcCircBuf)); } /* IF (Successfully Opened and Configured SPORT Device) */ if (nResult == ADI_DEV_RESULT_SUCCESS) { /* Enable SPORT dataflow - this enables AC-Link to AD1980 */ nResult = adi_dev_Control(poDevice->hSport, ADI_DEV_CMD_SET_DATAFLOW, (void *)true); } return (nResult); }
/****************************************************************** * * Function: system_init() * Description: * Initializes Device Manager, Interrupt * Manager and the Stack. * Return: * Returns 1 upon success -1 upon failure. * ******************************************************************/ int system_init() { unsigned int result; ADI_DEV_DEVICE_HANDLE lan_handle; char *ether_stack_block; u16 phyregs[32]; /* Initialize interrupt manager and device manager */ adi_ssl_Init(); #ifdef __ADSPBF526__ /* Set CCLK = 400 MHz, SCLK = 80 MHz */ adi_pwr_SetFreq(400000000,80000000, ADI_PWR_DF_NONE); #endif /* Initialize the kernel */ ker_init((void*)0); /* set thread type for the stack threads */ ker_set_auxdata((void*)kADI_TOOLS_IOEThreadType); /* open lan-device */ result = adi_dev_Open( adi_dev_ManagerHandle, #if ( defined(USB_LAN) || defined(__ADSPBF533__) || defined(__ADSPBF561__) || defined(__ADSPBF538__) ) &ADI_ETHER_USBLAN_Entrypoint, #elif defined(__ADSPBF526__) &ADI_ETHER_BF526_Entrypoint, #elif defined(__ADSPBF527__) &ADI_ETHER_BF527_Entrypoint, #elif ( defined(__ADSPBF537__) || defined(__ADSPBF536__) ) &ADI_ETHER_BF537_Entrypoint, #elif defined(__ADSPBF548__) &ADI_ETHER_LAN9218_Entrypoint, #endif 0, NULL, &lan_handle, ADI_DEV_DIRECTION_BIDIRECTIONAL, NULL, NULL, (ADI_DCB_CALLBACK_FN)stack_callback_handler); DEBUG_PRINT("Failed to open the lan-device\n",result != ADI_DEV_RESULT_SUCCESS); /* set the services with in stack */ set_pli_services(1,&lan_handle); #if (!defined(USB_LAN) && (defined(__ADSPBF527__) || defined(__ADSPBF526__) || defined(__ADSPBF537__) || defined(__ADSPBF536__) ) ) *pEBIU_AMGCTL = 0x1FF; #if defined(__ADSPBF527__) result = ReadMACAddress(hwaddr); #endif //BF527 /* * Read the EZ-KIT Lite's assigned MAC address, found at address 0x203F0000 +- offset. * We need to first set the AMGCTL register to allow access to asynchronous * memory. * * Bit 8 of the EBIU_AMGCTL register is also set to ensure that DMA gets more priority over * the processor while accessing external memory. If this is not done then frequent * DMA under and over runs occur when executing instructions from SDRAM */ #if ( defined(__ADSPBF526__) || defined(__ADSPBF537__) || defined(__ADSPBF536__) ) memcpy ( &hwaddr, (unsigned char *) ADDRESS_OF_MAC_ADDRESS, sizeof ( hwaddr ) ); #endif result = adi_dev_Control( lan_handle, ADI_ETHER_CMD_SET_MAC_ADDR, (void*)&hwaddr); DEBUG_PRINT("Failed set MAC address\n",result != ADI_DEV_RESULT_SUCCESS); #endif /* supply some memory for the driver */ result = adi_dev_Control( lan_handle, ADI_ETHER_CMD_SUPPLY_MEM, &memtable); DEBUG_PRINT("Failed to supply memory to driver\n",result != ADI_DEV_RESULT_SUCCESS); result = adi_dev_Control( lan_handle, ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void*)TRUE); /* if __cplb_ctrl is defined to non-zero value inform the driver about it */ if(__cplb_ctrl){ result = adi_dev_Control( lan_handle, ADI_ETHER_CMD_BUFFERS_IN_CACHE, (void *)TRUE); } DEBUG_PRINT("Failed to set caching mode in driver\n",result != ADI_DEV_RESULT_SUCCESS); /* Initialze the stack with user specified configuration priority -3 and * poll period of p_period msec. The stack is allocated a memory buffer as well. */ ether_stack_block = (char *) malloc ( ETHER_STACK_SIZE ); DEBUG_PRINT("Failed to malloc stack \n",!ether_stack_block); init_stack ( 3, p_period, ETHER_STACK_SIZE, ether_stack_block ); /* Start the MAC */ result = adi_dev_Control ( lan_handle, ADI_ETHER_CMD_START, NULL); DEBUG_PRINT("Failed to start the driver\n",result != ADI_DEV_RESULT_SUCCESS); /* read the PHY controller registers */ adi_dev_Control(lan_handle,ADI_ETHER_CMD_GET_PHY_REGS,phyregs); DEBUG_PRINT("PHY Controller has failed and the board needs power cycled\n",phyregs[1]==0xFFFF); /* wait for the link to be up */ if ( (phyregs[1]&0x4) ==0) { printf("Waiting for the link to be established\n"); while ( (phyregs[1]&0x4) ==0) { // wait period of time VDK_PendSemaphore(kPeriodic,0); adi_dev_Control(lan_handle,ADI_ETHER_CMD_GET_PHY_REGS,phyregs); } } printf("Link established\n"); return 1; }
/********************************************************************* * * Function: PPI_Open * * Description: Opens the ppi device for NL6448BC33-54 LCD dataflow * *********************************************************************/ static u32 PPI_Open( ADI_DEV_PDD_HANDLE PDDHandle // Physical Device Driver Handle ) { ADI_LCD *pLCD; // pointer to the device we're working on pLCD = (ADI_LCD *)PDDHandle; // Pointer to device driver instance // default return code u32 Result = ADI_DEV_RESULT_SUCCESS; // storage for PPI frame sync timer values ADI_PPI_FS_TMR FsTmrBuf = {0}; // initialize - sets all fields to zero // Configure the PPI registers for LCD ADI_DEV_CMD_VALUE_PAIR PPI_Cfg[] = { #if defined (__ADSPBF561__) // by default, PPI is configured as output & DMA32 enabled { ADI_PPI_CMD_SET_CONTROL_REG, (void *)0xB91E },// tx-mode,2or3 syncs,16bits and FS_INVERT = 1 #else // for BF533 & BF537 { ADI_PPI_CMD_SET_CONTROL_REG, (void *)0xB81E },// tx-mode,2or3 syncs,16bits and FS_INVERT = 1 #endif #if defined ADI_NEC_NL6448BC33_54 { ADI_PPI_CMD_SET_DELAY_COUNT_REG, (void *)143 },// clk delay after frame sync #else // ADI_SHARP_LQ10D368 #if defined (__ADSPBF537__) { ADI_PPI_CMD_SET_DELAY_COUNT_REG, (void *)199 },//BF537 clk delay after frame sync #else { ADI_PPI_CMD_SET_DELAY_COUNT_REG, (void *)199 },//BF533 or BF561 clk delay after frame sync #endif #endif { ADI_PPI_CMD_SET_TRANSFER_COUNT_REG, (void *)639 },// 640 active pixels { ADI_DEV_CMD_END, (void *)0 } }; // Open the PPI driver Result = adi_dev_Open( pLCD->ManagerHandle, // device manager handle &ADIPPIEntryPoint, // ppi Entry point pLCD->PPINumber, // ppi device number pLCD, // client handle - passed to internal callback function &pLCD->ppiHandle, // pointer to DM handle (for PPI driver) location ADI_DEV_DIRECTION_OUTBOUND, // PPI used only to receive video data pLCD->DMAHandle, // handle to the DMA manager pLCD->DCBHandle, // handle to the callback manager ppiCallbackFunction // internal callback function ); // return with appropriate code if PPI driver fails to open #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // set the PPI configuration Result = adi_dev_Control( pLCD->ppiHandle, ADI_DEV_CMD_TABLE, (void*)PPI_Cfg ); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // set the frame sync configuration. FsTmrBuf.pulse_hi = 0;//positive action pulse FsTmrBuf.emu_run = 1;// timer counter runs during emulation // timer 0 configuration (Hsync) #if defined ADI_NEC_NL6448BC33_54 FsTmrBuf.period = 800; // timer0 period (800clk = 1H) #else // ADI_SHARP_LQ10D368 FsTmrBuf.period = 900; // timer0 period (900clk) #endif FsTmrBuf.width = 96; // timer0 width (96clk) Result = adi_dev_Control( pLCD->ppiHandle, ADI_PPI_CMD_SET_TIMER_FRAME_SYNC_1, (void*)&FsTmrBuf ); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // timer 1 configuration (Vsync) #if defined ADI_NEC_NL6448BC33_54 FsTmrBuf.period = 0x668A0; // timer1 period (525H = 525*800clk) #else // ADI_SHARP_LQ10D368 FsTmrBuf.period = 0x735B4; // timer1 period (525*900clk) #endif FsTmrBuf.width = 1600; // timer1 width (2H = 2*800clk) Result = adi_dev_Control( pLCD->ppiHandle, ADI_PPI_CMD_SET_TIMER_FRAME_SYNC_2, (void*)&FsTmrBuf ); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif return (Result); }
/****************************************************************** * * Function: system_init() * Description: * Initializes Device Manager, Interrupt * Manager and the Stack. * Return: * Returns 1 upon success -1 upon failure. * ******************************************************************/ int system_init() { ADI_DEV_MANAGER_HANDLE devmgr_handle; unsigned int result; u32 response_count,critical_reg; ADI_DEV_DEVICE_HANDLE lan_handle; char *ether_stack_block; u16 phyregs[32]; #ifdef __ADSPBF537__ const unsigned int mac_address_in_flash = 0x203F0000; #endif /* initialize the interrupt manager */ result = adi_int_Init( intmgr_storage, sizeof(intmgr_storage), &response_count, &critical_reg); DEBUG_PRINT("Failed to Initialize interrupt manager\n",result != ADI_DEV_RESULT_SUCCESS); /* initialize the device manager */ result = adi_dev_Init( devmgr_storage, sizeof(devmgr_storage), &response_count, &devmgr_handle, &imask_storage); DEBUG_PRINT("Failed to Initilize device manager\n",result != ADI_DEV_RESULT_SUCCESS); /* Initialize the kernel */ ker_init((void*)0); /* set thread type for the stack threads */ ker_set_auxdata((void*)kADI_TOOLS_IOEThreadType); /* open lan-device */ result = adi_dev_Open( devmgr_handle, #if defined(__ADSPBF533__) &ADI_ETHER_USBLAN_Entrypoint, #elif defined(__ADSPBF537__) &ADI_ETHER_BF537_Entrypoint, #endif 0, NULL, &lan_handle, ADI_DEV_DIRECTION_BIDIRECTIONAL, NULL, NULL, (ADI_DCB_CALLBACK_FN)stack_callback_handler); DEBUG_PRINT("Failed to open the lan-device\n",result != ADI_DEV_RESULT_SUCCESS); /* set the services with in stack */ set_pli_services(1,&lan_handle); #ifdef __ADSPBF537__ /* * Read the EZ-KIT Lite's assigned MAC address, found at address 0x203F0000. * We need to first set the AMGCTL register to allow access to asynchronous * memory. * * DMA gets more priority than the processor while accessing SDRAM. */ *pEBIU_AMGCTL = 0xFF | 0x100; memcpy ( &hwaddr, (unsigned char *) mac_address_in_flash, sizeof ( hwaddr ) ); result = adi_dev_Control( lan_handle, ADI_ETHER_CMD_SET_MAC_ADDR, (void*)&hwaddr); DEBUG_PRINT("Failed set MAC address\n",result != ADI_DEV_RESULT_SUCCESS); #endif /* supply some memory for the driver */ result = adi_dev_Control( lan_handle, ADI_ETHER_CMD_SUPPLY_MEM, &memtable); DEBUG_PRINT("Failed to supply memory to driver\n",result != ADI_DEV_RESULT_SUCCESS); result = adi_dev_Control( lan_handle, ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void*)TRUE); /* Initialze the stack with user specified configuration priority -3 and * poll period of p_period msec. The stack is allocated a memory buffer as well. */ ether_stack_block = (char *) malloc ( ETHER_STACK_SIZE ); DEBUG_PRINT("Failed to malloc stack \n",!ether_stack_block); init_stack ( 3, p_period, ETHER_STACK_SIZE, ether_stack_block ); /* Start the MAC */ result = adi_dev_Control ( lan_handle, ADI_ETHER_CMD_START, NULL); DEBUG_PRINT("Failed to start the driver\n",result != ADI_DEV_RESULT_SUCCESS); /* read the PHY controller registers */ adi_dev_Control(lan_handle,ADI_ETHER_CMD_GET_PHY_REGS,phyregs); DEBUG_PRINT("PHY Controller has failed and the board needs power cycled\n",phyregs[1]==0xFFFF); /* wait for the link to be up */ if ( (phyregs[1]&0x4) ==0) { printf("Waiting for the link to be established\n"); while ( (phyregs[1]&0x4) ==0) { adi_dev_Control(lan_handle,ADI_ETHER_CMD_GET_PHY_REGS,phyregs); } } printf("Link established\n"); return 1; }
/********************************************************************* Function: Activate Description: Activates the host and enumerates the attached device *********************************************************************/ static u32 Activate(ADI_USB_DEF *pDevice, u32 EnableFlag) { u32 Result = ADI_FSS_RESULT_SUCCESS; u32 i = 0; /* The reset is only performed once for all PID's in chain */ if (EnableFlag) { /* Initialize the core */ if (pDevice->UseDefaultController) { adi_usb_CoreInit((void*)&Result); /* Open the BF54x USB Driver */ Result = adi_dev_Open( pDevice->ManagerHandle, /* DevMgr handle */ &ADI_USBDRC_Entrypoint, /* pdd entry point */ 0, /* device instance */ (void*)1, /* client handle callback identifier */ &pDevice->ControllerHandle, /* device handle */ ADI_DEV_DIRECTION_BIDIRECTIONAL, /* data direction for this device */ pDevice->DMAHandle, /* handle to DmaMgr for this device */ pDevice->DCBHandle, /* handle to deferred callback service */ ControllerCallback /* client's callback function */ ); } /* Get the current Device ID. Once the driver is opened its */ /* suppose to create the device. If the device is already opened then */ /* it must return the same device ID. */ if ((Result != ADI_DEV_RESULT_SUCCESS) || (pDevice->ControllerHandle == NULL)) { Result = ADI_FSS_RESULT_FAILED; } if ( Result==ADI_DEV_RESULT_SUCCESS && !pDevice->UseDefaultClassDriver ) { Result = adi_dev_Control ( pDevice->ClassDriverHandle, ADI_DEV_CMD_CHANGE_CLIENT_HANDLE, (void*)pDevice ); Result = adi_dev_Control ( pDevice->ClassDriverHandle, ADI_DEV_CMD_CHANGE_CLIENT_CALLBACK_FUNCTION, (void*)ClassDriverCallback ); } if ( Result==ADI_DEV_RESULT_SUCCESS && pDevice->UseDefaultClassDriver ) { /* open the class driver */ Result = adi_dev_Open( pDevice->ManagerHandle, /* DevMgr handle */ &ADI_USB_Host_MassStorageClass_Entrypoint, /* pdd entry point */ 0, /* device instance */ pDevice, /* client handle callback identifier */ &pDevice->ClassDriverHandle, /* device handle */ ADI_DEV_DIRECTION_BIDIRECTIONAL, /* data direction for this device */ pDevice->DMAHandle, /* handle to DmaMgr for this device */ pDevice->DCBHandle, /* handle to deferred callback service */ ClassDriverCallback /* client's callback function */ ); } if ((Result != ADI_DEV_RESULT_SUCCESS) || (pDevice->ClassDriverHandle == NULL)) { Result = ADI_FSS_RESULT_FAILED; } /* If the controller and class drivers are supplied, we assume that these steps * have already been taken */ if (pDevice->UseDefaultClassDriver && Result == ADI_DEV_RESULT_SUCCESS) { /* configure the controller mode */ Result = adi_dev_Control( pDevice->ClassDriverHandle, ADI_USB_CMD_CLASS_SET_CONTROLLER_HANDLE, (void*)pDevice->ControllerHandle ); /* configure the class driver */ if (Result == ADI_DEV_RESULT_SUCCESS) { Result = adi_dev_Control( pDevice->ClassDriverHandle, ADI_USB_CMD_CLASS_CONFIGURE, (void*)0 ); } /* configure the data flow method */ if (Result == ADI_DEV_RESULT_SUCCESS) { Result = adi_dev_Control( pDevice->ClassDriverHandle, ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void*)ADI_DEV_MODE_CHAINED ); } /* enable data flow */ if (Result == ADI_DEV_RESULT_SUCCESS) { Result = adi_dev_Control( pDevice->ClassDriverHandle, ADI_DEV_CMD_SET_DATAFLOW, (void*)TRUE ); } if (Result == ADI_DEV_RESULT_SUCCESS) { Result = adi_dev_Control( pDevice->ControllerHandle, ADI_USB_CMD_ENABLE_USB, 0 ); } } } else { /* Deactivate */ pDevice->MediaPresent = false; } return Result; }
static u32 adi_pdd_Open( ADI_DEV_MANAGER_HANDLE ManagerHandle, // device manager handle u32 DeviceNumber, // device number ADI_DEV_DEVICE_HANDLE DMHandle, // device handle ADI_DEV_PDD_HANDLE *pPDDHandle, // pointer to PDD handle location ADI_DEV_DIRECTION Direction, // data direction void *pEnterCriticalArg, // enter critical region parameter ADI_DMA_MANAGER_HANDLE DMAHandle, // handle to the DMA manager ADI_DCB_HANDLE DCBHandle, // callback handle ADI_DCB_CALLBACK_FN DMCallback // client callback function ) { // default return code u32 Result = ADI_DEV_RESULT_SUCCESS; ADI_AD1854 *pAD1854; // pointer to the AD1854 device we're working on void *pExitCriticalArg; // exit critical region parameter u32 ResponseCount; // Check for a valid device number and that we're only doing input #ifdef ADI_DEV_DEBUG if (DeviceNumber >= ADI_AD1854_NUM_DEVICES) return (ADI_DEV_RESULT_BAD_DEVICE_NUMBER); if (Direction != ADI_DEV_DIRECTION_OUTBOUND) return (ADI_DEV_RESULT_DIRECTION_NOT_SUPPORTED); #endif // assign the pointer to the device instance pAD1854 = &Device[DeviceNumber]; // and store the Device Manager handle pAD1854->DMHandle = DMHandle; // and callback function pAD1854->DMCallback = DMCallback; pExitCriticalArg = adi_int_EnterCriticalRegion(pEnterCriticalArg); if (pAD1854->InUseFlag == FALSE) { pAD1854->InUseFlag = TRUE; Result = ADI_DEV_RESULT_SUCCESS; } adi_int_ExitCriticalRegion(pExitCriticalArg); #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // Open SPORT0 for communication Result = adi_dev_Open(ManagerHandle, &ADISPORTEntryPoint, 0, pAD1854, &(pAD1854->sportHandle), ADI_DEV_DIRECTION_OUTBOUND, DMAHandle, DCBHandle, sportCallbackFunction); // return with appropriate code if SPORT driver fails to open #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif #ifdef ADI_DEV_DEBUG if (Result != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // save the physical device handle in the client supplied location *pPDDHandle = (ADI_DEV_PDD_HANDLE *)pAD1854; //Reset_DAC(); // return after successful completion return(Result); }
/********************************************************************* Function: Activate Description: Activates the host and enumerates the attached device *********************************************************************/ __ADI_NAND_SECTION_CODE static u32 Activate(ADI_NAND_DEF *pDevice, u32 EnableFlag) { u32 Result = ADI_FSS_RESULT_SUCCESS; u32 i = 0; void *Value = NULL; /* pointer to argument */ ADI_FSS_SUPER_BUFFER FSSBuffer; F_PHY FtlPhyLayer; /* The reset is only performed once for all PID's in chain */ if (!pDevice->Active) { if (!pDevice->NFC_DeviceHandle) { /* The NFC was not previously opened so open it */ Result = adi_dev_Open( pDevice->ManagerHandle, /* Device Manager handle */ &ADI_NFC_EntryPoint, /* NFC driver Entry point */ pDevice->DeviceNumber, /* NFC device number */ NULL, /* client handle */ &pDevice->NFC_DeviceHandle, /* Location to store NFC device handle */ pDevice->Direction, /* NFC Direction */ pDevice->DMAHandle, /* DMA manager Handle */ pDevice->DCBHandle, /* DCB Manager Handle */ CallbackFromNFC /* NFC callback function */ ); } /* configure the NFC driver */ if (Result==ADI_FSS_RESULT_SUCCESS) { Result = ConfigNFC( pDevice ); } /* If needed and enabled format the device */ if (( pDevice->Perform_Format_Flag == TRUE ) && (Result==ADI_FSS_RESULT_SUCCESS)) { if (adi_ftl_NandFormat()) { /* if format NFD failed, return error */ Result = ADI_FSS_RESULT_FAILED; } } /* Initialize the entry points for the wear leveling. */ if (Result == ADI_FSS_RESULT_SUCCESS) { /* initialize FTL layer */ pDevice->pFtlEntryPoints = adi_ftl_Init(); if (!pDevice->pFtlEntryPoints) { Result = ADI_FSS_RESULT_NO_MEDIA; } } if (Result==ADI_FSS_RESULT_SUCCESS) { /* Get Global Size parameters from FTL */ (pDevice->pFtlEntryPoints->getphy)(pDevice->pFtlEntryPoints, &FtlPhyLayer); pDevice->GlobalVolumeDef.VolumeSize = FtlPhyLayer.number_of_sectors; pDevice->GlobalVolumeDef.SectorSize = FtlPhyLayer.bytes_per_sector; } if (Result==ADI_FSS_RESULT_SUCCESS) { pDevice->Active = true; } } else { /* Deactivate */ pDevice->Active = false; pDevice->MediaPresent = false; } return Result; }