// This function gets called when the timeout period of debounce timer elapses. // It reports a switch change by completing a pending request // void HidFx2EvtTimerFunction(_In_ WDFTIMER hTimer) { WDFDEVICE hDevice = NULL; WDFREQUEST hRequest; PDEVICE_EXTENSION pDevContext = NULL; NTSTATUS status = STATUS_SUCCESS; size_t cBytesReturned = 0; unsigned char bToggledSwitch = 0; ULONG cBytesToCopy = 0; PHIDFX2_IO_REPORT pInputReport = NULL; TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n"); hDevice = WdfTimerGetParentObject(hTimer); pDevContext = GetDeviceContext(hDevice); bToggledSwitch = pDevContext->bLatestToggledSwitch; TraceInfo(DBG_IOCTL, "(%!FUNC!) mode %d switch %d\n", pDevContext->driverMode, bToggledSwitch); if (!((pDevContext->driverMode == DM_BUTTON || pDevContext->driverMode == DM_BUTTON_AND_LED) && bToggledSwitch == 0)) { // Check if there are any pending requests in the Interrupt Message Queue. // If a request is found then complete the pending request. status = WdfIoQueueRetrieveNextRequest(pDevContext->hInterruptMsgQueue, &hRequest); if (NT_SUCCESS(status)) { cBytesToCopy = sizeof(pInputReport[0]); status = WdfRequestRetrieveOutputBuffer(hRequest, cBytesToCopy, &pInputReport, &cBytesReturned); // BufferLength if (NT_SUCCESS(status)) { TraceInfo(DBG_IOCTL, "(%!FUNC!) WdfRequestRetrieveOutputBuffer switch %d\n", bToggledSwitch); pInputReport->bReportId = GENERIC_DESKTOP_REPORT_ID; pInputReport->bData = bToggledSwitch; cBytesReturned = cBytesToCopy; } else // WdfRequestRetrieveOutputBuffer failed { TraceErr(DBG_IOCTL, "(%!FUNC!) WdfRequestRetrieveOutputBuffer failed with status: %!STATUS!\n", status); } WdfRequestCompleteWithInformation(hRequest, status, cBytesReturned); } else if (status != STATUS_NO_MORE_ENTRIES) { TraceErr(DBG_IOCTL, "(%!FUNC!) WdfIoQueueRetrieveNextRequest status %!STATUS!\n", status); } } else { TraceInfo(DBG_IOCTL, "(%!FUNC!) ignore switch"); } TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n"); }
void nRF8001MeteoStation::onACIEvent(aci_evt_t* p_event) { switch(p_event->evt_opcode) { // if an ACI_EVT_DATA_ACK occurs, it searches the pipe, which has return a ACK case ACI_EVT_DATA_ACK: if (p_event->params.data_ack.pipe_number == PIPE_METEO_STATION_TEMPERATURE_MEASUREMENT_TX_ACK) { // sets to False; a new sending could take place in case of a new temperature (!= m_last_temp) m_ack_temperature_measure_pending = false; TraceInfo(F("ACK for temperature measurement received\n")); } else if (p_event->params.data_ack.pipe_number == PIPE_METEO_STATION_HUMIDITY_MEASUREMENT_TX_ACK) { m_ack_humidity_measure_pending = false; TraceInfo(F("ACK for humidity measurement received\n")); } /*else if (p_event->params.data_ack.pipe_number == PIPE_METEO_STATION_PRESSURE_MEASUREMENT_TX_ACK) { m_ack_pressure_measure_pending = false; TraceInfo(F("ACK for pressure measurement received\n")); }*/ notif.notify(YELLOW, 1, false); break; // if a paired device is disconnected, it sets the stored values to the biggest FLOAT value // and the ACKs to false. It avoids problems if the device want to connect again case ACI_EVT_DISCONNECTED: m_last_temp = FLT_MAX; m_last_hum = FLT_MAX; //m_last_pres = INT_MAX; m_ack_temperature_measure_pending = false; m_ack_humidity_measure_pending = false; //m_ack_pressure_measure_pending = false; break; // if a device asks for a connection case ACI_EVT_CONNECTED: notif.notify(WHITE, 1, false); break; // if the paired device sends data, it retrieves the data into the min or the max temperature (thermostat) case ACI_EVT_DATA_RECEIVED: if (p_event->params.data_received.rx_data.pipe_number == PIPE_METEO_STATION_THERMOSTAT_TEMPERATUR_RX) { for(uint8_t i = 0; i < p_event->len - 2; i++) { m_uart_buffer[i] = convert_hex_to_uint(p_event->params.data_received.rx_data.aci_data[i]); } if (m_thermo_temp == THERMO_TEMP_MIN) { m_thermo_temp_min = m_uart_buffer[0] * 10 + m_uart_buffer[1]; TraceInfoFormat(F("Thermostat min temperature set to : %u\n"), m_thermo_temp_min); } else if (m_thermo_temp == THERMO_TEMP_MAX) { m_thermo_temp_max = m_uart_buffer[0] * 10 + m_uart_buffer[1]; TraceInfoFormat(F("Thermostat max temperature set to : %u\n"), m_thermo_temp_max); } } notif.notify(WHITE, 1, false); break; } }
//Installable driver initialization entry point. This entry point is called directly by the I/O system. // NTSTATUS DriverEntry (_In_ PDRIVER_OBJECT pDriverObject, _In_ PUNICODE_STRING pszRegistryPath) { NTSTATUS status = STATUS_SUCCESS; WDF_DRIVER_CONFIG config; WDF_OBJECT_ATTRIBUTES attributes; // Initialize WPP Tracing WPP_INIT_TRACING(pDriverObject, pszRegistryPath); TraceInfo(DBG_INIT, "(%!FUNC!) Enter -Sample Built %s %s\n", __DATE__, __TIME__); WDF_DRIVER_CONFIG_INIT(&config, HidFx2EvtDeviceAdd); // Register a cleanup callback so that we can call WPP_CLEANUP when the framework driver object is deleted during driver unload. WDF_OBJECT_ATTRIBUTES_INIT(&attributes); attributes.EvtCleanupCallback = HidFx2EvtDriverContextCleanup; // Create a framework driver object to represent our driver. status = WdfDriverCreate(pDriverObject, pszRegistryPath, &attributes, // Driver Attributes &config, // Driver Config Info WDF_NO_HANDLE ); if (!NT_SUCCESS(status)) { TraceErr(DBG_INIT, "(%!FUNC!)WdfDriverCreate failed with status %!STATUS!\n", status); WPP_CLEANUP(pDriverObject); } TraceVerbose(DBG_INIT, "(%!FUNC!) Exit\n"); return status; }
static VOID ReceiverInitializeConfiguration(PRECEIVER Receiver) { PKEY_VALUE_PARTIAL_INFORMATION pInfo; NTSTATUS status; status = XenReadRegistryValue(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services\\xennet\\Parameters", L"LowResources", &pInfo); if (!NT_SUCCESS(status)) { TraceVerbose(("LowResources switch: not present\n")); goto done; } if (pInfo->Type != REG_DWORD) { TraceError(("LowResources switch: wrong type\n")); ExFreePool(pInfo); goto done; } Receiver->LowResources = *(DWORD *)pInfo->Data; ExFreePool(pInfo); done: TraceInfo(("LowResources: %08x\n", Receiver->LowResources)); }
ULONG XenLowerInterfaceVersion( PXEN_LOWER XenLower) { NTSTATUS status; PCHAR vstr; int version; vstr = XenLowerReadXenstoreValue(XenLower->BackendPath, "version"); if (vstr == NULL) { TraceError((__FUNCTION__\ ": XenLowerReadXenstoreValue() failed to return the vusb version.\n")); return 0; } sscanf_s(vstr, "%d", &version); XmFreeMemory(vstr); // Need to now write the version we support to the frontend status = xenbus_printf(XBT_NIL, XenLower->FrontendPath, "version", "%d", XEN_LOWER_INTERFACE_VERSION); if (!NT_SUCCESS(status)) { TraceError((__FUNCTION__\ ": xenbus_printf(frontend/version) failed.\n")); return 0; } TraceInfo((__FUNCTION__ ": Read backend version: %d - Wrote frontend version: %d\n", version, XEN_LOWER_INTERFACE_VERSION)); return (ULONG)version; }
BOOLEAN XenLowerBackendInit( PXEN_LOWER XenLower) { PCHAR path; NTSTATUS status; // Note this is split from the XenLowerInit so it can be called on the resume // path in case backend values change. XXX_TODO("--XT-- All the backend path handling assumes dom0 is the backend, this will change for device domains") // XXX TODO all the backend path handling assumes dom0 is the backend. This will // not necessarily be true with device domains. The changes to support this go // beyond this module though. path = XenLowerReadXenstoreValue(XenLower->FrontendPath, "backend"); if (path == NULL) { TraceError((__FUNCTION__ ": XenLowerReadXenstoreValue() failed to return the back end path, fatal.\n")); return FALSE; } status = RtlStringCchCopyA(XenLower->BackendPath, sizeof(XenLower->BackendPath), path); XmFreeMemory(path); if (status != STATUS_SUCCESS) { XenLower->BackendPath[0] = 0; TraceError((__FUNCTION__ ": Failed to copy back end path - status: 0x%x\n", status)); return FALSE; } status = xenbus_read_domain_id(XBT_NIL, XenLower->FrontendPath, "backend-id", &XenLower->BackendDomid); if (!NT_SUCCESS(status)) { TraceWarning((__FUNCTION__ ": Failed to read backend id from %s (%x), setting to dom0\n", XenLower->FrontendPath, status)); XenLower->BackendDomid = DOMAIN_ID_0(); } // XXX TODO for now we only support a dom0 backend so check that here. Later // when we support a device domain for vusb, other domids will be fine. XXX_TODO("--XT-- For now we only support a dom0 backend so check that here"); if (unwrap_DOMAIN_ID(XenLower->BackendDomid) != unwrap_DOMAIN_ID(DOMAIN_ID_0())) { TraceError((XENTARGET ": cannot connect to backend Domid: %d, only dom0 supported currently\n", XenLower->BackendDomid)); return FALSE; } TraceInfo((__FUNCTION__ ": XenLower initialized - FrontendPath: %s BackendPath: %s BackendDomid: %d\n", XenLower->FrontendPath, XenLower->BackendPath, unwrap_DOMAIN_ID(XenLower->BackendDomid))); return TRUE; }
static VOID _XenLowerTraceGref(PCSTR Caller, grant_ref_t greft, GRANT_REF gref) { grant_ref_t greftun = xen_GRANT_REF(gref); TraceInfo(("%s: GRANT_REF greft: %d (0x%x) greftun: %d (0x%x) wrapped: %2.2x:%2.2x:%2.2x:%2.2x\n", Caller, greft, greft, greftun, greftun, gref.__wrapped_data[0], gref.__wrapped_data[1], gref.__wrapped_data[2], gref.__wrapped_data[3])); }
int httproute_call(HttpSession *session) { queue_t *route_queue=&session->server->routes; char *path=session->request.path; queue_t *q=NULL; HttpRoute *route; //printf("httproute_call in !\n"); if(queue_empty(route_queue))return 404; for(q = queue_prev(route_queue); q != queue_sentinel(route_queue); q = queue_last(q) ) { route = queue_data(q, HttpRoute, node); if(strcmp(path,route->path)==0 ) { TraceInfo("route callback found!\n"); return route->func(session,route->arg); } } TraceInfo("route callback not found!\n"); return 404; }
//This routine sets the state of the Feature: in this case Segment Display on the USB FX2 board. NTSTATUS SendVendorCommand(_In_ WDFDEVICE hDevice, _In_ unsigned char bVendorCommand, _In_ unsigned char bCommandData) { NTSTATUS status = STATUS_SUCCESS; ULONG cBytesTransferred = 0; PDEVICE_EXTENSION pDevContext = NULL; WDF_MEMORY_DESCRIPTOR memDesc; WDF_USB_CONTROL_SETUP_PACKET controlSetupPacket; WDF_REQUEST_SEND_OPTIONS sendOptions; PAGED_CODE(); TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n"); pDevContext = GetDeviceContext(hDevice); TraceInfo(DBG_IOCTL, "(%!FUNC!): Command:0x%x, data: 0x%x\n", bVendorCommand, bCommandData); // Send the I/O with a timeout. // We do that because we send the I/O in the context of the user thread and if it gets stuck, it would prevent the user process from existing. WDF_REQUEST_SEND_OPTIONS_INIT(&sendOptions, WDF_REQUEST_SEND_OPTION_TIMEOUT); WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&sendOptions, WDF_REL_TIMEOUT_IN_SEC(5)); WDF_USB_CONTROL_SETUP_PACKET_INIT_VENDOR(&controlSetupPacket, BmRequestHostToDevice, BmRequestToDevice, bVendorCommand, // Request 0, // Value 0); // Index WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&memDesc, &bCommandData, sizeof(bCommandData)); status = WdfUsbTargetDeviceSendControlTransferSynchronously(pDevContext->hUsbDevice, WDF_NO_HANDLE, // Optional WDFREQUEST &sendOptions, // PWDF_REQUEST_SEND_OPTIONS &controlSetupPacket, &memDesc, &cBytesTransferred); if (!NT_SUCCESS(status)) { TraceErr(DBG_IOCTL, "(%!FUNC!): Failed to set Segment Display state - %!STATUS!\n", status); } TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n"); return status; }
//---------------------------------------------------------------------------------------------------------------------------- VOID Subsystem::Destroy() { Trace0Enter(""); m_State = 0; if (m_pThread) { TraceInfo(this, "Waiting for subsystem to terminate itself"); if (!m_pThread->Wait(2000)) { TraceWarning(this, "The subsystem manager timed-out whilst waiting for the subsystem to terminate. Subsystem will be forcably terminated"); m_pThread->Terminate(); } m_pThread = 0; } }
/* similar to xenvbd:ProbeBackendCapabiities() */ static void probe_backend_capabilities(struct scsifilt *sf) { NTSTATUS status; ULONG64 order; status = xenbus_read_domain_id(XBT_NIL, sf->frontend_path, "backend-id", &sf->backend_domid); if (!NT_SUCCESS(status)) { TraceError(("Failed to read backend id from %s (%x)\n", sf->frontend_path, status)); sf->backend_domid = DOMAIN_ID_0(); } /* check to see if we used a multi-page handshake previously */ status = xenbus_read_int(XBT_NIL, sf->frontend_path, "ring-page-order", &order); if (NT_SUCCESS(status)) { XM_ASSERT3U(order, <=, MAX_RING_PAGE_ORDER); sf->single_page = FALSE; sf->ring_order = (ULONG)order; return; } /* assume single page handshake */ sf->single_page = TRUE; sf->ring_order = 0; status = xenbus_read_int(XBT_NIL, sf->backend_path, "max-ring-page-order", &order); if (NT_SUCCESS(status)) { if (order > MAX_RING_PAGE_ORDER) order = MAX_RING_PAGE_ORDER; sf->single_page = FALSE; sf->ring_order = (ULONG)order; } TraceInfo(("Using %u sring page(s).\n", 1 << sf->ring_order)); }
static ULONG BalloonGetTopPage( VOID ) { PHYSICAL_MEMORY_RANGE *Range; PHYSICAL_ADDRESS TopAddress; ULONG Index; Range = MmGetPhysicalMemoryRanges(); TopAddress.QuadPart = 0ull; for (Index = 0; Range[Index].BaseAddress.QuadPart != 0 || Range[Index].NumberOfBytes.QuadPart != 0; Index++) { PHYSICAL_ADDRESS EndAddress; CHAR Key[32]; EndAddress.QuadPart = Range[Index].BaseAddress.QuadPart + Range[Index].NumberOfBytes.QuadPart; TraceInfo(("PHYSICAL MEMORY: RANGE[%u] %08x.%08x - %08x.%08x\n", Index, Range[Index].BaseAddress.HighPart, Range[Index].BaseAddress.LowPart, EndAddress.HighPart, EndAddress.LowPart)); (VOID) Xmsnprintf(Key, sizeof (Key), "data/physical-memory/range%u", Index); (VOID) xenbus_printf(XBT_NIL, Key, "base", "%08x.%08x", Range[Index].BaseAddress.HighPart, Range[Index].BaseAddress.LowPart); (VOID) xenbus_printf(XBT_NIL, Key, "end", "%08x.%08x", EndAddress.HighPart, EndAddress.LowPart); if (EndAddress.QuadPart > TopAddress.QuadPart) TopAddress.QuadPart = EndAddress.QuadPart; } TraceNotice(("PHYSICAL MEMORY: TOP = %08x.%08x\n", TopAddress.HighPart, TopAddress.LowPart)); return (ULONG)(TopAddress.QuadPart >> PAGE_SHIFT); }
NTSTATUS NTAPI DriverEntry(PDRIVER_OBJECT driverObject, PUNICODE_STRING registryPath) { UNREFERENCED_PARAMETER(registryPath); TraceVerbose(("====> '%s'.\n", __FUNCTION__)); PsGetVersion(&g_osMajorVersion, &g_osMinorVersion, NULL, NULL); if ((g_osMajorVersion < 5)||((g_osMajorVersion == 5)&&(g_osMinorVersion < 1))) { TraceWarning(("Windows XP or later operating systems supported!\n")); return STATUS_UNSUCCESSFUL; } TraceInfo(("Starting driver...\n")); driverObject->DriverUnload = V4vDriverUnload; driverObject->DriverExtension->AddDevice = V4vAddDevice; driverObject->MajorFunction[IRP_MJ_CREATE] = V4vDispatchCreate; driverObject->MajorFunction[IRP_MJ_CLEANUP] = V4vDispatchCleanup; driverObject->MajorFunction[IRP_MJ_CLOSE] = V4vDispatchClose; driverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = V4vDispatchDeviceControl; driverObject->MajorFunction[IRP_MJ_READ] = V4vDispatchRead; driverObject->MajorFunction[IRP_MJ_WRITE] = V4vDispatchWrite; driverObject->MajorFunction[IRP_MJ_PNP] = V4vDispatchPnP; driverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = V4vDispatchWmi; driverObject->MajorFunction[IRP_MJ_POWER] = V4vDispatchPower; // The rest can be handled by the system not supported routine TraceVerbose(("DriverEntry returning successfully\n")); TraceVerbose(("<==== '%s'.\n", __FUNCTION__)); return STATUS_SUCCESS; }
// This event is called when the framework receives IRP_MJ_INTERNAL DEVICE_CONTROL requests from the system. // void HidFx2EvtInternalDeviceControl( _In_ WDFQUEUE hQueue, _In_ WDFREQUEST hRequest, _In_ size_t cOutputBufferLength, _In_ size_t cInputBufferLength, _In_ ULONG ulIoControlCode ) { NTSTATUS status = STATUS_SUCCESS; WDFDEVICE hDevice; PDEVICE_EXTENSION pDevContext = NULL; UNREFERENCED_PARAMETER(cOutputBufferLength); UNREFERENCED_PARAMETER(cInputBufferLength); TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n"); hDevice = WdfIoQueueGetDevice(hQueue); pDevContext = GetDeviceContext(hDevice); TraceInfo(DBG_IOCTL, "(%!FUNC!) Queue:0x%p, Request:0x%p\n", hQueue, hRequest); switch (ulIoControlCode) { case IOCTL_HID_GET_DEVICE_DESCRIPTOR: TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_DEVICE_DESCRIPTOR\n"); status = HidFx2GetHidDescriptor(hDevice, hRequest); WdfRequestComplete(hRequest, status); break; case IOCTL_HID_GET_DEVICE_ATTRIBUTES: TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_DEVICE_ATTRIBUTES\n"); status = HidFx2GetDeviceAttributes(hRequest); WdfRequestComplete(hRequest, status); break; case IOCTL_HID_GET_REPORT_DESCRIPTOR: TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_REPORT_DESCRIPTOR\n"); status = HidFx2GetReportDescriptor(hDevice, hRequest); WdfRequestComplete(hRequest, status); break; case IOCTL_HID_READ_REPORT: TraceInfo(DBG_IOCTL, "IOCTL_HID_READ_REPORT\n"); status = WdfRequestForwardToIoQueue(hRequest, pDevContext->hInterruptMsgQueue); if (!NT_SUCCESS(status)) { TraceErr(DBG_IOCTL, "WdfRequestForwardToIoQueue failed with status: %!STATUS!\n", status); WdfRequestComplete(hRequest, status); } break; case IOCTL_HID_SEND_IDLE_NOTIFICATION_REQUEST: TraceInfo(DBG_IOCTL, "IOCTL_HID_SEND_IDLE_NOTIFICATION_REQUEST\n"); status = HidFx2SendIdleNotification(hRequest); if (!NT_SUCCESS(status)) { TraceErr(DBG_IOCTL, "SendIdleNotification failed with status: %!STATUS!\n", status); WdfRequestComplete(hRequest, status); } break; case IOCTL_HID_GET_INPUT_REPORT: TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_INPUT_REPORT\n"); HidFx2GetInput(hRequest); WdfRequestComplete(hRequest, status); break; case IOCTL_HID_SET_OUTPUT_REPORT: TraceInfo(DBG_IOCTL, "IOCTL_HID_SET_OUTPUT_REPORT\n"); status = HidFx2SetOutput(hRequest); WdfRequestComplete(hRequest, status); break; default: TraceInfo(DBG_IOCTL, "IOCTL Not Supported 0x%X\n", ulIoControlCode); status = STATUS_NOT_SUPPORTED; WdfRequestComplete(hRequest, status); break; } TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n"); return; }
/* returns the return value of the blakod */ int SendBlakodMessage(int object_id,int message_id,int num_parms,parm_node parms[]) { object_node *o; class_node *c,*propagate_class; message_node *m; val_type message_ret; int prev_interpreting_class; char *prev_bkod; int propagate_depth = 0; prev_bkod = bkod; prev_interpreting_class = kod_stat.interpreting_class; o = GetObjectByID(object_id); if (o == NULL) { bprintf("SendBlakodMessage can't find OBJECT %i\n",object_id); return NIL; } c = GetClassByID(o->class_id); if (c == NULL) { eprintf("SendBlakodMessage OBJECT %i can't find CLASS %i\n", object_id,o->class_id); return NIL; } m = GetMessageByID(c->class_id,message_id,&c); if (m == NULL) { bprintf("SendBlakodMessage CLASS %s (%i) OBJECT %i can't find a handler for MESSAGE %s (%i)\n", c->class_name,c->class_id,object_id,GetNameByID(message_id),message_id); return NIL; } m->called_count++; kod_stat.num_messages++; stack[message_depth].class_id = c->class_id; stack[message_depth].message_id = m->message_id; stack[message_depth].propagate_depth = 0; stack[message_depth].num_parms = num_parms; memcpy(stack[message_depth].parms,parms,num_parms*sizeof(parm_node)); stack[message_depth].bkod_ptr = bkod; if (message_depth > 0) stack[message_depth-1].bkod_ptr = prev_bkod; message_depth++; if (message_depth > kod_stat.message_depth_highest) kod_stat.message_depth_highest = message_depth; if (message_depth >= MAX_DEPTH) { bprintf("SendBlakodMessage sending to CLASS %s (%i), depth is %i, aborted!\n", c->class_name,c->class_id,message_depth); kod_stat.interpreting_class = prev_interpreting_class; message_depth--; bkod = prev_bkod; return NIL; } if (m->trace_session_id != INVALID_ID) { trace_session_id = m->trace_session_id; m->trace_session_id = INVALID_ID; } if (trace_session_id != INVALID_ID) TraceInfo(trace_session_id,c->class_name,m->message_id,num_parms,parms); kod_stat.interpreting_class = c->class_id; bkod = m->handler; propagate_depth = 1; while (InterpretAtMessage(object_id,c,m,num_parms,parms,&message_ret) == RETURN_PROPAGATE) { propagate_class = m->propagate_class; m = m->propagate_message; if (m == NULL) { bprintf("SendBlakodMessage can't propagate MESSAGE %s (%i) in CLASS %s (%i)\n", GetNameByID(message_id),message_id,c->class_name,c->class_id); message_depth -= propagate_depth; kod_stat.interpreting_class = prev_interpreting_class; bkod = prev_bkod; return NIL; } if (propagate_class == NULL) { bprintf("SendBlakodMessage can't find class to propagate to, from " "MESSAGE %s (%i) in CLASS %s (%i)\n",GetNameByID(message_id),message_id,c->class_name,c->class_id); message_depth -= propagate_depth; kod_stat.interpreting_class = prev_interpreting_class; bkod = prev_bkod; return NIL; } c = propagate_class; m->called_count++; if (m->trace_session_id != INVALID_ID) { trace_session_id = m->trace_session_id; m->trace_session_id = INVALID_ID; } if (trace_session_id != INVALID_ID) TraceInfo(trace_session_id,"(propagate)",m->message_id,num_parms,parms); kod_stat.interpreting_class = c->class_id; stack[message_depth-1].bkod_ptr = bkod; stack[message_depth].class_id = c->class_id; stack[message_depth].message_id = m->message_id; stack[message_depth].propagate_depth = propagate_depth; stack[message_depth].num_parms = num_parms; memcpy(stack[message_depth].parms,parms,num_parms*sizeof(parm_node)); stack[message_depth].bkod_ptr = m->handler; message_depth++; propagate_depth++; bkod = m->handler; } message_depth -= propagate_depth; kod_stat.interpreting_class = prev_interpreting_class; bkod = prev_bkod; return message_ret.int_val; }
static NTSTATUS XenLowerConnectBackendInternal( PXEN_LOWER XenLower, SUSPEND_TOKEN Token) { NTSTATUS status = STATUS_SUCCESS; XENBUS_STATE state; xenbus_transaction_t xbt; PCHAR fepath; if (is_null_EVTCHN_PORT(XenLower->EvtchnPort)) { TraceError((__FUNCTION__ ": no event channel port, this routine must be called after event channel initialization\n")); return STATUS_UNSUCCESSFUL; } //---------------------------Backend Wait Ready-------------------------------// // // Wait for backend to get ready for initialization. // status = xenbus_change_state(XBT_NIL, XenLower->FrontendPath, "state", XENBUS_STATE_INITIALISING); if (!NT_SUCCESS(status)) { TraceWarning((__FUNCTION__ ": Failed to change front end state to XENBUS_STATE_INITIALISING(%d) status: 0x%x\n", XENBUS_STATE_INITIALISING, status)); // Go on, best effort, chin up } TraceInfo((__FUNCTION__ ": Front end state set to XENBUS_STATE_INITIALISING(%d)\n", XENBUS_STATE_INITIALISING)); state = null_XENBUS_STATE(); for ( ; ; ) { // Turns out suspend tokens are not even used. state = XenbusWaitForBackendStateChange(XenLower->BackendPath, state, NULL, Token); if (same_XENBUS_STATE(state, XENBUS_STATE_INITWAIT)) { break; } if (same_XENBUS_STATE(state, XENBUS_STATE_CLOSING) || is_null_XENBUS_STATE(state)) { TraceError((__FUNCTION__ ": backend '%s' went away before we could connect to it?\n", XenLower->BackendPath)); status = STATUS_UNSUCCESSFUL; break; } } if (status != STATUS_SUCCESS) { return status; } TraceInfo((__FUNCTION__ ": Back end state went to XENBUS_STATE_INITWAIT(%d)\n", XENBUS_STATE_INITWAIT)); //----------------------------Backend Connect---------------------------------// // // Communicate configuration to backend. // fepath = XenLower->FrontendPath; do { xenbus_transaction_start(&xbt); xenbus_write_grant_ref(xbt, fepath, "ring-ref", XenLower->SringGrantRef); xenbus_write_evtchn_port(xbt, fepath, "event-channel", XenLower->EvtchnPort); xenbus_change_state(xbt, fepath, "state", XENBUS_STATE_CONNECTED); status = xenbus_transaction_end(xbt, 0); } while (status == STATUS_RETRY); if (status != STATUS_SUCCESS) { TraceError((__FUNCTION__ ": failed to configure xenstore frontend values.\n")); return STATUS_UNSUCCESSFUL; } TraceInfo((__FUNCTION__ ": Front end state set to XENBUS_STATE_CONNECTED(%d)\n", XENBUS_STATE_CONNECTED)); // // Wait for backend to accept configuration and complete initialization. // state = null_XENBUS_STATE(); for ( ; ; ) { state = XenbusWaitForBackendStateChange(XenLower->BackendPath, state, NULL, Token); if (is_null_XENBUS_STATE(state) || same_XENBUS_STATE(state, XENBUS_STATE_CLOSING) || same_XENBUS_STATE(state, XENBUS_STATE_CLOSED)) { TraceError((__FUNCTION__ ": Failed to connected '%s' <-> '%s' backend state: %d\n", XenLower->FrontendPath, XenLower->BackendPath, state)); status = STATUS_UNSUCCESSFUL; break; } if (same_XENBUS_STATE(state, XENBUS_STATE_CONNECTED)) { TraceNotice((__FUNCTION__ ": Connected '%s' <-> '%s' \n", XenLower->FrontendPath, XenLower->BackendPath)); TraceInfo((__FUNCTION__ ": Back end final state went to XENBUS_STATE_CONNECTED(%d)\n", XENBUS_STATE_CONNECTED)); break; } } return status; }
VOID XenGfxReadRegistryValues(XENGFX_DEVICE_EXTENSION *pXenGfxExtension, PUNICODE_STRING pDeviceRegistryPath) { #define _XENGFX_REGBUF_SPACE 240 NTSTATUS Status; HANDLE Key = NULL; ULONG Len = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(WCHAR)*_XENGFX_REGBUF_SPACE; // room for 240 UNICODE chars ULONG LenOut; UNICODE_STRING ValueName; OBJECT_ATTRIBUTES ObjectAttrs; KEY_VALUE_PARTIAL_INFORMATION *pKvpi = NULL; PAGED_CODE(); do { TraceVerbose(("%s Reading XENGFX device registry location: %.*ws\n", __FUNCTION__, pDeviceRegistryPath->Length >> 1, pDeviceRegistryPath->Buffer)); // Make a buffer for registry data pKvpi = (KEY_VALUE_PARTIAL_INFORMATION*)ExAllocatePoolWithTag(PagedPool, Len, XENGFX_TAG); if (pKvpi == NULL) { TraceError(("%s Failed to alloc registry read buffer!!\n", __FUNCTION__)); break; } // Open the device key, it should be present. InitializeObjectAttributes(&ObjectAttrs, pDeviceRegistryPath, OBJ_CASE_INSENSITIVE, NULL, NULL); Status = ZwOpenKey(&Key, KEY_QUERY_VALUE, &ObjectAttrs); if (!NT_SUCCESS(Status)) { TraceError(("%s Failed to open registry key for driver - error: 0x%x\n", __FUNCTION__, Status)); break; } // Get the ChildDeviceCount value - continue if it is not there. RtlInitUnicodeString(&ValueName, XENGFX_REG_CHILDDEVICECOUNT); RtlZeroMemory(pKvpi, Len); Status = ZwQueryValueKey(Key, &ValueName, KeyValuePartialInformation, pKvpi, Len, &LenOut); if ((!NT_SUCCESS(Status))||(pKvpi->Type != REG_DWORD)||(pKvpi->DataLength != sizeof(ULONG))) { TraceInfo(("%s Could not query ChildDeviceCount (may not be present) - type: %d length: 0x%x status: 0x%x\n", __FUNCTION__, pKvpi->Type, pKvpi->DataLength, Status)); } else pXenGfxExtension->VCrtcRegistryCount = *((ULONG*)pKvpi->Data); // Get the VidPnTracing value - continue if it is not there. RtlInitUnicodeString(&ValueName, XENGFX_REG_VIDPNTRACING); RtlZeroMemory(pKvpi, Len); Status = ZwQueryValueKey(Key, &ValueName, KeyValuePartialInformation, pKvpi, Len, &LenOut); if ((!NT_SUCCESS(Status))||(pKvpi->Type != REG_DWORD)||(pKvpi->DataLength != sizeof(ULONG))) { TraceInfo(("%s Could not query VidPnTracing (may not be present) - type: %d length: 0x%x status: 0x%x\n", __FUNCTION__, pKvpi->Type, pKvpi->DataLength, Status)); } else pXenGfxExtension->VidPnTracing = (*((ULONG*)pKvpi->Data) != 0) ? TRUE : FALSE; // Get the VidPnTracing value - continue if it is not there. RtlInitUnicodeString(&ValueName, XENGFX_REG_DEBUGLOGNAME); RtlZeroMemory(pKvpi, Len); Status = ZwQueryValueKey(Key, &ValueName, KeyValuePartialInformation, pKvpi, Len, &LenOut); if ((!NT_SUCCESS(Status))||(pKvpi->Type != REG_SZ)||(pKvpi->DataLength > _XENGFX_REGBUF_SPACE*sizeof(WCHAR))) { TraceInfo(("%s Could not query DebugLogName (may not be present) - type: %d length: 0x%x status: 0x%x\n", __FUNCTION__, pKvpi->Type, pKvpi->DataLength, Status)); } else { RtlStringCchCopyW(pXenGfxExtension->DebugLogName, pKvpi->DataLength/sizeof(WCHAR), (CONST WCHAR*)pKvpi->Data); TraceInfo(("%s DebugLogName: %S\n", __FUNCTION__, pXenGfxExtension->DebugLogName)); } } while (FALSE); if (pKvpi != NULL) ExFreePoolWithTag(pKvpi, XENGFX_TAG); }
// This the completion routine of the continuous reader. This can called concurrently on multiprocessor system if there are // more than one readers configured. So make sure to protect access to global resources. // void HidFx2EvtUsbInterruptPipeReadComplete( WDFUSBPIPE hPipe, WDFMEMORY hBuffer, size_t cNumBytesTransferred, WDFCONTEXT pContext ) { PDEVICE_EXTENSION pDevContext = pContext; BOOLEAN fInTimerQueue; unsigned char *pbSwitchState = NULL; unsigned char bCurrentSwitchState = 0; unsigned char bPrevSwitchState = 0; unsigned char bToggledSwitch = 0; UNREFERENCED_PARAMETER(cNumBytesTransferred); UNREFERENCED_PARAMETER(hPipe); TraceVerbose(DBG_INIT, "(%!FUNC!) Enter\n"); // Interrupt endpoints sends switch state when first started or when resuming from suspend. // We need to ignore that data since user did not change the switch state. if (pDevContext->fIsPowerUpSwitchState) { pDevContext->fIsPowerUpSwitchState = FALSE; TraceInfo(DBG_INIT, "(%!FUNC!) Dropping interrupt message since received during powerup/resume\n"); return; } // Make sure that there is data in the read packet. // Depending on the device specification, it is possible for it to return a 0 length read in certain conditions. if (cNumBytesTransferred == 0) { TraceWarning(DBG_INIT, "(%!FUNC!) Zero length read occured on the Interrupt Pipe's Continuous Reader\n"); return; } pbSwitchState = WdfMemoryGetBuffer(hBuffer, NULL); bCurrentSwitchState = ~(*pbSwitchState); // switchs are inverted on hardware boards bCurrentSwitchState &= RADIO_SWITCH_BUTTONS_BIT_MASK; //Mask off everything except the actual radio switch bit bPrevSwitchState = pDevContext->bCurrentSwitchState; if (bPrevSwitchState ^ bCurrentSwitchState) // make sure we toggled the radio switch { switch(pDevContext->driverMode) { // If it's a slider switch we want 0->1 and 1->0 transitions. case DM_SLIDER_SWITCH: case DM_SLIDER_SWITCH_AND_LED: bToggledSwitch = bCurrentSwitchState; // A timer is started for 10 ms everytime there is a switch toggled fInTimerQueue = WdfTimerStart(pDevContext->hDebounceTimer, WDF_REL_TIMEOUT_IN_MS(SWITCHPACK_DEBOUNCE_TIME)); TraceInfo(DBG_INIT, "(%!FUNC!) Debounce Timer started. Existing -%!bool!\n", fInTimerQueue); break; //If it's a button so we only report 0->1 transitions case DM_BUTTON: case DM_BUTTON_AND_LED: bToggledSwitch = (bPrevSwitchState ^ bCurrentSwitchState) & bCurrentSwitchState; if (bToggledSwitch != 0) { // A timer is started for 10 ms everytime there is a switch toggled on fInTimerQueue = WdfTimerStart(pDevContext->hDebounceTimer, WDF_REL_TIMEOUT_IN_MS(SWITCHPACK_DEBOUNCE_TIME)); TraceInfo(DBG_INIT, "(%!FUNC!) Debounce Timer started. Existing -%!bool!\n", fInTimerQueue); } break; // Ignore button presses if LED only case DM_LED_ONLY: default: break; } // Store switch state in device context pDevContext->bCurrentSwitchState = bCurrentSwitchState; pDevContext->bLatestToggledSwitch = bToggledSwitch; } else { TraceInfo(DBG_INIT, "(%!FUNC!) Not a radio switch toggle\n"); } TraceInfo(DBG_INIT, "(%!FUNC!) Switch 0x%x, prevSwitch:0x%x, X0R:0x%x\n", bCurrentSwitchState, bPrevSwitchState, bToggledSwitch); TraceVerbose(DBG_INIT, "(%!FUNC!) Exit\n"); }