Board Support Packages

Audio drivers

Updates to io-audio require audio drivers (deva-*) to make some minor modifications to work in QNX SDP 7.1.

QSA trigger callbacks

enum pcm_trigger
{
    ADO_PCM_TRIGGER_GO,
    ADO_PCM_TRIGGER_STOP_DRAIN,
    ADO_PCM_TRIGGER_STOP_DROP,
};

ADO_PCM_TRIGGER_STOP_DRAIN

Stop the interface after the buffered data has been played to completion.

ADO_PCM_TRIGGER_STOP_DROP

Stop the interface immediately and drop or discard buffered data.

In most cases, the deva -* driver does not need to distinguish the reason for a stop and can continue to use a basic if else statement. For example:

if (cmd == ADO_PCM_TRIGGER_GO)
{
    ...
    ...
}
else
{
/* STOP */
    ...
    ...
}

switch (cmd)
{
    case ADO_PCM_TRIGGER_GO:
        break;
    case ADO_PCM_TRIGGER_STOP_DROP:
        break;
    case ADO_PCM_TRIGGER_STOP_DRAIN:
        break;
    default:
          break;
}

Audio driver mixer APIs and PCM channel maps

The audio driver mixer APIs have been updated to use snd_pcm_chmap_t to provide channel location information.

Volume and mute callback

Any driver code that handles volume levels and mute callback needs to be updated to handle volume and mute data as contiguous channel sets.

Do not use SND_MIXER_CHN_* definitions to index into volume arrays or mute bits in your volume and mute callbacks. Volume and mute data are contiguous channel sets based on the ordering defined in the PCM channel map (snd_chmap_t). Because everything is contiguous, you can directly use the loop index when you walk the channels.

ado_pcm_capabilities_t

The ado_pcm_capabilities_t structure now includes a channel map that should be filled in. If you do not fill it, io-audio automatically creates a default channel map based on the number of voices. You can use the ado_pcm_get_default_chmap() helper function to get the default map.

However, to expose the channel mapping clearly, QNX recommends that the driver set the channel mapping explicitly using ado_pcm_get_default_chmap(), ado_pcm_parse_chmap() or by manually creating a channel map.

The ado_pcm_parse_chmap() function allows you to create a channel map based on command line options. Because the channel map it returns is allocated on the heap (unlike the static, default channel maps), it is the driver's responsibility to free this channel map in the ctrl_destroy() callback.

For example:

ctrl_init()
{
   .
   .
   .
   if (hw_ctx->tx_chmap)
   {
      /* chmap was allocated from command line parsing */
      hw_ctx->playback.pcm_caps.chmap = hw_ctx->tx_chmap;
   }
   else
   {
      /* No chmap was provided on the command line, use a static default chmap */
      hw_ctx->playback.pcm_caps.chmap = ado_pcm_get_default_chmap(hw_ctx->playback.voices);
   }
   /* Do the same for capture */
   ado_pcm_create(…);
   .
   .
   .
}


ctrl_destroy()
{
   .
   .
   .
   if (hw_ctx->tx_chmap)
      ado_free(hw_ctx->tx_chmap);

   if (hw_ctx->rx_chmap)
      ado_free(hw_ctx->rx_chmap);
   
   ado_free(hw_ctx);
}

The ctrl_version() callback

The date argument of the ctrl_version() callback has been updated from char * to a char**:

ado_dll_version_t ctrl_version;
void ctrl_version (int *major, int *minor, const char **date)
{
    *major = ADO_MAJOR_VERSION;
    *minor = 1;
    *date = __DATE__;
}

Memory and PCI APIs

The following memory functions now require an ado_card_t pointer as the first parameter:

ado_device_mmap ( ado_card_t *card,
                  unsigned long addr ,
                  unsigned long size )

ado_device_munmap ( ado_card_t *card,
                    void *addr ,
                    unsigned long size )

uintptr_t ado_device_mmap_io ( ado_card_t *card,
                               unsigned long addr ,
                               unsigned long size )

int ado_device_munmap_io ( ado_card_t *card,
                           uintptr_t addr ,
                           unsigned long size )

void *ado_pcm_buf_alloc ( ado_card_t *card,
                          struct ado_pcm_config *config ,
                          size_t size ,
                          uint32_t flags );

void *ado_pcm_buf_map ( ado_card_t *card,
                        struct ado_pcm_config *config ,
                        off64_t phys_addr ,
                        size_t size ,
                        uint32_t flags );

void ado_pcm_buf_free ( ado_card_t *card,
                        struct ado_pcm_config *config );

The following PCM functions have been removed and replaced:

The ado_pcm_buf_*() functions create shared memory objects for the buffers so that libasound can access the memory for client data processing via the libasound MMAP plugin.

In addition, there are two new functions for more general physical memory mappings: ado_mmap_phys() and ado_munmap_phys(). These mappings would be private to the driver (no shared object created for exposure via libasound MMAP plugin).

PCM buffer allocations should use the ado_pcm_buf_*() functions and generic physical memory allocations should use ado_mmap_phys(). Device registers mappings should continue to use ado_device_*() functions.

The following PCI functions now require an ado_card_t pointer as the first parameter:

struct ado_pci *ado_pci_device ( ado_card_t *card,
                                 uint32_t vendor ,
                                 uint32_t device ,
                                 char *args )

void ado_pci_release ( ado_card_t *card,
                       struct ado_pci *pci )