static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl)
{
struct video_device *dev = video_devdata(file);
struct zol_device *zol = dev->priv;
switch (ctrl->id) {
case V4L2_CID_AUDIO_MUTE:
if (ctrl->value)
zol_mute(zol);
else {
zol_unmute(zol);
zol_setvol(zol,zol->curvol);
}
return 0;
case V4L2_CID_AUDIO_VOLUME:
zol_setvol(zol,ctrl->value/4096);
return 0;
}
zol->stereo = 1;
zol_setfreq(zol, zol->curfreq);
#if 0
/* FIXME: Implement stereo/mono switch on V4L2 */
if (v->mode & VIDEO_SOUND_STEREO) {
zol->stereo = 1;
zol_setfreq(zol, zol->curfreq);
}
if (v->mode & VIDEO_SOUND_MONO) {
zol->stereo = 0;
zol_setfreq(zol, zol->curfreq);
}
#endif
return -EINVAL;
}
static void zol_unmute(struct zol_device *dev)
{
dev->muted = 0;
zol_setvol(dev, dev->curvol);
}
static int zol_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *arg)
{
struct video_device *dev = video_devdata(file);
struct zol_device *zol = dev->priv;
switch (cmd) {
case VIDIOCGCAP:
{
struct video_capability *v = arg;
memset(v,0,sizeof(*v));
v->type = VID_TYPE_TUNER;
v->channels = 1 + zol->stereo;
v->audios = 1;
strcpy(v->name, "Zoltrix Radio");
return 0;
}
case VIDIOCGTUNER:
{
struct video_tuner *v = arg;
if (v->tuner)
return -EINVAL;
strcpy(v->name, "FM");
v->rangelow = (int) (88.0 * 16000);
v->rangehigh = (int) (108.0 * 16000);
v->flags = zol_is_stereo(zol)
? VIDEO_TUNER_STEREO_ON : 0;
v->flags |= VIDEO_TUNER_LOW;
v->mode = VIDEO_MODE_AUTO;
v->signal = 0xFFFF * zol_getsigstr(zol);
return 0;
}
case VIDIOCSTUNER:
{
struct video_tuner *v = arg;
if (v->tuner != 0)
return -EINVAL;
/* Only 1 tuner so no setting needed ! */
return 0;
}
case VIDIOCGFREQ:
{
unsigned long *freq = arg;
*freq = zol->curfreq;
return 0;
}
case VIDIOCSFREQ:
{
unsigned long *freq = arg;
zol->curfreq = *freq;
zol_setfreq(zol, zol->curfreq);
return 0;
}
case VIDIOCGAUDIO:
{
struct video_audio *v = arg;
memset(v, 0, sizeof(*v));
v->flags |= VIDEO_AUDIO_MUTABLE | VIDEO_AUDIO_VOLUME;
v->mode |= zol_is_stereo(zol)
? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
v->volume = zol->curvol * 4096;
v->step = 4096;
strcpy(v->name, "Zoltrix Radio");
return 0;
}
case VIDIOCSAUDIO:
{
struct video_audio *v = arg;
if (v->audio)
return -EINVAL;
if (v->flags & VIDEO_AUDIO_MUTE)
zol_mute(zol);
else {
zol_unmute(zol);
zol_setvol(zol, v->volume / 4096);
}
if (v->mode & VIDEO_SOUND_STEREO) {
zol->stereo = 1;
zol_setfreq(zol, zol->curfreq);
}
if (v->mode & VIDEO_SOUND_MONO) {
zol->stereo = 0;
zol_setfreq(zol, zol->curfreq);
}
return 0;
}
default:
return -ENOIOCTLCMD;
}
}
static int zol_setfreq(struct zol_device *dev, unsigned long freq)
{
/* tunes the radio to the desired frequency */
unsigned long long bitmask, f, m;
unsigned int stereo = dev->stereo;
int i;
if (freq == 0)
return 1;
m = (freq / 160 - 8800) * 2;
f = (unsigned long long) m + 0x4d1c;
bitmask = 0xc480402c10080000ull;
i = 45;
down(&dev->lock);
outb(0, io);
outb(0, io);
inb(io + 3); /* Zoltrix needs to be read to confirm */
outb(0x40, io);
outb(0xc0, io);
bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ ( stereo << 31));
while (i--) {
if ((bitmask & 0x8000000000000000ull) != 0) {
outb(0x80, io);
udelay(50);
outb(0x00, io);
udelay(50);
outb(0x80, io);
udelay(50);
} else {
outb(0xc0, io);
udelay(50);
outb(0x40, io);
udelay(50);
outb(0xc0, io);
udelay(50);
}
bitmask *= 2;
}
/* termination sequence */
outb(0x80, io);
outb(0xc0, io);
outb(0x40, io);
udelay(1000);
inb(io+2);
udelay(1000);
if (dev->muted)
{
outb(0, io);
outb(0, io);
inb(io + 3);
udelay(1000);
}
up(&dev->lock);
if(!dev->muted)
{
zol_setvol(dev, dev->curvol);
}
return 0;
}
static int zol_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *arg)
{
struct video_device *dev = video_devdata(file);
struct zol_device *zol = dev->priv;
switch (cmd) {
case VIDIOC_QUERYCAP:
{
struct v4l2_capability *v = arg;
memset(v,0,sizeof(*v));
strlcpy(v->driver, "radio-zoltrix", sizeof (v->driver));
strlcpy(v->card, "Zoltrix Radio", sizeof (v->card));
sprintf(v->bus_info,"ISA");
v->version = RADIO_VERSION;
v->capabilities = V4L2_CAP_TUNER;
return 0;
}
case VIDIOC_G_TUNER:
{
struct v4l2_tuner *v = arg;
if (v->index > 0)
return -EINVAL;
memset(v,0,sizeof(*v));
strcpy(v->name, "FM");
v->type = V4L2_TUNER_RADIO;
v->rangelow=(88*16000);
v->rangehigh=(108*16000);
v->rxsubchans =V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
v->capability=V4L2_TUNER_CAP_LOW;
if(zol_is_stereo(zol))
v->audmode = V4L2_TUNER_MODE_STEREO;
else
v->audmode = V4L2_TUNER_MODE_MONO;
v->signal=0xFFFF*zol_getsigstr(zol);
return 0;
}
case VIDIOC_S_TUNER:
{
struct v4l2_tuner *v = arg;
if (v->index > 0)
return -EINVAL;
return 0;
}
case VIDIOC_S_FREQUENCY:
{
struct v4l2_frequency *f = arg;
zol->curfreq = f->frequency;
zol_setfreq(zol, zol->curfreq);
return 0;
}
case VIDIOC_G_FREQUENCY:
{
struct v4l2_frequency *f = arg;
f->type = V4L2_TUNER_RADIO;
f->frequency = zol->curfreq;
return 0;
}
case VIDIOC_QUERYCTRL:
{
struct v4l2_queryctrl *qc = arg;
int i;
for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
if (qc->id && qc->id == radio_qctrl[i].id) {
memcpy(qc, &(radio_qctrl[i]),
sizeof(*qc));
return (0);
}
}
return -EINVAL;
}
case VIDIOC_G_CTRL:
{
struct v4l2_control *ctrl= arg;
switch (ctrl->id) {
case V4L2_CID_AUDIO_MUTE:
ctrl->value=zol->muted;
return (0);
case V4L2_CID_AUDIO_VOLUME:
ctrl->value=zol->curvol * 4096;
return (0);
}
return -EINVAL;
}
case VIDIOC_S_CTRL:
{
struct v4l2_control *ctrl= arg;
switch (ctrl->id) {
case V4L2_CID_AUDIO_MUTE:
if (ctrl->value) {
zol_mute(zol);
} else {
zol_unmute(zol);
zol_setvol(zol,zol->curvol);
}
return (0);
case V4L2_CID_AUDIO_VOLUME:
zol_setvol(zol,ctrl->value/4096);
return (0);
}
zol->stereo = 1;
zol_setfreq(zol, zol->curfreq);
#if 0
/* FIXME: Implement stereo/mono switch on V4L2 */
if (v->mode & VIDEO_SOUND_STEREO) {
zol->stereo = 1;
zol_setfreq(zol, zol->curfreq);
}
if (v->mode & VIDEO_SOUND_MONO) {
zol->stereo = 0;
zol_setfreq(zol, zol->curfreq);
}
#endif
return -EINVAL;
}
default:
return v4l_compat_translate_ioctl(inode,file,cmd,arg,
zol_do_ioctl);
}
}
static int zol_setfreq(struct zoltrix *zol, unsigned long freq)
{
/* tunes the radio to the desired frequency */
struct v4l2_device *v4l2_dev = &zol->v4l2_dev;
unsigned long long bitmask, f, m;
unsigned int stereo = zol->stereo;
int i;
if (freq == 0) {
v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n");
return -EINVAL;
}
m = (freq / 160 - 8800) * 2;
f = (unsigned long long)m + 0x4d1c;
bitmask = 0xc480402c10080000ull;
i = 45;
mutex_lock(&zol->lock);
zol->curfreq = freq;
outb(0, zol->io);
outb(0, zol->io);
inb(zol->io + 3); /* Zoltrix needs to be read to confirm */
outb(0x40, zol->io);
outb(0xc0, zol->io);
bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31));
while (i--) {
if ((bitmask & 0x8000000000000000ull) != 0) {
outb(0x80, zol->io);
udelay(50);
outb(0x00, zol->io);
udelay(50);
outb(0x80, zol->io);
udelay(50);
} else {
outb(0xc0, zol->io);
udelay(50);
outb(0x40, zol->io);
udelay(50);
outb(0xc0, zol->io);
udelay(50);
}
bitmask *= 2;
}
/* termination sequence */
outb(0x80, zol->io);
outb(0xc0, zol->io);
outb(0x40, zol->io);
udelay(1000);
inb(zol->io + 2);
udelay(1000);
if (zol->muted) {
outb(0, zol->io);
outb(0, zol->io);
inb(zol->io + 3);
udelay(1000);
}
mutex_unlock(&zol->lock);
if (!zol->muted)
zol_setvol(zol, zol->curvol);
return 0;
}
static void zol_unmute(struct zoltrix *zol)
{
zol->muted = 0;
zol_setvol(zol, zol->curvol);
}
