return r;
        }
        WREG32(scratch, 0xCAFEDEAD);
-       r = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &ib);
+       r = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &ib, 256);
        if (r) {
                return r;
        }
 
                return r;
        }
        WREG32(scratch, 0xCAFEDEAD);
-       r = radeon_ib_get(rdev, ring, &ib);
+       r = radeon_ib_get(rdev, ring, &ib, 256);
        if (r) {
                DRM_ERROR("radeon: failed to get ib (%d).\n", r);
                return r;
 
        radeon_bo_unref(&rdev->r600_blit.shader_obj);
 }
 
-static int r600_vb_ib_get(struct radeon_device *rdev)
+static int r600_vb_ib_get(struct radeon_device *rdev, unsigned size)
 {
        int r;
-       r = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &rdev->r600_blit.vb_ib);
+       r = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX,
+                         &rdev->r600_blit.vb_ib, size);
        if (r) {
                DRM_ERROR("failed to get IB for vertex buffer\n");
                return r;
        }
 
-       rdev->r600_blit.vb_total = 64*1024;
+       rdev->r600_blit.vb_total = size;
        rdev->r600_blit.vb_used = 0;
        return 0;
 }
        int num_loops = 0;
        int dwords_per_loop = rdev->r600_blit.ring_size_per_loop;
 
-       r = r600_vb_ib_get(rdev);
-       if (r)
-               return r;
-
        /* num loops */
        while (num_gpu_pages) {
                num_gpu_pages -=
                num_loops++;
        }
 
+       /* 48 bytes for vertex per loop */
+       r = r600_vb_ib_get(rdev, (num_loops*48)+256);
+       if (r)
+               return r;
+
        /* calculate number of loops correctly */
        ring_size = num_loops * dwords_per_loop;
        ring_size += rdev->r600_blit.ring_size_common;
 
 
 void r600_blit_suspend(struct radeon_device *rdev);
 
-int radeon_ib_get(struct radeon_device *rdev, int ring, struct radeon_ib **ib);
+int radeon_ib_get(struct radeon_device *rdev, int ring,
+                 struct radeon_ib **ib, unsigned size);
 void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib **ib);
 int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib);
 int radeon_ib_pool_init(struct radeon_device *rdev);
 
                radeon_mutex_unlock(&rdev->cs_mutex);
                return r;
        }
-       r =  radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &parser.ib);
+       ib_chunk = &parser.chunks[parser.chunk_ib_idx];
+       r =  radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &parser.ib,
+                          ib_chunk->length_dw * 4);
        if (r) {
                DRM_ERROR("Failed to get ib !\n");
                radeon_cs_parser_fini(&parser, r);
        /* Copy the packet into the IB, the parser will read from the
         * input memory (cached) and write to the IB (which can be
         * uncached). */
-       ib_chunk = &parser.chunks[parser.chunk_ib_idx];
        parser.ib->length_dw = ib_chunk->length_dw;
        r = radeon_cs_parse(&parser);
        if (r || parser.parser_error) {
 
        return done;
 }
 
-int radeon_ib_get(struct radeon_device *rdev, int ring, struct radeon_ib **ib)
+int radeon_ib_get(struct radeon_device *rdev, int ring,
+                 struct radeon_ib **ib, unsigned size)
 {
        struct radeon_fence *fence;
        unsigned cretry = 0;
        int r = 0, i, idx;
 
        *ib = NULL;
+       /* align size on 256 bytes */
+       size = ALIGN(size, 256);
 
        r = radeon_fence_create(rdev, &fence, ring);
        if (r) {
                if (rdev->ib_pool.ibs[idx].fence == NULL) {
                        r = radeon_sa_bo_new(rdev, &rdev->ib_pool.sa_manager,
                                             &rdev->ib_pool.ibs[idx].sa_bo,
-                                            64*1024, 64);
+                                            size, 256);
                        if (!r) {
                                *ib = &rdev->ib_pool.ibs[idx];
                                (*ib)->ptr = rdev->ib_pool.sa_manager.cpu_ptr;