drm/radeon/kms: add r600 KMS support

This adds the r600 KMS + CS support to the Linux kernel.

The r600 TTM support is quite basic and still needs more
work esp around using interrupts, but the polled fencing
should work okay for now.

Also currently TTM is using memcpy to do VRAM moves,
the code is here to use a 3D blit to do this, but
isn't fully debugged yet.

Authors:
Alex Deucher <alexdeucher@gmail.com>
Dave Airlie <airlied@redhat.com>
Jerome Glisse <jglisse@redhat.com>

Signed-off-by: Jerome Glisse <jglisse@redhat.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>

1 files changed, 248 insertions, 4 deletions

diff --git a/drivers/gpu/drm/radeon/r600_cp.c b/drivers/gpu/drm/radeon/r600_cp.c
index 8327912de964..6d5a711c2e91 100644
--- a/drivers/gpu/drm/radeon/r600_cp.c
+++ b/drivers/gpu/drm/radeon/r600_cp.c
@@ -58,6 +58,12 @@ MODULE_FIRMWARE("radeon/RV730_me.bin");
 MODULE_FIRMWARE("radeon/RV710_pfp.bin");
 MODULE_FIRMWARE("radeon/RV710_me.bin");
 
+
+int r600_cs_legacy(struct drm_device *dev, void *data, struct drm_file *filp,
+                        unsigned family, u32 *ib, int *l);
+void r600_cs_legacy_init(void);
+
+
 # define ATI_PCIGART_PAGE_SIZE          4096    /**< PCI GART page size */
 # define ATI_PCIGART_PAGE_MASK          (~(ATI_PCIGART_PAGE_SIZE-1))
 
@@ -1857,6 +1863,8 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
 
         DRM_DEBUG("\n");
 
+        mutex_init(&dev_priv->cs_mutex);
+        r600_cs_legacy_init();
         /* if we require new memory map but we don't have it fail */
         if ((dev_priv->flags & RADEON_NEW_MEMMAP) && !dev_priv->new_memmap) {
                 DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX for 3D\n");
@@ -1888,7 +1896,7 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
         /* Enable vblank on CRTC1 for older X servers
          */
         dev_priv->vblank_crtc = DRM_RADEON_VBLANK_CRTC1;
-
+        dev_priv->do_boxes = 0;
         dev_priv->cp_mode = init->cp_mode;
 
         /* We don't support anything other than bus-mastering ring mode,
@@ -1974,11 +1982,11 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
         } else
 #endif
         {
-                dev_priv->cp_ring->handle = (void *)dev_priv->cp_ring->offset;
+                dev_priv->cp_ring->handle = (void *)(unsigned long)dev_priv->cp_ring->offset;
                 dev_priv->ring_rptr->handle =
-                    (void *)dev_priv->ring_rptr->offset;
+                        (void *)(unsigned long)dev_priv->ring_rptr->offset;
                 dev->agp_buffer_map->handle =
-                    (void *)dev->agp_buffer_map->offset;
+                        (void *)(unsigned long)dev->agp_buffer_map->offset;
 
                 DRM_DEBUG("dev_priv->cp_ring->handle %p\n",
                           dev_priv->cp_ring->handle);
@@ -2282,3 +2290,239 @@ int r600_cp_dispatch_indirect(struct drm_device *dev,
 
         return 0;
 }
+
+void r600_cp_dispatch_swap(struct drm_device *dev, struct drm_file *file_priv)
+{
+        drm_radeon_private_t *dev_priv = dev->dev_private;
+        struct drm_master *master = file_priv->master;
+        struct drm_radeon_master_private *master_priv = master->driver_priv;
+        drm_radeon_sarea_t *sarea_priv = master_priv->sarea_priv;
+        int nbox = sarea_priv->nbox;
+        struct drm_clip_rect *pbox = sarea_priv->boxes;
+        int i, cpp, src_pitch, dst_pitch;
+        uint64_t src, dst;
+        RING_LOCALS;
+        DRM_DEBUG("\n");
+
+        if (dev_priv->color_fmt == RADEON_COLOR_FORMAT_ARGB8888)
+                cpp = 4;
+        else
+                cpp = 2;
+
+        if (sarea_priv->pfCurrentPage == 0) {
+                src_pitch = dev_priv->back_pitch;
+                dst_pitch = dev_priv->front_pitch;
+                src = dev_priv->back_offset + dev_priv->fb_location;
+                dst = dev_priv->front_offset + dev_priv->fb_location;
+        } else {
+                src_pitch = dev_priv->front_pitch;
+                dst_pitch = dev_priv->back_pitch;
+                src = dev_priv->front_offset + dev_priv->fb_location;
+                dst = dev_priv->back_offset + dev_priv->fb_location;
+        }
+
+        if (r600_prepare_blit_copy(dev, file_priv)) {
+                DRM_ERROR("unable to allocate vertex buffer for swap buffer\n");
+                return;
+        }
+        for (i = 0; i < nbox; i++) {
+                int x = pbox[i].x1;
+                int y = pbox[i].y1;
+                int w = pbox[i].x2 - x;
+                int h = pbox[i].y2 - y;
+
+                DRM_DEBUG("%d,%d-%d,%d\n", x, y, w, h);
+
+                r600_blit_swap(dev,
+                               src, dst,
+                               x, y, x, y, w, h,
+                               src_pitch, dst_pitch, cpp);
+        }
+        r600_done_blit_copy(dev);
+
+        /* Increment the frame counter.  The client-side 3D driver must
+         * throttle the framerate by waiting for this value before
+         * performing the swapbuffer ioctl.
+         */
+        sarea_priv->last_frame++;
+
+        BEGIN_RING(3);
+        R600_FRAME_AGE(sarea_priv->last_frame);
+        ADVANCE_RING();
+}
+
+int r600_cp_dispatch_texture(struct drm_device *dev,
+                             struct drm_file *file_priv,
+                             drm_radeon_texture_t *tex,
+                             drm_radeon_tex_image_t *image)
+{
+        drm_radeon_private_t *dev_priv = dev->dev_private;
+        struct drm_buf *buf;
+        u32 *buffer;
+        const u8 __user *data;
+        int size, pass_size;
+        u64 src_offset, dst_offset;
+
+        if (!radeon_check_offset(dev_priv, tex->offset)) {
+                DRM_ERROR("Invalid destination offset\n");
+                return -EINVAL;
+        }
+
+        /* this might fail for zero-sized uploads - are those illegal? */
+        if (!radeon_check_offset(dev_priv, tex->offset + tex->height * tex->pitch - 1)) {
+                DRM_ERROR("Invalid final destination offset\n");
+                return -EINVAL;
+        }
+
+        size = tex->height * tex->pitch;
+
+        if (size == 0)
+                return 0;
+
+        dst_offset = tex->offset;
+
+        if (r600_prepare_blit_copy(dev, file_priv)) {
+                DRM_ERROR("unable to allocate vertex buffer for swap buffer\n");
+                return -EAGAIN;
+        }
+        do {
+                data = (const u8 __user *)image->data;
+                pass_size = size;
+
+                buf = radeon_freelist_get(dev);
+                if (!buf) {
+                        DRM_DEBUG("EAGAIN\n");
+                        if (DRM_COPY_TO_USER(tex->image, image, sizeof(*image)))
+                                return -EFAULT;
+                        return -EAGAIN;
+                }
+
+                if (pass_size > buf->total)
+                        pass_size = buf->total;
+
+                /* Dispatch the indirect buffer.
+                 */
+                buffer =
+                    (u32 *) ((char *)dev->agp_buffer_map->handle + buf->offset);
+
+                if (DRM_COPY_FROM_USER(buffer, data, pass_size)) {
+                        DRM_ERROR("EFAULT on pad, %d bytes\n", pass_size);
+                        return -EFAULT;
+                }
+
+                buf->file_priv = file_priv;
+                buf->used = pass_size;
+                src_offset = dev_priv->gart_buffers_offset + buf->offset;
+
+                r600_blit_copy(dev, src_offset, dst_offset, pass_size);
+
+                radeon_cp_discard_buffer(dev, file_priv->master, buf);
+
+                /* Update the input parameters for next time */
+                image->data = (const u8 __user *)image->data + pass_size;
+                dst_offset += pass_size;
+                size -= pass_size;
+        } while (size > 0);
+        r600_done_blit_copy(dev);
+
+        return 0;
+}
+
+/*
+ * Legacy cs ioctl
+ */
+static u32 radeon_cs_id_get(struct drm_radeon_private *radeon)
+{
+        /* FIXME: check if wrap affect last reported wrap & sequence */
+        radeon->cs_id_scnt = (radeon->cs_id_scnt + 1) & 0x00FFFFFF;
+        if (!radeon->cs_id_scnt) {
+                /* increment wrap counter */
+                radeon->cs_id_wcnt += 0x01000000;
+                /* valid sequence counter start at 1 */
+                radeon->cs_id_scnt = 1;
+        }
+        return (radeon->cs_id_scnt | radeon->cs_id_wcnt);
+}
+
+static void r600_cs_id_emit(drm_radeon_private_t *dev_priv, u32 *id)
+{
+        RING_LOCALS;
+
+        *id = radeon_cs_id_get(dev_priv);
+
+        /* SCRATCH 2 */
+        BEGIN_RING(3);
+        R600_CLEAR_AGE(*id);
+        ADVANCE_RING();
+        COMMIT_RING();
+}
+
+static int r600_ib_get(struct drm_device *dev,
+                        struct drm_file *fpriv,
+                        struct drm_buf **buffer)
+{
+        struct drm_buf *buf;
+
+        *buffer = NULL;
+        buf = radeon_freelist_get(dev);
+        if (!buf) {
+                return -EBUSY;
+        }
+        buf->file_priv = fpriv;
+        *buffer = buf;
+        return 0;
+}
+
+static void r600_ib_free(struct drm_device *dev, struct drm_buf *buf,
+                        struct drm_file *fpriv, int l, int r)
+{
+        drm_radeon_private_t *dev_priv = dev->dev_private;
+
+        if (buf) {
+                if (!r)
+                        r600_cp_dispatch_indirect(dev, buf, 0, l * 4);
+                radeon_cp_discard_buffer(dev, fpriv->master, buf);
+                COMMIT_RING();
+        }
+}
+
+int r600_cs_legacy_ioctl(struct drm_device *dev, void *data, struct drm_file *fpriv)
+{
+        struct drm_radeon_private *dev_priv = dev->dev_private;
+        struct drm_radeon_cs *cs = data;
+        struct drm_buf *buf;
+        unsigned family;
+        int l, r = 0;
+        u32 *ib, cs_id = 0;
+
+        if (dev_priv == NULL) {
+                DRM_ERROR("called with no initialization\n");
+                return -EINVAL;
+        }
+        family = dev_priv->flags & RADEON_FAMILY_MASK;
+        if (family < CHIP_R600) {
+                DRM_ERROR("cs ioctl valid only for R6XX & R7XX in legacy mode\n");
+                return -EINVAL;
+        }
+        mutex_lock(&dev_priv->cs_mutex);
+        /* get ib */
+        r = r600_ib_get(dev, fpriv, &buf);
+        if (r) {
+                DRM_ERROR("ib_get failed\n");
+                goto out;
+        }
+        ib = dev->agp_buffer_map->handle + buf->offset;
+        /* now parse command stream */
+        r = r600_cs_legacy(dev, data,  fpriv, family, ib, &l);
+        if (r) {
+                goto out;
+        }
+
+out:
+        r600_ib_free(dev, buf, fpriv, l, r);
+        /* emit cs id sequence */
+        r600_cs_id_emit(dev_priv, &cs_id);
+        cs->cs_id = cs_id;
+        mutex_unlock(&dev_priv->cs_mutex);
+        return r;
+}