[media] tea575x-tuner: update to latest V4L2 framework requirements
[linux-3.10.git] / sound / i2c / other / tea575x-tuner.c
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  *   You should have received a copy of the GNU General Public License
18  *   along with this program; if not, write to the Free Software
19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  *
21  */
22
23 #include <asm/io.h>
24 #include <linux/delay.h>
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/sched.h>
29 #include <media/v4l2-device.h>
30 #include <media/v4l2-dev.h>
31 #include <media/v4l2-fh.h>
32 #include <media/v4l2-ioctl.h>
33 #include <media/v4l2-event.h>
34 #include <sound/tea575x-tuner.h>
35
36 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
37 MODULE_DESCRIPTION("Routines for control of TEA5757/5759 Philips AM/FM radio tuner chips");
38 MODULE_LICENSE("GPL");
39
40 #define FREQ_LO          (76U * 16000)
41 #define FREQ_HI         (108U * 16000)
42
43 /*
44  * definitions
45  */
46
47 #define TEA575X_BIT_SEARCH      (1<<24)         /* 1 = search action, 0 = tuned */
48 #define TEA575X_BIT_UPDOWN      (1<<23)         /* 0 = search down, 1 = search up */
49 #define TEA575X_BIT_MONO        (1<<22)         /* 0 = stereo, 1 = mono */
50 #define TEA575X_BIT_BAND_MASK   (3<<20)
51 #define TEA575X_BIT_BAND_FM     (0<<20)
52 #define TEA575X_BIT_BAND_MW     (1<<20)
53 #define TEA575X_BIT_BAND_LW     (1<<21)
54 #define TEA575X_BIT_BAND_SW     (1<<22)
55 #define TEA575X_BIT_PORT_0      (1<<19)         /* user bit */
56 #define TEA575X_BIT_PORT_1      (1<<18)         /* user bit */
57 #define TEA575X_BIT_SEARCH_MASK (3<<16)         /* search level */
58 #define TEA575X_BIT_SEARCH_5_28      (0<<16)    /* FM >5uV, AM >28uV */
59 #define TEA575X_BIT_SEARCH_10_40     (1<<16)    /* FM >10uV, AM > 40uV */
60 #define TEA575X_BIT_SEARCH_30_63     (2<<16)    /* FM >30uV, AM > 63uV */
61 #define TEA575X_BIT_SEARCH_150_1000  (3<<16)    /* FM > 150uV, AM > 1000uV */
62 #define TEA575X_BIT_DUMMY       (1<<15)         /* buffer */
63 #define TEA575X_BIT_FREQ_MASK   0x7fff
64
65 /*
66  * lowlevel part
67  */
68
69 static void snd_tea575x_write(struct snd_tea575x *tea, unsigned int val)
70 {
71         u16 l;
72         u8 data;
73
74         tea->ops->set_direction(tea, 1);
75         udelay(16);
76
77         for (l = 25; l > 0; l--) {
78                 data = (val >> 24) & TEA575X_DATA;
79                 val <<= 1;                      /* shift data */
80                 tea->ops->set_pins(tea, data | TEA575X_WREN);
81                 udelay(2);
82                 tea->ops->set_pins(tea, data | TEA575X_WREN | TEA575X_CLK);
83                 udelay(2);
84                 tea->ops->set_pins(tea, data | TEA575X_WREN);
85                 udelay(2);
86         }
87
88         if (!tea->mute)
89                 tea->ops->set_pins(tea, 0);
90 }
91
92 static unsigned int snd_tea575x_read(struct snd_tea575x *tea)
93 {
94         u16 l, rdata;
95         u32 data = 0;
96
97         tea->ops->set_direction(tea, 0);
98         tea->ops->set_pins(tea, 0);
99         udelay(16);
100
101         for (l = 24; l--;) {
102                 tea->ops->set_pins(tea, TEA575X_CLK);
103                 udelay(2);
104                 if (!l)
105                         tea->tuned = tea->ops->get_pins(tea) & TEA575X_MOST ? 0 : 1;
106                 tea->ops->set_pins(tea, 0);
107                 udelay(2);
108                 data <<= 1;                     /* shift data */
109                 rdata = tea->ops->get_pins(tea);
110                 if (!l)
111                         tea->stereo = (rdata & TEA575X_MOST) ?  0 : 1;
112                 if (rdata & TEA575X_DATA)
113                         data++;
114                 udelay(2);
115         }
116
117         if (tea->mute)
118                 tea->ops->set_pins(tea, TEA575X_WREN);
119
120         return data;
121 }
122
123 static void snd_tea575x_set_freq(struct snd_tea575x *tea)
124 {
125         u32 freq = tea->freq;
126
127         freq /= 16;             /* to kHz */
128         /* crystal fixup */
129         if (tea->tea5759)
130                 freq -= TEA575X_FMIF;
131         else
132                 freq += TEA575X_FMIF;
133         /* freq /= 12.5 */
134         freq *= 10;
135         freq /= 125;
136
137         tea->val &= ~TEA575X_BIT_FREQ_MASK;
138         tea->val |= freq & TEA575X_BIT_FREQ_MASK;
139         snd_tea575x_write(tea, tea->val);
140 }
141
142 /*
143  * Linux Video interface
144  */
145
146 static int vidioc_querycap(struct file *file, void  *priv,
147                                         struct v4l2_capability *v)
148 {
149         struct snd_tea575x *tea = video_drvdata(file);
150
151         strlcpy(v->driver, tea->v4l2_dev->name, sizeof(v->driver));
152         strlcpy(v->card, tea->card, sizeof(v->card));
153         strlcat(v->card, tea->tea5759 ? " TEA5759" : " TEA5757", sizeof(v->card));
154         strlcpy(v->bus_info, tea->bus_info, sizeof(v->bus_info));
155         v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
156         if (!tea->cannot_read_data)
157                 v->device_caps |= V4L2_CAP_HW_FREQ_SEEK;
158         v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
159         return 0;
160 }
161
162 static int vidioc_g_tuner(struct file *file, void *priv,
163                                         struct v4l2_tuner *v)
164 {
165         struct snd_tea575x *tea = video_drvdata(file);
166
167         if (v->index > 0)
168                 return -EINVAL;
169
170         snd_tea575x_read(tea);
171
172         strcpy(v->name, "FM");
173         v->type = V4L2_TUNER_RADIO;
174         v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
175         v->rangelow = FREQ_LO;
176         v->rangehigh = FREQ_HI;
177         v->rxsubchans = tea->stereo ? V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
178         v->audmode = (tea->val & TEA575X_BIT_MONO) ?
179                 V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO;
180         v->signal = tea->tuned ? 0xffff : 0;
181         return 0;
182 }
183
184 static int vidioc_s_tuner(struct file *file, void *priv,
185                                         struct v4l2_tuner *v)
186 {
187         struct snd_tea575x *tea = video_drvdata(file);
188
189         if (v->index)
190                 return -EINVAL;
191         tea->val &= ~TEA575X_BIT_MONO;
192         if (v->audmode == V4L2_TUNER_MODE_MONO)
193                 tea->val |= TEA575X_BIT_MONO;
194         snd_tea575x_write(tea, tea->val);
195         return 0;
196 }
197
198 static int vidioc_g_frequency(struct file *file, void *priv,
199                                         struct v4l2_frequency *f)
200 {
201         struct snd_tea575x *tea = video_drvdata(file);
202
203         if (f->tuner != 0)
204                 return -EINVAL;
205         f->type = V4L2_TUNER_RADIO;
206         f->frequency = tea->freq;
207         return 0;
208 }
209
210 static int vidioc_s_frequency(struct file *file, void *priv,
211                                         struct v4l2_frequency *f)
212 {
213         struct snd_tea575x *tea = video_drvdata(file);
214
215         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
216                 return -EINVAL;
217
218         tea->val &= ~TEA575X_BIT_SEARCH;
219         tea->freq = clamp(f->frequency, FREQ_LO, FREQ_HI);
220         snd_tea575x_set_freq(tea);
221         return 0;
222 }
223
224 static int vidioc_s_hw_freq_seek(struct file *file, void *fh,
225                                         struct v4l2_hw_freq_seek *a)
226 {
227         struct snd_tea575x *tea = video_drvdata(file);
228
229         if (tea->cannot_read_data)
230                 return -ENOTTY;
231         if (a->tuner || a->wrap_around)
232                 return -EINVAL;
233         tea->val |= TEA575X_BIT_SEARCH;
234         tea->val &= ~TEA575X_BIT_UPDOWN;
235         if (a->seek_upward)
236                 tea->val |= TEA575X_BIT_UPDOWN;
237         snd_tea575x_write(tea, tea->val);
238         for (;;) {
239                 unsigned val = snd_tea575x_read(tea);
240
241                 if (!(val & TEA575X_BIT_SEARCH)) {
242                         /* Found a frequency */
243                         val &= TEA575X_BIT_FREQ_MASK;
244                         val = (val * 10) / 125;
245                         if (tea->tea5759)
246                                 val += TEA575X_FMIF;
247                         else
248                                 val -= TEA575X_FMIF;
249                         tea->freq = clamp(val * 16, FREQ_LO, FREQ_HI);
250                         return 0;
251                 }
252                 if (schedule_timeout_interruptible(msecs_to_jiffies(10))) {
253                         /* some signal arrived, stop search */
254                         tea->val &= ~TEA575X_BIT_SEARCH;
255                         snd_tea575x_write(tea, tea->val);
256                         return -ERESTARTSYS;
257                 }
258         }
259         return 0;
260 }
261
262 static int tea575x_s_ctrl(struct v4l2_ctrl *ctrl)
263 {
264         struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler);
265
266         switch (ctrl->id) {
267         case V4L2_CID_AUDIO_MUTE:
268                 tea->mute = ctrl->val;
269                 snd_tea575x_set_freq(tea);
270                 return 0;
271         }
272
273         return -EINVAL;
274 }
275
276 static const struct v4l2_file_operations tea575x_fops = {
277         .owner          = THIS_MODULE,
278         .unlocked_ioctl = video_ioctl2,
279         .open           = v4l2_fh_open,
280         .release        = v4l2_fh_release,
281         .poll           = v4l2_ctrl_poll,
282 };
283
284 static const struct v4l2_ioctl_ops tea575x_ioctl_ops = {
285         .vidioc_querycap    = vidioc_querycap,
286         .vidioc_g_tuner     = vidioc_g_tuner,
287         .vidioc_s_tuner     = vidioc_s_tuner,
288         .vidioc_g_frequency = vidioc_g_frequency,
289         .vidioc_s_frequency = vidioc_s_frequency,
290         .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
291         .vidioc_log_status  = v4l2_ctrl_log_status,
292         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
293         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
294 };
295
296 static const struct video_device tea575x_radio = {
297         .fops           = &tea575x_fops,
298         .ioctl_ops      = &tea575x_ioctl_ops,
299         .release        = video_device_release_empty,
300 };
301
302 static const struct v4l2_ctrl_ops tea575x_ctrl_ops = {
303         .s_ctrl = tea575x_s_ctrl,
304 };
305
306 /*
307  * initialize all the tea575x chips
308  */
309 int snd_tea575x_init(struct snd_tea575x *tea)
310 {
311         int retval;
312
313         tea->mute = true;
314
315         /* Not all devices can or know how to read the data back.
316            Such devices can set cannot_read_data to true. */
317         if (!tea->cannot_read_data) {
318                 snd_tea575x_write(tea, 0x55AA);
319                 if (snd_tea575x_read(tea) != 0x55AA)
320                         return -ENODEV;
321         }
322
323         tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_10_40;
324         tea->freq = 90500 * 16;         /* 90.5Mhz default */
325         snd_tea575x_set_freq(tea);
326
327         tea->vd = tea575x_radio;
328         video_set_drvdata(&tea->vd, tea);
329         mutex_init(&tea->mutex);
330         strlcpy(tea->vd.name, tea->v4l2_dev->name, sizeof(tea->vd.name));
331         tea->vd.lock = &tea->mutex;
332         tea->vd.v4l2_dev = tea->v4l2_dev;
333         tea->vd.ctrl_handler = &tea->ctrl_handler;
334         set_bit(V4L2_FL_USE_FH_PRIO, &tea->vd.flags);
335
336         v4l2_ctrl_handler_init(&tea->ctrl_handler, 1);
337         v4l2_ctrl_new_std(&tea->ctrl_handler, &tea575x_ctrl_ops, V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
338         retval = tea->ctrl_handler.error;
339         if (retval) {
340                 v4l2_err(tea->v4l2_dev, "can't initialize controls\n");
341                 v4l2_ctrl_handler_free(&tea->ctrl_handler);
342                 return retval;
343         }
344
345         if (tea->ext_init) {
346                 retval = tea->ext_init(tea);
347                 if (retval) {
348                         v4l2_ctrl_handler_free(&tea->ctrl_handler);
349                         return retval;
350                 }
351         }
352
353         v4l2_ctrl_handler_setup(&tea->ctrl_handler);
354
355         retval = video_register_device(&tea->vd, VFL_TYPE_RADIO, tea->radio_nr);
356         if (retval) {
357                 v4l2_err(tea->v4l2_dev, "can't register video device!\n");
358                 v4l2_ctrl_handler_free(&tea->ctrl_handler);
359                 return retval;
360         }
361
362         return 0;
363 }
364
365 void snd_tea575x_exit(struct snd_tea575x *tea)
366 {
367         video_unregister_device(&tea->vd);
368         v4l2_ctrl_handler_free(&tea->ctrl_handler);
369 }
370
371 static int __init alsa_tea575x_module_init(void)
372 {
373         return 0;
374 }
375
376 static void __exit alsa_tea575x_module_exit(void)
377 {
378 }
379
380 module_init(alsa_tea575x_module_init)
381 module_exit(alsa_tea575x_module_exit)
382
383 EXPORT_SYMBOL(snd_tea575x_init);
384 EXPORT_SYMBOL(snd_tea575x_exit);