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