#include <strings.h>
#include <stdlib.h>
#include <stdint.h>
+#include <inttypes.h>
#include <stdarg.h>
#include <ctype.h>
#include <syslog.h>
/* ----------------------------------------------------------------------- */
-static int myDoCommand(uint32_t *p, unsigned bufSize, char *buf)
+static int myDoCommand(uintptr_t *p, unsigned bufSize, char *buf)
{
int res, i, j;
uint32_t mask;
if ((mask | p[1]) != mask)
{
DBG(DBG_USER,
- "gpioWrite_Bits_0_31_Clear: bad bits %08X (permissions %08X)",
+ "gpioWrite_Bits_0_31_Clear: bad bits %08"PRIXPTR" (permissions %08X)",
p[1], mask);
res = PI_SOME_PERMITTED;
}
if ((mask | p[1]) != mask)
{
DBG(DBG_USER,
- "gpioWrite_Bits_32_53_Clear: bad bits %08X (permissions %08X)",
+ "gpioWrite_Bits_32_53_Clear: bad bits %08"PRIXPTR" (permissions %08X)",
p[1], mask);
res = PI_SOME_PERMITTED;
}
if (!myPermit(p[1]))
{
DBG(DBG_USER,
- "bbSPIOpen: gpio %d, no permission to update CS", p[1]);
+ "bbSPIOpen: gpio %"PRIdPTR", no permission to update CS", p[1]);
res = PI_NOT_PERMITTED;
}
if ((mask | p[1]) != mask)
{
DBG(DBG_USER,
- "gpioWrite_Bits_0_31_Set: bad bits %08X (permissions %08X)",
+ "gpioWrite_Bits_0_31_Set: bad bits %08"PRIXPTR" (permissions %08X)",
p[1], mask);
res = PI_SOME_PERMITTED;
}
if ((mask | p[1]) != mask)
{
DBG(DBG_USER,
- "gpioWrite_Bits_32_53_Set: bad bits %08X (permissions %08X)",
+ "gpioWrite_Bits_32_53_Set: bad bits %08"PRIXPTR" (permissions %08X)",
p[1], mask);
res = PI_SOME_PERMITTED;
}
else
{
DBG(DBG_USER,
- "gpioHardwareClock: gpio %d, no permission to update",
+ "gpioHardwareClock: gpio %"PRIdPTR", no permission to update",
p[1] & 0xFFFFFF);
res = PI_NOT_PERMITTED;
}
else
{
DBG(DBG_USER,
- "gpioHardwarePWM: gpio %d, no permission to update", p[1]);
+ "gpioHardwarePWM: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioSetMode: gpio %d, no permission to update", p[1]);
+ "gpioSetMode: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioSetPWMfrequency: gpio %d, no permission to update", p[1]);
+ "gpioSetPWMfrequency: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioSetPWMrange: gpio %d, no permission to update", p[1]);
+ "gpioSetPWMrange: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioSetPullUpDown: gpio %d, no permission to update", p[1]);
+ "gpioSetPullUpDown: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
if (myPermit(p[1])) res = gpioPWM(p[1], p[2]);
else
{
- DBG(DBG_USER, "gpioPWM: gpio %d, no permission to update", p[1]);
+ DBG(DBG_USER, "gpioPWM: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioServo: gpio %d, no permission to update", p[1]);
+ "gpioServo: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
else
{
DBG(DBG_USER,
- "gpioTrigger: gpio %d, no permission to update", p[1]);
+ "gpioTrigger: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
if (myPermit(p[1])) res = gpioWrite(p[1], p[2]);
else
{
- DBG(DBG_USER, "gpioWrite: gpio %d, no permission to update", p[1]);
+ DBG(DBG_USER, "gpioWrite: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
{
DBG(
DBG_USER,
- "gpioWaveAddSerial: gpio %d, no permission to update", p[1]);
+ "gpioWaveAddSerial: gpio %"PRIdPTR", no permission to update", p[1]);
res = PI_NOT_PERMITTED;
}
break;
page = pos/CBS_PER_OPAGE;
slot = pos%CBS_PER_OPAGE;
- return (uint32_t) &dmaOBus[page]->cb[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaOBus contains bus addresses, not virtual addresses.
+ return (uint32_t)(uintptr_t) &dmaOBus[page]->cb[slot];
}
/* ----------------------------------------------------------------------- */
waveOOLPageSlot(pos, &page, &slot);
- return (uint32_t) &dmaOBus[page]->OOL[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaOBus contains bus addresses, not virtual addresses.
+ return (uint32_t)(uintptr_t) &dmaOBus[page]->OOL[slot];
}
p->dst = PWM_TIMER;
}
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaOBus contains bus addresses, not virtual addresses.
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = BPD * 20 / PI_WF_MICROS; /* 20 micros delay */
p->next = waveCbPOadr(botCB);
p->dst = PWM_TIMER;
}
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaOBus contains bus addresses, not virtual addresses.
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = BPD * delayLeft / PI_WF_MICROS;
int i, status;
- DBG(DBG_USER, "handle=%d reg=%d buf=%08X", handle, reg, (unsigned)buf);
+ DBG(DBG_USER, "handle=%d reg=%d buf=%08"PRIXPTR, handle, reg, (uintptr_t)buf);
CHECK_INITED;
int i, status;
uint32_t size;
- DBG(DBG_USER, "handle=%d reg=%d count=%d buf=%08X",
- handle, reg, count, (unsigned)buf);
+ DBG(DBG_USER, "handle=%d reg=%d count=%d buf=%08"PRIXPTR,
+ handle, reg, count, (uintptr_t)buf);
CHECK_INITED;
{
int bytes;
- DBG(DBG_USER, "handle=%d count=%d buf=%08X",
- handle, count, (unsigned)buf);
+ DBG(DBG_USER, "handle=%d count=%d buf=%08"PRIXPTR,
+ handle, count, (uintptr_t)buf);
CHECK_INITED;
int esc, setesc;
pi_i2c_msg_t segs[PI_I2C_RDRW_IOCTL_MAX_MSGS];
- DBG(DBG_USER, "handle=%d inBuf=%s outBuf=%08X len=%d",
- handle, myBuf2Str(inLen, (char *)inBuf), (int)outBuf, outLen);
+ DBG(DBG_USER, "handle=%d inBuf=%s outBuf=%08"PRIXPTR" len=%d",
+ handle, myBuf2Str(inLen, (char *)inBuf), (uintptr_t)outBuf, outLen);
CHECK_INITED;
{
int r;
- DBG(DBG_USER, "handle=%d count=%d buf=0x%X", handle, count, (unsigned)buf);
+ DBG(DBG_USER, "handle=%d count=%d buf=0x%"PRIXPTR, handle, count, (uintptr_t)buf);
SER_CHECK_INITED;
while (1)
{
- cb = (cbAddr - ((int)dmaIBus[page])) / 32;
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ cb = (cbAddr - ((int)(uintptr_t)dmaIBus[page])) / 32;
if (cb < CBS_PER_IPAGE)
{
while (1)
{
- cb = (cbAddr - ((int)dmaOBus[page])) / 32;
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ cb = (cbAddr - ((int)(uintptr_t)dmaOBus[page])) / 32;
if (cb < CBS_PER_OPAGE) return (page*CBS_PER_OPAGE) + cb;
while (1)
{
- cb = (cbAddr - ((int)dmaOBus[page])) / 32;
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ cb = (cbAddr - ((int)(uintptr_t)dmaOBus[page])) / 32;
if (cb < CBS_PER_OPAGE) return (page*CBS_PER_OPAGE) + cb;
while (1)
{
- cb = (cbAddr - ((int)dmaOBus[page])) / 32;
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ cb = (cbAddr - ((int)(uintptr_t)dmaOBus[page])) / 32;
if (cb < CBS_PER_OPAGE)
{
static uint32_t dmaPwmDataAdr(int pos)
{
- return (uint32_t) &dmaIBus[pos]->periphData;
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[pos]->periphData;
}
/* ----------------------------------------------------------------------- */
page = pos/ON_PER_IPAGE;
slot = pos%ON_PER_IPAGE;
- return (uint32_t) &dmaIBus[page]->gpioOn[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[page]->gpioOn[slot];
}
/* ----------------------------------------------------------------------- */
myOffPageSlot(pos, &page, &slot);
- return (uint32_t) &dmaIBus[page]->gpioOff[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[page]->gpioOff[slot];
}
/* ----------------------------------------------------------------------- */
myTckPageSlot(pos, &page, &slot);
- return (uint32_t) &dmaIBus[page]->tick[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[page]->tick[slot];
}
/* ----------------------------------------------------------------------- */
myLvsPageSlot(pos, &page, &slot);
- return (uint32_t) &dmaIBus[page]->level[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[page]->level[slot];
}
/* ----------------------------------------------------------------------- */
page = (pos/CBS_PER_IPAGE);
slot = (pos%CBS_PER_IPAGE);
- return (uint32_t) &dmaIBus[page]->cb[slot];
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ return (uint32_t)(uintptr_t) &dmaIBus[page]->cb[slot];
}
/* ----------------------------------------------------------------------- */
p->next = dmaCbAdr(0);
- DBG(DBG_STARTUP, "DMA page type count = %d", sizeof(dmaIPage_t));
+ DBG(DBG_STARTUP, "DMA page type count = %zd", sizeof(dmaIPage_t));
DBG(DBG_STARTUP, "%d control blocks (exp=%d)", b+1, NUM_CBS);
}
else
{
gpioStats.shortPipeWrite++;
- DBG(DBG_ALWAYS, "emitted %d, asked for %d",
+ DBG(DBG_ALWAYS, "emitted %zd, asked for %d",
err/sizeof(gpioReport_t), max_emits);
}
}
else
{
gpioStats.shortPipeWrite++;
- DBG(DBG_ALWAYS, "emitted %d, asked for %d",
+ DBG(DBG_ALWAYS, "emitted %zd, asked for %d",
err/sizeof(gpioReport_t), emit);
}
}
dmaInitCbs();
flushMemory();
- initDMAgo((uint32_t *)dmaIn, (uint32_t)dmaIBus[0]);
+ //cast twice to suppress compiler warning, I belive this cast is ok
+ //because dmaIbus contains bus addresses, not user addresses. --plugwash
+ initDMAgo((uint32_t *)dmaIn, (uint32_t)(uintptr_t)dmaIBus[0]);
myGpioDelay(5000); /* let DMA run for a while */
oldSlot = dmaCurrentSlot(dmaNowAtICB());
gpioStats.DMARestarts++;
{
char buf[CMD_MAX_EXTENSION];
int idx, flags, len, res, i;
- uint32_t p[CMD_P_ARR];
+ uintptr_t p[CMD_P_ARR];
cmdCtlParse_t ctl;
uint32_t *param;
char v[CMD_MAX_EXTENSION];
static void *pthSocketThreadHandler(void *fdC)
{
int sock = *(int*)fdC;
- uint32_t p[10];
+ uintptr_t p[10];
int opt;
char buf[CMD_MAX_EXTENSION];
{
/* Serious error. No point continuing. */
DBG(DBG_ALWAYS,
- "recv failed for %d bytes, sock=%d", p[3], sock);
+ "recv failed for %"PRIdPTR" bytes, sock=%d", p[3], sock);
closeOrphanedNotifications(-1, sock);
{
/* Serious error. No point continuing. */
DBG(DBG_ALWAYS,
- "ext too large %d(%d), sock=%d", p[3], sizeof(buf), sock);
+ "ext too large %"PRIdPTR"(%zd), sock=%d", p[3], sizeof(buf), sock);
closeOrphanedNotifications(-1, sock);
dmaOut = dmaReg + (gpioCfg.DMAsecondaryChannel * 0x40);
}
- DBG(DBG_STARTUP, "DMA #%d @ %08X @ %08X",
- gpioCfg.DMAprimaryChannel, dmaBase, (uint32_t)dmaIn);
+ DBG(DBG_STARTUP, "DMA #%d @ %08X @ %08"PRIXPTR,
+ gpioCfg.DMAprimaryChannel, dmaBase, (uintptr_t)dmaIn);
DBG(DBG_STARTUP, "debug reg is %08X", dmaIn[DMA_DEBUG]);
(int pmapFd, void *virtualBase, int basePage, int pages)
{
int n;
- long index;
+ uintptr_t index;
off_t offset;
ssize_t t;
uint32_t physical;
int status;
- uint32_t pageAdr;
+ uintptr_t pageAdr;
unsigned long long pa;
DBG(DBG_STARTUP, "");
status = 0;
- pageAdr = (uint32_t) dmaVirt[basePage];
+ pageAdr = (uintptr_t) dmaVirt[basePage];
- index = ((uint32_t)virtualBase / PAGE_SIZE) * 8;
+ index = ((uintptr_t)virtualBase / PAGE_SIZE) * 8;
offset = lseek(pmapFd, index, SEEK_SET);
if (physical)
{
- dmaBus[basePage+n] = (dmaPage_t *) (physical | pi_dram_bus);
+ //cast twice to suppress warning, I belive this is ok as these
+ //are bus addresses, not virtual addresses. --plugwash
+ dmaBus[basePage+n] = (dmaPage_t *)(uintptr_t) (physical | pi_dram_bus);
dmaVirt[basePage+n] = mmap
(
close(fdPmap);
- DBG(DBG_STARTUP, "dmaPMapBlk=%08X dmaIn=%08X",
- (uint32_t)dmaPMapBlk, (uint32_t)dmaIn);
+ DBG(DBG_STARTUP, "dmaPMapBlk=%08"PRIXPTR" dmaIn=%08"PRIX64,
+ (uintptr_t)dmaPMapBlk, (uintptr_t)dmaIn);
}
else
{
mbClose(fdMbox);
- DBG(DBG_STARTUP, "dmaMboxBlk=%08X dmaIn=%08X",
- (uint32_t)dmaMboxBlk, (uint32_t)dmaIn);
+ DBG(DBG_STARTUP, "dmaMboxBlk=%08"PRIXPTR" dmaIn=%08"PRIXPTR,
+ (uintptr_t)dmaMboxBlk, (uintptr_t)dmaIn);
}
DBG(DBG_STARTUP,
- "gpioReg=%08X pwmReg=%08X pcmReg=%08X clkReg=%08X auxReg=%08X",
- (uint32_t)gpioReg, (uint32_t)pwmReg,
- (uint32_t)pcmReg, (uint32_t)clkReg, (uint32_t)auxReg);
+ "gpioReg=%08"PRIX64" pwmReg=%08"PRIX64" pcmReg=%08"PRIX64" clkReg=%08"PRIX64" auxReg=%08"PRIX64,
+ (uintptr_t)gpioReg, (uintptr_t)pwmReg,
+ (uintptr_t)pcmReg, (uintptr_t)clkReg, (uintptr_t)auxReg);
for (i=0; i<DMAI_PAGES; i++)
- DBG(DBG_STARTUP, "dmaIBus[%d]=%08X", i, (uint32_t)dmaIBus[i]);
+ DBG(DBG_STARTUP, "dmaIBus[%d]=%08"PRIX64, i, (uintptr_t)dmaIBus[i]);
if (gpioCfg.dbgLevel >= DBG_DMACBS)
{
flushMemory();
- initDMAgo((uint32_t *)dmaIn, (uint32_t)dmaIBus[0]);
+ //cast twice to suppress compiler warning, I belive this cast
+ //is ok because dmaIBus contains bus addresses, not virtual
+ //addresses.
+ initDMAgo((uint32_t *)dmaIn, (uint32_t)(uintptr_t)dmaIBus[0]);
return PIGPIO_VERSION;
}
for (i=0; i<gpioScript[script_id].script.instrs; i++)
{
fprintf(stderr,
- "c%d=[%d, %d(%d), %d(%d), %d, %d]\n",
+ "c%d=[%"PRIdPTR", %"PRIdPTR"(%d), %"PRIdPTR"(%d), %"PRIdPTR", %"PRIdPTR"]\n",
i,
gpioScript[script_id].script.instr[i].p[0],
gpioScript[script_id].script.instr[i].p[1],
{
int p;
- DBG(DBG_USER, "numPulses=%u pulses=%08X", numPulses, (uint32_t)pulses);
+ DBG(DBG_USER, "numPulses=%u pulses=%08"PRIXPTR, numPulses, (uintptr_t)pulses);
CHECK_INITED;
int tx_bit_pos;
DBG(DBG_USER,
- "spi=%08X off=%d spiSS=%d tx=%08X, num=%d fb=%d lb=%d spiBits=%d",
- (uint32_t)spi, offset, spiSS, (uint32_t)buf, spiTxBits,
+ "spi=%08"PRIXPTR" off=%d spiSS=%d tx=%08"PRIXPTR", num=%d fb=%d lb=%d spiBits=%d",
+ (uintptr_t)spi, offset, spiSS, (uintptr_t)buf, spiTxBits,
spiBitFirst, spiBitLast, spiBits);
CHECK_INITED;
block = n / WCB_CHAIN_OOL;
index = n % WCB_CHAIN_OOL;
p = (uint32_t *) dmaOBus[block] + (WCB_COUNTER_CBS+WCB_CHAIN_CBS) * 8;
- return (uint32_t) (p + index);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses.
+ return (uint32_t)(uintptr_t) (p + index);
}
return 0;
}
page = counter / 2;
offset = (counter % 2 ? WCB_COUNTER_OOL : 0);
p = (uint32_t *) dmaOBus[page] + (WCB_COUNTER_CBS+WCB_CHAIN_CBS) * 8;
- return (uint32_t)(p + WCB_CHAIN_OOL + offset + slot);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ return (uint32_t)(uintptr_t)(p + WCB_CHAIN_OOL + offset + slot);
}
static int chainGetCntCB(int counter)
p->dst = PWM_TIMER;
}
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = BPD * 20 / PI_WF_MICROS; /* 20 micros delay */
p->next = waveCbPOadr(chainGetCB(cb));
/* dummy src and dest */
p->info = NORMAL_DMA;
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
- p->dst = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
+ p->dst = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = 4;
p->next = waveCbPOadr(chainGetCntCB(counters));
p->dst = PWM_TIMER;
}
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = BPD * delayLeft / PI_WF_MICROS;
/* dummy src and dest */
p->info = NORMAL_DMA;
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
- p->dst = (uint32_t) (&dmaOBus[0]->periphData);
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
+ p->dst = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = 4;
p->next = waveCbPOadr(chainGetCB(loop));
endPtr = &p->next;
p = rawWaveCBAdr(chaincb);
p->info = NORMAL_DMA;
- p->src = (uint32_t) (&dmaOBus[0]->periphData);
- p->dst = (uint32_t) (&dmaOBus[0]->periphData);
+
+ //cast twice to suppress warning, I belive this is ok as dmaOBus
+ //contains bus addresses not virtual addresses. --plugwash
+ p->src = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
+ p->dst = (uint32_t)(uintptr_t) (&dmaOBus[0]->periphData);
p->length = 4;
p->next = 0;
int addr, flags, esc, setesc;
wfRx_t *w;
- DBG(DBG_USER, "gpio=%d inBuf=%s outBuf=%08X len=%d",
- SDA, myBuf2Str(inLen, (char *)inBuf), (int)outBuf, outLen);
+ DBG(DBG_USER, "gpio=%d inBuf=%s outBuf=%08"PRIX64" len=%d",
+ SDA, myBuf2Str(inLen, (char *)inBuf), (uintptr_t)outBuf, outLen);
CHECK_INITED;
int pos;
wfRx_t *w;
- DBG(DBG_USER, "CS=%d inBuf=%s outBuf=%08X count=%d",
- CS, myBuf2Str(count, (char *)inBuf), (int)outBuf, count);
+ DBG(DBG_USER, "CS=%d inBuf=%s outBuf=%08"PRIXPTR" count=%d",
+ CS, myBuf2Str(count, (char *)inBuf), (uintptr_t)outBuf, count);
CHECK_INITED;
unsigned bytes=0, wpos;
volatile wfRx_t *w;
- DBG(DBG_USER, "gpio=%d buf=%08X bufSize=%d", gpio, (int)buf, bufSize);
+ DBG(DBG_USER, "gpio=%d buf=%08"PRIXPTR" bufSize=%zd", gpio, (uintptr_t)buf, bufSize);
CHECK_INITED;
int user,
void * userdata)
{
- DBG(DBG_INTERNAL, "event=%d function=%08X, user=%d, userdata=%08X",
- event, (uint32_t)f, user, (uint32_t)userdata);
+ DBG(DBG_INTERNAL, "event=%d function=%08"PRIXPTR", user=%d, userdata=%08"PRIXPTR,
+ event, (uintptr_t)f, user, (uintptr_t)userdata);
eventAlert[event].ex = user;
eventAlert[event].userdata = userdata;
int eventSetFunc(unsigned event, eventFunc_t f)
{
- DBG(DBG_USER, "event=%d function=%08X", event, (uint32_t)f);
+ DBG(DBG_USER, "event=%d function=%08"PRIXPTR, event, (uintptr_t)f);
CHECK_INITED;
int eventSetFuncEx(unsigned event, eventFuncEx_t f, void *userdata)
{
- DBG(DBG_USER, "event=%d function=%08X userdata=%08X",
- event, (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "event=%d function=%08"PRIx64" userdata=%08"PRIx64,
+ event, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED;
int user,
void * userdata)
{
- DBG(DBG_INTERNAL, "gpio=%d function=%08X, user=%d, userdata=%08X",
- gpio, (uint32_t)f, user, (uint32_t)userdata);
+ DBG(DBG_INTERNAL, "gpio=%d function=%08"PRIXPTR", user=%d, userdata=%08"PRIXPTR,
+ gpio, (uintptr_t)f, user, (uintptr_t)userdata);
gpioAlert[gpio].ex = user;
gpioAlert[gpio].userdata = userdata;
int gpioSetAlertFunc(unsigned gpio, gpioAlertFunc_t f)
{
- DBG(DBG_USER, "gpio=%d function=%08X", gpio, (uint32_t)f);
+ DBG(DBG_USER, "gpio=%d function=%08"PRIXPTR, gpio, (uintptr_t)f);
CHECK_INITED;
int gpioSetAlertFuncEx(unsigned gpio, gpioAlertFuncEx_t f, void *userdata)
{
- DBG(DBG_USER, "gpio=%d function=%08X userdata=%08X",
- gpio, (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "gpio=%d function=%08"PRIX64" userdata=%08"PRIX64,
+ gpio, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED;
struct pollfd pfd;
char buf[64];
- DBG(DBG_USER, "gpio=%d edge=%d timeout=%d f=%x u=%d data=%x",
- isr->gpio, isr->edge, isr->timeout, (uint32_t)isr->func,
- isr->ex, (uint32_t)isr->userdata);
+ DBG(DBG_USER, "gpio=%d edge=%d timeout=%d f=%"PRIxPTR" u=%d data=%"PRIxPTR,
+ isr->gpio, isr->edge, isr->timeout, (uintptr_t)isr->func,
+ isr->ex, (uintptr_t)isr->userdata);
sprintf(buf, "/sys/class/gpio/gpio%d/value", isr->gpio);
int err;
DBG(DBG_INTERNAL,
- "gpio=%d edge=%d timeout=%d function=%08X user=%d userdata=%08X",
- gpio, edge, timeout, (uint32_t)f, user, (uint32_t)userdata);
+ "gpio=%d edge=%d timeout=%d function=%08"PRIXPTR" user=%d userdata=%08"PRIXPTR,
+ gpio, edge, timeout, (uintptr_t)f, user, (uintptr_t)userdata);
if (f)
{
int timeout,
gpioISRFunc_t f)
{
- DBG(DBG_USER, "gpio=%d edge=%d timeout=%d function=%08X",
- gpio, edge, timeout, (uint32_t)f);
+ DBG(DBG_USER, "gpio=%d edge=%d timeout=%d function=%08"PRIXPTR,
+ gpio, edge, timeout, (uintptr_t)f);
CHECK_INITED;
gpioAlertFuncEx_t f,
void *userdata)
{
- DBG(DBG_USER, "gpio=%d edge=%d timeout=%d function=%08X userdata=%08X",
- gpio, edge, timeout, (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "gpio=%d edge=%d timeout=%d function=%08"PRIXPTR" userdata=%08"PRIXPTR,
+ gpio, edge, timeout, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED;
int gpioSetGetSamplesFunc(gpioGetSamplesFunc_t f, uint32_t bits)
{
- DBG(DBG_USER, "function=%08X bits=%08X", (uint32_t)f, bits);
+ DBG(DBG_USER, "function=%08"PRIXPTR" bits=%08X", (uintptr_t)f, bits);
CHECK_INITED;
uint32_t bits,
void * userdata)
{
- DBG(DBG_USER, "function=%08X bits=%08X", (uint32_t)f, bits);
+ DBG(DBG_USER, "function=%08"PRIXPTR" bits=%08X", (uintptr_t)f, bits);
CHECK_INITED;
{
pthread_attr_t pthAttr;
- DBG(DBG_INTERNAL, "id=%d millis=%d function=%08X user=%d userdata=%08X",
- id, millis, (uint32_t)f, user, (uint32_t)userdata);
+ DBG(DBG_INTERNAL, "id=%d millis=%d function=%08"PRIXPTR" user=%d userdata=%08"PRIXPTR,
+ id, millis, (uintptr_t)f, user, (uintptr_t)userdata);
gpioTimer[id].id = id;
int gpioSetTimerFunc(unsigned id, unsigned millis, gpioTimerFunc_t f)
{
- DBG(DBG_USER, "id=%d millis=%d function=%08X", id, millis, (uint32_t)f);
+ DBG(DBG_USER, "id=%d millis=%d function=%08"PRIXPTR, id, millis, (uintptr_t)f);
CHECK_INITED;
int gpioSetTimerFuncEx(unsigned id, unsigned millis, gpioTimerFuncEx_t f,
void * userdata)
{
- DBG(DBG_USER, "id=%d millis=%d function=%08X, userdata=%08X",
- id, millis, (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "id=%d millis=%d function=%08"PRIXPTR", userdata=%08"PRIXPTR,
+ id, millis, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED;
pthread_t *pth;
pthread_attr_t pthAttr;
- DBG(DBG_USER, "f=%08X, userdata=%08X", (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "f=%08"PRIXPTR", userdata=%08"PRIXPTR, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED_RET_NULL_PTR;
void gpioStopThread(pthread_t *pth)
{
- DBG(DBG_USER, "pth=%08X", (uint32_t)pth);
+ DBG(DBG_USER, "pth=%08"PRIXPTR, (uintptr_t)pth);
CHECK_INITED_RET_NIL;
{
int status = 0;
- DBG(DBG_USER, "script_id=%d numParam=%d param=%08X",
- script_id, numParam, (uint32_t)param);
+ DBG(DBG_USER, "script_id=%d numParam=%d param=%08"PRIXPTR,
+ script_id, numParam, (uintptr_t)param);
CHECK_INITED;
int gpioUpdateScript(unsigned script_id, unsigned numParam, uint32_t *param)
{
- DBG(DBG_USER, "script_id=%d numParam=%d param=%08X",
- script_id, numParam, (uint32_t)param);
+ DBG(DBG_USER, "script_id=%d numParam=%d param=%08"PRIXPTR,
+ script_id, numParam, (uintptr_t)param);
CHECK_INITED;
int gpioScriptStatus(unsigned script_id, uint32_t *param)
{
- DBG(DBG_USER, "script_id=%d param=%08X", script_id, (uint32_t)param);
+ DBG(DBG_USER, "script_id=%d param=%08"PRIXPTR, script_id, (uintptr_t)param);
CHECK_INITED;
int gpioSetSignalFunc(unsigned signum, gpioSignalFunc_t f)
{
- DBG(DBG_USER, "signum=%d function=%08X", signum, (uint32_t)f);
+ DBG(DBG_USER, "signum=%d function=%08"PRIXPTR, signum, (uintptr_t)f);
CHECK_INITED;
int gpioSetSignalFuncEx(unsigned signum, gpioSignalFuncEx_t f,
void *userdata)
{
- DBG(DBG_USER, "signum=%d function=%08X userdata=%08X",
- signum, (uint32_t)f, (uint32_t)userdata);
+ DBG(DBG_USER, "signum=%d function=%08"PRIXPTR" userdata=%08"PRIXPTR,
+ signum, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED;
{
int r;
- DBG(DBG_USER, "handle=%d count=%d buf=0x%X", handle, count, (unsigned)buf);
+ DBG(DBG_USER, "handle=%d count=%d buf=0x%"PRIXPTR, handle, count, (uintptr_t)buf);
CHECK_INITED;
glob_t pglob;
int i;
- DBG(DBG_USER, "fpat=%s count=%d buf=%x", fpat, count, (unsigned)buf);
+ DBG(DBG_USER, "fpat=%s count=%d buf=%"PRIxPTR, fpat, count, (uintptr_t)buf);
CHECK_INITED;
{
struct timespec ts;
- DBG(DBG_USER, "timetype=%d &seconds=%08X µs=%08X",
- timetype, (uint32_t)seconds, (uint32_t)micros);
+ DBG(DBG_USER, "timetype=%d &seconds=%08"PRIXPTR" µs=%08"PRIXPTR,
+ timetype, (uintptr_t)seconds, (uintptr_t)micros);
CHECK_INITED;
int gpioCfgPermissions(uint64_t updateMask)
{
- DBG(DBG_USER, "gpio update mask=%llX", updateMask);
+ DBG(DBG_USER, "gpio update mask=%"PRIX64, updateMask);
CHECK_NOT_INITED;
{
int i;
- DBG(DBG_USER, "numSockAddr=%d sockAddr=%08X",
- numSockAddr, (unsigned)sockAddr);
+ DBG(DBG_USER, "numSockAddr=%d sockAddr=%08"PRIXPTR,
+ numSockAddr, (uintptr_t)sockAddr);
CHECK_NOT_INITED;