Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'drm-fixes' of git://people.freedesktop.org/~airlied/linux
Pull drm fixes from Dave Airlie:
"Some final radeon and i915 fixes, black screens mostly"
* 'drm-fixes' of git://people.freedesktop.org/~airlied/linux:
drm/radeon/cik: use a separate counter for CP init timeout
drm/i915/hdmi: fix hdmi audio state readout
drm/i915: Don't leak command parser tables on suspend/resume
drm/radeon: add PX quirk for asus K53TK
drm/radeon: add a backlight quirk for Amilo Xi 2550
drm/radeon: add a module parameter for backlight control (v2)
drm/radeon: Update IH_RB_RPTR register after each processed interrupt
drm/radeon: Make IH ring overflow debugging output more useful
drm/radeon: Clear RB_OVERFLOW bit earlier
+71
-32
+7
-5
drivers/gpu/drm/i915/i915_cmd_parser.c
+7
-5
drivers/gpu/drm/i915/i915_cmd_parser.c
···
709
709
BUG_ON(!validate_cmds_sorted(ring, cmd_tables, cmd_table_count));
710
710
BUG_ON(!validate_regs_sorted(ring));
711
711
712
-
ret = init_hash_table(ring, cmd_tables, cmd_table_count);
713
-
if (ret) {
714
-
DRM_ERROR("CMD: cmd_parser_init failed!\n");
715
-
fini_hash_table(ring);
716
-
return ret;
712
+
if (hash_empty(ring->cmd_hash)) {
713
+
ret = init_hash_table(ring, cmd_tables, cmd_table_count);
714
+
if (ret) {
715
+
DRM_ERROR("CMD: cmd_parser_init failed!\n");
716
+
fini_hash_table(ring);
717
+
return ret;
718
+
}
717
719
}
718
720
719
721
ring->needs_cmd_parser = true;
+1
-1
drivers/gpu/drm/i915/intel_hdmi.c
+1
-1
drivers/gpu/drm/i915/intel_hdmi.c
+6
-6
drivers/gpu/drm/radeon/cik.c
+6
-6
drivers/gpu/drm/radeon/cik.c
···
4803
4803
*/
4804
4804
static int cik_cp_compute_resume(struct radeon_device *rdev)
4805
4805
{
4806
-
int r, i, idx;
4806
+
int r, i, j, idx;
4807
4807
u32 tmp;
4808
4808
bool use_doorbell = true;
4809
4809
u64 hqd_gpu_addr;
···
4922
4922
mqd->queue_state.cp_hqd_pq_wptr= 0;
4923
4923
if (RREG32(CP_HQD_ACTIVE) & 1) {
4924
4924
WREG32(CP_HQD_DEQUEUE_REQUEST, 1);
4925
-
for (i = 0; i < rdev->usec_timeout; i++) {
4925
+
for (j = 0; j < rdev->usec_timeout; j++) {
4926
4926
if (!(RREG32(CP_HQD_ACTIVE) & 1))
4927
4927
break;
4928
4928
udelay(1);
···
7751
7751
wptr = RREG32(IH_RB_WPTR);
7752
7752
7753
7753
if (wptr & RB_OVERFLOW) {
7754
+
wptr &= ~RB_OVERFLOW;
7754
7755
/* When a ring buffer overflow happen start parsing interrupt
7755
7756
* from the last not overwritten vector (wptr + 16). Hopefully
7756
7757
* this should allow us to catchup.
7757
7758
*/
7758
-
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, %d, %d)\n",
7759
-
wptr, rdev->ih.rptr, (wptr + 16) + rdev->ih.ptr_mask);
7759
+
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
7760
+
wptr, rdev->ih.rptr, (wptr + 16) & rdev->ih.ptr_mask);
7760
7761
rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
7761
7762
tmp = RREG32(IH_RB_CNTL);
7762
7763
tmp |= IH_WPTR_OVERFLOW_CLEAR;
7763
7764
WREG32(IH_RB_CNTL, tmp);
7764
-
wptr &= ~RB_OVERFLOW;
7765
7765
}
7766
7766
return (wptr & rdev->ih.ptr_mask);
7767
7767
}
···
8251
8251
/* wptr/rptr are in bytes! */
8252
8252
rptr += 16;
8253
8253
rptr &= rdev->ih.ptr_mask;
8254
+
WREG32(IH_RB_RPTR, rptr);
8254
8255
}
8255
8256
if (queue_hotplug)
8256
8257
schedule_work(&rdev->hotplug_work);
···
8260
8259
if (queue_thermal)
8261
8260
schedule_work(&rdev->pm.dpm.thermal.work);
8262
8261
rdev->ih.rptr = rptr;
8263
-
WREG32(IH_RB_RPTR, rdev->ih.rptr);
8264
8262
atomic_set(&rdev->ih.lock, 0);
8265
8263
8266
8264
/* make sure wptr hasn't changed while processing */
+4
-4
drivers/gpu/drm/radeon/evergreen.c
+4
-4
drivers/gpu/drm/radeon/evergreen.c
···
4749
4749
wptr = RREG32(IH_RB_WPTR);
4750
4750
4751
4751
if (wptr & RB_OVERFLOW) {
4752
+
wptr &= ~RB_OVERFLOW;
4752
4753
/* When a ring buffer overflow happen start parsing interrupt
4753
4754
* from the last not overwritten vector (wptr + 16). Hopefully
4754
4755
* this should allow us to catchup.
4755
4756
*/
4756
-
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, %d, %d)\n",
4757
-
wptr, rdev->ih.rptr, (wptr + 16) + rdev->ih.ptr_mask);
4757
+
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
4758
+
wptr, rdev->ih.rptr, (wptr + 16) & rdev->ih.ptr_mask);
4758
4759
rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
4759
4760
tmp = RREG32(IH_RB_CNTL);
4760
4761
tmp |= IH_WPTR_OVERFLOW_CLEAR;
4761
4762
WREG32(IH_RB_CNTL, tmp);
4762
-
wptr &= ~RB_OVERFLOW;
4763
4763
}
4764
4764
return (wptr & rdev->ih.ptr_mask);
4765
4765
}
···
5137
5137
/* wptr/rptr are in bytes! */
5138
5138
rptr += 16;
5139
5139
rptr &= rdev->ih.ptr_mask;
5140
+
WREG32(IH_RB_RPTR, rptr);
5140
5141
}
5141
5142
if (queue_hotplug)
5142
5143
schedule_work(&rdev->hotplug_work);
···
5146
5145
if (queue_thermal && rdev->pm.dpm_enabled)
5147
5146
schedule_work(&rdev->pm.dpm.thermal.work);
5148
5147
rdev->ih.rptr = rptr;
5149
-
WREG32(IH_RB_RPTR, rdev->ih.rptr);
5150
5148
atomic_set(&rdev->ih.lock, 0);
5151
5149
5152
5150
/* make sure wptr hasn't changed while processing */
+4
-4
drivers/gpu/drm/radeon/r600.c
+4
-4
drivers/gpu/drm/radeon/r600.c
···
3792
3792
wptr = RREG32(IH_RB_WPTR);
3793
3793
3794
3794
if (wptr & RB_OVERFLOW) {
3795
+
wptr &= ~RB_OVERFLOW;
3795
3796
/* When a ring buffer overflow happen start parsing interrupt
3796
3797
* from the last not overwritten vector (wptr + 16). Hopefully
3797
3798
* this should allow us to catchup.
3798
3799
*/
3799
-
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, %d, %d)\n",
3800
-
wptr, rdev->ih.rptr, (wptr + 16) + rdev->ih.ptr_mask);
3800
+
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
3801
+
wptr, rdev->ih.rptr, (wptr + 16) & rdev->ih.ptr_mask);
3801
3802
rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
3802
3803
tmp = RREG32(IH_RB_CNTL);
3803
3804
tmp |= IH_WPTR_OVERFLOW_CLEAR;
3804
3805
WREG32(IH_RB_CNTL, tmp);
3805
-
wptr &= ~RB_OVERFLOW;
3806
3806
}
3807
3807
return (wptr & rdev->ih.ptr_mask);
3808
3808
}
···
4048
4048
/* wptr/rptr are in bytes! */
4049
4049
rptr += 16;
4050
4050
rptr &= rdev->ih.ptr_mask;
4051
+
WREG32(IH_RB_RPTR, rptr);
4051
4052
}
4052
4053
if (queue_hotplug)
4053
4054
schedule_work(&rdev->hotplug_work);
···
4057
4056
if (queue_thermal && rdev->pm.dpm_enabled)
4058
4057
schedule_work(&rdev->pm.dpm.thermal.work);
4059
4058
rdev->ih.rptr = rptr;
4060
-
WREG32(IH_RB_RPTR, rdev->ih.rptr);
4061
4059
atomic_set(&rdev->ih.lock, 0);
4062
4060
4063
4061
/* make sure wptr hasn't changed while processing */
+1
drivers/gpu/drm/radeon/radeon.h
+1
drivers/gpu/drm/radeon/radeon.h
+4
drivers/gpu/drm/radeon/radeon_device.c
+4
drivers/gpu/drm/radeon/radeon_device.c
···
123
123
* https://bugzilla.kernel.org/show_bug.cgi?id=51381
124
124
*/
125
125
{ PCI_VENDOR_ID_ATI, 0x6741, 0x1043, 0x108c, RADEON_PX_QUIRK_DISABLE_PX },
126
+
/* Asus K53TK laptop with AMD A6-3420M APU and Radeon 7670m GPU
127
+
* https://bugzilla.kernel.org/show_bug.cgi?id=51381
128
+
*/
129
+
{ PCI_VENDOR_ID_ATI, 0x6840, 0x1043, 0x2122, RADEON_PX_QUIRK_DISABLE_PX },
126
130
/* macbook pro 8.2 */
127
131
{ PCI_VENDOR_ID_ATI, 0x6741, PCI_VENDOR_ID_APPLE, 0x00e2, RADEON_PX_QUIRK_LONG_WAKEUP },
128
132
{ 0, 0, 0, 0, 0 },
+4
drivers/gpu/drm/radeon/radeon_drv.c
+4
drivers/gpu/drm/radeon/radeon_drv.c
···
181
181
int radeon_deep_color = 0;
182
182
int radeon_use_pflipirq = 2;
183
183
int radeon_bapm = -1;
184
+
int radeon_backlight = -1;
184
185
185
186
MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers");
186
187
module_param_named(no_wb, radeon_no_wb, int, 0444);
···
263
262
264
263
MODULE_PARM_DESC(bapm, "BAPM support (1 = enable, 0 = disable, -1 = auto)");
265
264
module_param_named(bapm, radeon_bapm, int, 0444);
265
+
266
+
MODULE_PARM_DESC(backlight, "backlight support (1 = enable, 0 = disable, -1 = auto)");
267
+
module_param_named(backlight, radeon_backlight, int, 0444);
266
268
267
269
static struct pci_device_id pciidlist[] = {
268
270
radeon_PCI_IDS
+36
-8
drivers/gpu/drm/radeon/radeon_encoders.c
+36
-8
drivers/gpu/drm/radeon/radeon_encoders.c
···
158
158
return ret;
159
159
}
160
160
161
+
static void radeon_encoder_add_backlight(struct radeon_encoder *radeon_encoder,
162
+
struct drm_connector *connector)
163
+
{
164
+
struct drm_device *dev = radeon_encoder->base.dev;
165
+
struct radeon_device *rdev = dev->dev_private;
166
+
bool use_bl = false;
167
+
168
+
if (!(radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)))
169
+
return;
170
+
171
+
if (radeon_backlight == 0) {
172
+
return;
173
+
} else if (radeon_backlight == 1) {
174
+
use_bl = true;
175
+
} else if (radeon_backlight == -1) {
176
+
/* Quirks */
177
+
/* Amilo Xi 2550 only works with acpi bl */
178
+
if ((rdev->pdev->device == 0x9583) &&
179
+
(rdev->pdev->subsystem_vendor == 0x1734) &&
180
+
(rdev->pdev->subsystem_device == 0x1107))
181
+
use_bl = false;
182
+
else
183
+
use_bl = true;
184
+
}
185
+
186
+
if (use_bl) {
187
+
if (rdev->is_atom_bios)
188
+
radeon_atom_backlight_init(radeon_encoder, connector);
189
+
else
190
+
radeon_legacy_backlight_init(radeon_encoder, connector);
191
+
rdev->mode_info.bl_encoder = radeon_encoder;
192
+
}
193
+
}
194
+
161
195
void
162
196
radeon_link_encoder_connector(struct drm_device *dev)
163
197
{
164
-
struct radeon_device *rdev = dev->dev_private;
165
198
struct drm_connector *connector;
166
199
struct radeon_connector *radeon_connector;
167
200
struct drm_encoder *encoder;
···
207
174
radeon_encoder = to_radeon_encoder(encoder);
208
175
if (radeon_encoder->devices & radeon_connector->devices) {
209
176
drm_mode_connector_attach_encoder(connector, encoder);
210
-
if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
211
-
if (rdev->is_atom_bios)
212
-
radeon_atom_backlight_init(radeon_encoder, connector);
213
-
else
214
-
radeon_legacy_backlight_init(radeon_encoder, connector);
215
-
rdev->mode_info.bl_encoder = radeon_encoder;
216
-
}
177
+
if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
178
+
radeon_encoder_add_backlight(radeon_encoder, connector);
217
179
}
218
180
}
219
181
}
+4
-4
drivers/gpu/drm/radeon/si.c
+4
-4
drivers/gpu/drm/radeon/si.c
···
6316
6316
wptr = RREG32(IH_RB_WPTR);
6317
6317
6318
6318
if (wptr & RB_OVERFLOW) {
6319
+
wptr &= ~RB_OVERFLOW;
6319
6320
/* When a ring buffer overflow happen start parsing interrupt
6320
6321
* from the last not overwritten vector (wptr + 16). Hopefully
6321
6322
* this should allow us to catchup.
6322
6323
*/
6323
-
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, %d, %d)\n",
6324
-
wptr, rdev->ih.rptr, (wptr + 16) + rdev->ih.ptr_mask);
6324
+
dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
6325
+
wptr, rdev->ih.rptr, (wptr + 16) & rdev->ih.ptr_mask);
6325
6326
rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
6326
6327
tmp = RREG32(IH_RB_CNTL);
6327
6328
tmp |= IH_WPTR_OVERFLOW_CLEAR;
6328
6329
WREG32(IH_RB_CNTL, tmp);
6329
-
wptr &= ~RB_OVERFLOW;
6330
6330
}
6331
6331
return (wptr & rdev->ih.ptr_mask);
6332
6332
}
···
6664
6664
/* wptr/rptr are in bytes! */
6665
6665
rptr += 16;
6666
6666
rptr &= rdev->ih.ptr_mask;
6667
+
WREG32(IH_RB_RPTR, rptr);
6667
6668
}
6668
6669
if (queue_hotplug)
6669
6670
schedule_work(&rdev->hotplug_work);
6670
6671
if (queue_thermal && rdev->pm.dpm_enabled)
6671
6672
schedule_work(&rdev->pm.dpm.thermal.work);
6672
6673
rdev->ih.rptr = rptr;
6673
-
WREG32(IH_RB_RPTR, rdev->ih.rptr);
6674
6674
atomic_set(&rdev->ih.lock, 0);
6675
6675
6676
6676
/* make sure wptr hasn't changed while processing */