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