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);
457