main.lss

rtc code for lpc2148

 abc:	e8bd8010 	ldmia	sp!, {r4, pc}
 ac0:	e002c000 	and	ip, r2, r0
 ac4:	e0010000 	and	r0, r1, r0
 ac8:	fffff000 	undefined instruction 0xfffff000
 acc:	000002c0 	andeq	r0, r0, r0, asr #5
 ad0:	4000019c 	mulmi	r0, ip, r1
 ad4:	4000019a 	mulmi	r0, sl, r1
 ad8:	40000224 	andmi	r0, r0, r4, lsr #4
 adc:	40000194 	mulmi	r0, r4, r1
 ae0:	4000008c 	andmi	r0, r0, ip, lsl #1

00000ae4 <uart1Putch>:

/******************************************************************************
 *
 * Function Name: uart1Putch()
 *
 * Description:  
 *    This function puts a character into the UART output queue for
 *    transmission.
 *
 * Calling Sequence: 
 *    ch - character to be transmitted
 *
 * Returns:
 *    ch on success, -1 on error (queue full)
 *
 *****************************************************************************/
int uart1Putch(int ch)
{
 ae4:	e92d40f0 	stmdb	sp!, {r4, r5, r6, r7, lr}
#ifdef UART1_TX_INT_MODE
  uint16_t temp;
  unsigned cpsr;

  temp = (uart1_tx_insert_idx + 1) % UART1_TX_BUFFER_SIZE;
 ae8:	e59f6094 	ldr	r6, [pc, #148]	; b84 <.text+0xb84>
 aec:	e1d630b0 	ldrh	r3, [r6]
 af0:	e59f2090 	ldr	r2, [pc, #144]	; b88 <.text+0xb88>
 af4:	e2833001 	add	r3, r3, #1	; 0x1
 af8:	e0032002 	and	r2, r3, r2

  if (temp == uart1_tx_extract_idx)
 afc:	e59f3088 	ldr	r3, [pc, #136]	; b8c <.text+0xb8c>
 b00:	e1a02802 	mov	r2, r2, lsl #16
 b04:	e1d330b0 	ldrh	r3, [r3]
 b08:	e1a05822 	mov	r5, r2, lsr #16
 b0c:	e1530005 	cmp	r3, r5
    return -1;                          // no room

  cpsr = disableIRQ();                  // disable global interrupts
  U1IER &= ~UIER_ETBEI;                 // disable TX interrupts
 b10:	e59f7078 	ldr	r7, [pc, #120]	; b90 <.text+0xb90>
 b14:	e3e03000 	mvn	r3, #0	; 0x0
 b18:	e1a04000 	mov	r4, r0
 b1c:	0a000016 	beq	b7c <uart1Putch+0x98>
 b20:	ebfffe4f 	bl	464 <disableIRQ>
 b24:	e5d73004 	ldrb	r3, [r7, #4]
 b28:	e20330fd 	and	r3, r3, #253	; 0xfd
 b2c:	e5c73004 	strb	r3, [r7, #4]
  restoreIRQ(cpsr);                     // restore global interrupts
 b30:	ebfffe4f 	bl	474 <restoreIRQ>

  // check if in process of sending data
  if (uart1_tx_running)
 b34:	e59f1058 	ldr	r1, [pc, #88]	; b94 <.text+0xb94>
 b38:	e5913000 	ldr	r3, [r1]
 b3c:	e3530000 	cmp	r3, #0	; 0x0
    {
    // add to queue
    uart1_tx_buffer[uart1_tx_insert_idx] = (uint8_t)ch;
    uart1_tx_insert_idx = temp;
    }
  else
    {
    // set running flag and write to output register
    uart1_tx_running = 1;
    U1THR = (uint8_t)ch;
 b40:	e20420ff 	and	r2, r4, #255	; 0xff
 b44:	159f304c 	ldrne	r3, [pc, #76]	; b98 <.text+0xb98>
 b48:	11d620b0 	ldrneh	r2, [r6]
 b4c:	03a03001 	moveq	r3, #1	; 0x1
 b50:	17c24003 	strneb	r4, [r2, r3]
 b54:	05813000 	streq	r3, [r1]
 b58:	05c72000 	streqb	r2, [r7]
 b5c:	11c650b0 	strneh	r5, [r6]
    }

  cpsr = disableIRQ();                  // disable global interrupts
 b60:	ebfffe3f 	bl	464 <disableIRQ>
  U1IER |= UIER_ETBEI;                  // enable TX interrupts
 b64:	e59f2024 	ldr	r2, [pc, #36]	; b90 <.text+0xb90>
 b68:	e5d23004 	ldrb	r3, [r2, #4]
 b6c:	e3833002 	orr	r3, r3, #2	; 0x2
 b70:	e5c23004 	strb	r3, [r2, #4]
  restoreIRQ(cpsr);                     // restore global interrupts
 b74:	ebfffe3e 	bl	474 <restoreIRQ>
#else
  while (!(U1LSR & ULSR_THRE))          // wait for TX buffer to empty
    continue;                           // also either WDOG() or swap()

  U1THR = (uint8_t)ch;
#endif
  return (uint8_t)ch;
 b78:	e20430ff 	and	r3, r4, #255	; 0xff
}
 b7c:	e1a00003 	mov	r0, r3
 b80:	e8bd80f0 	ldmia	sp!, {r4, r5, r6, r7, pc}
 b84:	4000019a 	mulmi	r0, sl, r1
 b88:	8000007f 	andhi	r0, r0, pc, ror r0
 b8c:	40000224 	andmi	r0, r0, r4, lsr #4
 b90:	e0010000 	and	r0, r1, r0
 b94:	40000194 	mulmi	r0, r4, r1
 b98:	40000090 	mulmi	r0, r0, r0

00000b9c <uart1Space>:

/******************************************************************************
 *
 * Function Name: uart1Space()
 *
 * Description:  
 *    This function gets the available space in the transmit queue
 *
 * Calling Sequence: 
 *    void
 *
 * Returns:
 *    available space in the transmit queue
 *
 *****************************************************************************/
uint16_t uart1Space(void)
{
#ifdef UART1_TX_INT_MODE
  int space;

  if ((space = (uart1_tx_extract_idx - uart1_tx_insert_idx)) <= 0)
 b9c:	e59f3024 	ldr	r3, [pc, #36]	; bc8 <.text+0xbc8>
 ba0:	e1d320b0 	ldrh	r2, [r3]
 ba4:	e59f3020 	ldr	r3, [pc, #32]	; bcc <.text+0xbcc>
 ba8:	e1d330b0 	ldrh	r3, [r3]
 bac:	e0630002 	rsb	r0, r3, r2
 bb0:	e3500000 	cmp	r0, #0	; 0x0
    space += UART1_TX_BUFFER_SIZE;
 bb4:	d2800080 	addle	r0, r0, #128	; 0x80
 bb8:	e2400001 	sub	r0, r0, #1	; 0x1
 bbc:	e1a00800 	mov	r0, r0, lsl #16

  return (uint16_t)(space - 1);
#else
  return USHRT_MAX;
#endif
}
 bc0:	e1a00820 	mov	r0, r0, lsr #16
 bc4:	e12fff1e 	bx	lr
 bc8:	40000224 	andmi	r0, r0, r4, lsr #4
 bcc:	4000019a 	mulmi	r0, sl, r1

00000bd0 <uart1Puts>:

/******************************************************************************
 *
 * Function Name: uart1Puts()
 *
 * Description:  
 *    This function writes a NULL terminated 'string' to the UART output
 *    queue, returning a pointer to the next character to be written.
 *
 * Calling Sequence: 
 *    address of the string
 *
 * Returns:
 *    a pointer to the next character to be written
 *    (\0 if full string is written)
 *
 *****************************************************************************/
const char *uart1Puts(const char *string)
{
 bd0:	e92d4010 	stmdb	sp!, {r4, lr}
 bd4:	e1a04000 	mov	r4, r0
 bd8:	ea000000 	b	be0 <uart1Puts+0x10>
  register char ch;

  while ((ch = *string) && (uart1Putch(ch) >= 0))
    string++;
 bdc:	e2844001 	add	r4, r4, #1	; 0x1
 be0:	e5d43000 	ldrb	r3, [r4]
 be4:	e2530000 	subs	r0, r3, #0	; 0x0
 be8:	0a000002 	beq	bf8 <uart1Puts+0x28>
 bec:	ebffffbc 	bl	ae4 <uart1Putch>
 bf0:	e3500000 	cmp	r0, #0	; 0x0
 bf4:	aafffff8 	bge	bdc <uart1Puts+0xc>

  return string;
}
 bf8:	e1a00004 	mov	r0, r4
 bfc:	e8bd8010 	ldmia	sp!, {r4, pc}

00000c00 <uart1Write>:

/******************************************************************************
 *
 * Function Name: uart1Write()
 *
 * Description:  
 *    This function writes 'count' characters from 'buffer' to the UART
 *    output queue.
 *
 * Calling Sequence: 
 *    
 *
 * Returns:
 *    0 on success, -1 if insufficient room, -2 on error
 *    NOTE: if insufficient room, no characters are written.
 *
 *****************************************************************************/
int uart1Write(const char *buffer, uint16_t count)
{
 c00:	e92d4070 	stmdb	sp!, {r4, r5, r6, lr}
 c04:	e1a01801 	mov	r1, r1, lsl #16
 c08:	e1a06821 	mov	r6, r1, lsr #16
 c0c:	e1a05000 	mov	r5, r0
#ifdef UART1_TX_INT_MODE
  if (count > uart1Space())
 c10:	ebffffe1 	bl	b9c <uart1Space>
 c14:	e1560000 	cmp	r6, r0
 c18:	83e00000 	mvnhi	r0, #0	; 0x0
 c1c:	88bd8070 	ldmhiia	sp!, {r4, r5, r6, pc}
 c20:	ea000001 	b	c2c <uart1Write+0x2c>
    return -1;
#endif
  while (count && (uart1Putch(*buffer++) >= 0))
 c24:	e3a00000 	mov	r0, #0	; 0x0
 c28:	e8bd8070 	ldmia	sp!, {r4, r5, r6, pc}
 c2c:	e1a04006 	mov	r4, r6
 c30:	ea000002 	b	c40 <uart1Write+0x40>
    count--;
 c34:	e2443001 	sub	r3, r4, #1	; 0x1
 c38:	e1a03803 	mov	r3, r3, lsl #16
 c3c:	e1a04823 	mov	r4, r3, lsr #16
 c40:	e3540000 	cmp	r4, #0	; 0x0
 c44:	0afffff6 	beq	c24 <uart1Write+0x24>
 c48:	e4d50001 	ldrb	r0, [r5], #1
 c4c:	ebffffa4 	bl	ae4 <uart1Putch>
 c50:	e3500000 	cmp	r0, #0	; 0x0
 c54:	aafffff6 	bge	c34 <uart1Write+0x34>
 c58:	e3e00001 	mvn	r0, #1	; 0x1

  return (count ? -2 : 0);
}
 c5c:	e8bd8070 	ldmia	sp!, {r4, r5, r6, pc}

00000c60 <uart1TxEmpty>:

/******************************************************************************
 *
 * Function Name: uart1TxEmpty()
 *
 * Description:
 *    This function returns the status of the UART transmit data
 *    registers.
 *
 * Calling Sequence: 
 *    void
 *
 * Returns:
 *    FALSE - either the tx holding or shift register is not empty
 *   !FALSE - if both the tx holding & shift registers are empty
 *
 *****************************************************************************/
int uart1TxEmpty(void)
{
  return (U1LSR & (ULSR_THRE | ULSR_TEMT)) == (ULSR_THRE | ULSR_TEMT);
 c60:	e59f3014 	ldr	r3, [pc, #20]	; c7c <.text+0xc7c>
 c64:	e5d30014 	ldrb	r0, [r3, #20]
 c68:	e2000060 	and	r0, r0, #96	; 0x60
}
 c6c:	e3500060 	cmp	r0, #96	; 0x60
 c70:	13a00000 	movne	r0, #0	; 0x0
 c74:	03a00001 	moveq	r0, #1	; 0x1
 c78:	e12fff1e 	bx	lr
 c7c:	e0010000 	and	r0, r1, r0

00000c80 <uart1TxFlush>:

/******************************************************************************
 *
 * Function Name: uart1TxFlush()
 *
 * Description:  
 *    This function removes all characters from the UART transmit queue
 *    (without transmitting them).
 *
 * Calling Sequence: 
 *    void
 *
 * Returns:
 *    void
 *
 *****************************************************************************/
void uart1TxFlush(void)
{
 c80:	e92d4010 	stmdb	sp!, {r4, lr}
#ifdef UART1_TX_INT_MODE
  unsigned cpsr;

  U1FCR |= UFCR_TX_FIFO_RESET;          // clear the TX fifo
 c84:	e59f4034 	ldr	r4, [pc, #52]	; cc0 <.text+0xcc0>
 c88:	e5d43008 	ldrb	r3, [r4, #8]
 c8c:	e3833004 	orr	r3, r3, #4	; 0x4
 c90:	e5c43008 	strb	r3, [r4, #8]

  // "Empty" the transmit buffer.
  cpsr = disableIRQ();                  // disable global interrupts
 c94:	ebfffdf2 	bl	464 <disableIRQ>
  U1IER &= ~UIER_ETBEI;                 // disable TX interrupts
 c98:	e5d43004 	ldrb	r3, [r4, #4]
 c9c:	e20330fd 	and	r3, r3, #253	; 0xfd
 ca0:	e5c43004 	strb	r3, [r4, #4]
  restoreIRQ(cpsr);                     // restore global interrupts
 ca4:	ebfffdf2 	bl	474 <restoreIRQ>
  uart1_tx_insert_idx = uart1_tx_extract_idx = 0;
 ca8:	e59f3014 	ldr	r3, [pc, #20]	; cc4 <.text+0xcc4>
 cac:	e3a02000 	mov	r2, #0	; 0x0
 cb0:	e1c320b0 	strh	r2, [r3]
 cb4:	e59f300c 	ldr	r3, [pc, #12]	; cc8 <.text+0xcc8>
 cb8:	e1c320b0 	strh	r2, [r3]
#else
  U1FCR |= UFCR_TX_FIFO_RESET;          // clear the TX fifo
#endif
}
 cbc:	e8bd8010 	ldmia	sp!, {r4, pc}
 cc0:	e0010000 	and	r0, r1, r0
 cc4:	4000019a 	mulmi	r0, sl, r1
 cc8:	40000224 	andmi	r0, r0, r4, lsr #4

00000ccc <uart1Getch>:

/******************************************************************************
 *
 * Function Name: uart1Getch()
 *
 * Description:  
 *    This function gets a character from the UART receive queue
 *
 * Calling Sequence: 
 *    void
 *
 * Returns:
 *    character on success, -1 if no character is available
 *
 *****************************************************************************/
int uart1Getch(void)
{
 ccc:	e52de004 	str	lr, [sp, #-4]!
#ifdef UART1_RX_INT_MODE
  uint8_t ch;

  if (uart1_rx_insert_idx == uart1_rx_extract_idx) // check if character is available
 cd0:	e59fe034 	ldr	lr, [pc, #52]	; d0c <.text+0xd0c>
 cd4:	e1de30b0 	ldrh	r3, [lr]
 cd8:	e1a0c803 	mov	ip, r3, lsl #16
 cdc:	e59f302c 	ldr	r3, [pc, #44]	; d10 <.text+0xd10>
 ce0:	e1a0282c 	mov	r2, ip, lsr #16
 ce4:	e1d310b0 	ldrh	r1, [r3]
    return -1;

  ch = uart1_rx_buffer[uart1_rx_extract_idx++]; // get character, bump pointer
 ce8:	e2823001 	add	r3, r2, #1	; 0x1
  uart1_rx_extract_idx %= UART1_RX_BUFFER_SIZE; // limit the pointer
 cec:	e203307f 	and	r3, r3, #127	; 0x7f
 cf0:	e1510002 	cmp	r1, r2
 cf4:	11ce30b0 	strneh	r3, [lr]
 cf8:	159f3014 	ldrne	r3, [pc, #20]	; d14 <.text+0xd14>
 cfc:	17d3382c 	ldrneb	r3, [r3, ip, lsr #16]
 d00:	e3e00000 	mvn	r0, #0	; 0x0
  return ch;
 d04:	11a00003 	movne	r0, r3
#else
  if (U1LSR & ULSR_RDR)                 // check if character is available
    return U1RBR;                       // return character

  return -1;
#endif
}
 d08:	e49df004 	ldr	pc, [sp], #4
 d0c:	4000019c 	mulmi	r0, ip, r1
 d10:	4000008c 	andmi	r0, r0, ip, lsl #1
 d14:	40000110 	andmi	r0, r0, r0, lsl r1

00000d18 <initSysTime>:
  T0MCR = 0;                            // disable match registers
  T0CCR = 0;                            // disable compare registers
  T0EMR = 0;                            // disable external match register
  T0TCR = TCR_ENABLE;                   // enable timer 0
  sysTICs = 0;
 d18:	e59f302c 	ldr	r3, [pc, #44]	; d4c <.text+0xd4c>
 d1c:	e59f202c 	ldr	r2, [pc, #44]	; d50 <.text+0xd50>
 d20:	e3a01000 	mo