← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/staging/gma500/mrst_lvds.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/gma500/mrst_lvds.c
24
24
#include <drm/drmP.h>
25
25
#include <asm/mrst.h>
26
26
 
27
 
#include "psb_intel_bios.h"
 
27
#include "intel_bios.h"
28
28
#include "psb_drv.h"
29
29
#include "psb_intel_drv.h"
30
30
#include "psb_intel_reg.h"
31
 
#include "psb_powermgmt.h"
 
31
#include "power.h"
32
32
#include <linux/pm_runtime.h>
33
33
 
34
34
/* The max/min PWM frequency in BPCR[31:17] - */
46
46
                                struct psb_intel_output *output, bool on)
47
47
{
48
48
        u32 pp_status;
49
 
        DRM_DRIVER_PRIVATE_T *dev_priv = dev->dev_private;
50
 
        PSB_DEBUG_ENTRY("\n");
 
49
        struct drm_psb_private *dev_priv = dev->dev_private;
51
50
 
52
51
        if (!gma_power_begin(dev, true))
53
52
                return;
59
58
                        pp_status = REG_READ(PP_STATUS);
60
59
                } while ((pp_status & (PP_ON | PP_READY)) == PP_READY);
61
60
                dev_priv->is_lvds_on = true;
 
61
                if (dev_priv->ops->lvds_bl_power)
 
62
                        dev_priv->ops->lvds_bl_power(dev, true);
62
63
        } else {
 
64
                if (dev_priv->ops->lvds_bl_power)
 
65
                        dev_priv->ops->lvds_bl_power(dev, false);
63
66
                REG_WRITE(PP_CONTROL, REG_READ(PP_CONTROL) &
64
67
                          ~POWER_TARGET_ON);
65
68
                do {
68
71
                dev_priv->is_lvds_on = false;
69
72
                pm_request_idle(&dev->pdev->dev);
70
73
        }
71
 
 
72
74
        gma_power_end(dev);
73
75
}
74
76
 
77
79
        struct drm_device *dev = encoder->dev;
78
80
        struct psb_intel_output *output = enc_to_psb_intel_output(encoder);
79
81
 
80
 
        PSB_DEBUG_ENTRY("\n");
81
 
 
82
82
        if (mode == DRM_MODE_DPMS_ON)
83
83
                mrst_lvds_set_power(dev, output, true);
84
84
        else
94
94
        struct psb_intel_mode_device *mode_dev =
95
95
                                enc_to_psb_intel_output(encoder)->mode_dev;
96
96
        struct drm_device *dev = encoder->dev;
 
97
        struct drm_psb_private *dev_priv = dev->dev_private;
97
98
        u32 lvds_port;
98
99
        uint64_t v = DRM_MODE_SCALE_FULLSCREEN;
99
100
 
100
 
        PSB_DEBUG_ENTRY("\n");
101
 
 
102
101
        if (!gma_power_begin(dev, true))
103
102
                return;
104
103
 
112
111
                    LVDS_PORT_EN |
113
112
                    LVDS_BORDER_EN;
114
113
 
115
 
        if (mode_dev->panel_wants_dither)
 
114
        /* If the firmware says dither on Moorestown, or the BIOS does
 
115
           on Oaktrail then enable dithering */
 
116
        if (mode_dev->panel_wants_dither || dev_priv->lvds_dither)
116
117
                lvds_port |= MRST_PANEL_8TO6_DITHER_ENABLE;
117
118
 
118
119
        REG_WRITE(LVDS, lvds_port);
146
147
        gma_power_end(dev);
147
148
}
148
149
 
 
150
static void mrst_lvds_prepare(struct drm_encoder *encoder)
 
151
{
 
152
        struct drm_device *dev = encoder->dev;
 
153
        struct psb_intel_output *output = enc_to_psb_intel_output(encoder);
 
154
        struct psb_intel_mode_device *mode_dev = output->mode_dev;
 
155
 
 
156
        if (!gma_power_begin(dev, true))
 
157
                return;
 
158
 
 
159
        mode_dev->saveBLC_PWM_CTL = REG_READ(BLC_PWM_CTL);
 
160
        mode_dev->backlight_duty_cycle = (mode_dev->saveBLC_PWM_CTL &
 
161
                                          BACKLIGHT_DUTY_CYCLE_MASK);
 
162
        mrst_lvds_set_power(dev, output, false);
 
163
        gma_power_end(dev);
 
164
}
 
165
 
 
166
static u32 mrst_lvds_get_max_backlight(struct drm_device *dev)
 
167
{
 
168
        struct drm_psb_private *dev_priv = dev->dev_private;
 
169
        u32 ret;
 
170
 
 
171
        if (gma_power_begin(dev, false)) {
 
172
                ret = ((REG_READ(BLC_PWM_CTL) &
 
173
                          BACKLIGHT_MODULATION_FREQ_MASK) >>
 
174
                          BACKLIGHT_MODULATION_FREQ_SHIFT) * 2;
 
175
 
 
176
                gma_power_end(dev);
 
177
        } else
 
178
                ret = ((dev_priv->saveBLC_PWM_CTL &
 
179
                          BACKLIGHT_MODULATION_FREQ_MASK) >>
 
180
                          BACKLIGHT_MODULATION_FREQ_SHIFT) * 2;
 
181
 
 
182
        return ret;
 
183
}
 
184
 
 
185
static void mrst_lvds_commit(struct drm_encoder *encoder)
 
186
{
 
187
        struct drm_device *dev = encoder->dev;
 
188
        struct psb_intel_output *output = enc_to_psb_intel_output(encoder);
 
189
        struct psb_intel_mode_device *mode_dev = output->mode_dev;
 
190
 
 
191
        if (mode_dev->backlight_duty_cycle == 0)
 
192
                mode_dev->backlight_duty_cycle =
 
193
                                        mrst_lvds_get_max_backlight(dev);
 
194
        mrst_lvds_set_power(dev, output, true);
 
195
}
149
196
 
150
197
static const struct drm_encoder_helper_funcs mrst_lvds_helper_funcs = {
151
198
        .dpms = mrst_lvds_dpms,
152
199
        .mode_fixup = psb_intel_lvds_mode_fixup,
153
 
        .prepare = psb_intel_lvds_prepare,
 
200
        .prepare = mrst_lvds_prepare,
154
201
        .mode_set = mrst_lvds_mode_set,
155
 
        .commit = psb_intel_lvds_commit,
 
202
        .commit = mrst_lvds_commit,
156
203
};
157
204
 
158
205
static struct drm_display_mode lvds_configuration_modes[] = {
252
299
        struct i2c_adapter *i2c_adap;
253
300
        struct drm_display_mode *scan;  /* *modes, *bios_mode; */
254
301
 
255
 
        PSB_DEBUG_ENTRY("\n");
256
 
 
257
302
        psb_intel_output = kzalloc(sizeof(struct psb_intel_output), GFP_KERNEL);
258
303
        if (!psb_intel_output)
259
304
                return;
302
347
         *    if closed, act like it's not there for now
303
348
         */
304
349
 
305
 
         /* This ifdef can go once the cpu ident stuff is cleaned up in arch */
306
 
#if defined(CONFIG_X86_MRST)
307
 
        if (mrst_identify_cpu())
308
 
                i2c_adap = i2c_get_adapter(2);
309
 
        else    /* Oaktrail uses I2C 1 */
310
 
#endif        
311
 
                i2c_adap = i2c_get_adapter(1);
 
350
        i2c_adap = i2c_get_adapter(dev_priv->ops->i2c_bus);
312
351
 
313
352
        if (i2c_adap == NULL)
314
 
                printk(KERN_ALERT "No ddc adapter available!\n");
 
353
                dev_err(dev->dev, "No ddc adapter available!\n");
315
354
        /*
316
355
         * Attempt to get the fixed panel mode from DDC.  Assume that the
317
356
         * preferred mode is the right one.
333
372
                        }
334
373
                }
335
374
        }
336
 
 
337
375
        /*
338
376
         * If we didn't get EDID, try geting panel timing
339
377
         * from configuration data
341
379
        mode_dev->panel_fixed_mode = mrst_lvds_get_configuration_mode(dev);
342
380
 
343
381
        if (mode_dev->panel_fixed_mode) {
344
 
                mode_dev->panel_fixed_mode->type |=
345
 
                    DRM_MODE_TYPE_PREFERRED;
 
382
                mode_dev->panel_fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
346
383
                goto out;       /* FIXME: check for quirks */
347
384
        }
348
385
 
349
386
        /* If we still don't have a mode after all that, give up. */
350
387
        if (!mode_dev->panel_fixed_mode) {
351
 
                DRM_DEBUG
352
 
                    ("Found no modes on the lvds, ignoring the LVDS\n");
 
388
                dev_err(dev->dev, "Found no modes on the lvds, ignoring the LVDS\n");
353
389
                goto failed_find;
354
390
        }
355
391
 
358
394
        return;
359
395
 
360
396
failed_find:
361
 
        DRM_DEBUG("No LVDS modes found, disabling.\n");
 
397
        dev_dbg(dev->dev, "No LVDS modes found, disabling.\n");
362
398
        if (psb_intel_output->ddc_bus)
363
399
                psb_intel_i2c_destroy(psb_intel_output->ddc_bus);
364
400