From d2651e92d5936af26bbbae823e5464143a3e7076 Mon Sep 17 00:00:00 2001 From: "Sergey Semyonov (Serge)" Date: Wed, 29 Jun 2011 05:52:36 +0000 Subject: [PATCH] RC11 preview git-svn-id: svn://kolibrios.org@1986 a494cfbc-eb01-0410-851d-a64ba20cac60 --- drivers/video/drm/drm_fb_helper.c | 9 +- drivers/video/drm/radeon/Makefile | 6 + drivers/video/drm/radeon/atombios.h | 1 + drivers/video/drm/radeon/atombios_crtc.c | 7 + drivers/video/drm/radeon/evergreen.c | 704 +++++++++++++--- .../video/drm/radeon/evergreen_blit_shaders.c | 356 ++++++++ .../video/drm/radeon/evergreen_blit_shaders.h | 35 + .../video/drm/radeon/firmware/BARTS_mc.bin | Bin 0 -> 24096 bytes .../video/drm/radeon/firmware/BARTS_me.bin | Bin 0 -> 5504 bytes .../video/drm/radeon/firmware/BARTS_pfp.bin | Bin 0 -> 4480 bytes drivers/video/drm/radeon/firmware/BTC_rlc.bin | Bin 0 -> 3072 bytes .../video/drm/radeon/firmware/CAICOS_mc.bin | Bin 0 -> 24096 bytes .../video/drm/radeon/firmware/CAICOS_me.bin | Bin 0 -> 5504 bytes .../video/drm/radeon/firmware/CAICOS_pfp.bin | Bin 0 -> 4480 bytes .../video/drm/radeon/firmware/CAYMAN_mc.bin | Bin 0 -> 24148 bytes .../video/drm/radeon/firmware/CAYMAN_me.bin | Bin 0 -> 8704 bytes .../video/drm/radeon/firmware/CAYMAN_pfp.bin | Bin 0 -> 8704 bytes .../video/drm/radeon/firmware/CAYMAN_rlc.bin | Bin 0 -> 4096 bytes drivers/video/drm/radeon/firmware/PALM_me.bin | Bin 0 -> 5504 bytes .../video/drm/radeon/firmware/PALM_pfp.bin | Bin 0 -> 4480 bytes .../video/drm/radeon/firmware/SUMO_rlc.bin | Bin 0 -> 3072 bytes .../video/drm/radeon/firmware/TURKS_mc.bin | Bin 0 -> 24096 bytes .../video/drm/radeon/firmware/TURKS_me.bin | Bin 0 -> 5504 bytes .../video/drm/radeon/firmware/TURKS_pfp.bin | Bin 0 -> 4480 bytes drivers/video/drm/radeon/fwblob.asm | 204 ++++- drivers/video/drm/radeon/r600.c | 8 + drivers/video/drm/radeon/radeon_asic.c | 168 +++- drivers/video/drm/radeon/radeon_atombios.c | 40 + drivers/video/drm/radeon/radeon_combios.c | 9 +- drivers/video/drm/radeon/radeon_connectors.c | 56 +- drivers/video/drm/radeon/radeon_device.c | 9 +- drivers/video/drm/radeon/radeon_display.c | 13 - drivers/video/drm/radeon/radeon_encoders.c | 121 ++- drivers/video/drm/radeon/radeon_fb.c | 110 +-- drivers/video/drm/radeon/radeon_fence.c | 14 +- drivers/video/drm/radeon/radeon_gem.c | 70 +- drivers/video/drm/radeon/radeon_i2c.c | 3 - drivers/video/drm/radeon/radeon_mode.h | 2 + drivers/video/drm/radeon/radeon_object.c | 764 ------------------ drivers/video/drm/radeon/radeon_object_kos.c | 32 +- drivers/video/drm/radeon/radeon_pm.c | 1 + drivers/video/drm/radeon/rdisplay_kms.c | 161 +++- drivers/video/drm/radeon/rs400.c | 1 + drivers/video/drm/radeon/rv515.c | 1 + 44 files changed, 1740 insertions(+), 1165 deletions(-) create mode 100644 drivers/video/drm/radeon/evergreen_blit_shaders.c create mode 100644 drivers/video/drm/radeon/evergreen_blit_shaders.h create mode 100644 drivers/video/drm/radeon/firmware/BARTS_mc.bin create mode 100644 drivers/video/drm/radeon/firmware/BARTS_me.bin create mode 100644 drivers/video/drm/radeon/firmware/BARTS_pfp.bin create mode 100644 drivers/video/drm/radeon/firmware/BTC_rlc.bin create mode 100644 drivers/video/drm/radeon/firmware/CAICOS_mc.bin create mode 100644 drivers/video/drm/radeon/firmware/CAICOS_me.bin create mode 100644 drivers/video/drm/radeon/firmware/CAICOS_pfp.bin create mode 100644 drivers/video/drm/radeon/firmware/CAYMAN_mc.bin create mode 100644 drivers/video/drm/radeon/firmware/CAYMAN_me.bin create mode 100644 drivers/video/drm/radeon/firmware/CAYMAN_pfp.bin create mode 100644 drivers/video/drm/radeon/firmware/CAYMAN_rlc.bin create mode 100644 drivers/video/drm/radeon/firmware/PALM_me.bin create mode 100644 drivers/video/drm/radeon/firmware/PALM_pfp.bin create mode 100644 drivers/video/drm/radeon/firmware/SUMO_rlc.bin create mode 100644 drivers/video/drm/radeon/firmware/TURKS_mc.bin create mode 100644 drivers/video/drm/radeon/firmware/TURKS_me.bin create mode 100644 drivers/video/drm/radeon/firmware/TURKS_pfp.bin delete mode 100644 drivers/video/drm/radeon/radeon_object.c diff --git a/drivers/video/drm/drm_fb_helper.c b/drivers/video/drm/drm_fb_helper.c index 3e71f1822b..7fc1e649b7 100644 --- a/drivers/video/drm/drm_fb_helper.c +++ b/drivers/video/drm/drm_fb_helper.c @@ -590,8 +590,6 @@ int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, info = fb_helper->fbdev; -#if 0 - /* set the fb pointer */ for (i = 0; i < fb_helper->crtc_count; i++) { fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb; @@ -611,7 +609,6 @@ int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, if (new_fb) list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list); -#endif LEAVE(); @@ -926,9 +923,9 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper) height = dev->mode_config.max_height; /* clean out all the encoder/crtc combos */ -// list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { + list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { // encoder->crtc = NULL; -// } + } crtcs = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); @@ -1017,8 +1014,6 @@ bool drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel) } drm_setup_crtcs(fb_helper); - - return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel); } EXPORT_SYMBOL(drm_fb_helper_initial_config); diff --git a/drivers/video/drm/radeon/Makefile b/drivers/video/drm/radeon/Makefile index 04489b8b96..4d75d5d0ee 100644 --- a/drivers/video/drm/radeon/Makefile +++ b/drivers/video/drm/radeon/Makefile @@ -53,9 +53,12 @@ NAME_SRC= \ $(DRM_TOPDIR)/i2c/i2c-core.c \ $(DRM_TOPDIR)/i2c/i2c-algo-bit.c \ radeon_device.c \ + evergreen.c \ + evergreen_blit_shaders.c \ radeon_clocks.c \ radeon_i2c.c \ atom.c \ + radeon_gem.c \ radeon_atombios.c \ radeon_agp.c \ radeon_asic.c \ @@ -133,6 +136,8 @@ SRC_DEP:= NAME_OBJS = $(patsubst %.S, %.o, $(patsubst %.asm, %.o,\ $(patsubst %.c, %.o, $(NAME_SRC)))) + + all: $(NAME).dll $(NAME).dll: $(NAME_OBJS) $(FW_BINS) $(SRC_DEP) $(HFILES) $(LIBPATH)/libcore.a $(LIBPATH)/libddk.a atikms.lds Makefile @@ -148,6 +153,7 @@ $(NAME).dll: $(NAME_OBJS) $(FW_BINS) $(SRC_DEP) $(HFILES) $(LIBPATH)/libcore.a $ fwblob.o: fwblob.asm $(FW_BINS) Makefile $(FASM) $< $@ + clean: -rm -f */*.o diff --git a/drivers/video/drm/radeon/atombios.h b/drivers/video/drm/radeon/atombios.h index 3443d22122..a019eda3ab 100644 --- a/drivers/video/drm/radeon/atombios.h +++ b/drivers/video/drm/radeon/atombios.h @@ -1200,6 +1200,7 @@ typedef struct _EXTERNAL_ENCODER_CONTROL_PARAMETERS_V3 #define EXTERNAL_ENCODER_ACTION_V3_ENCODER_BLANKING_OFF 0x10 #define EXTERNAL_ENCODER_ACTION_V3_ENCODER_BLANKING 0x11 #define EXTERNAL_ENCODER_ACTION_V3_DACLOAD_DETECTION 0x12 +#define EXTERNAL_ENCODER_ACTION_V3_DDC_SETUP 0x14 // ucConfig #define EXTERNAL_ENCODER_CONFIG_V3_DPLINKRATE_MASK 0x03 diff --git a/drivers/video/drm/radeon/atombios_crtc.c b/drivers/video/drm/radeon/atombios_crtc.c index 994cd54be6..ffeb585d93 100644 --- a/drivers/video/drm/radeon/atombios_crtc.c +++ b/drivers/video/drm/radeon/atombios_crtc.c @@ -671,6 +671,13 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc, DISPPLL_CONFIG_DUAL_LINK; } } + if (radeon_encoder_is_dp_bridge(encoder)) { + struct drm_encoder *ext_encoder = radeon_atom_get_external_encoder(encoder); + struct radeon_encoder *ext_radeon_encoder = to_radeon_encoder(ext_encoder); + args.v3.sInput.ucExtTransmitterID = ext_radeon_encoder->encoder_id; + } else + args.v3.sInput.ucExtTransmitterID = 0; + atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); adjusted_clock = le32_to_cpu(args.v3.sOutput.ulDispPllFreq) * 10; diff --git a/drivers/video/drm/radeon/evergreen.c b/drivers/video/drm/radeon/evergreen.c index 865882af4e..cfcf0b26e9 100644 --- a/drivers/video/drm/radeon/evergreen.c +++ b/drivers/video/drm/radeon/evergreen.c @@ -32,12 +32,14 @@ #include "atom.h" #include "avivod.h" #include "evergreen_reg.h" +#include "evergreen_blit_shaders.h" #define EVERGREEN_PFP_UCODE_SIZE 1120 #define EVERGREEN_PM4_UCODE_SIZE 1376 static void evergreen_gpu_init(struct radeon_device *rdev); void evergreen_fini(struct radeon_device *rdev); +static void evergreen_pcie_gen2_enable(struct radeon_device *rdev); bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd) { @@ -217,11 +219,455 @@ void evergreen_hpd_fini(struct radeon_device *rdev) } #endif +/* watermark setup */ +static u32 evergreen_line_buffer_adjust(struct radeon_device *rdev, + struct radeon_crtc *radeon_crtc, + struct drm_display_mode *mode, + struct drm_display_mode *other_mode) +{ + u32 tmp; + /* + * Line Buffer Setup + * There are 3 line buffers, each one shared by 2 display controllers. + * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between + * the display controllers. The paritioning is done via one of four + * preset allocations specified in bits 2:0: + * first display controller + * 0 - first half of lb (3840 * 2) + * 1 - first 3/4 of lb (5760 * 2) + * 2 - whole lb (7680 * 2), other crtc must be disabled + * 3 - first 1/4 of lb (1920 * 2) + * second display controller + * 4 - second half of lb (3840 * 2) + * 5 - second 3/4 of lb (5760 * 2) + * 6 - whole lb (7680 * 2), other crtc must be disabled + * 7 - last 1/4 of lb (1920 * 2) + */ + /* this can get tricky if we have two large displays on a paired group + * of crtcs. Ideally for multiple large displays we'd assign them to + * non-linked crtcs for maximum line buffer allocation. + */ + if (radeon_crtc->base.enabled && mode) { + if (other_mode) + tmp = 0; /* 1/2 */ + else + tmp = 2; /* whole */ + } else + tmp = 0; + + /* second controller of the pair uses second half of the lb */ + if (radeon_crtc->crtc_id % 2) + tmp += 4; + WREG32(DC_LB_MEMORY_SPLIT + radeon_crtc->crtc_offset, tmp); + + if (radeon_crtc->base.enabled && mode) { + switch (tmp) { + case 0: + case 4: + default: + if (ASIC_IS_DCE5(rdev)) + return 4096 * 2; + else + return 3840 * 2; + case 1: + case 5: + if (ASIC_IS_DCE5(rdev)) + return 6144 * 2; + else + return 5760 * 2; + case 2: + case 6: + if (ASIC_IS_DCE5(rdev)) + return 8192 * 2; + else + return 7680 * 2; + case 3: + case 7: + if (ASIC_IS_DCE5(rdev)) + return 2048 * 2; + else + return 1920 * 2; + } + } + + /* controller not enabled, so no lb used */ + return 0; +} + +static u32 evergreen_get_number_of_dram_channels(struct radeon_device *rdev) +{ + u32 tmp = RREG32(MC_SHARED_CHMAP); + + switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) { + case 0: + default: + return 1; + case 1: + return 2; + case 2: + return 4; + case 3: + return 8; + } +} + +struct evergreen_wm_params { + u32 dram_channels; /* number of dram channels */ + u32 yclk; /* bandwidth per dram data pin in kHz */ + u32 sclk; /* engine clock in kHz */ + u32 disp_clk; /* display clock in kHz */ + u32 src_width; /* viewport width */ + u32 active_time; /* active display time in ns */ + u32 blank_time; /* blank time in ns */ + bool interlaced; /* mode is interlaced */ + fixed20_12 vsc; /* vertical scale ratio */ + u32 num_heads; /* number of active crtcs */ + u32 bytes_per_pixel; /* bytes per pixel display + overlay */ + u32 lb_size; /* line buffer allocated to pipe */ + u32 vtaps; /* vertical scaler taps */ +}; + +static u32 evergreen_dram_bandwidth(struct evergreen_wm_params *wm) +{ + /* Calculate DRAM Bandwidth and the part allocated to display. */ + fixed20_12 dram_efficiency; /* 0.7 */ + fixed20_12 yclk, dram_channels, bandwidth; + fixed20_12 a; + + a.full = dfixed_const(1000); + yclk.full = dfixed_const(wm->yclk); + yclk.full = dfixed_div(yclk, a); + dram_channels.full = dfixed_const(wm->dram_channels * 4); + a.full = dfixed_const(10); + dram_efficiency.full = dfixed_const(7); + dram_efficiency.full = dfixed_div(dram_efficiency, a); + bandwidth.full = dfixed_mul(dram_channels, yclk); + bandwidth.full = dfixed_mul(bandwidth, dram_efficiency); + + return dfixed_trunc(bandwidth); +} + +static u32 evergreen_dram_bandwidth_for_display(struct evergreen_wm_params *wm) +{ + /* Calculate DRAM Bandwidth and the part allocated to display. */ + fixed20_12 disp_dram_allocation; /* 0.3 to 0.7 */ + fixed20_12 yclk, dram_channels, bandwidth; + fixed20_12 a; + + a.full = dfixed_const(1000); + yclk.full = dfixed_const(wm->yclk); + yclk.full = dfixed_div(yclk, a); + dram_channels.full = dfixed_const(wm->dram_channels * 4); + a.full = dfixed_const(10); + disp_dram_allocation.full = dfixed_const(3); /* XXX worse case value 0.3 */ + disp_dram_allocation.full = dfixed_div(disp_dram_allocation, a); + bandwidth.full = dfixed_mul(dram_channels, yclk); + bandwidth.full = dfixed_mul(bandwidth, disp_dram_allocation); + + return dfixed_trunc(bandwidth); +} + +static u32 evergreen_data_return_bandwidth(struct evergreen_wm_params *wm) +{ + /* Calculate the display Data return Bandwidth */ + fixed20_12 return_efficiency; /* 0.8 */ + fixed20_12 sclk, bandwidth; + fixed20_12 a; + + a.full = dfixed_const(1000); + sclk.full = dfixed_const(wm->sclk); + sclk.full = dfixed_div(sclk, a); + a.full = dfixed_const(10); + return_efficiency.full = dfixed_const(8); + return_efficiency.full = dfixed_div(return_efficiency, a); + a.full = dfixed_const(32); + bandwidth.full = dfixed_mul(a, sclk); + bandwidth.full = dfixed_mul(bandwidth, return_efficiency); + + return dfixed_trunc(bandwidth); +} + +static u32 evergreen_dmif_request_bandwidth(struct evergreen_wm_params *wm) +{ + /* Calculate the DMIF Request Bandwidth */ + fixed20_12 disp_clk_request_efficiency; /* 0.8 */ + fixed20_12 disp_clk, bandwidth; + fixed20_12 a; + + a.full = dfixed_const(1000); + disp_clk.full = dfixed_const(wm->disp_clk); + disp_clk.full = dfixed_div(disp_clk, a); + a.full = dfixed_const(10); + disp_clk_request_efficiency.full = dfixed_const(8); + disp_clk_request_efficiency.full = dfixed_div(disp_clk_request_efficiency, a); + a.full = dfixed_const(32); + bandwidth.full = dfixed_mul(a, disp_clk); + bandwidth.full = dfixed_mul(bandwidth, disp_clk_request_efficiency); + + return dfixed_trunc(bandwidth); +} + +static u32 evergreen_available_bandwidth(struct evergreen_wm_params *wm) +{ + /* Calculate the Available bandwidth. Display can use this temporarily but not in average. */ + u32 dram_bandwidth = evergreen_dram_bandwidth(wm); + u32 data_return_bandwidth = evergreen_data_return_bandwidth(wm); + u32 dmif_req_bandwidth = evergreen_dmif_request_bandwidth(wm); + + return min(dram_bandwidth, min(data_return_bandwidth, dmif_req_bandwidth)); +} + +static u32 evergreen_average_bandwidth(struct evergreen_wm_params *wm) +{ + /* Calculate the display mode Average Bandwidth + * DisplayMode should contain the source and destination dimensions, + * timing, etc. + */ + fixed20_12 bpp; + fixed20_12 line_time; + fixed20_12 src_width; + fixed20_12 bandwidth; + fixed20_12 a; + + a.full = dfixed_const(1000); + line_time.full = dfixed_const(wm->active_time + wm->blank_time); + line_time.full = dfixed_div(line_time, a); + bpp.full = dfixed_const(wm->bytes_per_pixel); + src_width.full = dfixed_const(wm->src_width); + bandwidth.full = dfixed_mul(src_width, bpp); + bandwidth.full = dfixed_mul(bandwidth, wm->vsc); + bandwidth.full = dfixed_div(bandwidth, line_time); + + return dfixed_trunc(bandwidth); +} + +static u32 evergreen_latency_watermark(struct evergreen_wm_params *wm) +{ + /* First calcualte the latency in ns */ + u32 mc_latency = 2000; /* 2000 ns. */ + u32 available_bandwidth = evergreen_available_bandwidth(wm); + u32 worst_chunk_return_time = (512 * 8 * 1000) / available_bandwidth; + u32 cursor_line_pair_return_time = (128 * 4 * 1000) / available_bandwidth; + u32 dc_latency = 40000000 / wm->disp_clk; /* dc pipe latency */ + u32 other_heads_data_return_time = ((wm->num_heads + 1) * worst_chunk_return_time) + + (wm->num_heads * cursor_line_pair_return_time); + u32 latency = mc_latency + other_heads_data_return_time + dc_latency; + u32 max_src_lines_per_dst_line, lb_fill_bw, line_fill_time; + fixed20_12 a, b, c; + + if (wm->num_heads == 0) + return 0; + + a.full = dfixed_const(2); + b.full = dfixed_const(1); + if ((wm->vsc.full > a.full) || + ((wm->vsc.full > b.full) && (wm->vtaps >= 3)) || + (wm->vtaps >= 5) || + ((wm->vsc.full >= a.full) && wm->interlaced)) + max_src_lines_per_dst_line = 4; + else + max_src_lines_per_dst_line = 2; + + a.full = dfixed_const(available_bandwidth); + b.full = dfixed_const(wm->num_heads); + a.full = dfixed_div(a, b); + + b.full = dfixed_const(1000); + c.full = dfixed_const(wm->disp_clk); + b.full = dfixed_div(c, b); + c.full = dfixed_const(wm->bytes_per_pixel); + b.full = dfixed_mul(b, c); + + lb_fill_bw = min(dfixed_trunc(a), dfixed_trunc(b)); + + a.full = dfixed_const(max_src_lines_per_dst_line * wm->src_width * wm->bytes_per_pixel); + b.full = dfixed_const(1000); + c.full = dfixed_const(lb_fill_bw); + b.full = dfixed_div(c, b); + a.full = dfixed_div(a, b); + line_fill_time = dfixed_trunc(a); + + if (line_fill_time < wm->active_time) + return latency; + else + return latency + (line_fill_time - wm->active_time); + +} + +static bool evergreen_average_bandwidth_vs_dram_bandwidth_for_display(struct evergreen_wm_params *wm) +{ + if (evergreen_average_bandwidth(wm) <= + (evergreen_dram_bandwidth_for_display(wm) / wm->num_heads)) + return true; + else + return false; +}; + +static bool evergreen_average_bandwidth_vs_available_bandwidth(struct evergreen_wm_params *wm) +{ + if (evergreen_average_bandwidth(wm) <= + (evergreen_available_bandwidth(wm) / wm->num_heads)) + return true; + else + return false; +}; + +static bool evergreen_check_latency_hiding(struct evergreen_wm_params *wm) +{ + u32 lb_partitions = wm->lb_size / wm->src_width; + u32 line_time = wm->active_time + wm->blank_time; + u32 latency_tolerant_lines; + u32 latency_hiding; + fixed20_12 a; + + a.full = dfixed_const(1); + if (wm->vsc.full > a.full) + latency_tolerant_lines = 1; + else { + if (lb_partitions <= (wm->vtaps + 1)) + latency_tolerant_lines = 1; + else + latency_tolerant_lines = 2; + } + + latency_hiding = (latency_tolerant_lines * line_time + wm->blank_time); + + if (evergreen_latency_watermark(wm) <= latency_hiding) + return true; + else + return false; +} + +static void evergreen_program_watermarks(struct radeon_device *rdev, + struct radeon_crtc *radeon_crtc, + u32 lb_size, u32 num_heads) +{ + struct drm_display_mode *mode = &radeon_crtc->base.mode; + struct evergreen_wm_params wm; + u32 pixel_period; + u32 line_time = 0; + u32 latency_watermark_a = 0, latency_watermark_b = 0; + u32 priority_a_mark = 0, priority_b_mark = 0; + u32 priority_a_cnt = PRIORITY_OFF; + u32 priority_b_cnt = PRIORITY_OFF; + u32 pipe_offset = radeon_crtc->crtc_id * 16; + u32 tmp, arb_control3; + fixed20_12 a, b, c; + + if (radeon_crtc->base.enabled && num_heads && mode) { + pixel_period = 1000000 / (u32)mode->clock; + line_time = min((u32)mode->crtc_htotal * pixel_period, (u32)65535); + priority_a_cnt = 0; + priority_b_cnt = 0; + + wm.yclk = rdev->pm.current_mclk * 10; + wm.sclk = rdev->pm.current_sclk * 10; + wm.disp_clk = mode->clock; + wm.src_width = mode->crtc_hdisplay; + wm.active_time = mode->crtc_hdisplay * pixel_period; + wm.blank_time = line_time - wm.active_time; + wm.interlaced = false; + if (mode->flags & DRM_MODE_FLAG_INTERLACE) + wm.interlaced = true; + wm.vsc = radeon_crtc->vsc; + wm.vtaps = 1; + if (radeon_crtc->rmx_type != RMX_OFF) + wm.vtaps = 2; + wm.bytes_per_pixel = 4; /* XXX: get this from fb config */ + wm.lb_size = lb_size; + wm.dram_channels = evergreen_get_number_of_dram_channels(rdev); + wm.num_heads = num_heads; + + /* set for high clocks */ + latency_watermark_a = min(evergreen_latency_watermark(&wm), (u32)65535); + /* set for low clocks */ + /* wm.yclk = low clk; wm.sclk = low clk */ + latency_watermark_b = min(evergreen_latency_watermark(&wm), (u32)65535); + + /* possibly force display priority to high */ + /* should really do this at mode validation time... */ + if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm) || + !evergreen_average_bandwidth_vs_available_bandwidth(&wm) || + !evergreen_check_latency_hiding(&wm) || + (rdev->disp_priority == 2)) { + DRM_INFO("force priority to high\n"); + priority_a_cnt |= PRIORITY_ALWAYS_ON; + priority_b_cnt |= PRIORITY_ALWAYS_ON; + } + + a.full = dfixed_const(1000); + b.full = dfixed_const(mode->clock); + b.full = dfixed_div(b, a); + c.full = dfixed_const(latency_watermark_a); + c.full = dfixed_mul(c, b); + c.full = dfixed_mul(c, radeon_crtc->hsc); + c.full = dfixed_div(c, a); + a.full = dfixed_const(16); + c.full = dfixed_div(c, a); + priority_a_mark = dfixed_trunc(c); + priority_a_cnt |= priority_a_mark & PRIORITY_MARK_MASK; + + a.full = dfixed_const(1000); + b.full = dfixed_const(mode->clock); + b.full = dfixed_div(b, a); + c.full = dfixed_const(latency_watermark_b); + c.full = dfixed_mul(c, b); + c.full = dfixed_mul(c, radeon_crtc->hsc); + c.full = dfixed_div(c, a); + a.full = dfixed_const(16); + c.full = dfixed_div(c, a); + priority_b_mark = dfixed_trunc(c); + priority_b_cnt |= priority_b_mark & PRIORITY_MARK_MASK; + } + + /* select wm A */ + arb_control3 = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset); + tmp = arb_control3; + tmp &= ~LATENCY_WATERMARK_MASK(3); + tmp |= LATENCY_WATERMARK_MASK(1); + WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp); + WREG32(PIPE0_LATENCY_CONTROL + pipe_offset, + (LATENCY_LOW_WATERMARK(latency_watermark_a) | + LATENCY_HIGH_WATERMARK(line_time))); + /* select wm B */ + tmp = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset); + tmp &= ~LATENCY_WATERMARK_MASK(3); + tmp |= LATENCY_WATERMARK_MASK(2); + WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp); + WREG32(PIPE0_LATENCY_CONTROL + pipe_offset, + (LATENCY_LOW_WATERMARK(latency_watermark_b) | + LATENCY_HIGH_WATERMARK(line_time))); + /* restore original selection */ + WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, arb_control3); + + /* write the priority marks */ + WREG32(PRIORITY_A_CNT + radeon_crtc->crtc_offset, priority_a_cnt); + WREG32(PRIORITY_B_CNT + radeon_crtc->crtc_offset, priority_b_cnt); + +} void evergreen_bandwidth_update(struct radeon_device *rdev) { - /* XXX */ + struct drm_display_mode *mode0 = NULL; + struct drm_display_mode *mode1 = NULL; + u32 num_heads = 0, lb_size; + int i; + + radeon_update_display_priority(rdev); + + for (i = 0; i < rdev->num_crtc; i++) { + if (rdev->mode_info.crtcs[i]->base.enabled) + num_heads++; + } + for (i = 0; i < rdev->num_crtc; i += 2) { + mode0 = &rdev->mode_info.crtcs[i]->base.mode; + mode1 = &rdev->mode_info.crtcs[i+1]->base.mode; + lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i], mode0, mode1); + evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i], lb_size, num_heads); + lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i+1], mode1, mode0); + evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i+1], lb_size, num_heads); + } } int evergreen_mc_wait_for_idle(struct radeon_device *rdev) @@ -608,10 +1054,25 @@ void evergreen_mc_program(struct radeon_device *rdev) rv515_vga_render_disable(rdev); } -#if 0 /* * CP. */ +void evergreen_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib) +{ + /* set to DX10/11 mode */ + radeon_ring_write(rdev, PACKET3(PACKET3_MODE_CONTROL, 0)); + radeon_ring_write(rdev, 1); + /* FIXME: implement */ + radeon_ring_write(rdev, PACKET3(PACKET3_INDIRECT_BUFFER, 2)); + radeon_ring_write(rdev, +#ifdef __BIG_ENDIAN + (2 << 0) | +#endif + (ib->gpu_addr & 0xFFFFFFFC)); + radeon_ring_write(rdev, upper_32_bits(ib->gpu_addr) & 0xFF); + radeon_ring_write(rdev, ib->length_dw); +} + static int evergreen_cp_load_microcode(struct radeon_device *rdev) { @@ -930,7 +1391,48 @@ static u32 evergreen_get_tile_pipe_to_backend_map(struct radeon_device *rdev, return backend_map; } -#endif + +static void evergreen_program_channel_remap(struct radeon_device *rdev) +{ + u32 tcp_chan_steer_lo, tcp_chan_steer_hi, mc_shared_chremap, tmp; + + tmp = RREG32(MC_SHARED_CHMAP); + switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) { + case 0: + case 1: + case 2: + case 3: + default: + /* default mapping */ + mc_shared_chremap = 0x00fac688; + break; + } + + switch (rdev->family) { + case CHIP_HEMLOCK: + case CHIP_CYPRESS: + case CHIP_BARTS: + tcp_chan_steer_lo = 0x54763210; + tcp_chan_steer_hi = 0x0000ba98; + break; + case CHIP_JUNIPER: + case CHIP_REDWOOD: + case CHIP_CEDAR: + case CHIP_PALM: + case CHIP_SUMO: + case CHIP_SUMO2: + case CHIP_TURKS: + case CHIP_CAICOS: + default: + tcp_chan_steer_lo = 0x76543210; + tcp_chan_steer_hi = 0x0000ba98; + break; + } + + WREG32(TCP_CHAN_STEER_LO, tcp_chan_steer_lo); + WREG32(TCP_CHAN_STEER_HI, tcp_chan_steer_hi); + WREG32(MC_SHARED_CHREMAP, mc_shared_chremap); +} static void evergreen_gpu_init(struct radeon_device *rdev) { @@ -1359,9 +1861,9 @@ static void evergreen_gpu_init(struct radeon_device *rdev) rdev->config.evergreen.tile_config |= (3 << 0); break; } - /* num banks is 8 on all fusion asics */ + /* num banks is 8 on all fusion asics. 0 = 4, 1 = 8, 2 = 16 */ if (rdev->flags & RADEON_IS_IGP) - rdev->config.evergreen.tile_config |= 8 << 4; + rdev->config.evergreen.tile_config |= 1 << 4; else rdev->config.evergreen.tile_config |= ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT) << 4; @@ -1641,8 +2143,30 @@ int evergreen_mc_init(struct radeon_device *rdev) bool evergreen_gpu_is_lockup(struct radeon_device *rdev) { - /* FIXME: implement for evergreen */ + u32 srbm_status; + u32 grbm_status; + u32 grbm_status_se0, grbm_status_se1; + struct r100_gpu_lockup *lockup = &rdev->config.evergreen.lockup; + int r; + + srbm_status = RREG32(SRBM_STATUS); + grbm_status = RREG32(GRBM_STATUS); + grbm_status_se0 = RREG32(GRBM_STATUS_SE0); + grbm_status_se1 = RREG32(GRBM_STATUS_SE1); + if (!(grbm_status & GUI_ACTIVE)) { + r100_gpu_lockup_update(lockup, &rdev->cp); return false; + } + /* force CP activities */ + r = radeon_ring_lock(rdev, 2); + if (!r) { + /* PACKET2 NOP */ + radeon_ring_write(rdev, 0x80000000); + radeon_ring_write(rdev, 0x80000000); + radeon_ring_unlock_commit(rdev); + } + rdev->cp.rptr = RREG32(CP_RB_RPTR); + return r100_gpu_cp_is_lockup(rdev, lockup, &rdev->cp); } static int evergreen_gpu_soft_reset(struct radeon_device *rdev) @@ -1807,13 +2331,6 @@ static int evergreen_startup(struct radeon_device *rdev) #endif /* Enable IRQ */ - r = r600_irq_init(rdev); - if (r) { - DRM_ERROR("radeon: IH init failed (%d).\n", r); - radeon_irq_kms_fini(rdev); - return r; - } -// evergreen_irq_set(rdev); r = radeon_ring_init(rdev, rdev->cp.ring_size); if (r) @@ -1824,79 +2341,15 @@ static int evergreen_startup(struct radeon_device *rdev) r = evergreen_cp_resume(rdev); if (r) return r; - /* write back buffer are not vital so don't worry about failure */ - r600_wb_enable(rdev); return 0; } -int evergreen_resume(struct radeon_device *rdev) -{ - int r; - /* Do not reset GPU before posting, on rv770 hw unlike on r500 hw, - * posting will perform necessary task to bring back GPU into good - * shape. - */ - /* post card */ - atom_asic_init(rdev->mode_info.atom_context); - r = evergreen_startup(rdev); - if (r) { - DRM_ERROR("r600 startup failed on resume\n"); - return r; - } -#if 0 - r = r600_ib_test(rdev); - if (r) { - DRM_ERROR("radeon: failled testing IB (%d).\n", r); - return r; - } -#endif - return r; -} -int evergreen_suspend(struct radeon_device *rdev) -{ - int r; - /* FIXME: we should wait for ring to be empty */ - r700_cp_stop(rdev); - rdev->cp.ready = false; - r600_wb_disable(rdev); - evergreen_pcie_gart_disable(rdev); -#if 0 - /* unpin shaders bo */ - r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false); - if (likely(r == 0)) { - radeon_bo_unpin(rdev->r600_blit.shader_obj); - radeon_bo_unreserve(rdev->r600_blit.shader_obj); - } -#endif - return 0; -} - -static bool evergreen_card_posted(struct radeon_device *rdev) -{ - u32 reg; - - /* first check CRTCs */ - reg = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET) | - RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET) | - RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC2_REGISTER_OFFSET) | - RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC3_REGISTER_OFFSET) | - RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC4_REGISTER_OFFSET) | - RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC5_REGISTER_OFFSET); - if (reg & EVERGREEN_CRTC_MASTER_EN) - return true; - - /* then check MEM_SIZE, in case the crtcs are off */ - if (RREG32(CONFIG_MEMSIZE)) - return true; - - return false; -} /* Plan is to move initialization in that function and use * helper function so that radeon_device_init pretty much @@ -1908,9 +2361,6 @@ int evergreen_init(struct radeon_device *rdev) { int r; - r = radeon_dummy_page_init(rdev); - if (r) - return r; /* This don't do much */ r = radeon_gem_init(rdev); if (r) @@ -1922,14 +2372,19 @@ int evergreen_init(struct radeon_device *rdev) } /* Must be an ATOMBIOS */ if (!rdev->is_atom_bios) { - dev_err(rdev->dev, "Expecting atombios for R600 GPU\n"); + dev_err(rdev->dev, "Expecting atombios for evergreen GPU\n"); return -EINVAL; } r = radeon_atombios_init(rdev); if (r) return r; + /* reset the asic, the gfx blocks are often in a bad state + * after the driver is unloaded or after a resume + */ + if (radeon_asic_reset(rdev)) + dev_warn(rdev->dev, "GPU reset failed !\n"); /* Post card if necessary */ - if (!evergreen_card_posted(rdev)) { + if (!radeon_card_posted(rdev)) { if (!rdev->bios) { dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n"); return -EINVAL; @@ -1944,9 +2399,6 @@ int evergreen_init(struct radeon_device *rdev) /* Initialize clocks */ radeon_get_clock_info(rdev->ddev); /* Fence driver */ -// r = radeon_fence_driver_init(rdev); -// if (r) -// return r; /* initialize AGP */ if (rdev->flags & RADEON_IS_AGP) { r = radeon_agp_init(rdev); @@ -1962,9 +2414,6 @@ int evergreen_init(struct radeon_device *rdev) if (r) return r; - r = radeon_irq_kms_init(rdev); - if (r) - return r; rdev->cp.ring_obj = NULL; r600_ring_init(rdev, 1024 * 1024); @@ -1980,41 +2429,62 @@ int evergreen_init(struct radeon_device *rdev) r = evergreen_startup(rdev); if (r) { dev_err(rdev->dev, "disabling GPU acceleration\n"); - r700_cp_fini(rdev); - r600_irq_fini(rdev); - radeon_irq_kms_fini(rdev); - evergreen_pcie_gart_fini(rdev); rdev->accel_working = false; } if (rdev->accel_working) { - r = radeon_ib_pool_init(rdev); - if (r) { - DRM_ERROR("radeon: failed initializing IB pool (%d).\n", r); - rdev->accel_working = false; - } - r = r600_ib_test(rdev); - if (r) { - DRM_ERROR("radeon: failed testing IB (%d).\n", r); - rdev->accel_working = false; - } } return 0; } -void evergreen_fini(struct radeon_device *rdev) + +static void evergreen_pcie_gen2_enable(struct radeon_device *rdev) { - /*r600_blit_fini(rdev);*/ - r700_cp_fini(rdev); - r600_irq_fini(rdev); - radeon_wb_fini(rdev); - radeon_irq_kms_fini(rdev); - evergreen_pcie_gart_fini(rdev); - radeon_gem_fini(rdev); - radeon_fence_driver_fini(rdev); - radeon_agp_fini(rdev); - radeon_bo_fini(rdev); - radeon_atombios_fini(rdev); - kfree(rdev->bios); - rdev->bios = NULL; - radeon_dummy_page_fini(rdev); + u32 link_width_cntl, speed_cntl; + + if (radeon_pcie_gen2 == 0) + return; + + if (rdev->flags & RADEON_IS_IGP) + return; + + if (!(rdev->flags & RADEON_IS_PCIE)) + return; + + /* x2 cards have a special sequence */ + if (ASIC_IS_X2(rdev)) + return; + + speed_cntl = RREG32_PCIE_P(PCIE_LC_SPEED_CNTL); + if ((speed_cntl & LC_OTHER_SIDE_EVER_SENT_GEN2) || + (speed_cntl & LC_OTHER_SIDE_SUPPORTS_GEN2)) { + + link_width_cntl = RREG32_PCIE_P(PCIE_LC_LINK_WIDTH_CNTL); + link_width_cntl &= ~LC_UPCONFIGURE_DIS; + WREG32_PCIE_P(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl); + + speed_cntl = RREG32_PCIE_P(PCIE_LC_SPEED_CNTL); + speed_cntl &= ~LC_TARGET_LINK_SPEED_OVERRIDE_EN; + WREG32_PCIE_P(PCIE_LC_SPEED_CNTL, speed_cntl); + + speed_cntl = RREG32_PCIE_P(PCIE_LC_SPEED_CNTL); + speed_cntl |= LC_CLR_FAILED_SPD_CHANGE_CNT; + WREG32_PCIE_P(PCIE_LC_SPEED_CNTL, speed_cntl); + + speed_cntl = RREG32_PCIE_P(PCIE_LC_SPEED_CNTL); + speed_cntl &= ~LC_CLR_FAILED_SPD_CHANGE_CNT; + WREG32_PCIE_P(PCIE_LC_SPEED_CNTL, speed_cntl); + + speed_cntl = RREG32_PCIE_P(PCIE_LC_SPEED_CNTL); + speed_cntl |= LC_GEN2_EN_STRAP; + WREG32_PCIE_P(PCIE_LC_SPEED_CNTL, speed_cntl); + + } else { + link_width_cntl = RREG32_PCIE_P(PCIE_LC_LINK_WIDTH_CNTL); + /* XXX: only disable it if gen1 bridge vendor == 0x111d or 0x1106 */ + if (1) + link_width_cntl |= LC_UPCONFIGURE_DIS; + else + link_width_cntl &= ~LC_UPCONFIGURE_DIS; + WREG32_PCIE_P(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl); + } } diff --git a/drivers/video/drm/radeon/evergreen_blit_shaders.c b/drivers/video/drm/radeon/evergreen_blit_shaders.c new file mode 100644 index 0000000000..f62d2ecd8d --- /dev/null +++ b/drivers/video/drm/radeon/evergreen_blit_shaders.c @@ -0,0 +1,356 @@ +/* + * Copyright 2010 Advanced Micro Devices, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Alex Deucher + */ + +#include +#include + +/* + * evergreen cards need to use the 3D engine to blit data which requires + * quite a bit of hw state setup. Rather than pull the whole 3D driver + * (which normally generates the 3D state) into the DRM, we opt to use + * statically generated state tables. The regsiter state and shaders + * were hand generated to support blitting functionality. See the 3D + * driver or documentation for descriptions of the registers and + * shader instructions. + */ + +const u32 evergreen_default_state[] = +{ + 0xc0016900, + 0x0000023b, + 0x00000000, /* SQ_LDS_ALLOC_PS */ + + 0xc0066900, + 0x00000240, + 0x00000000, /* SQ_ESGS_RING_ITEMSIZE */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + + 0xc0046900, + 0x00000247, + 0x00000000, /* SQ_GS_VERT_ITEMSIZE */ + 0x00000000, + 0x00000000, + 0x00000000, + + 0xc0026900, + 0x00000010, + 0x00000000, /* DB_Z_INFO */ + 0x00000000, /* DB_STENCIL_INFO */ + + 0xc0016900, + 0x00000200, + 0x00000000, /* DB_DEPTH_CONTROL */ + + 0xc0066900, + 0x00000000, + 0x00000060, /* DB_RENDER_CONTROL */ + 0x00000000, /* DB_COUNT_CONTROL */ + 0x00000000, /* DB_DEPTH_VIEW */ + 0x0000002a, /* DB_RENDER_OVERRIDE */ + 0x00000000, /* DB_RENDER_OVERRIDE2 */ + 0x00000000, /* DB_HTILE_DATA_BASE */ + + 0xc0026900, + 0x0000000a, + 0x00000000, /* DB_STENCIL_CLEAR */ + 0x00000000, /* DB_DEPTH_CLEAR */ + + 0xc0016900, + 0x000002dc, + 0x0000aa00, /* DB_ALPHA_TO_MASK */ + + 0xc0016900, + 0x00000080, + 0x00000000, /* PA_SC_WINDOW_OFFSET */ + + 0xc00d6900, + 0x00000083, + 0x0000ffff, /* PA_SC_CLIPRECT_RULE */ + 0x00000000, /* PA_SC_CLIPRECT_0_TL */ + 0x20002000, /* PA_SC_CLIPRECT_0_BR */ + 0x00000000, + 0x20002000, + 0x00000000, + 0x20002000, + 0x00000000, + 0x20002000, + 0xaaaaaaaa, /* PA_SC_EDGERULE */ + 0x00000000, /* PA_SU_HARDWARE_SCREEN_OFFSET */ + 0x0000000f, /* CB_TARGET_MASK */ + 0x0000000f, /* CB_SHADER_MASK */ + + 0xc0226900, + 0x00000094, + 0x80000000, /* PA_SC_VPORT_SCISSOR_0_TL */ + 0x20002000, /* PA_SC_VPORT_SCISSOR_0_BR */ + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x80000000, + 0x20002000, + 0x00000000, /* PA_SC_VPORT_ZMIN_0 */ + 0x3f800000, /* PA_SC_VPORT_ZMAX_0 */ + + 0xc0016900, + 0x000000d4, + 0x00000000, /* SX_MISC */ + + 0xc0026900, + 0x00000292, + 0x00000000, /* PA_SC_MODE_CNTL_0 */ + 0x00000000, /* PA_SC_MODE_CNTL_1 */ + + 0xc0106900, + 0x00000300, + 0x00000000, /* PA_SC_LINE_CNTL */ + 0x00000000, /* PA_SC_AA_CONFIG */ + 0x00000005, /* PA_SU_VTX_CNTL */ + 0x3f800000, /* PA_CL_GB_VERT_CLIP_ADJ */ + 0x3f800000, /* PA_CL_GB_VERT_DISC_ADJ */ + 0x3f800000, /* PA_CL_GB_HORZ_CLIP_ADJ */ + 0x3f800000, /* PA_CL_GB_HORZ_DISC_ADJ */ + 0x00000000, /* PA_SC_AA_SAMPLE_LOCS_0 */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* PA_SC_AA_SAMPLE_LOCS_7 */ + 0xffffffff, /* PA_SC_AA_MASK */ + + 0xc00d6900, + 0x00000202, + 0x00cc0010, /* CB_COLOR_CONTROL */ + 0x00000210, /* DB_SHADER_CONTROL */ + 0x00010000, /* PA_CL_CLIP_CNTL */ + 0x00000004, /* PA_SU_SC_MODE_CNTL */ + 0x00000100, /* PA_CL_VTE_CNTL */ + 0x00000000, /* PA_CL_VS_OUT_CNTL */ + 0x00000000, /* PA_CL_NANINF_CNTL */ + 0x00000000, /* PA_SU_LINE_STIPPLE_CNTL */ + 0x00000000, /* PA_SU_LINE_STIPPLE_SCALE */ + 0x00000000, /* PA_SU_PRIM_FILTER_CNTL */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* SQ_DYN_GPR_RESOURCE_LIMIT_1 */ + + 0xc0066900, + 0x000002de, + 0x00000000, /* PA_SU_POLY_OFFSET_DB_FMT_CNTL */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + + 0xc0016900, + 0x00000229, + 0x00000000, /* SQ_PGM_START_FS */ + + 0xc0016900, + 0x0000022a, + 0x00000000, /* SQ_PGM_RESOURCES_FS */ + + 0xc0096900, + 0x00000100, + 0x00ffffff, /* VGT_MAX_VTX_INDX */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* SX_ALPHA_TEST_CONTROL */ + 0x00000000, /* CB_BLEND_RED */ + 0x00000000, /* CB_BLEND_GREEN */ + 0x00000000, /* CB_BLEND_BLUE */ + 0x00000000, /* CB_BLEND_ALPHA */ + + 0xc0026900, + 0x000002a8, + 0x00000000, /* VGT_INSTANCE_STEP_RATE_0 */ + 0x00000000, /* */ + + 0xc0026900, + 0x000002ad, + 0x00000000, /* VGT_REUSE_OFF */ + 0x00000000, /* */ + + 0xc0116900, + 0x00000280, + 0x00000000, /* PA_SU_POINT_SIZE */ + 0x00000000, /* PA_SU_POINT_MINMAX */ + 0x00000008, /* PA_SU_LINE_CNTL */ + 0x00000000, /* PA_SC_LINE_STIPPLE */ + 0x00000000, /* VGT_OUTPUT_PATH_CNTL */ + 0x00000000, /* VGT_HOS_CNTL */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* VGT_GS_MODE */ + + 0xc0016900, + 0x000002a1, + 0x00000000, /* VGT_PRIMITIVEID_EN */ + + 0xc0016900, + 0x000002a5, + 0x00000000, /* VGT_MULTI_PRIM_IB_RESET_EN */ + + 0xc0016900, + 0x000002d5, + 0x00000000, /* VGT_SHADER_STAGES_EN */ + + 0xc0026900, + 0x000002e5, + 0x00000000, /* VGT_STRMOUT_CONFIG */ + 0x00000000, /* */ + + 0xc0016900, + 0x000001e0, + 0x00000000, /* CB_BLEND0_CONTROL */ + + 0xc0016900, + 0x000001b1, + 0x00000000, /* SPI_VS_OUT_CONFIG */ + + 0xc0016900, + 0x00000187, + 0x00000000, /* SPI_VS_OUT_ID_0 */ + + 0xc0016900, + 0x00000191, + 0x00000100, /* SPI_PS_INPUT_CNTL_0 */ + + 0xc00b6900, + 0x000001b3, + 0x20000001, /* SPI_PS_IN_CONTROL_0 */ + 0x00000000, /* SPI_PS_IN_CONTROL_1 */ + 0x00000000, /* SPI_INTERP_CONTROL_0 */ + 0x00000000, /* SPI_INPUT_Z */ + 0x00000000, /* SPI_FOG_CNTL */ + 0x00100000, /* SPI_BARYC_CNTL */ + 0x00000000, /* SPI_PS_IN_CONTROL_2 */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + 0x00000000, /* */ + + 0xc0026900, + 0x00000316, + 0x0000000e, /* VGT_VERTEX_REUSE_BLOCK_CNTL */ + 0x00000010, /* */ +}; + +const u32 evergreen_vs[] = +{ + 0x00000004, + 0x80800400, + 0x0000a03c, + 0x95000688, + 0x00004000, + 0x15200688, + 0x00000000, + 0x00000000, + 0x3c000000, + 0x67961001, +#ifdef __BIG_ENDIAN + 0x000a0000, +#else + 0x00080000, +#endif + 0x00000000, + 0x1c000000, + 0x67961000, +#ifdef __BIG_ENDIAN + 0x00020008, +#else + 0x00000008, +#endif + 0x00000000, +}; + +const u32 evergreen_ps[] = +{ + 0x00000003, + 0xa00c0000, + 0x00000008, + 0x80400000, + 0x00000000, + 0x95200688, + 0x00380400, + 0x00146b10, + 0x00380000, + 0x20146b10, + 0x00380400, + 0x40146b00, + 0x80380000, + 0x60146b00, + 0x00000000, + 0x00000000, + 0x00000010, + 0x000d1000, + 0xb0800000, + 0x00000000, +}; + +const u32 evergreen_ps_size = ARRAY_SIZE(evergreen_ps); +const u32 evergreen_vs_size = ARRAY_SIZE(evergreen_vs); +const u32 evergreen_default_size = ARRAY_SIZE(evergreen_default_state); diff --git a/drivers/video/drm/radeon/evergreen_blit_shaders.h b/drivers/video/drm/radeon/evergreen_blit_shaders.h new file mode 100644 index 0000000000..8f2dbb7b0c --- /dev/null +++ b/drivers/video/drm/radeon/evergreen_blit_shaders.h @@ -0,0 +1,35 @@ +/* + * Copyright 2009 Advanced Micro Devices, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + */ + +#ifndef EVERGREEN_BLIT_SHADERS_H +#define EVERGREEN_BLIT_SHADERS_H + +extern const u32 evergreen_ps[]; +extern const u32 evergreen_vs[]; +extern const u32 evergreen_default_state[]; + +extern const u32 evergreen_ps_size, evergreen_vs_size; +extern const u32 evergreen_default_size; + +#endif diff --git a/drivers/video/drm/radeon/firmware/BARTS_mc.bin b/drivers/video/drm/radeon/firmware/BARTS_mc.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ba95683db9287249fcdbf74df12712691898478 GIT binary patch literal 24096 zcmd6vdwf;ZmH1co0fc}Ms7|r9HYi$rAs|+*R&QPKX>^;P_R*V^ZtoO_di z{q!-vKlbOIv-jF-uf5*;ajpctyTv_PA>s~^;C->;@}s4q@G%K`dGD>FR8yu%kR4As zoWgr{lDMw-#dT9wQC7b%LE~u>)X(>LepD&0XNb5jy&>|>89a{>cm5$fe^`RlMBY>4 z9vUM-!wPYAH4^M`;_AOAK`ZYkt_06^k!iIeM~)Zy)SFlxJ6v4;I(}#J zJD1-&k-gxbzCi+pt0)|8w96v!$7Ag&9jnEU6{P%}gSRRq*p#ANAa3&vaYB8HxraRI z;{kPV1>#PgFK!xiW}v0#ZgHt066A*SJ^@}7#hvpN-X}1hZ&7!2q7K?xzfE0%vRP!& zRFNf9L^hrzvUPIE@7w81du}r{cTfji(BaY(>C1Zt+A>4Mtvg%X`VHbXye9IUlfg3` ze5Z*#@=1~VJ|(W^qrkjNzvH2A6!^d~<5GTy(w}+M|D5*M!NF{ooJyb5eV;~ToT~!% zi{dW3Sb~v!F^^@; z1<-pC^dOry<{_gcSUgOE8$TyO=jRyjLUGM0;Ci6}_}qyS6ya_0Q0Snp)%a(T-_HX=$J{}c=TpAdV?INw}v|Nxc~jP zFN0$=`UDNVdnCv|O#h#vw`0+DbS(X0ah=ul#b(|~iK~Ujok#iiy<_Psl*!^AhJQVy zM2-VS<+kidV5f_lf0VeHIX`y(66+WA7DQe^9x2r&5xIu3^7PpQ?^da5FTZjCUxF&vK0GK2C@M-(xd;4%^zlwh8Jdcm@I+J~> z6z?&ICHh>IfQ6@ZWw4Wen1H=D0gFrxc2pm4kDU+G`)tE?=zP$-y`#m^=4C)##DnYu z34GQ4$3A{>0=BDfoY2<>#cFguOF@TXnMZVCWB5N;aT{&WlsX2TMITntz8XEMLGJAz z5wDLE#WhV3SBuZaeqGa1=oEgULwP*{o&Plb+9W8Tw{>Yh7wSxA)Vt<11EI5~bLfld z9C{b(Tu|I6?gVTthEcsyy-dJhUkVe=!|TK3Qn{V-cX7Mx(RofRZT}>?fIsfzZ_gn5 z;A4#Ge2FfsN#IvqNWhio!TJQ8(xGr8y$$`rI`B#YS9R%_CGy|n@gGq3N=qnvhpzoa zWv@I_xdujSf4QS~$@T$deir>hf7DOj316bJj_v3Tle@U_-Uq54lDG8n0o#jX0X$Bn zXjeKjv5vZF&^GNn&*SjfO?xpRn~3&N#IE6e{xu68jrH|+;%|TN?W*NY@J=BXp}#ro zY1&&hj?bTXUxkiRAL+V#2;4J>X~YpX{XY`(dW(sq`sUQGb8;cghj`zY5sUv)NxXN& z`*Fnn<32^6^hw_@M|&d1OC_=WxYNTnY*yoW{og`UMMyL8w@6;5^pU^0hyDs)T_6=3 z@5Yv%#fOk<0P9vOUOzY2)suL}HsX5hDSmz`@w_zg{FC@O$}yEc5&pqsT2T;@3gn&| zM>$lalGtl9hd=neijB}(Jc8VW`YRqGmmq)Hd?oy=5% zPwAo!oa(z4f?shJ&SQ)dLYXJ^$J<%OM)V}~b%W~>yhbmr&3utgQxhl zM(oY>eq7w&tsZN-Yxc9|HF0b41x0w*c(qt8RU68TU<~|19sJMnJo$QX=D|td;zY|M zgO)tB)KLd5jmWo^XN}ML8_6Nv*hg3Tf5mzc^k$K5C%CT=_Xv6SngV=U2%p-qS7g(z zdR6!Uj0?P{0@ls`yx%~?mNg@W!w2I zuxt5!kKY~}PxEKf^T+T*qn?%E0p6h_t{VfLKjIxYr7I}DXFMp^3&Y<;?jG@fK)ra^ z(oPYBx{;CV`4TdTfL z58I%-0Y4D+yMlN14QfMchle)Qh7H}0o>Wn)DN{oG!9IaAc-6IUo+-gSUzgyf6C_xX z!=D|_+Vu;pV@I*RoW&aN2@15$f1I+(`pJ>Vlf4MjvAWq35D%Qi_6pW6*lT?UrQQ3m zTkxZW`^gVFV_kH$%VS^Q=B~#6fp5Xyb?-&@V7jh{#w;{TOnaoqQb|4^`e>;P=c@DB z0qo8;{KFCWTJm#^OKrQM2YXwDy;*!CFIxnSdx6bd7}FCh?u~H<_ z`6Xm{RtQ@m!42?{yvSvT1H*Iu*MRvI@9<9Z4%+&`n;#u~yr6)e)O9suMzr_O8+=~i zhWrQn1NhS31;~hTXPygf&G;^Cs{a2{pOs+ADhci*?k!%y+NJ?|5@Y9>PZZ-?up^!; z9$#ef$(@g_{Ro@8h5q-i7kBguYj;BzA#e0SeHL-doxi8gS8jTPI_lREr+^nnTma5s zEpCNARmbQ?E?w*gY)XlHd`=(#%W0}WhC_ahoHUQt__vGk$jPrE=ZIu~4YYsz1!TSr z*+b8_;6=+_BCjLdw8jkTZ`;k>S7KYQiah^Y_9c+xNn6GJ7#%Q}yvR@Xg8w@3Biog2 z#P(m%=edFVO&Ll35XvzUG%aA>^hq(_n|Fgl;}5<`b;CCAwxeL7Bh z0d)U{g8gV5+LAK*2!#)~#7s5wb3?BSeyZ$1RO*Ik>!S>Ou zz@aDBroXgpZj@lym9*hkwnJkUxexstqao67%{hXFF9L&1m(7PJYzjSdjnofhLpNo? zeU7)e+g|ndJ=m|>q~QR!*(7o|9YS7ezh<}Cw(98swyo__IR?YP7F2FEN7%g7XS&YO zJR@V|9_gi<$6P}`y35g}>{w(bKL6G}x_)X%p>xzV;Ez7T`e6OZ=n8qq4B|vHdGSpA z{yArgn|C?yGvPD5RbKW`^0)F#zS>dGFS&Eax%}36`&fp~t$(@?SA<7#DxT(Z2Em12 zD8YqIEK@%Toy*`$?XltfkaKMdlfV|oL5uDiu4d1(b06}04;bagFleB@16ZYbJwCcP zi*hmTlN0UeMch80_G`m27BA3#B?0*eqJY?zD9k64{ z8H{-+V>0iD-h?L+j*5~P;c8fqpikx_iAnPM`=M^&FVv@|P6S7lkJ}C7vAY%G&PC4m z_ka`Ge(8SbXCAsgeZD?3&T90Uep1PNyHcY20k&r8Wt>P?d6s`5Zzo@O>m%Bb3w!#S zYXmpVBi_$L-;hJJw{JR(jj_kyABH;i`dt_EOXd`}d5PyH$VhKt5eSqML}_(}E^ z+=gbeRpVP67j{7}eb%98k=?9A@1A=Noj`s?>}?@_u94qGzp`~iRA;#i>k7*a3iL0+ zyH&qutSmOBwEPYo{SZ7sE?ICvpG+IYe!@ujp!C4^n_7wS#~}afLVm($gGU~~2e&=% z{fp)mN;B&YY5KIt7s!?LeMgbF(+%7&J>0gB!!KyR?M38;U8LZ5`Y3*p*{lLq2vC1GS~eC`NHw|C+O1n zRG0F+Bqq9!N5g0MieAXxPf(7ACe80QAhT+d*Fbos@(lb8^7;t!>QdX=<@wOXIE#)0 z_gNk{wqZJwWxVc_z1&ijrk|E)tYU6vlg9%OZ+aQCh|RX<_$3~WOCulb0ejLm*M-iI zp9G7J;hh-K3Xjyrn#KY<3B5^Sf8F^RepjKp*ZMy6wKkn!>$Sw7eO~7jUje!oqC-=+@$w1itE6yt zg@3Yfv~OxC@JRwa%Lo;%3 z6B+v&xT)7%SkHv4A8k{IdN=l8_&>W&o_aS_x!QU z8`$ElBE_GHjKGJaCVQUb;p0Keye`!+H)O~}OXi~OK?Cx>W>Q>l>sxeSaQQ%|$tThS zXw)?%dMH=_4Bpp<<0Esm{chw@E-(1#4%!~ds}>k=4k$15Za?yJYv31hb89v*zL%fo zLP2YDs5{gRBIgJ$mUEgpBy2TMT~nNDclel!C*Fj&(9K*;=W38~o<0Y?3189UNJk3j z_o7cQC;E4&3{DZLc?|@tOG21nM;p2$@I7tv33dY4g)Z+vuj_vn!@2xjj6c)#$8}E> zw`CzP$i0BB?O2F@E*(&(Ob*zW&*x`=dki`P-NkCk6!^pV=4VoVF6u+_(0f4JQdy}? z7#|%ewJm(_eq=R}ZJF*H-;ty06glaBWw7Nk>=ob91rJtZff)2kMCpi_!f=%#Aq4&5_2jb>unNbX8}LY<1EWlB7Ih$ zrFt$C&`Z^;@I1uUc6t`_3U%b~I+rMZ1}*H17!A-ZEW(Ulx+|+&8LbfkQ>-jBnXFX7!qx~3O%so|tibKWA4}2x@Ue7$3 zFY#S<+{btIK{`)tWPtb{$L>|gAhb*6%iytD?VJ+YYI#0mdorQVG#Vors85Z3DSDtW zvj<&K`L0GTw5u=mFvt{LaF-KDI?4S;Tx{|%oe6a;$Q&8#SdbxKQ61Eraq9!j7nwZu zXeb}_JO^y+k`O-4JMgWlhYPT;M}c?NR`KKn_&H82XWRf?kv_NnC?3mQLGGq!OX|~~ zWNkNq4n_0yGTOh5>6##34=wr-<0CIy4>5n;$86x8eXKv(dguqtZvt!j-Z{oIS$3Gn zy-Y^WlFIB@E_ywjcdf`pd*XImqh#PW>m1#;(|$JB9CaD^UAQiWb+zbgj=KHj%IB)A zR1WCF6mk&b?L*{1PjM!uYy4v<_|rc&caCh7vqo>HZT;=^;XUZyOmrOHb6#XNTVi9( z6+3bH{yDYkf{a7=G#>65+~)r1oVo^|{HMsP$ar|Ry5Qn8iw%Y9wEKM3Ah?mQCrRFAi6o`auxq3H!OD9_)wzT|aZ`*)?tN#Kv>@0Ij*Vf@iHvzKGw4|bvXJNr|E=YRN$ zFmJawqItaL15Z1? zB^6Ko4Ry##Y1F#>66#Lp1$)uG0=;vhZ5__TqAzL>@&oc`lf{L|N6${zTDyFwuio0h ze?VCQ6Wd2Jj~@wbU2P`20oSv%51PlTUu4coyV|qOA-35xb3-oJtTet&tYjZd;dFh! z0|8&tU(PL-c&E^e*shY*_7>9M)`& zXT2BP(i`^C{ER!o;k{tH6I{MNu>2n0#kpmj+3sMud}-c}U4}O9bU!W12`q14+&>@a zWWBX?s@Xc{cL3wLZ4+XUemq^++-n^vkue&pv(zA`hJ_gC1vVsCW=dh+Dm;&j~Oige)`M-00Ke(RZgUZ&2djHLG&M5y3b59+|>m0J-{6p7vG8Wng zSj*WSZP{LIUw_uqw!RyDpEcT(l&jgVXk?6a=svlT?m94FyHXbd(gTV+{({3^bOqY1>>{9p7>FpXR@bi`wm^~ z&y?+{O5<}ro{nHYB}JU&F0{Y*P{sbC@&#Q@?5DUizJ)t?dSA%zS;ND3fwA+5yX@I@ zqMu5y)^ESt+WP9K*E5SzPkA1wU#IweXlRM%qH~SrqVr13#dWck*L{Yvxo8}y=C*Dsgom%|ScJAGgFdBVPK;|bi=#OG|9#rf&Qc0T2vxHiO@;eLR} z8MqT92+j;+;l0hj-OewwZr24J8eDK%6e~RHZUH+5f|2FtfqkP)u7TA2y zy3p?_HqMct@vkY|uWH19a0kh9rCw-VeloJ;UC$gdz$j02k7gDA!tO+Epe^g$>#wzQ zH(R5(z}xyWyhZbO#3HlygBE&X1u^>$B3VYb-aPo;zTxrfdc zS4+;Nb7M|=Cs`JKgz`}vL+`i9Ui|+o^oKp{AT!;M-$q=`qqpi$-y#ki{5pLYU+>9A z{Q2fV;DuNEeTT;6y7R#?glA~ttle#xfXZYp02rr7rxQNfzvzob6 zC<`d?Z0=Vnj58P9Dx+s|^jCT~57+!Grso%8cYBlcoKsE@JZzdopDo}}dg!A#B6{jF zv~{Bc$Rc?*Qch1yXGoXnEpx3ogt=b}4s>04oY@L4#^n2+pa{=$)wFHpd6E4(J@-z$ z$8u479t|GFq4r{OrEerp#jiX|?sIprf1o~QXR6dc=p97Gq597qLZgkk*te#$p|8W| zq%Wpi1}dyElAEU#vKi{7dr3atYdR{-w8*^0wi(BA?wRADQqDc(AYDEM)=fWYx_A za#)Bw?tp)^scq|AIG?cfO$Bn$XTysXG%YPV~p`DgU?KWp_f{di-N%skr(difed)oO?Zf48J$y@V+}?>+uJL z#ppG3FUR&YH@CR_J-&g%?=8Q`*Ae60#uemRz%Ot0br!dO?7xd!{taJ89JjNwrN1Ul zw~6Z|W(~bV+^_$Mc)d*A%m0kOTrKW5{~|%tmHp@o^gD<&^~pPCW6tyIZPSU0aNfuN ze=%3Lp4hj1Cv%@I!Gc*5%;8t{MN7HPE}(4=Fj2eh|DmgTcc?>gFgIel-BXC);bFK} z8J|mrd~pA|i+GFw95XLopGIpl&0lqI$=?l8yk7+mxlcFwjoxX{{i0TUbIIKhVxiSv zTY@h-Pm1=b%GZIq7h>PopnGx=cVU~*Z|3OjAT4_CzeNA9Q;3=v)OGGJiTHGv=CR+ z{?ZG$hsk_ydj-)I@Z~Yc;%*dk$RFHlrLhBl1&(f>*<-SE-rf}7DZuj`{O+97-;Uvz>(ad{#!K3` z>S5JQo>t|%@-^grwEi`pUA5H1Xzt1WpW0Id=W5tbsQN!XW@s#q`s+BVTOq9N2Pka* zvsy_{!YcV0{Z{gv>~6UP0w33m$SARi8gQ~`)TeAtl2Q< zvu?_!kd6hOw&F&{hL>IHW6-IHUj5aW!#CzZ>%BfFE{x^(NDAwbhJS{}+oAtiXu<~d zJB1C*NAJOz9@J3xMyP+p#T5D;;&#m`zFEA0`=w2sWq(D2>|rs@!Jc|xKeiv(kJ)^J ztk-q73Efrt%IG$KHOQLMbrsMH=0~mYSzf=Qs&)I;se9PdynF8|aTchJMT9sPUAwDD4q%?Eh7==a#{?d7U0$o^CDu^KV0Y9b=^^ zb0}E~`fu>%Jiy0xL65FqtsioUea-~Nor=CKruZ=j@=?ORMTw4?uE0mt6ZApHbq}FG z#I+>fPAo9=_GnR>~*nXuyv298CAurs9WNn`B@bE`)|sI?8EqV;_fh=AJlP zjr^ADX~S0!0Y5nKWwtKMBOBc>u=@$L;lFL)Q+ZaPAk*j$w(SG!eQUeFTN&y;@iTEx zNbduc+~d`|KCAGBJ@~}s`}|mW;);%=d64Gvt=R$Z4|%$2Q#)WECA#zN^PjyXbFuRv zog1)j4R~klhCbwj-gp~D55n)-^t<55jt9G|s^{iGaTT$Q{Rgvg{2|{Q82-8|J^kt% zbnQ%jVE0)=zv)i;D0#lZjDYR}XG=}Qvn(_zJ^f*Ao*CdWj{{#tnG=o)?i@mJQ$;GL z^wCV6_tE&y+~Xogo+NVIGv1;(SANrdvOMHoNaZ+zbK9@{UzUU-ANwCI*2<3hEwnVCis;cSNZHx_}2mO zdw!M{Cj{8Jl`isEm~P_VZ~`ZZk-574zld=GNyrur!Dqt7+K z>oa`^^XUek*#B_r(d{nw&@4`&bL1OI-&~#}_;_;!;}LW7$giDzYS{$V-^fT~@IdkC zL+FqCW7e2S+(By_esZ5w{2Q^~_P&Y18kdaz-+>$a%fP=J{9(QFT<7T4&{y{jTT})W z_7DsqwZN#Xi2M?G-y`crYEPu;*qcNJKBTHjUBt=}T(eSh*Q{Z=N>JI`5i7y6f+ z?UcurP+oRde9iUvJWrF!GmN>(|I3K#qyKu6z0iE*JFHz-vX^@$I>mlu5Av`*MEpf@ zGBU<~upx0D#!h$ho`PTShWHT_XY-#V_-NY;B}c0n4=j9UY#W3BV6rjvH|nqa>rj1! zCt-g#ooD@aVGX$TdxCYu_J&Sz8SrVGTKBBDdh%aAvw8%Y^_~s?ITo~bnh&ekI3L=7 z;``TKCBfnpH2qM58()Br=zkXb$nl=bQ+g(Oa(_>Gfd0t1gjdX^xtYC-hv`27{llNl z!}iyb!>_|0X14hC#5wE@MzJgWu1syl`ZTIP)8{Rr{-fVn-Z>v|?DN>~W#lbo{Z0SN z>dd|qc4YroQ({L`5_VKzJ%JtZ-#2DQYA=~~{Ny(nmpxL|HM5y^>am&3+C;tD&|2!? zkLvaQcoy23Yf>FKt<=VD=tUls$i~!XC2d1x9qDak3nAZvm9O^so0Y$T*Ewt%JDP#+ zmGeb?mij4;Ys7WaQPtI(GxUMCH?r-lbq@bskA171Ms+Q`7g^)#ceInSJO2Aq_d@MVvV&jUFSPHT@dq8qME!pr zpL6J`+{cHeu4>-%)Yri8JkQ`d^wP4ip}*hQ)alsJ>kb{y{}lX!zPorni)UzNU)kCY z(eG<^d)_PE`IW$2Ca!%YW1>5m3G7EM!DnMvx(^fSo#DN#jE>v@bWo>s==Z4sIAc7# z>wkYnc=+a2^KScoKywd0J-J+DHgL2 z;|zJH&r7<;BEKr=s3Q;ISN8_>yofbil+%~r_p|SCQlsI`xxir$2ly5-D0cgGTevQ? zI|=xn^8Ri^AsiFk-O$E5X^-8jj{7SQh>`kTPrq+@h!wWiqc);3Lv6Vy#XR5a`1C39fb&AL|a%K?dV%6q*_HLiww?zfX0Cck^_`z{9EvwKtIg=&+QLlQTv4*ACC z66l@gk5`G2iG%VAM0h6Q^^`g_f6Q3PVVa*@Vht6IJr0UfpG5c zyX^zqGqwMQO3*1|-xJHP2KYv*@Be4GPq`O=t+C1R8~O?V{~Yi@eMjgo>_7IR_PSfK z)7jWB{q_5J{jS^gCdi8hxNE6<>2mc>k3TgD*nRZHmxJH;BQ_P(pI}Rz{rde1{J-Y2 zT1Va-WG68eIE>aqL@HD9zKcs?S9$Fp(j4YEK|@1`zZQScLm`)GnC)YD6aHe}m7@P8 zrT-Zf(GllDtqn09el0=YR_3h!`T74uN3a=N_wlP|iA`$X===_7A*T9oYSFpyzOUWA zG#Kqiz5NI4IQn7JP3n7zd3ryyX%>Z;Lw*;@BR;RmQinWLH>L4E;mLT);rPO(6!N;_ z1C;gRPW_5F{x{QLkeR1Pe^cy{Y=qauUp+HRVVlvOQVKkLH)dmQM+Vz3HNO+=+{14H zze~So-|{{gaR!@+OPh|QoNRfyt0N9}&Wri2xw@f&4o>TLY@*+HLbz4*)B332D)>H=e&|O#bXY%ZA|CIKuphB(xzoPUu}yjlJ&aXT)?XUzCb}e*v86MtX+H#BFi* z-$iaKG;+=wq-Rm;ecO|?-FrLVEYe19r}9@jv9+=0`X*z>jclNZ-V~9;w^%po9cn!v WVSV7?;BT}Zuzf@N*;;z7;{1Pk1bxl` literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/BARTS_me.bin b/drivers/video/drm/radeon/firmware/BARTS_me.bin new file mode 100644 index 0000000000000000000000000000000000000000..439cefc25e21cb672994f382edff89de0cded8a3 GIT binary patch literal 5504 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 literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/BTC_rlc.bin b/drivers/video/drm/radeon/firmware/BTC_rlc.bin new file mode 100644 index 0000000000000000000000000000000000000000..93e8c401d86302dc046a4275215191fa5472dc65 GIT binary patch literal 3072 zcmeHFO=}ZT6g`s(X==aHR@$J!jARqK8o@=})rA{(ZqnZ%xa?BtOJkv+phD85v@2JF zxNswZ3clhdrBkzT;~#M0PN54y+vhox49stk85r(;_nmw0z31Jafl_S%j0~0{U?*RO zcV;lpzs>VDZHsos0QbR<{=EKS3EM&4`y5mN`NJZ1ww{?O+E&LP6xIMu*^>zEj>W3{ zr@($N3y=0)&;WV{i#*TSFqn>h0kl`_?Q(f}6UEwQxqLbYJU+Jt@?Ps36j;yeSocR< z2Dtm=*cQlT7YC?LIK{0Rh zy?qz%fw;9J;uqh(#mq3odM!k51gtav8?nA()zH6Cj9g9bNOOW)pWuFI4<@)zX&gDu z$8~}t{l7uOIrd-F{=}Muet#VIq*FhR^F?fU^Mm@D>{-mA8o~&_Jit}k3wgzutp$X{`M0%M{2I$P~yF$P~yF I`2Q662O^6C&Hw-a literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/CAICOS_mc.bin b/drivers/video/drm/radeon/firmware/CAICOS_mc.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ba95683db9287249fcdbf74df12712691898478 GIT binary patch literal 24096 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 WVSV7?;BT}Zuzf@N*;;z7;{1Pk1bxl` literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/CAICOS_me.bin b/drivers/video/drm/radeon/firmware/CAICOS_me.bin new file mode 100644 index 0000000000000000000000000000000000000000..439cefc25e21cb672994f382edff89de0cded8a3 GIT binary patch literal 5504 zcmeHLeQ;FO75}}D-Aw?)BksZi8?w73kVHNLs8s}gn}{e91&tCEM!-P%Zne-ly1RMN z{J}W-PX|I0v`sS1lo{KOGwmo-XWAG0VQSwd5x14j#2GpxHFoR_9qibVkL~ZgeUBy) z{jbx1x-)mqz4x4Z&OIOZobxtqTIdDfSZJ~c^CsG2FG20HF*Th62B)Enb4_1`!0VXr20Q}%>Ur^ zaI#g8CU@$w9E?LhW+RwxFu^lT*+;FAQ%jyz(6b8= zJZ1^bF5*7m*=58nB5n!iq^~dv1(7pEo+8JUX~N8;_ zU{g9}!KE{?j_WVc@%$R{Y!yCs85CK|+^5Yq^p7f$$BW_%XG>_MN6SDdy94< zvJH`3d!L#cNIp8myB)O=NK_#{#5+>fb0rRxoYHrhzE;Qcmbq)oI;g@kQ;SgSD3n+i zg0WXLL`G4PZlJ6N6UR(Ux0gTL`i*$4!)R zF1CAX@Md?ea<5eOuE)ctBaNO_t?}pd<7VN0@HeC+4h*Fd2M24Q3C|OxWt^0CKx?FJ znrc4-cs``p_rK8rd^ptJ|K@Oe|8K|}jN|u+S3LYLJp5b4|JK8wAztn%=YQ$pe?|Q7 zJpB9If7{#tHTU1~_Vc38HG43Q?0N*V7tQ&E@wRnvG?pS zR(G4YQ4eED2lQ9%|gMWKTNvs@@<4Wc?W?rYoPS-An)~{oF{CvpoGZtuzx@9xv^>Hp)vlq zNDSHY7=MfjiK$=}M-9}WioPpDTl=nb*@Z8LUY!`f!YeicB}{sW*<;}Q;~UAP5(jea ziG!56f_K#HBz-@Vag}g&)FtM+Y!JHffZTb;Kq|3^ake)%kl1HY4~Mbl-&J@E-*n1G z^kn5&-EOSvv@j*DO8f#V>!DGfmJ@*15Jy0d!=&s7)2fLqM~?|iX=Utx3Zuuy6w)@? zb&Rn^h-bfVNp46<9vQMRkLR8ktcOmU9-tlvIoH}M`DQ*t=*DN4a&*X@nNx4TK$pGYF3m8iX&0Pom_6#SkIn`qg=@C~zH_w4O0(eZ!=6 z>7;dF{95M1S8UZ|U41J2Dc^e|?bt{=HrnX4i#c(ab|0qQhsW7nR2%*$eE@8hI4$y^ zy=pK^a8i3Zt-@iP%w@lAp7AF7%`_%u;(xrcFjHM%qIUR z^op+Oh0JUi-MCtrdD(>(;qPa`I#~R)~%}| zUpEp_))>eF1=aX}APJ{~7Bb%V8ysq~s(4b1H(-$6q1cYR*h3%%|nWiMcU z=Y5$2ORk%1r@_s&l;`GIKi?K*GDlLL$hq#>C>Hy<+n4K~m;B9KCHYEWoT(g|=&@8IV6g961f~1}&pc&@%Fn?_#@)Acjn=ITr1$$p z`&OuO=iyY`@ZLfNZCw)1BX-QZvR&S6vNh4{R2TinT%Ze&oQdsXx7Z=(*Jq%zc594d z);g_${=JELO`{(Tt{>w4HsqAv4V+Kcqq_fIpQO&TuU0|7*3u?RD@LKPr&~xHm$DyN zHh3HAh34Tyth;Yo3)h|wY@ls-41WPPw+k)rGk@hNs67^K$vJDZLRdw6LEtd(_=dC8 zXB1KUP6LTi3z;i+i2kxzbK32Bh;NKDuB#BuX3fxz^_Z7^+6-m3njzZu`Jq(e1=_h| ze2;YO46*P$(bCnc*H=slp3*C&uaN$m{1!_OPPoE@w+r-pbJhwY z&|Hj_9Gep9`vYCQ$n>$to((xyEB%!0=i00Pl#Ew@Am0T3K6CK_=Hi3iT9dnoznt~j zx!6mELcVF@U0Gk|FKgj{0+RDN=bL}rNhPfKdW-!S&Vt(s^6HqtfJ+;mC^a;mfG3=qeO$ ze;rz~H_;~FA*omR9TJ1tZ3CsOXYRL874zbLR0^(#-%}EIC+tfvQe06_Pp0I;NEDSD z!-%tIm^wR#WsKn+nI>~#{!!qVeJR85yahcxC(!crIJc5EXPuVbS$b*dou{5=Z_fUi zx%evK{%-q9z2rv!j9sQk9!N>w&Ro^z;oSTwb3flv)c=3~OA9Ev2?H9+5kLfUFcV44 z!YxQ(C91Fq)f@}49W`i1Eq0&|Pv9oP#n^)-*pH<+jCy(**nXA;4Gbif$Xw(D>5u>VX3qrMfdK^ip7-5$ATaqRuEcgX`9&M z5AN(9Eh;8Nk#txVY+d#jO-xfwqctXa5H(Yr*&PkmHQ6-VnrahKE6`G4x8w8Pz0(Yo zr20dDb&@yd+;iTK=lwYEIpet+0|3JFpftxZ3&?A@=Ulj6#a{FtsAC3IjfWA+yJ*$0 zKF@J}KTt(6aK0c|YvcU3V7{>N5c#Q(vSF@MBjtc~!PqS}^R6|Ki(+A}4!5n1!tshG z>HQkch8UazkS@4L7Y)*)hqA8dsl-OvHp(uziEN6psow!9&o#&;VC5P~4y>#${W3R) zqbZr(JTx8G#0P8`fn~%7*QT3=23Li1vh|kBSOZ~(l82fT<)pA7YI5($Brb+H``c zyv~m{`f)p|a!csPc_e$6A~HLwq=D=!FzGV(8;+DEeZ?_b;EX|P?NEb<$NNvm(ma}zp8FvCfMu4JN|e>!b2{RsUF00hquwOrICnTb__WvQ zVx0pg^NLAkHW|wsHBNUC4rQ{U+w0VRocMi2;%R17_w;U&X)HqJ&kTM)3s~$+bJg!hNIxbjG8oZsJbpo)D;ejzIsXG;N^EIQqlWTlW0-X|ffneLuE&JzH<|oBGrKLYfJv6ZQ^y|_V_Mb?3LQs*FOe_cT2K&f!orv&viDQLdR#@(b4lGZTHNFO^g?& zj6xmNrB~KpBJX}T$$sx_*aU|$+fvxaIQ-a;S?6)$X6zU_Vqi6w>nd-oci0)$tjgY)+QoM6ZvKQdF_qc&2-=ur{^hE!kp8yyKj9RL6 zl>JWD%h-QUKXcW@S4WcmQ;B&FznQD}IGU$Fhvwdk#*V!)ImREI95V;C>NBX%;PAfV+H;6UK}tCoXVcVfeEXUn&Qk9UO6&)E1iB7J~({5~_paTt?*aM+dij5Q|vyvKLs`Az&| zJXeshe82U4P21wb0X|n_MKt$gVtM7eg?|2A_{(+9;(W z*GS_e|9lSfy(@gNQ8e)l6cHVXQLNzH6S*M2dlDm9QP9}UnC$V_xF>RJ*1++70k+9o znP;Ur_Y%OnpxWaZmzo(Kz-I!U?TnFN?G5y9FUyLY=rebg!1`%1?HwiWP1nw>)pq8q zx`t<_+PkRj|3qKlPj%K{X5%QL(iiDZculw59ahteO#pjU^2OPJmlAUQ-kW*N*qK*# z!*MakKGz& z?*MGpRioUe9`ehuoxe~X3SMz!3_0BB-Cq| zrT&UrL+A0~&;*j|5SrB$IH6X|Q_rGR?Z7O7`&yDDIb)qy)yFFvN;!V0Sa z9mLcbI)YT_r$~p+pet0wr$aAegY{8tw3g#O9KsjyL+rqxuoGwSMba+PZqogv2k;ks r3ID_%)qw|9Jsu+MB|S`fg!HJIhA-n99wR-jc4NPF4})Fx|Dt~bi-}9! literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/CAYMAN_mc.bin b/drivers/video/drm/radeon/firmware/CAYMAN_mc.bin new file mode 100644 index 0000000000000000000000000000000000000000..f3839f094dab2ff16e7dd63d33ab27c4a06f02da GIT binary patch literal 24148 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 literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/CAYMAN_me.bin b/drivers/video/drm/radeon/firmware/CAYMAN_me.bin new file mode 100644 index 0000000000000000000000000000000000000000..07f8dc3aa78043a0fc34a4352ed21b4739b1ed7a GIT binary patch literal 8704 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 LUt++Gk2C!j$i~(7 literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/CAYMAN_rlc.bin b/drivers/video/drm/radeon/firmware/CAYMAN_rlc.bin new file mode 100644 index 0000000000000000000000000000000000000000..2ba672fb2470ec9aaed0f9463a422cbbb0d06461 GIT binary patch literal 4096 zcmeHJ-ESP#75|NQygM6D;;~~JgBJTH-c-hW2S~cP&trC!sTBw9tqDmBr zJWy$Oeba=pv_>VB9q;-hA0{M$7sLa|0@_~0%UD_4L5e|@A|bVa$#|NUrhpY8hw;^ znv%*l{|<26VeT0o-hB+t*sUa`Q)1TmjNj$Kiu@vz#i3d5Km%L-1grD6JZX7txSjuT}PM%a#0|oLqQM2A8&K4Y1 zf0L2Ax5&XyWUhfXWDLg9MIYJ32kpC3YZliW!6oaAv4F>>(;dn;B6}^tnXyh`&ra{lThFg;bKBkm;Uh2j4grBjNvtAS4 z)UR}I<5fT~vL zD<@bVw%F4ysvp+j3FaHsbV_#z<3{?pcB2}V8ke{dr@{RMCHP|{bZr1Wxp0Whh;Fo$ zxgk3GJ3{{t#5h03-72*l<9?UM(MOT)?RgNaSVFYPuKF(mx1eu7)4Cbc`G!_Ops!maF6;<5%uc^BZ+ zSf>RHCF{oNhTQ$;G@da#lv1_cZo5fLB$rC6HqzUceP7kaM>^%Z$J_EFkEq&#yW8>; zPpI0V18rGrReR`Ar~L3ko${j(cgjZ}?UWxs+9^Nzcw06`)t-8?Q?5MKmcvlhbfqnW z`9wYBBDt+c{IkUxNA;LpKANl2x4J^%lYMTkJfmH5m^V&wbIr%x+Clc(0i7e}HNmhx z&+#_aL*uH)f`*XBkHZJ4$8?3RH2k*Ae(x}WSQ$%L{2do#K8|&f<^IqV) z$o#&=`|{0lpe?@!`y?{op#Bo`yd3RokJ!-OW#8t$j3axqu1Ma-?G2gJdo6wDRD{oW z;)&f9EaP0VrG_*vm8N0W4Q$bK{f}1}PhxD@r}kmovH9k65^HQR9$S2i&dDfp$cT~u zh03?JNBw#b-2l{Mq!+Iw*<&Rf2SX&A@yQu2J@;e4*4FoYn7t;dgY`V^Tw*-9g&A0R z$@7{)1L2JU)>3ko(z62kEa!Dj_*DC8qu|c^@XD|FcKKs%j~;_{=P~Z>$9{Is=RZ~n z*3@16hkRA%@`qt{Ux&3r!ODIFYaZc0T09juqdn30|A;Y=jv@XlU(z=JNvw&>Tk%@| zTJ4z5O=5n$Jtpt^&kxn$ME89FUhr%70P-QW4L`gg--?6-_JW?4{ocdE1^MxeyZ1;y z&iQfn%FprMe894=T+Uxdj<2m0@bzJMv+M<2X3b~rWB>7kYk=gQCEx53VP#fl zE2ngSWl3ks4c#}Z!+)yb5TYNf!%406a_uAWHFy|aQrnz6EkAyghpaQsXnDri1;*ib Ypj&h?Z=cFM;Z5eBKc6%3|G>b%0ek>{!~g&Q literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/PALM_me.bin b/drivers/video/drm/radeon/firmware/PALM_me.bin new file mode 100644 index 0000000000000000000000000000000000000000..a03030f82b204c549d7ecf805879f651ea70a09b GIT binary patch literal 5504 zcmd^DZE%#;6@K2mZ*~L0u!)+Hpolnc9yVZEI?GlK^R@Q=CBsiyb=?2eoPvw$FKY7n2D7 z>#y$2JLlee&OPUz?|V0D+2{a}uu*Fh_FISto`S1YBQF{Ox+fr?V`VNxPH)$dqX}SB z!sz^jaJkU;S=dAxZ-!>-2%3wexid?{@$JpPOv1Yok#Ie~t^BqLJ`p+cPQv;MZ~DUZ zra!#Z41~9xzAl2(llhfKkfqfNV463D8_eqP#`upcPhuX=xe(@)imceYC2KPZ* za5{~9n|tRFH-orY9FxApn@WkC9`Y19j!X+yG7^4(dfi5v6-gt!F%jt;idv)XO&hF> zMr=5A7FKZnH9GFUjXdjxkIsi7a~Wr8`)fOgufX?#EM4wO7~;!l#6rpXRBF;jHBht( zMaia4SF$U-wufgsppg?QL$HTuq^uw1CSW9u&LR5RHIlcC9a~nxB|Kx5@B|LP2(-c- zct)Y<405AODQl^PgBB+0Suk@3!t3L+Gj^+hndk~_Pa2^eJx!s8%9r6v7@?hqEaY=6 zwtKDnCTHy8+BjLe5|1n$Y0O5KJ#wFU$V%M>{(6kiuAWF}cXtJp@H|Xf#z}rNR4r{& zTlopV{T{RW$ScjjJ3UQDUhQo<@(1z;rC{(5Hp4X(eLS??EpF581~q^sd>yl71&48|Mmpu}*n5%> zi`pz)Yx*#&8Ri?NAC=8;t?dptYgL)GnaRkJqq4@hhCtdJw7Eg(B2+fTCYz2NE%AH7 z_|6fU%5$(^?^`w8PV3=etk&7O~IPHbBJP>lbL z5<_|lW~N#}6S1D(UII`w7Gv!mlzcm?`k_((4?dl1Y&=14LU+Ldey z?WW8dc}Atf^nEeoD&**BO3bxt5IXUIlynW!P~Aep0u^P ziZM0=!N#B3QX3*tM|w1-aNmR7)i7z(UDRVY$0}aRocRQvYxg;ER^>Tv)c@Ru^CSJ9 z_+&eua3A4B!YJVcLYwd!!e+t(!Y2v6girg9BKNS(5FzCJ*(vo%ab7fLUNB~U&6xSP zG4q^}a~TU?u~oZ$=~3TD%=a4Fv4(c6(P+`>n%GOb_tNgYBkV4!^?php02?Gu(>!Re z3S1{R={+rW>Ups(WBN(fI+xgxx;&rgs$Ow`G|b;X)_)RLMP(>t9JpF6u!x$*yKcYIKLiub|atJQnGwtBzt zMY!TiXj`ar%*$0#TRSz{-)CGXV9qjsyzXPh;LoU#{A{?c)rGkNL)|_whFledg@m&c z?D2&20~fG_a8tC)&SNevsjPszat4YUe`R~5KG24Xqz2jKCwqjS*f=&pdvqaki`GLG zZNvo0qu2@UE@b^^oML$z@3uXxvy=g_|6CIJrZ?nguYipE*El`E;VEY#&Yi&(j>L&f z)5{*kl6cuaUQBKy-)=(kcYIgX0ki5TWlv+B=6PAma<5o3C%~zhl;_mTY~4)DWUZq- zk#ohpe$33);H=#2eyPK(IZ}5F#*2%elDaE3p0QC|(ke9$j_ulP#suxf7@u3v3NP)P zck2*qgJwuovDZI<(ua zWjS8npJu=)9N?ZuEl=TDc*8*_Coa>HjiYn+-luPdOU~RI33?^}e0?aPt#f_-2pqJA zACcS(*N5s77I{jp}A)d`{%3n^ySBMR@1hd zd%uKJqlK2|nY!Q@T#pJb?WWPY1Q!Zp5{9XfAa6tKY%c86fQY4F~zyjxS2X` zfa|n>jpFCrs|h`mKgWQ+ITwfMGxD(|9;Dx~)<=7dP>iwG7(Nz?n`Ow&_D1I(9fVmt zAEk%w)S%#GpZpjHWxRKm&F_cNW~GMd->I={I7Vtva1>KbSWcSBSD`7-*e>3^Pz@f| z=1C*;`P8A%7Y@xL;^xDg{4y4ozR3HROXp3w!2821%o!{7nb7w^4M{HA zm+QV->GT@QMhBR$Hfrgk{6iY*6x0Wz2lHc^ym=`1gFNOcYw`z&b!t#@JDWT5Udo(v zx$Ge>F7ZB=H|fK|D?@w72-@9OpiRHEjLwT0`a84qHf0EX7P1~2(KVJw=Kc3lzJ;x{ z#Y~AeJ?|{^T-xJR+bz9i>Tx<@$P4!Fy56qPy@@%Yd*!Xe7%69rl*P_#Pn%9%k~#S~ zHP$&B?KY_b)x1CDGUld}wnAb+axVib*dxzo`*2YJr3sBUS--m(-%1B~zv~Km-`x-7 zYz#WJQO|XBsGxxofrtNU_yb9f4NS8>{eMm1}m0yx{J!!fN_BYV=lCCdJ zm$vU!H5=j7l*QP`)h*K`Ky@gujv>w|IiwZzhIA^>oN2LW9An} zy+h4F2NI49&3AU!C|Wb1i4%Tb$7TJ({8X2Hqb?35YSQ1xGwCVpXRQ0H`;hCcgNwak zTCB(pay`iPDp}91Gf_ZXY>gdc@7mmdA4Z);+ z!0yak$yvI+>fLUiI@j%2?{x>%`=r@UnjO4jHn89CG=nh7AF&o|LW?!{i=?gIE8$yI z&m2I3AGxs?Y0unRj@+M!gzVr- zoA;$q6MJ$g=TGq4e-MK|CTtcu)>em}yq$cN|3N}^AuGXJAUboM`NrI&e19M26K~T* zN@{zwU(5S0N?tL3jbcyV5K2p0Q>j~CgbH_r;_^Op#pWN#Aa0CLEJz%6WcKh zJ24x3QH{qj7Z-37p5o5UxCQ^h0;3SO8s%7MEW#q=1uVfo5iuLE)Qq9V+>d3(N!&)< z?Z#(V&hHL>D_l?GF0~gcU2Uj!ox+TM18h=1!9(gf zY*sOBQ7@rh{T5r*o7kpK;5+IccvzjscJ(24nAf90{Tn;g$JnJl#cuTl9#O;iF2|2D jLmx9I;(MlnJ!UTUnm6EwW(T6?-H4f6Fwy+Y|N8qc{{SVD literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/PALM_pfp.bin b/drivers/video/drm/radeon/firmware/PALM_pfp.bin new file mode 100644 index 0000000000000000000000000000000000000000..94d779f7b64b17befe7d8531e55fc7f0ab9147bf GIT binary patch literal 4480 zcmeHKe{7Uz9sfM{Uf(OF;C0-=fh~QzAxEKuvLI{@;prXVSYU%v5QGsXG7!eL#EqEj zz4nn5@p%4U8GWPELrPr=F8k~}z_ruggpG_JO2 z^D|I)$k0Dv?EoArHn=y@&PFufjB!(rBi(+{#(M3j{epom@VS?K2N+1NhVD1mbj?4W z{a60c#~b|%d^5#v`XN4c<(r(5_Bp8O0-W}Dtnwq)?LB$yMf&IchlFp!%XFM zaWpZGJ5Z6I$2iU--LU|%KKk8HpUdNr7!Fv*Vm=|36q0oZq56SG{ftJZiM-`!42Y{| z7g$Ifehc8gYFs-X&Xm{GyIlsce(enHg|macb>#1Kh7L3FvUXdplqG*Geio73HVw%) z{m4r01yk`&{OYmLLtg;8OmPj*h_MCLyd?Id&RAn(SPQkR$tZQYw6}})TABAG`F=pZ zBRrqljp8uRE5q})@^jHco;vCppHE*5vaj!AvcHtQWdTpzLHjp4dI+8?Yt3UK~Ox=6Z2dXMxk()*+qPN=@+}Sds>=BWP(= z&tAvJ^A|LA13P7|Og#?8dE?kdsC~3)o76hi_a^#ddudztB$g1*skBi^8&cO*<#kJ& zd&J)$wz7JcJwqLWDKSoyX3(6>-Cdjoj$KeJQuZnTWfSwW8hH;hs5ea$Ua6qs#%(?YEc!C%!)~c-qOuqU;x*rfjMIsiWuQ(W?dL=m&-D zu@@xAf(d*3WAj^NYWtyjP9FP7C*W{4P3JtFUW!9xg-71Wb4+5BJ^H*t_8W(Q#97qm z9@MVzbZR&<6Ueh6nL@qrb`pTVKJb+giw@>*#eS<^V*K^OKj1}{^m)?d>{J!h&hiTSDs_5Fqzy+NJJi2Xf${ykk6 zylKy%it=X?m~tkCNx2OsMjtCgU(XRNGvuS)Wqe)|K64H3+@1Mq=PKvZSkBa|%vpvw zWMyVajnr@+b(`Wk&ZJnkEpDb7^uxI-I!YMI^Ju@>(OI1}@Us@tT15H`GK?+5`IX^& zl-Om6Tj?E9`s_zoGYQsu3eM_-tdk8oE%#KuiPTJ*2dDKsy!M})^qR-v@yd=zxb*Sjm_ZhnDZahtJ@P)O)4T(`wd>&#vyFv4#Nn3#W-W*4 zH?bpf^nn#F@r>r#`H1tfSn@TQK>g$tE~GbcHt(Sg;+osc+F%@Eu2v>_hb5a($+Njr z&(l8djAS#a!}ClufhcP=Q{N2b@!KeRC!*1Xv>(Pz%!BWU+yi=C?x-EdH8wGh`s9yU zhjnmsleF9ZBjX;{xMl2Xh#qE~V~3%byN?bTxu=}sVJPuwrPwO@ZV*{6c6k>Utw z$-0RPqigc9(KWZvs4k0fxgM+9S3|XTYUMv`s{OOJTKw>TsNHF=LNT^;E9d`EKJd!pgHeX3z!ryjY#uchI8!pD0f;3qagjmSKpKf&zj z<=ThQ+1RJ$JI5K4bKdPcdiYNNhuBw;wRGpTf6KTM!(K$*O!T9^8zb||zhxNbDd8{K z*~gqnZw2qNh7|OkMT7Vv=Q4xYmmiXbNkM=1@jF=f5`(DYcTr4qqz18&&%Vfo`Q4cs zz`}yTL&Rifu*WlzTeS*a5DV~td_%KW>htFS-Vc>Ndt7R!?+ES>c{URx@wFq=ySXGQ za-z@9FM{>cV4D{g{ma_Ttu}7%DO1Issq`-y_dn4W##7m8F}ZdSap_ma6J6CN_la}c z={kV3Dt&q?;Aez%Fne=#CL*N{_V?qh0L%;GP-H$*3)nk=W$EVcl;e zM$y#?iIL|k8RJTwo?MH$XV(Fpc3AG5kIl2t?+)5wP8bhYA*m@@<(o2m*4+B^_bCGZ zI|30naGV8*I*U-DPQb zFaaJW;#N$gp7Dt?EpIEAl~wviqpZ71!(U+{HYz)q#HOO40Fq}`-PNRN^pQxotF4C8Uq Q6KXr2bXo~)#s7o;4W_PDApigX literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/SUMO_rlc.bin b/drivers/video/drm/radeon/firmware/SUMO_rlc.bin new file mode 100644 index 0000000000000000000000000000000000000000..a77627319c17164a3f11aa981362c4dc7df977b7 GIT binary patch literal 3072 zcmeHJ&ud&&6#nj;>CBsE+D?C%4(-&u5X2BFOrhc^ih~By3W{22HsV5DNH;CmjgZo( z1{t-jMUpm6x~MC=5fPyVDtL=7UdS7x_z!eZ7w%dtB1-%GzWd%wUqVsPtpks9@A>ha zbI&>V+zC2pj4T2xA-2WvHk6w%{Sce`p;zMGBQ-HFz_rg$w8pQ_ugb4NIifnct?LNK z0)(v_24k-qoC7N0Z@!DN=rl}QGz4A|CFW**QN#0sQS)uk0kzg@+M&Fwyi`y zcFl#T(4U#H$)CasfkP***$T0K*}90K3{%+hK`djJ9|z=T)+RqOSEXEEJlYS5$F&jF zIhY$GUp#}0S2>lhf{#A+y?7tb?R#KMP?rgc4;o<8|84$@oS1}_=@7vKF5#` z=}3S3B6cv2$=t@}n06}{F{m6b-9+2J`uL$m_<`>=Y&%Jo&+wk#>Q-jEsKpUbmaV^*hA{glSlc-Cs<}_uMyF(p3VVEu z?3Ny2FC2gl(a89<;F9(4zkm`-!owi@8o^6U{JY$_p`9ihRa-O#6Sty%&3ZoN+`P=<9KdeB!>ReU6*W z>Nf(Pan^^gL_d;l+<_A{R4xFoiO=5GjPp3BUe$iS3wL+eJI|<|#QaRP<{TY=u?O|$ zVeNSbUM|>c_P?M#XRbc>-|%U@4e2{Dd?tvWPO|kC#SpW3*4cW{>%lKdL)I zy01^)xqd5xVShJBJ<@9C^ABg=@M;?xoXvc1`JN19>j7a2gSkm`W`1r)>I~Ko;NH1N z^E16u_w>{GBK?rFCgxntXHQlKha(? z_9wST{4!$BoDtv8Xg#BijItk`yqVFKqw3k1=hFY1JSRPY^CzDRoaOSd%JaRd>aF>s zxuf~=Z}+VqU^x4K6^`&@>s6LNVBge--;Pf^`mSQLqbSRde70`GEOfES?LSWaFZ0ea zHBm*oHe literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/TURKS_mc.bin b/drivers/video/drm/radeon/firmware/TURKS_mc.bin new file mode 100644 index 0000000000000000000000000000000000000000..5ba95683db9287249fcdbf74df12712691898478 GIT binary patch literal 24096 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 WVSV7?;BT}Zuzf@N*;;z7;{1Pk1bxl` literal 0 HcmV?d00001 diff --git a/drivers/video/drm/radeon/firmware/TURKS_me.bin b/drivers/video/drm/radeon/firmware/TURKS_me.bin new file mode 100644 index 0000000000000000000000000000000000000000..439cefc25e21cb672994f382edff89de0cded8a3 GIT binary patch literal 5504 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 & RADEON_SINGLE_CRTC) + rdev->num_crtc = 1; + else + rdev->num_crtc = 2; + switch (rdev->family) { case CHIP_R100: case CHIP_RV100: @@ -725,6 +855,18 @@ int radeon_asic_init(struct radeon_device *rdev) case CHIP_RV740: rdev->asic = &rv770_asic; break; + case CHIP_CEDAR: + case CHIP_REDWOOD: + case CHIP_JUNIPER: + case CHIP_CYPRESS: + case CHIP_HEMLOCK: + /* set num crtcs */ + if (rdev->family == CHIP_CEDAR) + rdev->num_crtc = 4; + else + rdev->num_crtc = 6; + rdev->asic = &evergreen_asic; + break; default: /* FIXME: not supported yet */ return -EINVAL; @@ -735,18 +877,6 @@ int radeon_asic_init(struct radeon_device *rdev) rdev->asic->set_memory_clock = NULL; } - /* set the number of crtcs */ - if (rdev->flags & RADEON_SINGLE_CRTC) - rdev->num_crtc = 1; - else { - if (ASIC_IS_DCE41(rdev)) - rdev->num_crtc = 2; - else if (ASIC_IS_DCE4(rdev)) - rdev->num_crtc = 6; - else - rdev->num_crtc = 2; - } - return 0; } diff --git a/drivers/video/drm/radeon/radeon_atombios.c b/drivers/video/drm/radeon/radeon_atombios.c index 730ed2b618..cdf73a5c60 100644 --- a/drivers/video/drm/radeon/radeon_atombios.c +++ b/drivers/video/drm/radeon/radeon_atombios.c @@ -2320,6 +2320,14 @@ static bool radeon_atombios_parse_pplib_clock_info(struct radeon_device *rdev, le16_to_cpu(clock_info->r600.usVDDC); } + /* patch up vddc if necessary */ + if (rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage == 0xff01) { + u16 vddc; + + if (radeon_atom_get_max_vddc(rdev, &vddc) == 0) + rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage = vddc; + } + if (rdev->flags & RADEON_IS_IGP) { /* skip invalid modes */ if (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0) @@ -2607,6 +2615,10 @@ void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 v if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev)) return; + /* 0xff01 is a flag rather then an actual voltage */ + if (voltage_level == 0xff01) + return; + switch (crev) { case 1: args.v1.ucVoltageType = voltage_type; @@ -2626,7 +2638,35 @@ void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 v atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); } +int radeon_atom_get_max_vddc(struct radeon_device *rdev, + u16 *voltage) +{ + union set_voltage args; + int index = GetIndexIntoMasterTable(COMMAND, SetVoltage); + u8 frev, crev; + if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev)) + return -EINVAL; + + switch (crev) { + case 1: + return -EINVAL; + case 2: + args.v2.ucVoltageType = SET_VOLTAGE_GET_MAX_VOLTAGE; + args.v2.ucVoltageMode = 0; + args.v2.usVoltageLevel = 0; + + atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); + + *voltage = le16_to_cpu(args.v2.usVoltageLevel); + break; + default: + DRM_ERROR("Unknown table version %d, %d\n", frev, crev); + return -EINVAL; + } + + return 0; +} void radeon_atom_initialize_bios_scratch_regs(struct drm_device *dev) { diff --git a/drivers/video/drm/radeon/radeon_combios.c b/drivers/video/drm/radeon/radeon_combios.c index 4c2f97a79f..4e697706d0 100644 --- a/drivers/video/drm/radeon/radeon_combios.c +++ b/drivers/video/drm/radeon/radeon_combios.c @@ -1553,9 +1553,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev) (rdev->pdev->subsystem_device == 0x4a48)) { /* Mac X800 */ rdev->mode_info.connector_table = CT_MAC_X800; - } else if (of_machine_is_compatible("PowerMac7,2") || - of_machine_is_compatible("PowerMac7,3")) { - /* Mac G5 9600 */ + } else if ((of_machine_is_compatible("PowerMac7,2") || + of_machine_is_compatible("PowerMac7,3")) && + (rdev->pdev->device == 0x4150) && + (rdev->pdev->subsystem_vendor == 0x1002) && + (rdev->pdev->subsystem_device == 0x4150)) { + /* Mac G5 tower 9600 */ rdev->mode_info.connector_table = CT_MAC_G5_9600; } else #endif /* CONFIG_PPC_PMAC */ diff --git a/drivers/video/drm/radeon/radeon_connectors.c b/drivers/video/drm/radeon/radeon_connectors.c index c77e823dd6..7f88b93902 100644 --- a/drivers/video/drm/radeon/radeon_connectors.c +++ b/drivers/video/drm/radeon/radeon_connectors.c @@ -44,6 +44,8 @@ extern void radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder, struct drm_connector *drm_connector); +bool radeon_connector_encoder_is_dp_bridge(struct drm_connector *connector); + void radeon_connector_hotplug(struct drm_connector *connector) { struct drm_device *dev = connector->dev; @@ -836,6 +838,13 @@ radeon_dvi_detect(struct drm_connector *connector, bool force) if (!radeon_connector->edid) { DRM_ERROR("%s: probed a monitor but no|invalid EDID\n", drm_get_connector_name(connector)); + /* rs690 seems to have a problem with connectors not existing and always + * return a block of 0's. If we see this just stop polling on this output */ + if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) { + ret = connector_status_disconnected; + DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector)); + radeon_connector->ddc_bus = NULL; + } } else { radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL); @@ -1063,10 +1072,11 @@ static int radeon_dp_get_modes(struct drm_connector *connector) { struct radeon_connector *radeon_connector = to_radeon_connector(connector); struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; + struct drm_encoder *encoder = radeon_best_single_encoder(connector); int ret; - if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { - struct drm_encoder *encoder; + if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || + (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { struct drm_display_mode *mode; if (!radeon_dig_connector->edp_on) @@ -1078,7 +1088,6 @@ static int radeon_dp_get_modes(struct drm_connector *connector) ATOM_TRANSMITTER_ACTION_POWER_OFF); if (ret > 0) { - encoder = radeon_best_single_encoder(connector); if (encoder) { radeon_fixup_lvds_native_mode(encoder, connector); /* add scaled modes */ @@ -1102,8 +1111,14 @@ static int radeon_dp_get_modes(struct drm_connector *connector) /* add scaled modes */ radeon_add_common_modes(encoder, connector); } - } else + } else { + /* need to setup ddc on the bridge */ + if (radeon_connector_encoder_is_dp_bridge(connector)) { + if (encoder) + radeon_atom_ext_encoder_setup_ddc(encoder); + } ret = radeon_ddc_get_modes(radeon_connector); + } return ret; } @@ -1187,14 +1202,15 @@ radeon_dp_detect(struct drm_connector *connector, bool force) struct radeon_connector *radeon_connector = to_radeon_connector(connector); enum drm_connector_status ret = connector_status_disconnected; struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; + struct drm_encoder *encoder = radeon_best_single_encoder(connector); if (radeon_connector->edid) { kfree(radeon_connector->edid); radeon_connector->edid = NULL; } - if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { - struct drm_encoder *encoder = radeon_best_single_encoder(connector); + if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || + (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { if (encoder) { struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); struct drm_display_mode *native_mode = &radeon_encoder->native_mode; @@ -1214,6 +1230,11 @@ radeon_dp_detect(struct drm_connector *connector, bool force) atombios_set_edp_panel_power(connector, ATOM_TRANSMITTER_ACTION_POWER_OFF); } else { + /* need to setup ddc on the bridge */ + if (radeon_connector_encoder_is_dp_bridge(connector)) { + if (encoder) + radeon_atom_ext_encoder_setup_ddc(encoder); + } radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector); if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) { ret = connector_status_connected; @@ -1228,6 +1249,16 @@ radeon_dp_detect(struct drm_connector *connector, bool force) ret = connector_status_connected; } } + + if ((ret == connector_status_disconnected) && + radeon_connector->dac_load_detect) { + struct drm_encoder *encoder = radeon_best_single_encoder(connector); + struct drm_encoder_helper_funcs *encoder_funcs; + if (encoder) { + encoder_funcs = encoder->helper_private; + ret = encoder_funcs->detect(encoder, connector); + } + } } radeon_connector_update_scratch_regs(connector, ret); @@ -1242,7 +1273,8 @@ static int radeon_dp_mode_valid(struct drm_connector *connector, /* XXX check mode bandwidth */ - if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { + if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || + (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { struct drm_encoder *encoder = radeon_best_single_encoder(connector); if ((mode->hdisplay < 320) || (mode->vdisplay < 240)) @@ -1401,6 +1433,10 @@ radeon_add_atom_connector(struct drm_device *dev, default: connector->interlace_allowed = true; connector->doublescan_allowed = true; + radeon_connector->dac_load_detect = true; + drm_connector_attach_property(&radeon_connector->base, + rdev->mode_info.load_detect_property, + 1); break; case DRM_MODE_CONNECTOR_DVII: case DRM_MODE_CONNECTOR_DVID: @@ -1422,6 +1458,12 @@ radeon_add_atom_connector(struct drm_device *dev, connector->doublescan_allowed = true; else connector->doublescan_allowed = false; + if (connector_type == DRM_MODE_CONNECTOR_DVII) { + radeon_connector->dac_load_detect = true; + drm_connector_attach_property(&radeon_connector->base, + rdev->mode_info.load_detect_property, + 1); + } break; case DRM_MODE_CONNECTOR_LVDS: case DRM_MODE_CONNECTOR_eDP: diff --git a/drivers/video/drm/radeon/radeon_device.c b/drivers/video/drm/radeon/radeon_device.c index fd5e501c00..de3a80bb99 100644 --- a/drivers/video/drm/radeon/radeon_device.c +++ b/drivers/video/drm/radeon/radeon_device.c @@ -125,6 +125,8 @@ static const char radeon_family_name[][16] = { "CYPRESS", "HEMLOCK", "PALM", + "SUMO", + "SUMO2", "BARTS", "TURKS", "CAICOS", @@ -668,6 +670,7 @@ int radeon_device_init(struct radeon_device *rdev, dma_bits = rdev->need_dma32 ? 32 : 40; r = pci_set_dma_mask(rdev->pdev, DMA_BIT_MASK(dma_bits)); if (r) { + rdev->need_dma32 = true; printk(KERN_WARNING "radeon: No suitable DMA available.\n"); } @@ -804,9 +807,9 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent) if (ret) goto err_g4; -// if( radeon_modeset ) -// init_display_kms(dev->dev_private, &usermode); -// else + if( radeon_modeset ) + init_display_kms(dev->dev_private, &usermode); + else init_display(dev->dev_private, &usermode); LEAVE(); diff --git a/drivers/video/drm/radeon/radeon_display.c b/drivers/video/drm/radeon/radeon_display.c index 7e3bf4a504..2bd716dc03 100644 --- a/drivers/video/drm/radeon/radeon_display.c +++ b/drivers/video/drm/radeon/radeon_display.c @@ -870,19 +870,6 @@ radeon_framebuffer_init(struct drm_device *dev, drm_helper_mode_fill_fb_struct(&rfb->base, mode_cmd); } -static struct drm_framebuffer * -radeon_user_framebuffer_create(struct drm_device *dev, - struct drm_file *file_priv, - struct drm_mode_fb_cmd *mode_cmd) -{ - struct drm_gem_object *obj; - - return NULL; - -// obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle); -// -// return radeon_framebuffer_create(dev, mode_cmd, obj); -} static const struct drm_mode_config_funcs radeon_mode_funcs = { diff --git a/drivers/video/drm/radeon/radeon_encoders.c b/drivers/video/drm/radeon/radeon_encoders.c index 02e0ea4bb1..28ba395c98 100644 --- a/drivers/video/drm/radeon/radeon_encoders.c +++ b/drivers/video/drm/radeon/radeon_encoders.c @@ -367,7 +367,8 @@ static bool radeon_atom_mode_fixup(struct drm_encoder *encoder, } if (ASIC_IS_DCE3(rdev) && - (radeon_encoder->active_device & (ATOM_DEVICE_DFP_SUPPORT | ATOM_DEVICE_LCD_SUPPORT))) { + ((radeon_encoder->active_device & (ATOM_DEVICE_DFP_SUPPORT | ATOM_DEVICE_LCD_SUPPORT)) || + radeon_encoder_is_dp_bridge(encoder))) { struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); radeon_dp_set_link_config(connector, mode); } @@ -660,21 +661,16 @@ atombios_get_encoder_mode(struct drm_encoder *encoder) if (radeon_encoder_is_dp_bridge(encoder)) return ATOM_ENCODER_MODE_DP; + /* DVO is always DVO */ + if (radeon_encoder->encoder_id == ATOM_ENCODER_MODE_DVO) + return ATOM_ENCODER_MODE_DVO; + connector = radeon_get_connector_for_encoder(encoder); - if (!connector) { - switch (radeon_encoder->encoder_id) { - case ENCODER_OBJECT_ID_INTERNAL_UNIPHY: - case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1: - case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2: - case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA: - case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1: - return ATOM_ENCODER_MODE_DVI; - case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1: - case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2: - default: - return ATOM_ENCODER_MODE_CRT; - } - } + /* if we don't have an active device yet, just use one of + * the connectors tied to the encoder. + */ + if (!connector) + connector = radeon_get_connector_for_encoder_init(encoder); radeon_connector = to_radeon_connector(connector); switch (connector->connector_type) { @@ -1094,9 +1090,10 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t break; } - if (is_dp) + if (is_dp) { args.v2.acConfig.fCoherentMode = 1; - else if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) { + args.v2.acConfig.fDPConnector = 1; + } else if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) { if (dig->coherent_mode) args.v2.acConfig.fCoherentMode = 1; if (radeon_encoder->pixel_clock > 165000) @@ -1435,6 +1432,10 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode) if (is_dig) { switch (mode) { case DRM_MODE_DPMS_ON: + /* some early dce3.2 boards have a bug in their transmitter control table */ + if ((rdev->family == CHIP_RV710) || (rdev->family == CHIP_RV730)) + atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE, 0, 0); + else atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE_OUTPUT, 0, 0); if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_DP) { struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); @@ -1526,26 +1527,29 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode) } if (ext_encoder) { - int action; - switch (mode) { case DRM_MODE_DPMS_ON: default: - if (ASIC_IS_DCE41(rdev)) - action = EXTERNAL_ENCODER_ACTION_V3_ENABLE_OUTPUT; - else - action = ATOM_ENABLE; + if (ASIC_IS_DCE41(rdev)) { + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_ENABLE_OUTPUT); + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_ENCODER_BLANKING_OFF); + } else + atombios_external_encoder_setup(encoder, ext_encoder, ATOM_ENABLE); break; case DRM_MODE_DPMS_STANDBY: case DRM_MODE_DPMS_SUSPEND: case DRM_MODE_DPMS_OFF: - if (ASIC_IS_DCE41(rdev)) - action = EXTERNAL_ENCODER_ACTION_V3_DISABLE_OUTPUT; - else - action = ATOM_DISABLE; + if (ASIC_IS_DCE41(rdev)) { + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_ENCODER_BLANKING); + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_DISABLE_OUTPUT); + } else + atombios_external_encoder_setup(encoder, ext_encoder, ATOM_DISABLE); break; } - atombios_external_encoder_setup(encoder, ext_encoder, action); } radeon_atombios_encoder_dpms_scratch_regs(encoder, (mode == DRM_MODE_DPMS_ON) ? true : false); @@ -2004,6 +2008,65 @@ radeon_atom_dac_detect(struct drm_encoder *encoder, struct drm_connector *connec return connector_status_disconnected; } +static enum drm_connector_status +radeon_atom_dig_detect(struct drm_encoder *encoder, struct drm_connector *connector) +{ + struct drm_device *dev = encoder->dev; + struct radeon_device *rdev = dev->dev_private; + struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); + struct radeon_connector *radeon_connector = to_radeon_connector(connector); + struct drm_encoder *ext_encoder = radeon_atom_get_external_encoder(encoder); + u32 bios_0_scratch; + + if (!ASIC_IS_DCE4(rdev)) + return connector_status_unknown; + + if (!ext_encoder) + return connector_status_unknown; + + if ((radeon_connector->devices & ATOM_DEVICE_CRT_SUPPORT) == 0) + return connector_status_unknown; + + /* load detect on the dp bridge */ + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_DACLOAD_DETECTION); + + bios_0_scratch = RREG32(R600_BIOS_0_SCRATCH); + + DRM_DEBUG_KMS("Bios 0 scratch %x %08x\n", bios_0_scratch, radeon_encoder->devices); + if (radeon_connector->devices & ATOM_DEVICE_CRT1_SUPPORT) { + if (bios_0_scratch & ATOM_S0_CRT1_MASK) + return connector_status_connected; + } + if (radeon_connector->devices & ATOM_DEVICE_CRT2_SUPPORT) { + if (bios_0_scratch & ATOM_S0_CRT2_MASK) + return connector_status_connected; + } + if (radeon_connector->devices & ATOM_DEVICE_CV_SUPPORT) { + if (bios_0_scratch & (ATOM_S0_CV_MASK|ATOM_S0_CV_MASK_A)) + return connector_status_connected; + } + if (radeon_connector->devices & ATOM_DEVICE_TV1_SUPPORT) { + if (bios_0_scratch & (ATOM_S0_TV1_COMPOSITE | ATOM_S0_TV1_COMPOSITE_A)) + return connector_status_connected; /* CTV */ + else if (bios_0_scratch & (ATOM_S0_TV1_SVIDEO | ATOM_S0_TV1_SVIDEO_A)) + return connector_status_connected; /* STV */ + } + return connector_status_disconnected; +} + +void +radeon_atom_ext_encoder_setup_ddc(struct drm_encoder *encoder) +{ + struct drm_encoder *ext_encoder = radeon_atom_get_external_encoder(encoder); + + if (ext_encoder) + /* ddc_setup on the dp bridge */ + atombios_external_encoder_setup(encoder, ext_encoder, + EXTERNAL_ENCODER_ACTION_V3_DDC_SETUP); + +} + static void radeon_atom_encoder_prepare(struct drm_encoder *encoder) { struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); @@ -2167,7 +2230,7 @@ static const struct drm_encoder_helper_funcs radeon_atom_dig_helper_funcs = { .mode_set = radeon_atom_encoder_mode_set, .commit = radeon_atom_encoder_commit, .disable = radeon_atom_encoder_disable, - /* no detect for TMDS/LVDS yet */ + .detect = radeon_atom_dig_detect, }; static const struct drm_encoder_helper_funcs radeon_atom_dac_helper_funcs = { diff --git a/drivers/video/drm/radeon/radeon_fb.c b/drivers/video/drm/radeon/radeon_fb.c index 55a16e268f..10d643de91 100644 --- a/drivers/video/drm/radeon/radeon_fb.c +++ b/drivers/video/drm/radeon/radeon_fb.c @@ -24,6 +24,7 @@ * David Airlie */ #include +#include #include #include "drmP.h" @@ -38,6 +39,10 @@ #include #include "radeon_object.h" +int radeonfb_create_object(struct radeon_fbdev *rfbdev, + struct drm_mode_fb_cmd *mode_cmd, + struct drm_gem_object **gobj_p); + /* object hierarchy - this contains a helper + a radeon fb the helper contains a pointer to radeon framebuffer baseclass. @@ -86,95 +91,6 @@ int radeon_align_pitch(struct radeon_device *rdev, int width, int bpp, bool tile return aligned; } -static void radeonfb_destroy_pinned_object(struct drm_gem_object *gobj) -{ - struct radeon_bo *rbo = gobj->driver_private; - int ret; - - ret = radeon_bo_reserve(rbo, false); - if (likely(ret == 0)) { - radeon_bo_kunmap(rbo); - radeon_bo_unpin(rbo); - radeon_bo_unreserve(rbo); - } -// drm_gem_object_unreference_unlocked(gobj); -} - -static int radeonfb_create_pinned_object(struct radeon_fbdev *rfbdev, - struct drm_mode_fb_cmd *mode_cmd, - struct drm_gem_object **gobj_p) -{ - struct radeon_device *rdev = rfbdev->rdev; - struct drm_gem_object *gobj = NULL; - struct radeon_bo *rbo = NULL; - bool fb_tiled = false; /* useful for testing */ - u32 tiling_flags = 0; - int ret; - int aligned_size, size; - - /* need to align pitch with crtc limits */ - mode_cmd->pitch = radeon_align_pitch(rdev, mode_cmd->width, mode_cmd->bpp, fb_tiled) * ((mode_cmd->bpp + 1) / 8); - - size = mode_cmd->pitch * mode_cmd->height; - aligned_size = ALIGN(size, PAGE_SIZE); -// ret = radeon_gem_object_create(rdev, aligned_size, 0, -// RADEON_GEM_DOMAIN_VRAM, -// false, true, -// &gobj); - if (ret) { - printk(KERN_ERR "failed to allocate framebuffer (%d)\n", - aligned_size); - return -ENOMEM; - } - rbo = gobj->driver_private; - - if (fb_tiled) - tiling_flags = RADEON_TILING_MACRO; - -#ifdef __BIG_ENDIAN - switch (mode_cmd->bpp) { - case 32: - tiling_flags |= RADEON_TILING_SWAP_32BIT; - break; - case 16: - tiling_flags |= RADEON_TILING_SWAP_16BIT; - default: - break; - } -#endif - - if (tiling_flags) { - ret = radeon_bo_set_tiling_flags(rbo, - tiling_flags | RADEON_TILING_SURFACE, - mode_cmd->pitch); - if (ret) - dev_err(rdev->dev, "FB failed to set tiling flags\n"); - } - - - ret = radeon_bo_reserve(rbo, false); - if (unlikely(ret != 0)) - goto out_unref; - ret = radeon_bo_pin(rbo, RADEON_GEM_DOMAIN_VRAM, NULL); - if (ret) { - radeon_bo_unreserve(rbo); - goto out_unref; - } - if (fb_tiled) - radeon_bo_check_tiling(rbo, 0, 0); - ret = radeon_bo_kmap(rbo, NULL); - radeon_bo_unreserve(rbo); - if (ret) { - goto out_unref; - } - - *gobj_p = gobj; - return 0; -out_unref: - radeonfb_destroy_pinned_object(gobj); - *gobj_p = NULL; - return ret; -} static int radeonfb_create(struct radeon_fbdev *rfbdev, struct drm_fb_helper_surface_size *sizes) @@ -201,8 +117,8 @@ static int radeonfb_create(struct radeon_fbdev *rfbdev, mode_cmd.bpp = sizes->surface_bpp; mode_cmd.depth = sizes->surface_depth; -// ret = radeonfb_create_pinned_object(rfbdev, &mode_cmd, &gobj); -// rbo = gobj->driver_private; + ret = radeonfb_create_object(rfbdev, &mode_cmd, &gobj); + rbo = gem_to_radeon_bo(gobj); /* okay we have an object now allocate the framebuffer */ info = framebuffer_alloc(0, device); @@ -213,7 +129,6 @@ static int radeonfb_create(struct radeon_fbdev *rfbdev, info->par = rfbdev; -#if 0 radeon_framebuffer_init(rdev->ddev, &rfbdev->rfb, &mode_cmd, gobj); fb = &rfbdev->rfb.base; @@ -263,7 +178,7 @@ static int radeonfb_create(struct radeon_fbdev *rfbdev, DRM_INFO("size %lu\n", (unsigned long)radeon_bo_size(rbo)); DRM_INFO("fb depth is %d\n", fb->depth); DRM_INFO(" pitch is %d\n", fb->pitch); -#endif + LEAVE(); @@ -307,7 +222,6 @@ static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfb } if (rfb->obj) { - radeonfb_destroy_pinned_object(rfb->obj); rfb->obj = NULL; } // drm_fb_helper_fini(&rfbdev->helper); @@ -322,6 +236,8 @@ static struct drm_fb_helper_funcs radeon_fb_helper_funcs = { .fb_probe = radeon_fb_find_or_create_single, }; +extern struct radeon_fbdev *kos_rfbdev; + int radeon_fbdev_init(struct radeon_device *rdev) { struct radeon_fbdev *rfbdev; @@ -353,6 +269,8 @@ int radeon_fbdev_init(struct radeon_device *rdev) drm_fb_helper_single_add_all_connectors(&rfbdev->helper); drm_fb_helper_initial_config(&rfbdev->helper, bpp_sel); + kos_rfbdev = rfbdev; + LEAVE(); return 0; @@ -374,14 +292,14 @@ int radeon_fbdev_total_size(struct radeon_device *rdev) struct radeon_bo *robj; int size = 0; - robj = rdev->mode_info.rfbdev->rfb.obj->driver_private; + robj = gem_to_radeon_bo(rdev->mode_info.rfbdev->rfb.obj); size += radeon_bo_size(robj); return size; } bool radeon_fbdev_robj_is_fb(struct radeon_device *rdev, struct radeon_bo *robj) { - if (robj == rdev->mode_info.rfbdev->rfb.obj->driver_private) + if (robj == gem_to_radeon_bo(rdev->mode_info.rfbdev->rfb.obj)) return true; return false; } diff --git a/drivers/video/drm/radeon/radeon_fence.c b/drivers/video/drm/radeon/radeon_fence.c index f940e408fe..15e73f0b33 100644 --- a/drivers/video/drm/radeon/radeon_fence.c +++ b/drivers/video/drm/radeon/radeon_fence.c @@ -33,6 +33,7 @@ #include #include #include +#include #include "drmP.h" #include "drm.h" #include "radeon_reg.h" @@ -56,9 +57,9 @@ int radeon_fence_emit(struct radeon_device *rdev, struct radeon_fence *fence) } else radeon_fence_ring_emit(rdev, fence); + trace_radeon_fence_emit(rdev->ddev, fence->seq); fence->emited = true; - list_del(&fence->list); - list_add_tail(&fence->list, &rdev->fence_drv.emited); + list_move_tail(&fence->list, &rdev->fence_drv.emited); write_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags); return 0; } @@ -77,7 +78,7 @@ static bool radeon_fence_poll_locked(struct radeon_device *rdev) scratch_index = R600_WB_EVENT_OFFSET + rdev->fence_drv.scratch_reg - rdev->scratch.reg_base; else scratch_index = RADEON_WB_SCRATCH_OFFSET + rdev->fence_drv.scratch_reg - rdev->scratch.reg_base; - seq = rdev->wb.wb[scratch_index/4]; + seq = le32_to_cpu(rdev->wb.wb[scratch_index/4]); } else seq = RREG32(rdev->fence_drv.scratch_reg); if (seq != rdev->fence_drv.last_seq) { @@ -118,8 +119,7 @@ static bool radeon_fence_poll_locked(struct radeon_device *rdev) i = n; do { n = i->prev; - list_del(i); - list_add_tail(i, &rdev->fence_drv.signaled); + list_move_tail(i, &rdev->fence_drv.signaled); fence = list_entry(i, struct radeon_fence, list); fence->signaled = true; i = n; @@ -212,6 +212,7 @@ int radeon_fence_wait(struct radeon_fence *fence, bool intr) retry: /* save current sequence used to check for GPU lockup */ seq = rdev->fence_drv.last_seq; + trace_radeon_fence_wait_begin(rdev->ddev, seq); if (intr) { radeon_irq_kms_sw_irq_get(rdev); r = wait_event_interruptible_timeout(rdev->fence_drv.queue, @@ -226,6 +227,7 @@ retry: radeon_fence_signaled(fence), timeout); radeon_irq_kms_sw_irq_put(rdev); } + trace_radeon_fence_wait_end(rdev->ddev, seq); if (unlikely(!radeon_fence_signaled(fence))) { /* we were interrupted for some reason and fence isn't * isn't signaled yet, resume wait @@ -319,7 +321,7 @@ void radeon_fence_unref(struct radeon_fence **fence) *fence = NULL; if (tmp) { - kref_put(&tmp->kref, &radeon_fence_destroy); + kref_put(&tmp->kref, radeon_fence_destroy); } } diff --git a/drivers/video/drm/radeon/radeon_gem.c b/drivers/video/drm/radeon/radeon_gem.c index 68fc2f20c0..5c68acccd6 100644 --- a/drivers/video/drm/radeon/radeon_gem.c +++ b/drivers/video/drm/radeon/radeon_gem.c @@ -38,9 +38,8 @@ int radeon_gem_object_init(struct drm_gem_object *obj) void radeon_gem_object_free(struct drm_gem_object *gobj) { - struct radeon_bo *robj = gobj->driver_private; + struct radeon_bo *robj = gem_to_radeon_bo(gobj); - gobj->driver_private = NULL; if (robj) { radeon_bo_unref(&robj); } @@ -51,34 +50,34 @@ int radeon_gem_object_create(struct radeon_device *rdev, int size, bool discardable, bool kernel, struct drm_gem_object **obj) { - struct drm_gem_object *gobj; struct radeon_bo *robj; int r; *obj = NULL; - gobj = drm_gem_object_alloc(rdev->ddev, size); - if (!gobj) { - return -ENOMEM; - } /* At least align on page size */ if (alignment < PAGE_SIZE) { alignment = PAGE_SIZE; } - r = radeon_bo_create(rdev, gobj, size, alignment, kernel, initial_domain, &robj); + r = radeon_bo_create(rdev, size, alignment, kernel, initial_domain, &robj); if (r) { - DRM_ERROR("Failed to allocate GEM object (%d, %d, %u)\n", - size, initial_domain, alignment); + if (r != -ERESTARTSYS) + DRM_ERROR("Failed to allocate GEM object (%d, %d, %u, %d)\n", + size, initial_domain, alignment, r); return r; } - gobj->driver_private = robj; - *obj = gobj; + *obj = &robj->gem_base; + + mutex_lock(&rdev->gem.mutex); + list_add_tail(&robj->list, &rdev->gem.objects); + mutex_unlock(&rdev->gem.mutex); + return 0; } int radeon_gem_object_pin(struct drm_gem_object *obj, uint32_t pin_domain, uint64_t *gpu_addr) { - struct radeon_bo *robj = obj->driver_private; + struct radeon_bo *robj = gem_to_radeon_bo(obj); int r; r = radeon_bo_reserve(robj, false); @@ -91,7 +90,7 @@ int radeon_gem_object_pin(struct drm_gem_object *obj, uint32_t pin_domain, void radeon_gem_object_unpin(struct drm_gem_object *obj) { - struct radeon_bo *robj = obj->driver_private; + struct radeon_bo *robj = gem_to_radeon_bo(obj); int r; r = radeon_bo_reserve(robj, false); @@ -109,7 +108,7 @@ int radeon_gem_set_domain(struct drm_gem_object *gobj, int r; /* FIXME: reeimplement */ - robj = gobj->driver_private; + robj = gem_to_radeon_bo(gobj); /* work out where to validate the buffer to */ domain = wdomain; if (!domain) { @@ -151,9 +150,12 @@ int radeon_gem_info_ioctl(struct drm_device *dev, void *data, { struct radeon_device *rdev = dev->dev_private; struct drm_radeon_gem_info *args = data; + struct ttm_mem_type_manager *man; + + man = &rdev->mman.bdev.man[TTM_PL_VRAM]; args->vram_size = rdev->mc.real_vram_size; - args->vram_visible = rdev->mc.real_vram_size; + args->vram_visible = (u64)man->size << PAGE_SHIFT; if (rdev->stollen_vga_memory) args->vram_visible -= radeon_bo_size(rdev->stollen_vga_memory); args->vram_visible -= radeon_fbdev_total_size(rdev); @@ -223,7 +225,7 @@ int radeon_gem_set_domain_ioctl(struct drm_device *dev, void *data, if (gobj == NULL) { return -ENOENT; } - robj = gobj->driver_private; + robj = gem_to_radeon_bo(gobj); r = radeon_gem_set_domain(gobj, args->read_domains, args->write_domain); @@ -231,21 +233,29 @@ int radeon_gem_set_domain_ioctl(struct drm_device *dev, void *data, return r; } +int radeon_mode_dumb_mmap(struct drm_file *filp, + struct drm_device *dev, + uint32_t handle, uint64_t *offset_p) +{ + struct drm_gem_object *gobj; + struct radeon_bo *robj; + + gobj = drm_gem_object_lookup(dev, filp, handle); + if (gobj == NULL) { + return -ENOENT; + } + robj = gem_to_radeon_bo(gobj); + *offset_p = radeon_bo_mmap_offset(robj); + drm_gem_object_unreference_unlocked(gobj); + return 0; +} + int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) { struct drm_radeon_gem_mmap *args = data; - struct drm_gem_object *gobj; - struct radeon_bo *robj; - gobj = drm_gem_object_lookup(dev, filp, args->handle); - if (gobj == NULL) { - return -ENOENT; - } - robj = gobj->driver_private; - args->addr_ptr = radeon_bo_mmap_offset(robj); - drm_gem_object_unreference_unlocked(gobj); - return 0; + return radeon_mode_dumb_mmap(filp, dev, args->handle, &args->addr_ptr); } int radeon_gem_busy_ioctl(struct drm_device *dev, void *data, @@ -261,7 +271,7 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data, if (gobj == NULL) { return -ENOENT; } - robj = gobj->driver_private; + robj = gem_to_radeon_bo(gobj); r = radeon_bo_wait(robj, &cur_placement, true); switch (cur_placement) { case TTM_PL_VRAM: @@ -291,7 +301,7 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data, if (gobj == NULL) { return -ENOENT; } - robj = gobj->driver_private; + robj = gem_to_radeon_bo(gobj); r = radeon_bo_wait(robj, NULL, false); /* callback hw specific functions if any */ if (robj->rdev->asic->ioctl_wait_idle) @@ -312,7 +322,7 @@ int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data, gobj = drm_gem_object_lookup(dev, filp, args->handle); if (gobj == NULL) return -ENOENT; - robj = gobj->driver_private; + robj = gem_to_radeon_bo(gobj); r = radeon_bo_set_tiling_flags(robj, args->tiling_flags, args->pitch); drm_gem_object_unreference_unlocked(gobj); return r; diff --git a/drivers/video/drm/radeon/radeon_i2c.c b/drivers/video/drm/radeon/radeon_i2c.c index 4022b43f1d..63a8bd7b92 100644 --- a/drivers/video/drm/radeon/radeon_i2c.c +++ b/drivers/video/drm/radeon/radeon_i2c.c @@ -795,8 +795,6 @@ static int radeon_hw_i2c_xfer(struct i2c_adapter *i2c_adap, struct radeon_i2c_bus_rec *rec = &i2c->rec; int ret = 0; - ENTER(); - switch (rdev->family) { case CHIP_R100: case CHIP_RV100: @@ -862,7 +860,6 @@ static int radeon_hw_i2c_xfer(struct i2c_adapter *i2c_adap, ret = -EIO; break; } - LEAVE(); return ret; } diff --git a/drivers/video/drm/radeon/radeon_mode.h b/drivers/video/drm/radeon/radeon_mode.h index fa4aaf8b7f..164e9129d7 100644 --- a/drivers/video/drm/radeon/radeon_mode.h +++ b/drivers/video/drm/radeon/radeon_mode.h @@ -480,6 +480,8 @@ extern void radeon_atom_encoder_init(struct radeon_device *rdev); extern void atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t lane_num, uint8_t lane_set); +extern void radeon_atom_ext_encoder_setup_ddc(struct drm_encoder *encoder); +extern struct drm_encoder *radeon_atom_get_external_encoder(struct drm_encoder *encoder); extern int radeon_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode, u8 write_byte, u8 *read_byte); diff --git a/drivers/video/drm/radeon/radeon_object.c b/drivers/video/drm/radeon/radeon_object.c deleted file mode 100644 index f178b9ea45..0000000000 --- a/drivers/video/drm/radeon/radeon_object.c +++ /dev/null @@ -1,764 +0,0 @@ -/* - * Copyright 2009 Jerome Glisse. - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - */ -/* - * Authors: - * Jerome Glisse - * Thomas Hellstrom - * Dave Airlie - */ -#include -#include -#include -#include "radeon_drm.h" -#include "radeon.h" -#include -#include "radeon_object.h" - -int radeon_gart_bind(struct radeon_device *rdev, unsigned offset, - int pages, u32_t *pagelist); - - - - -static struct drm_mm mm_gtt; -static struct drm_mm mm_vram; - - -int radeon_object_init(struct radeon_device *rdev) -{ - int r = 0; - - ENTER(); - - r = drm_mm_init(&mm_vram, 0xC00000 >> PAGE_SHIFT, - ((rdev->mc.real_vram_size - 0xC00000) >> PAGE_SHIFT)); - if (r) { - DRM_ERROR("Failed initializing VRAM heap.\n"); - return r; - }; - - r = drm_mm_init(&mm_gtt, 0, ((rdev->mc.gtt_size) >> PAGE_SHIFT)); - if (r) { - DRM_ERROR("Failed initializing GTT heap.\n"); - return r; - } - - return r; - // return radeon_ttm_init(rdev); -} - -static inline uint32_t radeon_object_flags_from_domain(uint32_t domain) -{ - uint32_t flags = 0; - if (domain & RADEON_GEM_DOMAIN_VRAM) { - flags |= TTM_PL_FLAG_VRAM; - } - if (domain & RADEON_GEM_DOMAIN_GTT) { - flags |= TTM_PL_FLAG_TT; - } - if (domain & RADEON_GEM_DOMAIN_CPU) { - flags |= TTM_PL_FLAG_SYSTEM; - } - if (!flags) { - flags |= TTM_PL_FLAG_SYSTEM; - } - return flags; -} - - -int radeon_bo_create(struct radeon_device *rdev, - unsigned long size, int byte_align, bool kernel, u32 domain, - struct radeon_bo **bo_ptr) -{ - struct radeon_bo *bo; - enum ttm_bo_type type; - uint32_t flags; - int r; - - if (kernel) { - type = ttm_bo_type_kernel; - } else { - type = ttm_bo_type_device; - } - *bo_ptr = NULL; - bo = kzalloc(sizeof(struct radeon_object), GFP_KERNEL); - if (bo == NULL) { - return -ENOMEM; - } - bo->rdev = rdev; - INIT_LIST_HEAD(&bo->list); - - flags = radeon_object_flags_from_domain(domain); - - bo->flags = flags; - - if( flags & TTM_PL_FLAG_VRAM) - { - size_t num_pages; - - struct drm_mm_node *vm_node; - - num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; - - if (num_pages == 0) { - dbgprintf("Illegal buffer object size.\n"); - return -EINVAL; - } -retry_pre_get: - r = drm_mm_pre_get(&mm_vram); - - if (unlikely(r != 0)) - return r; - - vm_node = drm_mm_search_free(&mm_vram, num_pages, 0, 0); - - if (unlikely(vm_node == NULL)) { - r = -ENOMEM; - return r; - } - - bo->mm_node = drm_mm_get_block_atomic(vm_node, num_pages, 0); - - if (unlikely(bo->mm_node == NULL)) { - goto retry_pre_get; - } - - bo->vm_addr = ((uint32_t)bo->mm_node->start); - -// dbgprintf("alloc vram: base %x size %x\n", -// robj->vm_addr << PAGE_SHIFT, num_pages << PAGE_SHIFT); - - }; - - if( flags & TTM_PL_FLAG_TT) - { - size_t num_pages; - - struct drm_mm_node *vm_node; - - num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; - - if (num_pages == 0) { - dbgprintf("Illegal buffer object size.\n"); - return -EINVAL; - } -retry_pre_get1: - r = drm_mm_pre_get(&mm_gtt); - - if (unlikely(r != 0)) - return r; - - vm_node = drm_mm_search_free(&mm_gtt, num_pages, 0, 0); - - if (unlikely(vm_node == NULL)) { - r = -ENOMEM; - return r; - } - - robj->mm_node = drm_mm_get_block_atomic(vm_node, num_pages, 0); - - if (unlikely(robj->mm_node == NULL)) { - goto retry_pre_get1; - } - - bo->vm_addr = ((uint32_t)bo->mm_node->start) ; - -// dbgprintf("alloc gtt: base %x size %x\n", -// robj->vm_addr << PAGE_SHIFT, num_pages << PAGE_SHIFT); - }; - -// r = ttm_buffer_object_init(&rdev->mman.bdev, &robj->tobj, size, type, flags, -// 0, 0, false, NULL, size, -// &radeon_ttm_object_object_destroy); - if (unlikely(r != 0)) { - /* ttm call radeon_ttm_object_object_destroy if error happen */ - DRM_ERROR("Failed to allocate TTM object (%ld, 0x%08X, %u)\n", - size, flags, 0); - return r; - } - *robj_ptr = robj; -// if (gobj) { -// list_add_tail(&robj->list, &rdev->gem.objects); -// } - return 0; -} - -#define page_tabs 0xFDC00000 - -int radeon_object_pin(struct radeon_object *robj, uint32_t domain, - uint64_t *gpu_addr) -{ - uint32_t flags; - uint32_t tmp; - int r = 0; - -// flags = radeon_object_flags_from_domain(domain); -// spin_lock(&robj->tobj.lock); - if (robj->pin_count) { - robj->pin_count++; - if (gpu_addr != NULL) { - *gpu_addr = robj->gpu_addr; - } -// spin_unlock(&robj->tobj.lock); - return 0; - } -// spin_unlock(&robj->tobj.lock); -// r = radeon_object_reserve(robj, false); -// if (unlikely(r != 0)) { -// DRM_ERROR("radeon: failed to reserve object for pinning it.\n"); -// return r; -// } -// tmp = robj->tobj.mem.placement; -// ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM); -// robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING; -// r = ttm_buffer_object_validate(&robj->tobj, -// robj->tobj.proposed_placement, -// false, false); - - robj->gpu_addr = ((u64)robj->vm_addr) << PAGE_SHIFT; - - if(robj->flags & TTM_PL_FLAG_VRAM) - robj->gpu_addr += (u64)robj->rdev->mc.vram_location; - else if (robj->flags & TTM_PL_FLAG_TT) - { - u32_t *pagelist; - robj->kptr = KernelAlloc( robj->mm_node->size << PAGE_SHIFT ); - dbgprintf("kernel alloc %x\n", robj->kptr ); - - pagelist = &((u32_t*)page_tabs)[(u32_t)robj->kptr >> 12]; - dbgprintf("pagelist %x\n", pagelist); - radeon_gart_bind(robj->rdev, robj->gpu_addr, - robj->mm_node->size, pagelist); - robj->gpu_addr += (u64)robj->rdev->mc.gtt_location; - } - else - { - DRM_ERROR("Unknown placement %d\n", robj->flags); - robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL; - r = -1; - }; - -// flags & TTM_PL_FLAG_VRAM - if (gpu_addr != NULL) { - *gpu_addr = robj->gpu_addr; - } - robj->pin_count = 1; - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to pin object.\n"); - } - - return r; -} - -int radeon_object_kmap(struct radeon_object *robj, void **ptr) -{ - int r = 0; - -// spin_lock(&robj->tobj.lock); - if (robj->kptr) { - if (ptr) { - *ptr = robj->kptr; - } -// spin_unlock(&robj->tobj.lock); - return 0; - } -// spin_unlock(&robj->tobj.lock); - - if(robj->flags & TTM_PL_FLAG_VRAM) - { - robj->cpu_addr = robj->rdev->mc.aper_base + - (robj->vm_addr << PAGE_SHIFT); - robj->kptr = (void*)MapIoMem(robj->cpu_addr, - robj->mm_node->size << 12, PG_SW); - } - else - { - return -1; - } - - if (ptr) { - *ptr = robj->kptr; - } - - return 0; -} - -void radeon_object_kunmap(struct radeon_object *robj) -{ -// spin_lock(&robj->tobj.lock); - if (robj->kptr == NULL) { -// spin_unlock(&robj->tobj.lock); - return; - } - - if (robj->flags & TTM_PL_FLAG_VRAM) - { - FreeKernelSpace(robj->kptr); - robj->kptr = NULL; - } -// spin_unlock(&robj->tobj.lock); -} - - -void radeon_object_unpin(struct radeon_object *robj) -{ - uint32_t flags; - int r; - -// spin_lock(&robj->tobj.lock); - if (!robj->pin_count) { -// spin_unlock(&robj->tobj.lock); - printk(KERN_WARNING "Unpin not necessary for %p !\n", robj); - return; - } - robj->pin_count--; - if (robj->pin_count) { -// spin_unlock(&robj->tobj.lock); - return; - } -// spin_unlock(&robj->tobj.lock); - - drm_mm_put_block(robj->mm_node); - - kfree(robj); -} - - -#if 0 - - -/* - * To exclude mutual BO access we rely on bo_reserve exclusion, as all - * function are calling it. - */ - -static int radeon_object_reserve(struct radeon_object *robj, bool interruptible) -{ - return ttm_bo_reserve(&robj->tobj, interruptible, false, false, 0); -} - -static void radeon_object_unreserve(struct radeon_object *robj) -{ - ttm_bo_unreserve(&robj->tobj); -} - -static void radeon_ttm_object_object_destroy(struct ttm_buffer_object *tobj) -{ - struct radeon_object *robj; - - robj = container_of(tobj, struct radeon_object, tobj); -// list_del_init(&robj->list); - kfree(robj); -} - -static inline void radeon_object_gpu_addr(struct radeon_object *robj) -{ - /* Default gpu address */ - robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL; - if (robj->tobj.mem.mm_node == NULL) { - return; - } - robj->gpu_addr = ((u64)robj->tobj.mem.mm_node->start) << PAGE_SHIFT; - switch (robj->tobj.mem.mem_type) { - case TTM_PL_VRAM: - robj->gpu_addr += (u64)robj->rdev->mc.vram_location; - break; - case TTM_PL_TT: - robj->gpu_addr += (u64)robj->rdev->mc.gtt_location; - break; - default: - DRM_ERROR("Unknown placement %d\n", robj->tobj.mem.mem_type); - robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL; - return; - } -} - - -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) -{ - struct radeon_object *robj; - enum ttm_bo_type type; - uint32_t flags; - int r; - -// if (unlikely(rdev->mman.bdev.dev_mapping == NULL)) { -// rdev->mman.bdev.dev_mapping = rdev->ddev->dev_mapping; -// } - if (kernel) { - type = ttm_bo_type_kernel; - } else { - type = ttm_bo_type_device; - } - *robj_ptr = NULL; - robj = kzalloc(sizeof(struct radeon_object), GFP_KERNEL); - if (robj == NULL) { - return -ENOMEM; - } - robj->rdev = rdev; - robj->gobj = gobj; -// INIT_LIST_HEAD(&robj->list); - - flags = radeon_object_flags_from_domain(domain); -// r = ttm_buffer_object_init(&rdev->mman.bdev, &robj->tobj, size, type, flags, -// 0, 0, false, NULL, size, -// &radeon_ttm_object_object_destroy); - if (unlikely(r != 0)) { - /* ttm call radeon_ttm_object_object_destroy if error happen */ - DRM_ERROR("Failed to allocate TTM object (%ld, 0x%08X, %u)\n", - size, flags, 0); - return r; - } - *robj_ptr = robj; -// if (gobj) { -// list_add_tail(&robj->list, &rdev->gem.objects); -// } - return 0; -} - -int radeon_object_kmap(struct radeon_object *robj, void **ptr) -{ - int r; - -// spin_lock(&robj->tobj.lock); - if (robj->kptr) { - if (ptr) { - *ptr = robj->kptr; - } -// spin_unlock(&robj->tobj.lock); - return 0; - } -// spin_unlock(&robj->tobj.lock); - r = ttm_bo_kmap(&robj->tobj, 0, robj->tobj.num_pages, &robj->kmap); - if (r) { - return r; - } -// spin_lock(&robj->tobj.lock); - robj->kptr = ttm_kmap_obj_virtual(&robj->kmap, &robj->is_iomem); -// spin_unlock(&robj->tobj.lock); - if (ptr) { - *ptr = robj->kptr; - } - return 0; -} - -void radeon_object_kunmap(struct radeon_object *robj) -{ -// spin_lock(&robj->tobj.lock); - if (robj->kptr == NULL) { -// spin_unlock(&robj->tobj.lock); - return; - } - robj->kptr = NULL; -// spin_unlock(&robj->tobj.lock); - ttm_bo_kunmap(&robj->kmap); -} - -void radeon_object_unref(struct radeon_object **robj) -{ - struct ttm_buffer_object *tobj; - - if ((*robj) == NULL) { - return; - } - tobj = &((*robj)->tobj); - ttm_bo_unref(&tobj); - if (tobj == NULL) { - *robj = NULL; - } -} - -int radeon_object_mmap(struct radeon_object *robj, uint64_t *offset) -{ - *offset = robj->tobj.addr_space_offset; - return 0; -} - -int radeon_object_pin(struct radeon_object *robj, uint32_t domain, - uint64_t *gpu_addr) -{ - uint32_t flags; - uint32_t tmp; - int r; - - flags = radeon_object_flags_from_domain(domain); -// spin_lock(&robj->tobj.lock); - if (robj->pin_count) { - robj->pin_count++; - if (gpu_addr != NULL) { - *gpu_addr = robj->gpu_addr; - } -// spin_unlock(&robj->tobj.lock); - return 0; - } -// spin_unlock(&robj->tobj.lock); - r = radeon_object_reserve(robj, false); - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to reserve object for pinning it.\n"); - return r; - } - tmp = robj->tobj.mem.placement; - ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM); - robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING; - r = ttm_buffer_object_validate(&robj->tobj, - robj->tobj.proposed_placement, - false, false); - radeon_object_gpu_addr(robj); - if (gpu_addr != NULL) { - *gpu_addr = robj->gpu_addr; - } - robj->pin_count = 1; - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to pin object.\n"); - } - radeon_object_unreserve(robj); - return r; -} - -void radeon_object_unpin(struct radeon_object *robj) -{ - uint32_t flags; - int r; - -// spin_lock(&robj->tobj.lock); - if (!robj->pin_count) { -// spin_unlock(&robj->tobj.lock); - printk(KERN_WARNING "Unpin not necessary for %p !\n", robj); - return; - } - robj->pin_count--; - if (robj->pin_count) { -// spin_unlock(&robj->tobj.lock); - return; - } -// spin_unlock(&robj->tobj.lock); - r = radeon_object_reserve(robj, false); - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to reserve object for unpinning it.\n"); - return; - } - flags = robj->tobj.mem.placement; - robj->tobj.proposed_placement = flags & ~TTM_PL_FLAG_NO_EVICT; - r = ttm_buffer_object_validate(&robj->tobj, - robj->tobj.proposed_placement, - false, false); - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to unpin buffer.\n"); - } - radeon_object_unreserve(robj); -} - -int radeon_object_wait(struct radeon_object *robj) -{ - int r = 0; - - /* FIXME: should use block reservation instead */ - r = radeon_object_reserve(robj, true); - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to reserve object for waiting.\n"); - return r; - } -// spin_lock(&robj->tobj.lock); - if (robj->tobj.sync_obj) { - r = ttm_bo_wait(&robj->tobj, true, false, false); - } -// spin_unlock(&robj->tobj.lock); - radeon_object_unreserve(robj); - return r; -} - -int radeon_object_evict_vram(struct radeon_device *rdev) -{ - if (rdev->flags & RADEON_IS_IGP) { - /* Useless to evict on IGP chips */ - return 0; - } - return ttm_bo_evict_mm(&rdev->mman.bdev, TTM_PL_VRAM); -} - -void radeon_object_force_delete(struct radeon_device *rdev) -{ - struct radeon_object *robj, *n; - struct drm_gem_object *gobj; - - if (list_empty(&rdev->gem.objects)) { - return; - } - DRM_ERROR("Userspace still has active objects !\n"); - list_for_each_entry_safe(robj, n, &rdev->gem.objects, list) { - mutex_lock(&rdev->ddev->struct_mutex); - gobj = robj->gobj; - DRM_ERROR("Force free for (%p,%p,%lu,%lu)\n", - gobj, robj, (unsigned long)gobj->size, - *((unsigned long *)&gobj->refcount)); - list_del_init(&robj->list); - radeon_object_unref(&robj); - gobj->driver_private = NULL; - drm_gem_object_unreference(gobj); - mutex_unlock(&rdev->ddev->struct_mutex); - } -} - -void radeon_object_fini(struct radeon_device *rdev) -{ - radeon_ttm_fini(rdev); -} - -void radeon_object_list_add_object(struct radeon_object_list *lobj, - struct list_head *head) -{ - if (lobj->wdomain) { - list_add(&lobj->list, head); - } else { - list_add_tail(&lobj->list, head); - } -} - -int radeon_object_list_reserve(struct list_head *head) -{ - struct radeon_object_list *lobj; - struct list_head *i; - int r; - - list_for_each(i, head) { - lobj = list_entry(i, struct radeon_object_list, list); - if (!lobj->robj->pin_count) { - r = radeon_object_reserve(lobj->robj, true); - if (unlikely(r != 0)) { - DRM_ERROR("radeon: failed to reserve object.\n"); - return r; - } - } else { - } - } - return 0; -} - -void radeon_object_list_unreserve(struct list_head *head) -{ - struct radeon_object_list *lobj; - struct list_head *i; - - list_for_each(i, head) { - lobj = list_entry(i, struct radeon_object_list, list); - if (!lobj->robj->pin_count) { - radeon_object_unreserve(lobj->robj); - } else { - } - } -} - -int radeon_object_list_validate(struct list_head *head, void *fence) -{ - struct radeon_object_list *lobj; - struct radeon_object *robj; - struct radeon_fence *old_fence = NULL; - struct list_head *i; - uint32_t flags; - int r; - - r = radeon_object_list_reserve(head); - if (unlikely(r != 0)) { - radeon_object_list_unreserve(head); - return r; - } - list_for_each(i, head) { - lobj = list_entry(i, struct radeon_object_list, list); - robj = lobj->robj; - if (lobj->wdomain) { - flags = radeon_object_flags_from_domain(lobj->wdomain); - flags |= TTM_PL_FLAG_TT; - } else { - flags = radeon_object_flags_from_domain(lobj->rdomain); - flags |= TTM_PL_FLAG_TT; - flags |= TTM_PL_FLAG_VRAM; - } - if (!robj->pin_count) { - robj->tobj.proposed_placement = flags | TTM_PL_MASK_CACHING; - r = ttm_buffer_object_validate(&robj->tobj, - robj->tobj.proposed_placement, - true, false); - if (unlikely(r)) { - radeon_object_list_unreserve(head); - DRM_ERROR("radeon: failed to validate.\n"); - return r; - } - radeon_object_gpu_addr(robj); - } - lobj->gpu_offset = robj->gpu_addr; - if (fence) { - old_fence = (struct radeon_fence *)robj->tobj.sync_obj; - robj->tobj.sync_obj = radeon_fence_ref(fence); - robj->tobj.sync_obj_arg = NULL; - } - if (old_fence) { - radeon_fence_unref(&old_fence); - } - } - return 0; -} - -void radeon_object_list_unvalidate(struct list_head *head) -{ - struct radeon_object_list *lobj; - struct radeon_fence *old_fence = NULL; - struct list_head *i; - - list_for_each(i, head) { - lobj = list_entry(i, struct radeon_object_list, list); - old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj; - lobj->robj->tobj.sync_obj = NULL; - if (old_fence) { - radeon_fence_unref(&old_fence); - } - } - radeon_object_list_unreserve(head); -} - -void radeon_object_list_clean(struct list_head *head) -{ - radeon_object_list_unreserve(head); -} - -int radeon_object_fbdev_mmap(struct radeon_object *robj, - struct vm_area_struct *vma) -{ - return ttm_fbdev_mmap(vma, &robj->tobj); -} - -#endif - -unsigned long radeon_object_size(struct radeon_object *robj) -{ - return robj->tobj.num_pages << PAGE_SHIFT; -} - - diff --git a/drivers/video/drm/radeon/radeon_object_kos.c b/drivers/video/drm/radeon/radeon_object_kos.c index 012548d6d6..2fe4a90a76 100644 --- a/drivers/video/drm/radeon/radeon_object_kos.c +++ b/drivers/video/drm/radeon/radeon_object_kos.c @@ -8,6 +8,26 @@ static struct drm_mm mm_gtt; static struct drm_mm mm_vram; + +/** + * Initialize an already allocate GEM object of the specified size with + * shmfs backing store. + */ +int drm_gem_object_init(struct drm_device *dev, + struct drm_gem_object *obj, size_t size) +{ + BUG_ON((size & (PAGE_SIZE - 1)) != 0); + + obj->dev = dev; + obj->filp = NULL; + + atomic_set(&obj->handle_count, 0); + obj->size = size; + + return 0; +} + + int drm_mm_alloc(struct drm_mm *mm, size_t num_pages, struct drm_mm_node **node) { @@ -38,6 +58,7 @@ retry_pre_get: }; + void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain) { u32 c = 0; @@ -102,13 +123,12 @@ void ttm_bo_unreserve(struct ttm_buffer_object *bo) } int radeon_bo_create(struct radeon_device *rdev, - unsigned long size, int byte_align, - bool kernel, u32 domain, + unsigned long size, int byte_align, bool kernel, u32 domain, struct radeon_bo **bo_ptr) { + struct radeon_bo *bo; enum ttm_bo_type type; - struct radeon_bo *bo; size_t num_pages; struct drm_mm *mman; u32 bo_domain; @@ -143,7 +163,13 @@ int radeon_bo_create(struct radeon_device *rdev, if (bo == NULL) return -ENOMEM; + r = drm_gem_object_init(rdev->ddev, &bo->gem_base, size); + if (unlikely(r)) { + kfree(bo); + return r; + } bo->rdev = rdev; + bo->gem_base.driver_private = NULL; bo->surface_reg = -1; bo->tbo.num_pages = num_pages; bo->domain = domain; diff --git a/drivers/video/drm/radeon/radeon_pm.c b/drivers/video/drm/radeon/radeon_pm.c index 4c1cda82e2..97937d72e1 100644 --- a/drivers/video/drm/radeon/radeon_pm.c +++ b/drivers/video/drm/radeon/radeon_pm.c @@ -23,6 +23,7 @@ #include "drmP.h" #include "radeon.h" #include "avivod.h" +#include "atom.h" #define DRM_DEBUG_DRIVER(fmt, args...) diff --git a/drivers/video/drm/radeon/rdisplay_kms.c b/drivers/video/drm/radeon/rdisplay_kms.c index 7149ddbcc8..1a52d9705f 100644 --- a/drivers/video/drm/radeon/rdisplay_kms.c +++ b/drivers/video/drm/radeon/rdisplay_kms.c @@ -6,6 +6,16 @@ #include "radeon.h" #include "radeon_object.h" #include "display.h" +#include "drm_fb_helper.h" + +struct radeon_fbdev { + struct drm_fb_helper helper; + struct radeon_framebuffer rfb; + struct list_head fbdev_list; + struct radeon_device *rdev; +}; + +struct radeon_fbdev *kos_rfbdev; static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor); @@ -197,6 +207,11 @@ bool set_mode(struct drm_device *dev, struct drm_connector *connector, { struct drm_display_mode *mode = NULL, *tmpmode; + struct drm_fb_helper *fb_helper; + + fb_helper = &kos_rfbdev->helper; + + bool ret = false; ENTER(); @@ -260,9 +275,12 @@ do_set: dbgprintf("set mode %d %d connector %s encoder %s\n", reqmode->width, reqmode->height, con_name, enc_name); + fb = fb_helper->fb; + fb->width = reqmode->width; fb->height = reqmode->height; fb->pitch = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8); + fb->bits_per_pixel = 32; crtc->fb = fb; crtc->enabled = true; @@ -318,9 +336,6 @@ static struct drm_connector* get_def_connector(struct drm_device *dev) struct drm_encoder *encoder; struct drm_crtc *crtc; - dbgprintf("CONNECTOR %x ID: %d status %d encoder %x\n", connector, - connector->base.id, connector->status, connector->encoder); - if( connector->status != connector_status_connected) continue; @@ -332,18 +347,25 @@ static struct drm_connector* get_def_connector(struct drm_device *dev) connector->encoder = encoder; crtc = encoder->crtc; - dbgprintf("encoder %x crtc %x\n", encoder, crtc); - if(crtc == NULL) - continue; + dbgprintf("CONNECTOR %x ID: %d status %d encoder %x\n crtc %x", + connector, connector->base.id, + connector->status, connector->encoder, + crtc); + +// if (crtc == NULL) +// continue; def_connector = connector; + break; }; return def_connector; }; + + bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode) { struct drm_device *dev; @@ -352,6 +374,11 @@ bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode) bool retval = false; u32_t ifl; + struct radeon_fbdev *rfbdev; + struct drm_fb_helper *fb_helper; + + int i; + ENTER(); rdisplay = GetDisplay(); @@ -367,6 +394,32 @@ bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode) }; safe_sti(ifl); + + + rfbdev = rdev->mode_info.rfbdev; + fb_helper = &rfbdev->helper; + + +// for (i = 0; i < fb_helper->crtc_count; i++) +// { + struct drm_mode_set *mode_set = &fb_helper->crtc_info[0].mode_set; + struct drm_crtc *crtc; + struct drm_display_mode *mode; + + crtc = mode_set->crtc; + +// if (!crtc->enabled) +// continue; + + mode = mode_set->mode; + + dbgprintf("crtc %d width %d height %d vrefresh %d\n", + crtc->base.id, + drm_mode_width(mode), drm_mode_height(mode), + drm_mode_vrefresh(mode)); +// } + + rdisplay->connector = get_def_connector(dev); if( rdisplay->connector == 0 ) { @@ -374,7 +427,9 @@ bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode) return false; }; - rdisplay->crtc = rdisplay->connector->encoder->crtc; + + rdisplay->crtc = rdisplay->connector->encoder->crtc = crtc; + rdisplay->supported_modes = count_connector_modes(rdisplay->connector); dbgprintf("current mode %d x %d x %d\n", @@ -477,40 +532,72 @@ int set_user_mode(videomode_t *mode) return err; }; -#if 0 -void drm_helper_disable_unused_functions(struct drm_device *dev) + + +int radeonfb_create_object(struct radeon_fbdev *rfbdev, + struct drm_mode_fb_cmd *mode_cmd, + struct drm_gem_object **gobj_p) { - struct drm_encoder *encoder; - struct drm_connector *connector; - struct drm_encoder_helper_funcs *encoder_funcs; - struct drm_crtc *crtc; + struct radeon_device *rdev = rfbdev->rdev; + struct drm_gem_object *gobj = NULL; + struct radeon_bo *rbo = NULL; + bool fb_tiled = false; /* useful for testing */ + u32 tiling_flags = 0; + int ret; + int aligned_size, size; + int height = mode_cmd->height; - list_for_each_entry(connector, &dev->mode_config.connector_list, head) { - if (!connector->encoder) - continue; - if (connector->status == connector_status_disconnected) - connector->encoder = NULL; + static struct radeon_bo kos_bo; + static struct drm_mm_node vm_node; + + /* need to align pitch with crtc limits */ + mode_cmd->pitch = radeon_align_pitch(rdev, mode_cmd->width, mode_cmd->bpp, fb_tiled) * ((mode_cmd->bpp + 1) / 8); + + if (rdev->family >= CHIP_R600) + height = ALIGN(mode_cmd->height, 8); + size = mode_cmd->pitch * height; + aligned_size = ALIGN(size, PAGE_SIZE); + + ret = drm_gem_object_init(rdev->ddev, &kos_bo.gem_base, aligned_size); + if (unlikely(ret)) { + return ret; } - list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { - encoder_funcs = encoder->helper_private; - if (!drm_helper_encoder_in_use(encoder)) { - if (encoder_funcs->disable) - (*encoder_funcs->disable)(encoder); - else - (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF); - /* disconnector encoder from any connector */ - encoder->crtc = NULL; - } + kos_bo.rdev = rdev; + kos_bo.gem_base.driver_private = NULL; + kos_bo.surface_reg = -1; + kos_bo.domain = RADEON_GEM_DOMAIN_VRAM; + + INIT_LIST_HEAD(&kos_bo.list); + + gobj = &kos_bo.gem_base; + rbo = gem_to_radeon_bo(gobj); + + if (fb_tiled) + tiling_flags = RADEON_TILING_MACRO; + + if (tiling_flags) { + rbo->tiling_flags = tiling_flags | RADEON_TILING_SURFACE; + rbo->pitch = mode_cmd->pitch; } - list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { - struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; - crtc->enabled = drm_helper_crtc_in_use(crtc); - if (!crtc->enabled) { - crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF); - crtc->fb = NULL; - } - } + vm_node.size = 0xC00000 >> 12; + vm_node.start = 0; + vm_node.mm = NULL; + + rbo->tbo.vm_node = &vm_node; + rbo->tbo.offset = rbo->tbo.vm_node->start << PAGE_SHIFT; + rbo->tbo.offset += (u64)rbo->rdev->mc.vram_start; + rbo->kptr = (void*)0xFE000000; + rbo->pin_count = 1; + +// if (fb_tiled) +// radeon_bo_check_tiling(rbo, 0, 0); + + *gobj_p = gobj; + return 0; } -#endif + + + + diff --git a/drivers/video/drm/radeon/rs400.c b/drivers/video/drm/radeon/rs400.c index 6827e6025d..520061b29c 100644 --- a/drivers/video/drm/radeon/rs400.c +++ b/drivers/video/drm/radeon/rs400.c @@ -26,6 +26,7 @@ * Jerome Glisse */ #include +#include #include #include "radeon.h" #include "radeon_asic.h" diff --git a/drivers/video/drm/radeon/rv515.c b/drivers/video/drm/radeon/rv515.c index 379f4edc54..1aaf331c73 100644 --- a/drivers/video/drm/radeon/rv515.c +++ b/drivers/video/drm/radeon/rv515.c @@ -26,6 +26,7 @@ * Jerome Glisse */ #include +#include #include "drmP.h" #include "rv515d.h" #include "radeon.h"