Loading...
1/*
2 * Copyright (C) 2009 Francisco Jerez.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
26
27#include "ch7006_priv.h"
28
29/* DRM encoder functions */
30
31static void ch7006_encoder_set_config(struct drm_encoder *encoder,
32 void *params)
33{
34 struct ch7006_priv *priv = to_ch7006_priv(encoder);
35
36 priv->params = *(struct ch7006_encoder_params *)params;
37}
38
39static void ch7006_encoder_destroy(struct drm_encoder *encoder)
40{
41 struct ch7006_priv *priv = to_ch7006_priv(encoder);
42
43 drm_property_destroy(encoder->dev, priv->scale_property);
44
45 kfree(priv);
46 to_encoder_slave(encoder)->slave_priv = NULL;
47
48 drm_i2c_encoder_destroy(encoder);
49}
50
51static void ch7006_encoder_dpms(struct drm_encoder *encoder, int mode)
52{
53 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
54 struct ch7006_priv *priv = to_ch7006_priv(encoder);
55 struct ch7006_state *state = &priv->state;
56
57 ch7006_dbg(client, "\n");
58
59 if (mode == priv->last_dpms)
60 return;
61 priv->last_dpms = mode;
62
63 ch7006_setup_power_state(encoder);
64
65 ch7006_load_reg(client, state, CH7006_POWER);
66}
67
68static void ch7006_encoder_save(struct drm_encoder *encoder)
69{
70 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
71 struct ch7006_priv *priv = to_ch7006_priv(encoder);
72
73 ch7006_dbg(client, "\n");
74
75 ch7006_state_save(client, &priv->saved_state);
76}
77
78static void ch7006_encoder_restore(struct drm_encoder *encoder)
79{
80 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
81 struct ch7006_priv *priv = to_ch7006_priv(encoder);
82
83 ch7006_dbg(client, "\n");
84
85 ch7006_state_load(client, &priv->saved_state);
86}
87
88static bool ch7006_encoder_mode_fixup(struct drm_encoder *encoder,
89 struct drm_display_mode *mode,
90 struct drm_display_mode *adjusted_mode)
91{
92 struct ch7006_priv *priv = to_ch7006_priv(encoder);
93
94 /* The ch7006 is painfully picky with the input timings so no
95 * custom modes for now... */
96
97 priv->mode = ch7006_lookup_mode(encoder, mode);
98
99 return !!priv->mode;
100}
101
102static int ch7006_encoder_mode_valid(struct drm_encoder *encoder,
103 struct drm_display_mode *mode)
104{
105 if (ch7006_lookup_mode(encoder, mode))
106 return MODE_OK;
107 else
108 return MODE_BAD;
109}
110
111static void ch7006_encoder_mode_set(struct drm_encoder *encoder,
112 struct drm_display_mode *drm_mode,
113 struct drm_display_mode *adjusted_mode)
114{
115 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
116 struct ch7006_priv *priv = to_ch7006_priv(encoder);
117 struct ch7006_encoder_params *params = &priv->params;
118 struct ch7006_state *state = &priv->state;
119 uint8_t *regs = state->regs;
120 struct ch7006_mode *mode = priv->mode;
121 struct ch7006_tv_norm_info *norm = &ch7006_tv_norms[priv->norm];
122 int start_active;
123
124 ch7006_dbg(client, "\n");
125
126 regs[CH7006_DISPMODE] = norm->dispmode | mode->dispmode;
127 regs[CH7006_BWIDTH] = 0;
128 regs[CH7006_INPUT_FORMAT] = bitf(CH7006_INPUT_FORMAT_FORMAT,
129 params->input_format);
130
131 regs[CH7006_CLKMODE] = CH7006_CLKMODE_SUBC_LOCK
132 | bitf(CH7006_CLKMODE_XCM, params->xcm)
133 | bitf(CH7006_CLKMODE_PCM, params->pcm);
134 if (params->clock_mode)
135 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_MASTER;
136 if (params->clock_edge)
137 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_POS_EDGE;
138
139 start_active = (drm_mode->htotal & ~0x7) - (drm_mode->hsync_start & ~0x7);
140 regs[CH7006_POV] = bitf(CH7006_POV_START_ACTIVE_8, start_active);
141 regs[CH7006_START_ACTIVE] = bitf(CH7006_START_ACTIVE_0, start_active);
142
143 regs[CH7006_INPUT_SYNC] = 0;
144 if (params->sync_direction)
145 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_OUTPUT;
146 if (params->sync_encoding)
147 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_EMBEDDED;
148 if (drm_mode->flags & DRM_MODE_FLAG_PVSYNC)
149 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PVSYNC;
150 if (drm_mode->flags & DRM_MODE_FLAG_PHSYNC)
151 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PHSYNC;
152
153 regs[CH7006_DETECT] = 0;
154 regs[CH7006_BCLKOUT] = 0;
155
156 regs[CH7006_SUBC_INC3] = 0;
157 if (params->pout_level)
158 regs[CH7006_SUBC_INC3] |= CH7006_SUBC_INC3_POUT_3_3V;
159
160 regs[CH7006_SUBC_INC4] = 0;
161 if (params->active_detect)
162 regs[CH7006_SUBC_INC4] |= CH7006_SUBC_INC4_DS_INPUT;
163
164 regs[CH7006_PLL_CONTROL] = priv->saved_state.regs[CH7006_PLL_CONTROL];
165
166 ch7006_setup_levels(encoder);
167 ch7006_setup_subcarrier(encoder);
168 ch7006_setup_pll(encoder);
169 ch7006_setup_power_state(encoder);
170 ch7006_setup_properties(encoder);
171
172 ch7006_state_load(client, state);
173}
174
175static enum drm_connector_status ch7006_encoder_detect(struct drm_encoder *encoder,
176 struct drm_connector *connector)
177{
178 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
179 struct ch7006_priv *priv = to_ch7006_priv(encoder);
180 struct ch7006_state *state = &priv->state;
181 int det;
182
183 ch7006_dbg(client, "\n");
184
185 ch7006_save_reg(client, state, CH7006_DETECT);
186 ch7006_save_reg(client, state, CH7006_POWER);
187 ch7006_save_reg(client, state, CH7006_CLKMODE);
188
189 ch7006_write(client, CH7006_POWER, CH7006_POWER_RESET |
190 bitfs(CH7006_POWER_LEVEL, NORMAL));
191 ch7006_write(client, CH7006_CLKMODE, CH7006_CLKMODE_MASTER);
192
193 ch7006_write(client, CH7006_DETECT, CH7006_DETECT_SENSE);
194
195 ch7006_write(client, CH7006_DETECT, 0);
196
197 det = ch7006_read(client, CH7006_DETECT);
198
199 ch7006_load_reg(client, state, CH7006_CLKMODE);
200 ch7006_load_reg(client, state, CH7006_POWER);
201 ch7006_load_reg(client, state, CH7006_DETECT);
202
203 if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
204 CH7006_DETECT_SVIDEO_C_TEST|
205 CH7006_DETECT_CVBS_TEST)) == 0)
206 priv->subconnector = DRM_MODE_SUBCONNECTOR_SCART;
207 else if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
208 CH7006_DETECT_SVIDEO_C_TEST)) == 0)
209 priv->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO;
210 else if ((det & CH7006_DETECT_CVBS_TEST) == 0)
211 priv->subconnector = DRM_MODE_SUBCONNECTOR_Composite;
212 else
213 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
214
215 drm_connector_property_set_value(connector,
216 encoder->dev->mode_config.tv_subconnector_property,
217 priv->subconnector);
218
219 return priv->subconnector ? connector_status_connected :
220 connector_status_disconnected;
221}
222
223static int ch7006_encoder_get_modes(struct drm_encoder *encoder,
224 struct drm_connector *connector)
225{
226 struct ch7006_priv *priv = to_ch7006_priv(encoder);
227 struct ch7006_mode *mode;
228 int n = 0;
229
230 for (mode = ch7006_modes; mode->mode.clock; mode++) {
231 if (~mode->valid_scales & 1<<priv->scale ||
232 ~mode->valid_norms & 1<<priv->norm)
233 continue;
234
235 drm_mode_probed_add(connector,
236 drm_mode_duplicate(encoder->dev, &mode->mode));
237
238 n++;
239 }
240
241 return n;
242}
243
244static int ch7006_encoder_create_resources(struct drm_encoder *encoder,
245 struct drm_connector *connector)
246{
247 struct ch7006_priv *priv = to_ch7006_priv(encoder);
248 struct drm_device *dev = encoder->dev;
249 struct drm_mode_config *conf = &dev->mode_config;
250
251 drm_mode_create_tv_properties(dev, NUM_TV_NORMS, ch7006_tv_norm_names);
252
253 priv->scale_property = drm_property_create(dev, DRM_MODE_PROP_RANGE,
254 "scale", 2);
255 priv->scale_property->values[0] = 0;
256 priv->scale_property->values[1] = 2;
257
258 drm_connector_attach_property(connector, conf->tv_select_subconnector_property,
259 priv->select_subconnector);
260 drm_connector_attach_property(connector, conf->tv_subconnector_property,
261 priv->subconnector);
262 drm_connector_attach_property(connector, conf->tv_left_margin_property,
263 priv->hmargin);
264 drm_connector_attach_property(connector, conf->tv_bottom_margin_property,
265 priv->vmargin);
266 drm_connector_attach_property(connector, conf->tv_mode_property,
267 priv->norm);
268 drm_connector_attach_property(connector, conf->tv_brightness_property,
269 priv->brightness);
270 drm_connector_attach_property(connector, conf->tv_contrast_property,
271 priv->contrast);
272 drm_connector_attach_property(connector, conf->tv_flicker_reduction_property,
273 priv->flicker);
274 drm_connector_attach_property(connector, priv->scale_property,
275 priv->scale);
276
277 return 0;
278}
279
280static int ch7006_encoder_set_property(struct drm_encoder *encoder,
281 struct drm_connector *connector,
282 struct drm_property *property,
283 uint64_t val)
284{
285 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
286 struct ch7006_priv *priv = to_ch7006_priv(encoder);
287 struct ch7006_state *state = &priv->state;
288 struct drm_mode_config *conf = &encoder->dev->mode_config;
289 struct drm_crtc *crtc = encoder->crtc;
290 bool modes_changed = false;
291
292 ch7006_dbg(client, "\n");
293
294 if (property == conf->tv_select_subconnector_property) {
295 priv->select_subconnector = val;
296
297 ch7006_setup_power_state(encoder);
298
299 ch7006_load_reg(client, state, CH7006_POWER);
300
301 } else if (property == conf->tv_left_margin_property) {
302 priv->hmargin = val;
303
304 ch7006_setup_properties(encoder);
305
306 ch7006_load_reg(client, state, CH7006_POV);
307 ch7006_load_reg(client, state, CH7006_HPOS);
308
309 } else if (property == conf->tv_bottom_margin_property) {
310 priv->vmargin = val;
311
312 ch7006_setup_properties(encoder);
313
314 ch7006_load_reg(client, state, CH7006_POV);
315 ch7006_load_reg(client, state, CH7006_VPOS);
316
317 } else if (property == conf->tv_mode_property) {
318 if (connector->dpms != DRM_MODE_DPMS_OFF)
319 return -EINVAL;
320
321 priv->norm = val;
322
323 modes_changed = true;
324
325 } else if (property == conf->tv_brightness_property) {
326 priv->brightness = val;
327
328 ch7006_setup_levels(encoder);
329
330 ch7006_load_reg(client, state, CH7006_BLACK_LEVEL);
331
332 } else if (property == conf->tv_contrast_property) {
333 priv->contrast = val;
334
335 ch7006_setup_properties(encoder);
336
337 ch7006_load_reg(client, state, CH7006_CONTRAST);
338
339 } else if (property == conf->tv_flicker_reduction_property) {
340 priv->flicker = val;
341
342 ch7006_setup_properties(encoder);
343
344 ch7006_load_reg(client, state, CH7006_FFILTER);
345
346 } else if (property == priv->scale_property) {
347 if (connector->dpms != DRM_MODE_DPMS_OFF)
348 return -EINVAL;
349
350 priv->scale = val;
351
352 modes_changed = true;
353
354 } else {
355 return -EINVAL;
356 }
357
358 if (modes_changed) {
359 drm_helper_probe_single_connector_modes(connector, 0, 0);
360
361 /* Disable the crtc to ensure a full modeset is
362 * performed whenever it's turned on again. */
363 if (crtc) {
364 struct drm_mode_set modeset = {
365 .crtc = crtc,
366 };
367
368 crtc->funcs->set_config(&modeset);
369 }
370 }
371
372 return 0;
373}
374
375static struct drm_encoder_slave_funcs ch7006_encoder_funcs = {
376 .set_config = ch7006_encoder_set_config,
377 .destroy = ch7006_encoder_destroy,
378 .dpms = ch7006_encoder_dpms,
379 .save = ch7006_encoder_save,
380 .restore = ch7006_encoder_restore,
381 .mode_fixup = ch7006_encoder_mode_fixup,
382 .mode_valid = ch7006_encoder_mode_valid,
383 .mode_set = ch7006_encoder_mode_set,
384 .detect = ch7006_encoder_detect,
385 .get_modes = ch7006_encoder_get_modes,
386 .create_resources = ch7006_encoder_create_resources,
387 .set_property = ch7006_encoder_set_property,
388};
389
390
391/* I2C driver functions */
392
393static int ch7006_probe(struct i2c_client *client, const struct i2c_device_id *id)
394{
395 uint8_t addr = CH7006_VERSION_ID;
396 uint8_t val;
397 int ret;
398
399 ch7006_dbg(client, "\n");
400
401 ret = i2c_master_send(client, &addr, sizeof(addr));
402 if (ret < 0)
403 goto fail;
404
405 ret = i2c_master_recv(client, &val, sizeof(val));
406 if (ret < 0)
407 goto fail;
408
409 ch7006_info(client, "Detected version ID: %x\n", val);
410
411 /* I don't know what this is for, but otherwise I get no
412 * signal.
413 */
414 ch7006_write(client, 0x3d, 0x0);
415
416 return 0;
417
418fail:
419 ch7006_err(client, "Error %d reading version ID\n", ret);
420
421 return -ENODEV;
422}
423
424static int ch7006_remove(struct i2c_client *client)
425{
426 ch7006_dbg(client, "\n");
427
428 return 0;
429}
430
431static int ch7006_suspend(struct i2c_client *client, pm_message_t mesg)
432{
433 ch7006_dbg(client, "\n");
434
435 return 0;
436}
437
438static int ch7006_resume(struct i2c_client *client)
439{
440 ch7006_dbg(client, "\n");
441
442 ch7006_write(client, 0x3d, 0x0);
443
444 return 0;
445}
446
447static int ch7006_encoder_init(struct i2c_client *client,
448 struct drm_device *dev,
449 struct drm_encoder_slave *encoder)
450{
451 struct ch7006_priv *priv;
452 int i;
453
454 ch7006_dbg(client, "\n");
455
456 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
457 if (!priv)
458 return -ENOMEM;
459
460 encoder->slave_priv = priv;
461 encoder->slave_funcs = &ch7006_encoder_funcs;
462
463 priv->norm = TV_NORM_PAL;
464 priv->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic;
465 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
466 priv->scale = 1;
467 priv->contrast = 50;
468 priv->brightness = 50;
469 priv->flicker = 50;
470 priv->hmargin = 50;
471 priv->vmargin = 50;
472 priv->last_dpms = -1;
473 priv->chip_version = ch7006_read(client, CH7006_VERSION_ID);
474
475 if (ch7006_tv_norm) {
476 for (i = 0; i < NUM_TV_NORMS; i++) {
477 if (!strcmp(ch7006_tv_norm_names[i], ch7006_tv_norm)) {
478 priv->norm = i;
479 break;
480 }
481 }
482
483 if (i == NUM_TV_NORMS)
484 ch7006_err(client, "Invalid TV norm setting \"%s\".\n",
485 ch7006_tv_norm);
486 }
487
488 if (ch7006_scale >= 0 && ch7006_scale <= 2)
489 priv->scale = ch7006_scale;
490 else
491 ch7006_err(client, "Invalid scale setting \"%d\".\n",
492 ch7006_scale);
493
494 return 0;
495}
496
497static struct i2c_device_id ch7006_ids[] = {
498 { "ch7006", 0 },
499 { }
500};
501MODULE_DEVICE_TABLE(i2c, ch7006_ids);
502
503static struct drm_i2c_encoder_driver ch7006_driver = {
504 .i2c_driver = {
505 .probe = ch7006_probe,
506 .remove = ch7006_remove,
507 .suspend = ch7006_suspend,
508 .resume = ch7006_resume,
509
510 .driver = {
511 .name = "ch7006",
512 },
513
514 .id_table = ch7006_ids,
515 },
516
517 .encoder_init = ch7006_encoder_init,
518};
519
520
521/* Module initialization */
522
523static int __init ch7006_init(void)
524{
525 return drm_i2c_encoder_register(THIS_MODULE, &ch7006_driver);
526}
527
528static void __exit ch7006_exit(void)
529{
530 drm_i2c_encoder_unregister(&ch7006_driver);
531}
532
533int ch7006_debug;
534module_param_named(debug, ch7006_debug, int, 0600);
535MODULE_PARM_DESC(debug, "Enable debug output.");
536
537char *ch7006_tv_norm;
538module_param_named(tv_norm, ch7006_tv_norm, charp, 0600);
539MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
540 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, PAL-60, NTSC-M, NTSC-J.\n"
541 "\t\tDefault: PAL");
542
543int ch7006_scale = 1;
544module_param_named(scale, ch7006_scale, int, 0600);
545MODULE_PARM_DESC(scale, "Default scale.\n"
546 "\t\tSupported: 0 -> Select video modes with a higher blanking ratio.\n"
547 "\t\t\t1 -> Select default video modes.\n"
548 "\t\t\t2 -> Select video modes with a lower blanking ratio.");
549
550MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>");
551MODULE_DESCRIPTION("Chrontel ch7006 TV encoder driver");
552MODULE_LICENSE("GPL and additional rights");
553
554module_init(ch7006_init);
555module_exit(ch7006_exit);
1/*
2 * Copyright (C) 2009 Francisco Jerez.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
26
27#include <linux/module.h>
28
29#include <drm/drm_crtc_helper.h>
30
31#include "ch7006_priv.h"
32
33/* DRM encoder functions */
34
35static void ch7006_encoder_set_config(struct drm_encoder *encoder,
36 void *params)
37{
38 struct ch7006_priv *priv = to_ch7006_priv(encoder);
39
40 priv->params = *(struct ch7006_encoder_params *)params;
41}
42
43static void ch7006_encoder_destroy(struct drm_encoder *encoder)
44{
45 struct ch7006_priv *priv = to_ch7006_priv(encoder);
46
47 drm_property_destroy(encoder->dev, priv->scale_property);
48
49 kfree(priv);
50 to_encoder_slave(encoder)->slave_priv = NULL;
51
52 drm_i2c_encoder_destroy(encoder);
53}
54
55static void ch7006_encoder_dpms(struct drm_encoder *encoder, int mode)
56{
57 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
58 struct ch7006_priv *priv = to_ch7006_priv(encoder);
59 struct ch7006_state *state = &priv->state;
60
61 ch7006_dbg(client, "\n");
62
63 if (mode == priv->last_dpms)
64 return;
65 priv->last_dpms = mode;
66
67 ch7006_setup_power_state(encoder);
68
69 ch7006_load_reg(client, state, CH7006_POWER);
70}
71
72static void ch7006_encoder_save(struct drm_encoder *encoder)
73{
74 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
75 struct ch7006_priv *priv = to_ch7006_priv(encoder);
76
77 ch7006_dbg(client, "\n");
78
79 ch7006_state_save(client, &priv->saved_state);
80}
81
82static void ch7006_encoder_restore(struct drm_encoder *encoder)
83{
84 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
85 struct ch7006_priv *priv = to_ch7006_priv(encoder);
86
87 ch7006_dbg(client, "\n");
88
89 ch7006_state_load(client, &priv->saved_state);
90}
91
92static bool ch7006_encoder_mode_fixup(struct drm_encoder *encoder,
93 const struct drm_display_mode *mode,
94 struct drm_display_mode *adjusted_mode)
95{
96 struct ch7006_priv *priv = to_ch7006_priv(encoder);
97
98 /* The ch7006 is painfully picky with the input timings so no
99 * custom modes for now... */
100
101 priv->mode = ch7006_lookup_mode(encoder, mode);
102
103 return !!priv->mode;
104}
105
106static int ch7006_encoder_mode_valid(struct drm_encoder *encoder,
107 struct drm_display_mode *mode)
108{
109 if (ch7006_lookup_mode(encoder, mode))
110 return MODE_OK;
111 else
112 return MODE_BAD;
113}
114
115static void ch7006_encoder_mode_set(struct drm_encoder *encoder,
116 struct drm_display_mode *drm_mode,
117 struct drm_display_mode *adjusted_mode)
118{
119 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
120 struct ch7006_priv *priv = to_ch7006_priv(encoder);
121 struct ch7006_encoder_params *params = &priv->params;
122 struct ch7006_state *state = &priv->state;
123 uint8_t *regs = state->regs;
124 const struct ch7006_mode *mode = priv->mode;
125 const struct ch7006_tv_norm_info *norm = &ch7006_tv_norms[priv->norm];
126 int start_active;
127
128 ch7006_dbg(client, "\n");
129
130 regs[CH7006_DISPMODE] = norm->dispmode | mode->dispmode;
131 regs[CH7006_BWIDTH] = 0;
132 regs[CH7006_INPUT_FORMAT] = bitf(CH7006_INPUT_FORMAT_FORMAT,
133 params->input_format);
134
135 regs[CH7006_CLKMODE] = CH7006_CLKMODE_SUBC_LOCK
136 | bitf(CH7006_CLKMODE_XCM, params->xcm)
137 | bitf(CH7006_CLKMODE_PCM, params->pcm);
138 if (params->clock_mode)
139 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_MASTER;
140 if (params->clock_edge)
141 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_POS_EDGE;
142
143 start_active = (drm_mode->htotal & ~0x7) - (drm_mode->hsync_start & ~0x7);
144 regs[CH7006_POV] = bitf(CH7006_POV_START_ACTIVE_8, start_active);
145 regs[CH7006_START_ACTIVE] = bitf(CH7006_START_ACTIVE_0, start_active);
146
147 regs[CH7006_INPUT_SYNC] = 0;
148 if (params->sync_direction)
149 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_OUTPUT;
150 if (params->sync_encoding)
151 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_EMBEDDED;
152 if (drm_mode->flags & DRM_MODE_FLAG_PVSYNC)
153 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PVSYNC;
154 if (drm_mode->flags & DRM_MODE_FLAG_PHSYNC)
155 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PHSYNC;
156
157 regs[CH7006_DETECT] = 0;
158 regs[CH7006_BCLKOUT] = 0;
159
160 regs[CH7006_SUBC_INC3] = 0;
161 if (params->pout_level)
162 regs[CH7006_SUBC_INC3] |= CH7006_SUBC_INC3_POUT_3_3V;
163
164 regs[CH7006_SUBC_INC4] = 0;
165 if (params->active_detect)
166 regs[CH7006_SUBC_INC4] |= CH7006_SUBC_INC4_DS_INPUT;
167
168 regs[CH7006_PLL_CONTROL] = priv->saved_state.regs[CH7006_PLL_CONTROL];
169
170 ch7006_setup_levels(encoder);
171 ch7006_setup_subcarrier(encoder);
172 ch7006_setup_pll(encoder);
173 ch7006_setup_power_state(encoder);
174 ch7006_setup_properties(encoder);
175
176 ch7006_state_load(client, state);
177}
178
179static enum drm_connector_status ch7006_encoder_detect(struct drm_encoder *encoder,
180 struct drm_connector *connector)
181{
182 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
183 struct ch7006_priv *priv = to_ch7006_priv(encoder);
184 struct ch7006_state *state = &priv->state;
185 int det;
186
187 ch7006_dbg(client, "\n");
188
189 ch7006_save_reg(client, state, CH7006_DETECT);
190 ch7006_save_reg(client, state, CH7006_POWER);
191 ch7006_save_reg(client, state, CH7006_CLKMODE);
192
193 ch7006_write(client, CH7006_POWER, CH7006_POWER_RESET |
194 bitfs(CH7006_POWER_LEVEL, NORMAL));
195 ch7006_write(client, CH7006_CLKMODE, CH7006_CLKMODE_MASTER);
196
197 ch7006_write(client, CH7006_DETECT, CH7006_DETECT_SENSE);
198
199 ch7006_write(client, CH7006_DETECT, 0);
200
201 det = ch7006_read(client, CH7006_DETECT);
202
203 ch7006_load_reg(client, state, CH7006_CLKMODE);
204 ch7006_load_reg(client, state, CH7006_POWER);
205 ch7006_load_reg(client, state, CH7006_DETECT);
206
207 if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
208 CH7006_DETECT_SVIDEO_C_TEST|
209 CH7006_DETECT_CVBS_TEST)) == 0)
210 priv->subconnector = DRM_MODE_SUBCONNECTOR_SCART;
211 else if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
212 CH7006_DETECT_SVIDEO_C_TEST)) == 0)
213 priv->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO;
214 else if ((det & CH7006_DETECT_CVBS_TEST) == 0)
215 priv->subconnector = DRM_MODE_SUBCONNECTOR_Composite;
216 else
217 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
218
219 drm_object_property_set_value(&connector->base,
220 encoder->dev->mode_config.tv_subconnector_property,
221 priv->subconnector);
222
223 return priv->subconnector ? connector_status_connected :
224 connector_status_disconnected;
225}
226
227static int ch7006_encoder_get_modes(struct drm_encoder *encoder,
228 struct drm_connector *connector)
229{
230 struct ch7006_priv *priv = to_ch7006_priv(encoder);
231 const struct ch7006_mode *mode;
232 int n = 0;
233
234 for (mode = ch7006_modes; mode->mode.clock; mode++) {
235 if (~mode->valid_scales & 1<<priv->scale ||
236 ~mode->valid_norms & 1<<priv->norm)
237 continue;
238
239 drm_mode_probed_add(connector,
240 drm_mode_duplicate(encoder->dev, &mode->mode));
241
242 n++;
243 }
244
245 return n;
246}
247
248static int ch7006_encoder_create_resources(struct drm_encoder *encoder,
249 struct drm_connector *connector)
250{
251 struct ch7006_priv *priv = to_ch7006_priv(encoder);
252 struct drm_device *dev = encoder->dev;
253 struct drm_mode_config *conf = &dev->mode_config;
254
255 drm_mode_create_tv_properties_legacy(dev, NUM_TV_NORMS, ch7006_tv_norm_names);
256
257 priv->scale_property = drm_property_create_range(dev, 0, "scale", 0, 2);
258 if (!priv->scale_property)
259 return -ENOMEM;
260
261 drm_object_attach_property(&connector->base, conf->tv_select_subconnector_property,
262 priv->select_subconnector);
263 drm_object_attach_property(&connector->base, conf->tv_subconnector_property,
264 priv->subconnector);
265 drm_object_attach_property(&connector->base, conf->tv_left_margin_property,
266 priv->hmargin);
267 drm_object_attach_property(&connector->base, conf->tv_bottom_margin_property,
268 priv->vmargin);
269 drm_object_attach_property(&connector->base, conf->legacy_tv_mode_property,
270 priv->norm);
271 drm_object_attach_property(&connector->base, conf->tv_brightness_property,
272 priv->brightness);
273 drm_object_attach_property(&connector->base, conf->tv_contrast_property,
274 priv->contrast);
275 drm_object_attach_property(&connector->base, conf->tv_flicker_reduction_property,
276 priv->flicker);
277 drm_object_attach_property(&connector->base, priv->scale_property,
278 priv->scale);
279
280 return 0;
281}
282
283static int ch7006_encoder_set_property(struct drm_encoder *encoder,
284 struct drm_connector *connector,
285 struct drm_property *property,
286 uint64_t val)
287{
288 struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
289 struct ch7006_priv *priv = to_ch7006_priv(encoder);
290 struct ch7006_state *state = &priv->state;
291 struct drm_mode_config *conf = &encoder->dev->mode_config;
292 struct drm_crtc *crtc = encoder->crtc;
293 bool modes_changed = false;
294
295 ch7006_dbg(client, "\n");
296
297 if (property == conf->tv_select_subconnector_property) {
298 priv->select_subconnector = val;
299
300 ch7006_setup_power_state(encoder);
301
302 ch7006_load_reg(client, state, CH7006_POWER);
303
304 } else if (property == conf->tv_left_margin_property) {
305 priv->hmargin = val;
306
307 ch7006_setup_properties(encoder);
308
309 ch7006_load_reg(client, state, CH7006_POV);
310 ch7006_load_reg(client, state, CH7006_HPOS);
311
312 } else if (property == conf->tv_bottom_margin_property) {
313 priv->vmargin = val;
314
315 ch7006_setup_properties(encoder);
316
317 ch7006_load_reg(client, state, CH7006_POV);
318 ch7006_load_reg(client, state, CH7006_VPOS);
319
320 } else if (property == conf->legacy_tv_mode_property) {
321 if (connector->dpms != DRM_MODE_DPMS_OFF)
322 return -EINVAL;
323
324 priv->norm = val;
325
326 modes_changed = true;
327
328 } else if (property == conf->tv_brightness_property) {
329 priv->brightness = val;
330
331 ch7006_setup_levels(encoder);
332
333 ch7006_load_reg(client, state, CH7006_BLACK_LEVEL);
334
335 } else if (property == conf->tv_contrast_property) {
336 priv->contrast = val;
337
338 ch7006_setup_properties(encoder);
339
340 ch7006_load_reg(client, state, CH7006_CONTRAST);
341
342 } else if (property == conf->tv_flicker_reduction_property) {
343 priv->flicker = val;
344
345 ch7006_setup_properties(encoder);
346
347 ch7006_load_reg(client, state, CH7006_FFILTER);
348
349 } else if (property == priv->scale_property) {
350 if (connector->dpms != DRM_MODE_DPMS_OFF)
351 return -EINVAL;
352
353 priv->scale = val;
354
355 modes_changed = true;
356
357 } else {
358 return -EINVAL;
359 }
360
361 if (modes_changed) {
362 drm_helper_probe_single_connector_modes(connector, 0, 0);
363
364 if (crtc)
365 drm_crtc_helper_set_mode(crtc, &crtc->mode,
366 crtc->x, crtc->y,
367 crtc->primary->fb);
368 }
369
370 return 0;
371}
372
373static const struct drm_encoder_slave_funcs ch7006_encoder_funcs = {
374 .set_config = ch7006_encoder_set_config,
375 .destroy = ch7006_encoder_destroy,
376 .dpms = ch7006_encoder_dpms,
377 .save = ch7006_encoder_save,
378 .restore = ch7006_encoder_restore,
379 .mode_fixup = ch7006_encoder_mode_fixup,
380 .mode_valid = ch7006_encoder_mode_valid,
381 .mode_set = ch7006_encoder_mode_set,
382 .detect = ch7006_encoder_detect,
383 .get_modes = ch7006_encoder_get_modes,
384 .create_resources = ch7006_encoder_create_resources,
385 .set_property = ch7006_encoder_set_property,
386};
387
388
389/* I2C driver functions */
390
391static int ch7006_probe(struct i2c_client *client)
392{
393 uint8_t addr = CH7006_VERSION_ID;
394 uint8_t val;
395 int ret;
396
397 ch7006_dbg(client, "\n");
398
399 ret = i2c_master_send(client, &addr, sizeof(addr));
400 if (ret < 0)
401 goto fail;
402
403 ret = i2c_master_recv(client, &val, sizeof(val));
404 if (ret < 0)
405 goto fail;
406
407 ch7006_info(client, "Detected version ID: %x\n", val);
408
409 /* I don't know what this is for, but otherwise I get no
410 * signal.
411 */
412 ch7006_write(client, 0x3d, 0x0);
413
414 return 0;
415
416fail:
417 ch7006_err(client, "Error %d reading version ID\n", ret);
418
419 return -ENODEV;
420}
421
422static void ch7006_remove(struct i2c_client *client)
423{
424 ch7006_dbg(client, "\n");
425}
426
427static int ch7006_resume(struct device *dev)
428{
429 struct i2c_client *client = to_i2c_client(dev);
430
431 ch7006_dbg(client, "\n");
432
433 ch7006_write(client, 0x3d, 0x0);
434
435 return 0;
436}
437
438static int ch7006_encoder_init(struct i2c_client *client,
439 struct drm_device *dev,
440 struct drm_encoder_slave *encoder)
441{
442 struct ch7006_priv *priv;
443 int i;
444
445 ch7006_dbg(client, "\n");
446
447 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
448 if (!priv)
449 return -ENOMEM;
450
451 encoder->slave_priv = priv;
452 encoder->slave_funcs = &ch7006_encoder_funcs;
453
454 priv->norm = TV_NORM_PAL;
455 priv->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic;
456 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
457 priv->scale = 1;
458 priv->contrast = 50;
459 priv->brightness = 50;
460 priv->flicker = 50;
461 priv->hmargin = 50;
462 priv->vmargin = 50;
463 priv->last_dpms = -1;
464 priv->chip_version = ch7006_read(client, CH7006_VERSION_ID);
465
466 if (ch7006_tv_norm) {
467 for (i = 0; i < NUM_TV_NORMS; i++) {
468 if (!strcmp(ch7006_tv_norm_names[i], ch7006_tv_norm)) {
469 priv->norm = i;
470 break;
471 }
472 }
473
474 if (i == NUM_TV_NORMS)
475 ch7006_err(client, "Invalid TV norm setting \"%s\".\n",
476 ch7006_tv_norm);
477 }
478
479 if (ch7006_scale >= 0 && ch7006_scale <= 2)
480 priv->scale = ch7006_scale;
481 else
482 ch7006_err(client, "Invalid scale setting \"%d\".\n",
483 ch7006_scale);
484
485 return 0;
486}
487
488static const struct i2c_device_id ch7006_ids[] = {
489 { "ch7006", 0 },
490 { }
491};
492MODULE_DEVICE_TABLE(i2c, ch7006_ids);
493
494static const struct dev_pm_ops ch7006_pm_ops = {
495 .resume = ch7006_resume,
496};
497
498static struct drm_i2c_encoder_driver ch7006_driver = {
499 .i2c_driver = {
500 .probe = ch7006_probe,
501 .remove = ch7006_remove,
502
503 .driver = {
504 .name = "ch7006",
505 .pm = &ch7006_pm_ops,
506 },
507
508 .id_table = ch7006_ids,
509 },
510
511 .encoder_init = ch7006_encoder_init,
512};
513
514
515/* Module initialization */
516
517static int __init ch7006_init(void)
518{
519 return drm_i2c_encoder_register(THIS_MODULE, &ch7006_driver);
520}
521
522static void __exit ch7006_exit(void)
523{
524 drm_i2c_encoder_unregister(&ch7006_driver);
525}
526
527int ch7006_debug;
528module_param_named(debug, ch7006_debug, int, 0600);
529MODULE_PARM_DESC(debug, "Enable debug output.");
530
531char *ch7006_tv_norm;
532module_param_named(tv_norm, ch7006_tv_norm, charp, 0600);
533MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
534 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, PAL-60, NTSC-M, NTSC-J.\n"
535 "\t\tDefault: PAL");
536
537int ch7006_scale = 1;
538module_param_named(scale, ch7006_scale, int, 0600);
539MODULE_PARM_DESC(scale, "Default scale.\n"
540 "\t\tSupported: 0 -> Select video modes with a higher blanking ratio.\n"
541 "\t\t\t1 -> Select default video modes.\n"
542 "\t\t\t2 -> Select video modes with a lower blanking ratio.");
543
544MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>");
545MODULE_DESCRIPTION("Chrontel ch7006 TV encoder driver");
546MODULE_LICENSE("GPL and additional rights");
547
548module_init(ch7006_init);
549module_exit(ch7006_exit);