C++ DEBUGOUT函数代码示例

/**
 *  e1000_acquire_swfw_sync_i210 - Acquire SW/FW semaphore
 *  @hw: pointer to the HW structure
 *  @mask: specifies which semaphore to acquire
 *
 *  Acquire the SW/FW semaphore to access the PHY or NVM.  The mask
 *  will also specify which port we're acquiring the lock for.
 **/
s32 e1000_acquire_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
{
	u32 swfw_sync;
	u32 swmask = mask;
	u32 fwmask = mask << 16;
	s32 ret_val = E1000_SUCCESS;
	s32 i = 0, timeout = 200; /* FIXME: find real value to use here */

	DEBUGFUNC("e1000_acquire_swfw_sync_i210");

	while (i < timeout) {
		if (e1000_get_hw_semaphore_i210(hw)) {
			ret_val = -E1000_ERR_SWFW_SYNC;
			goto out;
		}

		swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
		if (!(swfw_sync & fwmask))
			break;

		/*
		 * Firmware currently using resource (fwmask)
		 */
		e1000_put_hw_semaphore_i210(hw);
		msec_delay_irq(5);
		i++;
	}

	if (i == timeout) {
		DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
		ret_val = -E1000_ERR_SWFW_SYNC;
		goto out;
	}

	swfw_sync |= swmask;
	E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);

	e1000_put_hw_semaphore_i210(hw);

out:
	return ret_val;
}

static void
gadget_border_highlight(Widget w)
{

    DEBUGOUT(_LtDebug(__FILE__, w, "gadget_border_highlight\n"));

    /* with zero width, we don't need this... */
    if (G_HighlightThickness(w) == 0)
    {
	return;
    }

    _XmDrawHighlight(XtDisplayOfObject(w), XtWindowOfObject(w),
		     XmParentHighlightGC(w),
		     XtX(w), XtY(w), XtWidth(w), XtHeight(w),
		     G_HighlightThickness(w), LineSolid);

    G_Highlighted(w) = True;
    G_HighlightDrawn(w) = True;
}

static void
drop_timer(XtPointer cd, XtIntervalId *id)
{
    Widget dt = (Widget)cd;
    Atom select;

    DEBUGOUT(_LtDebug(__FILE__, dt, "%s:drop_timer(%d)\n",
    	__FILE__, __LINE__));

    if (DT_NumDropTransferLists(dt))
    {
	entry_transfer(dt, 0);
    }
    else
    {
	select = DC_ICCHandle(DT_DragContext(dt));

	terminate_transfer(dt, &select);
    }
}

int lua_debugpcall(lua_State *l, char *message, int a, int b, int c) {
  lua_list *l2 = lua_listfromstate(l);
  int ret;

#ifdef LUA_DEBUGSOCKET
  DEBUGOUT("%s: %s\n", l2->name->content, message);
#endif

#ifdef LUA_PROFILE
  ACCOUNTING_START(l2);
#endif

  ret = lua_pcall(l, a, b, c);

#ifdef LUA_PROFILE
  ACCOUNTING_STOP(l2);
#endif

  return ret;
}

/* Slave receive in interrupt mode */
static void readI2CSlave(void)
{
	ErrorCode_t error_code;

	/* Setup receive buffer, receive buffer size, and receive callback */
	paramRX.num_bytes_rec     = 2;	/* Address and single byte */
	paramRX.buffer_ptr_rec    = &recvBuff[0];
	paramRX.func_pt           = cbRXI2CComplete;

	/* Clear error code */
	RXintErrCode = -1;

	/* Function is non-blocking */
	error_code = LPC_I2CD_API->i2c_slave_receive_intr(i2cHandleSlave, &paramRX, &resultRX);

	/* Completed without erors? */
	if (error_code != LPC_OK) {
		DEBUGOUT("i2c_slave_receive_intr error code : %x\r\b", error_code);
		errorI2C();
	}
}

static Widget
start_drop_transfer(Widget refWidget,
		    ArgList args, Cardinal argCount)
{
    Widget disp = XmGetXmDisplay(XtDisplay(refWidget)), dt;

    DEBUGOUT(_LtDebug(__FILE__, refWidget, "%s:start_drop_transfer(%d)\n",
    	__FILE__, __LINE__));

    dt = XtCreateWidget("drop_transfer",
			Display_DropTransferClass(disp),
			disp, args, argCount);

    /* refWidget had BETTER be a DC */
    DT_DragContext(dt) = refWidget;
    DT_Timestamp(dt) = DC_DragFinishTime(refWidget);

    XtAppAddTimeOut(XtWidgetToApplicationContext(dt), 0,
		    drop_timer, (XtPointer)dt);
    return dt;
}

/*
 * cache (program local) the value of the drag window
 */
static void
set_drag_window(Display *display, Window win)
{
    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:set_drag_window(%d)\n",
		      __FILE__, __LINE__));

    if (displayToDW == None)
    {
	displayToDW = XUniqueContext();
    }

    if (XFindContext(display, DefaultRootWindow(display),
		     displayToDW, (XPointer *)&win) == XCSUCCESS)
    {
	XDeleteContext(display, DefaultRootWindow(display),
		       displayToDW);
    }

    XSaveContext(display, DefaultRootWindow(display),
		 displayToDW, (XPointer)win);
}

VOID
GetSpeedAndDuplex(PADAPTER_STRUCT Adapter, PUINT16 Speed, PUINT16 Duplex)
 {
    UINT32 DeviceStatusReg;
    UINT16 PhyData;

    DEBUGFUNC("GetSpeedAndDuplex")

        if (Adapter->AdapterStopped) {
        *Speed = 0;
        *Duplex = 0;
        return;
    }

    if (Adapter->MacType >= MAC_LIVENGOOD) {
        DEBUGOUT("Livengood MAC\n");
        DeviceStatusReg = E1000_READ_REG(Status);
        if (DeviceStatusReg & E1000_STATUS_SPEED_1000) {
            *Speed = SPEED_1000;
            DEBUGOUT("   1000 Mbs\n");
        } else if (DeviceStatusReg & E1000_STATUS_SPEED_100) {
            *Speed = SPEED_100;
            DEBUGOUT("   100 Mbs\n");
        } else {
            *Speed = SPEED_10;
            DEBUGOUT("   10 Mbs\n");
        }

        if (DeviceStatusReg & E1000_STATUS_FD) {
            *Duplex = FULL_DUPLEX;
            DEBUGOUT("   Full Duplex\r\n");
        } else {
            *Duplex = HALF_DUPLEX;
            DEBUGOUT("   Half Duplex\r\n");
        }
    } else {
        DEBUGOUT("Wiseman MAC - 1000 Mbs, Full Duplex\r\n");
        *Speed = SPEED_1000;
        *Duplex = FULL_DUPLEX;
    }

    return;
}

static void
class_part_initialize(WidgetClass widget_class)
{
    WidgetClass sc;

    DEBUGOUT(_LtDebug(__FILE__, NULL, "DropTransfer class part initialize\n"));

    _XmFastSubclassInit(widget_class, XmDROP_TRANSFER_BIT);

    sc = widget_class->core_class.superclass;

    if (DTC_StartTransferProc(widget_class) == XmInheritStartTransferProc)
    {
	DTC_StartTransferProc(widget_class) = DTC_StartTransferProc(sc);
    }

    if (DTC_AddTransferProc(widget_class) == XmInheritAddTransferProc)
    {
	DTC_AddTransferProc(widget_class) = DTC_AddTransferProc(sc);
    }
}

/*
 * fetch the cached atoms table
 */
static XmDndAtomsTable
get_atoms_table(Display *display)
{
    XmDndAtomsTable tbl = NULL;

    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:get_atoms_table(%d)\n",
		      __FILE__, __LINE__));

    if (displayToAtoms == (XContext)0)
    {
	displayToAtoms = XUniqueContext();
    }

    if (XFindContext(display, DefaultRootWindow(display),
		     displayToAtoms, (XPointer *)&tbl) != XCSUCCESS)
    {
	return NULL;
    }

    return tbl;
}

static XmDndAtomsTable
create_default_atoms_table(Display *display)
{
    XmDndAtomsTable tbl;

    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:create_default_atoms_table(%d)\n",
		      __FILE__, __LINE__));

    tbl = (XmDndAtomsTable) XtMalloc(sizeof(XmDndAtomsTableRec));
    tbl->num_entries = 1;

    tbl->entries =
	(XmDndAtomsTableEntry) XtMalloc(sizeof(XmDndAtomsTableEntryRec));

    tbl->entries->atom = XmInternAtom(display, _XA_MOTIF_ATOM_0, False);
    tbl->entries->time = CurrentTime;

    set_atoms_table(display, tbl);

    return tbl;
}

/**
 * @brief	Main routine for I2C example
 * @return	Function should not exit
 */
void i2C_slave_Task (void *pvParameters)
{
uint8_t i;
	

	/* Test I2c slave  */
	while (1) {
		
//		DEBUGOUT(" matched @: %u\r\n",Chip_I2C_GetPendingInt(LPC_I2C0));
		i = Chip_I2CS_ReadByte(LPC_I2C0);
		
  	xSemaphoreTake( xI2cSemaphore, portMAX_DELAY );
//		DEBUGOUT(" read value: 0x%x\r\n",i);
		
		DEBUGOUT(" I2C  transaction complete\r\n");
		
	}

	
	
}

extern char *
_XmStringSourceGetString(XmTextWidget w,
			 XmTextPosition from,
			 XmTextPosition to,
			 Boolean want_wchar)
{
#if 1
    _XmWarning((Widget)w, "_XmStringSourceGetString is not implemented yet.");

    return NULL;
#else
    if (want_wchar)
    {
	DEBUGOUT(_LtDebug(__FILE__, NULL,
	  "_XmStringSourceGetString: wide characters not implemented yet.\n"));

	return NULL;
    }
    return NULL;		/* FIX ME */
#endif
}

/*
 * I understand what it does, by why would you want to do it?
 */
extern void
_XmDestroyMotifWindow(Display *dpy)
{
    Atom dw;
    Window win;

    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:_XmDestroyMotifWindow(%d)\n",
		      __FILE__, __LINE__));

    win = read_drag_window(dpy);
    if (win == None)
    {
	return;
    }

    dw = XmInternAtom(dpy, _XA_MOTIF_DRAG_WINDOW, False);

    XDeleteProperty(dpy, DefaultRootWindow(dpy), dw);

    XDestroyWindow(dpy, win);
}

extern void
_LTCreateSearchPath(void)
{
    const char *XBMLANGPATH = getenv("XBMLANGPATH");
    const char *XAPPLRESDIR = getenv("XAPPLRESDIR");
    const char *HOME = _XmOSGetHomeDirName();

    
    if (HOME == NULL) {
	HOME = "";
    }
    if (XBMLANGPATH)
    {
      _search_path = XtNewString(XBMLANGPATH);
    }
    else if (XAPPLRESDIR)
    {

	_search_path = (char *)XtMalloc(strlen(XAPPLRESDIR_set_pattern)
					+ strlen(XAPPLRESDIR) * 6
					+ strlen(HOME) * 2 + 1);

	sprintf(_search_path, XAPPLRESDIR_set_pattern,
		XAPPLRESDIR, XAPPLRESDIR, XAPPLRESDIR,
		XAPPLRESDIR, XAPPLRESDIR, XAPPLRESDIR,
		HOME, HOME);

    }
    else
    {				/* neither of them was set... */
	_search_path = (char *)XtMalloc(strlen(nothing_set_pattern)
					+ strlen(HOME) * 7 + 1);

	sprintf(_search_path, nothing_set_pattern,
		HOME, HOME, HOME, HOME, HOME, HOME, HOME);
    }

    DEBUGOUT(_LtDebug(__FILE__, NULL,
		      "Using %s for search path\n", _search_path));
}