Pull ec into release branch
[linux-2.6] / drivers / media / video / ivtv / ivtv-gpio.c
1 /*
2     gpio functions.
3     Merging GPIO support into driver:
4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
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 #include "ivtv-driver.h"
23 #include "ivtv-cards.h"
24 #include "ivtv-gpio.h"
25 #include <media/tuner.h>
26
27 /*
28  * GPIO assignment of Yuan MPG600/MPG160
29  *
30  *    bit 15  14  13  12 |  11  10   9   8 |   7   6   5   4 |   3   2   1   0
31  * OUTPUT         IN1 IN0                                       AM3 AM2 AM1 AM0
32  *  INPUT                   DM1         DM0
33  *
34  *   IN* : Input selection
35  *          IN1 IN0
36  *           1   1  N/A
37  *           1   0  Line
38  *           0   1  N/A
39  *           0   0  Tuner
40  *
41  *   AM* : Audio Mode
42  *          AM3  0: Normal        1: Mixed(Sub+Main channel)
43  *          AM2  0: Subchannel    1: Main channel
44  *          AM1  0: Stereo        1: Mono
45  *          AM0  0: Normal        1: Mute
46  *
47  *   DM* : Detected tuner audio Mode
48  *          DM1  0: Stereo        1: Mono
49  *          DM0  0: Multiplex     1: Normal
50  *
51  * GPIO Initial Settings
52  *           MPG600   MPG160
53  *     DIR   0x3080   0x7080
54  *  OUTPUT   0x000C   0x400C
55  *
56  *  Special thanks to Makoto Iguchi <iguchi@tahoo.org> and Mr. Anonymous
57  *  for analyzing GPIO of MPG160.
58  *
59  *****************************************************************************
60  *
61  * GPIO assignment of Avermedia M179 (per information direct from AVerMedia)
62  *
63  *    bit 15  14  13  12 |  11  10   9   8 |   7   6   5   4 |   3   2   1   0
64  * OUTPUT IN0 AM0 IN1               AM1 AM2       IN2     BR0   BR1
65  *  INPUT
66  *
67  *   IN* : Input selection
68  *          IN0 IN1 IN2
69  *           *   1   *  Mute
70  *           0   0   0  Line-In
71  *           1   0   0  TV Tuner Audio
72  *           0   0   1  FM Audio
73  *           1   0   1  Mute
74  *
75  *   AM* : Audio Mode
76  *          AM0 AM1 AM2
77  *           0   0   0  TV Tuner Audio: L_OUT=(L+R)/2, R_OUT=SAP
78  *           0   0   1  TV Tuner Audio: L_OUT=R_OUT=SAP   (SAP)
79  *           0   1   0  TV Tuner Audio: L_OUT=L, R_OUT=R   (stereo)
80  *           0   1   1  TV Tuner Audio: mute
81  *           1   *   *  TV Tuner Audio: L_OUT=R_OUT=(L+R)/2   (mono)
82  *
83  *   BR* : Audio Sample Rate (BR stands for bitrate for some reason)
84  *          BR0 BR1
85  *           0   0   32 kHz
86  *           0   1   44.1 kHz
87  *           1   0   48 kHz
88  *
89  *   DM* : Detected tuner audio Mode
90  *         Unknown currently
91  *
92  * Special thanks to AVerMedia Technologies, Inc. and Jiun-Kuei Jung at
93  * AVerMedia for providing the GPIO information used to add support
94  * for the M179 cards.
95  */
96
97 /********************* GPIO stuffs *********************/
98
99 /* GPIO registers */
100 #define IVTV_REG_GPIO_IN    0x9008
101 #define IVTV_REG_GPIO_OUT   0x900c
102 #define IVTV_REG_GPIO_DIR   0x9020
103
104 void ivtv_reset_ir_gpio(struct ivtv *itv)
105 {
106         int curdir, curout;
107
108         if (itv->card->type != IVTV_CARD_PVR_150)
109                 return;
110         IVTV_DEBUG_INFO("Resetting PVR150 IR\n");
111         curout = read_reg(IVTV_REG_GPIO_OUT);
112         curdir = read_reg(IVTV_REG_GPIO_DIR);
113         curdir |= 0x80;
114         write_reg(curdir, IVTV_REG_GPIO_DIR);
115         curout = (curout & ~0xF) | 1;
116         write_reg(curout, IVTV_REG_GPIO_OUT);
117         /* We could use something else for smaller time */
118         schedule_timeout_interruptible(msecs_to_jiffies(1));
119         curout |= 2;
120         write_reg(curout, IVTV_REG_GPIO_OUT);
121         curdir &= ~0x80;
122         write_reg(curdir, IVTV_REG_GPIO_DIR);
123 }
124
125 #ifdef HAVE_XC3028
126 int ivtv_reset_tuner_gpio(enum v4l2_tuner_type mode, void *priv, int ptr)
127 {
128         int curdir, curout;
129         struct ivtv *itv = (struct ivtv *) priv;
130
131         if (itv->card->type != IVTV_CARD_PG600V2 || itv->options.tuner != TUNER_XCEIVE_XC3028)
132                 return -EINVAL;
133         IVTV_INFO("Resetting tuner\n");
134         curout = read_reg(IVTV_REG_GPIO_OUT);
135         curdir = read_reg(IVTV_REG_GPIO_DIR);
136         curdir |= (1 << 12);  /* GPIO bit 12 */
137
138         curout &= ~(1 << 12);
139         write_reg(curout, IVTV_REG_GPIO_OUT);
140         schedule_timeout_interruptible(msecs_to_jiffies(1));
141
142         curout |= (1 << 12);
143         write_reg(curout, IVTV_REG_GPIO_OUT);
144         schedule_timeout_interruptible(msecs_to_jiffies(1));
145
146         return 0;
147 }
148 #endif
149
150 void ivtv_gpio_init(struct ivtv *itv)
151 {
152         if (itv->card->gpio_init.direction == 0)
153                 return;
154
155         IVTV_DEBUG_INFO("GPIO initial dir: %08x out: %08x\n",
156                    read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT));
157
158         /* init output data then direction */
159         write_reg(itv->card->gpio_init.initial_value, IVTV_REG_GPIO_OUT);
160         write_reg(itv->card->gpio_init.direction, IVTV_REG_GPIO_DIR);
161 }
162
163 static struct v4l2_queryctrl gpio_ctrl_mute = {
164         .id            = V4L2_CID_AUDIO_MUTE,
165         .type          = V4L2_CTRL_TYPE_BOOLEAN,
166         .name          = "Mute",
167         .minimum       = 0,
168         .maximum       = 1,
169         .step          = 1,
170         .default_value = 1,
171         .flags         = 0,
172 };
173
174 int ivtv_gpio(struct ivtv *itv, unsigned int command, void *arg)
175 {
176         struct v4l2_tuner *tuner = arg;
177         struct v4l2_control *ctrl = arg;
178         struct v4l2_routing *route = arg;
179         u16 mask, data;
180
181         switch (command) {
182         case VIDIOC_INT_AUDIO_CLOCK_FREQ:
183                 mask = itv->card->gpio_audio_freq.mask;
184                 switch (*(u32 *)arg) {
185                 case 32000:
186                         data = itv->card->gpio_audio_freq.f32000;
187                         break;
188                 case 44100:
189                         data = itv->card->gpio_audio_freq.f44100;
190                         break;
191                 case 48000:
192                 default:
193                         data = itv->card->gpio_audio_freq.f48000;
194                         break;
195                 }
196                 break;
197
198         case VIDIOC_G_TUNER:
199                 mask = itv->card->gpio_audio_detect.mask;
200                 if (mask == 0 || (read_reg(IVTV_REG_GPIO_IN) & mask))
201                         tuner->rxsubchans = V4L2_TUNER_MODE_STEREO |
202                                V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
203                 else
204                         tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
205                 return 0;
206
207         case VIDIOC_S_TUNER:
208                 mask = itv->card->gpio_audio_mode.mask;
209                 switch (tuner->audmode) {
210                 case V4L2_TUNER_MODE_LANG1:
211                         data = itv->card->gpio_audio_mode.lang1;
212                         break;
213                 case V4L2_TUNER_MODE_LANG2:
214                         data = itv->card->gpio_audio_mode.lang2;
215                         break;
216                 case V4L2_TUNER_MODE_MONO:
217                         data = itv->card->gpio_audio_mode.mono;
218                         break;
219                 case V4L2_TUNER_MODE_STEREO:
220                 case V4L2_TUNER_MODE_LANG1_LANG2:
221                 default:
222                         data = itv->card->gpio_audio_mode.stereo;
223                         break;
224                 }
225                 break;
226
227         case AUDC_SET_RADIO:
228                 mask = itv->card->gpio_audio_input.mask;
229                 data = itv->card->gpio_audio_input.radio;
230                 break;
231
232         case VIDIOC_S_STD:
233                 mask = itv->card->gpio_audio_input.mask;
234                 data = itv->card->gpio_audio_input.tuner;
235                 break;
236
237         case VIDIOC_INT_S_AUDIO_ROUTING:
238                 if (route->input > 2)
239                         return -EINVAL;
240                 mask = itv->card->gpio_audio_input.mask;
241                 switch (route->input) {
242                         case 0:
243                                 data = itv->card->gpio_audio_input.tuner;
244                                 break;
245                         case 1:
246                                 data = itv->card->gpio_audio_input.linein;
247                                 break;
248                         case 2:
249                         default:
250                                 data = itv->card->gpio_audio_input.radio;
251                                 break;
252                 }
253                 break;
254
255         case VIDIOC_G_CTRL:
256                 if (ctrl->id != V4L2_CID_AUDIO_MUTE)
257                         return -EINVAL;
258                 mask = itv->card->gpio_audio_mute.mask;
259                 data = itv->card->gpio_audio_mute.mute;
260                 ctrl->value = (read_reg(IVTV_REG_GPIO_OUT) & mask) == data;
261                 return 0;
262
263         case VIDIOC_S_CTRL:
264                 if (ctrl->id != V4L2_CID_AUDIO_MUTE)
265                         return -EINVAL;
266                 mask = itv->card->gpio_audio_mute.mask;
267                 data = ctrl->value ? itv->card->gpio_audio_mute.mute : 0;
268                 break;
269
270         case VIDIOC_QUERYCTRL:
271         {
272                 struct v4l2_queryctrl *qc = arg;
273
274                 if (qc->id != V4L2_CID_AUDIO_MUTE)
275                         return -EINVAL;
276                 *qc = gpio_ctrl_mute;
277                 return 0;
278         }
279
280         case VIDIOC_LOG_STATUS:
281                 IVTV_INFO("GPIO status: DIR=0x%04x OUT=0x%04x IN=0x%04x\n",
282                         read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT),
283                         read_reg(IVTV_REG_GPIO_IN));
284                 return 0;
285
286         case VIDIOC_INT_S_VIDEO_ROUTING:
287                 if (route->input > 2) /* 0:Tuner 1:Composite 2:S-Video */
288                         return -EINVAL;
289                 mask = itv->card->gpio_video_input.mask;
290                 if  (route->input == 0)
291                         data = itv->card->gpio_video_input.tuner;
292                 else if  (route->input == 1)
293                         data = itv->card->gpio_video_input.composite;
294                 else
295                         data = itv->card->gpio_video_input.svideo;
296                 break;
297
298         default:
299                 return -EINVAL;
300         }
301         if (mask)
302                 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT);
303         return 0;
304 }