/* Register read and write function for a memory area.
addr is inside the area, if addr & addr_mask == addr_compare
(used also by peripheral devices like 16450 UART etc.) */
static struct dev_memarea *
register_memoryarea_mask (oraddr_t addr_mask,
oraddr_t addr_compare,
uint32_t size, unsigned mc_dev)
{
struct dev_memarea **pptmp;
unsigned int size_mask = bit_mask (size);
int found_error = 0;
addr_compare &= addr_mask;
/* Go to the end of the list. */
for (pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
if (((addr_compare >= (*pptmp)->addr_compare) &&
(addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)) ||
((addr_compare + size > (*pptmp)->addr_compare) &&
(addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)))
{
if (!found_error)
{
fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
fprintf (stderr,
"\taddr & %" PRIxADDR " == %" PRIxADDR " to %" PRIxADDR
", size %08" PRIx32 "\n", addr_mask, addr_compare,
addr_compare | bit_mask (size), size);
}
found_error = 1;
fprintf (stderr,
"and\taddr & %" PRIxADDR " == %" PRIxADDR " to %" PRIxADDR
", size %08" PRIx32 "\n", (*pptmp)->addr_mask,
(*pptmp)->addr_compare,
(*pptmp)->addr_compare | (*pptmp)->size_mask,
(*pptmp)->size);
}
if (found_error)
exit (-1);
cur_area = *pptmp =
(struct dev_memarea *) malloc (sizeof (struct dev_memarea));
if (mc_dev)
mc_area = *pptmp;
(*pptmp)->addr_mask = addr_mask;
(*pptmp)->addr_compare = addr_compare;
(*pptmp)->size = size;
(*pptmp)->size_mask = size_mask;
(*pptmp)->log = NULL;
(*pptmp)->valid = 1;
(*pptmp)->next = NULL;
return *pptmp;
}
void __init_or_cpufreq s3c_set_clksrc(struct clksrc_clk *clk, bool announce)
{
struct clksrc_sources *srcs = clk->sources;
u32 mask = bit_mask(clk->reg_src.shift, clk->reg_src.size);
u32 clksrc;
if (!clk->reg_src.reg) {
if (!clk->clk.parent)
printk(KERN_ERR "%s: no parent clock specified\n",
clk->clk.name);
return;
}
clksrc = __raw_readl(clk->reg_src.reg);
clksrc &= mask;
clk->clk.orig_src = clksrc;
clksrc >>= clk->reg_src.shift;
if (clksrc > srcs->nr_sources || !srcs->sources[clksrc]) {
printk(KERN_ERR "%s: bad source %d\n",
clk->clk.name, clksrc);
return;
}
clk->clk.parent = srcs->sources[clksrc];
if (announce)
printk(KERN_INFO "%s: source is %s (%d), rate is %ld\n",
clk->clk.name, clk->clk.parent->name, clksrc,
clk_get_rate(&clk->clk));
}
void
memory_table_status (void)
{
struct dev_memarea *ptmp;
/* Check list of registered devices. */
for (ptmp = dev_list; ptmp; ptmp = ptmp->next)
{
PRINTF ("addr & %" PRIxADDR " == %" PRIxADDR " to %" PRIxADDR ", size %"
PRIx32 "\n", ptmp->addr_mask, ptmp->addr_compare,
ptmp->addr_compare | bit_mask (ptmp->size), ptmp->size);
PRINTF ("\t");
if (ptmp->ops.delayr >= 0)
PRINTF ("read delay = %i cycles, ", ptmp->ops.delayr);
else
PRINTF ("reads not possible, ");
if (ptmp->ops.delayw >= 0)
PRINTF ("write delay = %i cycles", ptmp->ops.delayw);
else
PRINTF ("writes not possible");
if (ptmp->log)
PRINTF (", (logged)\n");
else
PRINTF ("\n");
}
}
void clear_bit(unsigned long *bitset, unsigned long bit)
{
unsigned long *addr, mask;
addr = bitset + (bit / BITS_PER_LONG);
mask = bit_mask(bit);
*addr &= ~mask;
}
static int s3c_setparent_clksrc(struct clk *clk, struct clk *parent)
{
struct clksrc_clk *sclk = to_clksrc(clk);
struct clksrc_sources *srcs = sclk->sources;
u32 clksrc = __raw_readl(sclk->reg_src.reg);
u32 mask = bit_mask(sclk->reg_src.shift, sclk->reg_src.size);
u32 tmp;
int src_nr = -1;
int ptr;
for (ptr = 0; ptr < srcs->nr_sources; ptr++)
if (srcs->sources[ptr] == parent) {
src_nr = ptr;
break;
}
if (src_nr < 0)
return -EINVAL;
clk->parent = parent;
clksrc &= ~mask;
clk->orig_src = src_nr << sclk->reg_src.shift;
clksrc |= src_nr << sclk->reg_src.shift;
__raw_writel(clksrc, sclk->reg_src.reg);
if (sclk->reg_src_stat.reg) {
mask = bit_mask(sclk->reg_src_stat.shift,
sclk->reg_src_stat.size);
do {
cpu_relax();
tmp = __raw_readl(sclk->reg_src_stat.reg);
tmp &= mask;
} while (tmp != BIT(src_nr + sclk->reg_src.shift));
}
return 0;
}
static unsigned long s3c_getrate_clksrc(struct clk *clk)
{
struct clksrc_clk *sclk = to_clksrc(clk);
unsigned long rate = clk_get_rate(clk->parent);
u32 clkdiv = __raw_readl(sclk->reg_div.reg);
u32 mask = bit_mask(sclk->reg_div.shift, sclk->reg_div.size);
clkdiv &= mask;
clkdiv >>= sclk->reg_div.shift;
clkdiv++;
rate /= clkdiv;
return rate;
}
void InterpreterOopMap::iterate_oop(OffsetClosure* oop_closure) {
int n = number_of_entries();
int word_index = 0;
uintptr_t value = 0;
uintptr_t mask = 0;
// iterate over entries
for (int i = 0; i < n; i++, mask <<= bits_per_entry) {
// get current word
if (mask == 0) {
value = bit_mask()[word_index++];
mask = 1;
}
// test for oop
if ((value & (mask << oop_bit_number)) != 0) oop_closure->offset_do(i);
}
}
/**
* Write a cpu syncpoint increment to the hardware, without touching
* the cache. Caller is responsible for host being powered.
*/
static void t20_syncpt_cpu_incr(struct nvhost_syncpt *sp, u32 id)
{
struct nvhost_master *dev = syncpt_to_dev(sp);
u32 reg_offset = id / 32;
if (!nvhost_syncpt_client_managed(sp, id)
&& nvhost_syncpt_min_eq_max(sp, id)) {
dev_err(&syncpt_to_dev(sp)->dev->dev,
"Trying to increment syncpoint id %d beyond max\n",
id);
nvhost_debug_dump(syncpt_to_dev(sp));
return;
}
writel(bit_mask(id), dev->sync_aperture +
host1x_sync_syncpt_cpu_incr_r() + reg_offset * 4);
}
void InterpreterOopMap::iterate_all(OffsetClosure* oop_closure, OffsetClosure* value_closure, OffsetClosure* dead_closure) {
int n = number_of_entries();
int word_index = 0;
uintptr_t value = 0;
uintptr_t mask = 0;
// iterate over entries
for (int i = 0; i < n; i++, mask <<= bits_per_entry) {
// get current word
if (mask == 0) {
value = bit_mask()[word_index++];
mask = 1;
}
// test for dead values & oops, and for live values
if ((value & (mask << dead_bit_number)) != 0) dead_closure->offset_do(i); // call this for all dead values or oops
else if ((value & (mask << oop_bit_number)) != 0) oop_closure->offset_do(i); // call this for all live oops
else value_closure->offset_do(i); // call this for all live values
}
}
long numoccs(unsigned char byte) {
int i;
long noccurrences = 0;
unsigned mask;
unsigned char pat;
for (i = 0; i < CHAR_BIT; i++) {
mask = bit_mask(bit_pattern_str);
pat = get_pattern(bit_pattern_str);
if ((byte & mask) == pat) { /* byte contains pat as a sub-pattern */
noccurrences += 1;
}
byte >>= 1; /* shift over 1 bit */
}
return noccurrences;
}
static int s3c_setrate_clksrc(struct clk *clk, unsigned long rate)
{
struct clksrc_clk *sclk = to_clksrc(clk);
void __iomem *reg = sclk->reg_div.reg;
unsigned int div;
u32 mask = bit_mask(sclk->reg_div.shift, sclk->reg_div.size);
u32 val;
rate = clk_round_rate(clk, rate);
div = clk_get_rate(clk->parent) / rate;
if (div > (1 << sclk->reg_div.size))
return -EINVAL;
val = __raw_readl(reg);
val &= ~mask;
clk->orig_div = (div - 1) << sclk->reg_div.shift;
val |= (div - 1) << sclk->reg_div.shift;
__raw_writel(val, reg);
return 0;
}
inline
size_t byte_mask(size_t num_bytes) {
return bit_mask(num_bytes << 3);
}
bool WritePict(uint32_t IndexPict, SectorInfo * SectorInfo, Bool OutPutTypeFrame) {
uint32_t PictNumber = 0;
Point RtfLt;
CPAGE_PICTURE pict;
uint32_t NumberPage = CPAGE_GetCurrentPage();
Handle h_Page = CPAGE_GetHandlePage(NumberPage);
Handle h_Pict = CPAGE_PictureGetFirst(h_Page);
while (h_Pict) {
if (++PictNumber > IndexPict)
break;
h_Pict = CPAGE_PictureGetNext(h_Page, h_Pict);
}
if (!h_Pict)
return false;
PAGEINFO pinfo;
if (!GetPageInfo(h_Page, &pinfo))
return false;
CIMAGE_InfoDataInGet in;
BitmapInfoHeader image_info;
Point Lr;
Point Wh;
Point LrN;
Point WhN;
if (CIMAGE_GetImageInfo(pinfo.szImageName, &image_info) == FALSE)
return false;
CPAGE_PictureGetPlace(h_Page, h_Pict, 0, &Lr, &Wh);
CPAGE_PictureGetPlace(h_Page, h_Pict, -pinfo.Incline2048, &LrN, &WhN);
Lr.rx() -= TemplateOffset.x();
Lr.ry() -= TemplateOffset.y();
int FrameOffset = abs(WhN.x() - Wh.x());
if (Lr.x() < 0)
FrameOffset += abs(Lr.x());
// Получим картинку из исходного изображения задав ее контур
//определяем размер маски
if (!CPAGE_PictureGetPlace(h_Page, h_Pict, -pinfo.Incline2048, &Lr, &Wh))
return false;
Bool rc = TRUE;
//piter : Корректируем координаты из-за повернута страницы.
switch (pinfo.Angle) {
case 0:
in.dwX = Lr.x();
in.dwY = Lr.y();
in.dwWidth = Wh.x();
in.dwHeight = Wh.y();
break;
case 270:
in.dwX = pinfo.Width - (Wh.y() + Lr.y());
in.dwY = Lr.x();
in.dwWidth = Wh.y();
in.dwHeight = Wh.x();
break;
case 180:
in.dwX = pinfo.Width - (Wh.x() + Lr.x());
in.dwY = pinfo.Height - (Wh.y() + Lr.y());
in.dwWidth = Wh.x();
in.dwHeight = Wh.y();
break;
case 90:
in.dwX = Lr.y();
in.dwY = pinfo.Height - (Wh.x() + Lr.x());
in.dwWidth = Wh.y();
in.dwHeight = Wh.x();
break;
}
// end piter
BitmapPtr pOutDIB = NULL;
if (!CIMAGE_GetDIBData(PUMA_IMAGE_USER, Rect(in.dwX, in.dwY, in.dwWidth, in.dwHeight), NULL, &pOutDIB)) {
Debug() << "[WritePict] CIMAGE_GetDIBData failed: " << PUMA_IMAGE_USER << "\n";
return false;
}
// Соберем изображение
const char * szTurnName = "RFRMT:TurnPicture";
const char * szPictName = "RFRMT:Picture";
const char * szRotateName = "RFRMT:RotatePicture";
const char * lpName = szPictName;
if (CIMAGE_AddImage(szPictName, (BitmapPtr) pOutDIB)) {
switch (pinfo.Angle) {
case 90:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_90);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
case 180:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_180);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
case 270:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_270);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
}
if (!rc) {
Debug() << "[WritePict] RIMAGE_Turn failed";
rc = FALSE;
}
} else {
Debug() << "[WritePict] CIMAGE_WriteDIB failed: " << szPictName << "\n";
}
// Довернем изображение на малый угол.
if (!RIMAGE_Rotate(lpName, szRotateName, pinfo.Incline2048, 2048)) {
Debug() << "[WritePict] RIMAGE_Rotate failed\n";
rc = FALSE;
} else {
CIMAGE_RemoveImage(lpName);
lpName = szRotateName;
}
// Маскируем полученное изображение
Point ptLt, ptWh;
if (rc && CPAGE_PictureGetPlace(h_Page, h_Pict, 0, &ptLt, &ptWh)) {
if (pinfo.Incline2048 >= 0) {
in.dwX = ptWh.y() * pinfo.Incline2048 / 2048;
in.dwY = 0;
} else {
in.dwX = 0;
// Beg of Almi Corr
// in.dwY = ptWh.x*pinfo.Incline2048/2048;
in.dwY = (-ptWh.x() * pinfo.Incline2048 / 2048);
// End of Almi Corr
}
if (!RIMAGE_RotatePoint(lpName, in.dwX, in.dwY, (int32_t *) &in.dwX,
(int32_t *) &in.dwY)) {
in.dwX = 0;
in.dwY = 0;
}
in.dwWidth = ptWh.x();
in.dwHeight = ptWh.y();
in.wByteWidth = (unsigned short) ((in.dwWidth + 7) / 8); //?
// Получим размер маски
uint32_t nSize = 0;
if (CPAGE_PictureGetMask(h_Page, h_Pict, 0, NULL, &nSize)) {
char * lpMask = (char*) malloc(sizeof(in) + nSize);
if (lpMask) {// Получаем маску
*(CIMAGE_InfoDataInGet*) lpMask = in;
if (CPAGE_PictureGetMask(h_Page, h_Pict, 0, lpMask + sizeof(in), &nSize)) {
cf::BitMask bit_mask(0, 0, (uchar*) lpMask + sizeof(in));
if (!CIMAGE_GetDIBData(lpName, Rect(in.dwX, in.dwY, in.dwWidth, in.dwHeight), &bit_mask, &pOutDIB)) {
Debug() << "CIMAGE_GetDIBData failed\n";
rc = FALSE;
}
} else {
Debug() << "PAGE_PictureGetMask failed\n";
rc = FALSE;
}
free(lpMask);
}
} else {
Debug() << "PAGE_PictureGetMask() failed\n";
rc = FALSE;
}
}
BlockElement * hPrevObject = NULL;
if (rc) {
CTDIB * pTmpDIB = new CTDIB;
pTmpDIB->setBitmap(pOutDIB);
cf::Size pictGoal;
pictGoal.rwidth() = pTmpDIB->lineWidth();
pictGoal.rheight() = pTmpDIB->linesNumber();
int32_t iDIBSize = pTmpDIB->dibSize();
delete pTmpDIB;
Rect indent;
Rect playout;
Lr.rx() = MAX(0, Lr.x());
Lr.ry() = MAX(0, Lr.y());
Rect slayout;
slayout.rleft() = Lr.x();
slayout.rright() = Lr.x() + Wh.x();
slayout.rtop() = Lr.y();
slayout.rbottom() = Lr.y() + Wh.y();
hPrevObject = SectorInfo->hObject;
if (SectorInfo->FlagInColumn || (OutPutTypeFrame && SectorInfo->FlagFictiveParagraph)) {
CEDParagraph * par = SectorInfo->hEDSector->createParagraph(SectorInfo->hColumn,
ALIGN_NONE, indent, SectorInfo->userNum, -1, playout);
par->addLine(new CEDLine(NULL, false, 6));
SectorInfo->FlagFictiveParagraph = FALSE;
}
if (RfrmtOptions::useNone() || SectorInfo->CountFragments == 1)
SectorInfo->hObject = SectorInfo->hColumn;
else {
if (SectorInfo->FlagInColumn == TRUE) {
Rect EdFragmRect;
EdFragmRect.setLeft(MAX(0, SectorInfo->OffsetFromColumn.x()));
EdFragmRect.setTop(MAX(0, SectorInfo->OffsetFromColumn.y()));
EdFragmRect.setWidth(MAX(0, Wh.x() - FrameOffset));
EdFragmRect.setHeight(Wh.y());
CEDFrame * frame = new CEDFrame(NULL, CEDFrame::HPOS_COLUMN,
CEDFrame::VPOS_PARAGRAPH);
frame->setBoundingRect(EdFragmRect);
SectorInfo->hColumn->addElement(frame);
SectorInfo->hObject = frame;
} else {
Rect EdFragmRect;
EdFragmRect.setLeft(Lr.x() - SectorInfo->Offset.x());
EdFragmRect.setTop(Lr.y() - SectorInfo->Offset.y());
EdFragmRect.setWidth(MAX(0, Wh.x() - FrameOffset));
EdFragmRect.setHeight(Wh.y());
CEDFrame * frame = new CEDFrame(NULL, CEDFrame::HPOS_COLUMN,
CEDFrame::VPOS_PARAGRAPH);
frame->setBoundingRect(EdFragmRect);
frame->dxfrtextx = 0;
frame->dxfrtexty = 0;
SectorInfo->hColumn->addElement(frame);
SectorInfo->hObject = frame;
}
}
CEDParagraph * ced_par = SectorInfo->hEDSector->createParagraph(SectorInfo->hObject,
ALIGN_NONE, indent, SectorInfo->userNum, -1, playout);
CEDLine * ced_line = new CEDLine;
// TODO hard coded font value
ced_line->setDefaultFontHeight(6);
CEDPicture * ced_pict = new CEDPicture();
ced_pict->setBoundingRect(slayout);
ced_pict->setPictureNumber(IndexPict);
ced_pict->setAlign(ED_ALIGN_MIDDLE);
uchar * img_data = new uchar[iDIBSize];
memcpy(img_data, pOutDIB, iDIBSize);
ced_pict->setImage(new Image(img_data, iDIBSize, Image::AllocatorNew));
ced_pict->image()->setSize(slayout.size());
ced_line->addElement(ced_pict);
ced_par->addLine(ced_line);
}
// piter
// освобождает память переданную по pOutDIB
CIMAGE_RemoveImage(lpName);
CIMAGE_FreeCopiedDIB(pOutDIB);
// end piter
SectorInfo->hObject = hPrevObject;
return TRUE;
}
/* Register read and write function for a memory area.
Memory areas should be aligned. Memory area is rounded up to
fit the nearest 2^n aligment.
(used also by peripheral devices like 16450 UART etc.)
If mc_dev is 1, this device will be checked first for a match
and will be accessed in case of overlaping memory areas.
Only one device can have this set to 1 (used for memory controller) */
struct dev_memarea *
reg_mem_area (oraddr_t addr, uint32_t size, unsigned mc_dev,
struct mem_ops *ops)
{
unsigned int size_mask = bit_mask (size);
unsigned int addr_mask = ~size_mask;
struct dev_memarea *mem;
mem = register_memoryarea_mask (addr_mask, addr & addr_mask, size_mask + 1,
mc_dev);
memcpy (&mem->ops, ops, sizeof (struct mem_ops));
memcpy (&mem->direct_ops, ops, sizeof (struct mem_ops));
if (!ops->readfunc32)
{
mem->ops.readfunc32 = eval_mem_32_inv;
mem->direct_ops.readfunc32 = eval_mem_32_inv_direct;
mem->direct_ops.read_dat32 = mem;
}
if (!ops->readfunc16)
{
mem->ops.readfunc16 = eval_mem_16_inv;
mem->direct_ops.readfunc16 = eval_mem_16_inv_direct;
mem->direct_ops.read_dat16 = mem;
}
if (!ops->readfunc8)
{
mem->ops.readfunc8 = eval_mem_8_inv;
mem->direct_ops.readfunc8 = eval_mem_8_inv_direct;
mem->direct_ops.read_dat8 = mem;
}
if (!ops->writefunc32)
{
mem->ops.writefunc32 = set_mem_32_inv;
mem->direct_ops.writefunc32 = set_mem_32_inv_direct;
mem->direct_ops.write_dat32 = mem;
}
if (!ops->writefunc16)
{
mem->ops.writefunc16 = set_mem_16_inv;
mem->direct_ops.writefunc16 = set_mem_16_inv_direct;
mem->direct_ops.write_dat16 = mem;
}
if (!ops->writefunc8)
{
mem->ops.writefunc8 = set_mem_8_inv;
mem->direct_ops.writefunc8 = set_mem_8_inv_direct;
mem->direct_ops.write_dat8 = mem;
}
if (!ops->writeprog8)
{
mem->ops.writeprog8 = mem->ops.writefunc8;
mem->ops.writeprog8_dat = mem->ops.write_dat8;
}
if (!ops->writeprog32)
{
mem->ops.writeprog32 = mem->ops.writefunc32;
mem->ops.writeprog32_dat = mem->ops.write_dat32;
}
if (ops->log)
{
if (!(mem->log = fopen (ops->log, "w")))
PRINTF ("ERR: Unable to open %s to log memory acesses to\n",
ops->log);
}
return mem;
}
