Subversion Repositories Kolibri OS

Rev

Rev 829 | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. #define BRUSH_MONO   (0<<4)
  3.  
  4.  
  5. int DrawRect(draw_t* draw)
  6. {
  7.   int x0, y0, x1, y1;
  8.  
  9.   pixmap_t *dstpixmap;
  10.  
  11.   dstpixmap = (draw->dstpix == (void*)-1) ? &scr_pixmap : draw->dstpix ;
  12.  
  13.   x0 = draw->x;
  14.   y0 = draw->y;
  15.  
  16.   x1 = x0+draw->w-1;
  17.   y1 = y0+draw->h-1;
  18.  
  19. //  dbgprintf("draw rect x0:%d, y0:%d, x1:%d, y1:%d, color: %x\n",
  20. //             x0, y0, x1, y1, draw->color);
  21.  
  22.   if( ! BlockClip( &x0, &y0, &x1, &y1))
  23.   {
  24.      u32 *ring, write;
  25.      int w, h;
  26.      u32 ifl;
  27.  
  28.      w = x1-x0+1;
  29.      h = y1-y0+1;
  30.  
  31.      ifl = safe_cli();
  32.  
  33.  
  34. #if R300_PIO
  35.  
  36.      R5xxFIFOWait(7);
  37.  
  38.      OUTREG(R5XX_DP_GUI_MASTER_CNTL, rhd.gui_control | R5XX_ROP3_P |
  39.                                      R5XX_GMC_BRUSH_SOLID_COLOR |
  40.                                      R5XX_GMC_SRC_DATATYPE_COLOR);
  41.  
  42.      OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color);
  43.      OUTREG(R5XX_DP_WRITE_MASK, 0xFFFFFFFF);
  44.      OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);
  45.      OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset);
  46.      OUTREG(R5XX_DST_Y_X,(y0<<16)|x0);
  47.      OUTREG(R5XX_DST_WIDTH_HEIGHT,(w<<16)|h);
  48.  
  49. #else
  50.  
  51.      BEGIN_RING();
  52.        OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_MULTI, 4));
  53.  
  54.        OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  55.                 RADEON_GMC_BRUSH_SOLID_COLOR      |
  56.                 RADEON_GMC_DST_32BPP              |
  57.                 RADEON_GMC_SRC_DATATYPE_COLOR     |
  58.                 (1 << 28)+(1 << 30) | R5XX_ROP3_P);
  59.  
  60.        OUT_RING(dstpixmap->pitch_offset);
  61.        OUT_RING(draw->color);
  62.        OUT_RING((x0<<16)|y0);
  63.        OUT_RING((w<<16)|h);
  64.      COMMIT_RING();
  65.  
  66. #endif
  67.  
  68.      safe_sti(ifl);
  69.   } ;
  70.   return ERR_OK;
  71. }
  72.  
  73. int FillRect(fill_t *fill)
  74. {
  75.   pixmap_t *dstpixmap;
  76.   int x0, y0, x1, y1;
  77.  
  78.   dstpixmap = (fill->dstpix == (void*)-1) ? &scr_pixmap : fill->dstpix ;
  79.  
  80.   x0 = fill->x;
  81.   y0 = fill->y;
  82.  
  83.   x1 = x0+fill->w-1;
  84.   y1 = y0+fill->h-1;
  85.  
  86. //  dbgprintf("fill rect x0:%d, y0:%d, x1:%d, y1:%d\n",
  87. //             x0, y0, x1, y1);
  88.  
  89.   if( ! BlockClip( &x0, &y0, &x1, &y1))
  90.   {
  91.      u32 *ring, write;
  92.      u32 ifl;
  93.  
  94.      ifl = safe_cli();
  95.  
  96. #if R300_PIO
  97.  
  98. #else
  99.  
  100.      BEGIN_RING();
  101.        OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT, 7));
  102.        OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL    |
  103.                 BRUSH_MONO                          |
  104.                 RADEON_GMC_DST_32BPP                |
  105.                 RADEON_GMC_SRC_DATATYPE_COLOR       |
  106.                 (1 << 28)+(1 << 30) | R5XX_ROP3_P);
  107.  
  108.          OUT_RING(dstpixmap->pitch_offset);
  109.          OUT_RING(fill->bkcolor);
  110.          OUT_RING(fill->fcolor);
  111.  
  112.          OUT_RING(fill->bmp0);
  113.          OUT_RING(fill->bmp1);
  114.  
  115.          OUT_RING((y0<<16)|x0);
  116.          OUT_RING((y1<<16)|x1);
  117.      COMMIT_RING();
  118.  
  119. #endif
  120.  
  121.      safe_sti(ifl);
  122.   };
  123.   return ERR_OK;
  124. }
  125.  
  126. int Blit(blit_t *blit)
  127. {
  128.   int x0, y0, x1, y1;
  129.  
  130.   x0 = blit->src_x;
  131.   y0 = blit->src_y;
  132.  
  133.   x1 = x0+blit->w-1;
  134.   y1 = y0+blit->h-1;
  135.  
  136.  
  137.   if( ! BlockClip( &x0, &y0, &x1, &y1))
  138.   {
  139.      u32 *ring, write;
  140.      int w, h;
  141.      u32 ifl;
  142.  
  143.      w = x1-x0+1;
  144.      h = y1-y0+1;
  145.  
  146.      ifl = safe_cli();
  147.  
  148. #if R300_PIO
  149.  
  150.  
  151. #else
  152.  
  153.      BEGIN_RING();
  154.        OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5));
  155.  
  156.        OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL  |
  157.                 RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  158.                 RADEON_GMC_BRUSH_NONE             |
  159.                 RADEON_GMC_DST_32BPP              |
  160.                 RADEON_GMC_SRC_DATATYPE_COLOR     |
  161.                 RADEON_DP_SRC_SOURCE_MEMORY       |
  162.                 (1 << 28)+(1 << 30) | R5XX_ROP3_S);
  163.  
  164.        OUT_RING(rhd.dst_pitch_offset);
  165.        OUT_RING(rhd.dst_pitch_offset);
  166.  
  167.        OUT_RING((x0<<16)|y0);
  168.        OUT_RING((blit->dst_x<<16)|blit->dst_y);
  169.        OUT_RING((w<<16)|h);
  170.      COMMIT_RING();
  171.  
  172. #endif
  173.  
  174.      safe_sti(ifl);
  175.   } ;
  176.   return ERR_OK;
  177. }
  178.  
  179. int Line2P(line2p_t *draw)
  180. {
  181.  
  182.   int x0, y0, x1, y1;
  183.  
  184.   x0 = draw->x0;
  185.   y0 = draw->y0;
  186.  
  187.   x1 = draw->x1;
  188.   y1 = draw->y1;
  189.  
  190.   if ( !LineClip( &x0, &y0, &x1, &y1 ))
  191.   {
  192.     u32 ifl;
  193.     u32 *ring, write;
  194.  
  195.     ifl = safe_cli();
  196.  
  197. #if R300_PIO
  198.  
  199.      R5xxFIFOWait(6);
  200.  
  201.      OUTREG(R5XX_DP_GUI_MASTER_CNTL,
  202.             rhd.gui_control             |
  203.             R5XX_GMC_BRUSH_SOLID_COLOR  |
  204.             R5XX_GMC_SRC_DATATYPE_COLOR |
  205.             R5XX_GMC_CLR_CMP_CNTL_DIS   |
  206.             R5XX_GMC_WR_MSK_DIS         |
  207.             R5XX_ROP3_P
  208.             );
  209.  
  210.      OUTREG(R5XX_DST_LINE_PATCOUNT, 0x55 << R5XX_BRES_CNTL_SHIFT);
  211.  
  212.      OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color);
  213.      OUTREG(R5XX_DST_PITCH_OFFSET, rhd.dst_pitch_offset);
  214.  
  215.      OUTREG(R5XX_DST_LINE_START,(y0<<16)|x0);
  216.      OUTREG(R5XX_DST_LINE_END,(y1<<16)|x1);
  217.  
  218. #else
  219.  
  220.      BEGIN_RING();
  221.          OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_POLYLINE, 4));
  222.          OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  223.                   RADEON_GMC_BRUSH_SOLID_COLOR      |
  224.                   RADEON_GMC_DST_32BPP              |
  225.                   RADEON_GMC_SRC_DATATYPE_COLOR     |
  226.                   R5XX_GMC_CLR_CMP_CNTL_DIS         |
  227.                   R5XX_GMC_WR_MSK_DIS               |
  228.                   R5XX_ROP3_P);
  229.  
  230.          OUT_RING(rhd.dst_pitch_offset);
  231.          OUT_RING(draw->color);
  232.          OUT_RING((y0<<16)|x0);
  233.          OUT_RING((y1<<16)|x1);
  234.      COMMIT_RING();
  235.  
  236. #endif
  237.      safe_sti(ifl);
  238.  
  239.   };
  240.   return ERR_OK;
  241. }
  242.  
  243.  
  244. int CreatePixmap(userpixmap_t *io)
  245. {
  246.  
  247.   pixmap_t *pixmap;
  248.  
  249.   u32_t pitch;
  250.   void *raw;
  251.  
  252.   if( (io->width == 0) || (io->width > 2048)||
  253.       (io->height == 0)|| (io->height > 2048))
  254.   {
  255.      dbgprintf("Invalid pixmap size w:%d h:%d\n", io->width,io->height);
  256.      return ERR_PARAM;
  257.  
  258.   };
  259.  
  260.   pitch = ((io->width+15)&~15)*4;
  261.   dbgprintf("pitch = %d\n", pitch);
  262.  
  263.   raw = rhd_mem_alloc(&rhd,RHD_MEM_FB,pitch*io->height) ;
  264.   if (! raw)
  265.   {
  266.     dbgprintf("Not enough memory for pixmap\n");
  267.     return ERR_PARAM;
  268.   };
  269.  
  270.   pixmap = malloc(sizeof(pixmap_t));
  271.   if(!pixmap)
  272.   {
  273.     rhd_mem_free(&rhd, RHD_MEM_FB,raw);
  274.     return ERR_PARAM;
  275.   }
  276.   else
  277.   {
  278.     io->pixmap  = pixmap;
  279.     io->usermap = NULL;
  280.     io->format  = PICT_a8r8g8b8;
  281.     io->pitch   = 0;
  282.  
  283.     pixmap->width   = io->width;
  284.     pixmap->height  = io->height;
  285.     pixmap->format  = PICT_a8r8g8b8;
  286.     pixmap->flags   = 0;
  287.     pixmap->pitch   = pitch;
  288.     pixmap->offset  = (u32_t)raw+rhd.FbIntAddress;
  289.     pixmap->pitch_offset =  ((pitch/64)<<22)| (pixmap->offset>>10);
  290.     pixmap->raw     = raw;
  291.     pixmap->usermap = NULL;
  292.  
  293.     dbgprintf("pixmap.pitch_offset: %x\n", pixmap->pitch_offset);
  294.     dbgprintf("width: %d height: %d\n",pixmap->width,pixmap->height );
  295.     dbgprintf("pixmap.offset: %x\n", pixmap->offset);
  296.  
  297.   }
  298.   return ERR_OK;
  299. }
  300.  
  301. int DestroyPixmap( userpixmap_t *io)
  302. {
  303.    pixmap_t *pixmap;
  304.  
  305.    dbgprintf("Destroy pixmap %x\n", io->pixmap);
  306.  
  307.    if(io->pixmap == (pixmap_t*)-1)
  308.      return ERR_PARAM;
  309.    else
  310.      pixmap = io->pixmap;
  311.  
  312.    if( (pixmap->flags & 1) == PX_LOCK )
  313.      UnlockPixmap(io);
  314.  
  315.    UserFree(pixmap->usermap);
  316.    rhd_mem_free(&rhd,RHD_MEM_FB,pixmap->raw);
  317.    free(pixmap);
  318.  
  319.    io->pixmap  = NULL;
  320.    io->usermap = NULL;
  321.    io->format  = 0;
  322.    io->pitch   = 0;
  323.  
  324.    return ERR_OK;
  325. };
  326.  
  327. int LockPixmap(userpixmap_t *io)
  328. {
  329.    pixmap_t *pixmap;
  330.    size_t    size;
  331.    void     *usermap;
  332.  
  333.    dbgprintf("Lock pixmap %x\n", io->pixmap);
  334.  
  335.    if(io->pixmap == (pixmap_t*)-1)
  336.      return ERR_PARAM;
  337.    else
  338.      pixmap = io->pixmap;
  339.  
  340.    if( (pixmap->flags & 1) == PX_LOCK )
  341.      return ERR_PARAM;
  342.  
  343.    size = (pixmap->pitch*pixmap->width+4095) & ~ 4095;
  344.    if (usermap = UserAlloc(size))
  345.    {
  346.      CommitPages(usermap, ((u32_t)pixmap->raw+rhd.PhisBase)|7|(1<<9), size);
  347.      pixmap->flags |= PX_LOCK;
  348.      pixmap->usermap = usermap;
  349.      io->usermap = usermap;
  350.      io->pitch   = pixmap->pitch;
  351.      dbgprintf("map at %x\n", io->usermap);
  352.  
  353.      return ERR_OK;
  354.    }
  355.    else
  356.      return ERR_PARAM;
  357. };
  358.  
  359. int UnlockPixmap(userpixmap_t *io)
  360. {
  361.   pixmap_t *pixmap;
  362.   size_t    size;
  363.  
  364.   dbgprintf("Unlock pixmap %x\n", io->pixmap);
  365.  
  366.   if(io->pixmap == (pixmap_t*)-1)
  367.     return ERR_PARAM;
  368.   else
  369.     pixmap = io->pixmap;
  370.  
  371.   if( (pixmap->flags & 1) != PX_LOCK )
  372.     return ERR_PARAM;
  373.  
  374. /*   Sanity checks  */
  375.  
  376.   if( (pixmap->usermap == 0)||
  377.       ((u32_t)pixmap->usermap >= 0x80000000) ||
  378.       ((u32_t)pixmap->usermap & 4095)
  379.     )
  380.     return ERR_PARAM;
  381.  
  382.   size = (pixmap->pitch*pixmap->width+4095) & ~ 4095;
  383.  
  384.   UnmapPages(pixmap->usermap, size);
  385.   UserFree(pixmap->usermap);
  386.   pixmap->usermap =  NULL;
  387.   pixmap->flags  &= ~PX_LOCK;
  388.   io->usermap     =  NULL;
  389.   io->pitch       =  0;
  390.  
  391.   return ERR_OK;
  392. };
  393.  
  394.  
  395. int PixBlit(pixblit_t *blit)
  396. {
  397.  
  398.      u32 *ring, write;
  399.      int w, h;
  400.      u32 ifl;
  401.      int x0, y0;
  402.  
  403.      pixmap_t *srcpixmap;
  404.      pixmap_t *dstpixmap;
  405.  
  406.      //dbgprintf("Pixblit src: %x dst: %x\n",blit->srcpix, blit->dstpix);
  407.  
  408.      dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ;
  409.      srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ;
  410.  
  411.      //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap);
  412.  
  413.      //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height);
  414.      //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height);
  415.      //dbgprintf("srcpitch: %x dstpitch: %x\n",
  416.      //           srcpixmap->pitch_offset,dstpixmap->pitch_offset);
  417.  
  418.      ifl = safe_cli();
  419.  
  420. #if R300_PIO
  421.  
  422.      R5xxFIFOWait(7);
  423.  
  424.      OUTREG(R5XX_DP_GUI_MASTER_CNTL,
  425.             RADEON_GMC_SRC_PITCH_OFFSET_CNTL  |
  426.             RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  427.             RADEON_GMC_BRUSH_NONE             |
  428.             RADEON_GMC_DST_32BPP              |
  429.             RADEON_GMC_SRC_DATATYPE_COLOR     |
  430.             RADEON_DP_SRC_SOURCE_MEMORY       |
  431.             R5XX_GMC_CLR_CMP_CNTL_DIS         |
  432.             R5XX_GMC_WR_MSK_DIS               |
  433.             R5XX_ROP3_S
  434.            );
  435.  
  436.      OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);
  437.  
  438.      OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset);
  439.      OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset);
  440.  
  441.      OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x);
  442.      OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x);
  443.      OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w);
  444.  
  445. #else
  446.  
  447.      BEGIN_RING();
  448.        OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5));
  449.  
  450.        OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL  |
  451.                 RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  452.                 RADEON_GMC_BRUSH_NONE             |
  453.                 RADEON_GMC_DST_32BPP              |
  454.                 RADEON_GMC_SRC_DATATYPE_COLOR     |
  455.                 RADEON_DP_SRC_SOURCE_MEMORY       |
  456.                 R5XX_GMC_CLR_CMP_CNTL_DIS         |
  457.                 R5XX_GMC_WR_MSK_DIS               |
  458.                 R5XX_ROP3_S
  459.                );
  460.  
  461.        OUT_RING(srcpixmap->pitch_offset);
  462.        OUT_RING(dstpixmap->pitch_offset);
  463.  
  464.        OUT_RING((blit->src_x<<16)|blit->src_y);
  465.        OUT_RING((blit->dst_x<<16)|blit->dst_y);
  466.        OUT_RING((blit->w<<16)|blit->h);
  467.      COMMIT_RING();
  468.  
  469. #endif
  470.  
  471.      safe_sti(ifl);
  472.   return ERR_OK;
  473. }
  474.  
  475.  
  476. int TransBlit(pixblit_t *blit)
  477. {
  478.  
  479.      u32 *ring, write;
  480.      int w, h;
  481.      u32 ifl;
  482.      int x0, y0;
  483.  
  484.      pixmap_t *srcpixmap;
  485.      pixmap_t *dstpixmap;
  486.  
  487.     // dbgprintf("Transblit src: %x dst: %x\n",blit->srcpix, blit->dstpix);
  488.  
  489.      dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ;
  490.      srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ;
  491.  
  492.      //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap);
  493.  
  494.      //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height);
  495.      //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height);
  496.      //dbgprintf("srcpitch: %x dstpitch: %x\n",
  497.      //           srcpixmap->pitch_offset,dstpixmap->pitch_offset);
  498.  
  499.      ifl = safe_cli();
  500.  
  501. #if R300_PIO
  502.  
  503.      R5xxFIFOWait(10);
  504.  
  505.      OUTREG(R5XX_DP_GUI_MASTER_CNTL,
  506.             RADEON_GMC_SRC_PITCH_OFFSET_CNTL  |
  507.             RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  508.             RADEON_GMC_BRUSH_NONE             |
  509.             RADEON_GMC_DST_32BPP              |
  510.             RADEON_GMC_SRC_DATATYPE_COLOR     |
  511.             RADEON_DP_SRC_SOURCE_MEMORY       |
  512.             R5XX_GMC_WR_MSK_DIS               |
  513.             R5XX_ROP3_S
  514.            );
  515.  
  516.      OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);
  517.  
  518.      OUTREG(R5XX_CLR_CMP_CLR_SRC, 0xFF000000);
  519.      OUTREG(R5XX_CLR_CMP_MASK, R5XX_CLR_CMP_MSK);
  520.      OUTREG(R5XX_CLR_CMP_CNTL, R5XX_SRC_CMP_EQ_COLOR | R5XX_CLR_CMP_SRC_SOURCE);
  521.  
  522.      OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset);
  523.      OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset);
  524.  
  525.      OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x);
  526.      OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x);
  527.      OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w);
  528.  
  529. #else
  530.  
  531.      BEGIN_RING();
  532.        OUT_RING(CP_PACKET3(RADEON_CNTL_TRANBLT, 8));
  533.  
  534.        OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL  |
  535.                 RADEON_GMC_DST_PITCH_OFFSET_CNTL  |
  536.                 RADEON_GMC_BRUSH_NONE             |
  537.                 RADEON_GMC_DST_32BPP              |
  538.                 RADEON_GMC_SRC_DATATYPE_COLOR     |
  539.                 RADEON_DP_SRC_SOURCE_MEMORY       |
  540.                 R5XX_GMC_WR_MSK_DIS               |
  541.                 R5XX_ROP3_S
  542.                );
  543.  
  544.        OUT_RING(srcpixmap->pitch_offset);
  545.        OUT_RING(dstpixmap->pitch_offset);
  546.  
  547.        OUT_RING(R5XX_CLR_CMP_SRC_SOURCE | R5XX_SRC_CMP_EQ_COLOR);
  548.        OUT_RING(0xFF000000);
  549.        OUT_RING(0xFF000000);
  550.  
  551.        OUT_RING((blit->src_x<<16)|blit->src_y);
  552.        OUT_RING((blit->dst_x<<16)|blit->dst_y);
  553.        OUT_RING((blit->w<<16)|blit->h);
  554.  
  555.      COMMIT_RING();
  556.  
  557. #endif
  558.  
  559.      safe_sti(ifl);
  560.   return ERR_OK;
  561. }
  562.  
  563.