Ticket #1234: use-kernel-cmdq-init.patch

File use-kernel-cmdq-init.patch, 11.0 KB (added by dodji@…, 11 years ago)

uses the DMA/blitter enabled kernel to perform system to video ram pixmap copies

  • hw/kdrive/glamo/glamo-cmdq.c

    old new  
    2424 */ 
    2525 
    2626#include <sys/time.h> 
     27#include <sys/ioctl.h> 
     28#include <stdint.h> 
    2729 
    2830#include "glamo-log.h" 
    2931#include "glamo.h" 
     
    3133#include "glamo-cmdq.h" 
    3234#include "glamo-draw.h" 
    3335 
     36#define USE_KERNEL_CMDQ_INIT 1 
     37 
     38#ifdef USE_KERNEL_CMDQ_INIT 
     39typedef struct { 
     40    uint32_t ring_addr; 
     41    uint32_t ring_len; 
     42} GLAMOFBInitCmdqInfo; 
     43#define FBIO_GLAMO_INIT_CMDQ \ 
     44    _IOW('F', 0x20, GLAMOFBInitCmdqInfo) 
     45#endif /*USE_KERNEL_CMDQ_INIT*/ 
    3446#ifndef NDEBUG 
     47 
    3548static void 
    3649GLAMODebugFifo(GLAMOScreenInfo *glamos) 
    3750{ 
     
    288301                                "(0x%x), resetting...\n", 
    289302                                status); 
    290303                GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CMDQ); 
     304                GLAMOCMDQSetInitParams(glamos->screen->pScreen); 
    291305                GLAMODrawSetup(glamos->screen->pScreen); 
    292306        } 
    293307} 
     
    323337        int count, ring_count; 
    324338        TIMEOUT_LOCALS; 
    325339 
     340        /*GLAMO_LOG ("enter\n");*/ 
     341 
    326342        addr = (CARD16 *)((char *)buf->address + glamos->cmd_queue_cache_start); 
    327343        count = (buf->used - glamos->cmd_queue_cache_start) / 2; 
    328344        ring_count = glamos->ring_len / 2; 
    329345 
     346        glamos->ring_write = 
     347                MMIO_IN16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRL); 
     348        glamos->ring_write |= 
     349                (MMIO_IN16(mmio, 
     350                           GLAMO_REG_CMDQ_WRITE_ADDRH) & 0x7) << 15; 
     351        glamos->ring_write >>= 1; 
     352 
     353        /*GLAMO_LOG("glamos->ring_write:%d\n", glamos->ring_write);*/ 
     354 
    330355        WHILE_NOT_TIMEOUT(.5) { 
    331356                if (count <= 0) 
    332357                        break; 
    333358 
     359                /*GLAMO_LOG ("writing to ring addr:%p + %d, value:%#x\n", 
     360                            glamos->ring_addr, glamos->ring_write, 
     361                            *addr);*/ 
    334362                glamos->ring_addr[glamos->ring_write++] = *addr++; 
    335363                if (glamos->ring_write >= ring_count) 
    336364                        glamos->ring_write = 0; 
    337365 
    338366                while (glamos->ring_write == glamos->ring_read) 
    339367                { 
     368                        GLAMO_LOG ("reading from cmd_read_addrl\n"); 
    340369                        glamos->ring_read = 
    341370                                MMIO_IN16(mmio, GLAMO_REG_CMDQ_READ_ADDRL); 
     371                        GLAMO_LOG ("reading from cmd_read_addrh\n"); 
    342372                        glamos->ring_read |= 
    343373                                (MMIO_IN16(mmio, GLAMO_REG_CMDQ_READ_ADDRH) & 0x7) << 16; 
     374                        GLAMO_LOG ("glamo->ring_read:%#x\n", 
     375                                   glamos->ring_read); 
    344376                } 
    345377 
    346378                count--; 
     
    349381                GLAMO_LOG_ERROR("Timeout submitting packets, resetting...\n"); 
    350382                GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CMDQ); 
    351383                GLAMODrawSetup(glamos->screen->pScreen); 
     384                GLAMOCMDQSetInitParams(glamos->screen->pScreen); 
    352385        } 
    353386 
    354387        MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRH, 
    355388                         (glamos->ring_write >> 15) & 0x7); 
    356389        MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRL, 
    357390                         (glamos->ring_write <<  1) & 0xffff); 
     391        /*GLAMO_LOG ("leave\n");*/ 
    358392} 
    359393 
    360394void 
     
    370404        glamos->cmd_queue_cache_start = 0; 
    371405} 
    372406 
    373 static Bool 
    374 GLAMOCMDQInit(ScreenPtr pScreen) 
     407Bool 
     408GLAMOCMDQSetInitParams(ScreenPtr pScreen) 
    375409{ 
    376410        KdScreenPriv(pScreen); 
    377411        GLAMOScreenInfo(pScreenPriv); 
    378412        GLAMOCardInfo(pScreenPriv); 
    379413        char *mmio = glamoc->reg_base; 
    380         int cq_len = 63; 
    381  
    382         if (glamos->cmd_queue) 
    383                 return TRUE; 
    384  
    385         glamos->ring_len = (cq_len + 1) * 1024; 
    386  
    387         glamos->cmd_queue = KdOffscreenAlloc(pScreen, glamos->ring_len + 4, 
    388                                              16, TRUE, NULL, NULL); 
    389         if (!glamos->cmd_queue) 
    390                 return FALSE; 
     414#ifdef USE_KERNEL_CMDQ_INIT 
     415        FbdevPriv *fbdev_priv = pScreenPriv->screen->card->driver; 
     416        int ioctl_res = 0; 
     417        GLAMOFBInitCmdqInfo info; 
     418#endif 
     419        if (!glamos || !glamos->cmd_queue) { 
     420                GLAMO_LOG_ERROR("sanity check failed\n"); 
     421                return FALSE; 
     422        } 
     423        GLAMO_LOG("enter, queue_offset:%d, queue_len:%d\n", 
     424                  glamos->cmd_queue->offset, glamos->ring_len); 
    391425 
    392426        glamos->ring_addr = (CARD16 *) (pScreenPriv->screen->memory_base + 
    393427                                        glamos->cmd_queue->offset); 
     
    398432        glamos->ring_addr[glamos->ring_len / 2] = 0x0; 
    399433        glamos->ring_addr[glamos->ring_len / 2 + 1] = 0x0; 
    400434 
     435#ifdef USE_KERNEL_CMDQ_INIT 
     436        info.ring_addr = glamos->cmd_queue->offset; 
     437        info.ring_len = glamos->ring_len; 
     438        ioctl_res = ioctl (fbdev_priv->fd, FBIO_GLAMO_INIT_CMDQ, &info); 
     439        if (ioctl_res) { 
     440            GLAMO_LOG_ERROR ("ioctl:%#x on fb:%d failed. error:%d\n", 
     441                             FBIO_GLAMO_INIT_CMDQ, fbdev_priv->fd, 
     442                             ioctl_res); 
     443            perror ("error in ioctling"); 
     444            return FALSE; 
     445        } 
     446#else /*USE_KERNEL_CMDQ_INIT*/ 
    401447        GLAMOEngineEnable(glamos->screen->pScreen, GLAMO_ENGINE_CMDQ); 
    402448        GLAMOEngineReset(glamos->screen->pScreen, GLAMO_ENGINE_CMDQ); 
    403449 
    404         MMIO_OUT16(mmio, GLAMO_REG_CMDQ_BASE_ADDRL, 
     450        MMIO_OUT16(mmio, 
     451                   GLAMO_REG_CMDQ_BASE_ADDRL, 
    405452                   glamos->cmd_queue->offset & 0xffff); 
    406         MMIO_OUT16(mmio, GLAMO_REG_CMDQ_BASE_ADDRH, 
     453        MMIO_OUT16(mmio, 
     454                   GLAMO_REG_CMDQ_BASE_ADDRH, 
    407455                   (glamos->cmd_queue->offset >> 16) & 0x7f); 
    408         MMIO_OUT16(mmio, GLAMO_REG_CMDQ_LEN, cq_len); 
     456        MMIO_OUT16(mmio, GLAMO_REG_CMDQ_LEN, (glamos->ring_len/1024)-1); 
    409457 
    410458        MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRH, 0); 
    411459        MMIO_OUT16(mmio, GLAMO_REG_CMDQ_WRITE_ADDRL, 0); 
     
    415463                         1 << 12 | 
    416464                         5 << 8 | 
    417465                         8 << 4); 
     466#endif /*USE_KERNEL_CMDQ_INIT*/ 
    418467 
     468        GLAMO_LOG ("leave\n"); 
    419469        return TRUE; 
    420470} 
    421471 
     472Bool 
     473GLAMOCMDQInit(ScreenPtr pScreen) 
     474{ 
     475        KdScreenPriv(pScreen); 
     476        GLAMOScreenInfo(pScreenPriv); 
     477        GLAMOCardInfo(pScreenPriv); 
     478        char *mmio = glamoc->reg_base; 
     479        int cq_len = 63; 
     480        GLAMO_LOG ("enter\n"); 
     481 
     482        if (glamos->cmd_queue) 
     483                return TRUE; 
     484        glamos->ring_len = (cq_len + 1) * 1024; 
     485 
     486        glamos->cmd_queue = KdOffscreenAlloc(pScreen, glamos->ring_len + 4, 
     487                                             16, TRUE, NULL, NULL); 
     488        if (!glamos->cmd_queue) { 
     489                GLAMO_LOG_ERROR("failed to allocate cmd queue\n"); 
     490                return FALSE; 
     491        } 
     492        return GLAMOCMDQSetInitParams(pScreen); 
     493} 
     494 
    422495void 
    423496GLAMOCMDQCacheSetup(ScreenPtr pScreen) 
    424497{ 
    425498        KdScreenPriv(pScreen); 
    426499        GLAMOScreenInfo(pScreenPriv); 
    427500 
     501        GLAMO_LOG ("enter\n"); 
     502 
    428503        GLAMOCMDQInit(pScreen); 
    429504 
    430505        if (glamos->cmd_queue_cache) 
     
    433508        glamos->cmd_queue_cache = GLAMOCreateCMDQCache(glamos); 
    434509        if (glamos->cmd_queue_cache == FALSE) 
    435510                FatalError("Failed to allocate cmd queue cache buffer.\n"); 
     511        GLAMO_LOG ("leave\n"); 
    436512} 
    437513 
    438514void 
  • hw/kdrive/glamo/glamo-draw.c

    old new  
    2626#ifdef HAVE_CONFIG_H 
    2727#include <kdrive-config.h> 
    2828#endif 
     29#include <sys/ioctl.h> 
    2930#include "glamo-log.h" 
    3031#include "glamo.h" 
    3132#include "glamo-regs.h" 
     
    7172    /* GXset        */      0xff,         /* 1 */ 
    7273}; 
    7374 
     75struct glamofb_pixmap { 
     76        unsigned int pitch; 
     77        unsigned int width; 
     78        unsigned int height; 
     79        unsigned int bits_per_pixel; 
     80        char *address; 
     81}; 
     82 
     83struct glamofb_upload_pixmap_info { 
     84        struct glamofb_pixmap pixmap; 
     85        unsigned int dest_offset;/*offset in glamo vram*/ 
     86        unsigned int dest_pitch; 
     87}; 
     88 
     89#define FBIO_GLAMO_UPLOAD_PIXMAP_TO_VRAM \ 
     90  _IOW('F', 0x19, struct glamofb_upload_pixmap_info) 
     91 
    7492GLAMOScreenInfo *accel_glamos; 
    7593CARD32 settings, color, src_pitch_offset, dst_pitch_offset; 
    7694 
     
    194212 
    195213        settings = GLAMOBltRop[alu] << 8; 
    196214 
     215        kaaWaitSync(pDst->drawable.pScreen); 
    197216        BEGIN_CMDQ(16); 
    198217 
    199218        OUT_REG(GLAMO_REG_2D_SRC_ADDRL, src_offset & 0xffff); 
     
    208227        OUT_REG(GLAMO_REG_2D_COMMAND2, settings); 
    209228 
    210229        END_CMDQ(); 
     230        kaaMarkSync(pDst->drawable.pScreen); 
    211231 
    212232        GLAMO_LOG("leave\n"); 
    213233 
     
    220240        GLAMOScreenInfo *glamos = accel_glamos; 
    221241        RING_LOCALS; 
    222242 
     243        kaaWaitSync(glamos->screen->pScreen); 
    223244        BEGIN_CMDQ(18); 
    224245        OUT_REG(GLAMO_REG_2D_SRC_X, srcX); 
    225246        OUT_REG(GLAMO_REG_2D_SRC_Y, srcY); 
     
    231252        OUT_REG(GLAMO_REG_2D_ID1, 0); 
    232253        OUT_REG(GLAMO_REG_2D_ID2, 0); 
    233254        END_CMDQ(); 
     255        kaaMarkSync(glamos->screen->pScreen); 
    234256} 
    235257 
    236258static void 
    237259GLAMODoneCopy(void) 
    238260{ 
    239261        GLAMO_LOG("enter\n"); 
     262        kaaWaitSync(accel_glamos->screen->pScreen); 
    240263        GLAMO_LOG("leave\n"); 
    241264} 
    242265 
    243266static Bool 
    244267GLAMOUploadToScreen(PixmapPtr pDst, char *src, int src_pitch) 
    245268{ 
     269        KdScreenPriv(pDst->drawable.pScreen); 
    246270        int width, height, bpp, i; 
    247271        CARD8 *dst_offset; 
     272        CARD32 dst_relative_offset; 
    248273        int dst_pitch; 
     274        char *use_dma = NULL; 
    249275 
    250276        GLAMO_LOG("enter\n"); 
    251277        dst_offset = (CARD8 *)pDst->devPrivate.ptr; 
     278        dst_relative_offset = dst_offset - pScreenPriv->screen->memory_base; 
    252279        dst_pitch = pDst->devKind; 
    253280        width = pDst->drawable.width; 
    254281        height = pDst->drawable.height; 
    255282        bpp = pDst->drawable.bitsPerPixel; 
    256283        bpp /= 8; 
    257284 
    258         GLAMO_LOG("dst_pitch:%d, src_pitch\n", dst_pitch, src_pitch); 
    259  
    260         for (i = 0; i < height; i++) 
    261         { 
    262                 memcpy(dst_offset, src, width * bpp); 
    263  
    264                 dst_offset += dst_pitch; 
    265                 src += src_pitch; 
     285        GLAMO_LOG("dst_pitch:%d, src_pitch:%d, dst_offset:%#x\n" 
     286                  "width:%d, height;%d\n", 
     287                  dst_pitch, src_pitch, 
     288                  dst_relative_offset, 
     289                  width, height); 
     290 
     291        use_dma = getenv("USE_DMA"); 
     292        if (use_dma) { 
     293                int err = 0; 
     294                struct glamofb_upload_pixmap_info info; 
     295                FbdevPriv *fbdev_priv = pScreenPriv->screen->card->driver; 
     296 
     297                GLAMO_LOG("using dma to upload the pixmap\n"); 
     298 
     299                info.dest_offset = dst_relative_offset; 
     300                info.dest_pitch = dst_pitch; 
     301                info.pixmap.pitch = src_pitch; 
     302                info.pixmap.width = width; 
     303                info.pixmap.height = height; 
     304                info.pixmap.bits_per_pixel = pDst->drawable.bitsPerPixel; 
     305                info.pixmap.address = src; 
     306                GLAMO_LOG("going to ioctl\n" 
     307                          "src_data:%p, dest_offset:%#x, dst_pitch:%d, " 
     308                          "pxm.pitch:%d, pxm.width:%d, pxm.height:%d" 
     309                          "\n", 
     310                          src, 
     311                          dst_relative_offset, 
     312                          dst_pitch, 
     313                          src_pitch, 
     314                          width, 
     315                          height); 
     316                kaaWaitSync(pDst->drawable.pScreen); 
     317                err = ioctl(fbdev_priv->fd, 
     318                            FBIO_GLAMO_UPLOAD_PIXMAP_TO_VRAM, 
     319                            &info); 
     320                if (err) { 
     321                        GLAMO_LOG_ERROR("ioctl " 
     322                                        "FBIO_GLAMO_UPLOAD_PIXMAP_TO_VRAM " 
     323                                        "failed. err:%d\n", err); 
     324                        perror("ioctl failed:"); 
     325                } 
     326                GLAMO_LOG("ioctl went okay\n"); 
     327                kaaMarkSync(pDst->drawable.pScreen); 
     328        } else { 
     329                GLAMO_LOG("using memcpy to upload the pixmap\n"); 
     330                for (i = 0; i < height; i++) { 
     331                        memcpy(dst_offset, src, width * bpp); 
     332                        dst_offset += dst_pitch; 
     333                        src += src_pitch; 
     334                } 
    266335        } 
    267  
    268336        return TRUE; 
    269337} 
    270338 
     
    279347         * make sure that the cmd queue cache 
    280348         * has been flushed. 
    281349         */ 
    282         if (glamos->cmd_queue_cache) 
     350        if (glamos->cmd_queue_cache) { 
    283351                GLAMOFlushCMDQCache(glamos, 1); 
     352                kaaMarkSync(pScreen); 
     353        } 
    284354} 
    285355 
    286356static void 
     
    328398        if (offscreen_memory_size > 0) { 
    329399                glamos->kaa.flags = KAA_OFFSCREEN_PIXMAPS; 
    330400        } 
    331         glamos->kaa.offsetAlign = 4; 
    332         glamos->kaa.pitchAlign = 1; 
     401        glamos->kaa.offsetAlign = 16; 
     402        glamos->kaa.pitchAlign = 16; 
    333403 
    334404        kaaInitTrapOffsets(8, sample_offsets_x, sample_offsets_y, 0.0, 0.0); 
    335405        sample_count = (1 << 8) - 1;