← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/gpu/drm/radeon/radeon_connectors.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/gpu/drm/radeon/radeon_connectors.c
430
430
        return 0;
431
431
}
432
432
 
433
 
/*
434
 
 * Some integrated ATI Radeon chipset implementations (e. g.
435
 
 * Asus M2A-VM HDMI) may indicate the availability of a DDC,
436
 
 * even when there's no monitor connected. For these connectors
437
 
 * following DDC probe extension will be applied: check also for the
438
 
 * availability of EDID with at least a correct EDID header. Only then,
439
 
 * DDC is assumed to be available. This prevents drm_get_edid() and
440
 
 * drm_edid_block_valid() from periodically dumping data and kernel
441
 
 * errors into the logs and onto the terminal.
442
 
 */
443
 
static bool radeon_connector_needs_extended_probe(struct radeon_device *dev,
444
 
                                     uint32_t supported_device,
445
 
                                     int connector_type)
446
 
{
447
 
        /* Asus M2A-VM HDMI board sends data to i2c bus even,
448
 
         * if HDMI add-on card is not plugged in or HDMI is disabled in
449
 
         * BIOS. Valid DDC can only be assumed, if also a valid EDID header
450
 
         * can be retrieved via i2c bus during DDC probe */
451
 
        if ((dev->pdev->device == 0x791e) &&
452
 
            (dev->pdev->subsystem_vendor == 0x1043) &&
453
 
            (dev->pdev->subsystem_device == 0x826d)) {
454
 
                if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
455
 
                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
456
 
                        return true;
457
 
        }
458
 
        /* ECS A740GM-M with ATI RADEON 2100 sends data to i2c bus
459
 
         * for a DVI connector that is not implemented */
460
 
        if ((dev->pdev->device == 0x796e) &&
461
 
            (dev->pdev->subsystem_vendor == 0x1019) &&
462
 
            (dev->pdev->subsystem_device == 0x2615)) {
463
 
                if ((connector_type == DRM_MODE_CONNECTOR_DVID) &&
464
 
                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
465
 
                        return true;
466
 
        }
467
 
        /* TOSHIBA Satellite L300D with ATI Mobility Radeon x1100
468
 
         * (RS690M) sends data to i2c bus for a HDMI connector that
469
 
         * is not implemented */
470
 
        if ((dev->pdev->device == 0x791f) &&
471
 
            (dev->pdev->subsystem_vendor == 0x1179) &&
472
 
            (dev->pdev->subsystem_device == 0xff68)) {
473
 
                if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
474
 
                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
475
 
                        return true;
476
 
        }
477
 
 
478
 
        /* Default: no EDID header probe required for DDC probing */
479
 
        return false;
480
 
}
481
 
 
482
433
static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
483
434
                                          struct drm_connector *connector)
484
435
{
485
436
        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
486
437
        struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 
438
        struct drm_display_mode *t, *mode;
 
439
 
 
440
        /* If the EDID preferred mode doesn't match the native mode, use it */
 
441
        list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
 
442
                if (mode->type & DRM_MODE_TYPE_PREFERRED) {
 
443
                        if (mode->hdisplay != native_mode->hdisplay ||
 
444
                            mode->vdisplay != native_mode->vdisplay)
 
445
                                memcpy(native_mode, mode, sizeof(*mode));
 
446
                }
 
447
        }
487
448
 
488
449
        /* Try to get native mode details from EDID if necessary */
489
450
        if (!native_mode->clock) {
490
 
                struct drm_display_mode *t, *mode;
491
 
 
492
451
                list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
493
452
                        if (mode->hdisplay == native_mode->hdisplay &&
494
453
                            mode->vdisplay == native_mode->vdisplay) {
499
458
                        }
500
459
                }
501
460
        }
 
461
 
502
462
        if (!native_mode->clock) {
503
463
                DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
504
464
                radeon_encoder->rmx_type = RMX_OFF;
710
670
                ret = connector_status_disconnected;
711
671
 
712
672
        if (radeon_connector->ddc_bus)
713
 
                dret = radeon_ddc_probe(radeon_connector,
714
 
                                        radeon_connector->requires_extended_probe);
 
673
                dret = radeon_ddc_probe(radeon_connector);
715
674
        if (dret) {
716
675
                radeon_connector->detected_by_load = false;
717
676
                if (radeon_connector->edid) {
893
852
        bool dret = false;
894
853
 
895
854
        if (radeon_connector->ddc_bus)
896
 
                dret = radeon_ddc_probe(radeon_connector,
897
 
                                        radeon_connector->requires_extended_probe);
 
855
                dret = radeon_ddc_probe(radeon_connector);
898
856
        if (dret) {
899
857
                radeon_connector->detected_by_load = false;
900
858
                if (radeon_connector->edid) {
1315
1273
                /* get the DPCD from the bridge */
1316
1274
                radeon_dp_getdpcd(radeon_connector);
1317
1275
 
1318
 
                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1319
 
                        ret = connector_status_connected;
1320
 
                else {
1321
 
                        /* need to setup ddc on the bridge */
1322
 
                        if (encoder)
1323
 
                                radeon_atom_ext_encoder_setup_ddc(encoder);
1324
 
                        if (radeon_ddc_probe(radeon_connector,
1325
 
                                             radeon_connector->requires_extended_probe))
 
1276
                if (encoder) {
 
1277
                        /* setup ddc on the bridge */
 
1278
                        radeon_atom_ext_encoder_setup_ddc(encoder);
 
1279
                        if (radeon_ddc_probe(radeon_connector)) /* try DDC */
1326
1280
                                ret = connector_status_connected;
1327
 
                }
1328
 
 
1329
 
                if ((ret == connector_status_disconnected) &&
1330
 
                    radeon_connector->dac_load_detect) {
1331
 
                        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1332
 
                        struct drm_encoder_helper_funcs *encoder_funcs;
1333
 
                        if (encoder) {
1334
 
                                encoder_funcs = encoder->helper_private;
 
1281
                        else if (radeon_connector->dac_load_detect) { /* try load detection */
 
1282
                                struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1335
1283
                                ret = encoder_funcs->detect(encoder, connector);
1336
1284
                        }
1337
1285
                }
1346
1294
                                if (radeon_dp_getdpcd(radeon_connector))
1347
1295
                                        ret = connector_status_connected;
1348
1296
                        } else {
1349
 
                                if (radeon_ddc_probe(radeon_connector,
1350
 
                                                     radeon_connector->requires_extended_probe))
 
1297
                                if (radeon_ddc_probe(radeon_connector))
1351
1298
                                        ret = connector_status_connected;
1352
1299
                        }
1353
1300
                }
1492
1439
        radeon_connector->shared_ddc = shared_ddc;
1493
1440
        radeon_connector->connector_object_id = connector_object_id;
1494
1441
        radeon_connector->hpd = *hpd;
1495
 
        radeon_connector->requires_extended_probe =
1496
 
                radeon_connector_needs_extended_probe(rdev, supported_device,
1497
 
                                                        connector_type);
 
1442
 
1498
1443
        radeon_connector->router = *router;
1499
1444
        if (router->ddc_valid || router->cd_valid) {
1500
1445
                radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1841
1786
        radeon_connector->devices = supported_device;
1842
1787
        radeon_connector->connector_object_id = connector_object_id;
1843
1788
        radeon_connector->hpd = *hpd;
1844
 
        radeon_connector->requires_extended_probe =
1845
 
                radeon_connector_needs_extended_probe(rdev, supported_device,
1846
 
                                                        connector_type);
 
1789
 
1847
1790
        switch (connector_type) {
1848
1791
        case DRM_MODE_CONNECTOR_VGA:
1849
1792
                drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);