DIBSTATUS DibDriverGetMonitoringDabAudio(struct DibDriverContext * pContext, ELEM_HDL ItemHdl, union DibDataMonit * pDataMonit, uint8_t ClearMonit) { struct DibDabMonitoring * pDabMonit = (struct DibDabMonitoring *) pDataMonit; struct DibDriverDabAudioServiceCtx * pService; FILTER_HDL FilterHdl = pContext->ItemInfo[ItemHdl].ParentFilter; DIB_ASSERT(pDabMonit); DIB_ASSERT(ItemHdl < DIB_MAX_NB_ITEMS); DIB_ASSERT(pContext->FilterInfo[FilterHdl].TypeFilter == eDAB); DIB_ASSERT(((ClearMonit == eDIB_TRUE) || (ClearMonit == eDIB_FALSE))); DIB_DEBUG(SOFT_IF_LOG, (CRB "DibDriverGetMonitoringDabAudio" CRA)); #if (LOG_APPLICATION_TO_DRIVER_CALLS_TO_FILE == 1) { DibLogToFile_Time(gLogFile, gLogFileStartTimeSec, gLogFileStartTimeMsec); DibLogToFile_Mesg(gLogFile, CRB "DibDriverGetMonitoringDabAudio" CRA); } #endif DibDriverTargetDisableIrqProcessing(pContext); pService = pContext->ItemInfo[ItemHdl].ItemCtx.pDabAudioService; if(pDabMonit) { /*** Initialize DAB Monitoring structure ***/ DibZeroMemory(pDabMonit, sizeof(struct DibDabMonitoring)); pDabMonit->NbPid = 0; pDabMonit->ChannelIndex = pContext->FilterInfo[pContext->ItemInfo[ItemHdl].ParentFilter].ParentChannel; pDabMonit->FilterIndex = FilterHdl; pDabMonit->FilterType = pContext->FilterInfo[FilterHdl].TypeFilter; if(pService) { pDabMonit->CountinuityError = pService->DabMonitoring.CountinuityError; pDabMonit->Error = pService->DabMonitoring.Error; pDabMonit->TotalPackets = pService->DabMonitoring.TotalPackets; pDabMonit->CorrPackets = pService->DabMonitoring.CorrectedPackets; /* Protected access to shared ressource, clear error and cc counts */ if(ClearMonit == eDIB_TRUE) DibZeroMemory(&pService->DabMonitoring, sizeof(pService->DabMonitoring)); } } DibDriverTargetEnableIrqProcessing(pContext); /* Send Message to clear internal monitoring info is sent separatly to avoid dead locks */ if((pService) && (ClearMonit == eDIB_TRUE)) DibDriverClearMonit(pContext, ItemHdl); return DIBSTATUS_SUCCESS; }
U8 dib_init() { struct dibI2CAdapter *i2c = open_dibcom_i2c(); DibZeroMemory(mon, sizeof(mon)); if (i2c == NULL) return 1; #ifdef DIB7000_DEMOD_7070Q // if (dib7070q_attach(i2c, DIB7070PA_DEFAULT_I2C_ADDRESS, &tfe7070q_config) != DIB_RETURN_SUCCESS) if ((sip = dib7070q_attach(i2c, DIB7070PA_DEFAULT_I2C_ADDRESS, &tfe7070q_config)) == NULL) #endif #ifdef DIB7000_DEMOD_7070P if (dib7070pa_attach(i2c, NUM_OF_DEMOD, DIB7070PA_DEFAULT_I2C_ADDRESS, nim7070p_config, sip) != DIB_RETURN_SUCCESS) #endif #ifdef DIB7000_DEMOD_7070M if (dib7070ma_attach(i2c, NUM_OF_DEMOD, DIB7070MA_DEFAULT_I2C_ADDRESS, nim7070md_config, sip) != DIB_RETURN_SUCCESS) #endif { DibDbgPrint("-E- DiB7070P: attaching demod and tuners failed.\n"); return 1; } return 0; }
/**************************************************************************** * Init the bridge from the driver ****************************************************************************/ DIBSTATUS DibDriverTargetInit(struct DibDriverContext *pContext) { struct IoctlInit pReq; if((pContext->DriverTargetCtx.BridgeFd = open(DEVICE_FILE_NAME, O_RDWR)) < 0) { DIB_DEBUG(PORT_ERR, (CRB "Could not open device %s" CRA, DEVICE_FILE_NAME)); return DIBSTATUS_ERROR; } /* this will create and initialise bridge */ pReq.BoardHdl = pContext->BoardHdl; pReq.ChipSelect = pContext->DibChip; #if (USE_DRAGONFLY == 1) if((pContext->DibChip == DIB_VOYAGER) || (pContext->DibChip == DIB_NAUTILUS)) { pReq.Config[0] = pContext->DragonflyRegisters.JedecAddr; pReq.Config[1] = pContext->DragonflyRegisters.JedecValue; pReq.Config[2] = pContext->DragonflyRegisters.MacMbxSize; pReq.Config[3] = pContext->DragonflyRegisters.MacMbxStart; pReq.Config[4] = pContext->DragonflyRegisters.MacMbxEnd; pReq.Config[5] = pContext->DragonflyRegisters.HostMbxSize; pReq.Config[6] = pContext->DragonflyRegisters.HostMbxStart; pReq.Config[7] = pContext->DragonflyRegisters.HostMbxEnd; pReq.Config[8] = pContext->DragonflyRegisters.HostMbxRdPtrReg; pReq.Config[9] = pContext->DragonflyRegisters.HostMbxWrPtrReg; pReq.Config[10] = pContext->DragonflyRegisters.MacMbxRdPtrReg; pReq.Config[11] = pContext->DragonflyRegisters.MacMbxWrPtrReg; } else #endif DibZeroMemory(pReq.Config, sizeof(pReq.Config)); if(ioctl(pContext->DriverTargetCtx.BridgeFd, REQUEST_BRIDGE_MODULE_INIT, &pReq) != DIBSTATUS_SUCCESS) { DIB_DEBUG(PORT_ERR, (CRB "Could initialise Bridge %s" CRA, DEVICE_FILE_NAME)); /* close open device and free allocated memory*/ close(pContext->DriverTargetCtx.BridgeFd); return DIBSTATUS_ERROR; } DibAllocateEvent(&pContext->DriverTargetCtx.IrqReadDone); DibInitNotificationEvent(&pContext->DriverTargetCtx.IrqReadDone); DibAllocateLock(&pContext->DriverTargetCtx.IrqLock); DibInitLock(&pContext->DriverTargetCtx.IrqLock); DIB_DEBUG(PORT_LOG, (CRB "Launching interrupt thread" CRA)); pthread_create(&pContext->DriverTargetCtx.IrqThread, NULL, IntDriverTargetIrqRead, (void *)pContext); DibWaitForEvent(&pContext->DriverTargetCtx.IrqReadDone, 0); return DIBSTATUS_SUCCESS; }
DIBSTATUS DibDriverGetMonitoringDabPacket(struct DibDriverContext * pContext, ELEM_HDL ItemHdl, union DibDataMonit * pDataMonit, uint8_t ClearMonit) { struct DibDabPacketMonitoring * pMonit = (struct DibDabPacketMonitoring *) pDataMonit; FILTER_HDL FilterHdl = pContext->ItemInfo[ItemHdl].ParentFilter; struct DibDriverDabPacketServiceCtx * pService; DIB_ASSERT(pMonit); DIB_ASSERT(ItemHdl < DIB_MAX_NB_ITEMS); DIB_ASSERT(pContext->FilterInfo[FilterHdl].TypeFilter == eDABPACKET); DIB_ASSERT(((ClearMonit == eDIB_TRUE) || (ClearMonit == eDIB_FALSE))); DibDriverTargetDisableIrqProcessing(pContext); pService = pContext->ItemInfo[ItemHdl].ItemCtx.pDabPacketService; if(pMonit) { /*** Initialize DAB Monitoring structure ***/ DibZeroMemory(pMonit, sizeof(struct DibDabPacketMonitoring)); pMonit->ChannelIndex = pContext->FilterInfo[pContext->ItemInfo[ItemHdl].ParentFilter].ParentChannel; pMonit->FilterIndex = FilterHdl; if(pService) { pMonit->MscPacketGood = pService->DabPacketMonitoring.MscPacketGood; pMonit->MscPacketsError = pService->DabPacketMonitoring.MscPacketsError; pMonit->DataGroupGood = pService->DabPacketMonitoring.DataGroupGood; pMonit->DataGroupError = pService->DabPacketMonitoring.DataGroupError; /* Protected access to shared ressource, clear error */ if(ClearMonit == eDIB_TRUE) DibZeroMemory(&pService->DabPacketMonitoring, sizeof(pService->DabPacketMonitoring)); } } DibDriverTargetEnableIrqProcessing(pContext); /* Send Message to clear internal monitoring info is sent separatly to avoid dead locks */ if((pService) && (ClearMonit == eDIB_TRUE)) DibDriverClearMonit(pContext, ItemHdl); DIB_DEBUG(SOFT_IF_LOG, (CRB "DibDriverGetDabPacketMonitoring %d" CRA, pMonit->FilterIndex)); return DIBSTATUS_SUCCESS; }
DIBSTATUS DibDriverGetMonitoringTdmb(struct DibDriverContext * pContext, ELEM_HDL ItemHdl, union DibDataMonit * pDataMonit, uint8_t ClearMonit) { struct DibDabMonitoring *pDabMonit = (struct DibDabMonitoring *) pDataMonit; FILTER_HDL FilterHdl = pContext->ItemInfo[ItemHdl].ParentFilter; struct DibDriverFilter *pFilter = &pContext->FilterInfo[FilterHdl]; DIB_ASSERT(pDabMonit); DIB_ASSERT(ItemHdl < DIB_MAX_NB_ITEMS); DIB_ASSERT(pContext->FilterInfo[FilterHdl].TypeFilter == eTDMB); DIB_ASSERT(((ClearMonit == eDIB_TRUE) || (ClearMonit == eDIB_FALSE))); DIB_DEBUG(SOFT_IF_LOG, (CRB "DibDriverGetTdmbMonitoring %d %u" CRA, FilterHdl, pFilter->DvbTMonitoring.TotalPackets)); DibDriverTargetDisableIrqProcessing(pContext); /* Set external DVB-T/TDMB monitoring info */ pDabMonit->FilterIndex = FilterHdl; pDabMonit->FilterType = pContext->FilterInfo[FilterHdl].TypeFilter; pDabMonit->NbPid = pFilter->NbActivePids; pDabMonit->ChannelIndex = pFilter->ParentChannel; /* checker of the bridge activated */ if(pFilter->DvbTMonitoring.CheckTotalPackets) pDabMonit->TotalPackets = pFilter->DvbTMonitoring.CheckTotalPackets; else pDabMonit->TotalPackets = pFilter->DvbTMonitoring.TotalPackets; pDabMonit->CountinuityError = pFilter->DvbTMonitoring.CheckCcFailCnt; pDabMonit->Error = pFilter->DvbTMonitoring.ErrCnt; if(ClearMonit == eDIB_TRUE) { /* Clear Driver monitoring info */ DibZeroMemory(&pFilter->DvbTMonitoring, sizeof(struct DvbTMonit)); } DibDriverTargetEnableIrqProcessing(pContext); if(ClearMonit == eDIB_TRUE) { /* Clear Firmware and Bridge monitoring info */ DibDriverClearMonit(pContext, ItemHdl); } return DIBSTATUS_SUCCESS; }
DIBSTATUS DibDriverDragonflyAddItemMpeIFec(struct DibDriverContext *pContext, union DibFilters *pFilterDesc, FILTER_HDL FilterHdl, uint32_t ItemHdl, struct MsgCreateItem * msg) { struct DibDriverMpeIFecServiceCtx *pMpeIFecService; struct DibDriverItem *pItem; msg->Param.Mpeifec.Pid = pFilterDesc->MpeIFec.Pid; msg->Param.Mpeifec.MaxBurstDuration = pFilterDesc->MpeIFec.MaxBurstDuration; msg->Param.Mpeifec.Prefetch = pFilterDesc->MpeIFec.Prefetch; msg->Param.Mpeifec.B = pFilterDesc->MpeIFec.EncodParal; msg->Param.Mpeifec.C = pFilterDesc->MpeIFec.NbAdstColumns; msg->Param.Mpeifec.S = pFilterDesc->MpeIFec.SpreadingFactor; msg->Param.Mpeifec.R = pFilterDesc->MpeIFec.MaxIFecSect; msg->Param.Mpeifec.D = pFilterDesc->MpeIFec.SendingDelay; pMpeIFecService = (struct DibDriverMpeIFecServiceCtx *) DibMemAlloc(sizeof(struct DibDriverMpeIFecServiceCtx)); pItem = &pContext->ItemInfo[ItemHdl]; pItem->ItemCtx.pMpeIFecService = pMpeIFecService; if(pMpeIFecService == NULL) { DIB_DEBUG(SOFT_IF_ERR, (CRB "IntDriverAddPid: no memory for MPE-IFEC service" CRA)); return DIBSTATUS_ERROR; } pMpeIFecService->RsNumRows = pFilterDesc->MpeIFec.NbRows; pMpeIFecService->Pid = pFilterDesc->MpeIFec.Pid; pMpeIFecService->OnlyIfPrioritaryChannel = pContext->ChannelInfo[pContext->FilterInfo[FilterHdl].ParentChannel].IsDataChannel; pMpeIFecService->MaxBurstDuration = pFilterDesc->MpeIFec.MaxBurstDuration; /* TBD_IF */ DibZeroMemory(&pMpeIFecService->DvbSHMonitoring, sizeof(struct DvbSHMonit)); pContext->FilterInfo[FilterHdl].NbActivePids++; return DIBSTATUS_SUCCESS; }
/** * Get MpeIFec Data monitoring * @param[in] pContext: driver context * @param[in] ItemHdl: filter item handler. * @param[out] pDVBMonit: DVB-SH monitoring information of the corresponding item * @param[in] ClearMonit: Reset internal monitoring information after retreiving them. */ DIBSTATUS DibDriverGetMonitoringMpeIFec(struct DibDriverContext *pContext, ELEM_HDL ItemHdl, union DibDataMonit *pDataMonit, uint8_t ClearMonit) { struct DibDvbSHMonitoring *pDvbSHMonit = (struct DibDvbSHMonitoring *) pDataMonit; struct DibDriverMpeIFecServiceCtx *pMpeIFecService; /* Points to MPE service context if target MPE. pMpeService_CONTEXT*/ FILTER_HDL FilterHdl = pContext->ItemInfo[ItemHdl].ParentFilter; DIB_ASSERT(pDvbSHMonit); DIB_ASSERT(ItemHdl < DIB_MAX_NB_ITEMS); DIB_ASSERT(pContext->FilterInfo[FilterHdl].TypeFilter == eMPEIFEC); DIB_ASSERT(((ClearMonit == eDIB_TRUE) || (ClearMonit == eDIB_FALSE))); DIB_DEBUG(SOFT_IF_LOG, (CRB "DibDriverGetDVBSHMonitoring" CRA)); #if (LOG_APPLICATION_TO_DRIVER_CALLS_TO_FILE == 1) { DibLogToFile_Time(gLogFile, gLogFileStartTimeSec, gLogFileStartTimeMsec); DibLogToFile_Mesg(gLogFile, CRB "DibDriverGetDVBSHMonitoring" CRA); } #endif DibDriverTargetDisableIrqProcessing(pContext); pMpeIFecService = pContext->ItemInfo[ItemHdl].ItemCtx.pMpeIFecService; if(pMpeIFecService) { if(pDvbSHMonit) { /*** Initialize DVBH Monitoring structure ***/ DibZeroMemory(pDvbSHMonit, sizeof(struct DibDvbSHMonitoring)); pDvbSHMonit->Pid = pContext->ItemInfo[ItemHdl].Config.MpeIFec.Pid; pDvbSHMonit->ChannelIndex = pContext->FilterInfo[pContext->ItemInfo[ItemHdl].ParentFilter].ParentChannel; pDvbSHMonit->FilterIndex = FilterHdl; pDvbSHMonit->NbRows = pContext->ItemInfo[ItemHdl].Config.MpeIFec.NbRows; pDvbSHMonit->EncodParal = pContext->ItemInfo[ItemHdl].Config.MpeIFec.EncodParal; pDvbSHMonit->SpreadingFactor = pContext->ItemInfo[ItemHdl].Config.MpeIFec.SpreadingFactor; pDvbSHMonit->SendingDelay = pContext->ItemInfo[ItemHdl].Config.MpeIFec.SendingDelay; pDvbSHMonit->NbAdstColumns = pContext->ItemInfo[ItemHdl].Config.MpeIFec.NbAdstColumns; pDvbSHMonit->MaxIFecSect = pContext->ItemInfo[ItemHdl].Config.MpeIFec.MaxIFecSect; pDvbSHMonit->AdstTotalTables = pMpeIFecService->DvbSHMonitoring.AdstTotalTables; pDvbSHMonit->AdstTablesLost = pMpeIFecService->DvbSHMonitoring.AdstTablesLost; pDvbSHMonit->AdstTablesCorrected = pMpeIFecService->DvbSHMonitoring.AdstTablesCorrected; pDvbSHMonit->AdstTablesFailed = pMpeIFecService->DvbSHMonitoring.AdstTablesFailed; pDvbSHMonit->AdstTablesGood = pMpeIFecService->DvbSHMonitoring.AdstTablesGood; pDvbSHMonit->AdtTotalTables = pMpeIFecService->DvbSHMonitoring.AdtTotalTables; pDvbSHMonit->AdtTablesCorrected = pMpeIFecService->DvbSHMonitoring.AdtTablesCorrected; pDvbSHMonit->AdtTablesFailed = pMpeIFecService->DvbSHMonitoring.AdtTablesFailed; pDvbSHMonit->AdtTablesGood = pMpeIFecService->DvbSHMonitoring.AdtTablesGood; pDvbSHMonit->DeltaTStream = pMpeIFecService->DvbSHMonitoring.DeltaTStream; pDvbSHMonit->DeltaTDetected = pMpeIFecService->DvbSHMonitoring.DeltaTDetected; pDvbSHMonit->BurstStream = pMpeIFecService->DvbSHMonitoring.BurstStream; pDvbSHMonit->BurstDetected = pMpeIFecService->DvbSHMonitoring.BurstDetected; pDvbSHMonit->PowerUpTime = pMpeIFecService->DvbSHMonitoring.PowerUpTime; pDvbSHMonit->CountinuityError = pMpeIFecService->DvbSHMonitoring.CcFailCnt; pDvbSHMonit->Error = pMpeIFecService->DvbSHMonitoring.ErrCnt; } /* Protected access to shared ressource, clear error and cc counts */ if(ClearMonit) DibZeroMemory(&pMpeIFecService->DvbSHMonitoring, sizeof(pMpeIFecService->DvbSHMonitoring)); } DibDriverTargetEnableIrqProcessing(pContext); /* Send Message to clear internal monitoring info is sent separatly to avoid dead locks */ if((pMpeIFecService) && (ClearMonit == eDIB_TRUE)) DibDriverClearMonit(pContext, ItemHdl); return DIBSTATUS_SUCCESS; }
/* example of creating all the demod-structure and tuner-structures and tuning them in diversity and start monitoring after that */ int main(int argc, char *argv[]) { struct dibI2CAdapter *main_i2c = open_spp_i2c(); struct dibI2CAdapter *tuner_i2c[2]; struct dibDemod *demod[2]; struct dibTuner *tuner[2]; struct dibDemodMonitor mon[2]; struct dibDVBChannel ch; DibZeroMemory(mon, sizeof(mon)); if (main_i2c == NULL) return 1; /* attach 2 demods, do i2c-enumeration */ if (dib7000p_attach(main_i2c, 2, DEFAULT_DIB7000P_I2C_ADDRESS, 1, dib7000p_example_board_config, demod) != 0) { DibDbgPrint("-E- dib7000 attaching and i2c enumeration failed.\n"); exit(1); } /* first tuner */ tuner_i2c[0] = dib7000p_get_i2c_master(demod[0], DIBX000_I2C_INTERFACE_TUNER, 1); if ((tuner[0] = env57h12d5_attach(tuner_i2c[0], &tuner_0_config)) == NULL) { DibDbgPrint("-E- env57h12d5 -0- attaching failed.\n"); exit(1); } /* second tuner */ tuner_i2c[1] = dib7000p_get_i2c_master(demod[1], DIBX000_I2C_INTERFACE_TUNER, 1); if ((tuner[1] = env57h12d5_attach(tuner_i2c[1], &tuner_1_config)) == NULL) { DibDbgPrint("-E- env57h12d5 -1- attaching failed.\n"); exit(1); } INIT_DVB_CHANNEL(&ch); ch.RF_kHz = 474000; ch.Bw = INDEX_BW_8_0_MHZ; /* tune the 2 demods and tuner to the channel "ch" */ tune_diversity_tuner_and_demod(tuner,demod,2,&ch); DibDbgPrint("-I- Tuning done <enter>\n"); getchar(); while (1) { /* get monitoring information for the first demod */ demod_get_monitoring(demod[0], &mon[0]); /* get monitoring information for the second demod */ demod_get_monitoring(demod[1], &mon[1]); /* display information for 2 demods */ dib7000_print_monitor(mon, NULL, 0, 2); usleep(100000); } DibDbgPrint("-I- Cleaning up\n"); /* release the 2 tuners */ tuner_release(tuner[1]); tuner_release(tuner[0]); /* release the 2 demods */ demod_release(demod[1]); demod_release(demod[0]); close_spp_i2c(); return 0; }
/* example of creating all the demod-structure and tuner-structures and tuning them in diversity and start monitoring after that */ int main(int argc, char *argv[]) { struct dibI2CAdapter *main_i2c = open_spp_i2c(); struct dibI2CAdapter *tuner_i2c[2]; struct dibDemod *demod[2]; struct dibTuner *tuner[2]; struct dibDemodMonitor mon[2]; struct dibDVBChannel ch; DibZeroMemory(mon, sizeof(mon)); if (main_i2c == NULL) return 1; if (dib7000m_attach(main_i2c, 2, DEFAULT_DIB7000M_I2C_ADDRESS, 1, dib7000m_demod_config, demod) != 0) { DibDbgPrint("-E- dib7000 attaching and i2c enumeration failed.\n"); exit(1); } tuner_i2c[0] = dib7000m_get_i2c_master(demod[0], DIBX000_I2C_INTERFACE_TUNER, 1); if ((tuner[0] = env57h12d5_attach(tuner_i2c[0], &tuner_0_config)) == NULL) { DibDbgPrint("-E- env57h12d5 -0- attaching failed.\n"); exit(1); } tuner_i2c[1] = dib7000m_get_i2c_master(demod[1], DIBX000_I2C_INTERFACE_TUNER, 1); if ((tuner[1] = env57h12d5_attach(tuner_i2c[1], &tuner_1_config)) == NULL) { DibDbgPrint("-E- env57h12d5 -1- attaching failed.\n"); exit(1); } INIT_DVB_CHANNEL(&ch); ch.RF_kHz = 474000; ch.Bw = INDEX_BW_8_0_MHZ; tune_diversity_tuner_and_demod(tuner,demod,2,&ch); DibDbgPrint("-I- Tuning done <enter>\n"); getchar(); while (1) { demod_get_monitoring(demod[0], &mon[0]); demod_get_monitoring(demod[1], &mon[1]); dib7000_print_monitor(mon, NULL, 0, 2); usleep(100000); } DibDbgPrint("-I- Cleaning up\n"); tuner_release(tuner[1]); tuner_release(tuner[0]); demod_release(demod[1]); demod_release(demod[0]); close_spp_i2c(); return 0; }
/*----------------------------------------------------------------------- | Open the Device Driver -----------------------------------------------------------------------*/ static int32_t DibBridgeTargetModuleOpen(struct inode *inode, struct file *file) { int32_t status = DIBSTATUS_ERROR; struct DibBridgeContext *pBridgeContext = NULL; printk(CRB "Trying to open dibbridge.."); pBridgeContext = (struct DibBridgeContext *) DibBridgeTargetAllocBuf(sizeof(struct DibBridgeContext)); if(pBridgeContext == NULL) { printk(CRB "%s: Out of memory" CRA, __func__); return -ENOMEM; } /* Clear Content */ DibZeroMemory(pBridgeContext, sizeof(struct DibBridgeContext)); /* Allocate ptr for IOCTL request */ pBridgeContext->BridgeTargetCtx.IoctlReq = kmalloc(sizeof(struct IoctlHead), GFP_KERNEL); if(pBridgeContext->BridgeTargetCtx.IoctlReq == NULL) { printk(CRB "%s: Out of memory" CRA, __func__); status = -ENOMEM; goto End; } /* Allocate buffer for IOCTL request */ pBridgeContext->BridgeTargetCtx.IoctlReq->Buffer = kmalloc(MAX_BRIDGE_DRIVER_BUFFER, GFP_KERNEL); if(pBridgeContext->BridgeTargetCtx.IoctlReq->Buffer == NULL) { printk(CRB "%s: Out of memory" CRA, __func__); status = -ENOMEM; goto End; } /* Init IOCTL Lock */ DibAllocateLock(&pBridgeContext->BridgeTargetCtx.IoctlLock); DibInitLock(&pBridgeContext->BridgeTargetCtx.IoctlLock); status = DIBSTATUS_SUCCESS; End: if(status != DIBSTATUS_SUCCESS) { /* Free possibly allocated struct */ IntBridgeTargetModuleFreeStruct(pBridgeContext); } else { status = (int32_t)DIBSTATUS_SUCCESS; /* Store Allocated Bridge Context */ file->private_data = pBridgeContext; try_module_get(THIS_MODULE); } return status; }
void frontend_init(struct dibFrontend *fe) { DibZeroMemory(fe,sizeof(struct dibFrontend)); }
/* both demods are on the same I2C-bus by default accessible through address 18 */ int main (void) { // default I2C implementation is based on parallel port but user can connect its // own I2C driver using host_i2c_interface_attach(); // implementation is done in sample/interface/host.c //struct dibDataBusHost *i2c = host_i2c_interface_attach(NULL), *b; struct dibDataBusHost *i2c = open_spp_i2c(), *b; struct dibFrontend frontend[2]; struct dibChannel ch; struct dibDemodMonitor mon[2]; struct dibPMU *pmu; if (i2c == NULL) return 1; DibZeroMemory(&mon, sizeof(mon)); frontend_init(&frontend[0]); /* initializing the frontend-structure */ frontend_init(&frontend[1]); /* initializing the frontend-structure */ frontend_set_id(&frontend[0], 0); /* assign an absolute ID to the frontend */ frontend_set_id(&frontend[1], 1); /* assign an absolute ID to the frontend */ if (dib9090_firmware_sip_register(&frontend[0], 0x80, i2c, &nim9090md_config[0]) == NULL) { /* using a frontend on I2C address 0x80 */ dbgp(" DiB9090: attaching demod and tuners failed.\n"); return DIB_RETURN_ERROR; } i2c = dib7000m_get_i2c_master(&frontend[0], DIBX000_I2C_INTERFACE_GPIO_3_4, 0); if (dib9090_firmware_sip_register(&frontend[1], 0x82, i2c, &nim9090md_config[1]) == NULL) { /* using a frontend on I2C address 0x82 */ dbgp(" DiB9090: attaching demod and tuners failed.\n"); return DIB_RETURN_ERROR; } /* do the i2c-enumeration for 2 demod and use 0x80 as the I2C address for first device */ i2c = data_bus_client_get_data_bus(demod_get_data_bus_client(&frontend[0])); dib7000m_i2c_enumeration(i2c, 1, 0x20, 0x80); /* non-standard i2c-enumeration, because of INT_SELECT-fixation */ i2c = data_bus_client_get_data_bus(demod_get_data_bus_client(&frontend[1])); dib7000m_i2c_enumeration(i2c, 1, DEFAULT_DIB9000_I2C_ADDRESS, 0x82); b = dib7000m_get_i2c_master(&frontend[0], DIBX000_I2C_INTERFACE_GPIO_1_2, 0); if ((pmu = osiris_create(b, &nim9090md_osiris_config)) == NULL) return DIB_RETURN_ERROR; dib9090_set_pmu(&frontend[0], pmu); /* workaround because we cannot access the PMU from the host after downloading the firmware - for now */ frontend_reset(&frontend[0]); frontend_reset(&frontend[1]); INIT_CHANNEL(&ch, STANDARD_DVBT); ch.RF_kHz = 474000; ch.bandwidth_kHz = 8000; /* just to set them in a known state - not important */ tune_diversity(frontend, 2, &ch); DibDbgPrint("-I- Tuning done <enter>\n"); getchar(); while (1) { /* after enumerating on the same i2c-bus, the i2c-addresses of the bus will be 0x80 for the diversity master and 0x82 for the slave */ demod_get_monitoring(&frontend[0], &mon[0]); demod_get_monitoring(&frontend[1], &mon[1]); dib7000_print_monitor(mon, NULL, 0 ,2); usleep(100000); } DibDbgPrint("-I- Cleaning up\n"); frontend_unregister_components(&frontend[1]); frontend_unregister_components(&frontend[0]); pmu_release(pmu); //host_i2c_release(i2c); close_spp_i2c(); return 0; }