1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2013 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/input.h>
11 #include <linux/usb.h>
12 #include <linux/hid.h>
13 #include <linux/mutex.h>
14 #include <linux/videodev2.h>
15 #include <asm/unaligned.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>
22 * 'Thanko's Raremono' is a Japanese si4734-based AM/FM/SW USB receiver:
24 * http://www.raremono.jp/product/484.html/
26 * The USB protocol has been reversed engineered using wireshark, initially
27 * by Dinesh Ram <dinesh.ram@cern.ch> and finished by Hans Verkuil
28 * <hverkuil@xs4all.nl>.
30 * Sadly the firmware used in this product hides lots of goodies since the
31 * si4734 has more features than are supported by the firmware. Oh well...
34 /* driver and module definitions */
35 MODULE_AUTHOR("Hans Verkuil <hverkuil@xs4all.nl>");
36 MODULE_DESCRIPTION("Thanko's Raremono AM/FM/SW Receiver USB driver");
37 MODULE_LICENSE("GPL v2");
40 * The Device announces itself as Cygnal Integrated Products, Inc.
42 * The vendor and product IDs (and in fact all other lsusb information as
43 * well) are identical to the si470x Silicon Labs USB FM Radio Reference
44 * Design board, even though this card has a si4734 device. Clearly the
45 * designer of this product never bothered to change the USB IDs.
48 /* USB Device ID List */
49 static const struct usb_device_id usb_raremono_device_table
[] = {
50 {USB_DEVICE_AND_INTERFACE_INFO(0x10c4, 0x818a, USB_CLASS_HID
, 0, 0) },
51 { } /* Terminating entry */
54 MODULE_DEVICE_TABLE(usb
, usb_raremono_device_table
);
56 #define BUFFER_LENGTH 64
58 /* Timeout is set to a high value, could probably be reduced. Need more tests */
59 #define USB_TIMEOUT 10000
61 /* Frequency limits in KHz */
62 #define FM_FREQ_RANGE_LOW 64000
63 #define FM_FREQ_RANGE_HIGH 108000
65 #define AM_FREQ_RANGE_LOW 520
66 #define AM_FREQ_RANGE_HIGH 1710
68 #define SW_FREQ_RANGE_LOW 2300
69 #define SW_FREQ_RANGE_HIGH 26100
71 enum { BAND_FM
, BAND_AM
, BAND_SW
};
73 static const struct v4l2_frequency_band bands
[] = {
76 .type
= V4L2_TUNER_RADIO
,
78 .capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_STEREO
|
79 V4L2_TUNER_CAP_FREQ_BANDS
,
80 .rangelow
= FM_FREQ_RANGE_LOW
* 16,
81 .rangehigh
= FM_FREQ_RANGE_HIGH
* 16,
82 .modulation
= V4L2_BAND_MODULATION_FM
,
86 .type
= V4L2_TUNER_RADIO
,
88 .capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_FREQ_BANDS
,
89 .rangelow
= AM_FREQ_RANGE_LOW
* 16,
90 .rangehigh
= AM_FREQ_RANGE_HIGH
* 16,
91 .modulation
= V4L2_BAND_MODULATION_AM
,
95 .type
= V4L2_TUNER_RADIO
,
97 .capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_FREQ_BANDS
,
98 .rangelow
= SW_FREQ_RANGE_LOW
* 16,
99 .rangehigh
= SW_FREQ_RANGE_HIGH
* 16,
100 .modulation
= V4L2_BAND_MODULATION_AM
,
104 struct raremono_device
{
105 struct usb_device
*usbdev
;
106 struct usb_interface
*intf
;
107 struct video_device vdev
;
108 struct v4l2_device v4l2_dev
;
116 static inline struct raremono_device
*to_raremono_dev(struct v4l2_device
*v4l2_dev
)
118 return container_of(v4l2_dev
, struct raremono_device
, v4l2_dev
);
122 static int raremono_cmd_main(struct raremono_device
*radio
, unsigned band
, unsigned freq
)
124 unsigned band_offset
;
139 radio
->buffer
[0] = 0x04 + band_offset
;
140 radio
->buffer
[1] = freq
>> 8;
141 radio
->buffer
[2] = freq
& 0xff;
143 ret
= usb_control_msg(radio
->usbdev
, usb_sndctrlpipe(radio
->usbdev
, 0),
145 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_OUT
,
146 0x0300 + radio
->buffer
[0], 2,
147 radio
->buffer
, 3, USB_TIMEOUT
);
150 dev_warn(radio
->v4l2_dev
.dev
, "%s failed (%d)\n", __func__
, ret
);
153 radio
->curfreq
= (band
== BAND_FM
) ? freq
* 10 : freq
;
157 /* Handle unplugging the device.
158 * We call video_unregister_device in any case.
159 * The last function called in this procedure is
160 * usb_raremono_device_release.
162 static void usb_raremono_disconnect(struct usb_interface
*intf
)
164 struct raremono_device
*radio
= to_raremono_dev(usb_get_intfdata(intf
));
166 dev_info(&intf
->dev
, "Thanko's Raremono disconnected\n");
168 mutex_lock(&radio
->lock
);
169 usb_set_intfdata(intf
, NULL
);
170 video_unregister_device(&radio
->vdev
);
171 v4l2_device_disconnect(&radio
->v4l2_dev
);
172 mutex_unlock(&radio
->lock
);
173 v4l2_device_put(&radio
->v4l2_dev
);
177 * Linux Video interface
179 static int vidioc_querycap(struct file
*file
, void *priv
,
180 struct v4l2_capability
*v
)
182 struct raremono_device
*radio
= video_drvdata(file
);
184 strscpy(v
->driver
, "radio-raremono", sizeof(v
->driver
));
185 strscpy(v
->card
, "Thanko's Raremono", sizeof(v
->card
));
186 usb_make_path(radio
->usbdev
, v
->bus_info
, sizeof(v
->bus_info
));
190 static int vidioc_enum_freq_bands(struct file
*file
, void *priv
,
191 struct v4l2_frequency_band
*band
)
193 if (band
->tuner
!= 0)
196 if (band
->index
>= ARRAY_SIZE(bands
))
199 *band
= bands
[band
->index
];
204 static int vidioc_g_tuner(struct file
*file
, void *priv
,
205 struct v4l2_tuner
*v
)
207 struct raremono_device
*radio
= video_drvdata(file
);
213 strscpy(v
->name
, "AM/FM/SW", sizeof(v
->name
));
214 v
->capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_STEREO
|
215 V4L2_TUNER_CAP_FREQ_BANDS
;
216 v
->rangelow
= AM_FREQ_RANGE_LOW
* 16;
217 v
->rangehigh
= FM_FREQ_RANGE_HIGH
* 16;
218 v
->rxsubchans
= V4L2_TUNER_SUB_STEREO
| V4L2_TUNER_SUB_MONO
;
219 v
->audmode
= (radio
->curfreq
< FM_FREQ_RANGE_LOW
) ?
220 V4L2_TUNER_MODE_MONO
: V4L2_TUNER_MODE_STEREO
;
221 memset(radio
->buffer
, 1, BUFFER_LENGTH
);
222 ret
= usb_control_msg(radio
->usbdev
, usb_rcvctrlpipe(radio
->usbdev
, 0),
223 1, 0xa1, 0x030d, 2, radio
->buffer
, BUFFER_LENGTH
, USB_TIMEOUT
);
226 dev_warn(radio
->v4l2_dev
.dev
, "%s failed (%d)\n", __func__
, ret
);
229 v
->signal
= ((radio
->buffer
[1] & 0xf) << 8 | radio
->buffer
[2]) << 4;
233 static int vidioc_s_tuner(struct file
*file
, void *priv
,
234 const struct v4l2_tuner
*v
)
236 return v
->index
? -EINVAL
: 0;
239 static int vidioc_s_frequency(struct file
*file
, void *priv
,
240 const struct v4l2_frequency
*f
)
242 struct raremono_device
*radio
= video_drvdata(file
);
246 if (f
->tuner
!= 0 || f
->type
!= V4L2_TUNER_RADIO
)
249 if (f
->frequency
>= (FM_FREQ_RANGE_LOW
+ SW_FREQ_RANGE_HIGH
) * 8)
251 else if (f
->frequency
<= (AM_FREQ_RANGE_HIGH
+ SW_FREQ_RANGE_LOW
) * 8)
256 freq
= clamp_t(u32
, f
->frequency
, bands
[band
].rangelow
, bands
[band
].rangehigh
);
257 return raremono_cmd_main(radio
, band
, freq
/ 16);
260 static int vidioc_g_frequency(struct file
*file
, void *priv
,
261 struct v4l2_frequency
*f
)
263 struct raremono_device
*radio
= video_drvdata(file
);
267 f
->type
= V4L2_TUNER_RADIO
;
268 f
->frequency
= radio
->curfreq
* 16;
272 static void raremono_device_release(struct v4l2_device
*v4l2_dev
)
274 struct raremono_device
*radio
= to_raremono_dev(v4l2_dev
);
276 kfree(radio
->buffer
);
280 /* File system interface */
281 static const struct v4l2_file_operations usb_raremono_fops
= {
282 .owner
= THIS_MODULE
,
283 .open
= v4l2_fh_open
,
284 .release
= v4l2_fh_release
,
285 .unlocked_ioctl
= video_ioctl2
,
288 static const struct v4l2_ioctl_ops usb_raremono_ioctl_ops
= {
289 .vidioc_querycap
= vidioc_querycap
,
290 .vidioc_g_tuner
= vidioc_g_tuner
,
291 .vidioc_s_tuner
= vidioc_s_tuner
,
292 .vidioc_g_frequency
= vidioc_g_frequency
,
293 .vidioc_s_frequency
= vidioc_s_frequency
,
294 .vidioc_enum_freq_bands
= vidioc_enum_freq_bands
,
297 /* check if the device is present and register with v4l and usb if it is */
298 static int usb_raremono_probe(struct usb_interface
*intf
,
299 const struct usb_device_id
*id
)
301 struct raremono_device
*radio
;
304 radio
= kzalloc(sizeof(*radio
), GFP_KERNEL
);
307 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
308 if (!radio
->buffer
) {
313 radio
->usbdev
= interface_to_usbdev(intf
);
317 * This device uses the same USB IDs as the si470x SiLabs reference
318 * design. So do an additional check: attempt to read the device ID
319 * from the si470x: the lower 12 bits are 0x0242 for the si470x. The
320 * Raremono always returns 0x0800 (the meaning of that is unknown, but
321 * at least it works).
323 * We use this check to determine which device we are dealing with.
326 retval
= usb_control_msg(radio
->usbdev
,
327 usb_rcvctrlpipe(radio
->usbdev
, 0),
329 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
331 radio
->buffer
, 3, 500);
333 (get_unaligned_be16(&radio
->buffer
[1]) & 0xfff) == 0x0242) {
334 dev_info(&intf
->dev
, "this is not Thanko's Raremono.\n");
339 dev_info(&intf
->dev
, "Thanko's Raremono connected: (%04X:%04X)\n",
340 id
->idVendor
, id
->idProduct
);
342 retval
= v4l2_device_register(&intf
->dev
, &radio
->v4l2_dev
);
344 dev_err(&intf
->dev
, "couldn't register v4l2_device\n");
348 mutex_init(&radio
->lock
);
350 strscpy(radio
->vdev
.name
, radio
->v4l2_dev
.name
,
351 sizeof(radio
->vdev
.name
));
352 radio
->vdev
.v4l2_dev
= &radio
->v4l2_dev
;
353 radio
->vdev
.fops
= &usb_raremono_fops
;
354 radio
->vdev
.ioctl_ops
= &usb_raremono_ioctl_ops
;
355 radio
->vdev
.lock
= &radio
->lock
;
356 radio
->vdev
.release
= video_device_release_empty
;
357 radio
->vdev
.device_caps
= V4L2_CAP_TUNER
| V4L2_CAP_RADIO
;
358 radio
->v4l2_dev
.release
= raremono_device_release
;
360 usb_set_intfdata(intf
, &radio
->v4l2_dev
);
362 video_set_drvdata(&radio
->vdev
, radio
);
364 raremono_cmd_main(radio
, BAND_FM
, 95160);
366 retval
= video_register_device(&radio
->vdev
, VFL_TYPE_RADIO
, -1);
368 dev_info(&intf
->dev
, "V4L2 device registered as %s\n",
369 video_device_node_name(&radio
->vdev
));
372 dev_err(&intf
->dev
, "could not register video device\n");
373 v4l2_device_unregister(&radio
->v4l2_dev
);
376 kfree(radio
->buffer
);
381 /* USB subsystem interface */
382 static struct usb_driver usb_raremono_driver
= {
383 .name
= "radio-raremono",
384 .probe
= usb_raremono_probe
,
385 .disconnect
= usb_raremono_disconnect
,
386 .id_table
= usb_raremono_device_table
,
389 module_usb_driver(usb_raremono_driver
);