28.4 Interfaces

28.4.1.1 Common notes for function parameters

Sound drivers usually have a private data structure to describe their device, and one structure for each play and record data channel that it supports.

For all CHANNEL interface functions, the first parameter is an opaque pointer.

The second parameter is a pointer to the private channel data structure, except for channel_init() which has a pointer to the private device structure (and returns the channel pointer for further use by pcm).

28.4.1.2 Overview of data transfer operations

For sound data transfers, the pcm core and the sound drivers communicate through a shared memory area, described by a struct snd_dbuf.

struct snd_dbuf is private to pcm, and sound drivers obtain values of interest by calls to accessor functions (sndbuf_getxxx()).

The shared memory area has a size of sndbuf_getsize() and is divided into fixed size blocks of sndbuf_getblksz() bytes.

When playing, the general transfer mechanism is as follows (reverse the idea for recording):

• pcm initially fills up the buffer, then calls the sound driver's xxxchannel_trigger() function with a parameter of PCMTRIG_START.

• The sound driver then arranges to repeatedly transfer the whole memory area (sndbuf_getbuf(), sndbuf_getsize()) to the device, in blocks of sndbuf_getblksz() bytes. It calls back the chn_intr() pcm function for each transferred block (this will typically happen at interrupt time).

• chn_intr() arranges to copy new data to the area that was transferred to the device (now free), and make appropriate updates to the snd_dbuf structure.

28.4.1.3 channel_init

xxxchannel_init() is called to initialize each of the play or record channels. The calls are initiated from the sound driver attach routine. (See the probe and attach section).

              static void *
              xxxchannel_init(kobj_t obj, void *data, 
                 struct snd_dbuf *b, struct pcm_channel *c, int dir)
              {
                  struct xxx_info *sc = data;
                  struct xxx_chinfo *ch;
                   ...
                  return ch;
               }

28.4.1.4 channel_setformat

xxxchannel_setformat() should set up the hardware for the specified channel for the specified sound format.

              static int
              xxxchannel_setformat(kobj_t obj, void *data, u_int32_t format)
              {
                  struct xxx_chinfo *ch = data;
                   ...
                  return 0;
               }

28.4.1.5 channel_setspeed

xxxchannel_setspeed() sets up the channel hardware for the specified sampling speed, and returns the possibly adjusted speed.

              static int
              xxxchannel_setspeed(kobj_t obj, void *data, u_int32_t speed)
              {
                  struct xxx_chinfo *ch = data;
                   ...
                  return speed;
               }

28.4.1.6 channel_setblocksize

xxxchannel_setblocksize() sets the block size, which is the size of unit transactions between pcm and the sound driver, and between the sound driver and the device. Typically, this would be the number of bytes transferred before an interrupt occurs. During a transfer, the sound driver should call pcm's chn_intr() every time this size has been transferred.

Most sound drivers only take note of the block size here, to be used when an actual transfer will be started.

              static int
              xxxchannel_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
              {
                  struct xxx_chinfo *ch = data;
                    ...
                  return blocksize;
               }

28.4.1.7 channel_trigger

xxxchannel_trigger() is called by pcm to control data transfer operations in the driver.

              static int
              xxxchannel_trigger(kobj_t obj, void *data, int go)
              {
                  struct xxx_chinfo *ch = data;
                   ...
                  return 0;
               }

28.4.1.8 channel_getptr

xxxchannel_getptr() returns the current offset in the transfer buffer. This will typically be called by chn_intr(), and this is how pcm knows where it can transfer new data.

28.4.1.9 channel_free

xxxchannel_free() is called to free up channel resources, for example when the driver is unloaded, and should be implemented if the channel data structures are dynamically allocated or if sndbuf_alloc() was not used for buffer allocation.

28.4.1.10 channel_getcaps

              struct pcmchan_caps *
              xxxchannel_getcaps(kobj_t obj, void *data)
              {
                  return &xxx_caps;
               }

28.4.1.11 More functions

channel_reset(), channel_resetdone(), and channel_notify() are for special purposes and should not be implemented in a driver without discussing it with the authorities (Cameron Grant <[email protected]>).

channel_setdir() is deprecated.

28.4.2.1 mixer_init

xxxmixer_init() initializes the hardware and tells pcm what mixer devices are available for playing and recording

              static int
              xxxmixer_init(struct snd_mixer *m)
              {
                  struct xxx_info   *sc = mix_getdevinfo(m);
                  u_int32_t v;
    
                  [Initialize hardware]
    
                  [Set appropriate bits in v for play mixers]
                  mix_setdevs(m, v);
                  [Set appropriate bits in v for record mixers]
                  mix_setrecdevs(m, v)
    
                  return 0;              
              }

Mixer bits definitions can be found in soundcard.h (SOUND_MASK_XXX values and SOUND_MIXER_XXX bit shifts).

28.4.2.2 mixer_set

xxxmixer_set() sets the volume level for one mixer device.

              static int
              xxxmixer_set(struct snd_mixer *m, unsigned dev, 
                               unsigned left, unsigned right)
              {
                  struct sc_info *sc = mix_getdevinfo(m);
                  [set volume level]
                  return left | (right << 8);
              }

28.4.2.3 mixer_setrecsrc

xxxmixer_setrecsrc() sets the recording source device.

              static int
              xxxmixer_setrecsrc(struct snd_mixer *m, u_int32_t src)
              {
                  struct xxx_info *sc = mix_getdevinfo(m);
    
                  [look for non zero bit(s) in src, set up hardware]
    
                  [update src to reflect actual action]
                  return src;
               }

28.4.2.4 mixer_uninit, mixer_reinit

xxxmixer_uninit() should ensure that all sound is muted and if possible mixer hardware should be powered down

xxxmixer_reinit() should ensure that the mixer hardware is powered up and any settings not controlled by mixer_set() or mixer_setrecsrc() are restored.