109c434b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /* radio-cadet.c - A video4linux driver for the ADS Cadet AM/FM Radio Card
31da177e4SLinus Torvalds *
41da177e4SLinus Torvalds * by Fred Gleason <fredg@wava.com>
51da177e4SLinus Torvalds * Version 0.3.3
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * (Loosely) based on code for the Aztech radio card by
81da177e4SLinus Torvalds *
91da177e4SLinus Torvalds * Russell Kroll (rkroll@exploits.org)
101da177e4SLinus Torvalds * Quay Ly
111da177e4SLinus Torvalds * Donald Song
121da177e4SLinus Torvalds * Jason Lewis (jlewis@twilight.vtc.vsc.edu)
131da177e4SLinus Torvalds * Scott McGrath (smcgrath@twilight.vtc.vsc.edu)
141da177e4SLinus Torvalds * William McGrath (wmcgrath@twilight.vtc.vsc.edu)
151da177e4SLinus Torvalds *
161da177e4SLinus Torvalds * History:
171da177e4SLinus Torvalds * 2000-04-29 Russell Kroll <rkroll@exploits.org>
181da177e4SLinus Torvalds * Added ISAPnP detection for Linux 2.3/2.4
191da177e4SLinus Torvalds *
201da177e4SLinus Torvalds * 2001-01-10 Russell Kroll <rkroll@exploits.org>
211da177e4SLinus Torvalds * Removed dead CONFIG_RADIO_CADET_PORT code
221da177e4SLinus Torvalds * PnP detection on load is now default (no args necessary)
231da177e4SLinus Torvalds *
241da177e4SLinus Torvalds * 2002-01-17 Adam Belay <ambx1@neo.rr.com>
251da177e4SLinus Torvalds * Updated to latest pnp code
261da177e4SLinus Torvalds *
27d9b01449SAlan Cox * 2003-01-31 Alan Cox <alan@lxorguk.ukuu.org.uk>
281da177e4SLinus Torvalds * Cleaned up locking, delay code, general odds and ends
29c0c7fa09SHans J. Koch *
30c0c7fa09SHans J. Koch * 2006-07-30 Hans J. Koch <koch@hjk-az.de>
31c0c7fa09SHans J. Koch * Changed API to V4L2
321da177e4SLinus Torvalds */
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds #include <linux/module.h> /* Modules */
351da177e4SLinus Torvalds #include <linux/init.h> /* Initdata */
36fb911ee8SPeter Osterlund #include <linux/ioport.h> /* request_region */
371da177e4SLinus Torvalds #include <linux/delay.h> /* udelay */
38c0c7fa09SHans J. Koch #include <linux/videodev2.h> /* V4L2 API defs */
391da177e4SLinus Torvalds #include <linux/param.h>
401da177e4SLinus Torvalds #include <linux/pnp.h>
41a99bbaf5SAlexey Dobriyan #include <linux/sched.h>
42bec2aec5SHans Verkuil #include <linux/io.h> /* outb, outb_p */
43bec2aec5SHans Verkuil #include <media/v4l2-device.h>
44bec2aec5SHans Verkuil #include <media/v4l2-ioctl.h>
45b54c97dbSHans Verkuil #include <media/v4l2-ctrls.h>
46b54c97dbSHans Verkuil #include <media/v4l2-fh.h>
47b54c97dbSHans Verkuil #include <media/v4l2-event.h>
48bec2aec5SHans Verkuil
49bec2aec5SHans Verkuil MODULE_AUTHOR("Fred Gleason, Russell Kroll, Quay Lu, Donald Song, Jason Lewis, Scott McGrath, William McGrath");
50bec2aec5SHans Verkuil MODULE_DESCRIPTION("A driver for the ADS Cadet AM/FM/RDS radio card.");
51bec2aec5SHans Verkuil MODULE_LICENSE("GPL");
5229834c1aSMauro Carvalho Chehab MODULE_VERSION("0.3.4");
53bec2aec5SHans Verkuil
54bec2aec5SHans Verkuil static int io = -1; /* default to isapnp activation */
55bec2aec5SHans Verkuil static int radio_nr = -1;
56bec2aec5SHans Verkuil
57bec2aec5SHans Verkuil module_param(io, int, 0);
58bec2aec5SHans Verkuil MODULE_PARM_DESC(io, "I/O address of Cadet card (0x330,0x332,0x334,0x336,0x338,0x33a,0x33c,0x33e)");
59bec2aec5SHans Verkuil module_param(radio_nr, int, 0);
60bec2aec5SHans Verkuil
611da177e4SLinus Torvalds #define RDS_BUFFER 256
62c0c7fa09SHans J. Koch #define RDS_RX_FLAG 1
63c0c7fa09SHans J. Koch #define MBS_RX_FLAG 2
64c0c7fa09SHans J. Koch
65bec2aec5SHans Verkuil struct cadet {
66bec2aec5SHans Verkuil struct v4l2_device v4l2_dev;
67bec2aec5SHans Verkuil struct video_device vdev;
68b54c97dbSHans Verkuil struct v4l2_ctrl_handler ctrl_handler;
69bec2aec5SHans Verkuil int io;
706652c716SHans Verkuil bool is_fm_band;
716652c716SHans Verkuil u32 curfreq;
72bec2aec5SHans Verkuil int tunestat;
73bec2aec5SHans Verkuil int sigstrength;
74bec2aec5SHans Verkuil wait_queue_head_t read_queue;
75bec2aec5SHans Verkuil struct timer_list readtimer;
76cc0d3266SHans Verkuil u8 rdsin, rdsout, rdsstat;
77bec2aec5SHans Verkuil unsigned char rdsbuf[RDS_BUFFER];
78bec2aec5SHans Verkuil struct mutex lock;
79bec2aec5SHans Verkuil int reading;
80c1c4fd3eSDouglas Landgraf };
81c1c4fd3eSDouglas Landgraf
82bec2aec5SHans Verkuil static struct cadet cadet_card;
831da177e4SLinus Torvalds
841da177e4SLinus Torvalds /*
851da177e4SLinus Torvalds * Signal Strength Threshold Values
861da177e4SLinus Torvalds * The V4L API spec does not define any particular unit for the signal
871da177e4SLinus Torvalds * strength value. These values are in microvolts of RF at the tuner's input.
881da177e4SLinus Torvalds */
896652c716SHans Verkuil static u16 sigtable[2][4] = {
906652c716SHans Verkuil { 1835, 2621, 4128, 65535 },
91cc0d3266SHans Verkuil { 2185, 4369, 13107, 65535 },
92bec2aec5SHans Verkuil };
931da177e4SLinus Torvalds
94b530a447SHans Verkuil static const struct v4l2_frequency_band bands[] = {
95b530a447SHans Verkuil {
96b530a447SHans Verkuil .index = 0,
97b530a447SHans Verkuil .type = V4L2_TUNER_RADIO,
98b530a447SHans Verkuil .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_FREQ_BANDS,
99b530a447SHans Verkuil .rangelow = 8320, /* 520 kHz */
100b530a447SHans Verkuil .rangehigh = 26400, /* 1650 kHz */
101b530a447SHans Verkuil .modulation = V4L2_BAND_MODULATION_AM,
102b530a447SHans Verkuil }, {
103b530a447SHans Verkuil .index = 1,
104b530a447SHans Verkuil .type = V4L2_TUNER_RADIO,
105b530a447SHans Verkuil .capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS |
106b530a447SHans Verkuil V4L2_TUNER_CAP_RDS_BLOCK_IO | V4L2_TUNER_CAP_LOW |
107b530a447SHans Verkuil V4L2_TUNER_CAP_FREQ_BANDS,
108b530a447SHans Verkuil .rangelow = 1400000, /* 87.5 MHz */
109b530a447SHans Verkuil .rangehigh = 1728000, /* 108.0 MHz */
110b530a447SHans Verkuil .modulation = V4L2_BAND_MODULATION_FM,
111b530a447SHans Verkuil },
112b530a447SHans Verkuil };
113b530a447SHans Verkuil
114c0c7fa09SHans J. Koch
cadet_getstereo(struct cadet * dev)115bec2aec5SHans Verkuil static int cadet_getstereo(struct cadet *dev)
1161da177e4SLinus Torvalds {
117c0c7fa09SHans J. Koch int ret = V4L2_TUNER_SUB_MONO;
118bec2aec5SHans Verkuil
1196652c716SHans Verkuil if (!dev->is_fm_band) /* Only FM has stereo capability! */
120c0c7fa09SHans J. Koch return V4L2_TUNER_SUB_MONO;
1211da177e4SLinus Torvalds
122bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
123bec2aec5SHans Verkuil if ((inb(dev->io + 1) & 0x40) == 0)
124c0c7fa09SHans J. Koch ret = V4L2_TUNER_SUB_STEREO;
1251da177e4SLinus Torvalds return ret;
1261da177e4SLinus Torvalds }
1271da177e4SLinus Torvalds
cadet_gettune(struct cadet * dev)128bec2aec5SHans Verkuil static unsigned cadet_gettune(struct cadet *dev)
1291da177e4SLinus Torvalds {
1301da177e4SLinus Torvalds int curvol, i;
1311da177e4SLinus Torvalds unsigned fifo = 0;
1321da177e4SLinus Torvalds
1331da177e4SLinus Torvalds /*
1341da177e4SLinus Torvalds * Prepare for read
1351da177e4SLinus Torvalds */
1361da177e4SLinus Torvalds
137bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
138bec2aec5SHans Verkuil curvol = inb(dev->io + 1); /* Save current volume/mute setting */
139bec2aec5SHans Verkuil outb(0x00, dev->io + 1); /* Ensure WRITE-ENABLE is LOW */
140bec2aec5SHans Verkuil dev->tunestat = 0xffff;
1411da177e4SLinus Torvalds
1421da177e4SLinus Torvalds /*
1431da177e4SLinus Torvalds * Read the shift register
1441da177e4SLinus Torvalds */
1451da177e4SLinus Torvalds for (i = 0; i < 25; i++) {
146bec2aec5SHans Verkuil fifo = (fifo << 1) | ((inb(dev->io + 1) >> 7) & 0x01);
1471da177e4SLinus Torvalds if (i < 24) {
148bec2aec5SHans Verkuil outb(0x01, dev->io + 1);
149bec2aec5SHans Verkuil dev->tunestat &= inb(dev->io + 1);
150bec2aec5SHans Verkuil outb(0x00, dev->io + 1);
1511da177e4SLinus Torvalds }
1521da177e4SLinus Torvalds }
1531da177e4SLinus Torvalds
1541da177e4SLinus Torvalds /*
1551da177e4SLinus Torvalds * Restore volume/mute setting
1561da177e4SLinus Torvalds */
157bec2aec5SHans Verkuil outb(curvol, dev->io + 1);
1581da177e4SLinus Torvalds return fifo;
1591da177e4SLinus Torvalds }
1601da177e4SLinus Torvalds
cadet_getfreq(struct cadet * dev)161bec2aec5SHans Verkuil static unsigned cadet_getfreq(struct cadet *dev)
1621da177e4SLinus Torvalds {
1631da177e4SLinus Torvalds int i;
1641da177e4SLinus Torvalds unsigned freq = 0, test, fifo = 0;
1651da177e4SLinus Torvalds
1661da177e4SLinus Torvalds /*
1671da177e4SLinus Torvalds * Read current tuning
1681da177e4SLinus Torvalds */
169bec2aec5SHans Verkuil fifo = cadet_gettune(dev);
1701da177e4SLinus Torvalds
1711da177e4SLinus Torvalds /*
1721da177e4SLinus Torvalds * Convert to actual frequency
1731da177e4SLinus Torvalds */
1746652c716SHans Verkuil if (!dev->is_fm_band) /* AM */
1756652c716SHans Verkuil return ((fifo & 0x7fff) - 450) * 16;
1766652c716SHans Verkuil
1771da177e4SLinus Torvalds test = 12500;
1781da177e4SLinus Torvalds for (i = 0; i < 14; i++) {
179bec2aec5SHans Verkuil if ((fifo & 0x01) != 0)
1801da177e4SLinus Torvalds freq += test;
1811da177e4SLinus Torvalds test = test << 1;
1821da177e4SLinus Torvalds fifo = fifo >> 1;
1831da177e4SLinus Torvalds }
1841da177e4SLinus Torvalds freq -= 10700000; /* IF frequency is 10.7 MHz */
185b54c97dbSHans Verkuil freq = (freq * 16) / 1000; /* Make it 1/16 kHz */
1861da177e4SLinus Torvalds return freq;
1871da177e4SLinus Torvalds }
1881da177e4SLinus Torvalds
cadet_settune(struct cadet * dev,unsigned fifo)189bec2aec5SHans Verkuil static void cadet_settune(struct cadet *dev, unsigned fifo)
1901da177e4SLinus Torvalds {
1911da177e4SLinus Torvalds int i;
1921da177e4SLinus Torvalds unsigned test;
1931da177e4SLinus Torvalds
194bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
1951da177e4SLinus Torvalds /*
1961da177e4SLinus Torvalds * Write the shift register
1971da177e4SLinus Torvalds */
1981da177e4SLinus Torvalds test = 0;
1991da177e4SLinus Torvalds test = (fifo >> 23) & 0x02; /* Align data for SDO */
2001da177e4SLinus Torvalds test |= 0x1c; /* SDM=1, SWE=1, SEN=1, SCK=0 */
201bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
202bec2aec5SHans Verkuil outb(test, dev->io + 1); /* Initialize for write */
2031da177e4SLinus Torvalds for (i = 0; i < 25; i++) {
2041da177e4SLinus Torvalds test |= 0x01; /* Toggle SCK High */
205bec2aec5SHans Verkuil outb(test, dev->io + 1);
2061da177e4SLinus Torvalds test &= 0xfe; /* Toggle SCK Low */
207bec2aec5SHans Verkuil outb(test, dev->io + 1);
2081da177e4SLinus Torvalds fifo = fifo << 1; /* Prepare the next bit */
2091da177e4SLinus Torvalds test = 0x1c | ((fifo >> 23) & 0x02);
210bec2aec5SHans Verkuil outb(test, dev->io + 1);
2111da177e4SLinus Torvalds }
2121da177e4SLinus Torvalds }
2131da177e4SLinus Torvalds
cadet_setfreq(struct cadet * dev,unsigned freq)214bec2aec5SHans Verkuil static void cadet_setfreq(struct cadet *dev, unsigned freq)
2151da177e4SLinus Torvalds {
2161da177e4SLinus Torvalds unsigned fifo;
2171da177e4SLinus Torvalds int i, j, test;
2181da177e4SLinus Torvalds int curvol;
2191da177e4SLinus Torvalds
220b530a447SHans Verkuil freq = clamp(freq, bands[dev->is_fm_band].rangelow,
221b530a447SHans Verkuil bands[dev->is_fm_band].rangehigh);
2226652c716SHans Verkuil dev->curfreq = freq;
2231da177e4SLinus Torvalds /*
2241da177e4SLinus Torvalds * Formulate a fifo command
2251da177e4SLinus Torvalds */
2261da177e4SLinus Torvalds fifo = 0;
2276652c716SHans Verkuil if (dev->is_fm_band) { /* FM */
2281da177e4SLinus Torvalds test = 102400;
229b54c97dbSHans Verkuil freq = freq / 16; /* Make it kHz */
2301da177e4SLinus Torvalds freq += 10700; /* IF is 10700 kHz */
2311da177e4SLinus Torvalds for (i = 0; i < 14; i++) {
2321da177e4SLinus Torvalds fifo = fifo << 1;
2331da177e4SLinus Torvalds if (freq >= test) {
2341da177e4SLinus Torvalds fifo |= 0x01;
2351da177e4SLinus Torvalds freq -= test;
2361da177e4SLinus Torvalds }
2371da177e4SLinus Torvalds test = test >> 1;
2381da177e4SLinus Torvalds }
2396652c716SHans Verkuil } else { /* AM */
2406652c716SHans Verkuil fifo = (freq / 16) + 450; /* Make it kHz */
2411da177e4SLinus Torvalds fifo |= 0x100000; /* Select AM Band */
2421da177e4SLinus Torvalds }
2431da177e4SLinus Torvalds
2441da177e4SLinus Torvalds /*
2451da177e4SLinus Torvalds * Save current volume/mute setting
2461da177e4SLinus Torvalds */
2471da177e4SLinus Torvalds
248bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
249bec2aec5SHans Verkuil curvol = inb(dev->io + 1);
2501da177e4SLinus Torvalds
2511da177e4SLinus Torvalds /*
2521da177e4SLinus Torvalds * Tune the card
2531da177e4SLinus Torvalds */
2541da177e4SLinus Torvalds for (j = 3; j > -1; j--) {
255bec2aec5SHans Verkuil cadet_settune(dev, fifo | (j << 16));
2561da177e4SLinus Torvalds
257bec2aec5SHans Verkuil outb(7, dev->io); /* Select tuner control */
258bec2aec5SHans Verkuil outb(curvol, dev->io + 1);
2591da177e4SLinus Torvalds
2601da177e4SLinus Torvalds msleep(100);
2611da177e4SLinus Torvalds
262bec2aec5SHans Verkuil cadet_gettune(dev);
263bec2aec5SHans Verkuil if ((dev->tunestat & 0x40) == 0) { /* Tuned */
2646652c716SHans Verkuil dev->sigstrength = sigtable[dev->is_fm_band][j];
265cc0d3266SHans Verkuil goto reset_rds;
2661da177e4SLinus Torvalds }
2671da177e4SLinus Torvalds }
268bec2aec5SHans Verkuil dev->sigstrength = 0;
269cc0d3266SHans Verkuil reset_rds:
270cc0d3266SHans Verkuil outb(3, dev->io);
271cc0d3266SHans Verkuil outb(inb(dev->io + 1) & 0x7f, dev->io + 1);
2721da177e4SLinus Torvalds }
2731da177e4SLinus Torvalds
cadet_has_rds_data(struct cadet * dev)274ce0ede2cSHans Verkuil static bool cadet_has_rds_data(struct cadet *dev)
275ce0ede2cSHans Verkuil {
276ce0ede2cSHans Verkuil bool result;
277ce0ede2cSHans Verkuil
278ce0ede2cSHans Verkuil mutex_lock(&dev->lock);
279ce0ede2cSHans Verkuil result = dev->rdsin != dev->rdsout;
280ce0ede2cSHans Verkuil mutex_unlock(&dev->lock);
281ce0ede2cSHans Verkuil return result;
282ce0ede2cSHans Verkuil }
283ce0ede2cSHans Verkuil
2841da177e4SLinus Torvalds
cadet_handler(struct timer_list * t)285297fced0SKees Cook static void cadet_handler(struct timer_list *t)
2861da177e4SLinus Torvalds {
287297fced0SKees Cook struct cadet *dev = from_timer(dev, t, readtimer);
2881da177e4SLinus Torvalds
289bec2aec5SHans Verkuil /* Service the RDS fifo */
290bec2aec5SHans Verkuil if (mutex_trylock(&dev->lock)) {
291bec2aec5SHans Verkuil outb(0x3, dev->io); /* Select RDS Decoder Control */
292bec2aec5SHans Verkuil if ((inb(dev->io + 1) & 0x20) != 0)
293ce0ede2cSHans Verkuil pr_err("cadet: RDS fifo overflow\n");
294bec2aec5SHans Verkuil outb(0x80, dev->io); /* Select RDS fifo */
295ce0ede2cSHans Verkuil
296bec2aec5SHans Verkuil while ((inb(dev->io) & 0x80) != 0) {
297bec2aec5SHans Verkuil dev->rdsbuf[dev->rdsin] = inb(dev->io + 1);
298ce0ede2cSHans Verkuil if (dev->rdsin + 1 != dev->rdsout)
299bec2aec5SHans Verkuil dev->rdsin++;
3001da177e4SLinus Torvalds }
301bec2aec5SHans Verkuil mutex_unlock(&dev->lock);
3021da177e4SLinus Torvalds }
3031da177e4SLinus Torvalds
3041da177e4SLinus Torvalds /*
3051da177e4SLinus Torvalds * Service pending read
3061da177e4SLinus Torvalds */
307ce0ede2cSHans Verkuil if (cadet_has_rds_data(dev))
308bec2aec5SHans Verkuil wake_up_interruptible(&dev->read_queue);
3091da177e4SLinus Torvalds
3101da177e4SLinus Torvalds /*
3111da177e4SLinus Torvalds * Clean up and exit
3121da177e4SLinus Torvalds */
313bec2aec5SHans Verkuil dev->readtimer.expires = jiffies + msecs_to_jiffies(50);
314bec2aec5SHans Verkuil add_timer(&dev->readtimer);
3151da177e4SLinus Torvalds }
3161da177e4SLinus Torvalds
cadet_start_rds(struct cadet * dev)317cc0d3266SHans Verkuil static void cadet_start_rds(struct cadet *dev)
3181da177e4SLinus Torvalds {
319bec2aec5SHans Verkuil dev->rdsstat = 1;
320bec2aec5SHans Verkuil outb(0x80, dev->io); /* Select RDS fifo */
321297fced0SKees Cook timer_setup(&dev->readtimer, cadet_handler, 0);
322bec2aec5SHans Verkuil dev->readtimer.expires = jiffies + msecs_to_jiffies(50);
323bec2aec5SHans Verkuil add_timer(&dev->readtimer);
3241da177e4SLinus Torvalds }
325cc0d3266SHans Verkuil
cadet_read(struct file * file,char __user * data,size_t count,loff_t * ppos)326cc0d3266SHans Verkuil static ssize_t cadet_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
327cc0d3266SHans Verkuil {
328cc0d3266SHans Verkuil struct cadet *dev = video_drvdata(file);
329cc0d3266SHans Verkuil unsigned char readbuf[RDS_BUFFER];
330cc0d3266SHans Verkuil int i = 0;
331cc0d3266SHans Verkuil
332cc0d3266SHans Verkuil mutex_lock(&dev->lock);
333cc0d3266SHans Verkuil if (dev->rdsstat == 0)
334cc0d3266SHans Verkuil cadet_start_rds(dev);
335cc0d3266SHans Verkuil mutex_unlock(&dev->lock);
336ce0ede2cSHans Verkuil
337ce0ede2cSHans Verkuil if (!cadet_has_rds_data(dev) && (file->f_flags & O_NONBLOCK))
338ce0ede2cSHans Verkuil return -EWOULDBLOCK;
339ce0ede2cSHans Verkuil i = wait_event_interruptible(dev->read_queue, cadet_has_rds_data(dev));
340ce0ede2cSHans Verkuil if (i)
341ce0ede2cSHans Verkuil return i;
342ce0ede2cSHans Verkuil
343cc0d3266SHans Verkuil mutex_lock(&dev->lock);
344bec2aec5SHans Verkuil while (i < count && dev->rdsin != dev->rdsout)
345bec2aec5SHans Verkuil readbuf[i++] = dev->rdsbuf[dev->rdsout++];
346ce0ede2cSHans Verkuil mutex_unlock(&dev->lock);
3471da177e4SLinus Torvalds
348cc0d3266SHans Verkuil if (i && copy_to_user(data, readbuf, i))
349ce0ede2cSHans Verkuil return -EFAULT;
3501da177e4SLinus Torvalds return i;
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds
3531da177e4SLinus Torvalds
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * v)354c1c4fd3eSDouglas Landgraf static int vidioc_querycap(struct file *file, void *priv,
355c1c4fd3eSDouglas Landgraf struct v4l2_capability *v)
3561da177e4SLinus Torvalds {
357c0decac1SMauro Carvalho Chehab strscpy(v->driver, "ADS Cadet", sizeof(v->driver));
358c0decac1SMauro Carvalho Chehab strscpy(v->card, "ADS Cadet", sizeof(v->card));
359c0decac1SMauro Carvalho Chehab strscpy(v->bus_info, "ISA:radio-cadet", sizeof(v->bus_info));
3601da177e4SLinus Torvalds return 0;
3611da177e4SLinus Torvalds }
362c1c4fd3eSDouglas Landgraf
vidioc_g_tuner(struct file * file,void * priv,struct v4l2_tuner * v)363c1c4fd3eSDouglas Landgraf static int vidioc_g_tuner(struct file *file, void *priv,
364c1c4fd3eSDouglas Landgraf struct v4l2_tuner *v)
3651da177e4SLinus Torvalds {
366bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
367bec2aec5SHans Verkuil
3686652c716SHans Verkuil if (v->index)
3696652c716SHans Verkuil return -EINVAL;
370c1c4fd3eSDouglas Landgraf v->type = V4L2_TUNER_RADIO;
371c0decac1SMauro Carvalho Chehab strscpy(v->name, "Radio", sizeof(v->name));
3726652c716SHans Verkuil v->capability = bands[0].capability | bands[1].capability;
3736652c716SHans Verkuil v->rangelow = bands[0].rangelow; /* 520 kHz (start of AM band) */
3746652c716SHans Verkuil v->rangehigh = bands[1].rangehigh; /* 108.0 MHz (end of FM band) */
3756652c716SHans Verkuil if (dev->is_fm_band) {
376bec2aec5SHans Verkuil v->rxsubchans = cadet_getstereo(dev);
377cc0d3266SHans Verkuil outb(3, dev->io);
378cc0d3266SHans Verkuil outb(inb(dev->io + 1) & 0x7f, dev->io + 1);
379cc0d3266SHans Verkuil mdelay(100);
380cc0d3266SHans Verkuil outb(3, dev->io);
381cc0d3266SHans Verkuil if (inb(dev->io + 1) & 0x80)
3828e280f24SHans Verkuil v->rxsubchans |= V4L2_TUNER_SUB_RDS;
3836652c716SHans Verkuil } else {
384c1c4fd3eSDouglas Landgraf v->rangelow = 8320; /* 520 kHz */
385c1c4fd3eSDouglas Landgraf v->rangehigh = 26400; /* 1650 kHz */
386c1c4fd3eSDouglas Landgraf v->rxsubchans = V4L2_TUNER_SUB_MONO;
3871da177e4SLinus Torvalds }
3886652c716SHans Verkuil v->audmode = V4L2_TUNER_MODE_STEREO;
389bec2aec5SHans Verkuil v->signal = dev->sigstrength; /* We might need to modify scaling of this */
3901da177e4SLinus Torvalds return 0;
3911da177e4SLinus Torvalds }
392c1c4fd3eSDouglas Landgraf
vidioc_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * v)393c1c4fd3eSDouglas Landgraf static int vidioc_s_tuner(struct file *file, void *priv,
3942f73c7c5SHans Verkuil const struct v4l2_tuner *v)
3951da177e4SLinus Torvalds {
3966652c716SHans Verkuil return v->index ? -EINVAL : 0;
3976652c716SHans Verkuil }
3986652c716SHans Verkuil
vidioc_enum_freq_bands(struct file * file,void * priv,struct v4l2_frequency_band * band)3996652c716SHans Verkuil static int vidioc_enum_freq_bands(struct file *file, void *priv,
4006652c716SHans Verkuil struct v4l2_frequency_band *band)
4016652c716SHans Verkuil {
4026652c716SHans Verkuil if (band->tuner)
403c0c7fa09SHans J. Koch return -EINVAL;
4046652c716SHans Verkuil if (band->index >= ARRAY_SIZE(bands))
4056652c716SHans Verkuil return -EINVAL;
4066652c716SHans Verkuil *band = bands[band->index];
4071da177e4SLinus Torvalds return 0;
4081da177e4SLinus Torvalds }
409c1c4fd3eSDouglas Landgraf
vidioc_g_frequency(struct file * file,void * priv,struct v4l2_frequency * f)410c1c4fd3eSDouglas Landgraf static int vidioc_g_frequency(struct file *file, void *priv,
411c1c4fd3eSDouglas Landgraf struct v4l2_frequency *f)
4121da177e4SLinus Torvalds {
413bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
414bec2aec5SHans Verkuil
4156652c716SHans Verkuil if (f->tuner)
416b54c97dbSHans Verkuil return -EINVAL;
417c0c7fa09SHans J. Koch f->type = V4L2_TUNER_RADIO;
4186652c716SHans Verkuil f->frequency = dev->curfreq;
419c0c7fa09SHans J. Koch return 0;
420c0c7fa09SHans J. Koch }
421c1c4fd3eSDouglas Landgraf
422c1c4fd3eSDouglas Landgraf
vidioc_s_frequency(struct file * file,void * priv,const struct v4l2_frequency * f)423c1c4fd3eSDouglas Landgraf static int vidioc_s_frequency(struct file *file, void *priv,
424b530a447SHans Verkuil const struct v4l2_frequency *f)
425c0c7fa09SHans J. Koch {
426bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
427bec2aec5SHans Verkuil
4286652c716SHans Verkuil if (f->tuner)
4291da177e4SLinus Torvalds return -EINVAL;
4306652c716SHans Verkuil dev->is_fm_band =
4316652c716SHans Verkuil f->frequency >= (bands[0].rangehigh + bands[1].rangelow) / 2;
432bec2aec5SHans Verkuil cadet_setfreq(dev, f->frequency);
4331da177e4SLinus Torvalds return 0;
4341da177e4SLinus Torvalds }
435c1c4fd3eSDouglas Landgraf
cadet_s_ctrl(struct v4l2_ctrl * ctrl)436b54c97dbSHans Verkuil static int cadet_s_ctrl(struct v4l2_ctrl *ctrl)
437c0c7fa09SHans J. Koch {
438b54c97dbSHans Verkuil struct cadet *dev = container_of(ctrl->handler, struct cadet, ctrl_handler);
439b54c97dbSHans Verkuil
440b54c97dbSHans Verkuil switch (ctrl->id) {
441bec2aec5SHans Verkuil case V4L2_CID_AUDIO_MUTE:
442b54c97dbSHans Verkuil outb(7, dev->io); /* Select tuner control */
443b54c97dbSHans Verkuil if (ctrl->val)
444b54c97dbSHans Verkuil outb(0x00, dev->io + 1);
445c1c4fd3eSDouglas Landgraf else
446b54c97dbSHans Verkuil outb(0x20, dev->io + 1);
447b54c97dbSHans Verkuil return 0;
448b54c97dbSHans Verkuil }
449c1c4fd3eSDouglas Landgraf return -EINVAL;
4501da177e4SLinus Torvalds }
451bec2aec5SHans Verkuil
cadet_open(struct file * file)452bec2aec5SHans Verkuil static int cadet_open(struct file *file)
453bec2aec5SHans Verkuil {
454bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
455b54c97dbSHans Verkuil int err;
456bec2aec5SHans Verkuil
4571cccee0bSHans Verkuil mutex_lock(&dev->lock);
458b54c97dbSHans Verkuil err = v4l2_fh_open(file);
459b54c97dbSHans Verkuil if (err)
460b54c97dbSHans Verkuil goto fail;
461b54c97dbSHans Verkuil if (v4l2_fh_is_singular_file(file))
462bec2aec5SHans Verkuil init_waitqueue_head(&dev->read_queue);
463b54c97dbSHans Verkuil fail:
4641cccee0bSHans Verkuil mutex_unlock(&dev->lock);
465b54c97dbSHans Verkuil return err;
4661da177e4SLinus Torvalds }
4671da177e4SLinus Torvalds
cadet_release(struct file * file)468bec2aec5SHans Verkuil static int cadet_release(struct file *file)
4691da177e4SLinus Torvalds {
470bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
4711da177e4SLinus Torvalds
4721cccee0bSHans Verkuil mutex_lock(&dev->lock);
473b54c97dbSHans Verkuil if (v4l2_fh_is_singular_file(file) && dev->rdsstat) {
474bec2aec5SHans Verkuil del_timer_sync(&dev->readtimer);
475bec2aec5SHans Verkuil dev->rdsstat = 0;
476c0c7fa09SHans J. Koch }
477b54c97dbSHans Verkuil v4l2_fh_release(file);
4781cccee0bSHans Verkuil mutex_unlock(&dev->lock);
479c0c7fa09SHans J. Koch return 0;
480c0c7fa09SHans J. Koch }
481c0c7fa09SHans J. Koch
cadet_poll(struct file * file,struct poll_table_struct * wait)482c23e0cb8SAl Viro static __poll_t cadet_poll(struct file *file, struct poll_table_struct *wait)
483c0c7fa09SHans J. Koch {
484bec2aec5SHans Verkuil struct cadet *dev = video_drvdata(file);
48501699437SAl Viro __poll_t req_events = poll_requested_events(wait);
486c23e0cb8SAl Viro __poll_t res = v4l2_ctrl_poll(file, wait);
487bec2aec5SHans Verkuil
488bec2aec5SHans Verkuil poll_wait(file, &dev->read_queue, wait);
489a9a08845SLinus Torvalds if (dev->rdsstat == 0 && (req_events & (EPOLLIN | EPOLLRDNORM))) {
490cc0d3266SHans Verkuil mutex_lock(&dev->lock);
491cc0d3266SHans Verkuil if (dev->rdsstat == 0)
492cc0d3266SHans Verkuil cadet_start_rds(dev);
493cc0d3266SHans Verkuil mutex_unlock(&dev->lock);
494cc0d3266SHans Verkuil }
495ce0ede2cSHans Verkuil if (cadet_has_rds_data(dev))
496a9a08845SLinus Torvalds res |= EPOLLIN | EPOLLRDNORM;
497b54c97dbSHans Verkuil return res;
4981da177e4SLinus Torvalds }
4991da177e4SLinus Torvalds
5001da177e4SLinus Torvalds
501bec43661SHans Verkuil static const struct v4l2_file_operations cadet_fops = {
5021da177e4SLinus Torvalds .owner = THIS_MODULE,
5031da177e4SLinus Torvalds .open = cadet_open,
5041da177e4SLinus Torvalds .release = cadet_release,
5051da177e4SLinus Torvalds .read = cadet_read,
5061cccee0bSHans Verkuil .unlocked_ioctl = video_ioctl2,
507c0c7fa09SHans J. Koch .poll = cadet_poll,
5081da177e4SLinus Torvalds };
5091da177e4SLinus Torvalds
510a399810cSHans Verkuil static const struct v4l2_ioctl_ops cadet_ioctl_ops = {
511c1c4fd3eSDouglas Landgraf .vidioc_querycap = vidioc_querycap,
512c1c4fd3eSDouglas Landgraf .vidioc_g_tuner = vidioc_g_tuner,
513c1c4fd3eSDouglas Landgraf .vidioc_s_tuner = vidioc_s_tuner,
514c1c4fd3eSDouglas Landgraf .vidioc_g_frequency = vidioc_g_frequency,
515c1c4fd3eSDouglas Landgraf .vidioc_s_frequency = vidioc_s_frequency,
5166652c716SHans Verkuil .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
517b54c97dbSHans Verkuil .vidioc_log_status = v4l2_ctrl_log_status,
518b54c97dbSHans Verkuil .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
519b54c97dbSHans Verkuil .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
520b54c97dbSHans Verkuil };
521b54c97dbSHans Verkuil
522b54c97dbSHans Verkuil static const struct v4l2_ctrl_ops cadet_ctrl_ops = {
523b54c97dbSHans Verkuil .s_ctrl = cadet_s_ctrl,
5241da177e4SLinus Torvalds };
5251da177e4SLinus Torvalds
526044dfc99SBjorn Helgaas #ifdef CONFIG_PNP
527044dfc99SBjorn Helgaas
528db4a8505SArvind Yadav static const struct pnp_device_id cadet_pnp_devices[] = {
5291da177e4SLinus Torvalds /* ADS Cadet AM/FM Radio Card */
5301da177e4SLinus Torvalds {.id = "MSM0c24", .driver_data = 0},
5311da177e4SLinus Torvalds {.id = ""}
5321da177e4SLinus Torvalds };
5331da177e4SLinus Torvalds
5341da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pnp, cadet_pnp_devices);
5351da177e4SLinus Torvalds
cadet_pnp_probe(struct pnp_dev * dev,const struct pnp_device_id * dev_id)5361da177e4SLinus Torvalds static int cadet_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
5371da177e4SLinus Torvalds {
5381da177e4SLinus Torvalds if (!dev)
5391da177e4SLinus Torvalds return -ENODEV;
5401da177e4SLinus Torvalds /* only support one device */
5411da177e4SLinus Torvalds if (io > 0)
5421da177e4SLinus Torvalds return -EBUSY;
5431da177e4SLinus Torvalds
544bec2aec5SHans Verkuil if (!pnp_port_valid(dev, 0))
5451da177e4SLinus Torvalds return -ENODEV;
5461da177e4SLinus Torvalds
5471da177e4SLinus Torvalds io = pnp_port_start(dev, 0);
5481da177e4SLinus Torvalds
549bec2aec5SHans Verkuil printk(KERN_INFO "radio-cadet: PnP reports device at %#x\n", io);
5501da177e4SLinus Torvalds
5511da177e4SLinus Torvalds return io;
5521da177e4SLinus Torvalds }
5531da177e4SLinus Torvalds
5541da177e4SLinus Torvalds static struct pnp_driver cadet_pnp_driver = {
5551da177e4SLinus Torvalds .name = "radio-cadet",
5561da177e4SLinus Torvalds .id_table = cadet_pnp_devices,
5571da177e4SLinus Torvalds .probe = cadet_pnp_probe,
5581da177e4SLinus Torvalds .remove = NULL,
5591da177e4SLinus Torvalds };
5601da177e4SLinus Torvalds
561044dfc99SBjorn Helgaas #else
562044dfc99SBjorn Helgaas static struct pnp_driver cadet_pnp_driver;
563044dfc99SBjorn Helgaas #endif
564044dfc99SBjorn Helgaas
cadet_probe(struct cadet * dev)565bec2aec5SHans Verkuil static void cadet_probe(struct cadet *dev)
5661da177e4SLinus Torvalds {
5671da177e4SLinus Torvalds static int iovals[8] = { 0x330, 0x332, 0x334, 0x336, 0x338, 0x33a, 0x33c, 0x33e };
5681da177e4SLinus Torvalds int i;
5691da177e4SLinus Torvalds
5701da177e4SLinus Torvalds for (i = 0; i < 8; i++) {
571bec2aec5SHans Verkuil dev->io = iovals[i];
572bec2aec5SHans Verkuil if (request_region(dev->io, 2, "cadet-probe")) {
5736652c716SHans Verkuil cadet_setfreq(dev, bands[1].rangelow);
5746652c716SHans Verkuil if (cadet_getfreq(dev) == bands[1].rangelow) {
575bec2aec5SHans Verkuil release_region(dev->io, 2);
576bec2aec5SHans Verkuil return;
5771da177e4SLinus Torvalds }
578bec2aec5SHans Verkuil release_region(dev->io, 2);
5791da177e4SLinus Torvalds }
5801da177e4SLinus Torvalds }
581bec2aec5SHans Verkuil dev->io = -1;
5821da177e4SLinus Torvalds }
5831da177e4SLinus Torvalds
5841da177e4SLinus Torvalds /*
5851da177e4SLinus Torvalds * io should only be set if the user has used something like
5861da177e4SLinus Torvalds * isapnp (the userspace program) to initialize this card for us
5871da177e4SLinus Torvalds */
5881da177e4SLinus Torvalds
cadet_init(void)5891da177e4SLinus Torvalds static int __init cadet_init(void)
5901da177e4SLinus Torvalds {
591bec2aec5SHans Verkuil struct cadet *dev = &cadet_card;
592bec2aec5SHans Verkuil struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
593b54c97dbSHans Verkuil struct v4l2_ctrl_handler *hdl;
594b54c97dbSHans Verkuil int res = -ENODEV;
5951da177e4SLinus Torvalds
596c0decac1SMauro Carvalho Chehab strscpy(v4l2_dev->name, "cadet", sizeof(v4l2_dev->name));
597bec2aec5SHans Verkuil mutex_init(&dev->lock);
598bec2aec5SHans Verkuil
599bec2aec5SHans Verkuil /* If a probe was requested then probe ISAPnP first (safest) */
6001da177e4SLinus Torvalds if (io < 0)
6011da177e4SLinus Torvalds pnp_register_driver(&cadet_pnp_driver);
602bec2aec5SHans Verkuil dev->io = io;
6031da177e4SLinus Torvalds
604bec2aec5SHans Verkuil /* If that fails then probe unsafely if probe is requested */
605bec2aec5SHans Verkuil if (dev->io < 0)
606bec2aec5SHans Verkuil cadet_probe(dev);
6071da177e4SLinus Torvalds
608bec2aec5SHans Verkuil /* Else we bail out */
609bec2aec5SHans Verkuil if (dev->io < 0) {
6101da177e4SLinus Torvalds #ifdef MODULE
611b24c20ccSHans Verkuil v4l2_err(v4l2_dev, "you must set an I/O address with io=0x330, 0x332, 0x334,\n");
612b24c20ccSHans Verkuil v4l2_err(v4l2_dev, "0x336, 0x338, 0x33a, 0x33c or 0x33e\n");
6131da177e4SLinus Torvalds #endif
6141da177e4SLinus Torvalds goto fail;
6151da177e4SLinus Torvalds }
616bec2aec5SHans Verkuil if (!request_region(dev->io, 2, "cadet"))
6171da177e4SLinus Torvalds goto fail;
618bec2aec5SHans Verkuil
619bec2aec5SHans Verkuil res = v4l2_device_register(NULL, v4l2_dev);
620bec2aec5SHans Verkuil if (res < 0) {
621bec2aec5SHans Verkuil release_region(dev->io, 2);
622bec2aec5SHans Verkuil v4l2_err(v4l2_dev, "could not register v4l2_device\n");
6231da177e4SLinus Torvalds goto fail;
6241da177e4SLinus Torvalds }
625bec2aec5SHans Verkuil
626b54c97dbSHans Verkuil hdl = &dev->ctrl_handler;
627b54c97dbSHans Verkuil v4l2_ctrl_handler_init(hdl, 2);
628b54c97dbSHans Verkuil v4l2_ctrl_new_std(hdl, &cadet_ctrl_ops,
629b54c97dbSHans Verkuil V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
630b54c97dbSHans Verkuil v4l2_dev->ctrl_handler = hdl;
631b54c97dbSHans Verkuil if (hdl->error) {
632b54c97dbSHans Verkuil res = hdl->error;
633b54c97dbSHans Verkuil v4l2_err(v4l2_dev, "Could not register controls\n");
634b54c97dbSHans Verkuil goto err_hdl;
635b54c97dbSHans Verkuil }
636b54c97dbSHans Verkuil
6376652c716SHans Verkuil dev->is_fm_band = true;
6386652c716SHans Verkuil dev->curfreq = bands[dev->is_fm_band].rangelow;
6396652c716SHans Verkuil cadet_setfreq(dev, dev->curfreq);
640c0decac1SMauro Carvalho Chehab strscpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
641bec2aec5SHans Verkuil dev->vdev.v4l2_dev = v4l2_dev;
642bec2aec5SHans Verkuil dev->vdev.fops = &cadet_fops;
643bec2aec5SHans Verkuil dev->vdev.ioctl_ops = &cadet_ioctl_ops;
644bec2aec5SHans Verkuil dev->vdev.release = video_device_release_empty;
645b54c97dbSHans Verkuil dev->vdev.lock = &dev->lock;
646e83ce300SHans Verkuil dev->vdev.device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO |
647e83ce300SHans Verkuil V4L2_CAP_READWRITE | V4L2_CAP_RDS_CAPTURE;
648bec2aec5SHans Verkuil video_set_drvdata(&dev->vdev, dev);
649bec2aec5SHans Verkuil
6508ca70804SPeter Senna Tschudin res = video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr);
6518ca70804SPeter Senna Tschudin if (res < 0)
652b54c97dbSHans Verkuil goto err_hdl;
653bec2aec5SHans Verkuil v4l2_info(v4l2_dev, "ADS Cadet Radio Card at 0x%x\n", dev->io);
6541da177e4SLinus Torvalds return 0;
655b54c97dbSHans Verkuil err_hdl:
656b54c97dbSHans Verkuil v4l2_ctrl_handler_free(hdl);
657b54c97dbSHans Verkuil v4l2_device_unregister(v4l2_dev);
658b54c97dbSHans Verkuil release_region(dev->io, 2);
6591da177e4SLinus Torvalds fail:
6601da177e4SLinus Torvalds pnp_unregister_driver(&cadet_pnp_driver);
661b54c97dbSHans Verkuil return res;
6621da177e4SLinus Torvalds }
6631da177e4SLinus Torvalds
cadet_exit(void)664bec2aec5SHans Verkuil static void __exit cadet_exit(void)
6651da177e4SLinus Torvalds {
666bec2aec5SHans Verkuil struct cadet *dev = &cadet_card;
667bec2aec5SHans Verkuil
668bec2aec5SHans Verkuil video_unregister_device(&dev->vdev);
669b54c97dbSHans Verkuil v4l2_ctrl_handler_free(&dev->ctrl_handler);
670bec2aec5SHans Verkuil v4l2_device_unregister(&dev->v4l2_dev);
671cc0d3266SHans Verkuil outb(7, dev->io); /* Mute */
672cc0d3266SHans Verkuil outb(0x00, dev->io + 1);
673bec2aec5SHans Verkuil release_region(dev->io, 2);
6741da177e4SLinus Torvalds pnp_unregister_driver(&cadet_pnp_driver);
6751da177e4SLinus Torvalds }
6761da177e4SLinus Torvalds
6771da177e4SLinus Torvalds module_init(cadet_init);
678bec2aec5SHans Verkuil module_exit(cadet_exit);
6791da177e4SLinus Torvalds
680