]>
Commit | Line | Data |
---|---|---|
1a0adaf3 HV |
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" | |
0e614cd1 | 25 | #include "tuner-xc2028.h" |
1a0adaf3 HV |
26 | #include <media/tuner.h> |
27 | ||
28 | /* | |
29 | * GPIO assignment of Yuan MPG600/MPG160 | |
30 | * | |
31 | * bit 15 14 13 12 | 11 10 9 8 | 7 6 5 4 | 3 2 1 0 | |
32 | * OUTPUT IN1 IN0 AM3 AM2 AM1 AM0 | |
33 | * INPUT DM1 DM0 | |
34 | * | |
35 | * IN* : Input selection | |
36 | * IN1 IN0 | |
37 | * 1 1 N/A | |
38 | * 1 0 Line | |
39 | * 0 1 N/A | |
40 | * 0 0 Tuner | |
41 | * | |
42 | * AM* : Audio Mode | |
43 | * AM3 0: Normal 1: Mixed(Sub+Main channel) | |
44 | * AM2 0: Subchannel 1: Main channel | |
45 | * AM1 0: Stereo 1: Mono | |
46 | * AM0 0: Normal 1: Mute | |
47 | * | |
48 | * DM* : Detected tuner audio Mode | |
49 | * DM1 0: Stereo 1: Mono | |
50 | * DM0 0: Multiplex 1: Normal | |
51 | * | |
52 | * GPIO Initial Settings | |
53 | * MPG600 MPG160 | |
54 | * DIR 0x3080 0x7080 | |
55 | * OUTPUT 0x000C 0x400C | |
56 | * | |
57 | * Special thanks to Makoto Iguchi <iguchi@tahoo.org> and Mr. Anonymous | |
58 | * for analyzing GPIO of MPG160. | |
59 | * | |
60 | ***************************************************************************** | |
61 | * | |
62 | * GPIO assignment of Avermedia M179 (per information direct from AVerMedia) | |
63 | * | |
64 | * bit 15 14 13 12 | 11 10 9 8 | 7 6 5 4 | 3 2 1 0 | |
65 | * OUTPUT IN0 AM0 IN1 AM1 AM2 IN2 BR0 BR1 | |
66 | * INPUT | |
67 | * | |
68 | * IN* : Input selection | |
69 | * IN0 IN1 IN2 | |
70 | * * 1 * Mute | |
71 | * 0 0 0 Line-In | |
72 | * 1 0 0 TV Tuner Audio | |
73 | * 0 0 1 FM Audio | |
74 | * 1 0 1 Mute | |
75 | * | |
76 | * AM* : Audio Mode | |
77 | * AM0 AM1 AM2 | |
78 | * 0 0 0 TV Tuner Audio: L_OUT=(L+R)/2, R_OUT=SAP | |
79 | * 0 0 1 TV Tuner Audio: L_OUT=R_OUT=SAP (SAP) | |
80 | * 0 1 0 TV Tuner Audio: L_OUT=L, R_OUT=R (stereo) | |
81 | * 0 1 1 TV Tuner Audio: mute | |
82 | * 1 * * TV Tuner Audio: L_OUT=R_OUT=(L+R)/2 (mono) | |
83 | * | |
84 | * BR* : Audio Sample Rate (BR stands for bitrate for some reason) | |
85 | * BR0 BR1 | |
86 | * 0 0 32 kHz | |
87 | * 0 1 44.1 kHz | |
88 | * 1 0 48 kHz | |
89 | * | |
90 | * DM* : Detected tuner audio Mode | |
91 | * Unknown currently | |
92 | * | |
93 | * Special thanks to AVerMedia Technologies, Inc. and Jiun-Kuei Jung at | |
94 | * AVerMedia for providing the GPIO information used to add support | |
95 | * for the M179 cards. | |
96 | */ | |
97 | ||
98 | /********************* GPIO stuffs *********************/ | |
99 | ||
100 | /* GPIO registers */ | |
101 | #define IVTV_REG_GPIO_IN 0x9008 | |
102 | #define IVTV_REG_GPIO_OUT 0x900c | |
103 | #define IVTV_REG_GPIO_DIR 0x9020 | |
104 | ||
105 | void ivtv_reset_ir_gpio(struct ivtv *itv) | |
106 | { | |
107 | int curdir, curout; | |
108 | ||
109 | if (itv->card->type != IVTV_CARD_PVR_150) | |
110 | return; | |
111 | IVTV_DEBUG_INFO("Resetting PVR150 IR\n"); | |
112 | curout = read_reg(IVTV_REG_GPIO_OUT); | |
113 | curdir = read_reg(IVTV_REG_GPIO_DIR); | |
114 | curdir |= 0x80; | |
115 | write_reg(curdir, IVTV_REG_GPIO_DIR); | |
116 | curout = (curout & ~0xF) | 1; | |
117 | write_reg(curout, IVTV_REG_GPIO_OUT); | |
118 | /* We could use something else for smaller time */ | |
97989ada | 119 | schedule_timeout_interruptible(msecs_to_jiffies(1)); |
1a0adaf3 HV |
120 | curout |= 2; |
121 | write_reg(curout, IVTV_REG_GPIO_OUT); | |
122 | curdir &= ~0x80; | |
123 | write_reg(curdir, IVTV_REG_GPIO_DIR); | |
124 | } | |
125 | ||
0e614cd1 | 126 | /* Xceive tuner reset function */ |
d7cba043 | 127 | int ivtv_reset_tuner_gpio(void *dev, int component, int cmd, int value) |
0e614cd1 HV |
128 | { |
129 | struct i2c_algo_bit_data *algo = dev; | |
130 | struct ivtv *itv = algo->data; | |
136531da | 131 | u32 curout; |
0e614cd1 HV |
132 | |
133 | if (cmd != XC2028_TUNER_RESET) | |
134 | return 0; | |
135 | IVTV_DEBUG_INFO("Resetting tuner\n"); | |
136 | curout = read_reg(IVTV_REG_GPIO_OUT); | |
136531da | 137 | curout &= ~(1 << itv->card->xceive_pin); |
0e614cd1 HV |
138 | write_reg(curout, IVTV_REG_GPIO_OUT); |
139 | schedule_timeout_interruptible(msecs_to_jiffies(1)); | |
140 | ||
136531da | 141 | curout |= 1 << itv->card->xceive_pin; |
0e614cd1 HV |
142 | write_reg(curout, IVTV_REG_GPIO_OUT); |
143 | schedule_timeout_interruptible(msecs_to_jiffies(1)); | |
144 | return 0; | |
145 | } | |
1a0adaf3 | 146 | |
67ec09fd | 147 | static inline struct ivtv *sd_to_ivtv(struct v4l2_subdev *sd) |
1a0adaf3 | 148 | { |
67ec09fd | 149 | return container_of(sd, struct ivtv, sd_gpio); |
1a0adaf3 HV |
150 | } |
151 | ||
152 | static struct v4l2_queryctrl gpio_ctrl_mute = { | |
153 | .id = V4L2_CID_AUDIO_MUTE, | |
154 | .type = V4L2_CTRL_TYPE_BOOLEAN, | |
155 | .name = "Mute", | |
156 | .minimum = 0, | |
157 | .maximum = 1, | |
158 | .step = 1, | |
159 | .default_value = 1, | |
160 | .flags = 0, | |
161 | }; | |
162 | ||
67ec09fd | 163 | static int subdev_s_clock_freq(struct v4l2_subdev *sd, u32 freq) |
1a0adaf3 | 164 | { |
67ec09fd | 165 | struct ivtv *itv = sd_to_ivtv(sd); |
1a0adaf3 HV |
166 | u16 mask, data; |
167 | ||
67ec09fd HV |
168 | mask = itv->card->gpio_audio_freq.mask; |
169 | switch (freq) { | |
170 | case 32000: | |
171 | data = itv->card->gpio_audio_freq.f32000; | |
172 | break; | |
173 | case 44100: | |
174 | data = itv->card->gpio_audio_freq.f44100; | |
175 | break; | |
176 | case 48000: | |
177 | default: | |
178 | data = itv->card->gpio_audio_freq.f48000; | |
1a0adaf3 | 179 | break; |
67ec09fd HV |
180 | } |
181 | if (mask) | |
182 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
183 | return 0; | |
184 | } | |
1a0adaf3 | 185 | |
67ec09fd HV |
186 | static int subdev_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) |
187 | { | |
188 | struct ivtv *itv = sd_to_ivtv(sd); | |
189 | u16 mask; | |
190 | ||
191 | mask = itv->card->gpio_audio_detect.mask; | |
192 | if (mask == 0 || (read_reg(IVTV_REG_GPIO_IN) & mask)) | |
dc47b778 HV |
193 | vt->rxsubchans = V4L2_TUNER_SUB_STEREO | |
194 | V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; | |
67ec09fd HV |
195 | else |
196 | vt->rxsubchans = V4L2_TUNER_SUB_MONO; | |
197 | return 0; | |
198 | } | |
1a0adaf3 | 199 | |
67ec09fd HV |
200 | static int subdev_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) |
201 | { | |
202 | struct ivtv *itv = sd_to_ivtv(sd); | |
203 | u16 mask, data; | |
1a0adaf3 | 204 | |
67ec09fd HV |
205 | mask = itv->card->gpio_audio_mode.mask; |
206 | switch (vt->audmode) { | |
207 | case V4L2_TUNER_MODE_LANG1: | |
208 | data = itv->card->gpio_audio_mode.lang1; | |
209 | break; | |
210 | case V4L2_TUNER_MODE_LANG2: | |
211 | data = itv->card->gpio_audio_mode.lang2; | |
212 | break; | |
213 | case V4L2_TUNER_MODE_MONO: | |
214 | data = itv->card->gpio_audio_mode.mono; | |
1a0adaf3 | 215 | break; |
67ec09fd HV |
216 | case V4L2_TUNER_MODE_STEREO: |
217 | case V4L2_TUNER_MODE_LANG1_LANG2: | |
218 | default: | |
219 | data = itv->card->gpio_audio_mode.stereo; | |
220 | break; | |
221 | } | |
222 | if (mask) | |
223 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
224 | return 0; | |
225 | } | |
226 | ||
227 | static int subdev_s_radio(struct v4l2_subdev *sd) | |
228 | { | |
229 | struct ivtv *itv = sd_to_ivtv(sd); | |
230 | u16 mask, data; | |
231 | ||
232 | mask = itv->card->gpio_audio_input.mask; | |
233 | data = itv->card->gpio_audio_input.radio; | |
234 | if (mask) | |
235 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
236 | return 0; | |
237 | } | |
1a0adaf3 | 238 | |
5325b427 HV |
239 | static int subdev_s_audio_routing(struct v4l2_subdev *sd, |
240 | u32 input, u32 output, u32 config) | |
67ec09fd HV |
241 | { |
242 | struct ivtv *itv = sd_to_ivtv(sd); | |
243 | u16 mask, data; | |
244 | ||
5325b427 | 245 | if (input > 2) |
67ec09fd HV |
246 | return -EINVAL; |
247 | mask = itv->card->gpio_audio_input.mask; | |
5325b427 | 248 | switch (input) { |
67ec09fd | 249 | case 0: |
1a0adaf3 HV |
250 | data = itv->card->gpio_audio_input.tuner; |
251 | break; | |
67ec09fd HV |
252 | case 1: |
253 | data = itv->card->gpio_audio_input.linein; | |
254 | break; | |
255 | case 2: | |
256 | default: | |
257 | data = itv->card->gpio_audio_input.radio; | |
1a0adaf3 | 258 | break; |
67ec09fd HV |
259 | } |
260 | if (mask) | |
261 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
262 | return 0; | |
263 | } | |
1a0adaf3 | 264 | |
67ec09fd HV |
265 | static int subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) |
266 | { | |
267 | struct ivtv *itv = sd_to_ivtv(sd); | |
268 | u16 mask, data; | |
1a0adaf3 | 269 | |
67ec09fd HV |
270 | if (ctrl->id != V4L2_CID_AUDIO_MUTE) |
271 | return -EINVAL; | |
272 | mask = itv->card->gpio_audio_mute.mask; | |
273 | data = itv->card->gpio_audio_mute.mute; | |
274 | ctrl->value = (read_reg(IVTV_REG_GPIO_OUT) & mask) == data; | |
275 | return 0; | |
276 | } | |
1a0adaf3 | 277 | |
67ec09fd HV |
278 | static int subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) |
279 | { | |
280 | struct ivtv *itv = sd_to_ivtv(sd); | |
281 | u16 mask, data; | |
1a0adaf3 | 282 | |
67ec09fd HV |
283 | if (ctrl->id != V4L2_CID_AUDIO_MUTE) |
284 | return -EINVAL; | |
285 | mask = itv->card->gpio_audio_mute.mask; | |
286 | data = ctrl->value ? itv->card->gpio_audio_mute.mute : 0; | |
287 | if (mask) | |
288 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
289 | return 0; | |
290 | } | |
291 | ||
292 | static int subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc) | |
293 | { | |
294 | if (qc->id != V4L2_CID_AUDIO_MUTE) | |
295 | return -EINVAL; | |
296 | *qc = gpio_ctrl_mute; | |
297 | return 0; | |
298 | } | |
299 | ||
300 | static int subdev_log_status(struct v4l2_subdev *sd) | |
301 | { | |
302 | struct ivtv *itv = sd_to_ivtv(sd); | |
1a0adaf3 | 303 | |
67ec09fd | 304 | IVTV_INFO("GPIO status: DIR=0x%04x OUT=0x%04x IN=0x%04x\n", |
1a0adaf3 HV |
305 | read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT), |
306 | read_reg(IVTV_REG_GPIO_IN)); | |
67ec09fd HV |
307 | return 0; |
308 | } | |
1a0adaf3 | 309 | |
5325b427 HV |
310 | static int subdev_s_video_routing(struct v4l2_subdev *sd, |
311 | u32 input, u32 output, u32 config) | |
67ec09fd HV |
312 | { |
313 | struct ivtv *itv = sd_to_ivtv(sd); | |
314 | u16 mask, data; | |
1a0adaf3 | 315 | |
5325b427 | 316 | if (input > 2) /* 0:Tuner 1:Composite 2:S-Video */ |
1a0adaf3 | 317 | return -EINVAL; |
67ec09fd | 318 | mask = itv->card->gpio_video_input.mask; |
5325b427 | 319 | if (input == 0) |
67ec09fd | 320 | data = itv->card->gpio_video_input.tuner; |
5325b427 | 321 | else if (input == 1) |
67ec09fd HV |
322 | data = itv->card->gpio_video_input.composite; |
323 | else | |
324 | data = itv->card->gpio_video_input.svideo; | |
1a0adaf3 HV |
325 | if (mask) |
326 | write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); | |
327 | return 0; | |
328 | } | |
67ec09fd HV |
329 | |
330 | static const struct v4l2_subdev_core_ops subdev_core_ops = { | |
331 | .log_status = subdev_log_status, | |
332 | .g_ctrl = subdev_g_ctrl, | |
333 | .s_ctrl = subdev_s_ctrl, | |
334 | .queryctrl = subdev_queryctrl, | |
335 | }; | |
336 | ||
337 | static const struct v4l2_subdev_tuner_ops subdev_tuner_ops = { | |
67ec09fd HV |
338 | .s_radio = subdev_s_radio, |
339 | .g_tuner = subdev_g_tuner, | |
340 | .s_tuner = subdev_s_tuner, | |
341 | }; | |
342 | ||
343 | static const struct v4l2_subdev_audio_ops subdev_audio_ops = { | |
344 | .s_clock_freq = subdev_s_clock_freq, | |
345 | .s_routing = subdev_s_audio_routing, | |
346 | }; | |
347 | ||
348 | static const struct v4l2_subdev_video_ops subdev_video_ops = { | |
349 | .s_routing = subdev_s_video_routing, | |
350 | }; | |
351 | ||
352 | static const struct v4l2_subdev_ops subdev_ops = { | |
353 | .core = &subdev_core_ops, | |
354 | .tuner = &subdev_tuner_ops, | |
355 | .audio = &subdev_audio_ops, | |
356 | .video = &subdev_video_ops, | |
357 | }; | |
358 | ||
359 | int ivtv_gpio_init(struct ivtv *itv) | |
360 | { | |
361 | u16 pin = 0; | |
362 | ||
363 | if (itv->card->xceive_pin) | |
364 | pin = 1 << itv->card->xceive_pin; | |
365 | ||
366 | if ((itv->card->gpio_init.direction | pin) == 0) | |
367 | return 0; | |
368 | ||
369 | IVTV_DEBUG_INFO("GPIO initial dir: %08x out: %08x\n", | |
370 | read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT)); | |
371 | ||
372 | /* init output data then direction */ | |
373 | write_reg(itv->card->gpio_init.initial_value | pin, IVTV_REG_GPIO_OUT); | |
374 | write_reg(itv->card->gpio_init.direction | pin, IVTV_REG_GPIO_DIR); | |
375 | v4l2_subdev_init(&itv->sd_gpio, &subdev_ops); | |
8ac05ae3 | 376 | snprintf(itv->sd_gpio.name, sizeof(itv->sd_gpio.name), "%s-gpio", itv->v4l2_dev.name); |
67ec09fd | 377 | itv->sd_gpio.grp_id = IVTV_HW_GPIO; |
8ac05ae3 | 378 | return v4l2_device_register_subdev(&itv->v4l2_dev, &itv->sd_gpio); |
67ec09fd | 379 | } |