/*! \internal \brief Send an IOCTL to the parallel port driver This function sends an IOCTL to the parallel port driver. It is an internal helper function for the following functions. \param Pdx Pointer to the device extension of the driver \param Ioctl The IOCTL to perform \param InBuffer Pointer to a buffer which holds the input. This can be NULL. \param InBufferLength Length of the buffer pointed to by InBuffer. Must be 0 if InBuffer == NULL. \param OutBuffer Pointer to a buffer which will get the output. This can be NULL. \param OutBufferLength Length of the buffer pointed to by OutBuffer. Must be 0 if OutBuffer == NULL. This function must be run at IRQL == PASSIVE_LEVEL. */ static NTSTATUS ParPortIoctlInOut(IN PDEVICE_EXTENSION Pdx, IN ULONG Ioctl, IN PVOID InBuffer, IN ULONG InBufferLength, OUT PVOID OutBuffer, IN ULONG OutBufferLength) { IO_STATUS_BLOCK ioStatusBlock; NTSTATUS ntStatus; KEVENT event; // event to be signalled when the IOCTL has finished PIRP irp; FUNC_ENTER(); // Initialize the event which we will use to be notified // when the IRP has finished DBG_IRQL( == PASSIVE_LEVEL); KeInitializeEvent(&event, NotificationEvent, FALSE); ntStatus = STATUS_SUCCESS; // build an IRP for this IOCTL DBG_IRQL( == PASSIVE_LEVEL); irp = IoBuildDeviceIoControlRequest( Ioctl, Pdx->ParallelPortFdo, InBuffer, InBufferLength, OutBuffer, OutBufferLength, TRUE, // it's an internal device control &event, &ioStatusBlock ); if (irp) { PIO_STACK_LOCATION irpStack; // get the current IRP stack location DBG_IRQL( <= DISPATCH_LEVEL); irpStack = IoGetNextIrpStackLocation(irp); // Reference the file object we are about to call. // This ensures the driver is not removed while we call it, // even if the underlying hardware is removed DBG_IRQL( <= DISPATCH_LEVEL); ObReferenceObject(Pdx->ParallelPortFileObject); // tell the IRP stack location to which file object we are // referring irpStack->FileObject = Pdx->ParallelPortFileObject; // Call the driver to perform the requested IOCTL DBG_IRQL( <= DISPATCH_LEVEL); ntStatus = IoCallDriver(Pdx->ParallelPortFdo, irp); // We're done, we can dereference the file object again DBG_IRQL( <= DISPATCH_LEVEL); ObDereferenceObject(Pdx->ParallelPortFileObject); if (!NT_SUCCESS(ntStatus)) { DBG_WARN((DBG_PREFIX "IoCallDriver FAILED!")); } else { // wait for the IRP to be completed DBG_IRQL( <= DISPATCH_LEVEL /* = only if timeout of NULL */); ntStatus = KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, // we are not alertable NULL); if (!NT_SUCCESS(ntStatus)) { DBG_WARN((DBG_PREFIX "KeWaitForSingleObject FAILED!")); } } } FUNC_LEAVE_NTSTATUS(ntStatus); }
VaapiEncoderH264::~VaapiEncoderH264() { FUNC_ENTER(); }
// --------------------------------------------------------------------------- // CLbtCreateTriggerAOOperation::ConstructL // --------------------------------------------------------------------------- // void CLbtCreateTriggerAOOperation::ConstructL() { FUNC_ENTER("CLbtCreateTriggerAOOperation::ConstructL"); CActiveScheduler::Add(this); }
Encode_Status VaapiEncoderBase::getMVBufferSize(uint32_t *Size) { FUNC_ENTER(); *Size = 0; return ENCODE_SUCCESS; }
void smap_rxeof(void *arg) { struct smap_softc *sc = arg; struct smap_desc *d; struct ifnet *ifp = &sc->ethercom.ec_if; struct mbuf *m; u_int16_t r16, stat; u_int32_t *p; int i, j, sz, rxsz, cnt; FUNC_ENTER(); i = sc->rx_done_index; for (cnt = 0;; cnt++, i = (i + 1) & 0x3f) { m = NULL; d = &sc->rx_desc[i]; stat = d->stat; if ((stat & SMAP_RXDESC_EMPTY) != 0) { break; } else if (stat & 0x7fff) { ifp->if_ierrors++; goto next_packet; } sz = d->sz; rxsz = ROUND4(sz); KDASSERT(sz >= ETHER_ADDR_LEN * 2 + ETHER_TYPE_LEN); KDASSERT(sz <= ETHER_MAX_LEN); /* load data from FIFO */ _reg_write_2(SMAP_RXFIFO_PTR_REG16, d->ptr & 0x3ffc); p = sc->rx_buf; for (j = 0; j < rxsz; j += sizeof(u_int32_t)) { *p++ = _reg_read_4(SMAP_RXFIFO_DATA_REG); } /* put to mbuf */ MGETHDR(m, M_DONTWAIT, MT_DATA); if (m == NULL) { printf("%s: unable to allocate Rx mbuf\n", DEVNAME); ifp->if_ierrors++; goto next_packet; } if (sz > (MHLEN - 2)) { MCLGET(m, M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { printf("%s: unable to allocate Rx cluster\n", DEVNAME); m_freem(m); m = NULL; ifp->if_ierrors++; goto next_packet; } } m->m_data += 2; /* for alignment */ m->m_pkthdr.rcvif = ifp; m->m_pkthdr.len = m->m_len = sz; memcpy(mtod(m, void *), (void *)sc->rx_buf, sz); next_packet: ifp->if_ipackets++; _reg_write_1(SMAP_RXFIFO_FRAME_DEC_REG8, 1); /* free descriptor */ d->sz = 0; d->ptr = 0; d->stat = SMAP_RXDESC_EMPTY; _wbflush(); if (m != NULL) { if (ifp->if_bpf) bpf_mtap(ifp->if_bpf, m); (*ifp->if_input)(ifp, m); } } sc->rx_done_index = i; r16 = _reg_read_2(SPD_INTR_ENABLE_REG16); if (((r16 & SPD_INTR_RXDNV) == 0) && cnt > 0) { r16 |= SPD_INTR_RXDNV; _reg_write_2(SPD_INTR_ENABLE_REG16, r16); } FUNC_EXIT(); }
/*! \brief Wait until listener is ready to receive This function waits until a listener is ready. \param Pdx Pointer to the device extension. \param SendEoi TRUE if we want to signal an EOI. FALSE otherwise. */ VOID cbmiec_wait_for_listener(IN PDEVICE_EXTENSION Pdx, IN BOOLEAN SendEoi) { ULONG NumberOfAcks = SendEoi ? 2 : 1; FUNC_ENTER(); PERF_EVENT_VERBOSE(0x1100, NumberOfAcks); // This function has two incarnations. The first one // is used if we have successfully allocated the interrupt. // In this case, we just wait until the ISR has done the // essential work // When entering this function, DATA_IN should not be active DBG_ASSERT(CBMIEC_GET(PP_DATA_IN)); if (Pdx->ParallelPortAllocatedInterrupt) { LONG ret; // This is implementation 1. It needs a working // ISR. The main work is done there // Tell the ISR how many interrupts to wait for PERF_EVENT_VERBOSE(0x1101, NumberOfAcks); ret = InterlockedExchange(&Pdx->IrqCount, NumberOfAcks); DBG_ASSERT(ret==0); PERF_EVENT_VERBOSE(0x1102, ret); // in the sequel, allow interrupts to occur DBG_IRQ(("Allow Interrupts")); CBMIEC_SET(PP_LP_IRQ); /*! \todo Shouldn't we make sure that there * is no spurious interrupt until now? */ // Give the LISTENer the sign: We want to send something DBG_IRQ(("Release CLK_OUT")); CBMIEC_RELEASE(PP_CLK_OUT); #ifdef USE_DPC // set the cancel routine which will wake us up if we do not get // an IRQ, and a cancellation is requested PERF_EVENT_VERBOSE(0x1103, 0); DBG_VERIFY(IoSetCancelRoutine(Pdx->IrpQueue.CurrentIrp, WaitCancelRoutine) DBGDO(== NULL)); // Now, wait until we have been signalled PERF_EVENT_VERBOSE(0x1104, 0); DBG_DPC((DBG_PREFIX "CALL KeWaitForSingleObject()")); KeWaitForSingleObject(&Pdx->EventWaitForListener, Executive, KernelMode, FALSE, NULL); DBG_DPC((DBG_PREFIX "RETURN from KeWaitForSingleObject()")); PERF_EVENT_VERBOSE(0x1105, 0); // we do not need the cancel routine anymore: if (IoSetCancelRoutine(Pdx->IrpQueue.CurrentIrp, NULL) == NULL) { PERF_EVENT_VERBOSE(0x1106, -1); // the cancel routine was called! // Make sure the IrqCount is resetted to zero. InterlockedExchange(&Pdx->IrqCount, 0); } #else // Wait until the listener has told us that it is able to listen while (!QueueShouldCancelCurrentIrp(&Pdx->IrpQueue) && Pdx->IrqCount) { cbmiec_schedule_timeout(libiec_global_timeouts.T_WaitForListener_Granu_T_H); } #endif DBG_IRQ(("IrqCount = 0")); // from here on, no interrupts will be generated anymore CBMIEC_RELEASE(PP_LP_IRQ); DBG_IRQ(("No more Interrupts")); }
Encode_Status VaapiEncoderBase::getConfig(VideoParamConfigType type, Yami_PTR videoEncConfig) { FUNC_ENTER(); return ENCODE_SUCCESS; }
// --------------------------------------------------------------------------- // CLbtCleanupHandler::ReadCleanupDataFromFileL // --------------------------------------------------------------------------- // void CLbtCleanupHandler::ReadCleanupDataFromFileL() { FUNC_ENTER("CLbtCleanupHandler::ReadCleanupDataFromFileL"); // First reset the cleanup data iCleanupItems.ResetAndDestroy(); // Open handle to file system RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); // Obtain the file path TFileName file; // Gets the path in which the file can be created fs.SessionPath(file); // Create the file Directory ie the private directory of the process fs.MkDirAll(file); // Append the name of the file file.Append(KLbtAppCleanupFileName); // Open read stream RFileReadStream readStream; TInt error = readStream.Open( fs, file, EFileRead ); if( error != KErrNone ) { // File may not exists ERROR("Opening of cleanup file failed with : %d", error); readStream.Close(); CleanupStack::PopAndDestroy(); //fs return; } CleanupClosePushL( readStream ); // Get the count in the cleanup array TInt count = readStream.ReadInt16L(); for(TInt i=0; i<count; ++i) { RArray<TLbtTriggerId> triggers; CleanupClosePushL(triggers); // Read the trigger ids TInt triggerCount = readStream.ReadInt16L(); for(TInt j=0;j<triggerCount;++j) { triggers.Append( readStream.ReadUint32L() ); } // Read the universal time TInt year = readStream.ReadInt32L(); TMonth month = static_cast<TMonth>( readStream.ReadInt32L() ); TInt day = readStream.ReadInt32L(); TDateTime dateTime( year, month, day, 0, 0, 0, 0 ); TTime time( dateTime ); CLbtCleanupItem* cleanupItem = new (ELeave) CLbtCleanupItem(); cleanupItem->AddCleanupItem( triggers, time ); CleanupStack::Pop(); // triggers triggers.Close(); // Append cleanup item to the cleaup items array iCleanupItems.Append( cleanupItem ); } CleanupStack::PopAndDestroy(2); // fs and readStream }
// --------------------------------------------------------------------------- // CLbtCleanupHandler::~CLbtCleanupHandler // --------------------------------------------------------------------------- // CLbtCleanupHandler::~CLbtCleanupHandler() { FUNC_ENTER("CLbtCleanupHandler::~CLbtCleanupHandler"); Cancel(); iCleanupItems.ResetAndDestroy(); }
// --------------------------------------------------------------------------- // CLbtCleanupHandler::RunError // --------------------------------------------------------------------------- // TInt CLbtCleanupHandler::RunError( TInt aError ) { FUNC_ENTER("CLbtCleanupHandler::RunError"); ERROR("CLbtCleanupHandler::RunL left with error code", aError); return KErrNone; }
// --------------------------------------------------------------------------- // CLbtCleanupHandler::WriteCleanupDataToFileL // --------------------------------------------------------------------------- // void CLbtCleanupHandler::WriteCleanupDataToFileL() { FUNC_ENTER("CLbtCleanupHandler::WriteCleanupDataToFileL"); RFs fs; User::LeaveIfError( fs.Connect() ); CleanupClosePushL( fs ); // Obtain the file path TFileName file; // Gets the path in which the file can be created fs.SessionPath(file); // Create the file Directory ie the private directory of the process fs.MkDirAll(file); // Append the name of the file file.Append(KLbtAppCleanupFileName); // Open write stream to write to the file RFileWriteStream writeStream; // Open the file to replace the contents. If the file is not preset // this method will create the file TInt error = writeStream.Replace( fs, file, EFileWrite ); if( error != KErrNone ) { ERROR("Opening of cleanup file failed with : %d", error); writeStream.Close(); CleanupStack::PopAndDestroy(); //fs User::Leave(error); } CleanupClosePushL( writeStream ); // First write the number of cleanup items writeStream.WriteInt16L( iCleanupItems.Count() ); for(TInt i=0;i<iCleanupItems.Count();++i) { RArray<TLbtTriggerId>& triggers = iCleanupItems[i]->GetTriggers(); // Write the trigger ids into the file writeStream.WriteInt16L( triggers.Count() ); for(TInt j=0;j<triggers.Count();++j) { writeStream.WriteUint32L( triggers[j] ); } // Write the time into the file const TDateTime dateTime = iCleanupItems[i]->GetTime().DateTime(); // Write the year writeStream.WriteInt32L( dateTime.Year() ); // Write the month writeStream.WriteInt32L( dateTime.Month() ); // Write the day writeStream.WriteInt32L( dateTime.Day() ); } CleanupStack::PopAndDestroy(2); //fs and writeSteam }
Encode_Status VaapiEncoderH264::start() { FUNC_ENTER(); resetParams(); return VaapiEncoderBase::start(); }
// --------------------------------------------------------------------------- // Destructor // --------------------------------------------------------------------------- // CLbtDbOperationAO::~CLbtDbOperationAO() { FUNC_ENTER("CLbtDbOperationAO::~CLbtDbOperationAO"); }
// --------------------------------------------------------------------------- // RunError // --------------------------------------------------------------------------- // TInt CLbtDbOperationAO::RunError(TInt /*aError*/) { FUNC_ENTER("CLbtDbOperationAO::RunError"); // RunL doesn't have any Leaving calls. So no implementation here. return KErrNone; }
/*! \brief Executes IOCTLs Executes IRPs containing the IRP_MJ_DEVICE_CONTROL I/O function code. \param Pdx Pointer to the DEVICE_EXTENSION structure. \param Irp Pointer to an IRP structure that describes the requested I/O operation. \return If the routine succeeds, it returns STATUS_SUCCESS. Otherwise, it return one of the error status values: \n STATUS_SUCCESS - Success. \n STATUS_BUFFER_TOO_SMALL - Buffer too small. This function does not perform any validity checks on the input and output buffer! This should already been done in cbm_devicecontrol. */ NTSTATUS cbm_execute_devicecontrol(IN PDEVICE_EXTENSION Pdx, IN PIRP Irp) { PPAR_SET_INFORMATION setInfo; PIO_STACK_LOCATION irpSp; ULONG_PTR returnLength; NTSTATUS ntStatus; FUNC_ENTER(); // As not every IOCTL needs to return a value, we initialize // the return length here. This way, it needs only be altered // if the IOCTL returns some value. returnLength = 0; // get the current IRP stack location irpSp = IoGetCurrentIrpStackLocation(Irp); PERF_EVENT_IOCTL_EXECUTE(irpSp->Parameters.DeviceIoControl.IoControlCode); DBG_IRPPATH_EXECUTE("Execute Ioctl"); // Call the appropriate function for processing the IOCTL // PrimaryAddresses are ANDed with 0x1F, as these are the only legitimate // primary addresses allowed for a IEC serial bus. switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case CBMCTRL_TALK: DBG_IRP(CBMCTRL_TALK); ntStatus = cbmiec_talk(Pdx, INPUTVALUE(CBMT_TALK_IN)->PrimaryAddress & 0x1F, INPUTVALUE(CBMT_TALK_IN)->SecondaryAddress); break; case CBMCTRL_LISTEN: DBG_IRP(CBMCTRL_LISTEN); ntStatus = cbmiec_listen(Pdx, INPUTVALUE(CBMT_LISTEN_IN)->PrimaryAddress & 0x1F, INPUTVALUE(CBMT_LISTEN_IN)->SecondaryAddress); break; case CBMCTRL_UNTALK: DBG_IRP(CBMCTRL_UNTALK); ntStatus = cbmiec_untalk(Pdx); break; case CBMCTRL_UNLISTEN: DBG_IRP(CBMCTRL_UNLISTEN); ntStatus = cbmiec_unlisten(Pdx); break; case CBMCTRL_OPEN: DBG_IRP(CBMCTRL_OPEN); ntStatus = cbmiec_open(Pdx, INPUTVALUE(CBMT_OPEN_IN)->PrimaryAddress & 0x1F, INPUTVALUE(CBMT_OPEN_IN)->SecondaryAddress); break; case CBMCTRL_CLOSE: DBG_IRP(CBMCTRL_CLOSE); ntStatus = cbmiec_close(Pdx,INPUTVALUE(CBMT_CLOSE_IN)->PrimaryAddress & 0x1F, INPUTVALUE(CBMT_CLOSE_IN)->SecondaryAddress); break; case CBMCTRL_RESET: DBG_IRP(CBMCTRL_RESET); ntStatus = cbmiec_reset(Pdx); break; case CBMCTRL_GET_EOI: DBG_IRP(CBMCTRL_GET_EOI); returnLength = sizeof(CBMT_GET_EOI_OUT); ntStatus = cbmiec_get_eoi(Pdx, &(OUTPUTVALUE(CBMT_GET_EOI_OUT)->Decision)); break; case CBMCTRL_CLEAR_EOI: DBG_IRP(CBMCTRL_CLEAR_EOI); ntStatus = cbmiec_clear_eoi(Pdx); break; case CBMCTRL_PP_READ: DBG_IRP(CBMCTRL_PP_READ); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_PP_READ_OUT), STATUS_SUCCESS); returnLength = sizeof(CBMT_PP_READ_OUT); ntStatus = cbmiec_pp_read(Pdx, &(OUTPUTVALUE(CBMT_PP_READ_OUT)->Byte)); break; case CBMCTRL_PP_WRITE: DBG_IRP(CBMCTRL_PP_WRITE); ntStatus = cbmiec_pp_write(Pdx, INPUTVALUE(CBMT_PP_WRITE_IN)->Byte); break; case CBMCTRL_IEC_POLL: DBG_IRP(CBMCTRL_IEC_POLL); returnLength = sizeof(CBMT_IEC_POLL_OUT); ntStatus = cbmiec_iec_poll(Pdx, &(OUTPUTVALUE(CBMT_IEC_POLL_OUT)->Line)); break; case CBMCTRL_IEC_SET: DBG_IRP(CBMCTRL_IEC_SET); ntStatus = cbmiec_iec_set(Pdx, INPUTVALUE(CBMT_IEC_SET_IN)->Line); break; case CBMCTRL_IEC_RELEASE: DBG_IRP(CBMCTRL_IEC_RELEASE); ntStatus = cbmiec_iec_release(Pdx, INPUTVALUE(CBMT_IEC_RELEASE_IN)->Line); break; case CBMCTRL_IEC_SETRELEASE: DBG_IRP(CBMCTRL_IEC_SETRELEASE); ntStatus = cbmiec_iec_setrelease(Pdx, INPUTVALUE(CBMT_IEC_SETRELEASE_IN)->State, INPUTVALUE(CBMT_IEC_SETRELEASE_IN)->Line); break; case CBMCTRL_IEC_WAIT: DBG_IRP(CBMCTRL_IEC_WAIT); returnLength = sizeof(CBMT_IEC_WAIT_OUT); ntStatus = cbmiec_iec_wait(Pdx, INPUTVALUE(CBMT_IEC_WAIT_IN)->Line, INPUTVALUE(CBMT_IEC_WAIT_IN)->State, &(OUTPUTVALUE(CBMT_IEC_WAIT_OUT)->Line)); break; case CBMCTRL_PARBURST_READ: DBG_IRP(CBMCTRL_PARBURST_READ); returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; ntStatus = cbmiec_parallel_burst_read(Pdx, &(OUTPUTVALUE(CBMT_PARBURST_PREAD_OUT)->Byte)); break; case CBMCTRL_PARBURST_WRITE: DBG_IRP(CBMCTRL_PARBURST_READ); returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; ntStatus = cbmiec_parallel_burst_write(Pdx, INPUTVALUE(CBMT_PARBURST_PWRITE_IN)->Byte); break; case CBMCTRL_PARBURST_READ_TRACK: DBG_IRP(CBMCTRL_PARBURST_READ_TRACK); returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; ntStatus = cbmiec_parallel_burst_read_track(Pdx, Irp->AssociatedIrp.SystemBuffer, (ULONG) returnLength); break; case CBMCTRL_PARBURST_WRITE_TRACK: DBG_IRP(CBMCTRL_PARBURST_WRITE_TRACK); returnLength = irpSp->Parameters.DeviceIoControl.InputBufferLength; ntStatus = cbmiec_parallel_burst_write_track(Pdx, Irp->AssociatedIrp.SystemBuffer, (ULONG) returnLength); break; case CBMCTRL_I_INSTALL: DBG_IRP(CBMCTRL_I_INSTALL); returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; ntStatus = cbm_install(Pdx, OUTPUTVALUE(CBMT_I_INSTALL_OUT), (PULONG) &returnLength); break; case CBMCTRL_PARPORT_LOCK: DBG_IRP(CBMCTRL_PARPORT_LOCK); ntStatus = cbm_lock(Pdx); break; case CBMCTRL_PARPORT_UNLOCK: DBG_IRP(CBMCTRL_PARPORT_UNLOCK); ntStatus = cbm_unlock(Pdx); break; case CBMCTRL_UPDATE: DBG_IRP(CBMCTRL_UPDATE); cbm_init_registry(NULL, Pdx); ntStatus = STATUS_SUCCESS; break; #if DBG case CBMCTRL_I_READDBG: DBG_IRP(CBMCTRL_I_READDBG); returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength; ntStatus = cbm_dbg_readbuffer(Pdx, OUTPUTVALUE(CHAR), (PULONG) &returnLength); break; #endif // #if DBG default: // As cbm_devicecontrol() already checked the IRP, // this piece of code should never be entered. If it // is, this is a sign of a forgotten IOCTL, or a severe // programming error DBG_ERROR((DBG_PREFIX "unknown IRP_MJ_DEVICE_CONTROL")); DBG_ASSERT(("THIS SHOULD NOT HAPPEN!", 0)); ntStatus = STATUS_INVALID_PARAMETER; break; } // If an error occurred, make sure not to return anything. if (!NT_SUCCESS(ntStatus)) { returnLength = 0; } // Complete the request: DBG_IRPPATH_COMPLETE("Execute Ioctl"); QueueCompleteIrp(&Pdx->IrpQueue, Irp, ntStatus, returnLength); FUNC_LEAVE_NTSTATUS(ntStatus); }
// --------------------------------------------------------------------------- // CLbtCleanupItem::~CLbtCleanupItem // --------------------------------------------------------------------------- // CLbtCleanupItem::~CLbtCleanupItem() { FUNC_ENTER("CLbtCleanupItem::~CLbtCleanupItem"); iTriggers.Close(); }
/*! \brief Log an error entry in the system log Log an error entry in the system log. \param Fdo Pointer to a DEVICE_OBJECT structure. This is the device object for the target device, previously created by the driver's AddDevice routine. \param ErrorCode The NTSTATUS code which should be reported on behalf of this error log entry \param String1 Pointer to the 1st (WCHAR) string which has to be included into the error log entry. This can be NULL if no string is to be inserted. \param String2 Pointer to the 2nd (WCHAR) string which has to be included into the error log entry. This can be NULL if no string is to be inserted. */ VOID LogError(IN PDEVICE_OBJECT Fdo, IN NTSTATUS ErrorCode, const WCHAR *String1, const WCHAR *String2) { USHORT stringSize; USHORT stringOffset; USHORT stringSize1; USHORT stringSize2; USHORT size; USHORT numberOfStrings; FUNC_ENTER(); // IoAllocateErrorLogEntry() and IoWriteErrorLogEntry() require this DBG_IRQL( <= DISPATCH_LEVEL); // calculate the size of the strings numberOfStrings = 0; // Check if there is a string 1, and calculate its size // (including the trailing zero) stringSize1 = String1 ? (++numberOfStrings, sizeof(WCHAR) * (wcslen(String1) + 1)) : 0; // Check if there is a string 2, and calculate its size // (including the trailing zero) stringSize2 = String2 ? (++numberOfStrings, sizeof(WCHAR) * (wcslen(String2) + 1)) : 0; // Add the sizes of both strings // This is the size of what has to be added to the error log entry stringSize = stringSize1 + stringSize2; // Offset where the string(s) will be written into the error log entry stringOffset = sizeof(IO_ERROR_LOG_PACKET); // The complete size of the event log entry size = stringOffset + stringSize; // Make sure we don't need more space than needed. // For debugging purposes, have an DBG_ASSERT(). Anyway, // in the wild, don't do anything if the size is too big. // Remember: Not being able to write a log is not an error! /*! \todo Would it make sense to short the strings if the * error log entry would be too big? */ DBG_ASSERT(size <= ERROR_LOG_MAXIMUM_SIZE); if (size <= ERROR_LOG_MAXIMUM_SIZE) { PIO_ERROR_LOG_PACKET pentry; // allocate the entry for the error log DBG_IRQL( <= DISPATCH_LEVEL); pentry = IoAllocateErrorLogEntry(Fdo, (UCHAR) size); DBG_ASSERT(pentry); if (pentry) { // clear the complete entry (to be sure) RtlZeroMemory(pentry, sizeof(*pentry)); // Write the relevant entries pentry->NumberOfStrings = numberOfStrings; pentry->StringOffset = stringOffset; pentry->ErrorCode = ErrorCode; // If there was a string1, write that into the entry if (String1) { wcscpy((wchar_t*)&((UCHAR*)pentry)[stringOffset], String1); } // If there was a string2, write that into the entry if (String2) { wcscpy((wchar_t*)&((UCHAR*)pentry)[stringOffset + stringSize1], String2); } // Now, give that entry to the system DBG_IRQL( <= DISPATCH_LEVEL); IoWriteErrorLogEntry(pentry); } }
void CLbtContainerAttrFilter::ProcessFilter(CLbtContainerTriggerEntry* aEntry,TInt& aIsFilterPresent,TBool& aIsEntryRequested ) { FUNC_ENTER("CLbtContainerAttrFilter::ProcessFilter"); TInt isFilterPresent = 0; TBool isEntryRequested=EFalse; if(aEntry) { CLbtTriggerEntry* trigEntry=aEntry->TriggerEntry(); CLbtExtendedTriggerInfo* contExtInfo=aEntry->ExtendedTriggerInfo(); TInt i=0; if(trigEntry!=NULL) { if( iTriggerStateArray.Count()>0 ) { isFilterPresent++; for(i=0;i<iTriggerStateArray.Count();i++) { if(trigEntry->State()==iTriggerStateArray[i]) { isEntryRequested=ETrue; break; } } } if( (isFilterPresent>0 && isEntryRequested ) || (isFilterPresent==0) ) { if(iTriggerValidityArray.Count()>0) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iTriggerValidityArray.Count();i++) { if(aEntry->DynInfo()->iValidity == iTriggerValidityArray[i]) { isEntryRequested=ETrue; } } } } if((isFilterPresent>0 && isEntryRequested && iTriggerTypeArray.Count()>0) || (iTriggerTypeArray.Count()>0 && isFilterPresent==0)) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iTriggerTypeArray.Count();i++) { if(trigEntry->Type()==iTriggerTypeArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iIdArray.Count()>0) || (iIdArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iIdArray.Count();i++) { if(trigEntry->Id()==iIdArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iManagerUiArray.Count()>0) || (iManagerUiArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iManagerUiArray.Count();i++) { if(trigEntry->ManagerUi()==iManagerUiArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iStartupProcessArray.Count()>0) || (iStartupProcessArray.Count()>0 && isFilterPresent==0 )) { // This filter applies to only startup triggers if( trigEntry->Type() == CLbtTriggerEntry::ETypeStartup ) { CLbtStartupTrigger* startupTrigger = static_cast<CLbtStartupTrigger*>(trigEntry); isFilterPresent++; isEntryRequested=EFalse; TFileName fileName; TSecureId secureId; startupTrigger->GetProcessId(fileName, secureId); // Append the EXE extension if (fileName.LocateReverse('.') == KErrNotFound) { if (fileName.Length() + 4 > KMaxFileName) return; fileName.Append( KFileExtensionExe ); } LOGSTRING( "Trigger File Name : \"%S\" ", &fileName ); for(i=0;i<iStartupProcessArray.Count();i++) { LOGSTRING( "Filter startup name: \"%S\" ", &iStartupProcessArray[i] ); if( FilesIdentical(fileName, iStartupProcessArray[i] ) ) { LOG("Files Are Identical"); isEntryRequested=ETrue; break; } } } } }// end of if(trigEntry!=NULL) if(contExtInfo!=NULL) { if((isFilterPresent>0 && isEntryRequested && iHystRadiusArray.Count()>0) || (iHystRadiusArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iHystRadiusArray.Count();i++) { if(contExtInfo->HysteresisRadius()==iHystRadiusArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iTriggerFiredArray.Count()>0) || (iTriggerFiredArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iTriggerFiredArray.Count();i++) { if(contExtInfo->IsTriggerFired()==iTriggerFiredArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iSidArray.Count()>0) || (iSidArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iSidArray.Count();i++) { if(contExtInfo->OwnerSid()==iSidArray[i]) { isEntryRequested=ETrue; } } } if((isFilterPresent>0 && isEntryRequested && iTriggerFireOnCreationArray.Count()>0) || (iTriggerFireOnCreationArray.Count()>0 && isFilterPresent==0 )) { isFilterPresent++; isEntryRequested=EFalse; for(i=0;i<iTriggerFireOnCreationArray.Count();i++) { if(contExtInfo->IsTriggerFireOnCreation()==iTriggerFireOnCreationArray[i]) { isEntryRequested=ETrue; } } } } // end of if(contExtInfo!=NULL) }//end of if(aEntry) aIsFilterPresent = isFilterPresent; aIsEntryRequested = isEntryRequested; }
static int v4l2_case_measure(void* user_ptr, int test_num) { FUNC_ENTER(); int max_width; int max_height; v4l2_data* data = (v4l2_data*)user_ptr; BLTS_DEBUG("Test number %i:\n", test_num); if(!open_device (data->device)) { BLTS_DEBUG("Can't open device %s\n", data->device->dev_name); FUNC_LEAVE(); return -1; } if(init_device (data->device, MAX_WIDTH, MAX_HEIGHT)) { BLTS_DEBUG("Maximum resolution is: %ix%i\n", data->device->format.fmt.pix.width, data->device->format.fmt.pix.height); BLTS_DEBUG("Measuring FPS on maximum resolution\n"); max_width = data->device->format.fmt.pix.width; max_height = data->device->format.fmt.pix.height; BLTS_DEBUG("-----------------------\n"); BLTS_DEBUG("%ix%i resolution\n", max_width, max_height); BLTS_DEBUG("-----------------------\n"); if(!start_capturing (data->device)) goto err; mainloop (data->device, LOOPS); stop_capturing (data->device); uninit_device (data->device); close_device (data->device); } else { BLTS_DEBUG("Can't initialize device\n"); goto err; } BLTS_DEBUG("Stepping down resolutions and calculating FPS\n"); int step_size_x, step_size_y, i, x, y; step_size_x = max_width / 10; step_size_y = max_height / 10; for(i=1; i<8; i++) { x = max_width - step_size_x * i; y = max_height - step_size_y * i; BLTS_DEBUG("-----------------------\n"); BLTS_DEBUG("%ix%i resolution\n", x, y); BLTS_DEBUG("-----------------------\n"); if(!open_device (data->device)) goto err; if(init_device (data->device, x, y)) { BLTS_DEBUG("Resolution is: %ix%i\n", x, y); if(!start_capturing (data->device)) goto err; if(!mainloop (data->device, LOOPS)) goto err; stop_capturing (data->device); uninit_device (data->device); } else { BLTS_DEBUG("Can't initialize device\n"); goto err; } close_device (data->device); } FUNC_LEAVE(); return 0; err: stop_capturing(data->device); uninit_device(data->device); close_device(data->device); FUNC_LEAVE(); return -1; }
// --------------------------------------------------------------------------- // CLbtAppChangeHandler::RunL // --------------------------------------------------------------------------- // void CLbtAppChangeHandler::RunL() { FUNC_ENTER("CLbtAppChangeHandler::RunL"); switch(iOperation) { case EOpRegiseteredForInitialListPoplulation: { // First get the set of installed applications in the system iAppArcSession.GetAllApps(); TApaAppInfo appInfo; TInt error = iAppArcSession.GetNextApp(appInfo); while(KErrNone == error) { TLbtAppInfo lbtAppInfo; lbtAppInfo.iUid = appInfo.iUid; lbtAppInfo.iFullName.Zero(); lbtAppInfo.iFullName.Copy( appInfo.iFullName ); iCurrentInstalledApps.AppendL(lbtAppInfo); error = iAppArcSession.GetNextApp(appInfo); } iOperation = EOpNone; break; } case EOpRegiseteredForListPoplulation: { HandleAppListEvent(KErrNone); break; } case EOpRemovalTriggerDeletion: { // Here the observer is set to the get the information pertaining // triggers that were deleted. TLbtTriggerEventMask eventMask = 0; eventMask|= CLbtContainer::ELbtConTriggerDeleted; iContainer.SetChangeObserver( this,eventMask ); // Delete triggers for which the un-installed application is the // startup process iOperation = EOpDeletionStartupProcessTriggers; DeleteTriggersOfStartupProcessL(); break; } case EOpRemovalListingStartupProcessTriggers: { // Here the observer is set to the get the information pertaining // triggers that were deleted. TLbtTriggerEventMask eventMask = 0; eventMask|= CLbtContainer::ELbtConTriggerDeleted; iContainer.SetChangeObserver( this,eventMask ); CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL(); CleanupStack::PushL(containerFilter); for(TInt i=0;i<iAppList.Count();++i) { containerFilter->AddOwnerSidInFilterL(iAppList[i].iUid); } CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL(); CleanupStack::PushL(filterByAttribute); filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup); CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL(filterByAttribute ,containerFilter); iContainer.DeleteTriggers(updateFilter, iOpId, iStatus); SetActive(); iOperation = EOpRemovalDeletingStartupProcessTriggers; break; } case EOpRemovalDeletingStartupProcessTriggers: { // Here the observer is set to the get the information pertaining // triggers that were deleted. TLbtTriggerEventMask eventMask = 0; eventMask|= CLbtContainer::ELbtConTriggerDeleted; iContainer.SetChangeObserver( this,eventMask ); break; } case EOpMMCInsertionListingTriggers: case EOpMMCRemovalListingTriggers: { // Listing Triggers of startup process LOG("Listing Triggers Over"); if( iOperation == EOpMMCInsertionListingTriggers ) { iOperation = EOpMMCInsertionListingTriggerForStartupProcess; } else { iOperation = EOpMMCRemovalListingTriggerForStartupProcess; } ListTriggersOfStartupProcessL(); iAppList.Close(); LOG("Listing Triggers for startup Process"); break; } case EOpMMCRemovalListingTriggerForStartupProcess: case EOpMMCInsertionListingTriggerForStartupProcess: { LOG("Listing Trigger For startup Process Done"); LOG1("iStatus = %d", iStatus.Int()); LOG1("Triggers Count = %d", iTriggerEntries.Count()); if(KErrNone == iStatus.Int()) { // The list operation is a success. Hence invalidate the triggers now RArray<TLbtTriggerId> triggerIds; for(TInt i=0;i<iTriggerEntries.Count();++i) { triggerIds.AppendL(iTriggerEntries[i]->TriggerEntry()->Id()); } TLbtTriggerDynamicInfo::TLbtTriggerValidity validity; if(iOperation == EOpMMCRemovalListingTriggerForStartupProcess) { validity = TLbtTriggerDynamicInfo::EInvalid; iCleanupHandler.AddTriggersForCleanupL( triggerIds ); } else { validity = TLbtTriggerDynamicInfo::EValid; iCleanupHandler.RemoveTriggersFromCleanupL( triggerIds ); } // update validity of the triggers iContainer.UpdateTriggersValidity( validity, triggerIds, iOpId, iStatus ); SetActive(); iOperation = EOpRequestValidityChange; triggerIds.Close(); iTriggerEntries.ResetAndDestroy(); } else { // Listing is not successful. Hence dont do anything iOperation = EOpNone; iTriggerEntries.ResetAndDestroy(); iAppList.Reset(); } break; } case EOpRequestValidityChange: { // Here the observer is set to the get the information pertaining // triggers that were changed to invalid TLbtTriggerEventMask eventMask = 0; eventMask|= CLbtContainer::ELbtConTriggerValidityFieldChanged; iContainer.SetChangeObserver( this,eventMask ); break; } default: { // Operation complete iTriggerEntries.ResetAndDestroy(); iAppList.Close(); iOperation = EOpNone; break; } } }
Encode_Status VaapiEncoderBase::getMaxOutSize(uint32_t *maxSize) { FUNC_ENTER(); *maxSize = 0; return ENCODE_SUCCESS; }
// --------------------------------------------------------------------------- // CLbtAppChangeHandler::ConstructL // --------------------------------------------------------------------------- // void CLbtAppChangeHandler::ConstructL() { FUNC_ENTER("CLbtAppChangeHandler::ConstructL"); User::LeaveIfError(iAppArcSession.Connect()); MemoryCardChar(); }
Encode_Status VaapiEncoderBase::stop(void) { FUNC_ENTER(); cleanupVA(); return ENCODE_SUCCESS; }
static void ppm_lcmoff_early_suspend(struct early_suspend *h) { FUNC_ENTER(FUNC_LV_POLICY); ppm_lcmoff_switch(0); FUNC_EXIT(FUNC_LV_POLICY); }
void smap_start(struct ifnet *ifp) { struct smap_softc *sc = ifp->if_softc; struct smap_desc *d; struct mbuf *m0, *m; u_int8_t *p, *q; u_int32_t *r; int i, sz, pktsz; u_int16_t fifop; u_int16_t r16; KDASSERT(ifp->if_flags & IFF_RUNNING); FUNC_ENTER(); while (1) { IFQ_POLL(&ifp->if_snd, m0); if (m0 == NULL) goto end; pktsz = m0->m_pkthdr.len; KDASSERT(pktsz <= ETHER_MAX_LEN - ETHER_CRC_LEN); sz = ROUND4(pktsz); if (sz > sc->tx_buf_freesize || sc->tx_desc_cnt >= SMAP_DESC_MAX || emac3_tx_done() != 0) { ifp->if_flags |= IFF_OACTIVE; goto end; } IFQ_DEQUEUE(&ifp->if_snd, m0); KDASSERT(m0 != NULL); if (ifp->if_bpf) bpf_mtap(ifp->if_bpf, m0); p = (u_int8_t *)sc->tx_buf; q = p + sz; /* copy to temporary buffer area */ for (m = m0; m != 0; m = m->m_next) { memcpy(p, mtod(m, void *), m->m_len); p += m->m_len; } m_freem(m0); /* zero padding area */ for (; p < q; p++) *p = 0; /* put to FIFO */ fifop = sc->tx_fifo_ptr; KDASSERT((fifop & 3) == 0); _reg_write_2(SMAP_TXFIFO_PTR_REG16, fifop); sc->tx_fifo_ptr = (fifop + sz) & 0xfff; r = sc->tx_buf; for (i = 0; i < sz; i += sizeof(u_int32_t)) *(volatile u_int32_t *)SMAP_TXFIFO_DATA_REG = *r++; _wbflush(); /* put FIFO to EMAC3 */ d = &sc->tx_desc[sc->tx_start_index]; KDASSERT((d->stat & SMAP_TXDESC_READY) == 0); d->sz = pktsz; d->ptr = fifop + SMAP_TXBUF_BASE; d->stat = SMAP_TXDESC_READY | SMAP_TXDESC_GENFCS | SMAP_TXDESC_GENPAD; _wbflush(); sc->tx_buf_freesize -= sz; sc->tx_desc_cnt++; sc->tx_start_index = (sc->tx_start_index + 1) & 0x3f; _reg_write_1(SMAP_TXFIFO_FRAME_INC_REG8, 1); emac3_tx_kick(); r16 = _reg_read_2(SPD_INTR_ENABLE_REG16); if ((r16 & SPD_INTR_TXDNV) == 0) { r16 |= SPD_INTR_TXDNV; _reg_write_2(SPD_INTR_ENABLE_REG16, r16); } } end: /* set watchdog timer */ ifp->if_timer = 5; FUNC_EXIT(); }
static void ppm_lcmoff_late_resume(struct early_suspend *h) { FUNC_ENTER(FUNC_LV_POLICY); ppm_lcmoff_switch(1); FUNC_EXIT(FUNC_LV_POLICY); }
Encode_Status VaapiEncoderH264::getMVBufferSize(uint32_t *Size) { FUNC_ENTER(); *Size = sizeof(VAMotionVectorIntel)*16*m_mbWidth*m_mbHeight; return ENCODE_SUCCESS; }
/*! \brief Services IOCTLs Services IRPs containing the IRP_MJ_DEVICE_CONTROL I/O function code. \param Fdo Pointer to a DEVICE_OBJECT structure. This is the device object for the target device, previously created by the driver's AddDevice routine. \param Irp Pointer to an IRP structure that describes the requested I/O operation. \return If the routine succeeds, it returns STATUS_SUCCESS. Otherwise, it return one of the error status values: \n STATUS_SUCCESS - Success. \n STATUS_PENDING - Request pending. \n STATUS_BUFFER_TOO_SMALL - Buffer too small. \n STATUS_INVALID_PARAMETER - Invalid io control request. The driver's DriverEntry routine stored this routine's address in DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]. Generally, all Dispatch routines execute in an arbitrary thread context at IRQL PASSIVE_LEVEL, but there are exceptions. */ NTSTATUS cbm_devicecontrol(IN PDEVICE_OBJECT Fdo, IN PIRP Irp) { PPAR_SET_INFORMATION setInfo; PIO_STACK_LOCATION irpSp; PDEVICE_EXTENSION pdx; NTSTATUS ntStatus; BOOLEAN fastStart; FUNC_ENTER(); // get the device extension pdx = Fdo->DeviceExtension; // get the current IRP stack location irpSp = IoGetCurrentIrpStackLocation(Irp); DBG_IRPPATH_PROCESS("Ioctl"); // assume we do not want to perform a faststart of this IRP fastStart = FALSE; // Now, check the input and/or output buffers of the given // IOCTLs if they are at least as big as the specification. // If not, the IRP (and thus the IOCTL) is failed switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case CBMCTRL_TALK: DBG_IRP(CBMCTRL_TALK); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_TALK_IN), STATUS_SUCCESS); break; case CBMCTRL_LISTEN: DBG_IRP(CBMCTRL_LISTEN); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_LISTEN_IN), STATUS_SUCCESS); break; case CBMCTRL_UNTALK: DBG_IRP(CBMCTRL_UNTALK); ntStatus = STATUS_SUCCESS; break; case CBMCTRL_UNLISTEN: DBG_IRP(CBMCTRL_UNLISTEN); ntStatus = STATUS_SUCCESS; break; case CBMCTRL_OPEN: DBG_IRP(CBMCTRL_OPEN); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_OPEN_IN), STATUS_SUCCESS); break; case CBMCTRL_CLOSE: DBG_IRP(CBMCTRL_CLOSE); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_CLOSE_IN), STATUS_SUCCESS); break; case CBMCTRL_RESET: DBG_IRP(CBMCTRL_RESET); ntStatus = STATUS_SUCCESS; break; case CBMCTRL_GET_EOI: DBG_IRP(CBMCTRL_GET_EOI); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_GET_EOI_OUT), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_CLEAR_EOI: DBG_IRP(CBMCTRL_CLEAR_EOI); ntStatus = STATUS_SUCCESS; fastStart = TRUE; break; case CBMCTRL_PP_READ: DBG_IRP(CBMCTRL_PP_READ); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_PP_READ_OUT), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_PP_WRITE: DBG_IRP(CBMCTRL_PP_WRITE); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_PP_WRITE_IN), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_IEC_POLL: DBG_IRP(CBMCTRL_IEC_POLL); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_IEC_POLL_OUT), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_IEC_SET: DBG_IRP(CBMCTRL_IEC_SET); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_IEC_SET_IN), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_IEC_RELEASE: DBG_IRP(CBMCTRL_IEC_RELEASE); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_IEC_RELEASE_IN), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_IEC_SETRELEASE: DBG_IRP(CBMCTRL_IEC_SETRELEASE); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_IEC_SETRELEASE_IN), STATUS_SUCCESS); fastStart = TRUE; break; case CBMCTRL_IEC_WAIT: DBG_IRP(CBMCTRL_IEC_WAIT); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_IEC_WAIT_OUT), cbm_checkinputbuffer(irpSp, sizeof(CBMT_IEC_WAIT_IN), STATUS_SUCCESS)); break; case CBMCTRL_PARBURST_READ: DBG_IRP(CBMCTRL_PARBURST_READ); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_PARBURST_PREAD_OUT), STATUS_SUCCESS); break; case CBMCTRL_PARBURST_WRITE: DBG_IRP(CBMCTRL_PARBURST_WRITE); ntStatus = cbm_checkinputbuffer(irpSp, sizeof(CBMT_PARBURST_PWRITE_IN), STATUS_SUCCESS); break; case CBMCTRL_PARBURST_READ_TRACK: DBG_IRP(CBMCTRL_PARBURST_READ_TRACK); ntStatus = cbm_checkoutputbuffer(irpSp, 1, STATUS_SUCCESS); break; case CBMCTRL_PARBURST_WRITE_TRACK: DBG_IRP(CBMCTRL_PARBURST_WRITE_TRACK); ntStatus = cbm_checkinputbuffer(irpSp, 1, STATUS_SUCCESS); break; case CBMCTRL_I_INSTALL: DBG_IRP(CBMCTRL_I_INSTALL); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CBMT_I_INSTALL_OUT), STATUS_SUCCESS); break; case CBMCTRL_PARPORT_LOCK: DBG_IRP(CBMCTRL_PARPORT_LOCK); ntStatus = STATUS_SUCCESS; break; case CBMCTRL_PARPORT_UNLOCK: DBG_IRP(CBMCTRL_PARPORT_UNLOCK); ntStatus = STATUS_SUCCESS; break; case CBMCTRL_UPDATE: DBG_IRP(CBMCTRL_UPDATE); ntStatus = STATUS_SUCCESS; fastStart = TRUE; break; #if DBG case CBMCTRL_I_READDBG: DBG_IRP(CBMCTRL_I_READDBG); ntStatus = cbm_checkoutputbuffer(irpSp, sizeof(CHAR), STATUS_SUCCESS); break; #endif // #if DBG default: DBG_ERROR((DBG_PREFIX "unknown IRP_MJ_DEVICE_CONTROL")); ntStatus = STATUS_INVALID_PARAMETER; break; } if (NT_SUCCESS(ntStatus)) { PERF_EVENT_IOCTL_QUEUE(irpSp->Parameters.DeviceIoControl.IoControlCode); // queue the IRP to be processed // If faststart is TRUE, it will be processed immediately // (for performance reasons) ntStatus = QueueStartPacket(&pdx->IrpQueue, Irp, fastStart, Fdo); } else { // there was an error, complete the request // with that error status QueueCompleteIrp(NULL, Irp, ntStatus, 0); } FUNC_LEAVE_NTSTATUS(ntStatus); }
// --------------------------------------------------------------------------- // CLbtCreateTriggerAOOperation::CreateTriggerL() // --------------------------------------------------------------------------- // void CLbtCreateTriggerAOOperation::CreateTriggerL() { FUNC_ENTER("CLbtCreateTriggerAOOperation::CreateTriggerL"); // Copy the trigger entry object descriptor from the client IPC message HBufC8* triggerEntryBuffer = LbtGlobal::CopyClientBuffer8LC(iMessage, KParamTriggerEntry); if( triggerEntryBuffer == NULL ) { iObserver.HandleOperationClosureL(this, KErrBadDescriptor); return; } TLbtTriggerCreationInfo triggerCreationInfo; TPckg<TLbtTriggerCreationInfo> des(triggerCreationInfo); LbtGlobal::Read(iMessage,2,des); // Read the buffer into a stream RDesReadStream stream(*triggerEntryBuffer); CleanupClosePushL(stream); // Create the trigger entry object based on the type of trigger CLbtTriggerEntry* trigger; if( triggerCreationInfo.iTriggerType== CLbtTriggerEntry::ETypeStartup) { trigger = CLbtStartupTrigger::NewLC(); } else { trigger = CLbtSessionTrigger::NewLC(); } // Internalize the trigger entry class since it is a "C" class trigger->InternalizeL(stream); // Fill the extended trigger info required by Stratergy CLbtExtendedTriggerInfo::TLbtTriggerRectArea area; if(trigger->GetCondition()->Type() == CLbtTriggerConditionBase::ETriggerConditionArea) { // Get the condition area base CLbtTriggerConditionArea* conditionArea = static_cast<CLbtTriggerConditionArea*>(trigger->GetCondition()); // Check if the area is a circle if(conditionArea->TriggerArea()->Type() == CLbtGeoAreaBase::ECircle) { CLbtGeoCircle* circle = static_cast<CLbtGeoCircle*>(conditionArea->TriggerArea()); // If the triggering area specified is less than the minimum triggering area // the return KErrTriggerAreaTooSmall if(circle->Radius() < iSettingsManager.MinimumTriggeringArea()) { CleanupStack::PopAndDestroy( 3 ); // trigger,stream,triggerEntry LbtGlobal::RequestComplete(iMessage, KErrTriggerAreaTooSmall); iObserver.HandleOperationClosureL(this, KErrTriggerAreaTooSmall); return; } CalculateRectangularArea(area, circle); } } // Create the extended trigger info CLbtExtendedTriggerInfo* extendedTriggerInfo = CLbtExtendedTriggerInfo::NewL(area, CalculateHysteresisAreaForTrigger(*trigger), EFalse, KNullDesC8, iMessage.SecureId(), triggerCreationInfo.iFireOnCreation); CleanupStack::PushL(extendedTriggerInfo); TLbtTriggerDynamicInfo* dynInfo = new (ELeave) TLbtTriggerDynamicInfo; CleanupStack::PushL(dynInfo); dynInfo->iValidity = TLbtTriggerDynamicInfo::EValid; // Create trigger class of Container. Container takes ownership of trigger and all info sent to it iContainerTriggerEntry = CLbtContainerTriggerEntry::NewL(trigger, dynInfo, extendedTriggerInfo); // Register for container change event observer TLbtTriggerEventMask eventMask = 0; eventMask|= CLbtContainer::ELbtConTriggerCreated; iContainer.SetChangeObserver( this ,eventMask ); // Creates the trigger in the container iContainer.CreateTrigger(*iContainerTriggerEntry,iAOIdentificationNum,iStatus); SetActive(); CleanupStack::Pop(5); //trigger, stream, triggerEntryBuffer, dynInfo and extendedTriggerInfo stream.Close(); delete triggerEntryBuffer; }
/*! \brief Initialize the knowledge on a parallel port This function gets some knowledge on a parallel port, and stores this info into the given DEVICE_EXTENSION. \param ParallelPortName UNICODE_STRING which holds the name of the parallel port driver \param Pdx Device extension which will be initialized with the needed knowledge on the parallel port. This function should be called before any other parallel port function is called. Usually, it is done in the driver's AddDevice (WDM) or DriverEntry (WKM, WDM) function. One of the purposes of this function is to make sure the parallel port driver is not unloaded from memory (via IoGetDeviceObjectPointer()). This function must be run at IRQL == PASSIVE_LEVEL. */ NTSTATUS ParPortInit(PUNICODE_STRING ParallelPortName, PDEVICE_EXTENSION Pdx) { NTSTATUS ntStatus; FUNC_ENTER(); DBG_ASSERT(ParallelPortName); DBG_ASSERT(Pdx); // First of all, get the PDEVICE_OBJECT of the parallel port driver DBG_IRQL( == PASSIVE_LEVEL); ntStatus = IoGetDeviceObjectPointer(ParallelPortName, FILE_READ_ATTRIBUTES, &Pdx->ParallelPortFileObject, &Pdx->ParallelPortFdo); if (!NT_SUCCESS(ntStatus)) { DBG_WARN((DBG_PREFIX "IoGetDeviceObjectPointer() FAILED!")); FUNC_LEAVE_NTSTATUS(ntStatus); } // Allocate memory to hold to parallel port info DBG_IRQL( == PASSIVE_LEVEL); Pdx->PortInfo = (PPARALLEL_PORT_INFORMATION) ExAllocatePoolWithTag(NonPagedPool, sizeof(*Pdx->PortInfo), MTAG_PPINFO); // If we got memory, get the info out of the parallel port driver if (Pdx->PortInfo) { ntStatus = ParPortIoctlInOut(Pdx, IOCTL_INTERNAL_GET_PARALLEL_PORT_INFO, NULL, 0, Pdx->PortInfo, sizeof(*Pdx->PortInfo)); } else { ntStatus = STATUS_INSUFFICIENT_RESOURCES; } if (NT_SUCCESS(ntStatus)) { Pdx->ParPortPortAddress = Pdx->PortInfo->Controller; DBG_PPORT((DBG_PREFIX "Got parallel port information:")); DBG_PPORT((DBG_PREFIX "- OriginalController = 0x%p", Pdx->PortInfo->OriginalController)); DBG_PPORT((DBG_PREFIX "- Controller = 0x%p", Pdx->PortInfo->Controller)); DBG_PPORT((DBG_PREFIX "- Span of controller = 0x%08x", Pdx->PortInfo->SpanOfController)); DBG_PPORT((DBG_PREFIX "- TryAllocatePort = 0x%p", Pdx->PortInfo->TryAllocatePort)); DBG_PPORT((DBG_PREFIX "- FreePort = 0x%p", Pdx->PortInfo->FreePort)); DBG_PPORT((DBG_PREFIX "- QueryNumWaiters = 0x%p", Pdx->PortInfo->QueryNumWaiters)); DBG_PPORT((DBG_PREFIX "- Context = 0x%p", Pdx->PortInfo->Context)); } // if we failed getting the parallel port info, but there was memory // allocated, free the memory. if (!NT_SUCCESS(ntStatus) && Pdx->PortInfo) { DBG_IRQL( < DISPATCH_LEVEL); ExFreePool(Pdx->PortInfo); Pdx->PortInfo = NULL; }