1 /*
2  * drivers/staging/media/radio-bcm2048.c
3  *
4  * Driver for I2C Broadcom BCM2048 FM Radio Receiver:
5  *
6  * Copyright (C) Nokia Corporation
7  * Contact: Eero Nurkkala <ext-eero.nurkkala@nokia.com>
8  *
9  * Copyright (C) Nils Faerber <nils.faerber@kernelconcepts.de>
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * version 2 as published by the Free Software Foundation.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23  * 02110-1301 USA
24  */
25 
26 /*
27  * History:
28  *		Eero Nurkkala <ext-eero.nurkkala@nokia.com>
29  *		Version 0.0.1
30  *		- Initial implementation
31  * 2010-02-21	Nils Faerber <nils.faerber@kernelconcepts.de>
32  *		Version 0.0.2
33  *		- Add support for interrupt driven rds data reading
34  */
35 
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/version.h>
40 #include <linux/interrupt.h>
41 #include <linux/sysfs.h>
42 #include <linux/completion.h>
43 #include <linux/delay.h>
44 #include <linux/i2c.h>
45 #include <linux/videodev2.h>
46 #include <linux/mutex.h>
47 #include <linux/slab.h>
48 #include <media/v4l2-common.h>
49 #include <media/v4l2-ioctl.h>
50 #include "radio-bcm2048.h"
51 
52 /* driver definitions */
53 #define BCM2048_DRIVER_AUTHOR	"Eero Nurkkala <ext-eero.nurkkala@nokia.com>"
54 #define BCM2048_DRIVER_NAME	BCM2048_NAME
55 #define BCM2048_DRIVER_VERSION	KERNEL_VERSION(0, 0, 1)
56 #define BCM2048_DRIVER_CARD	"Broadcom bcm2048 FM Radio Receiver"
57 #define BCM2048_DRIVER_DESC	"I2C driver for BCM2048 FM Radio Receiver"
58 
59 /* I2C Control Registers */
60 #define BCM2048_I2C_FM_RDS_SYSTEM	0x00
61 #define BCM2048_I2C_FM_CTRL		0x01
62 #define BCM2048_I2C_RDS_CTRL0		0x02
63 #define BCM2048_I2C_RDS_CTRL1		0x03
64 #define BCM2048_I2C_FM_AUDIO_PAUSE	0x04
65 #define BCM2048_I2C_FM_AUDIO_CTRL0	0x05
66 #define BCM2048_I2C_FM_AUDIO_CTRL1	0x06
67 #define BCM2048_I2C_FM_SEARCH_CTRL0	0x07
68 #define BCM2048_I2C_FM_SEARCH_CTRL1	0x08
69 #define BCM2048_I2C_FM_SEARCH_TUNE_MODE	0x09
70 #define BCM2048_I2C_FM_FREQ0		0x0a
71 #define BCM2048_I2C_FM_FREQ1		0x0b
72 #define BCM2048_I2C_FM_AF_FREQ0		0x0c
73 #define BCM2048_I2C_FM_AF_FREQ1		0x0d
74 #define BCM2048_I2C_FM_CARRIER		0x0e
75 #define BCM2048_I2C_FM_RSSI		0x0f
76 #define BCM2048_I2C_FM_RDS_MASK0	0x10
77 #define BCM2048_I2C_FM_RDS_MASK1	0x11
78 #define BCM2048_I2C_FM_RDS_FLAG0	0x12
79 #define BCM2048_I2C_FM_RDS_FLAG1	0x13
80 #define BCM2048_I2C_RDS_WLINE		0x14
81 #define BCM2048_I2C_RDS_BLKB_MATCH0	0x16
82 #define BCM2048_I2C_RDS_BLKB_MATCH1	0x17
83 #define BCM2048_I2C_RDS_BLKB_MASK0	0x18
84 #define BCM2048_I2C_RDS_BLKB_MASK1	0x19
85 #define BCM2048_I2C_RDS_PI_MATCH0	0x1a
86 #define BCM2048_I2C_RDS_PI_MATCH1	0x1b
87 #define BCM2048_I2C_RDS_PI_MASK0	0x1c
88 #define BCM2048_I2C_RDS_PI_MASK1	0x1d
89 #define BCM2048_I2C_SPARE1		0x20
90 #define BCM2048_I2C_SPARE2		0x21
91 #define BCM2048_I2C_FM_RDS_REV		0x28
92 #define BCM2048_I2C_SLAVE_CONFIGURATION	0x29
93 #define BCM2048_I2C_RDS_DATA		0x80
94 #define BCM2048_I2C_FM_BEST_TUNE_MODE	0x90
95 
96 /* BCM2048_I2C_FM_RDS_SYSTEM */
97 #define BCM2048_FM_ON			0x01
98 #define BCM2048_RDS_ON			0x02
99 
100 /* BCM2048_I2C_FM_CTRL */
101 #define BCM2048_BAND_SELECT			0x01
102 #define BCM2048_STEREO_MONO_AUTO_SELECT		0x02
103 #define BCM2048_STEREO_MONO_MANUAL_SELECT	0x04
104 #define BCM2048_STEREO_MONO_BLEND_SWITCH	0x08
105 #define BCM2048_HI_LO_INJECTION			0x10
106 
107 /* BCM2048_I2C_RDS_CTRL0 */
108 #define BCM2048_RBDS_RDS_SELECT		0x01
109 #define BCM2048_FLUSH_FIFO		0x02
110 
111 /* BCM2048_I2C_FM_AUDIO_PAUSE */
112 #define BCM2048_AUDIO_PAUSE_RSSI_TRESH	0x0f
113 #define BCM2048_AUDIO_PAUSE_DURATION	0xf0
114 
115 /* BCM2048_I2C_FM_AUDIO_CTRL0 */
116 #define BCM2048_RF_MUTE			0x01
117 #define BCM2048_MANUAL_MUTE		0x02
118 #define BCM2048_DAC_OUTPUT_LEFT		0x04
119 #define BCM2048_DAC_OUTPUT_RIGHT	0x08
120 #define BCM2048_AUDIO_ROUTE_DAC		0x10
121 #define BCM2048_AUDIO_ROUTE_I2S		0x20
122 #define BCM2048_DE_EMPHASIS_SELECT	0x40
123 #define BCM2048_AUDIO_BANDWIDTH_SELECT	0x80
124 
125 /* BCM2048_I2C_FM_SEARCH_CTRL0 */
126 #define BCM2048_SEARCH_RSSI_THRESHOLD	0x7f
127 #define BCM2048_SEARCH_DIRECTION	0x80
128 
129 /* BCM2048_I2C_FM_SEARCH_TUNE_MODE */
130 #define BCM2048_FM_AUTO_SEARCH		0x03
131 
132 /* BCM2048_I2C_FM_RSSI */
133 #define BCM2048_RSSI_VALUE		0xff
134 
135 /* BCM2048_I2C_FM_RDS_MASK0 */
136 /* BCM2048_I2C_FM_RDS_MASK1 */
137 #define BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED	0x01
138 #define BCM2048_FM_FLAG_SEARCH_TUNE_FAIL	0x02
139 #define BCM2048_FM_FLAG_RSSI_LOW		0x04
140 #define BCM2048_FM_FLAG_CARRIER_ERROR_HIGH	0x08
141 #define BCM2048_FM_FLAG_AUDIO_PAUSE_INDICATION	0x10
142 #define BCM2048_FLAG_STEREO_DETECTED		0x20
143 #define BCM2048_FLAG_STEREO_ACTIVE		0x40
144 
145 /* BCM2048_I2C_RDS_DATA */
146 #define BCM2048_SLAVE_ADDRESS			0x3f
147 #define BCM2048_SLAVE_ENABLE			0x80
148 
149 /* BCM2048_I2C_FM_BEST_TUNE_MODE */
150 #define BCM2048_BEST_TUNE_MODE			0x80
151 
152 #define BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED	0x01
153 #define BCM2048_FM_FLAG_SEARCH_TUNE_FAIL	0x02
154 #define BCM2048_FM_FLAG_RSSI_LOW		0x04
155 #define BCM2048_FM_FLAG_CARRIER_ERROR_HIGH	0x08
156 #define BCM2048_FM_FLAG_AUDIO_PAUSE_INDICATION	0x10
157 #define BCM2048_FLAG_STEREO_DETECTED		0x20
158 #define BCM2048_FLAG_STEREO_ACTIVE		0x40
159 
160 #define BCM2048_RDS_FLAG_FIFO_WLINE		0x02
161 #define BCM2048_RDS_FLAG_B_BLOCK_MATCH		0x08
162 #define BCM2048_RDS_FLAG_SYNC_LOST		0x10
163 #define BCM2048_RDS_FLAG_PI_MATCH		0x20
164 
165 #define BCM2048_RDS_MARK_END_BYTE0		0x7C
166 #define BCM2048_RDS_MARK_END_BYTEN		0xFF
167 
168 #define BCM2048_FM_FLAGS_ALL	(FM_FLAG_SEARCH_TUNE_FINISHED | \
169 				 FM_FLAG_SEARCH_TUNE_FAIL | \
170 				 FM_FLAG_RSSI_LOW | \
171 				 FM_FLAG_CARRIER_ERROR_HIGH | \
172 				 FM_FLAG_AUDIO_PAUSE_INDICATION | \
173 				 FLAG_STEREO_DETECTED | FLAG_STEREO_ACTIVE)
174 
175 #define BCM2048_RDS_FLAGS_ALL	(RDS_FLAG_FIFO_WLINE | \
176 				 RDS_FLAG_B_BLOCK_MATCH | \
177 				 RDS_FLAG_SYNC_LOST | RDS_FLAG_PI_MATCH)
178 
179 #define BCM2048_DEFAULT_TIMEOUT		1500
180 #define BCM2048_AUTO_SEARCH_TIMEOUT	3000
181 
182 
183 #define BCM2048_FREQDEV_UNIT		10000
184 #define BCM2048_FREQV4L2_MULTI		625
185 #define dev_to_v4l2(f)	((f * BCM2048_FREQDEV_UNIT) / BCM2048_FREQV4L2_MULTI)
186 #define v4l2_to_dev(f)	((f * BCM2048_FREQV4L2_MULTI) / BCM2048_FREQDEV_UNIT)
187 
188 #define msb(x)                  ((u8)((u16) x >> 8))
189 #define lsb(x)                  ((u8)((u16) x &  0x00FF))
190 #define compose_u16(msb, lsb)	(((u16)msb << 8) | lsb)
191 
192 #define BCM2048_DEFAULT_POWERING_DELAY	20
193 #define BCM2048_DEFAULT_REGION		0x02
194 #define BCM2048_DEFAULT_MUTE		0x01
195 #define BCM2048_DEFAULT_RSSI_THRESHOLD	0x64
196 #define BCM2048_DEFAULT_RDS_WLINE	0x7E
197 
198 #define BCM2048_FM_SEARCH_INACTIVE	0x00
199 #define BCM2048_FM_PRE_SET_MODE		0x01
200 #define BCM2048_FM_AUTO_SEARCH_MODE	0x02
201 #define BCM2048_FM_AF_JUMP_MODE		0x03
202 
203 #define BCM2048_FREQUENCY_BASE		64000
204 
205 #define BCM2048_POWER_ON		0x01
206 #define BCM2048_POWER_OFF		0x00
207 
208 #define BCM2048_ITEM_ENABLED		0x01
209 #define BCM2048_SEARCH_DIRECTION_UP	0x01
210 
211 #define BCM2048_DE_EMPHASIS_75us	75
212 #define BCM2048_DE_EMPHASIS_50us	50
213 
214 #define BCM2048_SCAN_FAIL		0x00
215 #define BCM2048_SCAN_OK			0x01
216 
217 #define BCM2048_FREQ_ERROR_FLOOR	-20
218 #define BCM2048_FREQ_ERROR_ROOF		20
219 
220 /* -60 dB is reported as full signal strenght */
221 #define BCM2048_RSSI_LEVEL_BASE		-60
222 #define BCM2048_RSSI_LEVEL_ROOF		-100
223 #define BCM2048_RSSI_LEVEL_ROOF_NEG	100
224 #define BCM2048_SIGNAL_MULTIPLIER	(0xFFFF / \
225 					 (BCM2048_RSSI_LEVEL_ROOF_NEG + \
226 					  BCM2048_RSSI_LEVEL_BASE))
227 
228 #define BCM2048_RDS_FIFO_DUPLE_SIZE	0x03
229 #define BCM2048_RDS_CRC_MASK		0x0F
230 #define BCM2048_RDS_CRC_NONE		0x00
231 #define BCM2048_RDS_CRC_MAX_2BITS	0x04
232 #define BCM2048_RDS_CRC_LEAST_2BITS	0x08
233 #define BCM2048_RDS_CRC_UNRECOVARABLE	0x0C
234 
235 #define BCM2048_RDS_BLOCK_MASK		0xF0
236 #define BCM2048_RDS_BLOCK_A		0x00
237 #define BCM2048_RDS_BLOCK_B		0x10
238 #define BCM2048_RDS_BLOCK_C		0x20
239 #define BCM2048_RDS_BLOCK_D		0x30
240 #define BCM2048_RDS_BLOCK_C_SCORED	0x40
241 #define BCM2048_RDS_BLOCK_E		0x60
242 
243 #define BCM2048_RDS_RT			0x20
244 #define BCM2048_RDS_PS			0x00
245 
246 #define BCM2048_RDS_GROUP_AB_MASK	0x08
247 #define BCM2048_RDS_GROUP_A		0x00
248 #define BCM2048_RDS_GROUP_B		0x08
249 
250 #define BCM2048_RDS_RT_AB_MASK		0x10
251 #define BCM2048_RDS_RT_A		0x00
252 #define BCM2048_RDS_RT_B		0x10
253 #define BCM2048_RDS_RT_INDEX		0x0F
254 
255 #define BCM2048_RDS_PS_INDEX		0x03
256 
257 struct rds_info {
258 	u16 rds_pi;
259 #define BCM2048_MAX_RDS_RT (64 + 1)
260 	u8 rds_rt[BCM2048_MAX_RDS_RT];
261 	u8 rds_rt_group_b;
262 	u8 rds_rt_ab;
263 #define BCM2048_MAX_RDS_PS (8 + 1)
264 	u8 rds_ps[BCM2048_MAX_RDS_PS];
265 	u8 rds_ps_group;
266 	u8 rds_ps_group_cnt;
267 #define BCM2048_MAX_RDS_RADIO_TEXT 255
268 	u8 radio_text[BCM2048_MAX_RDS_RADIO_TEXT + 3];
269 	u8 text_len;
270 };
271 
272 struct region_info {
273 	u32 bottom_frequency;
274 	u32 top_frequency;
275 	u8 deemphasis;
276 	u8 channel_spacing;
277 	u8 region;
278 };
279 
280 struct bcm2048_device {
281 	struct i2c_client *client;
282 	struct video_device videodev;
283 	struct work_struct work;
284 	struct completion compl;
285 	struct mutex mutex;
286 	struct bcm2048_platform_data *platform_data;
287 	struct rds_info rds_info;
288 	struct region_info region_info;
289 	u16 frequency;
290 	u8 cache_fm_rds_system;
291 	u8 cache_fm_ctrl;
292 	u8 cache_fm_audio_ctrl0;
293 	u8 cache_fm_search_ctrl0;
294 	u8 power_state;
295 	u8 rds_state;
296 	u8 fifo_size;
297 	u8 scan_state;
298 	u8 mute_state;
299 
300 	/* for rds data device read */
301 	wait_queue_head_t read_queue;
302 	unsigned int users;
303 	unsigned char rds_data_available;
304 	unsigned int rd_index;
305 };
306 
307 static int radio_nr = -1;	/* radio device minor (-1 ==> auto assign) */
308 module_param(radio_nr, int, 0);
309 MODULE_PARM_DESC(radio_nr,
310 		 "Minor number for radio device (-1 ==> auto assign)");
311 
312 static struct region_info region_configs[] = {
313 	/* USA */
314 	{
315 		.channel_spacing	= 20,
316 		.bottom_frequency	= 87500,
317 		.top_frequency		= 108000,
318 		.deemphasis		= 75,
319 		.region			= 0,
320 	},
321 	/* Australia */
322 	{
323 		.channel_spacing	= 20,
324 		.bottom_frequency	= 87500,
325 		.top_frequency		= 108000,
326 		.deemphasis		= 50,
327 		.region			= 1,
328 	},
329 	/* Europe */
330 	{
331 		.channel_spacing	= 10,
332 		.bottom_frequency	= 87500,
333 		.top_frequency		= 108000,
334 		.deemphasis		= 50,
335 		.region			= 2,
336 	},
337 	/* Japan */
338 	{
339 		.channel_spacing	= 10,
340 		.bottom_frequency	= 76000,
341 		.top_frequency		= 90000,
342 		.deemphasis		= 50,
343 		.region			= 3,
344 	},
345 	/* Japan wide band */
346 	{
347 		.channel_spacing	= 10,
348 		.bottom_frequency	= 76000,
349 		.top_frequency		= 108000,
350 		.deemphasis		= 50,
351 		.region			= 4,
352 	},
353 };
354 
355 /*
356  *	I2C Interface read / write
357  */
bcm2048_send_command(struct bcm2048_device * bdev,unsigned int reg,unsigned int value)358 static int bcm2048_send_command(struct bcm2048_device *bdev, unsigned int reg,
359 					unsigned int value)
360 {
361 	struct i2c_client *client = bdev->client;
362 	u8 data[2];
363 
364 	if (!bdev->power_state) {
365 		dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n");
366 		return -EIO;
367 	}
368 
369 	data[0] = reg & 0xff;
370 	data[1] = value & 0xff;
371 
372 	if (i2c_master_send(client, data, 2) == 2)
373 		return 0;
374 
375 	dev_err(&bdev->client->dev, "BCM I2C error!\n");
376 	dev_err(&bdev->client->dev, "Is Bluetooth up and running?\n");
377 	return -EIO;
378 }
379 
bcm2048_recv_command(struct bcm2048_device * bdev,unsigned int reg,u8 * value)380 static int bcm2048_recv_command(struct bcm2048_device *bdev, unsigned int reg,
381 			u8 *value)
382 {
383 	struct i2c_client *client = bdev->client;
384 
385 	if (!bdev->power_state) {
386 		dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n");
387 		return -EIO;
388 	}
389 
390 	value[0] = i2c_smbus_read_byte_data(client, reg & 0xff);
391 
392 	return 0;
393 }
394 
bcm2048_recv_duples(struct bcm2048_device * bdev,unsigned int reg,u8 * value,u8 duples)395 static int bcm2048_recv_duples(struct bcm2048_device *bdev, unsigned int reg,
396 			u8 *value, u8 duples)
397 {
398 	struct i2c_client *client = bdev->client;
399 	struct i2c_adapter *adap = client->adapter;
400 	struct i2c_msg msg[2];
401 	u8 buf;
402 
403 	if (!bdev->power_state) {
404 		dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n");
405 		return -EIO;
406 	}
407 
408 	buf = reg & 0xff;
409 
410 	msg[0].addr = client->addr;
411 	msg[0].flags = client->flags & I2C_M_TEN;
412 	msg[0].len = 1;
413 	msg[0].buf = &buf;
414 
415 	msg[1].addr = client->addr;
416 	msg[1].flags = client->flags & I2C_M_TEN;
417 	msg[1].flags |= I2C_M_RD;
418 	msg[1].len = duples;
419 	msg[1].buf = value;
420 
421 	return i2c_transfer(adap, msg, 2);
422 }
423 
424 /*
425  *	BCM2048 - I2C register programming helpers
426  */
bcm2048_set_power_state(struct bcm2048_device * bdev,u8 power)427 static int bcm2048_set_power_state(struct bcm2048_device *bdev, u8 power)
428 {
429 	int err = 0;
430 
431 	mutex_lock(&bdev->mutex);
432 
433 	if (power) {
434 		bdev->power_state = BCM2048_POWER_ON;
435 		bdev->cache_fm_rds_system |= BCM2048_FM_ON;
436 	} else {
437 		bdev->cache_fm_rds_system &= ~BCM2048_FM_ON;
438 	}
439 
440 	/*
441 	 * Warning! FM cannot be turned off because then
442 	 * the I2C communications get ruined!
443 	 * Comment off the "if (power)" when the chip works!
444 	 */
445 	if (power)
446 		err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM,
447 					bdev->cache_fm_rds_system);
448 	msleep(BCM2048_DEFAULT_POWERING_DELAY);
449 
450 	if (!power)
451 		bdev->power_state = BCM2048_POWER_OFF;
452 
453 	mutex_unlock(&bdev->mutex);
454 	return err;
455 }
456 
bcm2048_get_power_state(struct bcm2048_device * bdev)457 static int bcm2048_get_power_state(struct bcm2048_device *bdev)
458 {
459 	int err;
460 	u8 value;
461 
462 	mutex_lock(&bdev->mutex);
463 
464 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, &value);
465 
466 	mutex_unlock(&bdev->mutex);
467 
468 	if (!err && (value & BCM2048_FM_ON))
469 		return BCM2048_POWER_ON;
470 
471 	return err;
472 }
473 
bcm2048_set_rds_no_lock(struct bcm2048_device * bdev,u8 rds_on)474 static int bcm2048_set_rds_no_lock(struct bcm2048_device *bdev, u8 rds_on)
475 {
476 	int err;
477 	u8 flags;
478 
479 	bdev->cache_fm_rds_system &= ~BCM2048_RDS_ON;
480 
481 	if (rds_on) {
482 		bdev->cache_fm_rds_system |= BCM2048_RDS_ON;
483 		bdev->rds_state = BCM2048_RDS_ON;
484 		flags =	BCM2048_RDS_FLAG_FIFO_WLINE;
485 		err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1,
486 						flags);
487 	} else {
488 		flags =	0;
489 		bdev->rds_state = 0;
490 		err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1,
491 						flags);
492 		memset(&bdev->rds_info, 0, sizeof(bdev->rds_info));
493 	}
494 
495 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM,
496 					bdev->cache_fm_rds_system);
497 
498 	return err;
499 }
500 
bcm2048_get_rds_no_lock(struct bcm2048_device * bdev)501 static int bcm2048_get_rds_no_lock(struct bcm2048_device *bdev)
502 {
503 	int err;
504 	u8 value;
505 
506 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, &value);
507 
508 	if (!err && (value & BCM2048_RDS_ON))
509 		return BCM2048_ITEM_ENABLED;
510 
511 	return err;
512 }
513 
bcm2048_set_rds(struct bcm2048_device * bdev,u8 rds_on)514 static int bcm2048_set_rds(struct bcm2048_device *bdev, u8 rds_on)
515 {
516 	int err;
517 
518 	mutex_lock(&bdev->mutex);
519 
520 	err = bcm2048_set_rds_no_lock(bdev, rds_on);
521 
522 	mutex_unlock(&bdev->mutex);
523 	return err;
524 }
525 
bcm2048_get_rds(struct bcm2048_device * bdev)526 static int bcm2048_get_rds(struct bcm2048_device *bdev)
527 {
528 	int err;
529 
530 	mutex_lock(&bdev->mutex);
531 
532 	err = bcm2048_get_rds_no_lock(bdev);
533 
534 	mutex_unlock(&bdev->mutex);
535 	return err;
536 }
537 
bcm2048_get_rds_pi(struct bcm2048_device * bdev)538 static int bcm2048_get_rds_pi(struct bcm2048_device *bdev)
539 {
540 	return bdev->rds_info.rds_pi;
541 }
542 
bcm2048_set_fm_automatic_stereo_mono(struct bcm2048_device * bdev,u8 enabled)543 static int bcm2048_set_fm_automatic_stereo_mono(struct bcm2048_device *bdev,
544 						u8 enabled)
545 {
546 	int err;
547 
548 	mutex_lock(&bdev->mutex);
549 
550 	bdev->cache_fm_ctrl &= ~BCM2048_STEREO_MONO_AUTO_SELECT;
551 
552 	if (enabled)
553 		bdev->cache_fm_ctrl |= BCM2048_STEREO_MONO_AUTO_SELECT;
554 
555 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_CTRL,
556 					bdev->cache_fm_ctrl);
557 
558 	mutex_unlock(&bdev->mutex);
559 	return err;
560 }
561 
bcm2048_set_fm_hi_lo_injection(struct bcm2048_device * bdev,u8 hi_lo)562 static int bcm2048_set_fm_hi_lo_injection(struct bcm2048_device *bdev,
563 						u8 hi_lo)
564 {
565 	int err;
566 
567 	mutex_lock(&bdev->mutex);
568 
569 	bdev->cache_fm_ctrl &= ~BCM2048_HI_LO_INJECTION;
570 
571 	if (hi_lo)
572 		bdev->cache_fm_ctrl |= BCM2048_HI_LO_INJECTION;
573 
574 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_CTRL,
575 					bdev->cache_fm_ctrl);
576 
577 	mutex_unlock(&bdev->mutex);
578 	return err;
579 }
580 
bcm2048_get_fm_hi_lo_injection(struct bcm2048_device * bdev)581 static int bcm2048_get_fm_hi_lo_injection(struct bcm2048_device *bdev)
582 {
583 	int err;
584 	u8 value;
585 
586 	mutex_lock(&bdev->mutex);
587 
588 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_CTRL, &value);
589 
590 	mutex_unlock(&bdev->mutex);
591 
592 	if (!err && (value & BCM2048_HI_LO_INJECTION))
593 		return BCM2048_ITEM_ENABLED;
594 
595 	return err;
596 }
597 
bcm2048_set_fm_frequency(struct bcm2048_device * bdev,u32 frequency)598 static int bcm2048_set_fm_frequency(struct bcm2048_device *bdev, u32 frequency)
599 {
600 	int err;
601 
602 	if (frequency < bdev->region_info.bottom_frequency ||
603 		frequency > bdev->region_info.top_frequency)
604 		return -EDOM;
605 
606 	frequency -= BCM2048_FREQUENCY_BASE;
607 
608 	mutex_lock(&bdev->mutex);
609 
610 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_FREQ0, lsb(frequency));
611 	err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_FREQ1,
612 					msb(frequency));
613 
614 	if (!err)
615 		bdev->frequency = frequency;
616 
617 	mutex_unlock(&bdev->mutex);
618 	return err;
619 }
620 
bcm2048_get_fm_frequency(struct bcm2048_device * bdev)621 static int bcm2048_get_fm_frequency(struct bcm2048_device *bdev)
622 {
623 	int err;
624 	u8 lsb, msb;
625 
626 	mutex_lock(&bdev->mutex);
627 
628 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_FREQ0, &lsb);
629 	err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_FREQ1, &msb);
630 
631 	mutex_unlock(&bdev->mutex);
632 
633 	if (err)
634 		return err;
635 
636 	err = compose_u16(msb, lsb);
637 	err += BCM2048_FREQUENCY_BASE;
638 
639 	return err;
640 }
641 
bcm2048_set_fm_af_frequency(struct bcm2048_device * bdev,u32 frequency)642 static int bcm2048_set_fm_af_frequency(struct bcm2048_device *bdev,
643 						u32 frequency)
644 {
645 	int err;
646 
647 	if (frequency < bdev->region_info.bottom_frequency ||
648 		frequency > bdev->region_info.top_frequency)
649 		return -EDOM;
650 
651 	frequency -= BCM2048_FREQUENCY_BASE;
652 
653 	mutex_lock(&bdev->mutex);
654 
655 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AF_FREQ0,
656 					lsb(frequency));
657 	err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_AF_FREQ1,
658 					msb(frequency));
659 	if (!err)
660 		bdev->frequency = frequency;
661 
662 	mutex_unlock(&bdev->mutex);
663 	return err;
664 }
665 
bcm2048_get_fm_af_frequency(struct bcm2048_device * bdev)666 static int bcm2048_get_fm_af_frequency(struct bcm2048_device *bdev)
667 {
668 	int err;
669 	u8 lsb, msb;
670 
671 	mutex_lock(&bdev->mutex);
672 
673 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AF_FREQ0, &lsb);
674 	err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_AF_FREQ1, &msb);
675 
676 	mutex_unlock(&bdev->mutex);
677 
678 	if (err)
679 		return err;
680 
681 	err = compose_u16(msb, lsb);
682 	err += BCM2048_FREQUENCY_BASE;
683 
684 	return err;
685 }
686 
bcm2048_set_fm_deemphasis(struct bcm2048_device * bdev,int d)687 static int bcm2048_set_fm_deemphasis(struct bcm2048_device *bdev, int d)
688 {
689 	int err;
690 	u8 deemphasis;
691 
692 	if (d == BCM2048_DE_EMPHASIS_75us)
693 		deemphasis = BCM2048_DE_EMPHASIS_SELECT;
694 	else
695 		deemphasis = 0;
696 
697 	mutex_lock(&bdev->mutex);
698 
699 	bdev->cache_fm_audio_ctrl0 &= ~BCM2048_DE_EMPHASIS_SELECT;
700 	bdev->cache_fm_audio_ctrl0 |= deemphasis;
701 
702 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0,
703 		bdev->cache_fm_audio_ctrl0);
704 
705 	if (!err)
706 		bdev->region_info.deemphasis = d;
707 
708 	mutex_unlock(&bdev->mutex);
709 
710 	return err;
711 }
712 
bcm2048_get_fm_deemphasis(struct bcm2048_device * bdev)713 static int bcm2048_get_fm_deemphasis(struct bcm2048_device *bdev)
714 {
715 	int err;
716 	u8 value;
717 
718 	mutex_lock(&bdev->mutex);
719 
720 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value);
721 
722 	mutex_unlock(&bdev->mutex);
723 
724 	if (!err) {
725 		if (value & BCM2048_DE_EMPHASIS_SELECT)
726 			return BCM2048_DE_EMPHASIS_75us;
727 
728 		return BCM2048_DE_EMPHASIS_50us;
729 	}
730 
731 	return err;
732 }
733 
bcm2048_set_region(struct bcm2048_device * bdev,u8 region)734 static int bcm2048_set_region(struct bcm2048_device *bdev, u8 region)
735 {
736 	int err;
737 	u32 new_frequency = 0;
738 
739 	if (region >= ARRAY_SIZE(region_configs))
740 		return -EINVAL;
741 
742 	mutex_lock(&bdev->mutex);
743 	bdev->region_info = region_configs[region];
744 	mutex_unlock(&bdev->mutex);
745 
746 	if (bdev->frequency < region_configs[region].bottom_frequency ||
747 		bdev->frequency > region_configs[region].top_frequency)
748 		new_frequency = region_configs[region].bottom_frequency;
749 
750 	if (new_frequency > 0) {
751 		err = bcm2048_set_fm_frequency(bdev, new_frequency);
752 
753 		if (err)
754 			goto done;
755 	}
756 
757 	err = bcm2048_set_fm_deemphasis(bdev,
758 			region_configs[region].deemphasis);
759 
760 done:
761 	return err;
762 }
763 
bcm2048_get_region(struct bcm2048_device * bdev)764 static int bcm2048_get_region(struct bcm2048_device *bdev)
765 {
766 	int err;
767 
768 	mutex_lock(&bdev->mutex);
769 	err = bdev->region_info.region;
770 	mutex_unlock(&bdev->mutex);
771 
772 	return err;
773 }
774 
bcm2048_set_mute(struct bcm2048_device * bdev,u16 mute)775 static int bcm2048_set_mute(struct bcm2048_device *bdev, u16 mute)
776 {
777 	int err;
778 
779 	mutex_lock(&bdev->mutex);
780 
781 	bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_RF_MUTE | BCM2048_MANUAL_MUTE);
782 
783 	if (mute)
784 		bdev->cache_fm_audio_ctrl0 |= (BCM2048_RF_MUTE |
785 						BCM2048_MANUAL_MUTE);
786 
787 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0,
788 					bdev->cache_fm_audio_ctrl0);
789 
790 	if (!err)
791 		bdev->mute_state = mute;
792 
793 	mutex_unlock(&bdev->mutex);
794 	return err;
795 }
796 
bcm2048_get_mute(struct bcm2048_device * bdev)797 static int bcm2048_get_mute(struct bcm2048_device *bdev)
798 {
799 	int err;
800 	u8 value;
801 
802 	mutex_lock(&bdev->mutex);
803 
804 	if (bdev->power_state) {
805 		err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0,
806 						&value);
807 		if (!err)
808 			err = value & (BCM2048_RF_MUTE | BCM2048_MANUAL_MUTE);
809 	} else {
810 		err = bdev->mute_state;
811 	}
812 
813 	mutex_unlock(&bdev->mutex);
814 	return err;
815 }
816 
bcm2048_set_audio_route(struct bcm2048_device * bdev,u8 route)817 static int bcm2048_set_audio_route(struct bcm2048_device *bdev, u8 route)
818 {
819 	int err;
820 
821 	mutex_lock(&bdev->mutex);
822 
823 	route &= (BCM2048_AUDIO_ROUTE_DAC | BCM2048_AUDIO_ROUTE_I2S);
824 	bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_AUDIO_ROUTE_DAC |
825 		BCM2048_AUDIO_ROUTE_I2S);
826 	bdev->cache_fm_audio_ctrl0 |= route;
827 
828 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0,
829 					bdev->cache_fm_audio_ctrl0);
830 
831 	mutex_unlock(&bdev->mutex);
832 	return err;
833 }
834 
bcm2048_get_audio_route(struct bcm2048_device * bdev)835 static int bcm2048_get_audio_route(struct bcm2048_device *bdev)
836 {
837 	int err;
838 	u8 value;
839 
840 	mutex_lock(&bdev->mutex);
841 
842 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value);
843 
844 	mutex_unlock(&bdev->mutex);
845 
846 	if (!err)
847 		return value & (BCM2048_AUDIO_ROUTE_DAC |
848 			BCM2048_AUDIO_ROUTE_I2S);
849 
850 	return err;
851 }
852 
bcm2048_set_dac_output(struct bcm2048_device * bdev,u8 channels)853 static int bcm2048_set_dac_output(struct bcm2048_device *bdev, u8 channels)
854 {
855 	int err;
856 
857 	mutex_lock(&bdev->mutex);
858 
859 	bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_DAC_OUTPUT_LEFT |
860 					BCM2048_DAC_OUTPUT_RIGHT);
861 	bdev->cache_fm_audio_ctrl0 |= channels;
862 
863 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0,
864 					bdev->cache_fm_audio_ctrl0);
865 
866 	mutex_unlock(&bdev->mutex);
867 	return err;
868 }
869 
bcm2048_get_dac_output(struct bcm2048_device * bdev)870 static int bcm2048_get_dac_output(struct bcm2048_device *bdev)
871 {
872 	int err;
873 	u8 value;
874 
875 	mutex_lock(&bdev->mutex);
876 
877 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value);
878 
879 	mutex_unlock(&bdev->mutex);
880 
881 	if (!err)
882 		return value & (BCM2048_DAC_OUTPUT_LEFT |
883 			BCM2048_DAC_OUTPUT_RIGHT);
884 
885 	return err;
886 }
887 
bcm2048_set_fm_search_rssi_threshold(struct bcm2048_device * bdev,u8 threshold)888 static int bcm2048_set_fm_search_rssi_threshold(struct bcm2048_device *bdev,
889 							u8 threshold)
890 {
891 	int err;
892 
893 	mutex_lock(&bdev->mutex);
894 
895 	threshold &= BCM2048_SEARCH_RSSI_THRESHOLD;
896 	bdev->cache_fm_search_ctrl0 &= ~BCM2048_SEARCH_RSSI_THRESHOLD;
897 	bdev->cache_fm_search_ctrl0 |= threshold;
898 
899 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0,
900 					bdev->cache_fm_search_ctrl0);
901 
902 	mutex_unlock(&bdev->mutex);
903 	return err;
904 }
905 
bcm2048_get_fm_search_rssi_threshold(struct bcm2048_device * bdev)906 static int bcm2048_get_fm_search_rssi_threshold(struct bcm2048_device *bdev)
907 {
908 	int err;
909 	u8 value;
910 
911 	mutex_lock(&bdev->mutex);
912 
913 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, &value);
914 
915 	mutex_unlock(&bdev->mutex);
916 
917 	if (!err)
918 		return value & BCM2048_SEARCH_RSSI_THRESHOLD;
919 
920 	return err;
921 }
922 
bcm2048_set_fm_search_mode_direction(struct bcm2048_device * bdev,u8 direction)923 static int bcm2048_set_fm_search_mode_direction(struct bcm2048_device *bdev,
924 						u8 direction)
925 {
926 	int err;
927 
928 	mutex_lock(&bdev->mutex);
929 
930 	bdev->cache_fm_search_ctrl0 &= ~BCM2048_SEARCH_DIRECTION;
931 
932 	if (direction)
933 		bdev->cache_fm_search_ctrl0 |= BCM2048_SEARCH_DIRECTION;
934 
935 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0,
936 					bdev->cache_fm_search_ctrl0);
937 
938 	mutex_unlock(&bdev->mutex);
939 	return err;
940 }
941 
bcm2048_get_fm_search_mode_direction(struct bcm2048_device * bdev)942 static int bcm2048_get_fm_search_mode_direction(struct bcm2048_device *bdev)
943 {
944 	int err;
945 	u8 value;
946 
947 	mutex_lock(&bdev->mutex);
948 
949 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, &value);
950 
951 	mutex_unlock(&bdev->mutex);
952 
953 	if (!err && (value & BCM2048_SEARCH_DIRECTION))
954 		return BCM2048_SEARCH_DIRECTION_UP;
955 
956 	return err;
957 }
958 
bcm2048_set_fm_search_tune_mode(struct bcm2048_device * bdev,u8 mode)959 static int bcm2048_set_fm_search_tune_mode(struct bcm2048_device *bdev,
960 						u8 mode)
961 {
962 	int err, timeout, restart_rds = 0;
963 	u8 value, flags;
964 
965 	value = mode & BCM2048_FM_AUTO_SEARCH;
966 
967 	flags =	BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED |
968 		BCM2048_FM_FLAG_SEARCH_TUNE_FAIL;
969 
970 	mutex_lock(&bdev->mutex);
971 
972 	/*
973 	 * If RDS is enabled, and frequency is changed, RDS quits working.
974 	 * Thus, always restart RDS if it's enabled. Moreover, RDS must
975 	 * not be enabled while changing the frequency because it can
976 	 * provide a race to the mutex from the workqueue handler if RDS
977 	 * IRQ occurs while waiting for frequency changed IRQ.
978 	 */
979 	if (bcm2048_get_rds_no_lock(bdev)) {
980 		err = bcm2048_set_rds_no_lock(bdev, 0);
981 		if (err)
982 			goto unlock;
983 		restart_rds = 1;
984 	}
985 
986 	err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK0, flags);
987 
988 	if (err)
989 		goto unlock;
990 
991 	bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_TUNE_MODE, value);
992 
993 	if (mode != BCM2048_FM_AUTO_SEARCH_MODE)
994 		timeout = BCM2048_DEFAULT_TIMEOUT;
995 	else
996 		timeout = BCM2048_AUTO_SEARCH_TIMEOUT;
997 
998 	if (!wait_for_completion_timeout(&bdev->compl,
999 			msecs_to_jiffies(timeout)))
1000 			dev_err(&bdev->client->dev, "IRQ timeout.\n");
1001 
1002 	if (value)
1003 		if (!bdev->scan_state)
1004 			err = -EIO;
1005 
1006 unlock:
1007 	if (restart_rds)
1008 		err |= bcm2048_set_rds_no_lock(bdev, 1);
1009 
1010 	mutex_unlock(&bdev->mutex);
1011 
1012 	return err;
1013 }
1014 
bcm2048_get_fm_search_tune_mode(struct bcm2048_device * bdev)1015 static int bcm2048_get_fm_search_tune_mode(struct bcm2048_device *bdev)
1016 {
1017 	int err;
1018 	u8 value;
1019 
1020 	mutex_lock(&bdev->mutex);
1021 
1022 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_TUNE_MODE,
1023 					&value);
1024 
1025 	mutex_unlock(&bdev->mutex);
1026 
1027 	if (!err)
1028 		return value & BCM2048_FM_AUTO_SEARCH;
1029 
1030 	return err;
1031 }
1032 
bcm2048_set_rds_b_block_mask(struct bcm2048_device * bdev,u16 mask)1033 static int bcm2048_set_rds_b_block_mask(struct bcm2048_device *bdev, u16 mask)
1034 {
1035 	int err;
1036 
1037 	mutex_lock(&bdev->mutex);
1038 
1039 	err = bcm2048_send_command(bdev,
1040 			BCM2048_I2C_RDS_BLKB_MASK0, lsb(mask));
1041 	err |= bcm2048_send_command(bdev,
1042 			BCM2048_I2C_RDS_BLKB_MASK1, msb(mask));
1043 
1044 	mutex_unlock(&bdev->mutex);
1045 	return err;
1046 }
1047 
bcm2048_get_rds_b_block_mask(struct bcm2048_device * bdev)1048 static int bcm2048_get_rds_b_block_mask(struct bcm2048_device *bdev)
1049 {
1050 	int err;
1051 	u8 lsb, msb;
1052 
1053 	mutex_lock(&bdev->mutex);
1054 
1055 	err = bcm2048_recv_command(bdev,
1056 			BCM2048_I2C_RDS_BLKB_MASK0, &lsb);
1057 	err |= bcm2048_recv_command(bdev,
1058 			BCM2048_I2C_RDS_BLKB_MASK1, &msb);
1059 
1060 	mutex_unlock(&bdev->mutex);
1061 
1062 	if (!err)
1063 		return compose_u16(msb, lsb);
1064 
1065 	return err;
1066 }
1067 
bcm2048_set_rds_b_block_match(struct bcm2048_device * bdev,u16 match)1068 static int bcm2048_set_rds_b_block_match(struct bcm2048_device *bdev,
1069 						u16 match)
1070 {
1071 	int err;
1072 
1073 	mutex_lock(&bdev->mutex);
1074 
1075 	err = bcm2048_send_command(bdev,
1076 			BCM2048_I2C_RDS_BLKB_MATCH0, lsb(match));
1077 	err |= bcm2048_send_command(bdev,
1078 			BCM2048_I2C_RDS_BLKB_MATCH1, msb(match));
1079 
1080 	mutex_unlock(&bdev->mutex);
1081 	return err;
1082 }
1083 
bcm2048_get_rds_b_block_match(struct bcm2048_device * bdev)1084 static int bcm2048_get_rds_b_block_match(struct bcm2048_device *bdev)
1085 {
1086 	int err;
1087 	u8 lsb, msb;
1088 
1089 	mutex_lock(&bdev->mutex);
1090 
1091 	err = bcm2048_recv_command(bdev,
1092 			BCM2048_I2C_RDS_BLKB_MATCH0, &lsb);
1093 	err |= bcm2048_recv_command(bdev,
1094 			BCM2048_I2C_RDS_BLKB_MATCH1, &msb);
1095 
1096 	mutex_unlock(&bdev->mutex);
1097 
1098 	if (!err)
1099 		return compose_u16(msb, lsb);
1100 
1101 	return err;
1102 }
1103 
bcm2048_set_rds_pi_mask(struct bcm2048_device * bdev,u16 mask)1104 static int bcm2048_set_rds_pi_mask(struct bcm2048_device *bdev, u16 mask)
1105 {
1106 	int err;
1107 
1108 	mutex_lock(&bdev->mutex);
1109 
1110 	err = bcm2048_send_command(bdev,
1111 			BCM2048_I2C_RDS_PI_MASK0, lsb(mask));
1112 	err |= bcm2048_send_command(bdev,
1113 			BCM2048_I2C_RDS_PI_MASK1, msb(mask));
1114 
1115 	mutex_unlock(&bdev->mutex);
1116 	return err;
1117 }
1118 
bcm2048_get_rds_pi_mask(struct bcm2048_device * bdev)1119 static int bcm2048_get_rds_pi_mask(struct bcm2048_device *bdev)
1120 {
1121 	int err;
1122 	u8 lsb, msb;
1123 
1124 	mutex_lock(&bdev->mutex);
1125 
1126 	err = bcm2048_recv_command(bdev,
1127 			BCM2048_I2C_RDS_PI_MASK0, &lsb);
1128 	err |= bcm2048_recv_command(bdev,
1129 			BCM2048_I2C_RDS_PI_MASK1, &msb);
1130 
1131 	mutex_unlock(&bdev->mutex);
1132 
1133 	if (!err)
1134 		return compose_u16(msb, lsb);
1135 
1136 	return err;
1137 }
1138 
bcm2048_set_rds_pi_match(struct bcm2048_device * bdev,u16 match)1139 static int bcm2048_set_rds_pi_match(struct bcm2048_device *bdev, u16 match)
1140 {
1141 	int err;
1142 
1143 	mutex_lock(&bdev->mutex);
1144 
1145 	err = bcm2048_send_command(bdev,
1146 			BCM2048_I2C_RDS_PI_MATCH0, lsb(match));
1147 	err |= bcm2048_send_command(bdev,
1148 			BCM2048_I2C_RDS_PI_MATCH1, msb(match));
1149 
1150 	mutex_unlock(&bdev->mutex);
1151 	return err;
1152 }
1153 
bcm2048_get_rds_pi_match(struct bcm2048_device * bdev)1154 static int bcm2048_get_rds_pi_match(struct bcm2048_device *bdev)
1155 {
1156 	int err;
1157 	u8 lsb, msb;
1158 
1159 	mutex_lock(&bdev->mutex);
1160 
1161 	err = bcm2048_recv_command(bdev,
1162 			BCM2048_I2C_RDS_PI_MATCH0, &lsb);
1163 	err |= bcm2048_recv_command(bdev,
1164 			BCM2048_I2C_RDS_PI_MATCH1, &msb);
1165 
1166 	mutex_unlock(&bdev->mutex);
1167 
1168 	if (!err)
1169 		return compose_u16(msb, lsb);
1170 
1171 	return err;
1172 }
1173 
bcm2048_set_fm_rds_mask(struct bcm2048_device * bdev,u16 mask)1174 static int bcm2048_set_fm_rds_mask(struct bcm2048_device *bdev, u16 mask)
1175 {
1176 	int err;
1177 
1178 	mutex_lock(&bdev->mutex);
1179 
1180 	err = bcm2048_send_command(bdev,
1181 			BCM2048_I2C_FM_RDS_MASK0, lsb(mask));
1182 	err |= bcm2048_send_command(bdev,
1183 			BCM2048_I2C_FM_RDS_MASK1, msb(mask));
1184 
1185 	mutex_unlock(&bdev->mutex);
1186 	return err;
1187 }
1188 
bcm2048_get_fm_rds_mask(struct bcm2048_device * bdev)1189 static int bcm2048_get_fm_rds_mask(struct bcm2048_device *bdev)
1190 {
1191 	int err;
1192 	u8 value0, value1;
1193 
1194 	mutex_lock(&bdev->mutex);
1195 
1196 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_MASK0, &value0);
1197 	err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_MASK1, &value1);
1198 
1199 	mutex_unlock(&bdev->mutex);
1200 
1201 	if (!err)
1202 		return compose_u16(value1, value0);
1203 
1204 	return err;
1205 }
1206 
bcm2048_get_fm_rds_flags(struct bcm2048_device * bdev)1207 static int bcm2048_get_fm_rds_flags(struct bcm2048_device *bdev)
1208 {
1209 	int err;
1210 	u8 value0, value1;
1211 
1212 	mutex_lock(&bdev->mutex);
1213 
1214 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG0, &value0);
1215 	err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG1, &value1);
1216 
1217 	mutex_unlock(&bdev->mutex);
1218 
1219 	if (!err)
1220 		return compose_u16(value1, value0);
1221 
1222 	return err;
1223 }
1224 
bcm2048_get_region_bottom_frequency(struct bcm2048_device * bdev)1225 static int bcm2048_get_region_bottom_frequency(struct bcm2048_device *bdev)
1226 {
1227 	return bdev->region_info.bottom_frequency;
1228 }
1229 
bcm2048_get_region_top_frequency(struct bcm2048_device * bdev)1230 static int bcm2048_get_region_top_frequency(struct bcm2048_device *bdev)
1231 {
1232 	return bdev->region_info.top_frequency;
1233 }
1234 
bcm2048_set_fm_best_tune_mode(struct bcm2048_device * bdev,u8 mode)1235 static int bcm2048_set_fm_best_tune_mode(struct bcm2048_device *bdev, u8 mode)
1236 {
1237 	int err;
1238 	u8 value;
1239 
1240 	mutex_lock(&bdev->mutex);
1241 
1242 	/* Perform read as the manual indicates */
1243 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE,
1244 					&value);
1245 	value &= ~BCM2048_BEST_TUNE_MODE;
1246 
1247 	if (mode)
1248 		value |= BCM2048_BEST_TUNE_MODE;
1249 	err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE,
1250 					value);
1251 
1252 	mutex_unlock(&bdev->mutex);
1253 	return err;
1254 }
1255 
bcm2048_get_fm_best_tune_mode(struct bcm2048_device * bdev)1256 static int bcm2048_get_fm_best_tune_mode(struct bcm2048_device *bdev)
1257 {
1258 	int err;
1259 	u8 value;
1260 
1261 	mutex_lock(&bdev->mutex);
1262 
1263 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE,
1264 					&value);
1265 
1266 	mutex_unlock(&bdev->mutex);
1267 
1268 	if (!err && (value & BCM2048_BEST_TUNE_MODE))
1269 		return BCM2048_ITEM_ENABLED;
1270 
1271 	return err;
1272 }
1273 
bcm2048_get_fm_carrier_error(struct bcm2048_device * bdev)1274 static int bcm2048_get_fm_carrier_error(struct bcm2048_device *bdev)
1275 {
1276 	int err = 0;
1277 	s8 value;
1278 
1279 	mutex_lock(&bdev->mutex);
1280 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_CARRIER, &value);
1281 	mutex_unlock(&bdev->mutex);
1282 
1283 	if (!err)
1284 		return value;
1285 
1286 	return err;
1287 }
1288 
bcm2048_get_fm_rssi(struct bcm2048_device * bdev)1289 static int bcm2048_get_fm_rssi(struct bcm2048_device *bdev)
1290 {
1291 	int err;
1292 	s8 value;
1293 
1294 	mutex_lock(&bdev->mutex);
1295 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RSSI, &value);
1296 	mutex_unlock(&bdev->mutex);
1297 
1298 	if (!err)
1299 		return value;
1300 
1301 	return err;
1302 }
1303 
bcm2048_set_rds_wline(struct bcm2048_device * bdev,u8 wline)1304 static int bcm2048_set_rds_wline(struct bcm2048_device *bdev, u8 wline)
1305 {
1306 	int err;
1307 
1308 	mutex_lock(&bdev->mutex);
1309 
1310 	err = bcm2048_send_command(bdev, BCM2048_I2C_RDS_WLINE, wline);
1311 
1312 	if (!err)
1313 		bdev->fifo_size = wline;
1314 
1315 	mutex_unlock(&bdev->mutex);
1316 	return err;
1317 }
1318 
bcm2048_get_rds_wline(struct bcm2048_device * bdev)1319 static int bcm2048_get_rds_wline(struct bcm2048_device *bdev)
1320 {
1321 	int err;
1322 	u8 value;
1323 
1324 	mutex_lock(&bdev->mutex);
1325 
1326 	err = bcm2048_recv_command(bdev, BCM2048_I2C_RDS_WLINE, &value);
1327 
1328 	mutex_unlock(&bdev->mutex);
1329 
1330 	if (!err) {
1331 		bdev->fifo_size = value;
1332 		return value;
1333 	}
1334 
1335 	return err;
1336 }
1337 
bcm2048_checkrev(struct bcm2048_device * bdev)1338 static int bcm2048_checkrev(struct bcm2048_device *bdev)
1339 {
1340 	int err;
1341 	u8 version;
1342 
1343 	mutex_lock(&bdev->mutex);
1344 
1345 	err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_REV, &version);
1346 
1347 	mutex_unlock(&bdev->mutex);
1348 
1349 	if (!err) {
1350 		dev_info(&bdev->client->dev, "BCM2048 Version 0x%x\n",
1351 			version);
1352 		return version;
1353 	}
1354 
1355 	return err;
1356 }
1357 
bcm2048_get_rds_rt(struct bcm2048_device * bdev,char * data)1358 static int bcm2048_get_rds_rt(struct bcm2048_device *bdev, char *data)
1359 {
1360 	int err = 0, i, j = 0, ce = 0, cr = 0;
1361 	char data_buffer[BCM2048_MAX_RDS_RT+1];
1362 
1363 	mutex_lock(&bdev->mutex);
1364 
1365 	if (!bdev->rds_info.text_len) {
1366 		err = -EINVAL;
1367 		goto unlock;
1368 	}
1369 
1370 	for (i = 0; i < BCM2048_MAX_RDS_RT; i++) {
1371 		if (bdev->rds_info.rds_rt[i]) {
1372 			ce = i;
1373 			/* Skip the carriage return */
1374 			if (bdev->rds_info.rds_rt[i] != 0x0d) {
1375 				data_buffer[j++] = bdev->rds_info.rds_rt[i];
1376 			} else {
1377 				cr = i;
1378 				break;
1379 			}
1380 		}
1381 	}
1382 
1383 	if (j <= BCM2048_MAX_RDS_RT)
1384 		data_buffer[j] = 0;
1385 
1386 	for (i = 0; i < BCM2048_MAX_RDS_RT; i++) {
1387 		if (!bdev->rds_info.rds_rt[i]) {
1388 			if (cr && (i < cr)) {
1389 				err = -EBUSY;
1390 				goto unlock;
1391 			}
1392 			if (i < ce) {
1393 				if (cr && (i >= cr))
1394 					break;
1395 				err = -EBUSY;
1396 				goto unlock;
1397 			}
1398 		}
1399 	}
1400 
1401 	memcpy(data, data_buffer, sizeof(data_buffer));
1402 
1403 unlock:
1404 	mutex_unlock(&bdev->mutex);
1405 	return err;
1406 }
1407 
bcm2048_get_rds_ps(struct bcm2048_device * bdev,char * data)1408 static int bcm2048_get_rds_ps(struct bcm2048_device *bdev, char *data)
1409 {
1410 	int err = 0, i, j = 0;
1411 	char data_buffer[BCM2048_MAX_RDS_PS+1];
1412 
1413 	mutex_lock(&bdev->mutex);
1414 
1415 	if (!bdev->rds_info.text_len) {
1416 		err = -EINVAL;
1417 		goto unlock;
1418 	}
1419 
1420 	for (i = 0; i < BCM2048_MAX_RDS_PS; i++) {
1421 		if (bdev->rds_info.rds_ps[i]) {
1422 			data_buffer[j++] = bdev->rds_info.rds_ps[i];
1423 		} else {
1424 			if (i < (BCM2048_MAX_RDS_PS - 1)) {
1425 				err = -EBUSY;
1426 				goto unlock;
1427 			}
1428 		}
1429 	}
1430 
1431 	if (j <= BCM2048_MAX_RDS_PS)
1432 		data_buffer[j] = 0;
1433 
1434 	memcpy(data, data_buffer, sizeof(data_buffer));
1435 
1436 unlock:
1437 	mutex_unlock(&bdev->mutex);
1438 	return err;
1439 }
1440 
bcm2048_parse_rds_pi(struct bcm2048_device * bdev)1441 static void bcm2048_parse_rds_pi(struct bcm2048_device *bdev)
1442 {
1443 	int i, cnt = 0;
1444 	u16 pi;
1445 
1446 	for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) {
1447 
1448 		/* Block A match, only data without crc errors taken */
1449 		if (bdev->rds_info.radio_text[i] == BCM2048_RDS_BLOCK_A) {
1450 
1451 			pi = (bdev->rds_info.radio_text[i+1] << 8) +
1452 				bdev->rds_info.radio_text[i+2];
1453 
1454 			if (!bdev->rds_info.rds_pi) {
1455 				bdev->rds_info.rds_pi = pi;
1456 				return;
1457 			}
1458 			if (pi != bdev->rds_info.rds_pi) {
1459 				cnt++;
1460 				if (cnt > 3) {
1461 					bdev->rds_info.rds_pi = pi;
1462 					cnt = 0;
1463 				}
1464 			} else {
1465 				cnt = 0;
1466 			}
1467 		}
1468 	}
1469 }
1470 
bcm2048_rds_block_crc(struct bcm2048_device * bdev,int i)1471 static int bcm2048_rds_block_crc(struct bcm2048_device *bdev, int i)
1472 {
1473 	return bdev->rds_info.radio_text[i] & BCM2048_RDS_CRC_MASK;
1474 }
1475 
bcm2048_parse_rds_rt_block(struct bcm2048_device * bdev,int i,int index,int crc)1476 static void bcm2048_parse_rds_rt_block(struct bcm2048_device *bdev, int i,
1477 					int index, int crc)
1478 {
1479 	/* Good data will overwrite poor data */
1480 	if (crc) {
1481 		if (!bdev->rds_info.rds_rt[index])
1482 			bdev->rds_info.rds_rt[index] =
1483 				bdev->rds_info.radio_text[i+1];
1484 		if (!bdev->rds_info.rds_rt[index+1])
1485 			bdev->rds_info.rds_rt[index+1] =
1486 				bdev->rds_info.radio_text[i+2];
1487 	} else {
1488 		bdev->rds_info.rds_rt[index] = bdev->rds_info.radio_text[i+1];
1489 		bdev->rds_info.rds_rt[index+1] =
1490 			bdev->rds_info.radio_text[i+2];
1491 	}
1492 }
1493 
bcm2048_parse_rt_match_b(struct bcm2048_device * bdev,int i)1494 static int bcm2048_parse_rt_match_b(struct bcm2048_device *bdev, int i)
1495 {
1496 	int crc, rt_id, rt_group_b, rt_ab, index = 0;
1497 
1498 	crc = bcm2048_rds_block_crc(bdev, i);
1499 
1500 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1501 		return -EIO;
1502 
1503 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1504 		BCM2048_RDS_BLOCK_B) {
1505 
1506 		rt_id = bdev->rds_info.radio_text[i+1] &
1507 			BCM2048_RDS_BLOCK_MASK;
1508 		rt_group_b = bdev->rds_info.radio_text[i+1] &
1509 			BCM2048_RDS_GROUP_AB_MASK;
1510 		rt_ab = bdev->rds_info.radio_text[i+2] &
1511 				BCM2048_RDS_RT_AB_MASK;
1512 
1513 		if (rt_group_b != bdev->rds_info.rds_rt_group_b) {
1514 			memset(bdev->rds_info.rds_rt, 0,
1515 				sizeof(bdev->rds_info.rds_rt));
1516 			bdev->rds_info.rds_rt_group_b = rt_group_b;
1517 		}
1518 
1519 		if (rt_id == BCM2048_RDS_RT) {
1520 			/* A to B or (vice versa), means: clear screen */
1521 			if (rt_ab != bdev->rds_info.rds_rt_ab) {
1522 				memset(bdev->rds_info.rds_rt, 0,
1523 					sizeof(bdev->rds_info.rds_rt));
1524 				bdev->rds_info.rds_rt_ab = rt_ab;
1525 			}
1526 
1527 			index = bdev->rds_info.radio_text[i+2] &
1528 					BCM2048_RDS_RT_INDEX;
1529 
1530 			if (bdev->rds_info.rds_rt_group_b)
1531 				index <<= 1;
1532 			else
1533 				index <<= 2;
1534 
1535 			return index;
1536 		}
1537 	}
1538 
1539 	return -EIO;
1540 }
1541 
bcm2048_parse_rt_match_c(struct bcm2048_device * bdev,int i,int index)1542 static int bcm2048_parse_rt_match_c(struct bcm2048_device *bdev, int i,
1543 					int index)
1544 {
1545 	int crc;
1546 
1547 	crc = bcm2048_rds_block_crc(bdev, i);
1548 
1549 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1550 		return 0;
1551 
1552 	BUG_ON((index+2) >= BCM2048_MAX_RDS_RT);
1553 
1554 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1555 		BCM2048_RDS_BLOCK_C) {
1556 		if (bdev->rds_info.rds_rt_group_b)
1557 			return 1;
1558 		bcm2048_parse_rds_rt_block(bdev, i, index, crc);
1559 		return 1;
1560 	}
1561 
1562 	return 0;
1563 }
1564 
bcm2048_parse_rt_match_d(struct bcm2048_device * bdev,int i,int index)1565 static void bcm2048_parse_rt_match_d(struct bcm2048_device *bdev, int i,
1566 					int index)
1567 {
1568 	int crc;
1569 
1570 	crc = bcm2048_rds_block_crc(bdev, i);
1571 
1572 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1573 		return;
1574 
1575 	BUG_ON((index+4) >= BCM2048_MAX_RDS_RT);
1576 
1577 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1578 		BCM2048_RDS_BLOCK_D)
1579 		bcm2048_parse_rds_rt_block(bdev, i, index+2, crc);
1580 }
1581 
bcm2048_parse_rds_rt(struct bcm2048_device * bdev)1582 static void bcm2048_parse_rds_rt(struct bcm2048_device *bdev)
1583 {
1584 	int i, index = 0, crc, match_b = 0, match_c = 0, match_d = 0;
1585 
1586 	for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) {
1587 
1588 		if (match_b) {
1589 			match_b = 0;
1590 			index = bcm2048_parse_rt_match_b(bdev, i);
1591 			if (index >= 0 && index <= (BCM2048_MAX_RDS_RT - 5))
1592 				match_c = 1;
1593 			continue;
1594 		} else if (match_c) {
1595 			match_c = 0;
1596 			if (bcm2048_parse_rt_match_c(bdev, i, index))
1597 				match_d = 1;
1598 			continue;
1599 		} else if (match_d) {
1600 			match_d = 0;
1601 			bcm2048_parse_rt_match_d(bdev, i, index);
1602 			continue;
1603 		}
1604 
1605 		/* Skip erroneous blocks due to messed up A block altogether */
1606 		if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK)
1607 			== BCM2048_RDS_BLOCK_A) {
1608 			crc = bcm2048_rds_block_crc(bdev, i);
1609 			if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1610 				continue;
1611 			/* Syncronize to a good RDS PI */
1612 			if (((bdev->rds_info.radio_text[i+1] << 8) +
1613 				bdev->rds_info.radio_text[i+2]) ==
1614 				bdev->rds_info.rds_pi)
1615 					match_b = 1;
1616 		}
1617 	}
1618 }
1619 
bcm2048_parse_rds_ps_block(struct bcm2048_device * bdev,int i,int index,int crc)1620 static void bcm2048_parse_rds_ps_block(struct bcm2048_device *bdev, int i,
1621 					int index, int crc)
1622 {
1623 	/* Good data will overwrite poor data */
1624 	if (crc) {
1625 		if (!bdev->rds_info.rds_ps[index])
1626 			bdev->rds_info.rds_ps[index] =
1627 				bdev->rds_info.radio_text[i+1];
1628 		if (!bdev->rds_info.rds_ps[index+1])
1629 			bdev->rds_info.rds_ps[index+1] =
1630 				bdev->rds_info.radio_text[i+2];
1631 	} else {
1632 		bdev->rds_info.rds_ps[index] = bdev->rds_info.radio_text[i+1];
1633 		bdev->rds_info.rds_ps[index+1] =
1634 			bdev->rds_info.radio_text[i+2];
1635 	}
1636 }
1637 
bcm2048_parse_ps_match_c(struct bcm2048_device * bdev,int i,int index)1638 static int bcm2048_parse_ps_match_c(struct bcm2048_device *bdev, int i,
1639 					int index)
1640 {
1641 	int crc;
1642 
1643 	crc = bcm2048_rds_block_crc(bdev, i);
1644 
1645 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1646 		return 0;
1647 
1648 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1649 		BCM2048_RDS_BLOCK_C)
1650 		return 1;
1651 
1652 	return 0;
1653 }
1654 
bcm2048_parse_ps_match_d(struct bcm2048_device * bdev,int i,int index)1655 static void bcm2048_parse_ps_match_d(struct bcm2048_device *bdev, int i,
1656 					int index)
1657 {
1658 	int crc;
1659 
1660 	crc = bcm2048_rds_block_crc(bdev, i);
1661 
1662 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1663 		return;
1664 
1665 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1666 		BCM2048_RDS_BLOCK_D)
1667 		bcm2048_parse_rds_ps_block(bdev, i, index, crc);
1668 }
1669 
bcm2048_parse_ps_match_b(struct bcm2048_device * bdev,int i)1670 static int bcm2048_parse_ps_match_b(struct bcm2048_device *bdev, int i)
1671 {
1672 	int crc, index, ps_id, ps_group;
1673 
1674 	crc = bcm2048_rds_block_crc(bdev, i);
1675 
1676 	if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1677 		return -EIO;
1678 
1679 	/* Block B Radio PS match */
1680 	if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) ==
1681 		BCM2048_RDS_BLOCK_B) {
1682 		ps_id = bdev->rds_info.radio_text[i+1] &
1683 			BCM2048_RDS_BLOCK_MASK;
1684 		ps_group = bdev->rds_info.radio_text[i+1] &
1685 			BCM2048_RDS_GROUP_AB_MASK;
1686 
1687 		/*
1688 		 * Poor RSSI will lead to RDS data corruption
1689 		 * So using 3 (same) sequential values to justify major changes
1690 		 */
1691 		if (ps_group != bdev->rds_info.rds_ps_group) {
1692 			if (crc == BCM2048_RDS_CRC_NONE) {
1693 				bdev->rds_info.rds_ps_group_cnt++;
1694 				if (bdev->rds_info.rds_ps_group_cnt > 2) {
1695 					bdev->rds_info.rds_ps_group = ps_group;
1696 					bdev->rds_info.rds_ps_group_cnt	= 0;
1697 					dev_err(&bdev->client->dev,
1698 						"RDS PS Group change!\n");
1699 				} else {
1700 					return -EIO;
1701 				}
1702 			} else {
1703 				bdev->rds_info.rds_ps_group_cnt = 0;
1704 			}
1705 		}
1706 
1707 		if (ps_id == BCM2048_RDS_PS) {
1708 			index = bdev->rds_info.radio_text[i+2] &
1709 				BCM2048_RDS_PS_INDEX;
1710 			index <<= 1;
1711 			return index;
1712 		}
1713 	}
1714 
1715 	return -EIO;
1716 }
1717 
bcm2048_parse_rds_ps(struct bcm2048_device * bdev)1718 static void bcm2048_parse_rds_ps(struct bcm2048_device *bdev)
1719 {
1720 	int i, index = 0, crc, match_b = 0, match_c = 0, match_d = 0;
1721 
1722 	for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) {
1723 
1724 		if (match_b) {
1725 			match_b = 0;
1726 			index = bcm2048_parse_ps_match_b(bdev, i);
1727 			if (index >= 0 && index < (BCM2048_MAX_RDS_PS - 1))
1728 				match_c = 1;
1729 			continue;
1730 		} else if (match_c) {
1731 			match_c = 0;
1732 			if (bcm2048_parse_ps_match_c(bdev, i, index))
1733 				match_d = 1;
1734 			continue;
1735 		} else if (match_d) {
1736 			match_d = 0;
1737 			bcm2048_parse_ps_match_d(bdev, i, index);
1738 			continue;
1739 		}
1740 
1741 		/* Skip erroneous blocks due to messed up A block altogether */
1742 		if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK)
1743 			== BCM2048_RDS_BLOCK_A) {
1744 			crc = bcm2048_rds_block_crc(bdev, i);
1745 			if (crc == BCM2048_RDS_CRC_UNRECOVARABLE)
1746 				continue;
1747 			/* Syncronize to a good RDS PI */
1748 			if (((bdev->rds_info.radio_text[i+1] << 8) +
1749 				bdev->rds_info.radio_text[i+2]) ==
1750 				bdev->rds_info.rds_pi)
1751 					match_b = 1;
1752 		}
1753 	}
1754 }
1755 
bcm2048_rds_fifo_receive(struct bcm2048_device * bdev)1756 static void bcm2048_rds_fifo_receive(struct bcm2048_device *bdev)
1757 {
1758 	int err;
1759 
1760 	mutex_lock(&bdev->mutex);
1761 
1762 	err = bcm2048_recv_duples(bdev, BCM2048_I2C_RDS_DATA,
1763 				bdev->rds_info.radio_text, bdev->fifo_size);
1764 	if (err != 2) {
1765 		dev_err(&bdev->client->dev, "RDS Read problem\n");
1766 		mutex_unlock(&bdev->mutex);
1767 		return;
1768 	}
1769 
1770 	bdev->rds_info.text_len = bdev->fifo_size;
1771 
1772 	bcm2048_parse_rds_pi(bdev);
1773 	bcm2048_parse_rds_rt(bdev);
1774 	bcm2048_parse_rds_ps(bdev);
1775 
1776 	mutex_unlock(&bdev->mutex);
1777 
1778 	wake_up_interruptible(&bdev->read_queue);
1779 }
1780 
bcm2048_get_rds_data(struct bcm2048_device * bdev,char * data)1781 static int bcm2048_get_rds_data(struct bcm2048_device *bdev, char *data)
1782 {
1783 	int err = 0, i, p = 0;
1784 	char *data_buffer;
1785 
1786 	mutex_lock(&bdev->mutex);
1787 
1788 	if (!bdev->rds_info.text_len) {
1789 		err = -EINVAL;
1790 		goto unlock;
1791 	}
1792 
1793 	data_buffer = kcalloc(BCM2048_MAX_RDS_RADIO_TEXT, 5, GFP_KERNEL);
1794 	if (!data_buffer) {
1795 		err = -ENOMEM;
1796 		goto unlock;
1797 	}
1798 
1799 	for (i = 0; i < bdev->rds_info.text_len; i++) {
1800 		p += sprintf(data_buffer+p, "%x ",
1801 			bdev->rds_info.radio_text[i]);
1802 	}
1803 
1804 	memcpy(data, data_buffer, p);
1805 	kfree(data_buffer);
1806 
1807 unlock:
1808 	mutex_unlock(&bdev->mutex);
1809 	return err;
1810 }
1811 
1812 /*
1813  *	BCM2048 default initialization sequence
1814  */
bcm2048_init(struct bcm2048_device * bdev)1815 static int bcm2048_init(struct bcm2048_device *bdev)
1816 {
1817 	int err;
1818 
1819 	err = bcm2048_set_power_state(bdev, BCM2048_POWER_ON);
1820 	if (err < 0)
1821 		goto exit;
1822 
1823 	err = bcm2048_set_audio_route(bdev, BCM2048_AUDIO_ROUTE_DAC);
1824 	if (err < 0)
1825 		goto exit;
1826 
1827 	err = bcm2048_set_dac_output(bdev, BCM2048_DAC_OUTPUT_LEFT |
1828 		BCM2048_DAC_OUTPUT_RIGHT);
1829 
1830 exit:
1831 	return err;
1832 }
1833 
1834 /*
1835  *	BCM2048 default deinitialization sequence
1836  */
bcm2048_deinit(struct bcm2048_device * bdev)1837 static int bcm2048_deinit(struct bcm2048_device *bdev)
1838 {
1839 	int err;
1840 
1841 	err = bcm2048_set_audio_route(bdev, 0);
1842 	if (err < 0)
1843 		goto exit;
1844 
1845 	err = bcm2048_set_dac_output(bdev, 0);
1846 	if (err < 0)
1847 		goto exit;
1848 
1849 	err = bcm2048_set_power_state(bdev, BCM2048_POWER_OFF);
1850 	if (err < 0)
1851 		goto exit;
1852 
1853 exit:
1854 	return err;
1855 }
1856 
1857 /*
1858  *	BCM2048 probe sequence
1859  */
bcm2048_probe(struct bcm2048_device * bdev)1860 static int bcm2048_probe(struct bcm2048_device *bdev)
1861 {
1862 	int err;
1863 
1864 	err = bcm2048_set_power_state(bdev, BCM2048_POWER_ON);
1865 	if (err < 0)
1866 		goto unlock;
1867 
1868 	err = bcm2048_checkrev(bdev);
1869 	if (err < 0)
1870 		goto unlock;
1871 
1872 	err = bcm2048_set_mute(bdev, BCM2048_DEFAULT_MUTE);
1873 	if (err < 0)
1874 		goto unlock;
1875 
1876 	err = bcm2048_set_region(bdev, BCM2048_DEFAULT_REGION);
1877 	if (err < 0)
1878 		goto unlock;
1879 
1880 	err = bcm2048_set_fm_search_rssi_threshold(bdev,
1881 					BCM2048_DEFAULT_RSSI_THRESHOLD);
1882 	if (err < 0)
1883 		goto unlock;
1884 
1885 	err = bcm2048_set_fm_automatic_stereo_mono(bdev, BCM2048_ITEM_ENABLED);
1886 	if (err < 0)
1887 		goto unlock;
1888 
1889 	err = bcm2048_get_rds_wline(bdev);
1890 	if (err < BCM2048_DEFAULT_RDS_WLINE)
1891 		err = bcm2048_set_rds_wline(bdev, BCM2048_DEFAULT_RDS_WLINE);
1892 	if (err < 0)
1893 		goto unlock;
1894 
1895 	err = bcm2048_set_power_state(bdev, BCM2048_POWER_OFF);
1896 
1897 	init_waitqueue_head(&bdev->read_queue);
1898 	bdev->rds_data_available = 0;
1899 	bdev->rd_index = 0;
1900 	bdev->users = 0;
1901 
1902 unlock:
1903 	return err;
1904 }
1905 
1906 /*
1907  *	BCM2048 workqueue handler
1908  */
bcm2048_work(struct work_struct * work)1909 static void bcm2048_work(struct work_struct *work)
1910 {
1911 	struct bcm2048_device *bdev;
1912 	u8 flag_lsb, flag_msb, flags;
1913 
1914 	bdev = container_of(work, struct bcm2048_device, work);
1915 	bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG0, &flag_lsb);
1916 	bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG1, &flag_msb);
1917 
1918 	if (flag_lsb & (BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED |
1919 			BCM2048_FM_FLAG_SEARCH_TUNE_FAIL)) {
1920 
1921 		if (flag_lsb & BCM2048_FM_FLAG_SEARCH_TUNE_FAIL)
1922 			bdev->scan_state = BCM2048_SCAN_FAIL;
1923 		else
1924 			bdev->scan_state = BCM2048_SCAN_OK;
1925 
1926 		complete(&bdev->compl);
1927 	}
1928 
1929 	if (flag_msb & BCM2048_RDS_FLAG_FIFO_WLINE) {
1930 		bcm2048_rds_fifo_receive(bdev);
1931 		if (bdev->rds_state) {
1932 			flags =	BCM2048_RDS_FLAG_FIFO_WLINE;
1933 			bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1,
1934 						flags);
1935 		}
1936 		bdev->rds_data_available = 1;
1937 		bdev->rd_index = 0; /* new data, new start */
1938 	}
1939 }
1940 
1941 /*
1942  *	BCM2048 interrupt handler
1943  */
bcm2048_handler(int irq,void * dev)1944 static irqreturn_t bcm2048_handler(int irq, void *dev)
1945 {
1946 	struct bcm2048_device *bdev = dev;
1947 
1948 	dev_dbg(&bdev->client->dev, "IRQ called, queuing work\n");
1949 	if (bdev->power_state)
1950 		schedule_work(&bdev->work);
1951 
1952 	return IRQ_HANDLED;
1953 }
1954 
1955 /*
1956  *	BCM2048 sysfs interface definitions
1957  */
1958 #define property_write(prop, type, mask, check)				\
1959 static ssize_t bcm2048_##prop##_write(struct device *dev,		\
1960 					struct device_attribute *attr,	\
1961 					const char *buf,		\
1962 					size_t count)			\
1963 {									\
1964 	struct bcm2048_device *bdev = dev_get_drvdata(dev);		\
1965 	type value;							\
1966 	int err;							\
1967 									\
1968 	if (!bdev)							\
1969 		return -ENODEV;						\
1970 									\
1971 	if (sscanf(buf, mask, &value) != 1)				\
1972 		return -EINVAL;						\
1973 									\
1974 	if (check)							\
1975 		return -EDOM;						\
1976 									\
1977 	err = bcm2048_set_##prop(bdev, value);				\
1978 									\
1979 	return err < 0 ? err : count;					\
1980 }
1981 
1982 #define property_read(prop, size, mask)					\
1983 static ssize_t bcm2048_##prop##_read(struct device *dev,		\
1984 					struct device_attribute *attr,	\
1985 					char *buf)			\
1986 {									\
1987 	struct bcm2048_device *bdev = dev_get_drvdata(dev);		\
1988 	int value;							\
1989 									\
1990 	if (!bdev)							\
1991 		return -ENODEV;						\
1992 									\
1993 	value = bcm2048_get_##prop(bdev);				\
1994 									\
1995 	if (value >= 0)							\
1996 		value = sprintf(buf, mask "\n", value);			\
1997 									\
1998 	return value;							\
1999 }
2000 
2001 #define property_signed_read(prop, size, mask)				\
2002 static ssize_t bcm2048_##prop##_read(struct device *dev,		\
2003 					struct device_attribute *attr,	\
2004 					char *buf)			\
2005 {									\
2006 	struct bcm2048_device *bdev = dev_get_drvdata(dev);		\
2007 	size value;							\
2008 									\
2009 	if (!bdev)							\
2010 		return -ENODEV;						\
2011 									\
2012 	value = bcm2048_get_##prop(bdev);				\
2013 									\
2014 	value = sprintf(buf, mask "\n", value);				\
2015 									\
2016 	return value;							\
2017 }
2018 
2019 #define DEFINE_SYSFS_PROPERTY(prop, signal, size, mask, check)		\
2020 property_write(prop, signal size, mask, check)				\
2021 property_read(prop, size, mask)
2022 
2023 #define property_str_read(prop, size)					\
2024 static ssize_t bcm2048_##prop##_read(struct device *dev,		\
2025 					struct device_attribute *attr,	\
2026 					char *buf)			\
2027 {									\
2028 	struct bcm2048_device *bdev = dev_get_drvdata(dev);		\
2029 	int count;							\
2030 	u8 *out;							\
2031 									\
2032 	if (!bdev)							\
2033 		return -ENODEV;						\
2034 									\
2035 	out = kzalloc(size + 1, GFP_KERNEL);				\
2036 	if (!out)							\
2037 		return -ENOMEM;						\
2038 									\
2039 	bcm2048_get_##prop(bdev, out);					\
2040 	count = sprintf(buf, "%s\n", out);				\
2041 									\
2042 	kfree(out);							\
2043 									\
2044 	return count;							\
2045 }
2046 
2047 DEFINE_SYSFS_PROPERTY(power_state, unsigned, int, "%u", 0)
2048 DEFINE_SYSFS_PROPERTY(mute, unsigned, int, "%u", 0)
2049 DEFINE_SYSFS_PROPERTY(audio_route, unsigned, int, "%u", 0)
2050 DEFINE_SYSFS_PROPERTY(dac_output, unsigned, int, "%u", 0)
2051 
2052 DEFINE_SYSFS_PROPERTY(fm_hi_lo_injection, unsigned, int, "%u", 0)
2053 DEFINE_SYSFS_PROPERTY(fm_frequency, unsigned, int, "%u", 0)
2054 DEFINE_SYSFS_PROPERTY(fm_af_frequency, unsigned, int, "%u", 0)
2055 DEFINE_SYSFS_PROPERTY(fm_deemphasis, unsigned, int, "%u", 0)
2056 DEFINE_SYSFS_PROPERTY(fm_rds_mask, unsigned, int, "%u", 0)
2057 DEFINE_SYSFS_PROPERTY(fm_best_tune_mode, unsigned, int, "%u", 0)
2058 DEFINE_SYSFS_PROPERTY(fm_search_rssi_threshold, unsigned, int, "%u", 0)
2059 DEFINE_SYSFS_PROPERTY(fm_search_mode_direction, unsigned, int, "%u", 0)
2060 DEFINE_SYSFS_PROPERTY(fm_search_tune_mode, unsigned, int, "%u", value > 3)
2061 
2062 DEFINE_SYSFS_PROPERTY(rds, unsigned, int, "%u", 0)
2063 DEFINE_SYSFS_PROPERTY(rds_b_block_mask, unsigned, int, "%u", 0)
2064 DEFINE_SYSFS_PROPERTY(rds_b_block_match, unsigned, int, "%u", 0)
2065 DEFINE_SYSFS_PROPERTY(rds_pi_mask, unsigned, int, "%u", 0)
2066 DEFINE_SYSFS_PROPERTY(rds_pi_match, unsigned, int, "%u", 0)
2067 DEFINE_SYSFS_PROPERTY(rds_wline, unsigned, int, "%u", 0)
2068 property_read(rds_pi, unsigned int, "%x")
2069 property_str_read(rds_rt, (BCM2048_MAX_RDS_RT + 1))
2070 property_str_read(rds_ps, (BCM2048_MAX_RDS_PS + 1))
2071 
2072 property_read(fm_rds_flags, unsigned int, "%u")
2073 property_str_read(rds_data, BCM2048_MAX_RDS_RADIO_TEXT*5)
2074 
2075 property_read(region_bottom_frequency, unsigned int, "%u")
2076 property_read(region_top_frequency, unsigned int, "%u")
2077 property_signed_read(fm_carrier_error, int, "%d")
2078 property_signed_read(fm_rssi, int, "%d")
2079 DEFINE_SYSFS_PROPERTY(region, unsigned, int, "%u", 0)
2080 
2081 static struct device_attribute attrs[] = {
2082 	__ATTR(power_state, S_IRUGO | S_IWUSR, bcm2048_power_state_read,
2083 		bcm2048_power_state_write),
2084 	__ATTR(mute, S_IRUGO | S_IWUSR, bcm2048_mute_read,
2085 		bcm2048_mute_write),
2086 	__ATTR(audio_route, S_IRUGO | S_IWUSR, bcm2048_audio_route_read,
2087 		bcm2048_audio_route_write),
2088 	__ATTR(dac_output, S_IRUGO | S_IWUSR, bcm2048_dac_output_read,
2089 		bcm2048_dac_output_write),
2090 	__ATTR(fm_hi_lo_injection, S_IRUGO | S_IWUSR,
2091 		bcm2048_fm_hi_lo_injection_read,
2092 		bcm2048_fm_hi_lo_injection_write),
2093 	__ATTR(fm_frequency, S_IRUGO | S_IWUSR, bcm2048_fm_frequency_read,
2094 		bcm2048_fm_frequency_write),
2095 	__ATTR(fm_af_frequency, S_IRUGO | S_IWUSR,
2096 		bcm2048_fm_af_frequency_read,
2097 		bcm2048_fm_af_frequency_write),
2098 	__ATTR(fm_deemphasis, S_IRUGO | S_IWUSR, bcm2048_fm_deemphasis_read,
2099 		bcm2048_fm_deemphasis_write),
2100 	__ATTR(fm_rds_mask, S_IRUGO | S_IWUSR, bcm2048_fm_rds_mask_read,
2101 		bcm2048_fm_rds_mask_write),
2102 	__ATTR(fm_best_tune_mode, S_IRUGO | S_IWUSR,
2103 		bcm2048_fm_best_tune_mode_read,
2104 		bcm2048_fm_best_tune_mode_write),
2105 	__ATTR(fm_search_rssi_threshold, S_IRUGO | S_IWUSR,
2106 		bcm2048_fm_search_rssi_threshold_read,
2107 		bcm2048_fm_search_rssi_threshold_write),
2108 	__ATTR(fm_search_mode_direction, S_IRUGO | S_IWUSR,
2109 		bcm2048_fm_search_mode_direction_read,
2110 		bcm2048_fm_search_mode_direction_write),
2111 	__ATTR(fm_search_tune_mode, S_IRUGO | S_IWUSR,
2112 		bcm2048_fm_search_tune_mode_read,
2113 		bcm2048_fm_search_tune_mode_write),
2114 	__ATTR(rds, S_IRUGO | S_IWUSR, bcm2048_rds_read,
2115 		bcm2048_rds_write),
2116 	__ATTR(rds_b_block_mask, S_IRUGO | S_IWUSR,
2117 		bcm2048_rds_b_block_mask_read,
2118 		bcm2048_rds_b_block_mask_write),
2119 	__ATTR(rds_b_block_match, S_IRUGO | S_IWUSR,
2120 		bcm2048_rds_b_block_match_read,
2121 		bcm2048_rds_b_block_match_write),
2122 	__ATTR(rds_pi_mask, S_IRUGO | S_IWUSR, bcm2048_rds_pi_mask_read,
2123 		bcm2048_rds_pi_mask_write),
2124 	__ATTR(rds_pi_match, S_IRUGO | S_IWUSR, bcm2048_rds_pi_match_read,
2125 		bcm2048_rds_pi_match_write),
2126 	__ATTR(rds_wline, S_IRUGO | S_IWUSR, bcm2048_rds_wline_read,
2127 		bcm2048_rds_wline_write),
2128 	__ATTR(rds_pi, S_IRUGO, bcm2048_rds_pi_read, NULL),
2129 	__ATTR(rds_rt, S_IRUGO, bcm2048_rds_rt_read, NULL),
2130 	__ATTR(rds_ps, S_IRUGO, bcm2048_rds_ps_read, NULL),
2131 	__ATTR(fm_rds_flags, S_IRUGO, bcm2048_fm_rds_flags_read, NULL),
2132 	__ATTR(region_bottom_frequency, S_IRUGO,
2133 		bcm2048_region_bottom_frequency_read, NULL),
2134 	__ATTR(region_top_frequency, S_IRUGO,
2135 		bcm2048_region_top_frequency_read, NULL),
2136 	__ATTR(fm_carrier_error, S_IRUGO,
2137 		bcm2048_fm_carrier_error_read, NULL),
2138 	__ATTR(fm_rssi, S_IRUGO,
2139 		bcm2048_fm_rssi_read, NULL),
2140 	__ATTR(region, S_IRUGO | S_IWUSR, bcm2048_region_read,
2141 		bcm2048_region_write),
2142 	__ATTR(rds_data, S_IRUGO, bcm2048_rds_data_read, NULL),
2143 };
2144 
bcm2048_sysfs_unregister_properties(struct bcm2048_device * bdev,int size)2145 static int bcm2048_sysfs_unregister_properties(struct bcm2048_device *bdev,
2146 						int size)
2147 {
2148 	int i;
2149 
2150 	for (i = 0; i < size; i++)
2151 		device_remove_file(&bdev->client->dev, &attrs[i]);
2152 
2153 	return 0;
2154 }
2155 
bcm2048_sysfs_register_properties(struct bcm2048_device * bdev)2156 static int bcm2048_sysfs_register_properties(struct bcm2048_device *bdev)
2157 {
2158 	int err = 0;
2159 	int i;
2160 
2161 	for (i = 0; i < ARRAY_SIZE(attrs); i++) {
2162 		if (device_create_file(&bdev->client->dev, &attrs[i]) != 0) {
2163 			dev_err(&bdev->client->dev,
2164 					"could not register sysfs entry\n");
2165 			err = -EBUSY;
2166 			bcm2048_sysfs_unregister_properties(bdev, i);
2167 			break;
2168 		}
2169 	}
2170 
2171 	return err;
2172 }
2173 
2174 
bcm2048_fops_open(struct file * file)2175 static int bcm2048_fops_open(struct file *file)
2176 {
2177 	struct bcm2048_device *bdev = video_drvdata(file);
2178 
2179 	bdev->users++;
2180 	bdev->rd_index = 0;
2181 	bdev->rds_data_available = 0;
2182 
2183 	return 0;
2184 }
2185 
bcm2048_fops_release(struct file * file)2186 static int bcm2048_fops_release(struct file *file)
2187 {
2188 	struct bcm2048_device *bdev = video_drvdata(file);
2189 
2190 	bdev->users--;
2191 
2192 	return 0;
2193 }
2194 
bcm2048_fops_poll(struct file * file,struct poll_table_struct * pts)2195 static unsigned int bcm2048_fops_poll(struct file *file,
2196 		struct poll_table_struct *pts)
2197 {
2198 	struct bcm2048_device *bdev = video_drvdata(file);
2199 	int retval = 0;
2200 
2201 	poll_wait(file, &bdev->read_queue, pts);
2202 
2203 	if (bdev->rds_data_available)
2204 		retval = POLLIN | POLLRDNORM;
2205 
2206 	return retval;
2207 }
2208 
bcm2048_fops_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)2209 static ssize_t bcm2048_fops_read(struct file *file, char __user *buf,
2210 	size_t count, loff_t *ppos)
2211 {
2212 	struct bcm2048_device *bdev = video_drvdata(file);
2213 	int i;
2214 	int retval = 0;
2215 
2216 	/* we return at least 3 bytes, one block */
2217 	count = (count / 3) * 3; /* only multiples of 3 */
2218 	if (count < 3)
2219 		return -ENOBUFS;
2220 
2221 	while (!bdev->rds_data_available) {
2222 		if (file->f_flags & O_NONBLOCK) {
2223 			retval = -EWOULDBLOCK;
2224 			goto done;
2225 		}
2226 		/* interruptible_sleep_on(&bdev->read_queue); */
2227 		if (wait_event_interruptible(bdev->read_queue,
2228 			bdev->rds_data_available) < 0) {
2229 			retval = -EINTR;
2230 			goto done;
2231 		}
2232 	}
2233 
2234 	mutex_lock(&bdev->mutex);
2235 	/* copy data to userspace */
2236 	i = bdev->fifo_size - bdev->rd_index;
2237 	if (count > i)
2238 		count = (i / 3) * 3;
2239 
2240 	i = 0;
2241 	while (i < count) {
2242 		unsigned char tmpbuf[3];
2243 
2244 		tmpbuf[i] = bdev->rds_info.radio_text[bdev->rd_index+i+2];
2245 		tmpbuf[i+1] = bdev->rds_info.radio_text[bdev->rd_index+i+1];
2246 		tmpbuf[i+2] = (bdev->rds_info.radio_text[bdev->rd_index + i] & 0xf0) >> 4;
2247 		if ((bdev->rds_info.radio_text[bdev->rd_index+i] &
2248 			BCM2048_RDS_CRC_MASK) == BCM2048_RDS_CRC_UNRECOVARABLE)
2249 			tmpbuf[i+2] |= 0x80;
2250 		if (copy_to_user(buf+i, tmpbuf, 3)) {
2251 			retval = -EFAULT;
2252 			break;
2253 		}
2254 		i += 3;
2255 	}
2256 
2257 	bdev->rd_index += i;
2258 	if (bdev->rd_index >= bdev->fifo_size)
2259 		bdev->rds_data_available = 0;
2260 
2261 	mutex_unlock(&bdev->mutex);
2262 	if (retval == 0)
2263 		retval = i;
2264 
2265 done:
2266 	return retval;
2267 }
2268 
2269 /*
2270  *	bcm2048_fops - file operations interface
2271  */
2272 static const struct v4l2_file_operations bcm2048_fops = {
2273 	.owner		= THIS_MODULE,
2274 	.unlocked_ioctl	= video_ioctl2,
2275 	/* for RDS read support */
2276 	.open		= bcm2048_fops_open,
2277 	.release	= bcm2048_fops_release,
2278 	.read		= bcm2048_fops_read,
2279 	.poll		= bcm2048_fops_poll
2280 };
2281 
2282 /*
2283  *	Video4Linux Interface
2284  */
2285 static struct v4l2_queryctrl bcm2048_v4l2_queryctrl[] = {
2286 	{
2287 		.id		= V4L2_CID_AUDIO_VOLUME,
2288 		.flags		= V4L2_CTRL_FLAG_DISABLED,
2289 	},
2290 	{
2291 		.id		= V4L2_CID_AUDIO_BALANCE,
2292 		.flags		= V4L2_CTRL_FLAG_DISABLED,
2293 	},
2294 	{
2295 		.id		= V4L2_CID_AUDIO_BASS,
2296 		.flags		= V4L2_CTRL_FLAG_DISABLED,
2297 	},
2298 	{
2299 		.id		= V4L2_CID_AUDIO_TREBLE,
2300 		.flags		= V4L2_CTRL_FLAG_DISABLED,
2301 	},
2302 	{
2303 		.id		= V4L2_CID_AUDIO_MUTE,
2304 		.type		= V4L2_CTRL_TYPE_BOOLEAN,
2305 		.name		= "Mute",
2306 		.minimum	= 0,
2307 		.maximum	= 1,
2308 		.step		= 1,
2309 		.default_value	= 1,
2310 	},
2311 	{
2312 		.id		= V4L2_CID_AUDIO_LOUDNESS,
2313 		.flags		= V4L2_CTRL_FLAG_DISABLED,
2314 	},
2315 };
2316 
bcm2048_vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * capability)2317 static int bcm2048_vidioc_querycap(struct file *file, void *priv,
2318 		struct v4l2_capability *capability)
2319 {
2320 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2321 
2322 	strlcpy(capability->driver, BCM2048_DRIVER_NAME,
2323 		sizeof(capability->driver));
2324 	strlcpy(capability->card, BCM2048_DRIVER_CARD,
2325 		sizeof(capability->card));
2326 	snprintf(capability->bus_info, 32, "I2C: 0x%X", bdev->client->addr);
2327 	capability->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO |
2328 					V4L2_CAP_HW_FREQ_SEEK;
2329 	capability->capabilities = capability->device_caps |
2330 		V4L2_CAP_DEVICE_CAPS;
2331 
2332 	return 0;
2333 }
2334 
bcm2048_vidioc_g_input(struct file * filp,void * priv,unsigned int * i)2335 static int bcm2048_vidioc_g_input(struct file *filp, void *priv,
2336 		unsigned int *i)
2337 {
2338 	*i = 0;
2339 
2340 	return 0;
2341 }
2342 
bcm2048_vidioc_s_input(struct file * filp,void * priv,unsigned int i)2343 static int bcm2048_vidioc_s_input(struct file *filp, void *priv,
2344 					unsigned int i)
2345 {
2346 	if (i)
2347 		return -EINVAL;
2348 
2349 	return 0;
2350 }
2351 
bcm2048_vidioc_queryctrl(struct file * file,void * priv,struct v4l2_queryctrl * qc)2352 static int bcm2048_vidioc_queryctrl(struct file *file, void *priv,
2353 		struct v4l2_queryctrl *qc)
2354 {
2355 	int i;
2356 
2357 	for (i = 0; i < ARRAY_SIZE(bcm2048_v4l2_queryctrl); i++) {
2358 		if (qc->id && qc->id == bcm2048_v4l2_queryctrl[i].id) {
2359 			*qc = bcm2048_v4l2_queryctrl[i];
2360 			return 0;
2361 		}
2362 	}
2363 
2364 	return -EINVAL;
2365 }
2366 
bcm2048_vidioc_g_ctrl(struct file * file,void * priv,struct v4l2_control * ctrl)2367 static int bcm2048_vidioc_g_ctrl(struct file *file, void *priv,
2368 		struct v4l2_control *ctrl)
2369 {
2370 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2371 	int err = 0;
2372 
2373 	if (!bdev)
2374 		return -ENODEV;
2375 
2376 	switch (ctrl->id) {
2377 	case V4L2_CID_AUDIO_MUTE:
2378 		err = bcm2048_get_mute(bdev);
2379 		if (err >= 0)
2380 			ctrl->value = err;
2381 		break;
2382 	}
2383 
2384 	return err;
2385 }
2386 
bcm2048_vidioc_s_ctrl(struct file * file,void * priv,struct v4l2_control * ctrl)2387 static int bcm2048_vidioc_s_ctrl(struct file *file, void *priv,
2388 		struct v4l2_control *ctrl)
2389 {
2390 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2391 	int err = 0;
2392 
2393 	if (!bdev)
2394 		return -ENODEV;
2395 
2396 	switch (ctrl->id) {
2397 	case V4L2_CID_AUDIO_MUTE:
2398 		if (ctrl->value) {
2399 			if (bdev->power_state) {
2400 				err = bcm2048_set_mute(bdev, ctrl->value);
2401 				err |= bcm2048_deinit(bdev);
2402 			}
2403 		} else {
2404 			if (!bdev->power_state) {
2405 				err = bcm2048_init(bdev);
2406 				err |= bcm2048_set_mute(bdev, ctrl->value);
2407 			}
2408 		}
2409 		break;
2410 	}
2411 
2412 	return err;
2413 }
2414 
bcm2048_vidioc_g_audio(struct file * file,void * priv,struct v4l2_audio * audio)2415 static int bcm2048_vidioc_g_audio(struct file *file, void *priv,
2416 		struct v4l2_audio *audio)
2417 {
2418 	if (audio->index > 1)
2419 		return -EINVAL;
2420 
2421 	strncpy(audio->name, "Radio", 32);
2422 	audio->capability = V4L2_AUDCAP_STEREO;
2423 
2424 	return 0;
2425 }
2426 
bcm2048_vidioc_s_audio(struct file * file,void * priv,const struct v4l2_audio * audio)2427 static int bcm2048_vidioc_s_audio(struct file *file, void *priv,
2428 		const struct v4l2_audio *audio)
2429 {
2430 	if (audio->index != 0)
2431 		return -EINVAL;
2432 
2433 	return 0;
2434 }
2435 
bcm2048_vidioc_g_tuner(struct file * file,void * priv,struct v4l2_tuner * tuner)2436 static int bcm2048_vidioc_g_tuner(struct file *file, void *priv,
2437 		struct v4l2_tuner *tuner)
2438 {
2439 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2440 	s8 f_error;
2441 	s8 rssi;
2442 
2443 	if (!bdev)
2444 		return -ENODEV;
2445 
2446 	if (tuner->index > 0)
2447 		return -EINVAL;
2448 
2449 	strncpy(tuner->name, "FM Receiver", 32);
2450 	tuner->type = V4L2_TUNER_RADIO;
2451 	tuner->rangelow =
2452 		dev_to_v4l2(bcm2048_get_region_bottom_frequency(bdev));
2453 	tuner->rangehigh =
2454 		dev_to_v4l2(bcm2048_get_region_top_frequency(bdev));
2455 	tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
2456 	tuner->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW;
2457 	tuner->audmode = V4L2_TUNER_MODE_STEREO;
2458 	tuner->afc = 0;
2459 	if (bdev->power_state) {
2460 		/*
2461 		 * Report frequencies with high carrier errors to have zero
2462 		 * signal level
2463 		 */
2464 		f_error = bcm2048_get_fm_carrier_error(bdev);
2465 		if (f_error < BCM2048_FREQ_ERROR_FLOOR ||
2466 		    f_error > BCM2048_FREQ_ERROR_ROOF) {
2467 			tuner->signal = 0;
2468 		} else {
2469 			/*
2470 			 * RSSI level -60 dB is defined to report full
2471 			 * signal strenght
2472 			 */
2473 			rssi = bcm2048_get_fm_rssi(bdev);
2474 			if (rssi >= BCM2048_RSSI_LEVEL_BASE) {
2475 				tuner->signal = 0xFFFF;
2476 			} else if (rssi > BCM2048_RSSI_LEVEL_ROOF) {
2477 				tuner->signal = (rssi +
2478 						 BCM2048_RSSI_LEVEL_ROOF_NEG)
2479 						 * BCM2048_SIGNAL_MULTIPLIER;
2480 			} else {
2481 				tuner->signal = 0;
2482 			}
2483 		}
2484 	} else {
2485 		tuner->signal = 0;
2486 	}
2487 
2488 	return 0;
2489 }
2490 
bcm2048_vidioc_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * tuner)2491 static int bcm2048_vidioc_s_tuner(struct file *file, void *priv,
2492 		const struct v4l2_tuner *tuner)
2493 {
2494 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2495 
2496 	if (!bdev)
2497 		return -ENODEV;
2498 
2499 	if (tuner->index > 0)
2500 		return -EINVAL;
2501 
2502 	return 0;
2503 }
2504 
bcm2048_vidioc_g_frequency(struct file * file,void * priv,struct v4l2_frequency * freq)2505 static int bcm2048_vidioc_g_frequency(struct file *file, void *priv,
2506 		struct v4l2_frequency *freq)
2507 {
2508 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2509 	int err = 0;
2510 	int f;
2511 
2512 	if (!bdev->power_state)
2513 		return -ENODEV;
2514 
2515 	freq->type = V4L2_TUNER_RADIO;
2516 	f = bcm2048_get_fm_frequency(bdev);
2517 
2518 	if (f < 0)
2519 		err = f;
2520 	else
2521 		freq->frequency = dev_to_v4l2(f);
2522 
2523 	return err;
2524 }
2525 
bcm2048_vidioc_s_frequency(struct file * file,void * priv,const struct v4l2_frequency * freq)2526 static int bcm2048_vidioc_s_frequency(struct file *file, void *priv,
2527 		const struct v4l2_frequency *freq)
2528 {
2529 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2530 	int err;
2531 
2532 	if (freq->type != V4L2_TUNER_RADIO)
2533 		return -EINVAL;
2534 
2535 	if (!bdev->power_state)
2536 		return -ENODEV;
2537 
2538 	err = bcm2048_set_fm_frequency(bdev, v4l2_to_dev(freq->frequency));
2539 	err |= bcm2048_set_fm_search_tune_mode(bdev, BCM2048_FM_PRE_SET_MODE);
2540 
2541 	return err;
2542 }
2543 
bcm2048_vidioc_s_hw_freq_seek(struct file * file,void * priv,const struct v4l2_hw_freq_seek * seek)2544 static int bcm2048_vidioc_s_hw_freq_seek(struct file *file, void *priv,
2545 					const struct v4l2_hw_freq_seek *seek)
2546 {
2547 	struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file));
2548 	int err;
2549 
2550 	if (!bdev->power_state)
2551 		return -ENODEV;
2552 
2553 	if ((seek->tuner != 0) || (seek->type != V4L2_TUNER_RADIO))
2554 		return -EINVAL;
2555 
2556 	err = bcm2048_set_fm_search_mode_direction(bdev, seek->seek_upward);
2557 	err |= bcm2048_set_fm_search_tune_mode(bdev,
2558 			BCM2048_FM_AUTO_SEARCH_MODE);
2559 
2560 	return err;
2561 }
2562 
2563 static struct v4l2_ioctl_ops bcm2048_ioctl_ops = {
2564 	.vidioc_querycap	= bcm2048_vidioc_querycap,
2565 	.vidioc_g_input		= bcm2048_vidioc_g_input,
2566 	.vidioc_s_input		= bcm2048_vidioc_s_input,
2567 	.vidioc_queryctrl	= bcm2048_vidioc_queryctrl,
2568 	.vidioc_g_ctrl		= bcm2048_vidioc_g_ctrl,
2569 	.vidioc_s_ctrl		= bcm2048_vidioc_s_ctrl,
2570 	.vidioc_g_audio		= bcm2048_vidioc_g_audio,
2571 	.vidioc_s_audio		= bcm2048_vidioc_s_audio,
2572 	.vidioc_g_tuner		= bcm2048_vidioc_g_tuner,
2573 	.vidioc_s_tuner		= bcm2048_vidioc_s_tuner,
2574 	.vidioc_g_frequency	= bcm2048_vidioc_g_frequency,
2575 	.vidioc_s_frequency	= bcm2048_vidioc_s_frequency,
2576 	.vidioc_s_hw_freq_seek  = bcm2048_vidioc_s_hw_freq_seek,
2577 };
2578 
2579 /*
2580  * bcm2048_viddev_template - video device interface
2581  */
2582 static struct video_device bcm2048_viddev_template = {
2583 	.fops			= &bcm2048_fops,
2584 	.name			= BCM2048_DRIVER_NAME,
2585 	.release		= video_device_release_empty,
2586 	.ioctl_ops		= &bcm2048_ioctl_ops,
2587 };
2588 
2589 /*
2590  *	I2C driver interface
2591  */
bcm2048_i2c_driver_probe(struct i2c_client * client,const struct i2c_device_id * id)2592 static int bcm2048_i2c_driver_probe(struct i2c_client *client,
2593 					const struct i2c_device_id *id)
2594 {
2595 	struct bcm2048_device *bdev;
2596 	int err, skip_release = 0;
2597 
2598 	bdev = kzalloc(sizeof(*bdev), GFP_KERNEL);
2599 	if (!bdev) {
2600 		err = -ENOMEM;
2601 		goto exit;
2602 	}
2603 
2604 	bdev->client = client;
2605 	i2c_set_clientdata(client, bdev);
2606 	mutex_init(&bdev->mutex);
2607 	init_completion(&bdev->compl);
2608 	INIT_WORK(&bdev->work, bcm2048_work);
2609 
2610 	if (client->irq) {
2611 		err = request_irq(client->irq,
2612 			bcm2048_handler, IRQF_TRIGGER_FALLING,
2613 			client->name, bdev);
2614 		if (err < 0) {
2615 			dev_err(&client->dev, "Could not request IRQ\n");
2616 			goto free_bdev;
2617 		}
2618 		dev_dbg(&client->dev, "IRQ requested.\n");
2619 	} else {
2620 		dev_dbg(&client->dev, "IRQ not configured. Using timeouts.\n");
2621 	}
2622 
2623 	bdev->videodev = bcm2048_viddev_template;
2624 	video_set_drvdata(&bdev->videodev, bdev);
2625 	if (video_register_device(&bdev->videodev, VFL_TYPE_RADIO, radio_nr)) {
2626 		dev_dbg(&client->dev, "Could not register video device.\n");
2627 		err = -EIO;
2628 		goto free_irq;
2629 	}
2630 
2631 	err = bcm2048_sysfs_register_properties(bdev);
2632 	if (err < 0) {
2633 		dev_dbg(&client->dev, "Could not register sysfs interface.\n");
2634 		goto free_registration;
2635 	}
2636 
2637 	err = bcm2048_probe(bdev);
2638 	if (err < 0) {
2639 		dev_dbg(&client->dev, "Failed to probe device information.\n");
2640 		goto free_sysfs;
2641 	}
2642 
2643 	return 0;
2644 
2645 free_sysfs:
2646 	bcm2048_sysfs_unregister_properties(bdev, ARRAY_SIZE(attrs));
2647 free_registration:
2648 	video_unregister_device(&bdev->videodev);
2649 	skip_release = 1;
2650 free_irq:
2651 	if (client->irq)
2652 		free_irq(client->irq, bdev);
2653 free_bdev:
2654 	i2c_set_clientdata(client, NULL);
2655 	kfree(bdev);
2656 exit:
2657 	return err;
2658 }
2659 
bcm2048_i2c_driver_remove(struct i2c_client * client)2660 static int __exit bcm2048_i2c_driver_remove(struct i2c_client *client)
2661 {
2662 	struct bcm2048_device *bdev = i2c_get_clientdata(client);
2663 
2664 	if (!client->adapter)
2665 		return -ENODEV;
2666 
2667 	if (bdev) {
2668 		bcm2048_sysfs_unregister_properties(bdev, ARRAY_SIZE(attrs));
2669 		video_unregister_device(&bdev->videodev);
2670 
2671 		if (bdev->power_state)
2672 			bcm2048_set_power_state(bdev, BCM2048_POWER_OFF);
2673 
2674 		if (client->irq > 0)
2675 			free_irq(client->irq, bdev);
2676 
2677 		cancel_work_sync(&bdev->work);
2678 
2679 		kfree(bdev);
2680 	}
2681 
2682 	return 0;
2683 }
2684 
2685 /*
2686  *	bcm2048_i2c_driver - i2c driver interface
2687  */
2688 static const struct i2c_device_id bcm2048_id[] = {
2689 	{ "bcm2048", 0 },
2690 	{ },
2691 };
2692 MODULE_DEVICE_TABLE(i2c, bcm2048_id);
2693 
2694 static struct i2c_driver bcm2048_i2c_driver = {
2695 	.driver		= {
2696 		.name	= BCM2048_DRIVER_NAME,
2697 	},
2698 	.probe		= bcm2048_i2c_driver_probe,
2699 	.remove		= __exit_p(bcm2048_i2c_driver_remove),
2700 	.id_table	= bcm2048_id,
2701 };
2702 
2703 module_i2c_driver(bcm2048_i2c_driver);
2704 
2705 MODULE_LICENSE("GPL");
2706 MODULE_AUTHOR(BCM2048_DRIVER_AUTHOR);
2707 MODULE_DESCRIPTION(BCM2048_DRIVER_DESC);
2708 MODULE_VERSION("0.0.2");
2709