fdo-mirrors/mesa-drm
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/drm.git synced 2025-12-21 04:00:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Realign via driver with changes in Linux kernel (mainly whitespace)

Browse source
This commit is contained in:
Dave Airlie 2006-01-02 03:25:49 +00:00
parent 26462b9aa4
commit 42cd50fa90
6 changed files with 75 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
linux-core/via_dmablit.c
View file

@ -631,8 +631,9 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
return DRM_ERR(EINVAL); return DRM_ERR(EINVAL);
} }
#else #else
if ((((unsigned long)xfer->mem_addr & 15) || ((unsigned long)xfer->fb_addr & 3)) || if ((((unsigned long)xfer->mem_addr & 15) ||
(xfer->mem_stride & 15) || (xfer->fb_stride & 3)) { ((unsigned long)xfer->fb_addr & 3)) || (xfer->mem_stride & 15) ||
(xfer->fb_stride & 3)) {
DRM_ERROR("Invalid DRM bitblt alignment.\n"); DRM_ERROR("Invalid DRM bitblt alignment.\n");
return DRM_ERR(EINVAL); return DRM_ERR(EINVAL);
} }

76
shared-core/via_dma.c
View file

@ -80,11 +80,9 @@ static void via_pad_cache(drm_via_private_t *dev_priv, int qwords);
* Free space in command buffer. * Free space in command buffer.
*/ */
static uint32_t static uint32_t via_cmdbuf_space(drm_via_private_t *dev_priv)
via_cmdbuf_space(drm_via_private_t *dev_priv)
{ {
uint32_t agp_base = dev_priv->dma_offset + uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
(uint32_t) dev_priv->agpAddr;
uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base; uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
return ((hw_addr <= dev_priv->dma_low) ? return ((hw_addr <= dev_priv->dma_low) ?
@ -96,11 +94,9 @@ via_cmdbuf_space(drm_via_private_t *dev_priv)
* How much does the command regulator lag behind? * How much does the command regulator lag behind?
*/ */
static uint32_t static uint32_t via_cmdbuf_lag(drm_via_private_t *dev_priv)
via_cmdbuf_lag(drm_via_private_t *dev_priv)
{ {
uint32_t agp_base = dev_priv->dma_offset + uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
(uint32_t) dev_priv->agpAddr;
uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base; uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
return ((hw_addr <= dev_priv->dma_low) ? return ((hw_addr <= dev_priv->dma_low) ?
@ -126,8 +122,9 @@ via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
do { do {
hw_addr = *hw_addr_ptr - agp_base; hw_addr = *hw_addr_ptr - agp_base;
if (count-- == 0) { if (count-- == 0) {
DRM_ERROR("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n", DRM_ERROR
hw_addr, cur_addr, next_addr); ("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n",
hw_addr, cur_addr, next_addr);
return -1; return -1;
} }
} while ((cur_addr < hw_addr) && (next_addr >= hw_addr)); } while ((cur_addr < hw_addr) && (next_addr >= hw_addr));
@ -145,7 +142,8 @@ via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv, static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv,
unsigned int size) unsigned int size)
{ {
if ((dev_priv->dma_low + size + 4*CMDBUF_ALIGNMENT_SIZE) > dev_priv->dma_high) { if ((dev_priv->dma_low + size + 4 * CMDBUF_ALIGNMENT_SIZE) >
dev_priv->dma_high) {
via_cmdbuf_rewind(dev_priv); via_cmdbuf_rewind(dev_priv);
} }
if (via_cmdbuf_wait(dev_priv, size) != 0) { if (via_cmdbuf_wait(dev_priv, size) != 0) {
@ -291,12 +289,12 @@ static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
* copy it to AGP memory when ready. * copy it to AGP memory when ready.
*/ */
if ((ret =
if ((ret = via_verify_command_stream((uint32_t *)dev_priv->pci_buf, cmd->size, dev, 1))) { via_verify_command_stream((uint32_t *)dev_priv->pci_buf,
cmd->size, dev, 1))) {
return ret; return ret;
} }
vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size); vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size);
if (vb == NULL) { if (vb == NULL) {
return DRM_ERR(EAGAIN); return DRM_ERR(EAGAIN);
@ -370,11 +368,15 @@ static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size)) if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
return DRM_ERR(EFAULT); return DRM_ERR(EFAULT);
if ((ret = via_verify_command_stream((uint32_t *)dev_priv->pci_buf, cmd->size, dev, 0))) { if ((ret =
via_verify_command_stream((uint32_t *)dev_priv->pci_buf,
cmd->size, dev, 0))) {
return ret; return ret;
} }
ret = via_parse_command_stream(dev, (const uint32_t *)dev_priv->pci_buf, cmd->size); ret =
via_parse_command_stream(dev, (const uint32_t *)dev_priv->pci_buf,
cmd->size);
return ret; return ret;
} }
@ -455,15 +457,16 @@ static int via_hook_segment(drm_via_private_t *dev_priv,
if ((count <= 8) && (count >= 0)) { if ((count <= 8) && (count >= 0)) {
uint32_t rgtr, ptr; uint32_t rgtr, ptr;
rgtr = *(dev_priv->hw_addr_ptr); rgtr = *(dev_priv->hw_addr_ptr);
ptr = ((volatile char *)dev_priv->last_pause_ptr - dev_priv->dma_ptr) + ptr = ((volatile char *)dev_priv->last_pause_ptr -
dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4 - dev_priv->dma_ptr) + dev_priv->dma_offset +
CMDBUF_ALIGNMENT_SIZE; (uint32_t) dev_priv->agpAddr + 4 - CMDBUF_ALIGNMENT_SIZE;
if (rgtr <= ptr) { if (rgtr <= ptr) {
DRM_ERROR("Command regulator\npaused at count %d, address %x, " DRM_ERROR
"while current pause address is %x.\n" ("Command regulator\npaused at count %d, address %x, "
"Please mail this message to " "while current pause address is %x.\n"
"<unichrome-devel@lists.sourceforge.net>\n", "Please mail this message to "
count, rgtr, ptr); "<unichrome-devel@lists.sourceforge.net>\n", count,
rgtr, ptr);
} }
} }
@ -472,7 +475,8 @@ static int via_hook_segment(drm_via_private_t *dev_priv,
uint32_t ptr_low; uint32_t ptr_low;
count = 1000000; count = 1000000;
while ((VIA_READ(VIA_REG_STATUS) & VIA_CMD_RGTR_BUSY) && count--); while ((VIA_READ(VIA_REG_STATUS) & VIA_CMD_RGTR_BUSY)
&& count--);
rgtr = *(dev_priv->hw_addr_ptr); rgtr = *(dev_priv->hw_addr_ptr);
ptr = ((volatile char *)paused_at - dev_priv->dma_ptr) + ptr = ((volatile char *)paused_at - dev_priv->dma_ptr) +
@ -503,8 +507,7 @@ static int via_wait_idle(drm_via_private_t * dev_priv)
static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type, static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
uint32_t addr, uint32_t *cmd_addr_hi, uint32_t addr, uint32_t *cmd_addr_hi,
uint32_t *cmd_addr_lo, uint32_t *cmd_addr_lo, int skip_wait)
int skip_wait)
{ {
uint32_t agp_base; uint32_t agp_base;
uint32_t cmd_addr, addr_lo, addr_hi; uint32_t cmd_addr, addr_lo, addr_hi;
@ -521,7 +524,6 @@ static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
qw_pad_count = (CMDBUF_ALIGNMENT_SIZE >> 3) - qw_pad_count = (CMDBUF_ALIGNMENT_SIZE >> 3) -
((dev_priv->dma_low & CMDBUF_ALIGNMENT_MASK) >> 3); ((dev_priv->dma_low & CMDBUF_ALIGNMENT_MASK) >> 3);
cmd_addr = (addr) ? addr : cmd_addr = (addr) ? addr :
agp_base + dev_priv->dma_low - 8 + (qw_pad_count << 3); agp_base + dev_priv->dma_low - 8 + (qw_pad_count << 3);
addr_lo = ((HC_SubA_HAGPBpL << 24) | (cmd_type & HC_HAGPBpID_MASK) | addr_lo = ((HC_SubA_HAGPBpL << 24) | (cmd_type & HC_HAGPBpID_MASK) |
@ -529,8 +531,7 @@ static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
addr_hi = ((HC_SubA_HAGPBpH << 24) | (cmd_addr >> 24)); addr_hi = ((HC_SubA_HAGPBpH << 24) | (cmd_addr >> 24));
vb = via_align_buffer(dev_priv, vb, qw_pad_count - 1); vb = via_align_buffer(dev_priv, vb, qw_pad_count - 1);
VIA_OUT_RING_QW(*cmd_addr_hi = addr_hi, VIA_OUT_RING_QW(*cmd_addr_hi = addr_hi, *cmd_addr_lo = addr_lo);
*cmd_addr_lo = addr_lo);
return vb; return vb;
} }
@ -621,7 +622,8 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
via_dummy_bitblt(dev_priv); via_dummy_bitblt(dev_priv);
via_dummy_bitblt(dev_priv); via_dummy_bitblt(dev_priv);
last_pause_ptr = via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, last_pause_ptr =
via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
&pause_addr_lo, 0) -1; &pause_addr_lo, 0) -1;
via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
&pause_addr_lo, 0); &pause_addr_lo, 0);
@ -638,7 +640,8 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
* does not seem to get updated immediately when a jump occurs. * does not seem to get updated immediately when a jump occurs.
*/ */
last_pause_ptr = via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, last_pause_ptr =
via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
&pause_addr_lo, 0) -1; &pause_addr_lo, 0) -1;
via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
&pause_addr_lo, 0); &pause_addr_lo, 0);
@ -681,8 +684,7 @@ static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
* User interface to the space and lag functions. * User interface to the space and lag functions.
*/ */
int int via_cmdbuf_size(DRM_IOCTL_ARGS)
via_cmdbuf_size(DRM_IOCTL_ARGS)
{ {
DRM_DEVICE; DRM_DEVICE;
drm_via_cmdbuf_size_t d_siz; drm_via_cmdbuf_size_t d_siz;
@ -709,7 +711,8 @@ via_cmdbuf_size(DRM_IOCTL_ARGS)
tmp_size = d_siz.size; tmp_size = d_siz.size;
switch(d_siz.func) { switch(d_siz.func) {
case VIA_CMDBUF_SPACE: case VIA_CMDBUF_SPACE:
while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz.size) && count--) { while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz.size)
&& count--) {
if (!d_siz.wait) { if (!d_siz.wait) {
break; break;
} }
@ -720,7 +723,8 @@ via_cmdbuf_size(DRM_IOCTL_ARGS)
} }
break; break;
case VIA_CMDBUF_LAG: case VIA_CMDBUF_LAG:
while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz.size) && count--) { while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz.size)
&& count--) {
if (!d_siz.wait) { if (!d_siz.wait) {
break; break;
} }

17
shared-core/via_drm.h
View file

@ -203,7 +203,6 @@ typedef struct _drm_via_sarea {
/* Used by the 3d driver only at this point, for pageflipping: /* Used by the 3d driver only at this point, for pageflipping:
*/ */
unsigned int pfCurrentOffset; unsigned int pfCurrentOffset;
} drm_via_sarea_t; } drm_via_sarea_t;
@ -225,13 +224,15 @@ typedef enum {
#define VIA_IRQ_FLAGS_MASK 0xF0000000 #define VIA_IRQ_FLAGS_MASK 0xF0000000
enum drm_via_irqs{drm_via_irq_hqv0 = 0, enum drm_via_irqs{
drm_via_irq_hqv1, drm_via_irq_hqv0 = 0,
drm_via_irq_dma0_dd, drm_via_irq_hqv1,
drm_via_irq_dma0_td, drm_via_irq_dma0_dd,
drm_via_irq_dma1_dd, drm_via_irq_dma0_td,
drm_via_irq_dma1_td, drm_via_irq_dma1_dd,
drm_via_irq_num}; drm_via_irq_dma1_td,
drm_via_irq_num
};
struct drm_via_wait_irq_request{ struct drm_via_wait_irq_request{
unsigned irq; unsigned irq;

4
shared-core/via_drv.h
View file

@ -148,8 +148,8 @@ extern int via_driver_dma_quiescent(drm_device_t * dev);
extern void via_init_futex(drm_via_private_t *dev_priv); extern void via_init_futex(drm_via_private_t *dev_priv);
extern void via_cleanup_futex(drm_via_private_t *dev_priv); extern void via_cleanup_futex(drm_via_private_t *dev_priv);
extern void via_release_futex(drm_via_private_t *dev_priv, int context); extern void via_release_futex(drm_via_private_t *dev_priv, int context);
extern int via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence, extern int via_driver_irq_wait(drm_device_t * dev, unsigned int irq,
unsigned int *sequence); int force_sequence, unsigned int *sequence);
#ifdef VIA_HAVE_DMABLIT #ifdef VIA_HAVE_DMABLIT
extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq); extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq);
extern void via_init_dmablit(drm_device_t *dev); extern void via_init_dmablit(drm_device_t *dev);

29
shared-core/via_irq.c
View file

@ -66,16 +66,18 @@
* Currently we activate the HQV interrupts of Unichrome Pro group A. * Currently we activate the HQV interrupts of Unichrome Pro group A.
*/ */
static maskarray_t via_pro_group_a_irqs[] = { static maskarray_t via_pro_group_a_irqs[] = {
{VIA_IRQ_HQV0_ENABLE, VIA_IRQ_HQV0_PENDING, 0x000003D0, 0x00008010, 0x00000000 }, {VIA_IRQ_HQV0_ENABLE, VIA_IRQ_HQV0_PENDING, 0x000003D0, 0x00008010,
{VIA_IRQ_HQV1_ENABLE, VIA_IRQ_HQV1_PENDING, 0x000013D0, 0x00008010, 0x00000000 }, 0x00000000 },
{VIA_IRQ_HQV1_ENABLE, VIA_IRQ_HQV1_PENDING, 0x000013D0, 0x00008010,
0x00000000 },
{VIA_IRQ_DMA0_TD_ENABLE, VIA_IRQ_DMA0_TD_PENDING, VIA_PCI_DMA_CSR0, {VIA_IRQ_DMA0_TD_ENABLE, VIA_IRQ_DMA0_TD_PENDING, VIA_PCI_DMA_CSR0,
VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008}, VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008},
{VIA_IRQ_DMA1_TD_ENABLE, VIA_IRQ_DMA1_TD_PENDING, VIA_PCI_DMA_CSR1, {VIA_IRQ_DMA1_TD_ENABLE, VIA_IRQ_DMA1_TD_PENDING, VIA_PCI_DMA_CSR1,
VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008} VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008},
}; };
static int via_num_pro_group_a = sizeof(via_pro_group_a_irqs)/sizeof(maskarray_t); static int via_num_pro_group_a =
sizeof(via_pro_group_a_irqs)/sizeof(maskarray_t);
static int via_irqmap_pro_group_a[] = {0, 1, -1, 2, -1, 3}; static int via_irqmap_pro_group_a[] = {0, 1, -1, 2, -1, 3};
static maskarray_t via_unichrome_irqs[] = { static maskarray_t via_unichrome_irqs[] = {
@ -116,7 +118,8 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
#endif #endif
if (dev_priv->last_vblank_valid) { if (dev_priv->last_vblank_valid) {
dev_priv->usec_per_vblank = dev_priv->usec_per_vblank =
time_diff( &cur_vblank,&dev_priv->last_vblank) >> 4; time_diff(&cur_vblank,
&dev_priv->last_vblank) >> 4;
} }
dev_priv->last_vblank = cur_vblank; dev_priv->last_vblank = cur_vblank;
dev_priv->last_vblank_valid = 1; dev_priv->last_vblank_valid = 1;
@ -130,10 +133,8 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
handled = 1; handled = 1;
} }
for (i=0; i<dev_priv->num_irqs; ++i) { for (i=0; i<dev_priv->num_irqs; ++i) {
if (status & cur_irq->pending_mask) { if (status & cur_irq->pending_mask) {
DRM_DEBUG("Received IRQ %d\n", i);
atomic_inc( &cur_irq->irq_received ); atomic_inc( &cur_irq->irq_received );
DRM_WAKEUP( &cur_irq->irq_queue ); DRM_WAKEUP( &cur_irq->irq_queue );
handled = 1; handled = 1;
@ -216,14 +217,16 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
} }
if (irq >= drm_via_irq_num ) { if (irq >= drm_via_irq_num ) {
DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__, irq); DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
irq);
return DRM_ERR(EINVAL); return DRM_ERR(EINVAL);
} }
real_irq = dev_priv->irq_map[irq]; real_irq = dev_priv->irq_map[irq];
if (real_irq < 0) { if (real_irq < 0) {
DRM_ERROR("%s Video IRQ %d is not available on this hardware.\n", __FUNCTION__, irq); DRM_ERROR("%s Video IRQ %d not available on this hardware.\n",
__FUNCTION__, irq);
return DRM_ERR(EINVAL); return DRM_ERR(EINVAL);
} }
@ -232,11 +235,13 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
if (masks[real_irq][2] && !force_sequence) { if (masks[real_irq][2] && !force_sequence) {
DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * DRM_HZ, DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * DRM_HZ,
((VIA_READ(masks[irq][2]) & masks[irq][3]) == masks[irq][4])); ((VIA_READ(masks[irq][2]) & masks[irq][3]) ==
masks[irq][4]));
cur_irq_sequence = atomic_read(&cur_irq->irq_received); cur_irq_sequence = atomic_read(&cur_irq->irq_received);
} else { } else {
DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * DRM_HZ, DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * DRM_HZ,
(((cur_irq_sequence = atomic_read(&cur_irq->irq_received)) - (((cur_irq_sequence =
atomic_read(&cur_irq->irq_received)) -
*sequence) <= (1 << 23))); *sequence) <= (1 << 23)));
} }
*sequence = cur_irq_sequence; *sequence = cur_irq_sequence;

7
shared-core/via_mm.c
View file

@ -81,7 +81,8 @@ int via_agp_init(DRM_IOCTL_ARGS)
AgpHeap = via_mmInit(agp.offset, agp.size); AgpHeap = via_mmInit(agp.offset, agp.size);
DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset, (unsigned long)agp.size); DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset,
(unsigned long)agp.size);
return 0; return 0;
} }
@ -97,7 +98,8 @@ int via_fb_init(DRM_IOCTL_ARGS)
FBHeap = via_mmInit(fb.offset, fb.size); FBHeap = via_mmInit(fb.offset, fb.size);
DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset, (unsigned long)fb.size); DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset,
(unsigned long)fb.size);
return 0; return 0;
} }
@ -173,7 +175,6 @@ int via_final_context(struct drm_device *dev, int context)
} }
via_release_futex(dev_priv, context); via_release_futex(dev_priv, context);
#if defined(__linux__) #if defined(__linux__)
/* Linux specific until context tracking code gets ported to BSD */ /* Linux specific until context tracking code gets ported to BSD */
/* Last context, perform cleanup */ /* Last context, perform cleanup */