root/drivers/media/radio/radio-ma901.c

DEFINITIONS

1. to_ma901radio_dev
2. ma901radio_set_freq
3. ma901radio_set_volume
4. ma901_set_stereo
5. usb_ma901radio_disconnect
6. vidioc_querycap
7. vidioc_g_tuner
8. vidioc_s_tuner
9. vidioc_s_frequency
10. vidioc_g_frequency
11. usb_ma901radio_s_ctrl
12. usb_ma901radio_suspend
13. usb_ma901radio_resume
14. usb_ma901radio_release
15. usb_ma901radio_probe

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Driver for the MasterKit MA901 USB FM radio. This device plugs
   4  * into the USB port and an analog audio input or headphones, so this thing
   5  * only deals with initialization, frequency setting, volume.
   6  *
   7  * Copyright (c) 2012 Alexey Klimov <klimov.linux@gmail.com>
   8  */
   9 
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/input.h>
  15 #include <linux/videodev2.h>
  16 #include <media/v4l2-device.h>
  17 #include <media/v4l2-ioctl.h>
  18 #include <media/v4l2-ctrls.h>
  19 #include <media/v4l2-event.h>
  20 #include <linux/usb.h>
  21 #include <linux/mutex.h>
  22 
  23 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>"
  24 #define DRIVER_DESC "Masterkit MA901 USB FM radio driver"
  25 #define DRIVER_VERSION "0.0.1"
  26 
  27 MODULE_AUTHOR(DRIVER_AUTHOR);
  28 MODULE_DESCRIPTION(DRIVER_DESC);
  29 MODULE_LICENSE("GPL");
  30 MODULE_VERSION(DRIVER_VERSION);
  31 
  32 #define USB_MA901_VENDOR  0x16c0
  33 #define USB_MA901_PRODUCT 0x05df
  34 
  35 /* dev_warn macro with driver name */
  36 #define MA901_DRIVER_NAME "radio-ma901"
  37 #define ma901radio_dev_warn(dev, fmt, arg...)                           \
  38                 dev_warn(dev, MA901_DRIVER_NAME " - " fmt, ##arg)
  39 
  40 #define ma901radio_dev_err(dev, fmt, arg...) \
  41                 dev_err(dev, MA901_DRIVER_NAME " - " fmt, ##arg)
  42 
  43 /* Probably USB_TIMEOUT should be modified in module parameter */
  44 #define BUFFER_LENGTH 8
  45 #define USB_TIMEOUT 500
  46 
  47 #define FREQ_MIN  87.5
  48 #define FREQ_MAX 108.0
  49 #define FREQ_MUL 16000
  50 
  51 #define MA901_VOLUME_MAX 16
  52 #define MA901_VOLUME_MIN 0
  53 
  54 /* Commands that device should understand
  55  * List isn't full and will be updated with implementation of new functions
  56  */
  57 #define MA901_RADIO_SET_FREQ            0x03
  58 #define MA901_RADIO_SET_VOLUME          0x04
  59 #define MA901_RADIO_SET_MONO_STEREO     0x05
  60 
  61 /* Comfortable defines for ma901radio_set_stereo */
  62 #define MA901_WANT_STEREO               0x50
  63 #define MA901_WANT_MONO                 0xd0
  64 
  65 /* module parameter */
  66 static int radio_nr = -1;
  67 module_param(radio_nr, int, 0);
  68 MODULE_PARM_DESC(radio_nr, "Radio file number");
  69 
  70 /* Data for one (physical) device */
  71 struct ma901radio_device {
  72         /* reference to USB and video device */
  73         struct usb_device *usbdev;
  74         struct usb_interface *intf;
  75         struct video_device vdev;
  76         struct v4l2_device v4l2_dev;
  77         struct v4l2_ctrl_handler hdl;
  78 
  79         u8 *buffer;
  80         struct mutex lock;      /* buffer locking */
  81         int curfreq;
  82         u16 volume;
  83         int stereo;
  84         bool muted;
  85 };
  86 
  87 static inline struct ma901radio_device *to_ma901radio_dev(struct v4l2_device *v4l2_dev)
  88 {
  89         return container_of(v4l2_dev, struct ma901radio_device, v4l2_dev);
  90 }
  91 
  92 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
  93 static int ma901radio_set_freq(struct ma901radio_device *radio, int freq)
  94 {
  95         unsigned int freq_send = 0x300 + (freq >> 5) / 25;
  96         int retval;
  97 
  98         radio->buffer[0] = 0x0a;
  99         radio->buffer[1] = MA901_RADIO_SET_FREQ;
 100         radio->buffer[2] = ((freq_send >> 8) & 0xff) + 0x80;
 101         radio->buffer[3] = freq_send & 0xff;
 102         radio->buffer[4] = 0x00;
 103         radio->buffer[5] = 0x00;
 104         radio->buffer[6] = 0x00;
 105         radio->buffer[7] = 0x00;
 106 
 107         retval = usb_control_msg(radio->usbdev, usb_sndctrlpipe(radio->usbdev, 0),
 108                                 9, 0x21, 0x0300, 0,
 109                                 radio->buffer, BUFFER_LENGTH, USB_TIMEOUT);
 110         if (retval < 0)
 111                 return retval;
 112 
 113         radio->curfreq = freq;
 114         return 0;
 115 }
 116 
 117 static int ma901radio_set_volume(struct ma901radio_device *radio, u16 vol_to_set)
 118 {
 119         int retval;
 120 
 121         radio->buffer[0] = 0x0a;
 122         radio->buffer[1] = MA901_RADIO_SET_VOLUME;
 123         radio->buffer[2] = 0xc2;
 124         radio->buffer[3] = vol_to_set + 0x20;
 125         radio->buffer[4] = 0x00;
 126         radio->buffer[5] = 0x00;
 127         radio->buffer[6] = 0x00;
 128         radio->buffer[7] = 0x00;
 129 
 130         retval = usb_control_msg(radio->usbdev, usb_sndctrlpipe(radio->usbdev, 0),
 131                                 9, 0x21, 0x0300, 0,
 132                                 radio->buffer, BUFFER_LENGTH, USB_TIMEOUT);
 133         if (retval < 0)
 134                 return retval;
 135 
 136         radio->volume = vol_to_set;
 137         return retval;
 138 }
 139 
 140 static int ma901_set_stereo(struct ma901radio_device *radio, u8 stereo)
 141 {
 142         int retval;
 143 
 144         radio->buffer[0] = 0x0a;
 145         radio->buffer[1] = MA901_RADIO_SET_MONO_STEREO;
 146         radio->buffer[2] = stereo;
 147         radio->buffer[3] = 0x00;
 148         radio->buffer[4] = 0x00;
 149         radio->buffer[5] = 0x00;
 150         radio->buffer[6] = 0x00;
 151         radio->buffer[7] = 0x00;
 152 
 153         retval = usb_control_msg(radio->usbdev, usb_sndctrlpipe(radio->usbdev, 0),
 154                                 9, 0x21, 0x0300, 0,
 155                                 radio->buffer, BUFFER_LENGTH, USB_TIMEOUT);
 156 
 157         if (retval < 0)
 158                 return retval;
 159 
 160         if (stereo == MA901_WANT_STEREO)
 161                 radio->stereo = V4L2_TUNER_MODE_STEREO;
 162         else
 163                 radio->stereo = V4L2_TUNER_MODE_MONO;
 164 
 165         return retval;
 166 }
 167 
 168 /* Handle unplugging the device.
 169  * We call video_unregister_device in any case.
 170  * The last function called in this procedure is
 171  * usb_ma901radio_device_release.
 172  */
 173 static void usb_ma901radio_disconnect(struct usb_interface *intf)
 174 {
 175         struct ma901radio_device *radio = to_ma901radio_dev(usb_get_intfdata(intf));
 176 
 177         mutex_lock(&radio->lock);
 178         video_unregister_device(&radio->vdev);
 179         usb_set_intfdata(intf, NULL);
 180         v4l2_device_disconnect(&radio->v4l2_dev);
 181         mutex_unlock(&radio->lock);
 182         v4l2_device_put(&radio->v4l2_dev);
 183 }
 184 
 185 /* vidioc_querycap - query device capabilities */
 186 static int vidioc_querycap(struct file *file, void *priv,
 187                                         struct v4l2_capability *v)
 188 {
 189         struct ma901radio_device *radio = video_drvdata(file);
 190 
 191         strscpy(v->driver, "radio-ma901", sizeof(v->driver));
 192         strscpy(v->card, "Masterkit MA901 USB FM Radio", sizeof(v->card));
 193         usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
 194         return 0;
 195 }
 196 
 197 /* vidioc_g_tuner - get tuner attributes */
 198 static int vidioc_g_tuner(struct file *file, void *priv,
 199                                 struct v4l2_tuner *v)
 200 {
 201         struct ma901radio_device *radio = video_drvdata(file);
 202 
 203         if (v->index > 0)
 204                 return -EINVAL;
 205 
 206         v->signal = 0;
 207 
 208         /* TODO: the same words like in _probe() goes here.
 209          * When receiving of stats will be implemented then we can call
 210          * ma901radio_get_stat().
 211          * retval = ma901radio_get_stat(radio, &is_stereo, &v->signal);
 212          */
 213 
 214         strscpy(v->name, "FM", sizeof(v->name));
 215         v->type = V4L2_TUNER_RADIO;
 216         v->rangelow = FREQ_MIN * FREQ_MUL;
 217         v->rangehigh = FREQ_MAX * FREQ_MUL;
 218         v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
 219         /* v->rxsubchans = is_stereo ? V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO; */
 220         v->audmode = radio->stereo ?
 221                 V4L2_TUNER_MODE_STEREO : V4L2_TUNER_MODE_MONO;
 222         return 0;
 223 }
 224 
 225 /* vidioc_s_tuner - set tuner attributes */
 226 static int vidioc_s_tuner(struct file *file, void *priv,
 227                                 const struct v4l2_tuner *v)
 228 {
 229         struct ma901radio_device *radio = video_drvdata(file);
 230 
 231         if (v->index > 0)
 232                 return -EINVAL;
 233 
 234         /* mono/stereo selector */
 235         switch (v->audmode) {
 236         case V4L2_TUNER_MODE_MONO:
 237                 return ma901_set_stereo(radio, MA901_WANT_MONO);
 238         default:
 239                 return ma901_set_stereo(radio, MA901_WANT_STEREO);
 240         }
 241 }
 242 
 243 /* vidioc_s_frequency - set tuner radio frequency */
 244 static int vidioc_s_frequency(struct file *file, void *priv,
 245                                 const struct v4l2_frequency *f)
 246 {
 247         struct ma901radio_device *radio = video_drvdata(file);
 248 
 249         if (f->tuner != 0)
 250                 return -EINVAL;
 251 
 252         return ma901radio_set_freq(radio, clamp_t(unsigned, f->frequency,
 253                                 FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL));
 254 }
 255 
 256 /* vidioc_g_frequency - get tuner radio frequency */
 257 static int vidioc_g_frequency(struct file *file, void *priv,
 258                                 struct v4l2_frequency *f)
 259 {
 260         struct ma901radio_device *radio = video_drvdata(file);
 261 
 262         if (f->tuner != 0)
 263                 return -EINVAL;
 264         f->frequency = radio->curfreq;
 265 
 266         return 0;
 267 }
 268 
 269 static int usb_ma901radio_s_ctrl(struct v4l2_ctrl *ctrl)
 270 {
 271         struct ma901radio_device *radio =
 272                 container_of(ctrl->handler, struct ma901radio_device, hdl);
 273 
 274         switch (ctrl->id) {
 275         case V4L2_CID_AUDIO_VOLUME:     /* set volume */
 276                 return ma901radio_set_volume(radio, (u16)ctrl->val);
 277         }
 278 
 279         return -EINVAL;
 280 }
 281 
 282 /* TODO: Should we really need to implement suspend and resume functions?
 283  * Radio has it's own memory and will continue playing if power is present
 284  * on usb port and on resume it will start to play again based on freq, volume
 285  * values in device memory.
 286  */
 287 static int usb_ma901radio_suspend(struct usb_interface *intf, pm_message_t message)
 288 {
 289         return 0;
 290 }
 291 
 292 static int usb_ma901radio_resume(struct usb_interface *intf)
 293 {
 294         return 0;
 295 }
 296 
 297 static const struct v4l2_ctrl_ops usb_ma901radio_ctrl_ops = {
 298         .s_ctrl = usb_ma901radio_s_ctrl,
 299 };
 300 
 301 /* File system interface */
 302 static const struct v4l2_file_operations usb_ma901radio_fops = {
 303         .owner          = THIS_MODULE,
 304         .open           = v4l2_fh_open,
 305         .release        = v4l2_fh_release,
 306         .poll           = v4l2_ctrl_poll,
 307         .unlocked_ioctl = video_ioctl2,
 308 };
 309 
 310 static const struct v4l2_ioctl_ops usb_ma901radio_ioctl_ops = {
 311         .vidioc_querycap    = vidioc_querycap,
 312         .vidioc_g_tuner     = vidioc_g_tuner,
 313         .vidioc_s_tuner     = vidioc_s_tuner,
 314         .vidioc_g_frequency = vidioc_g_frequency,
 315         .vidioc_s_frequency = vidioc_s_frequency,
 316         .vidioc_log_status  = v4l2_ctrl_log_status,
 317         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 318         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 319 };
 320 
 321 static void usb_ma901radio_release(struct v4l2_device *v4l2_dev)
 322 {
 323         struct ma901radio_device *radio = to_ma901radio_dev(v4l2_dev);
 324 
 325         v4l2_ctrl_handler_free(&radio->hdl);
 326         v4l2_device_unregister(&radio->v4l2_dev);
 327         kfree(radio->buffer);
 328         kfree(radio);
 329 }
 330 
 331 /* check if the device is present and register with v4l and usb if it is */
 332 static int usb_ma901radio_probe(struct usb_interface *intf,
 333                                 const struct usb_device_id *id)
 334 {
 335         struct usb_device *dev = interface_to_usbdev(intf);
 336         struct ma901radio_device *radio;
 337         int retval = 0;
 338 
 339         /* Masterkit MA901 usb radio has the same USB ID as many others
 340          * Atmel V-USB devices. Let's make additional checks to be sure
 341          * that this is our device.
 342          */
 343 
 344         if (dev->product && dev->manufacturer &&
 345                 (strncmp(dev->product, "MA901", 5) != 0
 346                 || strncmp(dev->manufacturer, "www.masterkit.ru", 16) != 0))
 347                 return -ENODEV;
 348 
 349         radio = kzalloc(sizeof(struct ma901radio_device), GFP_KERNEL);
 350         if (!radio) {
 351                 dev_err(&intf->dev, "kzalloc for ma901radio_device failed\n");
 352                 retval = -ENOMEM;
 353                 goto err;
 354         }
 355 
 356         radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL);
 357         if (!radio->buffer) {
 358                 dev_err(&intf->dev, "kmalloc for radio->buffer failed\n");
 359                 retval = -ENOMEM;
 360                 goto err_nobuf;
 361         }
 362 
 363         retval = v4l2_device_register(&intf->dev, &radio->v4l2_dev);
 364         if (retval < 0) {
 365                 dev_err(&intf->dev, "couldn't register v4l2_device\n");
 366                 goto err_v4l2;
 367         }
 368 
 369         v4l2_ctrl_handler_init(&radio->hdl, 1);
 370 
 371         /* TODO:It looks like this radio doesn't have mute/unmute control
 372          * and windows program just emulate it using volume control.
 373          * Let's plan to do the same in this driver.
 374          *
 375          * v4l2_ctrl_new_std(&radio->hdl, &usb_ma901radio_ctrl_ops,
 376          *                V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
 377          */
 378 
 379         v4l2_ctrl_new_std(&radio->hdl, &usb_ma901radio_ctrl_ops,
 380                           V4L2_CID_AUDIO_VOLUME, MA901_VOLUME_MIN,
 381                           MA901_VOLUME_MAX, 1, MA901_VOLUME_MAX);
 382 
 383         if (radio->hdl.error) {
 384                 retval = radio->hdl.error;
 385                 dev_err(&intf->dev, "couldn't register control\n");
 386                 goto err_ctrl;
 387         }
 388         mutex_init(&radio->lock);
 389 
 390         radio->v4l2_dev.ctrl_handler = &radio->hdl;
 391         radio->v4l2_dev.release = usb_ma901radio_release;
 392         strscpy(radio->vdev.name, radio->v4l2_dev.name,
 393                 sizeof(radio->vdev.name));
 394         radio->vdev.v4l2_dev = &radio->v4l2_dev;
 395         radio->vdev.fops = &usb_ma901radio_fops;
 396         radio->vdev.ioctl_ops = &usb_ma901radio_ioctl_ops;
 397         radio->vdev.release = video_device_release_empty;
 398         radio->vdev.lock = &radio->lock;
 399         radio->vdev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
 400 
 401         radio->usbdev = interface_to_usbdev(intf);
 402         radio->intf = intf;
 403         usb_set_intfdata(intf, &radio->v4l2_dev);
 404         radio->curfreq = 95.21 * FREQ_MUL;
 405 
 406         video_set_drvdata(&radio->vdev, radio);
 407 
 408         /* TODO: we can get some statistics (freq, volume) from device
 409          * but it's not implemented yet. After insertion in usb-port radio
 410          * setups frequency and starts playing without any initialization.
 411          * So we don't call usb_ma901radio_init/get_stat() here.
 412          * retval = usb_ma901radio_init(radio);
 413          */
 414 
 415         retval = video_register_device(&radio->vdev, VFL_TYPE_RADIO,
 416                                         radio_nr);
 417         if (retval < 0) {
 418                 dev_err(&intf->dev, "could not register video device\n");
 419                 goto err_vdev;
 420         }
 421 
 422         return 0;
 423 
 424 err_vdev:
 425         v4l2_ctrl_handler_free(&radio->hdl);
 426 err_ctrl:
 427         v4l2_device_unregister(&radio->v4l2_dev);
 428 err_v4l2:
 429         kfree(radio->buffer);
 430 err_nobuf:
 431         kfree(radio);
 432 err:
 433         return retval;
 434 }
 435 
 436 /* USB Device ID List */
 437 static const struct usb_device_id usb_ma901radio_device_table[] = {
 438         { USB_DEVICE_AND_INTERFACE_INFO(USB_MA901_VENDOR, USB_MA901_PRODUCT,
 439                                                         USB_CLASS_HID, 0, 0) },
 440         { }                                             /* Terminating entry */
 441 };
 442 
 443 MODULE_DEVICE_TABLE(usb, usb_ma901radio_device_table);
 444 
 445 /* USB subsystem interface */
 446 static struct usb_driver usb_ma901radio_driver = {
 447         .name                   = MA901_DRIVER_NAME,
 448         .probe                  = usb_ma901radio_probe,
 449         .disconnect             = usb_ma901radio_disconnect,
 450         .suspend                = usb_ma901radio_suspend,
 451         .resume                 = usb_ma901radio_resume,
 452         .reset_resume           = usb_ma901radio_resume,
 453         .id_table               = usb_ma901radio_device_table,
 454 };
 455 
 456 module_usb_driver(usb_ma901radio_driver);