You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Merge remote branch 'korg/drm-radeon-next' into drm-linus
This merges all the radeon changes that weren't reliant on core-next.
This commit is contained in:
@@ -241,6 +241,7 @@ void atombios_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
{
|
||||
struct drm_device *dev = crtc->dev;
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
|
||||
|
||||
switch (mode) {
|
||||
case DRM_MODE_DPMS_ON:
|
||||
@@ -248,20 +249,19 @@ void atombios_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
if (ASIC_IS_DCE3(rdev))
|
||||
atombios_enable_crtc_memreq(crtc, 1);
|
||||
atombios_blank_crtc(crtc, 0);
|
||||
drm_vblank_post_modeset(dev, radeon_crtc->crtc_id);
|
||||
radeon_crtc_load_lut(crtc);
|
||||
break;
|
||||
case DRM_MODE_DPMS_STANDBY:
|
||||
case DRM_MODE_DPMS_SUSPEND:
|
||||
case DRM_MODE_DPMS_OFF:
|
||||
drm_vblank_pre_modeset(dev, radeon_crtc->crtc_id);
|
||||
atombios_blank_crtc(crtc, 1);
|
||||
if (ASIC_IS_DCE3(rdev))
|
||||
atombios_enable_crtc_memreq(crtc, 0);
|
||||
atombios_enable_crtc(crtc, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
if (mode != DRM_MODE_DPMS_OFF) {
|
||||
radeon_crtc_load_lut(crtc);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -457,9 +457,8 @@ void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
|
||||
if (encoder->encoder_type !=
|
||||
DRM_MODE_ENCODER_DAC)
|
||||
pll_flags |= RADEON_PLL_NO_ODD_POST_DIV;
|
||||
if (!ASIC_IS_AVIVO(rdev)
|
||||
&& (encoder->encoder_type ==
|
||||
DRM_MODE_ENCODER_LVDS))
|
||||
if (encoder->encoder_type ==
|
||||
DRM_MODE_ENCODER_LVDS)
|
||||
pll_flags |= RADEON_PLL_USE_REF_DIV;
|
||||
}
|
||||
radeon_encoder = to_radeon_encoder(encoder);
|
||||
@@ -574,21 +573,34 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
struct radeon_framebuffer *radeon_fb;
|
||||
struct drm_gem_object *obj;
|
||||
struct drm_radeon_gem_object *obj_priv;
|
||||
struct radeon_bo *rbo;
|
||||
uint64_t fb_location;
|
||||
uint32_t fb_format, fb_pitch_pixels, tiling_flags;
|
||||
int r;
|
||||
|
||||
if (!crtc->fb)
|
||||
return -EINVAL;
|
||||
/* no fb bound */
|
||||
if (!crtc->fb) {
|
||||
DRM_DEBUG("No FB bound\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
radeon_fb = to_radeon_framebuffer(crtc->fb);
|
||||
|
||||
/* Pin framebuffer & get tilling informations */
|
||||
obj = radeon_fb->obj;
|
||||
obj_priv = obj->driver_private;
|
||||
|
||||
if (radeon_gem_object_pin(obj, RADEON_GEM_DOMAIN_VRAM, &fb_location)) {
|
||||
rbo = obj->driver_private;
|
||||
r = radeon_bo_reserve(rbo, false);
|
||||
if (unlikely(r != 0))
|
||||
return r;
|
||||
r = radeon_bo_pin(rbo, RADEON_GEM_DOMAIN_VRAM, &fb_location);
|
||||
if (unlikely(r != 0)) {
|
||||
radeon_bo_unreserve(rbo);
|
||||
return -EINVAL;
|
||||
}
|
||||
radeon_bo_get_tiling_flags(rbo, &tiling_flags, NULL);
|
||||
radeon_bo_unreserve(rbo);
|
||||
if (tiling_flags & RADEON_TILING_MACRO)
|
||||
fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
|
||||
|
||||
switch (crtc->fb->bits_per_pixel) {
|
||||
case 8:
|
||||
@@ -618,11 +630,6 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
radeon_object_get_tiling_flags(obj->driver_private,
|
||||
&tiling_flags, NULL);
|
||||
if (tiling_flags & RADEON_TILING_MACRO)
|
||||
fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
|
||||
|
||||
if (tiling_flags & RADEON_TILING_MICRO)
|
||||
fb_format |= AVIVO_D1GRPH_TILED;
|
||||
|
||||
@@ -674,7 +681,12 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
|
||||
|
||||
if (old_fb && old_fb != crtc->fb) {
|
||||
radeon_fb = to_radeon_framebuffer(old_fb);
|
||||
radeon_gem_object_unpin(radeon_fb->obj);
|
||||
rbo = radeon_fb->obj->driver_private;
|
||||
r = radeon_bo_reserve(rbo, false);
|
||||
if (unlikely(r != 0))
|
||||
return r;
|
||||
radeon_bo_unpin(rbo);
|
||||
radeon_bo_unreserve(rbo);
|
||||
}
|
||||
|
||||
/* Bytes per pixel may have changed */
|
||||
|
||||
@@ -94,6 +94,15 @@ int r100_pci_gart_init(struct radeon_device *rdev)
|
||||
return radeon_gart_table_ram_alloc(rdev);
|
||||
}
|
||||
|
||||
/* required on r1xx, r2xx, r300, r(v)350, r420/r481, rs400/rs480 */
|
||||
void r100_enable_bm(struct radeon_device *rdev)
|
||||
{
|
||||
uint32_t tmp;
|
||||
/* Enable bus mastering */
|
||||
tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS;
|
||||
WREG32(RADEON_BUS_CNTL, tmp);
|
||||
}
|
||||
|
||||
int r100_pci_gart_enable(struct radeon_device *rdev)
|
||||
{
|
||||
uint32_t tmp;
|
||||
@@ -105,9 +114,6 @@ int r100_pci_gart_enable(struct radeon_device *rdev)
|
||||
WREG32(RADEON_AIC_LO_ADDR, rdev->mc.gtt_location);
|
||||
tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1;
|
||||
WREG32(RADEON_AIC_HI_ADDR, tmp);
|
||||
/* Enable bus mastering */
|
||||
tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS;
|
||||
WREG32(RADEON_BUS_CNTL, tmp);
|
||||
/* set PCI GART page-table base address */
|
||||
WREG32(RADEON_AIC_PT_BASE, rdev->gart.table_addr);
|
||||
tmp = RREG32(RADEON_AIC_CNTL) | RADEON_PCIGART_TRANSLATE_EN;
|
||||
@@ -255,24 +261,27 @@ int r100_wb_init(struct radeon_device *rdev)
|
||||
int r;
|
||||
|
||||
if (rdev->wb.wb_obj == NULL) {
|
||||
r = radeon_object_create(rdev, NULL, RADEON_GPU_PAGE_SIZE,
|
||||
true,
|
||||
RADEON_GEM_DOMAIN_GTT,
|
||||
false, &rdev->wb.wb_obj);
|
||||
r = radeon_bo_create(rdev, NULL, RADEON_GPU_PAGE_SIZE, true,
|
||||
RADEON_GEM_DOMAIN_GTT,
|
||||
&rdev->wb.wb_obj);
|
||||
if (r) {
|
||||
DRM_ERROR("radeon: failed to create WB buffer (%d).\n", r);
|
||||
dev_err(rdev->dev, "(%d) create WB buffer failed\n", r);
|
||||
return r;
|
||||
}
|
||||
r = radeon_object_pin(rdev->wb.wb_obj,
|
||||
RADEON_GEM_DOMAIN_GTT,
|
||||
&rdev->wb.gpu_addr);
|
||||
r = radeon_bo_reserve(rdev->wb.wb_obj, false);
|
||||
if (unlikely(r != 0))
|
||||
return r;
|
||||
r = radeon_bo_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT,
|
||||
&rdev->wb.gpu_addr);
|
||||
if (r) {
|
||||
DRM_ERROR("radeon: failed to pin WB buffer (%d).\n", r);
|
||||
dev_err(rdev->dev, "(%d) pin WB buffer failed\n", r);
|
||||
radeon_bo_unreserve(rdev->wb.wb_obj);
|
||||
return r;
|
||||
}
|
||||
r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
|
||||
r = radeon_bo_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
|
||||
radeon_bo_unreserve(rdev->wb.wb_obj);
|
||||
if (r) {
|
||||
DRM_ERROR("radeon: failed to map WB buffer (%d).\n", r);
|
||||
dev_err(rdev->dev, "(%d) map WB buffer failed\n", r);
|
||||
return r;
|
||||
}
|
||||
}
|
||||
@@ -290,11 +299,19 @@ void r100_wb_disable(struct radeon_device *rdev)
|
||||
|
||||
void r100_wb_fini(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
r100_wb_disable(rdev);
|
||||
if (rdev->wb.wb_obj) {
|
||||
radeon_object_kunmap(rdev->wb.wb_obj);
|
||||
radeon_object_unpin(rdev->wb.wb_obj);
|
||||
radeon_object_unref(&rdev->wb.wb_obj);
|
||||
r = radeon_bo_reserve(rdev->wb.wb_obj, false);
|
||||
if (unlikely(r != 0)) {
|
||||
dev_err(rdev->dev, "(%d) can't finish WB\n", r);
|
||||
return;
|
||||
}
|
||||
radeon_bo_kunmap(rdev->wb.wb_obj);
|
||||
radeon_bo_unpin(rdev->wb.wb_obj);
|
||||
radeon_bo_unreserve(rdev->wb.wb_obj);
|
||||
radeon_bo_unref(&rdev->wb.wb_obj);
|
||||
rdev->wb.wb = NULL;
|
||||
rdev->wb.wb_obj = NULL;
|
||||
}
|
||||
@@ -1288,17 +1305,17 @@ static int r100_packet0_check(struct radeon_cs_parser *p,
|
||||
|
||||
int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p,
|
||||
struct radeon_cs_packet *pkt,
|
||||
struct radeon_object *robj)
|
||||
struct radeon_bo *robj)
|
||||
{
|
||||
unsigned idx;
|
||||
u32 value;
|
||||
idx = pkt->idx + 1;
|
||||
value = radeon_get_ib_value(p, idx + 2);
|
||||
if ((value + 1) > radeon_object_size(robj)) {
|
||||
if ((value + 1) > radeon_bo_size(robj)) {
|
||||
DRM_ERROR("[drm] Buffer too small for PACKET3 INDX_BUFFER "
|
||||
"(need %u have %lu) !\n",
|
||||
value + 1,
|
||||
radeon_object_size(robj));
|
||||
radeon_bo_size(robj));
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
@@ -1583,6 +1600,14 @@ void r100_gpu_init(struct radeon_device *rdev)
|
||||
r100_hdp_reset(rdev);
|
||||
}
|
||||
|
||||
void r100_hdp_flush(struct radeon_device *rdev)
|
||||
{
|
||||
u32 tmp;
|
||||
tmp = RREG32(RADEON_HOST_PATH_CNTL);
|
||||
tmp |= RADEON_HDP_READ_BUFFER_INVALIDATE;
|
||||
WREG32(RADEON_HOST_PATH_CNTL, tmp);
|
||||
}
|
||||
|
||||
void r100_hdp_reset(struct radeon_device *rdev)
|
||||
{
|
||||
uint32_t tmp;
|
||||
@@ -1650,6 +1675,17 @@ int r100_gpu_reset(struct radeon_device *rdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void r100_set_common_regs(struct radeon_device *rdev)
|
||||
{
|
||||
/* set these so they don't interfere with anything */
|
||||
WREG32(RADEON_OV0_SCALE_CNTL, 0);
|
||||
WREG32(RADEON_SUBPIC_CNTL, 0);
|
||||
WREG32(RADEON_VIPH_CONTROL, 0);
|
||||
WREG32(RADEON_I2C_CNTL_1, 0);
|
||||
WREG32(RADEON_DVI_I2C_CNTL_1, 0);
|
||||
WREG32(RADEON_CAP0_TRIG_CNTL, 0);
|
||||
WREG32(RADEON_CAP1_TRIG_CNTL, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* VRAM info
|
||||
@@ -2594,7 +2630,7 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
|
||||
struct r100_cs_track *track, unsigned idx)
|
||||
{
|
||||
unsigned face, w, h;
|
||||
struct radeon_object *cube_robj;
|
||||
struct radeon_bo *cube_robj;
|
||||
unsigned long size;
|
||||
|
||||
for (face = 0; face < 5; face++) {
|
||||
@@ -2607,9 +2643,9 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
|
||||
|
||||
size += track->textures[idx].cube_info[face].offset;
|
||||
|
||||
if (size > radeon_object_size(cube_robj)) {
|
||||
if (size > radeon_bo_size(cube_robj)) {
|
||||
DRM_ERROR("Cube texture offset greater than object size %lu %lu\n",
|
||||
size, radeon_object_size(cube_robj));
|
||||
size, radeon_bo_size(cube_robj));
|
||||
r100_cs_track_texture_print(&track->textures[idx]);
|
||||
return -1;
|
||||
}
|
||||
@@ -2620,7 +2656,7 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
|
||||
static int r100_cs_track_texture_check(struct radeon_device *rdev,
|
||||
struct r100_cs_track *track)
|
||||
{
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
unsigned long size;
|
||||
unsigned u, i, w, h;
|
||||
int ret;
|
||||
@@ -2676,9 +2712,9 @@ static int r100_cs_track_texture_check(struct radeon_device *rdev,
|
||||
"%u\n", track->textures[u].tex_coord_type, u);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (size > radeon_object_size(robj)) {
|
||||
if (size > radeon_bo_size(robj)) {
|
||||
DRM_ERROR("Texture of unit %u needs %lu bytes but is "
|
||||
"%lu\n", u, size, radeon_object_size(robj));
|
||||
"%lu\n", u, size, radeon_bo_size(robj));
|
||||
r100_cs_track_texture_print(&track->textures[u]);
|
||||
return -EINVAL;
|
||||
}
|
||||
@@ -2700,10 +2736,10 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
|
||||
}
|
||||
size = track->cb[i].pitch * track->cb[i].cpp * track->maxy;
|
||||
size += track->cb[i].offset;
|
||||
if (size > radeon_object_size(track->cb[i].robj)) {
|
||||
if (size > radeon_bo_size(track->cb[i].robj)) {
|
||||
DRM_ERROR("[drm] Buffer too small for color buffer %d "
|
||||
"(need %lu have %lu) !\n", i, size,
|
||||
radeon_object_size(track->cb[i].robj));
|
||||
radeon_bo_size(track->cb[i].robj));
|
||||
DRM_ERROR("[drm] color buffer %d (%u %u %u %u)\n",
|
||||
i, track->cb[i].pitch, track->cb[i].cpp,
|
||||
track->cb[i].offset, track->maxy);
|
||||
@@ -2717,10 +2753,10 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
|
||||
}
|
||||
size = track->zb.pitch * track->zb.cpp * track->maxy;
|
||||
size += track->zb.offset;
|
||||
if (size > radeon_object_size(track->zb.robj)) {
|
||||
if (size > radeon_bo_size(track->zb.robj)) {
|
||||
DRM_ERROR("[drm] Buffer too small for z buffer "
|
||||
"(need %lu have %lu) !\n", size,
|
||||
radeon_object_size(track->zb.robj));
|
||||
radeon_bo_size(track->zb.robj));
|
||||
DRM_ERROR("[drm] zbuffer (%u %u %u %u)\n",
|
||||
track->zb.pitch, track->zb.cpp,
|
||||
track->zb.offset, track->maxy);
|
||||
@@ -2738,11 +2774,12 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
|
||||
"bound\n", prim_walk, i);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (size > radeon_object_size(track->arrays[i].robj)) {
|
||||
DRM_ERROR("(PW %u) Vertex array %u need %lu dwords "
|
||||
"have %lu dwords\n", prim_walk, i,
|
||||
size >> 2,
|
||||
radeon_object_size(track->arrays[i].robj) >> 2);
|
||||
if (size > radeon_bo_size(track->arrays[i].robj)) {
|
||||
dev_err(rdev->dev, "(PW %u) Vertex array %u "
|
||||
"need %lu dwords have %lu dwords\n",
|
||||
prim_walk, i, size >> 2,
|
||||
radeon_bo_size(track->arrays[i].robj)
|
||||
>> 2);
|
||||
DRM_ERROR("Max indices %u\n", track->max_indx);
|
||||
return -EINVAL;
|
||||
}
|
||||
@@ -2756,10 +2793,12 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
|
||||
"bound\n", prim_walk, i);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (size > radeon_object_size(track->arrays[i].robj)) {
|
||||
DRM_ERROR("(PW %u) Vertex array %u need %lu dwords "
|
||||
"have %lu dwords\n", prim_walk, i, size >> 2,
|
||||
radeon_object_size(track->arrays[i].robj) >> 2);
|
||||
if (size > radeon_bo_size(track->arrays[i].robj)) {
|
||||
dev_err(rdev->dev, "(PW %u) Vertex array %u "
|
||||
"need %lu dwords have %lu dwords\n",
|
||||
prim_walk, i, size >> 2,
|
||||
radeon_bo_size(track->arrays[i].robj)
|
||||
>> 2);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
@@ -3101,6 +3140,9 @@ static int r100_startup(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* set common regs */
|
||||
r100_set_common_regs(rdev);
|
||||
/* program mc */
|
||||
r100_mc_program(rdev);
|
||||
/* Resume clock */
|
||||
r100_clock_startup(rdev);
|
||||
@@ -3108,13 +3150,13 @@ static int r100_startup(struct radeon_device *rdev)
|
||||
r100_gpu_init(rdev);
|
||||
/* Initialize GART (initialize after TTM so we can allocate
|
||||
* memory through TTM but finalize after TTM) */
|
||||
r100_enable_bm(rdev);
|
||||
if (rdev->flags & RADEON_IS_PCI) {
|
||||
r = r100_pci_gart_enable(rdev);
|
||||
if (r)
|
||||
return r;
|
||||
}
|
||||
/* Enable IRQ */
|
||||
rdev->irq.sw_int = true;
|
||||
r100_irq_set(rdev);
|
||||
/* 1M ring buffer */
|
||||
r = r100_cp_init(rdev, 1024 * 1024);
|
||||
@@ -3174,7 +3216,7 @@ void r100_fini(struct radeon_device *rdev)
|
||||
r100_pci_gart_fini(rdev);
|
||||
radeon_irq_kms_fini(rdev);
|
||||
radeon_fence_driver_fini(rdev);
|
||||
radeon_object_fini(rdev);
|
||||
radeon_bo_fini(rdev);
|
||||
radeon_atombios_fini(rdev);
|
||||
kfree(rdev->bios);
|
||||
rdev->bios = NULL;
|
||||
@@ -3242,10 +3284,8 @@ int r100_init(struct radeon_device *rdev)
|
||||
RREG32(R_0007C0_CP_STAT));
|
||||
}
|
||||
/* check if cards are posted or not */
|
||||
if (!radeon_card_posted(rdev) && rdev->bios) {
|
||||
DRM_INFO("GPU not posted. posting now...\n");
|
||||
radeon_combios_asic_init(rdev->ddev);
|
||||
}
|
||||
if (radeon_boot_test_post_card(rdev) == false)
|
||||
return -EINVAL;
|
||||
/* Set asic errata */
|
||||
r100_errata(rdev);
|
||||
/* Initialize clocks */
|
||||
@@ -3264,7 +3304,7 @@ int r100_init(struct radeon_device *rdev)
|
||||
if (r)
|
||||
return r;
|
||||
/* Memory manager */
|
||||
r = radeon_object_init(rdev);
|
||||
r = radeon_bo_init(rdev);
|
||||
if (r)
|
||||
return r;
|
||||
if (rdev->flags & RADEON_IS_PCI) {
|
||||
|
||||
@@ -10,26 +10,26 @@
|
||||
* CS functions
|
||||
*/
|
||||
struct r100_cs_track_cb {
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
unsigned pitch;
|
||||
unsigned cpp;
|
||||
unsigned offset;
|
||||
};
|
||||
|
||||
struct r100_cs_track_array {
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
unsigned esize;
|
||||
};
|
||||
|
||||
struct r100_cs_cube_info {
|
||||
struct radeon_object *robj;
|
||||
unsigned offset;
|
||||
struct radeon_bo *robj;
|
||||
unsigned offset;
|
||||
unsigned width;
|
||||
unsigned height;
|
||||
};
|
||||
|
||||
struct r100_cs_track_texture {
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
struct r100_cs_cube_info cube_info[5]; /* info for 5 non-primary faces */
|
||||
unsigned pitch;
|
||||
unsigned width;
|
||||
|
||||
@@ -137,14 +137,19 @@ int rv370_pcie_gart_enable(struct radeon_device *rdev)
|
||||
|
||||
void rv370_pcie_gart_disable(struct radeon_device *rdev)
|
||||
{
|
||||
uint32_t tmp;
|
||||
u32 tmp;
|
||||
int r;
|
||||
|
||||
tmp = RREG32_PCIE(RADEON_PCIE_TX_GART_CNTL);
|
||||
tmp |= RADEON_PCIE_TX_GART_UNMAPPED_ACCESS_DISCARD;
|
||||
WREG32_PCIE(RADEON_PCIE_TX_GART_CNTL, tmp & ~RADEON_PCIE_TX_GART_EN);
|
||||
if (rdev->gart.table.vram.robj) {
|
||||
radeon_object_kunmap(rdev->gart.table.vram.robj);
|
||||
radeon_object_unpin(rdev->gart.table.vram.robj);
|
||||
r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
|
||||
if (likely(r == 0)) {
|
||||
radeon_bo_kunmap(rdev->gart.table.vram.robj);
|
||||
radeon_bo_unpin(rdev->gart.table.vram.robj);
|
||||
radeon_bo_unreserve(rdev->gart.table.vram.robj);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1181,6 +1186,9 @@ static int r300_startup(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* set common regs */
|
||||
r100_set_common_regs(rdev);
|
||||
/* program mc */
|
||||
r300_mc_program(rdev);
|
||||
/* Resume clock */
|
||||
r300_clock_startup(rdev);
|
||||
@@ -1193,13 +1201,18 @@ static int r300_startup(struct radeon_device *rdev)
|
||||
if (r)
|
||||
return r;
|
||||
}
|
||||
|
||||
if (rdev->family == CHIP_R300 ||
|
||||
rdev->family == CHIP_R350 ||
|
||||
rdev->family == CHIP_RV350)
|
||||
r100_enable_bm(rdev);
|
||||
|
||||
if (rdev->flags & RADEON_IS_PCI) {
|
||||
r = r100_pci_gart_enable(rdev);
|
||||
if (r)
|
||||
return r;
|
||||
}
|
||||
/* Enable IRQ */
|
||||
rdev->irq.sw_int = true;
|
||||
r100_irq_set(rdev);
|
||||
/* 1M ring buffer */
|
||||
r = r100_cp_init(rdev, 1024 * 1024);
|
||||
@@ -1265,7 +1278,7 @@ void r300_fini(struct radeon_device *rdev)
|
||||
r100_pci_gart_fini(rdev);
|
||||
radeon_irq_kms_fini(rdev);
|
||||
radeon_fence_driver_fini(rdev);
|
||||
radeon_object_fini(rdev);
|
||||
radeon_bo_fini(rdev);
|
||||
radeon_atombios_fini(rdev);
|
||||
kfree(rdev->bios);
|
||||
rdev->bios = NULL;
|
||||
@@ -1303,10 +1316,8 @@ int r300_init(struct radeon_device *rdev)
|
||||
RREG32(R_0007C0_CP_STAT));
|
||||
}
|
||||
/* check if cards are posted or not */
|
||||
if (!radeon_card_posted(rdev) && rdev->bios) {
|
||||
DRM_INFO("GPU not posted. posting now...\n");
|
||||
radeon_combios_asic_init(rdev->ddev);
|
||||
}
|
||||
if (radeon_boot_test_post_card(rdev) == false)
|
||||
return -EINVAL;
|
||||
/* Set asic errata */
|
||||
r300_errata(rdev);
|
||||
/* Initialize clocks */
|
||||
@@ -1325,7 +1336,7 @@ int r300_init(struct radeon_device *rdev)
|
||||
if (r)
|
||||
return r;
|
||||
/* Memory manager */
|
||||
r = radeon_object_init(rdev);
|
||||
r = radeon_bo_init(rdev);
|
||||
if (r)
|
||||
return r;
|
||||
if (rdev->flags & RADEON_IS_PCIE) {
|
||||
|
||||
@@ -169,6 +169,9 @@ static int r420_startup(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* set common regs */
|
||||
r100_set_common_regs(rdev);
|
||||
/* program mc */
|
||||
r300_mc_program(rdev);
|
||||
/* Resume clock */
|
||||
r420_clock_resume(rdev);
|
||||
@@ -186,7 +189,6 @@ static int r420_startup(struct radeon_device *rdev)
|
||||
}
|
||||
r420_pipes_init(rdev);
|
||||
/* Enable IRQ */
|
||||
rdev->irq.sw_int = true;
|
||||
r100_irq_set(rdev);
|
||||
/* 1M ring buffer */
|
||||
r = r100_cp_init(rdev, 1024 * 1024);
|
||||
@@ -258,7 +260,7 @@ void r420_fini(struct radeon_device *rdev)
|
||||
radeon_agp_fini(rdev);
|
||||
radeon_irq_kms_fini(rdev);
|
||||
radeon_fence_driver_fini(rdev);
|
||||
radeon_object_fini(rdev);
|
||||
radeon_bo_fini(rdev);
|
||||
if (rdev->is_atom_bios) {
|
||||
radeon_atombios_fini(rdev);
|
||||
} else {
|
||||
@@ -301,14 +303,9 @@ int r420_init(struct radeon_device *rdev)
|
||||
RREG32(R_0007C0_CP_STAT));
|
||||
}
|
||||
/* check if cards are posted or not */
|
||||
if (!radeon_card_posted(rdev) && rdev->bios) {
|
||||
DRM_INFO("GPU not posted. posting now...\n");
|
||||
if (rdev->is_atom_bios) {
|
||||
atom_asic_init(rdev->mode_info.atom_context);
|
||||
} else {
|
||||
radeon_combios_asic_init(rdev->ddev);
|
||||
}
|
||||
}
|
||||
if (radeon_boot_test_post_card(rdev) == false)
|
||||
return -EINVAL;
|
||||
|
||||
/* Initialize clocks */
|
||||
radeon_get_clock_info(rdev->ddev);
|
||||
/* Initialize power management */
|
||||
@@ -331,10 +328,13 @@ int r420_init(struct radeon_device *rdev)
|
||||
return r;
|
||||
}
|
||||
/* Memory manager */
|
||||
r = radeon_object_init(rdev);
|
||||
r = radeon_bo_init(rdev);
|
||||
if (r) {
|
||||
return r;
|
||||
}
|
||||
if (rdev->family == CHIP_R420)
|
||||
r100_enable_bm(rdev);
|
||||
|
||||
if (rdev->flags & RADEON_IS_PCIE) {
|
||||
r = rv370_pcie_gart_init(rdev);
|
||||
if (r)
|
||||
|
||||
@@ -185,7 +185,6 @@ static int r520_startup(struct radeon_device *rdev)
|
||||
return r;
|
||||
}
|
||||
/* Enable IRQ */
|
||||
rdev->irq.sw_int = true;
|
||||
rs600_irq_set(rdev);
|
||||
/* 1M ring buffer */
|
||||
r = r100_cp_init(rdev, 1024 * 1024);
|
||||
@@ -254,6 +253,9 @@ int r520_init(struct radeon_device *rdev)
|
||||
RREG32(R_0007C0_CP_STAT));
|
||||
}
|
||||
/* check if cards are posted or not */
|
||||
if (radeon_boot_test_post_card(rdev) == false)
|
||||
return -EINVAL;
|
||||
|
||||
if (!radeon_card_posted(rdev) && rdev->bios) {
|
||||
DRM_INFO("GPU not posted. posting now...\n");
|
||||
atom_asic_init(rdev->mode_info.atom_context);
|
||||
@@ -277,7 +279,7 @@ int r520_init(struct radeon_device *rdev)
|
||||
if (r)
|
||||
return r;
|
||||
/* Memory manager */
|
||||
r = radeon_object_init(rdev);
|
||||
r = radeon_bo_init(rdev);
|
||||
if (r)
|
||||
return r;
|
||||
r = rv370_pcie_gart_init(rdev);
|
||||
|
||||
+606
-56
File diff suppressed because it is too large
Load Diff
@@ -473,9 +473,8 @@ int r600_blit_init(struct radeon_device *rdev)
|
||||
obj_size += r6xx_ps_size * 4;
|
||||
obj_size = ALIGN(obj_size, 256);
|
||||
|
||||
r = radeon_object_create(rdev, NULL, obj_size,
|
||||
true, RADEON_GEM_DOMAIN_VRAM,
|
||||
false, &rdev->r600_blit.shader_obj);
|
||||
r = radeon_bo_create(rdev, NULL, obj_size, true, RADEON_GEM_DOMAIN_VRAM,
|
||||
&rdev->r600_blit.shader_obj);
|
||||
if (r) {
|
||||
DRM_ERROR("r600 failed to allocate shader\n");
|
||||
return r;
|
||||
@@ -485,12 +484,14 @@ int r600_blit_init(struct radeon_device *rdev)
|
||||
obj_size,
|
||||
rdev->r600_blit.vs_offset, rdev->r600_blit.ps_offset);
|
||||
|
||||
r = radeon_object_kmap(rdev->r600_blit.shader_obj, &ptr);
|
||||
r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
|
||||
if (unlikely(r != 0))
|
||||
return r;
|
||||
r = radeon_bo_kmap(rdev->r600_blit.shader_obj, &ptr);
|
||||
if (r) {
|
||||
DRM_ERROR("failed to map blit object %d\n", r);
|
||||
return r;
|
||||
}
|
||||
|
||||
if (rdev->family >= CHIP_RV770)
|
||||
memcpy_toio(ptr + rdev->r600_blit.state_offset,
|
||||
r7xx_default_state, rdev->r600_blit.state_len * 4);
|
||||
@@ -500,19 +501,26 @@ int r600_blit_init(struct radeon_device *rdev)
|
||||
if (num_packet2s)
|
||||
memcpy_toio(ptr + rdev->r600_blit.state_offset + (rdev->r600_blit.state_len * 4),
|
||||
packet2s, num_packet2s * 4);
|
||||
|
||||
|
||||
memcpy(ptr + rdev->r600_blit.vs_offset, r6xx_vs, r6xx_vs_size * 4);
|
||||
memcpy(ptr + rdev->r600_blit.ps_offset, r6xx_ps, r6xx_ps_size * 4);
|
||||
|
||||
radeon_object_kunmap(rdev->r600_blit.shader_obj);
|
||||
radeon_bo_kunmap(rdev->r600_blit.shader_obj);
|
||||
radeon_bo_unreserve(rdev->r600_blit.shader_obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void r600_blit_fini(struct radeon_device *rdev)
|
||||
{
|
||||
radeon_object_unpin(rdev->r600_blit.shader_obj);
|
||||
radeon_object_unref(&rdev->r600_blit.shader_obj);
|
||||
int r;
|
||||
|
||||
r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
|
||||
if (unlikely(r != 0)) {
|
||||
dev_err(rdev->dev, "(%d) can't finish r600 blit\n", r);
|
||||
goto out_unref;
|
||||
}
|
||||
radeon_bo_unpin(rdev->r600_blit.shader_obj);
|
||||
radeon_bo_unreserve(rdev->r600_blit.shader_obj);
|
||||
out_unref:
|
||||
radeon_bo_unref(&rdev->r600_blit.shader_obj);
|
||||
}
|
||||
|
||||
int r600_vb_ib_get(struct radeon_device *rdev)
|
||||
@@ -569,9 +577,9 @@ int r600_blit_prepare_copy(struct radeon_device *rdev, int size_bytes)
|
||||
ring_size = num_loops * dwords_per_loop;
|
||||
/* set default + shaders */
|
||||
ring_size += 40; /* shaders + def state */
|
||||
ring_size += 3; /* fence emit for VB IB */
|
||||
ring_size += 5; /* fence emit for VB IB */
|
||||
ring_size += 5; /* done copy */
|
||||
ring_size += 3; /* fence emit for done copy */
|
||||
ring_size += 5; /* fence emit for done copy */
|
||||
r = radeon_ring_lock(rdev, ring_size);
|
||||
WARN_ON(r);
|
||||
|
||||
|
||||
@@ -456,7 +456,163 @@
|
||||
#define WAIT_2D_IDLECLEAN_bit (1 << 16)
|
||||
#define WAIT_3D_IDLECLEAN_bit (1 << 17)
|
||||
|
||||
#define IH_RB_CNTL 0x3e00
|
||||
# define IH_RB_ENABLE (1 << 0)
|
||||
# define IH_IB_SIZE(x) ((x) << 1) /* log2 */
|
||||
# define IH_RB_FULL_DRAIN_ENABLE (1 << 6)
|
||||
# define IH_WPTR_WRITEBACK_ENABLE (1 << 8)
|
||||
# define IH_WPTR_WRITEBACK_TIMER(x) ((x) << 9) /* log2 */
|
||||
# define IH_WPTR_OVERFLOW_ENABLE (1 << 16)
|
||||
# define IH_WPTR_OVERFLOW_CLEAR (1 << 31)
|
||||
#define IH_RB_BASE 0x3e04
|
||||
#define IH_RB_RPTR 0x3e08
|
||||
#define IH_RB_WPTR 0x3e0c
|
||||
# define RB_OVERFLOW (1 << 0)
|
||||
# define WPTR_OFFSET_MASK 0x3fffc
|
||||
#define IH_RB_WPTR_ADDR_HI 0x3e10
|
||||
#define IH_RB_WPTR_ADDR_LO 0x3e14
|
||||
#define IH_CNTL 0x3e18
|
||||
# define ENABLE_INTR (1 << 0)
|
||||
# define IH_MC_SWAP(x) ((x) << 2)
|
||||
# define IH_MC_SWAP_NONE 0
|
||||
# define IH_MC_SWAP_16BIT 1
|
||||
# define IH_MC_SWAP_32BIT 2
|
||||
# define IH_MC_SWAP_64BIT 3
|
||||
# define RPTR_REARM (1 << 4)
|
||||
# define MC_WRREQ_CREDIT(x) ((x) << 15)
|
||||
# define MC_WR_CLEAN_CNT(x) ((x) << 20)
|
||||
|
||||
#define RLC_CNTL 0x3f00
|
||||
# define RLC_ENABLE (1 << 0)
|
||||
#define RLC_HB_BASE 0x3f10
|
||||
#define RLC_HB_CNTL 0x3f0c
|
||||
#define RLC_HB_RPTR 0x3f20
|
||||
#define RLC_HB_WPTR 0x3f1c
|
||||
#define RLC_HB_WPTR_LSB_ADDR 0x3f14
|
||||
#define RLC_HB_WPTR_MSB_ADDR 0x3f18
|
||||
#define RLC_MC_CNTL 0x3f44
|
||||
#define RLC_UCODE_CNTL 0x3f48
|
||||
#define RLC_UCODE_ADDR 0x3f2c
|
||||
#define RLC_UCODE_DATA 0x3f30
|
||||
|
||||
#define SRBM_SOFT_RESET 0xe60
|
||||
# define SOFT_RESET_RLC (1 << 13)
|
||||
|
||||
#define CP_INT_CNTL 0xc124
|
||||
# define CNTX_BUSY_INT_ENABLE (1 << 19)
|
||||
# define CNTX_EMPTY_INT_ENABLE (1 << 20)
|
||||
# define SCRATCH_INT_ENABLE (1 << 25)
|
||||
# define TIME_STAMP_INT_ENABLE (1 << 26)
|
||||
# define IB2_INT_ENABLE (1 << 29)
|
||||
# define IB1_INT_ENABLE (1 << 30)
|
||||
# define RB_INT_ENABLE (1 << 31)
|
||||
#define CP_INT_STATUS 0xc128
|
||||
# define SCRATCH_INT_STAT (1 << 25)
|
||||
# define TIME_STAMP_INT_STAT (1 << 26)
|
||||
# define IB2_INT_STAT (1 << 29)
|
||||
# define IB1_INT_STAT (1 << 30)
|
||||
# define RB_INT_STAT (1 << 31)
|
||||
|
||||
#define GRBM_INT_CNTL 0x8060
|
||||
# define RDERR_INT_ENABLE (1 << 0)
|
||||
# define WAIT_COUNT_TIMEOUT_INT_ENABLE (1 << 1)
|
||||
# define GUI_IDLE_INT_ENABLE (1 << 19)
|
||||
|
||||
#define INTERRUPT_CNTL 0x5468
|
||||
# define IH_DUMMY_RD_OVERRIDE (1 << 0)
|
||||
# define IH_DUMMY_RD_EN (1 << 1)
|
||||
# define IH_REQ_NONSNOOP_EN (1 << 3)
|
||||
# define GEN_IH_INT_EN (1 << 8)
|
||||
#define INTERRUPT_CNTL2 0x546c
|
||||
|
||||
#define D1MODE_VBLANK_STATUS 0x6534
|
||||
#define D2MODE_VBLANK_STATUS 0x6d34
|
||||
# define DxMODE_VBLANK_OCCURRED (1 << 0)
|
||||
# define DxMODE_VBLANK_ACK (1 << 4)
|
||||
# define DxMODE_VBLANK_STAT (1 << 12)
|
||||
# define DxMODE_VBLANK_INTERRUPT (1 << 16)
|
||||
# define DxMODE_VBLANK_INTERRUPT_TYPE (1 << 17)
|
||||
#define D1MODE_VLINE_STATUS 0x653c
|
||||
#define D2MODE_VLINE_STATUS 0x6d3c
|
||||
# define DxMODE_VLINE_OCCURRED (1 << 0)
|
||||
# define DxMODE_VLINE_ACK (1 << 4)
|
||||
# define DxMODE_VLINE_STAT (1 << 12)
|
||||
# define DxMODE_VLINE_INTERRUPT (1 << 16)
|
||||
# define DxMODE_VLINE_INTERRUPT_TYPE (1 << 17)
|
||||
#define DxMODE_INT_MASK 0x6540
|
||||
# define D1MODE_VBLANK_INT_MASK (1 << 0)
|
||||
# define D1MODE_VLINE_INT_MASK (1 << 4)
|
||||
# define D2MODE_VBLANK_INT_MASK (1 << 8)
|
||||
# define D2MODE_VLINE_INT_MASK (1 << 12)
|
||||
#define DCE3_DISP_INTERRUPT_STATUS 0x7ddc
|
||||
# define DC_HPD1_INTERRUPT (1 << 18)
|
||||
# define DC_HPD2_INTERRUPT (1 << 19)
|
||||
#define DISP_INTERRUPT_STATUS 0x7edc
|
||||
# define LB_D1_VLINE_INTERRUPT (1 << 2)
|
||||
# define LB_D2_VLINE_INTERRUPT (1 << 3)
|
||||
# define LB_D1_VBLANK_INTERRUPT (1 << 4)
|
||||
# define LB_D2_VBLANK_INTERRUPT (1 << 5)
|
||||
# define DACA_AUTODETECT_INTERRUPT (1 << 16)
|
||||
# define DACB_AUTODETECT_INTERRUPT (1 << 17)
|
||||
# define DC_HOT_PLUG_DETECT1_INTERRUPT (1 << 18)
|
||||
# define DC_HOT_PLUG_DETECT2_INTERRUPT (1 << 19)
|
||||
# define DC_I2C_SW_DONE_INTERRUPT (1 << 20)
|
||||
# define DC_I2C_HW_DONE_INTERRUPT (1 << 21)
|
||||
#define DCE3_DISP_INTERRUPT_STATUS_CONTINUE 0x7de8
|
||||
# define DC_HPD4_INTERRUPT (1 << 14)
|
||||
# define DC_HPD4_RX_INTERRUPT (1 << 15)
|
||||
# define DC_HPD3_INTERRUPT (1 << 28)
|
||||
# define DC_HPD1_RX_INTERRUPT (1 << 29)
|
||||
# define DC_HPD2_RX_INTERRUPT (1 << 30)
|
||||
#define DCE3_DISP_INTERRUPT_STATUS_CONTINUE2 0x7dec
|
||||
# define DC_HPD3_RX_INTERRUPT (1 << 0)
|
||||
# define DIGA_DP_VID_STREAM_DISABLE_INTERRUPT (1 << 1)
|
||||
# define DIGA_DP_STEER_FIFO_OVERFLOW_INTERRUPT (1 << 2)
|
||||
# define DIGB_DP_VID_STREAM_DISABLE_INTERRUPT (1 << 3)
|
||||
# define DIGB_DP_STEER_FIFO_OVERFLOW_INTERRUPT (1 << 4)
|
||||
# define AUX1_SW_DONE_INTERRUPT (1 << 5)
|
||||
# define AUX1_LS_DONE_INTERRUPT (1 << 6)
|
||||
# define AUX2_SW_DONE_INTERRUPT (1 << 7)
|
||||
# define AUX2_LS_DONE_INTERRUPT (1 << 8)
|
||||
# define AUX3_SW_DONE_INTERRUPT (1 << 9)
|
||||
# define AUX3_LS_DONE_INTERRUPT (1 << 10)
|
||||
# define AUX4_SW_DONE_INTERRUPT (1 << 11)
|
||||
# define AUX4_LS_DONE_INTERRUPT (1 << 12)
|
||||
# define DIGA_DP_FAST_TRAINING_COMPLETE_INTERRUPT (1 << 13)
|
||||
# define DIGB_DP_FAST_TRAINING_COMPLETE_INTERRUPT (1 << 14)
|
||||
/* DCE 3.2 */
|
||||
# define AUX5_SW_DONE_INTERRUPT (1 << 15)
|
||||
# define AUX5_LS_DONE_INTERRUPT (1 << 16)
|
||||
# define AUX6_SW_DONE_INTERRUPT (1 << 17)
|
||||
# define AUX6_LS_DONE_INTERRUPT (1 << 18)
|
||||
# define DC_HPD5_INTERRUPT (1 << 19)
|
||||
# define DC_HPD5_RX_INTERRUPT (1 << 20)
|
||||
# define DC_HPD6_INTERRUPT (1 << 21)
|
||||
# define DC_HPD6_RX_INTERRUPT (1 << 22)
|
||||
|
||||
#define DCE3_DACA_AUTODETECT_INT_CONTROL 0x7038
|
||||
#define DCE3_DACB_AUTODETECT_INT_CONTROL 0x7138
|
||||
#define DACA_AUTODETECT_INT_CONTROL 0x7838
|
||||
#define DACB_AUTODETECT_INT_CONTROL 0x7a38
|
||||
# define DACx_AUTODETECT_ACK (1 << 0)
|
||||
# define DACx_AUTODETECT_INT_ENABLE (1 << 16)
|
||||
|
||||
#define DC_HOT_PLUG_DETECT1_INT_CONTROL 0x7d08
|
||||
#define DC_HOT_PLUG_DETECT2_INT_CONTROL 0x7d18
|
||||
#define DC_HOT_PLUG_DETECT3_INT_CONTROL 0x7d2c
|
||||
# define DC_HOT_PLUG_DETECTx_INT_ACK (1 << 0)
|
||||
# define DC_HOT_PLUG_DETECTx_INT_POLARITY (1 << 8)
|
||||
# define DC_HOT_PLUG_DETECTx_INT_EN (1 << 16)
|
||||
/* DCE 3.2 */
|
||||
#define DC_HPD1_INT_CONTROL 0x7d04
|
||||
#define DC_HPD2_INT_CONTROL 0x7d10
|
||||
#define DC_HPD3_INT_CONTROL 0x7d1c
|
||||
#define DC_HPD4_INT_CONTROL 0x7d28
|
||||
# define DC_HPDx_INT_ACK (1 << 0)
|
||||
# define DC_HPDx_INT_POLARITY (1 << 8)
|
||||
# define DC_HPDx_INT_EN (1 << 16)
|
||||
# define DC_HPDx_RX_INT_ACK (1 << 20)
|
||||
# define DC_HPDx_RX_INT_EN (1 << 24)
|
||||
|
||||
/*
|
||||
* PM4
|
||||
@@ -500,7 +656,6 @@
|
||||
#define PACKET3_WAIT_REG_MEM 0x3C
|
||||
#define PACKET3_MEM_WRITE 0x3D
|
||||
#define PACKET3_INDIRECT_BUFFER 0x32
|
||||
#define PACKET3_CP_INTERRUPT 0x40
|
||||
#define PACKET3_SURFACE_SYNC 0x43
|
||||
# define PACKET3_CB0_DEST_BASE_ENA (1 << 6)
|
||||
# define PACKET3_TC_ACTION_ENA (1 << 23)
|
||||
@@ -674,4 +829,5 @@
|
||||
#define S_000E60_SOFT_RESET_TSC(x) (((x) & 1) << 16)
|
||||
#define S_000E60_SOFT_RESET_VMC(x) (((x) & 1) << 17)
|
||||
|
||||
#define R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL 0x5480
|
||||
#endif
|
||||
|
||||
@@ -28,8 +28,6 @@
|
||||
#ifndef __RADEON_H__
|
||||
#define __RADEON_H__
|
||||
|
||||
#include "radeon_object.h"
|
||||
|
||||
/* TODO: Here are things that needs to be done :
|
||||
* - surface allocator & initializer : (bit like scratch reg) should
|
||||
* initialize HDP_ stuff on RS600, R600, R700 hw, well anythings
|
||||
@@ -67,6 +65,11 @@
|
||||
#include <linux/list.h>
|
||||
#include <linux/kref.h>
|
||||
|
||||
#include <ttm/ttm_bo_api.h>
|
||||
#include <ttm/ttm_bo_driver.h>
|
||||
#include <ttm/ttm_placement.h>
|
||||
#include <ttm/ttm_module.h>
|
||||
|
||||
#include "radeon_family.h"
|
||||
#include "radeon_mode.h"
|
||||
#include "radeon_reg.h"
|
||||
@@ -186,76 +189,60 @@ void radeon_fence_unref(struct radeon_fence **fence);
|
||||
* Tiling registers
|
||||
*/
|
||||
struct radeon_surface_reg {
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *bo;
|
||||
};
|
||||
|
||||
#define RADEON_GEM_MAX_SURFACES 8
|
||||
|
||||
/*
|
||||
* Radeon buffer.
|
||||
* TTM.
|
||||
*/
|
||||
struct radeon_object;
|
||||
struct radeon_mman {
|
||||
struct ttm_bo_global_ref bo_global_ref;
|
||||
struct ttm_global_reference mem_global_ref;
|
||||
bool mem_global_referenced;
|
||||
struct ttm_bo_device bdev;
|
||||
};
|
||||
|
||||
struct radeon_object_list {
|
||||
struct radeon_bo {
|
||||
/* Protected by gem.mutex */
|
||||
struct list_head list;
|
||||
/* Protected by tbo.reserved */
|
||||
struct ttm_buffer_object tbo;
|
||||
struct ttm_bo_kmap_obj kmap;
|
||||
unsigned pin_count;
|
||||
void *kptr;
|
||||
u32 tiling_flags;
|
||||
u32 pitch;
|
||||
int surface_reg;
|
||||
/* Constant after initialization */
|
||||
struct radeon_device *rdev;
|
||||
struct drm_gem_object *gobj;
|
||||
};
|
||||
|
||||
struct radeon_bo_list {
|
||||
struct list_head list;
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *bo;
|
||||
uint64_t gpu_offset;
|
||||
unsigned rdomain;
|
||||
unsigned wdomain;
|
||||
uint32_t tiling_flags;
|
||||
u32 tiling_flags;
|
||||
};
|
||||
|
||||
int radeon_object_init(struct radeon_device *rdev);
|
||||
void radeon_object_fini(struct radeon_device *rdev);
|
||||
int radeon_object_create(struct radeon_device *rdev,
|
||||
struct drm_gem_object *gobj,
|
||||
unsigned long size,
|
||||
bool kernel,
|
||||
uint32_t domain,
|
||||
bool interruptible,
|
||||
struct radeon_object **robj_ptr);
|
||||
int radeon_object_kmap(struct radeon_object *robj, void **ptr);
|
||||
void radeon_object_kunmap(struct radeon_object *robj);
|
||||
void radeon_object_unref(struct radeon_object **robj);
|
||||
int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
|
||||
uint64_t *gpu_addr);
|
||||
void radeon_object_unpin(struct radeon_object *robj);
|
||||
int radeon_object_wait(struct radeon_object *robj);
|
||||
int radeon_object_busy_domain(struct radeon_object *robj, uint32_t *cur_placement);
|
||||
int radeon_object_evict_vram(struct radeon_device *rdev);
|
||||
int radeon_object_mmap(struct radeon_object *robj, uint64_t *offset);
|
||||
void radeon_object_force_delete(struct radeon_device *rdev);
|
||||
void radeon_object_list_add_object(struct radeon_object_list *lobj,
|
||||
struct list_head *head);
|
||||
int radeon_object_list_validate(struct list_head *head, void *fence);
|
||||
void radeon_object_list_unvalidate(struct list_head *head);
|
||||
void radeon_object_list_clean(struct list_head *head);
|
||||
int radeon_object_fbdev_mmap(struct radeon_object *robj,
|
||||
struct vm_area_struct *vma);
|
||||
unsigned long radeon_object_size(struct radeon_object *robj);
|
||||
void radeon_object_clear_surface_reg(struct radeon_object *robj);
|
||||
int radeon_object_check_tiling(struct radeon_object *robj, bool has_moved,
|
||||
bool force_drop);
|
||||
void radeon_object_set_tiling_flags(struct radeon_object *robj,
|
||||
uint32_t tiling_flags, uint32_t pitch);
|
||||
void radeon_object_get_tiling_flags(struct radeon_object *robj, uint32_t *tiling_flags, uint32_t *pitch);
|
||||
void radeon_bo_move_notify(struct ttm_buffer_object *bo,
|
||||
struct ttm_mem_reg *mem);
|
||||
void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo);
|
||||
/*
|
||||
* GEM objects.
|
||||
*/
|
||||
struct radeon_gem {
|
||||
struct mutex mutex;
|
||||
struct list_head objects;
|
||||
};
|
||||
|
||||
int radeon_gem_init(struct radeon_device *rdev);
|
||||
void radeon_gem_fini(struct radeon_device *rdev);
|
||||
int radeon_gem_object_create(struct radeon_device *rdev, int size,
|
||||
int alignment, int initial_domain,
|
||||
bool discardable, bool kernel,
|
||||
bool interruptible,
|
||||
struct drm_gem_object **obj);
|
||||
int alignment, int initial_domain,
|
||||
bool discardable, bool kernel,
|
||||
struct drm_gem_object **obj);
|
||||
int radeon_gem_object_pin(struct drm_gem_object *obj, uint32_t pin_domain,
|
||||
uint64_t *gpu_addr);
|
||||
void radeon_gem_object_unpin(struct drm_gem_object *obj);
|
||||
@@ -271,7 +258,7 @@ struct radeon_gart_table_ram {
|
||||
};
|
||||
|
||||
struct radeon_gart_table_vram {
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
volatile uint32_t *ptr;
|
||||
};
|
||||
|
||||
@@ -352,11 +339,14 @@ struct radeon_irq {
|
||||
bool sw_int;
|
||||
/* FIXME: use a define max crtc rather than hardcode it */
|
||||
bool crtc_vblank_int[2];
|
||||
spinlock_t sw_lock;
|
||||
int sw_refcount;
|
||||
};
|
||||
|
||||
int radeon_irq_kms_init(struct radeon_device *rdev);
|
||||
void radeon_irq_kms_fini(struct radeon_device *rdev);
|
||||
|
||||
void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev);
|
||||
void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev);
|
||||
|
||||
/*
|
||||
* CP & ring.
|
||||
@@ -376,7 +366,7 @@ struct radeon_ib {
|
||||
*/
|
||||
struct radeon_ib_pool {
|
||||
struct mutex mutex;
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
struct list_head scheduled_ibs;
|
||||
struct radeon_ib ibs[RADEON_IB_POOL_SIZE];
|
||||
bool ready;
|
||||
@@ -384,7 +374,7 @@ struct radeon_ib_pool {
|
||||
};
|
||||
|
||||
struct radeon_cp {
|
||||
struct radeon_object *ring_obj;
|
||||
struct radeon_bo *ring_obj;
|
||||
volatile uint32_t *ring;
|
||||
unsigned rptr;
|
||||
unsigned wptr;
|
||||
@@ -399,8 +389,25 @@ struct radeon_cp {
|
||||
bool ready;
|
||||
};
|
||||
|
||||
/*
|
||||
* R6xx+ IH ring
|
||||
*/
|
||||
struct r600_ih {
|
||||
struct radeon_bo *ring_obj;
|
||||
volatile uint32_t *ring;
|
||||
unsigned rptr;
|
||||
unsigned wptr;
|
||||
unsigned wptr_old;
|
||||
unsigned ring_size;
|
||||
uint64_t gpu_addr;
|
||||
uint32_t align_mask;
|
||||
uint32_t ptr_mask;
|
||||
spinlock_t lock;
|
||||
bool enabled;
|
||||
};
|
||||
|
||||
struct r600_blit {
|
||||
struct radeon_object *shader_obj;
|
||||
struct radeon_bo *shader_obj;
|
||||
u64 shader_gpu_addr;
|
||||
u32 vs_offset, ps_offset;
|
||||
u32 state_offset;
|
||||
@@ -430,8 +437,8 @@ void radeon_ring_fini(struct radeon_device *rdev);
|
||||
*/
|
||||
struct radeon_cs_reloc {
|
||||
struct drm_gem_object *gobj;
|
||||
struct radeon_object *robj;
|
||||
struct radeon_object_list lobj;
|
||||
struct radeon_bo *robj;
|
||||
struct radeon_bo_list lobj;
|
||||
uint32_t handle;
|
||||
uint32_t flags;
|
||||
};
|
||||
@@ -527,7 +534,7 @@ void radeon_agp_fini(struct radeon_device *rdev);
|
||||
* Writeback
|
||||
*/
|
||||
struct radeon_wb {
|
||||
struct radeon_object *wb_obj;
|
||||
struct radeon_bo *wb_obj;
|
||||
volatile uint32_t *wb;
|
||||
uint64_t gpu_addr;
|
||||
};
|
||||
@@ -639,6 +646,7 @@ struct radeon_asic {
|
||||
uint32_t offset, uint32_t obj_size);
|
||||
int (*clear_surface_reg)(struct radeon_device *rdev, int reg);
|
||||
void (*bandwidth_update)(struct radeon_device *rdev);
|
||||
void (*hdp_flush)(struct radeon_device *rdev);
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -751,9 +759,9 @@ struct radeon_device {
|
||||
uint8_t *bios;
|
||||
bool is_atom_bios;
|
||||
uint16_t bios_header_start;
|
||||
struct radeon_object *stollen_vga_memory;
|
||||
struct radeon_bo *stollen_vga_memory;
|
||||
struct fb_info *fbdev_info;
|
||||
struct radeon_object *fbdev_robj;
|
||||
struct radeon_bo *fbdev_rbo;
|
||||
struct radeon_framebuffer *fbdev_rfb;
|
||||
/* Register mmio */
|
||||
resource_size_t rmmio_base;
|
||||
@@ -791,8 +799,10 @@ struct radeon_device {
|
||||
struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES];
|
||||
const struct firmware *me_fw; /* all family ME firmware */
|
||||
const struct firmware *pfp_fw; /* r6/700 PFP firmware */
|
||||
const struct firmware *rlc_fw; /* r6/700 RLC firmware */
|
||||
struct r600_blit r600_blit;
|
||||
int msi_enabled; /* msi enabled */
|
||||
struct r600_ih ih; /* r6/700 interrupt ring */
|
||||
};
|
||||
|
||||
int radeon_device_init(struct radeon_device *rdev,
|
||||
@@ -829,6 +839,10 @@ static inline void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Cast helper
|
||||
*/
|
||||
#define to_radeon_fence(p) ((struct radeon_fence *)(p))
|
||||
|
||||
/*
|
||||
* Registers read & write functions.
|
||||
@@ -965,18 +979,20 @@ static inline void radeon_ring_write(struct radeon_device *rdev, uint32_t v)
|
||||
#define radeon_get_engine_clock(rdev) (rdev)->asic->get_engine_clock((rdev))
|
||||
#define radeon_set_engine_clock(rdev, e) (rdev)->asic->set_engine_clock((rdev), (e))
|
||||
#define radeon_get_memory_clock(rdev) (rdev)->asic->get_memory_clock((rdev))
|
||||
#define radeon_set_memory_clock(rdev, e) (rdev)->asic->set_engine_clock((rdev), (e))
|
||||
#define radeon_set_memory_clock(rdev, e) (rdev)->asic->set_memory_clock((rdev), (e))
|
||||
#define radeon_set_pcie_lanes(rdev, l) (rdev)->asic->set_pcie_lanes((rdev), (l))
|
||||
#define radeon_set_clock_gating(rdev, e) (rdev)->asic->set_clock_gating((rdev), (e))
|
||||
#define radeon_set_surface_reg(rdev, r, f, p, o, s) ((rdev)->asic->set_surface_reg((rdev), (r), (f), (p), (o), (s)))
|
||||
#define radeon_clear_surface_reg(rdev, r) ((rdev)->asic->clear_surface_reg((rdev), (r)))
|
||||
#define radeon_bandwidth_update(rdev) (rdev)->asic->bandwidth_update((rdev))
|
||||
#define radeon_hdp_flush(rdev) (rdev)->asic->hdp_flush((rdev))
|
||||
|
||||
/* Common functions */
|
||||
extern int radeon_gart_table_vram_pin(struct radeon_device *rdev);
|
||||
extern int radeon_modeset_init(struct radeon_device *rdev);
|
||||
extern void radeon_modeset_fini(struct radeon_device *rdev);
|
||||
extern bool radeon_card_posted(struct radeon_device *rdev);
|
||||
extern bool radeon_boot_test_post_card(struct radeon_device *rdev);
|
||||
extern int radeon_clocks_init(struct radeon_device *rdev);
|
||||
extern void radeon_clocks_fini(struct radeon_device *rdev);
|
||||
extern void radeon_scratch_init(struct radeon_device *rdev);
|
||||
@@ -1021,7 +1037,7 @@ extern int r100_cp_reset(struct radeon_device *rdev);
|
||||
extern void r100_vga_render_disable(struct radeon_device *rdev);
|
||||
extern int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p,
|
||||
struct radeon_cs_packet *pkt,
|
||||
struct radeon_object *robj);
|
||||
struct radeon_bo *robj);
|
||||
extern int r100_cs_parse_packet0(struct radeon_cs_parser *p,
|
||||
struct radeon_cs_packet *pkt,
|
||||
const unsigned *auth, unsigned n,
|
||||
@@ -1029,6 +1045,8 @@ extern int r100_cs_parse_packet0(struct radeon_cs_parser *p,
|
||||
extern int r100_cs_packet_parse(struct radeon_cs_parser *p,
|
||||
struct radeon_cs_packet *pkt,
|
||||
unsigned idx);
|
||||
extern void r100_enable_bm(struct radeon_device *rdev);
|
||||
extern void r100_set_common_regs(struct radeon_device *rdev);
|
||||
|
||||
/* rv200,rv250,rv280 */
|
||||
extern void r200_set_safe_registers(struct radeon_device *rdev);
|
||||
@@ -1104,7 +1122,14 @@ extern void r600_wb_disable(struct radeon_device *rdev);
|
||||
extern void r600_scratch_init(struct radeon_device *rdev);
|
||||
extern int r600_blit_init(struct radeon_device *rdev);
|
||||
extern void r600_blit_fini(struct radeon_device *rdev);
|
||||
extern int r600_cp_init_microcode(struct radeon_device *rdev);
|
||||
extern int r600_init_microcode(struct radeon_device *rdev);
|
||||
extern int r600_gpu_reset(struct radeon_device *rdev);
|
||||
/* r600 irq */
|
||||
extern int r600_irq_init(struct radeon_device *rdev);
|
||||
extern void r600_irq_fini(struct radeon_device *rdev);
|
||||
extern void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size);
|
||||
extern int r600_irq_set(struct radeon_device *rdev);
|
||||
|
||||
#include "radeon_object.h"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -76,6 +76,7 @@ int r100_clear_surface_reg(struct radeon_device *rdev, int reg);
|
||||
void r100_bandwidth_update(struct radeon_device *rdev);
|
||||
void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib);
|
||||
int r100_ring_test(struct radeon_device *rdev);
|
||||
void r100_hdp_flush(struct radeon_device *rdev);
|
||||
|
||||
static struct radeon_asic r100_asic = {
|
||||
.init = &r100_init,
|
||||
@@ -107,6 +108,7 @@ static struct radeon_asic r100_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &r100_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -162,6 +164,7 @@ static struct radeon_asic r300_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &r100_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -201,6 +204,7 @@ static struct radeon_asic r420_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &r100_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -245,6 +249,7 @@ static struct radeon_asic rs400_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &r100_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -291,6 +296,7 @@ static struct radeon_asic rs600_asic = {
|
||||
.set_pcie_lanes = NULL,
|
||||
.set_clock_gating = &radeon_atom_set_clock_gating,
|
||||
.bandwidth_update = &rs600_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -334,6 +340,7 @@ static struct radeon_asic rs690_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &rs690_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -381,6 +388,7 @@ static struct radeon_asic rv515_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &rv515_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
|
||||
@@ -419,6 +427,7 @@ static struct radeon_asic r520_asic = {
|
||||
.set_surface_reg = r100_set_surface_reg,
|
||||
.clear_surface_reg = r100_clear_surface_reg,
|
||||
.bandwidth_update = &rv515_bandwidth_update,
|
||||
.hdp_flush = &r100_hdp_flush,
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -455,6 +464,7 @@ int r600_ring_test(struct radeon_device *rdev);
|
||||
int r600_copy_blit(struct radeon_device *rdev,
|
||||
uint64_t src_offset, uint64_t dst_offset,
|
||||
unsigned num_pages, struct radeon_fence *fence);
|
||||
void r600_hdp_flush(struct radeon_device *rdev);
|
||||
|
||||
static struct radeon_asic r600_asic = {
|
||||
.init = &r600_init,
|
||||
@@ -470,6 +480,7 @@ static struct radeon_asic r600_asic = {
|
||||
.ring_ib_execute = &r600_ring_ib_execute,
|
||||
.irq_set = &r600_irq_set,
|
||||
.irq_process = &r600_irq_process,
|
||||
.get_vblank_counter = &rs600_get_vblank_counter,
|
||||
.fence_ring_emit = &r600_fence_ring_emit,
|
||||
.cs_parse = &r600_cs_parse,
|
||||
.copy_blit = &r600_copy_blit,
|
||||
@@ -484,6 +495,7 @@ static struct radeon_asic r600_asic = {
|
||||
.set_surface_reg = r600_set_surface_reg,
|
||||
.clear_surface_reg = r600_clear_surface_reg,
|
||||
.bandwidth_update = &rv515_bandwidth_update,
|
||||
.hdp_flush = &r600_hdp_flush,
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -509,6 +521,7 @@ static struct radeon_asic rv770_asic = {
|
||||
.ring_ib_execute = &r600_ring_ib_execute,
|
||||
.irq_set = &r600_irq_set,
|
||||
.irq_process = &r600_irq_process,
|
||||
.get_vblank_counter = &rs600_get_vblank_counter,
|
||||
.fence_ring_emit = &r600_fence_ring_emit,
|
||||
.cs_parse = &r600_cs_parse,
|
||||
.copy_blit = &r600_copy_blit,
|
||||
@@ -523,6 +536,7 @@ static struct radeon_asic rv770_asic = {
|
||||
.set_surface_reg = r600_set_surface_reg,
|
||||
.clear_surface_reg = r600_clear_surface_reg,
|
||||
.bandwidth_update = &rv515_bandwidth_update,
|
||||
.hdp_flush = &r600_hdp_flush,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -82,18 +82,18 @@ static inline struct radeon_i2c_bus_rec radeon_lookup_gpio(struct drm_device
|
||||
|
||||
i2c.mask_clk_reg = le16_to_cpu(gpio.usClkMaskRegisterIndex) * 4;
|
||||
i2c.mask_data_reg = le16_to_cpu(gpio.usDataMaskRegisterIndex) * 4;
|
||||
i2c.put_clk_reg = le16_to_cpu(gpio.usClkEnRegisterIndex) * 4;
|
||||
i2c.put_data_reg = le16_to_cpu(gpio.usDataEnRegisterIndex) * 4;
|
||||
i2c.get_clk_reg = le16_to_cpu(gpio.usClkY_RegisterIndex) * 4;
|
||||
i2c.get_data_reg = le16_to_cpu(gpio.usDataY_RegisterIndex) * 4;
|
||||
i2c.en_clk_reg = le16_to_cpu(gpio.usClkEnRegisterIndex) * 4;
|
||||
i2c.en_data_reg = le16_to_cpu(gpio.usDataEnRegisterIndex) * 4;
|
||||
i2c.y_clk_reg = le16_to_cpu(gpio.usClkY_RegisterIndex) * 4;
|
||||
i2c.y_data_reg = le16_to_cpu(gpio.usDataY_RegisterIndex) * 4;
|
||||
i2c.a_clk_reg = le16_to_cpu(gpio.usClkA_RegisterIndex) * 4;
|
||||
i2c.a_data_reg = le16_to_cpu(gpio.usDataA_RegisterIndex) * 4;
|
||||
i2c.mask_clk_mask = (1 << gpio.ucClkMaskShift);
|
||||
i2c.mask_data_mask = (1 << gpio.ucDataMaskShift);
|
||||
i2c.put_clk_mask = (1 << gpio.ucClkEnShift);
|
||||
i2c.put_data_mask = (1 << gpio.ucDataEnShift);
|
||||
i2c.get_clk_mask = (1 << gpio.ucClkY_Shift);
|
||||
i2c.get_data_mask = (1 << gpio.ucDataY_Shift);
|
||||
i2c.en_clk_mask = (1 << gpio.ucClkEnShift);
|
||||
i2c.en_data_mask = (1 << gpio.ucDataEnShift);
|
||||
i2c.y_clk_mask = (1 << gpio.ucClkY_Shift);
|
||||
i2c.y_data_mask = (1 << gpio.ucDataY_Shift);
|
||||
i2c.a_clk_mask = (1 << gpio.ucClkA_Shift);
|
||||
i2c.a_data_mask = (1 << gpio.ucDataA_Shift);
|
||||
i2c.valid = true;
|
||||
@@ -135,6 +135,23 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
|
||||
}
|
||||
}
|
||||
|
||||
/* HIS X1300 is DVI+VGA, not DVI+DVI */
|
||||
if ((dev->pdev->device == 0x7146) &&
|
||||
(dev->pdev->subsystem_vendor == 0x17af) &&
|
||||
(dev->pdev->subsystem_device == 0x2058)) {
|
||||
if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
|
||||
if ((dev->pdev->device == 0x7142) &&
|
||||
(dev->pdev->subsystem_vendor == 0x1458) &&
|
||||
(dev->pdev->subsystem_device == 0x2134)) {
|
||||
if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/* Funky macbooks */
|
||||
if ((dev->pdev->device == 0x71C5) &&
|
||||
(dev->pdev->subsystem_vendor == 0x106b) &&
|
||||
@@ -172,6 +189,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
|
||||
}
|
||||
}
|
||||
|
||||
/* Acer laptop reports DVI-D as DVI-I */
|
||||
if ((dev->pdev->device == 0x95c4) &&
|
||||
(dev->pdev->subsystem_vendor == 0x1025) &&
|
||||
(dev->pdev->subsystem_device == 0x013c)) {
|
||||
if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
|
||||
(supported_device == ATOM_DEVICE_DFP1_SUPPORT))
|
||||
*connector_type = DRM_MODE_CONNECTOR_DVID;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -901,7 +927,7 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
struct radeon_mode_info *mode_info = &rdev->mode_info;
|
||||
int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
|
||||
uint16_t data_offset;
|
||||
uint16_t data_offset, misc;
|
||||
union lvds_info *lvds_info;
|
||||
uint8_t frev, crev;
|
||||
struct radeon_encoder_atom_dig *lvds = NULL;
|
||||
@@ -940,6 +966,19 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
|
||||
lvds->panel_pwr_delay =
|
||||
le16_to_cpu(lvds_info->info.usOffDelayInMs);
|
||||
lvds->lvds_misc = lvds_info->info.ucLVDS_Misc;
|
||||
|
||||
misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
|
||||
if (misc & ATOM_VSYNC_POLARITY)
|
||||
lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
|
||||
if (misc & ATOM_HSYNC_POLARITY)
|
||||
lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
|
||||
if (misc & ATOM_COMPOSITESYNC)
|
||||
lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
|
||||
if (misc & ATOM_INTERLACE)
|
||||
lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
|
||||
if (misc & ATOM_DOUBLE_CLOCK_MODE)
|
||||
lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
|
||||
|
||||
/* set crtc values */
|
||||
drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
|
||||
|
||||
|
||||
@@ -29,8 +29,8 @@
|
||||
void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
|
||||
unsigned sdomain, unsigned ddomain)
|
||||
{
|
||||
struct radeon_object *dobj = NULL;
|
||||
struct radeon_object *sobj = NULL;
|
||||
struct radeon_bo *dobj = NULL;
|
||||
struct radeon_bo *sobj = NULL;
|
||||
struct radeon_fence *fence = NULL;
|
||||
uint64_t saddr, daddr;
|
||||
unsigned long start_jiffies;
|
||||
@@ -41,19 +41,27 @@ void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
|
||||
|
||||
size = bsize;
|
||||
n = 1024;
|
||||
r = radeon_object_create(rdev, NULL, size, true, sdomain, false, &sobj);
|
||||
r = radeon_bo_create(rdev, NULL, size, true, sdomain, &sobj);
|
||||
if (r) {
|
||||
goto out_cleanup;
|
||||
}
|
||||
r = radeon_object_pin(sobj, sdomain, &saddr);
|
||||
r = radeon_bo_reserve(sobj, false);
|
||||
if (unlikely(r != 0))
|
||||
goto out_cleanup;
|
||||
r = radeon_bo_pin(sobj, sdomain, &saddr);
|
||||
radeon_bo_unreserve(sobj);
|
||||
if (r) {
|
||||
goto out_cleanup;
|
||||
}
|
||||
r = radeon_object_create(rdev, NULL, size, true, ddomain, false, &dobj);
|
||||
r = radeon_bo_create(rdev, NULL, size, true, ddomain, &dobj);
|
||||
if (r) {
|
||||
goto out_cleanup;
|
||||
}
|
||||
r = radeon_object_pin(dobj, ddomain, &daddr);
|
||||
r = radeon_bo_reserve(dobj, false);
|
||||
if (unlikely(r != 0))
|
||||
goto out_cleanup;
|
||||
r = radeon_bo_pin(dobj, ddomain, &daddr);
|
||||
radeon_bo_unreserve(dobj);
|
||||
if (r) {
|
||||
goto out_cleanup;
|
||||
}
|
||||
@@ -109,12 +117,20 @@ void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
|
||||
}
|
||||
out_cleanup:
|
||||
if (sobj) {
|
||||
radeon_object_unpin(sobj);
|
||||
radeon_object_unref(&sobj);
|
||||
r = radeon_bo_reserve(sobj, false);
|
||||
if (likely(r == 0)) {
|
||||
radeon_bo_unpin(sobj);
|
||||
radeon_bo_unreserve(sobj);
|
||||
}
|
||||
radeon_bo_unref(&sobj);
|
||||
}
|
||||
if (dobj) {
|
||||
radeon_object_unpin(dobj);
|
||||
radeon_object_unref(&dobj);
|
||||
r = radeon_bo_reserve(dobj, false);
|
||||
if (likely(r == 0)) {
|
||||
radeon_bo_unpin(dobj);
|
||||
radeon_bo_unreserve(dobj);
|
||||
}
|
||||
radeon_bo_unref(&dobj);
|
||||
}
|
||||
if (fence) {
|
||||
radeon_fence_unref(&fence);
|
||||
|
||||
@@ -44,6 +44,10 @@ uint32_t radeon_legacy_get_engine_clock(struct radeon_device *rdev)
|
||||
|
||||
ref_div =
|
||||
RREG32_PLL(RADEON_M_SPLL_REF_FB_DIV) & RADEON_M_SPLL_REF_DIV_MASK;
|
||||
|
||||
if (ref_div == 0)
|
||||
return 0;
|
||||
|
||||
sclk = fb_div / ref_div;
|
||||
|
||||
post_div = RREG32_PLL(RADEON_SCLK_CNTL) & RADEON_SCLK_SRC_SEL_MASK;
|
||||
@@ -70,6 +74,10 @@ static uint32_t radeon_legacy_get_memory_clock(struct radeon_device *rdev)
|
||||
|
||||
ref_div =
|
||||
RREG32_PLL(RADEON_M_SPLL_REF_FB_DIV) & RADEON_M_SPLL_REF_DIV_MASK;
|
||||
|
||||
if (ref_div == 0)
|
||||
return 0;
|
||||
|
||||
mclk = fb_div / ref_div;
|
||||
|
||||
post_div = RREG32_PLL(RADEON_MCLK_CNTL) & 0x7;
|
||||
@@ -98,8 +106,19 @@ void radeon_get_clock_info(struct drm_device *dev)
|
||||
ret = radeon_combios_get_clock_info(dev);
|
||||
|
||||
if (ret) {
|
||||
if (p1pll->reference_div < 2)
|
||||
p1pll->reference_div = 12;
|
||||
if (p1pll->reference_div < 2) {
|
||||
if (!ASIC_IS_AVIVO(rdev)) {
|
||||
u32 tmp = RREG32_PLL(RADEON_PPLL_REF_DIV);
|
||||
if (ASIC_IS_R300(rdev))
|
||||
p1pll->reference_div =
|
||||
(tmp & R300_PPLL_REF_DIV_ACC_MASK) >> R300_PPLL_REF_DIV_ACC_SHIFT;
|
||||
else
|
||||
p1pll->reference_div = tmp & RADEON_PPLL_REF_DIV_MASK;
|
||||
if (p1pll->reference_div < 2)
|
||||
p1pll->reference_div = 12;
|
||||
} else
|
||||
p1pll->reference_div = 12;
|
||||
}
|
||||
if (p2pll->reference_div < 2)
|
||||
p2pll->reference_div = 12;
|
||||
if (rdev->family < CHIP_RS600) {
|
||||
|
||||
@@ -450,29 +450,29 @@ struct radeon_i2c_bus_rec combios_setup_i2c_bus(int ddc_line)
|
||||
i2c.mask_data_mask = RADEON_GPIO_EN_0;
|
||||
i2c.a_clk_mask = RADEON_GPIO_A_1;
|
||||
i2c.a_data_mask = RADEON_GPIO_A_0;
|
||||
i2c.put_clk_mask = RADEON_GPIO_EN_1;
|
||||
i2c.put_data_mask = RADEON_GPIO_EN_0;
|
||||
i2c.get_clk_mask = RADEON_GPIO_Y_1;
|
||||
i2c.get_data_mask = RADEON_GPIO_Y_0;
|
||||
i2c.en_clk_mask = RADEON_GPIO_EN_1;
|
||||
i2c.en_data_mask = RADEON_GPIO_EN_0;
|
||||
i2c.y_clk_mask = RADEON_GPIO_Y_1;
|
||||
i2c.y_data_mask = RADEON_GPIO_Y_0;
|
||||
if ((ddc_line == RADEON_LCD_GPIO_MASK) ||
|
||||
(ddc_line == RADEON_MDGPIO_EN_REG)) {
|
||||
i2c.mask_clk_reg = ddc_line;
|
||||
i2c.mask_data_reg = ddc_line;
|
||||
i2c.a_clk_reg = ddc_line;
|
||||
i2c.a_data_reg = ddc_line;
|
||||
i2c.put_clk_reg = ddc_line;
|
||||
i2c.put_data_reg = ddc_line;
|
||||
i2c.get_clk_reg = ddc_line + 4;
|
||||
i2c.get_data_reg = ddc_line + 4;
|
||||
i2c.en_clk_reg = ddc_line;
|
||||
i2c.en_data_reg = ddc_line;
|
||||
i2c.y_clk_reg = ddc_line + 4;
|
||||
i2c.y_data_reg = ddc_line + 4;
|
||||
} else {
|
||||
i2c.mask_clk_reg = ddc_line;
|
||||
i2c.mask_data_reg = ddc_line;
|
||||
i2c.a_clk_reg = ddc_line;
|
||||
i2c.a_data_reg = ddc_line;
|
||||
i2c.put_clk_reg = ddc_line;
|
||||
i2c.put_data_reg = ddc_line;
|
||||
i2c.get_clk_reg = ddc_line;
|
||||
i2c.get_data_reg = ddc_line;
|
||||
i2c.en_clk_reg = ddc_line;
|
||||
i2c.en_data_reg = ddc_line;
|
||||
i2c.y_clk_reg = ddc_line;
|
||||
i2c.y_data_reg = ddc_line;
|
||||
}
|
||||
|
||||
if (ddc_line)
|
||||
@@ -495,7 +495,7 @@ bool radeon_combios_get_clock_info(struct drm_device *dev)
|
||||
uint16_t sclk, mclk;
|
||||
|
||||
if (rdev->bios == NULL)
|
||||
return NULL;
|
||||
return false;
|
||||
|
||||
pll_info = combios_get_table_offset(dev, COMBIOS_PLL_INFO_TABLE);
|
||||
if (pll_info) {
|
||||
@@ -993,8 +993,8 @@ static const struct radeon_tmds_pll default_tmds_pll[CHIP_LAST][4] = {
|
||||
{{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}}, /* CHIP_R420 */
|
||||
{{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}}, /* CHIP_R423 */
|
||||
{{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}}, /* CHIP_RV410 */
|
||||
{{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}}, /* CHIP_RS400 */
|
||||
{{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}}, /* CHIP_RS480 */
|
||||
{ {0, 0}, {0, 0}, {0, 0}, {0, 0} }, /* CHIP_RS400 */
|
||||
{ {0, 0}, {0, 0}, {0, 0}, {0, 0} }, /* CHIP_RS480 */
|
||||
};
|
||||
|
||||
bool radeon_legacy_get_tmds_info_from_table(struct radeon_encoder *encoder,
|
||||
@@ -1028,7 +1028,6 @@ bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
|
||||
tmds_info = combios_get_table_offset(dev, COMBIOS_DFP_INFO_TABLE);
|
||||
|
||||
if (tmds_info) {
|
||||
|
||||
ver = RBIOS8(tmds_info);
|
||||
DRM_INFO("DFP table revision: %d\n", ver);
|
||||
if (ver == 3) {
|
||||
@@ -1063,45 +1062,132 @@ bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
|
||||
tmds->tmds_pll[i].value);
|
||||
}
|
||||
}
|
||||
} else
|
||||
} else {
|
||||
DRM_INFO("No TMDS info found in BIOS\n");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
struct radeon_encoder_int_tmds *radeon_combios_get_tmds_info(struct radeon_encoder *encoder)
|
||||
{
|
||||
struct radeon_encoder_int_tmds *tmds = NULL;
|
||||
bool ret;
|
||||
|
||||
tmds = kzalloc(sizeof(struct radeon_encoder_int_tmds), GFP_KERNEL);
|
||||
|
||||
if (!tmds)
|
||||
return NULL;
|
||||
|
||||
ret = radeon_legacy_get_tmds_info_from_combios(encoder, tmds);
|
||||
if (ret == false)
|
||||
radeon_legacy_get_tmds_info_from_table(encoder, tmds);
|
||||
|
||||
return tmds;
|
||||
}
|
||||
|
||||
void radeon_combios_get_ext_tmds_info(struct radeon_encoder *encoder)
|
||||
bool radeon_legacy_get_ext_tmds_info_from_table(struct radeon_encoder *encoder,
|
||||
struct radeon_encoder_ext_tmds *tmds)
|
||||
{
|
||||
struct drm_device *dev = encoder->base.dev;
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
uint16_t ext_tmds_info;
|
||||
uint8_t ver;
|
||||
struct radeon_i2c_bus_rec i2c_bus;
|
||||
|
||||
/* default for macs */
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_MONID);
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
|
||||
/* XXX some macs have duallink chips */
|
||||
switch (rdev->mode_info.connector_table) {
|
||||
case CT_POWERBOOK_EXTERNAL:
|
||||
case CT_MINI_EXTERNAL:
|
||||
default:
|
||||
tmds->dvo_chip = DVO_SIL164;
|
||||
tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder,
|
||||
struct radeon_encoder_ext_tmds *tmds)
|
||||
{
|
||||
struct drm_device *dev = encoder->base.dev;
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
uint16_t offset;
|
||||
uint8_t ver, id, blocks, clk, data;
|
||||
int i;
|
||||
enum radeon_combios_ddc gpio;
|
||||
struct radeon_i2c_bus_rec i2c_bus;
|
||||
|
||||
if (rdev->bios == NULL)
|
||||
return;
|
||||
return false;
|
||||
|
||||
ext_tmds_info =
|
||||
combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
|
||||
if (ext_tmds_info) {
|
||||
ver = RBIOS8(ext_tmds_info);
|
||||
DRM_INFO("External TMDS Table revision: %d\n", ver);
|
||||
// TODO
|
||||
tmds->i2c_bus = NULL;
|
||||
if (rdev->flags & RADEON_IS_IGP) {
|
||||
offset = combios_get_table_offset(dev, COMBIOS_I2C_INFO_TABLE);
|
||||
if (offset) {
|
||||
ver = RBIOS8(offset);
|
||||
DRM_INFO("GPIO Table revision: %d\n", ver);
|
||||
blocks = RBIOS8(offset + 2);
|
||||
for (i = 0; i < blocks; i++) {
|
||||
id = RBIOS8(offset + 3 + (i * 5) + 0);
|
||||
if (id == 136) {
|
||||
clk = RBIOS8(offset + 3 + (i * 5) + 3);
|
||||
data = RBIOS8(offset + 3 + (i * 5) + 4);
|
||||
i2c_bus.valid = true;
|
||||
i2c_bus.mask_clk_mask = (1 << clk);
|
||||
i2c_bus.mask_data_mask = (1 << data);
|
||||
i2c_bus.a_clk_mask = (1 << clk);
|
||||
i2c_bus.a_data_mask = (1 << data);
|
||||
i2c_bus.en_clk_mask = (1 << clk);
|
||||
i2c_bus.en_data_mask = (1 << data);
|
||||
i2c_bus.y_clk_mask = (1 << clk);
|
||||
i2c_bus.y_data_mask = (1 << data);
|
||||
i2c_bus.mask_clk_reg = RADEON_GPIOPAD_MASK;
|
||||
i2c_bus.mask_data_reg = RADEON_GPIOPAD_MASK;
|
||||
i2c_bus.a_clk_reg = RADEON_GPIOPAD_A;
|
||||
i2c_bus.a_data_reg = RADEON_GPIOPAD_A;
|
||||
i2c_bus.en_clk_reg = RADEON_GPIOPAD_EN;
|
||||
i2c_bus.en_data_reg = RADEON_GPIOPAD_EN;
|
||||
i2c_bus.y_clk_reg = RADEON_GPIOPAD_Y;
|
||||
i2c_bus.y_data_reg = RADEON_GPIOPAD_Y;
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
tmds->dvo_chip = DVO_SIL164;
|
||||
tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
|
||||
if (offset) {
|
||||
ver = RBIOS8(offset);
|
||||
DRM_INFO("External TMDS Table revision: %d\n", ver);
|
||||
tmds->slave_addr = RBIOS8(offset + 4 + 2);
|
||||
tmds->slave_addr >>= 1; /* 7 bit addressing */
|
||||
gpio = RBIOS8(offset + 4 + 3);
|
||||
switch (gpio) {
|
||||
case DDC_MONID:
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_MONID);
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
break;
|
||||
case DDC_DVI:
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
break;
|
||||
case DDC_VGA:
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
break;
|
||||
case DDC_CRT2:
|
||||
/* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
|
||||
if (rdev->family >= CHIP_R300)
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_MONID);
|
||||
else
|
||||
i2c_bus = combios_setup_i2c_bus(RADEON_GPIO_CRT2_DDC);
|
||||
tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
|
||||
break;
|
||||
case DDC_LCD: /* MM i2c */
|
||||
DRM_ERROR("MM i2c requires hw i2c engine\n");
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Unsupported gpio %d\n", gpio);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!tmds->i2c_bus) {
|
||||
DRM_INFO("No valid Ext TMDS info found in BIOS\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
|
||||
@@ -1567,20 +1653,25 @@ static bool radeon_apply_legacy_quirks(struct drm_device *dev,
|
||||
ddc_i2c->mask_data_mask = 0x80;
|
||||
ddc_i2c->a_clk_mask = (0x20 << 8);
|
||||
ddc_i2c->a_data_mask = 0x80;
|
||||
ddc_i2c->put_clk_mask = (0x20 << 8);
|
||||
ddc_i2c->put_data_mask = 0x80;
|
||||
ddc_i2c->get_clk_mask = (0x20 << 8);
|
||||
ddc_i2c->get_data_mask = 0x80;
|
||||
ddc_i2c->en_clk_mask = (0x20 << 8);
|
||||
ddc_i2c->en_data_mask = 0x80;
|
||||
ddc_i2c->y_clk_mask = (0x20 << 8);
|
||||
ddc_i2c->y_data_mask = 0x80;
|
||||
ddc_i2c->mask_clk_reg = RADEON_GPIOPAD_MASK;
|
||||
ddc_i2c->mask_data_reg = RADEON_GPIOPAD_MASK;
|
||||
ddc_i2c->a_clk_reg = RADEON_GPIOPAD_A;
|
||||
ddc_i2c->a_data_reg = RADEON_GPIOPAD_A;
|
||||
ddc_i2c->put_clk_reg = RADEON_GPIOPAD_EN;
|
||||
ddc_i2c->put_data_reg = RADEON_GPIOPAD_EN;
|
||||
ddc_i2c->get_clk_reg = RADEON_LCD_GPIO_Y_REG;
|
||||
ddc_i2c->get_data_reg = RADEON_LCD_GPIO_Y_REG;
|
||||
ddc_i2c->en_clk_reg = RADEON_GPIOPAD_EN;
|
||||
ddc_i2c->en_data_reg = RADEON_GPIOPAD_EN;
|
||||
ddc_i2c->y_clk_reg = RADEON_GPIOPAD_Y;
|
||||
ddc_i2c->y_data_reg = RADEON_GPIOPAD_Y;
|
||||
}
|
||||
|
||||
/* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
|
||||
if ((rdev->family >= CHIP_R300) &&
|
||||
ddc_i2c->mask_clk_reg == RADEON_GPIO_CRT2_DDC)
|
||||
*ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
|
||||
|
||||
/* Certain IBM chipset RN50s have a BIOS reporting two VGAs,
|
||||
one with VGA DDC and one with CRT2 DDC. - kill the CRT2 DDC one */
|
||||
if (dev->pdev->device == 0x515e &&
|
||||
@@ -1624,6 +1715,12 @@ static bool radeon_apply_legacy_tv_quirks(struct drm_device *dev)
|
||||
dev->pdev->subsystem_device == 0x280a)
|
||||
return false;
|
||||
|
||||
/* MSI S270 has non-existent TV port */
|
||||
if (dev->pdev->device == 0x5955 &&
|
||||
dev->pdev->subsystem_vendor == 0x1462 &&
|
||||
dev->pdev->subsystem_device == 0x0131)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1939,13 +2036,13 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.a_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
ddc_i2c.put_clk_mask =
|
||||
ddc_i2c.en_clk_mask =
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.put_data_mask =
|
||||
ddc_i2c.en_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
ddc_i2c.get_clk_mask =
|
||||
ddc_i2c.y_clk_mask =
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.get_data_mask =
|
||||
ddc_i2c.y_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
break;
|
||||
case DDC_GPIO:
|
||||
@@ -1960,13 +2057,13 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.a_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
ddc_i2c.put_clk_mask =
|
||||
ddc_i2c.en_clk_mask =
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.put_data_mask =
|
||||
ddc_i2c.en_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
ddc_i2c.get_clk_mask =
|
||||
ddc_i2c.y_clk_mask =
|
||||
RBIOS32(lcd_ddc_info + 3);
|
||||
ddc_i2c.get_data_mask =
|
||||
ddc_i2c.y_data_mask =
|
||||
RBIOS32(lcd_ddc_info + 7);
|
||||
break;
|
||||
default:
|
||||
@@ -2014,6 +2111,193 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
|
||||
return true;
|
||||
}
|
||||
|
||||
void radeon_external_tmds_setup(struct drm_encoder *encoder)
|
||||
{
|
||||
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
||||
struct radeon_encoder_ext_tmds *tmds = radeon_encoder->enc_priv;
|
||||
|
||||
if (!tmds)
|
||||
return;
|
||||
|
||||
switch (tmds->dvo_chip) {
|
||||
case DVO_SIL164:
|
||||
/* sil 164 */
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 1);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
0x08, 0x30);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
0x09, 0x00);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
0x0a, 0x90);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
0x0c, 0x89);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
0x08, 0x3b);
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 0);
|
||||
break;
|
||||
case DVO_SIL1178:
|
||||
/* sil 1178 - untested */
|
||||
/*
|
||||
* 0x0f, 0x44
|
||||
* 0x0f, 0x4c
|
||||
* 0x0e, 0x01
|
||||
* 0x0a, 0x80
|
||||
* 0x09, 0x30
|
||||
* 0x0c, 0xc9
|
||||
* 0x0d, 0x70
|
||||
* 0x08, 0x32
|
||||
* 0x08, 0x33
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool radeon_combios_external_tmds_setup(struct drm_encoder *encoder)
|
||||
{
|
||||
struct drm_device *dev = encoder->dev;
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
||||
uint16_t offset;
|
||||
uint8_t blocks, slave_addr, rev;
|
||||
uint32_t index, id;
|
||||
uint32_t reg, val, and_mask, or_mask;
|
||||
struct radeon_encoder_ext_tmds *tmds = radeon_encoder->enc_priv;
|
||||
|
||||
if (rdev->bios == NULL)
|
||||
return false;
|
||||
|
||||
if (!tmds)
|
||||
return false;
|
||||
|
||||
if (rdev->flags & RADEON_IS_IGP) {
|
||||
offset = combios_get_table_offset(dev, COMBIOS_TMDS_POWER_ON_TABLE);
|
||||
rev = RBIOS8(offset);
|
||||
if (offset) {
|
||||
rev = RBIOS8(offset);
|
||||
if (rev > 1) {
|
||||
blocks = RBIOS8(offset + 3);
|
||||
index = offset + 4;
|
||||
while (blocks > 0) {
|
||||
id = RBIOS16(index);
|
||||
index += 2;
|
||||
switch (id >> 13) {
|
||||
case 0:
|
||||
reg = (id & 0x1fff) * 4;
|
||||
val = RBIOS32(index);
|
||||
index += 4;
|
||||
WREG32(reg, val);
|
||||
break;
|
||||
case 2:
|
||||
reg = (id & 0x1fff) * 4;
|
||||
and_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
or_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
val = RREG32(reg);
|
||||
val = (val & and_mask) | or_mask;
|
||||
WREG32(reg, val);
|
||||
break;
|
||||
case 3:
|
||||
val = RBIOS16(index);
|
||||
index += 2;
|
||||
udelay(val);
|
||||
break;
|
||||
case 4:
|
||||
val = RBIOS16(index);
|
||||
index += 2;
|
||||
udelay(val * 1000);
|
||||
break;
|
||||
case 6:
|
||||
slave_addr = id & 0xff;
|
||||
slave_addr >>= 1; /* 7 bit addressing */
|
||||
index++;
|
||||
reg = RBIOS8(index);
|
||||
index++;
|
||||
val = RBIOS8(index);
|
||||
index++;
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 1);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
slave_addr,
|
||||
reg, val);
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 0);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Unknown id %d\n", id >> 13);
|
||||
break;
|
||||
}
|
||||
blocks--;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
|
||||
if (offset) {
|
||||
index = offset + 10;
|
||||
id = RBIOS16(index);
|
||||
while (id != 0xffff) {
|
||||
index += 2;
|
||||
switch (id >> 13) {
|
||||
case 0:
|
||||
reg = (id & 0x1fff) * 4;
|
||||
val = RBIOS32(index);
|
||||
WREG32(reg, val);
|
||||
break;
|
||||
case 2:
|
||||
reg = (id & 0x1fff) * 4;
|
||||
and_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
or_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
val = RREG32(reg);
|
||||
val = (val & and_mask) | or_mask;
|
||||
WREG32(reg, val);
|
||||
break;
|
||||
case 4:
|
||||
val = RBIOS16(index);
|
||||
index += 2;
|
||||
udelay(val);
|
||||
break;
|
||||
case 5:
|
||||
reg = id & 0x1fff;
|
||||
and_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
or_mask = RBIOS32(index);
|
||||
index += 4;
|
||||
val = RREG32_PLL(reg);
|
||||
val = (val & and_mask) | or_mask;
|
||||
WREG32_PLL(reg, val);
|
||||
break;
|
||||
case 6:
|
||||
reg = id & 0x1fff;
|
||||
val = RBIOS8(index);
|
||||
index += 1;
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 1);
|
||||
radeon_i2c_sw_put_byte(tmds->i2c_bus,
|
||||
tmds->slave_addr,
|
||||
reg, val);
|
||||
radeon_i2c_do_lock(tmds->i2c_bus, 0);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Unknown id %d\n", id >> 13);
|
||||
break;
|
||||
}
|
||||
id = RBIOS16(index);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void combios_parse_mmio_table(struct drm_device *dev, uint16_t offset)
|
||||
{
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
|
||||
@@ -445,10 +445,10 @@ static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connec
|
||||
ret = connector_status_connected;
|
||||
else {
|
||||
if (radeon_connector->ddc_bus) {
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
||||
&radeon_connector->ddc_bus->adapter);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
if (radeon_connector->edid)
|
||||
ret = connector_status_connected;
|
||||
}
|
||||
@@ -553,17 +553,17 @@ static enum drm_connector_status radeon_vga_detect(struct drm_connector *connect
|
||||
if (!encoder)
|
||||
ret = connector_status_disconnected;
|
||||
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
dret = radeon_ddc_probe(radeon_connector);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
if (dret) {
|
||||
if (radeon_connector->edid) {
|
||||
kfree(radeon_connector->edid);
|
||||
radeon_connector->edid = NULL;
|
||||
}
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
|
||||
if (!radeon_connector->edid) {
|
||||
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
||||
@@ -708,17 +708,17 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
|
||||
enum drm_connector_status ret = connector_status_disconnected;
|
||||
bool dret;
|
||||
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
dret = radeon_ddc_probe(radeon_connector);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
if (dret) {
|
||||
if (radeon_connector->edid) {
|
||||
kfree(radeon_connector->edid);
|
||||
radeon_connector->edid = NULL;
|
||||
}
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
|
||||
if (!radeon_connector->edid) {
|
||||
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
||||
@@ -735,6 +735,39 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
|
||||
ret = connector_status_disconnected;
|
||||
} else
|
||||
ret = connector_status_connected;
|
||||
|
||||
/* multiple connectors on the same encoder with the same ddc line
|
||||
* This tends to be HDMI and DVI on the same encoder with the
|
||||
* same ddc line. If the edid says HDMI, consider the HDMI port
|
||||
* connected and the DVI port disconnected. If the edid doesn't
|
||||
* say HDMI, vice versa.
|
||||
*/
|
||||
if (radeon_connector->shared_ddc && connector_status_connected) {
|
||||
struct drm_device *dev = connector->dev;
|
||||
struct drm_connector *list_connector;
|
||||
struct radeon_connector *list_radeon_connector;
|
||||
list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
|
||||
if (connector == list_connector)
|
||||
continue;
|
||||
list_radeon_connector = to_radeon_connector(list_connector);
|
||||
if (radeon_connector->devices == list_radeon_connector->devices) {
|
||||
if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
|
||||
if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
|
||||
kfree(radeon_connector->edid);
|
||||
radeon_connector->edid = NULL;
|
||||
ret = connector_status_disconnected;
|
||||
}
|
||||
} else {
|
||||
if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
|
||||
(connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
|
||||
kfree(radeon_connector->edid);
|
||||
radeon_connector->edid = NULL;
|
||||
ret = connector_status_disconnected;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1020,6 +1053,9 @@ radeon_add_atom_connector(struct drm_device *dev,
|
||||
drm_connector_attach_property(&radeon_connector->base,
|
||||
rdev->mode_info.load_detect_property,
|
||||
1);
|
||||
drm_connector_attach_property(&radeon_connector->base,
|
||||
rdev->mode_info.tv_std_property,
|
||||
1);
|
||||
}
|
||||
break;
|
||||
case DRM_MODE_CONNECTOR_LVDS:
|
||||
@@ -1160,6 +1196,9 @@ radeon_add_legacy_connector(struct drm_device *dev,
|
||||
drm_connector_attach_property(&radeon_connector->base,
|
||||
rdev->mode_info.load_detect_property,
|
||||
1);
|
||||
drm_connector_attach_property(&radeon_connector->base,
|
||||
rdev->mode_info.tv_std_property,
|
||||
1);
|
||||
}
|
||||
break;
|
||||
case DRM_MODE_CONNECTOR_LVDS:
|
||||
|
||||
@@ -76,17 +76,17 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
|
||||
}
|
||||
p->relocs_ptr[i] = &p->relocs[i];
|
||||
p->relocs[i].robj = p->relocs[i].gobj->driver_private;
|
||||
p->relocs[i].lobj.robj = p->relocs[i].robj;
|
||||
p->relocs[i].lobj.bo = p->relocs[i].robj;
|
||||
p->relocs[i].lobj.rdomain = r->read_domains;
|
||||
p->relocs[i].lobj.wdomain = r->write_domain;
|
||||
p->relocs[i].handle = r->handle;
|
||||
p->relocs[i].flags = r->flags;
|
||||
INIT_LIST_HEAD(&p->relocs[i].lobj.list);
|
||||
radeon_object_list_add_object(&p->relocs[i].lobj,
|
||||
&p->validated);
|
||||
radeon_bo_list_add_object(&p->relocs[i].lobj,
|
||||
&p->validated);
|
||||
}
|
||||
}
|
||||
return radeon_object_list_validate(&p->validated, p->ib->fence);
|
||||
return radeon_bo_list_validate(&p->validated, p->ib->fence);
|
||||
}
|
||||
|
||||
int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
|
||||
@@ -190,9 +190,10 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)
|
||||
unsigned i;
|
||||
|
||||
if (error) {
|
||||
radeon_object_list_unvalidate(&parser->validated);
|
||||
radeon_bo_list_unvalidate(&parser->validated,
|
||||
parser->ib->fence);
|
||||
} else {
|
||||
radeon_object_list_clean(&parser->validated);
|
||||
radeon_bo_list_unreserve(&parser->validated);
|
||||
}
|
||||
for (i = 0; i < parser->nrelocs; i++) {
|
||||
if (parser->relocs[i].gobj) {
|
||||
|
||||
@@ -208,6 +208,24 @@ bool radeon_card_posted(struct radeon_device *rdev)
|
||||
|
||||
}
|
||||
|
||||
bool radeon_boot_test_post_card(struct radeon_device *rdev)
|
||||
{
|
||||
if (radeon_card_posted(rdev))
|
||||
return true;
|
||||
|
||||
if (rdev->bios) {
|
||||
DRM_INFO("GPU not posted. posting now...\n");
|
||||
if (rdev->is_atom_bios)
|
||||
atom_asic_init(rdev->mode_info.atom_context);
|
||||
else
|
||||
radeon_combios_asic_init(rdev->ddev);
|
||||
return true;
|
||||
} else {
|
||||
dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int radeon_dummy_page_init(struct radeon_device *rdev)
|
||||
{
|
||||
rdev->dummy_page.page = alloc_page(GFP_DMA32 | GFP_KERNEL | __GFP_ZERO);
|
||||
@@ -544,6 +562,9 @@ int radeon_device_init(struct radeon_device *rdev,
|
||||
mutex_init(&rdev->cs_mutex);
|
||||
mutex_init(&rdev->ib_pool.mutex);
|
||||
mutex_init(&rdev->cp.mutex);
|
||||
if (rdev->family >= CHIP_R600)
|
||||
spin_lock_init(&rdev->ih.lock);
|
||||
mutex_init(&rdev->gem.mutex);
|
||||
rwlock_init(&rdev->fence_drv.lock);
|
||||
INIT_LIST_HEAD(&rdev->gem.objects);
|
||||
|
||||
@@ -553,7 +574,7 @@ int radeon_device_init(struct radeon_device *rdev,
|
||||
return r;
|
||||
}
|
||||
|
||||
if (radeon_agpmode == -1) {
|
||||
if (rdev->flags & RADEON_IS_AGP && radeon_agpmode == -1) {
|
||||
radeon_agp_disable(rdev);
|
||||
}
|
||||
|
||||
@@ -633,6 +654,7 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
|
||||
{
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
struct drm_crtc *crtc;
|
||||
int r;
|
||||
|
||||
if (dev == NULL || rdev == NULL) {
|
||||
return -ENODEV;
|
||||
@@ -643,18 +665,22 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
|
||||
/* unpin the front buffers */
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
struct radeon_framebuffer *rfb = to_radeon_framebuffer(crtc->fb);
|
||||
struct radeon_object *robj;
|
||||
struct radeon_bo *robj;
|
||||
|
||||
if (rfb == NULL || rfb->obj == NULL) {
|
||||
continue;
|
||||
}
|
||||
robj = rfb->obj->driver_private;
|
||||
if (robj != rdev->fbdev_robj) {
|
||||
radeon_object_unpin(robj);
|
||||
if (robj != rdev->fbdev_rbo) {
|
||||
r = radeon_bo_reserve(robj, false);
|
||||
if (unlikely(r == 0)) {
|
||||
radeon_bo_unpin(robj);
|
||||
radeon_bo_unreserve(robj);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* evict vram memory */
|
||||
radeon_object_evict_vram(rdev);
|
||||
radeon_bo_evict_vram(rdev);
|
||||
/* wait for gpu to finish processing current batch */
|
||||
radeon_fence_wait_last(rdev);
|
||||
|
||||
@@ -662,7 +688,7 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
|
||||
|
||||
radeon_suspend(rdev);
|
||||
/* evict remaining vram memory */
|
||||
radeon_object_evict_vram(rdev);
|
||||
radeon_bo_evict_vram(rdev);
|
||||
|
||||
pci_save_state(dev->pdev);
|
||||
if (state.event == PM_EVENT_SUSPEND) {
|
||||
|
||||
@@ -270,10 +270,10 @@ static void radeon_print_display_setup(struct drm_device *dev)
|
||||
radeon_connector->ddc_bus->rec.mask_data_reg,
|
||||
radeon_connector->ddc_bus->rec.a_clk_reg,
|
||||
radeon_connector->ddc_bus->rec.a_data_reg,
|
||||
radeon_connector->ddc_bus->rec.put_clk_reg,
|
||||
radeon_connector->ddc_bus->rec.put_data_reg,
|
||||
radeon_connector->ddc_bus->rec.get_clk_reg,
|
||||
radeon_connector->ddc_bus->rec.get_data_reg);
|
||||
radeon_connector->ddc_bus->rec.en_clk_reg,
|
||||
radeon_connector->ddc_bus->rec.en_data_reg,
|
||||
radeon_connector->ddc_bus->rec.y_clk_reg,
|
||||
radeon_connector->ddc_bus->rec.y_data_reg);
|
||||
DRM_INFO(" Encoders:\n");
|
||||
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
|
||||
radeon_encoder = to_radeon_encoder(encoder);
|
||||
@@ -324,6 +324,7 @@ static bool radeon_setup_enc_conn(struct drm_device *dev)
|
||||
ret = radeon_get_legacy_connector_info_from_table(dev);
|
||||
}
|
||||
if (ret) {
|
||||
radeon_setup_encoder_clones(dev);
|
||||
radeon_print_display_setup(dev);
|
||||
list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head)
|
||||
radeon_ddc_dump(drm_connector);
|
||||
@@ -339,9 +340,9 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
|
||||
if (!radeon_connector->ddc_bus)
|
||||
return -1;
|
||||
if (!radeon_connector->edid) {
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
}
|
||||
|
||||
if (radeon_connector->edid) {
|
||||
@@ -361,9 +362,9 @@ static int radeon_ddc_dump(struct drm_connector *connector)
|
||||
|
||||
if (!radeon_connector->ddc_bus)
|
||||
return -1;
|
||||
radeon_i2c_do_lock(radeon_connector, 1);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
|
||||
edid = drm_get_edid(connector, &radeon_connector->ddc_bus->adapter);
|
||||
radeon_i2c_do_lock(radeon_connector, 0);
|
||||
radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
|
||||
if (edid) {
|
||||
kfree(edid);
|
||||
}
|
||||
@@ -750,9 +751,17 @@ bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
|
||||
if (encoder->crtc != crtc)
|
||||
continue;
|
||||
if (first) {
|
||||
radeon_crtc->rmx_type = radeon_encoder->rmx_type;
|
||||
/* set scaling */
|
||||
if (radeon_encoder->rmx_type == RMX_OFF)
|
||||
radeon_crtc->rmx_type = RMX_OFF;
|
||||
else if (mode->hdisplay < radeon_encoder->native_mode.hdisplay ||
|
||||
mode->vdisplay < radeon_encoder->native_mode.vdisplay)
|
||||
radeon_crtc->rmx_type = radeon_encoder->rmx_type;
|
||||
else
|
||||
radeon_crtc->rmx_type = RMX_OFF;
|
||||
/* copy native mode */
|
||||
memcpy(&radeon_crtc->native_mode,
|
||||
&radeon_encoder->native_mode,
|
||||
&radeon_encoder->native_mode,
|
||||
sizeof(struct drm_display_mode));
|
||||
first = false;
|
||||
} else {
|
||||
|
||||
@@ -1104,7 +1104,6 @@ extern u32 radeon_get_scratch(drm_radeon_private_t *dev_priv, int index);
|
||||
# define R600_IT_WAIT_REG_MEM 0x00003C00
|
||||
# define R600_IT_MEM_WRITE 0x00003D00
|
||||
# define R600_IT_INDIRECT_BUFFER 0x00003200
|
||||
# define R600_IT_CP_INTERRUPT 0x00004000
|
||||
# define R600_IT_SURFACE_SYNC 0x00004300
|
||||
# define R600_CB0_DEST_BASE_ENA (1 << 6)
|
||||
# define R600_TC_ACTION_ENA (1 << 23)
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user