lh79524_adc_driver.c

LH79524SoftwareLH79524 Software

          (ADC_FIFO_OV_IRQ | ADC_WATERM_IRQ |
          ADC_EOS_IRQ |ADC_PEN_IRQ |
          ADC_BROWNOUT_IRQ));
        break;
        
      case ADC_GEN_ST:
        /* Returns general status register value */
        status = adcregsptr->adcgensts;
        break;
        
      case ADC_CONV_COUNT:
      /* Return the number of conversions in the
        conversion count sequence */
        status = adccfgptr->conv_count;
        break;
        
      default:
        /* Unsupported parameter */
        status = SMA_BAD_PARAMS;
        break;
      }
      break;

    case ADC_SET_ADCLK_SCOC:
      tmp = adc_get_clock(adccfgptr);
      adccfgptr->adc_clk_source = adc_default(adcregsptr,
                                     (UNS_32)arg,
                                      TRUE);
      if(adc_set_clock(tmp, adccfgptr) == 0)
        status = _ERROR;
        break;
    
    case ADC_SET_4WIRE_TSC_MODE:
      status = adc_setup_4wire_touchscreen((ADC_TSC_CONV_T*)arg, 
                  adccfgptr);
      break;
      
    case ADC_SET_5WIRE_TSC_MODE:
      status = adc_setup_5wire_touchscreen((ADC_TSC_CONV_T*)arg, 
                  adccfgptr);
      break;
      
    default:
      /* Unsupported parameter */
      status = SMA_BAD_PARAMS;
    }
  }
  
  return status;
}

/***********************************************************************
*
* Function: adc_read_polled
*
* Purpose: Reads data directly from the ADC FIFO
*
* Processing:
*     If the device is not initialized, return 0 to the caller.
*     Otherwise, hile the number of bytes read is less than max_bytes
*     and the ADC FIFO is not empty, read a FIFO entry from the ADC
*     FIFO and place it into the passed user buffer. Increment bytes
*     by 2. When the loop is exited, return the number of bytes read
*     to the caller.
*
* Parameters:
*     devid:     Pointer to an ADC configuration structure
*     buffer:    Pointer to data buffer to copy to
*     max_bytes: Number of bytes to read
*
* Outputs: None
*
* Returns: The number of bytes read from the FIFO
*
* Notes: None
*
**********************************************************************/
INT_32 adc_read_polled(INT_32 devid,
                       void *buffer,
                       INT_32 max_bytes)
{
  ADC_CFG_T *adccfgptr = (ADC_CFG_T *) devid;
  ADC_REGS_T *adcregptr = adccfgptr->regptr;
  UNS_16 *adcbuf = (UNS_16 *) buffer;
  INT_32 bytes = 0;
  
  if (adccfgptr->init == TRUE)
  {
    /* Grab all entries or until size equals max_bytes */
    while ((bytes < max_bytes) &&
      ((adcregptr->adcfifosts & ADC_FIFO_EMPTY) == 0))
    {
      *adcbuf = (UNS_16) adcregptr->adcresults;
      adcbuf++;
      bytes = bytes + 2;
    }
  }
  
  return bytes;
}

/***********************************************************************
*
* Function: adc_read_ring
*
* Purpose: Reads data from the ADC ring buffer
*
* Processing:
*     If the init flag for the ADC structure is FALSE, return 0 to
*     the caller. Otherwise, save the state of the ADC interrupts and
*     disable the ADC interrupts. Loop until max_bytes equals 0 or
*     until the receive ring buffer is empty, whichever comes
*     first. Read the data from the ring buffer  indexed by the tail
*     pointer and place it into the user buffer. Increment the tail
*     pointer and user buffer pointer. If the tail pointer exceeds the
*     buffer size, set the tail pointer to 0. Increment bytes, and
*     decrement max_bytes. Exit the loop based on the loop conditions,
*     re-enable the receive interrupts, and return the number of bytes
*     read to the caller.
*
* Parameters:
*     devid:     Pointer to an ADC configuration structure
*     buffer:    Pointer to data buffer to copy to
*     max_bytes: Number of bytes to read
*
* Outputs: None
*
* Returns: The number of bytes actually read from the ring buffer
*
* Notes: None
*
**********************************************************************/
INT_32 adc_read_ring(INT_32 devid,
                     void *buffer,
                     INT_32 max_bytes)
{
  ADC_CFG_T *adccfgptr = (ADC_CFG_T *) devid;
  ADC_REGS_T *adcregs;
  UNS_32 tmp1;
  UNS_16 *data = (UNS_16 *) buffer;
  INT_32 bytes = 0;
  
  if (adccfgptr->init == TRUE)
  {
    adcregs = adccfgptr->regptr;
    
    /* Temporarily lock out ADC receive interrupt during this
    read so the ADC receive interrupt won't cause problems
    with the ring buffer index values */
    tmp1 = adcregs->adcie & (ADC_FIFO_OV_INT | ADC_WATERM_INT |
      ADC_EOS_INT | ADC_PEN_INT | ADC_GLOBAL_INT);
    adcregs->adcie &= ~(ADC_FIFO_OV_INT | ADC_WATERM_INT |
      ADC_EOS_INT | ADC_PEN_INT | ADC_GLOBAL_INT);
    
      /* Loop until receive ring buffer is empty or until max_bytes
    expires */
    while ((max_bytes > 0) &&
      (adccfgptr->rx_tail != adccfgptr->rx_head))
    {
      /* Read data from ring buffer into user buffer */
      *data = adccfgptr->rx[adccfgptr->rx_tail];
      data++;
      
      /* Update tail pointer */
      adccfgptr->rx_tail++;
      
      /* Make sure tail didn't overflow */
      if (adccfgptr->rx_tail >= ADC_RING_BUFSIZE)
      {
        adccfgptr->rx_tail = 0;
      }
      
      /* Increment data count and decrement buffer size count */
      bytes = bytes + 2;
      max_bytes = max_bytes - 2;
    }
    
    /* Re-enable ADC receive interrupt(s) */
    adcregs->adcie |= tmp1;
  }
  
  return bytes;
}

/***********************************************************************
*
* Function: adc_write
*
* Purpose: ADC write function (stub only)
*
* Processing:
*     Returns 0 to the caller.
*
* Parameters:
*     devid: Pointer to ADC config structure
*     buffer:  Pointer to data buffer to copy from
*     n_bytes: Number of bytes to write
*
* Outputs: None
*
* Returns: Number of bytes actually written (always 0)
*
* Notes: None
*
**********************************************************************/
INT_32 adc_write(INT_32 devid,
                 void *buffer,
                 INT_32 n_bytes)
{
  return 0;
}

/***********************************************************************
*
* Function: adc_isr
*
* Purpose: ADC interrupt handler
*
* Processing:
*     On an interrupt, read the (masked) interrupt status. Based on
*     the status, handle the watermark or end of sequence interrupts
*     by calling the adc_ring_fill() to move the data from the ADC
*     FIFO to the ADC driver ring buffer. If the interrupt was due to
*     an end of sequence and the end of sequence callback function
*     exists, then call the user function. If the interrupt was due
*     to a pendown event and the pendown callback function exists,
*     then call the user function. If the interrupt was due to a
*     brownout interrupt and the brownout callback function exists,
*     then call the user function. 
*
* Parameters: None
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
void adc_isr(void)
{
  UNS_32 int_status;
  
  /* Read interrupt status register */
  int_status = ADC->adcmis;
  
  /* Perform function based on interrupt status */
  if ((int_status & ADC_WATERM_INT) != 0)
  {
    /* FIFO needs servicing, called ring fill handler */
    adc_ring_fill(&adccfg);
  }
  
  if ((int_status & ADC_EOS_INT) != 0)
  {
  /* ADC end of sequence interrupt, move data from FIFO
    to ring buffer */
    adc_ring_fill(&adccfg);
    
    /* Call user function if it exists */
    if (adccfg.eos_cbfunc != (PFV) 0)
    {
      adccfg.eos_cbfunc();
    }
    
    /* Clear end of sequence interrupt */
    ADC->adcic = ADC_EOS_CLR;
  }
  
  if ((int_status & ADC_PEN_INT) != 0)
  {
    /* Call user function if it exists */
    if (adccfg.pd_cbfunc != (PFV) 0)
    {
      adccfg.pd_cbfunc();
    }
    
    /* Clear end of pendown interrupt and call user function */
    ADC->adcic = ADC_PEN_CLR;
    
  }
  
  if ((int_status & ADC_BROWNOUT_IRQ) != 0)
  {
    
    /* If the brownout interrupt callback function exists, call it */
    if (adccfg.bro_cbfunc != (PFV) 0)
    {
      adccfg.bro_cbfunc();
    }
    
    /* Brownout interrupt, clear it */
    ADC->adcic = ADC_BROWNOUT_CLR;
  }
}

/***********************************************************************
*
* Function: adc_pen_isr
*
* Purpose: ADC Pen Vectored interrupt handler
*
* Processing:
*     If pendown callback function exists, then call the user function
*     and clear the interrupt. 
*
* Parameters: None
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
void adc_pen_isr(void)
{
  
  /* Call user function if it exists */
  if (adccfg.pd_cbfunc != (PFV) 0)
  {
    adccfg.pd_cbfunc();
  }
  /* Clear end of pendown interrupt and call user function */
  ADC->adcic = ADC_PEN_CLR;
}

/***********************************************************************
*
* Function: adc_brownout_isr
*
* Purpose: ADC brownout Vectored interrupt handler
*
* Processing:
*     If brownout callback function exists, then call the user function
*     and clear the interrupt. 
*
* Parameters: None
*
* Outputs: None
*
* Returns: Nothing
*
* Notes: None
*
**********************************************************************/
void adc_brownout_isr(void)
{
  /* If the brownout interrupt callback function exists, call it */
  if (adccfg.bro_cbfunc != (PFV) 0)
  {
    adccfg.bro_cbfunc();
  }
  
  /* Brownout interrupt, clear it */
  ADC->adcic = ADC_BROWNOUT_CLR;
}

/***********************************************************************
*
* Function: adc_strip_data
*
* Purpose: Strip out and justify analog data from a sample
*
* Processing:
*     The data that is returned from the adc_read() function returns a
*     value that has data and the analog input number mixed into it.
*     This function strips off the analog input number and returns only
*     the converted 10-bit data value right justified into a 16-bit
*     field.
*
* Parameters:
*     data : The raw ADC sample to extract the data from
*
* Outputs: None
*
* Returns: The right justified analog data value
*
* Notes: None
*
**********************************************************************/
UNS_16 adc_strip_data(UNS_16 data)
{
  return ADC_READ_OUTPUT(data);
}

/***********************************************************************
*
* Function: adc_strip_input
*
* Purpose: Strip out the analog input channel from a sample
*
* Processing:
*     The data that is returned from the adc_read() function returns a
*     value that has data and the analog input number mixed into it.
*     This function strips off the converted data and returns only the
*     analog input channel number.
*
* Parameters:
*     data : The raw ADC sample to extract the data from
*
* Outputs: None
*
* Returns: The right justified analog data value
*

  * Notes: None
  *
**********************************************************************/
UNS_16 adc_strip_input(UNS_16 data)
{
  return (data & ADC_CBANKTAG);
}