AdiDeviceResult AdiDevice::Write(ADI_DEV_BUFFER_TYPE bufferType, ADI_DEV_BUFFER *pBuffer) { ESS_ASSERT(IsOpened()); return adi_dev_Write(m_deviceHandle, bufferType, pBuffer); }
void UARTwrite(u8* data, u32 len) { while (len>0) { while (UARTsending()); sending_done = 0; OutboundBuffer.ElementCount = min(OUTBUFLEN,len); memcpy( OutboundData, data, OutboundBuffer.ElementCount ); len -= OutboundBuffer.ElementCount; data+= OutboundBuffer.ElementCount; OutboundBuffer.ProcessedFlag = 0; // requeue the outbound buffer ezErrorCheck(adi_dev_Write(DriverHandle, ADI_DEV_1D, (ADI_DEV_BUFFER *)&OutboundBuffer)); } while (UARTsending()); }
static u32 adi_pdd_Write( // Writes data or queues an outbound buffer to a device ADI_DEV_PDD_HANDLE PDDHandle, // PDD handle ADI_DEV_BUFFER_TYPE BufferType, // buffer type ADI_DEV_BUFFER *pBuffer // pointer to buffer ) { // Pointer to ADAV801 device driver instance ADI_ADAV801 *pADAV801 = (ADI_ADAV801 *)PDDHandle; #ifdef ADI_DEV_DEBUG // check for errors if required u32 Result = ADI_DEV_RESULT_SUCCESS; if ((Result = ValidatePDDHandle(PDDHandle)) != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // pass write operation to SPORT return(adi_dev_Write(pADAV801->sportHandle,BufferType,pBuffer)); }
static u32 adi_pdd_Write( // Writes data or queues an outbound buffer to a device ADI_DEV_PDD_HANDLE PDDHandle, // PDD handle ADI_DEV_BUFFER_TYPE BufferType, // buffer type ADI_DEV_BUFFER *pBuffer // pointer to buffer ){ // check for errors if required u32 Result = ADI_DEV_RESULT_SUCCESS; #if defined(ADI_DEV_DEBUG) if ((Result = ValidatePDDHandle(PDDHandle)) != ADI_DEV_RESULT_SUCCESS) return (Result); #endif // Simply pass the request on ADI_LCD *pLCD = (ADI_LCD *)PDDHandle; Result = adi_dev_Write(pLCD->ppiHandle,BufferType,pBuffer); 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); }
/*########################################################################## * * Output pbuf chain to hardware. It is assumed that there is a complete and * correct ethernet frame in p. The only buffering in this system is in the * list of tx ADI_ETHER_BUFFER's. If there is no room in it, then drop the frame. * *#########################################################################*/ static err_t low_level_output(struct netif* netif, struct pbuf* p) { struct nifce_info* nip = (struct nifce_info*)netif->state; ADI_ETHER_BUFFER* tx; struct pbuf *q; char* data; unsigned short *ps; struct hw_eth_hdr* ethhdr; u32_t old_level; int len; if (p->tot_len > nip->tx_buff_datalen) { // frame too big for our buffers #ifdef LINK_STATS lwip_stats.link.memerr++; #endif return ERR_MEM; } // No need of data maipulation as we are directly getting from pbufs. if (Trace_Function) Trace_Function('T',p->tot_len,((unsigned char *)p->payload)+2); // see whether we've got a free transmit buffer old_level = sys_arch_protect(); tx = (ADI_ETHER_BUFFER*)nip->x; if (tx == NULL) { #ifdef LINK_STATS lwip_stats.link.memerr++; #endif sys_arch_unprotect(old_level); return ERR_MEM; } // remove first free one from the list nip->x = tx->pNext; tx->pNext = NULL; sys_arch_unprotect(old_level); // copy data from pbuf(s) into our buffer q = p; //data = (char*)tx->Data; // // first two bytes reserved for length data = (char*)tx->Data+2; // ... first pbuf: skip field unused1 in struct eth_hdr memcpy(data, ((u8_t*)q->payload) + 2, q->len - 2); data += (q->len - 2); len = q->len - 2; q = q->next; // copy any subsequent pbufs while (q) { memcpy(data, q->payload, q->len); data += q->len; len += q->len; q = q->next; } LWIP_ASSERT("low_level_output: data length correct", len == (p->tot_len - 2)); //tx->ElementCount = p->tot_len - 2; tx->ElementCount = p->tot_len; // total element count including 2 byte header // see whether we need to shuffle etharp frame up to account for // the alignment fields unused2 and unused3 //ethhdr = (struct hw_eth_hdr*)tx->Data; // ethhdr = (struct hw_eth_hdr*)((char*)tx->Data+2);//skip the header if (htons(ethhdr->type) == ETHTYPE_ARP) { u8_t* pdst = (u8_t*)tx->Data + 28 +2; u8_t* psrc = pdst + 2; // skip unused2 field memmove(pdst, psrc, 10); pdst += 10; psrc += 12; // skip unused3 field memmove(pdst, psrc, 4); //tx->num_elements -= 4; tx->ElementCount -= 4; } ps = (unsigned short*)tx->Data; *ps = tx->ElementCount-2; // only the frame size excluding 2 byte header tx->PayLoad = 0; // payload is part of the packet tx->StatusWord = 0; // changes from 0 to the status info // give it to the physical driver adi_dev_Write(nip->handle,ADI_DEV_1D,(ADI_DEV_BUFFER*)tx); #ifdef LINK_STATS lwip_stats.link.xmit++; #endif //sys_arch_unprotect(old_level); return ERR_OK; }
static u32 adi_pdd_Write( ADI_DEV_PDD_HANDLE PDDHandle, /* PDD handle */ ADI_DEV_BUFFER_TYPE BufferType, /* buffer type */ ADI_DEV_BUFFER *pBuffer /* pointer to buffer */ ) { u32 Result; /* Expose the Device Definition structure */ ADI_USB_DEF *pDevice = (ADI_USB_DEF *)PDDHandle; /* Expose the FSS super buffer structure */ ADI_FSS_SUPER_BUFFER *pSuperBuffer = (ADI_FSS_SUPER_BUFFER *)pBuffer; /* Assign callback function and handle to Super Buffer */ pSuperBuffer->PIDCallbackFunction = CallbackFromFSS; pSuperBuffer->PIDCallbackHandle = (void*)pDevice; #if defined(_BF527_SDRAM_ISSUE_WORKAROUND) /* tranfser 'gEndPointMaxPacketSize' bytes at at time & copy to request buffer */ ADI_DEV_1D_BUFFER TempBuffer, *pClientBuffer; u32 BytesRemaining = pBuffer->OneD.ElementCount*pBuffer->OneD.ElementWidth; u32 *pClientData = (u32*)pBuffer->OneD.Data; u32 *pTempData; u32 i; u32 SectorNumber = pSuperBuffer->LBARequest.StartSector; u32 BufferSize; u32 SectorIncrement; if (BytesRemaining< TEMP_BUF_SIZE) { BufferSize = BytesRemaining; } else { BufferSize = TEMP_BUF_SIZE; } SectorIncrement = BufferSize/512; /* change LBA request to 1 sector */ pSuperBuffer->LBARequest.SectorCount = SectorIncrement; /* get max end point buffer size from MSH class driver */ //adi_dev_Control( pDevice->ClassDriverHandle, ADI_USB_MSD_CMD_GET_MAX_EP_PACKET_SIZE, (void*)&TempBuffer.ElementCount ); TempBuffer.Data = (void*)&TempBufferData[0]; TempBuffer.ElementWidth = sizeof(u8); TempBuffer.ElementCount = BufferSize; TempBuffer.ProcessedElementCount = 0; TempBuffer.ProcessedFlag = FALSE; TempBuffer.CallbackParameter = &TempBuffer; TempBuffer.pNext = NULL; pClientBuffer = &pSuperBuffer->Buffer; while (pClientBuffer) { while (BytesRemaining) { pTempData = (u32*)&TempBufferData[0]; /* If a Memory DMA stream has been registered with the driver then it is used for the * transfer between the L1 temporary buffer and the client buffer */ if (pDevice->MemDMAStreamHandle) { adi_dma_MemoryCopy( pDevice->MemDMAStreamHandle, /* Stream Handle */ pTempData, /* Destination buffer */ pClientData, /* Source buffer */ sizeof(u32), /* Element Width */ (TempBuffer.ElementCount)/sizeof(u32), /* Number of elements */ MemDmaCallback /* Callback function */ ); /* pend on completion */ adi_sem_Pend(MemDmaSemaphoreHandle,ADI_SEM_TIMEOUT_FOREVER); pClientData += (TempBuffer.ElementCount)/sizeof(u32); } /* Otherwise a core copy is used */ else { for(i=0;i<(TempBuffer.ElementCount)/sizeof(u32);i++,pClientData++,pTempData++) { *pTempData = *pClientData; } } pDevice->ClassCommandComplete = FALSE; /* Pass LBA request to the Class Driver */ SendLbaRequest(pDevice,&pSuperBuffer->LBARequest); /* queue the buffer */ Result = adi_dev_Write( pDevice->ClassDriverHandle, ADI_DEV_1D, (ADI_DEV_BUFFER*)&TempBuffer ); if (Result!=ADI_DEV_RESULT_SUCCESS) { return Result; } /* and wait for completion */ WaitOnCommandCompletion(pDevice); BytesRemaining -= TempBuffer.ElementCount; pSuperBuffer->LBARequest.StartSector += SectorIncrement; } pClientBuffer = pClientBuffer->pNext; } (pDevice->DMCallback) ( pDevice->DeviceHandle, ADI_DEV_EVENT_BUFFER_PROCESSED, (void *)pBuffer ); (pDevice->DMCallback) ( pDevice->DeviceHandle, ADI_PID_EVENT_DEVICE_INTERRUPT, (void *)pBuffer); #else #if defined(_USE_BACKG_XFER) /* save aside the next buffer in the chain */ pNextBufferInChain = (ADI_FSS_SUPER_BUFFER *)pBuffer->OneD.pNext; /* and clear it so that the USB driver only deals with a single buffer */ pBuffer->OneD.pNext = NULL; #endif #if defined(_USE_BACKG_XFER) /* Pass LBA request to the Class Driver */ SendLbaRequest(pDevice,&pSuperBuffer->LBARequest); #endif /* Pass on the request to the Class Driver */ Result = adi_dev_Write( pDevice->ClassDriverHandle, BufferType, pBuffer ); #endif return(Result); }
/********************************************************************* Function: CallbackFromFSS Description: This is the callback to be taken from the Class Driver. *********************************************************************/ static void ClassDriverCallback(void *pHandle, u32 Event, void *pArg) { ADI_USB_DEF *pDevice = (ADI_USB_DEF *)pHandle; void *pExitCriticalArg; u32 Result; switch (Event) { /* CASE (USB DEVICE INSERTED) */ case ADI_USB_EVENT_CONNECT: /* Callback FSS with ADI_FSS_EVENT_MEDIA_DETECTED event, which may pass the event on to * the application which can take action to Poll for Media. */ #if 0 if (FSSDirectCallbackFunction) { (FSSDirectCallbackFunction)( &pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_DETECTED, 0 ); } else { (pDevice->DMCallback) ( pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_DETECTED, 0 ); } #endif if (MediaDetectionCallbackFunction) { (MediaDetectionCallbackFunction)( &pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_DETECTED, 0 ); } break; /* CASE (USB DEVICE REMOVED) */ case ADI_USB_EVENT_DISCONNECT: /* simply flag as not present. Next ADI_PID_CMD_POLL_MEDIA_CHANGE command will * result in the ADI_FSS_EVENT_MEDIA_REMOVED event being sent to FSS. */ if (pDevice->MediaPresent) { pDevice->MediaPresent = FALSE; } if (MediaDetectionCallbackFunction) { (MediaDetectionCallbackFunction)( &pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_REMOVED, 0 ); } break; /* CASE (USB DATA TRANSFER COMPLETE) */ case ADI_DEV_EVENT_BUFFER_PROCESSED: /* pass on event to FSS via DM callback */ #if !defined(_BF527_SDRAM_ISSUE_WORKAROUND) (pDevice->DMCallback)( pDevice->DeviceHandle, Event, pArg); #endif /* If there is another buffer in the chain, send the next LBA request and * queue the next buffer with the class driver */ #if defined(_USE_BACKG_XFER) if (pNextBufferInChain) { ADI_FSS_SUPER_BUFFER *pSuperBuffer = pNextBufferInChain; /* The next buffer may not have an LBA Request associated with it, as * it may have been combimed with the previous buffer. In which case * we do not need to send the LBA request */ if (pSuperBuffer->LBARequest.SectorCount) { SendLbaRequest(pDevice, &pSuperBuffer->LBARequest); } pNextBufferInChain = (ADI_FSS_SUPER_BUFFER *)pSuperBuffer->Buffer.pNext; pSuperBuffer->Buffer.pNext = NULL; /* Queue the data buffer with the class driver */ if (pSuperBuffer->LBARequest.ReadFlag) { adi_dev_Read( pDevice->ClassDriverHandle, ADI_DEV_1D, (ADI_DEV_BUFFER *)pSuperBuffer); } else { adi_dev_Write( pDevice->ClassDriverHandle, ADI_DEV_1D, (ADI_DEV_BUFFER *)pSuperBuffer ); } } else #endif { /* At the end of the chain we issue the Device Interrupt event to signal * total completion */ #if defined(_BF527_SDRAM_ISSUE_WORKAROUND) pExitCriticalArg = adi_int_EnterCriticalRegion( pDevice->pEnterCriticalArg ); pDevice->ClassCommandComplete = TRUE; adi_int_ExitCriticalRegion(pExitCriticalArg); #else (pDevice->DMCallback)( pDevice->DeviceHandle, ADI_PID_EVENT_DEVICE_INTERRUPT, pArg); #endif } break; case ADI_USB_MSD_EVENT_SCSI_CMD_COMPLETE: /* post the semaphore upon which the DevicePollMedia function is pending */ pExitCriticalArg = adi_int_EnterCriticalRegion( pDevice->pEnterCriticalArg ); pDevice->ClassCommandComplete = TRUE; adi_int_ExitCriticalRegion(pExitCriticalArg); break; case ADI_USB_MSD_EVENT_SCSI_CMD_ERROR: pExitCriticalArg = adi_int_EnterCriticalRegion( pDevice->pEnterCriticalArg ); pDevice->SCSICommandError = TRUE; adi_int_ExitCriticalRegion(pExitCriticalArg); break; case ADI_FSS_EVENT_MEDIA_ERROR: { if (FSSDirectCallbackFunction) { (FSSDirectCallbackFunction)( &pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_REMOVED, 0 ); } else { (pDevice->DMCallback) ( pDevice->DeviceHandle, ADI_FSS_EVENT_MEDIA_REMOVED, 0 ); } } break; } }