1 /*
2  *   ALSA driver for TEA5757/5759 Philips AM/FM radio tuner chips
3  *
4  *	Copyright (c) 2004 Jaroslav Kysela <perex@perex.cz>
5  *
6  *
7  *   This program is free software; you can redistribute it and/or modify
8  *   it under the terms of the GNU General Public License as published by
9  *   the Free Software Foundation; either version 2 of the License, or
10  *   (at your option) any later version.
11  *
12  *   This program is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  */
18 
19 #include <linux/delay.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/sched.h>
24 #include <asm/io.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-dev.h>
27 #include <media/v4l2-fh.h>
28 #include <media/v4l2-ioctl.h>
29 #include <media/v4l2-event.h>
30 #include <media/drv-intf/tea575x.h>
31 
32 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
33 MODULE_DESCRIPTION("Routines for control of TEA5757/5759 Philips AM/FM radio tuner chips");
34 MODULE_LICENSE("GPL");
35 
36 /*
37  * definitions
38  */
39 
40 #define TEA575X_BIT_SEARCH	(1<<24)		/* 1 = search action, 0 = tuned */
41 #define TEA575X_BIT_UPDOWN	(1<<23)		/* 0 = search down, 1 = search up */
42 #define TEA575X_BIT_MONO	(1<<22)		/* 0 = stereo, 1 = mono */
43 #define TEA575X_BIT_BAND_MASK	(3<<20)
44 #define TEA575X_BIT_BAND_FM	(0<<20)
45 #define TEA575X_BIT_BAND_MW	(1<<20)
46 #define TEA575X_BIT_BAND_LW	(2<<20)
47 #define TEA575X_BIT_BAND_SW	(3<<20)
48 #define TEA575X_BIT_PORT_0	(1<<19)		/* user bit */
49 #define TEA575X_BIT_PORT_1	(1<<18)		/* user bit */
50 #define TEA575X_BIT_SEARCH_MASK	(3<<16)		/* search level */
51 #define TEA575X_BIT_SEARCH_5_28	     (0<<16)	/* FM >5uV, AM >28uV */
52 #define TEA575X_BIT_SEARCH_10_40     (1<<16)	/* FM >10uV, AM > 40uV */
53 #define TEA575X_BIT_SEARCH_30_63     (2<<16)	/* FM >30uV, AM > 63uV */
54 #define TEA575X_BIT_SEARCH_150_1000  (3<<16)	/* FM > 150uV, AM > 1000uV */
55 #define TEA575X_BIT_DUMMY	(1<<15)		/* buffer */
56 #define TEA575X_BIT_FREQ_MASK	0x7fff
57 
58 enum { BAND_FM, BAND_FM_JAPAN, BAND_AM };
59 
60 static const struct v4l2_frequency_band bands[] = {
61 	{
62 		.type = V4L2_TUNER_RADIO,
63 		.index = 0,
64 		.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
65 			      V4L2_TUNER_CAP_FREQ_BANDS,
66 		.rangelow   =  87500 * 16,
67 		.rangehigh  = 108000 * 16,
68 		.modulation = V4L2_BAND_MODULATION_FM,
69 	},
70 	{
71 		.type = V4L2_TUNER_RADIO,
72 		.index = 0,
73 		.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
74 			      V4L2_TUNER_CAP_FREQ_BANDS,
75 		.rangelow   = 76000 * 16,
76 		.rangehigh  = 91000 * 16,
77 		.modulation = V4L2_BAND_MODULATION_FM,
78 	},
79 	{
80 		.type = V4L2_TUNER_RADIO,
81 		.index = 1,
82 		.capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_FREQ_BANDS,
83 		.rangelow   =  530 * 16,
84 		.rangehigh  = 1710 * 16,
85 		.modulation = V4L2_BAND_MODULATION_AM,
86 	},
87 };
88 
89 /*
90  * lowlevel part
91  */
92 
snd_tea575x_write(struct snd_tea575x * tea,unsigned int val)93 static void snd_tea575x_write(struct snd_tea575x *tea, unsigned int val)
94 {
95 	u16 l;
96 	u8 data;
97 
98 	if (tea->ops->write_val)
99 		return tea->ops->write_val(tea, val);
100 
101 	tea->ops->set_direction(tea, 1);
102 	udelay(16);
103 
104 	for (l = 25; l > 0; l--) {
105 		data = (val >> 24) & TEA575X_DATA;
106 		val <<= 1;			/* shift data */
107 		tea->ops->set_pins(tea, data | TEA575X_WREN);
108 		udelay(2);
109 		tea->ops->set_pins(tea, data | TEA575X_WREN | TEA575X_CLK);
110 		udelay(2);
111 		tea->ops->set_pins(tea, data | TEA575X_WREN);
112 		udelay(2);
113 	}
114 
115 	if (!tea->mute)
116 		tea->ops->set_pins(tea, 0);
117 }
118 
snd_tea575x_read(struct snd_tea575x * tea)119 static u32 snd_tea575x_read(struct snd_tea575x *tea)
120 {
121 	u16 l, rdata;
122 	u32 data = 0;
123 
124 	if (tea->ops->read_val)
125 		return tea->ops->read_val(tea);
126 
127 	tea->ops->set_direction(tea, 0);
128 	tea->ops->set_pins(tea, 0);
129 	udelay(16);
130 
131 	for (l = 24; l--;) {
132 		tea->ops->set_pins(tea, TEA575X_CLK);
133 		udelay(2);
134 		if (!l)
135 			tea->tuned = tea->ops->get_pins(tea) & TEA575X_MOST ? 0 : 1;
136 		tea->ops->set_pins(tea, 0);
137 		udelay(2);
138 		data <<= 1;			/* shift data */
139 		rdata = tea->ops->get_pins(tea);
140 		if (!l)
141 			tea->stereo = (rdata & TEA575X_MOST) ?  0 : 1;
142 		if (rdata & TEA575X_DATA)
143 			data++;
144 		udelay(2);
145 	}
146 
147 	if (tea->mute)
148 		tea->ops->set_pins(tea, TEA575X_WREN);
149 
150 	return data;
151 }
152 
snd_tea575x_val_to_freq(struct snd_tea575x * tea,u32 val)153 static u32 snd_tea575x_val_to_freq(struct snd_tea575x *tea, u32 val)
154 {
155 	u32 freq = val & TEA575X_BIT_FREQ_MASK;
156 
157 	if (freq == 0)
158 		return freq;
159 
160 	switch (tea->band) {
161 	case BAND_FM:
162 		/* freq *= 12.5 */
163 		freq *= 125;
164 		freq /= 10;
165 		/* crystal fixup */
166 		freq -= TEA575X_FMIF;
167 		break;
168 	case BAND_FM_JAPAN:
169 		/* freq *= 12.5 */
170 		freq *= 125;
171 		freq /= 10;
172 		/* crystal fixup */
173 		freq += TEA575X_FMIF;
174 		break;
175 	case BAND_AM:
176 		/* crystal fixup */
177 		freq -= TEA575X_AMIF;
178 		break;
179 	}
180 
181 	return clamp(freq * 16, bands[tea->band].rangelow,
182 				bands[tea->band].rangehigh); /* from kHz */
183 }
184 
snd_tea575x_get_freq(struct snd_tea575x * tea)185 static u32 snd_tea575x_get_freq(struct snd_tea575x *tea)
186 {
187 	return snd_tea575x_val_to_freq(tea, snd_tea575x_read(tea));
188 }
189 
snd_tea575x_set_freq(struct snd_tea575x * tea)190 void snd_tea575x_set_freq(struct snd_tea575x *tea)
191 {
192 	u32 freq = tea->freq / 16;	/* to kHz */
193 	u32 band = 0;
194 
195 	switch (tea->band) {
196 	case BAND_FM:
197 		band = TEA575X_BIT_BAND_FM;
198 		/* crystal fixup */
199 		freq += TEA575X_FMIF;
200 		/* freq /= 12.5 */
201 		freq *= 10;
202 		freq /= 125;
203 		break;
204 	case BAND_FM_JAPAN:
205 		band = TEA575X_BIT_BAND_FM;
206 		/* crystal fixup */
207 		freq -= TEA575X_FMIF;
208 		/* freq /= 12.5 */
209 		freq *= 10;
210 		freq /= 125;
211 		break;
212 	case BAND_AM:
213 		band = TEA575X_BIT_BAND_MW;
214 		/* crystal fixup */
215 		freq += TEA575X_AMIF;
216 		break;
217 	}
218 
219 	tea->val &= ~(TEA575X_BIT_FREQ_MASK | TEA575X_BIT_BAND_MASK);
220 	tea->val |= band;
221 	tea->val |= freq & TEA575X_BIT_FREQ_MASK;
222 	snd_tea575x_write(tea, tea->val);
223 	tea->freq = snd_tea575x_val_to_freq(tea, tea->val);
224 }
225 EXPORT_SYMBOL(snd_tea575x_set_freq);
226 
227 /*
228  * Linux Video interface
229  */
230 
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * v)231 static int vidioc_querycap(struct file *file, void  *priv,
232 					struct v4l2_capability *v)
233 {
234 	struct snd_tea575x *tea = video_drvdata(file);
235 
236 	strlcpy(v->driver, tea->v4l2_dev->name, sizeof(v->driver));
237 	strlcpy(v->card, tea->card, sizeof(v->card));
238 	strlcat(v->card, tea->tea5759 ? " TEA5759" : " TEA5757", sizeof(v->card));
239 	strlcpy(v->bus_info, tea->bus_info, sizeof(v->bus_info));
240 	v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
241 	if (!tea->cannot_read_data)
242 		v->device_caps |= V4L2_CAP_HW_FREQ_SEEK;
243 	v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
244 	return 0;
245 }
246 
snd_tea575x_enum_freq_bands(struct snd_tea575x * tea,struct v4l2_frequency_band * band)247 int snd_tea575x_enum_freq_bands(struct snd_tea575x *tea,
248 					struct v4l2_frequency_band *band)
249 {
250 	int index;
251 
252 	if (band->tuner != 0)
253 		return -EINVAL;
254 
255 	switch (band->index) {
256 	case 0:
257 		if (tea->tea5759)
258 			index = BAND_FM_JAPAN;
259 		else
260 			index = BAND_FM;
261 		break;
262 	case 1:
263 		if (tea->has_am) {
264 			index = BAND_AM;
265 			break;
266 		}
267 		/* Fall through */
268 	default:
269 		return -EINVAL;
270 	}
271 
272 	*band = bands[index];
273 	if (!tea->cannot_read_data)
274 		band->capability |= V4L2_TUNER_CAP_HWSEEK_BOUNDED;
275 
276 	return 0;
277 }
278 EXPORT_SYMBOL(snd_tea575x_enum_freq_bands);
279 
vidioc_enum_freq_bands(struct file * file,void * priv,struct v4l2_frequency_band * band)280 static int vidioc_enum_freq_bands(struct file *file, void *priv,
281 					 struct v4l2_frequency_band *band)
282 {
283 	struct snd_tea575x *tea = video_drvdata(file);
284 
285 	return snd_tea575x_enum_freq_bands(tea, band);
286 }
287 
snd_tea575x_g_tuner(struct snd_tea575x * tea,struct v4l2_tuner * v)288 int snd_tea575x_g_tuner(struct snd_tea575x *tea, struct v4l2_tuner *v)
289 {
290 	struct v4l2_frequency_band band_fm = { 0, };
291 
292 	if (v->index > 0)
293 		return -EINVAL;
294 
295 	snd_tea575x_read(tea);
296 	snd_tea575x_enum_freq_bands(tea, &band_fm);
297 
298 	memset(v, 0, sizeof(*v));
299 	strlcpy(v->name, tea->has_am ? "FM/AM" : "FM", sizeof(v->name));
300 	v->type = V4L2_TUNER_RADIO;
301 	v->capability = band_fm.capability;
302 	v->rangelow = tea->has_am ? bands[BAND_AM].rangelow : band_fm.rangelow;
303 	v->rangehigh = band_fm.rangehigh;
304 	v->rxsubchans = tea->stereo ? V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
305 	v->audmode = (tea->val & TEA575X_BIT_MONO) ?
306 		V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO;
307 	v->signal = tea->tuned ? 0xffff : 0;
308 	return 0;
309 }
310 EXPORT_SYMBOL(snd_tea575x_g_tuner);
311 
vidioc_g_tuner(struct file * file,void * priv,struct v4l2_tuner * v)312 static int vidioc_g_tuner(struct file *file, void *priv,
313 					struct v4l2_tuner *v)
314 {
315 	struct snd_tea575x *tea = video_drvdata(file);
316 
317 	return snd_tea575x_g_tuner(tea, v);
318 }
319 
vidioc_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * v)320 static int vidioc_s_tuner(struct file *file, void *priv,
321 					const struct v4l2_tuner *v)
322 {
323 	struct snd_tea575x *tea = video_drvdata(file);
324 	u32 orig_val = tea->val;
325 
326 	if (v->index)
327 		return -EINVAL;
328 	tea->val &= ~TEA575X_BIT_MONO;
329 	if (v->audmode == V4L2_TUNER_MODE_MONO)
330 		tea->val |= TEA575X_BIT_MONO;
331 	/* Only apply changes if currently tuning FM */
332 	if (tea->band != BAND_AM && tea->val != orig_val)
333 		snd_tea575x_set_freq(tea);
334 
335 	return 0;
336 }
337 
vidioc_g_frequency(struct file * file,void * priv,struct v4l2_frequency * f)338 static int vidioc_g_frequency(struct file *file, void *priv,
339 					struct v4l2_frequency *f)
340 {
341 	struct snd_tea575x *tea = video_drvdata(file);
342 
343 	if (f->tuner != 0)
344 		return -EINVAL;
345 	f->type = V4L2_TUNER_RADIO;
346 	f->frequency = tea->freq;
347 	return 0;
348 }
349 
vidioc_s_frequency(struct file * file,void * priv,const struct v4l2_frequency * f)350 static int vidioc_s_frequency(struct file *file, void *priv,
351 					const struct v4l2_frequency *f)
352 {
353 	struct snd_tea575x *tea = video_drvdata(file);
354 
355 	if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
356 		return -EINVAL;
357 
358 	if (tea->has_am && f->frequency < (20000 * 16))
359 		tea->band = BAND_AM;
360 	else if (tea->tea5759)
361 		tea->band = BAND_FM_JAPAN;
362 	else
363 		tea->band = BAND_FM;
364 
365 	tea->freq = clamp_t(u32, f->frequency, bands[tea->band].rangelow,
366 					bands[tea->band].rangehigh);
367 	snd_tea575x_set_freq(tea);
368 	return 0;
369 }
370 
snd_tea575x_s_hw_freq_seek(struct file * file,struct snd_tea575x * tea,const struct v4l2_hw_freq_seek * a)371 int snd_tea575x_s_hw_freq_seek(struct file *file, struct snd_tea575x *tea,
372 				const struct v4l2_hw_freq_seek *a)
373 {
374 	unsigned long timeout;
375 	int i, spacing;
376 
377 	if (tea->cannot_read_data)
378 		return -ENOTTY;
379 	if (a->tuner || a->wrap_around)
380 		return -EINVAL;
381 
382 	if (file->f_flags & O_NONBLOCK)
383 		return -EWOULDBLOCK;
384 
385 	if (a->rangelow || a->rangehigh) {
386 		for (i = 0; i < ARRAY_SIZE(bands); i++) {
387 			if ((i == BAND_FM && tea->tea5759) ||
388 			    (i == BAND_FM_JAPAN && !tea->tea5759) ||
389 			    (i == BAND_AM && !tea->has_am))
390 				continue;
391 			if (bands[i].rangelow  == a->rangelow &&
392 			    bands[i].rangehigh == a->rangehigh)
393 				break;
394 		}
395 		if (i == ARRAY_SIZE(bands))
396 			return -EINVAL; /* No matching band found */
397 		if (i != tea->band) {
398 			tea->band = i;
399 			tea->freq = clamp(tea->freq, bands[i].rangelow,
400 						     bands[i].rangehigh);
401 			snd_tea575x_set_freq(tea);
402 		}
403 	}
404 
405 	spacing = (tea->band == BAND_AM) ? 5 : 50; /* kHz */
406 
407 	/* clear the frequency, HW will fill it in */
408 	tea->val &= ~TEA575X_BIT_FREQ_MASK;
409 	tea->val |= TEA575X_BIT_SEARCH;
410 	if (a->seek_upward)
411 		tea->val |= TEA575X_BIT_UPDOWN;
412 	else
413 		tea->val &= ~TEA575X_BIT_UPDOWN;
414 	snd_tea575x_write(tea, tea->val);
415 	timeout = jiffies + msecs_to_jiffies(10000);
416 	for (;;) {
417 		if (time_after(jiffies, timeout))
418 			break;
419 		if (schedule_timeout_interruptible(msecs_to_jiffies(10))) {
420 			/* some signal arrived, stop search */
421 			tea->val &= ~TEA575X_BIT_SEARCH;
422 			snd_tea575x_set_freq(tea);
423 			return -ERESTARTSYS;
424 		}
425 		if (!(snd_tea575x_read(tea) & TEA575X_BIT_SEARCH)) {
426 			u32 freq;
427 
428 			/* Found a frequency, wait until it can be read */
429 			for (i = 0; i < 100; i++) {
430 				msleep(10);
431 				freq = snd_tea575x_get_freq(tea);
432 				if (freq) /* available */
433 					break;
434 			}
435 			if (freq == 0) /* shouldn't happen */
436 				break;
437 			/*
438 			 * if we moved by less than the spacing, or in the
439 			 * wrong direction, continue seeking
440 			 */
441 			if (abs(tea->freq - freq) < 16 * spacing ||
442 					(a->seek_upward && freq < tea->freq) ||
443 					(!a->seek_upward && freq > tea->freq)) {
444 				snd_tea575x_write(tea, tea->val);
445 				continue;
446 			}
447 			tea->freq = freq;
448 			tea->val &= ~TEA575X_BIT_SEARCH;
449 			return 0;
450 		}
451 	}
452 	tea->val &= ~TEA575X_BIT_SEARCH;
453 	snd_tea575x_set_freq(tea);
454 	return -ENODATA;
455 }
456 EXPORT_SYMBOL(snd_tea575x_s_hw_freq_seek);
457 
vidioc_s_hw_freq_seek(struct file * file,void * fh,const struct v4l2_hw_freq_seek * a)458 static int vidioc_s_hw_freq_seek(struct file *file, void *fh,
459 					const struct v4l2_hw_freq_seek *a)
460 {
461 	struct snd_tea575x *tea = video_drvdata(file);
462 
463 	return snd_tea575x_s_hw_freq_seek(file, tea, a);
464 }
465 
tea575x_s_ctrl(struct v4l2_ctrl * ctrl)466 static int tea575x_s_ctrl(struct v4l2_ctrl *ctrl)
467 {
468 	struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler);
469 
470 	switch (ctrl->id) {
471 	case V4L2_CID_AUDIO_MUTE:
472 		tea->mute = ctrl->val;
473 		snd_tea575x_set_freq(tea);
474 		return 0;
475 	}
476 
477 	return -EINVAL;
478 }
479 
480 static const struct v4l2_file_operations tea575x_fops = {
481 	.unlocked_ioctl	= video_ioctl2,
482 	.open           = v4l2_fh_open,
483 	.release        = v4l2_fh_release,
484 	.poll           = v4l2_ctrl_poll,
485 };
486 
487 static const struct v4l2_ioctl_ops tea575x_ioctl_ops = {
488 	.vidioc_querycap    = vidioc_querycap,
489 	.vidioc_g_tuner     = vidioc_g_tuner,
490 	.vidioc_s_tuner     = vidioc_s_tuner,
491 	.vidioc_g_frequency = vidioc_g_frequency,
492 	.vidioc_s_frequency = vidioc_s_frequency,
493 	.vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
494 	.vidioc_enum_freq_bands = vidioc_enum_freq_bands,
495 	.vidioc_log_status  = v4l2_ctrl_log_status,
496 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
497 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
498 };
499 
500 static const struct video_device tea575x_radio = {
501 	.ioctl_ops	= &tea575x_ioctl_ops,
502 	.release        = video_device_release_empty,
503 };
504 
505 static const struct v4l2_ctrl_ops tea575x_ctrl_ops = {
506 	.s_ctrl = tea575x_s_ctrl,
507 };
508 
509 
snd_tea575x_hw_init(struct snd_tea575x * tea)510 int snd_tea575x_hw_init(struct snd_tea575x *tea)
511 {
512 	tea->mute = true;
513 
514 	/* Not all devices can or know how to read the data back.
515 	   Such devices can set cannot_read_data to true. */
516 	if (!tea->cannot_read_data) {
517 		snd_tea575x_write(tea, 0x55AA);
518 		if (snd_tea575x_read(tea) != 0x55AA)
519 			return -ENODEV;
520 	}
521 
522 	tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_5_28;
523 	tea->freq = 90500 * 16;		/* 90.5Mhz default */
524 	snd_tea575x_set_freq(tea);
525 
526 	return 0;
527 }
528 EXPORT_SYMBOL(snd_tea575x_hw_init);
529 
snd_tea575x_init(struct snd_tea575x * tea,struct module * owner)530 int snd_tea575x_init(struct snd_tea575x *tea, struct module *owner)
531 {
532 	int retval = snd_tea575x_hw_init(tea);
533 
534 	if (retval)
535 		return retval;
536 
537 	tea->vd = tea575x_radio;
538 	video_set_drvdata(&tea->vd, tea);
539 	mutex_init(&tea->mutex);
540 	strlcpy(tea->vd.name, tea->v4l2_dev->name, sizeof(tea->vd.name));
541 	tea->vd.lock = &tea->mutex;
542 	tea->vd.v4l2_dev = tea->v4l2_dev;
543 	tea->fops = tea575x_fops;
544 	tea->fops.owner = owner;
545 	tea->vd.fops = &tea->fops;
546 	/* disable hw_freq_seek if we can't use it */
547 	if (tea->cannot_read_data)
548 		v4l2_disable_ioctl(&tea->vd, VIDIOC_S_HW_FREQ_SEEK);
549 
550 	if (!tea->cannot_mute) {
551 		tea->vd.ctrl_handler = &tea->ctrl_handler;
552 		v4l2_ctrl_handler_init(&tea->ctrl_handler, 1);
553 		v4l2_ctrl_new_std(&tea->ctrl_handler, &tea575x_ctrl_ops,
554 				  V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
555 		retval = tea->ctrl_handler.error;
556 		if (retval) {
557 			v4l2_err(tea->v4l2_dev, "can't initialize controls\n");
558 			v4l2_ctrl_handler_free(&tea->ctrl_handler);
559 			return retval;
560 		}
561 
562 		if (tea->ext_init) {
563 			retval = tea->ext_init(tea);
564 			if (retval) {
565 				v4l2_ctrl_handler_free(&tea->ctrl_handler);
566 				return retval;
567 			}
568 		}
569 
570 		v4l2_ctrl_handler_setup(&tea->ctrl_handler);
571 	}
572 
573 	retval = video_register_device(&tea->vd, VFL_TYPE_RADIO, tea->radio_nr);
574 	if (retval) {
575 		v4l2_err(tea->v4l2_dev, "can't register video device!\n");
576 		v4l2_ctrl_handler_free(tea->vd.ctrl_handler);
577 		return retval;
578 	}
579 
580 	return 0;
581 }
582 EXPORT_SYMBOL(snd_tea575x_init);
583 
snd_tea575x_exit(struct snd_tea575x * tea)584 void snd_tea575x_exit(struct snd_tea575x *tea)
585 {
586 	video_unregister_device(&tea->vd);
587 	v4l2_ctrl_handler_free(tea->vd.ctrl_handler);
588 }
589 EXPORT_SYMBOL(snd_tea575x_exit);
590