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