1 /* 2 * Framework for ISA radio drivers. 3 * This takes care of all the V4L2 scaffolding, allowing the ISA drivers 4 * to concentrate on the actual hardware operation. 5 * 6 * Copyright (C) 2012 Hans Verkuil <hans.verkuil@cisco.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 */ 22 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/ioport.h> 26 #include <linux/delay.h> 27 #include <linux/videodev2.h> 28 #include <linux/io.h> 29 #include <linux/slab.h> 30 #include <media/v4l2-device.h> 31 #include <media/v4l2-ioctl.h> 32 #include <media/v4l2-fh.h> 33 #include <media/v4l2-ctrls.h> 34 #include <media/v4l2-event.h> 35 36 #include "radio-isa.h" 37 38 MODULE_AUTHOR("Hans Verkuil"); 39 MODULE_DESCRIPTION("A framework for ISA radio drivers."); 40 MODULE_LICENSE("GPL"); 41 42 #define FREQ_LOW (87U * 16000U) 43 #define FREQ_HIGH (108U * 16000U) 44 45 static int radio_isa_querycap(struct file *file, void *priv, 46 struct v4l2_capability *v) 47 { 48 struct radio_isa_card *isa = video_drvdata(file); 49 50 strlcpy(v->driver, isa->drv->driver.driver.name, sizeof(v->driver)); 51 strlcpy(v->card, isa->drv->card, sizeof(v->card)); 52 snprintf(v->bus_info, sizeof(v->bus_info), "ISA:%s", isa->v4l2_dev.name); 53 54 v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO; 55 v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS; 56 return 0; 57 } 58 59 static int radio_isa_g_tuner(struct file *file, void *priv, 60 struct v4l2_tuner *v) 61 { 62 struct radio_isa_card *isa = video_drvdata(file); 63 const struct radio_isa_ops *ops = isa->drv->ops; 64 65 if (v->index > 0) 66 return -EINVAL; 67 68 strlcpy(v->name, "FM", sizeof(v->name)); 69 v->type = V4L2_TUNER_RADIO; 70 v->rangelow = FREQ_LOW; 71 v->rangehigh = FREQ_HIGH; 72 v->capability = V4L2_TUNER_CAP_LOW; 73 if (isa->drv->has_stereo) 74 v->capability |= V4L2_TUNER_CAP_STEREO; 75 76 if (ops->g_rxsubchans) 77 v->rxsubchans = ops->g_rxsubchans(isa); 78 else 79 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 80 v->audmode = isa->stereo ? V4L2_TUNER_MODE_STEREO : V4L2_TUNER_MODE_MONO; 81 if (ops->g_signal) 82 v->signal = ops->g_signal(isa); 83 else 84 v->signal = (v->rxsubchans & V4L2_TUNER_SUB_STEREO) ? 85 0xffff : 0; 86 return 0; 87 } 88 89 static int radio_isa_s_tuner(struct file *file, void *priv, 90 const struct v4l2_tuner *v) 91 { 92 struct radio_isa_card *isa = video_drvdata(file); 93 const struct radio_isa_ops *ops = isa->drv->ops; 94 95 if (v->index) 96 return -EINVAL; 97 if (ops->s_stereo) { 98 isa->stereo = (v->audmode == V4L2_TUNER_MODE_STEREO); 99 return ops->s_stereo(isa, isa->stereo); 100 } 101 return 0; 102 } 103 104 static int radio_isa_s_frequency(struct file *file, void *priv, 105 const struct v4l2_frequency *f) 106 { 107 struct radio_isa_card *isa = video_drvdata(file); 108 u32 freq = f->frequency; 109 int res; 110 111 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO) 112 return -EINVAL; 113 freq = clamp(freq, FREQ_LOW, FREQ_HIGH); 114 res = isa->drv->ops->s_frequency(isa, freq); 115 if (res == 0) 116 isa->freq = freq; 117 return res; 118 } 119 120 static int radio_isa_g_frequency(struct file *file, void *priv, 121 struct v4l2_frequency *f) 122 { 123 struct radio_isa_card *isa = video_drvdata(file); 124 125 if (f->tuner != 0) 126 return -EINVAL; 127 f->type = V4L2_TUNER_RADIO; 128 f->frequency = isa->freq; 129 return 0; 130 } 131 132 static int radio_isa_s_ctrl(struct v4l2_ctrl *ctrl) 133 { 134 struct radio_isa_card *isa = 135 container_of(ctrl->handler, struct radio_isa_card, hdl); 136 137 switch (ctrl->id) { 138 case V4L2_CID_AUDIO_MUTE: 139 return isa->drv->ops->s_mute_volume(isa, ctrl->val, 140 isa->volume ? isa->volume->val : 0); 141 } 142 return -EINVAL; 143 } 144 145 static int radio_isa_log_status(struct file *file, void *priv) 146 { 147 struct radio_isa_card *isa = video_drvdata(file); 148 149 v4l2_info(&isa->v4l2_dev, "I/O Port = 0x%03x\n", isa->io); 150 v4l2_ctrl_handler_log_status(&isa->hdl, isa->v4l2_dev.name); 151 return 0; 152 } 153 154 static const struct v4l2_ctrl_ops radio_isa_ctrl_ops = { 155 .s_ctrl = radio_isa_s_ctrl, 156 }; 157 158 static const struct v4l2_file_operations radio_isa_fops = { 159 .owner = THIS_MODULE, 160 .open = v4l2_fh_open, 161 .release = v4l2_fh_release, 162 .poll = v4l2_ctrl_poll, 163 .unlocked_ioctl = video_ioctl2, 164 }; 165 166 static const struct v4l2_ioctl_ops radio_isa_ioctl_ops = { 167 .vidioc_querycap = radio_isa_querycap, 168 .vidioc_g_tuner = radio_isa_g_tuner, 169 .vidioc_s_tuner = radio_isa_s_tuner, 170 .vidioc_g_frequency = radio_isa_g_frequency, 171 .vidioc_s_frequency = radio_isa_s_frequency, 172 .vidioc_log_status = radio_isa_log_status, 173 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 174 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 175 }; 176 177 int radio_isa_match(struct device *pdev, unsigned int dev) 178 { 179 struct radio_isa_driver *drv = pdev->platform_data; 180 181 return drv->probe || drv->io_params[dev] >= 0; 182 } 183 EXPORT_SYMBOL_GPL(radio_isa_match); 184 185 static bool radio_isa_valid_io(const struct radio_isa_driver *drv, int io) 186 { 187 int i; 188 189 for (i = 0; i < drv->num_of_io_ports; i++) 190 if (drv->io_ports[i] == io) 191 return true; 192 return false; 193 } 194 195 static struct radio_isa_card *radio_isa_alloc(struct radio_isa_driver *drv, 196 struct device *pdev) 197 { 198 struct v4l2_device *v4l2_dev; 199 struct radio_isa_card *isa = drv->ops->alloc(); 200 if (!isa) 201 return NULL; 202 203 dev_set_drvdata(pdev, isa); 204 isa->drv = drv; 205 v4l2_dev = &isa->v4l2_dev; 206 strlcpy(v4l2_dev->name, dev_name(pdev), sizeof(v4l2_dev->name)); 207 208 return isa; 209 } 210 211 static int radio_isa_common_probe(struct radio_isa_card *isa, 212 struct device *pdev, 213 int radio_nr, unsigned region_size) 214 { 215 const struct radio_isa_driver *drv = isa->drv; 216 const struct radio_isa_ops *ops = drv->ops; 217 struct v4l2_device *v4l2_dev = &isa->v4l2_dev; 218 int res; 219 220 if (!request_region(isa->io, region_size, v4l2_dev->name)) { 221 v4l2_err(v4l2_dev, "port 0x%x already in use\n", isa->io); 222 kfree(isa); 223 return -EBUSY; 224 } 225 226 res = v4l2_device_register(pdev, v4l2_dev); 227 if (res < 0) { 228 v4l2_err(v4l2_dev, "Could not register v4l2_device\n"); 229 goto err_dev_reg; 230 } 231 232 v4l2_ctrl_handler_init(&isa->hdl, 1); 233 isa->mute = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops, 234 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 235 if (drv->max_volume) 236 isa->volume = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops, 237 V4L2_CID_AUDIO_VOLUME, 0, drv->max_volume, 1, 238 drv->max_volume); 239 v4l2_dev->ctrl_handler = &isa->hdl; 240 if (isa->hdl.error) { 241 res = isa->hdl.error; 242 v4l2_err(v4l2_dev, "Could not register controls\n"); 243 goto err_hdl; 244 } 245 if (drv->max_volume) 246 v4l2_ctrl_cluster(2, &isa->mute); 247 v4l2_dev->ctrl_handler = &isa->hdl; 248 249 mutex_init(&isa->lock); 250 isa->vdev.lock = &isa->lock; 251 strlcpy(isa->vdev.name, v4l2_dev->name, sizeof(isa->vdev.name)); 252 isa->vdev.v4l2_dev = v4l2_dev; 253 isa->vdev.fops = &radio_isa_fops; 254 isa->vdev.ioctl_ops = &radio_isa_ioctl_ops; 255 isa->vdev.release = video_device_release_empty; 256 set_bit(V4L2_FL_USE_FH_PRIO, &isa->vdev.flags); 257 video_set_drvdata(&isa->vdev, isa); 258 isa->freq = FREQ_LOW; 259 isa->stereo = drv->has_stereo; 260 261 if (ops->init) 262 res = ops->init(isa); 263 if (!res) 264 res = v4l2_ctrl_handler_setup(&isa->hdl); 265 if (!res) 266 res = ops->s_frequency(isa, isa->freq); 267 if (!res && ops->s_stereo) 268 res = ops->s_stereo(isa, isa->stereo); 269 if (res < 0) { 270 v4l2_err(v4l2_dev, "Could not setup card\n"); 271 goto err_hdl; 272 } 273 res = video_register_device(&isa->vdev, VFL_TYPE_RADIO, radio_nr); 274 275 if (res < 0) { 276 v4l2_err(v4l2_dev, "Could not register device node\n"); 277 goto err_hdl; 278 } 279 280 v4l2_info(v4l2_dev, "Initialized radio card %s on port 0x%03x\n", 281 drv->card, isa->io); 282 return 0; 283 284 err_hdl: 285 v4l2_ctrl_handler_free(&isa->hdl); 286 err_dev_reg: 287 release_region(isa->io, region_size); 288 kfree(isa); 289 return res; 290 } 291 292 static int radio_isa_common_remove(struct radio_isa_card *isa, 293 unsigned region_size) 294 { 295 const struct radio_isa_ops *ops = isa->drv->ops; 296 297 ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0); 298 video_unregister_device(&isa->vdev); 299 v4l2_ctrl_handler_free(&isa->hdl); 300 v4l2_device_unregister(&isa->v4l2_dev); 301 release_region(isa->io, region_size); 302 v4l2_info(&isa->v4l2_dev, "Removed radio card %s\n", isa->drv->card); 303 kfree(isa); 304 return 0; 305 } 306 307 int radio_isa_probe(struct device *pdev, unsigned int dev) 308 { 309 struct radio_isa_driver *drv = pdev->platform_data; 310 const struct radio_isa_ops *ops = drv->ops; 311 struct v4l2_device *v4l2_dev; 312 struct radio_isa_card *isa; 313 314 isa = radio_isa_alloc(drv, pdev); 315 if (!isa) 316 return -ENOMEM; 317 isa->io = drv->io_params[dev]; 318 v4l2_dev = &isa->v4l2_dev; 319 320 if (drv->probe && ops->probe) { 321 int i; 322 323 for (i = 0; i < drv->num_of_io_ports; ++i) { 324 int io = drv->io_ports[i]; 325 326 if (request_region(io, drv->region_size, v4l2_dev->name)) { 327 bool found = ops->probe(isa, io); 328 329 release_region(io, drv->region_size); 330 if (found) { 331 isa->io = io; 332 break; 333 } 334 } 335 } 336 } 337 338 if (!radio_isa_valid_io(drv, isa->io)) { 339 int i; 340 341 if (isa->io < 0) 342 return -ENODEV; 343 v4l2_err(v4l2_dev, "you must set an I/O address with io=0x%03x", 344 drv->io_ports[0]); 345 for (i = 1; i < drv->num_of_io_ports; i++) 346 printk(KERN_CONT "/0x%03x", drv->io_ports[i]); 347 printk(KERN_CONT ".\n"); 348 kfree(isa); 349 return -EINVAL; 350 } 351 352 return radio_isa_common_probe(isa, pdev, drv->radio_nr_params[dev], 353 drv->region_size); 354 } 355 EXPORT_SYMBOL_GPL(radio_isa_probe); 356 357 int radio_isa_remove(struct device *pdev, unsigned int dev) 358 { 359 struct radio_isa_card *isa = dev_get_drvdata(pdev); 360 361 return radio_isa_common_remove(isa, isa->drv->region_size); 362 } 363 EXPORT_SYMBOL_GPL(radio_isa_remove); 364 365 #ifdef CONFIG_PNP 366 int radio_isa_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id) 367 { 368 struct pnp_driver *pnp_drv = to_pnp_driver(dev->dev.driver); 369 struct radio_isa_driver *drv = container_of(pnp_drv, 370 struct radio_isa_driver, pnp_driver); 371 struct radio_isa_card *isa; 372 373 if (!pnp_port_valid(dev, 0)) 374 return -ENODEV; 375 376 isa = radio_isa_alloc(drv, &dev->dev); 377 if (!isa) 378 return -ENOMEM; 379 380 isa->io = pnp_port_start(dev, 0); 381 382 return radio_isa_common_probe(isa, &dev->dev, drv->radio_nr_params[0], 383 pnp_port_len(dev, 0)); 384 } 385 EXPORT_SYMBOL_GPL(radio_isa_pnp_probe); 386 387 void radio_isa_pnp_remove(struct pnp_dev *dev) 388 { 389 struct radio_isa_card *isa = dev_get_drvdata(&dev->dev); 390 391 radio_isa_common_remove(isa, pnp_port_len(dev, 0)); 392 } 393 EXPORT_SYMBOL_GPL(radio_isa_pnp_remove); 394 #endif 395