b29b88f93c9e07e8e1860881576043c19c734f6e
[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         ((tea->tea5759 ? 760 :  875) * 1600U)
41 #define FREQ_HI         ((tea->tea5759 ? 910 : 1080) * 1600U)
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 u32 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 u32 snd_tea575x_val_to_freq(struct snd_tea575x *tea, u32 val)
124 {
125         u32 freq = val & TEA575X_BIT_FREQ_MASK;
126
127         if (freq == 0)
128                 return freq;
129
130         /* freq *= 12.5 */
131         freq *= 125;
132         freq /= 10;
133         /* crystal fixup */
134         if (tea->tea5759)
135                 freq += TEA575X_FMIF;
136         else
137                 freq -= TEA575X_FMIF;
138
139         return clamp(freq * 16, FREQ_LO, FREQ_HI); /* from kHz */
140 }
141
142 static u32 snd_tea575x_get_freq(struct snd_tea575x *tea)
143 {
144         return snd_tea575x_val_to_freq(tea, snd_tea575x_read(tea));
145 }
146
147 static void snd_tea575x_set_freq(struct snd_tea575x *tea)
148 {
149         u32 freq = tea->freq;
150
151         freq /= 16;             /* to kHz */
152         /* crystal fixup */
153         if (tea->tea5759)
154                 freq -= TEA575X_FMIF;
155         else
156                 freq += TEA575X_FMIF;
157         /* freq /= 12.5 */
158         freq *= 10;
159         freq /= 125;
160
161         tea->val &= ~TEA575X_BIT_FREQ_MASK;
162         tea->val |= freq & TEA575X_BIT_FREQ_MASK;
163         snd_tea575x_write(tea, tea->val);
164         tea->freq = snd_tea575x_val_to_freq(tea, tea->val);
165 }
166
167 /*
168  * Linux Video interface
169  */
170
171 static int vidioc_querycap(struct file *file, void  *priv,
172                                         struct v4l2_capability *v)
173 {
174         struct snd_tea575x *tea = video_drvdata(file);
175
176         strlcpy(v->driver, tea->v4l2_dev->name, sizeof(v->driver));
177         strlcpy(v->card, tea->card, sizeof(v->card));
178         strlcat(v->card, tea->tea5759 ? " TEA5759" : " TEA5757", sizeof(v->card));
179         strlcpy(v->bus_info, tea->bus_info, sizeof(v->bus_info));
180         v->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
181         if (!tea->cannot_read_data)
182                 v->device_caps |= V4L2_CAP_HW_FREQ_SEEK;
183         v->capabilities = v->device_caps | V4L2_CAP_DEVICE_CAPS;
184         return 0;
185 }
186
187 static int vidioc_g_tuner(struct file *file, void *priv,
188                                         struct v4l2_tuner *v)
189 {
190         struct snd_tea575x *tea = video_drvdata(file);
191
192         if (v->index > 0)
193                 return -EINVAL;
194
195         snd_tea575x_read(tea);
196
197         strcpy(v->name, "FM");
198         v->type = V4L2_TUNER_RADIO;
199         v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
200         if (!tea->cannot_read_data)
201                 v->capability |= V4L2_TUNER_CAP_HWSEEK_BOUNDED;
202         v->rangelow = FREQ_LO;
203         v->rangehigh = FREQ_HI;
204         v->rxsubchans = tea->stereo ? V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
205         v->audmode = (tea->val & TEA575X_BIT_MONO) ?
206                 V4L2_TUNER_MODE_MONO : V4L2_TUNER_MODE_STEREO;
207         v->signal = tea->tuned ? 0xffff : 0;
208         return 0;
209 }
210
211 static int vidioc_s_tuner(struct file *file, void *priv,
212                                         struct v4l2_tuner *v)
213 {
214         struct snd_tea575x *tea = video_drvdata(file);
215
216         if (v->index)
217                 return -EINVAL;
218         tea->val &= ~TEA575X_BIT_MONO;
219         if (v->audmode == V4L2_TUNER_MODE_MONO)
220                 tea->val |= TEA575X_BIT_MONO;
221         snd_tea575x_write(tea, tea->val);
222         return 0;
223 }
224
225 static int vidioc_g_frequency(struct file *file, void *priv,
226                                         struct v4l2_frequency *f)
227 {
228         struct snd_tea575x *tea = video_drvdata(file);
229
230         if (f->tuner != 0)
231                 return -EINVAL;
232         f->type = V4L2_TUNER_RADIO;
233         f->frequency = tea->freq;
234         return 0;
235 }
236
237 static int vidioc_s_frequency(struct file *file, void *priv,
238                                         struct v4l2_frequency *f)
239 {
240         struct snd_tea575x *tea = video_drvdata(file);
241
242         if (f->tuner != 0 || f->type != V4L2_TUNER_RADIO)
243                 return -EINVAL;
244
245         tea->val &= ~TEA575X_BIT_SEARCH;
246         tea->freq = clamp(f->frequency, FREQ_LO, FREQ_HI);
247         snd_tea575x_set_freq(tea);
248         return 0;
249 }
250
251 static int vidioc_s_hw_freq_seek(struct file *file, void *fh,
252                                         struct v4l2_hw_freq_seek *a)
253 {
254         struct snd_tea575x *tea = video_drvdata(file);
255         unsigned long timeout;
256         int i;
257
258         if (tea->cannot_read_data)
259                 return -ENOTTY;
260         if (a->tuner || a->wrap_around)
261                 return -EINVAL;
262
263         /* clear the frequency, HW will fill it in */
264         tea->val &= ~TEA575X_BIT_FREQ_MASK;
265         tea->val |= TEA575X_BIT_SEARCH;
266         if (a->seek_upward)
267                 tea->val |= TEA575X_BIT_UPDOWN;
268         else
269                 tea->val &= ~TEA575X_BIT_UPDOWN;
270         snd_tea575x_write(tea, tea->val);
271         timeout = jiffies + msecs_to_jiffies(10000);
272         for (;;) {
273                 if (time_after(jiffies, timeout))
274                         break;
275                 if (schedule_timeout_interruptible(msecs_to_jiffies(10))) {
276                         /* some signal arrived, stop search */
277                         tea->val &= ~TEA575X_BIT_SEARCH;
278                         snd_tea575x_set_freq(tea);
279                         return -ERESTARTSYS;
280                 }
281                 if (!(snd_tea575x_read(tea) & TEA575X_BIT_SEARCH)) {
282                         u32 freq;
283
284                         /* Found a frequency, wait until it can be read */
285                         for (i = 0; i < 100; i++) {
286                                 msleep(10);
287                                 freq = snd_tea575x_get_freq(tea);
288                                 if (freq) /* available */
289                                         break;
290                         }
291                         if (freq == 0) /* shouldn't happen */
292                                 break;
293                         /*
294                          * if we moved by less than 50 kHz, or in the wrong
295                          * direction, continue seeking
296                          */
297                         if (abs(tea->freq - freq) < 16 * 50 ||
298                                         (a->seek_upward && freq < tea->freq) ||
299                                         (!a->seek_upward && freq > tea->freq)) {
300                                 snd_tea575x_write(tea, tea->val);
301                                 continue;
302                         }
303                         tea->freq = freq;
304                         tea->val &= ~TEA575X_BIT_SEARCH;
305                         return 0;
306                 }
307         }
308         tea->val &= ~TEA575X_BIT_SEARCH;
309         snd_tea575x_set_freq(tea);
310         return -ENODATA;
311 }
312
313 static int tea575x_s_ctrl(struct v4l2_ctrl *ctrl)
314 {
315         struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler);
316
317         switch (ctrl->id) {
318         case V4L2_CID_AUDIO_MUTE:
319                 tea->mute = ctrl->val;
320                 snd_tea575x_set_freq(tea);
321                 return 0;
322         }
323
324         return -EINVAL;
325 }
326
327 static const struct v4l2_file_operations tea575x_fops = {
328         .unlocked_ioctl = video_ioctl2,
329         .open           = v4l2_fh_open,
330         .release        = v4l2_fh_release,
331         .poll           = v4l2_ctrl_poll,
332 };
333
334 static const struct v4l2_ioctl_ops tea575x_ioctl_ops = {
335         .vidioc_querycap    = vidioc_querycap,
336         .vidioc_g_tuner     = vidioc_g_tuner,
337         .vidioc_s_tuner     = vidioc_s_tuner,
338         .vidioc_g_frequency = vidioc_g_frequency,
339         .vidioc_s_frequency = vidioc_s_frequency,
340         .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
341         .vidioc_log_status  = v4l2_ctrl_log_status,
342         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
343         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
344 };
345
346 static const struct video_device tea575x_radio = {
347         .ioctl_ops      = &tea575x_ioctl_ops,
348         .release        = video_device_release_empty,
349 };
350
351 static const struct v4l2_ctrl_ops tea575x_ctrl_ops = {
352         .s_ctrl = tea575x_s_ctrl,
353 };
354
355 /*
356  * initialize all the tea575x chips
357  */
358 int snd_tea575x_init(struct snd_tea575x *tea, struct module *owner)
359 {
360         int retval;
361
362         tea->mute = true;
363
364         /* Not all devices can or know how to read the data back.
365            Such devices can set cannot_read_data to true. */
366         if (!tea->cannot_read_data) {
367                 snd_tea575x_write(tea, 0x55AA);
368                 if (snd_tea575x_read(tea) != 0x55AA)
369                         return -ENODEV;
370         }
371
372         tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_5_28;
373         tea->freq = 90500 * 16;         /* 90.5Mhz default */
374         snd_tea575x_set_freq(tea);
375
376         tea->vd = tea575x_radio;
377         video_set_drvdata(&tea->vd, tea);
378         mutex_init(&tea->mutex);
379         strlcpy(tea->vd.name, tea->v4l2_dev->name, sizeof(tea->vd.name));
380         tea->vd.lock = &tea->mutex;
381         tea->vd.v4l2_dev = tea->v4l2_dev;
382         tea->vd.ctrl_handler = &tea->ctrl_handler;
383         tea->fops = tea575x_fops;
384         tea->fops.owner = owner;
385         tea->vd.fops = &tea->fops;
386         set_bit(V4L2_FL_USE_FH_PRIO, &tea->vd.flags);
387         /* disable hw_freq_seek if we can't use it */
388         if (tea->cannot_read_data)
389                 v4l2_disable_ioctl(&tea->vd, VIDIOC_S_HW_FREQ_SEEK);
390
391         v4l2_ctrl_handler_init(&tea->ctrl_handler, 1);
392         v4l2_ctrl_new_std(&tea->ctrl_handler, &tea575x_ctrl_ops, V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
393         retval = tea->ctrl_handler.error;
394         if (retval) {
395                 v4l2_err(tea->v4l2_dev, "can't initialize controls\n");
396                 v4l2_ctrl_handler_free(&tea->ctrl_handler);
397                 return retval;
398         }
399
400         if (tea->ext_init) {
401                 retval = tea->ext_init(tea);
402                 if (retval) {
403                         v4l2_ctrl_handler_free(&tea->ctrl_handler);
404                         return retval;
405                 }
406         }
407
408         v4l2_ctrl_handler_setup(&tea->ctrl_handler);
409
410         retval = video_register_device(&tea->vd, VFL_TYPE_RADIO, tea->radio_nr);
411         if (retval) {
412                 v4l2_err(tea->v4l2_dev, "can't register video device!\n");
413                 v4l2_ctrl_handler_free(&tea->ctrl_handler);
414                 return retval;
415         }
416
417         return 0;
418 }
419
420 void snd_tea575x_exit(struct snd_tea575x *tea)
421 {
422         video_unregister_device(&tea->vd);
423         v4l2_ctrl_handler_free(&tea->ctrl_handler);
424 }
425
426 static int __init alsa_tea575x_module_init(void)
427 {
428         return 0;
429 }
430
431 static void __exit alsa_tea575x_module_exit(void)
432 {
433 }
434
435 module_init(alsa_tea575x_module_init)
436 module_exit(alsa_tea575x_module_exit)
437
438 EXPORT_SYMBOL(snd_tea575x_init);
439 EXPORT_SYMBOL(snd_tea575x_exit);