Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 1 | /* |
| 2 | * Zoltrix Radio Plus driver |
| 3 | * Copyright 1998 C. van Schaik <carl@leg.uct.ac.za> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
Mauro Carvalho Chehab | 4286c6f | 2006-04-08 16:06:16 -0300 | [diff] [blame] | 5 | * BUGS |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | * Due to the inconsistency in reading from the signal flags |
| 7 | * it is difficult to get an accurate tuned signal. |
| 8 | * |
| 9 | * It seems that the card is not linear to 0 volume. It cuts off |
| 10 | * at a low volume, and it is not possible (at least I have not found) |
| 11 | * to get fine volume control over the low volume range. |
| 12 | * |
| 13 | * Some code derived from code by Romolo Manfredini |
| 14 | * romolo@bicnet.it |
| 15 | * |
| 16 | * 1999-05-06 - (C. van Schaik) |
| 17 | * - Make signal strength and stereo scans |
Mauro Carvalho Chehab | 4286c6f | 2006-04-08 16:06:16 -0300 | [diff] [blame] | 18 | * kinder to cpu while in delay |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | * 1999-01-05 - (C. van Schaik) |
| 20 | * - Changed tuning to 1/160Mhz accuracy |
| 21 | * - Added stereo support |
| 22 | * (card defaults to stereo) |
| 23 | * (can explicitly force mono on the card) |
| 24 | * (can detect if station is in stereo) |
| 25 | * - Added unmute function |
| 26 | * - Reworked ioctl functions |
| 27 | * 2002-07-15 - Fix Stereo typo |
Mauro Carvalho Chehab | 2ab6529 | 2006-08-08 09:10:04 -0300 | [diff] [blame] | 28 | * |
| 29 | * 2006-07-24 - Converted to V4L2 API |
| 30 | * by Mauro Carvalho Chehab <mchehab@infradead.org> |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 31 | * |
| 32 | * Converted to the radio-isa framework by Hans Verkuil <hans.verkuil@cisco.com> |
| 33 | * |
| 34 | * Note that this is the driver for the Zoltrix Radio Plus. |
| 35 | * This driver does not work for the Zoltrix Radio Plus 108 or the |
| 36 | * Zoltrix Radio Plus for Windows. |
| 37 | * |
| 38 | * Fully tested with the Keene USB FM Transmitter and the v4l2-compliance tool. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | */ |
| 40 | |
| 41 | #include <linux/module.h> /* Modules */ |
| 42 | #include <linux/init.h> /* Initdata */ |
Peter Osterlund | fb911ee | 2005-09-13 01:25:15 -0700 | [diff] [blame] | 43 | #include <linux/ioport.h> /* request_region */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | #include <linux/delay.h> /* udelay, msleep */ |
Mauro Carvalho Chehab | 2ab6529 | 2006-08-08 09:10:04 -0300 | [diff] [blame] | 45 | #include <linux/videodev2.h> /* kernel radio structs */ |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 46 | #include <linux/mutex.h> |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 47 | #include <linux/io.h> /* outb, outb_p */ |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 48 | #include <media/v4l2-device.h> |
Hans Verkuil | 35ea11f | 2008-07-20 08:12:02 -0300 | [diff] [blame] | 49 | #include <media/v4l2-ioctl.h> |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 50 | #include "radio-isa.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 52 | MODULE_AUTHOR("C. van Schaik"); |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 53 | MODULE_DESCRIPTION("A driver for the Zoltrix Radio Plus."); |
| 54 | MODULE_LICENSE("GPL"); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 55 | MODULE_VERSION("0.1.99"); |
Mauro Carvalho Chehab | 2ab6529 | 2006-08-08 09:10:04 -0300 | [diff] [blame] | 56 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | #ifndef CONFIG_RADIO_ZOLTRIX_PORT |
| 58 | #define CONFIG_RADIO_ZOLTRIX_PORT -1 |
| 59 | #endif |
| 60 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 61 | #define ZOLTRIX_MAX 2 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 63 | static int io[ZOLTRIX_MAX] = { [0] = CONFIG_RADIO_ZOLTRIX_PORT, |
| 64 | [1 ... (ZOLTRIX_MAX - 1)] = -1 }; |
| 65 | static int radio_nr[ZOLTRIX_MAX] = { [0 ... (ZOLTRIX_MAX - 1)] = -1 }; |
| 66 | |
| 67 | module_param_array(io, int, NULL, 0444); |
| 68 | MODULE_PARM_DESC(io, "I/O addresses of the Zoltrix Radio Plus card (0x20c or 0x30c)"); |
| 69 | module_param_array(radio_nr, int, NULL, 0444); |
| 70 | MODULE_PARM_DESC(radio_nr, "Radio device numbers"); |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 71 | |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 72 | struct zoltrix { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 73 | struct radio_isa_card isa; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | int curvol; |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 75 | bool muted; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | }; |
| 77 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 78 | static struct radio_isa_card *zoltrix_alloc(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 80 | struct zoltrix *zol = kzalloc(sizeof(*zol), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 82 | return zol ? &zol->isa : NULL; |
| 83 | } |
| 84 | |
| 85 | static int zoltrix_s_mute_volume(struct radio_isa_card *isa, bool mute, int vol) |
| 86 | { |
| 87 | struct zoltrix *zol = container_of(isa, struct zoltrix, isa); |
| 88 | |
| 89 | zol->curvol = vol; |
| 90 | zol->muted = mute; |
| 91 | if (mute || vol == 0) { |
| 92 | outb(0, isa->io); |
| 93 | outb(0, isa->io); |
| 94 | inb(isa->io + 3); /* Zoltrix needs to be read to confirm */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | return 0; |
| 96 | } |
| 97 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 98 | outb(vol - 1, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | msleep(10); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 100 | inb(isa->io + 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | return 0; |
| 102 | } |
| 103 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 104 | /* tunes the radio to the desired frequency */ |
| 105 | static int zoltrix_s_frequency(struct radio_isa_card *isa, u32 freq) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 107 | struct zoltrix *zol = container_of(isa, struct zoltrix, isa); |
| 108 | struct v4l2_device *v4l2_dev = &isa->v4l2_dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | unsigned long long bitmask, f, m; |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 110 | bool stereo = isa->stereo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | int i; |
| 112 | |
Alexey Klimov | b4be204 | 2008-10-09 13:46:59 -0300 | [diff] [blame] | 113 | if (freq == 0) { |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 114 | v4l2_warn(v4l2_dev, "cannot set a frequency of 0.\n"); |
Alexey Klimov | b4be204 | 2008-10-09 13:46:59 -0300 | [diff] [blame] | 115 | return -EINVAL; |
| 116 | } |
| 117 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | m = (freq / 160 - 8800) * 2; |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 119 | f = (unsigned long long)m + 0x4d1c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | |
| 121 | bitmask = 0xc480402c10080000ull; |
| 122 | i = 45; |
| 123 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 124 | outb(0, isa->io); |
| 125 | outb(0, isa->io); |
| 126 | inb(isa->io + 3); /* Zoltrix needs to be read to confirm */ |
Mauro Carvalho Chehab | 4286c6f | 2006-04-08 16:06:16 -0300 | [diff] [blame] | 127 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 128 | outb(0x40, isa->io); |
| 129 | outb(0xc0, isa->io); |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 130 | |
| 131 | bitmask = (bitmask ^ ((f & 0xff) << 47) ^ ((f & 0xff00) << 30) ^ (stereo << 31)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | while (i--) { |
| 133 | if ((bitmask & 0x8000000000000000ull) != 0) { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 134 | outb(0x80, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | udelay(50); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 136 | outb(0x00, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | udelay(50); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 138 | outb(0x80, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | udelay(50); |
| 140 | } else { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 141 | outb(0xc0, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | udelay(50); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 143 | outb(0x40, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | udelay(50); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 145 | outb(0xc0, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | udelay(50); |
| 147 | } |
| 148 | bitmask *= 2; |
| 149 | } |
| 150 | /* termination sequence */ |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 151 | outb(0x80, isa->io); |
| 152 | outb(0xc0, isa->io); |
| 153 | outb(0x40, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | udelay(1000); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 155 | inb(isa->io + 2); |
Mauro Carvalho Chehab | 4286c6f | 2006-04-08 16:06:16 -0300 | [diff] [blame] | 156 | udelay(1000); |
| 157 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 158 | return zoltrix_s_mute_volume(isa, zol->muted, zol->curvol); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | /* Get signal strength */ |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 162 | static u32 zoltrix_g_rxsubchans(struct radio_isa_card *isa) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 164 | struct zoltrix *zol = container_of(isa, struct zoltrix, isa); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | int a, b; |
| 166 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 167 | outb(0x00, isa->io); /* This stuff I found to do nothing */ |
| 168 | outb(zol->curvol, isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | msleep(20); |
| 170 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 171 | a = inb(isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | msleep(10); |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 173 | b = inb(isa->io); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 175 | return (a == b && a == 0xcf) ? |
| 176 | V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO; |
| 177 | } |
| 178 | |
| 179 | static u32 zoltrix_g_signal(struct radio_isa_card *isa) |
| 180 | { |
| 181 | struct zoltrix *zol = container_of(isa, struct zoltrix, isa); |
| 182 | int a, b; |
| 183 | |
| 184 | outb(0x00, isa->io); /* This stuff I found to do nothing */ |
| 185 | outb(zol->curvol, isa->io); |
| 186 | msleep(20); |
| 187 | |
| 188 | a = inb(isa->io); |
| 189 | msleep(10); |
| 190 | b = inb(isa->io); |
Mauro Carvalho Chehab | 4286c6f | 2006-04-08 16:06:16 -0300 | [diff] [blame] | 191 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | if (a != b) |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 193 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 195 | /* I found this out by playing with a binary scanner on the card io */ |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 196 | return (a == 0xcf || a == 0xdf || a == 0xef) ? 0xffff : 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 199 | static int zoltrix_s_stereo(struct radio_isa_card *isa, bool stereo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 201 | return zoltrix_s_frequency(isa, isa->freq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | } |
| 203 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 204 | static const struct radio_isa_ops zoltrix_ops = { |
| 205 | .alloc = zoltrix_alloc, |
| 206 | .s_mute_volume = zoltrix_s_mute_volume, |
| 207 | .s_frequency = zoltrix_s_frequency, |
| 208 | .s_stereo = zoltrix_s_stereo, |
| 209 | .g_rxsubchans = zoltrix_g_rxsubchans, |
| 210 | .g_signal = zoltrix_g_signal, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | }; |
| 212 | |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 213 | static const int zoltrix_ioports[] = { 0x20c, 0x30c }; |
| 214 | |
| 215 | static struct radio_isa_driver zoltrix_driver = { |
| 216 | .driver = { |
| 217 | .match = radio_isa_match, |
| 218 | .probe = radio_isa_probe, |
| 219 | .remove = radio_isa_remove, |
| 220 | .driver = { |
| 221 | .name = "radio-zoltrix", |
| 222 | }, |
| 223 | }, |
| 224 | .io_params = io, |
| 225 | .radio_nr_params = radio_nr, |
| 226 | .io_ports = zoltrix_ioports, |
| 227 | .num_of_io_ports = ARRAY_SIZE(zoltrix_ioports), |
| 228 | .region_size = 2, |
| 229 | .card = "Zoltrix Radio Plus", |
| 230 | .ops = &zoltrix_ops, |
| 231 | .has_stereo = true, |
| 232 | .max_volume = 15, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | }; |
| 234 | |
| 235 | static int __init zoltrix_init(void) |
| 236 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 237 | return isa_register_driver(&zoltrix_driver.driver, ZOLTRIX_MAX); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | } |
| 239 | |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 240 | static void __exit zoltrix_exit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | { |
Hans Verkuil | 6b39246cf | 2012-01-16 05:18:40 -0300 | [diff] [blame^] | 242 | isa_unregister_driver(&zoltrix_driver.driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | module_init(zoltrix_init); |
Hans Verkuil | ec632c8 | 2009-03-06 13:55:34 -0300 | [diff] [blame] | 246 | module_exit(zoltrix_exit); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | |