Subversion Repositories Kolibri OS

{

  int x0, y0, x1, y1;

  y0 = draw->y;

  y1 = y0+draw->h-1;

//             x0, y0, x1, y1, draw->color);

  {

     u32 *ring, write;

     int w, h;

     u32 ifl;

     h = y1-y0+1;

                                     R5XX_GMC_BRUSH_SOLID_COLOR |

                                     R5XX_GMC_SRC_DATATYPE_COLOR);

     OUTREG(R5XX_DP_WRITE_MASK, 0xFFFFFFFF);

     OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);

     OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset);

     OUTREG(R5XX_DST_Y_X,(y0<<16)|x0);

     OUTREG(R5XX_DST_WIDTH_HEIGHT,(w<<16)|h);

       OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_MULTI, 4));

                RADEON_GMC_BRUSH_SOLID_COLOR      |

                RADEON_GMC_DST_32BPP              |

                RADEON_GMC_SRC_DATATYPE_COLOR     |

                (1 << 28)+(1 << 30) | R5XX_ROP3_P);

       OUT_RING(draw->color);

       OUT_RING((x0<<16)|y0);

       OUT_RING((w<<16)|h);

     COMMIT_RING();

  } ;

  return ERR_OK;

}

{

  pixmap_t *dstpixmap;

  int x0, y0, x1, y1;

  y0 = fill->y;

  y1 = y0+fill->h-1;

//             x0, y0, x1, y1);

  {

     u32 *ring, write;

     u32 ifl;

       OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT, 7));

       OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL    |

                BRUSH_MONO                          |

                RADEON_GMC_DST_32BPP                |

                RADEON_GMC_SRC_DATATYPE_COLOR       |

                (1 << 28)+(1 << 30) | R5XX_ROP3_P);

         OUT_RING(fill->bkcolor);

         OUT_RING(fill->fcolor);

         OUT_RING(fill->bmp1);

         OUT_RING((y1<<16)|x1);

     COMMIT_RING();

  };

  return ERR_OK;

}

{

  int x0, y0, x1, y1;

  y0 = blit->src_y;

  y1 = y0+blit->h-1;

  {

     u32 *ring, write;

     int w, h;

     u32 ifl;

     h = y1-y0+1;

       OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5));

                RADEON_GMC_DST_PITCH_OFFSET_CNTL  |

                RADEON_GMC_BRUSH_NONE             |

                RADEON_GMC_DST_32BPP              |

                RADEON_GMC_SRC_DATATYPE_COLOR     |

                RADEON_DP_SRC_SOURCE_MEMORY       |

                (1 << 28)+(1 << 30) | R5XX_ROP3_S);

       OUT_RING(rhd.dst_pitch_offset);

       OUT_RING((blit->dst_x<<16)|blit->dst_y);

       OUT_RING((w<<16)|h);

     COMMIT_RING();

  } ;

  return ERR_OK;

}

{

  y0 = draw->y0;

  y1 = draw->y1;

  {

    u32 ifl;

    u32 *ring, write;

                                     R5XX_GMC_BRUSH_SOLID_COLOR |

                                     R5XX_GMC_SRC_DATATYPE_COLOR);

     OUTREG(R5XX_DP_WRITE_MASK, 0xFFFFFFFF);

     OUTREG(R5XX_DST_PITCH_OFFSET, rhd.dst_pitch_offset);

     OUTREG(R5XX_DST_LINE_END,(y1<<16)|x1);

         OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_POLYLINE, 4));

         OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL  |

                  RADEON_GMC_BRUSH_SOLID_COLOR      |

                  RADEON_GMC_DST_32BPP              |

                  RADEON_GMC_SRC_DATATYPE_COLOR     |

                  (1 << 28)+(1 << 30) | R5XX_ROP3_P);

         OUT_RING(draw->color);

         OUT_RING((y0<<16)|x0);

         OUT_RING((y1<<16)|x1);

     COMMIT_RING();

     safe_sti(ifl);

  return ERR_OK;

}

{

  void *raw;

      (io->height == 0)|| (io->height > 2048))

  {

     dbgprintf("Invalid pixmap size w:%d h:%d\n", io->width,io->height);

     return ERR_PARAM;

  dbgprintf("pitch = %d\n", pitch);

  if (! raw)

  {

    dbgprintf("Not enough memory for pixmap\n");

    return ERR_PARAM;

  };

  if(!pixmap)

  {

    rhd_mem_free(&rhd, RHD_MEM_FB,raw);

    return ERR_PARAM;

  }

  else

  {

    io->pixmap  = pixmap;

    io->usermap = NULL;

    io->format  = PICT_a8r8g8b8;

    io->pitch   = 0;

    pixmap->height  = io->height;

    pixmap->format  = PICT_a8r8g8b8;

    pixmap->flags   = 0;

    pixmap->pitch   = pitch;

    pixmap->offset  = (u32_t)raw+rhd.FbIntAddress;

    pixmap->pitch_offset =  ((pitch/64)<<22)| (pixmap->offset>>10);

    pixmap->raw     = raw;

    pixmap->usermap = NULL;

    dbgprintf("width: %d height: %d\n",pixmap->width,pixmap->height );

    dbgprintf("pixmap.offset: %x\n", pixmap->offset);

  return ERR_OK;

}

{

  pixmap_t *pixmap;

  size_t    size;

  void     *usermap;

    return ERR_PARAM;

  else

    pixmap = io->pixmap;

    return ERR_PARAM;

  if (usermap = UserAlloc(size))

  {

    CommitPages(usermap, ((u32_t)pixmap->raw+rhd.PhisBase)|7|(1<<9), size);

    pixmap->flags |= 1;

    pixmap->usermap = usermap;

    io->usermap = usermap;

    io->pitch   = pixmap->pitch;

    dbgprintf("map at %x\n", io->usermap);

  }

  else

    return ERR_PARAM;

};

{

     int w, h;

     u32 ifl;

     int x0, y0;

     pixmap_t *dstpixmap;

     srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ;

     //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height);

     //dbgprintf("srcpitch: %x dstpitch: %x\n",

     //           srcpixmap->pitch_offset,dstpixmap->pitch_offset);

       OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5));

                RADEON_GMC_DST_PITCH_OFFSET_CNTL  |

                RADEON_GMC_BRUSH_NONE             |

                RADEON_GMC_DST_32BPP              |

                RADEON_GMC_SRC_DATATYPE_COLOR     |

                RADEON_DP_SRC_SOURCE_MEMORY       |

                (1 << 28)+(1 << 30) | R5XX_ROP3_S);

       OUT_RING(dstpixmap->pitch_offset);

       OUT_RING((blit->dst_x<<16)|blit->dst_y);

       OUT_RING((blit->w<<16)|blit->h);

     COMMIT_RING();

  return ERR_OK;

}

>