hal_uart.s51

cc2430应用实例

//  610     HAL_UART_ASSERT( (config->rx.maxBufSize < 256) );
//  611     cfg->rxBuf = osal_mem_alloc( cfg->rxMax+1 );
//  612     URX0IE = 1;
//  613     IEN2 |= UTX0IE;
//  614 #endif
//  615 
//  616     // 8 bits/char; no parity; 1 stop bit; stop bit hi.
//  617     if ( config->flowControl )
//  618     {
//  619       cfg->flag |= UART_CFG_FLW;
//  620       U0UCR = UCR_FLOW | UCR_STOP;
//  621       // Must rely on H/W for RTS (i.e. Tx stops when receiver negates CTS.)
//  622       P0SEL |= HAL_UART_0_P0_RTS;
//  623       // Cannot use H/W for CTS as DMA does not clear the Rx bytes properly.
//  624       P0DIR |= HAL_UART_0_P0_CTS;
//  625       RX0_FLOW_ON;
//  626     }
//  627     else
//  628     {
//  629       U0UCR = UCR_STOP;
//  630     }
//  631     }
//  632 #endif
//  633 
//  634 #if HAL_UART_1_ENABLE
//  635   if ( port == HAL_UART_PORT_1 )
//  636   {
//  637     // Only supporting 38400 or 115200 for code size - other is possible.
//  638     U1BAUD = (config->baudRate == HAL_UART_BR_38400) ? 59 : 216;
//  639     U1GCR = (config->baudRate == HAL_UART_BR_38400) ? 10 : 11;
//  640 
//  641     U1CSR |= CSR_RE;
//  642 
//  643 #if HAL_UART_DMA == 2
//  644     cfg->flag = (UART_CFG_U1F | UART_CFG_DMA);
//  645     HAL_UART_ASSERT( (config->rx.maxBufSize <= 128) );
//  646     HAL_UART_ASSERT( (config->rx.maxBufSize > SAFE_RX_MIN) );
//  647     cfg->rxBuf = osal_mem_alloc( cfg->rxMax*2 );
//  648     osal_memset( cfg->rxBuf, ~DMA_PAD, cfg->rxMax*2 );
//  649     DMA_RX( cfg );
//  650 #else
//  651     cfg->flag = UART_CFG_U1F;
//  652     HAL_UART_ASSERT( (config->rx.maxBufSize < 256) );
//  653     cfg->rxBuf = osal_mem_alloc( cfg->rxMax+1 );
//  654     URX1IE = 1;
//  655     IEN2 |= UTX1IE;
//  656 #endif
//  657 
//  658     // 8 bits/char; no parity; 1 stop bit; stop bit hi.
//  659     if ( config->flowControl )
//  660     {
//  661       cfg->flag |= UART_CFG_FLW;
//  662       U1UCR = UCR_FLOW | UCR_STOP;
//  663       // Must rely on H/W for RTS (i.e. Tx stops when receiver negates CTS.)
//  664       P1SEL |= HAL_UART_1_P1_RTS;
//  665       // Cannot use H/W for CTS as DMA does not clear the Rx bytes properly.
//  666       P1DIR |= HAL_UART_1_P1_CTS;
//  667       RX1_FLOW_ON;
//  668     }
//  669     else
//  670     {
//  671       U1UCR = UCR_STOP;
//  672     }
//  673   }
//  674 #endif
//  675 
//  676   return HAL_UART_SUCCESS;
        MOV	R1,#0x0
        MOV	R7,#0x4
        LJMP	?BANKED_LEAVE_XDATA
        CFI EndBlock cfiBlock1
//  677 }
//  678 
//  679 /******************************************************************************
//  680  * @fn      HalUARTClose
//  681  *
//  682  * @brief   Close the UART
//  683  *
//  684  * @param   port - UART port
//  685  *
//  686  * @return  none
//  687  *****************************************************************************/

        RSEG BANKED_CODE:CODE:NOROOT(0)
//  688 void HalUARTClose( uint8 port )
HalUARTClose:
        CFI Block cfiBlock2 Using cfiCommon0
        CFI Function HalUARTClose
//  689 {
        ; Saved register size: 0
        ; Auto size: 0
//  690 #if HAL_UART_CLOSE
//  691   uartCfg_t *cfg;
//  692 
//  693 #if HAL_UART_0_ENABLE
//  694   if ( port == HAL_UART_PORT_0 )
//  695   {
//  696     U0CSR &= ~CSR_RE;
//  697 #if HAL_UART_DMA == 1
//  698     HAL_DMA_ABORT_CH( HAL_DMA_CH_RX );
//  699     HAL_DMA_ABORT_CH( HAL_DMA_CH_TX );
//  700 #else
//  701     URX0IE = 0;
//  702 #endif
//  703     cfg = cfg0;
//  704     cfg0 = NULL;
//  705   }
//  706 #endif
//  707 #if HAL_UART_1_ENABLE
//  708   if ( port == HAL_UART_PORT_1 )
//  709   {
//  710     U1CSR &= ~CSR_RE;
//  711 #if HAL_UART_DMA == 2
//  712     HAL_DMA_ABORT_CH( HAL_DMA_CH_RX );
//  713     HAL_DMA_ABORT_CH( HAL_DMA_CH_TX );
//  714 #else
//  715     URX1IE = 0;
//  716 #endif
//  717     cfg = cfg1;
//  718     cfg1 = NULL;
//  719   }
//  720 #endif
//  721 
//  722   if ( cfg )
//  723   {
//  724     if ( cfg->rxBuf )
//  725     {
//  726       osal_mem_free( cfg->rxBuf );
//  727     }
//  728     if ( cfg->txBuf )
//  729     {
//  730       osal_mem_free( cfg->txBuf );
//  731     }
//  732     osal_mem_free( cfg );
//  733   }
//  734 #endif
//  735 }
        LJMP	?BRET
        CFI EndBlock cfiBlock2
//  736 
//  737 /******************************************************************************
//  738  * @fn      HalUARTPoll
//  739  *
//  740  * @brief   Poll the UART.
//  741  *
//  742  * @param   none
//  743  *
//  744  * @return  none
//  745  *****************************************************************************/

        RSEG BANKED_CODE:CODE:NOROOT(0)
//  746 void HalUARTPoll( void )
HalUARTPoll:
        CFI Block cfiBlock3 Using cfiCommon0
        CFI Function HalUARTPoll
//  747 {
        ; Saved register size: 0
        ; Auto size: 0
//  748 #if ( HAL_UART_0_ENABLE | HAL_UART_1_ENABLE )
//  749   static uint8 tickShdw;
//  750   uartCfg_t *cfg;
//  751   uint8 tick;
//  752 
//  753 #if HAL_UART_0_ENABLE
//  754   if ( cfg0 )
//  755   {
//  756     cfg = cfg0;
//  757   }
//  758 #endif
//  759 #if HAL_UART_1_ENABLE
//  760   if ( cfg1 )
//  761   {
//  762     cfg = cfg1;
//  763   }
//  764 #endif
//  765 
//  766   // Use the LSB of the sleep timer (ST0 must be read first anyway).
//  767   tick = ST0 - tickShdw;
//  768   tickShdw = ST0;
//  769 
//  770   do
//  771   {
//  772     if ( cfg->txTick > tick )
//  773     {
//  774       cfg->txTick -= tick;
//  775     }
//  776     else
//  777     {
//  778       cfg->txTick = 0;
//  779     }
//  780 
//  781     if ( cfg->rxTick > tick )
//  782     {
//  783       cfg->rxTick -= tick;
//  784     }
//  785     else
//  786     {
//  787       cfg->rxTick = 0;
//  788     }
//  789 
//  790 #if HAL_UART_ISR
//  791 #if HAL_UART_DMA
//  792     if ( cfg->flag & UART_CFG_DMA )
//  793     {
//  794       pollDMA( cfg );
//  795     }
//  796     else
//  797 #endif
//  798       {
//  799       pollISR( cfg );
//  800       }
//  801 #elif HAL_UART_DMA
//  802     pollDMA( cfg );
//  803 #endif
//  804 
//  805     /* The following logic makes continuous callbacks on any eligible flag
//  806      * until the condition corresponding to the flag is rectified.
//  807      * So even if new data is not received, continuous callbacks are made.
//  808      */
//  809       if ( cfg->rxHead != cfg->rxTail )
//  810       {
//  811       uint8 evt;
//  812 
//  813       if ( cfg->rxHead >= (cfg->rxMax - SAFE_RX_MIN) )
//  814       {
//  815         evt = HAL_UART_RX_FULL;
//  816       }
//  817       else if ( cfg->rxHigh && (cfg->rxHead >= cfg->rxHigh) )
//  818       {
//  819         evt = HAL_UART_RX_ABOUT_FULL;
//  820     }
//  821       else if ( cfg->rxTick == 0 )
//  822     {
//  823         evt = HAL_UART_RX_TIMEOUT;
//  824     }
//  825     else
//  826     {
//  827         evt = 0;
//  828     }
//  829 
//  830     if ( evt && cfg->rxCB )
//  831     {
//  832         cfg->rxCB( ((cfg->flag & UART_CFG_U1F)!=0), evt );
//  833     }
//  834     }
//  835 
//  836 #if HAL_UART_0_ENABLE
//  837     if ( cfg == cfg0 )
//  838     {
//  839 #if HAL_UART_1_ENABLE
//  840       if ( cfg1 )
//  841       {
//  842         cfg = cfg1;
//  843       }
//  844       else
//  845 #endif
//  846         break;
//  847     }
//  848     else
//  849 #endif
//  850       break;
//  851 
//  852   } while ( TRUE );
//  853 #else
//  854   return;
        LJMP	?BRET
        CFI EndBlock cfiBlock3
//  855 #endif
//  856 }
//  857 
//  858 /**************************************************************************************************
//  859  * @fn      Hal_UART_RxBufLen()
//  860  *
//  861  * @brief   Calculate Rx Buffer length - the number of bytes in the buffer.
//  862  *
//  863  * @param   port - UART port
//  864  *
//  865  * @return  length of current Rx Buffer
//  866  **************************************************************************************************/

        RSEG BANKED_CODE:CODE:NOROOT(0)
//  867 uint16 Hal_UART_RxBufLen( uint8 port )
Hal_UART_RxBufLen:
        CFI Block cfiBlock4 Using cfiCommon0
        CFI Function Hal_UART_RxBufLen
//  868 {
        PUSH	DPL
        CFI DPL0 Frame(CFA_SP, 4)
        CFI CFA_SP SP+-4
        PUSH	DPH
        CFI DPH0 Frame(CFA_SP, 5)
        CFI CFA_SP SP+-5
        ; Saved register size: 2
        ; Auto size: 0
//  869   uartCfg_t *cfg = NULL;
//  870 
//  871 #if HAL_UART_0_ENABLE
//  872   if ( port == HAL_UART_PORT_0 )
//  873   {
//  874     cfg = cfg0;
//  875   }
//  876 #endif
//  877 #if HAL_UART_1_ENABLE
//  878   if ( port == HAL_UART_PORT_1 )
//  879   {
//  880     cfg = cfg1;
//  881   }
//  882 #endif
//  883 
//  884   HAL_UART_ASSERT( cfg );
//  885 
//  886   return UART_RX_AVAIL( cfg );
        MOV	DPTR,#0x2
        MOVX	A,@DPTR
        PUSH	A
        CFI CFA_SP SP+-6
        MOV	DPTR,#0x3
        MOVX	A,@DPTR
        MOV	R2,A
        POP	A
        CFI CFA_SP SP+-5
        CLR	C
        SUBB	A,R2
        JC	??Hal_UART_RxBufLen_0
        MOV	DPTR,#0x2
        MOVX	A,@DPTR
        CLR	C
        SUBB	A,R2
        MOV	R2,A
        CLR	A
        SUBB	A,#0x0
        SJMP	??Hal_UART_RxBufLen_1
??Hal_UART_RxBufLen_0:
        MOV	DPTR,#0x4
        MOVX	A,@DPTR
        CLR	C
        SUBB	A,R2
        MOV	R0,A
        CLR	A
        SUBB	A,#0x0
        MOV	R1,A
        MOV	DPTR,#0x2
        MOVX	A,@DPTR
        ADD	A,R0
        MOV	R0,A
        CLR	A
        ADDC	A,R1
        MOV	R1,A
        MOV	A,#0x1
        ADD	A,R0
        MOV	R2,A
        CLR	A
        ADDC	A,R1
??Hal_UART_RxBufLen_1:
        MOV	R3,A
        POP	DPH
        CFI DPH0 SameValue
        CFI CFA_SP SP+-4
        POP	DPL
        CFI DPL0 SameValue
        CFI CFA_SP SP+-3
        LJMP	?BRET
        CFI EndBlock cfiBlock4
//  887 }
//  888 
//  889 /*****************************************************************************
//  890  * @fn      HalUARTRead
//  891  *
//  892  * @brief   Read a buffer from the UART
//  893  *
//  894  * @param   port - USART module designation
//  895  *          buf  - valid data buffer at least 'len' bytes in size
//  896  *          len  - max length number of bytes to copy to 'buf'
//  897  *
//  898  * @return  length of buffer that was read
//  899  *****************************************************************************/

        RSEG BANKED_CODE:CODE:NOROOT(0)
//  900 uint16 HalUARTRead( uint8 port, uint8 *buf, uint16 len )