The Ioctl Interface
Prev | Chapter 2. Radio Devices | Next

## The Ioctl Interface

This leaves the ioctl routine, without which the driver will not be terribly useful to anyone.

    static int radio_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
    {
            switch(cmd)
            {
                    case VIDIOCGCAP:
                    {
                            struct video_capability v;
                            v.type = VID_TYPE_TUNER;
                            v.channels = 1;
                            v.audios = 1;
                            v.maxwidth = 0;
                            v.minwidth = 0;
                            v.maxheight = 0;
                            v.minheight = 0;
                            strcpy(v.name, "My Radio");
                            if(copy_to_user(arg, &v, sizeof(v)))
                                    return -EFAULT;
                            return 0;
                    }

VIDIOCGCAP is the first ioctl all video4linux devices must support. It allows the applications to find out what sort of a card they have found and to figure out what they want to do about it. The fields in the structure are

Table 2.2. struct video_capability fields

name | The device text name. This is intended for the user.
channels | The number of different channels you can tune on this card. It could even by zero for a card that has no tuning capability. For our simple FM radio it is 1. An AM/FM radio would report 2.
audios | The number of audio inputs on this device. For our radio there is only one audio input.
minwidth,minheight | The smallest size the card is capable of capturing images in. We set these to zero. Radios do not capture pictures
maxwidth,maxheight | The largest image size the card is capable of capturing. For our radio we report 0.
type | This reports the capabilities of the device, and matches the field we filled in in the struct video_device when registering.

Having filled in the fields, we use copy_to_user to copy the structure into the users buffer. If the copy fails we return an EFAULT to the application so that it knows it tried to feed us garbage.

The next pair of ioctl operations select which tuner is to be used and let the application find the tuner properties. We have only a single FM band tuner in our example device.

                    case VIDIOCGTUNER:
                    {
                            struct video_tuner v;
                            if(copy_from_user(&v, arg, sizeof(v))!=0)
                                    return -EFAULT;
                            if(v.tuner)
                                    return -EINVAL;
                            v.rangelow=(87*16000);
                            v.rangehigh=(108*16000);
                            v.flags = VIDEO_TUNER_LOW;
                            v.mode = VIDEO_MODE_AUTO;
                            v.signal = 0xFFFF;
                            strcpy(v.name, "FM");
                            if(copy_to_user(&v, arg, sizeof(v))!=0)
                                    return -EFAULT;
                            return 0;
                    }

The VIDIOCGTUNER ioctl allows applications to query a tuner. The application sets the tuner field to the tuner number it wishes to query. The query does not change the tuner that is being used, it merely enquires about the tuner in question.

We have exactly one tuner so after copying the user buffer to our temporary structure we complain if they asked for a tuner other than tuner 0.

The video_tuner structure has the following fields

Table 2.3. struct video_tuner fields

int tuner | The number of the tuner in question
char name[32] | A text description of this tuner. "FM" will do fine. This is intended for the application.
u32 flags | Tuner capability flags
u16 mode | The current reception mode
u16 signal | The signal strength scaled between 0 and 65535. If a device cannot tell the signal strength it should report 65535. Many simple cards contain only a signal/no signal bit. Such cards will report either 0 or 65535.
u32 rangelow, rangehigh | The range of frequencies supported by the radio or TV. It is scaled according to the VIDEO_TUNER_LOW flag.

Table 2.4. struct video_tuner flags

VIDEO_TUNER_PAL | A PAL TV tuner
VIDEO_TUNER_NTSC | An NTSC (US) TV tuner
VIDEO_TUNER_SECAM | A SECAM (French) TV tuner
VIDEO_TUNER_LOW | The tuner frequency is scaled in 1/16th of a KHz steps. If not it is in 1/16th of a MHz steps
VIDEO_TUNER_NORM | The tuner can set its format
VIDEO_TUNER_STEREO_ON | The tuner is currently receiving a stereo signal

Table 2.5. struct video_tuner modes

VIDEO_MODE_PAL | PAL Format
VIDEO_MODE_NTSC | NTSC Format (USA)
VIDEO_MODE_SECAM | French Format
VIDEO_MODE_AUTO | A device that does not need to do TV format switching

The settings for the radio card are thus fairly simple. We report that we are a tuner called "FM" for FM radio. In order to get the best tuning resolution we report VIDEO_TUNER_LOW and select tuning to 1/16th of KHz. Its unlikely our card can do that resolution but it is a fair bet the card can do better than 1/16th of a MHz. VIDEO_TUNER_LOW is appropriate to almost all radio usage.

We report that the tuner automatically handles deciding what format it is receiving - true enough as it only handles FM radio. Our example card is also incapable of detecting stereo or signal strengths so it reports a strength of 0xFFFF (maximum) and no stereo detected.

To finish off we set the range that can be tuned to be 87-108Mhz, the normal FM broadcast radio range. It is important to find out what the card is actually capable of tuning. It is easy enough to simply use the FM broadcast range. Unfortunately if you do this you will discover the FM broadcast ranges in the USA, Europe and Japan are all subtly different and some users cannot receive all the stations they wish.

The application also needs to be able to set the tuner it wishes to use. In our case, with a single tuner this is rather simple to arrange.

                    case VIDIOCSTUNER:
                    {
                            struct video_tuner v;
                            if(copy_from_user(&v, arg, sizeof(v)))
                                    return -EFAULT;
                            if(v.tuner != 0)
                                    return -EINVAL;
                            return 0;
                    }

We copy the user supplied structure into kernel memory so we can examine it. If the user has selected a tuner other than zero we reject the request. If they wanted tuner 0 then, surprisingly enough, that is the current tuner already.

The next two ioctls we need to provide are to get and set the frequency of the radio. These both use an unsigned long argument which is the frequency. The scale of the frequency depends on the VIDEO_TUNER_LOW flag as I mentioned earlier on. Since we have VIDEO_TUNER_LOW set this will be in 1/16ths of a KHz.

    static unsigned long current_freq;

                    case VIDIOCGFREQ:
                            if(copy_to_user(arg, &current_freq,
                                    sizeof(unsigned long))
                                    return -EFAULT;
                            return 0;

Querying the frequency in our case is relatively simple. Our radio card is too dumb to let us query the signal strength so we remember our setting if we know it. All we have to do is copy it to the user.

                    case VIDIOCSFREQ:
                    {
                            u32 freq;
                            if(copy_from_user(arg, &freq,
                                    sizeof(unsigned long))!=0)
                                    return -EFAULT;
                            if(hardware_set_freq(freq)<0)
                                    return -EINVAL;
                            current_freq = freq;
                            return 0;
                    }

Setting the frequency is a little more complex. We begin by copying the desired frequency into kernel space. Next we call a hardware specific routine to set the radio up. This might be as simple as some scaling and a few writes to an I/O port. For most radio cards it turns out a good deal more complicated and may involve programming things like a phase locked loop on the card. This is what documentation is for.

The final set of operations we need to provide for our radio are the volume controls. Not all radio cards can even do volume control. After all there is a perfectly good volume control on the sound card. We will assume our radio card has a simple 4 step volume control.

There are two ioctls with audio we need to support

    static int current_volume=0;

                    case VIDIOCGAUDIO:
                    {
                            struct video_audio v;
                            if(copy_from_user(&v, arg, sizeof(v)))
                                    return -EFAULT;
                            if(v.audio != 0)
                                    return -EINVAL;
                            v.volume = 16384*current_volume;
                            v.step = 16384;
                            strcpy(v.name, "Radio");
                            v.mode = VIDEO_SOUND_MONO;
                            v.balance = 0;
                            v.base = 0;
                            v.treble = 0;

                            if(copy_to_user(arg. &v, sizeof(v)))
                                    return -EFAULT;
                            return 0;
                    }

Much like the tuner we start by copying the user structure into kernel space. Again we check if the user has asked for a valid audio input. We have only input 0 and we punt if they ask for another input.

Then we fill in the video_audio structure. This has the following format

Table 2.6. struct video_audio fields

audio | The input the user wishes to query
volume | The volume setting on a scale of 0-65535
base | The base level on a scale of 0-65535
treble | The treble level on a scale of 0-65535
flags | The features this audio device supports
name | A text name to display to the user. We picked "Radio" as it explains things quite nicely.
mode | The current reception mode for the audio We report MONO because our card is too stupid to know if it is in mono or stereo.
balance | The stereo balance on a scale of 0-65535, 32768 is middle.
step | The step by which the volume control jumps. This is used to help make it easy for applications to set slider behaviour.

Table 2.7. struct video_audio flags

VIDEO_AUDIO_MUTE | The audio is currently muted. We could fake this in our driver but we choose not to bother.
VIDEO_AUDIO_MUTABLE | The input has a mute option
VIDEO_AUDIO_TREBLE | The input has a treble control
VIDEO_AUDIO_BASS | The input has a base control

Table 2.8. struct video_audio modes

VIDEO_SOUND_MONO | Mono sound
VIDEO_SOUND_STEREO | Stereo sound
VIDEO_SOUND_LANG1 | Alternative language 1 (TV specific)
VIDEO_SOUND_LANG2 | Alternative language 2 (TV specific)

Having filled in the structure we copy it back to user space.

The VIDIOCSAUDIO ioctl allows the user to set the audio parameters in the video_audio structure. The driver does its best to honour the request.

                    case VIDIOCSAUDIO:
                    {
                            struct video_audio v;
                            if(copy_from_user(&v, arg, sizeof(v)))
                                    return -EFAULT;
                            if(v.audio)
                                    return -EINVAL;
                            current_volume = v/16384;
                            hardware_set_volume(current_volume);
                            return 0;
                    }

In our case there is very little that the user can set. The volume is basically the limit. Note that we could pretend to have a mute feature by rewriting this to

                    case VIDIOCSAUDIO:
                    {
                            struct video_audio v;
                            if(copy_from_user(&v, arg, sizeof(v)))
                                    return -EFAULT;
                            if(v.audio)
                                    return -EINVAL;
                            current_volume = v/16384;
                            if(v.flags&VIDEO_AUDIO_MUTE)
                                    hardware_set_volume(0);
                            else
                                    hardware_set_volume(current_volume);
                            current_muted = v.flags &
                                                  VIDEO_AUDIO_MUTE;
                            return 0;
                    }

This with the corresponding changes to the VIDIOCGAUDIO code to report the state of the mute flag we save and to report the card has a mute function, will allow applications to use a mute facility with this card. It is questionable whether this is a good idea however. User applications can already fake this themselves and kernel space is precious.

We now have a working radio ioctl handler. So we just wrap up the function

            }
            return -ENOIOCTLCMD;
    }

and pass the Video4Linux layer back an error so that it knows we did not understand the request we got passed.

Prev | Up | Next
Opening And Closing The Radio | Home | Module Wrapper