自学教程：C++ DBG_LEAVE函数代码示例

NDIS_STATUSPGPnetPMNewSA(PGPnetPMContext *pContext, 			  void *data, 			  UINT dataLen, 			  ULONG *pSrcBufferLen){    DBG_FUNC("PGPnetPMNewSA")    DBG_ENTER();	*pSrcBufferLen = sizeof(PGPikeSA);	if (dataLen != *pSrcBufferLen) {		DBG_LEAVE(NDIS_STATUS_INVALID_LENGTH);		return NDIS_STATUS_INVALID_LENGTH;	}	if (!PMAddSA(pContext, (PGPikeSA*) data)) {		DBG_LEAVE(NDIS_STATUS_FAILURE);		return NDIS_STATUS_FAILURE;	}	*pSrcBufferLen = 0;    DBG_LEAVE(NDIS_STATUS_SUCCESS);	return NDIS_STATUS_SUCCESS;}

NDIS_STATUSPGPnetPMFailedSA(PGPnetPMContext *pContext, 				 void *data,				 UINT dataLen,				 ULONG *pSrcBufferLen){    DBG_FUNC("PGPnetPMFailedSA")	PGPikeMTSAFailed * pSAFailed = (PGPikeMTSAFailed*)data;    DBG_ENTER();	*pSrcBufferLen = sizeof(PGPikeMTSAFailed);	if (dataLen != *pSrcBufferLen) {		DBG_LEAVE(NDIS_STATUS_INVALID_LENGTH);		return NDIS_STATUS_INVALID_LENGTH;	}	PMRemovePendingSA(pContext, pSAFailed->ipAddress,		pSAFailed->u.ipsec.ipAddrStart,		pSAFailed->u.ipsec.ipMaskEnd);	*pSrcBufferLen = 0;    DBG_LEAVE(NDIS_STATUS_SUCCESS);	return NDIS_STATUS_SUCCESS;}

/** * et131x_device_alloc * * Returns pointer to the allocated and initialized net_device struct for * this device. * * Create instances of net_device and wl_private for the new adapter and * register the device's entry points in the net_device structure. */struct net_device *et131x_device_alloc(void){	struct net_device *netdev;	DBG_ENTER(et131x_dbginfo);	/* Alloc net_device and adapter structs */	netdev = alloc_etherdev(sizeof(struct et131x_adapter));	if (netdev == NULL) {		DBG_ERROR(et131x_dbginfo,			  "Alloc of net_device struct failed/n");		DBG_LEAVE(et131x_dbginfo);		return NULL;	}	/* Setup the function registration table (and other data) for a	 * net_device	 */	//netdev->init               = &et131x_init;	//netdev->set_config = &et131x_config;	netdev->watchdog_timeo = ET131X_TX_TIMEOUT;	netdev->netdev_ops = &et131x_netdev_ops;	//netdev->ethtool_ops        = &et131x_ethtool_ops;	// Poll?	//netdev->poll               = &et131x_poll;	//netdev->poll_controller    = &et131x_poll_controller;	DBG_LEAVE(et131x_dbginfo);	return netdev;}

/******************************************************************************* *	wl_adapter_open() ******************************************************************************* * *  DESCRIPTION: * *      Open the device. * *  PARAMETERS: * *      dev - a pointer to a net_device structure representing the network *            device to open. * *  RETURNS: * *      0 on success *      errno value otherwise * ******************************************************************************/int wl_adapter_open(struct net_device *dev){	struct wl_private *lp = wl_priv(dev);	struct pcmcia_device *link = lp->link;	int result = 0;	int hcf_status = HCF_SUCCESS;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_open");	DBG_ENTER(DbgInfo);	DBG_PRINT("%s/n", VERSION_INFO);	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);	if (!pcmcia_dev_present(link)) {		DBG_LEAVE(DbgInfo);		return -ENODEV;	}	link->open++;	hcf_status = wl_open(dev);	if (hcf_status != HCF_SUCCESS) {		link->open--;		result = -ENODEV;	}	DBG_LEAVE(DbgInfo);	return result;} /* wl_adapter_open */

NDIS_STATUSPGPnetPMNewHost(PGPnetPMContext *context, 				void *data,				UINT dataLen,				ULONG *pSrcBufferLen){    DBG_FUNC("PGPnetPMNewHost")    DBG_ENTER();	*pSrcBufferLen = sizeof(PGPNetHostEntry) - 8; /* minus 8 bytes for eth_dstAddress */	if (dataLen != *pSrcBufferLen) {		DBG_LEAVE(NDIS_STATUS_INVALID_LENGTH);		return NDIS_STATUS_INVALID_LENGTH;	}	if (!PMAddHost(context, (PGPNetHostEntry*) data)) {		DBG_LEAVE(NDIS_STATUS_FAILURE);		return NDIS_STATUS_FAILURE;	}	*pSrcBufferLen = 0;	DBG_LEAVE(NDIS_STATUS_SUCCESS);	return NDIS_STATUS_SUCCESS;}

void wl_adapter_insert(struct pcmcia_device *link){	struct net_device *dev;	int i;	int ret;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_insert");	DBG_ENTER(DbgInfo);	DBG_PARAM(DbgInfo, "link", "0x%p", link);	dev     = link->priv;	/* Do we need to allocate an interrupt? */	link->config_flags |= CONF_ENABLE_IRQ;	link->io_lines = 6;	ret = pcmcia_request_io(link);	if (ret != 0)		goto failed;	ret = pcmcia_request_irq(link, (void *) wl_isr);	if (ret != 0)		goto failed;	ret = pcmcia_enable_device(link);	if (ret != 0)		goto failed;	dev->irq        = link->irq;	dev->base_addr  = link->resource[0]->start;	SET_NETDEV_DEV(dev, &link->dev);	if (register_netdev(dev) != 0) {;		goto failed;	}	register_wlags_sysfs(dev);//	printk(KERN_INFO "%s: Wireless, io_addr %#03lx, irq %d, ""mac_address ",;	for (i = 0; i < ETH_ALEN; i++);	DBG_LEAVE(DbgInfo);	return;failed:	wl_adapter_release(link);	DBG_LEAVE(DbgInfo);	return;} /* wl_adapter_insert */

void wl_adapter_insert( struct pcmcia_device *link ){    struct net_device       *dev;    int i;    int                     ret;    /*------------------------------------------------------------------------*/    DBG_FUNC( "wl_adapter_insert" );    DBG_ENTER( DbgInfo );    DBG_PARAM( DbgInfo, "link", "0x%p", link );    dev     = link->priv;    /* Do we need to allocate an interrupt? */    link->conf.Attributes |= CONF_ENABLE_IRQ;    ret = pcmcia_request_io(link, &link->io);    if (ret != 0)        goto failed;    ret = pcmcia_request_irq(link, (void *) wl_isr);    if (ret != 0)        goto failed;    ret = pcmcia_request_configuration(link, &link->conf);    if (ret != 0)        goto failed;    dev->irq        = link->irq;    dev->base_addr  = link->io.BasePort1;    SET_NETDEV_DEV(dev, &link->dev);    if (register_netdev(dev) != 0) {	printk("%s: register_netdev() failed/n", MODULE_NAME);	goto failed;    }    register_wlags_sysfs(dev);    printk(KERN_INFO "%s: Wireless, io_addr %#03lx, irq %d, ""mac_address ",               dev->name, dev->base_addr, dev->irq);    for( i = 0; i < ETH_ALEN; i++ ) {        printk("%02X%c", dev->dev_addr[i], ((i < (ETH_ALEN-1)) ? ':' : '/n'));    }    DBG_LEAVE( DbgInfo );    return;failed:    wl_adapter_release( link );    DBG_LEAVE(DbgInfo);    return;} // wl_adapter_insert

//// DispatchCreate()://// This is the Add Device dispatch for the capture device.  It creates// the CCaptureDevice and associates it with the device via the bag.//NTSTATUSCAvsCameraDevice::DispatchCreate (    _In_ PKSDEVICE Device){    PAGED_CODE();    DBG_ENTER("()");    CAvsCameraDevice *CapDevice = new (NonPagedPoolNx, 'eviD') CAvsCameraDevice (Device);    if( !CapDevice)    {        //        //  Return failure if we couldn't create the device.        //        return STATUS_INSUFFICIENT_RESOURCES;    }    NTSTATUS Status = CapDevice->Prepare();    if (!NT_SUCCESS (Status))    {        //  Init failure.        delete CapDevice;    }    DBG_LEAVE("()");    return Status;}

/** * et131x_close - Close the device * @netdev: device to be closed * * Returns 0 on success, errno on failure (as defined in errno.h) */int et131x_close(struct net_device *netdev){	struct et131x_adapter *adapter = netdev_priv(netdev);	DBG_ENTER(et131x_dbginfo);	/* First thing is to stop the queue */	netif_stop_queue(netdev);	/* Stop the Tx and Rx DMA engines */	et131x_rx_dma_disable(adapter);	et131x_tx_dma_disable(adapter);	/* Disable device interrupts */	et131x_disable_interrupts(adapter);	/* Deregistering ISR */	MP_CLEAR_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);	DBG_TRACE(et131x_dbginfo, "Deregistering ISR.../n");	free_irq(netdev->irq, netdev);	/* Stop the error timer */	del_timer_sync(&adapter->ErrorTimer);	DBG_LEAVE(et131x_dbginfo);	return 0;}

NTSTATUSCCaptureDevice::DispatchQueryPower(    _In_ PKSDEVICE Device,    _In_ PIRP Irp,    _In_ DEVICE_POWER_STATE DeviceTo,    _In_ DEVICE_POWER_STATE DeviceFrom,    _In_ SYSTEM_POWER_STATE SystemTo,    _In_ SYSTEM_POWER_STATE SystemFrom,    _In_ POWER_ACTION Action){    //  If this device supports the the DO_POWER_INRUSH flag, this function    //  can be called at DISPATCH.    DBG_ENTER("()");    NTSTATUS Status =        Recast(Device)->        PnpQueryPower(            Irp,            DeviceTo,            DeviceFrom,            SystemTo,            SystemFrom,            Action );    DBG_LEAVE("()=0x%08X", Status);    return Status;}

//  Function://      bool CImageHardwareSimulation::IsPfsEOS(void)////  Description://      Determine if we're at the EOS.////  Parameters://      [None]////  Returns://      bool - true if we've reached the end of our Per Frame Settings.//boolCImageHardwareSimulation::IsPfsEOS(void){    PAGED_CODE();    DBG_ENTER( "()" );    DBG_TRACE( "m_bTriggered=%s, m_bEndOfSequence=%s, m_PinMode=%d, m_pIspSetting=0x%p",               ( m_bTriggered ? "true" : "false" ),               ( m_bEndOfSequence ? "true" : "false" ),               m_PinMode,               m_pIspSettings );    //    //  Make sure we're in a Variable Photo Sequence.    //    bool result =        bool( m_bTriggered == TRUE &&              m_bEndOfSequence &&              m_PinMode == PinBurstMode &&              m_pIspSettings );       // Must have ISP settings set to be PFS EOS.    DBG_LEAVE( "() = %s", (result ? "true" : "false") );    return result;}

int wl_get_tallies(struct wl_private *lp,		   CFG_HERMES_TALLIES_STRCT *tallies){    int ret = 0;    int status;    CFG_HERMES_TALLIES_STRCT *pTallies;    DBG_FUNC( "wl_get_tallies" );    DBG_ENTER(DbgInfo);    /* Get the current tallies from the adapter */    lp->ltvRecord.len = 1 + HCF_TOT_TAL_CNT * sizeof(hcf_16);    lp->ltvRecord.typ = CFG_TALLIES;    status = hcf_get_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));    if( status == HCF_SUCCESS ) {	pTallies = (CFG_HERMES_TALLIES_STRCT *)&(lp->ltvRecord.u.u32);	memcpy(tallies, pTallies, sizeof(*tallies));	DBG_TRACE( DbgInfo, "Get tallies okay, dixe: %d/n", sizeof(*tallies) );    } else {	DBG_TRACE( DbgInfo, "Get tallies failed/n" );	ret = -EFAULT;    }    DBG_LEAVE( DbgInfo );    return ret;}

LONGCImageHardwareSimulation::GetTriggerMode()/*++Returns the pin's current trigger mode and state:    Return Value:    mode -         Normal trigger, start or stop photo sequence.        --*/{    PAGED_CODE();    NTSTATUS status = STATUS_SUCCESS;    LONG	 mode = 0;    DBG_ENTER( "(), m_PinMode=%d", m_PinMode );    KScopedMutex Lock( m_ListLock );    if( m_bTriggered )    {        mode = (m_PinMode == PinBurstMode) ?            KS_VideoControlFlag_StartPhotoSequenceCapture :            KS_VideoControlFlag_Trigger;    }    DBG_LEAVE("()=0x%08X", mode);    return mode;}

static int wl_adapter_attach(struct pcmcia_device *link){    struct net_device   *dev;    struct wl_private	*lp;    /*------------------------------------------------------------------------*/    DBG_FUNC( "wl_adapter_attach" );    DBG_ENTER( DbgInfo );    dev = wl_device_alloc();    if(dev == NULL) {        DBG_ERROR( DbgInfo, "wl_device_alloc returned NULL/n");	return -ENOMEM;    }    link->io.NumPorts1      = HCF_NUM_IO_PORTS;    link->io.Attributes1    = IO_DATA_PATH_WIDTH_16;    link->io.IOAddrLines    = 6;    link->conf.Attributes   = CONF_ENABLE_IRQ;    link->conf.IntType      = INT_MEMORY_AND_IO;    link->conf.ConfigIndex  = 5;    link->conf.Present      = PRESENT_OPTION;    link->priv = dev;    lp = wl_priv(dev);    lp->link = link;    wl_adapter_insert(link);    DBG_LEAVE( DbgInfo );    return 0;} // wl_adapter_attach

voidPGPnetRASdisconnect(PVPN_ADAPTER adapter){	/* fire event */	DBG_FUNC("PGPnetRASdisconnect")	PGPMESSAGE_CONTEXT	*	kernelMessageContext;	PGPnetMessageHeader *	kernelMessageHeader;	PGPUInt32				head = 0;	DBG_ENTER();	if ((adapter != NULL) && (adapter->pgpMessage != NULL)) {		kernelMessageContext = (PGPMESSAGE_CONTEXT*)(adapter->pgpMessage);		kernelMessageHeader = &kernelMessageContext->header;				NdisAcquireSpinLock(&adapter->general_lock);		head = kernelMessageHeader->head + 1;		if (head > kernelMessageHeader->maxSlots)			head = 1;		kernelMessageContext = &kernelMessageContext[head];		kernelMessageContext->messageType = PGPnetMessageRASdisconnect;		kernelMessageHeader->head = head;		NdisReleaseSpinLock(&adapter->general_lock);		PgpEventSet(&adapter->pgpEvent);	}	DBG_LEAVE(0);}

/******************************************************************************* *	wl_adapter_attach() ******************************************************************************* * *  DESCRIPTION: * *      Creates an instance of the driver, allocating local data structures for *  one device. The device is registered with Card Services. * *  PARAMETERS: * *      none * *  RETURNS: * *      pointer to an allocated dev_link_t structure *      NULL on failure * ******************************************************************************/static int wl_adapter_attach(struct pcmcia_device *link){	struct net_device   *dev;	struct wl_private   *lp;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_attach");	DBG_ENTER(DbgInfo);	dev = wl_device_alloc();	if (dev == NULL) {		DBG_ERROR(DbgInfo, "wl_device_alloc returned NULL/n");		return -ENOMEM;	}	link->resource[0]->end  = HCF_NUM_IO_PORTS;	link->resource[0]->flags= IO_DATA_PATH_WIDTH_16;	link->config_flags     |= CONF_ENABLE_IRQ;	link->config_index      = 5;	link->config_regs       = PRESENT_OPTION;	link->priv = dev;	lp = wl_priv(dev);	lp->link = link;	wl_adapter_insert(link);	DBG_LEAVE(DbgInfo);	return 0;} /* wl_adapter_attach */

/******************************************************************************* *	wl_process_updated_record() ******************************************************************************* * *  DESCRIPTION: * *      Process the updated information record message signaled by the device. * *  PARAMETERS: * *      lp - a pointer to the device's private structure * *  RETURNS: * *      N/A * ******************************************************************************/void wl_process_updated_record( struct wl_private *lp ){    DBG_FUNC( "wl_process_updated_record" );    DBG_ENTER( DbgInfo );    if( lp != NULL ) {        lp->updatedRecord.u.u16[0] = CNV_LITTLE_TO_INT( lp->updatedRecord.u.u16[0] );        switch( lp->updatedRecord.u.u16[0] ) {        case CFG_CUR_COUNTRY_INFO:            DBG_TRACE( DbgInfo, "Updated Record: CFG_CUR_COUNTRY_INFO/n" );            wl_connect( lp );            break;        case CFG_PORT_STAT:            DBG_TRACE( DbgInfo, "Updated Record: WAIT_FOR_CONNECT (0xFD40)/n" );            //wl_connect( lp );            break;        default:            DBG_TRACE( DbgInfo, "UNKNOWN: 0x%04x/n",                       lp->updatedRecord.u.u16[0] );        }    }    DBG_LEAVE( DbgInfo );    return;} // wl_process_updated_record

NTSTATUSCImageHardwareSimulation::SetMode(    _In_    ULONGLONG Flags,    _In_    ULONG PastBuffers)/*++Routine Description:    Set the photo sequence mode.Arguments:    Flags -         Normal or photo sequence.    PastBuffers -        Number of history frames to gather.        Return Value:    Success / Failure (typical failure will be out of memory on the    scratch buffer, etc...)--*/{    PAGED_CODE();    DBG_ENTER( "(Flags=0x%016llX, PastBuffers=%d)", Flags, PastBuffers );    if(m_bTriggered == TRUE)    {        return STATUS_INVALID_TRANSACTION;    }    m_PastBufferCount = PastBuffers;    if(Flags & KSCAMERA_EXTENDEDPROP_PHOTOMODE_SEQUENCE)    {        m_PinMode = PinBurstMode;    }    else    {        m_PinMode = PinNormalMode;    }    DBG_LEAVE("()");    return STATUS_SUCCESS;}

NTSTATUSCHardwareSimulation::GeneratePhotoConfirmation(    _In_ ULONG      PfsFrameNumber,    _In_ LONGLONG   time)/*++Routine Description:    So a photo sim can ask a preview sim for a confirmation frame.Arguments:    PfsFrameNumber -        The VPS shot number.    time -        The precise time of the associated photo.Return Value:    None--*/{    PAGED_CODE();    KScopedMutex Lock( m_ListLock );    if( PinRunning != m_PinState )    {        return STATUS_DEVICE_NOT_READY;    }    DBG_ENTER("( Index=%d, Time=0x%016llX )", PfsFrameNumber, time );    m_PhotoConfirmationEntry = PHOTOCONFIRMATION_INFO( PfsFrameNumber, time );    // We basically used the previously synthesized preview image    NTSTATUS status = FillScatterGatherBuffers();    //Clean up the photo confiramtion flag    m_PhotoConfirmationEntry = PHOTOCONFIRMATION_INFO();    if(NT_SUCCESS(status))    {        m_Sensor->Interrupt (m_PinID);    }    DBG_LEAVE("() = 0x%08X", status);    return status;}

/******************************************************************************* *	wl_adapter_cleanup_module() ******************************************************************************* * *  DESCRIPTION: * *      Called by cleanup_module() to perform driver uninitialization. * *  PARAMETERS: * *      N/A * *  RETURNS: * *      N/A * ******************************************************************************/void wl_adapter_cleanup_module(void){	DBG_FUNC("wl_adapter_cleanup_module");	DBG_ENTER(DbgInfo);	DBG_TRACE(DbgInfo, "wl_adapter_cleanup_module() -- PCMCIA/n");	pcmcia_unregister_driver(&wlags49_driver);	DBG_LEAVE(DbgInfo);	return;} /* wl_adapter_cleanup_module */

/******************************************************************************* *	ParseConfigLine() ******************************************************************************* * *  DESCRIPTION: * *      Parses a line from the configuration file into an L-val and an R-val, *  representing a key/value pair. * *  PARAMETERS: * *      pszLine     - the line from the config file to parse *      ppszLVal    - the resulting L-val (Key) *      ppszRVal    - the resulting R-val (Value) * *  RETURNS: * *      N/A * ******************************************************************************/void ParseConfigLine(char *pszLine, char **ppszLVal, char **ppszRVal){	int i;	int size;	/*------------------------------------------------------------------------*/	DBG_FUNC("ParseConfigLine");	DBG_ENTER(DbgInfo);	/* get a snapshot of our string size */	size      = strlen(pszLine);	*ppszLVal = NULL;	*ppszRVal = NULL;	if (pszLine[0] != '#' &&							/* skip the line if it is a comment */		 pszLine[0] != '/n' &&							/* if it's an empty UNIX line, do nothing */		 !(pszLine[0] == '/r' && pszLine[1] == '/n')	/* if it's an empty MS-DOS line, do nothing */	   ) {		/* advance past any whitespace, and assign the L-value */		for (i = 0; i < size; i++) {			if (pszLine[i] != ' ') {				*ppszLVal = &pszLine[i];				break;			}		}		/* advance to the end of the l-value*/		for (i++; i < size; i++) {			if (pszLine[i] == ' ' || pszLine[i] == '=') {				pszLine[i] = '/0';				break;			}		}		/* make any whitespace and the equal sign a NULL character, and		   advance to the R-Value */		for (i++; i < size; i++) {			if (pszLine[i] == ' ' || pszLine[i] == '=') {				pszLine[i] = '/0';				continue;			}			*ppszRVal = &pszLine[i];			break;		}		/* make the line ending character(s) a NULL */		for (i++; i < size; i++) {			if (pszLine[i] == '/n')				pszLine[i] = '/0';			if ((pszLine[i] == '/r') && (pszLine[i+1] == '/n'))				pszLine[i] = '/0';		}	}	DBG_LEAVE(DbgInfo);} /* ParseConfigLine */

void wl_adapter_release(struct pcmcia_device *link){	DBG_FUNC("wl_adapter_release");	DBG_ENTER(DbgInfo);	DBG_PARAM(DbgInfo, "link", "0x%p", link);	/* Stop hardware */	wl_remove(link->priv);	pcmcia_disable_device(link);	DBG_LEAVE(DbgInfo);} /* wl_adapter_release */

NDIS_STATUSPGPnetPMRemoveSA(PGPnetPMContext *pContext, 				 void *data,				 UINT dataLen,				 ULONG *pSrcBufferLen){	DBG_FUNC("PGPnetPMRemoveSA")	DBG_ENTER();	*pSrcBufferLen = sizeof(PGPipsecSPI);	if (dataLen != *pSrcBufferLen) {		DBG_LEAVE(NDIS_STATUS_INVALID_LENGTH);		return NDIS_STATUS_INVALID_LENGTH;	}	(void) PMRemoveSA(pContext, (PGPByte*) data);	*pSrcBufferLen = 0;	DBG_LEAVE(NDIS_STATUS_SUCCESS);	return NDIS_STATUS_SUCCESS;}

voidCCaptureDevice::DispatchCancelRemove(    _In_ PKSDEVICE Device,    _In_ PIRP Irp){    PAGED_CODE();    DBG_ENTER("()");    Recast(Device)->PnpCancelRemove(Irp);    DBG_LEAVE("()");}

voidCCaptureDevice::DispatchSurpriseRemoval(    _In_ PKSDEVICE Device,    _In_ PIRP Irp){    PAGED_CODE();    DBG_ENTER("()");    Recast(Device)->PnpSurpriseRemoval(Irp);    DBG_LEAVE("()");}

/******************************************************************************* *	wl_process_security_status() ******************************************************************************* * *  DESCRIPTION: * *      Process the security status message signaled by the device. * *  PARAMETERS: * *      lp - a pointer to the device's private structure * *  RETURNS: * *      N/A * ******************************************************************************/void wl_process_security_status( struct wl_private *lp ){    SECURITY_STATUS_STRCT *sec_stat;    /*------------------------------------------------------------------------*/    DBG_FUNC( "wl_process_security_status" );    DBG_ENTER( DbgInfo );    if( lp != NULL ) {        sec_stat = (SECURITY_STATUS_STRCT *)&lp->sec_stat;        wl_endian_translate_event( (ltv_t *)sec_stat );        switch( sec_stat->securityStatus ) {        case 1:            DBG_TRACE( DbgInfo, "Security Status : Dissassociate [AP]/n" );            break;        case 2:            DBG_TRACE( DbgInfo, "Security Status : Deauthenticate [AP]/n" );            break;        case 3:            DBG_TRACE( DbgInfo, "Security Status : Authenticate Fail [STA] or [AP]/n" );            break;        case 4:            DBG_TRACE( DbgInfo, "Security Status : MIC Fail/n" );            break;        case 5:            DBG_TRACE( DbgInfo, "Security Status : Associate Fail/n" );            break;        default:            DBG_TRACE( DbgInfo, "Security Status : UNKNOWN (0x%04x)/n",                       sec_stat->securityStatus );            break;        }        DBG_TRACE( DbgInfo, "STA Address     : %s/n",                   DbgHwAddr( sec_stat->staAddr ));        DBG_TRACE( DbgInfo, "Reason          : 0x%04x /n", sec_stat->reason );    }    DBG_LEAVE( DbgInfo );    return;} // wl_process_security_status

/******************************************************************************* *	wl_adapter_init_module() ******************************************************************************* * *  DESCRIPTION: * *      Called by init_module() to perform PCMCIA driver initialization. * *  PARAMETERS: * *      N/A * *  RETURNS: * *      0 on success *      -1 on error * ******************************************************************************/int wl_adapter_init_module(void){	int ret;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_init_module");	DBG_ENTER(DbgInfo);	DBG_TRACE(DbgInfo, "wl_adapter_init_module() -- PCMCIA/n");	ret = pcmcia_register_driver(&wlags49_driver);	DBG_LEAVE(DbgInfo);	return ret;} /* wl_adapter_init_module */

/******************************************************************************* *	wl_adapter_close() ******************************************************************************* * *  DESCRIPTION: * *      Close the device. * *  PARAMETERS: * *      dev - a pointer to a net_device structure representing the network *            device to close. * *  RETURNS: * *      0 on success *      errno value otherwise * ******************************************************************************/int wl_adapter_close(struct net_device *dev){	struct wl_private *lp = wl_priv(dev);	struct pcmcia_device *link = lp->link;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_close");	DBG_ENTER(DbgInfo);	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);	if (link == NULL) {		DBG_LEAVE(DbgInfo);		return -ENODEV;	}	DBG_TRACE(DbgInfo, "%s: Shutting down adapter./n", dev->name);	wl_close(dev);	link->open--;	DBG_LEAVE(DbgInfo);	return 0;} /* wl_adapter_close */

/** * et131x_open - Open the device for use. * @netdev: device to be opened * * Returns 0 on success, errno on failure (as defined in errno.h) */int et131x_open(struct net_device *netdev){	int result = 0;	struct et131x_adapter *adapter = netdev_priv(netdev);	DBG_ENTER(et131x_dbginfo);	/* Start the timer to track NIC errors */	add_timer(&adapter->ErrorTimer);	/* Register our ISR */	DBG_TRACE(et131x_dbginfo, "Registering ISR.../n");	result =	    request_irq(netdev->irq, et131x_isr, IRQF_SHARED, netdev->name,			netdev);	if (result) {		DBG_ERROR(et131x_dbginfo, "Could not register ISR/n");		DBG_LEAVE(et131x_dbginfo);		return result;	}	/* Enable the Tx and Rx DMA engines (if not already enabled) */	et131x_rx_dma_enable(adapter);	et131x_tx_dma_enable(adapter);	/* Enable device interrupts */	et131x_enable_interrupts(adapter);	MP_SET_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);	/* We're ready to move some data, so start the queue */	netif_start_queue(netdev);	DBG_LEAVE(et131x_dbginfo);	return result;}

NTSTATUSCCaptureDevice::DispatchCreate (    _In_ PKSDEVICE Device)/*++Routine Description:    Create the capture device.  This is the creation dispatch for the    capture device.Arguments:    Device -        The AVStream device being created.Return Value:    Success / Failure--*/{    PAGED_CODE();    DBG_ENTER("()");    CCaptureDevice *CapDevice = new (NonPagedPoolNx, 'eviD') CCaptureDevice (Device);    if( !CapDevice)    {        //        //  Return failure if we couldn't create the device.        //        return STATUS_INSUFFICIENT_RESOURCES;    }    NTSTATUS Status = CapDevice->Prepare();    if (!NT_SUCCESS (Status))    {        //  Init failure.        delete CapDevice;    }    DBG_LEAVE("()");    return Status;}