?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2800: initialize BBP_R104 on proper subroutines
[linux/fpc-iii.git] / drivers / media / radio / radio-tea5764.c
blob38d563d625956a35f8beda12deb3442adc27f43a
1 /*
2 * driver/media/radio/radio-tea5764.c
3 *
4 * Driver for TEA5764 radio chip for linux 2.6.
5 * This driver is for TEA5764 chip from NXP, used in EZX phones from Motorola.
6 * The I2C protocol is used for communicate with chip.
7 *
8 * Based in radio-tea5761.c Copyright (C) 2005 Nokia Corporation
9 *
10 * Copyright (c) 2008 Fabio Belavenuto <belavenuto@gmail.com>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 * History:
27 * 2008-12-06 Fabio Belavenuto <belavenuto@gmail.com>
28 * initial code
29 *
30 * TODO:
31 * add platform_data support for IRQs platform dependencies
32 * add RDS support
33 */
34 #include <linux/kernel.h>
35 #include <linux/slab.h>
36 #include <linux/module.h>
37 #include <linux/init.h> /* Initdata */
38 #include <linux/videodev2.h> /* kernel radio structs */
39 #include <linux/i2c.h> /* I2C */
40 #include <media/v4l2-common.h>
41 #include <media/v4l2-ioctl.h>
42
43 #define DRIVER_VERSION "0.0.2"
44
45 #define DRIVER_AUTHOR "Fabio Belavenuto <belavenuto@gmail.com>"
46 #define DRIVER_DESC "A driver for the TEA5764 radio chip for EZX Phones."
47
48 #define PINFO(format, ...)\
49 printk(KERN_INFO KBUILD_MODNAME ": "\
50 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
51 #define PWARN(format, ...)\
52 printk(KERN_WARNING KBUILD_MODNAME ": "\
53 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
54 # define PDEBUG(format, ...)\
55 printk(KERN_DEBUG KBUILD_MODNAME ": "\
56 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
57
58 /* Frequency limits in MHz -- these are European values. For Japanese
59 devices, that would be 76000 and 91000. */
60 #define FREQ_MIN 87500
61 #define FREQ_MAX 108000
62 #define FREQ_MUL 16
63
64 /* TEA5764 registers */
65 #define TEA5764_MANID 0x002b
66 #define TEA5764_CHIPID 0x5764
67
68 #define TEA5764_INTREG_BLMSK 0x0001
69 #define TEA5764_INTREG_FRRMSK 0x0002
70 #define TEA5764_INTREG_LEVMSK 0x0008
71 #define TEA5764_INTREG_IFMSK 0x0010
72 #define TEA5764_INTREG_BLMFLAG 0x0100
73 #define TEA5764_INTREG_FRRFLAG 0x0200
74 #define TEA5764_INTREG_LEVFLAG 0x0800
75 #define TEA5764_INTREG_IFFLAG 0x1000
76
77 #define TEA5764_FRQSET_SUD 0x8000
78 #define TEA5764_FRQSET_SM 0x4000
79
80 #define TEA5764_TNCTRL_PUPD1 0x8000
81 #define TEA5764_TNCTRL_PUPD0 0x4000
82 #define TEA5764_TNCTRL_BLIM 0x2000
83 #define TEA5764_TNCTRL_SWPM 0x1000
84 #define TEA5764_TNCTRL_IFCTC 0x0800
85 #define TEA5764_TNCTRL_AFM 0x0400
86 #define TEA5764_TNCTRL_SMUTE 0x0200
87 #define TEA5764_TNCTRL_SNC 0x0100
88 #define TEA5764_TNCTRL_MU 0x0080
89 #define TEA5764_TNCTRL_SSL1 0x0040
90 #define TEA5764_TNCTRL_SSL0 0x0020
91 #define TEA5764_TNCTRL_HLSI 0x0010
92 #define TEA5764_TNCTRL_MST 0x0008
93 #define TEA5764_TNCTRL_SWP 0x0004
94 #define TEA5764_TNCTRL_DTC 0x0002
95 #define TEA5764_TNCTRL_AHLSI 0x0001
96
97 #define TEA5764_TUNCHK_LEVEL(x) (((x) & 0x00F0) >> 4)
98 #define TEA5764_TUNCHK_IFCNT(x) (((x) & 0xFE00) >> 9)
99 #define TEA5764_TUNCHK_TUNTO 0x0100
100 #define TEA5764_TUNCHK_LD 0x0008
101 #define TEA5764_TUNCHK_STEREO 0x0004
102
103 #define TEA5764_TESTREG_TRIGFR 0x0800
104
105 struct tea5764_regs {
106 u16 intreg; /* INTFLAG & INTMSK */
107 u16 frqset; /* FRQSETMSB & FRQSETLSB */
108 u16 tnctrl; /* TNCTRL1 & TNCTRL2 */
109 u16 frqchk; /* FRQCHKMSB & FRQCHKLSB */
110 u16 tunchk; /* IFCHK & LEVCHK */
111 u16 testreg; /* TESTBITS & TESTMODE */
112 u16 rdsstat; /* RDSSTAT1 & RDSSTAT2 */
113 u16 rdslb; /* RDSLBMSB & RDSLBLSB */
114 u16 rdspb; /* RDSPBMSB & RDSPBLSB */
115 u16 rdsbc; /* RDSBBC & RDSGBC */
116 u16 rdsctrl; /* RDSCTRL1 & RDSCTRL2 */
117 u16 rdsbbl; /* PAUSEDET & RDSBBL */
118 u16 manid; /* MANID1 & MANID2 */
119 u16 chipid; /* CHIPID1 & CHIPID2 */
120 } __attribute__ ((packed));
121
122 struct tea5764_write_regs {
123 u8 intreg; /* INTMSK */
124 u16 frqset; /* FRQSETMSB & FRQSETLSB */
125 u16 tnctrl; /* TNCTRL1 & TNCTRL2 */
126 u16 testreg; /* TESTBITS & TESTMODE */
127 u16 rdsctrl; /* RDSCTRL1 & RDSCTRL2 */
128 u16 rdsbbl; /* PAUSEDET & RDSBBL */
129 } __attribute__ ((packed));
130
131 #ifdef CONFIG_RADIO_TEA5764_XTAL
132 #define RADIO_TEA5764_XTAL 1
133 #else
134 #define RADIO_TEA5764_XTAL 0
135 #endif
136
137 static int radio_nr = -1;
138 static int use_xtal = RADIO_TEA5764_XTAL;
139
140 struct tea5764_device {
141 struct i2c_client *i2c_client;
142 struct video_device *videodev;
143 struct tea5764_regs regs;
144 struct mutex mutex;
145 };
146
147 /* I2C code related */
148 static int tea5764_i2c_read(struct tea5764_device *radio)
149 {
150 int i;
151 u16 *p = (u16 *) &radio->regs;
152
153 struct i2c_msg msgs[1] = {
154 { .addr = radio->i2c_client->addr,
155 .flags = I2C_M_RD,
156 .len = sizeof(radio->regs),
157 .buf = (void *)&radio->regs
158 },
159 };
160 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
161 return -EIO;
162 for (i = 0; i < sizeof(struct tea5764_regs) / sizeof(u16); i++)
163 p[i] = __be16_to_cpu(p[i]);
164
165 return 0;
166 }
167
168 static int tea5764_i2c_write(struct tea5764_device *radio)
169 {
170 struct tea5764_write_regs wr;
171 struct tea5764_regs *r = &radio->regs;
172 struct i2c_msg msgs[1] = {
173 {
174 .addr = radio->i2c_client->addr,
175 .len = sizeof(wr),
176 .buf = (void *)&wr
177 },
178 };
179 wr.intreg = r->intreg & 0xff;
180 wr.frqset = __cpu_to_be16(r->frqset);
181 wr.tnctrl = __cpu_to_be16(r->tnctrl);
182 wr.testreg = __cpu_to_be16(r->testreg);
183 wr.rdsctrl = __cpu_to_be16(r->rdsctrl);
184 wr.rdsbbl = __cpu_to_be16(r->rdsbbl);
185 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
186 return -EIO;
187 return 0;
188 }
189
190 /* V4L2 code related */
191 static struct v4l2_queryctrl radio_qctrl[] = {
192 {
193 .id = V4L2_CID_AUDIO_MUTE,
194 .name = "Mute",
195 .minimum = 0,
196 .maximum = 1,
197 .default_value = 1,
198 .type = V4L2_CTRL_TYPE_BOOLEAN,
199 }
200 };
201
202 static void tea5764_power_up(struct tea5764_device *radio)
203 {
204 struct tea5764_regs *r = &radio->regs;
205
206 if (!(r->tnctrl & TEA5764_TNCTRL_PUPD0)) {
207 r->tnctrl &= ~(TEA5764_TNCTRL_AFM | TEA5764_TNCTRL_MU |
208 TEA5764_TNCTRL_HLSI);
209 if (!use_xtal)
210 r->testreg |= TEA5764_TESTREG_TRIGFR;
211 else
212 r->testreg &= ~TEA5764_TESTREG_TRIGFR;
213
214 r->tnctrl |= TEA5764_TNCTRL_PUPD0;
215 tea5764_i2c_write(radio);
216 }
217 }
218
219 static void tea5764_power_down(struct tea5764_device *radio)
220 {
221 struct tea5764_regs *r = &radio->regs;
222
223 if (r->tnctrl & TEA5764_TNCTRL_PUPD0) {
224 r->tnctrl &= ~TEA5764_TNCTRL_PUPD0;
225 tea5764_i2c_write(radio);
226 }
227 }
228
229 static void tea5764_set_freq(struct tea5764_device *radio, int freq)
230 {
231 struct tea5764_regs *r = &radio->regs;
232
233 /* formula: (freq [+ or -] 225000) / 8192 */
234 if (r->tnctrl & TEA5764_TNCTRL_HLSI)
235 r->frqset = (freq + 225000) / 8192;
236 else
237 r->frqset = (freq - 225000) / 8192;
238 }
239
240 static int tea5764_get_freq(struct tea5764_device *radio)
241 {
242 struct tea5764_regs *r = &radio->regs;
243
244 if (r->tnctrl & TEA5764_TNCTRL_HLSI)
245 return (r->frqchk * 8192) - 225000;
246 else
247 return (r->frqchk * 8192) + 225000;
248 }
249
250 /* tune an frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
251 static void tea5764_tune(struct tea5764_device *radio, int freq)
252 {
253 tea5764_set_freq(radio, freq);
254 if (tea5764_i2c_write(radio))
255 PWARN("Could not set frequency!");
256 }
257
258 static void tea5764_set_audout_mode(struct tea5764_device *radio, int audmode)
259 {
260 struct tea5764_regs *r = &radio->regs;
261 int tnctrl = r->tnctrl;
262
263 if (audmode == V4L2_TUNER_MODE_MONO)
264 r->tnctrl |= TEA5764_TNCTRL_MST;
265 else
266 r->tnctrl &= ~TEA5764_TNCTRL_MST;
267 if (tnctrl != r->tnctrl)
268 tea5764_i2c_write(radio);
269 }
270
271 static int tea5764_get_audout_mode(struct tea5764_device *radio)
272 {
273 struct tea5764_regs *r = &radio->regs;
274
275 if (r->tnctrl & TEA5764_TNCTRL_MST)
276 return V4L2_TUNER_MODE_MONO;
277 else
278 return V4L2_TUNER_MODE_STEREO;
279 }
280
281 static void tea5764_mute(struct tea5764_device *radio, int on)
282 {
283 struct tea5764_regs *r = &radio->regs;
284 int tnctrl = r->tnctrl;
285
286 if (on)
287 r->tnctrl |= TEA5764_TNCTRL_MU;
288 else
289 r->tnctrl &= ~TEA5764_TNCTRL_MU;
290 if (tnctrl != r->tnctrl)
291 tea5764_i2c_write(radio);
292 }
293
294 static int tea5764_is_muted(struct tea5764_device *radio)
295 {
296 return radio->regs.tnctrl & TEA5764_TNCTRL_MU;
297 }
298
299 /* V4L2 vidioc */
300 static int vidioc_querycap(struct file *file, void *priv,
301 struct v4l2_capability *v)
302 {
303 struct tea5764_device *radio = video_drvdata(file);
304 struct video_device *dev = radio->videodev;
305
306 strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
307 strlcpy(v->card, dev->name, sizeof(v->card));
308 snprintf(v->bus_info, sizeof(v->bus_info),
309 "I2C:%s", dev_name(&dev->dev));
310 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
311 return 0;
312 }
313
314 static int vidioc_g_tuner(struct file *file, void *priv,
315 struct v4l2_tuner *v)
316 {
317 struct tea5764_device *radio = video_drvdata(file);
318 struct tea5764_regs *r = &radio->regs;
319
320 if (v->index > 0)
321 return -EINVAL;
322
323 memset(v, 0, sizeof(*v));
324 strcpy(v->name, "FM");
325 v->type = V4L2_TUNER_RADIO;
326 tea5764_i2c_read(radio);
327 v->rangelow = FREQ_MIN * FREQ_MUL;
328 v->rangehigh = FREQ_MAX * FREQ_MUL;
329 v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
330 if (r->tunchk & TEA5764_TUNCHK_STEREO)
331 v->rxsubchans = V4L2_TUNER_SUB_STEREO;
332 else
333 v->rxsubchans = V4L2_TUNER_SUB_MONO;
334 v->audmode = tea5764_get_audout_mode(radio);
335 v->signal = TEA5764_TUNCHK_LEVEL(r->tunchk) * 0xffff / 0xf;
336 v->afc = TEA5764_TUNCHK_IFCNT(r->tunchk);
337
338 return 0;
339 }
340
341 static int vidioc_s_tuner(struct file *file, void *priv,
342 const struct v4l2_tuner *v)
343 {
344 struct tea5764_device *radio = video_drvdata(file);
345
346 if (v->index > 0)
347 return -EINVAL;
348
349 tea5764_set_audout_mode(radio, v->audmode);
350 return 0;
351 }
352
353 static int vidioc_s_frequency(struct file *file, void *priv,
354 const struct v4l2_frequency *f)
355 {
356 struct tea5764_device *radio = video_drvdata(file);
357
358 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
359 return -EINVAL;
360 if (f->frequency == 0) {
361 /* We special case this as a power down control. */
362 tea5764_power_down(radio);
363 }
364 if (f->frequency < (FREQ_MIN * FREQ_MUL))
365 return -EINVAL;
366 if (f->frequency > (FREQ_MAX * FREQ_MUL))
367 return -EINVAL;
368 tea5764_power_up(radio);
369 tea5764_tune(radio, (f->frequency * 125) / 2);
370 return 0;
371 }
372
373 static int vidioc_g_frequency(struct file *file, void *priv,
374 struct v4l2_frequency *f)
375 {
376 struct tea5764_device *radio = video_drvdata(file);
377 struct tea5764_regs *r = &radio->regs;
378
379 if (f->tuner != 0)
380 return -EINVAL;
381 tea5764_i2c_read(radio);
382 memset(f, 0, sizeof(*f));
383 f->type = V4L2_TUNER_RADIO;
384 if (r->tnctrl & TEA5764_TNCTRL_PUPD0)
385 f->frequency = (tea5764_get_freq(radio) * 2) / 125;
386 else
387 f->frequency = 0;
388
389 return 0;
390 }
391
392 static int vidioc_queryctrl(struct file *file, void *priv,
393 struct v4l2_queryctrl *qc)
394 {
395 int i;
396
397 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
398 if (qc->id && qc->id == radio_qctrl[i].id) {
399 memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
400 return 0;
401 }
402 }
403 return -EINVAL;
404 }
405
406 static int vidioc_g_ctrl(struct file *file, void *priv,
407 struct v4l2_control *ctrl)
408 {
409 struct tea5764_device *radio = video_drvdata(file);
410
411 switch (ctrl->id) {
412 case V4L2_CID_AUDIO_MUTE:
413 tea5764_i2c_read(radio);
414 ctrl->value = tea5764_is_muted(radio) ? 1 : 0;
415 return 0;
416 }
417 return -EINVAL;
418 }
419
420 static int vidioc_s_ctrl(struct file *file, void *priv,
421 struct v4l2_control *ctrl)
422 {
423 struct tea5764_device *radio = video_drvdata(file);
424
425 switch (ctrl->id) {
426 case V4L2_CID_AUDIO_MUTE:
427 tea5764_mute(radio, ctrl->value);
428 return 0;
429 }
430 return -EINVAL;
431 }
432
433 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
434 {
435 *i = 0;
436 return 0;
437 }
438
439 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
440 {
441 if (i != 0)
442 return -EINVAL;
443 return 0;
444 }
445
446 static int vidioc_g_audio(struct file *file, void *priv,
447 struct v4l2_audio *a)
448 {
449 if (a->index > 1)
450 return -EINVAL;
451
452 strcpy(a->name, "Radio");
453 a->capability = V4L2_AUDCAP_STEREO;
454 return 0;
455 }
456
457 static int vidioc_s_audio(struct file *file, void *priv,
458 const struct v4l2_audio *a)
459 {
460 if (a->index != 0)
461 return -EINVAL;
462
463 return 0;
464 }
465
466 /* File system interface */
467 static const struct v4l2_file_operations tea5764_fops = {
468 .owner = THIS_MODULE,
469 .unlocked_ioctl = video_ioctl2,
470 };
471
472 static const struct v4l2_ioctl_ops tea5764_ioctl_ops = {
473 .vidioc_querycap = vidioc_querycap,
474 .vidioc_g_tuner = vidioc_g_tuner,
475 .vidioc_s_tuner = vidioc_s_tuner,
476 .vidioc_g_audio = vidioc_g_audio,
477 .vidioc_s_audio = vidioc_s_audio,
478 .vidioc_g_input = vidioc_g_input,
479 .vidioc_s_input = vidioc_s_input,
480 .vidioc_g_frequency = vidioc_g_frequency,
481 .vidioc_s_frequency = vidioc_s_frequency,
482 .vidioc_queryctrl = vidioc_queryctrl,
483 .vidioc_g_ctrl = vidioc_g_ctrl,
484 .vidioc_s_ctrl = vidioc_s_ctrl,
485 };
486
487 /* V4L2 interface */
488 static struct video_device tea5764_radio_template = {
489 .name = "TEA5764 FM-Radio",
490 .fops = &tea5764_fops,
491 .ioctl_ops = &tea5764_ioctl_ops,
492 .release = video_device_release,
493 };
494
495 /* I2C probe: check if the device exists and register with v4l if it is */
496 static int tea5764_i2c_probe(struct i2c_client *client,
497 const struct i2c_device_id *id)
498 {
499 struct tea5764_device *radio;
500 struct tea5764_regs *r;
501 int ret;
502
503 PDEBUG("probe");
504 radio = kzalloc(sizeof(struct tea5764_device), GFP_KERNEL);
505 if (!radio)
506 return -ENOMEM;
507
508 mutex_init(&radio->mutex);
509 radio->i2c_client = client;
510 ret = tea5764_i2c_read(radio);
511 if (ret)
512 goto errfr;
513 r = &radio->regs;
514 PDEBUG("chipid = %04X, manid = %04X", r->chipid, r->manid);
515 if (r->chipid != TEA5764_CHIPID ||
516 (r->manid & 0x0fff) != TEA5764_MANID) {
517 PWARN("This chip is not a TEA5764!");
518 ret = -EINVAL;
519 goto errfr;
520 }
521
522 radio->videodev = video_device_alloc();
523 if (!(radio->videodev)) {
524 ret = -ENOMEM;
525 goto errfr;
526 }
527 memcpy(radio->videodev, &tea5764_radio_template,
528 sizeof(tea5764_radio_template));
529
530 i2c_set_clientdata(client, radio);
531 video_set_drvdata(radio->videodev, radio);
532 radio->videodev->lock = &radio->mutex;
533
534 /* initialize and power off the chip */
535 tea5764_i2c_read(radio);
536 tea5764_set_audout_mode(radio, V4L2_TUNER_MODE_STEREO);
537 tea5764_mute(radio, 1);
538 tea5764_power_down(radio);
539
540 ret = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr);
541 if (ret < 0) {
542 PWARN("Could not register video device!");
543 goto errrel;
544 }
545
546 PINFO("registered.");
547 return 0;
548 errrel:
549 video_device_release(radio->videodev);
550 errfr:
551 kfree(radio);
552 return ret;
553 }
554
555 static int tea5764_i2c_remove(struct i2c_client *client)
556 {
557 struct tea5764_device *radio = i2c_get_clientdata(client);
558
559 PDEBUG("remove");
560 if (radio) {
561 tea5764_power_down(radio);
562 video_unregister_device(radio->videodev);
563 kfree(radio);
564 }
565 return 0;
566 }
567
568 /* I2C subsystem interface */
569 static const struct i2c_device_id tea5764_id[] = {
570 { "radio-tea5764", 0 },
571 { } /* Terminating entry */
572 };
573 MODULE_DEVICE_TABLE(i2c, tea5764_id);
574
575 static struct i2c_driver tea5764_i2c_driver = {
576 .driver = {
577 .name = "radio-tea5764",
578 .owner = THIS_MODULE,
579 },
580 .probe = tea5764_i2c_probe,
581 .remove = tea5764_i2c_remove,
582 .id_table = tea5764_id,
583 };
584
585 module_i2c_driver(tea5764_i2c_driver);
586
587 MODULE_AUTHOR(DRIVER_AUTHOR);
588 MODULE_DESCRIPTION(DRIVER_DESC);
589 MODULE_LICENSE("GPL");
590 MODULE_VERSION(DRIVER_VERSION);
591
592 module_param(use_xtal, int, 0);
593 MODULE_PARM_DESC(use_xtal, "Chip have a xtal connected in board");
594 module_param(radio_nr, int, 0);
595 MODULE_PARM_DESC(radio_nr, "video4linux device number to use");
Linux with added FPC-III support