tree ea3c0e5d3691a4f01474f27cdf297cf5a5e84873
parent 02e6859eae4a8e511fa1a2c9a689ea25cdc6166a
author Alex Deucher <alexander.deucher@amd.com> 1317739594 -0400
committer Dave Airlie <airlied@redhat.com> 1317745454 +0100

drm/radeon/kms: fix channel_remap setup (v2)

Most asics just use the hw default value which requires
no explicit programming.  For those that need a different
value, the vbios will program it properly.  As such,
there's no need to program these registers explicitly
in the driver.  Changing MC_SHARED_CHREMAP requires a reload
of all data in vram otherwise its contents will be scambled.

Fixes:
https://bugs.freedesktop.org/show_bug.cgi?id=40103

v2: drop now unused channel_remap functions.

Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
Reviewed-by: Michel Dänzer <michel.daenzer@amd.com>
Cc: stable@kernel.org
Signed-off-by: Dave Airlie <airlied@redhat.com>
