开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
uarthw_evmdm642.c
资源名称：DSP-C6000-DM642DEMO.rar　[点击查看]
上传用户：dahaojd
上传日期：2008-01-29
资源大小：14357k
文件大小：14k
源码类别：

DSP编程

开发平台：

C/C++

uarthw_evmdm642.c：源码内容
  1. /*
  2.  *  Copyright 2003 by Texas Instruments Incorporated.
  3.  *  All rights reserved. Property of Texas Instruments Incorporated.
  4.  *  Restricted rights to use, duplicate or disclose this code are
  5.  *  granted through contract.
  6.  *  
  7.  */
  8. /* "@(#) DDK 1.10.00.23 07-02-03 (ddk-b12)" */
  9. /*
  10.  *  ======== uarthw_evmdm642.c ========
  11.  */
  12.  
  13. #include <std.h>
  15. #define CHIP_DM642      1
  17. #include <hwi.h>
  18. #include <iom.h>
  20. #include <csl.h>
  21. #include <csl_irq.h>
  23. #include <evmdm642.h>
  24. #include <evmdm642_osd.h>
  26. #include <uarthw.h>
  27. #include <uarthw_evmdm642.h>
  28. #include <uarthw_evmdm642hal.h>
  30. #define RBRREG(regset)  regset->uart[0]
  31. #define THRREG(regset)  regset->uart[0]
  32. #define DLLREG(regset)  regset->uart[0]
  33. #define DLHREG(regset)  regset->uart[1]
  34. #define IERREG(regset)  regset->uart[1]
  35. #define FCRREG(regset)  regset->uart[2]
  36. #define EFRREG(regset)  regset->uart[2]
  37. #define IIRREG(regset)  regset->uart[2]
  38. #define LCRREG(regset)  regset->uart[3]
  39. #define MCRREG(regset)  regset->uart[4]
  40. #define XON1REG(regset) regset->uart[4]
  41. #define LSRREG(regset)  regset->uart[5]
  42. #define XON2REG(regset) regset->uart[5]
  43. #define MSRREG(regset)  regset->uart[6]
  44. #define XOF1REG(regset) regset->uart[6]
  45. #define TCRREG(regset)  regset->uart[6]
  46. #define SPRREG(regset)  regset->uart[7]
  47. #define XOF2REG(regset) regset->uart[7]
  48. #define TLRREG(regset)  regset->uart[7]
  49. #define FRDYREG(regset) regset->uart[7]
  51. #define getLineStatus(regset)           (LSRREG(regset))
  52. #define getModemControlReg(regset)      (MCRREG(regset))
  53. #define setModemControlReg(regset, c)   MCRREG(regset) = (c)
  54. #define getLineControlReg(regset)       (LCRREG(regset))
  55. #define setLineControlReg(regset, c)    LCRREG(regset) = (c)
  56. #define disableRx(regset)               (IERREG(regset) &= ~UART_IER_RXDATAEN)
  57. #define disableTx(regset)               (IERREG(regset) &= ~UART_IER_THREMPEN)
  58. #define enableRx(regset)                (IERREG(regset) |= UART_IER_RXDATAEN)
  59. #define enableTx(regset)                (IERREG(regset) |= UART_IER_THREMPEN)
  60. #ifdef _DEBUG
  61. #define getInt(regset)                  (IIRREG(regset) & 0x3f)
  62. #else
  63. #define getInt(regset)                  (IIRREG(regset) & 0x0f)
  64. #endif /* _DEBUG */
  66. #define NUMPORTS                        2
  67. #define NOINTPENDING                    0x01
  68. #define IDENTIFYINT(id)                 ((id >> 1) & 0x03)
  70. #define MCRDTRMASK                      0xFE
  71. #define MCRRTSMASK                      0xFD
  72. #define LCRBRKMASK                      0xBF
  74. #define AFERTSCTSMASK                   0xDD
  75. #define AFERTSCTSFLW                    0x22
  76. #define AFECTSFLW                       0x20
  77. #define AFEDISFLW                       0x00
  79. #define LCRBREAKPOS                     6
  80. #define MCRRTSPOS                       1
  82. typedef struct UartRegs {
  83.     volatile Byte uart[8];
  84. } UartRegs;
  86. static void setupFlowParams(UARTHW_Handle hUart, Uns flowParam);
  87. static void uartIsr(Ptr cbArg);
  88. static Int uartRxFull(UartRegs * regs);
  90. static UARTHW_EVMDM642_Params defaultParams = { 
  91.     UARTHW_EVMDM642_FLOW_NONE,                  
  92.     UARTHW_EVMDM642_DISABLE_PARITY,             
  93.     UARTHW_EVMDM642_WORD8,                      
  94.     UARTHW_EVMDM642_STOP1,                      
  95.     UARTHW_EVMDM642_BAUD_115200                 
  96. };
  98. typedef struct UARTHW_Obj {
  99.     Int uartId;                         /* UART port ID */
  100.     Int rxDisabled;                     /* disabled flag */
  101.     UartRegs * regs;                    /* base pointer to reg set */
  102.     UARTHW_EVMDM642_Params *params;
  103.     UARTHW_Tcallback * cbFxns;
  104.     Ptr cbArg;
  105. } UARTHW_Obj;
  107. UARTHW_Obj portObj[NUMPORTS];
  109. #ifdef _DEBUG
  110. struct {
  111.         Int errInts;
  112.         Int mdmInts;
  113.         Int rhrInts;
  114.         Int thrInts;
  115.         Int rtoInts;
  116.         Int rxCnt;
  117.         Int rxXoff;
  118.         Int rtsCts;
  119. } intStats[NUMPORTS] =
  120. {
  121.         {0, 0, 0, 0, 0, 0, 0, 0},
  122.         {0, 0, 0, 0, 0, 0, 0, 0}
  123. };
  124. #endif /* _DEBUG */
  127. /*
  128.  *  ======== UARTHW_open ========
  129.  *
  130.  *  This function is used to attach to the UART.
  131.  *  Typically this function plugs the UART interrupt vector with
  132.  *  the internal driver supplied isr routine.
  133.  *  Initializes the UART, UART flow parameters and UART communication parameters
  134.  *
  135.  */
  136. UARTHW_Handle UARTHW_open(Int uartId, Ptr params, Ptr cbArg, UARTHW_Tcallback *cbFxns)
  137. {
  138.     volatile Char c;
  139.         UartRegs *regs;
  140.     UARTHW_EVMDM642_Params *uartParams = (UARTHW_EVMDM642_Params *)params;
  141.     UARTHW_Handle  port;
  143.     if (uartId >= NUMPORTS) {
  144.         return (NULL);                  // invalid UART id
  145.     }
  147.     port = &portObj[uartId];
  148.     
  149.     port->uartId = uartId;
  150.     regs = port->regs = (UartRegs *) (EVMDM642_CPLD_BASE + (uartId * sizeof(UartRegs)));
  152.     /* 
  153.      * Initialize the isrhandler to the one given by
  154.      * generic uart.
  155.      */
  156.     port->cbFxns = cbFxns;
  157.     port->cbArg = cbArg;
  158.        
  159.     EVMDM642_OSD_init();
  161.     if (uartId == 0) {
  162.         EVMDM642_OSD_intHook(UARTA_IRQ, uartIsr, port);
  163.     } 
  164.     else {
  165.         EVMDM642_OSD_intHook(UARTB_IRQ, uartIsr, port);
  166.     }
  168.     /* 
  169.      * Use the default attributes if one is not given
  170.      */
  171.     if (uartParams == NULL) {
  172.         uartParams = &defaultParams;
  173.     }
  175.     /*
  176.      * Set EFR registers
  177.      */
  178.     LCRREG(regs) = 0xBF;                /* address secondary register set */
  179.     EFRREG(regs) = 
  180.     UART_EFR_AUTOCTS | UART_EFR_AUTORTS | UART_EFR_ENHFUNCEN; /* enable enhanced functions */
  182.     LCRREG(regs) = 0x00;                /* back to primary register set */
  183.     MCRREG(regs) = 0x00;
  184.     MCRREG(regs) = UART_MCR_IRQENOP | UART_MCR_FIFORDYEN; /* enable IRQ and FIF rdy register */
  185.     IERREG(regs) = 0x00;                /* set interrupt enable register */
  186.     FCRREG(regs) = 0x00;                /* set FIFO control */
  188.     /*
  189.      * Set up baud rate and other comm parameters
  190.      */
  191.     LCRREG(regs) = UART_LCR_DLTCHEN; /* enable divisor */
  192.     DLLREG(regs) = uartParams->baud;
  193.     DLHREG(regs) = uartParams->baud >> 8;
  194.     LCRREG(regs) = uartParams->wordSize | (uartParams->stopBits << 2) |
  195.                 (uartParams->parity << 3);
  197.     FCRREG(regs) =                              /* FIFO control register */
  198.                 UART_FCR_RXTRG16 | UART_FCR_TXTRG32 | UART_FCR_DMAMODE |
  199.                 UART_FCR_RSTTXFIFO | UART_FCR_RSTRXFIFO | UART_FCR_FIFOEN;
  200.     IERREG(regs) =                              /* enable normal interrupts */
  201.                 UART_IER_MDMSTATEN | UART_IER_RXLSTATEN | UART_IER_THREMPEN |
  202.                 UART_IER_RXDATAEN;
  203.     LSRREG(regs);                               /* clear previous line status */
  204.     MSRREG(regs);                               /* modem status register */
  205.     MCRREG(regs);                               /* modem control register */
  207.     while (uartRxFull(regs)) { /* remove active characters */
  208.         c = RBRREG(regs);
  209.     }
  211.     port->params = uartParams;
  212.       
  213.     setupFlowParams(port, (uartParams->flowControl) & UARTHW_EVMDM642_HW_FLOW_MASK);
  215.     port->rxDisabled = 0;               /* indicate we're enabled now */
  216.     enableRx(regs);
  217.     enableTx(regs);
  218.   
  219.     return (port);
  220. }
  222. /*
  223.  *  ======== UARTHW_getModemStatus ========
  224.  *
  225.  *  This function is used to get the modem status for the UART. 
  226.  */
  227.  
  228. Int UARTHW_getModemStatus(UARTHW_Handle hUart, char *pmodemStatus)
  229. {
  230.     *pmodemStatus = MSRREG(hUart->regs);
  232.     return (IOM_COMPLETED);
  233. }
  235. /*
  236.  *  ======== UARTHW_resetDevice ========
  237.  *
  238.  *  This function is used to reset the UART 16c75x.
  239.  *  Ideally this function should clear the transmit and 
  240.  *  receive fifos if the fifos are being used.
  241.  */
  242. void UARTHW_resetDevice(UARTHW_Handle hUart)
  243. {
  244.     FCRREG(hUart->regs) =
  245.                 UART_FCR_RXTRG16 | UART_FCR_TXTRG32 | UART_FCR_DMAMODE |
  246.                 UART_FCR_RSTTXFIFO | UART_FCR_RSTRXFIFO | UART_FCR_FIFOEN;
  247. }
  249. /*
  250.  *  ======== UARTHW_setBreak ========
  251.  *
  252.  *  This function is used to set the break on/off for the UART 16c75x 
  253.  */
  254. Int UARTHW_setBreak(UARTHW_Handle hUart, Int bBreak)
  255. {
  256.     char lcrVal;
  258.     lcrVal = getLineControlReg(hUart->regs);
  259.     lcrVal = (lcrVal & LCRBRKMASK) | (bBreak << LCRBREAKPOS);
  260.     setLineControlReg(hUart->regs, lcrVal);
  261.    
  262.     return (IOM_COMPLETED);
  263. }
  265. /*
  266.  *  ======== UARTHW_setDTR ========
  267.  *
  268.  *  This function is used to set the DTR signal for the UART 16c75x 
  269.  */
  270. Int UARTHW_setDTR(UARTHW_Handle hUart, int dtrval)
  271. {
  272.     char mcrVal;
  274.     mcrVal = getModemControlReg(hUart->regs);
  275.     mcrVal = (mcrVal & MCRDTRMASK) | dtrval;
  276.     setModemControlReg(hUart->regs, mcrVal);
  278.     return (IOM_COMPLETED);
  279. }
  281. /*
  282.  *  ======== UARTHW_setRTS ========
  283.  *
  284.  *  This function is used to set the RTS signal for the UART 16c75x 
  285.  */
  286. Int UARTHW_setRTS(UARTHW_Handle hUart, int rtsval)
  287. {
  288.     char mcrVal;
  290.     mcrVal = getModemControlReg(hUart->regs);
  291.     mcrVal = (mcrVal & MCRRTSMASK) | (rtsval << MCRRTSPOS);
  292.     setModemControlReg(hUart->regs, mcrVal);
  293.     
  294.     return (IOM_COMPLETED);
  295. }
  297. /*
  298.  *  ======== UARTHW_txEmpty ========
  299.  *
  300.  *  This function is used to get the transmit buffer empty condition 
  301.  */
  302. Int UARTHW_txEmpty(UARTHW_Handle hUart)
  303. {
  304.     return (LSRREG(hUart->regs) & UART_LSR_THREMPTY);
  305. }
  307. /*
  308.  *  ======== UARTHW_writeChar ========
  309.  *
  310.  *  This function is used to write a character to the transmit register 
  311.  */
  312. void UARTHW_writeChar(UARTHW_Handle hUart, char c)
  313. {
  314.     THRREG(hUart->regs) = c;
  315. }
  317. /*
  318.  *  ======== UARTHW_enableRx ========
  319.  *  Enable the Rx Interrupt of the UART.
  320.  *
  321.  */
  322. void UARTHW_enableRx(UARTHW_Handle hUart)
  323. {
  324.     if (ATM_seti(&hUart->rxDisabled, 0)) {
  325.         enableRx(hUart->regs);
  326.     }
  327. }
  329. /*
  330.  *  ======== UARTHW_disableRx ========
  331.  *  Disable the Rx Interrupt of the UART.
  332.  *
  333.  */
  334. void UARTHW_disableRx(UARTHW_Handle hUart)
  335. {
  336.     int gie;
  338.     gie = IRQ_globalDisable();
  339.     disableRx(hUart->regs);
  340.     hUart->rxDisabled = 1;
  341.     IRQ_globalRestore(gie);
  342. }
  344. /*
  345.  *  ======== setupFlowParams ========
  346.  *
  347.  *  This function is used to setup the UART 16c75x flow paramaters
  348.  */
  349. static void setupFlowParams(UARTHW_Handle hUart, Uns flowParam)
  350. {
  351.     char mcrVal;
  352.  
  353.     mcrVal = getModemControlReg(hUart->regs);
  354.         mcrVal &= AFERTSCTSMASK;
  355.  
  356.     if (flowParam & UARTHW_EVMDM642_FLOW_AFE_RTSCTS) {
  357.         mcrVal |= AFERTSCTSFLW;
  358.     }
  359.     else if (flowParam & UARTHW_EVMDM642_FLOW_AFE_CTS) {
  360.         mcrVal |= AFECTSFLW;
  361.     }
  362.     else {
  363.         mcrVal |= AFEDISFLW;  
  364.     }
  366.     setModemControlReg(hUart->regs, mcrVal);                
  367. }
  369. /* 
  370.  *  ======== uartIsr ========
  371.  *
  372.  *  This is the interrupt service handler used by the EVMDM642
  373.  *  UART driver.
  374.  */
  375. static void uartIsr(Ptr portArg)
  376. {
  377.     Int                 id;
  378.     Int                 argval;
  379.     Int                 temp;
  380.     UARTHW_Handle       port = (UARTHW_Handle) portArg;
  381.     UARTHW_Tcallback    *callbacks = port->cbFxns;
  382.     Ptr                 cbArg = port->cbArg;
  384.     /*
  385.      * While loop here since 16C752/4 holds interrupt line high until
  386.      * all interrupt conditions are handled (2 or more may be pending
  387.      * at same time).  DM642 uses edge-triggered interrupts and would
  388.      * miss interrupts otherwise.
  389.      */
  390.     while (!((id = getInt(port->regs)) & NOINTPENDING)) {
  391.         switch (id) {
  392.             case UART_INT_MSR: /* Modem status interrupt -- read and dispatch */
  393. #ifdef _DEBUG
  394.                 intStats[port->uartId].mdmInts++;
  395. #endif /* _DEBUG */
  396.                 argval = MSRREG(port->regs);
  397.                 (*callbacks[UARTHW_MODEM_STATUSHANDLER])(cbArg, argval);
  398.                 break;
  400.             case UART_INT_THR:          /* Transmit handler */
  401. #ifdef _DEBUG
  402.                 intStats[port->uartId].thrInts++;
  403. #endif /* _DEBUG */
  404.                 /* NOTE:
  405.                  * This shouldn't be necessary, but sometimes the interrupt
  406.                  * comes in before the transmitter is really empty.  Still
  407.                  * working on this one
  408.                  */
  409.                 while (!(temp = UARTHW_txEmpty(port))) {
  410.                     asm(" NOP");
  411.                 }
  413.                 (*callbacks[UARTHW_TXEMPTY_STATUSHANDLER])(cbArg, temp);
  414.                 break;
  416.             case UART_INT_RHR:          /* Receive Handler */
  417.             case UART_INT_RXTO:         /* Receive time-out error */
  418. #ifdef _DEBUG
  419.                 if (id == UART_INT_RHR)
  420.                     intStats[port->uartId].rhrInts++;
  421.                 else
  422.                     intStats[port->uartId].rtoInts++;
  423. #endif /* _DEBUG */
  424.                 while ((!port->rxDisabled) && uartRxFull(port->regs)) {
  425. #ifdef _DEBUG
  426.                     intStats[port->uartId].rxCnt++;
  427. #endif /* _DEBUG */
  428.                     argval = RBRREG(port->regs);
  429.                     (*callbacks[UARTHW_RXFULL_STATUSHANDLER])(cbArg, argval); 
  430.                 }
  431.                 break;
  433.                 case UART_INT_RLSERR:   /* Receiver line status error */
  434. #ifdef _DEBUG
  435.                     intStats[port->uartId].errInts++;
  436. #endif /* _DEBUG */
  437.                     argval = LSRREG(port->regs);
  438.                     /*
  439.                      * Isolate parity/framing/overrun and data ready
  440.                      * Discard characters by reading the receiver buffer
  441.                      * ready register, and get the line status again
  442.                      */
  443.                     while ((argval & UART_LSR_ERRMASK) && (argval & UART_LSR_DATAIN)) {
  444.                         RBRREG(port->regs);
  445.                         argval = LSRREG(port->regs);
  446.                     }
  447.                     (*callbacks[UARTHW_LINE_STATUSHANDLER])(cbArg, argval);
  448.                     break;
  449. #ifdef _DEBUG
  450.                 case UART_INT_XOFF:     /* Xoff interrupt */
  451.                     intStats[port->uartId].rxXoff++;
  452.                     break;
  454.                 case UART_INT_CTSRTS:  /* RTS or CTS pin change to inactive */
  455.                     intStats[port->uartId].rtsCts++;
  456.                     break;
  457.                 default:
  458.                     while (1) {
  459.                         /* should never get here ... */
  460.                         asm(" NOP");
  461.                     }
  462. #endif /* _DEBUG */
  463.         }
  464.     }
  465. }
  467. /*
  468.  * ======== uartRxFull ========
  469. * * 
  470.  * This function is used to get the Receive Buffer Full condition 
  471.  */
  472. static Int uartRxFull(UartRegs *regs)
  473. {
  474.     return (LSRREG(regs) & UART_LSR_DATAIN);
  475. }