static BT_HANDLE fullfat_mount(BT_HANDLE hFS, BT_HANDLE hVolume, BT_ERROR *pError) { FF_ERROR ffError; BT_ERROR Error = BT_ERR_GENERIC; BT_FF_MOUNT *pMount = (BT_FF_MOUNT *) BT_CreateHandle(&oHandleInterface, sizeof(BT_FF_MOUNT), pError); if(!pMount) { return NULL; } pMount->pBlockCache = BT_kMalloc(8192); pMount->hVolume = hVolume; pMount->pIoman = FF_CreateIOMAN(pMount->pBlockCache, 8192, 512, &ffError); if(!pMount->pIoman) { Error = BT_ERR_GENERIC; goto err_free_out; } ffError = FF_RegisterBlkDevice(pMount->pIoman, 512, fullfat_writeblocks, fullfat_readblocks, pMount); ffError = FF_MountPartition(pMount->pIoman, 0); return (BT_HANDLE) pMount; err_free_out: BT_kFree(pMount->pBlockCache); BT_DestroyHandle((BT_HANDLE)pMount); *pError = Error; return NULL; }
static BT_HANDLE ext2_opendir(BT_HANDLE hMount, const BT_i8 *szpPath, BT_ERROR *pError) { if(!hMount) { if(pError) *pError = BT_ERR_GENERIC; goto err_out; } BT_EXT2_DIR *pDir = (BT_EXT2_DIR *) BT_CreateHandle(&oDirHandleInterface, sizeof(BT_EXT2_DIR), pError); if(!pDir) { *pError = BT_ERR_NO_MEMORY; goto err_out; } pDir->pMount = (BT_EXT2_MOUNT *)hMount; pDir->szpFname = BT_kMalloc(BT_EXT2_FNAME_MAX_STRLEN); if(!pDir->szpFname) { *pError = BT_ERR_NO_MEMORY; goto err_free_out; } if(ext2fs_open_dir((char *)szpPath) < 0) { if(pError) *pError = BT_ERR_GENERIC; goto err_free_out; } #if 0 if(ext2fs_ls((char *)szpPath) < 0) { if(pError) *pError = BT_ERR_GENERIC; goto err_free_out; } #endif return (BT_HANDLE) pDir; err_free_out: if(pDir->szpFname) BT_kFree(pDir->szpFname); BT_DestroyHandle((BT_HANDLE)pDir); err_out: return NULL; }
BT_HANDLE BT_FifoCreate(BT_u32 ulElements, BT_u32 ulElementWidth, BT_ERROR *pError) { BT_HANDLE hFifo; BT_ERROR Error = BT_ERR_NONE; hFifo = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hFifo) { Error = BT_ERR_NO_MEMORY; goto err_out; } hFifo->hQueue = BT_CreateQueue(ulElements, ulElementWidth, &Error); if (!hFifo->hQueue) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hFifo->ulElementWidth = ulElementWidth; hFifo->ulElements = ulElements; return hFifo; err_free_out: BT_DestroyHandle(hFifo); err_out: if (pError) { *pError = Error; } return NULL; }
static BT_HANDLE fullfat_opendir(BT_HANDLE hMount, const BT_i8 *szpPath, BT_ERROR *pError) { BT_FF_DIR *pDir = (BT_FF_DIR *) BT_CreateHandle(&oDirHandleInterface, sizeof(BT_FF_DIR), pError); if(!pDir) { *pError = BT_ERR_NO_MEMORY; goto err_out; } BT_FF_MOUNT *pMount = (BT_FF_MOUNT *) hMount; FF_ERROR ffError = FF_FindFirst(pMount->pIoman, &pDir->oDirent, szpPath); if(ffError) { *pError = BT_ERR_GENERIC; goto err_free_out; } pDir->pMount = pMount; return (BT_HANDLE) pDir; err_free_out: BT_DestroyHandle((BT_HANDLE)pDir); err_out: return NULL; }
static BT_HANDLE devcfg_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error; if(g_bInUse) { Error = BT_ERR_GENERIC; goto err_set_out; } g_bInUse = BT_TRUE; BT_HANDLE hDevcfg = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hDevcfg) { goto err_set_out; } const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } hDevcfg->pRegs = (volatile ZYNQ_DEVCFG_REGS *) bt_ioremap((void *) pResource->ulStart, sizeof(ZYNQ_DEVCFG_REGS)); hDevcfg->pRegs->UNLOCK = 0x757BDF0D; // Unlock the DEVCFG interface. hDevcfg->pRegs->INT_STS = 0xFFFFFFFF; // Clear all interrupt status signals. hDevcfg->pRegs->CTRL |= CTRL_PCFG_PROG_B; hDevcfg->pRegs->CTRL |= CTRL_PCAP_MODE; // Enable PCAP transfer mode. hDevcfg->pRegs->CTRL |= CTRL_PCAP_PR; // Select PCAP for reconfiguration, (disables ICAP). hDevcfg->pRegs->CTRL &= ~CTRL_QUARTER_PCAP_RATE; // Set full bandwidth PCAP loading rate. hDevcfg->pRegs->MCTRL &= ~MCTRL_PCAP_LPBK; // Ensure internal PCAP looback is disabled. hDevcfg->pSLCR = (volatile ZYNQ_SLCR_REGS *) bt_ioremap((void *) ZYNQ_SLCR_BASE, sizeof(ZYNQ_SLCR_REGS)); zynq_slcr_unlock(hDevcfg->pSLCR); zynq_slcr_preload_fpga(hDevcfg->pSLCR); zynq_slcr_lock(hDevcfg->pSLCR); devcfg_reset_pl(hDevcfg); if(pError) { *pError = BT_ERR_NONE; } return hDevcfg; err_free_out: BT_DestroyHandle(hDevcfg); err_set_out: if(pError) { *pError = Error; } return NULL; }
static BT_ERROR ext2_init() { BT_ERROR Error; BT_HANDLE hFsExt2 = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!hFsExt2) { return Error; } return BT_RegisterFilesystem(hFsExt2); }
static BT_ERROR fullfat_init() { BT_ERROR Error; BT_HANDLE hFullFAT = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!hFullFAT) { return Error; } return BT_RegisterFilesystem(hFullFAT); }
BT_HANDLE BT_CreateMutex(BT_ERROR *pError) { BT_HANDLE hMutex = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hMutex) { return NULL; } hMutex->pMutex = BT_kMutexCreate(); return hMutex; }
static BT_HANDLE gpio_probe(const BT_I2C_BUS *pBus, const BT_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hGPIO = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hGPIO) { Error = BT_ERR_NO_MEMORY; goto err_out; } hGPIO->oClient.pBus = pBus; const BT_RESOURCE *pResource = BT_GetDeviceResource(pDevice, BT_RESOURCE_BUSID, 0); if(!pResource) { Error = BT_ERR_INVALID_RESOURCE; goto err_free_out; } hGPIO->oClient.addr = pResource->ulStart; pResource = BT_GetDeviceResource(pDevice, BT_RESOURCE_IO, 0); if(!pResource) { Error = BT_ERR_INVALID_RESOURCE; goto err_free_out; } BT_u32 base = pResource->ulStart; BT_u32 total = (pResource->ulEnd - pResource->ulStart) + 1; Error = BT_RegisterGpioController(base, total, hGPIO); if(Error) { goto err_free_out; } BT_kPrint("MAX7312 : Initialising GPIO Port Expander."); BT_u8 in1, in2; in1 = gpio_read_register(hGPIO, 0x00, &Error); in2 = gpio_read_register(hGPIO, 0x01, &Error); BT_kPrint("MAX7312 : in1 : %02X", in1); BT_kPrint("MAX7312 : in2 : %02X", in2); return hGPIO; err_free_out: BT_DestroyHandle(hGPIO); err_out: if(pError) { *pError = Error; } return NULL; }
BT_HANDLE gpio_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error; if(pError) { *pError = BT_ERR_NONE; } BT_HANDLE hGPIO = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hGPIO) { goto err_out; } const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IO, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } BT_u32 base = pResource->ulStart; BT_u32 total = (pResource->ulEnd - pResource->ulStart) + 1; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } hGPIO->pRegs = (LPC11Axx_GPIO_REGS *) pResource->ulStart; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } //Error = BT_EnableInterrupt(pResource->ulStart); Error = BT_RegisterGpioController(base, total, hGPIO); if(Error) { goto err_free_out; } return hGPIO; err_free_out: BT_DestroyHandle(hGPIO); if(pError) { *pError = Error; } err_out: return NULL; }
static BT_HANDLE timer_register_callback(BT_HANDLE hTimer, BT_TIMER_CALLBACK pfnCallback, void *pParam, BT_ERROR *pError) { struct _TIMER_CALLBACK_HANDLE *pCallback = (struct _TIMER_CALLBACK_HANDLE*)BT_CreateHandle(&oCallbackHandleInterface, sizeof(struct _TIMER_CALLBACK_HANDLE),pError); if (pCallback) { pCallback->pfnCallback = pfnCallback; pCallback->pParam = pParam; hTimer->pCallback = pCallback; } return (BT_HANDLE)pCallback; }
static BT_HANDLE mcpwm_register_callback(BT_HANDLE hMCPWM, BT_MCPWM_CALLBACK pfnCallback, void *pParam, BT_ERROR *pError) { struct _MCPWM_CALLBACK_HANDLE *pCallback = (struct _MCPWM_CALLBACK_HANDLE*)BT_CreateHandle(&oCallbackHandleInterface, sizeof(struct _MCPWM_CALLBACK_HANDLE),pError); if (pCallback) { pCallback->pfnCallback = pfnCallback; pCallback->pParam = pParam; hMCPWM->pCallback = pCallback; } return (BT_HANDLE)pCallback; }
static BT_HANDLE nvic_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error; if(g_hActiveHandle) { if(pError) { *pError = BT_ERR_GENERIC; } return NULL; } BT_HANDLE hNVIC = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hNVIC) { goto err_out; } const BT_RESOURCE *pResource; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_chip; } hNVIC->pRegs = (NVIC_REGS *) pResource->ulStart; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_chip; } BT_u32 base, total; base = pResource->ulStart; total = (pResource->ulEnd - pResource->ulStart) + 1; Error = BT_RegisterInterruptController(base, total, hNVIC); if(Error) { goto err_free_chip; } return hNVIC; err_free_chip: BT_DestroyHandle(hNVIC); if(pError) { *pError = Error; } err_out: return hNVIC; }
static BT_HANDLE timer_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hTimer = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hTimer) { Error = BT_ERR_NO_MEMORY; goto err_out; } const BT_RESOURCE *pResource; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } hTimer->pRegs = (SYSTICK_REGS *) pResource->ulStart; hTimer->pRegs->CTRL &= ~0x04; hTimer->pRegs->CTRL |= BT_CONFIG_ARCH_ARM_SYSTICK_CLKSRC; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* * In normal timer drivers we might register the interrupt here. * By default we want the linker to patch our vector table for us * and therefore its up to the Kernel to override the * correct symbol name... i.e. BT_NVIC_SysTick_Handler * */ return hTimer; err_free_out: BT_DestroyHandle(hTimer); err_out: if(pError) { *pError = Error; } return NULL; }
int socket(int domain, int type, int protocol) { if(!BT_isNetworkingReady()) { return -1; } BT_ERROR Error; BT_HANDLE hSocket = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!hSocket) { return 0; } hSocket->socket = lwip_socket(domain, type, protocol); return (int)hSocket; }
static struct _MII_HANDLE* mii_init(BT_HANDLE hMac, BT_ERROR *pError) { struct _MII_HANDLE *pMII = (struct _MII_HANDLE *) BT_CreateHandle(&oMIIHandleInterface, sizeof(struct _MII_HANDLE), pError); if(!pMII) { if(pError) { *pError = BT_ERR_NO_MEMORY; } return NULL; } hMac->hMII = (BT_HANDLE) pMII; pMII->mii.hMAC = hMac; pMII->mii.name = "LM3Sxx mac-mii bus"; return pMII; }
int accept(int s, struct sockaddr *addr, socklen_t *addrlen) { BT_HANDLE hSocket = (BT_HANDLE)s; int new_socket = lwip_accept(hSocket->socket, addr, addrlen); if(new_socket) { BT_ERROR Error; BT_HANDLE h = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!h) { lwip_close(new_socket); return 0; } h->socket = new_socket; return (int)h; } return 0; }
static BT_HANDLE ext2_open_inode(BT_HANDLE hMount, const BT_i8 *szpPath, BT_ERROR *pError) { if(!hMount) { if(pError) *pError = BT_ERR_GENERIC; goto err_out; } BT_EXT2_INODE *pInode = (BT_EXT2_INODE *) BT_CreateHandle(&oInodeHandleInterface, sizeof(BT_EXT2_INODE), pError); if(!pInode) { *pError = BT_ERR_NO_MEMORY; goto err_out; } pInode->pMount = (BT_EXT2_MOUNT *)hMount; pInode->szpPath = szpPath; return (BT_HANDLE) pInode; err_out: return NULL; }
static BT_HANDLE fullfat_open(BT_HANDLE hMount, const BT_i8 *szpPath, BT_u32 ulModeFlags, BT_ERROR *pError) { FF_ERROR ffError; BT_FF_FILE *pFile = (BT_FF_FILE *) BT_CreateHandle(&oFileHandleInterface, sizeof(BT_FF_FILE), pError); if(!pFile) { return NULL; } BT_FF_MOUNT *pMount = (BT_FF_MOUNT *) hMount; pFile->pFile = FF_Open(pMount->pIoman, szpPath, FF_MODE_READ, &ffError); if(!pFile->pFile) { return NULL; } pFile->pMount = pMount; return (BT_HANDLE) pFile; }
static BT_HANDLE ext2_mount(BT_HANDLE hFS, BT_HANDLE hVolume, const void *data, BT_ERROR *pError) { if(!hFS || !hVolume) { if(pError) *pError = BT_ERR_GENERIC; goto err_out; } BT_EXT2_MOUNT *pMount = (BT_EXT2_MOUNT *) BT_CreateHandle(&oHandleInterface, sizeof(BT_EXT2_MOUNT), pError); if(!pMount) { *pError = BT_ERR_NO_MEMORY; goto err_out; } pMount->hVolume = hVolume; ext2fs_set_readblocks(ext2_readblocks, hVolume); if(ext2fs_mount(0) < 0) { if(pError) *pError = BT_ERR_GENERIC; goto err_free_out; } return (BT_HANDLE) pMount; err_free_out: BT_DestroyHandle((BT_HANDLE)pMount); err_out: return NULL; }
static BT_HANDLE ext2_open(BT_HANDLE hMount, const BT_i8 *szpPath, BT_u32 ulModeFlags, BT_ERROR *pError) { if(!hMount) { if(pError) *pError = BT_ERR_GENERIC; goto err_out; } BT_EXT2_FILE *pFile = (BT_EXT2_FILE *) BT_CreateHandle(&oFileHandleInterface, sizeof(BT_EXT2_FILE), pError); if(!pFile) { *pError = BT_ERR_NO_MEMORY; goto err_out; } pFile->pMount = (BT_EXT2_MOUNT *)hMount; if(ext2fs_open((char *)szpPath) < 0) { if(pError) *pError = BT_ERR_GENERIC; goto err_free_out; } return (BT_HANDLE) pFile; err_free_out: BT_DestroyHandle((BT_HANDLE)pFile); err_out: return NULL; }
static BT_HANDLE fullfat_open_inode(BT_HANDLE hMount, const BT_i8 *szpPath, BT_ERROR *pError) { BT_FF_INODE *pInode = (BT_FF_INODE *) BT_CreateHandle(&oInodeHandleInterface, sizeof(BT_FF_INODE), pError); if(!pInode) { goto err_out; } BT_FF_MOUNT *pMount = (BT_FF_MOUNT *) hMount; FF_ERROR ffError = FF_FindFirst(pMount->pIoman, &pInode->oDirent, szpPath); if(ffError) { goto err_free_out; } pInode->pMount = pMount; return (BT_HANDLE) pInode; err_free_out: BT_DestroyHandle((BT_HANDLE)pInode); err_out: return NULL; }
static BT_HANDLE timer_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hTimer = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_ENUM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } if (g_TIMER_HANDLES[pResource->ulStart]){ Error = BT_ERR_GENERIC; goto err_free_out; } hTimer = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hTimer) { goto err_out; } g_TIMER_HANDLES[pResource->ulStart] = hTimer; hTimer->pDevice = pDevice; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hTimer->pRegs = (LM3Sxx_TIMER_REGS *) pResource->ulStart; TimerSetPowerState(hTimer, BT_POWER_STATE_AWAKE); ResetTimer(hTimer); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* On NVIC we don't need to register interrupts, LINKER has patched vector for us * Error = BT_RegisterInterrupt(pResource->ulStart, timer_irq_handler, hTimer); if(Error) { goto err_free_out; }*/ Error = BT_EnableInterrupt(pResource->ulStart); return hTimer; err_free_out: BT_kFree(hTimer); err_out: if(pError) { *pError = Error; } return NULL; }
static BT_HANDLE gic_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error; if(g_hActiveHandle) { if(pError) { *pError = BT_ERR_GENERIC; } return NULL; } BT_HANDLE hGic = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hGic) { goto err_out; } const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_chip; } hGic->pGICC = (GICC_REGS *) bt_ioremap((void *)pResource->ulStart, BT_SIZE_4K); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 1); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_chip; } hGic->pGICD = (GICD_REGS *) bt_ioremap((void *)pResource->ulStart, BT_SIZE_4K); // Set private members. pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_chip; } BT_u32 base = pResource->ulStart; BT_u32 total = (pResource->ulEnd - pResource->ulStart) + 1; hGic->ulBaseIRQ = base; BT_u32 i; for(i = 0; i < total; i++) { g_oVectorTable[i].pfnHandler = gic_stubhandler; g_oVectorTable[i].pParam = NULL; } Error = BT_RegisterInterruptController(base, total, hGic); if(Error) { goto err_free_chip; } g_hActiveHandle = hGic; // Enable the Distributor and CPU interfaces. BT_u32 ulGicIRQs = (hGic->pGICD->TYPER & 0x1F); ulGicIRQs = (ulGicIRQs + 1) * 32; /* * GIC can support a mximum 1020 IRQs. */ if(ulGicIRQs > 1020) { ulGicIRQs = 1020; } hGic->ulGicIRQs = ulGicIRQs; //#ifdef BT_CONFIG_ARCH_ARM_GIC_INIT_DISTRIBUTOR gic_dist_init(hGic); //#endif gic_cpu_init(hGic); return hGic; err_free_chip: BT_DestroyHandle(hGic); if(pError) { *pError = Error; } err_out: return NULL; }
static BT_HANDLE i2c_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hI2C = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hI2C = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hI2C) { goto err_out; } hI2C->pRegs = (LPC11xx_I2C_REGS *) pResource->ulStart; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_ENUM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hI2C->i2c_master.pDevice = pDevice; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_INTEGER, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } i2cSetPowerState(hI2C, BT_POWER_STATE_AWAKE); // Reset all registers to their defaults! ResetI2C(hI2C); i2cEnable(hI2C); i2c_set_clock_rate(hI2C, pResource->ulStart); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* On NVIC we don't need to register interrupts, LINKER has patched vector for us * Error = BT_RegisterInterrupt(pResource->ulStart, I2C_irq_handler, hI2C); if(Error) { goto err_free_out; }*/ //@@Error = BT_EnableInterrupt(pResource->ulStart); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_BUSID, 0); if(!pResource) { goto err_free_out; } BT_u32 ulBusID = pResource->ulStart; hI2C->i2c_master.ulBusID = ulBusID; hI2C->i2c_master.hBus = hI2C; // Save pointer to bus's private data. hI2C->i2c_master.pDevice = pDevice; BT_I2C_RegisterBus(&hI2C->i2c_master); if(pError) { *pError = Error; } return hI2C; err_free_out: BT_DestroyHandle(hI2C); err_out: if(pError) { *pError = Error; } return NULL; }
static BT_HANDLE uart_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hUart = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_ENUM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } if (g_USART_HANDLES[pResource->ulStart]){ Error = BT_ERR_GENERIC; goto err_free_out; } hUart = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hUart) { goto err_out; } g_USART_HANDLES[pResource->ulStart] = hUart; hUart->pDevice = pDevice; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hUart->pRegs = (LM3Sxx_UART_REGS *) pResource->ulStart; uartSetPowerState(hUart, BT_POWER_STATE_AWAKE); // Reset all registers to their defaults! ResetUart(hUart); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* On NVIC we don't need to register interrupts, LINKER has patched vector for us * Error = BT_RegisterInterrupt(pResource->ulStart, uart_irq_handler, hUart); if(Error) { goto err_free_out; }*/ BT_SetInterruptPriority(pResource->ulStart, ((0x01 << BT_CONFIG_MACH_PRIORITY_BITS)-1)); Error = BT_EnableInterrupt(pResource->ulStart); return hUart; err_free_out: BT_DestroyHandle(hUart); err_out: if(pError) { *pError = Error; } return NULL; }
static BT_HANDLE can_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hCan = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_ENUM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } if (g_CAN_HANDLES[pResource->ulStart]){ Error = BT_ERR_GENERIC; goto err_free_out; } hCan = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hCan) { goto err_out; } g_CAN_HANDLES[pResource->ulStart] = hCan; hCan->pDevice = pDevice; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hCan->pRegs = (LPC17xx_CAN_REGS *) pResource->ulStart; canSetPowerState(hCan, BT_POWER_STATE_AWAKE); // Reset all registers to their defaults! canDisable(hCan); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* On NVIC we don't need to register interrupts, LINKER has patched vector for us * Error = BT_RegisterInterrupt(pResource->ulStart, uart_irq_handler, hCan); if(Error) { goto err_free_out; }*/ Error = BT_EnableInterrupt(pResource->ulStart); return hCan; err_free_out: BT_DestroyHandle(hCan); err_out: if(pError) { *pError = Error; } return NULL; }
static BT_HANDLE gpio_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_u32 i; BT_ERROR Error; if(pError) { *pError = BT_ERR_NONE; } BT_HANDLE hGPIO = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hGPIO) { goto err_out; } const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IO, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } BT_u32 base = pResource->ulStart; BT_u32 total = (pResource->ulEnd - pResource->ulStart) + 1; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } hGPIO->pRegs = (ZYNQ_GPIO_REGS *) pResource->ulStart; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } Error = BT_RegisterInterrupt(pResource->ulStart, gpio_irq_handler, hGPIO); if(Error) { goto err_free_out; } // Prevent Pending Interrupts for(i = 0; i < total; i += 32) { hGPIO->pRegs->bank[i/32].INT_DIS = 0xFFFFFFFF; } Error = BT_EnableInterrupt(pResource->ulStart); Error = BT_RegisterGpioController(base, total, hGPIO); if(Error) { goto err_free_irq; } return hGPIO; err_free_irq: BT_UnregisterInterrupt(pResource->ulStart, gpio_irq_handler, hGPIO); err_free_out: BT_DestroyHandle(hGPIO); if(pError) { *pError = Error; } err_out: return NULL; }
static BT_HANDLE i2c_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hI2C = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_INVALID_RESOURCE; goto err_out; } hI2C = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hI2C) { Error = BT_ERR_NO_MEMORY; goto err_out; } hI2C->pRegs = (ZYNQ_I2C_REGS *) bt_ioremap((void *)pResource->ulStart, BT_SIZE_4K); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_INVALID_RESOURCE; goto err_free_out; } BT_u32 ulIRQ = pResource->ulStart; Error = BT_RegisterInterrupt(ulIRQ, i2c_irq_handler, hI2C); if(Error) { Error = BT_ERR_GENERIC; // Device already in use! goto err_free_out; } BT_EnableInterrupt(ulIRQ); hI2C->pDevice = pDevice; i2c_set_clock_rate(hI2C, BT_I2C_CLOCKRATE_400kHz); hI2C->pMutex = BT_kMutexCreate(); if(!hI2C->pMutex) { Error = BT_ERR_NO_MEMORY; goto err_free_int_out; } BT_kMutexPend(hI2C->pMutex, 0); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_BUSID, 0); if(!pResource) { Error = BT_ERR_INVALID_RESOURCE; goto err_free_int_out; } BT_u32 ulBusID = pResource->ulStart; hI2C->pRegs->CONTROL |= 0x0000000E; BT_I2C_RegisterBusWithID(hI2C, ulBusID); if(pError) { *pError = Error; } return hI2C; err_free_int_out: BT_UnregisterInterrupt(ulIRQ, i2c_irq_handler, hI2C); err_free_out: BT_DestroyHandle(hI2C); err_out: if(pError) { *pError = Error; } return NULL; }
static BT_HANDLE pwm_probe(const BT_INTEGRATED_DEVICE *pDevice, BT_ERROR *pError) { BT_ERROR Error = BT_ERR_NONE; BT_HANDLE hPwm = NULL; const BT_RESOURCE *pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_ENUM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } if (g_PWM_HANDLES[pResource->ulStart]){ Error = BT_ERR_GENERIC; goto err_free_out; } hPwm = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), pError); if(!hPwm) { goto err_out; } hPwm->id = pResource->ulStart; g_PWM_HANDLES[pResource->ulStart] = hPwm; hPwm->pDevice = pDevice; pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_MEM, 0); if(!pResource) { Error = BT_ERR_NO_MEMORY; goto err_free_out; } hPwm->pRegs = (LPC17xx_PWM_REGS *) pResource->ulStart; PwmSetPowerState(hPwm, BT_POWER_STATE_AWAKE); ResetPwm(hPwm); pResource = BT_GetIntegratedResource(pDevice, BT_RESOURCE_IRQ, 0); if(!pResource) { Error = BT_ERR_GENERIC; goto err_free_out; } /* On NVIC we don't need to register interrupts, LINKER has patched vector for us * Error = BT_RegisterInterrupt(pResource->ulStart, pwm_irq_handler, hPwm); if(Error) { goto err_free_out; }*/ Error = BT_EnableInterrupt(pResource->ulStart); return hPwm; err_free_out: BT_DestroyHandle(hPwm); err_out: if(pError) { *pError = Error; } return NULL; }