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