aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--drivers/media/radio/Kconfig19
-rw-r--r--drivers/media/radio/Makefile1
-rw-r--r--drivers/media/radio/radio-tea5764.c634
3 files changed, 654 insertions, 0 deletions
diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
index 5189c4eb439f..3315cac875e5 100644
--- a/drivers/media/radio/Kconfig
+++ b/drivers/media/radio/Kconfig
@@ -387,4 +387,23 @@ config USB_MR800
387 To compile this driver as a module, choose M here: the 387 To compile this driver as a module, choose M here: the
388 module will be called radio-mr800. 388 module will be called radio-mr800.
389 389
390config RADIO_TEA5764
391 tristate "TEA5764 I2C FM radio support"
392 depends on I2C && VIDEO_V4L2
393 ---help---
394 Say Y here if you want to use the TEA5764 FM chip found in
395 EZX phones. This FM chip is present in EZX phones from Motorola,
396 connected to internal pxa I2C bus.
397
398 To compile this driver as a module, choose M here: the
399 module will be called radio-tea5764.
400
401config RADIO_TEA5764_XTAL
402 bool "TEA5764 crystal reference"
403 depends on RADIO_TEA5764=y
404 default y
405 help
406 Say Y here if TEA5764 have a 32768 Hz crystal in circuit, say N
407 here if TEA5764 reference frequency is connected in FREQIN.
408
390endif # RADIO_ADAPTERS 409endif # RADIO_ADAPTERS
diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile
index 240ec63cdafc..0f2b35b3e560 100644
--- a/drivers/media/radio/Makefile
+++ b/drivers/media/radio/Makefile
@@ -19,5 +19,6 @@ obj-$(CONFIG_RADIO_MAESTRO) += radio-maestro.o
19obj-$(CONFIG_USB_DSBR) += dsbr100.o 19obj-$(CONFIG_USB_DSBR) += dsbr100.o
20obj-$(CONFIG_USB_SI470X) += radio-si470x.o 20obj-$(CONFIG_USB_SI470X) += radio-si470x.o
21obj-$(CONFIG_USB_MR800) += radio-mr800.o 21obj-$(CONFIG_USB_MR800) += radio-mr800.o
22obj-$(CONFIG_RADIO_TEA5764) += radio-tea5764.o
22 23
23EXTRA_CFLAGS += -Isound 24EXTRA_CFLAGS += -Isound
diff --git a/drivers/media/radio/radio-tea5764.c b/drivers/media/radio/radio-tea5764.c
new file mode 100644
index 000000000000..4d35308fc1ff
--- /dev/null
+++ b/drivers/media/radio/radio-tea5764.c
@@ -0,0 +1,634 @@
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/module.h>
36#include <linux/init.h> /* Initdata */
37#include <linux/videodev2.h> /* kernel radio structs */
38#include <linux/i2c.h> /* I2C */
39#include <media/v4l2-common.h>
40#include <media/v4l2-ioctl.h>
41#include <linux/version.h> /* for KERNEL_VERSION MACRO */
42
43#define DRIVER_VERSION "v0.01"
44#define RADIO_VERSION KERNEL_VERSION(0, 0, 1)
45
46#define DRIVER_AUTHOR "Fabio Belavenuto <belavenuto@gmail.com>"
47#define DRIVER_DESC "A driver for the TEA5764 radio chip for EZX Phones."
48
49#define PINFO(format, ...)\
50 printk(KERN_INFO KBUILD_MODNAME ": "\
51 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
52#define PWARN(format, ...)\
53 printk(KERN_WARNING KBUILD_MODNAME ": "\
54 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
55# define PDEBUG(format, ...)\
56 printk(KERN_DEBUG KBUILD_MODNAME ": "\
57 DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
58
59/* Frequency limits in MHz -- these are European values. For Japanese
60devices, that would be 76000 and 91000. */
61#define FREQ_MIN 87500
62#define FREQ_MAX 108000
63#define FREQ_MUL 16
64
65/* TEA5764 registers */
66#define TEA5764_MANID 0x002b
67#define TEA5764_CHIPID 0x5764
68
69#define TEA5764_INTREG_BLMSK 0x0001
70#define TEA5764_INTREG_FRRMSK 0x0002
71#define TEA5764_INTREG_LEVMSK 0x0008
72#define TEA5764_INTREG_IFMSK 0x0010
73#define TEA5764_INTREG_BLMFLAG 0x0100
74#define TEA5764_INTREG_FRRFLAG 0x0200
75#define TEA5764_INTREG_LEVFLAG 0x0800
76#define TEA5764_INTREG_IFFLAG 0x1000
77
78#define TEA5764_FRQSET_SUD 0x8000
79#define TEA5764_FRQSET_SM 0x4000
80
81#define TEA5764_TNCTRL_PUPD1 0x8000
82#define TEA5764_TNCTRL_PUPD0 0x4000
83#define TEA5764_TNCTRL_BLIM 0x2000
84#define TEA5764_TNCTRL_SWPM 0x1000
85#define TEA5764_TNCTRL_IFCTC 0x0800
86#define TEA5764_TNCTRL_AFM 0x0400
87#define TEA5764_TNCTRL_SMUTE 0x0200
88#define TEA5764_TNCTRL_SNC 0x0100
89#define TEA5764_TNCTRL_MU 0x0080
90#define TEA5764_TNCTRL_SSL1 0x0040
91#define TEA5764_TNCTRL_SSL0 0x0020
92#define TEA5764_TNCTRL_HLSI 0x0010
93#define TEA5764_TNCTRL_MST 0x0008
94#define TEA5764_TNCTRL_SWP 0x0004
95#define TEA5764_TNCTRL_DTC 0x0002
96#define TEA5764_TNCTRL_AHLSI 0x0001
97
98#define TEA5764_TUNCHK_LEVEL(x) (((x) & 0x00F0) >> 4)
99#define TEA5764_TUNCHK_IFCNT(x) (((x) & 0xFE00) >> 9)
100#define TEA5764_TUNCHK_TUNTO 0x0100
101#define TEA5764_TUNCHK_LD 0x0008
102#define TEA5764_TUNCHK_STEREO 0x0004
103
104#define TEA5764_TESTREG_TRIGFR 0x0800
105
106struct tea5764_regs {
107 u16 intreg; /* INTFLAG & INTMSK */
108 u16 frqset; /* FRQSETMSB & FRQSETLSB */
109 u16 tnctrl; /* TNCTRL1 & TNCTRL2 */
110 u16 frqchk; /* FRQCHKMSB & FRQCHKLSB */
111 u16 tunchk; /* IFCHK & LEVCHK */
112 u16 testreg; /* TESTBITS & TESTMODE */
113 u16 rdsstat; /* RDSSTAT1 & RDSSTAT2 */
114 u16 rdslb; /* RDSLBMSB & RDSLBLSB */
115 u16 rdspb; /* RDSPBMSB & RDSPBLSB */
116 u16 rdsbc; /* RDSBBC & RDSGBC */
117 u16 rdsctrl; /* RDSCTRL1 & RDSCTRL2 */
118 u16 rdsbbl; /* PAUSEDET & RDSBBL */
119 u16 manid; /* MANID1 & MANID2 */
120 u16 chipid; /* CHIPID1 & CHIPID2 */
121} __attribute__ ((packed));
122
123struct tea5764_write_regs {
124 u8 intreg; /* INTMSK */
125 u16 frqset; /* FRQSETMSB & FRQSETLSB */
126 u16 tnctrl; /* TNCTRL1 & TNCTRL2 */
127 u16 testreg; /* TESTBITS & TESTMODE */
128 u16 rdsctrl; /* RDSCTRL1 & RDSCTRL2 */
129 u16 rdsbbl; /* PAUSEDET & RDSBBL */
130} __attribute__ ((packed));
131
132#ifndef RADIO_TEA5764_XTAL
133#define RADIO_TEA5764_XTAL 1
134#endif
135
136static int radio_nr = -1;
137static int use_xtal = RADIO_TEA5764_XTAL;
138
139struct tea5764_device {
140 struct i2c_client *i2c_client;
141 struct video_device *videodev;
142 struct tea5764_regs regs;
143 struct mutex mutex;
144 int users;
145};
146
147/* I2C code related */
148int 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 { radio->i2c_client->addr, I2C_M_RD, sizeof(radio->regs),
155 (void *)&radio->regs },
156 };
157 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
158 return -EIO;
159 for (i = 0; i < sizeof(struct tea5764_regs) / sizeof(u16); i++)
160 p[i] = __be16_to_cpu(p[i]);
161
162 return 0;
163}
164
165int tea5764_i2c_write(struct tea5764_device *radio)
166{
167 struct tea5764_write_regs wr;
168 struct tea5764_regs *r = &radio->regs;
169 struct i2c_msg msgs[1] = {
170 { radio->i2c_client->addr, 0, sizeof(wr), (void *) &wr },
171 };
172 wr.intreg = r->intreg & 0xff;
173 wr.frqset = __cpu_to_be16(r->frqset);
174 wr.tnctrl = __cpu_to_be16(r->tnctrl);
175 wr.testreg = __cpu_to_be16(r->testreg);
176 wr.rdsctrl = __cpu_to_be16(r->rdsctrl);
177 wr.rdsbbl = __cpu_to_be16(r->rdsbbl);
178 if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
179 return -EIO;
180 return 0;
181}
182
183/* V4L2 code related */
184static struct v4l2_queryctrl radio_qctrl[] = {
185 {
186 .id = V4L2_CID_AUDIO_MUTE,
187 .name = "Mute",
188 .minimum = 0,
189 .maximum = 1,
190 .default_value = 1,
191 .type = V4L2_CTRL_TYPE_BOOLEAN,
192 }
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 /* formula: (freq [+ or -] 225000) / 8192 */
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/* tune an frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
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
287static int tea5764_is_muted(struct tea5764_device *radio)
288{
289 return radio->regs.tnctrl & TEA5764_TNCTRL_MU;
290}
291
292/* V4L2 vidioc */
293static int vidioc_querycap(struct file *file, void *priv,
294 struct v4l2_capability *v)
295{
296 struct tea5764_device *radio = video_drvdata(file);
297 struct video_device *dev = radio->videodev;
298
299 strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
300 strlcpy(v->card, dev->name, sizeof(v->card));
301 snprintf(v->bus_info, sizeof(v->bus_info), "I2C:%s", dev->dev.bus_id);
302 v->version = RADIO_VERSION;
303 v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
304 return 0;
305}
306
307static int vidioc_g_tuner(struct file *file, void *priv,
308 struct v4l2_tuner *v)
309{
310 struct tea5764_device *radio = video_drvdata(file);
311 struct tea5764_regs *r = &radio->regs;
312
313 if (v->index > 0)
314 return -EINVAL;
315
316 memset(v, 0, sizeof(v));
317 strcpy(v->name, "FM");
318 v->type = V4L2_TUNER_RADIO;
319 tea5764_i2c_read(radio);
320 v->rangelow = FREQ_MIN * FREQ_MUL;
321 v->rangehigh = FREQ_MAX * FREQ_MUL;
322 v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
323 if (r->tunchk & TEA5764_TUNCHK_STEREO)
324 v->rxsubchans = V4L2_TUNER_SUB_STEREO;
325 v->audmode = tea5764_get_audout_mode(radio);
326 v->signal = TEA5764_TUNCHK_LEVEL(r->tunchk) * 0xffff / 0xf;
327 v->afc = TEA5764_TUNCHK_IFCNT(r->tunchk);
328
329 return 0;
330}
331
332static int vidioc_s_tuner(struct file *file, void *priv,
333 struct v4l2_tuner *v)
334{
335 struct tea5764_device *radio = video_drvdata(file);
336
337 if (v->index > 0)
338 return -EINVAL;
339
340 tea5764_set_audout_mode(radio, v->audmode);
341 return 0;
342}
343
344static int vidioc_s_frequency(struct file *file, void *priv,
345 struct v4l2_frequency *f)
346{
347 struct tea5764_device *radio = video_drvdata(file);
348
349 if (f->tuner != 0)
350 return -EINVAL;
351 if (f->frequency == 0) {
352 /* We special case this as a power down control. */
353 tea5764_power_down(radio);
354 }
355 if (f->frequency < (FREQ_MIN * FREQ_MUL))
356 return -EINVAL;
357 if (f->frequency > (FREQ_MAX * FREQ_MUL))
358 return -EINVAL;
359 tea5764_power_up(radio);
360 tea5764_tune(radio, (f->frequency * 125) / 2);
361 return 0;
362}
363
364static int vidioc_g_frequency(struct file *file, void *priv,
365 struct v4l2_frequency *f)
366{
367 struct tea5764_device *radio = video_drvdata(file);
368 struct tea5764_regs *r = &radio->regs;
369
370 tea5764_i2c_read(radio);
371 memset(f, 0, sizeof(f));
372 f->type = V4L2_TUNER_RADIO;
373 if (r->tnctrl & TEA5764_TNCTRL_PUPD0)
374 f->frequency = (tea5764_get_freq(radio) * 2) / 125;
375 else
376 f->frequency = 0;
377
378 return 0;
379}
380
381static int vidioc_queryctrl(struct file *file, void *priv,
382 struct v4l2_queryctrl *qc)
383{
384 int i;
385
386 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
387 if (qc->id && qc->id == radio_qctrl[i].id) {
388 memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
389 return 0;
390 }
391 }
392 return -EINVAL;
393}
394
395static int vidioc_g_ctrl(struct file *file, void *priv,
396 struct v4l2_control *ctrl)
397{
398 struct tea5764_device *radio = video_drvdata(file);
399
400 switch (ctrl->id) {
401 case V4L2_CID_AUDIO_MUTE:
402 tea5764_i2c_read(radio);
403 ctrl->value = tea5764_is_muted(radio) ? 1 : 0;
404 return 0;
405 }
406 return -EINVAL;
407}
408
409static int vidioc_s_ctrl(struct file *file, void *priv,
410 struct v4l2_control *ctrl)
411{
412 struct tea5764_device *radio = video_drvdata(file);
413
414 switch (ctrl->id) {
415 case V4L2_CID_AUDIO_MUTE:
416 tea5764_mute(radio, ctrl->value);
417 return 0;
418 }
419 return -EINVAL;
420}
421
422static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
423{
424 *i = 0;
425 return 0;
426}
427
428static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
429{
430 if (i != 0)
431 return -EINVAL;
432 return 0;
433}
434
435static int vidioc_g_audio(struct file *file, void *priv,
436 struct v4l2_audio *a)
437{
438 if (a->index > 1)
439 return -EINVAL;
440
441 strcpy(a->name, "Radio");
442 a->capability = V4L2_AUDCAP_STEREO;
443 return 0;
444}
445
446static int vidioc_s_audio(struct file *file, void *priv,
447 struct v4l2_audio *a)
448{
449 if (a->index != 0)
450 return -EINVAL;
451
452 return 0;
453}
454
455static int tea5764_open(struct file *file)
456{
457 /* Currently we support only one device */
458 int minor = video_devdata(file)->minor;
459 struct tea5764_device *radio = video_drvdata(file);
460
461 if (radio->videodev->minor != minor)
462 return -ENODEV;
463
464 mutex_lock(&radio->mutex);
465 /* Only exclusive access */
466 if (radio->users) {
467 mutex_unlock(&radio->mutex);
468 return -EBUSY;
469 }
470 radio->users++;
471 mutex_unlock(&radio->mutex);
472 file->private_data = radio;
473 return 0;
474}
475
476static int tea5764_close(struct file *file)
477{
478 struct tea5764_device *radio = video_drvdata(file);
479
480 if (!radio)
481 return -ENODEV;
482 mutex_lock(&radio->mutex);
483 radio->users--;
484 mutex_unlock(&radio->mutex);
485 return 0;
486}
487
488/* File system interface */
489static const struct v4l2_file_operations tea5764_fops = {
490 .owner = THIS_MODULE,
491 .open = tea5764_open,
492 .release = tea5764_close,
493 .ioctl = video_ioctl2,
494};
495
496static const struct v4l2_ioctl_ops tea5764_ioctl_ops = {
497 .vidioc_querycap = vidioc_querycap,
498 .vidioc_g_tuner = vidioc_g_tuner,
499 .vidioc_s_tuner = vidioc_s_tuner,
500 .vidioc_g_audio = vidioc_g_audio,
501 .vidioc_s_audio = vidioc_s_audio,
502 .vidioc_g_input = vidioc_g_input,
503 .vidioc_s_input = vidioc_s_input,
504 .vidioc_g_frequency = vidioc_g_frequency,
505 .vidioc_s_frequency = vidioc_s_frequency,
506 .vidioc_queryctrl = vidioc_queryctrl,
507 .vidioc_g_ctrl = vidioc_g_ctrl,
508 .vidioc_s_ctrl = vidioc_s_ctrl,
509};
510
511/* V4L2 interface */
512static struct video_device tea5764_radio_template = {
513 .name = "TEA5764 FM-Radio",
514 .fops = &tea5764_fops,
515 .ioctl_ops = &tea5764_ioctl_ops,
516 .release = video_device_release,
517};
518
519/* I2C probe: check if the device exists and register with v4l if it is */
520static int __devinit tea5764_i2c_probe(struct i2c_client *client,
521 const struct i2c_device_id *id)
522{
523 struct tea5764_device *radio;
524 struct tea5764_regs *r;
525 int ret;
526
527 PDEBUG("probe");
528 radio = kmalloc(sizeof(struct tea5764_device), GFP_KERNEL);
529 if (!radio)
530 return -ENOMEM;
531
532 mutex_init(&radio->mutex);
533 radio->i2c_client = client;
534 ret = tea5764_i2c_read(radio);
535 if (ret)
536 goto errfr;
537 r = &radio->regs;
538 PDEBUG("chipid = %04X, manid = %04X", r->chipid, r->manid);
539 if (r->chipid != TEA5764_CHIPID ||
540 (r->manid & 0x0fff) != TEA5764_MANID) {
541 PWARN("This chip is not a TEA5764!");
542 ret = -EINVAL;
543 goto errfr;
544 }
545
546 radio->videodev = video_device_alloc();
547 if (!(radio->videodev)) {
548 ret = -ENOMEM;
549 goto errfr;
550 }
551 memcpy(radio->videodev, &tea5764_radio_template,
552 sizeof(tea5764_radio_template));
553
554 i2c_set_clientdata(client, radio);
555 video_set_drvdata(radio->videodev, radio);
556
557 ret = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr);
558 if (ret < 0) {
559 PWARN("Could not register video device!");
560 goto errrel;
561 }
562
563 /* initialize and power off the chip */
564 tea5764_i2c_read(radio);
565 tea5764_set_audout_mode(radio, V4L2_TUNER_MODE_STEREO);
566 tea5764_mute(radio, 1);
567 tea5764_power_down(radio);
568
569 PINFO("registered.");
570 return 0;
571errrel:
572 video_device_release(radio->videodev);
573errfr:
574 kfree(radio);
575 return ret;
576}
577
578static int __devexit tea5764_i2c_remove(struct i2c_client *client)
579{
580 struct tea5764_device *radio = i2c_get_clientdata(client);
581
582 PDEBUG("remove");
583 if (radio) {
584 tea5764_power_down(radio);
585 video_unregister_device(radio->videodev);
586 kfree(radio);
587 }
588 return 0;
589}
590
591/* I2C subsystem interface */
592static const struct i2c_device_id tea5764_id[] = {
593 { "radio-tea5764", 0 },
594 { } /* Terminating entry */
595};
596MODULE_DEVICE_TABLE(i2c, tea5764_id);
597
598static struct i2c_driver tea5764_i2c_driver = {
599 .driver = {
600 .name = "radio-tea5764",
601 .owner = THIS_MODULE,
602 },
603 .probe = tea5764_i2c_probe,
604 .remove = __devexit_p(tea5764_i2c_remove),
605 .id_table = tea5764_id,
606};
607
608/* init the driver */
609static int __init tea5764_init(void)
610{
611 int ret = i2c_add_driver(&tea5764_i2c_driver);
612
613 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ": "
614 DRIVER_DESC "\n");
615 return ret;
616}
617
618/* cleanup the driver */
619static void __exit tea5764_exit(void)
620{
621 i2c_del_driver(&tea5764_i2c_driver);
622}
623
624MODULE_AUTHOR(DRIVER_AUTHOR);
625MODULE_DESCRIPTION(DRIVER_DESC);
626MODULE_LICENSE("GPL");
627
628module_param(use_xtal, int, 1);
629MODULE_PARM_DESC(use_xtal, "Chip have a xtal connected in board");
630module_param(radio_nr, int, 0);
631MODULE_PARM_DESC(radio_nr, "video4linux device number to use");
632
633module_init(tea5764_init);
634module_exit(tea5764_exit);