Device Table Functions

These functions are placed in the standard device table entry for each channel and handle initialization and location of the device within the generic driver infrastructure.

static bool example_adc_init(struct cyg_devtab_entry *tab) This function is called from the device IO infrastructure to initialize the device. It should perform any work needed to start up the device, short of actually starting the generation of samples. This function will be called for each channel, so if there is initialization that only needs to be done once, such as creating an interrupt object, then care should be taken to do this. This function should also call cyg_adc_device_init() to initialize the generic parts of the driver.

static Cyg_ErrNo example_adc_lookup(struct cyg_devtab_entry **tab, struct cyg_devtab_entry *sub_tab, const char *name) This function is called when a client looks up or opens a channel. It should call cyg_adc_channel_init() to initialize the generic part of the channel. It should also perform any operations needed to start the channel generating samples.

Driver Functions

These are the functions installed into the driver function table by the CYG_ADC_FUNCTIONS() macro.

static void example_adc_enable( cyg_adc_channel *chan ) This function is called from the generic ADC package to enable the channel in response to a CYG_IO_SET_CONFIG_ADC_ENABLE config operation. It should take any steps needed to start the channel generating samples.

static void example_adc_disable( cyg_adc_channel *chan ) This function is called from the generic ADC package to enable the channel in response to a CYG_IO_SET_CONFIG_ADC_DISABLE config operation. It should take any steps needed to stop the channel generating samples.

static void example_adc_set_rate( cyg_adc_channel *chan, cyg_uint32 rate ) This function is called from the generic ADC package to enable the channel in response to a CYG_IO_SET_CONFIG_ADC_RATE config operation. It should take any steps needed to change the sample rate of the channel, or of the entire device.

Generic Package Functions

These functions are called by a hardware ADC device driver to perform operations in the generic ADC package.

__externC void cyg_adc_device_init( cyg_adc_device *device ) This function is called from the driver's init function and is used to initialize the cyg_adc_device object.

__externC void cyg_adc_channel_init(cyg_adc_channel *chan) This function is called from the driver's lookup function and is used to initialize the cyg_adc_channel object.

__externC cyg_uint32 cyg_adc_receive_sample(cyg_adc_channel *chan, cyg_adc_sample_t sample) This function is called from the driver's ISR to add a new sample to the buffer. The return value will be either zero, or CYG_ISR_CALL_DSR and should be ORed with the return value of the ISR.

__externC void cyg_adc_wakeup(cyg_adc_channel *chan ) This function is called from the driver's DSR to cause any threads waiting for data to wake up when a new sample is available. It should only be called if the wakeup field of the channel object is true.

Interrupt Functions

These functions are internal to the driver, but make calls on generic package functions. Typically an ADC device will have a single interrupt vector with which it signals available samples on the channels and any error conditions such as overruns.

static cyg_uint32 example_adc_isr(cyg_vector_t vector, cyg_addrword_t data) This function is the ISR attached to the ADC device's interrupt vector. It is responsible for reading samples from the channels and passing them on to the generic layer. It needs to check each channel for data, and call cyg_adc_receive_sample() for each new sample available, and then ready the device for the next interrupt. It's activities are best explained by example:

static cyg_uint32 example_adc_isr(cyg_vector_t vector, cyg_addrword_t data)
{
    cyg_adc_device *example_device = (cyg_adc_device *) data;
    example_adc_info *example_info = example_device->dev_priv;
    cyg_uint32 res = 0;
    int i;

    // Deal with errors if necessary
    DEVICE_CHECK_ERRORS( example_info );

    // Look for all channels with data available
    for( i = 0; i < CHANNEL_COUNT; i++ )
    {
        if( CHANNEL_SAMPLE_AVALIABLE(i) )
        {
            // Fetch data from this channel and pass up to higher
            // level.

            cyg_adc_sample_t data = CHANNEL_GET_SAMPLE(i);

            res |= CYG_ISR_HANDLED | cyg_adc_receive_sample( example_info->channel[i], data );
        }
    }

   // Clear any interrupt conditions
    DEVICE_CLEAR_INTERRUPTS( example_info );

    cyg_drv_interrupt_acknowledge(example_info->vector);

    return res;
}

static void example_adc_dsr(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data) This function is the DSR attached to the ADC device's interrupt vector. It is called by the kernel if the ISR return value contains the CYG_ISR_HANDLED bit. It needs to call cyg_adc_wakeup() for each channel that has its wakeup field set. Again, and example should make it all clear:

static void example_adc_dsr(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data)
{
    cyg_adc_device *example_device = (cyg_adc_device *) data;
    example_adc_info *example_info = example_device->dev_priv;
    int i;

    // Look for all channels with pending wakeups
    for( i = 0; i < CHANNEL_COUNT; i++ )
    {
        if( example_info->channel[i]->wakeup )
            cyg_adc_wakeup( example_info->channel[i] );
    }
}