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