sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add register monitor debug support

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@969 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2008-09-30 23:44:53 +00:00
parent 539369d52d
commit 9cc7f4e5b8
1 changed files with 139 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
arch/arm/src/lpc214x/lpc214x_usbdev.c
View File

@ -82,6 +82,12 @@
# define USB_FAST_INT 0 # define USB_FAST_INT 0
#endif #endif
/* Extremely detailed register debug that you would normally never want
* enabled.
*/
#undef CONFIG_LPC214X_USBDEV_REGDEBUG
/* Enable reading SOF from interrupt handler vs. simply reading on demand. Probably /* Enable reading SOF from interrupt handler vs. simply reading on demand. Probably
* a bad idea... Unless there is some issue with sampling the SOF from hardware * a bad idea... Unless there is some issue with sampling the SOF from hardware
* asynchronously. * asynchronously.
@ -114,7 +120,7 @@
#ifndef CONFIG_USBDEV_TRACE #ifndef CONFIG_USBDEV_TRACE
# undef usbtrace # undef usbtrace
# define usbtrace(a,b) udbg("%04x:%04x\n", a, b) # define usbtrace(a,b) ulldbg("%04x:%04x\n", a, b)
#endif #endif
/* Trace error codes */ /* Trace error codes */
@ -337,6 +343,16 @@ struct lpc214x_usbdev_s
* Private Function Prototypes * Private Function Prototypes
*******************************************************************************/ *******************************************************************************/
/* Register operations */
#if defined(CONFIG_LPC214X_USBDEV_REGDEBUG) && defined(CONFIG_DEBUG)
static uint32 lpc214x_getreg(uint32 addr);
static void lpc214x_putreg(uint32 val, uint32 addr);
#else
# define lpc214x_getreg(addr) getreg32(addr)
# define lpc214x_putreg(val,addr) putreg32(val,addr)
#endif
/* Command operations */ /* Command operations */
static uint32 lpc214x_usbcmd(uint16 cmd, ubyte data); static uint32 lpc214x_usbcmd(uint16 cmd, ubyte data);
@ -446,6 +462,39 @@ static const struct usbdev_ops_s g_devops =
* Private Functions * Private Functions
*******************************************************************************/ *******************************************************************************/
/*******************************************************************************
* Name: lpc214x_getreg
*
* Description:
* Get the contents of an LPC214x register
*
*******************************************************************************/
#if defined(CONFIG_LPC214X_USBDEV_REGDEBUG) && defined(CONFIG_DEBUG)
static uint32 lpc214x_getreg(uint32 addr)
{
uint32 val = getreg32(addr);
lldbg("%04x->%04x\n", addr, val);
return val;
}
#endif
/*******************************************************************************
* Name: lpc214x_putreg
*
* Description:
* Set the contents of an LPC214x register to a value
*
*******************************************************************************/
#if defined(CONFIG_LPC214X_USBDEV_REGDEBUG) && defined(CONFIG_DEBUG)
static void lpc214x_putreg(uint32 val, uint32 addr)
{
lldbg("%04x<-%04x\n", addr, val);
putreg32(val, addr);
}
#endif
/******************************************************************************* /*******************************************************************************
* Name: lpc214x_usbcmd * Name: lpc214x_usbcmd
* *
@ -462,19 +511,19 @@ static uint32 lpc214x_usbcmd(uint16 cmd, ubyte data)
/* Disable interrupt and clear CDFULL and CCEMPTY interrupt status */ /* Disable interrupt and clear CDFULL and CCEMPTY interrupt status */
flags = irqsave(); flags = irqsave();
putreg32(USBDEV_DEVINT_CDFULL|USBDEV_DEVINT_CCEMTY, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_CDFULL|USBDEV_DEVINT_CCEMTY, LPC214X_USBDEV_DEVINTCLR);
/* Load commonad in USB engine */ /* Load commonad in USB engine */
putreg32(((cmd & 0xff) << 16) + CMD_USB_CMDWR, LPC214X_USBDEV_CMDCODE); lpc214x_putreg(((cmd & 0xff) << 16) + CMD_USB_CMDWR, LPC214X_USBDEV_CMDCODE);
/* Wait until command is accepted */ /* Wait until command is accepted */
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0);
/* Clear command register empty (CCEMPTY) interrupt */ /* Clear command register empty (CCEMPTY) interrupt */
putreg32(USBDEV_DEVINT_CCEMTY, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_CCEMTY, LPC214X_USBDEV_DEVINTCLR);
/* determinate next phase of the command */ /* determinate next phase of the command */
@ -484,28 +533,28 @@ static uint32 lpc214x_usbcmd(uint16 cmd, ubyte data)
case CMD_USB_DEV_CONFIG: case CMD_USB_DEV_CONFIG:
case CMD_USB_DEV_SETMODE: case CMD_USB_DEV_SETMODE:
case CMD_USB_DEV_SETSTATUS: case CMD_USB_DEV_SETSTATUS:
putreg32((data << 16) + CMD_USB_DATAWR, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((data << 16) + CMD_USB_DATAWR, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0);
break; break;
case CMD_USB_DEV_READFRAMENO: case CMD_USB_DEV_READFRAMENO:
case CMD_USB_DEV_READTESTREG: case CMD_USB_DEV_READTESTREG:
putreg32((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0);
putreg32(USBDEV_DEVINT_CDFULL, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_CDFULL, LPC214X_USBDEV_DEVINTCLR);
tmp = getreg32(LPC214X_USBDEV_CMDDATA); tmp = lpc214x_getreg(LPC214X_USBDEV_CMDDATA);
putreg32((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0);
tmp |= getreg32(LPC214X_USBDEV_CMDDATA) << 8; tmp |= lpc214x_getreg(LPC214X_USBDEV_CMDDATA) << 8;
break; break;
case CMD_USB_DEV_GETSTATUS: case CMD_USB_DEV_GETSTATUS:
case CMD_USB_DEV_GETERRORCODE: case CMD_USB_DEV_GETERRORCODE:
case CMD_USB_DEV_READERRORSTATUS: case CMD_USB_DEV_READERRORSTATUS:
case CMD_USB_EP_CLRBUFFER: case CMD_USB_EP_CLRBUFFER:
putreg32((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0);
tmp = getreg32(LPC214X_USBDEV_CMDDATA); tmp = lpc214x_getreg(LPC214X_USBDEV_CMDDATA);
break; break;
default: default:
@ -513,14 +562,14 @@ static uint32 lpc214x_usbcmd(uint16 cmd, ubyte data)
{ {
case CMD_USB_EP_SELECT: case CMD_USB_EP_SELECT:
case CMD_USB_EP_SELECTCLEAR: case CMD_USB_EP_SELECTCLEAR:
putreg32((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((cmd << 16) + CMD_USB_DATARD, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0);
tmp = getreg32(LPC214X_USBDEV_CMDDATA); tmp = lpc214x_getreg(LPC214X_USBDEV_CMDDATA);
break; break;
case CMD_USB_EP_SETSTATUS: case CMD_USB_EP_SETSTATUS:
putreg32((data << 16) + CMD_USB_DATAWR, LPC214X_USBDEV_CMDCODE); lpc214x_putreg((data << 16) + CMD_USB_DATAWR, LPC214X_USBDEV_CMDCODE);
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CCEMTY) == 0);
break; break;
} }
break; break;
@ -544,7 +593,7 @@ static void lpc214x_epwrite(ubyte epphy, const ubyte *data, uint32 nbytes)
{ {
/* Set the write enable bit for this physical EP address */ /* Set the write enable bit for this physical EP address */
putreg32(((epphy << 1) & LPC214X_USBCTRL_EPMASK) | LPC214X_USBCTRL_WREN, lpc214x_putreg(((epphy << 1) & LPC214X_USBCTRL_EPMASK) | LPC214X_USBCTRL_WREN,
LPC214X_USBDEV_CTRL); LPC214X_USBDEV_CTRL);
/* Set the transmit packet length (nbytes must be less than 2048) */ /* Set the transmit packet length (nbytes must be less than 2048) */
@ -559,20 +608,20 @@ static void lpc214x_epwrite(ubyte epphy, const ubyte *data, uint32 nbytes)
if (nbytes) if (nbytes)
{ {
putreg32(*data++, LPC214X_USBDEV_TXDATA); lpc214x_putreg(*data++, LPC214X_USBDEV_TXDATA);
} }
else else
{ {
/* Zero length packet */ /* Zero length packet */
putreg32(0, LPC214X_USBDEV_TXDATA); lpc214x_putreg(0, LPC214X_USBDEV_TXDATA);
} }
} }
while ((getreg32(LPC214X_USBDEV_CTRL) & LPC214X_USBCTRL_WREN) != 0); while ((lpc214x_getreg(LPC214X_USBDEV_CTRL) & LPC214X_USBCTRL_WREN) != 0);
/* Done */ /* Done */
putreg32(0, LPC214X_USBDEV_CTRL); lpc214x_putreg(0, LPC214X_USBDEV_CTRL);
(void)lpc214x_usbcmd(CMD_USB_EP_SELECT | epphy, 0); (void)lpc214x_usbcmd(CMD_USB_EP_SELECT | epphy, 0);
(void)lpc214x_usbcmd(CMD_USB_EP_VALIDATEBUFFER, 0); (void)lpc214x_usbcmd(CMD_USB_EP_VALIDATEBUFFER, 0);
} }
@ -593,22 +642,22 @@ static int lpc214x_epread(ubyte epphy, ubyte *data, uint32 nbytes)
/* Set the read enable bit for this physical EP address */ /* Set the read enable bit for this physical EP address */
putreg32(((epphy << 1) & LPC214X_USBCTRL_EPMASK) | LPC214X_USBCTRL_RDEN, lpc214x_putreg(((epphy << 1) & LPC214X_USBCTRL_EPMASK) | LPC214X_USBCTRL_RDEN,
LPC214X_USBDEV_CTRL); LPC214X_USBDEV_CTRL);
/* Wait for packet buffer ready for reading */ /* Wait for packet buffer ready for reading */
while ((getreg32(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_PKTRDY) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_PKTRDY) == 0);
/* Get the about of data to be read */ /* Get the about of data to be read */
pktlen = getreg32(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_PKTLENGTH; pktlen = lpc214x_getreg(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_PKTLENGTH;
/* Read data from input buffer while read data is valid (DV) */ /* Read data from input buffer while read data is valid (DV) */
while ((getreg32(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_DV) != 0) while ((lpc214x_getreg(LPC214X_USBDEV_RXPLEN) & USBDEV_RXPLEN_DV) != 0)
{ {
value = getreg32(LPC214X_USBDEV_RXDATA); value = lpc214x_getreg(LPC214X_USBDEV_RXDATA);
if (data) if (data)
{ {
*data++ = value; *data++ = value;
@ -617,7 +666,7 @@ static int lpc214x_epread(ubyte epphy, ubyte *data, uint32 nbytes)
/* Done */ /* Done */
putreg32(0, LPC214X_USBDEV_CTRL); lpc214x_putreg(0, LPC214X_USBDEV_CTRL);
(void)lpc214x_usbcmd(CMD_USB_EP_SELECT | epphy, 0); (void)lpc214x_usbcmd(CMD_USB_EP_SELECT | epphy, 0);
result = lpc214x_usbcmd(CMD_USB_EP_CLRBUFFER, 0); result = lpc214x_usbcmd(CMD_USB_EP_CLRBUFFER, 0);
@ -857,26 +906,26 @@ static void lpc214x_eprealize(struct lpc214x_ep_s *privep, boolean prio, uint32
/* Clear realize interrupt bit */ /* Clear realize interrupt bit */
putreg32(USBDEV_DEVINT_EPRLZED, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_EPRLZED, LPC214X_USBDEV_DEVINTCLR);
/* Realize the endpoint */ /* Realize the endpoint */
reg = getreg32(LPC214X_USBDEV_REEP); reg = lpc214x_getreg(LPC214X_USBDEV_REEP);
reg |= (1 << privep->epphy); reg |= (1 << privep->epphy);
putreg32(reg, LPC214X_USBDEV_REEP); lpc214x_putreg(reg, LPC214X_USBDEV_REEP);
/* Set endpoint maximum packet size */ /* Set endpoint maximum packet size */
putreg(privep->epphy, LPC214X_USBDEV_EPIND); lpc214x_putreg(privep->epphy, LPC214X_USBDEV_EPIND);
putreg(packetsize, LPC214X_USBDEV_MAXPSIZE); lpc214x_putreg(packetsize, LPC214X_USBDEV_MAXPSIZE);
/* Wait for Realize complete */ /* Wait for Realize complete */
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_EPRLZED) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_EPRLZED) == 0);
/* Clear realize interrupt bit */ /* Clear realize interrupt bit */
putreg32(USBDEV_DEVINT_EPRLZED,LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_EPRLZED,LPC214X_USBDEV_DEVINTCLR);
} }
/******************************************************************************* /*******************************************************************************
@ -891,15 +940,15 @@ static ubyte lpc214x_epclrinterrupt(ubyte epphy)
{ {
/* Clear the endpoint interrupt */ /* Clear the endpoint interrupt */
putreg32(1 << epphy, LPC214X_USBDEV_EPINTCLR); lpc214x_putreg(1 << epphy, LPC214X_USBDEV_EPINTCLR);
/* Wait for data in the command data register */ /* Wait for data in the command data register */
while ((getreg32(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0); while ((lpc214x_getreg(LPC214X_USBDEV_DEVINTST) & USBDEV_DEVINT_CDFULL) == 0);
/* Return the value of the command data register */ /* Return the value of the command data register */
return getreg32(LPC214X_USBDEV_CMDDATA); return lpc214x_getreg(LPC214X_USBDEV_CMDDATA);
} }
/******************************************************************************* /*******************************************************************************
@ -921,9 +970,9 @@ static inline void lpc214x_ep0configure(struct lpc214x_usbdev_s *priv)
/* Enable EP0 interrupts (not DMA) */ /* Enable EP0 interrupts (not DMA) */
inten = getreg32(LPC214X_USBDEV_EPINTEN); inten = lpc214x_getreg(LPC214X_USBDEV_EPINTEN);
inten |= 3; /* EP0 Rx and Tx */ inten |= 3; /* EP0 Rx and Tx */
putreg32(inten, LPC214X_USBDEV_EPINTEN); lpc214x_putreg(inten, LPC214X_USBDEV_EPINTEN);
} }
/******************************************************************************* /*******************************************************************************
@ -940,11 +989,11 @@ static inline void lpc214x_dmareset(uint32 enable)
/* Disable All DMA interrupts */ /* Disable All DMA interrupts */
putreg32(0, LPC214X_USBDEV_DMAINTEN); lpc214x_putreg(0, LPC214X_USBDEV_DMAINTEN);
/* DMA Disable */ /* DMA Disable */
putreg32(0xffffffff, LPC214X_USBDEV_EPDMADIS); lpc214x_putreg(0xffffffff, LPC214X_USBDEV_EPDMADIS);
/* DMA Request clear */ /* DMA Request clear */
@ -971,7 +1020,7 @@ static inline void lpc214x_dmareset(uint32 enable)
/* Set USB UDCA Head register */ /* Set USB UDCA Head register */
putreg32((uint32)USB_UDCA, LPC214X_USBDEV_UDCAH); lpc214x_putreg((uint32)USB_UDCA, LPC214X_USBDEV_UDCAH);
/* Invalidate all DMA descriptors */ /* Invalidate all DMA descriptors */
@ -982,7 +1031,7 @@ static inline void lpc214x_dmareset(uint32 enable)
/* Enable DMA interrupts */ /* Enable DMA interrupts */
putreg32(enable, LPC214X_USBDEV_DMAINTEN); lpc214x_putreg(enable, LPC214X_USBDEV_DMAINTEN);
} }
#endif #endif
@ -998,16 +1047,16 @@ static void lpc214x_usbreset(struct lpc214x_usbdev_s *priv)
{ {
/* Disable all endpoint interrupts */ /* Disable all endpoint interrupts */
putreg32(0, LPC214X_USBDEV_EPINTEN); lpc214x_putreg(0, LPC214X_USBDEV_EPINTEN);
/* Frame is Hp interrupt */ /* Frame is Hp interrupt */
putreg32(1, LPC214X_USBDEV_DEVINTPRI); lpc214x_putreg(1, LPC214X_USBDEV_DEVINTPRI);
/* Clear all pending interrupts */ /* Clear all pending interrupts */
putreg32(0xffffffff, LPC214X_USBDEV_EPINTCLR); lpc214x_putreg(0xffffffff, LPC214X_USBDEV_EPINTCLR);
putreg32(0xffffffff, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(0xffffffff, LPC214X_USBDEV_DEVINTCLR);
/* Periperhal address is needed */ /* Periperhal address is needed */
@ -1032,7 +1081,7 @@ static void lpc214x_usbreset(struct lpc214x_usbdev_s *priv)
/* Enable Device interrupts */ /* Enable Device interrupts */
putreg32(USB_SLOW_INT|USB_DEVSTATUS_INT|USB_FAST_INT|USB_FRAME_INT|USB_ERROR_INT, lpc214x_putreg(USB_SLOW_INT|USB_DEVSTATUS_INT|USB_FAST_INT|USB_FRAME_INT|USB_ERROR_INT,
LPC214X_USBDEV_DEVINTEN); LPC214X_USBDEV_DEVINTEN);
} }
@ -1477,12 +1526,12 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
/* Read the device interrupt status register */ /* Read the device interrupt status register */
devintstatus = getreg32(LPC214X_USBDEV_DEVINTST); devintstatus = lpc214x_getreg(LPC214X_USBDEV_DEVINTST);
#ifdef CONFIG_LPC214X_USBDEV_DMA #ifdef CONFIG_LPC214X_USBDEV_DMA
/* Check for low priority and high priority (non-DMA) interrupts */ /* Check for low priority and high priority (non-DMA) interrupts */
if ((getreg(LPC214X_USBDEV_INTST) & (USBDEV_INTST_REQLP|USBDEV_INTST_REQHP)) != 0) if ((lpc214x_getreg(LPC214X_USBDEV_INTST) & (USBDEV_INTST_REQLP|USBDEV_INTST_REQHP)) != 0)
{ {
#endif #endif
#ifdef CONFIG_LPC214X_USBDEV_EPFAST_INTERRUPT #ifdef CONFIG_LPC214X_USBDEV_EPFAST_INTERRUPT
@ -1492,7 +1541,7 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
{ {
/* Clear Fast EP interrupt */ /* Clear Fast EP interrupt */
putreg32(USBDEV_DEVINT_EPFAST, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_EPFAST, LPC214X_USBDEV_DEVINTCLR);
usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_EPFAST), 0); usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_EPFAST), 0);
/* Do what? */ /* Do what? */
@ -1509,7 +1558,7 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
/* Clear the error interrupt */ /* Clear the error interrupt */
putreg32(USBDEV_DEVINT_EPRINT, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_EPRINT, LPC214X_USBDEV_DEVINTCLR);
/* And show what error occurred */ /* And show what error occurred */
@ -1525,7 +1574,7 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
{ {
/* Clear the frame interrupt */ /* Clear the frame interrupt */
putreg32(USBDEV_DEVINT_FRAME, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_FRAME, LPC214X_USBDEV_DEVINTCLR);
usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_FRAME), 0); usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_FRAME), 0);
/* Then read the start of frame value */ /* Then read the start of frame value */
@ -1540,7 +1589,7 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
{ {
/* Clear Device status interrupt */ /* Clear Device status interrupt */
putreg32(USBDEV_DEVINT_DEVSTAT, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_DEVSTAT, LPC214X_USBDEV_DEVINTCLR);
/* Get device status */ /* Get device status */
@ -1601,14 +1650,14 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
{ {
/* Clear Slow EP interrupt */ /* Clear Slow EP interrupt */
putreg32(USBDEV_DEVINT_EPSLOW, LPC214X_USBDEV_DEVINTCLR); lpc214x_putreg(USBDEV_DEVINT_EPSLOW, LPC214X_USBDEV_DEVINTCLR);
usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_EPSLOW), 0); usbtrace(TRACE_INTDECODE(LPC214X_TRACEINTID_EPSLOW), 0);
do do
{ {
/* Read the endpoint interrupt status register */ /* Read the endpoint interrupt status register */
epintstatus = getreg32(LPC214X_USBDEV_EPINTST); epintstatus = lpc214x_getreg(LPC214X_USBDEV_EPINTST);
/* Loop twice: Process software high priority interrupts /* Loop twice: Process software high priority interrupts
* on the first pass and low priority interrupts on the * on the first pass and low priority interrupts on the
@ -1727,7 +1776,7 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
/* Check for DMA interrupts */ /* Check for DMA interrupts */
if ((getreg(LPC214X_USBDEV_INTST) & USBDEV_INTST_REQDMA) != 0) if ((lpc214x_getreg(LPC214X_USBDEV_INTST) & USBDEV_INTST_REQDMA) != 0)
{ {
/* First Software High priority and then low priority */ /* First Software High priority and then low priority */
@ -1736,26 +1785,26 @@ static int lpc214x_usbinterrupt(int irq, FAR void *context)
/* Collect the DMA interrupt sources */ /* Collect the DMA interrupt sources */
dmaintstatus = 0; dmaintstatus = 0;
tmp = getreg32(LPC214X_USBDEV_EOTINTST); tmp = lpc214x_getreg(LPC214X_USBDEV_EOTINTST);
if (getreg32(LPC214X_USBDEV_DMAINTEN) & 1) if (lpc214x_getreg(LPC214X_USBDEV_DMAINTEN) & 1)
{ {
dmaintstatus |= tmp; dmaintstatus |= tmp;
} }
putreg32(tmp, LPC214X_USBDEV_EOTINTCLR); lpc214x_putreg(tmp, LPC214X_USBDEV_EOTINTCLR);
tmp = getreg32(LPC214X_USBDEV_NDDRINTST); tmp = lpc214x_getreg(LPC214X_USBDEV_NDDRINTST);
if (getreg32(LPC214X_USBDEV_DMAINTEN) & 2) if (lpc214x_getreg(LPC214X_USBDEV_DMAINTEN) & 2)
{ {
dmaintstatus |= tmp; dmaintstatus |= tmp;
} }
putreg32(tmp, LPC214X_USBDEV_NDDRINTCLR); lpc214x_putreg(tmp, LPC214X_USBDEV_NDDRINTCLR);
tmp = getreg32(LPC214X_USBDEV_SYSERRINTST); tmp = lpc214x_getreg(LPC214X_USBDEV_SYSERRINTST);
if (getreg32(LPC214X_USBDEV_DMAINTEN) & 4) if (lpc214x_getreg(LPC214X_USBDEV_DMAINTEN) & 4)
{ {
dmaintstatus |= tmp; dmaintstatus |= tmp;
} }
putreg32(tmp, LPC214X_USBDEV_SYSERRINTCLR); lpc214x_putreg(tmp, LPC214X_USBDEV_SYSERRINTCLR);
/* Loop twice: Process software high priority interrupts on the /* Loop twice: Process software high priority interrupts on the
* first pass and low priority interrupts on the second. * first pass and low priority interrupts on the second.
@ -1894,7 +1943,7 @@ static void lpc214x_dmarestart(ubyte epphy, uint32 descndx)
/* Enable DMA transfer on the endpoint */ /* Enable DMA transfer on the endpoint */
putreg32(1 << epph, LPC214X_USBDEV_EPDMAEN); lpc214x_putreg(1 << epph, LPC214X_USBDEV_EPDMAEN);
/* Check the state of IN/OUT EP buffer */ /* Check the state of IN/OUT EP buffer */
@ -1962,13 +2011,13 @@ static int lpc214x_epconfigure(FAR struct usbdev_ep_s *ep,
#ifdef CONFIG_LPC214X_USBDEV_DMA #ifdef CONFIG_LPC214X_USBDEV_DMA
/* Enable DMA Ep interrupt (WO) */ /* Enable DMA Ep interrupt (WO) */
putreg32(1 << epphy, LPC214X_USBDEV_EPDMAEN); lpc214x_putreg(1 << epphy, LPC214X_USBDEV_EPDMAEN);
#else #else
/* Enable Ep interrupt (R/W) */ /* Enable Ep interrupt (R/W) */
inten = getreg32(LPC214X_USBDEV_EPINTEN); inten = lpc214x_getreg(LPC214X_USBDEV_EPINTEN);
inten |= (1 << epphy); inten |= (1 << epphy);
putreg32(inten, LPC214X_USBDEV_EPINTEN); lpc214x_putreg(inten, LPC214X_USBDEV_EPINTEN);
#endif #endif
return OK; return OK;
} }
@ -2004,15 +2053,15 @@ static int lpc214x_epdisable(FAR struct usbdev_ep_s *ep)
/* Disable endpoint and interrupt */ /* Disable endpoint and interrupt */
reg = getreg32(LPC214X_USBDEV_REEP); reg = lpc214x_getreg(LPC214X_USBDEV_REEP);
reg &= ~mask; reg &= ~mask;
putreg32(reg, LPC214X_USBDEV_REEP); lpc214x_putreg(reg, LPC214X_USBDEV_REEP);
putreg32(mask, LPC214X_USBDEV_EPDMADIS); lpc214x_putreg(mask, LPC214X_USBDEV_EPDMADIS);
reg = getreg32(LPC214X_USBDEV_EPINTEN); reg = lpc214x_getreg(LPC214X_USBDEV_EPINTEN);
reg &= ~mask; reg &= ~mask;
putreg32(reg, LPC214X_USBDEV_EPINTEN); lpc214x_putreg(reg, LPC214X_USBDEV_EPINTEN);
irqrestore(flags); irqrestore(flags);
return OK; return OK;
@ -2540,15 +2589,15 @@ void up_usbinitialize(void)
/* Turn on USB power and clocking */ /* Turn on USB power and clocking */
reg = getreg32(LPC214X_PCON_PCONP); reg = lpc214x_getreg(LPC214X_PCON_PCONP);
reg |= LPC214X_PCONP_PCUSB; reg |= LPC214X_PCONP_PCUSB;
putreg32(reg, LPC214X_PCON_PCONP); lpc214x_putreg(reg, LPC214X_PCON_PCONP);
/* Enable Vbus sense and Connect */ /* Enable Vbus sense and Connect */
reg = getreg32(LPC214X_PINSEL1); reg = lpc214x_getreg(LPC214X_PINSEL1);
reg = (reg & LPC214X_USBDEV_PINMASK) | LPC214X_USBDEV_PINSEL; reg = (reg & LPC214X_USBDEV_PINMASK) | LPC214X_USBDEV_PINSEL;
putreg32(reg, LPC214X_PINSEL1); lpc214x_putreg(reg, LPC214X_PINSEL1);
/* Attach USB controller interrupt handler */ /* Attach USB controller interrupt handler */
@ -2615,9 +2664,9 @@ void up_usbuninitialize(void)
/* Turn off USB power and clocking */ /* Turn off USB power and clocking */
reg = getreg32(LPC214X_PCON_PCONP); reg = lpc214x_getreg(LPC214X_PCON_PCONP);
reg &= ~LPC214X_PCONP_PCUSB; reg &= ~LPC214X_PCONP_PCUSB;
putreg32(reg, LPC214X_PCON_PCONP); lpc214x_putreg(reg, LPC214X_PCON_PCONP);
irqrestore(flags); irqrestore(flags);
} }