1 /* SF16FMR2 radio driver for Linux radio support 2 * heavily based on fmi driver... 3 * (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com 4 * 5 * Notes on the hardware 6 * 7 * Frequency control is done digitally -- ie out(port,encodefreq(95.8)); 8 * No volume control - only mute/unmute - you have to use line volume 9 * 10 * For read stereo/mono you must wait 0.1 sec after set frequency and 11 * card unmuted so I set frequency on unmute 12 * Signal handling seem to work only on autoscanning (not implemented) 13 * 14 * Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org> 15 */ 16 17 #include <linux/module.h> /* Modules */ 18 #include <linux/init.h> /* Initdata */ 19 #include <linux/ioport.h> /* request_region */ 20 #include <linux/delay.h> /* udelay */ 21 #include <linux/videodev2.h> /* kernel radio structs */ 22 #include <linux/mutex.h> 23 #include <linux/version.h> /* for KERNEL_VERSION MACRO */ 24 #include <linux/io.h> /* outb, outb_p */ 25 #include <media/v4l2-device.h> 26 #include <media/v4l2-ioctl.h> 27 28 MODULE_AUTHOR("Ziglio Frediano, freddy77@angelfire.com"); 29 MODULE_DESCRIPTION("A driver for the SF16FMR2 radio."); 30 MODULE_LICENSE("GPL"); 31 32 static int io = 0x384; 33 static int radio_nr = -1; 34 35 module_param(io, int, 0); 36 MODULE_PARM_DESC(io, "I/O address of the SF16FMR2 card (should be 0x384, if do not work try 0x284)"); 37 module_param(radio_nr, int, 0); 38 39 #define RADIO_VERSION KERNEL_VERSION(0,0,2) 40 41 #define AUD_VOL_INDEX 1 42 43 #undef DEBUG 44 //#define DEBUG 1 45 46 #ifdef DEBUG 47 # define debug_print(s) printk s 48 #else 49 # define debug_print(s) 50 #endif 51 52 /* this should be static vars for module size */ 53 struct fmr2 54 { 55 struct v4l2_device v4l2_dev; 56 struct video_device vdev; 57 struct mutex lock; 58 int io; 59 int curvol; /* 0-15 */ 60 int mute; 61 int stereo; /* card is producing stereo audio */ 62 unsigned long curfreq; /* freq in kHz */ 63 int card_type; 64 u32 flags; 65 }; 66 67 static struct fmr2 fmr2_card; 68 69 /* hw precision is 12.5 kHz 70 * It is only useful to give freq in intervall of 200 (=0.0125Mhz), 71 * other bits will be truncated 72 */ 73 #define RSF16_ENCODE(x) ((x) / 200 + 856) 74 #define RSF16_MINFREQ (87 * 16000) 75 #define RSF16_MAXFREQ (108 * 16000) 76 77 static inline void wait(int n, int io) 78 { 79 for (; n; --n) 80 inb(io); 81 } 82 83 static void outbits(int bits, unsigned int data, int nWait, int io) 84 { 85 int bit; 86 87 for (; --bits >= 0;) { 88 bit = (data >> bits) & 1; 89 outb(bit, io); 90 wait(nWait, io); 91 outb(bit | 2, io); 92 wait(nWait, io); 93 outb(bit, io); 94 wait(nWait, io); 95 } 96 } 97 98 static inline void fmr2_mute(int io) 99 { 100 outb(0x00, io); 101 wait(4, io); 102 } 103 104 static inline void fmr2_unmute(int io) 105 { 106 outb(0x04, io); 107 wait(4, io); 108 } 109 110 static inline int fmr2_stereo_mode(int io) 111 { 112 int n = inb(io); 113 114 outb(6, io); 115 inb(io); 116 n = ((n >> 3) & 1) ^ 1; 117 debug_print((KERN_DEBUG "stereo: %d\n", n)); 118 return n; 119 } 120 121 static int fmr2_product_info(struct fmr2 *dev) 122 { 123 int n = inb(dev->io); 124 125 n &= 0xC1; 126 if (n == 0) { 127 /* this should support volume set */ 128 dev->card_type = 12; 129 return 0; 130 } 131 /* not volume (mine is 11) */ 132 dev->card_type = (n == 128) ? 11 : 0; 133 return n; 134 } 135 136 static inline int fmr2_getsigstr(struct fmr2 *dev) 137 { 138 /* !!! works only if scanning freq */ 139 int res = 0xffff; 140 141 outb(5, dev->io); 142 wait(4, dev->io); 143 if (!(inb(dev->io) & 1)) 144 res = 0; 145 debug_print((KERN_DEBUG "signal: %d\n", res)); 146 return res; 147 } 148 149 /* set frequency and unmute card */ 150 static int fmr2_setfreq(struct fmr2 *dev) 151 { 152 unsigned long freq = dev->curfreq; 153 154 fmr2_mute(dev->io); 155 156 /* 0x42 for mono output 157 * 0x102 forward scanning 158 * 0x182 scansione avanti 159 */ 160 outbits(9, 0x2, 3, dev->io); 161 outbits(16, RSF16_ENCODE(freq), 2, dev->io); 162 163 fmr2_unmute(dev->io); 164 165 /* wait 0.11 sec */ 166 msleep(110); 167 168 /* NOTE if mute this stop radio 169 you must set freq on unmute */ 170 dev->stereo = fmr2_stereo_mode(dev->io); 171 return 0; 172 } 173 174 /* !!! not tested, in my card this does't work !!! */ 175 static int fmr2_setvolume(struct fmr2 *dev) 176 { 177 int vol[16] = { 0x021, 0x084, 0x090, 0x104, 178 0x110, 0x204, 0x210, 0x402, 179 0x404, 0x408, 0x410, 0x801, 180 0x802, 0x804, 0x808, 0x810 }; 181 int i, a; 182 int n = vol[dev->curvol & 0x0f]; 183 184 if (dev->card_type != 11) 185 return 1; 186 187 for (i = 12; --i >= 0; ) { 188 a = ((n >> i) & 1) << 6; /* if (a==0) a = 0; else a = 0x40; */ 189 outb(a | 4, dev->io); 190 wait(4, dev->io); 191 outb(a | 0x24, dev->io); 192 wait(4, dev->io); 193 outb(a | 4, dev->io); 194 wait(4, dev->io); 195 } 196 for (i = 6; --i >= 0; ) { 197 a = ((0x18 >> i) & 1) << 6; 198 outb(a | 4, dev->io); 199 wait(4, dev->io); 200 outb(a | 0x24, dev->io); 201 wait(4, dev->io); 202 outb(a | 4, dev->io); 203 wait(4, dev->io); 204 } 205 wait(4, dev->io); 206 outb(0x14, dev->io); 207 return 0; 208 } 209 210 static int vidioc_querycap(struct file *file, void *priv, 211 struct v4l2_capability *v) 212 { 213 strlcpy(v->driver, "radio-sf16fmr2", sizeof(v->driver)); 214 strlcpy(v->card, "SF16-FMR2 radio", sizeof(v->card)); 215 strlcpy(v->bus_info, "ISA", sizeof(v->bus_info)); 216 v->version = RADIO_VERSION; 217 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO; 218 return 0; 219 } 220 221 static int vidioc_g_tuner(struct file *file, void *priv, 222 struct v4l2_tuner *v) 223 { 224 int mult; 225 struct fmr2 *fmr2 = video_drvdata(file); 226 227 if (v->index > 0) 228 return -EINVAL; 229 230 strlcpy(v->name, "FM", sizeof(v->name)); 231 v->type = V4L2_TUNER_RADIO; 232 233 mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000; 234 v->rangelow = RSF16_MINFREQ / mult; 235 v->rangehigh = RSF16_MAXFREQ / mult; 236 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 237 v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW; 238 v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO: 239 V4L2_TUNER_MODE_MONO; 240 mutex_lock(&fmr2->lock); 241 v->signal = fmr2_getsigstr(fmr2); 242 mutex_unlock(&fmr2->lock); 243 return 0; 244 } 245 246 static int vidioc_s_tuner(struct file *file, void *priv, 247 struct v4l2_tuner *v) 248 { 249 return v->index ? -EINVAL : 0; 250 } 251 252 static int vidioc_s_frequency(struct file *file, void *priv, 253 struct v4l2_frequency *f) 254 { 255 struct fmr2 *fmr2 = video_drvdata(file); 256 257 if (!(fmr2->flags & V4L2_TUNER_CAP_LOW)) 258 f->frequency *= 1000; 259 if (f->frequency < RSF16_MINFREQ || 260 f->frequency > RSF16_MAXFREQ) 261 return -EINVAL; 262 /* rounding in steps of 200 to match the freq 263 that will be used */ 264 fmr2->curfreq = (f->frequency / 200) * 200; 265 266 /* set card freq (if not muted) */ 267 if (fmr2->curvol && !fmr2->mute) { 268 mutex_lock(&fmr2->lock); 269 fmr2_setfreq(fmr2); 270 mutex_unlock(&fmr2->lock); 271 } 272 return 0; 273 } 274 275 static int vidioc_g_frequency(struct file *file, void *priv, 276 struct v4l2_frequency *f) 277 { 278 struct fmr2 *fmr2 = video_drvdata(file); 279 280 f->type = V4L2_TUNER_RADIO; 281 f->frequency = fmr2->curfreq; 282 if (!(fmr2->flags & V4L2_TUNER_CAP_LOW)) 283 f->frequency /= 1000; 284 return 0; 285 } 286 287 static int vidioc_queryctrl(struct file *file, void *priv, 288 struct v4l2_queryctrl *qc) 289 { 290 struct fmr2 *fmr2 = video_drvdata(file); 291 292 switch (qc->id) { 293 case V4L2_CID_AUDIO_MUTE: 294 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1); 295 case V4L2_CID_AUDIO_VOLUME: 296 /* Only card_type == 11 implements volume */ 297 if (fmr2->card_type == 11) 298 return v4l2_ctrl_query_fill(qc, 0, 15, 1, 0); 299 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0); 300 } 301 return -EINVAL; 302 } 303 304 static int vidioc_g_ctrl(struct file *file, void *priv, 305 struct v4l2_control *ctrl) 306 { 307 struct fmr2 *fmr2 = video_drvdata(file); 308 309 switch (ctrl->id) { 310 case V4L2_CID_AUDIO_MUTE: 311 ctrl->value = fmr2->mute; 312 return 0; 313 case V4L2_CID_AUDIO_VOLUME: 314 ctrl->value = fmr2->curvol; 315 return 0; 316 } 317 return -EINVAL; 318 } 319 320 static int vidioc_s_ctrl(struct file *file, void *priv, 321 struct v4l2_control *ctrl) 322 { 323 struct fmr2 *fmr2 = video_drvdata(file); 324 325 switch (ctrl->id) { 326 case V4L2_CID_AUDIO_MUTE: 327 fmr2->mute = ctrl->value; 328 break; 329 case V4L2_CID_AUDIO_VOLUME: 330 fmr2->curvol = ctrl->value; 331 break; 332 default: 333 return -EINVAL; 334 } 335 336 #ifdef DEBUG 337 if (fmr2->curvol && !fmr2->mute) 338 printk(KERN_DEBUG "unmute\n"); 339 else 340 printk(KERN_DEBUG "mute\n"); 341 #endif 342 343 mutex_lock(&fmr2->lock); 344 if (fmr2->curvol && !fmr2->mute) { 345 fmr2_setvolume(fmr2); 346 /* Set frequency and unmute card */ 347 fmr2_setfreq(fmr2); 348 } else 349 fmr2_mute(fmr2->io); 350 mutex_unlock(&fmr2->lock); 351 return 0; 352 } 353 354 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 355 { 356 *i = 0; 357 return 0; 358 } 359 360 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 361 { 362 return i ? -EINVAL : 0; 363 } 364 365 static int vidioc_g_audio(struct file *file, void *priv, 366 struct v4l2_audio *a) 367 { 368 a->index = 0; 369 strlcpy(a->name, "Radio", sizeof(a->name)); 370 a->capability = V4L2_AUDCAP_STEREO; 371 return 0; 372 } 373 374 static int vidioc_s_audio(struct file *file, void *priv, 375 struct v4l2_audio *a) 376 { 377 return a->index ? -EINVAL : 0; 378 } 379 380 static const struct v4l2_file_operations fmr2_fops = { 381 .owner = THIS_MODULE, 382 .ioctl = video_ioctl2, 383 }; 384 385 static const struct v4l2_ioctl_ops fmr2_ioctl_ops = { 386 .vidioc_querycap = vidioc_querycap, 387 .vidioc_g_tuner = vidioc_g_tuner, 388 .vidioc_s_tuner = vidioc_s_tuner, 389 .vidioc_g_audio = vidioc_g_audio, 390 .vidioc_s_audio = vidioc_s_audio, 391 .vidioc_g_input = vidioc_g_input, 392 .vidioc_s_input = vidioc_s_input, 393 .vidioc_g_frequency = vidioc_g_frequency, 394 .vidioc_s_frequency = vidioc_s_frequency, 395 .vidioc_queryctrl = vidioc_queryctrl, 396 .vidioc_g_ctrl = vidioc_g_ctrl, 397 .vidioc_s_ctrl = vidioc_s_ctrl, 398 }; 399 400 static int __init fmr2_init(void) 401 { 402 struct fmr2 *fmr2 = &fmr2_card; 403 struct v4l2_device *v4l2_dev = &fmr2->v4l2_dev; 404 int res; 405 406 strlcpy(v4l2_dev->name, "sf16fmr2", sizeof(v4l2_dev->name)); 407 fmr2->io = io; 408 fmr2->stereo = 1; 409 fmr2->flags = V4L2_TUNER_CAP_LOW; 410 mutex_init(&fmr2->lock); 411 412 if (!request_region(fmr2->io, 2, "sf16fmr2")) { 413 v4l2_err(v4l2_dev, "request_region failed!\n"); 414 return -EBUSY; 415 } 416 417 res = v4l2_device_register(NULL, v4l2_dev); 418 if (res < 0) { 419 release_region(fmr2->io, 2); 420 v4l2_err(v4l2_dev, "Could not register v4l2_device\n"); 421 return res; 422 } 423 424 strlcpy(fmr2->vdev.name, v4l2_dev->name, sizeof(fmr2->vdev.name)); 425 fmr2->vdev.v4l2_dev = v4l2_dev; 426 fmr2->vdev.fops = &fmr2_fops; 427 fmr2->vdev.ioctl_ops = &fmr2_ioctl_ops; 428 fmr2->vdev.release = video_device_release_empty; 429 video_set_drvdata(&fmr2->vdev, fmr2); 430 431 if (video_register_device(&fmr2->vdev, VFL_TYPE_RADIO, radio_nr) < 0) { 432 v4l2_device_unregister(v4l2_dev); 433 release_region(fmr2->io, 2); 434 return -EINVAL; 435 } 436 437 v4l2_info(v4l2_dev, "SF16FMR2 radio card driver at 0x%x.\n", fmr2->io); 438 /* mute card - prevents noisy bootups */ 439 mutex_lock(&fmr2->lock); 440 fmr2_mute(fmr2->io); 441 fmr2_product_info(fmr2); 442 mutex_unlock(&fmr2->lock); 443 debug_print((KERN_DEBUG "card_type %d\n", fmr2->card_type)); 444 return 0; 445 } 446 447 static void __exit fmr2_exit(void) 448 { 449 struct fmr2 *fmr2 = &fmr2_card; 450 451 video_unregister_device(&fmr2->vdev); 452 v4l2_device_unregister(&fmr2->v4l2_dev); 453 release_region(fmr2->io, 2); 454 } 455 456 module_init(fmr2_init); 457 module_exit(fmr2_exit); 458 459 #ifndef MODULE 460 461 static int __init fmr2_setup_io(char *str) 462 { 463 get_option(&str, &io); 464 return 1; 465 } 466 467 __setup("sf16fmr2=", fmr2_setup_io); 468 469 #endif 470