1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Driver for the Texas Instruments WL1273 FM radio.
4	*
5	* Copyright (C) 2011 Nokia Corporation
6	* Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com>
7	*/
8
9	#include <linux/delay.h>
10	#include <linux/firmware.h>
11	#include <linux/interrupt.h>
12	#include <linux/mfd/wl1273-core.h>
13	#include <linux/slab.h>
14	#include <linux/module.h>
15	#include <media/v4l2-common.h>
16	#include <media/v4l2-ctrls.h>
17	#include <media/v4l2-device.h>
18	#include <media/v4l2-ioctl.h>
19
20	#define DRIVER_DESC "Wl1273 FM Radio"
21
22	#define WL1273_POWER_SET_OFF 0
23	#define WL1273_POWER_SET_FM BIT(0)
24	#define WL1273_POWER_SET_RDS BIT(1)
25	#define WL1273_POWER_SET_RETENTION BIT(4)
26
27	#define WL1273_PUPD_SET_OFF 0x00
28	#define WL1273_PUPD_SET_ON 0x01
29	#define WL1273_PUPD_SET_RETENTION 0x10
30
31	#define WL1273_FREQ(x) (x * 10000 / 625)
32	#define WL1273_INV_FREQ(x) (x * 625 / 10000)
33
34	/*
35	* static int radio_nr - The number of the radio device
36	*
37	* The default is 0.
38	*/
39	static int radio_nr;
40	module_param(radio_nr, int, 0);
41	MODULE_PARM_DESC(radio_nr, "The number of the radio device. Default = 0");
42
43	struct wl1273_device {
44	char *bus_type;
45
46	u8 forbidden;
47	unsigned int preemphasis;
48	unsigned int spacing;
49	unsigned int tx_power;
50	unsigned int rx_frequency;
51	unsigned int tx_frequency;
52	unsigned int rangelow;
53	unsigned int rangehigh;
54	unsigned int band;
55	bool stereo;
56
57	/* RDS */
58	unsigned int rds_on;
59
60	wait_queue_head_t read_queue;
61	struct mutex lock; /* for serializing fm radio operations */
62	struct completion busy;
63
64	unsigned char *buffer;
65	unsigned int buf_size;
66	unsigned int rd_index;
67	unsigned int wr_index;
68
69	/* Selected interrupts */
70	u16 irq_flags;
71	u16 irq_received;
72
73	struct v4l2_ctrl_handler ctrl_handler;
74	struct v4l2_device v4l2dev;
75	struct video_device videodev;
76	struct device *dev;
77	struct wl1273_core *core;
78	struct file *owner;
79	char *write_buf;
80	unsigned int rds_users;
81	};
82
83	#define WL1273_IRQ_MASK (WL1273_FR_EVENT | \
84	WL1273_POW_ENB_EVENT)
85
86	/*
87	* static unsigned int rds_buf - the number of RDS buffer blocks used.
88	*
89	* The default number is 100.
90	*/
91	static unsigned int rds_buf = 100;
92	module_param(rds_buf, uint, 0);
93	MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100");
94
95	static int wl1273_fm_write_fw(struct wl1273_core *core,
96	__u8 *fw, int len)
97	{
98	struct i2c_client *client = core->client;
99	struct i2c_msg msg;
100	int i, r = 0;
101
102	msg.addr = client->addr;
103	msg.flags = 0;
104
105	for (i = 0; i <= len; i++) {
106	msg.len = fw[0];
107	msg.buf = fw + 1;
108
109	fw += msg.len + 1;
110	dev_dbg(&client->dev, "%s:len[%d]: %d\n", __func__, i, msg.len);
111
112	r = i2c_transfer(adap: client->adapter, msgs: &msg, num: 1);
113	if (r < 0 && i < len + 1)
114	break;
115	}
116
117	dev_dbg(&client->dev, "%s: i: %d\n", __func__, i);
118	dev_dbg(&client->dev, "%s: len + 1: %d\n", __func__, len + 1);
119
120	/* Last transfer always fails. */
121	if (i == len || r == 1)
122	r = 0;
123
124	return r;
125	}
126
127	#define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status)
128	#define WL1273_RDS_CORRECTABLE_ERROR (1 << 3)
129	#define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4)
130
131	static int wl1273_fm_rds(struct wl1273_device *radio)
132	{
133	struct wl1273_core *core = radio->core;
134	struct i2c_client *client = core->client;
135	u16 val;
136	u8 b0 = WL1273_RDS_DATA_GET, status;
137	struct v4l2_rds_data rds = { 0, 0, 0 };
138	struct i2c_msg msg[] = {
139	{
140	.addr = client->addr,
141	.flags = 0,
142	.buf = &b0,
143	.len = 1,
144	},
145	{
146	.addr = client->addr,
147	.flags = I2C_M_RD,
148	.buf = (u8 *) &rds,
149	.len = sizeof(rds),
150	}
151	};
152	int r;
153
154	if (core->mode != WL1273_MODE_RX)
155	return 0;
156
157	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
158	if (r)
159	return r;
160
161	if ((val & 0x01) == 0) {
162	/* RDS decoder not synchronized */
163	return -EAGAIN;
164	}
165
166	/* copy all four RDS blocks to internal buffer */
167	do {
168	r = i2c_transfer(adap: client->adapter, msgs: msg, ARRAY_SIZE(msg));
169	if (r != ARRAY_SIZE(msg)) {
170	dev_err(radio->dev, WL1273_FM_DRIVER_NAME
171	": %s: read_rds error r == %i)\n",
172	__func__, r);
173	}
174
175	status = rds.block;
176
177	if (!WL1273_FIFO_HAS_DATA(status))
178	break;
179
180	/* copy bits 0-2 (the block ID) to bits 3-5 */
181	rds.block = V4L2_RDS_BLOCK_MSK & status;
182	rds.block |= rds.block << 3;
183
184	/* copy the error bits to standard positions */
185	if (WL1273_RDS_UNCORRECTABLE_ERROR & status) {
186	rds.block |= V4L2_RDS_BLOCK_ERROR;
187	rds.block &= ~V4L2_RDS_BLOCK_CORRECTED;
188	} else if (WL1273_RDS_CORRECTABLE_ERROR & status) {
189	rds.block &= ~V4L2_RDS_BLOCK_ERROR;
190	rds.block |= V4L2_RDS_BLOCK_CORRECTED;
191	}
192
193	/* copy RDS block to internal buffer */
194	memcpy(&radio->buffer[radio->wr_index], &rds, RDS_BLOCK_SIZE);
195	radio->wr_index += 3;
196
197	/* wrap write pointer */
198	if (radio->wr_index >= radio->buf_size)
199	radio->wr_index = 0;
200
201	/* check for overflow & start over */
202	if (radio->wr_index == radio->rd_index) {
203	dev_dbg(radio->dev, "RDS OVERFLOW");
204
205	radio->rd_index = 0;
206	radio->wr_index = 0;
207	break;
208	}
209	} while (WL1273_FIFO_HAS_DATA(status));
210
211	/* wake up read queue */
212	if (radio->wr_index != radio->rd_index)
213	wake_up_interruptible(&radio->read_queue);
214
215	return 0;
216	}
217
218	static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id)
219	{
220	struct wl1273_device *radio = dev_id;
221	struct wl1273_core *core = radio->core;
222	u16 flags;
223	int r;
224
225	r = core->read(core, WL1273_FLAG_GET, &flags);
226	if (r)
227	goto out;
228
229	if (flags & WL1273_BL_EVENT) {
230	radio->irq_received = flags;
231	dev_dbg(radio->dev, "IRQ: BL\n");
232	}
233
234	if (flags & WL1273_RDS_EVENT) {
235	msleep(msecs: 200);
236
237	wl1273_fm_rds(radio);
238	}
239
240	if (flags & WL1273_BBLK_EVENT)
241	dev_dbg(radio->dev, "IRQ: BBLK\n");
242
243	if (flags & WL1273_LSYNC_EVENT)
244	dev_dbg(radio->dev, "IRQ: LSYNC\n");
245
246	if (flags & WL1273_LEV_EVENT) {
247	u16 level;
248
249	r = core->read(core, WL1273_RSSI_LVL_GET, &level);
250	if (r)
251	goto out;
252
253	if (level > 14)
254	dev_dbg(radio->dev, "IRQ: LEV: 0x%x04\n", level);
255	}
256
257	if (flags & WL1273_IFFR_EVENT)
258	dev_dbg(radio->dev, "IRQ: IFFR\n");
259
260	if (flags & WL1273_PI_EVENT)
261	dev_dbg(radio->dev, "IRQ: PI\n");
262
263	if (flags & WL1273_PD_EVENT)
264	dev_dbg(radio->dev, "IRQ: PD\n");
265
266	if (flags & WL1273_STIC_EVENT)
267	dev_dbg(radio->dev, "IRQ: STIC\n");
268
269	if (flags & WL1273_MAL_EVENT)
270	dev_dbg(radio->dev, "IRQ: MAL\n");
271
272	if (flags & WL1273_POW_ENB_EVENT) {
273	complete(&radio->busy);
274	dev_dbg(radio->dev, "NOT BUSY\n");
275	dev_dbg(radio->dev, "IRQ: POW_ENB\n");
276	}
277
278	if (flags & WL1273_SCAN_OVER_EVENT)
279	dev_dbg(radio->dev, "IRQ: SCAN_OVER\n");
280
281	if (flags & WL1273_ERROR_EVENT)
282	dev_dbg(radio->dev, "IRQ: ERROR\n");
283
284	if (flags & WL1273_FR_EVENT) {
285	u16 freq;
286
287	dev_dbg(radio->dev, "IRQ: FR:\n");
288
289	if (core->mode == WL1273_MODE_RX) {
290	r = core->write(core, WL1273_TUNER_MODE_SET,
291	TUNER_MODE_STOP_SEARCH);
292	if (r) {
293	dev_err(radio->dev,
294	"%s: TUNER_MODE_SET fails: %d\n",
295	__func__, r);
296	goto out;
297	}
298
299	r = core->read(core, WL1273_FREQ_SET, &freq);
300	if (r)
301	goto out;
302
303	if (radio->band == WL1273_BAND_JAPAN)
304	radio->rx_frequency = WL1273_BAND_JAPAN_LOW +
305	freq * 50;
306	else
307	radio->rx_frequency = WL1273_BAND_OTHER_LOW +
308	freq * 50;
309	/*
310	* The driver works better with this msleep,
311	* the documentation doesn't mention it.
312	*/
313	usleep_range(min: 10000, max: 15000);
314
315	dev_dbg(radio->dev, "%dkHz\n", radio->rx_frequency);
316
317	} else {
318	r = core->read(core, WL1273_CHANL_SET, &freq);
319	if (r)
320	goto out;
321
322	dev_dbg(radio->dev, "%dkHz\n", freq);
323	}
324	dev_dbg(radio->dev, "%s: NOT BUSY\n", __func__);
325	}
326
327	out:
328	core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
329	complete(&radio->busy);
330
331	return IRQ_HANDLED;
332	}
333
334	static int wl1273_fm_set_tx_freq(struct wl1273_device *radio, unsigned int freq)
335	{
336	struct wl1273_core *core = radio->core;
337	int r = 0;
338	unsigned long t;
339
340	if (freq < WL1273_BAND_TX_LOW) {
341	dev_err(radio->dev,
342	"Frequency out of range: %d < %d\n", freq,
343	WL1273_BAND_TX_LOW);
344	return -ERANGE;
345	}
346
347	if (freq > WL1273_BAND_TX_HIGH) {
348	dev_err(radio->dev,
349	"Frequency out of range: %d > %d\n", freq,
350	WL1273_BAND_TX_HIGH);
351	return -ERANGE;
352	}
353
354	/*
355	* The driver works better with this sleep,
356	* the documentation doesn't mention it.
357	*/
358	usleep_range(min: 5000, max: 10000);
359
360	dev_dbg(radio->dev, "%s: freq: %d kHz\n", __func__, freq);
361
362	/* Set the current tx channel */
363	r = core->write(core, WL1273_CHANL_SET, freq / 10);
364	if (r)
365	return r;
366
367	reinit_completion(x: &radio->busy);
368
369	/* wait for the FR IRQ */
370	t = wait_for_completion_timeout(x: &radio->busy, timeout: msecs_to_jiffies(m: 2000));
371	if (!t)
372	return -ETIMEDOUT;
373
374	dev_dbg(radio->dev, "WL1273_CHANL_SET: %lu\n", t);
375
376	/* Enable the output power */
377	r = core->write(core, WL1273_POWER_ENB_SET, 1);
378	if (r)
379	return r;
380
381	reinit_completion(x: &radio->busy);
382
383	/* wait for the POWER_ENB IRQ */
384	t = wait_for_completion_timeout(x: &radio->busy, timeout: msecs_to_jiffies(m: 1000));
385	if (!t)
386	return -ETIMEDOUT;
387
388	radio->tx_frequency = freq;
389	dev_dbg(radio->dev, "WL1273_POWER_ENB_SET: %lu\n", t);
390
391	return 0;
392	}
393
394	static int wl1273_fm_set_rx_freq(struct wl1273_device *radio, unsigned int freq)
395	{
396	struct wl1273_core *core = radio->core;
397	int r, f;
398	unsigned long t;
399
400	if (freq < radio->rangelow) {
401	dev_err(radio->dev,
402	"Frequency out of range: %d < %d\n", freq,
403	radio->rangelow);
404	r = -ERANGE;
405	goto err;
406	}
407
408	if (freq > radio->rangehigh) {
409	dev_err(radio->dev,
410	"Frequency out of range: %d > %d\n", freq,
411	radio->rangehigh);
412	r = -ERANGE;
413	goto err;
414	}
415
416	dev_dbg(radio->dev, "%s: %dkHz\n", __func__, freq);
417
418	core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
419
420	if (radio->band == WL1273_BAND_JAPAN)
421	f = (freq - WL1273_BAND_JAPAN_LOW) / 50;
422	else
423	f = (freq - WL1273_BAND_OTHER_LOW) / 50;
424
425	r = core->write(core, WL1273_FREQ_SET, f);
426	if (r) {
427	dev_err(radio->dev, "FREQ_SET fails\n");
428	goto err;
429	}
430
431	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET);
432	if (r) {
433	dev_err(radio->dev, "TUNER_MODE_SET fails\n");
434	goto err;
435	}
436
437	reinit_completion(x: &radio->busy);
438
439	t = wait_for_completion_timeout(x: &radio->busy, timeout: msecs_to_jiffies(m: 2000));
440	if (!t) {
441	dev_err(radio->dev, "%s: TIMEOUT\n", __func__);
442	return -ETIMEDOUT;
443	}
444
445	radio->rd_index = 0;
446	radio->wr_index = 0;
447	radio->rx_frequency = freq;
448	return 0;
449	err:
450	return r;
451	}
452
453	static int wl1273_fm_get_freq(struct wl1273_device *radio)
454	{
455	struct wl1273_core *core = radio->core;
456	unsigned int freq;
457	u16 f;
458	int r;
459
460	if (core->mode == WL1273_MODE_RX) {
461	r = core->read(core, WL1273_FREQ_SET, &f);
462	if (r)
463	return r;
464
465	dev_dbg(radio->dev, "Freq get: 0x%04x\n", f);
466	if (radio->band == WL1273_BAND_JAPAN)
467	freq = WL1273_BAND_JAPAN_LOW + 50 * f;
468	else
469	freq = WL1273_BAND_OTHER_LOW + 50 * f;
470	} else {
471	r = core->read(core, WL1273_CHANL_SET, &f);
472	if (r)
473	return r;
474
475	freq = f * 10;
476	}
477
478	return freq;
479	}
480
481	/**
482	* wl1273_fm_upload_firmware_patch() - Upload the firmware.
483	* @radio: A pointer to the device struct.
484	*
485	* The firmware file consists of arrays of bytes where the first byte
486	* gives the array length. The first byte in the file gives the
487	* number of these arrays.
488	*/
489	static int wl1273_fm_upload_firmware_patch(struct wl1273_device *radio)
490	{
491	struct wl1273_core *core = radio->core;
492	unsigned int packet_num;
493	const struct firmware *fw_p;
494	const char *fw_name = "radio-wl1273-fw.bin";
495	struct device *dev = radio->dev;
496	__u8 *ptr;
497	int r;
498
499	dev_dbg(dev, "%s:\n", __func__);
500
501	/*
502	* Uploading the firmware patch is not always necessary,
503	* so we only print an info message.
504	*/
505	if (request_firmware(fw: &fw_p, name: fw_name, device: dev)) {
506	dev_info(dev, "%s - %s not found\n", __func__, fw_name);
507
508	return 0;
509	}
510
511	ptr = (__u8 *) fw_p->data;
512	packet_num = ptr[0];
513	dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num);
514
515	r = wl1273_fm_write_fw(core, fw: ptr + 1, len: packet_num);
516	if (r) {
517	dev_err(dev, "FW upload error: %d\n", r);
518	goto out;
519	}
520
521	/* ignore possible error here */
522	core->write(core, WL1273_RESET, 0);
523
524	dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r);
525	out:
526	release_firmware(fw: fw_p);
527	return r;
528	}
529
530	static int wl1273_fm_stop(struct wl1273_device *radio)
531	{
532	struct wl1273_core *core = radio->core;
533
534	if (core->mode == WL1273_MODE_RX) {
535	int r = core->write(core, WL1273_POWER_SET,
536	WL1273_POWER_SET_OFF);
537	if (r)
538	dev_err(radio->dev, "%s: POWER_SET fails: %d\n",
539	__func__, r);
540	} else if (core->mode == WL1273_MODE_TX) {
541	int r = core->write(core, WL1273_PUPD_SET,
542	WL1273_PUPD_SET_OFF);
543	if (r)
544	dev_err(radio->dev,
545	"%s: PUPD_SET fails: %d\n", __func__, r);
546	}
547
548	if (core->pdata->disable) {
549	core->pdata->disable();
550	dev_dbg(radio->dev, "Back to reset\n");
551	}
552
553	return 0;
554	}
555
556	static int wl1273_fm_start(struct wl1273_device *radio, int new_mode)
557	{
558	struct wl1273_core *core = radio->core;
559	struct wl1273_fm_platform_data *pdata = core->pdata;
560	struct device *dev = radio->dev;
561	int r = -EINVAL;
562
563	if (pdata->enable && core->mode == WL1273_MODE_OFF) {
564	dev_dbg(radio->dev, "Out of reset\n");
565
566	pdata->enable();
567	msleep(msecs: 250);
568	}
569
570	if (new_mode == WL1273_MODE_RX) {
571	u16 val = WL1273_POWER_SET_FM;
572
573	if (radio->rds_on)
574	val |= WL1273_POWER_SET_RDS;
575
576	/* If this fails try again */
577	r = core->write(core, WL1273_POWER_SET, val);
578	if (r) {
579	msleep(msecs: 100);
580
581	r = core->write(core, WL1273_POWER_SET, val);
582	if (r) {
583	dev_err(dev, "%s: POWER_SET fails\n", __func__);
584	goto fail;
585	}
586	}
587
588	/* rds buffer configuration */
589	radio->wr_index = 0;
590	radio->rd_index = 0;
591
592	} else if (new_mode == WL1273_MODE_TX) {
593	/* If this fails try again once */
594	r = core->write(core, WL1273_PUPD_SET, WL1273_PUPD_SET_ON);
595	if (r) {
596	msleep(msecs: 100);
597	r = core->write(core, WL1273_PUPD_SET,
598	WL1273_PUPD_SET_ON);
599	if (r) {
600	dev_err(dev, "%s: PUPD_SET fails\n", __func__);
601	goto fail;
602	}
603	}
604
605	if (radio->rds_on) {
606	r = core->write(core, WL1273_RDS_DATA_ENB, 1);
607	if (r) {
608	dev_err(dev, "%s: RDS_DATA_ENB ON fails\n",
609	__func__);
610	goto fail;
611	}
612	} else {
613	r = core->write(core, WL1273_RDS_DATA_ENB, 0);
614	if (r) {
615	dev_err(dev, "%s: RDS_DATA_ENB OFF fails\n",
616	__func__);
617	goto fail;
618	}
619	}
620	} else {
621	dev_warn(dev, "%s: Illegal mode.\n", __func__);
622	}
623
624	if (core->mode == WL1273_MODE_OFF) {
625	r = wl1273_fm_upload_firmware_patch(radio);
626	if (r)
627	dev_warn(dev, "Firmware upload failed.\n");
628
629	/*
630	* Sometimes the chip is in a wrong power state at this point.
631	* So we set the power once again.
632	*/
633	if (new_mode == WL1273_MODE_RX) {
634	u16 val = WL1273_POWER_SET_FM;
635
636	if (radio->rds_on)
637	val |= WL1273_POWER_SET_RDS;
638
639	r = core->write(core, WL1273_POWER_SET, val);
640	if (r) {
641	dev_err(dev, "%s: POWER_SET fails\n", __func__);
642	goto fail;
643	}
644	} else if (new_mode == WL1273_MODE_TX) {
645	r = core->write(core, WL1273_PUPD_SET,
646	WL1273_PUPD_SET_ON);
647	if (r) {
648	dev_err(dev, "%s: PUPD_SET fails\n", __func__);
649	goto fail;
650	}
651	}
652	}
653
654	return 0;
655	fail:
656	if (pdata->disable)
657	pdata->disable();
658
659	dev_dbg(dev, "%s: return: %d\n", __func__, r);
660	return r;
661	}
662
663	static int wl1273_fm_suspend(struct wl1273_device *radio)
664	{
665	struct wl1273_core *core = radio->core;
666	int r;
667
668	/* Cannot go from OFF to SUSPENDED */
669	if (core->mode == WL1273_MODE_RX)
670	r = core->write(core, WL1273_POWER_SET,
671	WL1273_POWER_SET_RETENTION);
672	else if (core->mode == WL1273_MODE_TX)
673	r = core->write(core, WL1273_PUPD_SET,
674	WL1273_PUPD_SET_RETENTION);
675	else
676	r = -EINVAL;
677
678	if (r) {
679	dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r);
680	goto out;
681	}
682
683	out:
684	return r;
685	}
686
687	static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode)
688	{
689	struct wl1273_core *core = radio->core;
690	struct device *dev = radio->dev;
691	int old_mode;
692	int r;
693
694	dev_dbg(dev, "%s\n", __func__);
695	dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden);
696
697	old_mode = core->mode;
698	if (mode & radio->forbidden) {
699	r = -EPERM;
700	goto out;
701	}
702
703	switch (mode) {
704	case WL1273_MODE_RX:
705	case WL1273_MODE_TX:
706	r = wl1273_fm_start(radio, new_mode: mode);
707	if (r) {
708	dev_err(dev, "%s: Cannot start.\n", __func__);
709	wl1273_fm_stop(radio);
710	goto out;
711	}
712
713	core->mode = mode;
714	r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
715	if (r) {
716	dev_err(dev, "INT_MASK_SET fails.\n");
717	goto out;
718	}
719
720	/* remember previous settings */
721	if (mode == WL1273_MODE_RX) {
722	r = wl1273_fm_set_rx_freq(radio, freq: radio->rx_frequency);
723	if (r) {
724	dev_err(dev, "set freq fails: %d.\n", r);
725	goto out;
726	}
727
728	r = core->set_volume(core, core->volume);
729	if (r) {
730	dev_err(dev, "set volume fails: %d.\n", r);
731	goto out;
732	}
733
734	dev_dbg(dev, "%s: Set vol: %d.\n", __func__,
735	core->volume);
736	} else {
737	r = wl1273_fm_set_tx_freq(radio, freq: radio->tx_frequency);
738	if (r) {
739	dev_err(dev, "set freq fails: %d.\n", r);
740	goto out;
741	}
742	}
743
744	dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__);
745
746	r = core->set_audio(core, core->audio_mode);
747	if (r)
748	dev_err(dev, "Cannot set audio mode.\n");
749	break;
750
751	case WL1273_MODE_OFF:
752	r = wl1273_fm_stop(radio);
753	if (r)
754	dev_err(dev, "%s: Off fails: %d\n", __func__, r);
755	else
756	core->mode = WL1273_MODE_OFF;
757
758	break;
759
760	case WL1273_MODE_SUSPENDED:
761	r = wl1273_fm_suspend(radio);
762	if (r)
763	dev_err(dev, "%s: Suspend fails: %d\n", __func__, r);
764	else
765	core->mode = WL1273_MODE_SUSPENDED;
766
767	break;
768
769	default:
770	dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode);
771	r = -EINVAL;
772	break;
773	}
774	out:
775	if (r)
776	core->mode = old_mode;
777
778	return r;
779	}
780
781	static int wl1273_fm_set_seek(struct wl1273_device *radio,
782	unsigned int wrap_around,
783	unsigned int seek_upward,
784	int level)
785	{
786	struct wl1273_core *core = radio->core;
787	int r = 0;
788	unsigned int dir = (seek_upward == 0) ? 0 : 1;
789	unsigned int f;
790
791	f = radio->rx_frequency;
792	dev_dbg(radio->dev, "rx_frequency: %d\n", f);
793
794	if (dir && f + radio->spacing <= radio->rangehigh)
795	r = wl1273_fm_set_rx_freq(radio, freq: f + radio->spacing);
796	else if (dir && wrap_around)
797	r = wl1273_fm_set_rx_freq(radio, freq: radio->rangelow);
798	else if (f - radio->spacing >= radio->rangelow)
799	r = wl1273_fm_set_rx_freq(radio, freq: f - radio->spacing);
800	else if (wrap_around)
801	r = wl1273_fm_set_rx_freq(radio, freq: radio->rangehigh);
802
803	if (r)
804	goto out;
805
806	if (level < SCHAR_MIN || level > SCHAR_MAX)
807	return -EINVAL;
808
809	reinit_completion(x: &radio->busy);
810	dev_dbg(radio->dev, "%s: BUSY\n", __func__);
811
812	r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
813	if (r)
814	goto out;
815
816	dev_dbg(radio->dev, "%s\n", __func__);
817
818	r = core->write(core, WL1273_SEARCH_LVL_SET, level);
819	if (r)
820	goto out;
821
822	r = core->write(core, WL1273_SEARCH_DIR_SET, dir);
823	if (r)
824	goto out;
825
826	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
827	if (r)
828	goto out;
829
830	/* wait for the FR IRQ */
831	wait_for_completion_timeout(x: &radio->busy, timeout: msecs_to_jiffies(m: 1000));
832	if (!(radio->irq_received & WL1273_BL_EVENT)) {
833	r = -ETIMEDOUT;
834	goto out;
835	}
836
837	radio->irq_received &= ~WL1273_BL_EVENT;
838
839	if (!wrap_around)
840	goto out;
841
842	/* Wrap around */
843	dev_dbg(radio->dev, "Wrap around in HW seek.\n");
844
845	if (seek_upward)
846	f = radio->rangelow;
847	else
848	f = radio->rangehigh;
849
850	r = wl1273_fm_set_rx_freq(radio, freq: f);
851	if (r)
852	goto out;
853
854	reinit_completion(x: &radio->busy);
855	dev_dbg(radio->dev, "%s: BUSY\n", __func__);
856
857	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
858	if (r)
859	goto out;
860
861	/* wait for the FR IRQ */
862	if (!wait_for_completion_timeout(x: &radio->busy, timeout: msecs_to_jiffies(m: 1000)))
863	r = -ETIMEDOUT;
864	out:
865	dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r);
866	return r;
867	}
868
869	/**
870	* wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value.
871	* @radio: A pointer to the device struct.
872	*/
873	static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio)
874	{
875	struct wl1273_core *core = radio->core;
876	struct device *dev = radio->dev;
877	u16 val;
878	int r;
879
880	if (core->mode == WL1273_MODE_OFF ||
881	core->mode == WL1273_MODE_SUSPENDED)
882	return -EPERM;
883
884	r = core->read(core, WL1273_READ_FMANT_TUNE_VALUE, &val);
885	if (r) {
886	dev_err(dev, "%s: read error: %d\n", __func__, r);
887	goto out;
888	}
889
890	out:
891	return val;
892	}
893
894	/**
895	* wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
896	* @radio: A pointer to the device struct.
897	* @preemphasis: The new pre-amphasis value.
898	*
899	* Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
900	* V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
901	*/
902	static int wl1273_fm_set_preemphasis(struct wl1273_device *radio,
903	unsigned int preemphasis)
904	{
905	struct wl1273_core *core = radio->core;
906	int r;
907	u16 em;
908
909	if (core->mode == WL1273_MODE_OFF ||
910	core->mode == WL1273_MODE_SUSPENDED)
911	return -EPERM;
912
913	mutex_lock(&core->lock);
914
915	switch (preemphasis) {
916	case V4L2_PREEMPHASIS_DISABLED:
917	em = 1;
918	break;
919	case V4L2_PREEMPHASIS_50_uS:
920	em = 0;
921	break;
922	case V4L2_PREEMPHASIS_75_uS:
923	em = 2;
924	break;
925	default:
926	r = -EINVAL;
927	goto out;
928	}
929
930	r = core->write(core, WL1273_PREMPH_SET, em);
931	if (r)
932	goto out;
933
934	radio->preemphasis = preemphasis;
935
936	out:
937	mutex_unlock(lock: &core->lock);
938	return r;
939	}
940
941	static int wl1273_fm_rds_on(struct wl1273_device *radio)
942	{
943	struct wl1273_core *core = radio->core;
944	int r;
945
946	dev_dbg(radio->dev, "%s\n", __func__);
947	if (radio->rds_on)
948	return 0;
949
950	r = core->write(core, WL1273_POWER_SET,
951	WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS);
952	if (r)
953	goto out;
954
955	r = wl1273_fm_set_rx_freq(radio, freq: radio->rx_frequency);
956	if (r)
957	dev_err(radio->dev, "set freq fails: %d.\n", r);
958	out:
959	return r;
960	}
961
962	static int wl1273_fm_rds_off(struct wl1273_device *radio)
963	{
964	struct wl1273_core *core = radio->core;
965	int r;
966
967	if (!radio->rds_on)
968	return 0;
969
970	radio->irq_flags &= ~WL1273_RDS_EVENT;
971
972	r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
973	if (r)
974	goto out;
975
976	/* Service pending read */
977	wake_up_interruptible(&radio->read_queue);
978
979	dev_dbg(radio->dev, "%s\n", __func__);
980
981	r = core->write(core, WL1273_POWER_SET, WL1273_POWER_SET_FM);
982	if (r)
983	goto out;
984
985	r = wl1273_fm_set_rx_freq(radio, freq: radio->rx_frequency);
986	if (r)
987	dev_err(radio->dev, "set freq fails: %d.\n", r);
988	out:
989	dev_dbg(radio->dev, "%s: exiting...\n", __func__);
990
991	return r;
992	}
993
994	static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode)
995	{
996	int r = 0;
997	struct wl1273_core *core = radio->core;
998
999	if (core->mode == WL1273_MODE_OFF ||
1000	core->mode == WL1273_MODE_SUSPENDED)
1001	return -EPERM;
1002
1003	if (new_mode == WL1273_RDS_RESET) {
1004	r = core->write(core, WL1273_RDS_CNTRL_SET, 1);
1005	return r;
1006	}
1007
1008	if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) {
1009	r = core->write(core, WL1273_RDS_DATA_ENB, 0);
1010	} else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) {
1011	r = core->write(core, WL1273_RDS_DATA_ENB, 1);
1012	} else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) {
1013	r = wl1273_fm_rds_off(radio);
1014	} else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) {
1015	r = wl1273_fm_rds_on(radio);
1016	} else {
1017	dev_err(radio->dev, "%s: Unknown mode: %d\n",
1018	__func__, new_mode);
1019	r = -EINVAL;
1020	}
1021
1022	if (!r)
1023	radio->rds_on = new_mode == WL1273_RDS_ON;
1024
1025	return r;
1026	}
1027
1028	static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf,
1029	size_t count, loff_t *ppos)
1030	{
1031	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1032	struct wl1273_core *core = radio->core;
1033	u16 val;
1034	int r;
1035
1036	dev_dbg(radio->dev, "%s\n", __func__);
1037
1038	if (core->mode != WL1273_MODE_TX)
1039	return count;
1040
1041	if (radio->rds_users == 0) {
1042	dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1043	return 0;
1044	}
1045
1046	if (mutex_lock_interruptible(&core->lock))
1047	return -EINTR;
1048	/*
1049	* Multiple processes can open the device, but only
1050	* one gets to write to it.
1051	*/
1052	if (radio->owner && radio->owner != file) {
1053	r = -EBUSY;
1054	goto out;
1055	}
1056	radio->owner = file;
1057
1058	/* Manual Mode */
1059	if (count > 255)
1060	val = 255;
1061	else
1062	val = count;
1063
1064	core->write(core, WL1273_RDS_CONFIG_DATA_SET, val);
1065
1066	if (copy_from_user(to: radio->write_buf + 1, from: buf, n: val)) {
1067	r = -EFAULT;
1068	goto out;
1069	}
1070
1071	dev_dbg(radio->dev, "Count: %d\n", val);
1072	dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf);
1073
1074	radio->write_buf[0] = WL1273_RDS_DATA_SET;
1075	core->write_data(core, radio->write_buf, val + 1);
1076
1077	r = val;
1078	out:
1079	mutex_unlock(lock: &core->lock);
1080
1081	return r;
1082	}
1083
1084	static __poll_t wl1273_fm_fops_poll(struct file *file,
1085	struct poll_table_struct *pts)
1086	{
1087	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1088	struct wl1273_core *core = radio->core;
1089
1090	if (radio->owner && radio->owner != file)
1091	return EPOLLERR;
1092
1093	radio->owner = file;
1094
1095	if (core->mode == WL1273_MODE_RX) {
1096	poll_wait(filp: file, wait_address: &radio->read_queue, p: pts);
1097
1098	if (radio->rd_index != radio->wr_index)
1099	return EPOLLIN | EPOLLRDNORM;
1100
1101	} else if (core->mode == WL1273_MODE_TX) {
1102	return EPOLLOUT | EPOLLWRNORM;
1103	}
1104
1105	return 0;
1106	}
1107
1108	static int wl1273_fm_fops_open(struct file *file)
1109	{
1110	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1111	struct wl1273_core *core = radio->core;
1112	int r = 0;
1113
1114	dev_dbg(radio->dev, "%s\n", __func__);
1115
1116	if (core->mode == WL1273_MODE_RX && radio->rds_on &&
1117	!radio->rds_users) {
1118	dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode);
1119
1120	if (mutex_lock_interruptible(&core->lock))
1121	return -EINTR;
1122
1123	radio->irq_flags |= WL1273_RDS_EVENT;
1124
1125	r = core->write(core, WL1273_INT_MASK_SET,
1126	radio->irq_flags);
1127	if (r) {
1128	mutex_unlock(lock: &core->lock);
1129	goto out;
1130	}
1131
1132	radio->rds_users++;
1133
1134	mutex_unlock(lock: &core->lock);
1135	}
1136	out:
1137	return r;
1138	}
1139
1140	static int wl1273_fm_fops_release(struct file *file)
1141	{
1142	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1143	struct wl1273_core *core = radio->core;
1144	int r = 0;
1145
1146	dev_dbg(radio->dev, "%s\n", __func__);
1147
1148	if (radio->rds_users > 0) {
1149	radio->rds_users--;
1150	if (radio->rds_users == 0) {
1151	mutex_lock(&core->lock);
1152
1153	radio->irq_flags &= ~WL1273_RDS_EVENT;
1154
1155	if (core->mode == WL1273_MODE_RX) {
1156	r = core->write(core,
1157	WL1273_INT_MASK_SET,
1158	radio->irq_flags);
1159	if (r) {
1160	mutex_unlock(lock: &core->lock);
1161	goto out;
1162	}
1163	}
1164	mutex_unlock(lock: &core->lock);
1165	}
1166	}
1167
1168	if (file == radio->owner)
1169	radio->owner = NULL;
1170	out:
1171	return r;
1172	}
1173
1174	static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf,
1175	size_t count, loff_t *ppos)
1176	{
1177	int r = 0;
1178	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1179	struct wl1273_core *core = radio->core;
1180	unsigned int block_count = 0;
1181	u16 val;
1182
1183	dev_dbg(radio->dev, "%s\n", __func__);
1184
1185	if (core->mode != WL1273_MODE_RX)
1186	return 0;
1187
1188	if (radio->rds_users == 0) {
1189	dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1190	return 0;
1191	}
1192
1193	if (mutex_lock_interruptible(&core->lock))
1194	return -EINTR;
1195
1196	/*
1197	* Multiple processes can open the device, but only
1198	* one at a time gets read access.
1199	*/
1200	if (radio->owner && radio->owner != file) {
1201	r = -EBUSY;
1202	goto out;
1203	}
1204	radio->owner = file;
1205
1206	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1207	if (r) {
1208	dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__);
1209	goto out;
1210	} else if (val == 0) {
1211	dev_info(radio->dev, "RDS_SYNC: Not synchronized\n");
1212	r = -ENODATA;
1213	goto out;
1214	}
1215
1216	/* block if no new data available */
1217	while (radio->wr_index == radio->rd_index) {
1218	if (file->f_flags & O_NONBLOCK) {
1219	r = -EWOULDBLOCK;
1220	goto out;
1221	}
1222
1223	dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__);
1224	if (wait_event_interruptible(radio->read_queue,
1225	radio->wr_index !=
1226	radio->rd_index) < 0) {
1227	r = -EINTR;
1228	goto out;
1229	}
1230	}
1231
1232	/* calculate block count from byte count */
1233	count /= RDS_BLOCK_SIZE;
1234
1235	/* copy RDS blocks from the internal buffer and to user buffer */
1236	while (block_count < count) {
1237	if (radio->rd_index == radio->wr_index)
1238	break;
1239
1240	/* always transfer complete RDS blocks */
1241	if (copy_to_user(to: buf, from: &radio->buffer[radio->rd_index],
1242	RDS_BLOCK_SIZE))
1243	break;
1244
1245	/* increment and wrap the read pointer */
1246	radio->rd_index += RDS_BLOCK_SIZE;
1247	if (radio->rd_index >= radio->buf_size)
1248	radio->rd_index = 0;
1249
1250	/* increment counters */
1251	block_count++;
1252	buf += RDS_BLOCK_SIZE;
1253	r += RDS_BLOCK_SIZE;
1254	}
1255
1256	out:
1257	dev_dbg(radio->dev, "%s: exit\n", __func__);
1258	mutex_unlock(lock: &core->lock);
1259
1260	return r;
1261	}
1262
1263	static const struct v4l2_file_operations wl1273_fops = {
1264	.owner = THIS_MODULE,
1265	.read = wl1273_fm_fops_read,
1266	.write = wl1273_fm_fops_write,
1267	.poll = wl1273_fm_fops_poll,
1268	.unlocked_ioctl = video_ioctl2,
1269	.open = wl1273_fm_fops_open,
1270	.release = wl1273_fm_fops_release,
1271	};
1272
1273	static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
1274	struct v4l2_capability *capability)
1275	{
1276	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1277
1278	dev_dbg(radio->dev, "%s\n", __func__);
1279
1280	strscpy(capability->driver, WL1273_FM_DRIVER_NAME,
1281	sizeof(capability->driver));
1282	strscpy(capability->card, "TI Wl1273 FM Radio",
1283	sizeof(capability->card));
1284	strscpy(capability->bus_info, radio->bus_type,
1285	sizeof(capability->bus_info));
1286	return 0;
1287	}
1288
1289	static int wl1273_fm_vidioc_g_input(struct file *file, void *priv,
1290	unsigned int *i)
1291	{
1292	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1293
1294	dev_dbg(radio->dev, "%s\n", __func__);
1295
1296	*i = 0;
1297
1298	return 0;
1299	}
1300
1301	static int wl1273_fm_vidioc_s_input(struct file *file, void *priv,
1302	unsigned int i)
1303	{
1304	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1305
1306	dev_dbg(radio->dev, "%s\n", __func__);
1307
1308	if (i != 0)
1309	return -EINVAL;
1310
1311	return 0;
1312	}
1313
1314	/**
1315	* wl1273_fm_set_tx_power() - Set the transmission power value.
1316	* @radio: A pointer to the device struct.
1317	* @power: The new power value.
1318	*/
1319	static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power)
1320	{
1321	struct wl1273_core *core = radio->core;
1322	int r;
1323
1324	if (core->mode == WL1273_MODE_OFF ||
1325	core->mode == WL1273_MODE_SUSPENDED)
1326	return -EPERM;
1327
1328	mutex_lock(&core->lock);
1329
1330	/* Convert the dBuV value to chip presentation */
1331	r = core->write(core, WL1273_POWER_LEV_SET, 122 - power);
1332	if (r)
1333	goto out;
1334
1335	radio->tx_power = power;
1336
1337	out:
1338	mutex_unlock(lock: &core->lock);
1339	return r;
1340	}
1341
1342	#define WL1273_SPACING_50kHz 1
1343	#define WL1273_SPACING_100kHz 2
1344	#define WL1273_SPACING_200kHz 4
1345
1346	static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio,
1347	unsigned int spacing)
1348	{
1349	struct wl1273_core *core = radio->core;
1350	int r;
1351
1352	if (spacing == 0) {
1353	r = core->write(core, WL1273_SCAN_SPACING_SET,
1354	WL1273_SPACING_100kHz);
1355	radio->spacing = 100;
1356	} else if (spacing - 50000 < 25000) {
1357	r = core->write(core, WL1273_SCAN_SPACING_SET,
1358	WL1273_SPACING_50kHz);
1359	radio->spacing = 50;
1360	} else if (spacing - 100000 < 50000) {
1361	r = core->write(core, WL1273_SCAN_SPACING_SET,
1362	WL1273_SPACING_100kHz);
1363	radio->spacing = 100;
1364	} else {
1365	r = core->write(core, WL1273_SCAN_SPACING_SET,
1366	WL1273_SPACING_200kHz);
1367	radio->spacing = 200;
1368	}
1369
1370	return r;
1371	}
1372
1373	static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1374	{
1375	struct wl1273_device *radio = ctrl->priv;
1376	struct wl1273_core *core = radio->core;
1377
1378	dev_dbg(radio->dev, "%s\n", __func__);
1379
1380	if (mutex_lock_interruptible(&core->lock))
1381	return -EINTR;
1382
1383	switch (ctrl->id) {
1384	case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1385	ctrl->val = wl1273_fm_get_tx_ctune(radio);
1386	break;
1387
1388	default:
1389	dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1390	__func__, ctrl->id);
1391	break;
1392	}
1393
1394	mutex_unlock(lock: &core->lock);
1395
1396	return 0;
1397	}
1398
1399	#define WL1273_MUTE_SOFT_ENABLE (1 << 0)
1400	#define WL1273_MUTE_AC (1 << 1)
1401	#define WL1273_MUTE_HARD_LEFT (1 << 2)
1402	#define WL1273_MUTE_HARD_RIGHT (1 << 3)
1403	#define WL1273_MUTE_SOFT_FORCE (1 << 4)
1404
1405	static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
1406	{
1407	return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
1408	}
1409
1410	static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl)
1411	{
1412	struct wl1273_device *radio = to_radio(ctrl);
1413	struct wl1273_core *core = radio->core;
1414	int r = 0;
1415
1416	dev_dbg(radio->dev, "%s\n", __func__);
1417
1418	switch (ctrl->id) {
1419	case V4L2_CID_AUDIO_MUTE:
1420	if (mutex_lock_interruptible(&core->lock))
1421	return -EINTR;
1422
1423	if (core->mode == WL1273_MODE_RX && ctrl->val)
1424	r = core->write(core,
1425	WL1273_MUTE_STATUS_SET,
1426	WL1273_MUTE_HARD_LEFT |
1427	WL1273_MUTE_HARD_RIGHT);
1428	else if (core->mode == WL1273_MODE_RX)
1429	r = core->write(core,
1430	WL1273_MUTE_STATUS_SET, 0x0);
1431	else if (core->mode == WL1273_MODE_TX && ctrl->val)
1432	r = core->write(core, WL1273_MUTE, 1);
1433	else if (core->mode == WL1273_MODE_TX)
1434	r = core->write(core, WL1273_MUTE, 0);
1435
1436	mutex_unlock(lock: &core->lock);
1437	break;
1438
1439	case V4L2_CID_AUDIO_VOLUME:
1440	if (ctrl->val == 0)
1441	r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF);
1442	else
1443	r = core->set_volume(core, core->volume);
1444	break;
1445
1446	case V4L2_CID_TUNE_PREEMPHASIS:
1447	r = wl1273_fm_set_preemphasis(radio, preemphasis: ctrl->val);
1448	break;
1449
1450	case V4L2_CID_TUNE_POWER_LEVEL:
1451	r = wl1273_fm_set_tx_power(radio, power: ctrl->val);
1452	break;
1453
1454	default:
1455	dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1456	__func__, ctrl->id);
1457	break;
1458	}
1459
1460	dev_dbg(radio->dev, "%s\n", __func__);
1461	return r;
1462	}
1463
1464	static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv,
1465	struct v4l2_audio *audio)
1466	{
1467	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1468
1469	dev_dbg(radio->dev, "%s\n", __func__);
1470
1471	if (audio->index > 1)
1472	return -EINVAL;
1473
1474	strscpy(audio->name, "Radio", sizeof(audio->name));
1475	audio->capability = V4L2_AUDCAP_STEREO;
1476
1477	return 0;
1478	}
1479
1480	static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv,
1481	const struct v4l2_audio *audio)
1482	{
1483	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1484
1485	dev_dbg(radio->dev, "%s\n", __func__);
1486
1487	if (audio->index != 0)
1488	return -EINVAL;
1489
1490	return 0;
1491	}
1492
1493	#define WL1273_RDS_NOT_SYNCHRONIZED 0
1494	#define WL1273_RDS_SYNCHRONIZED 1
1495
1496	static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv,
1497	struct v4l2_tuner *tuner)
1498	{
1499	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1500	struct wl1273_core *core = radio->core;
1501	u16 val;
1502	int r;
1503
1504	dev_dbg(radio->dev, "%s\n", __func__);
1505
1506	if (tuner->index > 0)
1507	return -EINVAL;
1508
1509	strscpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name));
1510	tuner->type = V4L2_TUNER_RADIO;
1511
1512	tuner->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1513	tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1514
1515	tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1516	V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO |
1517	V4L2_TUNER_CAP_HWSEEK_BOUNDED | V4L2_TUNER_CAP_HWSEEK_WRAP;
1518
1519	if (radio->stereo)
1520	tuner->audmode = V4L2_TUNER_MODE_STEREO;
1521	else
1522	tuner->audmode = V4L2_TUNER_MODE_MONO;
1523
1524	if (core->mode != WL1273_MODE_RX)
1525	return 0;
1526
1527	if (mutex_lock_interruptible(&core->lock))
1528	return -EINTR;
1529
1530	r = core->read(core, WL1273_STEREO_GET, &val);
1531	if (r)
1532	goto out;
1533
1534	if (val == 1)
1535	tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
1536	else
1537	tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
1538
1539	r = core->read(core, WL1273_RSSI_LVL_GET, &val);
1540	if (r)
1541	goto out;
1542
1543	tuner->signal = (s16) val;
1544	dev_dbg(radio->dev, "Signal: %d\n", tuner->signal);
1545
1546	tuner->afc = 0;
1547
1548	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1549	if (r)
1550	goto out;
1551
1552	if (val == WL1273_RDS_SYNCHRONIZED)
1553	tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
1554	out:
1555	mutex_unlock(lock: &core->lock);
1556
1557	return r;
1558	}
1559
1560	static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv,
1561	const struct v4l2_tuner *tuner)
1562	{
1563	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1564	struct wl1273_core *core = radio->core;
1565	int r = 0;
1566
1567	dev_dbg(radio->dev, "%s\n", __func__);
1568	dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index);
1569	dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name);
1570	dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability);
1571	dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans);
1572	dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow);
1573	dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh);
1574
1575	if (tuner->index > 0)
1576	return -EINVAL;
1577
1578	if (mutex_lock_interruptible(&core->lock))
1579	return -EINTR;
1580
1581	r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1582	if (r)
1583	goto out;
1584
1585	if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS)
1586	r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1587	else
1588	r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1589
1590	if (r)
1591	dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r);
1592
1593	if (tuner->audmode == V4L2_TUNER_MODE_MONO) {
1594	r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_MONO);
1595	if (r < 0) {
1596	dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1597	__func__, r);
1598	goto out;
1599	}
1600	radio->stereo = false;
1601	} else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) {
1602	r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_STEREO);
1603	if (r < 0) {
1604	dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1605	__func__, r);
1606	goto out;
1607	}
1608	radio->stereo = true;
1609	} else {
1610	dev_err(radio->dev, "%s: tuner->audmode: %d\n",
1611	__func__, tuner->audmode);
1612	r = -EINVAL;
1613	goto out;
1614	}
1615
1616	out:
1617	mutex_unlock(lock: &core->lock);
1618
1619	return r;
1620	}
1621
1622	static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv,
1623	struct v4l2_frequency *freq)
1624	{
1625	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1626	struct wl1273_core *core = radio->core;
1627
1628	dev_dbg(radio->dev, "%s\n", __func__);
1629
1630	if (mutex_lock_interruptible(&core->lock))
1631	return -EINTR;
1632
1633	freq->type = V4L2_TUNER_RADIO;
1634	freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio));
1635
1636	mutex_unlock(lock: &core->lock);
1637
1638	return 0;
1639	}
1640
1641	static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv,
1642	const struct v4l2_frequency *freq)
1643	{
1644	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1645	struct wl1273_core *core = radio->core;
1646	int r;
1647
1648	dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency);
1649
1650	if (freq->type != V4L2_TUNER_RADIO) {
1651	dev_dbg(radio->dev,
1652	"freq->type != V4L2_TUNER_RADIO: %d\n", freq->type);
1653	return -EINVAL;
1654	}
1655
1656	if (mutex_lock_interruptible(&core->lock))
1657	return -EINTR;
1658
1659	if (core->mode == WL1273_MODE_RX) {
1660	dev_dbg(radio->dev, "freq: %d\n", freq->frequency);
1661
1662	r = wl1273_fm_set_rx_freq(radio,
1663	WL1273_INV_FREQ(freq->frequency));
1664	if (r)
1665	dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1666	": set frequency failed with %d\n", r);
1667	} else {
1668	r = wl1273_fm_set_tx_freq(radio,
1669	WL1273_INV_FREQ(freq->frequency));
1670	if (r)
1671	dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1672	": set frequency failed with %d\n", r);
1673	}
1674
1675	mutex_unlock(lock: &core->lock);
1676
1677	dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n");
1678	return r;
1679	}
1680
1681	#define WL1273_DEFAULT_SEEK_LEVEL 7
1682
1683	static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv,
1684	const struct v4l2_hw_freq_seek *seek)
1685	{
1686	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1687	struct wl1273_core *core = radio->core;
1688	int r;
1689
1690	dev_dbg(radio->dev, "%s\n", __func__);
1691
1692	if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO)
1693	return -EINVAL;
1694
1695	if (file->f_flags & O_NONBLOCK)
1696	return -EWOULDBLOCK;
1697
1698	if (mutex_lock_interruptible(&core->lock))
1699	return -EINTR;
1700
1701	r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1702	if (r)
1703	goto out;
1704
1705	r = wl1273_fm_tx_set_spacing(radio, spacing: seek->spacing);
1706	if (r)
1707	dev_warn(radio->dev, "HW seek failed: %d\n", r);
1708
1709	r = wl1273_fm_set_seek(radio, wrap_around: seek->wrap_around, seek_upward: seek->seek_upward,
1710	WL1273_DEFAULT_SEEK_LEVEL);
1711	if (r)
1712	dev_warn(radio->dev, "HW seek failed: %d\n", r);
1713
1714	out:
1715	mutex_unlock(lock: &core->lock);
1716	return r;
1717	}
1718
1719	static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv,
1720	const struct v4l2_modulator *modulator)
1721	{
1722	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1723	struct wl1273_core *core = radio->core;
1724	int r = 0;
1725
1726	dev_dbg(radio->dev, "%s\n", __func__);
1727
1728	if (modulator->index > 0)
1729	return -EINVAL;
1730
1731	if (mutex_lock_interruptible(&core->lock))
1732	return -EINTR;
1733
1734	r = wl1273_fm_set_mode(radio, WL1273_MODE_TX);
1735	if (r)
1736	goto out;
1737
1738	if (modulator->txsubchans & V4L2_TUNER_SUB_RDS)
1739	r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1740	else
1741	r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1742
1743	if (modulator->txsubchans & V4L2_TUNER_SUB_MONO)
1744	r = core->write(core, WL1273_MONO_SET, WL1273_TX_MONO);
1745	else
1746	r = core->write(core, WL1273_MONO_SET,
1747	WL1273_RX_STEREO);
1748	if (r < 0)
1749	dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1750	"MONO_SET fails: %d\n", r);
1751	out:
1752	mutex_unlock(lock: &core->lock);
1753
1754	return r;
1755	}
1756
1757	static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv,
1758	struct v4l2_modulator *modulator)
1759	{
1760	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1761	struct wl1273_core *core = radio->core;
1762	u16 val;
1763	int r;
1764
1765	dev_dbg(radio->dev, "%s\n", __func__);
1766
1767	strscpy(modulator->name, WL1273_FM_DRIVER_NAME,
1768	sizeof(modulator->name));
1769
1770	modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1771	modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1772
1773	modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1774	V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1775
1776	if (core->mode != WL1273_MODE_TX)
1777	return 0;
1778
1779	if (mutex_lock_interruptible(&core->lock))
1780	return -EINTR;
1781
1782	r = core->read(core, WL1273_MONO_SET, &val);
1783	if (r)
1784	goto out;
1785
1786	if (val == WL1273_TX_STEREO)
1787	modulator->txsubchans = V4L2_TUNER_SUB_STEREO;
1788	else
1789	modulator->txsubchans = V4L2_TUNER_SUB_MONO;
1790
1791	if (radio->rds_on)
1792	modulator->txsubchans |= V4L2_TUNER_SUB_RDS;
1793	out:
1794	mutex_unlock(lock: &core->lock);
1795
1796	return 0;
1797	}
1798
1799	static int wl1273_fm_vidioc_log_status(struct file *file, void *priv)
1800	{
1801	struct wl1273_device *radio = video_get_drvdata(vdev: video_devdata(file));
1802	struct wl1273_core *core = radio->core;
1803	struct device *dev = radio->dev;
1804	u16 val;
1805	int r;
1806
1807	dev_info(dev, DRIVER_DESC);
1808
1809	if (core->mode == WL1273_MODE_OFF) {
1810	dev_info(dev, "Mode: Off\n");
1811	return 0;
1812	}
1813
1814	if (core->mode == WL1273_MODE_SUSPENDED) {
1815	dev_info(dev, "Mode: Suspended\n");
1816	return 0;
1817	}
1818
1819	r = core->read(core, WL1273_ASIC_ID_GET, &val);
1820	if (r)
1821	dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__);
1822	else
1823	dev_info(dev, "ASIC_ID: 0x%04x\n", val);
1824
1825	r = core->read(core, WL1273_ASIC_VER_GET, &val);
1826	if (r)
1827	dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__);
1828	else
1829	dev_info(dev, "ASIC Version: 0x%04x\n", val);
1830
1831	r = core->read(core, WL1273_FIRM_VER_GET, &val);
1832	if (r)
1833	dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__);
1834	else
1835	dev_info(dev, "FW version: %d(0x%04x)\n", val, val);
1836
1837	r = core->read(core, WL1273_BAND_SET, &val);
1838	if (r)
1839	dev_err(dev, "%s: Get BAND fails.\n", __func__);
1840	else
1841	dev_info(dev, "BAND: %d\n", val);
1842
1843	if (core->mode == WL1273_MODE_TX) {
1844	r = core->read(core, WL1273_PUPD_SET, &val);
1845	if (r)
1846	dev_err(dev, "%s: Get PUPD fails.\n", __func__);
1847	else
1848	dev_info(dev, "PUPD: 0x%04x\n", val);
1849
1850	r = core->read(core, WL1273_CHANL_SET, &val);
1851	if (r)
1852	dev_err(dev, "%s: Get CHANL fails.\n", __func__);
1853	else
1854	dev_info(dev, "Tx frequency: %dkHz\n", val*10);
1855	} else if (core->mode == WL1273_MODE_RX) {
1856	int bf = radio->rangelow;
1857
1858	r = core->read(core, WL1273_FREQ_SET, &val);
1859	if (r)
1860	dev_err(dev, "%s: Get FREQ fails.\n", __func__);
1861	else
1862	dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50);
1863
1864	r = core->read(core, WL1273_MOST_MODE_SET, &val);
1865	if (r)
1866	dev_err(dev, "%s: Get MOST_MODE fails.\n",
1867	__func__);
1868	else if (val == 0)
1869	dev_info(dev, "MOST_MODE: Stereo according to blend\n");
1870	else if (val == 1)
1871	dev_info(dev, "MOST_MODE: Force mono output\n");
1872	else
1873	dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val);
1874
1875	r = core->read(core, WL1273_MOST_BLEND_SET, &val);
1876	if (r)
1877	dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__);
1878	else if (val == 0)
1879	dev_info(dev,
1880	"MOST_BLEND: Switched blend & hysteresis.\n");
1881	else if (val == 1)
1882	dev_info(dev, "MOST_BLEND: Soft blend.\n");
1883	else
1884	dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val);
1885
1886	r = core->read(core, WL1273_STEREO_GET, &val);
1887	if (r)
1888	dev_err(dev, "%s: Get STEREO fails.\n", __func__);
1889	else if (val == 0)
1890	dev_info(dev, "STEREO: Not detected\n");
1891	else if (val == 1)
1892	dev_info(dev, "STEREO: Detected\n");
1893	else
1894	dev_info(dev, "STEREO: Unexpected value: %d\n", val);
1895
1896	r = core->read(core, WL1273_RSSI_LVL_GET, &val);
1897	if (r)
1898	dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__);
1899	else
1900	dev_info(dev, "RX signal strength: %d\n", (s16) val);
1901
1902	r = core->read(core, WL1273_POWER_SET, &val);
1903	if (r)
1904	dev_err(dev, "%s: Get POWER fails.\n", __func__);
1905	else
1906	dev_info(dev, "POWER: 0x%04x\n", val);
1907
1908	r = core->read(core, WL1273_INT_MASK_SET, &val);
1909	if (r)
1910	dev_err(dev, "%s: Get INT_MASK fails.\n", __func__);
1911	else
1912	dev_info(dev, "INT_MASK: 0x%04x\n", val);
1913
1914	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1915	if (r)
1916	dev_err(dev, "%s: Get RDS_SYNC fails.\n",
1917	__func__);
1918	else if (val == 0)
1919	dev_info(dev, "RDS_SYNC: Not synchronized\n");
1920
1921	else if (val == 1)
1922	dev_info(dev, "RDS_SYNC: Synchronized\n");
1923	else
1924	dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val);
1925
1926	r = core->read(core, WL1273_I2S_MODE_CONFIG_SET, &val);
1927	if (r)
1928	dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n",
1929	__func__);
1930	else
1931	dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val);
1932
1933	r = core->read(core, WL1273_VOLUME_SET, &val);
1934	if (r)
1935	dev_err(dev, "%s: Get VOLUME fails.\n", __func__);
1936	else
1937	dev_info(dev, "VOLUME: 0x%04x\n", val);
1938	}
1939
1940	return 0;
1941	}
1942
1943	static void wl1273_vdev_release(struct video_device *dev)
1944	{
1945	}
1946
1947	static const struct v4l2_ctrl_ops wl1273_ctrl_ops = {
1948	.s_ctrl = wl1273_fm_vidioc_s_ctrl,
1949	.g_volatile_ctrl = wl1273_fm_g_volatile_ctrl,
1950	};
1951
1952	static const struct v4l2_ioctl_ops wl1273_ioctl_ops = {
1953	.vidioc_querycap = wl1273_fm_vidioc_querycap,
1954	.vidioc_g_input = wl1273_fm_vidioc_g_input,
1955	.vidioc_s_input = wl1273_fm_vidioc_s_input,
1956	.vidioc_g_audio = wl1273_fm_vidioc_g_audio,
1957	.vidioc_s_audio = wl1273_fm_vidioc_s_audio,
1958	.vidioc_g_tuner = wl1273_fm_vidioc_g_tuner,
1959	.vidioc_s_tuner = wl1273_fm_vidioc_s_tuner,
1960	.vidioc_g_frequency = wl1273_fm_vidioc_g_frequency,
1961	.vidioc_s_frequency = wl1273_fm_vidioc_s_frequency,
1962	.vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek,
1963	.vidioc_g_modulator = wl1273_fm_vidioc_g_modulator,
1964	.vidioc_s_modulator = wl1273_fm_vidioc_s_modulator,
1965	.vidioc_log_status = wl1273_fm_vidioc_log_status,
1966	};
1967
1968	static const struct video_device wl1273_viddev_template = {
1969	.fops = &wl1273_fops,
1970	.ioctl_ops = &wl1273_ioctl_ops,
1971	.name = WL1273_FM_DRIVER_NAME,
1972	.release = wl1273_vdev_release,
1973	.vfl_dir = VFL_DIR_TX,
1974	.device_caps = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
1975	V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
1976	V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
1977	V4L2_CAP_RDS_OUTPUT,
1978	};
1979
1980	static void wl1273_fm_radio_remove(struct platform_device *pdev)
1981	{
1982	struct wl1273_device *radio = platform_get_drvdata(pdev);
1983	struct wl1273_core *core = radio->core;
1984
1985	dev_info(&pdev->dev, "%s.\n", __func__);
1986
1987	free_irq(core->client->irq, radio);
1988	core->pdata->free_resources();
1989
1990	v4l2_ctrl_handler_free(hdl: &radio->ctrl_handler);
1991	video_unregister_device(vdev: &radio->videodev);
1992	v4l2_device_unregister(v4l2_dev: &radio->v4l2dev);
1993	}
1994
1995	static int wl1273_fm_radio_probe(struct platform_device *pdev)
1996	{
1997	struct wl1273_core **core = pdev->dev.platform_data;
1998	struct wl1273_device *radio;
1999	struct v4l2_ctrl *ctrl;
2000	int r = 0;
2001
2002	pr_debug("%s\n", __func__);
2003
2004	if (!core) {
2005	dev_err(&pdev->dev, "No platform data.\n");
2006	r = -EINVAL;
2007	goto pdata_err;
2008	}
2009
2010	radio = devm_kzalloc(dev: &pdev->dev, size: sizeof(*radio), GFP_KERNEL);
2011	if (!radio) {
2012	r = -ENOMEM;
2013	goto pdata_err;
2014	}
2015
2016	/* RDS buffer allocation */
2017	radio->buf_size = rds_buf * RDS_BLOCK_SIZE;
2018	radio->buffer = devm_kzalloc(dev: &pdev->dev, size: radio->buf_size, GFP_KERNEL);
2019	if (!radio->buffer) {
2020	pr_err("Cannot allocate memory for RDS buffer.\n");
2021	r = -ENOMEM;
2022	goto pdata_err;
2023	}
2024
2025	radio->core = *core;
2026	radio->irq_flags = WL1273_IRQ_MASK;
2027	radio->dev = &radio->core->client->dev;
2028	radio->rds_on = false;
2029	radio->core->mode = WL1273_MODE_OFF;
2030	radio->tx_power = 118;
2031	radio->core->audio_mode = WL1273_AUDIO_ANALOG;
2032	radio->band = WL1273_BAND_OTHER;
2033	radio->core->i2s_mode = WL1273_I2S_DEF_MODE;
2034	radio->core->channel_number = 2;
2035	radio->core->volume = WL1273_DEFAULT_VOLUME;
2036	radio->rx_frequency = WL1273_BAND_OTHER_LOW;
2037	radio->tx_frequency = WL1273_BAND_OTHER_HIGH;
2038	radio->rangelow = WL1273_BAND_OTHER_LOW;
2039	radio->rangehigh = WL1273_BAND_OTHER_HIGH;
2040	radio->stereo = true;
2041	radio->bus_type = "I2C";
2042
2043	if (radio->core->pdata->request_resources) {
2044	r = radio->core->pdata->request_resources(radio->core->client);
2045	if (r) {
2046	dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2047	": Cannot get platform data\n");
2048	goto pdata_err;
2049	}
2050
2051	dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq);
2052
2053	r = request_threaded_irq(irq: radio->core->client->irq, NULL,
2054	thread_fn: wl1273_fm_irq_thread_handler,
2055	IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
2056	name: "wl1273-fm", dev: radio);
2057	if (r < 0) {
2058	dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2059	": Unable to register IRQ handler: %d\n", r);
2060	goto err_request_irq;
2061	}
2062	} else {
2063	dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ not configured");
2064	r = -EINVAL;
2065	goto pdata_err;
2066	}
2067
2068	init_completion(x: &radio->busy);
2069	init_waitqueue_head(&radio->read_queue);
2070
2071	radio->write_buf = devm_kzalloc(dev: &pdev->dev, size: 256, GFP_KERNEL);
2072	if (!radio->write_buf) {
2073	r = -ENOMEM;
2074	goto write_buf_err;
2075	}
2076
2077	radio->dev = &pdev->dev;
2078	radio->v4l2dev.ctrl_handler = &radio->ctrl_handler;
2079	radio->rds_users = 0;
2080
2081	r = v4l2_device_register(dev: &pdev->dev, v4l2_dev: &radio->v4l2dev);
2082	if (r) {
2083	dev_err(&pdev->dev, "Cannot register v4l2_device.\n");
2084	goto write_buf_err;
2085	}
2086
2087	/* V4L2 configuration */
2088	radio->videodev = wl1273_viddev_template;
2089
2090	radio->videodev.v4l2_dev = &radio->v4l2dev;
2091
2092	v4l2_ctrl_handler_init(&radio->ctrl_handler, 6);
2093
2094	/* add in ascending ID order */
2095	v4l2_ctrl_new_std(hdl: &radio->ctrl_handler, ops: &wl1273_ctrl_ops,
2096	V4L2_CID_AUDIO_VOLUME, min: 0, WL1273_MAX_VOLUME, step: 1,
2097	WL1273_DEFAULT_VOLUME);
2098
2099	v4l2_ctrl_new_std(hdl: &radio->ctrl_handler, ops: &wl1273_ctrl_ops,
2100	V4L2_CID_AUDIO_MUTE, min: 0, max: 1, step: 1, def: 1);
2101
2102	v4l2_ctrl_new_std_menu(hdl: &radio->ctrl_handler, ops: &wl1273_ctrl_ops,
2103	V4L2_CID_TUNE_PREEMPHASIS,
2104	max: V4L2_PREEMPHASIS_75_uS, mask: 0x03,
2105	def: V4L2_PREEMPHASIS_50_uS);
2106
2107	v4l2_ctrl_new_std(hdl: &radio->ctrl_handler, ops: &wl1273_ctrl_ops,
2108	V4L2_CID_TUNE_POWER_LEVEL, min: 91, max: 122, step: 1, def: 118);
2109
2110	ctrl = v4l2_ctrl_new_std(hdl: &radio->ctrl_handler, ops: &wl1273_ctrl_ops,
2111	V4L2_CID_TUNE_ANTENNA_CAPACITOR,
2112	min: 0, max: 255, step: 1, def: 255);
2113	if (ctrl)
2114	ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
2115
2116	if (radio->ctrl_handler.error) {
2117	r = radio->ctrl_handler.error;
2118	dev_err(&pdev->dev, "Ctrl handler error: %d\n", r);
2119	goto handler_init_err;
2120	}
2121
2122	video_set_drvdata(vdev: &radio->videodev, data: radio);
2123	platform_set_drvdata(pdev, data: radio);
2124
2125	/* register video device */
2126	r = video_register_device(vdev: &radio->videodev, type: VFL_TYPE_RADIO, nr: radio_nr);
2127	if (r) {
2128	dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME
2129	": Could not register video device\n");
2130	goto handler_init_err;
2131	}
2132
2133	return 0;
2134
2135	handler_init_err:
2136	v4l2_ctrl_handler_free(hdl: &radio->ctrl_handler);
2137	v4l2_device_unregister(v4l2_dev: &radio->v4l2dev);
2138	write_buf_err:
2139	free_irq(radio->core->client->irq, radio);
2140	err_request_irq:
2141	radio->core->pdata->free_resources();
2142	pdata_err:
2143	return r;
2144	}
2145
2146	static struct platform_driver wl1273_fm_radio_driver = {
2147	.probe = wl1273_fm_radio_probe,
2148	.remove_new = wl1273_fm_radio_remove,
2149	.driver = {
2150	.name = "wl1273_fm_radio",
2151	},
2152	};
2153
2154	module_platform_driver(wl1273_fm_radio_driver);
2155
2156	MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");
2157	MODULE_DESCRIPTION(DRIVER_DESC);
2158	MODULE_LICENSE("GPL");
2159	MODULE_ALIAS("platform:wl1273_fm_radio");
2160