1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <linux/kernel.h>
35#include <linux/slab.h>
36#include <linux/module.h>
37#include <linux/init.h>
38#include <linux/videodev2.h>
39#include <linux/i2c.h>
40#include <media/v4l2-common.h>
41#include <media/v4l2-ioctl.h>
42#include <media/v4l2-device.h>
43#include <media/v4l2-ctrls.h>
44#include <media/v4l2-event.h>
45
46#define DRIVER_VERSION "0.0.2"
47
48#define DRIVER_AUTHOR "Fabio Belavenuto <belavenuto@gmail.com>"
49#define DRIVER_DESC "A driver for the TEA5764 radio chip for EZX Phones."
50
51#define PINFO(format, ...)\
52 printk(KERN_INFO KBUILD_MODNAME ": "\
53 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
54#define PWARN(format, ...)\
55 printk(KERN_WARNING KBUILD_MODNAME ": "\
56 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
57# define PDEBUG(format, ...)\
58 printk(KERN_DEBUG KBUILD_MODNAME ": "\
59 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
60
61
62
63#define FREQ_MIN 87500U
64#define FREQ_MAX 108000U
65#define FREQ_MUL 16
66
67
68#define TEA5764_MANID 0x002b
69#define TEA5764_CHIPID 0x5764
70
71#define TEA5764_INTREG_BLMSK 0x0001
72#define TEA5764_INTREG_FRRMSK 0x0002
73#define TEA5764_INTREG_LEVMSK 0x0008
74#define TEA5764_INTREG_IFMSK 0x0010
75#define TEA5764_INTREG_BLMFLAG 0x0100
76#define TEA5764_INTREG_FRRFLAG 0x0200
77#define TEA5764_INTREG_LEVFLAG 0x0800
78#define TEA5764_INTREG_IFFLAG 0x1000
79
80#define TEA5764_FRQSET_SUD 0x8000
81#define TEA5764_FRQSET_SM 0x4000
82
83#define TEA5764_TNCTRL_PUPD1 0x8000
84#define TEA5764_TNCTRL_PUPD0 0x4000
85#define TEA5764_TNCTRL_BLIM 0x2000
86#define TEA5764_TNCTRL_SWPM 0x1000
87#define TEA5764_TNCTRL_IFCTC 0x0800
88#define TEA5764_TNCTRL_AFM 0x0400
89#define TEA5764_TNCTRL_SMUTE 0x0200
90#define TEA5764_TNCTRL_SNC 0x0100
91#define TEA5764_TNCTRL_MU 0x0080
92#define TEA5764_TNCTRL_SSL1 0x0040
93#define TEA5764_TNCTRL_SSL0 0x0020
94#define TEA5764_TNCTRL_HLSI 0x0010
95#define TEA5764_TNCTRL_MST 0x0008
96#define TEA5764_TNCTRL_SWP 0x0004
97#define TEA5764_TNCTRL_DTC 0x0002
98#define TEA5764_TNCTRL_AHLSI 0x0001
99
100#define TEA5764_TUNCHK_LEVEL(x) (((x) & 0x00F0) >> 4)
101#define TEA5764_TUNCHK_IFCNT(x) (((x) & 0xFE00) >> 9)
102#define TEA5764_TUNCHK_TUNTO 0x0100
103#define TEA5764_TUNCHK_LD 0x0008
104#define TEA5764_TUNCHK_STEREO 0x0004
105
106#define TEA5764_TESTREG_TRIGFR 0x0800
107
108struct tea5764_regs {
109 u16 intreg;
110 u16 frqset;
111 u16 tnctrl;
112 u16 frqchk;
113 u16 tunchk;
114 u16 testreg;
115 u16 rdsstat;
116 u16 rdslb;
117 u16 rdspb;
118 u16 rdsbc;
119 u16 rdsctrl;
120 u16 rdsbbl;
121 u16 manid;
122 u16 chipid;
123} __attribute__ ((packed));
124
125struct tea5764_write_regs {
126 u8 intreg;
127 u16 frqset;
128 u16 tnctrl;
129 u16 testreg;
130 u16 rdsctrl;
131 u16 rdsbbl;
132} __attribute__ ((packed));
133
134#ifdef CONFIG_RADIO_TEA5764_XTAL
135#define RADIO_TEA5764_XTAL 1
136#else
137#define RADIO_TEA5764_XTAL 0
138#endif
139
140static int radio_nr = -1;
141static int use_xtal = RADIO_TEA5764_XTAL;
142
143struct tea5764_device {
144 struct v4l2_device v4l2_dev;
145 struct v4l2_ctrl_handler ctrl_handler;
146 struct i2c_client *i2c_client;
147 struct video_device vdev;
148 struct tea5764_regs regs;
149 struct mutex mutex;
150};
151
152
153static int tea5764_i2c_read(struct tea5764_device *radio)
154{
155 int i;
156 u16 *p = (u16 *) &radio->regs;
157
158 struct i2c_msg msgs[1] = {
159 { .addr = radio->i2c_client->addr,
160 .flags = I2C_M_RD,
161 .len = sizeof(radio->regs),
162 .buf = (void *)&radio->regs
163 },
164 };
165 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
166 return -EIO;
167 for (i = 0; i < sizeof(struct tea5764_regs) / sizeof(u16); i++)
168 p[i] = __be16_to_cpu(p[i]);
169
170 return 0;
171}
172
173static int tea5764_i2c_write(struct tea5764_device *radio)
174{
175 struct tea5764_write_regs wr;
176 struct tea5764_regs *r = &radio->regs;
177 struct i2c_msg msgs[1] = {
178 {
179 .addr = radio->i2c_client->addr,
180 .len = sizeof(wr),
181 .buf = (void *)&wr
182 },
183 };
184 wr.intreg = r->intreg & 0xff;
185 wr.frqset = __cpu_to_be16(r->frqset);
186 wr.tnctrl = __cpu_to_be16(r->tnctrl);
187 wr.testreg = __cpu_to_be16(r->testreg);
188 wr.rdsctrl = __cpu_to_be16(r->rdsctrl);
189 wr.rdsbbl = __cpu_to_be16(r->rdsbbl);
190 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
191 return -EIO;
192 return 0;
193}
194
195static void tea5764_power_up(struct tea5764_device *radio)
196{
197 struct tea5764_regs *r = &radio->regs;
198
199 if (!(r->tnctrl & TEA5764_TNCTRL_PUPD0)) {
200 r->tnctrl &= ~(TEA5764_TNCTRL_AFM | TEA5764_TNCTRL_MU |
201 TEA5764_TNCTRL_HLSI);
202 if (!use_xtal)
203 r->testreg |= TEA5764_TESTREG_TRIGFR;
204 else
205 r->testreg &= ~TEA5764_TESTREG_TRIGFR;
206
207 r->tnctrl |= TEA5764_TNCTRL_PUPD0;
208 tea5764_i2c_write(radio);
209 }
210}
211
212static void tea5764_power_down(struct tea5764_device *radio)
213{
214 struct tea5764_regs *r = &radio->regs;
215
216 if (r->tnctrl & TEA5764_TNCTRL_PUPD0) {
217 r->tnctrl &= ~TEA5764_TNCTRL_PUPD0;
218 tea5764_i2c_write(radio);
219 }
220}
221
222static void tea5764_set_freq(struct tea5764_device *radio, int freq)
223{
224 struct tea5764_regs *r = &radio->regs;
225
226
227 if (r->tnctrl & TEA5764_TNCTRL_HLSI)
228 r->frqset = (freq + 225000) / 8192;
229 else
230 r->frqset = (freq - 225000) / 8192;
231}
232
233static int tea5764_get_freq(struct tea5764_device *radio)
234{
235 struct tea5764_regs *r = &radio->regs;
236
237 if (r->tnctrl & TEA5764_TNCTRL_HLSI)
238 return (r->frqchk * 8192) - 225000;
239 else
240 return (r->frqchk * 8192) + 225000;
241}
242
243
244static void tea5764_tune(struct tea5764_device *radio, int freq)
245{
246 tea5764_set_freq(radio, freq);
247 if (tea5764_i2c_write(radio))
248 PWARN("Could not set frequency!");
249}
250
251static void tea5764_set_audout_mode(struct tea5764_device *radio, int audmode)
252{
253 struct tea5764_regs *r = &radio->regs;
254 int tnctrl = r->tnctrl;
255
256 if (audmode == V4L2_TUNER_MODE_MONO)
257 r->tnctrl |= TEA5764_TNCTRL_MST;
258 else
259 r->tnctrl &= ~TEA5764_TNCTRL_MST;
260 if (tnctrl != r->tnctrl)
261 tea5764_i2c_write(radio);
262}
263
264static int tea5764_get_audout_mode(struct tea5764_device *radio)
265{
266 struct tea5764_regs *r = &radio->regs;
267
268 if (r->tnctrl & TEA5764_TNCTRL_MST)
269 return V4L2_TUNER_MODE_MONO;
270 else
271 return V4L2_TUNER_MODE_STEREO;
272}
273
274static void tea5764_mute(struct tea5764_device *radio, int on)
275{
276 struct tea5764_regs *r = &radio->regs;
277 int tnctrl = r->tnctrl;
278
279 if (on)
280 r->tnctrl |= TEA5764_TNCTRL_MU;
281 else
282 r->tnctrl &= ~TEA5764_TNCTRL_MU;
283 if (tnctrl != r->tnctrl)
284 tea5764_i2c_write(radio);
285}
286
287
288static int vidioc_querycap(struct file *file, void *priv,
289 struct v4l2_capability *v)
290{
291 struct tea5764_device *radio = video_drvdata(file);
292 struct video_device *dev = &radio->vdev;
293
294 strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
295 strlcpy(v->card, dev->name, sizeof(v->card));
296 snprintf(v->bus_info, sizeof(v->bus_info),
297 "I2C:%s", dev_name(&dev->dev));
298 v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
299 v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
300 return 0;
301}
302
303static int vidioc_g_tuner(struct file *file, void *priv,
304 struct v4l2_tuner *v)
305{
306 struct tea5764_device *radio = video_drvdata(file);
307 struct tea5764_regs *r = &radio->regs;
308
309 if (v->index > 0)
310 return -EINVAL;
311
312 strlcpy(v->name, "FM", sizeof(v->name));
313 v->type = V4L2_TUNER_RADIO;
314 tea5764_i2c_read(radio);
315 v->rangelow = FREQ_MIN * FREQ_MUL;
316 v->rangehigh = FREQ_MAX * FREQ_MUL;
317 v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
318 if (r->tunchk & TEA5764_TUNCHK_STEREO)
319 v->rxsubchans = V4L2_TUNER_SUB_STEREO;
320 else
321 v->rxsubchans = V4L2_TUNER_SUB_MONO;
322 v->audmode = tea5764_get_audout_mode(radio);
323 v->signal = TEA5764_TUNCHK_LEVEL(r->tunchk) * 0xffff / 0xf;
324 v->afc = TEA5764_TUNCHK_IFCNT(r->tunchk);
325
326 return 0;
327}
328
329static int vidioc_s_tuner(struct file *file, void *priv,
330 const struct v4l2_tuner *v)
331{
332 struct tea5764_device *radio = video_drvdata(file);
333
334 if (v->index > 0)
335 return -EINVAL;
336
337 tea5764_set_audout_mode(radio, v->audmode);
338 return 0;
339}
340
341static int vidioc_s_frequency(struct file *file, void *priv,
342 const struct v4l2_frequency *f)
343{
344 struct tea5764_device *radio = video_drvdata(file);
345 unsigned freq = f->frequency;
346
347 if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
348 return -EINVAL;
349 if (freq == 0) {
350
351 tea5764_power_down(radio);
352
353
354
355
356
357 return -EINVAL;
358 }
359 clamp(freq, FREQ_MIN * FREQ_MUL, FREQ_MAX * FREQ_MUL);
360 tea5764_power_up(radio);
361 tea5764_tune(radio, (freq * 125) / 2);
362 return 0;
363}
364
365static int vidioc_g_frequency(struct file *file, void *priv,
366 struct v4l2_frequency *f)
367{
368 struct tea5764_device *radio = video_drvdata(file);
369 struct tea5764_regs *r = &radio->regs;
370
371 if (f->tuner != 0)
372 return -EINVAL;
373 tea5764_i2c_read(radio);
374 f->type = V4L2_TUNER_RADIO;
375 if (r->tnctrl & TEA5764_TNCTRL_PUPD0)
376 f->frequency = (tea5764_get_freq(radio) * 2) / 125;
377 else
378 f->frequency = 0;
379
380 return 0;
381}
382
383static int tea5764_s_ctrl(struct v4l2_ctrl *ctrl)
384{
385 struct tea5764_device *radio =
386 container_of(ctrl->handler, struct tea5764_device, ctrl_handler);
387
388 switch (ctrl->id) {
389 case V4L2_CID_AUDIO_MUTE:
390 tea5764_mute(radio, ctrl->val);
391 return 0;
392 }
393 return -EINVAL;
394}
395
396static const struct v4l2_ctrl_ops tea5764_ctrl_ops = {
397 .s_ctrl = tea5764_s_ctrl,
398};
399
400
401static const struct v4l2_file_operations tea5764_fops = {
402 .owner = THIS_MODULE,
403 .open = v4l2_fh_open,
404 .release = v4l2_fh_release,
405 .poll = v4l2_ctrl_poll,
406 .unlocked_ioctl = video_ioctl2,
407};
408
409static const struct v4l2_ioctl_ops tea5764_ioctl_ops = {
410 .vidioc_querycap = vidioc_querycap,
411 .vidioc_g_tuner = vidioc_g_tuner,
412 .vidioc_s_tuner = vidioc_s_tuner,
413 .vidioc_g_frequency = vidioc_g_frequency,
414 .vidioc_s_frequency = vidioc_s_frequency,
415 .vidioc_log_status = v4l2_ctrl_log_status,
416 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
417 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
418};
419
420
421static struct video_device tea5764_radio_template = {
422 .name = "TEA5764 FM-Radio",
423 .fops = &tea5764_fops,
424 .ioctl_ops = &tea5764_ioctl_ops,
425 .release = video_device_release_empty,
426};
427
428
429static int tea5764_i2c_probe(struct i2c_client *client,
430 const struct i2c_device_id *id)
431{
432 struct tea5764_device *radio;
433 struct v4l2_device *v4l2_dev;
434 struct v4l2_ctrl_handler *hdl;
435 struct tea5764_regs *r;
436 int ret;
437
438 PDEBUG("probe");
439 radio = kzalloc(sizeof(struct tea5764_device), GFP_KERNEL);
440 if (!radio)
441 return -ENOMEM;
442
443 v4l2_dev = &radio->v4l2_dev;
444 ret = v4l2_device_register(&client->dev, v4l2_dev);
445 if (ret < 0) {
446 v4l2_err(v4l2_dev, "could not register v4l2_device\n");
447 goto errfr;
448 }
449
450 hdl = &radio->ctrl_handler;
451 v4l2_ctrl_handler_init(hdl, 1);
452 v4l2_ctrl_new_std(hdl, &tea5764_ctrl_ops,
453 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
454 v4l2_dev->ctrl_handler = hdl;
455 if (hdl->error) {
456 ret = hdl->error;
457 v4l2_err(v4l2_dev, "Could not register controls\n");
458 goto errunreg;
459 }
460
461 mutex_init(&radio->mutex);
462 radio->i2c_client = client;
463 ret = tea5764_i2c_read(radio);
464 if (ret)
465 goto errunreg;
466 r = &radio->regs;
467 PDEBUG("chipid = %04X, manid = %04X", r->chipid, r->manid);
468 if (r->chipid != TEA5764_CHIPID ||
469 (r->manid & 0x0fff) != TEA5764_MANID) {
470 PWARN("This chip is not a TEA5764!");
471 ret = -EINVAL;
472 goto errunreg;
473 }
474
475 radio->vdev = tea5764_radio_template;
476
477 i2c_set_clientdata(client, radio);
478 video_set_drvdata(&radio->vdev, radio);
479 radio->vdev.lock = &radio->mutex;
480 radio->vdev.v4l2_dev = v4l2_dev;
481 set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags);
482
483
484 tea5764_i2c_read(radio);
485 tea5764_set_audout_mode(radio, V4L2_TUNER_MODE_STEREO);
486 tea5764_mute(radio, 1);
487 tea5764_power_down(radio);
488
489 ret = video_register_device(&radio->vdev, VFL_TYPE_RADIO, radio_nr);
490 if (ret < 0) {
491 PWARN("Could not register video device!");
492 goto errunreg;
493 }
494
495 PINFO("registered.");
496 return 0;
497errunreg:
498 v4l2_ctrl_handler_free(hdl);
499 v4l2_device_unregister(v4l2_dev);
500errfr:
501 kfree(radio);
502 return ret;
503}
504
505static int tea5764_i2c_remove(struct i2c_client *client)
506{
507 struct tea5764_device *radio = i2c_get_clientdata(client);
508
509 PDEBUG("remove");
510 if (radio) {
511 tea5764_power_down(radio);
512 video_unregister_device(&radio->vdev);
513 v4l2_ctrl_handler_free(&radio->ctrl_handler);
514 v4l2_device_unregister(&radio->v4l2_dev);
515 kfree(radio);
516 }
517 return 0;
518}
519
520
521static const struct i2c_device_id tea5764_id[] = {
522 { "radio-tea5764", 0 },
523 { }
524};
525MODULE_DEVICE_TABLE(i2c, tea5764_id);
526
527static struct i2c_driver tea5764_i2c_driver = {
528 .driver = {
529 .name = "radio-tea5764",
530 .owner = THIS_MODULE,
531 },
532 .probe = tea5764_i2c_probe,
533 .remove = tea5764_i2c_remove,
534 .id_table = tea5764_id,
535};
536
537module_i2c_driver(tea5764_i2c_driver);
538
539MODULE_AUTHOR(DRIVER_AUTHOR);
540MODULE_DESCRIPTION(DRIVER_DESC);
541MODULE_LICENSE("GPL");
542MODULE_VERSION(DRIVER_VERSION);
543
544module_param(use_xtal, int, 0);
545MODULE_PARM_DESC(use_xtal, "Chip have a xtal connected in board");
546module_param(radio_nr, int, 0);
547MODULE_PARM_DESC(radio_nr, "video4linux device number to use");
548
