blob: 802b61ac31390d92b2affaf14f787b75f8caab2f [file] [log] [blame]
Dave Airlie785b93e2009-08-28 15:46:53 +10001/*
2 * Copyright (c) 2006-2009 Red Hat Inc.
3 * Copyright (c) 2006-2008 Intel Corporation
4 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
5 *
6 * DRM framebuffer helper functions
7 *
8 * Permission to use, copy, modify, distribute, and sell this software and its
9 * documentation for any purpose is hereby granted without fee, provided that
10 * the above copyright notice appear in all copies and that both that copyright
11 * notice and this permission notice appear in supporting documentation, and
12 * that the name of the copyright holders not be used in advertising or
13 * publicity pertaining to distribution of the software without specific,
14 * written prior permission. The copyright holders make no representations
15 * about the suitability of this software for any purpose. It is provided "as
16 * is" without express or implied warranty.
17 *
18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 *
26 * Authors:
27 * Dave Airlie <airlied@linux.ie>
28 * Jesse Barnes <jesse.barnes@intel.com>
29 */
Andy Shevchenko3b40a442010-02-02 14:40:32 -080030#include <linux/kernel.h>
Dave Airlie785b93e2009-08-28 15:46:53 +100031#include <linux/sysrq.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Dave Airlie785b93e2009-08-28 15:46:53 +100033#include <linux/fb.h>
34#include "drmP.h"
35#include "drm_crtc.h"
36#include "drm_fb_helper.h"
37#include "drm_crtc_helper.h"
38
Dave Airlie6fcefd52009-09-08 11:08:32 +100039MODULE_AUTHOR("David Airlie, Jesse Barnes");
40MODULE_DESCRIPTION("DRM KMS helper");
41MODULE_LICENSE("GPL and additional rights");
42
Dave Airlie785b93e2009-08-28 15:46:53 +100043static LIST_HEAD(kernel_fb_helper_list);
44
Dave Airlie0b4c0f32010-03-30 05:34:15 +000045/* simple single crtc case helper function */
46int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
Dave Airlied50ba252009-09-23 14:44:08 +100047{
Dave Airlie0b4c0f32010-03-30 05:34:15 +000048 struct drm_device *dev = fb_helper->dev;
49 struct drm_connector *connector;
50 int i;
Dave Airlied50ba252009-09-23 14:44:08 +100051
Dave Airlie0b4c0f32010-03-30 05:34:15 +000052 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
53 struct drm_fb_helper_connector *fb_helper_connector;
54
55 fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
56 if (!fb_helper_connector)
57 goto fail;
58
59 fb_helper_connector->connector = connector;
60 fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
61 }
Dave Airlied50ba252009-09-23 14:44:08 +100062 return 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +000063fail:
64 for (i = 0; i < fb_helper->connector_count; i++) {
65 kfree(fb_helper->connector_info[i]);
66 fb_helper->connector_info[i] = NULL;
67 }
68 fb_helper->connector_count = 0;
69 return -ENOMEM;
Dave Airlied50ba252009-09-23 14:44:08 +100070}
Dave Airlie0b4c0f32010-03-30 05:34:15 +000071EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
Dave Airlied50ba252009-09-23 14:44:08 +100072
Dave Airlie0b4c0f32010-03-30 05:34:15 +000073static int drm_fb_helper_parse_command_line(struct drm_fb_helper *fb_helper)
Dave Airlied50ba252009-09-23 14:44:08 +100074{
Dave Airlie0b4c0f32010-03-30 05:34:15 +000075 struct drm_fb_helper_connector *fb_helper_conn;
76 int i;
Dave Airlied50ba252009-09-23 14:44:08 +100077
Dave Airlie0b4c0f32010-03-30 05:34:15 +000078 for (i = 0; i < fb_helper->connector_count; i++) {
Chris Wilson1794d252011-04-17 07:43:32 +010079 struct drm_cmdline_mode *mode;
80 struct drm_connector *connector;
Dave Airlied50ba252009-09-23 14:44:08 +100081 char *option = NULL;
82
Dave Airlie0b4c0f32010-03-30 05:34:15 +000083 fb_helper_conn = fb_helper->connector_info[i];
Chris Wilson1794d252011-04-17 07:43:32 +010084 connector = fb_helper_conn->connector;
85 mode = &fb_helper_conn->cmdline_mode;
Dave Airlie0b4c0f32010-03-30 05:34:15 +000086
Dave Airlied50ba252009-09-23 14:44:08 +100087 /* do something on return - turn off connector maybe */
Chris Wilson1794d252011-04-17 07:43:32 +010088 if (fb_get_options(drm_get_connector_name(connector), &option))
Dave Airlied50ba252009-09-23 14:44:08 +100089 continue;
90
Chris Wilson1794d252011-04-17 07:43:32 +010091 if (drm_mode_parse_command_line_for_connector(option,
92 connector,
93 mode)) {
94 if (mode->force) {
95 const char *s;
96 switch (mode->force) {
97 case DRM_FORCE_OFF: s = "OFF"; break;
98 case DRM_FORCE_ON_DIGITAL: s = "ON - dig"; break;
99 default:
100 case DRM_FORCE_ON: s = "ON"; break;
101 }
102
103 DRM_INFO("forcing %s connector %s\n",
104 drm_get_connector_name(connector), s);
105 connector->force = mode->force;
106 }
107
108 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
109 drm_get_connector_name(connector),
110 mode->xres, mode->yres,
111 mode->refresh_specified ? mode->refresh : 60,
112 mode->rb ? " reduced blanking" : "",
113 mode->margins ? " with margins" : "",
114 mode->interlace ? " interlaced" : "");
115 }
116
Dave Airlied50ba252009-09-23 14:44:08 +1000117 }
118 return 0;
119}
120
Jason Wessel99231022010-10-13 14:09:43 -0500121static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
122{
123 uint16_t *r_base, *g_base, *b_base;
124 int i;
125
126 r_base = crtc->gamma_store;
127 g_base = r_base + crtc->gamma_size;
128 b_base = g_base + crtc->gamma_size;
129
130 for (i = 0; i < crtc->gamma_size; i++)
131 helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
132}
133
134static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
135{
136 uint16_t *r_base, *g_base, *b_base;
137
138 r_base = crtc->gamma_store;
139 g_base = r_base + crtc->gamma_size;
140 b_base = g_base + crtc->gamma_size;
141
142 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
143}
144
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500145int drm_fb_helper_debug_enter(struct fb_info *info)
146{
147 struct drm_fb_helper *helper = info->par;
148 struct drm_crtc_helper_funcs *funcs;
149 int i;
150
151 if (list_empty(&kernel_fb_helper_list))
152 return false;
153
154 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
155 for (i = 0; i < helper->crtc_count; i++) {
156 struct drm_mode_set *mode_set =
157 &helper->crtc_info[i].mode_set;
158
159 if (!mode_set->crtc->enabled)
160 continue;
161
162 funcs = mode_set->crtc->helper_private;
Jason Wessel99231022010-10-13 14:09:43 -0500163 drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500164 funcs->mode_set_base_atomic(mode_set->crtc,
165 mode_set->fb,
166 mode_set->x,
Jason Wessel413d45d2010-09-26 06:47:25 -0500167 mode_set->y,
Jason Wessel21c74a82010-10-13 14:09:44 -0500168 ENTER_ATOMIC_MODE_SET);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500169 }
170 }
171
172 return 0;
173}
174EXPORT_SYMBOL(drm_fb_helper_debug_enter);
175
176/* Find the real fb for a given fb helper CRTC */
177static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
178{
179 struct drm_device *dev = crtc->dev;
180 struct drm_crtc *c;
181
182 list_for_each_entry(c, &dev->mode_config.crtc_list, head) {
183 if (crtc->base.id == c->base.id)
184 return c->fb;
185 }
186
187 return NULL;
188}
189
190int drm_fb_helper_debug_leave(struct fb_info *info)
191{
192 struct drm_fb_helper *helper = info->par;
193 struct drm_crtc *crtc;
194 struct drm_crtc_helper_funcs *funcs;
195 struct drm_framebuffer *fb;
196 int i;
197
198 for (i = 0; i < helper->crtc_count; i++) {
199 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
200 crtc = mode_set->crtc;
201 funcs = crtc->helper_private;
202 fb = drm_mode_config_fb(crtc);
203
204 if (!crtc->enabled)
205 continue;
206
207 if (!fb) {
208 DRM_ERROR("no fb to restore??\n");
209 continue;
210 }
211
Jason Wessel99231022010-10-13 14:09:43 -0500212 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500213 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
Jason Wessel21c74a82010-10-13 14:09:44 -0500214 crtc->y, LEAVE_ATOMIC_MODE_SET);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500215 }
216
217 return 0;
218}
219EXPORT_SYMBOL(drm_fb_helper_debug_leave);
220
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100221bool drm_fb_helper_restore_fbdev_mode(struct drm_fb_helper *fb_helper)
222{
223 bool error = false;
224 int i, ret;
225 for (i = 0; i < fb_helper->crtc_count; i++) {
226 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
227 ret = drm_crtc_helper_set_config(mode_set);
228 if (ret)
229 error = true;
230 }
231 return error;
232}
233EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode);
234
Dave Airlie785b93e2009-08-28 15:46:53 +1000235bool drm_fb_helper_force_kernel_mode(void)
236{
Dave Airlie785b93e2009-08-28 15:46:53 +1000237 bool ret, error = false;
238 struct drm_fb_helper *helper;
239
240 if (list_empty(&kernel_fb_helper_list))
241 return false;
242
243 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100244 if (helper->dev->switch_power_state == DRM_SWITCH_POWER_OFF)
245 continue;
246
247 ret = drm_fb_helper_restore_fbdev_mode(helper);
248 if (ret)
249 error = true;
Dave Airlie785b93e2009-08-28 15:46:53 +1000250 }
251 return error;
252}
253
254int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
255 void *panic_str)
256{
Dave Airliefc2362a2010-06-07 12:14:54 +1000257 printk(KERN_ERR "panic occurred, switching back to text console\n");
Dave Airlie785b93e2009-08-28 15:46:53 +1000258 return drm_fb_helper_force_kernel_mode();
259 return 0;
260}
261EXPORT_SYMBOL(drm_fb_helper_panic);
262
263static struct notifier_block paniced = {
264 .notifier_call = drm_fb_helper_panic,
265};
266
267/**
268 * drm_fb_helper_restore - restore the framebuffer console (kernel) config
269 *
270 * Restore's the kernel's fbcon mode, used for lastclose & panic paths.
271 */
272void drm_fb_helper_restore(void)
273{
274 bool ret;
275 ret = drm_fb_helper_force_kernel_mode();
276 if (ret == true)
277 DRM_ERROR("Failed to restore crtc configuration\n");
278}
279EXPORT_SYMBOL(drm_fb_helper_restore);
280
Mikael Petterssonbea1d352009-09-28 18:26:25 +0200281#ifdef CONFIG_MAGIC_SYSRQ
Dave Airlie785b93e2009-08-28 15:46:53 +1000282static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
283{
284 drm_fb_helper_restore();
285}
286static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
287
Dmitry Torokhov1495cc92010-08-17 21:15:46 -0700288static void drm_fb_helper_sysrq(int dummy1)
Dave Airlie785b93e2009-08-28 15:46:53 +1000289{
290 schedule_work(&drm_fb_helper_restore_work);
291}
292
293static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
294 .handler = drm_fb_helper_sysrq,
295 .help_msg = "force-fb(V)",
296 .action_msg = "Restore framebuffer console",
297};
Randy Dunlapb8c40d62010-03-25 18:29:05 +0000298#else
299static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
Mikael Petterssonbea1d352009-09-28 18:26:25 +0200300#endif
Dave Airlie785b93e2009-08-28 15:46:53 +1000301
302static void drm_fb_helper_on(struct fb_info *info)
303{
304 struct drm_fb_helper *fb_helper = info->par;
305 struct drm_device *dev = fb_helper->dev;
306 struct drm_crtc *crtc;
Dave Airlie8be48d92010-03-30 05:34:14 +0000307 struct drm_crtc_helper_funcs *crtc_funcs;
Jesse Barnes023eb572010-07-02 10:48:08 -0700308 struct drm_connector *connector;
Dave Airlie785b93e2009-08-28 15:46:53 +1000309 struct drm_encoder *encoder;
Jesse Barnes023eb572010-07-02 10:48:08 -0700310 int i, j;
Dave Airlie785b93e2009-08-28 15:46:53 +1000311
312 /*
313 * For each CRTC in this fb, turn the crtc on then,
314 * find all associated encoders and turn them on.
315 */
Dave Airlie8be48d92010-03-30 05:34:14 +0000316 mutex_lock(&dev->mode_config.mutex);
Jesse Barnese87b2c42009-09-17 18:14:41 -0700317 for (i = 0; i < fb_helper->crtc_count; i++) {
Dave Airlie8be48d92010-03-30 05:34:14 +0000318 crtc = fb_helper->crtc_info[i].mode_set.crtc;
319 crtc_funcs = crtc->helper_private;
Dave Airlie785b93e2009-08-28 15:46:53 +1000320
Dave Airlie8be48d92010-03-30 05:34:14 +0000321 if (!crtc->enabled)
322 continue;
Dave Airlie785b93e2009-08-28 15:46:53 +1000323
Dave Airlie8be48d92010-03-30 05:34:14 +0000324 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
Dave Airlie785b93e2009-08-28 15:46:53 +1000325
Jesse Barnes023eb572010-07-02 10:48:08 -0700326 /* Walk the connectors & encoders on this fb turning them on */
327 for (j = 0; j < fb_helper->connector_count; j++) {
328 connector = fb_helper->connector_info[j]->connector;
329 connector->dpms = DRM_MODE_DPMS_ON;
330 drm_connector_property_set_value(connector,
331 dev->mode_config.dpms_property,
332 DRM_MODE_DPMS_ON);
333 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000334 /* Found a CRTC on this fb, now find encoders */
335 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
336 if (encoder->crtc == crtc) {
337 struct drm_encoder_helper_funcs *encoder_funcs;
338
339 encoder_funcs = encoder->helper_private;
340 encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
Dave Airlie785b93e2009-08-28 15:46:53 +1000341 }
342 }
343 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000344 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie785b93e2009-08-28 15:46:53 +1000345}
346
347static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
348{
349 struct drm_fb_helper *fb_helper = info->par;
350 struct drm_device *dev = fb_helper->dev;
351 struct drm_crtc *crtc;
Dave Airlie8be48d92010-03-30 05:34:14 +0000352 struct drm_crtc_helper_funcs *crtc_funcs;
Jesse Barnes023eb572010-07-02 10:48:08 -0700353 struct drm_connector *connector;
Dave Airlie785b93e2009-08-28 15:46:53 +1000354 struct drm_encoder *encoder;
Jesse Barnes023eb572010-07-02 10:48:08 -0700355 int i, j;
Dave Airlie785b93e2009-08-28 15:46:53 +1000356
357 /*
358 * For each CRTC in this fb, find all associated encoders
359 * and turn them off, then turn off the CRTC.
360 */
Dave Airlie8be48d92010-03-30 05:34:14 +0000361 mutex_lock(&dev->mode_config.mutex);
Jesse Barnese87b2c42009-09-17 18:14:41 -0700362 for (i = 0; i < fb_helper->crtc_count; i++) {
Dave Airlie8be48d92010-03-30 05:34:14 +0000363 crtc = fb_helper->crtc_info[i].mode_set.crtc;
364 crtc_funcs = crtc->helper_private;
Dave Airlie785b93e2009-08-28 15:46:53 +1000365
Dave Airlie8be48d92010-03-30 05:34:14 +0000366 if (!crtc->enabled)
367 continue;
Dave Airlie785b93e2009-08-28 15:46:53 +1000368
Jesse Barnes023eb572010-07-02 10:48:08 -0700369 /* Walk the connectors on this fb and mark them off */
370 for (j = 0; j < fb_helper->connector_count; j++) {
371 connector = fb_helper->connector_info[j]->connector;
372 connector->dpms = dpms_mode;
373 drm_connector_property_set_value(connector,
374 dev->mode_config.dpms_property,
375 dpms_mode);
376 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000377 /* Found a CRTC on this fb, now find encoders */
378 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
379 if (encoder->crtc == crtc) {
380 struct drm_encoder_helper_funcs *encoder_funcs;
Dave Airlie785b93e2009-08-28 15:46:53 +1000381
Dave Airlie8be48d92010-03-30 05:34:14 +0000382 encoder_funcs = encoder->helper_private;
383 encoder_funcs->dpms(encoder, dpms_mode);
Jesse Barnese87b2c42009-09-17 18:14:41 -0700384 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000385 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000386 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
Dave Airlie785b93e2009-08-28 15:46:53 +1000387 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000388 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie785b93e2009-08-28 15:46:53 +1000389}
390
391int drm_fb_helper_blank(int blank, struct fb_info *info)
392{
393 switch (blank) {
James Simmons731b5a12009-10-29 20:39:07 +0000394 /* Display: On; HSync: On, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000395 case FB_BLANK_UNBLANK:
396 drm_fb_helper_on(info);
397 break;
James Simmons731b5a12009-10-29 20:39:07 +0000398 /* Display: Off; HSync: On, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000399 case FB_BLANK_NORMAL:
Zhenyu Wang5fd4df42010-01-18 16:47:04 +0800400 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
Dave Airlie785b93e2009-08-28 15:46:53 +1000401 break;
James Simmons731b5a12009-10-29 20:39:07 +0000402 /* Display: Off; HSync: Off, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000403 case FB_BLANK_HSYNC_SUSPEND:
404 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
405 break;
James Simmons731b5a12009-10-29 20:39:07 +0000406 /* Display: Off; HSync: On, VSync: Off */
Dave Airlie785b93e2009-08-28 15:46:53 +1000407 case FB_BLANK_VSYNC_SUSPEND:
408 drm_fb_helper_off(info, DRM_MODE_DPMS_SUSPEND);
409 break;
James Simmons731b5a12009-10-29 20:39:07 +0000410 /* Display: Off; HSync: Off, VSync: Off */
Dave Airlie785b93e2009-08-28 15:46:53 +1000411 case FB_BLANK_POWERDOWN:
412 drm_fb_helper_off(info, DRM_MODE_DPMS_OFF);
413 break;
414 }
415 return 0;
416}
417EXPORT_SYMBOL(drm_fb_helper_blank);
418
419static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
420{
421 int i;
422
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000423 for (i = 0; i < helper->connector_count; i++)
424 kfree(helper->connector_info[i]);
425 kfree(helper->connector_info);
Dave Airlie785b93e2009-08-28 15:46:53 +1000426 for (i = 0; i < helper->crtc_count; i++)
427 kfree(helper->crtc_info[i].mode_set.connectors);
428 kfree(helper->crtc_info);
429}
430
Dave Airlie4abe3522010-03-30 05:34:18 +0000431int drm_fb_helper_init(struct drm_device *dev,
432 struct drm_fb_helper *fb_helper,
Dave Airlieeb1f8e42010-05-07 06:42:51 +0000433 int crtc_count, int max_conn_count)
Dave Airlie785b93e2009-08-28 15:46:53 +1000434{
Dave Airlie785b93e2009-08-28 15:46:53 +1000435 struct drm_crtc *crtc;
436 int ret = 0;
437 int i;
438
Dave Airlie4abe3522010-03-30 05:34:18 +0000439 fb_helper->dev = dev;
Dave Airlie4abe3522010-03-30 05:34:18 +0000440
441 INIT_LIST_HEAD(&fb_helper->kernel_fb_list);
442
443 fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
444 if (!fb_helper->crtc_info)
Dave Airlie785b93e2009-08-28 15:46:53 +1000445 return -ENOMEM;
446
Dave Airlie4abe3522010-03-30 05:34:18 +0000447 fb_helper->crtc_count = crtc_count;
448 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
449 if (!fb_helper->connector_info) {
450 kfree(fb_helper->crtc_info);
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000451 return -ENOMEM;
452 }
Dave Airlie4abe3522010-03-30 05:34:18 +0000453 fb_helper->connector_count = 0;
Dave Airlie785b93e2009-08-28 15:46:53 +1000454
455 for (i = 0; i < crtc_count; i++) {
Dave Airlie4abe3522010-03-30 05:34:18 +0000456 fb_helper->crtc_info[i].mode_set.connectors =
Dave Airlie785b93e2009-08-28 15:46:53 +1000457 kcalloc(max_conn_count,
458 sizeof(struct drm_connector *),
459 GFP_KERNEL);
460
Dave Airlie4abe3522010-03-30 05:34:18 +0000461 if (!fb_helper->crtc_info[i].mode_set.connectors) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000462 ret = -ENOMEM;
463 goto out_free;
464 }
Dave Airlie4abe3522010-03-30 05:34:18 +0000465 fb_helper->crtc_info[i].mode_set.num_connectors = 0;
Dave Airlie785b93e2009-08-28 15:46:53 +1000466 }
467
468 i = 0;
469 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
Dave Airlie4abe3522010-03-30 05:34:18 +0000470 fb_helper->crtc_info[i].crtc_id = crtc->base.id;
471 fb_helper->crtc_info[i].mode_set.crtc = crtc;
Dave Airlie785b93e2009-08-28 15:46:53 +1000472 i++;
473 }
Dave Airlie4abe3522010-03-30 05:34:18 +0000474 fb_helper->conn_limit = max_conn_count;
Dave Airlie785b93e2009-08-28 15:46:53 +1000475 return 0;
476out_free:
Dave Airlie4abe3522010-03-30 05:34:18 +0000477 drm_fb_helper_crtc_free(fb_helper);
Dave Airlie785b93e2009-08-28 15:46:53 +1000478 return -ENOMEM;
479}
Dave Airlie4abe3522010-03-30 05:34:18 +0000480EXPORT_SYMBOL(drm_fb_helper_init);
481
482void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
483{
484 if (!list_empty(&fb_helper->kernel_fb_list)) {
485 list_del(&fb_helper->kernel_fb_list);
486 if (list_empty(&kernel_fb_helper_list)) {
Kirill Smelkov3da1f332010-05-14 19:45:16 +0400487 printk(KERN_INFO "drm: unregistered panic notifier\n");
Dave Airlie4abe3522010-03-30 05:34:18 +0000488 atomic_notifier_chain_unregister(&panic_notifier_list,
489 &paniced);
490 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
491 }
492 }
493
494 drm_fb_helper_crtc_free(fb_helper);
495
Dave Airlie4abe3522010-03-30 05:34:18 +0000496}
497EXPORT_SYMBOL(drm_fb_helper_fini);
Dave Airlie785b93e2009-08-28 15:46:53 +1000498
Dave Airliec850cb72009-10-23 18:49:03 +1000499static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000500 u16 blue, u16 regno, struct fb_info *info)
501{
502 struct drm_fb_helper *fb_helper = info->par;
503 struct drm_framebuffer *fb = fb_helper->fb;
504 int pindex;
505
Dave Airliec850cb72009-10-23 18:49:03 +1000506 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
507 u32 *palette;
508 u32 value;
509 /* place color in psuedopalette */
510 if (regno > 16)
511 return -EINVAL;
512 palette = (u32 *)info->pseudo_palette;
513 red >>= (16 - info->var.red.length);
514 green >>= (16 - info->var.green.length);
515 blue >>= (16 - info->var.blue.length);
516 value = (red << info->var.red.offset) |
517 (green << info->var.green.offset) |
518 (blue << info->var.blue.offset);
Rob Clark9da12b6a2011-02-16 02:45:51 +0000519 if (info->var.transp.length > 0) {
520 u32 mask = (1 << info->var.transp.length) - 1;
521 mask <<= info->var.transp.offset;
522 value |= mask;
523 }
Dave Airliec850cb72009-10-23 18:49:03 +1000524 palette[regno] = value;
525 return 0;
526 }
527
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000528 pindex = regno;
529
530 if (fb->bits_per_pixel == 16) {
531 pindex = regno << 3;
532
533 if (fb->depth == 16 && regno > 63)
Dave Airliec850cb72009-10-23 18:49:03 +1000534 return -EINVAL;
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000535 if (fb->depth == 15 && regno > 31)
Dave Airliec850cb72009-10-23 18:49:03 +1000536 return -EINVAL;
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000537
538 if (fb->depth == 16) {
539 u16 r, g, b;
540 int i;
541 if (regno < 32) {
542 for (i = 0; i < 8; i++)
543 fb_helper->funcs->gamma_set(crtc, red,
544 green, blue, pindex + i);
545 }
546
547 fb_helper->funcs->gamma_get(crtc, &r,
548 &g, &b,
549 pindex >> 1);
550
551 for (i = 0; i < 4; i++)
552 fb_helper->funcs->gamma_set(crtc, r,
553 green, b,
554 (pindex >> 1) + i);
555 }
556 }
557
558 if (fb->depth != 16)
559 fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
Dave Airliec850cb72009-10-23 18:49:03 +1000560 return 0;
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000561}
562
Dave Airlie068143d2009-10-05 09:58:02 +1000563int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
564{
565 struct drm_fb_helper *fb_helper = info->par;
Dave Airlie8be48d92010-03-30 05:34:14 +0000566 struct drm_crtc_helper_funcs *crtc_funcs;
Dave Airlie068143d2009-10-05 09:58:02 +1000567 u16 *red, *green, *blue, *transp;
568 struct drm_crtc *crtc;
roel062ac622011-03-07 18:00:34 +0100569 int i, j, rc = 0;
Dave Airlie068143d2009-10-05 09:58:02 +1000570 int start;
571
Dave Airlie8be48d92010-03-30 05:34:14 +0000572 for (i = 0; i < fb_helper->crtc_count; i++) {
573 crtc = fb_helper->crtc_info[i].mode_set.crtc;
574 crtc_funcs = crtc->helper_private;
Dave Airlie068143d2009-10-05 09:58:02 +1000575
576 red = cmap->red;
577 green = cmap->green;
578 blue = cmap->blue;
579 transp = cmap->transp;
580 start = cmap->start;
581
roel062ac622011-03-07 18:00:34 +0100582 for (j = 0; j < cmap->len; j++) {
Dave Airlie068143d2009-10-05 09:58:02 +1000583 u16 hred, hgreen, hblue, htransp = 0xffff;
584
585 hred = *red++;
586 hgreen = *green++;
587 hblue = *blue++;
588
589 if (transp)
590 htransp = *transp++;
591
Dave Airliec850cb72009-10-23 18:49:03 +1000592 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
593 if (rc)
594 return rc;
Dave Airlie068143d2009-10-05 09:58:02 +1000595 }
596 crtc_funcs->load_lut(crtc);
597 }
598 return rc;
599}
600EXPORT_SYMBOL(drm_fb_helper_setcmap);
601
Dave Airlie785b93e2009-08-28 15:46:53 +1000602int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
603 struct fb_info *info)
604{
605 struct drm_fb_helper *fb_helper = info->par;
606 struct drm_framebuffer *fb = fb_helper->fb;
607 int depth;
608
Jason Wesself90ebd92010-08-05 09:22:32 -0500609 if (var->pixclock != 0 || in_dbg_master())
Dave Airlie785b93e2009-08-28 15:46:53 +1000610 return -EINVAL;
611
612 /* Need to resize the fb object !!! */
Dave Airlie509c7d82010-01-08 09:27:08 +1000613 if (var->bits_per_pixel > fb->bits_per_pixel || var->xres > fb->width || var->yres > fb->height) {
614 DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
615 "object %dx%d-%d > %dx%d-%d\n", var->xres, var->yres, var->bits_per_pixel,
616 fb->width, fb->height, fb->bits_per_pixel);
Dave Airlie785b93e2009-08-28 15:46:53 +1000617 return -EINVAL;
618 }
619
620 switch (var->bits_per_pixel) {
621 case 16:
622 depth = (var->green.length == 6) ? 16 : 15;
623 break;
624 case 32:
625 depth = (var->transp.length > 0) ? 32 : 24;
626 break;
627 default:
628 depth = var->bits_per_pixel;
629 break;
630 }
631
632 switch (depth) {
633 case 8:
634 var->red.offset = 0;
635 var->green.offset = 0;
636 var->blue.offset = 0;
637 var->red.length = 8;
638 var->green.length = 8;
639 var->blue.length = 8;
640 var->transp.length = 0;
641 var->transp.offset = 0;
642 break;
643 case 15:
644 var->red.offset = 10;
645 var->green.offset = 5;
646 var->blue.offset = 0;
647 var->red.length = 5;
648 var->green.length = 5;
649 var->blue.length = 5;
650 var->transp.length = 1;
651 var->transp.offset = 15;
652 break;
653 case 16:
654 var->red.offset = 11;
655 var->green.offset = 5;
656 var->blue.offset = 0;
657 var->red.length = 5;
658 var->green.length = 6;
659 var->blue.length = 5;
660 var->transp.length = 0;
661 var->transp.offset = 0;
662 break;
663 case 24:
664 var->red.offset = 16;
665 var->green.offset = 8;
666 var->blue.offset = 0;
667 var->red.length = 8;
668 var->green.length = 8;
669 var->blue.length = 8;
670 var->transp.length = 0;
671 var->transp.offset = 0;
672 break;
673 case 32:
674 var->red.offset = 16;
675 var->green.offset = 8;
676 var->blue.offset = 0;
677 var->red.length = 8;
678 var->green.length = 8;
679 var->blue.length = 8;
680 var->transp.length = 8;
681 var->transp.offset = 24;
682 break;
683 default:
684 return -EINVAL;
685 }
686 return 0;
687}
688EXPORT_SYMBOL(drm_fb_helper_check_var);
689
690/* this will let fbcon do the mode init */
691int drm_fb_helper_set_par(struct fb_info *info)
692{
693 struct drm_fb_helper *fb_helper = info->par;
694 struct drm_device *dev = fb_helper->dev;
695 struct fb_var_screeninfo *var = &info->var;
696 struct drm_crtc *crtc;
697 int ret;
698 int i;
699
Clemens Ladisch5349ef32009-11-04 09:42:52 +0100700 if (var->pixclock != 0) {
Pavel Roskin172e91f2010-02-11 14:31:32 +1000701 DRM_ERROR("PIXEL CLOCK SET\n");
Dave Airlie785b93e2009-08-28 15:46:53 +1000702 return -EINVAL;
703 }
704
Dave Airlie8be48d92010-03-30 05:34:14 +0000705 mutex_lock(&dev->mode_config.mutex);
706 for (i = 0; i < fb_helper->crtc_count; i++) {
707 crtc = fb_helper->crtc_info[i].mode_set.crtc;
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000708 ret = crtc->funcs->set_config(&fb_helper->crtc_info[i].mode_set);
709 if (ret) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000710 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000711 return ret;
Dave Airlie785b93e2009-08-28 15:46:53 +1000712 }
713 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000714 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie4abe3522010-03-30 05:34:18 +0000715
716 if (fb_helper->delayed_hotplug) {
717 fb_helper->delayed_hotplug = false;
Dave Airlieeb1f8e42010-05-07 06:42:51 +0000718 drm_fb_helper_hotplug_event(fb_helper);
Dave Airlie4abe3522010-03-30 05:34:18 +0000719 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000720 return 0;
721}
722EXPORT_SYMBOL(drm_fb_helper_set_par);
723
724int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
725 struct fb_info *info)
726{
727 struct drm_fb_helper *fb_helper = info->par;
728 struct drm_device *dev = fb_helper->dev;
729 struct drm_mode_set *modeset;
730 struct drm_crtc *crtc;
731 int ret = 0;
732 int i;
733
Dave Airlie8be48d92010-03-30 05:34:14 +0000734 mutex_lock(&dev->mode_config.mutex);
735 for (i = 0; i < fb_helper->crtc_count; i++) {
736 crtc = fb_helper->crtc_info[i].mode_set.crtc;
Dave Airlie785b93e2009-08-28 15:46:53 +1000737
738 modeset = &fb_helper->crtc_info[i].mode_set;
739
740 modeset->x = var->xoffset;
741 modeset->y = var->yoffset;
742
743 if (modeset->num_connectors) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000744 ret = crtc->funcs->set_config(modeset);
Dave Airlie785b93e2009-08-28 15:46:53 +1000745 if (!ret) {
746 info->var.xoffset = var->xoffset;
747 info->var.yoffset = var->yoffset;
748 }
749 }
750 }
Dave Airlie8be48d92010-03-30 05:34:14 +0000751 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie785b93e2009-08-28 15:46:53 +1000752 return ret;
753}
754EXPORT_SYMBOL(drm_fb_helper_pan_display);
755
Dave Airlie8be48d92010-03-30 05:34:14 +0000756int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
757 int preferred_bpp)
Dave Airlie785b93e2009-08-28 15:46:53 +1000758{
Dave Airlie785b93e2009-08-28 15:46:53 +1000759 int new_fb = 0;
760 int crtc_count = 0;
Dave Airlie4abe3522010-03-30 05:34:18 +0000761 int i;
Dave Airlie785b93e2009-08-28 15:46:53 +1000762 struct fb_info *info;
Dave Airlie38651672010-03-30 05:34:13 +0000763 struct drm_fb_helper_surface_size sizes;
Dave Airlie8be48d92010-03-30 05:34:14 +0000764 int gamma_size = 0;
Dave Airlie38651672010-03-30 05:34:13 +0000765
766 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
767 sizes.surface_depth = 24;
768 sizes.surface_bpp = 32;
769 sizes.fb_width = (unsigned)-1;
770 sizes.fb_height = (unsigned)-1;
Dave Airlie785b93e2009-08-28 15:46:53 +1000771
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000772 /* if driver picks 8 or 16 by default use that
773 for both depth/bpp */
Dave Airlie38651672010-03-30 05:34:13 +0000774 if (preferred_bpp != sizes.surface_bpp) {
775 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
Dave Airlieb8c00ac2009-10-06 13:54:01 +1000776 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000777 /* first up get a count of crtcs now in use and new min/maxes width/heights */
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000778 for (i = 0; i < fb_helper->connector_count; i++) {
779 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
Chris Wilson1794d252011-04-17 07:43:32 +0100780 struct drm_cmdline_mode *cmdline_mode;
Dave Airlie8ef86782009-09-26 06:39:00 +1000781
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000782 cmdline_mode = &fb_helper_conn->cmdline_mode;
Dave Airlied50ba252009-09-23 14:44:08 +1000783
784 if (cmdline_mode->bpp_specified) {
785 switch (cmdline_mode->bpp) {
786 case 8:
Dave Airlie38651672010-03-30 05:34:13 +0000787 sizes.surface_depth = sizes.surface_bpp = 8;
Dave Airlied50ba252009-09-23 14:44:08 +1000788 break;
789 case 15:
Dave Airlie38651672010-03-30 05:34:13 +0000790 sizes.surface_depth = 15;
791 sizes.surface_bpp = 16;
Dave Airlied50ba252009-09-23 14:44:08 +1000792 break;
793 case 16:
Dave Airlie38651672010-03-30 05:34:13 +0000794 sizes.surface_depth = sizes.surface_bpp = 16;
Dave Airlied50ba252009-09-23 14:44:08 +1000795 break;
796 case 24:
Dave Airlie38651672010-03-30 05:34:13 +0000797 sizes.surface_depth = sizes.surface_bpp = 24;
Dave Airlied50ba252009-09-23 14:44:08 +1000798 break;
799 case 32:
Dave Airlie38651672010-03-30 05:34:13 +0000800 sizes.surface_depth = 24;
801 sizes.surface_bpp = 32;
Dave Airlied50ba252009-09-23 14:44:08 +1000802 break;
803 }
804 break;
805 }
806 }
807
Dave Airlie8be48d92010-03-30 05:34:14 +0000808 crtc_count = 0;
809 for (i = 0; i < fb_helper->crtc_count; i++) {
810 struct drm_display_mode *desired_mode;
811 desired_mode = fb_helper->crtc_info[i].desired_mode;
Dave Airlie785b93e2009-08-28 15:46:53 +1000812
Dave Airlie8be48d92010-03-30 05:34:14 +0000813 if (desired_mode) {
814 if (gamma_size == 0)
815 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
816 if (desired_mode->hdisplay < sizes.fb_width)
817 sizes.fb_width = desired_mode->hdisplay;
818 if (desired_mode->vdisplay < sizes.fb_height)
819 sizes.fb_height = desired_mode->vdisplay;
820 if (desired_mode->hdisplay > sizes.surface_width)
821 sizes.surface_width = desired_mode->hdisplay;
822 if (desired_mode->vdisplay > sizes.surface_height)
823 sizes.surface_height = desired_mode->vdisplay;
Dave Airlie785b93e2009-08-28 15:46:53 +1000824 crtc_count++;
825 }
826 }
827
Dave Airlie38651672010-03-30 05:34:13 +0000828 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000829 /* hmm everyone went away - assume VGA cable just fell out
830 and will come back later. */
Dave Airlieeb1f8e42010-05-07 06:42:51 +0000831 DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
Dave Airlie19b4b442010-03-30 05:34:16 +0000832 sizes.fb_width = sizes.surface_width = 1024;
833 sizes.fb_height = sizes.surface_height = 768;
Dave Airlie785b93e2009-08-28 15:46:53 +1000834 }
835
Dave Airlie38651672010-03-30 05:34:13 +0000836 /* push down into drivers */
Dave Airlie4abe3522010-03-30 05:34:18 +0000837 new_fb = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
Dave Airlie38651672010-03-30 05:34:13 +0000838 if (new_fb < 0)
839 return new_fb;
Dave Airlie785b93e2009-08-28 15:46:53 +1000840
Dave Airlie38651672010-03-30 05:34:13 +0000841 info = fb_helper->fbdev;
Dave Airlie785b93e2009-08-28 15:46:53 +1000842
Dave Airlie8be48d92010-03-30 05:34:14 +0000843 /* set the fb pointer */
844 for (i = 0; i < fb_helper->crtc_count; i++) {
845 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
Dave Airlie785b93e2009-08-28 15:46:53 +1000846 }
847
Dave Airlie785b93e2009-08-28 15:46:53 +1000848 if (new_fb) {
Clemens Ladisch5349ef32009-11-04 09:42:52 +0100849 info->var.pixclock = 0;
Clemens Ladisch3bea21b2009-11-04 09:43:00 +0100850 if (register_framebuffer(info) < 0) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000851 return -EINVAL;
Clemens Ladisch3bea21b2009-11-04 09:43:00 +0100852 }
Dave Airlie38651672010-03-30 05:34:13 +0000853
854 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
855 info->fix.id);
856
Dave Airlie785b93e2009-08-28 15:46:53 +1000857 } else {
858 drm_fb_helper_set_par(info);
859 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000860
861 /* Switch back to kernel console on panic */
862 /* multi card linked list maybe */
863 if (list_empty(&kernel_fb_helper_list)) {
Kirill Smelkov3da1f332010-05-14 19:45:16 +0400864 printk(KERN_INFO "drm: registered panic notifier\n");
Dave Airlie785b93e2009-08-28 15:46:53 +1000865 atomic_notifier_chain_register(&panic_notifier_list,
866 &paniced);
867 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
868 }
Dave Airlie38651672010-03-30 05:34:13 +0000869 if (new_fb)
870 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
871
Dave Airlie785b93e2009-08-28 15:46:53 +1000872 return 0;
873}
874EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
875
Dave Airlie3632ef82011-01-15 09:27:00 +1000876void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
877 uint32_t depth)
878{
879 info->fix.type = FB_TYPE_PACKED_PIXELS;
880 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
881 FB_VISUAL_TRUECOLOR;
882 info->fix.mmio_start = 0;
883 info->fix.mmio_len = 0;
884 info->fix.type_aux = 0;
885 info->fix.xpanstep = 1; /* doing it in hw */
886 info->fix.ypanstep = 1; /* doing it in hw */
887 info->fix.ywrapstep = 0;
888 info->fix.accel = FB_ACCEL_NONE;
889 info->fix.type_aux = 0;
890
891 info->fix.line_length = pitch;
892 return;
893}
894EXPORT_SYMBOL(drm_fb_helper_fill_fix);
895
Dave Airlie38651672010-03-30 05:34:13 +0000896void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
Dave Airlie785b93e2009-08-28 15:46:53 +1000897 uint32_t fb_width, uint32_t fb_height)
898{
Dave Airlie38651672010-03-30 05:34:13 +0000899 struct drm_framebuffer *fb = fb_helper->fb;
900 info->pseudo_palette = fb_helper->pseudo_palette;
Dave Airlie785b93e2009-08-28 15:46:53 +1000901 info->var.xres_virtual = fb->width;
902 info->var.yres_virtual = fb->height;
903 info->var.bits_per_pixel = fb->bits_per_pixel;
James Simmons57084d02010-12-20 19:10:39 +0000904 info->var.accel_flags = FB_ACCELF_TEXT;
Dave Airlie785b93e2009-08-28 15:46:53 +1000905 info->var.xoffset = 0;
906 info->var.yoffset = 0;
907 info->var.activate = FB_ACTIVATE_NOW;
908 info->var.height = -1;
909 info->var.width = -1;
910
911 switch (fb->depth) {
912 case 8:
913 info->var.red.offset = 0;
914 info->var.green.offset = 0;
915 info->var.blue.offset = 0;
916 info->var.red.length = 8; /* 8bit DAC */
917 info->var.green.length = 8;
918 info->var.blue.length = 8;
919 info->var.transp.offset = 0;
920 info->var.transp.length = 0;
921 break;
922 case 15:
923 info->var.red.offset = 10;
924 info->var.green.offset = 5;
925 info->var.blue.offset = 0;
926 info->var.red.length = 5;
927 info->var.green.length = 5;
928 info->var.blue.length = 5;
929 info->var.transp.offset = 15;
930 info->var.transp.length = 1;
931 break;
932 case 16:
933 info->var.red.offset = 11;
934 info->var.green.offset = 5;
935 info->var.blue.offset = 0;
936 info->var.red.length = 5;
937 info->var.green.length = 6;
938 info->var.blue.length = 5;
939 info->var.transp.offset = 0;
940 break;
941 case 24:
942 info->var.red.offset = 16;
943 info->var.green.offset = 8;
944 info->var.blue.offset = 0;
945 info->var.red.length = 8;
946 info->var.green.length = 8;
947 info->var.blue.length = 8;
948 info->var.transp.offset = 0;
949 info->var.transp.length = 0;
950 break;
951 case 32:
952 info->var.red.offset = 16;
953 info->var.green.offset = 8;
954 info->var.blue.offset = 0;
955 info->var.red.length = 8;
956 info->var.green.length = 8;
957 info->var.blue.length = 8;
958 info->var.transp.offset = 24;
959 info->var.transp.length = 8;
960 break;
961 default:
962 break;
963 }
964
965 info->var.xres = fb_width;
966 info->var.yres = fb_height;
967}
968EXPORT_SYMBOL(drm_fb_helper_fill_var);
Dave Airlie38651672010-03-30 05:34:13 +0000969
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000970static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
971 uint32_t maxX,
972 uint32_t maxY)
Dave Airlie38651672010-03-30 05:34:13 +0000973{
974 struct drm_connector *connector;
975 int count = 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000976 int i;
Dave Airlie38651672010-03-30 05:34:13 +0000977
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000978 for (i = 0; i < fb_helper->connector_count; i++) {
979 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +0000980 count += connector->funcs->fill_modes(connector, maxX, maxY);
981 }
982
983 return count;
984}
985
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000986static struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
Dave Airlie38651672010-03-30 05:34:13 +0000987{
988 struct drm_display_mode *mode;
989
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000990 list_for_each_entry(mode, &fb_connector->connector->modes, head) {
Dave Airlie38651672010-03-30 05:34:13 +0000991 if (drm_mode_width(mode) > width ||
992 drm_mode_height(mode) > height)
993 continue;
994 if (mode->type & DRM_MODE_TYPE_PREFERRED)
995 return mode;
996 }
997 return NULL;
998}
999
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001000static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
Dave Airlie38651672010-03-30 05:34:13 +00001001{
Chris Wilson1794d252011-04-17 07:43:32 +01001002 struct drm_cmdline_mode *cmdline_mode;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001003 cmdline_mode = &fb_connector->cmdline_mode;
Dave Airlie38651672010-03-30 05:34:13 +00001004 return cmdline_mode->specified;
1005}
1006
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001007static struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
1008 int width, int height)
Dave Airlie38651672010-03-30 05:34:13 +00001009{
Chris Wilson1794d252011-04-17 07:43:32 +01001010 struct drm_cmdline_mode *cmdline_mode;
Dave Airlie38651672010-03-30 05:34:13 +00001011 struct drm_display_mode *mode = NULL;
1012
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001013 cmdline_mode = &fb_helper_conn->cmdline_mode;
Dave Airlie38651672010-03-30 05:34:13 +00001014 if (cmdline_mode->specified == false)
1015 return mode;
1016
1017 /* attempt to find a matching mode in the list of modes
1018 * we have gotten so far, if not add a CVT mode that conforms
1019 */
1020 if (cmdline_mode->rb || cmdline_mode->margins)
1021 goto create_mode;
1022
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001023 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
Dave Airlie38651672010-03-30 05:34:13 +00001024 /* check width/height */
1025 if (mode->hdisplay != cmdline_mode->xres ||
1026 mode->vdisplay != cmdline_mode->yres)
1027 continue;
1028
1029 if (cmdline_mode->refresh_specified) {
1030 if (mode->vrefresh != cmdline_mode->refresh)
1031 continue;
1032 }
1033
1034 if (cmdline_mode->interlace) {
1035 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
1036 continue;
1037 }
1038 return mode;
1039 }
1040
1041create_mode:
Chris Wilson1794d252011-04-17 07:43:32 +01001042 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
1043 cmdline_mode);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001044 list_add(&mode->head, &fb_helper_conn->connector->modes);
Dave Airlie38651672010-03-30 05:34:13 +00001045 return mode;
1046}
1047
1048static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
1049{
1050 bool enable;
1051
1052 if (strict) {
1053 enable = connector->status == connector_status_connected;
1054 } else {
1055 enable = connector->status != connector_status_disconnected;
1056 }
1057 return enable;
1058}
1059
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001060static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1061 bool *enabled)
Dave Airlie38651672010-03-30 05:34:13 +00001062{
1063 bool any_enabled = false;
1064 struct drm_connector *connector;
1065 int i = 0;
1066
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001067 for (i = 0; i < fb_helper->connector_count; i++) {
1068 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001069 enabled[i] = drm_connector_enabled(connector, true);
1070 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1071 enabled[i] ? "yes" : "no");
1072 any_enabled |= enabled[i];
Dave Airlie38651672010-03-30 05:34:13 +00001073 }
1074
1075 if (any_enabled)
1076 return;
1077
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001078 for (i = 0; i < fb_helper->connector_count; i++) {
1079 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001080 enabled[i] = drm_connector_enabled(connector, false);
Dave Airlie38651672010-03-30 05:34:13 +00001081 }
1082}
1083
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001084static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1085 struct drm_display_mode **modes,
1086 bool *enabled, int width, int height)
1087{
1088 int count, i, j;
1089 bool can_clone = false;
1090 struct drm_fb_helper_connector *fb_helper_conn;
1091 struct drm_display_mode *dmt_mode, *mode;
1092
1093 /* only contemplate cloning in the single crtc case */
1094 if (fb_helper->crtc_count > 1)
1095 return false;
1096
1097 count = 0;
1098 for (i = 0; i < fb_helper->connector_count; i++) {
1099 if (enabled[i])
1100 count++;
1101 }
1102
1103 /* only contemplate cloning if more than one connector is enabled */
1104 if (count <= 1)
1105 return false;
1106
1107 /* check the command line or if nothing common pick 1024x768 */
1108 can_clone = true;
1109 for (i = 0; i < fb_helper->connector_count; i++) {
1110 if (!enabled[i])
1111 continue;
1112 fb_helper_conn = fb_helper->connector_info[i];
1113 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1114 if (!modes[i]) {
1115 can_clone = false;
1116 break;
1117 }
1118 for (j = 0; j < i; j++) {
1119 if (!enabled[j])
1120 continue;
1121 if (!drm_mode_equal(modes[j], modes[i]))
1122 can_clone = false;
1123 }
1124 }
1125
1126 if (can_clone) {
1127 DRM_DEBUG_KMS("can clone using command line\n");
1128 return true;
1129 }
1130
1131 /* try and find a 1024x768 mode on each connector */
1132 can_clone = true;
1133 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60);
1134
1135 for (i = 0; i < fb_helper->connector_count; i++) {
1136
1137 if (!enabled[i])
1138 continue;
1139
1140 fb_helper_conn = fb_helper->connector_info[i];
1141 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1142 if (drm_mode_equal(mode, dmt_mode))
1143 modes[i] = mode;
1144 }
1145 if (!modes[i])
1146 can_clone = false;
1147 }
1148
1149 if (can_clone) {
1150 DRM_DEBUG_KMS("can clone using 1024x768\n");
1151 return true;
1152 }
1153 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1154 return false;
1155}
1156
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001157static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
Dave Airlie38651672010-03-30 05:34:13 +00001158 struct drm_display_mode **modes,
1159 bool *enabled, int width, int height)
1160{
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001161 struct drm_fb_helper_connector *fb_helper_conn;
1162 int i;
Dave Airlie38651672010-03-30 05:34:13 +00001163
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001164 for (i = 0; i < fb_helper->connector_count; i++) {
1165 fb_helper_conn = fb_helper->connector_info[i];
Dave Airlie38651672010-03-30 05:34:13 +00001166
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001167 if (enabled[i] == false)
Dave Airlie38651672010-03-30 05:34:13 +00001168 continue;
Dave Airlie38651672010-03-30 05:34:13 +00001169
1170 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001171 fb_helper_conn->connector->base.id);
Dave Airlie38651672010-03-30 05:34:13 +00001172
1173 /* got for command line mode first */
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001174 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00001175 if (!modes[i]) {
1176 DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001177 fb_helper_conn->connector->base.id);
1178 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00001179 }
1180 /* No preferred modes, pick one off the list */
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001181 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1182 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
Dave Airlie38651672010-03-30 05:34:13 +00001183 break;
1184 }
1185 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1186 "none");
Dave Airlie38651672010-03-30 05:34:13 +00001187 }
1188 return true;
1189}
1190
Dave Airlie8be48d92010-03-30 05:34:14 +00001191static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1192 struct drm_fb_helper_crtc **best_crtcs,
Dave Airlie38651672010-03-30 05:34:13 +00001193 struct drm_display_mode **modes,
1194 int n, int width, int height)
1195{
1196 int c, o;
Dave Airlie8be48d92010-03-30 05:34:14 +00001197 struct drm_device *dev = fb_helper->dev;
Dave Airlie38651672010-03-30 05:34:13 +00001198 struct drm_connector *connector;
1199 struct drm_connector_helper_funcs *connector_funcs;
1200 struct drm_encoder *encoder;
Dave Airlie8be48d92010-03-30 05:34:14 +00001201 struct drm_fb_helper_crtc *best_crtc;
Dave Airlie38651672010-03-30 05:34:13 +00001202 int my_score, best_score, score;
Dave Airlie8be48d92010-03-30 05:34:14 +00001203 struct drm_fb_helper_crtc **crtcs, *crtc;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001204 struct drm_fb_helper_connector *fb_helper_conn;
Dave Airlie38651672010-03-30 05:34:13 +00001205
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001206 if (n == fb_helper->connector_count)
Dave Airlie38651672010-03-30 05:34:13 +00001207 return 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001208
1209 fb_helper_conn = fb_helper->connector_info[n];
1210 connector = fb_helper_conn->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001211
1212 best_crtcs[n] = NULL;
1213 best_crtc = NULL;
Dave Airlie8be48d92010-03-30 05:34:14 +00001214 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00001215 if (modes[n] == NULL)
1216 return best_score;
1217
Dave Airlie8be48d92010-03-30 05:34:14 +00001218 crtcs = kzalloc(dev->mode_config.num_connector *
1219 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
Dave Airlie38651672010-03-30 05:34:13 +00001220 if (!crtcs)
1221 return best_score;
1222
1223 my_score = 1;
1224 if (connector->status == connector_status_connected)
1225 my_score++;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001226 if (drm_has_cmdline_mode(fb_helper_conn))
Dave Airlie38651672010-03-30 05:34:13 +00001227 my_score++;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001228 if (drm_has_preferred_mode(fb_helper_conn, width, height))
Dave Airlie38651672010-03-30 05:34:13 +00001229 my_score++;
1230
1231 connector_funcs = connector->helper_private;
1232 encoder = connector_funcs->best_encoder(connector);
1233 if (!encoder)
1234 goto out;
1235
Dave Airlie38651672010-03-30 05:34:13 +00001236 /* select a crtc for this connector and then attempt to configure
1237 remaining connectors */
Dave Airlie8be48d92010-03-30 05:34:14 +00001238 for (c = 0; c < fb_helper->crtc_count; c++) {
1239 crtc = &fb_helper->crtc_info[c];
Dave Airlie38651672010-03-30 05:34:13 +00001240
1241 if ((encoder->possible_crtcs & (1 << c)) == 0) {
Dave Airlie38651672010-03-30 05:34:13 +00001242 continue;
1243 }
1244
1245 for (o = 0; o < n; o++)
1246 if (best_crtcs[o] == crtc)
1247 break;
1248
1249 if (o < n) {
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001250 /* ignore cloning unless only a single crtc */
1251 if (fb_helper->crtc_count > 1)
1252 continue;
1253
1254 if (!drm_mode_equal(modes[o], modes[n]))
1255 continue;
Dave Airlie38651672010-03-30 05:34:13 +00001256 }
1257
1258 crtcs[n] = crtc;
Dave Airlie8be48d92010-03-30 05:34:14 +00001259 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
1260 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
Dave Airlie38651672010-03-30 05:34:13 +00001261 width, height);
1262 if (score > best_score) {
1263 best_crtc = crtc;
1264 best_score = score;
1265 memcpy(best_crtcs, crtcs,
1266 dev->mode_config.num_connector *
Dave Airlie8be48d92010-03-30 05:34:14 +00001267 sizeof(struct drm_fb_helper_crtc *));
Dave Airlie38651672010-03-30 05:34:13 +00001268 }
Dave Airlie38651672010-03-30 05:34:13 +00001269 }
1270out:
1271 kfree(crtcs);
1272 return best_score;
1273}
1274
Dave Airlie8be48d92010-03-30 05:34:14 +00001275static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
Dave Airlie38651672010-03-30 05:34:13 +00001276{
Dave Airlie8be48d92010-03-30 05:34:14 +00001277 struct drm_device *dev = fb_helper->dev;
1278 struct drm_fb_helper_crtc **crtcs;
Dave Airlie38651672010-03-30 05:34:13 +00001279 struct drm_display_mode **modes;
1280 struct drm_encoder *encoder;
Dave Airlie8be48d92010-03-30 05:34:14 +00001281 struct drm_mode_set *modeset;
Dave Airlie38651672010-03-30 05:34:13 +00001282 bool *enabled;
1283 int width, height;
1284 int i, ret;
1285
1286 DRM_DEBUG_KMS("\n");
1287
1288 width = dev->mode_config.max_width;
1289 height = dev->mode_config.max_height;
1290
1291 /* clean out all the encoder/crtc combos */
1292 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1293 encoder->crtc = NULL;
1294 }
1295
1296 crtcs = kcalloc(dev->mode_config.num_connector,
Dave Airlie8be48d92010-03-30 05:34:14 +00001297 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
Dave Airlie38651672010-03-30 05:34:13 +00001298 modes = kcalloc(dev->mode_config.num_connector,
1299 sizeof(struct drm_display_mode *), GFP_KERNEL);
1300 enabled = kcalloc(dev->mode_config.num_connector,
1301 sizeof(bool), GFP_KERNEL);
1302
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001303 drm_enable_connectors(fb_helper, enabled);
Dave Airlie38651672010-03-30 05:34:13 +00001304
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001305 ret = drm_target_cloned(fb_helper, modes, enabled, width, height);
1306 if (!ret) {
1307 ret = drm_target_preferred(fb_helper, modes, enabled, width, height);
1308 if (!ret)
1309 DRM_ERROR("Unable to find initial modes\n");
1310 }
Dave Airlie38651672010-03-30 05:34:13 +00001311
1312 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height);
1313
Dave Airlie8be48d92010-03-30 05:34:14 +00001314 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
1315
1316 /* need to set the modesets up here for use later */
1317 /* fill out the connector<->crtc mappings into the modesets */
1318 for (i = 0; i < fb_helper->crtc_count; i++) {
1319 modeset = &fb_helper->crtc_info[i].mode_set;
1320 modeset->num_connectors = 0;
1321 }
Dave Airlie38651672010-03-30 05:34:13 +00001322
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001323 for (i = 0; i < fb_helper->connector_count; i++) {
Dave Airlie38651672010-03-30 05:34:13 +00001324 struct drm_display_mode *mode = modes[i];
Dave Airlie8be48d92010-03-30 05:34:14 +00001325 struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
1326 modeset = &fb_crtc->mode_set;
Dave Airlie38651672010-03-30 05:34:13 +00001327
Dave Airlie8be48d92010-03-30 05:34:14 +00001328 if (mode && fb_crtc) {
Dave Airlie38651672010-03-30 05:34:13 +00001329 DRM_DEBUG_KMS("desired mode %s set on crtc %d\n",
Dave Airlie8be48d92010-03-30 05:34:14 +00001330 mode->name, fb_crtc->mode_set.crtc->base.id);
1331 fb_crtc->desired_mode = mode;
1332 if (modeset->mode)
1333 drm_mode_destroy(dev, modeset->mode);
1334 modeset->mode = drm_mode_duplicate(dev,
1335 fb_crtc->desired_mode);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001336 modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001337 }
Dave Airlie38651672010-03-30 05:34:13 +00001338 }
1339
1340 kfree(crtcs);
1341 kfree(modes);
1342 kfree(enabled);
1343}
1344
1345/**
1346 * drm_helper_initial_config - setup a sane initial connector configuration
1347 * @dev: DRM device
1348 *
1349 * LOCKING:
1350 * Called at init time, must take mode config lock.
1351 *
1352 * Scan the CRTCs and connectors and try to put together an initial setup.
1353 * At the moment, this is a cloned configuration across all heads with
1354 * a new framebuffer object as the backing store.
1355 *
1356 * RETURNS:
1357 * Zero if everything went ok, nonzero otherwise.
1358 */
Dave Airlie4abe3522010-03-30 05:34:18 +00001359bool drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
Dave Airlie38651672010-03-30 05:34:13 +00001360{
Dave Airlie8be48d92010-03-30 05:34:14 +00001361 struct drm_device *dev = fb_helper->dev;
Dave Airlie38651672010-03-30 05:34:13 +00001362 int count = 0;
1363
1364 /* disable all the possible outputs/crtcs before entering KMS mode */
Dave Airlie8be48d92010-03-30 05:34:14 +00001365 drm_helper_disable_unused_functions(fb_helper->dev);
Dave Airlie38651672010-03-30 05:34:13 +00001366
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001367 drm_fb_helper_parse_command_line(fb_helper);
Dave Airlie38651672010-03-30 05:34:13 +00001368
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001369 count = drm_fb_helper_probe_connector_modes(fb_helper,
1370 dev->mode_config.max_width,
1371 dev->mode_config.max_height);
Dave Airlie38651672010-03-30 05:34:13 +00001372 /*
1373 * we shouldn't end up with no modes here.
1374 */
Dave Airlie5c4426a2010-03-30 05:34:17 +00001375 if (count == 0) {
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001376 printk(KERN_INFO "No connectors reported connected with modes\n");
Dave Airlie5c4426a2010-03-30 05:34:17 +00001377 }
Dave Airlie8be48d92010-03-30 05:34:14 +00001378 drm_setup_crtcs(fb_helper);
Dave Airlie38651672010-03-30 05:34:13 +00001379
Dave Airlie4abe3522010-03-30 05:34:18 +00001380 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
Dave Airlie38651672010-03-30 05:34:13 +00001381}
Dave Airlie8be48d92010-03-30 05:34:14 +00001382EXPORT_SYMBOL(drm_fb_helper_initial_config);
Dave Airlie38651672010-03-30 05:34:13 +00001383
Chris Wilson73943712011-04-22 11:03:57 +01001384/**
1385 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
1386 * probing all the outputs attached to the fb.
1387 * @fb_helper: the drm_fb_helper
1388 *
1389 * LOCKING:
1390 * Called at runtime, must take mode config lock.
1391 *
1392 * Scan the connectors attached to the fb_helper and try to put together a
1393 * setup after *notification of a change in output configuration.
1394 *
1395 * RETURNS:
1396 * 0 on success and a non-zero error code otherwise.
1397 */
1398int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
Dave Airlie38651672010-03-30 05:34:13 +00001399{
Chris Wilson73943712011-04-22 11:03:57 +01001400 struct drm_device *dev = fb_helper->dev;
Dave Airlie5c4426a2010-03-30 05:34:17 +00001401 int count = 0;
Dave Airlie4abe3522010-03-30 05:34:18 +00001402 u32 max_width, max_height, bpp_sel;
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001403 bool bound = false, crtcs_bound = false;
1404 struct drm_crtc *crtc;
Dave Airlie4abe3522010-03-30 05:34:18 +00001405
1406 if (!fb_helper->fb)
Chris Wilson73943712011-04-22 11:03:57 +01001407 return 0;
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001408
Chris Wilson73943712011-04-22 11:03:57 +01001409 mutex_lock(&dev->mode_config.mutex);
1410 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001411 if (crtc->fb)
1412 crtcs_bound = true;
1413 if (crtc->fb == fb_helper->fb)
1414 bound = true;
1415 }
1416
1417 if (!bound && crtcs_bound) {
1418 fb_helper->delayed_hotplug = true;
Chris Wilson73943712011-04-22 11:03:57 +01001419 mutex_unlock(&dev->mode_config.mutex);
1420 return 0;
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001421 }
Dave Airlie38651672010-03-30 05:34:13 +00001422 DRM_DEBUG_KMS("\n");
1423
Dave Airlie4abe3522010-03-30 05:34:18 +00001424 max_width = fb_helper->fb->width;
1425 max_height = fb_helper->fb->height;
1426 bpp_sel = fb_helper->fb->bits_per_pixel;
1427
Dave Airlie5c4426a2010-03-30 05:34:17 +00001428 count = drm_fb_helper_probe_connector_modes(fb_helper, max_width,
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001429 max_height);
Dave Airlie8be48d92010-03-30 05:34:14 +00001430 drm_setup_crtcs(fb_helper);
Chris Wilson73943712011-04-22 11:03:57 +01001431 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie38651672010-03-30 05:34:13 +00001432
Dave Airlie4abe3522010-03-30 05:34:18 +00001433 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
Dave Airlie38651672010-03-30 05:34:13 +00001434}
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001435EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
Dave Airlie5c4426a2010-03-30 05:34:17 +00001436
David Rientjes6a108a12011-01-20 14:44:16 -08001437/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
David Fries3ce05162010-12-12 12:39:22 -06001438 * but the module doesn't depend on any fb console symbols. At least
1439 * attempt to load fbcon to avoid leaving the system without a usable console.
1440 */
David Rientjes6a108a12011-01-20 14:44:16 -08001441#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
David Fries3ce05162010-12-12 12:39:22 -06001442static int __init drm_fb_helper_modinit(void)
1443{
1444 const char *name = "fbcon";
1445 struct module *fbcon;
1446
1447 mutex_lock(&module_mutex);
1448 fbcon = find_module(name);
1449 mutex_unlock(&module_mutex);
1450
1451 if (!fbcon)
1452 request_module_nowait(name);
1453 return 0;
1454}
1455
1456module_init(drm_fb_helper_modinit);
1457#endif