static void mask_ipv6_addr(const __be32 old[4], const __be32 addr[4],
const __be32 mask[4], __be32 masked[4])
{
masked[0] = MASKED(old[0], addr[0], mask[0]);
masked[1] = MASKED(old[1], addr[1], mask[1]);
masked[2] = MASKED(old[2], addr[2], mask[2]);
masked[3] = MASKED(old[3], addr[3], mask[3]);
}
int dma_pulse_DRQ(int ch, Bit8u * buf)
{
int ret = DMA_DACK;
if (MASKED(DI(ch), CI(ch))) {
q_printf("DMA: channel %i masked, DRQ ignored\n", ch);
ret = DMA_NO_DACK;
}
if ((dma[DI(ch)].status & 0xf0) || dma[DI(ch)].request) {
error("DMA: channel %i already active! (m=%#x s=%#x r=%#x)\n",
ch, dma[DI(ch)].chans[CI(ch)].mode, dma[DI(ch)].status,
dma[DI(ch)].request);
ret = DMA_NO_DACK;
}
#if 0
q_printf("DMA: pulse DRQ on channel %d\n", ch);
#endif
if (ret == DMA_DACK) {
DMA_LOCK();
dma[DI(ch)].status |= 1 << (CI(ch) + 4);
memcpy(dma_data_bus, buf, 1 << DI(ch));
dma_run_channel(DI(ch), CI(ch));
memcpy(buf, dma_data_bus, 1 << DI(ch));
DMA_UNLOCK();
} else {
memset(buf, 0xff, 1 << DI(ch));
}
return ret;
}
static void dma_run_channel(int dma_idx, int chan_idx)
{
int done = 0;
long ticks = 0;
while (!done &&
(HAVE_DRQ(dma_idx, chan_idx) || SW_ACTIVE(dma_idx, chan_idx))) {
if (!MASKED(dma_idx, chan_idx) &&
!REACHED_TC(dma_idx, chan_idx) &&
!(dma[dma_idx].command & 4) &&
(DMA_TRANSFER_MODE(dma[dma_idx].chans[chan_idx].mode) != CASCADE)) {
dma_process_channel(dma_idx, chan_idx);
ticks++;
} else {
done = 1;
}
dma_update_DRQ(dma_idx, chan_idx);
}
if (ticks > 1)
q_printf("DMA: processed %lu (left %u) cycles on controller %i channel %i\n",
ticks, dma[dma_idx].chans[chan_idx].cur_count.value, dma_idx,
chan_idx);
}
static int set_mpls(struct sk_buff *skb, struct sw_flow_key *flow_key,
const __be32 *mpls_lse, const __be32 *mask)
{
__be32 *stack;
__be32 lse;
int err;
err = skb_ensure_writable(skb, skb->mac_len + MPLS_HLEN);
if (unlikely(err))
return err;
stack = (__be32 *)skb_mpls_header(skb);
lse = MASKED(*stack, *mpls_lse, *mask);
if (skb->ip_summed == CHECKSUM_COMPLETE) {
__be32 diff[] = { ~(*stack), lse };
skb->csum = ~csum_partial((char *)diff, sizeof(diff),
~skb->csum);
}
*stack = lse;
flow_key->mpls.top_lse = lse;
return 0;
}
/* flooder:
* Fills a horizontal line around the specified position, and adds it
* to the list of drawn segments. Returns the first x coordinate after
* the part of the line which it has dealt with.
*/
static int flooder(const Image* image,
const Mask* mask,
int x, int y,
const gfx::Rect& bounds,
color_t src_color, int tolerance, void *data, AlgoHLine proc)
{
#define MASKED(u, v) \
(mask && \
(!mask->bounds().contains(u, v) || \
(mask->bitmap() && \
!get_pixel_fast<BitmapTraits>(mask->bitmap(), \
(u)-mask->bounds().x, \
(v)-mask->bounds().y))))
FLOODED_LINE *p;
int left = 0, right = 0;
int c;
switch (image->pixelFormat()) {
case IMAGE_RGB:
{
uint32_t* address = reinterpret_cast<uint32_t*>(image->getPixelAddress(0, y));
// Check start pixel
if (!color_equal_32((int)*(address+x), src_color, tolerance) || MASKED(x, y))
return x+1;
// Work left from starting point
for (left=x-1; left>=bounds.x; left--) {
if (!color_equal_32((int)*(address+left), src_color, tolerance) || MASKED(left, y))
break;
}
// Work right from starting point
for (right=x+1; right<bounds.x2(); right++) {
if (!color_equal_32((int)*(address+right), src_color, tolerance) || MASKED(right, y))
break;
}
}
break;
case IMAGE_GRAYSCALE:
{
uint16_t* address = reinterpret_cast<uint16_t*>(image->getPixelAddress(0, y));
// Check start pixel
if (!color_equal_16((int)*(address+x), src_color, tolerance) || MASKED(x, y))
return x+1;
// Work left from starting point
for (left=x-1; left>=bounds.x; left--) {
if (!color_equal_16((int)*(address+left), src_color, tolerance) || MASKED(left, y))
break;
}
// Work right from starting point
for (right=x+1; right<bounds.x2(); right++) {
if (!color_equal_16((int)*(address+right), src_color, tolerance) || MASKED(right, y))
break;
}
}
break;
case IMAGE_INDEXED:
{
uint8_t* address = image->getPixelAddress(0, y);
// Check start pixel
if (!color_equal_8((int)*(address+x), src_color, tolerance) || MASKED(x, y))
return x+1;
// Work left from starting point
for (left=x-1; left>=bounds.x; left--) {
if (!color_equal_8((int)*(address+left), src_color, tolerance) || MASKED(left, y))
break;
}
// Work right from starting point
for (right=x+1; right<bounds.x2(); right++) {
if (!color_equal_8((int)*(address+right), src_color, tolerance) || MASKED(right, y))
break;
}
}
break;
default:
// Check start pixel
if (get_pixel(image, x, y) != src_color || MASKED(x, y))
return x+1;
// Work left from starting point
for (left=x-1; left>=bounds.x; left--) {
if (get_pixel(image, left, y) != src_color || MASKED(left, y))
break;
}
// Work right from starting point
for (right=x+1; right<bounds.x2(); right++) {
if (get_pixel(image, right, y) != src_color || MASKED(right, y))
break;
}
break;
}
left++;
right--;
/* draw the line */
(*proc)(left, y, right, data);
/* store it in the list of flooded segments */
c = y;
p = FLOOD_LINE(c);
if (p->flags) {
while (p->next) {
c = p->next;
p = FLOOD_LINE(c);
}
p->next = c = flood_count++;
flood_buf.resize(flood_count);
p = FLOOD_LINE(c);
}
p->flags = FLOOD_IN_USE;
p->lpos = left;
p->rpos = right;
p->y = y;
p->next = 0;
if (y > bounds.y)
p->flags |= FLOOD_TODO_ABOVE;
if (y+1 < bounds.y2())
p->flags |= FLOOD_TODO_BELOW;
return right+2;
}