void ICMPv4::ping_reply(full_header* full_hdr, uint16_t size) { auto packet_ptr = inet_.create_packet(size); auto buf = packet_ptr->buffer(); icmp_header* hdr = &reinterpret_cast<full_header*>(buf)->icmp_hdr; hdr->type = ICMP_ECHO_REPLY; hdr->code = 0; hdr->identifier = full_hdr->icmp_hdr.identifier; hdr->sequence = full_hdr->icmp_hdr.sequence; debug("<ICMP> Rest of header IN: 0x%lx OUT: 0x%lx\n", full_hdr->icmp_hdr.rest, hdr->rest); debug("<ICMP> Transmitting answer\n"); // Populate response IP header auto ip4_pckt = static_unique_ptr_cast<PacketIP4>(std::move(packet_ptr)); ip4_pckt->init(); ip4_pckt->set_src(full_hdr->ip_hdr.daddr); ip4_pckt->set_dst(full_hdr->ip_hdr.saddr); ip4_pckt->set_protocol(IP4::IP4_ICMP); ip4_pckt->set_ip_data_length(sizeof(icmp_header) + size - sizeof(full_header)); // Copy payload from old to new packet uint8_t* payload = reinterpret_cast<uint8_t*>(hdr) + sizeof(icmp_header); uint8_t* source = reinterpret_cast<uint8_t*>(&full_hdr->icmp_hdr) + sizeof(icmp_header); memcpy(payload, source, size - sizeof(full_header)); hdr->checksum = 0; hdr->checksum = net::checksum(reinterpret_cast<uint16_t*>(hdr), size - sizeof(full_header) + sizeof(icmp_header)); network_layer_out_(std::move(ip4_pckt)); }
void UDP::WriteBuffer::write() { // the bytes remaining to be written UDP::Packet_ptr chain_head{}; debug("<UDP> %i bytes to write, need %i packets \n", remaining(), remaining() / udp.max_datagram_size() + (remaining() % udp.max_datagram_size() ? 1 : 0)); do { size_t total = remaining(); total = (total > udp.max_datagram_size()) ? udp.max_datagram_size() : total; // create some packet p (and convert it to PacketUDP) auto p = udp.stack().createPacket(0); // fill buffer (at payload position) memcpy(p->buffer() + PacketUDP::HEADERS_SIZE, buf.get() + this->offset, total); // initialize packet with several infos auto p2 = std::static_pointer_cast<PacketUDP>(p); p2->init(); p2->header().sport = htons(l_port); p2->header().dport = htons(d_port); p2->set_src(l_addr); p2->set_dst(d_addr); p2->set_length(total); // Attach packet to chain if (!chain_head) chain_head = p2; else chain_head->chain(p2); // next position in buffer this->offset += total; } while ( remaining() ); // ship the packet udp.transmit(chain_head); }
void ICMPv6::discover() { // ether-broadcast an IPv6 packet to all routers // IPv6mcast_02: 33:33:00:00:00:02 auto pckt = IP6::create( IP6::PROTO_ICMPv6, Ethernet::addr::IPv6mcast_02, IP6::addr::link_unspecified); // RFC4861 4.1. Router Solicitation Message Format pckt->set_hoplimit(255); NDP::router_sol* ndp = (NDP::router_sol*) pckt->payload(); // set to Router Solicitation Request ndp->type = ICMPv6::ND_ROUTER_SOL; ndp->code = 0; ndp->checksum = 0; ndp->reserved = 0; auto icmp = std::static_pointer_cast<PacketICMP6> (pckt); // source and destination addresses icmp->set_src(this->local_ip()); //IP6::addr::link_unspecified); icmp->set_dst(IP6::addr::link_all_routers); // ICMP header length field icmp->set_length(sizeof(NDP::router_sol)); // calculate and set checksum // NOTE: do this after changing packet contents! ndp->checksum = ICMPv6::checksum(icmp); this->transmit(icmp); /// DHCPv6 test /// // ether-broadcast an IPv6 packet to all routers //pckt = IP6::create( // IP6::PROTO_UDP, // Ethernet::addr::IPv6mcast_02, // IP6::addr::link_unspecified); }
enum bverror do_blit(struct bvbltparams *bvbltparams, struct gcbatch *batch, struct surfaceinfo *srcinfo) { enum bverror bverror = BVERR_NONE; struct gccontext *gccontext = get_context(); struct gcmosrc0 *gcmosrc0; struct gcmosrc *gcmosrc; struct gcblit *gcblit; unsigned int index; struct bvbuffmap *dstmap = NULL; struct bvbuffmap *srcmap = NULL; struct surfaceinfo *dstinfo; int dstshiftX, dstshiftY; int dstpixalign, dstbyteshift; int dstoffsetX, dstoffsetY; int srcshiftX, srcshiftY, srctopedge; struct gcrect srcclipped; int srcsurfwidth, srcsurfheight; unsigned int physwidth, physheight; int orthogonal; int multisrc; GCENTER(GCZONE_BLIT); /* 3-plane source not supported. */ if ((srcinfo->format.type == BVFMT_YUV) && (srcinfo->format.cs.yuv.planecount == 3)) { BVSETBLTERROR((srcinfo->index == 0) ? BVERR_SRC1GEOM_FORMAT : BVERR_SRC2GEOM_FORMAT, "unsupported source%d format.", srcinfo->index + 1); goto exit; } /* Get a shortcut to the destination surface. */ dstinfo = &batch->dstinfo; /* Parse destination parameters. */ bverror = parse_destination(bvbltparams, batch); if (bverror != BVERR_NONE) goto exit; /* Setup rotation. */ process_dest_rotation(bvbltparams, batch); /*********************************************************************** * Determine source surface alignment offset. */ /* Determine whether the source and the destination are orthogonal * to each other. */ orthogonal = (srcinfo->angle % 2) != (dstinfo->angle % 2); /* Compute clipped source rectangle. */ srcclipped.left = srcinfo->rect.left + batch->clipdelta.left; srcclipped.top = srcinfo->rect.top + batch->clipdelta.top; srcclipped.right = srcinfo->rect.right + batch->clipdelta.right; srcclipped.bottom = srcinfo->rect.bottom + batch->clipdelta.bottom; GCPRINT_RECT(GCZONE_SURF, "clipped source", &srcclipped); /* Validate the source rectangle. */ if (!valid_rect(srcinfo->geom, &srcclipped)) { BVSETBLTERROR((srcinfo->index == 0) ? BVERR_SRC1RECT : BVERR_SRC2RECT, "invalid source rectangle."); goto exit; } /* Compute the source surface shift. */ switch (srcinfo->angle) { case ROT_ANGLE_0: srctopedge = srcclipped.top; srcshiftX = srcclipped.left - batch->dstadjusted.left; srcshiftY = srctopedge - batch->dstadjusted.top; break; case ROT_ANGLE_90: srctopedge = srcinfo->geom->width - srcclipped.left; srcshiftX = srcclipped.top - batch->dstadjusted.top; srcshiftY = srctopedge - (batch->dstwidth - batch->dstadjusted.left); srctopedge += 1; break; case ROT_ANGLE_180: srctopedge = srcinfo->geom->height - srcclipped.top; srcshiftX = (srcinfo->geom->width - srcclipped.left) - (batch->dstwidth - batch->dstadjusted.left); srcshiftY = srctopedge - (batch->dstheight - batch->dstadjusted.top); srctopedge += 1; break; case ROT_ANGLE_270: srctopedge = srcclipped.left; srcshiftX = (srcinfo->geom->height - srcclipped.top) - (batch->dstheight - batch->dstadjusted.top); srcshiftY = srctopedge - batch->dstadjusted.left; break; default: srctopedge = 0; srcshiftX = 0; srcshiftY = 0; } /* We cannot be in the middle of a sample, currently only YUV formats * can have subsamples. Adjust vertical position as necessary. * Horizontal position will be adjusted based on the byte offset and * base address alignment requirement. This assumes that if we are * aligned on the base address, then we are also aligned at the * beginning of a sample. */ if (srcinfo->format.type == BVFMT_YUV) { int mody = (srctopedge + srcshiftY) % srcinfo->format.cs.yuv.ysample; if (mody < 0) mody = srcinfo->format.cs.yuv.ysample + mody; srcshiftY -= mody; srcinfo->ypixalign = -mody; } else { srcinfo->ypixalign = 0; } /* Compute the source surface offset in bytes. */ srcinfo->bytealign = srcshiftY * (int) srcinfo->geom->virtstride + srcshiftX * (int) srcinfo->format.bitspp / 8; /* Compute the source offset in pixels needed to compensate * for the surface base address misalignment if any. */ srcinfo->xpixalign = get_pixel_offset(srcinfo, srcinfo->bytealign); GCDBG(GCZONE_SURF, "source surface %d:\n", srcinfo->index + 1); GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n", srcshiftX, srcshiftY); GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n", srcinfo->bytealign); GCDBG(GCZONE_SURF, " srcpixalign = %d,%d\n", srcinfo->xpixalign, srcinfo->ypixalign); /* Apply the source alignment. */ srcinfo->bytealign += srcinfo->xpixalign * (int) srcinfo->format.bitspp / 8; srcshiftX += srcinfo->xpixalign; /* NOTE: at this point the source is ready to be presented, * srcinfo->xpixalign and srcinfo->ypixalign represent additional * adjustments for the DESTINATION. */ GCDBG(GCZONE_SURF, " adjusted surface offset (pixels) = %d,%d\n", srcshiftX, srcshiftY); GCDBG(GCZONE_SURF, " adjusted surface offset (bytes) = 0x%08X\n", srcinfo->bytealign); /* Compute U/V plane offsets. */ if ((srcinfo->format.type == BVFMT_YUV) && (srcinfo->format.cs.yuv.planecount > 1)) set_computeyuv(srcinfo, srcshiftX, srcshiftY); /* Set precomputed destination adjustments based on the destination * base address misalignment only. */ dstshiftX = dstinfo->xpixalign; dstshiftY = dstinfo->ypixalign; /* Apply source adjustemnts. */ if (srcinfo->angle == dstinfo->angle) { dstshiftX += srcinfo->xpixalign; dstshiftY += srcinfo->ypixalign; } else if (((srcinfo->angle + 3) % 4) == dstinfo->angle) { dstshiftY += srcinfo->xpixalign; } else if (((srcinfo->angle + 1) % 4) == dstinfo->angle) { dstshiftX += srcinfo->ypixalign; } /* Compute the destination surface offset in bytes. */ dstbyteshift = dstshiftY * (int) dstinfo->geom->virtstride + dstshiftX * (int) dstinfo->format.bitspp / 8; /* Compute the destination offset in pixels needed to compensate * for the surface base address misalignment if any. If dstpixalign * comes out anything other than zero, multisource blit cannot be * performed. */ dstpixalign = get_pixel_offset(dstinfo, dstbyteshift); GCDBG(GCZONE_SURF, "destination surface:\n"); GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n", dstshiftX, dstshiftY); GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n", dstbyteshift); GCDBG(GCZONE_SURF, " realignment = %d\n", dstpixalign); if ((dstpixalign != 0) || ((srcinfo->xpixalign != 0) && (srcinfo->angle == dstinfo->angle))) { /* Adjust the destination to match the source geometry. */ switch (srcinfo->angle) { case ROT_ANGLE_0: /* Adjust coordinates. */ srcclipped.left -= srcshiftX; srcclipped.top -= srcshiftY; /* Determine source size. */ srcsurfwidth = srcinfo->geom->width - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->height; break; case ROT_ANGLE_90: /* Adjust top coordinate. */ srcclipped.top -= srcshiftX; /* Determine source size. */ srcsurfwidth = srcinfo->geom->height - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->width; break; case ROT_ANGLE_180: /* Determine source size. */ srcsurfwidth = srcinfo->geom->width - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->height; break; case ROT_ANGLE_270: /* Adjust coordinates. */ srcclipped.left -= srcshiftY; /* Determine source size. */ srcsurfwidth = srcinfo->geom->height - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->width; break; default: srcsurfwidth = 0; srcsurfheight = 0; } GCDBG(GCZONE_SURF, "srcrect origin = %d,%d\n", srcclipped.left, srcclipped.top); GCDBG(GCZONE_SURF, "source physical size = %dx%d\n", srcsurfwidth, srcsurfheight); /* Overwrite destination byte offset. */ dstbyteshift = dstinfo->bytealign; /* No adjustment necessary for single-source. */ dstoffsetX = 0; dstoffsetY = 0; /* Set the physical destination size. */ physwidth = dstinfo->physwidth; physheight = dstinfo->physheight; /* Disable multi source for the cases where the destination * and the source address alignments do not match. */ multisrc = 0; GCDBG(GCZONE_SURF, "multi-source disabled.\n"); } else { /* Source origin is not used in multi-source setup. */ srcclipped.left = 0; srcclipped.top = 0; /* Adjust the destination to match the source geometry. */ switch (srcinfo->angle) { case ROT_ANGLE_0: /* Adjust the destination horizontally. */ dstoffsetX = srcinfo->xpixalign; dstoffsetY = srcinfo->ypixalign; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } else { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } break; case ROT_ANGLE_90: /* Adjust the destination vertically. */ dstoffsetX = srcinfo->ypixalign; dstoffsetY = srcinfo->xpixalign; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } else { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } break; case ROT_ANGLE_180: /* No adjustment necessary. */ dstoffsetX = 0; dstoffsetY = 0; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } else { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } break; case ROT_ANGLE_270: /* No adjustment necessary. */ dstoffsetX = 0; dstoffsetY = 0; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } else { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } break; default: physwidth = 0; physheight = 0; dstoffsetX = 0; dstoffsetY = 0; } /* Source geometry is now the same as the destination. */ if (orthogonal) { srcsurfwidth = physheight; srcsurfheight = physwidth; } else { srcsurfwidth = physwidth; srcsurfheight = physheight; } /* Enable multi-source. */ multisrc = 1; GCDBG(GCZONE_SURF, "multi-source enabled.\n"); } /* Misaligned source may cause the destination parameters * to change, verify whether this has happened. */ if ((batch->dstbyteshift != dstbyteshift) || (batch->dstphyswidth != physwidth) || (batch->dstphysheight != physheight) || (batch->dstoffsetX != dstoffsetX) || (batch->dstoffsetY != dstoffsetY)) { /* Set new values. */ batch->dstbyteshift = dstbyteshift; batch->dstphyswidth = physwidth; batch->dstphysheight = physheight; batch->dstoffsetX = dstoffsetX; batch->dstoffsetY = dstoffsetY; /* Now we need to end the current batch and program * the hardware with the new destination. */ batch->batchflags |= BVBATCH_DST; } /* Check if we need to finalize existing batch. */ if ((batch->batchend != do_blit_end) || (batch->op.blit.srccount == 4) || (batch->op.blit.multisrc == 0) || (multisrc == 0) || ((batch->batchflags & (BVBATCH_DST | BVBATCH_CLIPRECT | BVBATCH_DESTRECT)) != 0)) { /* Finalize existing batch if any. */ bverror = batch->batchend(bvbltparams, batch); if (bverror != BVERR_NONE) goto exit; /* Blit batch. */ batch->batchend = do_blit_end; /* Initialize the new batch. */ gcblit = &batch->op.blit; gcblit->blockenable = 0; gcblit->srccount = 0; gcblit->multisrc = multisrc; /* Set the destination format. */ gcblit->format = dstinfo->format.format; gcblit->swizzle = dstinfo->format.swizzle; /* Set the destination coordinates. */ gcblit->dstrect.left = batch->dstadjusted.left - dstoffsetX; gcblit->dstrect.top = batch->dstadjusted.top - dstoffsetY; gcblit->dstrect.right = batch->dstadjusted.right - dstoffsetX; gcblit->dstrect.bottom = batch->dstadjusted.bottom - dstoffsetY; /* Map the destination. */ bverror = do_map(dstinfo->buf.desc, batch, &dstmap); if (bverror != BVERR_NONE) { bvbltparams->errdesc = gccontext->bverrorstr; goto exit; } /* Set the new destination. */ bverror = set_dst(bvbltparams, batch, dstmap); if (bverror != BVERR_NONE) goto exit; /* Reset the modified flag. */ batch->batchflags &= ~(BVBATCH_DST | BVBATCH_CLIPRECT | BVBATCH_DESTRECT); } /* Map the source. */ bverror = do_map(srcinfo->buf.desc, batch, &srcmap); if (bverror != BVERR_NONE) { bvbltparams->errdesc = gccontext->bverrorstr; goto exit; } /*********************************************************************** ** Configure source. */ /* We need to walk in blocks if the source and the destination * surfaces are orthogonal to each other. */ batch->op.blit.blockenable |= orthogonal; /* Shortcut to the register index. */ index = batch->op.blit.srccount; /* Set surface parameters. */ if (index == 0) { /* Allocate command buffer. */ bverror = claim_buffer(bvbltparams, batch, sizeof(struct gcmosrc0), (void **) &gcmosrc0); if (bverror != BVERR_NONE) goto exit; add_fixup(bvbltparams, batch, &gcmosrc0->address, srcinfo->bytealign); gcmosrc0->config_ldst = gcmosrc0_config_ldst; gcmosrc0->address = GET_MAP_HANDLE(srcmap); gcmosrc0->stride = srcinfo->geom->virtstride; gcmosrc0->rotation.raw = 0; gcmosrc0->rotation.reg.surf_width = srcsurfwidth; gcmosrc0->config.raw = 0; gcmosrc0->config.reg.swizzle = srcinfo->format.swizzle; gcmosrc0->config.reg.format = srcinfo->format.format; gcmosrc0->origin.reg.x = srcclipped.left; gcmosrc0->origin.reg.y = srcclipped.top; gcmosrc0->size.reg = gcregsrcsize_max; gcmosrc0->rotation_ldst = gcmosrc0_rotation_ldst; gcmosrc0->rotationheight.reg.height = srcsurfheight; gcmosrc0->rotationangle.raw = 0; gcmosrc0->rotationangle.reg.src = rotencoding[srcinfo->angle]; gcmosrc0->rotationangle.reg.dst = rotencoding[dstinfo->angle]; gcmosrc0->rotationangle.reg.src_mirror = srcinfo->mirror; gcmosrc0->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE; gcmosrc0->rop_ldst = gcmosrc0_rop_ldst; gcmosrc0->rop.raw = 0; gcmosrc0->rop.reg.type = GCREG_ROP_TYPE_ROP3; gcmosrc0->rop.reg.fg = (unsigned char) srcinfo->rop; gcmosrc0->mult_ldst = gcmosrc0_mult_ldst; gcmosrc0->mult.raw = 0; gcmosrc0->mult.reg.srcglobalpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE; if (srcinfo->format.premultiplied) gcmosrc0->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; else gcmosrc0->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; if (dstinfo->format.premultiplied) { gcmosrc0->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; gcmosrc0->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE; } else { gcmosrc0->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; gcmosrc0->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE; } /* Program blending. */ bverror = set_blending(bvbltparams, batch, srcinfo); if (bverror != BVERR_NONE) goto exit; /* Program YUV source. */ if (srcinfo->format.type == BVFMT_YUV) { bverror = set_yuvsrc(bvbltparams, batch, srcinfo, srcmap); if (bverror != BVERR_NONE) goto exit; } } else { /* Allocate command buffer. */ bverror = claim_buffer(bvbltparams, batch, sizeof(struct gcmosrc), (void **) &gcmosrc); if (bverror != BVERR_NONE) goto exit; add_fixup(bvbltparams, batch, &gcmosrc->address, srcinfo->bytealign); gcmosrc->address_ldst = gcmosrc_address_ldst[index]; gcmosrc->address = GET_MAP_HANDLE(srcmap); gcmosrc->stride_ldst = gcmosrc_stride_ldst[index]; gcmosrc->stride = srcinfo->geom->virtstride; gcmosrc->rotation_ldst = gcmosrc_rotation_ldst[index]; gcmosrc->rotation.raw = 0; gcmosrc->rotation.reg.surf_width = srcsurfwidth; gcmosrc->config_ldst = gcmosrc_config_ldst[index]; gcmosrc->config.raw = 0; gcmosrc->config.reg.swizzle = srcinfo->format.swizzle; gcmosrc->config.reg.format = srcinfo->format.format; gcmosrc->origin_ldst = gcmosrc_origin_ldst[index]; gcmosrc->origin.reg.x = srcclipped.left; gcmosrc->origin.reg.y = srcclipped.top; gcmosrc->size_ldst = gcmosrc_size_ldst[index]; gcmosrc->size.reg = gcregsrcsize_max; gcmosrc->rotationheight_ldst = gcmosrc_rotationheight_ldst[index]; gcmosrc->rotationheight.reg.height = srcsurfheight; gcmosrc->rotationangle_ldst = gcmosrc_rotationangle_ldst[index]; gcmosrc->rotationangle.raw = 0; gcmosrc->rotationangle.reg.src = rotencoding[srcinfo->angle]; gcmosrc->rotationangle.reg.dst = rotencoding[dstinfo->angle]; gcmosrc->rotationangle.reg.src_mirror = srcinfo->mirror; gcmosrc->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE; gcmosrc->rop_ldst = gcmosrc_rop_ldst[index]; gcmosrc->rop.raw = 0; gcmosrc->rop.reg.type = GCREG_ROP_TYPE_ROP3; gcmosrc->rop.reg.fg = (unsigned char) srcinfo->rop; gcmosrc->mult_ldst = gcmosrc_mult_ldst[index]; gcmosrc->mult.raw = 0; gcmosrc->mult.reg.srcglobalpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE; if (srcinfo->format.premultiplied) gcmosrc->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; else gcmosrc->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; if (dstinfo->format.premultiplied) { gcmosrc->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; gcmosrc->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE; } else { gcmosrc->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; gcmosrc->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE; } /* Program blending. */ bverror = set_blending_index(bvbltparams, batch, srcinfo, index); if (bverror != BVERR_NONE) goto exit; /* Program YUV source. */ if (srcinfo->format.type == BVFMT_YUV) { bverror = set_yuvsrc_index(bvbltparams, batch, srcinfo, srcmap, index); if (bverror != BVERR_NONE) goto exit; } } batch->op.blit.srccount += 1; exit: GCEXITARG(GCZONE_BLIT, "bv%s = %d\n", (bverror == BVERR_NONE) ? "result" : "error", bverror); return bverror; }
void ntp_setup(void) { tv_t tv; tz_t tz; time_t sec; struct ip_info getinfo; // Wait until we have an IP address before we set the time if(!network_init) return; if(ntp_init == 0) { ip_addr_t *addr = (ip_addr_t *)safecalloc(sizeof(ip_addr_t),1); // form pool.ntp.org ipaddr_aton("206.108.0.131", addr); sntp_setserver(1,addr); ipaddr_aton("167.114.204.238", addr); sntp_setserver(2,addr); #if 0 // Alternate time setting if the local router does NTP if(wifi_get_ip_info(0, &getinfo)) { printf("NTP:0 GW: %s\n", ipv4_2str(getinfo.gw.addr)); printf("NTP:0 IP: %s\n", ipv4_2str(getinfo.ip.addr)); sntp_setserver(1, & getinfo.gw); sntp_setserver(2, & getinfo.ip); } else { printf("NTP:0 failed to get GW address\n"); return; } #endif if( sntp_set_timezone(0) ) { printf("NTP: set_timeone OK\n"); sntp_init(); safefree(addr); ntp_init = 1; printf("NTP:1\n"); } else { printf("NTP: set_timeone Failed\n"); } } if(ntp_init == 1) { // they hard coded it to +8 hours from GMT if( (sec = sntp_get_current_timestamp()) > 10 ) { sntp_stop(); ntp_init = 2; } } if(ntp_init == 2) { time_t s; tm_t *p; printf("NTP:2\n"); // they return GMT + 8 // sec = sec - (8UL * 3600UL); tv.tv_sec = sec; printf("ntp_init: %s\n", asctime(gmtime(&sec))); printf("ntp_init: %s\n", ctime_gm(&sec)); tv.tv_usec = 0; tz.tz_minuteswest = 300; tz.tz_dsttime = 0; settimeofday(&tv, &tz); printf("SEC:%ld\n",sec); printf("TIME:%s\n", ctime(&sec)); printf("Zone: %d\n", (int) sntp_get_timezone()); ntp_init = 3; set_dst(tv.tv_sec); print_dst_gmt(); print_dst(); p = gmtime(&tv.tv_sec); mktime(p); printf("Localtime: %s\n", asctime(p)); } }