]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/media/usb/dvb-usb-v2/mxl111sf-gpio.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'efi-urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/mfleming...
[mirror_ubuntu-hirsute-kernel.git] / drivers / media / usb / dvb-usb-v2 / mxl111sf-gpio.c
1 /*
2 * mxl111sf-gpio.c - driver for the MaxLinear MXL111SF
3 *
4 * Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "mxl111sf-gpio.h"
22 #include "mxl111sf-i2c.h"
23 #include "mxl111sf.h"
24
25 /* ------------------------------------------------------------------------- */
26
27 #define MXL_GPIO_MUX_REG_0 0x84
28 #define MXL_GPIO_MUX_REG_1 0x89
29 #define MXL_GPIO_MUX_REG_2 0x82
30
31 #define MXL_GPIO_DIR_INPUT 0
32 #define MXL_GPIO_DIR_OUTPUT 1
33
34
35 static int mxl111sf_set_gpo_state(struct mxl111sf_state *state, u8 pin, u8 val)
36 {
37 int ret;
38 u8 tmp;
39
40 mxl_debug_adv("(%d, %d)", pin, val);
41
42 if ((pin > 0) && (pin < 8)) {
43 ret = mxl111sf_read_reg(state, 0x19, &tmp);
44 if (mxl_fail(ret))
45 goto fail;
46 tmp &= ~(1 << (pin - 1));
47 tmp |= (val << (pin - 1));
48 ret = mxl111sf_write_reg(state, 0x19, tmp);
49 if (mxl_fail(ret))
50 goto fail;
51 } else if (pin <= 10) {
52 if (pin == 0)
53 pin += 7;
54 ret = mxl111sf_read_reg(state, 0x30, &tmp);
55 if (mxl_fail(ret))
56 goto fail;
57 tmp &= ~(1 << (pin - 3));
58 tmp |= (val << (pin - 3));
59 ret = mxl111sf_write_reg(state, 0x30, tmp);
60 if (mxl_fail(ret))
61 goto fail;
62 } else
63 ret = -EINVAL;
64 fail:
65 return ret;
66 }
67
68 static int mxl111sf_get_gpi_state(struct mxl111sf_state *state, u8 pin, u8 *val)
69 {
70 int ret;
71 u8 tmp;
72
73 mxl_debug("(0x%02x)", pin);
74
75 *val = 0;
76
77 switch (pin) {
78 case 0:
79 case 1:
80 case 2:
81 case 3:
82 ret = mxl111sf_read_reg(state, 0x23, &tmp);
83 if (mxl_fail(ret))
84 goto fail;
85 *val = (tmp >> (pin + 4)) & 0x01;
86 break;
87 case 4:
88 case 5:
89 case 6:
90 case 7:
91 ret = mxl111sf_read_reg(state, 0x2f, &tmp);
92 if (mxl_fail(ret))
93 goto fail;
94 *val = (tmp >> pin) & 0x01;
95 break;
96 case 8:
97 case 9:
98 case 10:
99 ret = mxl111sf_read_reg(state, 0x22, &tmp);
100 if (mxl_fail(ret))
101 goto fail;
102 *val = (tmp >> (pin - 3)) & 0x01;
103 break;
104 default:
105 return -EINVAL; /* invalid pin */
106 }
107 fail:
108 return ret;
109 }
110
111 struct mxl_gpio_cfg {
112 u8 pin;
113 u8 dir;
114 u8 val;
115 };
116
117 static int mxl111sf_config_gpio_pins(struct mxl111sf_state *state,
118 struct mxl_gpio_cfg *gpio_cfg)
119 {
120 int ret;
121 u8 tmp;
122
123 mxl_debug_adv("(%d, %d)", gpio_cfg->pin, gpio_cfg->dir);
124
125 switch (gpio_cfg->pin) {
126 case 0:
127 case 1:
128 case 2:
129 case 3:
130 ret = mxl111sf_read_reg(state, MXL_GPIO_MUX_REG_0, &tmp);
131 if (mxl_fail(ret))
132 goto fail;
133 tmp &= ~(1 << (gpio_cfg->pin + 4));
134 tmp |= (gpio_cfg->dir << (gpio_cfg->pin + 4));
135 ret = mxl111sf_write_reg(state, MXL_GPIO_MUX_REG_0, tmp);
136 if (mxl_fail(ret))
137 goto fail;
138 break;
139 case 4:
140 case 5:
141 case 6:
142 case 7:
143 ret = mxl111sf_read_reg(state, MXL_GPIO_MUX_REG_1, &tmp);
144 if (mxl_fail(ret))
145 goto fail;
146 tmp &= ~(1 << gpio_cfg->pin);
147 tmp |= (gpio_cfg->dir << gpio_cfg->pin);
148 ret = mxl111sf_write_reg(state, MXL_GPIO_MUX_REG_1, tmp);
149 if (mxl_fail(ret))
150 goto fail;
151 break;
152 case 8:
153 case 9:
154 case 10:
155 ret = mxl111sf_read_reg(state, MXL_GPIO_MUX_REG_2, &tmp);
156 if (mxl_fail(ret))
157 goto fail;
158 tmp &= ~(1 << (gpio_cfg->pin - 3));
159 tmp |= (gpio_cfg->dir << (gpio_cfg->pin - 3));
160 ret = mxl111sf_write_reg(state, MXL_GPIO_MUX_REG_2, tmp);
161 if (mxl_fail(ret))
162 goto fail;
163 break;
164 default:
165 return -EINVAL; /* invalid pin */
166 }
167
168 ret = (MXL_GPIO_DIR_OUTPUT == gpio_cfg->dir) ?
169 mxl111sf_set_gpo_state(state,
170 gpio_cfg->pin, gpio_cfg->val) :
171 mxl111sf_get_gpi_state(state,
172 gpio_cfg->pin, &gpio_cfg->val);
173 mxl_fail(ret);
174 fail:
175 return ret;
176 }
177
178 static int mxl111sf_hw_do_set_gpio(struct mxl111sf_state *state,
179 int gpio, int direction, int val)
180 {
181 struct mxl_gpio_cfg gpio_config = {
182 .pin = gpio,
183 .dir = direction,
184 .val = val,
185 };
186
187 mxl_debug("(%d, %d, %d)", gpio, direction, val);
188
189 return mxl111sf_config_gpio_pins(state, &gpio_config);
190 }
191
192 /* ------------------------------------------------------------------------- */
193
194 #define PIN_MUX_MPEG_MODE_MASK 0x40 /* 0x17 <6> */
195 #define PIN_MUX_MPEG_PAR_EN_MASK 0x01 /* 0x18 <0> */
196 #define PIN_MUX_MPEG_SER_EN_MASK 0x02 /* 0x18 <1> */
197 #define PIN_MUX_MPG_IN_MUX_MASK 0x80 /* 0x3D <7> */
198 #define PIN_MUX_BT656_ENABLE_MASK 0x04 /* 0x12 <2> */
199 #define PIN_MUX_I2S_ENABLE_MASK 0x40 /* 0x15 <6> */
200 #define PIN_MUX_SPI_MODE_MASK 0x10 /* 0x3D <4> */
201 #define PIN_MUX_MCLK_EN_CTRL_MASK 0x10 /* 0x82 <4> */
202 #define PIN_MUX_MPSYN_EN_CTRL_MASK 0x20 /* 0x82 <5> */
203 #define PIN_MUX_MDVAL_EN_CTRL_MASK 0x40 /* 0x82 <6> */
204 #define PIN_MUX_MPERR_EN_CTRL_MASK 0x80 /* 0x82 <7> */
205 #define PIN_MUX_MDAT_EN_0_MASK 0x10 /* 0x84 <4> */
206 #define PIN_MUX_MDAT_EN_1_MASK 0x20 /* 0x84 <5> */
207 #define PIN_MUX_MDAT_EN_2_MASK 0x40 /* 0x84 <6> */
208 #define PIN_MUX_MDAT_EN_3_MASK 0x80 /* 0x84 <7> */
209 #define PIN_MUX_MDAT_EN_4_MASK 0x10 /* 0x89 <4> */
210 #define PIN_MUX_MDAT_EN_5_MASK 0x20 /* 0x89 <5> */
211 #define PIN_MUX_MDAT_EN_6_MASK 0x40 /* 0x89 <6> */
212 #define PIN_MUX_MDAT_EN_7_MASK 0x80 /* 0x89 <7> */
213
214 int mxl111sf_config_pin_mux_modes(struct mxl111sf_state *state,
215 enum mxl111sf_mux_config pin_mux_config)
216 {
217 u8 r12, r15, r17, r18, r3D, r82, r84, r89;
218 int ret;
219
220 mxl_debug("(%d)", pin_mux_config);
221
222 ret = mxl111sf_read_reg(state, 0x17, &r17);
223 if (mxl_fail(ret))
224 goto fail;
225 ret = mxl111sf_read_reg(state, 0x18, &r18);
226 if (mxl_fail(ret))
227 goto fail;
228 ret = mxl111sf_read_reg(state, 0x12, &r12);
229 if (mxl_fail(ret))
230 goto fail;
231 ret = mxl111sf_read_reg(state, 0x15, &r15);
232 if (mxl_fail(ret))
233 goto fail;
234 ret = mxl111sf_read_reg(state, 0x82, &r82);
235 if (mxl_fail(ret))
236 goto fail;
237 ret = mxl111sf_read_reg(state, 0x84, &r84);
238 if (mxl_fail(ret))
239 goto fail;
240 ret = mxl111sf_read_reg(state, 0x89, &r89);
241 if (mxl_fail(ret))
242 goto fail;
243 ret = mxl111sf_read_reg(state, 0x3D, &r3D);
244 if (mxl_fail(ret))
245 goto fail;
246
247 switch (pin_mux_config) {
248 case PIN_MUX_TS_OUT_PARALLEL:
249 /* mpeg_mode = 1 */
250 r17 |= PIN_MUX_MPEG_MODE_MASK;
251 /* mpeg_par_en = 1 */
252 r18 |= PIN_MUX_MPEG_PAR_EN_MASK;
253 /* mpeg_ser_en = 0 */
254 r18 &= ~PIN_MUX_MPEG_SER_EN_MASK;
255 /* mpg_in_mux = 0 */
256 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
257 /* bt656_enable = 0 */
258 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
259 /* i2s_enable = 0 */
260 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
261 /* spi_mode = 0 */
262 r3D &= ~PIN_MUX_SPI_MODE_MASK;
263 /* mclk_en_ctrl = 1 */
264 r82 |= PIN_MUX_MCLK_EN_CTRL_MASK;
265 /* mperr_en_ctrl = 1 */
266 r82 |= PIN_MUX_MPERR_EN_CTRL_MASK;
267 /* mdval_en_ctrl = 1 */
268 r82 |= PIN_MUX_MDVAL_EN_CTRL_MASK;
269 /* mpsyn_en_ctrl = 1 */
270 r82 |= PIN_MUX_MPSYN_EN_CTRL_MASK;
271 /* mdat_en_ctrl[3:0] = 0xF */
272 r84 |= 0xF0;
273 /* mdat_en_ctrl[7:4] = 0xF */
274 r89 |= 0xF0;
275 break;
276 case PIN_MUX_TS_OUT_SERIAL:
277 /* mpeg_mode = 1 */
278 r17 |= PIN_MUX_MPEG_MODE_MASK;
279 /* mpeg_par_en = 0 */
280 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
281 /* mpeg_ser_en = 1 */
282 r18 |= PIN_MUX_MPEG_SER_EN_MASK;
283 /* mpg_in_mux = 0 */
284 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
285 /* bt656_enable = 0 */
286 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
287 /* i2s_enable = 0 */
288 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
289 /* spi_mode = 0 */
290 r3D &= ~PIN_MUX_SPI_MODE_MASK;
291 /* mclk_en_ctrl = 1 */
292 r82 |= PIN_MUX_MCLK_EN_CTRL_MASK;
293 /* mperr_en_ctrl = 1 */
294 r82 |= PIN_MUX_MPERR_EN_CTRL_MASK;
295 /* mdval_en_ctrl = 1 */
296 r82 |= PIN_MUX_MDVAL_EN_CTRL_MASK;
297 /* mpsyn_en_ctrl = 1 */
298 r82 |= PIN_MUX_MPSYN_EN_CTRL_MASK;
299 /* mdat_en_ctrl[3:0] = 0xF */
300 r84 |= 0xF0;
301 /* mdat_en_ctrl[7:4] = 0xF */
302 r89 |= 0xF0;
303 break;
304 case PIN_MUX_GPIO_MODE:
305 /* mpeg_mode = 0 */
306 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
307 /* mpeg_par_en = 0 */
308 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
309 /* mpeg_ser_en = 0 */
310 r18 &= ~PIN_MUX_MPEG_SER_EN_MASK;
311 /* mpg_in_mux = 0 */
312 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
313 /* bt656_enable = 0 */
314 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
315 /* i2s_enable = 0 */
316 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
317 /* spi_mode = 0 */
318 r3D &= ~PIN_MUX_SPI_MODE_MASK;
319 /* mclk_en_ctrl = 0 */
320 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
321 /* mperr_en_ctrl = 0 */
322 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
323 /* mdval_en_ctrl = 0 */
324 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
325 /* mpsyn_en_ctrl = 0 */
326 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
327 /* mdat_en_ctrl[3:0] = 0x0 */
328 r84 &= 0x0F;
329 /* mdat_en_ctrl[7:4] = 0x0 */
330 r89 &= 0x0F;
331 break;
332 case PIN_MUX_TS_SERIAL_IN_MODE_0:
333 /* mpeg_mode = 0 */
334 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
335 /* mpeg_par_en = 0 */
336 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
337 /* mpeg_ser_en = 1 */
338 r18 |= PIN_MUX_MPEG_SER_EN_MASK;
339 /* mpg_in_mux = 0 */
340 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
341 /* bt656_enable = 0 */
342 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
343 /* i2s_enable = 0 */
344 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
345 /* spi_mode = 0 */
346 r3D &= ~PIN_MUX_SPI_MODE_MASK;
347 /* mclk_en_ctrl = 0 */
348 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
349 /* mperr_en_ctrl = 0 */
350 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
351 /* mdval_en_ctrl = 0 */
352 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
353 /* mpsyn_en_ctrl = 0 */
354 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
355 /* mdat_en_ctrl[3:0] = 0x0 */
356 r84 &= 0x0F;
357 /* mdat_en_ctrl[7:4] = 0x0 */
358 r89 &= 0x0F;
359 break;
360 case PIN_MUX_TS_SERIAL_IN_MODE_1:
361 /* mpeg_mode = 0 */
362 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
363 /* mpeg_par_en = 0 */
364 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
365 /* mpeg_ser_en = 1 */
366 r18 |= PIN_MUX_MPEG_SER_EN_MASK;
367 /* mpg_in_mux = 1 */
368 r3D |= PIN_MUX_MPG_IN_MUX_MASK;
369 /* bt656_enable = 0 */
370 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
371 /* i2s_enable = 0 */
372 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
373 /* spi_mode = 0 */
374 r3D &= ~PIN_MUX_SPI_MODE_MASK;
375 /* mclk_en_ctrl = 0 */
376 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
377 /* mperr_en_ctrl = 0 */
378 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
379 /* mdval_en_ctrl = 0 */
380 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
381 /* mpsyn_en_ctrl = 0 */
382 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
383 /* mdat_en_ctrl[3:0] = 0x0 */
384 r84 &= 0x0F;
385 /* mdat_en_ctrl[7:4] = 0x0 */
386 r89 &= 0x0F;
387 break;
388 case PIN_MUX_TS_SPI_IN_MODE_1:
389 /* mpeg_mode = 0 */
390 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
391 /* mpeg_par_en = 0 */
392 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
393 /* mpeg_ser_en = 1 */
394 r18 |= PIN_MUX_MPEG_SER_EN_MASK;
395 /* mpg_in_mux = 1 */
396 r3D |= PIN_MUX_MPG_IN_MUX_MASK;
397 /* bt656_enable = 0 */
398 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
399 /* i2s_enable = 1 */
400 r15 |= PIN_MUX_I2S_ENABLE_MASK;
401 /* spi_mode = 1 */
402 r3D |= PIN_MUX_SPI_MODE_MASK;
403 /* mclk_en_ctrl = 0 */
404 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
405 /* mperr_en_ctrl = 0 */
406 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
407 /* mdval_en_ctrl = 0 */
408 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
409 /* mpsyn_en_ctrl = 0 */
410 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
411 /* mdat_en_ctrl[3:0] = 0x0 */
412 r84 &= 0x0F;
413 /* mdat_en_ctrl[7:4] = 0x0 */
414 r89 &= 0x0F;
415 break;
416 case PIN_MUX_TS_SPI_IN_MODE_0:
417 /* mpeg_mode = 0 */
418 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
419 /* mpeg_par_en = 0 */
420 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
421 /* mpeg_ser_en = 1 */
422 r18 |= PIN_MUX_MPEG_SER_EN_MASK;
423 /* mpg_in_mux = 0 */
424 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
425 /* bt656_enable = 0 */
426 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
427 /* i2s_enable = 1 */
428 r15 |= PIN_MUX_I2S_ENABLE_MASK;
429 /* spi_mode = 1 */
430 r3D |= PIN_MUX_SPI_MODE_MASK;
431 /* mclk_en_ctrl = 0 */
432 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
433 /* mperr_en_ctrl = 0 */
434 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
435 /* mdval_en_ctrl = 0 */
436 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
437 /* mpsyn_en_ctrl = 0 */
438 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
439 /* mdat_en_ctrl[3:0] = 0x0 */
440 r84 &= 0x0F;
441 /* mdat_en_ctrl[7:4] = 0x0 */
442 r89 &= 0x0F;
443 break;
444 case PIN_MUX_TS_PARALLEL_IN:
445 /* mpeg_mode = 0 */
446 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
447 /* mpeg_par_en = 1 */
448 r18 |= PIN_MUX_MPEG_PAR_EN_MASK;
449 /* mpeg_ser_en = 0 */
450 r18 &= ~PIN_MUX_MPEG_SER_EN_MASK;
451 /* mpg_in_mux = 0 */
452 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
453 /* bt656_enable = 0 */
454 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
455 /* i2s_enable = 0 */
456 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
457 /* spi_mode = 0 */
458 r3D &= ~PIN_MUX_SPI_MODE_MASK;
459 /* mclk_en_ctrl = 0 */
460 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
461 /* mperr_en_ctrl = 0 */
462 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
463 /* mdval_en_ctrl = 0 */
464 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
465 /* mpsyn_en_ctrl = 0 */
466 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
467 /* mdat_en_ctrl[3:0] = 0x0 */
468 r84 &= 0x0F;
469 /* mdat_en_ctrl[7:4] = 0x0 */
470 r89 &= 0x0F;
471 break;
472 case PIN_MUX_BT656_I2S_MODE:
473 /* mpeg_mode = 0 */
474 r17 &= ~PIN_MUX_MPEG_MODE_MASK;
475 /* mpeg_par_en = 0 */
476 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
477 /* mpeg_ser_en = 0 */
478 r18 &= ~PIN_MUX_MPEG_SER_EN_MASK;
479 /* mpg_in_mux = 0 */
480 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
481 /* bt656_enable = 1 */
482 r12 |= PIN_MUX_BT656_ENABLE_MASK;
483 /* i2s_enable = 1 */
484 r15 |= PIN_MUX_I2S_ENABLE_MASK;
485 /* spi_mode = 0 */
486 r3D &= ~PIN_MUX_SPI_MODE_MASK;
487 /* mclk_en_ctrl = 0 */
488 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
489 /* mperr_en_ctrl = 0 */
490 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
491 /* mdval_en_ctrl = 0 */
492 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
493 /* mpsyn_en_ctrl = 0 */
494 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
495 /* mdat_en_ctrl[3:0] = 0x0 */
496 r84 &= 0x0F;
497 /* mdat_en_ctrl[7:4] = 0x0 */
498 r89 &= 0x0F;
499 break;
500 case PIN_MUX_DEFAULT:
501 default:
502 /* mpeg_mode = 1 */
503 r17 |= PIN_MUX_MPEG_MODE_MASK;
504 /* mpeg_par_en = 0 */
505 r18 &= ~PIN_MUX_MPEG_PAR_EN_MASK;
506 /* mpeg_ser_en = 0 */
507 r18 &= ~PIN_MUX_MPEG_SER_EN_MASK;
508 /* mpg_in_mux = 0 */
509 r3D &= ~PIN_MUX_MPG_IN_MUX_MASK;
510 /* bt656_enable = 0 */
511 r12 &= ~PIN_MUX_BT656_ENABLE_MASK;
512 /* i2s_enable = 0 */
513 r15 &= ~PIN_MUX_I2S_ENABLE_MASK;
514 /* spi_mode = 0 */
515 r3D &= ~PIN_MUX_SPI_MODE_MASK;
516 /* mclk_en_ctrl = 0 */
517 r82 &= ~PIN_MUX_MCLK_EN_CTRL_MASK;
518 /* mperr_en_ctrl = 0 */
519 r82 &= ~PIN_MUX_MPERR_EN_CTRL_MASK;
520 /* mdval_en_ctrl = 0 */
521 r82 &= ~PIN_MUX_MDVAL_EN_CTRL_MASK;
522 /* mpsyn_en_ctrl = 0 */
523 r82 &= ~PIN_MUX_MPSYN_EN_CTRL_MASK;
524 /* mdat_en_ctrl[3:0] = 0x0 */
525 r84 &= 0x0F;
526 /* mdat_en_ctrl[7:4] = 0x0 */
527 r89 &= 0x0F;
528 break;
529 }
530
531 ret = mxl111sf_write_reg(state, 0x17, r17);
532 if (mxl_fail(ret))
533 goto fail;
534 ret = mxl111sf_write_reg(state, 0x18, r18);
535 if (mxl_fail(ret))
536 goto fail;
537 ret = mxl111sf_write_reg(state, 0x12, r12);
538 if (mxl_fail(ret))
539 goto fail;
540 ret = mxl111sf_write_reg(state, 0x15, r15);
541 if (mxl_fail(ret))
542 goto fail;
543 ret = mxl111sf_write_reg(state, 0x82, r82);
544 if (mxl_fail(ret))
545 goto fail;
546 ret = mxl111sf_write_reg(state, 0x84, r84);
547 if (mxl_fail(ret))
548 goto fail;
549 ret = mxl111sf_write_reg(state, 0x89, r89);
550 if (mxl_fail(ret))
551 goto fail;
552 ret = mxl111sf_write_reg(state, 0x3D, r3D);
553 if (mxl_fail(ret))
554 goto fail;
555 fail:
556 return ret;
557 }
558
559 /* ------------------------------------------------------------------------- */
560
561 static int mxl111sf_hw_set_gpio(struct mxl111sf_state *state, int gpio, int val)
562 {
563 return mxl111sf_hw_do_set_gpio(state, gpio, MXL_GPIO_DIR_OUTPUT, val);
564 }
565
566 static int mxl111sf_hw_gpio_initialize(struct mxl111sf_state *state)
567 {
568 u8 gpioval = 0x07; /* write protect enabled, signal LEDs off */
569 int i, ret;
570
571 mxl_debug("()");
572
573 for (i = 3; i < 8; i++) {
574 ret = mxl111sf_hw_set_gpio(state, i, (gpioval >> i) & 0x01);
575 if (mxl_fail(ret))
576 break;
577 }
578
579 return ret;
580 }
581
582 #define PCA9534_I2C_ADDR (0x40 >> 1)
583 static int pca9534_set_gpio(struct mxl111sf_state *state, int gpio, int val)
584 {
585 u8 w[2] = { 1, 0 };
586 u8 r = 0;
587 struct i2c_msg msg[] = {
588 { .addr = PCA9534_I2C_ADDR,
589 .flags = 0, .buf = w, .len = 1 },
590 { .addr = PCA9534_I2C_ADDR,
591 .flags = I2C_M_RD, .buf = &r, .len = 1 },
592 };
593
594 mxl_debug("(%d, %d)", gpio, val);
595
596 /* read current GPIO levels from flip-flop */
597 i2c_transfer(&state->d->i2c_adap, msg, 2);
598
599 /* prepare write buffer with current GPIO levels */
600 msg[0].len = 2;
601 #if 0
602 w[0] = 1;
603 #endif
604 w[1] = r;
605
606 /* clear the desired GPIO */
607 w[1] &= ~(1 << gpio);
608
609 /* set the desired GPIO value */
610 w[1] |= ((val ? 1 : 0) << gpio);
611
612 /* write new GPIO levels to flip-flop */
613 i2c_transfer(&state->d->i2c_adap, &msg[0], 1);
614
615 return 0;
616 }
617
618 static int pca9534_init_port_expander(struct mxl111sf_state *state)
619 {
620 u8 w[2] = { 1, 0x07 }; /* write protect enabled, signal LEDs off */
621
622 struct i2c_msg msg = {
623 .addr = PCA9534_I2C_ADDR,
624 .flags = 0, .buf = w, .len = 2
625 };
626
627 mxl_debug("()");
628
629 i2c_transfer(&state->d->i2c_adap, &msg, 1);
630
631 /* configure all pins as outputs */
632 w[0] = 3;
633 w[1] = 0;
634
635 i2c_transfer(&state->d->i2c_adap, &msg, 1);
636
637 return 0;
638 }
639
640 int mxl111sf_set_gpio(struct mxl111sf_state *state, int gpio, int val)
641 {
642 mxl_debug("(%d, %d)", gpio, val);
643
644 switch (state->gpio_port_expander) {
645 default:
646 mxl_printk(KERN_ERR,
647 "gpio_port_expander undefined, assuming PCA9534");
648 /* fall-thru */
649 case mxl111sf_PCA9534:
650 return pca9534_set_gpio(state, gpio, val);
651 case mxl111sf_gpio_hw:
652 return mxl111sf_hw_set_gpio(state, gpio, val);
653 }
654 }
655
656 static int mxl111sf_probe_port_expander(struct mxl111sf_state *state)
657 {
658 int ret;
659 u8 w = 1;
660 u8 r = 0;
661 struct i2c_msg msg[] = {
662 { .flags = 0, .buf = &w, .len = 1 },
663 { .flags = I2C_M_RD, .buf = &r, .len = 1 },
664 };
665
666 mxl_debug("()");
667
668 msg[0].addr = 0x70 >> 1;
669 msg[1].addr = 0x70 >> 1;
670
671 /* read current GPIO levels from flip-flop */
672 ret = i2c_transfer(&state->d->i2c_adap, msg, 2);
673 if (ret == 2) {
674 state->port_expander_addr = msg[0].addr;
675 state->gpio_port_expander = mxl111sf_PCA9534;
676 mxl_debug("found port expander at 0x%02x",
677 state->port_expander_addr);
678 return 0;
679 }
680
681 msg[0].addr = 0x40 >> 1;
682 msg[1].addr = 0x40 >> 1;
683
684 ret = i2c_transfer(&state->d->i2c_adap, msg, 2);
685 if (ret == 2) {
686 state->port_expander_addr = msg[0].addr;
687 state->gpio_port_expander = mxl111sf_PCA9534;
688 mxl_debug("found port expander at 0x%02x",
689 state->port_expander_addr);
690 return 0;
691 }
692 state->port_expander_addr = 0xff;
693 state->gpio_port_expander = mxl111sf_gpio_hw;
694 mxl_debug("using hardware gpio");
695 return 0;
696 }
697
698 int mxl111sf_init_port_expander(struct mxl111sf_state *state)
699 {
700 mxl_debug("()");
701
702 if (0x00 == state->port_expander_addr)
703 mxl111sf_probe_port_expander(state);
704
705 switch (state->gpio_port_expander) {
706 default:
707 mxl_printk(KERN_ERR,
708 "gpio_port_expander undefined, assuming PCA9534");
709 /* fall-thru */
710 case mxl111sf_PCA9534:
711 return pca9534_init_port_expander(state);
712 case mxl111sf_gpio_hw:
713 return mxl111sf_hw_gpio_initialize(state);
714 }
715 }
716
717 /* ------------------------------------------------------------------------ */
718
719 int mxl111sf_gpio_mode_switch(struct mxl111sf_state *state, unsigned int mode)
720 {
721 /* GPO:
722 * 3 - ATSC/MH# | 1 = ATSC transport, 0 = MH transport | default 0
723 * 4 - ATSC_RST## | 1 = ATSC enable, 0 = ATSC Reset | default 0
724 * 5 - ATSC_EN | 1 = ATSC power enable, 0 = ATSC power off | default 0
725 * 6 - MH_RESET# | 1 = MH enable, 0 = MH Reset | default 0
726 * 7 - MH_EN | 1 = MH power enable, 0 = MH power off | default 0
727 */
728 mxl_debug("(%d)", mode);
729
730 switch (mode) {
731 case MXL111SF_GPIO_MOD_MH:
732 mxl111sf_set_gpio(state, 4, 0);
733 mxl111sf_set_gpio(state, 5, 0);
734 msleep(50);
735 mxl111sf_set_gpio(state, 7, 1);
736 msleep(50);
737 mxl111sf_set_gpio(state, 6, 1);
738 msleep(50);
739
740 mxl111sf_set_gpio(state, 3, 0);
741 break;
742 case MXL111SF_GPIO_MOD_ATSC:
743 mxl111sf_set_gpio(state, 6, 0);
744 mxl111sf_set_gpio(state, 7, 0);
745 msleep(50);
746 mxl111sf_set_gpio(state, 5, 1);
747 msleep(50);
748 mxl111sf_set_gpio(state, 4, 1);
749 msleep(50);
750 mxl111sf_set_gpio(state, 3, 1);
751 break;
752 default: /* DVBT / STANDBY */
753 mxl111sf_init_port_expander(state);
754 break;
755 }
756 return 0;
757 }
Ubuntu Hirsute Linux kernel mirror