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

// sangam dbg : used by the set and query info but linux not supported// is adapter halted?BOOLEAN adpIsHalted(PMINIPORT_ADAPTER Adapter){    int		i;    PMINIPORT_ADAPTER*	p = g_Adapters;	ENTER;    // check first one    if (*p == Adapter) {	// found		if (g_HaltedFlags[0]) {		    DumpDebug(HARDWARE, " Adapter (%lu, 0) halted: YES", (unsigned long)Adapter);		}		return g_HaltedFlags[0];    }    p++;    // check others    for (i = 1; i < ADAPTER_MAX_NUMBER; i++, p++) {	if (*p == Adapter) {	    // found	    if (g_HaltedFlags[i]) {			DumpDebug(HARDWARE, " Adapter (%lu, %d) halted: YES", (unsigned long)Adapter, i);	    }	    return g_HaltedFlags[i];	}    }    DumpDebug(HARDWARE, "Adapter (%lu) halted (removed): YES", (unsigned long)Adapter);    // not found, assume that it was removed already    return TRUE;}

VOID hwRemove(MINIPORT_ADAPTER *Adapter){	PBUFFER_DESCRIPTOR  dsc;    ENTER;	//sangam :Free the pending data packets and control packets	while(!QueueEmpty(Adapter->hw.Q_Send.Head)) {	//sangam dbg : used only for data packet so free skb		DumpDebug(DISPATCH, "<1> Freeing Q_Send");		dsc = (PBUFFER_DESCRIPTOR) QueueGetHead(Adapter->hw.Q_Send.Head);		if (!dsc) {			DumpDebug(DISPATCH, "<1> Fail...node is null");			continue;		}		QueueRemoveHead(Adapter->hw.Q_Send.Head);		if(dsc->Buffer)			kfree(dsc->Buffer);		if(dsc)			kfree(dsc);	}	// stop data out buffer//	if (Adapter->hw.ReceiveBuffer!= NULL) //			kfree(Adapter->hw.ReceiveBuffer);	// stop TempData out buffer#if 0	//cky 20100624	if (Adapter->hw.ReceiveTempBuffer!= NULL) 			kfree(Adapter->hw.ReceiveTempBuffer);#endif	hwGPIODeInit();		LEAVE;}

voidDoConvolution(FFT_DATA_TYPE *FFTNum,int Cache,size_t Len2){StartTimer(ConvTime);if (Cache==-2) /* In memory convolution of both nums */  {FFT_DATA_TYPE *FFTNum2=FFTNum+Len2;   DumpDebug("Cm...");   DoScrambledFHTConv(FFTNum,FFTNum2,Len2);  }else if (Cache==-1)  /* In memory self convolution. */  {   DumpDebug("C");   DoScrambledFHTConv(FFTNum,FFTNum,Len2);  }#ifdef VIRTUAL_CACHEelse /* Virtual Mem based convolution. */  {FFT_DATA_TYPE *Num1=FFTNum;   FFT_DATA_TYPE *Num2=FFTCash[Cache].Mem;   if (Num2==NULL)     FatalError("Cache %d doesn't exist./n",Cache);   DumpDebug("C%d...",Cache);   DoScrambledFHTConv(Num1,Num2,Len2);  }#else#error#if 0/*** Eyuk!  What a kludge!*/else  {FILE *f;FFT_DATA_TYPE h1p,h1m;

static voidlocalFreeOffscreenLinear(FBLinearPtr linear){    FBManagerPtr offman;    FBLinearLinkPtr pLink, pLinkPrev = NULL;    ScreenPtr pScreen = linear->pScreen;    offman = (FBManagerPtr) dixLookupPrivate(&pScreen->devPrivates,                                             xf86FBScreenKey);    pLink = offman->LinearAreas;    if (!pLink)        return;    while (&(pLink->linear) != linear) {        pLinkPrev = pLink;        pLink = pLink->next;        if (!pLink)            return;    }    if (pLink->area) {          /* really an XY area */        DebugF("FREEING AREA/n");        localFreeOffscreenArea(pLink->area);        if (pLinkPrev)            pLinkPrev->next = pLink->next;        else            offman->LinearAreas = pLink->next;        free(pLink);        DumpDebug(offman->LinearAreas);        return;    }    pLink->free = 1;    if (pLink->next && pLink->next->free) {        FBLinearLinkPtr p = pLink->next;        pLink->linear.size += p->linear.size;        pLink->next = p->next;        free(p);    }    if (pLinkPrev) {        if (pLinkPrev->next && pLinkPrev->next->free && !pLinkPrev->area) {            FBLinearLinkPtr p = pLinkPrev->next;            pLinkPrev->linear.size += p->linear.size;            pLinkPrev->next = p->next;            free(p);        }    }    DebugF("FREEING LINEAR/n");    DumpDebug(offman->LinearAreas);}

void hwSetInterface(){	ENTER;	g_dwLineState = WimaxMode();	s3c_gpio_cfgpin(WIMAX_WAKEUP, S3C_GPIO_SFN(1));	s3c_gpio_cfgpin(WIMAX_IF_MODE0, S3C_GPIO_SFN(1));	if(g_dwLineState == SDIO_MODE)	{			gpio_set_value(WIMAX_WAKEUP, GPIO_LEVEL_HIGH);		gpio_set_value(WIMAX_IF_MODE0, GPIO_LEVEL_HIGH);		msleep(10);		DatadwValue = 1;		ControldwValue = 1;		DumpDebug(HARDWARE, "Interface mode SDIO_MODE");	}	else if(g_dwLineState == WTM_MODE || g_dwLineState == AUTH_MODE)	{		gpio_set_value(WIMAX_WAKEUP, GPIO_LEVEL_LOW);		gpio_set_value(WIMAX_IF_MODE0, GPIO_LEVEL_LOW);		msleep(10);				DatadwValue = 0;		ControldwValue = 0;		DumpDebug(HARDWARE, "Interface mode WTM_MODE || AUTH_MODE");	}	else if(g_dwLineState == DM_MODE)	{		gpio_set_value(WIMAX_WAKEUP, GPIO_LEVEL_HIGH);		gpio_set_value(WIMAX_IF_MODE0, GPIO_LEVEL_LOW);		msleep(10);		DumpDebug(HARDWARE, "Interface mode DM_MODE");	}	else if(g_dwLineState == USB_MODE || g_dwLineState ==  USIM_RELAY_MODE)	{		gpio_set_value(WIMAX_WAKEUP, GPIO_LEVEL_LOW);		gpio_set_value(WIMAX_IF_MODE0, GPIO_LEVEL_HIGH);		msleep(10);		DatadwValue = 1;		ControldwValue = 0;		DumpDebug(HARDWARE, "Interface mode USB_MODE (USIM_RELAY)");	}	LEAVE;}

INT hwInit(MINIPORT_ADAPTER *Adapter){	ENTER;	static PVOID ReceiveBuffer = NULL;	//cky 20100624	if(!hwGPIOInit())	{		DumpDebug(DISPATCH, "hwInit: Can't intialize GPIO");		return STATUS_UNSUCCESSFUL;	}	if (ReceiveBuffer == NULL)	{		DumpDebug(DISPATCH, "Alloc ReceiveBuffer");		ReceiveBuffer = kmalloc(SDIO_BUFFER_SIZE+8, GFP_KERNEL); //sumanth: the extra space required to copy ethernet header		if (ReceiveBuffer == NULL)		{			DumpDebug(DISPATCH, "kmalloc fail!!");			return -ENOMEM;		}	}	else	{		DumpDebug(DISPATCH, "ReceiveBuffer already allocated - skip");	}	memset(&Adapter->hw,0,sizeof(HARDWARE_INFO));/*	Adapter->hw.ReceiveBuffer= kmalloc(SDIO_BUFFER_SIZE, GFP_ATOMIC);	if(Adapter->hw.ReceiveBuffer ==NULL) {		return -ENOMEM;	}*/ //sumanth: this buffer is not logically required hence it is eliminated#if 1	//cky 20100624	Adapter->hw.ReceiveTempBuffer = ReceiveBuffer;#else	Adapter->hw.ReceiveTempBuffer= kmalloc(SDIO_BUFFER_SIZE+8, GFP_ATOMIC); //sumanth: the extra space required to copy ethernet header	if(Adapter->hw.ReceiveTempBuffer ==NULL) {//			if(Adapter->hw.ReceiveBuffer)			//sumanth no point in freeing a NULL pointer//				kfree(Adapter->hw.ReceiveTempBuffer);		return -ENOMEM;	}#endif	// For sending data and control packets	QueueInitList(Adapter->hw.Q_Send.Head);	spin_lock_init(&Adapter->hw.Q_Send.Lock);		INIT_WORK(&Adapter->work, hwTransmitThread);	init_waitqueue_head(&Adapter->hFWDNEndEvent);	init_completion(&Adapter->hAwakeAckEvent);		return STATUS_SUCCESS;	LEAVE;}

/* get MAC address from device */VOID GetMacAddress(MINIPORT_ADAPTER *Adapter){	UINT nCount = 0;	int nResult = 0;	HW_PRIVATE_PACKET req; 	ENTER;	req.Id0   = 'W';	req.Id1   = 'P';	req.Code  = HwCodeMacRequest;	req.Value = 0;	Adapter->acquired_mac_address = FALSE;		do {		if(Adapter->bHaltPending)			return;		sdio_claim_host(Adapter->func);		//nResult = sdio_memcpy_toio(Adapter->func,SDIO_DATA_PORT_REG, &req, sizeof(HW_PRIVATE_PACKET));		nResult = sd_send(Adapter, &req, sizeof(HW_PRIVATE_PACKET));				if(nResult != 0) 			DumpDebug(DRV_ENTRY,"Send GetMacAddress Request msg but error occurred!! res = %d",nResult);		sdio_release_host(Adapter->func);		if(!wait_for_completion_interruptible_timeout(&Adapter->hFWInitCompleteEvent, msecs_to_jiffies(HARDWARE_START_TIMEOUT))) {			DumpDebug(DRV_ENTRY, "timedout mac req, retry..");			if(nCount >= HARDWARE_MAX_MAC_RESPONSES || Adapter->bHaltPending == TRUE) {				DumpDebug(DRV_ENTRY,"Can't get mac address, exceeded number of retries (%d)",nCount);				Adapter->bHaltPending = TRUE;				wake_up_interruptible(&Adapter->hFWDNEndEvent);				gpio_wimax_poweroff();				gpio_wimax_poweron();				break;			}			nCount++;			continue;		}		// If wait exit before timeout then mac assigned or surprise remove		if(Adapter->acquired_mac_address == TRUE) {			DumpDebug(DRV_ENTRY,"MAC Address acquired");			break;		}//		msleep(500);		} while(TRUE);	return;	LEAVE;}

static voidDoConvolutions(int Cache,size_t FFTLen2,size_t StartP, size_t EndP){size_t Pass; ModInt *Num1,*Num2;StartTimer(ConvTime);if (Cache==-2) /* In memory convolution of both nums */  {ModInt *FFTNum2=FFTNum+FFTLen2*NPrimes;   DumpDebug("Cm...");   for (Pass=StartP;Pass < EndP;Pass++)     {      SetModPrime(Pass);      Num1=FFTNum+FFTLen2*(Pass-StartP);      Num2=FFTNum2+FFTLen2*(Pass-StartP);      PrepVector(Prime,FFTLen2);      VectorModMul( Num1, Num2, FFTLen2);     }  }else if (Cache==-1)  /* In memory self convolution. */  {   DumpDebug("C");   for (Pass=StartP;Pass < EndP;Pass++)     {      SetModPrime(Pass);      Num1=FFTNum+FFTLen2*(Pass-StartP);      PrepVector(Prime,FFTLen2);      VectorModMul( Num1, Num1, FFTLen2);     }  }#ifdef VIRTUAL_CACHEelse /* Virtual Mem based convolution. */  {   Num1=FFTNum;   Num2=(ModInt*)FFTCash[Cache].Mem;   if (Num2==NULL)     FatalError("Cache %d doesn't exist./n",Cache);   DumpDebug("C%d...",Cache);   for (Pass=StartP;Pass < EndP;Pass++)     {      SetModPrime(Pass);      PrepVector(Prime,FFTLen2);      VectorModMul( Num1, Num2, FFTLen2);      Num1+=FFTLen2;Num2+=FFTLen2;     }  }#elseelse /* Disk based convolution. */  {FILE *f;

static int proc_write_sleepmode(struct file *foke, const char *buffer, unsigned long count, void *data){	if (buffer[0] == '0' && g_dwSleepMode == 1)	{		DumpDebug("WiMAX Sleep Mode: VI");		g_dwSleepMode = 0;	}	else if (buffer[0] == '1' && g_dwSleepMode == 0)	{		DumpDebug("WiMAX Sleep Mode: IDLE");		g_dwSleepMode = 1;	}	return 0;}

BOOLEAN SendCmdPacket(PMINIPORT_ADAPTER Adapter, unsigned short uiCmdId){	PHW_PACKET_HEADER pPktHdr;	UCHAR pTxPkt[CMD_MSG_TOTAL_LENGTH];	UINT uiBufOffset;	PWIMAX_MESSAGE_HEADER pWibroMsgHdr;	int status = 0;	UINT dwTxSize;	pPktHdr = (PHW_PACKET_HEADER)pTxPkt;	pPktHdr->Id0 = 'W';	pPktHdr->Id1 = 'C';		pPktHdr->Length = be16_to_cpu(CMD_MSG_TOTAL_LENGTH); 	uiBufOffset = sizeof(HW_PACKET_HEADER);	pWibroMsgHdr = (PWIMAX_MESSAGE_HEADER)(pTxPkt + uiBufOffset);	pWibroMsgHdr->MsgType = be16_to_cpu(ETHERTYPE_DL);	pWibroMsgHdr->MsgID = be16_to_cpu(uiCmdId);		pWibroMsgHdr->MsgLength = be32_to_cpu(CMD_MSG_LENGTH);			dwTxSize = CMD_MSG_TOTAL_LENGTH;	status = sd_send(Adapter, pTxPkt, dwTxSize);	if(status != STATUS_SUCCESS) {		// crc error or data error - set PCWRT '1' & send current type A packet again				DumpDebug(FW_DNLD, "hwSdioWrite : crc error");		return status;//goto rewrite;	}	return status;}

int LoadWiMaxImage(void){		DWORD dwImgSize;			unsigned long buforder;	struct file *fp;		int read_size = 0;		if ( g_dwLineState == AUTH_MODE)	{		fp = klib_fopen(WIMAX_LOADER_PATH, O_RDONLY, 0);	// download mode	}	else	{		fp = klib_fopen(WIMAX_IMAGE_PATH, O_RDONLY, 0);		// wimax mode	}	if(fp)	{		if (g_stWiMAXImage.pImage == NULL)	// check already allocated		{			g_stWiMAXImage.pImage = (char *) vmalloc(MAX_WIMAXFW_SIZE);			if(!g_stWiMAXImage.pImage)			{				DumpDebug(HARDWARE, "Error: Memory alloc failure");				klib_fclose(fp);				return STATUS_UNSUCCESSFUL;			}		}				memset(g_stWiMAXImage.pImage, 0, MAX_WIMAXFW_SIZE);		read_size = klib_flen_fcopy(g_stWiMAXImage.pImage, MAX_WIMAXFW_SIZE, fp);		g_stWiMAXImage.uiSize = read_size;		g_stWiMAXImage.uiWorkAddress = CMC730_WIBRO_ADDRESS;		g_stWiMAXImage.uiOffset = 0;		g_stWiMAXImage.buforder = buforder;		klib_fclose(fp);	}	else {		DumpDebug(HARDWARE, "Error: WiMAX image file open failed");		return STATUS_UNSUCCESSFUL;	}	return STATUS_SUCCESS;}

INT hwStart(MINIPORT_ADAPTER *Adapter){	ENTER;	if(LoadWiMaxImage())			return STATUS_UNSUCCESSFUL;		Adapter->WibroStatus = WIBRO_STATE_READY;	Adapter->IPRefreshing = FALSE;	Adapter->bFWDNEndFlag = FALSE;		if(Adapter->DownloadMode)	{//		wimax_download_start_time = jiffies;		sdio_claim_host(Adapter->func);		SendCmdPacket(Adapter, MSG_DRIVER_OK_REQ);		sdio_release_host(Adapter->func);		switch( wait_event_interruptible_timeout(Adapter->hFWDNEndEvent, (Adapter->bFWDNEndFlag == TRUE), msecs_to_jiffies(FWDOWNLOAD_TIMEOUT*wimax_timeout_multiplier) ) ) 		{			// timeout			case 0:				Adapter->bHaltPending = TRUE;				DumpDebug(HARDWARE, "Error hwStart :  F/W Download timeout failed");				return STATUS_UNSUCCESSFUL;						// Interrupted by signal			case -ERESTARTSYS:				DumpDebug(HARDWARE, "Error hwStart :  -ERESTARTSYS retry");				return STATUS_UNSUCCESSFUL;			// normal condition check				default:				if (Adapter->SurpriseRemoval == TRUE || Adapter->bHaltPending == TRUE)				{												DumpDebug(HARDWARE, "Error hwStart :  F/W Download surprise removed");					return STATUS_UNSUCCESSFUL;				}				DumpDebug(HARDWARE, "hwStart :  F/W Download Complete");				break;		}		Adapter->DownloadMode = FALSE;	}	LEAVE;	return STATUS_SUCCESS;}

static int proc_read_dump(char *page, char **start, off_t off, int count, int *eof, void *data){	DumpDebug("CONTROL_IOCTL_WIMAX_CHECK_CAL");	gpio_wimax_poweroff();	//WIMAX_Check_Cal();		return 0;}

void DumpMemConfig(FRConfig * Config, const char * Conf){	FILE * ConfigFile = fopen(Conf,"w");	DumpDebug(&Config->Debug,ConfigFile);	DumpPreferences(&Config->Preferences,ConfigFile);	DumpSound(&Config->Sound,ConfigFile);	DumpSystem(&Config->System,ConfigFile);	fclose(ConfigFile);}

int	WimaxMode(void){	struct file *fp;	int mode = -1;	fp = klib_fopen("/proc/wmxmode/mode", O_RDONLY, 0);	if(fp != NULL) 	{		mode = klib_fgetc(fp);		DumpDebug(HARDWARE, "Mode = %d", mode);		klib_fclose(fp);	}	else	{		DumpDebug(HARDWARE, "Mode access failed!!!");	}	return mode;}

VOID hwGetMacAddressThread(VOID *data){	PMINIPORT_ADAPTER Adapter = (MINIPORT_ADAPTER *)data;	ENTER;	DumpDebug(TX, "Wait for SDIO ready...");	msleep(2000);	//cky 20100525 important; wait for cmc730 can handle mac req packet		GetMacAddress(Adapter);	LEAVE;}

INT	hwDeviceWakeup(PMINIPORT_ADAPTER pAdapter){	CHAR str[] = "WAKE";	UCHAR	nCount = 0;	int nRet = 0;		ENTER;	do {		nRet = sdio_memcpy_toio(pAdapter->func, SDIO_DATA_PORT_REG, str, 4);			nCount++;		DumpDebug(HARDWARE, "device wakeup fail..");	}while((nRet) && (!pAdapter->bHaltPending) && (nCount < HARDWARE_WAKE_MAX_COUNTER) );	if(nRet) {		DumpDebug(HARDWARE, "Retry wake-up sequence");		msleep(HARDWARE_WAKEUP_TIMEOUT);	}	LEAVE;	return nRet;}

void UnLoadWiMaxImage(void){	ENTER;	if(g_stWiMAXImage.pImage != NULL)	{		DumpDebug(HARDWARE, "Delete the Image Loaded");		vfree(g_stWiMAXImage.pImage);		g_stWiMAXImage.pImage = NULL;	}	LEAVE;}

static void DumpFunction(const ktap_proto *f, DumpState *D){	DumpInt(f->linedefined, D);	DumpInt(f->lastlinedefined, D);	DumpChar(f->numparams, D);	DumpChar(f->is_vararg, D);	DumpChar(f->maxstacksize, D);	DumpCode(f, D);	DumpConstants(f, D);	DumpUpvalues(f, D);	DumpDebug(f, D);}

static int proc_write_dump(struct file *foke, const char *buffer, unsigned long count, void *data){	if (buffer[0] == '0')	{		if (isDumpEnabled())		{			DumpDebug("Control Dump Disabled.");			g_dumpLogs = 0;		}	}	else if (buffer[0] == '1')	{		if (!isDumpEnabled())		{			DumpDebug("Control Dump Enabled.");			g_dumpLogs = 1;		}	}	return 0;}

static void DumpFunction(const Proto* f, const TString* p, DumpState* D){    DumpString((f->source==p || D->strip) ? NULL : f->source,D);    DumpInt(f->linedefined,D);    DumpInt(f->lastlinedefined,D);    DumpChar(f->nups,D);    DumpChar(f->numparams,D);    DumpChar(f->is_vararg,D);    DumpChar(f->maxstacksize,D);    DumpCode(f,D);    DumpConstants(f,D);    DumpDebug(f,D);}

static void DumpFunction(const Proto* f, DumpState* D){ int i; DumpInt(f->linedefined,D); DumpInt(f->lastlinedefined,D); DumpChar(f->numparams,D); DumpChar(f->is_vararg,D); DumpChar(f->maxstacksize,D); DumpInt(f->sizecode,D); for (i=0; i<f->sizecode; i++) DumpUInt(f->code[i],D); DumpConstants(f,D); DumpUpvalues(f,D); DumpDebug(f,D);}

static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {  if (D->strip || f->source == psource)    DumpString(NULL, D);  /* no debug info or same source as its parent */  else    DumpString(f->source, D);  DumpInt(f->linedefined, D);  DumpInt(f->lastlinedefined, D);  DumpByte(f->numparams, D);  DumpByte(f->is_vararg, D);  DumpByte(f->maxstacksize, D);  DumpCode(f, D);  DumpConstants(f, D);  DumpUpvalues(f, D);  DumpProtos(f, D);  DumpDebug(f, D);}

// remove adapter from arrayVOID adpRemove(PMINIPORT_ADAPTER Adapter){    int		i;    PMINIPORT_ADAPTER*	p = g_Adapters;	ENTER;    for (i = 0; i < ADAPTER_MAX_NUMBER; i++, p++) {	if (*p == Adapter) {	    DumpDebug(HARDWARE, " Adapter (%lu) removed from %d index", (unsigned long)Adapter, i);	    // clear	    *p = NULL;	    break;	}    }	LEAVE;}

// sangam dbg : Not usefull as adpsave is success.// get adapter indexULONG adpIndex(PMINIPORT_ADAPTER Adapter){    int		i;    PMINIPORT_ADAPTER*	p = g_Adapters;	ENTER;    for (i = 0; i < ADAPTER_MAX_NUMBER; i++, p++) {	if (*p == Adapter) {	    // found	    DumpDebug(HARDWARE, "Index is %d", i);	    return i;	}    }	LEAVE;    return (ULONG)(-1);}

// save adapter to first free indexULONG adpSave(PMINIPORT_ADAPTER Adapter){    int		i;    PMINIPORT_ADAPTER*	p = g_Adapters;	ENTER;    for (i = 0; i < ADAPTER_MAX_NUMBER; i++, p++) {	if (*p == NULL) {		DumpDebug(HARDWARE, "Adapter (%lu) saved to %d index", (unsigned long)Adapter, i);	    // initialize	    *p = Adapter;	    return i;	}    }	LEAVE;    return (ULONG)(-1);}