1 /**************************************************************************
2 * Copyright (c) 2007, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
19 * develop this driver.
21 **************************************************************************/
28 #include "psb_intel_reg.h"
31 #include "mdfld_output.h"
38 psb_pipestat(int pipe
)
50 mid_pipe_event(int pipe
)
53 return _PSB_PIPEA_EVENT_FLAG
;
55 return _MDFLD_PIPEB_EVENT_FLAG
;
57 return _MDFLD_PIPEC_EVENT_FLAG
;
62 mid_pipe_vsync(int pipe
)
65 return _PSB_VSYNC_PIPEA_FLAG
;
67 return _PSB_VSYNC_PIPEB_FLAG
;
69 return _MDFLD_PIPEC_VBLANK_FLAG
;
74 mid_pipeconf(int pipe
)
86 psb_enable_pipestat(struct drm_psb_private
*dev_priv
, int pipe
, u32 mask
)
88 if ((dev_priv
->pipestat
[pipe
] & mask
) != mask
) {
89 u32 reg
= psb_pipestat(pipe
);
90 dev_priv
->pipestat
[pipe
] |= mask
;
91 /* Enable the interrupt, clear any pending status */
92 if (gma_power_begin(dev_priv
->dev
, false)) {
93 u32 writeVal
= PSB_RVDC32(reg
);
94 writeVal
|= (mask
| (mask
>> 16));
95 PSB_WVDC32(writeVal
, reg
);
96 (void) PSB_RVDC32(reg
);
97 gma_power_end(dev_priv
->dev
);
103 psb_disable_pipestat(struct drm_psb_private
*dev_priv
, int pipe
, u32 mask
)
105 if ((dev_priv
->pipestat
[pipe
] & mask
) != 0) {
106 u32 reg
= psb_pipestat(pipe
);
107 dev_priv
->pipestat
[pipe
] &= ~mask
;
108 if (gma_power_begin(dev_priv
->dev
, false)) {
109 u32 writeVal
= PSB_RVDC32(reg
);
111 PSB_WVDC32(writeVal
, reg
);
112 (void) PSB_RVDC32(reg
);
113 gma_power_end(dev_priv
->dev
);
118 static void mid_enable_pipe_event(struct drm_psb_private
*dev_priv
, int pipe
)
120 if (gma_power_begin(dev_priv
->dev
, false)) {
121 u32 pipe_event
= mid_pipe_event(pipe
);
122 dev_priv
->vdc_irq_mask
|= pipe_event
;
123 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
124 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
125 gma_power_end(dev_priv
->dev
);
129 static void mid_disable_pipe_event(struct drm_psb_private
*dev_priv
, int pipe
)
131 if (dev_priv
->pipestat
[pipe
] == 0) {
132 if (gma_power_begin(dev_priv
->dev
, false)) {
133 u32 pipe_event
= mid_pipe_event(pipe
);
134 dev_priv
->vdc_irq_mask
&= ~pipe_event
;
135 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
136 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
137 gma_power_end(dev_priv
->dev
);
143 * Display controller interrupt handler for pipe event.
146 static void mid_pipe_event_handler(struct drm_device
*dev
, int pipe
)
148 struct drm_psb_private
*dev_priv
=
149 (struct drm_psb_private
*) dev
->dev_private
;
151 uint32_t pipe_stat_val
= 0;
152 uint32_t pipe_stat_reg
= psb_pipestat(pipe
);
153 uint32_t pipe_enable
= dev_priv
->pipestat
[pipe
];
154 uint32_t pipe_status
= dev_priv
->pipestat
[pipe
] >> 16;
158 spin_lock(&dev_priv
->irqmask_lock
);
160 pipe_stat_val
= PSB_RVDC32(pipe_stat_reg
);
161 pipe_stat_val
&= pipe_enable
| pipe_status
;
162 pipe_stat_val
&= pipe_stat_val
>> 16;
164 spin_unlock(&dev_priv
->irqmask_lock
);
166 /* Clear the 2nd level interrupt status bits
167 * Sometimes the bits are very sticky so we repeat until they unstick */
168 for (i
= 0; i
< 0xffff; i
++) {
169 PSB_WVDC32(PSB_RVDC32(pipe_stat_reg
), pipe_stat_reg
);
170 pipe_clear
= PSB_RVDC32(pipe_stat_reg
) & pipe_status
;
178 "%s, can't clear status bits for pipe %d, its value = 0x%x.\n",
179 __func__
, pipe
, PSB_RVDC32(pipe_stat_reg
));
181 if (pipe_stat_val
& PIPE_VBLANK_STATUS
)
182 drm_handle_vblank(dev
, pipe
);
184 if (pipe_stat_val
& PIPE_TE_STATUS
)
185 drm_handle_vblank(dev
, pipe
);
189 * Display controller interrupt handler.
191 static void psb_vdc_interrupt(struct drm_device
*dev
, uint32_t vdc_stat
)
193 if (vdc_stat
& _PSB_VSYNC_PIPEA_FLAG
)
194 mid_pipe_event_handler(dev
, 0);
196 if (vdc_stat
& _PSB_VSYNC_PIPEB_FLAG
)
197 mid_pipe_event_handler(dev
, 1);
200 irqreturn_t
psb_irq_handler(DRM_IRQ_ARGS
)
202 struct drm_device
*dev
= (struct drm_device
*) arg
;
203 struct drm_psb_private
*dev_priv
=
204 (struct drm_psb_private
*) dev
->dev_private
;
206 uint32_t vdc_stat
, dsp_int
= 0, sgx_int
= 0;
209 spin_lock(&dev_priv
->irqmask_lock
);
211 vdc_stat
= PSB_RVDC32(PSB_INT_IDENTITY_R
);
213 if (vdc_stat
& _PSB_PIPE_EVENT_FLAG
)
216 /* FIXME: Handle Medfield
217 if (vdc_stat & _MDFLD_DISP_ALL_IRQ_FLAG)
221 if (vdc_stat
& _PSB_IRQ_SGX_FLAG
)
224 vdc_stat
&= dev_priv
->vdc_irq_mask
;
225 spin_unlock(&dev_priv
->irqmask_lock
);
227 if (dsp_int
&& gma_power_is_on(dev
)) {
228 psb_vdc_interrupt(dev
, vdc_stat
);
233 /* Not expected - we have it masked, shut it up */
235 s
= PSB_RSGX32(PSB_CR_EVENT_STATUS
);
236 s2
= PSB_RSGX32(PSB_CR_EVENT_STATUS2
);
237 PSB_WSGX32(s
, PSB_CR_EVENT_HOST_CLEAR
);
238 PSB_WSGX32(s2
, PSB_CR_EVENT_HOST_CLEAR2
);
239 /* if s & _PSB_CE_TWOD_COMPLETE we have 2D done but
240 we may as well poll even if we add that ! */
244 PSB_WVDC32(vdc_stat
, PSB_INT_IDENTITY_R
);
245 (void) PSB_RVDC32(PSB_INT_IDENTITY_R
);
246 DRM_READMEMORYBARRIER();
254 void psb_irq_preinstall(struct drm_device
*dev
)
256 struct drm_psb_private
*dev_priv
=
257 (struct drm_psb_private
*) dev
->dev_private
;
258 unsigned long irqflags
;
260 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
262 if (gma_power_is_on(dev
))
263 PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM
);
264 if (dev
->vblank_enabled
[0])
265 dev_priv
->vdc_irq_mask
|= _PSB_VSYNC_PIPEA_FLAG
;
266 if (dev
->vblank_enabled
[1])
267 dev_priv
->vdc_irq_mask
|= _PSB_VSYNC_PIPEB_FLAG
;
269 /* FIXME: Handle Medfield irq mask
270 if (dev->vblank_enabled[1])
271 dev_priv->vdc_irq_mask |= _MDFLD_PIPEB_EVENT_FLAG;
272 if (dev->vblank_enabled[2])
273 dev_priv->vdc_irq_mask |= _MDFLD_PIPEC_EVENT_FLAG;
276 /* This register is safe even if display island is off */
277 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
278 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
281 int psb_irq_postinstall(struct drm_device
*dev
)
283 struct drm_psb_private
*dev_priv
=
284 (struct drm_psb_private
*) dev
->dev_private
;
285 unsigned long irqflags
;
287 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
289 /* This register is safe even if display island is off */
290 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
291 PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM
);
293 if (dev
->vblank_enabled
[0])
294 psb_enable_pipestat(dev_priv
, 0, PIPE_VBLANK_INTERRUPT_ENABLE
);
296 psb_disable_pipestat(dev_priv
, 0, PIPE_VBLANK_INTERRUPT_ENABLE
);
298 if (dev
->vblank_enabled
[1])
299 psb_enable_pipestat(dev_priv
, 1, PIPE_VBLANK_INTERRUPT_ENABLE
);
301 psb_disable_pipestat(dev_priv
, 1, PIPE_VBLANK_INTERRUPT_ENABLE
);
303 if (dev
->vblank_enabled
[2])
304 psb_enable_pipestat(dev_priv
, 2, PIPE_VBLANK_INTERRUPT_ENABLE
);
306 psb_disable_pipestat(dev_priv
, 2, PIPE_VBLANK_INTERRUPT_ENABLE
);
308 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
312 void psb_irq_uninstall(struct drm_device
*dev
)
314 struct drm_psb_private
*dev_priv
=
315 (struct drm_psb_private
*) dev
->dev_private
;
316 unsigned long irqflags
;
318 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
320 PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM
);
322 if (dev
->vblank_enabled
[0])
323 psb_disable_pipestat(dev_priv
, 0, PIPE_VBLANK_INTERRUPT_ENABLE
);
325 if (dev
->vblank_enabled
[1])
326 psb_disable_pipestat(dev_priv
, 1, PIPE_VBLANK_INTERRUPT_ENABLE
);
328 if (dev
->vblank_enabled
[2])
329 psb_disable_pipestat(dev_priv
, 2, PIPE_VBLANK_INTERRUPT_ENABLE
);
331 dev_priv
->vdc_irq_mask
&= _PSB_IRQ_SGX_FLAG
|
332 _PSB_IRQ_MSVDX_FLAG
|
335 /* These two registers are safe even if display island is off */
336 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
337 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
341 /* This register is safe even if display island is off */
342 PSB_WVDC32(PSB_RVDC32(PSB_INT_IDENTITY_R
), PSB_INT_IDENTITY_R
);
343 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
346 void psb_irq_turn_on_dpst(struct drm_device
*dev
)
348 struct drm_psb_private
*dev_priv
=
349 (struct drm_psb_private
*) dev
->dev_private
;
353 if (gma_power_begin(dev
, false)) {
354 PSB_WVDC32(1 << 31, HISTOGRAM_LOGIC_CONTROL
);
355 hist_reg
= PSB_RVDC32(HISTOGRAM_LOGIC_CONTROL
);
356 PSB_WVDC32(1 << 31, HISTOGRAM_INT_CONTROL
);
357 hist_reg
= PSB_RVDC32(HISTOGRAM_INT_CONTROL
);
359 PSB_WVDC32(0x80010100, PWM_CONTROL_LOGIC
);
360 pwm_reg
= PSB_RVDC32(PWM_CONTROL_LOGIC
);
361 PSB_WVDC32(pwm_reg
| PWM_PHASEIN_ENABLE
362 | PWM_PHASEIN_INT_ENABLE
,
364 pwm_reg
= PSB_RVDC32(PWM_CONTROL_LOGIC
);
366 psb_enable_pipestat(dev_priv
, 0, PIPE_DPST_EVENT_ENABLE
);
368 hist_reg
= PSB_RVDC32(HISTOGRAM_INT_CONTROL
);
369 PSB_WVDC32(hist_reg
| HISTOGRAM_INT_CTRL_CLEAR
,
370 HISTOGRAM_INT_CONTROL
);
371 pwm_reg
= PSB_RVDC32(PWM_CONTROL_LOGIC
);
372 PSB_WVDC32(pwm_reg
| 0x80010100 | PWM_PHASEIN_ENABLE
,
379 int psb_irq_enable_dpst(struct drm_device
*dev
)
381 struct drm_psb_private
*dev_priv
=
382 (struct drm_psb_private
*) dev
->dev_private
;
383 unsigned long irqflags
;
385 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
388 mid_enable_pipe_event(dev_priv
, 0);
389 psb_irq_turn_on_dpst(dev
);
391 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
395 void psb_irq_turn_off_dpst(struct drm_device
*dev
)
397 struct drm_psb_private
*dev_priv
=
398 (struct drm_psb_private
*) dev
->dev_private
;
402 if (gma_power_begin(dev
, false)) {
403 PSB_WVDC32(0x00000000, HISTOGRAM_INT_CONTROL
);
404 hist_reg
= PSB_RVDC32(HISTOGRAM_INT_CONTROL
);
406 psb_disable_pipestat(dev_priv
, 0, PIPE_DPST_EVENT_ENABLE
);
408 pwm_reg
= PSB_RVDC32(PWM_CONTROL_LOGIC
);
409 PSB_WVDC32(pwm_reg
& !(PWM_PHASEIN_INT_ENABLE
),
411 pwm_reg
= PSB_RVDC32(PWM_CONTROL_LOGIC
);
417 int psb_irq_disable_dpst(struct drm_device
*dev
)
419 struct drm_psb_private
*dev_priv
=
420 (struct drm_psb_private
*) dev
->dev_private
;
421 unsigned long irqflags
;
423 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
425 mid_disable_pipe_event(dev_priv
, 0);
426 psb_irq_turn_off_dpst(dev
);
428 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
434 static int psb_vblank_do_wait(struct drm_device
*dev
,
435 unsigned int *sequence
, atomic_t
*counter
)
437 unsigned int cur_vblank
;
439 DRM_WAIT_ON(ret
, dev
->vbl_queue
, 3 * DRM_HZ
,
440 (((cur_vblank
= atomic_read(counter
))
441 - *sequence
) <= (1 << 23)));
442 *sequence
= cur_vblank
;
449 * It is used to enable VBLANK interrupt
451 int psb_enable_vblank(struct drm_device
*dev
, int pipe
)
453 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
454 unsigned long irqflags
;
455 uint32_t reg_val
= 0;
456 uint32_t pipeconf_reg
= mid_pipeconf(pipe
);
458 /* Medfield is different - we should perhaps extract out vblank
459 and blacklight etc ops */
461 return mdfld_enable_te(dev
, pipe
);
463 if (gma_power_begin(dev
, false)) {
464 reg_val
= REG_READ(pipeconf_reg
);
468 if (!(reg_val
& PIPEACONF_ENABLE
))
471 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
474 dev_priv
->vdc_irq_mask
|= _PSB_VSYNC_PIPEA_FLAG
;
476 dev_priv
->vdc_irq_mask
|= _PSB_VSYNC_PIPEB_FLAG
;
478 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
479 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
480 psb_enable_pipestat(dev_priv
, pipe
, PIPE_VBLANK_INTERRUPT_ENABLE
);
482 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
488 * It is used to disable VBLANK interrupt
490 void psb_disable_vblank(struct drm_device
*dev
, int pipe
)
492 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
493 unsigned long irqflags
;
496 mdfld_disable_te(dev
, pipe
);
497 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
500 dev_priv
->vdc_irq_mask
&= ~_PSB_VSYNC_PIPEA_FLAG
;
502 dev_priv
->vdc_irq_mask
&= ~_PSB_VSYNC_PIPEB_FLAG
;
504 PSB_WVDC32(~dev_priv
->vdc_irq_mask
, PSB_INT_MASK_R
);
505 PSB_WVDC32(dev_priv
->vdc_irq_mask
, PSB_INT_ENABLE_R
);
506 psb_disable_pipestat(dev_priv
, pipe
, PIPE_VBLANK_INTERRUPT_ENABLE
);
508 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
512 * It is used to enable TE interrupt
514 int mdfld_enable_te(struct drm_device
*dev
, int pipe
)
516 struct drm_psb_private
*dev_priv
=
517 (struct drm_psb_private
*) dev
->dev_private
;
518 unsigned long irqflags
;
519 uint32_t reg_val
= 0;
520 uint32_t pipeconf_reg
= mid_pipeconf(pipe
);
522 if (gma_power_begin(dev
, false)) {
523 reg_val
= REG_READ(pipeconf_reg
);
527 if (!(reg_val
& PIPEACONF_ENABLE
))
530 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
532 mid_enable_pipe_event(dev_priv
, pipe
);
533 psb_enable_pipestat(dev_priv
, pipe
, PIPE_TE_ENABLE
);
535 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
541 * It is used to disable TE interrupt
543 void mdfld_disable_te(struct drm_device
*dev
, int pipe
)
545 struct drm_psb_private
*dev_priv
=
546 (struct drm_psb_private
*) dev
->dev_private
;
547 unsigned long irqflags
;
549 if (!dev_priv
->dsr_enable
)
552 spin_lock_irqsave(&dev_priv
->irqmask_lock
, irqflags
);
554 mid_disable_pipe_event(dev_priv
, pipe
);
555 psb_disable_pipestat(dev_priv
, pipe
, PIPE_TE_ENABLE
);
557 spin_unlock_irqrestore(&dev_priv
->irqmask_lock
, irqflags
);
560 /* Called from drm generic code, passed a 'crtc', which
561 * we use as a pipe index
563 u32
psb_get_vblank_counter(struct drm_device
*dev
, int pipe
)
565 uint32_t high_frame
= PIPEAFRAMEHIGH
;
566 uint32_t low_frame
= PIPEAFRAMEPIXEL
;
567 uint32_t pipeconf_reg
= PIPEACONF
;
568 uint32_t reg_val
= 0;
569 uint32_t high1
= 0, high2
= 0, low
= 0, count
= 0;
575 high_frame
= PIPEBFRAMEHIGH
;
576 low_frame
= PIPEBFRAMEPIXEL
;
577 pipeconf_reg
= PIPEBCONF
;
580 high_frame
= PIPECFRAMEHIGH
;
581 low_frame
= PIPECFRAMEPIXEL
;
582 pipeconf_reg
= PIPECCONF
;
585 dev_err(dev
->dev
, "%s, invalid pipe.\n", __func__
);
589 if (!gma_power_begin(dev
, false))
592 reg_val
= REG_READ(pipeconf_reg
);
594 if (!(reg_val
& PIPEACONF_ENABLE
)) {
595 dev_err(dev
->dev
, "trying to get vblank count for disabled pipe %d\n",
597 goto psb_get_vblank_counter_exit
;
601 * High & low register fields aren't synchronized, so make sure
602 * we get a low value that's stable across two reads of the high
606 high1
= ((REG_READ(high_frame
) & PIPE_FRAME_HIGH_MASK
) >>
607 PIPE_FRAME_HIGH_SHIFT
);
608 low
= ((REG_READ(low_frame
) & PIPE_FRAME_LOW_MASK
) >>
609 PIPE_FRAME_LOW_SHIFT
);
610 high2
= ((REG_READ(high_frame
) & PIPE_FRAME_HIGH_MASK
) >>
611 PIPE_FRAME_HIGH_SHIFT
);
612 } while (high1
!= high2
);
614 count
= (high1
<< 8) | low
;
616 psb_get_vblank_counter_exit
: